try to move cursor back to original position

Author: Case Nelson

Diff for: rplugin/node/clj-refactor.js

@@ -1,7 +1,10 @@
 (ns clj-refactor.edit
  (:require
+   [clojure.string :as string]
+   [clojure.zip :as cz]
    [rewrite-clj.node :as n]
    [rewrite-clj.node.forms :as nf]
+   [rewrite-clj.node.protocols :as np]
    [rewrite-clj.paredit :as p]
    [rewrite-clj.zip :as z]
    [rewrite-clj.zip.utils :as zu]
@@ -20,6 +23,9 @@
        (take-while p?)
        last))
 
+(defn to-root [loc]
+  (exec-to loc z/up #(not (top? %))))
+
 (defn parent-let? [zloc]
   (= 'let (-> zloc z/up z/leftmost z/sexpr)))
 
@@ -112,3 +118,33 @@
         z/rightmost
         z/down
         z/down)))
+
+(defn remove-all-after
+  [zloc]
+  (loop [zloc (zu/remove-right-while zloc (constantly true))]
+    (if-let [uploc (z/up zloc)]
+      (recur (zu/remove-right-while uploc (constantly true)))
+      zloc)))
+
+(defn read-position
+  [old-pos zloc]
+  (-> zloc
+      (zdbg "read-position")
+      (remove-all-after)
+      (z/root-string)
+      (z/of-string)
+      (z/rightmost)
+      (z/find-next-depth-first (comp z/end? z/next))
+      (z/node)
+      (meta)
+      ((juxt :row :col))))
+
+(defn mark-position
+  [zloc marker]
+  (z/replace zloc (assoc (z/node zloc) ::marker marker)))
+
+(defn find-mark
+  [zloc marker]
+  (if-let [mloc (z/find (to-root zloc) z/next #(= marker (get (z/node %) ::marker)))]
+    mloc
+    zloc))

Diff for: src/clj_refactor/edit.cljs

@@ -35,22 +35,35 @@
 
 (declare run-transform)
 
+(defn swap-position!
+  [zloc cursor-ref]
+  (swap! cursor-ref edit/read-position zloc)
+  zloc)
+
 (defn zip-it
   "Finds the loc at row col of the file and runs the transformer-fn."
   [transformer lines row col args]
   (try
-    (let [sexpr (string/join "\n" lines)
+    (let [new-cursor (atom [row col])
+          sexpr (string/join "\n" lines)
           pos {:row row :col col :end-row row :end-col col}
           new-sexpr (-> sexpr
                         (z/of-string)
                         (z/find-last-by-pos pos #(not= (z/tag %) :whitespace))
+                        (edit/mark-position :new-cursor)
                         (transformer args)
+                        (edit/find-mark :new-cursor)
+                        (swap-position! new-cursor)
+                        (edit/zdbg (pr-str @new-cursor))
                         ;; TODO should check if anything has changed
                         ;; - should return nil if transformer returned nil
                         (z/root-string)
                         (parinfer/parenMode)
                         (aget "text"))]
-      (split-lines new-sexpr))
+      (let [[row col] @new-cursor]
+        {:row row
+         :col col
+         :new-lines (split-lines new-sexpr)}))
     (catch :default e
       (jdbg "zip-it" e (.-stack e))
       (throw e))))
@@ -62,8 +75,14 @@
                       (fn [err buf]
                         (.getLineSlice buf 0 -1 true true
                                        (fn [err lines]
-                                         (when-let [new-lines (clj->js (zip-it transformer (js->clj lines) row col (concat args static-args)))]
-                                           (.setLineSlice buf 0 -1 true true new-lines))))))
+                                         (when-let [{:keys [row col new-lines]} (zip-it transformer (js->clj lines) row col (concat args static-args))]
+                                           (jdbg "saving" row col)
+                                           (try
+                                             (.setLineSlice buf 0 -1 true true (clj->js new-lines)
+                                                            (fn [err]
+                                                             (.command nvim (str "call cursor("row "," col")"))))
+                                            (catch :default e
+                                              (jdbg "save" e (.-stack e)))))))))
    (catch :default e
      (jdbg "run-transform" e))))
 

