fix

fnl/formedit/find.fnl

@@ -0,0 +1,42 @@
+(local ts (require :nvim-treesitter.ts_utils))
+
+(local forms {:list_lit true
+              :vec_lit true
+              :map_lit true
+              :set_lit true
+              :anon_fn_lit true})
+
+(local start-offset {:list_lit 0
+                     :vec_lit 0
+                     :map_lit 0
+                     :set_lit 1
+                     :anon_fn_lit 1})
+
+(local insert-offset {:list_lit 1
+                      :vec_lit 1
+                      :map_lit 1
+                      :set_lit 2
+                      :anon_fn_lit 2})
+
+;; Tree search
+(fn find-current-form [node]
+  (if (. forms (node:type))
+      node
+      (let [parent (node:parent)]
+        (when parent (find-current-form parent)))))
+
+(fn find-root-form [node]
+  (if (node:parent)
+      (find-root-form (node:parent))
+      node))
+
+;; Find node
+(fn form []
+  (let [node (ts.get_node_at_cursor)]
+    (find-current-form node)))
+
+(fn root []
+  (let [node (ts.get_node_at_cursor)]
+    (find-root-form node)))
+
+{: form : root : insert-offset : start-offset}

fnl/formedit/init.fnl

@@ -0,0 +1,7 @@
+
+(local find (require :formedit.find))
+(local insertion (require :formedit.insertion))
+(local select (require :formedit.select))
+(local wrap (require :formedit.wrap))
+
+{: find : insertion : select : wrap}

fnl/formedit/insertion.fnl

@@ -0,0 +1,25 @@
+(local find (require :formedit.find))
+
+(fn range [form]
+  (let [[start-row start-col end-row end-col] [(form:range)]]
+    [(+ start-row 1) start-col (+ end-row 1) end-col]))
+
+(fn head []
+  (let [form (find.form)
+        start-offset (. find.start-offset (form:type))
+        insert-offset (. find.insert-offset (form:type))
+        [start-row start-col _ _] (range form)]
+    (vim.api.nvim_win_set_cursor 0 [start-row (+ start-col start-offset)])
+    (vim.api.nvim_command "normal! a ")
+    (vim.api.nvim_win_set_cursor 0 [start-row (+ start-col insert-offset)])
+    (vim.api.nvim_feedkeys :i :n true)))
+
+(fn tail []
+  (let [form (find.form)
+        [_ _ end-row end-col] (range form)]
+    (vim.api.nvim_win_set_cursor 0 [end-row (- end-col 1)])
+    (vim.api.nvim_command "normal! i ")
+    (vim.api.nvim_win_set_cursor 0 [end-row end-col])
+    (vim.api.nvim_feedkeys :i :n true)))
+
+{: head : tail}

fnl/formedit/select.fnl

@@ -1,45 +1,12 @@
 (local ts (require :nvim-treesitter.ts_utils))
+(local find (require :formedit.find))
 
