stgit.el: Forbid stgit-{delete,edit,mark,rename} on index and work tree
[stgit] / contrib / stgit.el
index 97a6d13..9bbc87d 100644 (file)
@@ -164,8 +164,8 @@ Returns nil if there was no output."
   "Returns non-nil if the index contains no changes from HEAD."
   (zerop (stgit-run-git-silent "diff-index" "--cached" "--quiet" "HEAD")))
 
-(defvar stgit-index-node nil)
-(defvar stgit-worktree-node nil)
+(defvar stgit-index-node)
+(defvar stgit-worktree-node)
 
 (defun stgit-refresh-index ()
   (when stgit-index-node
@@ -232,7 +232,7 @@ Returns nil if there was no output."
                           (with-temp-buffer
                             (stgit-run-silent "branch")
                             (buffer-substring (point-min) (1- (point-max))))
-                          'face 'bold)
+                          'face 'stgit-branch-name-face)
                          "\n")
                  (if stgit-show-worktree
                      "--"
@@ -256,6 +256,11 @@ Returns nil if there was no output."
   "The face used for StGit descriptions"
   :group 'stgit)
 
+(defface stgit-branch-name-face
+  '((t :inherit bold))
+  "The face used for the StGit branch name"
+  :group 'stgit)
+
 (defface stgit-top-patch-face
   '((((background dark)) (:weight bold :foreground "yellow"))
     (((background light)) (:weight bold :foreground "purple"))
@@ -434,14 +439,19 @@ Cf. `stgit-file-type-change-string'."
                          (list 'entry-type 'file
                                'file-data file))))
 
+(defun stgit-find-copies-harder-diff-arg ()
+  "Return the flag to use with `git-diff' depending on the
+`stgit-expand-find-copies-harder' flag."
+  (if stgit-expand-find-copies-harder
+      "--find-copies-harder"
+    "-C"))
+
 (defun stgit-insert-patch-files (patch)
   "Expand (show modification of) the patch PATCH after the line
 at point."
   (let* ((patchsym (stgit-patch-name patch))
          (end (progn (insert "#") (prog1 (point-marker) (forward-char -1))))
-         (args (list "-z" (if stgit-expand-find-copies-harder
-                              "--find-copies-harder"
-                            "-C")))
+         (args (list "-z" (stgit-find-copies-harder-diff-arg)))
          (ewoc (ewoc-create #'stgit-file-pp nil nil t)))
     (setf (stgit-patch-files-ewoc patch) ewoc)
     (with-temp-buffer
@@ -462,15 +472,21 @@ at point."
           (let ((file
                  (cond ((looking-at
                          "\\([CR]\\)\\([0-9]*\\)\0\\([^\0]*\\)\0\\([^\0]*\\)\0")
-                        (make-stgit-file
-                         :old-perm       old-perm
-                         :new-perm       new-perm
-                         :copy-or-rename t
-                         :cr-score       (string-to-number (match-string 2))
-                         :cr-from        (match-string 3)
-                         :cr-to          (match-string 4)
-                         :status         (stgit-file-status-code (match-string 1))
-                         :file           (match-string 3)))
+                        (let* ((patch-status (stgit-patch-status patch))
+                               (file-subexp  (if (eq patch-status 'unapplied)
+                                                 3
+                                               4))
+                               (file         (match-string file-subexp)))
+                          (make-stgit-file
+                           :old-perm       old-perm
+                           :new-perm       new-perm
+                           :copy-or-rename t
+                           :cr-score       (string-to-number (match-string 2))
+                           :cr-from        (match-string 3)
+                           :cr-to          (match-string 4)
+                           :status         (stgit-file-status-code
+                                            (match-string 1))
+                           :file           file)))
                        ((looking-at "\\([ABD-QS-Z]\\)\0\\([^\0]*\\)\0")
                         (make-stgit-file
                          :old-perm       old-perm
@@ -479,7 +495,8 @@ at point."
                          :cr-score       nil
                          :cr-from        nil
                          :cr-to          nil
-                         :status         (stgit-file-status-code (match-string 1))
+                         :status         (stgit-file-status-code
+                                          (match-string 1))
                          :file           (match-string 2))))))
             (ewoc-enter-last ewoc file))
           (goto-char (match-end 0))))
@@ -601,16 +618,17 @@ at point."
             ("\M-{" .     stgit-previous-patch)
             ("\M-}" .     stgit-next-patch)
             ("s" .        stgit-git-status)
-            ("g" .        stgit-reload)
+            ("g" .        stgit-reload-or-repair)
             ("r" .        stgit-refresh)
             ("\C-c\C-r" . stgit-rename)
             ("e" .        stgit-edit)
             ("M" .        stgit-move-patches)
             ("S" .        stgit-squash)
             ("N" .        stgit-new)
-            ("R" .        stgit-repair)
-            ("C" .        stgit-commit)
-            ("U" .        stgit-uncommit)
+            ("\C-c\C-c" . stgit-commit)
+            ("\C-c\C-u" . stgit-uncommit)
+            ("U" .        stgit-revert-file)
+            ("R" .        stgit-resolve-file)
             ("\r" .       stgit-select)
             ("o" .        stgit-find-file-other-window)
             ("i" .        stgit-file-toggle-index)
@@ -640,6 +658,8 @@ Commands:
   (set (make-local-variable 'stgit-marked-patches) nil)
   (set (make-local-variable 'stgit-expanded-patches) nil)
   (set (make-local-variable 'stgit-show-worktree) stgit-default-show-worktree)
+  (set (make-local-variable 'stgit-index-node) nil)
+  (set (make-local-variable 'stgit-worktree-node) nil)
   (set-variable 'truncate-lines 't)
   (add-hook 'after-save-hook 'stgit-update-saved-file)
   (run-hooks 'stgit-mode-hook))
@@ -669,10 +689,16 @@ Commands:
 (defun stgit-patch-at-point (&optional cause-error)
   (get-text-property (point) 'patch-data))
 
-(defun stgit-patch-name-at-point (&optional cause-error)
+(defun stgit-patch-name-at-point (&optional cause-error only-patches)
   "Return the patch name on the current line as a symbol.
-If CAUSE-ERROR is not nil, signal an error if none found."
+If CAUSE-ERROR is not nil, signal an error if none found.
+If ONLY-PATCHES is not nil, only allow real patches, and not
+index or work tree."
   (let ((patch (stgit-patch-at-point)))
+    (and patch
+         only-patches
+         (memq (stgit-patch-status patch) '(work index))
+         (setq patch nil))
     (cond (patch
            (stgit-patch-name patch))
           (cause-error
@@ -712,7 +738,12 @@ If that patch cannot be found, do nothing."
   "Mark the patch under point."
   (interactive)
   (let* ((node (ewoc-locate stgit-ewoc))
-         (patch (ewoc-data node)))
+         (patch (ewoc-data node))
+         (name (stgit-patch-name patch)))
+    (when (eq name :work)
+      (error "Cannot mark the work tree"))
+    (when (eq name :index)
+      (error "Cannot mark the index"))
     (stgit-add-mark (stgit-patch-name patch))
     (ewoc-invalidate stgit-ewoc node))
   (stgit-next-patch))
@@ -738,9 +769,10 @@ If that patch cannot be found, do nothing."
 
 (defun stgit-rename (name)
   "Rename the patch under point to NAME."
-  (interactive (list (read-string "Patch name: "
-                                  (symbol-name (stgit-patch-name-at-point t)))))
-  (let ((old-patchsym (stgit-patch-name-at-point t)))
+  (interactive (list
+                (read-string "Patch name: "
+                             (symbol-name (stgit-patch-name-at-point t t)))))
+  (let ((old-patchsym (stgit-patch-name-at-point t t)))
     (stgit-capture-output nil
       (stgit-run "rename" old-patchsym name))
     (let ((name-sym (intern name)))
@@ -753,6 +785,16 @@ If that patch cannot be found, do nothing."
       (stgit-reload)
       (stgit-goto-patch name-sym))))
 
+(defun stgit-reload-or-repair (repair)
+  "Update the contents of the StGit buffer (`stgit-reload').
+
+With a prefix argument, repair the StGit metadata if the branch
+was modified with git commands (`stgit-repair')."
+  (interactive "P")
+  (if repair
+      (stgit-repair)
+    (stgit-reload)))
+
 (defun stgit-repair ()
   "Run stg repair."
   (interactive)
@@ -785,6 +827,56 @@ Interactively, the prefix argument is used as COUNT."
   (stgit-capture-output nil (stgit-run "commit" "-n" count))
   (stgit-reload))
 
+(defun stgit-revert-file ()
+  "Revert the file at point, which must be in the index or the
+working tree."
+  (interactive)
+  (let* ((patched-file (or (stgit-patched-file-at-point)
+                           (error "No file on the current line")))
+         (patch-name   (stgit-patch-name-at-point))
+         (file-status  (stgit-file-status patched-file))
+         (rm-file      (cond ((stgit-file-copy-or-rename patched-file)
+                              (stgit-file-cr-to patched-file))
+                             ((eq file-status 'add)
+                              (stgit-file-file patched-file))))
+         (co-file      (cond ((eq file-status 'rename)
+                              (stgit-file-cr-from patched-file))
+                             ((not (memq file-status '(copy add)))
+                              (stgit-file-file patched-file)))))
+
+    (unless (memq patch-name '(:work :index))
+      (error "No index or working tree file on this line"))
+
+    (let ((nfiles (+ (if rm-file 1 0) (if co-file 1 0))))
+      (when (yes-or-no-p (format "Revert %d file%s? "
+                                 nfiles
+                                 (if (= nfiles 1) "" "s")))
+        (stgit-capture-output nil
+          (when rm-file
+            (stgit-run-git "rm" "-f" "-q" "--" rm-file))
+          (when co-file
+            (stgit-run-git "checkout" "HEAD" co-file)))
+        (stgit-reload)))))
+
+(defun stgit-resolve-file ()
+  "Resolve conflict in the file at point."
+  (interactive)
+  (let* ((patched-file (stgit-patched-file-at-point))
+         (patch        (stgit-patch-at-point))
+         (patch-name   (and patch (stgit-patch-name patch)))
+         (status       (and patched-file (stgit-file-status patched-file))))
+
+    (unless (memq patch-name '(:work :index))
+      (error "No index or working tree file on this line"))
+
+    (unless (eq status 'unmerged)
+      (error "No conflict to resolve at the current line"))
+
+    (stgit-capture-output nil
+      (stgit-move-change-to-index (stgit-file-file patched-file)))
+
+    (stgit-reload)))
+
 (defun stgit-uncommit (count)
   "Run stg uncommit on COUNT commits.
 Interactively, the prefix argument is used as COUNT."
@@ -852,9 +944,7 @@ If PATCHSYM is a keyword, returns PATCHSYM unmodified."
               (patch-name (stgit-patch-name-at-point))
               (patch-id (stgit-id patch-name))
               (args (append (and (stgit-file-cr-from patched-file)
-                                 (if stgit-expand-find-copies-harder
-                                     '("--find-copies-harder")
-                                   '("-C")))
+                                 (list (stgit-find-copies-harder-diff-arg)))
                             (cond ((eq patch-id :index)
                                    '("--cached"))
                                   ((eq patch-id :work)
@@ -868,8 +958,15 @@ If PATCHSYM is a keyword, returns PATCHSYM unmodified."
                                 (list (stgit-file-file patched-file))))))
          (apply 'stgit-run-git "diff" args)))
       ('patch
-       (stgit-run "show" "-O" "--patch-with-stat" "-O" "-M"
-                  (stgit-patch-name-at-point)))
+       (let* ((patch-name (stgit-patch-name-at-point))
+              (patch-id (stgit-id patch-name)))
+         (if (or (eq patch-id :index) (eq patch-id :work))
+             (apply 'stgit-run-git "diff"
+                    (stgit-find-copies-harder-diff-arg)
+                    (and (eq patch-id :index)
+                         '("--cached")))
+           (stgit-run "show" "-O" "--patch-with-stat" "-O" "-M"
+                      (stgit-patch-name-at-point)))))
       (t
        (error "No patch or file at point")))
     (with-current-buffer standard-output
@@ -878,9 +975,10 @@ If PATCHSYM is a keyword, returns PATCHSYM unmodified."
 
 (defun stgit-move-change-to-index (file)
   "Copies the workspace state of FILE to index, using git add or git rm"
-  (let ((op (if (file-exists-p file) "add" "rm")))
+  (let ((op (if (or (file-exists-p file) (file-symlink-p file))
+                '("add") '("rm" "-q"))))
     (stgit-capture-output "*git output*"
-      (stgit-run-git op "--" file))))
+      (apply 'stgit-run-git (append op '("--") (list file))))))
 
 (defun stgit-remove-change-from-index (file)
   "Unstages the change in FILE from the index"
@@ -893,6 +991,8 @@ If PATCHSYM is a keyword, returns PATCHSYM unmodified."
   (let ((patched-file (stgit-patched-file-at-point)))
     (unless patched-file
       (error "No file on the current line"))
+    (when (eq (stgit-file-status patched-file) 'unmerged)
+      (error (substitute-command-keys "Use \\[stgit-resolve-file] to move an unmerged file to the index")))
     (let ((patch-name (stgit-patch-name-at-point)))
       (cond ((eq patch-name :work)
              (stgit-move-change-to-index (stgit-file-file patched-file)))
@@ -906,7 +1006,7 @@ If PATCHSYM is a keyword, returns PATCHSYM unmodified."
 (defun stgit-edit ()
   "Edit the patch on the current line."
   (interactive)
-  (let ((patchsym (stgit-patch-name-at-point t))
+  (let ((patchsym (stgit-patch-name-at-point t t))
         (edit-buf (get-buffer-create "*StGit edit*"))
         (dir default-directory))
     (log-edit 'stgit-confirm-edit t nil edit-buf)
@@ -976,6 +1076,11 @@ the work tree and index."
                      current-prefix-arg))
   (unless patchsyms
     (error "No patches to delete"))
+  (when (memq :index patchsyms)
+    (error "Cannot delete the index"))
+  (when (memq :work  patchsyms)
+    (error "Cannot delete the work tree"))
+
   (let ((npatches (length patchsyms)))
     (when (yes-or-no-p (format "Really delete %d patch%s%s? "
                               npatches
@@ -1119,6 +1224,8 @@ With prefix argument, run it with the --hard flag."
 
 (defun stgit-refresh (&optional arg)
   "Run stg refresh.
+If the index contains any changes, only refresh from index.
+
 With prefix argument, refresh the marked patch or the patch under point."
   (interactive "P")
   (let ((patchargs (if arg
@@ -1130,6 +1237,8 @@ With prefix argument, refresh the marked patch or the patch under point."
                                (t
                                 (cons "-p" patches))))
                      nil)))
+    (unless (stgit-index-empty-p)
+      (setq patchargs (cons "--index" patchargs)))
     (stgit-capture-output nil
       (apply 'stgit-run "refresh" patchargs))
     (stgit-refresh-git-status))