emacs-elpa-diffs
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[elpa] scratch/add-vdiff ad37c86 009/258: Factor out subtraction overlay


From: Justin Burkett
Subject: [elpa] scratch/add-vdiff ad37c86 009/258: Factor out subtraction overlay and prefix internal vars
Date: Wed, 17 May 2017 08:13:12 -0400 (EDT)

branch: scratch/add-vdiff
commit ad37c867e0a6e67051f68b9c92e65cbbe7330ff9
Author: justbur <address@hidden>
Commit: justbur <address@hidden>

    Factor out subtraction overlay and prefix internal vars
---
 vdiff.el | 533 +++++++++++++++++++++++++++++++++++----------------------------
 1 file changed, 299 insertions(+), 234 deletions(-)

diff --git a/vdiff.el b/vdiff.el
index cb3c4ac..0346525 100644
--- a/vdiff.el
+++ b/vdiff.el
@@ -186,39 +186,39 @@ the buffer here, because those are handled differently."
                         (max (point-min)
                              (1- pos))
                       pos)))
-        (when (overlay-get ovr 'vdiff-type)
+        (when (overlay-get ovr 'vdiff--type)
           (throw 'yes ovr))))))
 
-(defun vdiff-overlays-in-region (beg end)
+(defun vdiff--overlays-in-region (beg end)
   (let (ovrs)
     (dolist (ovr (overlays-in beg end))
-      (when (overlay-get ovr 'vdiff-type)
+      (when (overlay-get ovr 'vdiff--type)
         (push ovr ovrs)))
     (nreverse ovrs)))
 
-(defun vdiff-maybe-exit-overlay (&optional up)
-  (let* ((ovr (vdiff-overlay-at-point up))
-         (type (when ovr (overlay-get ovr 'vdiff-type))))
+(defun vdiff--maybe-exit-overlay (&optional up)
+  (let* ((ovr (vdiff--overlay-at-point up))
+         (type (when ovr (overlay-get ovr 'vdiff--type))))
     (when (memq type '(addition change))
-      (let ((range (overlay-get ovr 'vdiff-range)))
+      (let ((range (overlay-get ovr 'vdiff--range)))
         (goto-char (if up (car range) (cdr range)))))))
 
-(defmacro vdiff-with-other-window (&rest body)
-  `(when (and (vdiff-buffer-p)
-              (not vdiff-inhibit-window-switch)
-              (vdiff-other-window))
-     (setq vdiff-inhibit-window-switch t)
+(defmacro vdiff--with-other-window (&rest body)
+  `(when (and (vdiff--buffer-p)
+              (not vdiff--inhibit-window-switch)
+              (vdiff--other-window))
+     (setq vdiff--inhibit-window-switch t)
      (save-selected-window
        (unwind-protect
            (progn
-             (select-window (vdiff-other-window))
+             (select-window (vdiff--other-window))
              ,@body)
-         (setq vdiff-inhibit-window-switch nil)))))
+         (setq vdiff--inhibit-window-switch nil)))))
 
-(defmacro vdiff-with-both-buffers (&rest body)
-  `(when (and (buffer-live-p (car vdiff-buffers))
-              (buffer-live-p (cadr vdiff-buffers)))
-     (dolist (buf vdiff-buffers)
+(defmacro vdiff--with-both-buffers (&rest body)
+  `(when (and (buffer-live-p (car vdiff--buffers))
+              (buffer-live-p (cadr vdiff--buffers)))
+     (dolist (buf vdiff--buffers)
        (with-current-buffer buf
          ,@body))))
 
@@ -229,79 +229,83 @@ the buffer here, because those are handled differently."
                          (list
                           vdiff-diff-program
                           vdiff-diff-program-args
-                          (car vdiff-temp-files)
-                          (cadr vdiff-temp-files))
+                          (car vdiff--temp-files)
+                          (cadr vdiff--temp-files))
                          " "))
-         proc)
-    (with-current-buffer (car vdiff-buffers)
-      (write-region nil nil (car vdiff-temp-files)))
-    (with-current-buffer (cadr vdiff-buffers)
-      (write-region nil nil (cadr vdiff-temp-files)))
-    (with-current-buffer (get-buffer-create vdiff-process-buffer)
-      (erase-buffer))
+         (proc (get-buffer-process
+                vdiff--process-buffer)))
+    (with-current-buffer (car vdiff--buffers)
+      (write-region nil nil (car vdiff--temp-files)))
+    (with-current-buffer (cadr vdiff--buffers)
+      (write-region nil nil (cadr vdiff--temp-files)))
     (when proc
       (kill-process proc))
+    (with-current-buffer (get-buffer-create vdiff--process-buffer)
+      (erase-buffer))
     (setq proc (start-process-shell-command
-                vdiff-process-buffer
-                vdiff-process-buffer
+                vdiff--process-buffer
+                vdiff--process-buffer
                 cmd))
-    (set-process-sentinel proc #'vdiff-diff-refresh-1)))
-
-(defun vdiff-diff-refresh-1 (proc event)
-  (cond ((string-match-p "exited abnormally with code 1" event)
-         (setq vdiff-diff-data nil)
+    (set-process-sentinel proc #'vdiff--diff-refresh-1)))
+
+(defun vdiff--diff-refresh-1 (_proc event)
+  (cond ((string= "finished\n" event)
+         ;; means no difference between files
+         (setq vdiff--diff-data nil)
+         (vdiff--refresh-overlays))
+        ((string= "exited abnormally with code 1\n" event)
+         (setq vdiff--diff-data nil)
          (let (res)
-           (with-current-buffer vdiff-process-buffer
+           (with-current-buffer vdiff--process-buffer
              (goto-char (point-min))
-             (while (re-search-forward vdiff-diff-code-regexp nil t)
-               (push (list (match-string 3)
-                           (cons (vdiff-maybe-int (match-string 1))
-                                 (vdiff-maybe-int (match-string 2)))
-                           (cons (vdiff-maybe-int (match-string 4))
-                                 (vdiff-maybe-int (match-string 5))))
-                     res)))
-           (setq vdiff-diff-data (nreverse res)))
-         (vdiff-refresh-overlays))
-        ((string= event "finished\n"))
+             (while (re-search-forward vdiff--diff-code-regexp nil t)
+               (let ((code (match-string 3))
+                     (a-range (cons (vdiff--maybe-int (match-string 1))
+                                    (vdiff--maybe-int (match-string 2))))
+                     (b-range (cons (vdiff--maybe-int (match-string 4))
+                                    (vdiff--maybe-int (match-string 5)))))
+                 (push (list code a-range b-range) res))))
+           (setq vdiff--diff-data (nreverse res)))
+         (vdiff--refresh-overlays))
         ((string-match-p "exited abnormally with code" event)
+         (setq vdiff--diff-data nil)
+         (vdiff--refresh-overlays)
          (message "vdiff process error: %s" event))))
 
-(defun vdiff-remove-all-overlays ()
-  (vdiff-with-both-buffers (remove-overlays)))
+(defun vdiff--remove-all-overlays ()
+  (vdiff--with-both-buffers (remove-overlays)))
 
 (defun vdiff-save-buffers ()
+  "Save all vdiff buffers."
   (interactive)
-  (vdiff-with-both-buffers (save-buffer)))
+  (vdiff--with-both-buffers (save-buffer)))
 
 ;; * Add overlays
 
-(defun vdiff-add-subtraction-overlays
-    (buffer start-line target-range amount)
+(defun vdiff--make-subtraction-string (length)
+  (let (string)
+    (dotimes (_ length)
+      (push (make-string (vdiff--min-window-width) ?-) string))
+    (propertize
+     (concat (mapconcat #'identity string "\n") "\n")
+     'face '(:background "#440000"))))
+
+(defun vdiff--add-subtraction-overlays (buffer start-line target-range amount)
   (with-current-buffer buffer
-    (vdiff-move-to-line start-line)
+    (vdiff--move-to-line start-line)
     (end-of-line)
-    (let ((position (1+ (point)))
-          text)
-      (dotimes (i amount)
-        (push
-         (make-string
-          (1- (window-width (get-buffer-window buffer)))
-          ?-)
-         text))
-      (let ((ovr (make-overlay position (1+ position))))
-        (overlay-put ovr 'before-string 
-                     (propertize
-                      (concat
-                       (mapconcat #'identity text "\n")
-                       "\n")
-                      'face '(:background "#440000")))
-        (overlay-put ovr 'vdiff-type 'subtraction) 
-        (overlay-put ovr 'vdiff-target-range target-range)))))
-
-(defun vdiff-add-change-overlays
-    (buffer start-line lines target-range &optional addition)
+    (let* ((position (1+ (point)))
+           (ovr (make-overlay position (1+ position))))
+      (overlay-put ovr 'before-string 
+                   (vdiff--make-subtraction-string amount))
+      (overlay-put ovr 'vdiff--target-range target-range)
+      (overlay-put ovr 'vdiff--type 'subtraction))))
+
+(defun vdiff--add-change-overlays
+    (buffer start-line lines target-range
+            &optional addition subtraction-padding)
   (with-current-buffer buffer
-    (vdiff-move-to-line start-line)
+    (vdiff--move-to-line start-line)
     (let ((beg (point))
           (end (progn (forward-line lines)
                       (point))))
@@ -309,20 +313,23 @@ the buffer here, because those are handled differently."
         (overlay-put ovr 'face (if addition
                                    '(:background "#004422")
                                  '(:background "#353500")))
-        (overlay-put ovr 'vdiff-type (if addition
-                                            'addition
-                                          'change))
-        (overlay-put ovr 'vdiff-range (cons beg end))
-        (overlay-put ovr 'vdiff-target-range target-range)))))
-
-(defun vdiff-refresh-overlays ()
-  (vdiff-remove-all-overlays)
-  (vdiff-refresh-line-maps)
+        (overlay-put ovr 'vdiff--type (if addition
+                                         'addition
+                                       'change))
+        (overlay-put ovr 'vdiff--range (cons beg end))
+        (overlay-put ovr 'vdiff--target-range target-range)
+        (when subtraction-padding
+          (overlay-put ovr 'after-string
+                       (vdiff--make-subtraction-string 
subtraction-padding)))))))
+
+(defun vdiff--refresh-overlays ()
+  (vdiff--remove-all-overlays)
+  (vdiff--refresh-line-maps)
   (save-excursion
-    (dolist (header vdiff-diff-data)
+    (dolist (header vdiff--diff-data)
       (let* ((code (nth 0 header))
-             (a-buffer (car vdiff-buffers))
-             (b-buffer (cadr vdiff-buffers))
+             (a-buffer (car vdiff--buffers))
+             (b-buffer (cadr vdiff--buffers))
              (a-range (nth 1 header))
              (a-beg (car a-range))
              (a-end (if (cdr-safe a-range)
@@ -338,33 +345,35 @@ the buffer here, because those are handled differently."
              (b-norm-range (cons b-beg b-end))
              (b-length (1+ (- b-end b-beg))))
         (cond ((string= code "d")
-               (vdiff-add-subtraction-overlays
+               (vdiff--add-subtraction-overlays
                 b-buffer b-beg a-norm-range a-length)
-               (vdiff-add-change-overlays
+               (vdiff--add-change-overlays
                 a-buffer a-beg a-length b-norm-range t))
+
               ((string= code "a")
-               (vdiff-add-subtraction-overlays
+               (vdiff--add-subtraction-overlays
                 a-buffer a-beg b-norm-range b-length)
-               (vdiff-add-change-overlays
+               (vdiff--add-change-overlays
                 b-buffer b-beg b-length a-norm-range t))
+
               ((and (string= code "c") (> a-length b-length))
-               (vdiff-add-change-overlays
+               (vdiff--add-change-overlays
                 a-buffer a-beg a-length b-norm-range)
-               (vdiff-add-change-overlays
-                b-buffer b-beg b-length a-norm-range)
-               (vdiff-add-subtraction-overlays
-                b-buffer b-end nil (- a-length b-length)))
+               (vdiff--add-change-overlays
+                b-buffer b-beg b-length a-norm-range
+                nil (- a-length b-length)))
+
               ((and (string= code "c") (< a-length b-length))
-               (vdiff-add-change-overlays
-                a-buffer a-beg a-length b-norm-range)
-               (vdiff-add-change-overlays
-                b-buffer b-beg b-length a-norm-range)
-               (vdiff-add-subtraction-overlays
-                a-buffer a-end nil (- b-length a-length)))
+               (vdiff--add-change-overlays
+                a-buffer a-beg a-length b-norm-range
+                nil (- b-length a-length))
+               (vdiff--add-change-overlays
+                b-buffer b-beg b-length a-norm-range))
+
               ((string= code "c")
-               (vdiff-add-change-overlays
+               (vdiff--add-change-overlays
                 a-buffer a-beg a-length b-norm-range)
-               (vdiff-add-change-overlays
+               (vdiff--add-change-overlays
                 b-buffer b-beg b-length a-norm-range)))))))
 
 ;; * Moving changes
@@ -377,7 +386,7 @@ changes under point or on the immediately preceding line."
    (if (region-active-p)
        (list (region-beginning) (region-end))
      (list (if (or (= (line-number-at-pos) 1)
-                   (vdiff-overlay-at-point
+                   (vdiff--overlay-at-point
                     nil (line-beginning-position)))
                (line-beginning-position)
              (save-excursion
@@ -386,11 +395,14 @@ changes under point or on the immediately preceding line."
            (line-end-position))))
   (let* ((ovrs (overlays-in beg end)))
     (dolist (ovr ovrs)
-      (cond ((memq (overlay-get ovr 'vdiff-type)
+      (cond ((memq (overlay-get ovr 'vdiff--type)
                    '(change addition))
-             (vdiff-transmit-change-overlay ovr receive))
-            ((eq (overlay-get ovr 'vdiff-type) 'subtraction)
-             (vdiff-transmit-subtraction-overlay ovr receive))))
+             (vdiff--transmit-change-overlay ovr receive))
+            ((eq (overlay-get ovr 'vdiff--type) 'change-subtraction)
+             (vdiff--transmit-subtraction-overlay
+              (overlay-get ovr 'vdiff--change-overlay) receive))
+            ((eq (overlay-get ovr 'vdiff--type) 'subtraction)
+             (vdiff--transmit-subtraction-overlay ovr receive))))
     (vdiff-refresh)))
 
 (defun vdiff-receive-changes (beg end)
@@ -402,7 +414,7 @@ changes under point or on the immediately preceding line."
    (if (region-active-p)
        (list (region-beginning) (region-end))
      (list (if (or (= (line-number-at-pos) 1)
-                   (vdiff-overlay-at-point
+                   (vdiff--overlay-at-point
                     nil (line-beginning-position)))
                (line-beginning-position)
              (save-excursion
@@ -411,25 +423,25 @@ changes under point or on the immediately preceding line."
            (line-end-position))))
   (vdiff-send-changes beg end t))
 
-(defun vdiff-transmit-change-overlay (chg-ovr &optional receive)
+(defun vdiff--transmit-change-overlay (chg-ovr &optional receive)
   (cond ((not (overlayp chg-ovr))
          (message "No change found"))
         (receive
-         (let* ((target-rng (overlay-get chg-ovr 'vdiff-target-range))
-                (pos (vdiff-pos-at-line-beginning
-                      (car target-rng) (vdiff-other-buffer))))
-           (vdiff-with-other-window
+         (let* ((target-rng (overlay-get chg-ovr 'vdiff--target-range))
+                (pos (vdiff--pos-at-line-beginning
+                      (car target-rng) (vdiff--other-buffer))))
+           (vdiff--with-other-window
             (vdiff-send-changes pos (1+ pos)))))
         (t
-         (let* ((addition (eq 'addition (overlay-get chg-ovr 'vdiff-type)))
-                (target-rng (overlay-get chg-ovr 'vdiff-target-range))
+         (let* ((addition (eq 'addition (overlay-get chg-ovr 'vdiff--type)))
+                (target-rng (overlay-get chg-ovr 'vdiff--target-range))
                 (text (buffer-substring-no-properties
                        (overlay-start chg-ovr)
                        (overlay-end chg-ovr))))
-           (with-current-buffer (vdiff-other-buffer)
+           (with-current-buffer (vdiff--other-buffer)
              (if addition
-                 (vdiff-move-to-line (1+ (car target-rng)))
-               (vdiff-move-to-line (car target-rng))
+                 (vdiff--move-to-line (1+ (car target-rng)))
+               (vdiff--move-to-line (car target-rng))
                (delete-region (point)
                               (save-excursion
                                 (forward-line
@@ -438,44 +450,41 @@ changes under point or on the immediately preceding line."
                                 (point))))
              (insert text))))))
 
-(defun vdiff-transmit-subtraction-overlay (sub-ovr &optional receive)
+(defun vdiff--transmit-subtraction-overlay (sub-ovr &optional receive)
   (cond ((not (overlayp sub-ovr))
          (message "No change found"))
         (receive
-         (let* ((target-rng (overlay-get sub-ovr 'vdiff-target-range))
-                (pos (vdiff-pos-at-line-beginning
-                      (car target-rng) (vdiff-other-buffer))))
-           (vdiff-with-other-window
+         (let* ((target-rng (overlay-get sub-ovr 'vdiff--target-range))
+                (pos (vdiff--pos-at-line-beginning
+                      (car target-rng) (vdiff--other-buffer))))
+           (vdiff--with-other-window
             (vdiff-send-changes pos (1+ pos)))))
         (t
          (let* ((target-rng
-                 (overlay-get sub-ovr 'vdiff-target-range)))
+                 (overlay-get sub-ovr 'vdiff--target-range)))
            (when target-rng
-             (with-current-buffer (vdiff-other-buffer)
-               (vdiff-move-to-line (car target-rng))
+             (with-current-buffer (vdiff--other-buffer)
+               (vdiff--move-to-line (car target-rng))
                (delete-region (point)
                               (save-excursion
-                                (vdiff-move-to-line
+                                (vdiff--move-to-line
                                  (1+ (cdr target-rng)))
                                 (point)))))))))
 
 ;; * Scrolling and line syncing
 
-(defun vdiff-refresh-line-maps ()
+(defun vdiff--refresh-line-maps ()
   (let (new-map)
-    (dolist (entry vdiff-diff-data)
+    (dolist (entry vdiff--diff-data)
       (let* ((code (car entry))
              (a-lines (nth 1 entry))
              (a-beg (car a-lines))
              (a-end (or (cdr-safe a-lines)
                         (car a-lines)))
-             ;; (a-length (1+ (- a-end a-beg)) )
              (b-lines (nth 2 entry))
              (b-beg (car b-lines))
              (b-end (or (cdr-safe b-lines)
-                        (car b-lines)))
-             ;; (b-length (1+ (- b-end b-beg)))
-             (delta 0))
+                        (car b-lines))))
         (cond ((string= code "d")
                (push (cons (1- a-beg) b-beg) new-map)
                (push (cons (1+ a-end) (1+ b-end)) new-map))
@@ -485,13 +494,13 @@ changes under point or on the immediately preceding line."
               ((and (string= code "c"))
                (push (cons (1- a-beg) (1- b-beg)) new-map)
                (push (cons (1+ a-end) (1+ b-end)) new-map)))))
-    (setq vdiff-line-map (nreverse new-map))))
+    (setq vdiff--line-map (nreverse new-map))))
 
-(defun vdiff-translate-line (line &optional B-to-A)
+(defun vdiff--translate-line (line &optional B-to-A)
   (let ((nearest-line
          (catch 'closest
            (let (closest)
-             (dolist (entry vdiff-line-map)
+             (dolist (entry vdiff--line-map)
                (if (> (if B-to-A
                           (cdr entry)
                         (car entry)) line)
@@ -505,183 +514,239 @@ changes under point or on the immediately preceding 
line."
           (t line))))
 
 (defun vdiff-goto-corresponding-line (line in-b)
+  "Jump to the line in the other vdiff buffer that corresponds to
+the current one."
   (interactive (list (line-number-at-pos)
-                     (not (vdiff-buffer-a-p))))
+                     (not (vdiff--buffer-a-p))))
   (vdiff-refresh)
-  (let* ((new-line (vdiff-translate-line line in-b))
-         (new-pos (vdiff-pos-at-line-beginning new-line)))
-    (select-window (vdiff-other-window))
+  (let* ((new-line (vdiff--translate-line line in-b))
+         (new-pos (vdiff--pos-at-line-beginning new-line)))
+    (select-window (vdiff--other-window))
     (goto-char new-pos)))
 
-(defun vdiff-sync-line (line in-a)
+(defun vdiff--sync-line (line in-a)
+  "Sync point in the other vdiff buffer to the line in this
+buffer. This is usually not necessary."
   (interactive (list (line-number-at-pos)
-                     (not (vdiff-buffer-a-p))))
-  (let ((new-line (vdiff-translate-line
+                     (not (vdiff--buffer-a-p))))
+  (let ((new-line (vdiff--translate-line
                    line (not in-a)))
-        (other-buffer (vdiff-other-buffer))
-        (other-window (vdiff-other-window)))
+        (other-buffer (vdiff--other-buffer))
+        (other-window (vdiff--other-window)))
     (set-window-point
      other-window
-     (vdiff-pos-at-line-beginning new-line other-buffer))))
+     (vdiff--pos-at-line-beginning new-line other-buffer))))
 
 (defun vdiff-sync-and-center ()
+  "Sync point in the other vdiff buffer to the line in this
+buffer and center both buffers at this line."
   (interactive)
-  (vdiff-sync-line (line-number-at-pos) (vdiff-buffer-a-p))
+  (vdiff--sync-line (line-number-at-pos) (vdiff--buffer-a-p))
   (recenter)
-  (vdiff-with-other-window
+  (vdiff--with-other-window
    (recenter)))
 
-(defun vdiff-pos-at-line-beginning (line &optional buffer)
+(defun vdiff--pos-at-line-beginning (line &optional buffer)
   (with-current-buffer (or buffer (current-buffer))
     (save-excursion
-      (vdiff-move-to-line line)
+      (vdiff--move-to-line line)
       (line-beginning-position))))
 
-(defun vdiff-scroll-other (window window-start)
-  (let ((win-a (get-buffer-window (car vdiff-buffers)))
-        (win-b (get-buffer-window (nth 1 vdiff-buffers))))
+(defun vdiff-sync-scroll (window window-start)
+  "Sync scrolling of all vdiff windows."
+  (let* ((buf-a (car vdiff--buffers))
+         (buf-b (cadr vdiff--buffers))
+         (win-a (get-buffer-window buf-a))
+         (win-b (get-buffer-window buf-b)))
     (when (and (eq window (selected-window))
                (window-live-p win-a)
                (window-live-p win-b)
                (memq window (list win-a win-b)))
       (let* ((in-b (eq window win-b))
-             (this-window (if in-b win-b win-a))
              (other-window (if in-b win-a win-b))
-             (other-buffer (if in-b (car vdiff-buffers)
-                             (nth 1 vdiff-buffers)))
+             (other-buffer (if in-b buf-a buf-b))
              (this-line (line-number-at-pos (point)))
-             (other-line (vdiff-translate-line
+             (other-line (vdiff--translate-line
                           this-line in-b))
              (this-start  (line-number-at-pos window-start))
-             (other-start (vdiff-translate-line
+             (other-start (vdiff--translate-line
                            this-start in-b))
-             (other-start-pos (vdiff-pos-at-line-beginning
-                               other-start other-buffer))
-             other-pos)
+             (other-start-pos (vdiff--pos-at-line-beginning
+                               other-start other-buffer)))
         (set-window-start other-window other-start-pos)
-        (vdiff-with-other-window
-         (goto-char (vdiff-pos-at-line-beginning other-line)))))))
-
-(defun vdiff-toggle-lock ()
-  (interactive)
-  (with-current-buffer (car vdiff-buffers)
-    (vdiff-sync-line (line-number-at-pos) t)
-    (scroll-all-mode)))
-
+        (vdiff--with-other-window
+         (goto-char (vdiff--pos-at-line-beginning other-line)))))))
 
-(defun vdiff-sync-scroll ()
+(defun vdiff-mirror-commands ()
+  "Execute `vdiff-mirrored-commands' in all buffers."
   ;; Use real-this-command because evil-next-line and evil-previous-line 
pretend
   ;; they are next-line and previous-line
-  (when (and (memq real-this-command vdiff-copied-commands)
-             (not vdiff-inhibit-sync))
+  (when (and (memq real-this-command vdiff-mirrored-commands)
+             (not vdiff--inhibit-sync))
     (let ((this-line (line-number-at-pos))
           ;; This is necessary to not screw up the cursor column after calling
           ;; next-line or previous-line again from the other buffer
           temporary-goal-column)
-      (vdiff-with-other-window
+      (vdiff--with-other-window
        (ignore-errors
-         (let ((vdiff-inhibit-sync t))
+         (let ((vdiff--inhibit-sync t))
            (call-interactively real-this-command))
-         (if (< vdiff-scroll-command-cnt 40)
-             (incf vdiff-scroll-command-cnt)
+         (if (< vdiff--scroll-command-cnt 40)
+             (incf vdiff--scroll-command-cnt)
            ;; (message "syncing lines")
-           (setq vdiff-scroll-command-cnt 0)
-           (vdiff-move-to-line
-            (vdiff-translate-line
-             this-line (vdiff-buffer-a-p)))))))))
+           (setq vdiff--scroll-command-cnt 0)
+           (vdiff--move-to-line
+            (vdiff--translate-line
+             this-line (vdiff--buffer-a-p)))))))))
 
 ;; * Movement
 
 (defun vdiff-next-change ()
+  "Jump to next change in this buffer."
   (interactive)
-  (vdiff-maybe-exit-overlay)
+  (vdiff--maybe-exit-overlay)
   (let ((next (next-overlay-change (point))))
     (if (= next (point-max))
         (message "No more changes")
       (goto-char next)
       (while (and (not (eobp))
-                  (not (vdiff-overlay-at-point)))
+                  (not (vdiff--overlay-at-point)))
         (goto-char next)
         (setq next (next-overlay-change (point))))
       (vdiff-sync-and-center))))
 
 (defun vdiff-previous-change ()
+  "Jump to previous change in this buffer."
   (interactive)
-  (vdiff-maybe-exit-overlay t)
+  (vdiff--maybe-exit-overlay t)
   (let ((next (previous-overlay-change (point))))
     (if (= next (point-min))
         (message "No more changes")
       (goto-char next)
       (while (and (not (bobp))
-                  (not (vdiff-overlay-at-point)))
+                  (not (vdiff--overlay-at-point)))
         (goto-char next)
         (setq next (previous-overlay-change (point))))
       (vdiff-sync-and-center))))
 
 ;; * Entry points
- 
-(defun vdiff-files (A B &optional horizontal)
-  (interactive (let ((file-a (read-file-name "File 1: ")))
-                 (list
-                  file-a
-                  (read-file-name
-                   (format "[File 1 %s] File 2: "
-                           (file-name-nondirectory file-a)))
-                  current-prefix-arg)))
-  (let (a-window b-window a-buffer)
+
+;;;###autoload
+(defun vdiff-files (file-a file-b &optional horizontal)
+  "Start a vdiff session. If called interactively, you will be
+asked to select two files."
+  (interactive
+   (let* ((file-a (read-file-name "File 1: "))
+          (default-directory
+            (file-name-directory file-a)))
+     (list
+      file-a
+      (read-file-name
+       (format "[File 1 %s] File 2: "
+               (file-name-nondirectory file-a)))
+      current-prefix-arg)))
+  (let (window-b buffer-a)
+    (delete-other-windows)
+    (find-file file-a)
+    (goto-char (point-min))
+    (setq buffer-a (current-buffer))
+    (save-selected-window
+      (setq window-b (if horizontal
+                         (split-window-vertically)
+                       (split-window-horizontally)))
+      (find-file-other-window file-b)
+      (setq vdiff--buffers (list buffer-a (window-buffer window-b)))
+      (vdiff-mode 1)
+      (vdiff-refresh))))
+
+;;;###autoload
+(defun vdiff-buffers (buffer-a buffer-b &optional horizontal)
+  "Start a vdiff session. If called interactively, you will be
+asked to select two buffers."
+  (interactive
+   (let* ((buffer-a
+           (get-buffer
+            (read-buffer
+             "Buffer 1: " (current-buffer)))))
+     (list
+      buffer-a
+      (get-buffer
+       (read-buffer
+        (format "[Buffer 1 %s] Buffer 2: " buffer-a)
+        (window-buffer (next-window (selected-window)))))
+      current-prefix-arg)))
+  (let (window-b)
     (delete-other-windows)
-    (find-file A)
+    (switch-to-buffer buffer-a)
     (goto-char (point-min))
-    (setq a-buffer (current-buffer))
     (save-selected-window
-      (setq b-window (if horizontal
+      (setq window-b (if horizontal
                          (split-window-vertically)
                        (split-window-horizontally)))
-      (find-file-other-window B)
-      (setq vdiff-buffers (list a-buffer (window-buffer b-window)))
-      (vdiff-with-both-buffers
+      (switch-to-buffer-other-window buffer-b)
+      (setq vdiff--buffers (list buffer-a buffer-b))
+      (vdiff--with-both-buffers
        (vdiff-mode 1))
       (vdiff-refresh))))
 
-(defvar vdiff-mode-map (make-sparse-keymap))
-(define-key vdiff-mode-map "\C-l"  'vdiff-sync-and-center)
-(define-key vdiff-mode-map "\C-cg" 'vdiff-goto-corresponding-line)
-(define-key vdiff-mode-map "\C-cn" 'vdiff-next-change)
-(define-key vdiff-mode-map "\C-cp" 'vdiff-previous-change)
-(define-key vdiff-mode-map "\C-cs" 'vdiff-send-changes)
-(define-key vdiff-mode-map "\C-cr" 'vdiff-receive-changes)
+(defvar vdiff-mode-map
+  (let ((map (make-sparse-keymap)))
+    (define-key map "\C-l"  'vdiff-sync-and-center)
+    map))
+
+(defvar vdiff-mode-prefix-map
+  (let ((map (make-sparse-keymap)))
+    (define-key map "g" 'vdiff-goto-corresponding-line)
+    (define-key map "n" 'vdiff-next-change)
+    (define-key map "p" 'vdiff-previous-change)
+    (define-key map "s" 'vdiff-send-changes)
+    (define-key map "r" 'vdiff-receive-changes)
+    (define-key map "w" 'vdiff-save-buffers)
+    map))
 
 (define-minor-mode vdiff-mode
-  " "
-  nil " VDIFF" 'vdiff-mode-map
-  (if vdiff-mode
-      (progn
-        (setq cursor-in-non-selected-windows nil)
-        (add-hook 'after-save-hook #'vdiff-refresh nil t)
-        (when vdiff-lock-scrolling
-          (vdiff-scroll-lock-mode 1)))
-    (setq cursor-in-non-selected-windows t)
-    (setq vdiff-diff-data nil)
-    (vdiff-remove-all-overlays)
-    (remove-hook 'after-save-hook #'vdiff-refresh t)
-    (when vdiff-scroll-lock-mode
-      (vdiff-scroll-lock-mode -1))))
+  "Minor mode active in a vdiff session. This sets up key
+bindings in `vdiff-mode-map' and adds hooks to refresh diff on
+changes. This will be enabled automatically after calling
+commands like `vdiff-files' or `vdiff-buffers'."
+  nil " vdiff" 'vdiff-mode-map
+  (cond (vdiff-mode
+         (setq cursor-in-non-selected-windows nil)
+         (add-hook 'after-save-hook #'vdiff-refresh nil t)
+         (when vdiff-lock-scrolling
+           (vdiff-scroll-lock-mode 1)))
+        (t
+         (vdiff--remove-all-overlays)
+         (setq cursor-in-non-selected-windows t)
+         (remove-hook 'after-save-hook #'vdiff-refresh t)
+         (when vdiff-scroll-lock-mode
+           (vdiff-scroll-lock-mode -1))
+         (setq vdiff--diff-data nil)
+         (setq vdiff--buffers nil)
+         (setq vdiff--line-map nil)
+         (setq vdiff--temp-files nil)
+         (when (process-live-p vdiff--process-buffer)
+           (kill-process vdiff--process-buffer))
+         (when (buffer-live-p vdiff--process-buffer)
+           (kill-buffer vdiff--process-buffer))
+         (setq vdiff--scroll-command-cnt 0))))
 
 (define-minor-mode vdiff-scroll-lock-mode
-  " "
+  "Lock scrolling between vdiff buffers. This minor mode will be
+enabled automatically if `vdiff-lock-scrolling' is non-nil."
   nil nil nil
-  (if vdiff-scroll-lock-mode
-      (progn
-        (unless vdiff-mode
-          (vdiff-mode 1))
-        (message "Scrolling locked")
-        (vdiff-with-both-buffers
-         (add-hook 'window-scroll-functions #'vdiff-scroll-other nil t)
-         (add-hook 'post-command-hook #'vdiff-sync-scroll nil t)))
-    (message "Scrolling unlocked")
-    (vdiff-with-both-buffers
-     (remove-hook 'after-save-hook #'vdiff-refresh t)
-     (remove-hook 'window-scroll-functions #'vdiff-scroll-other t))))
+  (cond (vdiff-scroll-lock-mode
+         (unless vdiff-mode
+           (vdiff-mode 1))
+         (vdiff--with-both-buffers
+          (add-hook 'window-scroll-functions #'vdiff-sync-scroll nil t)
+          (add-hook 'post-command-hook #'vdiff-mirror-commands nil t))
+         (message "Scrolling locked"))
+        (t
+         (vdiff--with-both-buffers
+          (remove-hook 'window-scroll-functions #'vdiff-sync-scroll t)
+          (remove-hook 'post-command-hook #'vdiff-mirror-commands t))
+         (message "Scrolling unlocked"))))
 
 (provide 'vdiff)
 ;;; vdiff.el ends here



reply via email to

[Prev in Thread] Current Thread [Next in Thread]