Rewrite indentation testing code (#26)

Benefits of new solution:

1. Faster (runs indentation tests in parallel)
   - On GitHub Actions, the tests now finish >10 seconds quicker, but we will see a greater benefit when I add more indentation tests (hopefully soon).
2. Less code
3. Adding new indentation test cases doesn't require editing the indent_test.clj Clojure file anymore
4. Fixed issues with the test vimrc so tests now work on newer Vim versions (previously they only worked on Vim 8.1 and below)
5. Can now set different config options per-test
6. Indentation tests now all pass on my computer

Now we're in a good position to start adding more indentation tests.

Author: axvr

.github/workflows/clojure.yml

@@ -29,7 +29,7 @@ jobs:
       env:
         cache-name: cache-m2
       with:
-        path: ~/.m2
+        path: ~/.m2/repository
         key: ${{ runner.os }}-build-${{ env.cache-name }}-${{ hashFiles('**/project.clj') }}
         restore-keys: |
           ${{ runner.os }}-build-${{ env.cache-name }}-

clj/.clj-kondo/config.edn

@@ -1,3 +1,2 @@
-{:lint-as {vim.test/with-tempfile clojure.core/fn
-           vim.test/defpredicates clojure.core/def
+{:lint-as {vim.test/defpredicates clojure.core/def
            vim.test/defsyntaxtest clojure.core/def}}

clj/resources/indent-test-cases/test-basic-sexp-indent.txt renamed to clj/resources/indent-test-cases/basic-sexp/in.clj

@@ -3,5 +3,3 @@
   tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
   quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
   consequat.")
-
-;; vim:ft=clojure:

clj/resources/indent-test-cases/basic-sexp/out.clj

@@ -0,0 +1,5 @@
+(ns test-basic-sexp-indent
+  "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
+  tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
+  quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
+  consequat.")

clj/resources/indent-test-cases/test-dispatch-macro-indent.in renamed to clj/resources/indent-test-cases/dispach-macro/in.clj

@@ -27,5 +27,3 @@ bar))
 
 (#_(foo bar)
 a)
-
-;; vim:ft=clojure:

clj/resources/indent-test-cases/test-dispatch-macro-indent.out renamed to clj/resources/indent-test-cases/dispach-macro/out.clj

@@ -27,5 +27,3 @@
 
 (#_(foo bar)
  a)
-
-;; vim:ft=clojure:

clj/resources/indent-test-cases/inherit-indentation/config.edn

@@ -0,0 +1,3 @@
+{:indent? false
+ :extra-cmds ["normal! gg"
+              "exec \"normal! /α\\<CR>s\\<C-O>Oa\\<Esc>/β\\<CR>s\\<CR>\\<CR>\\<C-H>\\<C-H>\\<C-H>\\<C-H>\\<C-H>\\<C-H>\\<C-H>b\\<CR>c\\<CR>\\<CR>d\\<Esc>\""]}

clj/resources/indent-test-cases/test-inherit-indent.in renamed to clj/resources/indent-test-cases/inherit-indentation/in.clj

@@ -35,5 +35,3 @@
         (six-times [y]
 (* (twice y) 3))]
       (foo #{:foo :bar :biz} :foo))
-
-;; vim:ft=clojure:

clj/resources/indent-test-cases/test-inherit-indent.out renamed to clj/resources/indent-test-cases/inherit-indentation/out.clj

@@ -35,5 +35,3 @@
         (six-times [y]
           (* (twice y) 3))]
   (foo #{:foo :bar :biz} :foo))
-
-;; vim:ft=clojure:

clj/resources/indent-test-cases/test-special-case-indent.in renamed to clj/resources/indent-test-cases/letfn/in.clj

@@ -1,5 +1,3 @@
 (let [Δt (if foo
            bar
            baz)])
-
-;; vim:ft=clojure:

clj/resources/indent-test-cases/test-special-case-indent.out renamed to clj/resources/indent-test-cases/letfn/out.clj

@@ -0,0 +1,3 @@
+(let [Δt (if foo
+           bar
+           baz)])

clj/resources/indent-test-cases/test-multibyte-indent.txt renamed to clj/resources/indent-test-cases/multibyte-indentation/in.clj

@@ -9,5 +9,3 @@
 
 #?@(:clj  [5 6 7 8]
       :cljs [1 2 3 4])))
