Add powershell script equivalents of test scripts and add windows to the test matrix for the test pipeline

.github/workflows/test.yaml

@@ -4,16 +4,17 @@ on: [ push ]
 
 jobs:
   test:
-    runs-on: ubuntu-latest
     strategy:
       matrix:
         neovim-version: [ "v0.9.0", "v0.9.1", "stable", "nightly" ]
-
+        os: [ windows-latest, ubuntu-latest ]
+    runs-on: ${{ matrix.os }}
     steps:
-      - uses: actions/checkout@v3
-      - uses: MunifTanjim/setup-neovim-action@v1
+      - uses: actions/checkout@v4
+      - uses: rhysd/action-setup-vim@v1
         with:
-          tag: ${{ matrix.neovim-version }}
+          neovim: true
+          version: ${{ matrix.neovim-version }}
       - name: Install Neovim plugins
         run: |
           ./script/setup-test-deps

.gitignore

@@ -1,2 +1,3 @@
 /.clj-kondo/
 /.test-config/
+/.test-state/

fnl/nfnl/compile.fnl

@@ -10,7 +10,8 @@
 (local header-marker "[nfnl]")
 
 (fn with-header [file src]
-  (.. "-- " header-marker " Compiled from " file " by https://github.com/Olical/nfnl, do not edit.\n" src))
+  (let [file (fs.standardize-path file)]  ;; Normalize the path for Windows
+    (.. "-- " header-marker " Compiled from " file " by https://github.com/Olical/nfnl, do not edit.\n" src)))
 
 (fn safe-target? [path]
   "Reads the given file and checks if it contains our header marker on the

fnl/nfnl/core.fnl

@@ -408,6 +408,12 @@
       (tset t k nil)))
   nil)
 
+(fn dbg [x]
+  "Prints each of the arguments using vim.inspect and returns them.
+   Great for debugging some confusing code without changing the behavior"
+   (print (vim.inspect x))
+   x)
+
 {: rand
  : nil?
  : number?
@@ -458,4 +464,5 @@
  : constantly
  : distinct
  : sort
- : clear-table!}
+ : clear-table!
+ : dbg}

fnl/nfnl/fs.fnl

@@ -93,6 +93,15 @@
       (replace-extension "lua")
       (replace-dirs "fnl" "lua")))
 
+(fn standardize-path [path]
+  "Replaces all non standard path separators with the standard forward slash"
+  (str.replace path "\\" "/"))
+
+(fn correct-separators [path]
+  "Replaces all path separators with the ones appropriate for this system"
+  (str.replace path "\\" (path-sep))
+  (str.replace path "/" (path-sep)))
+
 {: basename
  : filename
  : file-name-root
@@ -108,4 +117,6 @@
  : join-path
  : read-first-line
  : replace-dirs
- : fnl-path->lua-path}
+ : fnl-path->lua-path
+ : standardize-path
+ : correct-separators}

fnl/nfnl/string.fnl

@@ -66,10 +66,15 @@
       (= suffix (string.sub s (- s-len suffix-len -1)))
       false)))
 
+(fn replace [s from to]
+  "Replace all occurrences of from with to in the string."
+  (string.gsub s from to))
+
 {: join
  : split
  : blank?
  : triml
  : trimr
  : trim
- : ends-with?}
+ : ends-with?
+ : replace}

fnl/spec/nfnl/config_spec.fnl

@@ -1,4 +1,5 @@
 (local {: describe : it} (require :plenary.busted))
+(local core (autoload :nfnl.core))
 (local assert (require :luassert.assert))
 (local config (require :nfnl.config))
 (local fs (require :nfnl.fs))
@@ -32,9 +33,24 @@
           (assert.is_true (config.config-file-path? ".nfnl.fnl"))
           (assert.is_false (config.config-file-path? ".fnl.fnl"))))))
 
