add boilerplate for fennel plugin with nfnl

Author: joaopluigi

.gitattributes

@@ -0,0 +1,2 @@
+lua/**/*.lua linguist-generated
+lua/example/nfnl/**/*.lua linguist-vendored

.gitignore

@@ -0,0 +1 @@
+deps/

.ignore

@@ -0,0 +1 @@
+lua/**/*.lua

.nfnl.fnl

@@ -1,50 +1,9 @@
-{;; Enables verbose notifications from nfnl, including notifications about
- ;; when it starts up and when it compiles successfully. Useful for debugging
- ;; the plugin itself and checking that it's running when you expect it to.
- :verbose false
-
- ;; When false, will not write the protective `-- [nfnl] ...` header to the resulting .lua files.
- ;; It will also prevent nfnl from checking for this header before overwriting .lua files.
- ;; Intended for users who wish to write shebang comments at the top of their .lua for easier execution.
- :header-comment true
-
- :orphan-detection
- {;; Automatically invoke :NfnlFindOrphans whenever you write to a .fnl file. This acts as a passive
-  ;; garbage collection check and will warn you about dangling .lua files left over from .fnl deletions or renames.
-  ;; If an orphan is found, you can use :NfnlDeleteOrphans to delete all of the files listed
-  ;; automatically. The deletion command will NOT prompt you, so make sure you check the list first!
-  :auto? true
-
-  ;; If you embed nfnl, for example, in your Lua directory then nfnl will detect those files as orphans.
-  ;; You can add Lua patterns here to tell nfnl which Lua paths are okay and should not be counted as orphans.
-  ;; Example: ["lua/nfnl/"]
-  :ignore-patterns []}
-
- ;; Passed to fennel.compileString when your code is compiled.
- ;; See https://fennel-lang.org/api for more information.
- :compiler-options {;; Disables ansi escape sequences in compiler output.
-                    :error-pinpoint false}
-
- ;; Warning! In reality these paths are absolute and set to the root directory
- ;; of your project (where your .nfnl.fnl file is). This means even if you
- ;; open a .fnl file from outside your project's cwd the compiler will still
- ;; find your macro files. If you use relative paths like I'm demonstrating here
- ;; then macros will only work if your cwd is in the project you're working on.
-
- ;; They also use OS specific path separators, what you see below is just an example really.
- ;; I'm not including nfnl's directory from your runtimepath, but it would be there by default.
- ;; See :rtp-patterns below for more information on including other plugins in your path.
-
- ;; String to set the compiler's fennel.path to before compilation.
- :fennel-path "/home/.../?.fnlm;/home/.../?/init.fnlm;/home/.../fnl/?.fnlm;/home/.../fnl/?/init.fnlm;/home/.../?.fnl;/home/.../?/init.fnl;/home/.../?/init-macros.fnl;/home/.../fnl/?.fnl;/home/.../fnl/?/init.fnl;/home/.../fnl/?/init-macros.fnl"
-
- ;; String to set the compiler's fennel.macro-path to before compilation.
- :fennel-macro-path "/home/.../?.fnlm;/home/.../?/init.fnlm;/home/.../fnl/?.fnlm;/home/.../fnl/?/init.fnlm;/home/.../?.fnl;/home/.../?/init.fnl;/home/.../?/init-macros.fnl;/home/.../fnl/?.fnl;/home/.../fnl/?/init.fnl;/home/.../fnl/?/init-macros.fnl"
-
- ;; A list of glob patterns (autocmd pattern syntax) of files that
- ;; should be compiled. This is used as configuration for the BufWritePost
- ;; autocmd, so it'll only apply to buffers you're interested in.
- ;; Will use backslashes on Windows.
- ;; Defaults to compiling all .fnl files, you may want to limit it to your fnl/ directory.
- :source-file-patterns ["fnl/**/*.fnl"]
-}
+(local core (require :eca.nfnl.core))
+(local config (require :eca.nfnl.config))
+(local defaults (config.default))
+
+{:compiler-options (core.merge
+                     defaults.compiler-options
+                     {:compilerEnv _G})
+ :source-file-patterns [".nvim.fnl" "plugin/*.fnl" "fnl/**/*.fnl"]
+ :orphan-detection {:ignore-patterns ["lua/eca/nfnl/"]}}

Makefile

@@ -0,0 +1,18 @@
+# Makefile for ECA Neovim plugin testing
+
+.PHONY: test deps clean
+
+# Download dependencies for testing
+deps: deps/plenary
+
+deps/plenary:
+	mkdir -p deps
+	git clone --filter=blob:none https://github.com/nvim-lua/plenary.nvim.git
+
+# Run all tests
+test: deps
+	./script/test
+
+# Clean up dependencies
+clean:
+	rm -rf deps/

