wrap and insertion

fnl/formedit/find.fnl

@@ -0,0 +1,36 @@
+(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})
+
+;; 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)))
+
+; (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]))
+
+{: form : root}

fnl/formedit/insertion.fnl

@@ -0,0 +1,23 @@
+(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-row start-col _ _] (range form)]
+    (vim.api.nvim_win_set_cursor 0 [start-row start-col])
+    (vim.api.nvim_command "normal! a ")
+    (vim.api.nvim_win_set_cursor 0 [start-row start-col])
+    (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,17 @@
+(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 form-head []
+  (let [form (find.form)
+        [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])
+    (vim.api.nvim_feedkeys :i :n true)))
+
+{: form-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/helper.fnl

@@ -13,11 +13,13 @@
 (fn escape-keys [keys] (vim.api.nvim_replace_termcodes keys true false true))
 (fn feedkeys [keys] (vim.api.nvim_feedkeys (escape-keys keys) :xmt true))
 
-(fn expect [{: cursor : content}]
+(fn expect [{: cursor : content : mode}]
   (when content
     (assert.are.same content
                      (core.first (vim.api.nvim_buf_get_lines 0 0 10 false))))
   (when cursor
-    (assert.are.same cursor (vim.api.nvim_win_get_cursor 0))))
+    (assert.are.same cursor (vim.api.nvim_win_get_cursor 0)))
+  (when mode
+    (assert.are.equal mode (. (vim.api.nvim_get_mode) :mode))))
 
 {: setup : expect : feedkeys}

fnl/spec/insertion_spec.fnl

@@ -0,0 +1,38 @@
+(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 0]})))
+            (it :sub
+                (fn []
+                  (h.setup {:content "(1 (2))" :cursor [1 4]})
+                  (h.feedkeys head-keymap)
+                  (h.expect {:content "(1 ( 2))" :cursor [1 2]})))))
+
+(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_form_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.form-head)))
+            (it "form head"
+                (fn []
+                  (h.setup {:content "(1)" :cursor [1 0]})
+                  (h.feedkeys keymap)
+                  (h.expect {:content "( (1))" :cursor [1 0]})))
+            (it "sub form"
+                (fn []
+                  (h.setup {:content "(1 (2))" :cursor [1 4]})
+                  (h.feedkeys keymap)
+                  (h.expect {:content "(1 ( (2)))" :cursor [1 2]})))))