Convert nfnl.fs to nfnl.module/define

Author: Olical

fnl/nfnl/fs.fnl

@@ -1,62 +1,64 @@
-(local {: autoload} (require :nfnl.module))
+(local {: autoload : define} (require :nfnl.module))
 (local core (autoload :nfnl.core))
 (local str (autoload :nfnl.string))
 
-(fn basename [path]
+(local M (define :nfnl.fs))
+
+(fn M.basename [path]
   "Remove the file part of the path."
   (when path
     (vim.fn.fnamemodify path ":h")))
 
-(fn filename [path]
+(fn M.filename [path]
   "Just the filename / tail of a path."
   (when path
     (vim.fn.fnamemodify path ":t")))
 
-(fn file-name-root [path]
+(fn M.file-name-root [path]
   "Remove the suffix / extension of the file in a path."
   (when path
     (vim.fn.fnamemodify path ":r")))
 
-(fn full-path [path]
+(fn M.full-path [path]
   (when path
     (vim.fn.fnamemodify path ":p")))
 
-(fn mkdirp [dir]
+(fn M.mkdirp [dir]
   (when dir
     (vim.fn.mkdir dir "p")))
 
-(fn replace-extension [path ext]
+(fn M.replace-extension [path ext]
   (when path
-    (.. (file-name-root path) (.. "." ext))))
+    (.. (M.file-name-root path) (.. "." ext))))
 
-(fn read-first-line [path]
+(fn M.read-first-line [path]
   (let [f (io.open path "r")]
     (when (and f (not (core.string? f)))
       (let [line (f:read "*line")]
         (f:close)
         line))))
 
-(fn absglob [dir expr]
+(fn M.absglob [dir expr]
   "Glob all files under dir matching the expression and return the absolute paths."
   (vim.fn.globpath dir expr true true))
 
-(fn relglob [dir expr]
+(fn M.relglob [dir expr]
   "Glob all files under dir matching the expression and return the paths
   relative to the dir argument."
   (let [dir-len (+ 2 (string.len dir))]
-    (->> (absglob dir expr)
+    (->> (M.absglob dir expr)
          (core.map #(string.sub $1 dir-len)))))
 
-(fn glob-dir-newer? [a-dir b-dir expr b-dir-path-fn]
-  "Returns true if a-dir has newer changes than b-dir. All paths from a-dir are mapped through b-dir-path-fn before comparing to b-dir."
+(fn M.glob-dir-newer? [a-dir b-dir expr b-dir-path-fn]
+  "Returns true if a-dir has newer changes than b-dir. All paths from a-dir are mapped through b-dir-path-fn M.before comparing to b-dir."
   (var newer? false)
   (each [_ path (ipairs (relglob a-dir expr))]
     (when (> (vim.fn.getftime (.. a-dir path))
              (vim.fn.getftime (.. b-dir (b-dir-path-fn path))))
       (set newer? true)))
   newer?)
 
-(fn path-sep []
+(fn M.path-sep []
   ;; https://github.com/nvim-lua/plenary.nvim/blob/8bae2c1fadc9ed5bfcfb5ecbd0c0c4d7d40cb974/lua/plenary/path.lua#L20-L31
   (let [os (string.lower jit.os)]
     (if (or (= :linux os)
@@ -67,53 +69,37 @@
       "/"
       "\\")))
 
-(fn findfile [name path]
+(fn M.findfile [name path]
   "Wrapper around Neovim's findfile() that returns nil
   instead of an empty string."
   (let [res (vim.fn.findfile name path)]
     (when (not (core.empty? res))
-      (full-path res))))
+      (M.full-path res))))
 
-(fn split-path [path]
-  (str.split path (path-sep)))
+(fn M.split-path [path]
+  (str.split path (M.path-sep)))
 
-(fn join-path [parts]
-  (str.join (path-sep) (core.concat parts)))
+(fn M.join-path [parts]
+  (str.join (M.path-sep) (core.concat parts)))
 
-(fn replace-dirs [path from to]
+(fn M.replace-dirs [path from to]
   "Replaces directories in `path` that match `from` with `to`."
   (->> (split-path path)
        (core.map
          (fn [segment]
            (if (= from segment)
              to
              segment)))
-       (join-path)))
+       (M.join-path)))
 
-(fn fnl-path->lua-path [fnl-path]
+(fn M.fnl-path->lua-path [fnl-path]
   (-> fnl-path
-      (replace-extension "lua")
-      (replace-dirs "fnl" "lua")))
+      (M.replace-extension "lua")
+      (M.replace-dirs "fnl" "lua")))
 
-(fn glob-matches? [dir expr path]
+(fn M.glob-matches? [dir expr path]
   "Return true if path matches the glob expression. The path should be absolute and the glob should be relative to dir."
-  (let [regex (vim.regex (vim.fn.glob2regpat (join-path [dir expr])))]
+  (let [regex (vim.regex (vim.fn.glob2regpat (M.join-path [dir expr])))]
     (regex:match_str path)))
 
-{: basename
- : filename
- : file-name-root
- : full-path
- : mkdirp
- : replace-extension
- : absglob
- : relglob
- : glob-dir-newer?
- : path-sep
- : findfile
- : split-path
- : join-path
- : read-first-line
- : replace-dirs
- : fnl-path->lua-path
- : glob-matches?}
+M