-
-;; vim:ft=clojure:

clj/resources/indent-test-cases/multibyte-indentation/out.clj

@@ -9,5 +9,3 @@
 
 #?@(:clj  [5 6 7 8]
     :cljs [1 2 3 4])))
-
-;; vim:ft=clojure:

clj/resources/indent-test-cases/test-reader-conditional-indent.in renamed to clj/resources/indent-test-cases/reader-conditional/in.clj

@@ -0,0 +1,3 @@
+{:indent? false
+ :extra-cmds ["normal! gg"
+              "exec \"normal! /α\\<CR>:call GetClojureIndent()\\<CR>rxj:call GetClojureIndent()\\<CR>ry\""]}

clj/resources/indent-test-cases/test-reader-conditional-indent.out renamed to clj/resources/indent-test-cases/reader-conditional/out.clj

@@ -0,0 +1,21 @@
+(ns vim.helpers
+  (:require [clojure.edn :as edn]
+            [clojure.java.shell :as shell])
+  (:import [java.io File FileReader PushbackReader]))
+
+(defn read-edn-file [^File file]
+  (when (.exists file)
+    (with-open [rdr (FileReader. file)]
+      (edn/read (PushbackReader. rdr)))))
+
+(def ^:dynamic *vim* "vim")
+
+(defn vim!
+  "Run commands on a file in Vim."
+  [^File file cmds & {:keys [vimrc], :or {vimrc "NONE"}}]
+  (let [cmds (mapcat (fn [cmd] ["-c" cmd]) cmds)
+        args (concat ["--clean" "-N" "-u" (str vimrc)] cmds ["-c" "quitall!" "--" (str file)])
+        ret  (apply shell/sh *vim* args)]
+    (when (pos? (:exit ret))
+      (throw (ex-info "Failed to run Vim command"
+                      (assoc ret :vim *vim*, :args args))))))

clj/resources/indent-test-cases/side-effects-in-indentexpr/config.edn

@@ -1,40 +1,43 @@
 (ns vim.indent-test
-  (:require [clojure.test :refer [deftest]]
-            [vim.test :refer [test-indent]]))
+  (:require [clojure.test :refer [deftest testing is]]
+            [clojure.string :as str]
+            [clojure.java.io :as io]
+            [vim.helpers :as h])
+  (:import [java.io File]))
 