+(describe
+  "find"
+  (fn []
+    (it "finds the nearest .nfnl file to the given path"
+        (fn []
+          (assert.equals 
+            (fs.join-path (fs.full-path ".") ".nfnl.fnl") 
+            (fs.join-path ".nfnl.fnl" (config.find ".")))))))
+
 (describe
   "find-and-load"
   (fn []
+    ; (it "can read found path securely"
+    ;     (fn []
+    ;       (let [config-file-path (config.find ".")
+    ;             config-source (vim.secure.read (core.dbg (fs.standardize-path config-file-path)))]
+    ;         (assert.equals "{:verbose true}" config-source))))
+
     (it "loads the repo config file"
         (fn []
           (let [{: cfg : root-dir : config}
@@ -45,7 +61,7 @@
 
     (it "returns an empty table if a config file isn't found"
         (fn []
-          (assert.are.same {} (config.find-and-load "/some/made/up/dir"))))))
+          (assert.are.same {} (config.find-and-load (fs.correct-separators "/some/made/up/dir")))))))
 
 (fn sorted [xs]
   (table.sort xs)

fnl/spec/nfnl/fs_spec.fnl

@@ -2,13 +2,15 @@
 (local assert (require :luassert.assert))
 (local fs (require :nfnl.fs))
 
+(fn windows? [] (= jit.os "Windows"))
+
 (describe
   "basename"
   (fn []
     (it "removes the last segment of a path"
         (fn []
-          (assert.equals "foo" (fs.basename "foo/bar.fnl"))
-          (assert.equals "foo/bar" (fs.basename "foo/bar/baz.fnl"))
+          (assert.equals "foo" (fs.basename (fs.join-path ["foo" "bar.fnl"])))
+          (assert.equals (fs.join-path ["foo" "bar"]) (fs.basename (fs.join-path ["foo" "bar" "baz.fnl"])))
           (assert.equals "." (fs.basename "baz.fnl"))))
 
     (it "happily lets nils flow back out"
@@ -18,9 +20,11 @@
 (describe
   "path-sep"
   (fn []
-    (it "returns the OS path separator (test assumes Linux)"
+    (it "returns the OS path separator"
         (fn []
-          (assert.equals "/" (fs.path-sep))))))
+            (if (windows?)
+                (assert.equals "\\" (fs.path-sep))
+                (assert.equals "/" (fs.path-sep)))))))
 
 (describe
   "replace-extension"
@@ -34,22 +38,41 @@
   (fn []
     (it "splits a path into parts"
         (fn []
-          (assert.are.same ["foo" "bar" "baz"] (fs.split-path "foo/bar/baz"))
-          (assert.are.same ["" "foo" "bar" "baz"] (fs.split-path "/foo/bar/baz"))))))
+            (assert.are.same ["foo" "bar" "baz"] (fs.split-path (fs.correct-separators "foo/bar/baz"))z)
+            (assert.are.same ["" "foo" "bar" "baz"] (fs.split-path (fs.correct-separators "/foo/bar/baz")))))))
 
 (describe
   "join-path"
   (fn []
     (it "joins a path together"
         (fn []
-          (assert.equals "foo/bar/baz" (fs.join-path ["foo" "bar" "baz"]))
-          (assert.equals "/foo/bar/baz" (fs.join-path ["" "foo" "bar" "baz"]))))))
+            (assert.equals "foo/bar/baz" (fs.standardize-path (fs.join-path ["foo" "bar" "baz"])))
+            (assert.equals "/foo/bar/baz" (fs.standardize-path (fs.join-path ["" "foo" "bar" "baz"])))))))
 
 (describe
   "replace-dirs"
   (fn []
     (it "replaces directories in a path that match a string with another string"
         (fn []
-          (assert.equals "foo/lua/bar" (fs.replace-dirs "foo/fnl/bar" "fnl" "lua"))
-          (assert.equals "/foo/lua/bar" (fs.replace-dirs "/foo/fnl/bar" "fnl" "lua"))
-          (assert.equals "/foo/nfnl/bar" (fs.replace-dirs "/foo/nfnl/bar" "fnl" "lua"))))))
+            (assert.equals "foo/lua/bar" (fs.standardize-path (fs.replace-dirs (fs.correct-separators "foo/fnl/bar") "fnl" "lua")))
+            (assert.equals "/foo/lua/bar" (fs.standardize-path (fs.replace-dirs (fs.correct-separators "/foo/fnl/bar") "fnl" "lua")))
+            (assert.equals "/foo/nfnl/bar" (fs.standardize-path (fs.replace-dirs "/foo/nfnl/bar" "fnl" "lua")))))))
+
+(describe
+  "standardize-path"
+  (fn []
+    (it "replaces all path separators with forward slash"
+        (fn []
+          (assert.equals "foo/bar/baz.fnl" (fs.standardize-path "foo\\bar\\baz.fnl"))
+          (assert.equals "foo/bar/baz.fnl" (fs.standardize-path "foo/bar/baz.fnl"))))))
+
+(describe
+  "correct-separators"
+  (fn []
+    (it ""
+        (fn []
+          (if (windows?)
+              (do (assert.equals "foo\\bar\\baz.fnl" (fs.correct-separators "foo/bar/baz.fnl"))
+                  (assert.equals "foo\\bar\\baz.fnl" (fs.correct-separators "foo\\bar\\baz.fnl")))
+              (do (assert.equals "foo/bar/baz.fnl" (fs.correct-separators "foo/bar/baz.fnl"))
+                  (assert.equals "foo/bar/baz.fnl" (fs.correct-separators "foo\\bar\\baz.fnl"))))))))