inner select

fnl/formedit/find.fnl

@@ -6,17 +6,7 @@
               :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})
+(local offset {:list_lit 1 :vec_lit 1 :map_lit 1 :set_lit 2 :anon_fn_lit 2})
 
 ;; Tree search
 (fn find-current-form [node]
@@ -49,4 +39,4 @@
   (let [node (ts.get_node_at_cursor)]
     (find-root-form node)))
 
-{: form : root : insert-offset : start-offset : first : last}
+{: form : root : offset : first : last}

fnl/formedit/insertion.fnl

@@ -2,9 +2,9 @@
 
 (fn head []
   (let [form (find.form)
-        insert-offset (. find.insert-offset (form:type))
+        offset (. find.offset (form:type))
         [start-row start-col] [(form:start)]
-        start-col (+ start-col insert-offset)]
+        start-col (+ start-col offset)]
     (vim.api.nvim_buf_set_text 0 start-row start-col start-row start-col [" "])
     (vim.api.nvim_win_set_cursor 0 [(+ start-row 1) (+ start-col 1)])
     (vim.api.nvim_feedkeys :i :n true)))

fnl/formedit/select.fnl

@@ -9,4 +9,20 @@
   (let [form (find.root)]
     (ts.update_selection 0 form)))
 
-{: form : root}
+(fn inner-select [form]
+  (let [[start-row start-col end-row end-col] [(form:range)]
+        type (form:type)
+        offset (. find.offset type)]
+    (vim.api.nvim_win_set_cursor 0 [(+ start-row 1) (+ start-col offset)])
+    (vim.api.nvim_command "normal! v")
+    (vim.api.nvim_win_set_cursor 0 [(+ end-row 1) (- end-col 2)])))
+
+(fn inner []
+  (let [form (find.form)]
+    (inner-select form)))
+
+(fn inner-root []
+  (let [form (find.root)]
+    (inner-select form)))
+
+{: form : root : inner : inner-root}

fnl/formedit/slurp.fnl

@@ -17,7 +17,7 @@
   (let [form (find.form)
         [row col] [(form:start)]
         type (form:type)
-        offset (. find.insert-offset type)
+        offset (. find.offset type)
         col (+ col offset)
         sibling (form:prev_sibling)
         sibling-text (ts.get_node_text sibling 0)

fnl/formedit/wrap.fnl

@@ -2,13 +2,11 @@
 
 (fn head []
   (let [form (find.form)
-        insert-offset (. find.insert-offset (form:type))
+        offset (. find.offset (form:type))
         [start-row start-col end-row end-col] [(form:range)]]
     (vim.api.nvim_buf_set_text 0 end-row end-col end-row end-col [")"])
     (vim.api.nvim_buf_set_text 0 start-row start-col start-row start-col ["( "])
-    (vim.api.nvim_win_set_cursor 0
-                                 [(+ start-row 1)
-                                  (+ start-col insert-offset 1)])
+    (vim.api.nvim_win_set_cursor 0 [(+ start-row 1) (+ start-col offset 1)])
     (vim.api.nvim_feedkeys :i :n true)))
 
 {: head}

fnl/spec/delete_inner_spec.fnl

@@ -0,0 +1,33 @@
+(local {: describe : it : before_each} (require :plenary.busted))
+(local h (require :spec.helper))
+(local select (require :formedit.select))
+
+(describe "delete inner form"
+          (fn []
+            (before_each (fn []
+                           (vim.keymap.set :o :if select.inner)))
+            (it :list
+                (fn []
+                  (h.setup {:content "(1)" :cursor [1 0]})
+                  (h.feedkeys :dif)
+                  (h.expect {:content "()" :cursor [1 1]})))
+            (it :set
+                (fn []
+                  (h.setup {:content "#{1}" :cursor [1 0]})
+                  (h.feedkeys :dif)
+                  (h.expect {:content "#{}" :cursor [1 2]})))))
+
+(describe "delete inner root form"
+          (fn []
+            (before_each (fn []
+                           (vim.keymap.set :o :iF select.inner-root)))
+            (it "within first node"
+                (fn []
+                  (h.setup {:content "([1] 2)" :cursor [1 1]})
+                  (h.feedkeys :diF)
+                  (h.expect {:content "()" :cursor [1 1]})))
+            (it "within second node"
+                (fn []
+                  (h.setup {:content "(1 [2])" :cursor [1 3]})
+                  (h.feedkeys :diF)
+                  (h.expect {:content "()" :cursor [1 1]})))))