mirror of https://github.com/Chizi123/.emacs.d.git

Chizi123
2018-11-18 76bbd07de7add0f9d13c6914f158d19630fe2f62
commit | author | age
5cb5f7 1 ;;; magit-extras.el --- additional functionality for Magit  -*- lexical-binding: t -*-
C 2
3 ;; Copyright (C) 2008-2018  The Magit Project Contributors
4 ;;
5 ;; You should have received a copy of the AUTHORS.md file which
6 ;; lists all contributors.  If not, see http://magit.vc/authors.
7
8 ;; Magit is free software; you can redistribute it and/or modify it
9 ;; under the terms of the GNU General Public License as published by
10 ;; the Free Software Foundation; either version 3, or (at your option)
11 ;; any later version.
12 ;;
13 ;; Magit is distributed in the hope that it will be useful, but WITHOUT
14 ;; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15 ;; or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
16 ;; License for more details.
17 ;;
18 ;; You should have received a copy of the GNU General Public License
19 ;; along with Magit.  If not, see http://www.gnu.org/licenses.
20
21 ;;; Commentary:
22
23 ;; Additional functionality for Magit.
24
25 ;;; Code:
26
27 (eval-when-compile
28   (require 'subr-x))
29
30 (require 'magit)
31
32 (declare-function dired-read-shell-command "dired-aux" (prompt arg files))
33
34 (defgroup magit-extras nil
35   "Additional functionality for Magit."
36   :group 'magit-extensions)
37
38 ;;; External Tools
39
40 (defcustom magit-gitk-executable
41   (or (and (eq system-type 'windows-nt)
42            (let ((exe (magit-git-string
43                        "-c" "alias.X=!x() { which \"$1\" | cygpath -mf -; }; x"
44                        "X" "gitk.exe")))
45              (and exe (file-executable-p exe) exe)))
46       (executable-find "gitk") "gitk")
47   "The Gitk executable."
48   :group 'magit-extras
49   :set-after '(magit-git-executable)
50   :type 'string)
51
52 ;;;###autoload
53 (defun magit-run-git-gui ()
54   "Run `git gui' for the current git repository."
55   (interactive)
56   (magit-with-toplevel
57     (magit-process-file magit-git-executable nil 0 nil "gui")))
58
59 ;;;###autoload
60 (defun magit-run-git-gui-blame (commit filename &optional linenum)
61   "Run `git gui blame' on the given FILENAME and COMMIT.
62 Interactively run it for the current file and the `HEAD', with a
63 prefix or when the current file cannot be determined let the user
64 choose.  When the current buffer is visiting FILENAME instruct
65 blame to center around the line point is on."
66   (interactive
67    (let (revision filename)
68      (when (or current-prefix-arg
69                (not (setq revision "HEAD"
70                           filename (magit-file-relative-name nil 'tracked))))
71        (setq revision (magit-read-branch-or-commit "Blame from revision"))
72        (setq filename (magit-read-file-from-rev revision "Blame file")))
73      (list revision filename
74            (and (equal filename
75                        (ignore-errors
76                          (magit-file-relative-name buffer-file-name)))
77                 (line-number-at-pos)))))
78   (magit-with-toplevel
79     (apply #'magit-process-file magit-git-executable nil 0 nil "gui" "blame"
80            `(,@(and linenum (list (format "--line=%d" linenum)))
81              ,commit
82              ,filename))))
83
84 ;;;###autoload
85 (defun magit-run-gitk ()
86   "Run `gitk' in the current repository."
87   (interactive)
88   (magit-process-file magit-gitk-executable nil 0))
89
90 ;;;###autoload
91 (defun magit-run-gitk-branches ()
92   "Run `gitk --branches' in the current repository."
93   (interactive)
94   (magit-process-file magit-gitk-executable nil 0 nil "--branches"))
95
96 ;;;###autoload
97 (defun magit-run-gitk-all ()
98   "Run `gitk --all' in the current repository."
99   (interactive)
100   (magit-process-file magit-gitk-executable nil 0 nil "--all"))
101
102 ;;; Emacs Tools
103
104 ;;;###autoload
105 (defun ido-enter-magit-status ()
106   "Drop into `magit-status' from file switching.
107
108 This command does not work in Emacs 26.  It does work in Emacs 25
109 and Emacs 27.  See https://github.com/magit/magit/issues/3634 and
110 https://debbugs.gnu.org/cgi/bugreport.cgi?bug=31707.
111
112 To make this command available use something like:
113
114   (add-hook \\='ido-setup-hook
115             (lambda ()
116               (define-key ido-completion-map
117                 (kbd \"C-x g\") \\='ido-enter-magit-status)))
118
119 Starting with Emacs 25.1 the Ido keymaps are defined just once
120 instead of every time Ido is invoked, so now you can modify it
121 like pretty much every other keymap:
122
123   (define-key ido-common-completion-map
124     (kbd \"C-x g\") \\='ido-enter-magit-status)"
125   (interactive)
126   (with-no-warnings ; FIXME these are internal variables
127     (setq ido-exit 'fallback)
128     (setq fallback 'magit-status)      ; for Emacs 25
129     (setq ido-fallback 'magit-status)) ; for Emacs 27
130   (exit-minibuffer))
131
132 ;;;###autoload
133 (defun magit-dired-jump (&optional other-window)
134   "Visit file at point using Dired.
135 With a prefix argument, visit in another window.  If there
136 is no file at point, then instead visit `default-directory'."
137   (interactive "P")
138   (dired-jump other-window
139               (when-let ((file (magit-file-at-point)))
140                 (expand-file-name (if (file-directory-p file)
141                                       (file-name-as-directory file)
142                                     file)))))
143
144 ;;;###autoload
145 (defun magit-dired-log (&optional follow)
146   "Show log for all marked files, or the current file."
147   (interactive "P")
148   (if-let ((topdir (magit-toplevel default-directory)))
149       (let ((args (car (magit-log-arguments)))
150             (files (dired-get-marked-files nil nil #'magit-file-tracked-p)))
151         (unless files
152           (user-error "No marked file is being tracked by Git"))
153         (when (and follow
154                    (not (member "--follow" args))
155                    (not (cdr files)))
156           (push "--follow" args))
157         (magit-mode-setup-internal
158          #'magit-log-mode
159          (list (list (or (magit-get-current-branch) "HEAD"))
160                args
161                (let ((default-directory topdir))
162                  (mapcar #'file-relative-name files)))
163          magit-log-buffer-file-locked))
164     (magit--not-inside-repository-error)))
165
166 ;;;###autoload
167 (defun magit-do-async-shell-command (file)
168   "Open FILE with `dired-do-async-shell-command'.
169 Interactively, open the file at point."
170   (interactive (list (or (magit-file-at-point)
171                          (completing-read "Act on file: "
172                                           (magit-list-files)))))
173   (require 'dired-aux)
174   (dired-do-async-shell-command
175    (dired-read-shell-command "& on %s: " current-prefix-arg (list file))
176    nil (list file)))
177
178 ;;; Shift Selection
179
180 (defun magit--turn-on-shift-select-mode-p ()
181   (and shift-select-mode
182        this-command-keys-shift-translated
183        (not mark-active)
184        (not (eq (car-safe transient-mark-mode) 'only))))
185
186 ;;;###autoload
187 (defun magit-previous-line (&optional arg try-vscroll)
188   "Like `previous-line' but with Magit-specific shift-selection.
189
190 Magit's selection mechanism is based on the region but selects an
191 area that is larger than the region.  This causes `previous-line'
192 when invoked while holding the shift key to move up one line and
193 thereby select two lines.  When invoked inside a hunk body this
194 command does not move point on the first invocation and thereby
195 it only selects a single line.  Which inconsistency you prefer
196 is a matter of preference."
197   (declare (interactive-only
198             "use `forward-line' with negative argument instead."))
199   (interactive "p\np")
200   (unless arg (setq arg 1))
201   (let ((stay (or (magit-diff-inside-hunk-body-p)
202                   (magit-section-position-in-heading-p))))
203     (if (and stay (= arg 1) (magit--turn-on-shift-select-mode-p))
204         (push-mark nil nil t)
205       (with-no-warnings
206         (handle-shift-selection)
207         (previous-line (if stay (max (1- arg) 1) arg) try-vscroll)))))
208
209 ;;;###autoload
210 (defun magit-next-line (&optional arg try-vscroll)
211   "Like `next-line' but with Magit-specific shift-selection.
212
213 Magit's selection mechanism is based on the region but selects
214 an area that is larger than the region.  This causes `next-line'
215 when invoked while holding the shift key to move down one line
216 and thereby select two lines.  When invoked inside a hunk body
217 this command does not move point on the first invocation and
218 thereby it only selects a single line.  Which inconsistency you
219 prefer is a matter of preference."
220   (declare (interactive-only forward-line))
221   (interactive "p\np")
222   (unless arg (setq arg 1))
223   (let ((stay (or (magit-diff-inside-hunk-body-p)
224                   (magit-section-position-in-heading-p))))
225     (if (and stay (= arg 1) (magit--turn-on-shift-select-mode-p))
226         (push-mark nil nil t)
227       (with-no-warnings
228         (handle-shift-selection)
229         (next-line (if stay (max (1- arg) 1) arg) try-vscroll)))))
230
231 ;;; Clean
232
233 ;;;###autoload
234 (defun magit-clean (&optional arg)
235   "Remove untracked files from the working tree.
236 With a prefix argument also remove ignored files,
237 with two prefix arguments remove ignored files only.
238 \n(git clean -f -d [-x|-X])"
239   (interactive "p")
240   (when (yes-or-no-p (format "Remove %s files? "
241                              (pcase arg
242                                (1 "untracked")
243                                (4 "untracked and ignored")
244                                (_ "ignored"))))
245     (magit-wip-commit-before-change)
246     (magit-run-git "clean" "-f" "-d" (pcase arg (4 "-x") (16 "-X")))))
247
248 (put 'magit-clean 'disabled t)
249
250 ;;; ChangeLog
251
252 ;;;###autoload
253 (defun magit-add-change-log-entry (&optional whoami file-name other-window)
254   "Find change log file and add date entry and item for current change.
255 This differs from `add-change-log-entry' (which see) in that
256 it acts on the current hunk in a Magit buffer instead of on
257 a position in a file-visiting buffer."
258   (interactive (list current-prefix-arg
259                      (prompt-for-change-log-name)))
260   (let (buf pos)
261     (save-window-excursion
262       (call-interactively #'magit-diff-visit-file)
263       (setq buf (current-buffer))
264       (setq pos (point)))
265     (save-excursion
266       (with-current-buffer buf
267         (goto-char pos)
268         (add-change-log-entry whoami file-name other-window)))))
269
270 ;;;###autoload
271 (defun magit-add-change-log-entry-other-window (&optional whoami file-name)
272   "Find change log file in other window and add entry and item.
273 This differs from `add-change-log-entry-other-window' (which see)
274 in that it acts on the current hunk in a Magit buffer instead of
275 on a position in a file-visiting buffer."
276   (interactive (and current-prefix-arg
277                     (list current-prefix-arg
278                           (prompt-for-change-log-name))))
279   (magit-add-change-log-entry whoami file-name t))
280
281 ;;; Edit Line Commit
282
283 ;;;###autoload
284 (defun magit-edit-line-commit (&optional type)
285   "Edit the commit that added the current line.
286
287 With a prefix argument edit the commit that removes the line,
288 if any.  The commit is determined using `git blame' and made
289 editable using `git rebase --interactive' if it is reachable
290 from `HEAD', or by checking out the commit (or a branch that
291 points at it) otherwise."
292   (interactive (list (and current-prefix-arg 'removal)))
293   (let* ((chunk (magit-current-blame-chunk (or type 'addition)))
294          (rev   (oref chunk orig-rev)))
295     (if (equal rev "0000000000000000000000000000000000000000")
296         (message "This line has not been committed yet")
297       (let ((rebase (magit-rev-ancestor-p rev "HEAD"))
298             (file   (expand-file-name (oref chunk orig-file)
299                                       (magit-toplevel))))
300         (if rebase
301             (let ((magit--rebase-published-symbol 'edit-published))
302               (magit-rebase-edit-commit rev (magit-rebase-arguments)))
303           (magit-checkout (or (magit-rev-branch rev) rev)))
304         (unless (and buffer-file-name
305                      (file-equal-p file buffer-file-name))
306           (let ((blame-type (and magit-blame-mode magit-blame-type)))
307             (if rebase
308                 (set-process-sentinel
309                  magit-this-process
310                  (lambda (process event)
311                    (magit-sequencer-process-sentinel process event)
312                    (when (eq (process-status process) 'exit)
313                      (find-file file)
314                      (when blame-type
315                        (magit-blame--pre-blame-setup blame-type)
316                        (magit-blame--run)))))
317               (find-file file)
318               (when blame-type
319                 (magit-blame--pre-blame-setup blame-type)
320                 (magit-blame--run)))))))))
321
322 (put 'magit-edit-line-commit 'disabled t)
323
324 (defun magit-diff-edit-hunk-commit ()
325   "From a hunk, edit the respective commit and visit the file.
326
327 First visit the file being modified by the hunk at the correct
328 location using `magit-diff-visit-file'.  This actually visits a
329 blob.  When point is on a diff header, not within an individual
330 hunk, then this visits the blob the first hunk is about.
331
332 Then invoke `magit-edit-line-commit', which uses an interactive
333 rebase to make the commit editable, or if that is not possible
334 because the commit is not reachable from `HEAD' by checking out
335 that commit directly.  This also causes the actual worktree file
336 to be visited.
337
338 Neither the blob nor the file buffer are killed when finishing
339 the rebase.  If that is undesirable, then it might be better to
340 use `magit-rebase-edit-command' instead of this command."
341   (interactive)
342   (let ((magit-diff-visit-previous-blob nil))
343     (magit-diff-visit-file (--if-let (magit-file-at-point)
344                                (expand-file-name it)
345                              (user-error "No file at point"))
346                            nil 'switch-to-buffer))
347   (magit-edit-line-commit))
348
349 (put 'magit-diff-edit-hunk-commit 'disabled t)
350
351 ;;; Reshelve
352
353 ;;;###autoload
354 (defun magit-reshelve-since (rev)
355   "Change the author and committer dates of the commits since REV.
356
357 Ask the user for the first reachable commit whose dates should
358 be changed.  The read the new date for that commit.  The initial
359 minibuffer input and the previous history element offer good
360 values.  The next commit will be created one minute later and so
361 on.
362
363 This command is only intended for interactive use and should only
364 be used on highly rearranged and unpublished history."
365   (interactive (list nil))
366   (cond
367    ((not rev)
368     (let ((backup (concat "refs/original/refs/heads/"
369                           (magit-get-current-branch))))
370       (when (and (magit-ref-p backup)
371                  (not (magit-y-or-n-p
372                        "Backup ref %s already exists.  Override? " backup)))
373         (user-error "Abort")))
374     (magit-log-select 'magit-reshelve-since
375       "Type %p on a commit to reshelve it and the commits above it,"))
376    (t
377     (cl-flet ((adjust (time offset)
378                       (format-time-string
379                        "%F %T %z"
380                        (+ (floor time)
381                           (* offset 60)
382                           (- (car (decode-time time)))))))
383       (let* ((start (concat rev "^"))
384              (range (concat start ".." (magit-get-current-branch)))
385              (time-rev (adjust (float-time (string-to-number
386                                             (magit-rev-format "%at" start)))
387                                1))
388              (time-now (adjust (float-time)
389                                (- (string-to-number
390                                    (magit-git-string "rev-list" "--count"
391                                                      range))))))
392         (push time-rev magit--reshelve-history)
393         (let ((date (floor
394                      (float-time
395                       (date-to-time
396                        (read-string "Date for first commit: "
397                                     time-now 'magit--reshelve-history))))))
398           (magit-with-toplevel
399             (magit-run-git-async
400              "filter-branch" "--force" "--env-filter"
401              (format "case $GIT_COMMIT in %s\nesac"
402                      (mapconcat (lambda (rev)
403                                   (prog1 (format "%s) \
404 export GIT_AUTHOR_DATE=\"%s\"; \
405 export GIT_COMMITTER_DATE=\"%s\";;" rev date date)
406                                     (cl-incf date 60)))
407                                 (magit-git-lines "rev-list" "--reverse"
408                                                  range)
409                                 " "))
410              range "--")
411             (set-process-sentinel
412              magit-this-process
413              (lambda (process event)
414                (when (memq (process-status process) '(exit signal))
415                  (if (> (process-exit-status process) 0)
416                      (magit-process-sentinel process event)
417                    (process-put process 'inhibit-refresh t)
418                    (magit-process-sentinel process event)
419                    (magit-run-git "update-ref" "-d"
420                                   (concat "refs/original/refs/heads/"
421                                           (magit-get-current-branch))))))))))))))
422
423 ;;; Revision Stack
424
425 (defvar magit-revision-stack nil)
426
427 (defcustom magit-pop-revision-stack-format
428   '("[%N: %h] " "%N: %H\n   %s\n" "\\[\\([0-9]+\\)[]:]")
429   "Control how `magit-pop-revision-stack' inserts a revision.
430
431 The command `magit-pop-revision-stack' inserts a representation
432 of the revision last pushed to the `magit-revision-stack' into
433 the current buffer.  It inserts text at point and/or near the end
434 of the buffer, and removes the consumed revision from the stack.
435
436 The entries on the stack have the format (HASH TOPLEVEL) and this
437 option has the format (POINT-FORMAT EOB-FORMAT INDEX-REGEXP), all
438 of which may be nil or a string (though either one of EOB-FORMAT
439 or POINT-FORMAT should be a string, and if INDEX-REGEXP is
440 non-nil, then the two formats should be too).
441
442 First INDEX-REGEXP is used to find the previously inserted entry,
443 by searching backward from point.  The first submatch must match
444 the index number.  That number is incremented by one, and becomes
445 the index number of the entry to be inserted.  If you don't want
446 to number the inserted revisions, then use nil for INDEX-REGEXP.
447
448 If INDEX-REGEXP is non-nil, then both POINT-FORMAT and EOB-FORMAT
449 should contain \"%N\", which is replaced with the number that was
450 determined in the previous step.
451
452 Both formats, if non-nil and after removing %N, are then expanded
453 using `git show --format=FORMAT ...' inside TOPLEVEL.
454
455 The expansion of POINT-FORMAT is inserted at point, and the
456 expansion of EOB-FORMAT is inserted at the end of the buffer (if
457 the buffer ends with a comment, then it is inserted right before
458 that)."
459   :package-version '(magit . "2.3.0")
460   :group 'magit-commands
461   :type '(list (choice (string :tag "Insert at point format")
462                        (cons (string :tag "Insert at point format")
463                              (repeat (string :tag "Argument to git show")))
464                        (const :tag "Don't insert at point" nil))
465                (choice (string :tag "Insert at eob format")
466                        (cons (string :tag "Insert at eob format")
467                              (repeat (string :tag "Argument to git show")))
468                        (const :tag "Don't insert at eob" nil))
469                (choice (regexp :tag "Find index regexp")
470                        (const :tag "Don't number entries" nil))))
471
472 ;;;###autoload
473 (defun magit-pop-revision-stack (rev toplevel)
474   "Insert a representation of a revision into the current buffer.
475
476 Pop a revision from the `magit-revision-stack' and insert it into
477 the current buffer according to `magit-pop-revision-stack-format'.
478 Revisions can be put on the stack using `magit-copy-section-value'
479 and `magit-copy-buffer-revision'.
480
481 If the stack is empty or with a prefix argument, instead read a
482 revision in the minibuffer.  By using the minibuffer history this
483 allows selecting an item which was popped earlier or to insert an
484 arbitrary reference or revision without first pushing it onto the
485 stack.
486
487 When reading the revision from the minibuffer, then it might not
488 be possible to guess the correct repository.  When this command
489 is called inside a repository (e.g. while composing a commit
490 message), then that repository is used.  Otherwise (e.g. while
491 composing an email) then the repository recorded for the top
492 element of the stack is used (even though we insert another
493 revision).  If not called inside a repository and with an empty
494 stack, or with two prefix arguments, then read the repository in
495 the minibuffer too."
496   (interactive
497    (if (or current-prefix-arg (not magit-revision-stack))
498        (let ((default-directory
499                (or (and (not (= (prefix-numeric-value current-prefix-arg) 16))
500                         (or (magit-toplevel)
501                             (cadr (car magit-revision-stack))))
502                    (magit-read-repository))))
503          (list (magit-read-branch-or-commit "Insert revision")
504                default-directory))
505      (push (caar magit-revision-stack) magit-revision-history)
506      (pop magit-revision-stack)))
507   (if rev
508       (pcase-let ((`(,pnt-format ,eob-format ,idx-format)
509                    magit-pop-revision-stack-format))
510         (let ((default-directory toplevel)
511               (idx (and idx-format
512                         (save-excursion
513                           (if (re-search-backward idx-format nil t)
514                               (number-to-string
515                                (1+ (string-to-number (match-string 1))))
516                             "1"))))
517               pnt-args eob-args)
518           (when (listp pnt-format)
519             (setq pnt-args (cdr pnt-format))
520             (setq pnt-format (car pnt-format)))
521           (when (listp eob-format)
522             (setq eob-args (cdr eob-format))
523             (setq eob-format (car eob-format)))
524           (when pnt-format
525             (when idx-format
526               (setq pnt-format
527                     (replace-regexp-in-string "%N" idx pnt-format t t)))
528             (magit-rev-insert-format pnt-format rev pnt-args)
529             (backward-delete-char 1))
530           (when eob-format
531             (when idx-format
532               (setq eob-format
533                     (replace-regexp-in-string "%N" idx eob-format t t)))
534             (save-excursion
535               (goto-char (point-max))
536               (skip-syntax-backward ">s-")
537               (beginning-of-line)
538               (if (and comment-start (looking-at comment-start))
539                   (while (looking-at comment-start)
540                     (forward-line -1))
541                 (forward-line)
542                 (unless (= (current-column) 0)
543                   (insert ?\n)))
544               (insert ?\n)
545               (magit-rev-insert-format eob-format rev eob-args)
546               (backward-delete-char 1)))))
547     (user-error "Revision stack is empty")))
548
549 (define-key git-commit-mode-map
550   (kbd "C-c C-w") 'magit-pop-revision-stack)
551
552 ;;;###autoload
553 (defun magit-copy-section-value ()
554   "Save the value of the current section for later use.
555
556 Save the section value to the `kill-ring', and, provided that
557 the current section is a commit, branch, or tag section, push
558 the (referenced) revision to the `magit-revision-stack' for use
559 with `magit-pop-revision-stack'.
560
561 When the current section is a branch or a tag, and a prefix
562 argument is used, then save the revision at its tip to the
563 `kill-ring' instead of the reference name.
564
565 When the region is active, then save that to the `kill-ring',
566 like `kill-ring-save' would, instead of behaving as described
567 above."
568   (interactive)
569   (if (use-region-p)
570       (copy-region-as-kill nil nil 'region)
571     (when-let ((section (magit-current-section))
572                (value (oref section value)))
573       (magit-section-case
574         ((branch commit module-commit tag)
575          (let ((default-directory default-directory) ref)
576            (magit-section-case
577              ((branch tag)
578               (setq ref value))
579              (module-commit
580               (setq default-directory
581                     (file-name-as-directory
582                      (expand-file-name (magit-section-parent-value section)
583                                        (magit-toplevel))))))
584            (setq value (magit-rev-parse value))
585            (push (list value default-directory) magit-revision-stack)
586            (kill-new (message "%s" (or (and current-prefix-arg ref)
587                                        value)))))
588         (t (kill-new (message "%s" value)))))))
589
590 ;;;###autoload
591 (defun magit-copy-buffer-revision ()
592   "Save the revision of the current buffer for later use.
593
594 Save the revision shown in the current buffer to the `kill-ring'
595 and push it to the `magit-revision-stack'.
596
597 This command is mainly intended for use in `magit-revision-mode'
598 buffers, the only buffers where it is always unambiguous exactly
599 which revision should be saved.
600
601 Most other Magit buffers usually show more than one revision, in
602 some way or another, so this command has to select one of them,
603 and that choice might not always be the one you think would have
604 been the best pick.
605
606 In such buffers it is often more useful to save the value of
607 the current section instead, using `magit-copy-section-value'.
608
609 When the region is active, then save that to the `kill-ring',
610 like `kill-ring-save' would, instead of behaving as described
611 above."
612   (interactive)
613   (if (use-region-p)
614       (copy-region-as-kill nil nil 'region)
615     (when-let ((rev (cond ((memq major-mode '(magit-cherry-mode
616                                               magit-log-select-mode
617                                               magit-reflog-mode
618                                               magit-refs-mode
619                                               magit-revision-mode
620                                               magit-stash-mode
621                                               magit-stashes-mode))
622                            (car magit-refresh-args))
623                           ((memq major-mode '(magit-diff-mode
624                                               magit-log-mode))
625                            (let ((r (caar magit-refresh-args)))
626                              (if (string-match "\\.\\.\\.?\\(.+\\)" r)
627                                  (match-string 1 r)
628                                r)))
629                           ((eq major-mode 'magit-status-mode) "HEAD"))))
630       (when (magit-rev-verify-commit rev)
631         (setq rev (magit-rev-parse rev))
632         (push (list rev default-directory) magit-revision-stack)
633         (kill-new (message "%s" rev))))))
634
635 ;;; Miscellaneous
636
637 ;;;###autoload
638 (defun magit-abort-dwim ()
639   "Abort current operation.
640 Depending on the context, this will abort a merge, a rebase, a
641 patch application, a cherry-pick, a revert, or a bisect."
642   (interactive)
643   (cond ((magit-merge-in-progress-p)     (magit-merge-abort))
644         ((magit-rebase-in-progress-p)    (magit-rebase-abort))
645         ((magit-am-in-progress-p)        (magit-am-abort))
646         ((magit-sequencer-in-progress-p) (magit-sequencer-abort))
647         ((magit-bisect-in-progress-p)    (magit-bisect-reset))))
648
649 ;;; _
650 (provide 'magit-extras)
651 ;;; magit-extras.el ends here