Use tree sitter to select and delete form text object. Broke inside text

object

fnl/formedit/tree.fnl

@@ -17,4 +17,8 @@
         form (get-form node)]
     form))
 
-{: get-current-form}
+(fn select-form []
+  (let [form (get-current-form)]
+    (ts.update_selection 0 form)))
+
+{: get-current-form : select-form}

fnl/spec/delete_around_spec.fnl

@@ -1,36 +1,38 @@
-(local {: describe : it} (require :plenary.busted))
+(local {: describe : it : before_each} (require :plenary.busted))
 (local h (require :spec.helper))
-(local selection (require :formedit.selection))
+(local tree (require :formedit.tree))
 
 (describe "delete around"
           (fn []
+            (before_each (fn []
+                           (vim.keymap.set :o :af tree.select-form)))
             (it :list
                 (fn []
                   (h.setup {:content "(1)" :cursor [1 1]})
-                  (selection.delete-around-form)
+                  (h.feedkeys :daf)
                   (h.expect {:content "" :cursor [1 0]})))
             (it :vector
                 (fn []
                   (h.setup {:content "[1]" :cursor [1 1]})
-                  (selection.delete-around-form)
+                  (h.feedkeys :daf)
                   (h.expect {:content "" :cursor [1 0]})))
             (it :set
                 (fn []
                   (h.setup {:content "#{1}" :cursor [1 1]})
-                  (selection.delete-around-form)
+                  (h.feedkeys :daf)
                   (h.expect {:content "" :cursor [1 0]})))
             (it "anonymous function"
                 (fn []
                   (h.setup {:content "#(fn [x] x)" :cursor [1 1]})
-                  (selection.delete-around-form)
+                  (h.feedkeys :daf)
                   (h.expect {:content "" :cursor [1 0]})))
             (it "delete multiple children"
                 (fn []
                   (h.setup {:content "([1] [2])" :cursor [1 0]})
-                  (selection.delete-around-form)
+                  (h.feedkeys :daf)
                   (h.expect {:content "" :cursor [1 0]})))
             (it "delete across lines"
                 (fn []
                   (h.setup {:content ["([1]" "[2])"] :cursor [1 0]})
-                  (selection.delete-around-form)
+                  (h.feedkeys :daf)
                   (h.expect {:content "" :cursor [1 0] :lines 1})))))

fnl/spec/delete_inside1_spec.fnl

@@ -0,0 +1,13 @@
+(local {: describe : it : before_each} (require :plenary.busted))
+(local h (require :spec.helper))
+(local tree (require :formedit.tree))
+
+(describe "delete inside"
+          (fn []
+            (before_each (fn []
+                           (vim.keymap.set :o :if tree.select-form)))
+            (it :list
+                (fn []
+                  (h.setup {:content "(1)" :cursor [1 0]})
+                  (h.feedkeys :dif)
+                  (h.expect {:content "()" :cursor [1 0]})))))

fnl/spec/delete_inner_spec.fnl → fnl/spec/delete_inside_spec.fnl

@@ -1,49 +1,51 @@
-(local {: describe : it} (require :plenary.busted))
+(local {: describe : it : before_each} (require :plenary.busted))
 (local h (require :spec.helper))
-(local selection (require :formedit.selection))
+(local tree (require :formedit.tree))
 
-(describe "delete inner"
+(describe "delete inside"
           (fn []
+            (before_each (fn []
+                           (vim.keymap.set :o :if tree.select-form)))
             (it :list
                 (fn []
                   (h.setup {:content "(1)" :cursor [1 0]})
-                  (selection.delete-inner-form)
+                  (h.feedkeys :dif)
                   (h.expect {:content "()" :cursor [1 0]})))
             (it :vector
                 (fn []
                   (h.setup {:content "[1]" :cursor [1 1]})
-                  (selection.delete-inner-form)
+                  (h.feedkeys :dif)
                   (h.expect {:content "[]" :cursor [1 1]})))
             (it :set
                 (fn []
                   (h.setup {:content "#{1}" :cursor [1 1]})
-                  (selection.delete-inner-form)
+                  (h.feedkeys :dif)
                   (h.expect {:content "#{}" :cursor [1 1]})))
             (it "anonymous function"
                 (fn []
                   (h.setup {:content "#(fn [x] x)" :cursor [1 1]})
-                  (selection.delete-inner-form)
+                  (h.feedkeys :dif)
                   (h.expect {:content "#()" :cursor [1 1]})))
             (it "delete multiple children"
                 (fn []
                   (h.setup {:content "([1] [2])" :cursor [1 0]})
-                  (selection.delete-inner-form)
+                  (h.feedkeys :dif)
                   (h.expect {:content "()" :cursor [1 0]})))))
 
-(describe "delete inner across lines"
+(describe "delete inside across lines"
           (fn []
             (it :list
                 (fn []
                   (h.setup {:content ["(1" "2)"] :cursor [1 0]})
-                  (selection.delete-inner-form)
+                  (h.feedkeys :dif)
                   (h.expect {:content "()" :cursor [1 0]})))
             (it :vector
                 (fn []
                   (h.setup {:content ["[1" "2]"] :cursor [1 0]})
-                  (selection.delete-inner-form)
+                  (h.feedkeys :dif)
                   (h.expect {:content "[]" :cursor [1 0]})))
             (it :set
                 (fn []
                   (h.setup {:content ["#{1" "2}"] :cursor [1 0]})
-                  (selection.delete-inner-form)
+                  (h.feedkeys :dif)
                   (h.expect {:content "#{}" :cursor [1 0]})))))

fnl/spec/helper.fnl

@@ -10,11 +10,14 @@
     (vim.api.nvim_win_set_cursor 0 cursor)
     (: (vim.treesitter.get_parser 0) :parse)))
 
+(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}]
   (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))))
 
-{: setup : expect}
+{: setup : expect : feedkeys}

fnl/spec/tree_spec.fnl

@@ -2,7 +2,6 @@
 (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 []
@@ -80,7 +79,7 @@
               (it "cursor start of form"
                   (fn []
                     (h.setup {:content "#{1}" :cursor [1 2]})
-                    (let [ actual (tree.get-current-form)]
+                    (let [actual (tree.get-current-form)]
                       (assert.equals form-type (actual:type)))))
               (it "cursor within form"
                   (fn []