(require 'git nil t)
(require 'cl)
(require 'ewoc)
+(require 'easymenu)
(defun stgit (dir)
"Manage StGit patches for the tree in DIR.
(switch-to-stgit-buffer (git-get-top-dir dir))
(stgit-reload))
+(defun stgit-assert-mode ()
+ "Signal an error if not in an StGit buffer."
+ (assert (derived-mode-p 'stgit-mode) nil "Not an StGit buffer"))
+
(unless (fboundp 'git-get-top-dir)
(defun git-get-top-dir (dir)
"Retrieve the top-level directory of a git tree."
"Returns non-nil if the index contains no changes from HEAD."
(zerop (stgit-run-git-silent "diff-index" "--cached" "--quiet" "HEAD")))
+(defun stgit-work-tree-empty-p ()
+ "Returns non-nil if the work tree contains no changes from index."
+ (zerop (stgit-run-git-silent "diff-files" "--quiet")))
+
(defvar stgit-index-node)
(defvar stgit-worktree-node)
worktree-node
all-patchsyms)
(with-temp-buffer
- (let ((exit-status (stgit-run-silent "series" "--description" "--empty")))
+ (let* ((standard-output (current-buffer))
+ (exit-status (stgit-run-silent "series"
+ "--description" "--empty")))
(goto-char (point-min))
(if (not (zerop exit-status))
(cond ((looking-at "stg series: \\(.*\\)")
(defun stgit-reload ()
"Update the contents of the StGit buffer."
(interactive)
+ (stgit-assert-mode)
(let ((inhibit-read-only t)
(curline (line-number-at-pos))
(curpatch (stgit-patch-name-at-point))
(ewoc-set-hf stgit-ewoc
(concat "Branch: "
(propertize
- (with-temp-buffer
- (stgit-run-silent "branch")
- (buffer-substring (point-min) (1- (point-max))))
+ (substring (with-output-to-string
+ (stgit-run-silent "branch"))
+ 0 -1)
'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)))
+ 'face 'stgit-description-face)))
(stgit-run-series stgit-ewoc)
(if curpatch
(stgit-goto-patch curpatch (and curfile (stgit-file-file curfile)))
old-perm new-perm copy-or-rename cr-score cr-from cr-to status file)
(defun stgit-describe-copy-or-rename (file)
- (let (from to common-head common-tail
- (arrow (concat " "
- (propertize "->" 'face 'stgit-description-face)
- " ")))
+ (let ((arrow (concat " " (propertize "->" 'face 'stgit-description-face) " "))
+ from to common-head common-tail)
(when stgit-abbreviate-copies-and-renames
(setq from (split-string (stgit-file-cr-from file) "/")
(set-marker-insertion-type end t)
(setf (stgit-patch-files-ewoc patch) ewoc)
(with-temp-buffer
- (apply 'stgit-run-git
- (cond ((eq patchsym :work)
- `("diff-files" "-0" ,@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)))
+ (let ((standard-output (current-buffer)))
+ (apply 'stgit-run-git
+ (cond ((eq patchsym :work)
+ `("diff-files" "-0" ,@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))
- (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)))
- (goto-char (match-end 0))
- (let ((file
- (cond ((looking-at
- "\\([CR]\\)\\([0-9]*\\)\0\\([^\0]*\\)\0\\([^\0]*\\)\0")
- (let* ((patch-status (stgit-patch-status patch))
- (file-subexp (if (eq patch-status 'unapplied)
- 3
- 4))
- (file (match-string file-subexp)))
+ (goto-char (point-min))
+ (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)))
+ (goto-char (match-end 0))
+ (let ((file
+ (cond ((looking-at
+ "\\([CR]\\)\\([0-9]*\\)\0\\([^\0]*\\)\0\\([^\0]*\\)\0")
+ (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
: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)
+ :copy-or-rename nil
+ :cr-score nil
+ :cr-from nil
+ :cr-to nil
: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
- :new-perm new-perm
- :copy-or-rename nil
- :cr-score nil
- :cr-from nil
- :cr-to nil
- :status (stgit-file-status-code
- (match-string 1))
- :file (match-string 2))))))
- (goto-char (match-end 0))
- (ewoc-enter-last ewoc file))))
-
- (unless (ewoc-nth ewoc 0)
- (ewoc-set-hf ewoc ""
- (concat " "
- (propertize "<no files>"
- 'face 'stgit-description-face)
- "\n"))))
+ :file (match-string 2))))))
+ (goto-char (match-end 0))
+ (ewoc-enter-last ewoc file))))
+
+ (unless (ewoc-nth ewoc 0)
+ (ewoc-set-hf ewoc ""
+ (concat " "
+ (propertize "<no files>"
+ 'face 'stgit-description-face)
+ "\n")))))
(goto-char end)))
(defun stgit-find-file (&optional other-window)
(when (eq (stgit-file-status file) 'unmerged)
(smerge-mode 1))))
+(defun stgit-expand (&optional patches collapse)
+ "Show the contents of marked patches, or the patch at point.
+
+See also `stgit-collapse'.
+
+Non-interactively, operate on PATCHES, and collapse instead of
+expand if COLLAPSE is not nil."
+ (interactive (list (stgit-patches-marked-or-at-point t)))
+ (stgit-assert-mode)
+ (let ((patches-diff (funcall (if collapse #'intersection #'set-difference)
+ patches stgit-expanded-patches)))
+ (setq stgit-expanded-patches
+ (if collapse
+ (set-difference stgit-expanded-patches patches-diff)
+ (append stgit-expanded-patches patches-diff)))
+ (ewoc-map #'(lambda (patch)
+ (memq (stgit-patch-name patch) patches-diff))
+ stgit-ewoc))
+ (move-to-column (stgit-goal-column)))
+
+(defun stgit-collapse (&optional patches)
+ "Hide the contents of marked patches, or the patch at point.
+
+See also `stgit-expand'."
+ (interactive (list (stgit-patches-marked-or-at-point t)))
+ (stgit-assert-mode)
+ (stgit-expand patches t))
+
(defun stgit-select-patch ()
(let ((patchname (stgit-patch-name-at-point)))
- (if (memq patchname stgit-expanded-patches)
- (setq stgit-expanded-patches (delq patchname stgit-expanded-patches))
- (setq stgit-expanded-patches (cons patchname stgit-expanded-patches)))
- (ewoc-invalidate stgit-ewoc (ewoc-locate stgit-ewoc)))
- (move-to-column (stgit-goal-column)))
+ (stgit-expand (list patchname)
+ (memq patchname stgit-expanded-patches))))
(defun stgit-select ()
"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)
+ (stgit-assert-mode)
(case (get-text-property (point) 'entry-type)
('patch
(stgit-select-patch))
(defun stgit-find-file-other-window ()
"Open file at point in other window"
(interactive)
+ (stgit-assert-mode)
(stgit-find-file t))
(defun stgit-find-file-merge ()
"Open file at point and merge it using `smerge-ediff'."
(interactive)
+ (stgit-assert-mode)
(stgit-find-file t)
(smerge-ediff))
(defun stgit-quit ()
"Hide the stgit buffer."
(interactive)
+ (stgit-assert-mode)
(bury-buffer))
(defun stgit-git-status ()
"Show status using `git-status'."
(interactive)
+ (stgit-assert-mode)
(unless (fboundp 'git-status)
(error "The stgit-git-status command requires git-status"))
(let ((dir default-directory))
(defun stgit-next-line (&optional arg)
"Move cursor vertically down ARG lines"
(interactive "p")
+ (stgit-assert-mode)
(next-line arg)
(move-to-column (stgit-goal-column)))
(defun stgit-previous-line (&optional arg)
"Move cursor vertically up ARG lines"
(interactive "p")
+ (stgit-assert-mode)
(previous-line arg)
(move-to-column (stgit-goal-column)))
(defun stgit-next-patch (&optional arg)
"Move cursor down ARG patches."
(interactive "p")
+ (stgit-assert-mode)
(ewoc-goto-next stgit-ewoc (or arg 1))
(move-to-column goal-column))
(defun stgit-previous-patch (&optional arg)
"Move cursor up ARG patches."
(interactive "p")
+ (stgit-assert-mode)
(ewoc-goto-prev stgit-ewoc (or arg 1))
(move-to-column goal-column))
"Keymap for StGit major mode.")
(unless stgit-mode-map
- (let ((diff-map (make-keymap))
- (toggle-map (make-keymap)))
+ (let ((diff-map (make-sparse-keymap))
+ (toggle-map (make-sparse-keymap)))
(suppress-keymap diff-map)
(mapc (lambda (arg) (define-key diff-map (car arg) (cdr arg)))
'(("b" . stgit-diff-base)
(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)
+ `((" " . stgit-mark-down)
+ ("m" . stgit-mark-down)
("\d" . stgit-unmark-up)
("u" . stgit-unmark-down)
("?" . stgit-help)
("M" . stgit-move-patches)
("S" . stgit-squash)
("N" . stgit-new)
+ ("c" . stgit-new-and-refresh)
("\C-c\C-c" . stgit-commit)
("\C-c\C-u" . stgit-uncommit)
- ("U" . stgit-revert-file)
+ ("U" . stgit-revert)
("R" . stgit-resolve-file)
("\r" . stgit-select)
+ ("+" . stgit-expand)
+ ("-" . stgit-collapse)
("o" . stgit-find-file-other-window)
- ("i" . stgit-file-toggle-index)
+ ("i" . stgit-toggle-index)
(">" . stgit-push-next)
("<" . stgit-pop-next)
("P" . stgit-push-or-pop)
("\C-c\C-b" . stgit-rebase)
("t" . ,toggle-map)
("d" . ,diff-map)
- ("q" . stgit-quit)))))
+ ("q" . stgit-quit))))
+
+ (let ((at-unmerged-file '(let ((file (stgit-patched-file-at-point)))
+ (and file (eq (stgit-file-status file)
+ 'unmerged))))
+ (patch-collapsed-p '(lambda (p) (not (memq p stgit-expanded-patches)))))
+ (easy-menu-define stgit-menu stgit-mode-map
+ "StGit Menu"
+ `("StGit"
+ ["Reload" stgit-reload-or-repair
+ :help "Reload StGit status from disk"]
+ ["Repair" stgit-repair
+ :keys "\\[universal-argument] \\[stgit-reload-or-repair]"
+ :help "Repair StGit metadata"]
+ "-"
+ ["Undo" stgit-undo t]
+ ["Redo" stgit-redo t]
+ "-"
+ ["Git status" stgit-git-status :active (fboundp 'git-status)]
+ "-"
+ ["New patch" stgit-new-and-refresh
+ :help "Create a new patch from changes in index or work tree"
+ :active (not (and (stgit-index-empty-p) (stgit-work-tree-empty-p)))]
+ ["New empty patch" stgit-new
+ :help "Create a new, empty patch"]
+ ["(Un)mark patch" stgit-toggle-mark
+ :label (if (memq (stgit-patch-name-at-point nil t)
+ stgit-marked-patches)
+ "Unmark patch" "Mark patch")
+ :active (stgit-patch-name-at-point nil t)]
+ ["Expand/collapse patch"
+ (let ((patches (stgit-patches-marked-or-at-point)))
+ (if (member-if ,patch-collapsed-p patches)
+ (stgit-expand patches)
+ (stgit-collapse patches)))
+ :label (if (member-if ,patch-collapsed-p
+ (stgit-patches-marked-or-at-point))
+ "Expand patches"
+ "Collapse patches")
+ :active (stgit-patches-marked-or-at-point)]
+ ["Edit patch" stgit-edit
+ :help "Edit patch comment"
+ :active (stgit-patch-name-at-point nil t)]
+ ["Rename patch" stgit-rename :active (stgit-patch-name-at-point nil t)]
+ ["Push/pop patch" stgit-push-or-pop
+ :label (if (subsetp (stgit-patches-marked-or-at-point nil t)
+ (stgit-applied-patchsyms t))
+ "Pop patches" "Push patches")]
+ ["Delete patches" stgit-delete
+ :active (stgit-patches-marked-or-at-point nil t)]
+ "-"
+ ["Move patches" stgit-move-patches
+ :active stgit-marked-patches
+ :help "Move marked patch(es) to point"]
+ ["Squash patches" stgit-squash
+ :active (> (length stgit-marked-patches) 1)
+ :help "Merge marked patches into one"]
+ "-"
+ ["Refresh top patch" stgit-refresh
+ :active (not (and (stgit-index-empty-p) (stgit-work-tree-empty-p)))
+ :help "Refresh the top patch with changes in index or work tree"]
+ ["Refresh this patch" (stgit-refresh t)
+ :keys "\\[universal-argument] \\[stgit-refresh]"
+ :help "Refresh marked patch with changes in index or work tree"
+ :active (and (not (and (stgit-index-empty-p)
+ (stgit-work-tree-empty-p)))
+ (stgit-patch-name-at-point nil t))]
+ "-"
+ ["Find file" stgit-select
+ :active (eq (get-text-property (point) 'entry-type) 'file)]
+ ["Open file" stgit-find-file-other-window
+ :active (eq (get-text-property (point) 'entry-type) 'file)]
+ ["Toggle file index" stgit-toggle-index
+ :active (and (eq (get-text-property (point) 'entry-type) 'file)
+ (memq (stgit-patch-name-at-point) '(:work :index)))
+ :label (if (eq (stgit-patch-name-at-point) :work)
+ "Move change to index"
+ "Move change to work tree")]
+ "-"
+ ["Show diff" stgit-diff
+ :active (get-text-property (point) 'entry-type)]
+ ("Merge"
+ :active (stgit-git-index-unmerged-p)
+ ["Combined diff" stgit-diff-combined
+ :active (memq (stgit-patch-name-at-point nil nil) '(:work :index))]
+ ["Diff against base" stgit-diff-base
+ :help "Show diff against the common base"
+ :active (memq (stgit-patch-name-at-point nil nil) '(:work :index))]
+ ["Diff against ours" stgit-diff-ours
+ :help "Show diff against our branch"
+ :active (memq (stgit-patch-name-at-point nil nil) '(:work :index))]
+ ["Diff against theirs" stgit-diff-theirs
+ :help "Show diff against their branch"
+ :active (memq (stgit-patch-name-at-point nil nil) '(:work :index))]
+ "-"
+ ["Interactive merge" stgit-find-file-merge
+ :help "Interactively merge the file"
+ :active ,at-unmerged-file]
+ ["Resolve file" stgit-resolve-file
+ :help "Mark file conflict as resolved"
+ :active ,at-unmerged-file]
+ )
+ "-"
+ ["Show index & work tree" stgit-toggle-worktree :style toggle
+ :selected stgit-show-worktree]
+ ["Show unknown files" stgit-toggle-unknown :style toggle
+ :selected stgit-show-unknown :active stgit-show-worktree]
+ ["Show ignored files" stgit-toggle-ignored :style toggle
+ :selected stgit-show-ignored :active stgit-show-worktree]
+ "-"
+ ["Switch branches" stgit-branch t
+ :help "Switch to another branch"]
+ ["Rebase branch" stgit-rebase t
+ :help "Rebase the current branch"]
+ ))))
+
+;; disable tool bar editing buttons
+(put 'stgit-mode 'mode-class 'special)
(defun stgit-mode ()
"Major mode for interacting with StGit.
\\[stgit-previous-patch] Move to previous patch
\\[stgit-next-patch] Move to next patch
-\\[stgit-mark] Mark patch
+\\[stgit-mark-down] Mark patch and move down
\\[stgit-unmark-up] Unmark patch and move up
\\[stgit-unmark-down] Unmark patch and move down
\\[stgit-refresh] Refresh patch with changes in index or work tree
\\[stgit-diff] Show the patch log and diff
+\\[stgit-expand] Show changes in marked patches
+\\[stgit-collapse] Hide changes in marked patches
+
\\[stgit-new] Create a new, empty patch
+\\[stgit-new-and-refresh] Create a new patch from index or work tree
\\[stgit-rename] Rename patch
\\[stgit-edit] Edit patch description
\\[stgit-delete] Delete patch(es)
+\\[stgit-revert] Revert all changes in index or work tree
+\\[stgit-toggle-index] Toggle all changes between index and work tree
+
\\[stgit-push-next] Push next patch onto stack
\\[stgit-pop-next] Pop current patch from stack
\\[stgit-push-or-pop] Push or pop patch at point
\\[stgit-find-file-other-window] Open the file in another window
\\[stgit-diff] Show the file's diff
-\\[stgit-file-toggle-index] Toggle change between index and work tree
-\\[stgit-revert-file] Revert changes to file
+\\[stgit-toggle-index] Toggle change between index and work tree
+\\[stgit-revert] Revert changes to file
Display commands:
\\[stgit-toggle-worktree] Toggle showing index and work tree
(defun stgit-patched-file-at-point ()
(get-text-property (point) 'file-data))
-(defun stgit-patches-marked-or-at-point ()
- "Return the symbols of the marked patches, or the patch on the current line."
+(defun stgit-patches-marked-or-at-point (&optional cause-error only-patches)
+ "Return the symbols of the marked patches, or the patch on the current line.
+If CAUSE-ERRROR is not nil, signal an error if none found.
+If ONLY-PATCHES is not nil, do not include index or work tree."
(if stgit-marked-patches
stgit-marked-patches
- (let ((patch (stgit-patch-name-at-point)))
- (if patch
- (list patch)
- '()))))
+ (let ((patch (stgit-patch-name-at-point nil only-patches)))
+ (cond (patch (list patch))
+ (cause-error (error "No patches marked or at this line"))
+ (t nil)))))
(defun stgit-goto-patch (patchsym &optional file)
"Move point to the line containing patch PATCHSYM.
(defun stgit-init ()
"Run stg init."
(interactive)
+ (stgit-assert-mode)
(stgit-capture-output nil
(stgit-run "init"))
(stgit-reload))
+(defun stgit-toggle-mark ()
+ "Toggle mark on the patch under point."
+ (interactive)
+ (stgit-assert-mode)
+ (if (memq (stgit-patch-name-at-point t t) stgit-marked-patches)
+ (stgit-unmark)
+ (stgit-mark)))
+
(defun stgit-mark ()
"Mark the patch under point."
(interactive)
+ (stgit-assert-mode)
(let* ((node (ewoc-locate stgit-ewoc))
(patch (ewoc-data node))
(name (stgit-patch-name patch)))
(when (eq name :index)
(error "Cannot mark the index"))
(stgit-add-mark (stgit-patch-name patch))
- (ewoc-invalidate stgit-ewoc node))
+ (let ((column (current-column)))
+ (ewoc-invalidate stgit-ewoc node)
+ (move-to-column column))))
+
+(defun stgit-mark-down ()
+ "Mark the patch under point and move to the next patch."
+ (interactive)
+ (stgit-mark)
(stgit-next-patch))
-(defun stgit-unmark-up ()
- "Remove mark from the patch on the previous line."
+(defun stgit-unmark ()
+ "Remove mark from the patch on the current line."
(interactive)
- (stgit-previous-patch)
+ (stgit-assert-mode)
(let* ((node (ewoc-locate stgit-ewoc))
(patch (ewoc-data node)))
(stgit-remove-mark (stgit-patch-name patch))
- (ewoc-invalidate stgit-ewoc node))
- (move-to-column (stgit-goal-column)))
+ (let ((column (current-column)))
+ (ewoc-invalidate stgit-ewoc node)
+ (move-to-column column))))
+
+(defun stgit-unmark-up ()
+ "Remove mark from the patch on the previous line."
+ (interactive)
+ (stgit-assert-mode)
+ (stgit-previous-patch)
+ (stgit-unmark))
(defun stgit-unmark-down ()
"Remove mark from the patch on the current line."
(interactive)
- (let* ((node (ewoc-locate stgit-ewoc))
- (patch (ewoc-data node)))
- (stgit-remove-mark (stgit-patch-name patch))
- (ewoc-invalidate stgit-ewoc node))
+ (stgit-assert-mode)
+ (stgit-unmark)
(stgit-next-patch))
(defun stgit-rename (name)
(interactive (list
(read-string "Patch name: "
(symbol-name (stgit-patch-name-at-point t t)))))
+ (stgit-assert-mode)
(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)))
(when (memq old-patchsym stgit-expanded-patches)
(setq stgit-expanded-patches
- (cons name-sym (delq old-patchsym stgit-expanded-patches))))
+ (cons name-sym (delq old-patchsym stgit-expanded-patches))))
(when (memq old-patchsym stgit-marked-patches)
(setq stgit-marked-patches
- (cons name-sym (delq old-patchsym stgit-marked-patches))))
+ (cons name-sym (delq old-patchsym stgit-marked-patches))))
(stgit-reload)
(stgit-goto-patch name-sym))))
With a prefix argument, repair the StGit metadata if the branch
was modified with git commands (`stgit-repair')."
(interactive "P")
+ (stgit-assert-mode)
(if repair
(stgit-repair)
(stgit-reload)))
(defun stgit-repair ()
"Run stg repair."
(interactive)
+ (stgit-assert-mode)
(stgit-capture-output nil
(stgit-run "repair"))
(stgit-reload))
"Switch to branch BRANCH."
(interactive (list (completing-read "Switch to branch: "
(stgit-available-branches))))
+ (stgit-assert-mode)
(stgit-capture-output nil (stgit-run "branch" "--" branch))
(stgit-reload))
"Rebase to NEW-BASE."
(interactive (list (completing-read "Rebase to: "
(stgit-available-refs t))))
+ (stgit-assert-mode)
(stgit-capture-output nil (stgit-run "rebase" new-base))
(stgit-reload))
Interactively, the prefix argument is used as COUNT.
A negative COUNT will uncommit instead."
(interactive "p")
+ (stgit-assert-mode)
(if (< count 0)
(stgit-uncommit (- count))
(stgit-capture-output nil (stgit-run "commit" "-n" count))
Interactively, the prefix argument is used as COUNT.
A negative COUNT will commit instead."
(interactive "p")
+ (stgit-assert-mode)
(if (< count 0)
(stgit-commit (- count))
(stgit-capture-output nil (stgit-run "uncommit" "-n" count))
"Revert the file at point, which must be in the index or the
working tree."
(interactive)
+ (stgit-assert-mode)
(let* ((patched-file (or (stgit-patched-file-at-point)
(error "No file on the current line")))
(patch-name (stgit-patch-name-at-point))
(stgit-reload)
(stgit-goto-patch patch-name next-file)))))
+(defun stgit-revert ()
+ "Revert the change at point, which must be the index, the work
+tree, or a single change in either."
+ (interactive)
+ (stgit-assert-mode)
+ (let ((patched-file (stgit-patched-file-at-point)))
+ (if patched-file
+ (stgit-revert-file)
+ (let* ((patch-name (or (stgit-patch-name-at-point)
+ (error "No patch or file at point")))
+ (patch-desc (case patch-name
+ (:index "index")
+ (:work "work tree")
+ (t (error (substitute-command-keys
+ "Use \\[stgit-delete] to delete a patch"))))))
+ (when (if (eq patch-name :work)
+ (stgit-work-tree-empty-p)
+ (stgit-index-empty-p))
+ (error (format "There are no changes in the %s to revert"
+ patch-desc)))
+ (and (eq patch-name :index)
+ (not (stgit-work-tree-empty-p))
+ (error "Cannot revert index as work tree contains unstaged changes"))
+
+ (when (yes-or-no-p (format "Revert all changes in the %s? "
+ patch-desc))
+ (if (eq patch-name :index)
+ (stgit-run-git-silent "reset" "--hard" "-q")
+ (stgit-run-git-silent "checkout" "--" "."))
+ (stgit-refresh-index)
+ (stgit-refresh-worktree)
+ (stgit-goto-patch patch-name))))))
+
(defun stgit-resolve-file ()
"Resolve conflict in the file at point."
(interactive)
+ (stgit-assert-mode)
(let* ((patched-file (stgit-patched-file-at-point))
(patch (stgit-patch-at-point))
(patch-name (and patch (stgit-patch-name patch)))
"Push the first unapplied patch.
With numeric prefix argument, push that many patches."
(interactive "p")
+ (stgit-assert-mode)
(stgit-capture-output nil (stgit-run "push" "-n" npatches))
(stgit-reload)
(stgit-refresh-git-status))
"Pop the topmost applied patch.
With numeric prefix argument, pop that many patches."
(interactive "p")
+ (stgit-assert-mode)
(stgit-capture-output nil (stgit-run "pop" "-n" npatches))
(stgit-reload)
(stgit-refresh-git-status))
-(defun stgit-applied-at-point ()
- "Is the patch on the current line applied?"
- (save-excursion
- (beginning-of-line)
- (looking-at "[>+]")))
+(defun stgit-applied-patches (&optional only-patches)
+ "Return a list of the applied patches.
+
+If ONLY-PATCHES is not nil, exclude index and work tree."
+ (let ((states (if only-patches
+ '(applied top)
+ '(applied top index work)))
+ result)
+ (ewoc-map (lambda (patch) (when (memq (stgit-patch-status patch) states)
+ (setq result (cons patch result))))
+ stgit-ewoc)
+ result))
+
+(defun stgit-applied-patchsyms (&optional only-patches)
+ "Return a list of the symbols of the applied patches.
+
+If ONLY-PATCHES is not nil, exclude index and work tree."
+ (mapcar #'stgit-patch-name (stgit-applied-patches only-patches)))
(defun stgit-push-or-pop ()
- "Push or pop the patch on the current line."
+ "Push or pop the marked patches."
(interactive)
- (let ((patchsym (stgit-patch-name-at-point t))
- (applied (stgit-applied-at-point)))
+ (stgit-assert-mode)
+ (let* ((patchsyms (stgit-patches-marked-or-at-point t t))
+ (applied-syms (stgit-applied-patchsyms t))
+ (unapplied (set-difference patchsyms applied-syms)))
(stgit-capture-output nil
- (stgit-run (if applied "pop" "push") patchsym))
- (stgit-reload)))
+ (apply 'stgit-run
+ (if unapplied "push" "pop")
+ "--"
+ (stgit-sort-patches (if unapplied unapplied patchsyms)))))
+ (stgit-reload))
(defun stgit-goto ()
"Go to the patch on the current line."
(interactive)
+ (stgit-assert-mode)
(let ((patchsym (stgit-patch-name-at-point t)))
(stgit-capture-output nil
(stgit-run "goto" patchsym))
(and space-arg (list "-O" space-arg))
(list (stgit-patch-name-at-point)))))
(apply 'stgit-run args)))))
- (t
- (error "No patch or file at point")))
+ (t
+ (error "No patch or file at point")))
(with-current-buffer standard-output
(goto-char (point-min))
(diff-mode)))))
"")
name)
(interactive "p")
+ (stgit-assert-mode)
(stgit-show-patch ,diff-arg ignore-whitespace)))
(stgit-define-diff stgit-diff
(stgit-capture-output "*git output*"
(stgit-run-git "reset" "-q" "--" file)))
+(defun stgit-git-index-unmerged-p ()
+ (let (result)
+ (with-output-to-string
+ (setq result (not (zerop (stgit-run-git-silent "diff-index" "--cached"
+ "--diff-filter=U"
+ "--quiet" "HEAD")))))
+ result))
+
(defun stgit-file-toggle-index ()
"Move modified file in or out of the index.
file ended up. You can then jump to the file with \
\\[exchange-point-and-mark]."
(interactive)
+ (stgit-assert-mode)
(let* ((patched-file (or (stgit-patched-file-at-point)
(error "No file on the current line")))
(patched-status (stgit-file-status patched-file)))
(stgit-file-cr-to patched-file)
(stgit-file-file patched-file)))
(point-file (if (eq patched-status 'rename)
- (stgit-file-cr-from patched-file)
- (stgit-neighbour-file))))
+ (stgit-file-cr-from patched-file)
+ (stgit-neighbour-file))))
(cond ((eq patch-name :work)
(stgit-move-change-to-index (stgit-file-file patched-file)
(push-mark nil t t)
(stgit-goto-patch patch-name point-file))))
+(defun stgit-toggle-index ()
+ "Move change in or out of the index.
+
+Works on index and work tree, as well as files in either.
+
+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)
+ (stgit-assert-mode)
+ (if (stgit-patched-file-at-point)
+ (stgit-file-toggle-index)
+ (let ((patch-name (stgit-patch-name-at-point)))
+ (unless (memq patch-name '(:index :work))
+ (error "Can only move changes between working tree and index"))
+ (when (stgit-git-index-unmerged-p)
+ (error "Resolve unmerged changes with \\[stgit-resolve-file] first"))
+ (if (if (eq patch-name :index)
+ (stgit-index-empty-p)
+ (stgit-work-tree-empty-p))
+ (message "No changes to be moved")
+ (stgit-capture-output nil
+ (if (eq patch-name :work)
+ (stgit-run-git "add" "--update")
+ (stgit-run-git "reset" "--mixed" "-q")))
+ (stgit-refresh-worktree)
+ (stgit-refresh-index))
+ (stgit-goto-patch (if (eq patch-name :index) :work :index)))))
+
(defun stgit-edit ()
"Edit the patch on the current line."
(interactive)
+ (stgit-assert-mode)
(let ((patchsym (stgit-patch-name-at-point t t))
(edit-buf (get-buffer-create "*StGit edit*"))
(dir default-directory))
(with-current-buffer log-edit-parent-buffer
(stgit-reload))))
-(defun stgit-new (add-sign)
+(defun stgit-new (add-sign &optional refresh)
"Create a new patch.
With a prefix argument, include a \"Signed-off-by:\" line at the
end of the patch."
(interactive "P")
+ (stgit-assert-mode)
(let ((edit-buf (get-buffer-create "*StGit edit*"))
(dir default-directory))
(log-edit 'stgit-confirm-new t nil edit-buf)
(setq default-directory dir)
+ (set (make-local-variable 'stgit-refresh-after-new) refresh)
(when add-sign
(save-excursion
(let ((standard-output (current-buffer)))
(defun stgit-confirm-new ()
(interactive)
- (let ((file (make-temp-file "stgit-edit-")))
+ (let ((file (make-temp-file "stgit-edit-"))
+ (refresh stgit-refresh-after-new))
(write-region (point-min) (point-max) file)
(stgit-capture-output nil
(stgit-run "new" "-f" file))
(with-current-buffer log-edit-parent-buffer
- (stgit-reload))))
+ (if refresh
+ (stgit-refresh)
+ (stgit-reload)))))
+
+(defun stgit-new-and-refresh (add-sign)
+ "Create a new patch and refresh it with the current changes.
+
+With a prefix argument, include a \"Signed-off-by:\" line at the
+end of the patch.
+
+This works just like running `stgit-new' followed by `stgit-refresh'."
+ (interactive "P")
+ (stgit-assert-mode)
+ (stgit-new add-sign t))
(defun stgit-create-patch-name (description)
"Create a patch name from a long description"
With a prefix argument, or SPILL-P, spill the patch contents to
the work tree and index."
- (interactive (list (stgit-patches-marked-or-at-point)
+ (interactive (list (stgit-patches-marked-or-at-point t t)
current-prefix-arg))
+ (stgit-assert-mode)
(unless patchsyms
(error "No patches to delete"))
(when (memq :index patchsyms)
"Return the patchsym indicating a target patch for
`stgit-move-patches'.
-This is either the patch at point, or one of :top and :bottom, if
-the point is after or before the applied patches."
+This is either the first unmarked patch at or after point, or one
+of :top and :bottom if the point is after or before the applied
+patches."
- (let ((patchsym (stgit-patch-name-at-point nil t)))
- (cond (patchsym patchsym)
- ((save-excursion (re-search-backward "^>" nil t)) :top)
- (t :bottom))))
+ (save-excursion
+ (let (result)
+ (while (not result)
+ (let ((patchsym (stgit-patch-name-at-point)))
+ (cond ((memq patchsym '(:work :index)) (setq result :top))
+ (patchsym (if (memq patchsym stgit-marked-patches)
+ (stgit-next-patch)
+ (setq result patchsym)))
+ ((re-search-backward "^>" nil t) (setq result :top))
+ (t (setq result :bottom)))))
+ result)))
(defun stgit-sort-patches (patchsyms)
"Returns the list of patches in PATCHSYMS sorted according to
Interactively, move the marked patches to where the point is."
(interactive (list stgit-marked-patches
(stgit-move-patches-target)))
+ (stgit-assert-mode)
(unless patchsyms
(error "Need at least one patch to move"))
(unless target-patch
(error "Point not at a patch"))
- (if (eq target-patch :top)
- (stgit-capture-output nil
- (apply 'stgit-run "float" patchsyms))
-
- ;; need to have patchsyms sorted by position in the stack
- (let ((sorted-patchsyms (stgit-sort-patches patchsyms)))
- (while sorted-patchsyms
- (setq sorted-patchsyms
- (and (stgit-capture-output nil
- (if (eq target-patch :bottom)
- (stgit-run "sink" "--" (car sorted-patchsyms))
- (stgit-run "sink" "--to" target-patch "--"
- (car sorted-patchsyms))))
- (cdr sorted-patchsyms))))))
+ ;; need to have patchsyms sorted by position in the stack
+ (let ((sorted-patchsyms (stgit-sort-patches patchsyms)))
+ (stgit-capture-output nil
+ (if (eq target-patch :top)
+ (apply 'stgit-run "float" sorted-patchsyms)
+ (apply 'stgit-run
+ "sink"
+ (append (unless (eq target-patch :bottom)
+ (list "--to" target-patch))
+ '("--")
+ sorted-patchsyms)))))
(stgit-reload))
(defun stgit-squash (patchsyms)
one patch, which will occupy the same spot in the series as the
deepest patch had before the squash."
(interactive (list stgit-marked-patches))
+ (stgit-assert-mode)
(when (< (length patchsyms) 2)
(error "Need at least two patches to squash"))
(let ((stgit-buffer (current-buffer))
See also `stgit-redo'."
(interactive "P")
+ (stgit-assert-mode)
(stgit-capture-output nil
(if arg
(stgit-run "undo" "--hard")
See also `stgit-undo'."
(interactive "P")
+ (stgit-assert-mode)
(stgit-capture-output nil
(if arg
(stgit-run "redo" "--hard")
With prefix argument, refresh the marked patch or the patch under point."
(interactive "P")
+ (stgit-assert-mode)
(let ((patchargs (if arg
- (let ((patches (stgit-patches-marked-or-at-point)))
- (cond ((null patches)
- (error "No patch to update"))
- ((> (length patches) 1)
- (error "Too many patches selected"))
- (t
- (cons "-p" patches))))
+ (let ((patches (stgit-patches-marked-or-at-point nil t)))
+ (when (> (length patches) 1)
+ (error "Too many patches marked"))
+ (cons "-p" patches))
nil)))
(unless (stgit-index-empty-p)
(setq patchargs (cons "--index" patchargs)))
`stgit-show-worktree-mode' controls where on screen the index and
work tree will show up."
(interactive)
+ (stgit-assert-mode)
(setq stgit-show-worktree
(if (numberp arg)
(> arg 0)
Use \\[stgit-toggle-worktree] to show the work tree."
(interactive)
+ (stgit-assert-mode)
(setq stgit-show-ignored
(if (numberp arg)
(> arg 0)
Use \\[stgit-toggle-worktree] to show the work tree."
(interactive)
+ (stgit-assert-mode)
(setq stgit-show-unknown
(if (numberp arg)
(> arg 0)