Fix whitespace sensitive testing for aligned multi-line strings

src/macaw/rewrite.clj

@@ -94,19 +94,21 @@
         (throw (ex-info (str "Unknown rename: " unknown) {:type k
                                                           :rename unknown}))))))
 
+(defn- index-by-instances [xs]
+  (into {} (for [x xs
+                 :let [c (:component x)]
+                 i (:instances c)]
+             [i c])))
+
 (defn replace-names
   "Given a SQL query and its corresponding (untransformed) AST, apply the given table and column renames."
   [sql parsed-ast {schema-renames :schemas
                    table-renames  :tables
                    column-renames :columns
                    :as renames}]
   (let [comps          (collect/query->components parsed-ast {:with-instance true})
-        columns        (into {} (for [c (:columns comps)
-                                      i (:instances (:component c))]
-                                  [i (:component c)]))
-        tables         (into {} (for [t (:tables comps)
-                                      i (:instances (:component t))]
-                                  [i (:component t)]))
+        columns        (index-by-instances (:columns comps))
+        tables         (index-by-instances (:tables comps))
         ;; execute rename
         updated-nodes  (volatile! [])
         res            (-> parsed-ast

test/macaw/core_test.clj

@@ -1,17 +1,15 @@
 (ns ^:parallel macaw.core-test
   (:require
-   [clojure.string :as str]
    [clojure.test :refer [deftest is testing]]
    [macaw.core :as m]
+   #_{:clj-kondo/ignore [:refer]}
+   [macaw.test-utils :refer [ws=]]
    [macaw.walk :as mw])
   (:import
    (net.sf.jsqlparser.schema Table)))
 
 (set! *warn-on-reflection* true)
 
-(defn- normalize-ws [s]
-  (str/replace s #"\s\s+" " "))
-
 (defn- and*
   [x y]
   (and x y))
@@ -236,34 +234,33 @@
          (m/replace-names "SELECT p.id, q.id FROM public.orders p join private.orders q"
                           {:tables {{:schema "public" :table "orders"} "whatever"}})))
 
-  (is (= (normalize-ws "SELECT SUM(public.orders.total) AS s,
-           MAX(orders.total) AS max,
-           MIN(total) AS min
-           FROM public.orders")
-         (m/replace-names
-          (normalize-ws "SELECT SUM(public.orders.amount) AS s,
-           MAX(orders.amount) AS max,
-           MIN(amount) AS min
-           FROM public.orders")
-          {:columns {{:schema "public" :table "orders" :column "amount"} "total"}})))
+  (is (ws= "SELECT SUM(public.orders.total) AS s,
+            MAX(orders.total) AS max,
+            MIN(total) AS min
+            FROM public.orders"
+           (m/replace-names
+            "SELECT SUM(public.orders.amount) AS s,
+             MAX(orders.amount) AS max,
+             MIN(amount) AS min
+             FROM public.orders"
+            {:columns {{:schema "public" :table "orders" :column "amount"} "total"}})))
 
-  (is (= (normalize-ws "SELECT *, sturmunddrang
-                                , oink AS oink
-                        FROM /* /* lore */
-                             floor_muser,
-                             user,  /* more */ vigilant_user ;")
-         (m/replace-names
-          (normalize-ws
-           "SELECT *, boink
-                    , yoink AS oink
+  (is (ws= "SELECT *, sturmunddrang
+                    , oink AS oink
             FROM /* /* lore */
-                core_user,
-                bore_user,  /* more */ snore_user ;")
-          {:tables  {{:schema "public" :table "core_user"}  "floor_muser"
-                     {:schema "public" :table "bore_user"}  "user"
-                     {:schema "public" :table "snore_user"} "vigilant_user"}
-           :columns {{:schema "public" :table "core_user" :column "boink"}  "sturmunddrang"
-                     {:schema "public" :table "snore_user" :column "yoink"} "oink"}})))
+                 floor_muser,
+                 user,  /* more */ vigilant_user ;"
+           (m/replace-names
+            "SELECT *, boink
+                     , yoink AS oink
+             FROM /* /* lore */
+                  core_user,
+                  bore_user,  /* more */ snore_user ;"
+            {:tables  {{:schema "public" :table "core_user"}  "floor_muser"
+                       {:schema "public" :table "bore_user"}  "user"
+                       {:schema "public" :table "snore_user"} "vigilant_user"}
+             :columns {{:schema "public" :table "core_user" :column "boink"}  "sturmunddrang"
+                       {:schema "public" :table "snore_user" :column "yoink"} "oink"}})))
 
   (is (thrown? Exception #"Unknown rename"
                (m/replace-names "SELECT 1" {:tables {{:schema "public" :table "a"} "aa"}}))))

test/macaw/test_utils.clj

@@ -0,0 +1,28 @@
+(ns macaw.test-utils
+  (:require
+   [clojure.string :as str]
+   [clojure.test :refer :all]
+   [clojure.walk :as walk]))
+
+(defn- indentation [s]
+  (count (re-find #"^\s*" s)))
+
+(defn- trim-indent* [margin s]
+  (if (< (count s) margin)
+    ""
+    (subs s margin)))
+
+(defn trim-indent
+  "Given a multi-line string, remove the common margin from the remaining lines.
+  Used so that strings with significant whitespace may be visually aligned."
+  [s]
+  (let [lines  (str/split-lines s)
+        margin (->> (rest lines)
+                    (remove str/blank?)
+                    (transduce (map indentation) min Integer/MAX_VALUE))]
+    (str/join "\n" (cons (first lines) (map (partial trim-indent* margin) (rest lines))))))
+
+(defmacro ws=
+  "Trim the extra indentation from all string literals before evaluation a given equality form."
+  [& xs]
+  `(= ~@(walk/postwalk #(cond-> % (string? %) trim-indent) xs)))