-(local forms {:list_lit true
-              :vec_lit true
-              :map_lit true
-              :set_lit true
-              :anon_fn_lit true})
-
-;; Tree search
-(fn find-current-form [node]
-  (if (. forms (node:type))
-      node
-      (let [parent (node:parent)]
-        (when parent (find-current-form parent)))))
-
-(fn find-root-form [node]
-  (if (node:parent)
-      (find-root-form (node:parent))
-      node))
-
-;; Find node
-(fn get-current-form []
-  (let [node (ts.get_node_at_cursor)]
-    (find-current-form node)))
-
-(fn get-current-root-form []
-  (let [node (ts.get_node_at_cursor)]
-    (find-root-form node)))
-
-; (fn get-inner-form []
-;   (let [form (get-current-form)
-;         [open-row open-col] [(: (. (form:field :open) 1) :end_)]
-;         [end-row end-col] [(: (. (form:field :close) 1) :start)]]
-;     [open-row open-col end-row end-col]))
-
-;; Select node
-(fn select-form []
-  (let [form (get-current-form)]
+(fn form []
+  (let [form (find.form)]
     (ts.update_selection 0 form)))
 
-(fn select-root-form []
-  (let [form (get-current-root-form)]
+(fn root []
+  (let [form (find.root)]
     (ts.update_selection 0 form)))
 
-{: get-current-form : select-form : select-root-form}
+{: form : root}

fnl/formedit/wrap.fnl

@@ -0,0 +1,18 @@
+(local find (require :formedit.find))
+
+(fn range [form]
+  (let [[start-row start-col end-row end-col] [(form:range)]]
+    [(+ start-row 1) start-col (+ end-row 1) end-col]))
+
+(fn head []
+  (let [form (find.form)
+        insert-offset (. find.insert-offset (form:type))
+        [start-row start-col end-row end-col] (range form)]
+    (vim.api.nvim_win_set_cursor 0 [end-row end-col])
+    (vim.api.nvim_command "normal! i)")
+    (vim.api.nvim_win_set_cursor 0 [start-row start-col])
+    (vim.api.nvim_command "normal! i( ")
+    (vim.api.nvim_win_set_cursor 0 [start-row (+ start-col insert-offset)])
+    (vim.api.nvim_feedkeys :i :n true)))
+
+{: head}

fnl/spec/delete_around_spec.fnl

@@ -5,7 +5,7 @@
 (describe "delete around"
           (fn []
             (before_each (fn []
-                           (vim.keymap.set :o :af select.select-form)))
+                           (vim.keymap.set :o :af select.form)))
             (it :list
                 (fn []
                   (h.setup {:content "(1)" :cursor [1 1]})
@@ -45,7 +45,7 @@
 (describe "delete around root"
           (fn []
             (before_each (fn []
-                           (vim.keymap.set :o :aF select.select-root-form)))
+                           (vim.keymap.set :o :aF select.root)))
             (it "cursor at head of form deletes root"
                 (fn []
                   (h.setup {:content "(+ 1 (+ 2 3))" :cursor [1 0]})

fnl/spec/insertion_spec.fnl

@@ -0,0 +1,43 @@
+(local {: describe : it : before_each} (require :plenary.busted))
+(local h (require :spec.helper))
+(local insertion (require :formedit.insertion))
+
+(local head-keymap :<localleader>h)
+(local tail-keymap :<localleader>t)
+
+(describe "head insertion"
+          (fn []
+            (before_each (fn []
+                           (set vim.g.maplocalleader ",")
+                           (vim.keymap.set :n head-keymap insertion.head)))
+            (it :form
+                (fn []
+                  (h.setup {:content "(1)" :cursor [1 0]})
+                  (h.feedkeys head-keymap)
+                  (h.expect {:content "( 1)" :cursor [1 1]})))
+            (it :set
+                (fn []
+                  (h.setup {:content "#{1}" :cursor [1 0]})
+                  (h.feedkeys head-keymap)
+                  (h.expect {:content "#{ 1}" :cursor [1 2]})))
+            (it "sub form"
+                (fn []
+                  (h.setup {:content "(1 (2))" :cursor [1 3]})
+                  (h.feedkeys head-keymap)
+                  (h.expect {:content "(1 ( 2))" :cursor [1 4]})))))
+
+(describe "tail insertion"
+          (fn []
+            (before_each (fn []
+                           (set vim.g.maplocalleader ",")
+                           (vim.keymap.set :n tail-keymap insertion.tail)))
+            (it :form
+                (fn []
+                  (h.setup {:content "(1)" :cursor [1 0]})
+                  (h.feedkeys tail-keymap)
+                  (h.expect {:content "(1 )" :cursor [1 2]})))
+            (it :sub
+                (fn []
+                  (h.setup {:content "(1 (2))" :cursor [1 4]})
+                  (h.feedkeys tail-keymap)
+                  (h.expect {:content "(1 (2 ))" :cursor [1 5]})))))

fnl/spec/wrap_spec.fnl

@@ -0,0 +1,21 @@
+(local {: describe : it : before_each} (require :plenary.busted))
+(local h (require :spec.helper))
+(local wrap (require :formedit.wrap))
+
+(local keymap :<localleader>i)
+
+(describe :wrap
+          (fn []
+            (before_each (fn []
+                           (set vim.g.maplocalleader keymap)
+                           (vim.keymap.set :n keymap wrap.head)))
+            (it "form head"
+                (fn []
+                  (h.setup {:content "(1)" :cursor [1 0]})
+                  (h.feedkeys keymap)
+                  (h.expect {:content "( (1))" :cursor [1 1]})))
+            (it "sub form"
+                (fn []
+                  (h.setup {:content "(1 (2))" :cursor [1 4]})
+                  (h.feedkeys keymap)
+                  (h.expect {:content "(1 ( (2)))" :cursor [1 4]})))))