Diff for: src/clj_refactor/main.cljs

@@ -88,7 +88,7 @@
   (let [node (z/sexpr zloc)]
     (if (symbol? node)
       (-> zloc
-          (edit/exec-to z/up #(not (edit/top? %))) ; Go to top level form
+          (edit/to-root)
           (z/insert-left (list 'declare node)) ; add declare
           (z/insert-left (n/newline-node "\n\n"))) ; add new line after location
       zloc)))
@@ -262,7 +262,7 @@
                  arg
                  (symbol (str "arg" (inc i)))))]
     (-> example-loc
-      (edit/exec-to z/up #(not (edit/top? %))) ; Go to top level form
+      (edit/to-root)
       (z/insert-left `(~'defn ~fn-name [~@args])) ; add declare
       (z/insert-left (n/newline-node "\n\n"))))) ; add new line after location
 
@@ -274,7 +274,7 @@
         used-syms (map symbol used-locals)]
     (-> expr-loc
       (z/replace `(~fn-sym ~@used-syms))
-      (edit/exec-to z/up #(not (edit/top? %))) ; Go to top level form
+      (edit/to-root)
       (z/insert-left `(~'defn ~fn-sym [~@used-syms] ~expr))
       (z/insert-left (n/newline-node "\n\n"))
       (z/left)

Diff for: src/clj_refactor/transform.cljs

@@ -2,11 +2,12 @@
   (:require
    [rewrite-clj.paredit :as p]
    [rewrite-clj.zip :as z]
+   [rewrite-clj.zip.whitespace :as zw]
    [cljs.nodejs :as nodejs]
    [cljs.test :refer-macros [deftest is testing run-tests are]]
    [clojure.string :as str]
    [clj-refactor.edit :as e]
-   [clj-refactor.test-helper :refer [apply-zip apply-zip-to]]))
+   [clj-refactor.test-helper :refer [str-zip-to zip-to apply-zip apply-zip-to]]))
 
 (deftest test-remove-right
   (are [i j] (= i j)
@@ -61,3 +62,21 @@
     '(x [a c b] y z) (apply-zip '(x [a b c] y z) 'b e/transpose-with-right)
 
     '(x y [a b c] z) (apply-zip '(x [a b c] y z) '[a b c] e/transpose-with-right)))
+
+(deftest test-marking
+  (let [zloc (str-zip-to "(a (b c))\n(x (y z))" 'z identity)]
+    (is (= 'z
+          (-> zloc
+              (e/mark-position ::marked)
+              (z/up)
+              (z/up)
+              (z/insert-left '(x y))
+              (z/left)
+              (e/find-mark ::marked)
+              (z/sexpr))))))
+
+(deftest test-read-position
+  (is (= [1 5]
+         (str-zip-to "(a (b c))\n(x (y z))" 'b (partial e/read-position [55 44]))))
+  (is (= [2 2]
+         (str-zip-to "(a (b c))\n(x (y z))" 'x (partial e/read-position [55 44])))))

Diff for: test/clj_refactor/edit_test.cljs

@@ -3,31 +3,32 @@
    [cljs.reader :as r]
    [rewrite-clj.zip :as z]))
 
-(defn zip-to
-  [form goto f]
-  (-> form
-      (str)
+(defn str-zip-to
+  [form-str goto f]
+  (-> form-str
       (z/of-string)
       (z/find z/next #(= (z/sexpr %) goto))
       (f)))
 
-(defn apply-goto
+(defn zip-to
   [form goto f]
-  (zip-to form goto f))
+  (-> form
+      (str)
+      (str-zip-to goto f)))
 
 (defn apply-zip-to
   [form goto f]
-  (z/sexpr (apply-goto form goto f)))
+  (z/sexpr (zip-to form goto f)))
 
 (defn apply-zip
   [form goto f]
-  (-> (apply-goto form goto f)
+  (-> (zip-to form goto f)
       (z/root-string)
       (r/read-string)))
 
 (defn apply-zip-root
   [form goto f]
   (r/read-string
    (str "(do "
-        (z/root-string (apply-goto form goto f))
+        (z/root-string (zip-to form goto f))
         ")")))