X-Git-Url: https://git.distorted.org.uk/~mdw/stgit/blobdiff_plain/3164eec6216006fa61f0ad0c12d57d6a90da85c3..a9089e68c3ff8943103a31f044c00cdab51c4674:/contrib/stgit.el diff --git a/contrib/stgit.el b/contrib/stgit.el index 0c39286..0d99467 100644 --- a/contrib/stgit.el +++ b/contrib/stgit.el @@ -42,8 +42,8 @@ directory DIR or `default-directory'" (with-current-buffer git-status-buffer (git-refresh-status)))))) -(defun switch-to-stgit-buffer (dir) - "Switch to a (possibly new) buffer displaying StGit patches for DIR." +(defun stgit-find-buffer (dir) + "Return the buffer displaying StGit patches for DIR, or nil if none." (setq dir (file-name-as-directory dir)) (let ((buffers (buffer-list))) (while (and buffers @@ -51,32 +51,40 @@ directory DIR or `default-directory'" (and (eq major-mode 'stgit-mode) (string= default-directory dir))))) (setq buffers (cdr buffers))) - (switch-to-buffer (if buffers - (car buffers) - (create-stgit-buffer dir))))) + (and buffers (car buffers)))) + +(defun switch-to-stgit-buffer (dir) + "Switch to a (possibly new) buffer displaying StGit patches for DIR." + (setq dir (file-name-as-directory dir)) + (let ((buffer (stgit-find-buffer dir))) + (switch-to-buffer (or buffer + (create-stgit-buffer dir))))) + (defstruct (stgit-patch) status name desc empty files-ewoc) (defun stgit-patch-pp (patch) - (let ((status (stgit-patch-status patch)) - (start (point)) - (name (stgit-patch-name patch))) + (let* ((status (stgit-patch-status patch)) + (start (point)) + (name (stgit-patch-name patch)) + (face (cdr (assq status stgit-patch-status-face-alist)))) (insert (case status ('applied "+") ('top ">") ('unapplied "-") - (t "·")) + (t " ")) (if (memq name stgit-marked-patches) - "*" " ") - (propertize (format "%-30s" (symbol-name name)) - 'face (case status - ('applied 'stgit-applied-patch-face) - ('top 'stgit-top-patch-face) - ('unapplied 'stgit-unapplied-patch-face))) - " " - (if (stgit-patch-empty patch) "(empty) " "") - (propertize (or (stgit-patch-desc patch) "") - 'face 'stgit-description-face)) + "*" " ")) + (if (memq status '(index work)) + (insert (propertize (if (eq status 'index) "Index" "Work tree") + 'face face)) + (insert (format "%-30s" + (propertize (symbol-name name) 'face face)) + " " + (if (stgit-patch-empty patch) "(empty) " "") + (propertize (or (stgit-patch-desc patch) "") + 'face 'stgit-description-face))) + (insert "\n") (put-text-property start (point) 'entry-type 'patch) (when (memq name stgit-expanded-patches) (stgit-insert-patch-files patch)) @@ -91,7 +99,7 @@ Argument DIR is the repository path." (setq default-directory dir) (stgit-mode) (set (make-local-variable 'stgit-ewoc) - (ewoc-create #'stgit-patch-pp "Branch:\n" "--")) + (ewoc-create #'stgit-patch-pp "Branch:\n\n" "--\n" t)) (setq buffer-read-only t)) buf)) @@ -149,15 +157,51 @@ Returns nil if there was no output." (setq args (stgit-make-run-args args)) (apply 'call-process "git" nil standard-output nil args)) +(defun stgit-index-empty-p () + "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) +(defvar stgit-worktree-node) + +(defun stgit-refresh-index () + (when stgit-index-node + (ewoc-invalidate (car stgit-index-node) (cdr stgit-index-node)))) + +(defun stgit-refresh-worktree () + (when stgit-worktree-node + (ewoc-invalidate (car stgit-worktree-node) (cdr stgit-worktree-node)))) + +(defun stgit-run-series-insert-index (ewoc) + (setq index-node (cons ewoc (ewoc-enter-last ewoc + (make-stgit-patch + :status 'index + :name :index + :desc nil + :empty nil))) + worktree-node (cons ewoc (ewoc-enter-last ewoc + (make-stgit-patch + :status 'work + :name :work + :desc nil + :empty nil))))) + (defun stgit-run-series (ewoc) - (let ((first-line t)) + (setq stgit-index-node nil + stgit-worktree-node nil) + (let ((inserted-index (not stgit-show-worktree)) + index-node + worktree-node + all-patchsyms) (with-temp-buffer (let ((exit-status (stgit-run-silent "series" "--description" "--empty"))) (goto-char (point-min)) (if (not (zerop exit-status)) (cond ((looking-at "stg series: \\(.*\\)") + (setq inserted-index t) (ewoc-set-hf ewoc (car (ewoc-get-hf ewoc)) - "-- not initialized (run M-x stgit-init)")) + (substitute-command-keys + "-- not initialized; run \\[stgit-init]"))) ((looking-at ".*") (error "Error running stg: %s" (match-string 0)))) @@ -168,23 +212,38 @@ Returns nil if there was no output." (let* ((state-str (match-string 2)) (state (cond ((string= state-str ">") 'top) ((string= state-str "+") 'applied) - ((string= state-str "-") 'unapplied)))) + ((string= state-str "-") 'unapplied))) + (name (intern (match-string 4))) + (desc (match-string 5)) + (empty (string= (match-string 1) "0"))) + (unless inserted-index + (when (or (eq stgit-show-worktree-mode 'top) + (and (eq stgit-show-worktree-mode 'center) + (eq state 'unapplied))) + (setq inserted-index t) + (stgit-run-series-insert-index ewoc))) + (setq all-patchsyms (cons name all-patchsyms)) (ewoc-enter-last ewoc (make-stgit-patch :status state - :name (intern (match-string 4)) - :desc (match-string 5) - :empty (string= (match-string 1) "0")))) - (setq first-line nil) - (forward-line 1))))))) - + :name name + :desc desc + :empty empty))) + (forward-line 1)))) + (unless inserted-index + (stgit-run-series-insert-index ewoc))) + (setq stgit-index-node index-node + stgit-worktree-node worktree-node + stgit-marked-patches (intersection stgit-marked-patches + all-patchsyms)))) (defun stgit-reload () "Update the contents of the StGit buffer." (interactive) (let ((inhibit-read-only t) (curline (line-number-at-pos)) - (curpatch (stgit-patch-name-at-point))) + (curpatch (stgit-patch-name-at-point)) + (curfile (stgit-patched-file-at-point))) (ewoc-filter stgit-ewoc #'(lambda (x) nil)) (ewoc-set-hf stgit-ewoc (concat "Branch: " @@ -192,12 +251,17 @@ Returns nil if there was no output." (with-temp-buffer (stgit-run-silent "branch") (buffer-substring (point-min) (1- (point-max)))) - 'face 'bold) - "\n") - "--") + 'face 'stgit-branch-name-face) + "\n\n") + (if stgit-show-worktree + "--" + (propertize + (substitute-command-keys "--\n\"\\[stgit-toggle-worktree]\"\ + shows the working tree\n") + 'face 'stgit-description-face))) (stgit-run-series stgit-ewoc) (if curpatch - (stgit-goto-patch curpatch) + (stgit-goto-patch curpatch (and curfile (stgit-file-file curfile))) (goto-line curline))) (stgit-refresh-git-status)) @@ -211,6 +275,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")) @@ -250,12 +319,24 @@ Returns nil if there was no output." "StGit mode face used for unknown file status" :group 'stgit) +(defface stgit-ignored-file-face + '((((class color) (background light)) (:foreground "grey60")) + (((class color) (background dark)) (:foreground "grey40"))) + "StGit mode face used for ignored files") + (defface stgit-file-permission-face '((((class color) (background light)) (:foreground "green" :bold t)) (((class color) (background dark)) (:foreground "green" :bold t))) "StGit mode face used for permission changes." :group 'stgit) +(defface stgit-index-work-tree-title-face + '((((supports :slant italic)) :slant italic) + (t :inherit bold)) + "StGit mode face used for the \"Index\" and \"Work tree\" titles" + :group 'stgit) + + (defcustom stgit-expand-find-copies-harder nil "Try harder to find copied files when listing patches. @@ -276,9 +357,18 @@ flag, which reduces performance." (rename "Renamed" stgit-modified-file-face) (mode-change "Mode change" stgit-modified-file-face) (unmerged "Unmerged" stgit-unmerged-file-face) - (unknown "Unknown" stgit-unknown-file-face))) + (unknown "Unknown" stgit-unknown-file-face) + (ignore "Ignored" stgit-ignored-file-face))) "Alist of code symbols to description strings") +(defconst stgit-patch-status-face-alist + '((applied . stgit-applied-patch-face) + (top . stgit-top-patch-face) + (unapplied . stgit-unapplied-patch-face) + (index . stgit-index-work-tree-title-face) + (work . stgit-index-work-tree-title-face)) + "Alist of face to use for a given patch status") + (defun stgit-file-status-code-as-string (file) "Return stgit status code for FILE as a string" (let* ((code (assq (stgit-file-status file) @@ -297,6 +387,7 @@ flag, which reduces performance." (let ((code (assoc str '(("A" . add) ("C" . copy) ("D" . delete) + ("I" . ignore) ("M" . modify) ("R" . rename) ("T" . mode-change) @@ -389,24 +480,52 @@ 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-ls-files (args file-flag) + (let ((start (point))) + (apply 'stgit-run-git + (append '("ls-files" "--exclude-standard" "-z") args)) + (goto-char start) + (while (looking-at "\\([^\0]*\\)\0") + (let ((name-len (- (match-end 0) (match-beginning 0)))) + (insert ":0 0 0000000000000000000000000000000000000000 0000000000000000000000000000000000000000 " file-flag "\0") + (forward-char name-len))))) + (defun stgit-insert-patch-files (patch) - "Expand (show modification of) the patch with name PATCHSYM (a -symbol) after the line at point. -`stgit-expand-find-copies-harder' controls how hard to try to -find copied files." - (insert "\n") + "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 "-r" "-z" (if stgit-expand-find-copies-harder - "--find-copies-harder" - "-C"))) - (ewoc (ewoc-create #'stgit-file-pp nil nil t))) + (end (point-marker)) + (args (list "-z" (stgit-find-copies-harder-diff-arg))) + (ewoc (ewoc-create #'stgit-file-pp nil nil t))) + (set-marker-insertion-type end t) (setf (stgit-patch-files-ewoc patch) ewoc) (with-temp-buffer - (apply 'stgit-run-git "diff-tree" - (append args (list (stgit-id patchsym)))) + (apply 'stgit-run-git + (cond ((eq patchsym :work) + `("diff-files" ,@args)) + ((eq patchsym :index) + `("diff-index" ,@args "--cached" "HEAD")) + (t + `("diff-tree" ,@args "-r" ,(stgit-id patchsym))))) + + (when (and (eq patchsym :work)) + (when stgit-show-ignored + (stgit-insert-ls-files '("--ignored" "--others") "I")) + (when stgit-show-unknown + (stgit-insert-ls-files '("--others") "X")) + (sort-regexp-fields nil ":[^\0]*\0\\([^\0]*\\)\0" "\\1" + (point-min) (point-max))) + (goto-char (point-min)) - (forward-char 41) + (unless (or (eobp) (memq patchsym '(:work :index))) + (forward-char 41)) (while (looking-at ":\\([0-7]+\\) \\([0-7]+\\) [0-9A-Fa-f]\\{40\\} [0-9A-Fa-f]\\{40\\} ") (let ((old-perm (string-to-number (match-string 1) 8)) (new-perm (string-to-number (match-string 2) 8))) @@ -414,15 +533,21 @@ find copied files." (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 @@ -431,15 +556,18 @@ find copied files." :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)))) (unless (ewoc-nth ewoc 0) - (ewoc-set-hf ewoc "" (propertize " \n" - 'face 'stgit-description-face)))) - (goto-char end) - (delete-char -2))) + (ewoc-set-hf ewoc "" + (concat " " + (propertize "" + 'face 'stgit-description-face) + "\n")))) + (goto-char end))) (defun stgit-select-file () (let ((filename (expand-file-name @@ -457,7 +585,10 @@ find copied files." (move-to-column (stgit-goal-column))) (defun stgit-select () - "Expand or collapse the current entry" + "With point on a patch, toggle showing files in the patch. + +With point on a file, open the associated file. Opens the target +file for (applied) copies and renames." (interactive) (case (get-text-property (point) 'entry-type) ('patch @@ -531,46 +662,55 @@ find copied files." "Keymap for StGit major mode.") (unless stgit-mode-map - (setq stgit-mode-map (make-keymap)) - (suppress-keymap stgit-mode-map) - (mapc (lambda (arg) (define-key stgit-mode-map (car arg) (cdr arg))) - '((" " . stgit-mark) - ("m" . stgit-mark) - ("\d" . stgit-unmark-up) - ("u" . stgit-unmark-down) - ("?" . stgit-help) - ("h" . stgit-help) - ("\C-p" . stgit-previous-line) - ("\C-n" . stgit-next-line) - ([up] . stgit-previous-line) - ([down] . stgit-next-line) - ("p" . stgit-previous-patch) - ("n" . stgit-next-patch) - ("\M-{" . stgit-previous-patch) - ("\M-}" . stgit-next-patch) - ("s" . stgit-git-status) - ("g" . stgit-reload) - ("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) - ("\r" . stgit-select) - ("o" . stgit-find-file-other-window) - (">" . stgit-push-next) - ("<" . stgit-pop-next) - ("P" . stgit-push-or-pop) - ("G" . stgit-goto) - ("=" . stgit-show) - ("D" . stgit-delete) - ([(control ?/)] . stgit-undo) - ("\C-_" . stgit-undo) - ("B" . stgit-branch) - ("q" . stgit-quit)))) + (let ((toggle-map (make-keymap))) + (suppress-keymap toggle-map) + (mapc (lambda (arg) (define-key toggle-map (car arg) (cdr arg))) + '(("t" . stgit-toggle-worktree) + ("i" . stgit-toggle-ignored) + ("u" . stgit-toggle-unknown))) + (setq stgit-mode-map (make-keymap)) + (suppress-keymap stgit-mode-map) + (mapc (lambda (arg) (define-key stgit-mode-map (car arg) (cdr arg))) + `((" " . stgit-mark) + ("m" . stgit-mark) + ("\d" . stgit-unmark-up) + ("u" . stgit-unmark-down) + ("?" . stgit-help) + ("h" . stgit-help) + ("\C-p" . stgit-previous-line) + ("\C-n" . stgit-next-line) + ([up] . stgit-previous-line) + ([down] . stgit-next-line) + ("p" . stgit-previous-patch) + ("n" . stgit-next-patch) + ("\M-{" . stgit-previous-patch) + ("\M-}" . stgit-next-patch) + ("s" . stgit-git-status) + ("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) + ("\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) + (">" . stgit-push-next) + ("<" . stgit-pop-next) + ("P" . stgit-push-or-pop) + ("G" . stgit-goto) + ("=" . stgit-show) + ("D" . stgit-delete) + ([(control ?/)] . stgit-undo) + ("\C-_" . stgit-undo) + ("B" . stgit-branch) + ("t" . ,toggle-map) + ("q" . stgit-quit))))) (defun stgit-mode () "Major mode for interacting with StGit. @@ -584,10 +724,24 @@ Commands: (use-local-map stgit-mode-map) (set (make-local-variable 'list-buffers-directory) default-directory) (set (make-local-variable 'stgit-marked-patches) nil) - (set (make-local-variable 'stgit-expanded-patches) nil) + (set (make-local-variable 'stgit-expanded-patches) (list :work :index)) + (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)) +(defun stgit-update-saved-file () + (let* ((file (expand-file-name buffer-file-name)) + (dir (file-name-directory file)) + (gitdir (condition-case nil (git-get-top-dir dir) + (error nil))) + (buffer (and gitdir (stgit-find-buffer gitdir)))) + (when buffer + (with-current-buffer buffer + (stgit-refresh-worktree))))) + (defun stgit-add-mark (patchsym) "Mark the patch PATCHSYM." (setq stgit-marked-patches (cons patchsym stgit-marked-patches))) @@ -603,10 +757,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 @@ -624,13 +784,26 @@ If CAUSE-ERROR is not nil, signal an error if none found." (list patch) '())))) -(defun stgit-goto-patch (patchsym) +(defun stgit-goto-patch (patchsym &optional file) "Move point to the line containing patch PATCHSYM. -If that patch cannot be found, do nothing." +If that patch cannot be found, do nothing. + +If the patch was found and FILE is not nil, instead move to that +file's line. If FILE cannot be found, stay on the line of +PATCHSYM." (let ((node (ewoc-nth stgit-ewoc 0))) (while (and node (not (eq (stgit-patch-name (ewoc-data node)) patchsym))) (setq node (ewoc-next stgit-ewoc node))) + (when (and node file) + (let* ((file-ewoc (stgit-patch-files-ewoc (ewoc-data node))) + (file-node (ewoc-nth file-ewoc 0))) + (while (and file-node (not (equal (stgit-file-file (ewoc-data file-node)) file))) + (setq file-node (ewoc-next file-ewoc file-node))) + (when file-node + (ewoc-goto-node file-ewoc file-node) + (move-to-column (stgit-goal-column)) + (setq node nil)))) (when node (ewoc-goto-node stgit-ewoc node) (move-to-column goal-column)))) @@ -646,7 +819,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)) @@ -672,9 +850,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))) @@ -687,6 +866,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) @@ -719,6 +908,62 @@ 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")) + + (when (eq file-status 'ignore) + (error "Cannot revert ignored files")) + + (when (eq file-status 'unknown) + (error "Cannot revert unknown files")) + + (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." @@ -786,10 +1031,13 @@ 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 (concat patch-id "^") patch-id) + (list (stgit-find-copies-harder-diff-arg))) + (cond ((eq patch-id :index) + '("--cached")) + ((eq patch-id :work) + nil) + (t + (list (concat patch-id "^") patch-id))) '("--") (if (stgit-file-copy-or-rename patched-file) (list (stgit-file-cr-from patched-file) @@ -797,18 +1045,81 @@ 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 (goto-char (point-min)) (diff-mode)))) +(defun stgit-move-change-to-index (file) + "Copies the workspace state of FILE to index, using git add or git rm" + (let ((op (if (or (file-exists-p file) (file-symlink-p file)) + '("add") '("rm" "-q")))) + (stgit-capture-output "*git output*" + (apply 'stgit-run-git (append op '("--") (list file)))))) + +(defun stgit-remove-change-from-index (file) + "Unstages the change in FILE from the index" + (stgit-capture-output "*git output*" + (stgit-run-git "reset" "-q" "--" file))) + +(defun stgit-file-toggle-index () + "Move modified file in or out of the index. + +Leaves the point where it is, but moves the mark to where the +file ended up. You can then jump to the file with \ +\\[exchange-point-and-mark]." + (interactive) + (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"))) + (when (eq (stgit-file-status patched-file) 'ignore) + (error "You cannot add ignored files to the index")) + (let* ((patch (stgit-patch-at-point)) + (patch-name (stgit-patch-name patch)) + (old-point (point)) + next-file) + + ;; find the next file in the patch, or the previous one if this + ;; was the last file + (and (zerop (forward-line 1)) + (let ((f (stgit-patched-file-at-point))) + (and f (setq next-file (stgit-file-file f))))) + (goto-char old-point) + (unless next-file + (and (zerop (forward-line -1)) + (let ((f (stgit-patched-file-at-point))) + (and f (setq next-file (stgit-file-file f))))) + (goto-char old-point)) + + (cond ((eq patch-name :work) + (stgit-move-change-to-index (stgit-file-file patched-file))) + ((eq patch-name :index) + (stgit-remove-change-from-index (stgit-file-file patched-file))) + (t + (error "Can only move files in the working tree to index"))) + (stgit-refresh-worktree) + (stgit-refresh-index) + (stgit-goto-patch (if (eq patch-name :index) :work :index) + (stgit-file-file patched-file)) + (push-mark nil t t) + (stgit-goto-patch patch-name next-file)))) + (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) @@ -878,6 +1189,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 @@ -1021,6 +1337,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 @@ -1032,9 +1350,83 @@ 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)) (stgit-reload)) +(defcustom stgit-show-worktree-mode 'center + "This variable controls where the \"Index\" and \"Work tree\" +will be shown on in the buffer. + +It can be set to 'top (above all patches), 'center (show between +applied and unapplied patches), and 'bottom (below all patches). + +See also `stgit-show-worktree'." + :type '(radio (const :tag "above all patches (top)" top) + (const :tag "between applied and unapplied patches (center)" + center) + (const :tag "below all patches (bottom)" bottom)) + :group 'stgit) + +(defcustom stgit-default-show-worktree + nil + "Set to non-nil to by default show the working tree in a new stgit buffer. + +This value is used as the default value for `stgit-show-worktree'." + :type 'boolean + :group 'stgit) + +(defvar stgit-show-worktree nil + "If nil, inhibit showing work tree and index in the stgit buffer. + +See also `stgit-show-worktree-mode'.") + +(defvar stgit-show-ignored nil + "If nil, inhibit showing files ignored by git.") + +(defvar stgit-show-unknown nil + "If nil, inhibit showing files not registered with git.") + +(defun stgit-toggle-worktree (&optional arg) + "Toggle the visibility of the work tree. +With arg, show the work tree if arg is positive. + +Its initial setting is controlled by `stgit-default-show-worktree'. + +`stgit-show-worktree-mode' controls where on screen the index and +work tree will show up." + (interactive) + (setq stgit-show-worktree + (if (numberp arg) + (> arg 0) + (not stgit-show-worktree))) + (stgit-reload)) + +(defun stgit-toggle-ignored (&optional arg) + "Toggle the visibility of files ignored by git in the work +tree. With ARG, show these files if ARG is positive. + +Use \\[stgit-toggle-worktree] to show the work tree." + (interactive) + (setq stgit-show-ignored + (if (numberp arg) + (> arg 0) + (not stgit-show-ignored))) + (stgit-reload)) + +(defun stgit-toggle-unknown (&optional arg) + "Toggle the visibility of files not registered with git in the +work tree. With ARG, show these files if ARG is positive. + +Use \\[stgit-toggle-worktree] to show the work tree." + (interactive) + (setq stgit-show-unknown + (if (numberp arg) + (> arg 0) + (not stgit-show-unknown))) + (stgit-reload)) + (provide 'stgit)