-(deftest test-basic-sexp-indent
-  (test-indent "works as expected with basic S-expressions"
-               :in "test-basic-sexp-indent.txt"
-               :out "test-basic-sexp-indent.txt"))
+(defn get-test-cases [^File test-case-dir]
+  (into []
+        (comp
+          (filter #(.isDirectory ^File %))
+          (map #(.getName ^File %)))
+        (.listFiles test-case-dir)))
 
-(deftest test-multibyte-indent
-  (test-indent "with multibyte characters"
-               :in "test-multibyte-indent.txt"
-               :out "test-multibyte-indent.txt"))
+(defn run-test-case [test-case-dir test-case]
+  (testing (str "Preparation for " test-case)
+    (let [input    (io/file test-case-dir test-case "in.clj")
+          expected (io/file test-case-dir test-case "out.clj")
+          actual   (File/createTempFile test-case ".clj")
+          config   (let [f (io/file test-case-dir test-case "config.edn")]
+                     (or (h/read-edn-file f) {}))
+          cmds     (concat (:extra-cmds config)
+                           (when (:indent? config true) ["normal! gg=G"])
+                           ["write"])]
+      (io/make-parents actual)
+      (io/copy input actual)
+      (h/vim! actual cmds :vimrc (io/file "vim/test-runtime.vim"))
+      {:test-case     test-case
+       :expected      (slurp expected)
+       :expected-file expected
+       :actual        (slurp actual)
+       :actual-file   actual})))
 
-(deftest test-inherit-indent
-  (test-indent "is inherited from previous element"
-               :in "test-inherit-indent.in"
-               :out "test-inherit-indent.out"
-               :keys "/α\\<CR>s\\<C-O>Oa\\<Esc>/β\\<CR>s\\<CR>\\<CR>\\<C-H>\\<C-H>\\<C-H>\\<C-H>\\<C-H>\\<C-H>\\<C-H>b\\<CR>c\\<CR>\\<CR>d\\<Esc>"))
-
-(deftest test-side-effects-in-indentexpr
-  (test-indent "GetClojureIndent does not move cursor"
-               :in "test-side-effects-in-indentexpr.in"
-               :out "test-side-effects-in-indentexpr.out"
-               :keys "/α\\<CR>:call GetClojureIndent()\\<CR>rxj:call GetClojureIndent()\\<CR>ry"))
-
-(deftest test-reader-conditional-indent
-  (test-indent "reader conditionals are indented like maps"
-               :in "test-reader-conditional-indent.in"
-               :out "test-reader-conditional-indent.out"))
-
-(deftest test-dispatch-macro-indent
-  (test-indent "dispatch macro indentation is handled correctly"
-               :in "test-dispatch-macro-indent.in"
-               :out "test-dispatch-macro-indent.out"))
-
-(deftest test-special-case-indent
-  (test-indent "special case indentation is handled correctly"
-               :in "test-special-case-indent.in"
-               :out "test-special-case-indent.out"))
+;; TODO: do this parallisation more intelligently with agents.
+(deftest test-indent
+  "Runs all indentation tests in parallel"
+  (let [test-case-dir (io/file (io/resource "indent-test-cases"))
+        test-cases    (get-test-cases test-case-dir)]
+    (doseq [{:keys [test-case expected expected-file actual actual-file]}
+            (pmap (partial run-test-case test-case-dir) test-cases)]
+      (testing test-case
+        (is (= expected actual)
+            (format "(not= \"%s\"\n      \"%s\")" expected-file actual-file))))))

clj/resources/indent-test-cases/test-side-effects-in-indentexpr.in renamed to clj/resources/indent-test-cases/side-effects-in-indentexpr/in.clj

@@ -9,34 +9,25 @@
   (:import [java.io File]
            [java.util List]))
 
-(defmacro with-tempfile
-  {:requires [File]}
-  [[tmp-sym] & body]
-  `(let [~tmp-sym (File/createTempFile "vim-clojure-static" ".tmp")]
-     (try
-       ~@body
-       (finally
-         (.delete ~tmp-sym)))))
-
 (defn vim-exec
   "Spit buf into file, then execute vim-expr after Vim loads the file. The
-   value of vim-expr is evaluated as EDN and returned."
+  value of vim-expr is evaluated as EDN and returned."
   [file buf vim-expr & opts]
-  (let [{:keys [pre]} (apply hash-map opts)]
-    (with-tempfile [tmp]
-      (io/make-parents file)
-      (spit file buf)
-      (spit tmp (str "let @x = " vim-expr))
-      (let [{:keys [exit err]}
-            (shell/sh "vim" "-N" "-u" "vim/test-runtime.vim"
-                      "-c" (or pre "execute")
-                      "-c" (str "source " tmp)
-                      "-c" (str "call writefile([@x], " (pr-str (str tmp)) ")")
-                      "-c" "quitall!"
-                      file)]
-        (when-not (zero? exit)
-          (throw (RuntimeException. ^String err))))
-      (edn/read-string (slurp tmp)))))
+  (let [{:keys [pre]} (apply hash-map opts)
+        tmp (File/createTempFile "vim-clojure-static" ".tmp")]
+    (io/make-parents file)
+    (spit file buf)
+    (spit tmp (str "let @x = " vim-expr))
+    (let [{:keys [exit err]}
+          (shell/sh "vim" "-N" "-u" "vim/test-runtime.vim"
+                    "-c" (or pre "execute")
+                    "-c" (str "source " tmp)
+                    "-c" (str "call writefile([@x], " (pr-str (str tmp)) ")")
+                    "-c" "quitall!"
+                    file)]
+      (when-not (zero? exit)
+        (throw (RuntimeException. ^String err))))
+    (edn/read-string (slurp tmp))))
 
 (defn syn-id-names
   "Map lines of clojure text to vim synID names at each column as keywords:
@@ -115,42 +106,6 @@
        [coll#]
        (boolean (some (partial not= ~kw) coll#)))))
 
-(defmacro with-transform-test
-  "Copy contents of `in` to a tempfile, execute body with tempfile bound to
-   tmp-sym, then finally compare the transformed contents of the tempfile with
-   the contents of `out`.
-
-   `in` and `out` are urls that will be passed to clojure.java.io/resource."
-  {:requires [#'test/testing #'with-tempfile]}
-  [string {:keys [in out]} [tmp-sym :as tmp-binding] & body]
-  `(test/testing ~string
-     (with-tempfile ~tmp-binding
-       (try
-         (spit ~tmp-sym (slurp (~io/resource (str "indent-test-cases/" ~in))))
-         ~@body
-         (catch Throwable e#
-           (spit ~tmp-sym e#))
-         (finally
-           (test/is (= (slurp ~tmp-sym)
-                       (slurp (~io/resource (str "indent-test-cases/" ~out))))))))))
-
-(defmacro test-indent
-  {:requires [#'with-transform-test]}
-  [string & opts]
-  (let [{:keys [in out pre keys]} (apply hash-map opts)
-        test-file (str "tmp/test-indent-" (string/replace string #"[^\w-]" "-") ".clj")
-        vim-expr (if keys
-                   (format "TypeKeys(%s)" (string/replace (pr-str keys) "\\\\" "\\"))
-                   "IndentFile()")]
-    `(with-transform-test ~string
-       {:in ~in :out ~out}
-       [tmp#]
-       ;; FIXME: Too much file IO
-       (~io/make-parents ~test-file)
-       (spit ~test-file "")
-       (~vim-exec ~test-file (slurp tmp#) ~vim-expr ~@(when pre [:pre pre]))
-       (spit tmp# (slurp ~test-file)))))
-
 (defn benchmark [n file buf & exprs]
   (vim-exec file buf (format "Benchmark(%d, %s)"
                              n

clj/resources/indent-test-cases/test-side-effects-in-indentexpr.out renamed to clj/resources/indent-test-cases/side-effects-in-indentexpr/out.clj

@@ -1,10 +1,9 @@
 " Authors: Sung Pae <self@sungpae.com>
 
-execute 'set rtp=' . expand('%:p:h:h:h') . ',$VIMRUNTIME'
+let &rtp = getcwd() . '/..,' . &rtp
 filetype plugin indent on
-syntax on
+syntax enable
 set synmaxcol=0 backspace=2
-setfiletype clojure
 
 function! EDN(value)
 	" Changing the quotes may make this valid EDN
@@ -20,16 +19,6 @@ function! ClojureSynIDNames()
 	return EDN(names)
 endfunction
 
-function! TypeKeys(keys)
-	execute 'normal! ' . a:keys
-	write
-endfunction
-
-function! IndentFile()
-	normal! gg=G
-	write
-endfunction
-
 function! Time(n, expr)
 	let start = reltime()
 	let i = 0