fnl/eca/init.fnl

@@ -0,0 +1,7 @@
+(local {: autoload} (require :eca.nfnl.module))
+(local notify (autoload :eca.nfnl.notify))
+
+(fn setup []
+  (notify.info "Hello, World!"))
+
+{: setup}

fnl/eca/nfnl/macros.fnlm

@@ -0,0 +1,52 @@
+(fn time [...]
+  `(let [start# (vim.loop.hrtime)
+         result# (do ,...)
+         end# (vim.loop.hrtime)]
+     (print (.. "Elapsed time: " (/ (- end# start#) 1000000) " msecs"))
+     result#))
+
+(fn conditional-let [branch bindings ...]
+  (assert (= 2 (length bindings)) "expected a single binding pair")
+
+  (let [[bind-expr value-expr] bindings]
+    (if
+      ;; Simple symbols
+      ;; [foo bar]
+      (sym? bind-expr)
+      `(let [,bind-expr ,value-expr]
+         (,branch ,bind-expr ,...))
+
+      ;; List / values destructure
+      ;; [(a b) c]
+      (list? bind-expr)
+      (do
+        ;; Even if the user isn't using the first slot, we will.
+        ;; [(_ val) (pcall #:foo)]
+        ;;  => [(bindGENSYM12345 val) (pcall #:foo)]
+        (when (= `_ (. bind-expr 1))
+          (tset bind-expr 1 (gensym "bind")))
+
+        `(let [,bind-expr ,value-expr]
+           (,branch ,(. bind-expr 1) ,...)))
+
+      ;; Sequential and associative table destructure
+      ;; [[a b] c]
+      ;; [{: a : b} c]
+      (table? bind-expr)
+      `(let [value# ,value-expr
+             ,bind-expr (or value# {})]
+         (,branch value# ,...))
+
+      ;; We should never get here, but just in case.
+      (assert (.. "unknown bind-expr type: " (type bind-expr))))))
+
+(fn if-let [bindings ...]
+  (assert (<= (length [...]) 2) (.. "if-let does not support more than two branches"))
+  (conditional-let `if bindings ...))
+
+(fn when-let [bindings ...]
+  (conditional-let `when bindings ...))
+
+{: time
+ : if-let
+ : when-let}

fnl/eca/nfnl/macros/aniseed.fnlm

@@ -0,0 +1,51 @@
+;; Copied over from Aniseed. Contains all of the def* module macro systems.
+;; https://github.com/Olical/aniseed
+
+;; This has been heavily slimmed down from the original implementation, the
+;; `(module ...) macro can now ONLY define your module, it can not be used
+;; to require dependencies.
+
+;; We had to slim things down because the Fennel compiler no longer supports
+;; the weird tricks we were using.
+
+;; In nfnl they are not automatically required, you must use import-macros to
+;; require them explicitly when migrating your Aniseed based projects.
+
+;; Avoids the compiler complaining that we're introducing locals without gensym.
+(local mod-str :*module*)
+(local mod-sym (sym mod-str))
+
+;; Upserts the existence of the module for subsequent def forms.
+;;
+;; (module foo
+;;   {:some-optional-base :table-of-things
+;;    :to-base :the-module-off-of})
+(fn module [mod-name mod-base]
+  `(local
+     ,mod-sym
+     (let [pkg# (require :package)]
+       (tset pkg#.loaded ,(tostring mod-name) ,(or mod-base {}))
+       (. pkg#.loaded ,(tostring mod-name)))))
+
+(fn def- [name value]
+  `(local ,name ,value))
+
+(fn def [name value]
+  `(local ,name (do (tset ,mod-sym ,(tostring name) ,value) (. ,mod-sym ,(tostring name)))))
+
+(fn defn- [name ...]
+  `(fn ,name ,...))
+
+(fn defn [name ...]
+  `(def ,name (fn ,name ,...)))
+
+(fn defonce- [name value]
+  `(def- ,name (or ,name ,value)))
+
+(fn defonce [name value]
+  `(def ,name (or (. ,mod-sym ,(tostring name)) ,value)))
+
+{:module module
+ :def- def- :def def
+ :defn- defn- :defn defn
+ :defonce- defonce- :defonce defonce}

fnl/spec/nfnl/example_spec.fnl

@@ -0,0 +1,15 @@
+(local {: describe : it} (require :plenary.busted))
+(local assert (require :luassert.assert))
+(local core (require :eca.nfnl.core))
+
+(describe
+  "first"
+  (fn []
+    (it "gets the first value"
+        (fn []
+          (assert.equals 1 (core.first [1 2 3 4 5]))))
+
+    (it "returns nil for empty lists or nil"
+        (fn []
+          (assert.is_nil (core.first nil))
+          (assert.is_nil (core.first []))))))