Get form

fnl/formedit/tree.fnl

@@ -4,10 +4,10 @@
               :set_lit true
               :anon_fn_lit true})
 
-(fn form? [node]
+(fn get-form [node]
   (if (. forms (node:type))
       node
-      (let [child (node:named_child 0)]
-        (when child (form? child)))))
+      (let [parent (node:parent)]
+        (when parent (get-form parent)))))
 
-{: form?}
+{: get-form}

fnl/spec/nfnl/helper.fnl → fnl/spec/helper.fnl

@@ -14,4 +14,4 @@
   (when cursor
     (assert.are.same cursor (vim.api.nvim_win_get_cursor 0))))
 
-{: setup : expect : feedkeys}
+{: setup : expect}

fnl/spec/tree/tree_spec.fnl

@@ -0,0 +1,136 @@
+(local {: describe : it} (require :plenary.busted))
+(local h (require :spec.helper))
+(local tree (require :formedit.tree))
+(local assert (require :luassert.assert))
+(local ts (require :nvim-treesitter.ts_utils))
+
+(describe "No form return nil"
+          (fn []
+            (it "cursor start of form"
+                (fn []
+                  (h.setup {:content " " :cursor [1 1]})
+                  (let [node (ts.get_node_at_cursor)
+                        actual (tree.get-form node)]
+                    (assert.falsy actual))))))
+
+(describe :List
+          (let [form-type :list_lit]
+            (fn []
+              (it "cursor start of form"
+                  (fn []
+                    (h.setup {:content "(a)" :cursor [1 1]})
+                    (let [node (ts.get_node_at_cursor)
+                          actual (tree.get-form node)]
+                      (assert.equals form-type (actual:type)))))
+              (it "cursor within form"
+                  (fn []
+                    (h.setup {:content "(a)" :cursor [1 2]})
+                    (let [node (ts.get_node_at_cursor)
+                          actual (tree.get-form node)]
+                      (assert.equals form-type (actual:type)))))
+              (it "cursor end of form"
+                  (fn []
+                    (h.setup {:content "(a)" :cursor [1 3]})
+                    (let [node (ts.get_node_at_cursor)
+                          actual (tree.get-form node)]
+                      (assert.equals form-type (actual:type))))))))
+
+(describe :Vector
+          (let [form-type :vec_lit]
+            (fn []
+              (it "cursor start of form"
+                  (fn []
+                    (h.setup {:content "[a]" :cursor [1 1]})
+                    (let [node (ts.get_node_at_cursor)
+                          actual (tree.get-form node)]
+                      (assert.equals form-type (actual:type)))))
+              (it "cursor within form"
+                  (fn []
+                    (h.setup {:content "[a]" :cursor [1 2]})
+                    (let [node (ts.get_node_at_cursor)
+                          actual (tree.get-form node)]
+                      (assert.equals form-type (actual:type)))))
+              (it "cursor end of form"
+                  (fn []
+                    (h.setup {:content "[a]" :cursor [1 3]})
+                    (let [node (ts.get_node_at_cursor)
+                          actual (tree.get-form node)]
+                      (assert.equals form-type (actual:type))))))))
+
+(describe :Map
+          (let [form-type :map_lit]
+            (fn []
+              (it "cursor start of form"
+                  (fn []
+                    (h.setup {:content "{:a 1}" :cursor [1 1]})
+                    (let [node (ts.get_node_at_cursor)
+                          actual (tree.get-form node)]
+                      (assert.equals form-type (actual:type)))))
+              (it "cursor within form"
+                  (fn []
+                    (h.setup {:content "{:a 1}" :cursor [1 2]})
+                    (let [node (ts.get_node_at_cursor)
+                          actual (tree.get-form node)]
+                      (assert.equals form-type (actual:type)))))
+              (it "cursor end of form"
+                  (fn []
+                    (h.setup {:content "{:a 1}" :cursor [1 6]})
+                    (let [node (ts.get_node_at_cursor)
+                          actual (tree.get-form node)]
+                      (assert.equals form-type (actual:type))))))))
+
+(describe :Set
+          (let [form-type :set_lit]
+            (fn []
+              (it "cursor on #"
+                  (fn []
+                    (h.setup {:content "#{1}" :cursor [1 1]})
+                    (let [node (ts.get_node_at_cursor)
+                          actual (tree.get-form node)]
+                      (assert.equals form-type (actual:type)))))
+              (it "cursor start of form"
+                  (fn []
+                    (h.setup {:content "#{1}" :cursor [1 2]})
+                    (let [node (ts.get_node_at_cursor)
+                          actual (tree.get-form node)]
+                      (assert.equals form-type (actual:type)))))
+              (it "cursor within form"
+                  (fn []
+                    (h.setup {:content "#{1}" :cursor [1 3]})
+                    (let [node (ts.get_node_at_cursor)
+                          actual (tree.get-form node)]
+                      (assert.equals form-type (actual:type)))))
+              (it "cursor end of form"
+                  (fn []
+                    (h.setup {:content "#{1}" :cursor [1 4]})
+                    (let [node (ts.get_node_at_cursor)
+                          actual (tree.get-form node)]
+                      (assert.equals form-type (actual:type))))))))
+
+(describe "Anonymous function"
+          (let [form-type :anon_fn_lit]
+            (fn []
+              (it "cursor on #"
+                  (fn []
+                    (h.setup {:content "#(1)" :cursor [1 1]})
+                    (let [node (ts.get_node_at_cursor)
+                          actual (tree.get-form node)]
+                      (assert.equals form-type (actual:type)))))
+              (it "cursor start of form"
+                  (fn []
+                    (h.setup {:content "#(1)" :cursor [1 2]})
+                    (let [node (ts.get_node_at_cursor)
+                          actual (tree.get-form node)]
+                      (assert.equals form-type (actual:type)))))
+              (it "cursor within form"
+                  (fn []
+                    (h.setup {:content "#(1)" :cursor [1 3]})
+                    (let [node (ts.get_node_at_cursor)
+                          actual (tree.get-form node)]
+                      (assert.equals form-type (actual:type)))))
+              (it "cursor end of form"
+                  (fn []
+                    (h.setup {:content "#(1)" :cursor [1 4]})
+                    (let [node (ts.get_node_at_cursor)
+                          actual (tree.get-form node)]
+                      (assert.equals form-type (actual:type))))))))

justfile

@@ -39,8 +39,8 @@ focus feature: prepare
     --headless \
     --noplugin \
     -u lua/spec/init.lua \
-    -c "PlenaryBustedDirectory lua/spec/nfnl/api/{{feature}} { minimal_init='lua/spec/init.lua', sequential=true }"
+    -c "PlenaryBustedDirectory lua/spec/{{feature}} { minimal_init='lua/spec/init.lua', sequential=true }"
 
 watch feature:
-	fswatch -o lua/formedit/api/{{feature}}.lua lua/spec/nfnl/api/{{feature}}/{{feature}}_spec.lua | xargs -n1 -I{} just focus {{feature}}
+	fswatch -o lua/formedit/{{feature}}.lua lua/spec/{{feature}}/{{feature}}_spec.lua | xargs -n1 -I{} just focus {{feature}}