gergely/my-emacs-d
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
f3549fe066
my-emacs-d/elpa/magit-1.4.1/magit.el

7839 lines
299 KiB
EmacsLisp
Raw Normal View History

Upgrade packages
2015-05-04 09:52:24 +00:00
;;; magit.el --- control Git from Emacs
;; Copyright (C) 2008-2015 The Magit Project Developers
;;
;; For a full list of contributors, see the AUTHORS.md file
;; at the top-level directory of this distribution and at
;; https://raw.github.com/magit/magit/master/AUTHORS.md
;; Author: Marius Vollmer <marius.vollmer@gmail.com>
;; Maintainer: Jonas Bernoulli <jonas@bernoul.li>
;; Former-Maintainers:
;; Nicolas Dudebout <nicolas.dudebout@gatech.edu>
;; Peter J. Weisberg <pj@irregularexpressions.net>
;; Phil Jackson <phil@shellarchive.co.uk>
;; Rémi Vanicat <vanicat@debian.org>
;; Yann Hodique <yann.hodique@gmail.com>
;; Keywords: vc tools
;; Package: magit
;; Package-Requires: ((cl-lib "0.5") (git-commit-mode "1.0.0") (git-rebase-mode "1.0.0"))
;; Magit requires at least GNU Emacs 23.2 and Git 1.7.2.5.
;; These are the versions shipped by Debian oldstable (6.0, Squeeze).
;; Contains code from GNU Emacs <https://www.gnu.org/software/emacs/>,
;; released under the GNU General Public License version 3 or later.
;; Magit is free software; you can redistribute it and/or modify it
;; under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 3, or (at your option)
;; any later version.
;;
;; Magit is distributed in the hope that it will be useful, but WITHOUT
;; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
;; or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
;; License for more details.
;;
;; You should have received a copy of the GNU General Public License
;; along with Magit. If not, see <http://www.gnu.org/licenses/>.
;;; Commentary:
;; Invoking the magit-status function will show a buffer with the
;; status of the current git repository and its working tree. That
;; buffer offers key bindings for manipulating the status in simple
;; ways.
;;
;; The status buffer mainly shows the difference between the working
;; tree and the index, and the difference between the index and the
;; current HEAD. You can add individual hunks from the working tree
;; to the index, and you can commit the index.
;;
;; See the Magit User Manual for more information.
;;; Code:
(defvar magit-version 'undefined
"The version of Magit that you're using.
Use the function by the same name instead of this variable.")
;; The value is set at the end of this file, using the
;; function `magit-version' which is also defined there.
;;;; Dependencies
(when (version< emacs-version "23.2")
(error "Magit requires at least GNU Emacs 23.2"))
(require 'git-commit-mode)
(require 'git-rebase-mode)
(require 'ansi-color)
(require 'autorevert)
(require 'cl-lib)
(require 'diff-mode)
(require 'easymenu)
(require 'epa)
(require 'format-spec)
(require 'grep)
(require 'help-mode)
(require 'ring)
(require 'server)
(require 'tramp)
(require 'view)
(eval-when-compile
(require 'dired)
(require 'dired-x)
(require 'ediff)
(require 'eshell)
(require 'ido)
(require 'package nil t)
(require 'view))
;;;; Declarations
(if (featurep 'vc-git)
(defalias 'magit-grep 'vc-git-grep)
(defalias 'magit-grep 'lgrep))
(declare-function dired-jump 'dired-x)
(declare-function dired-uncache 'dired)
(declare-function ediff-cleanup-mess 'ediff)
(declare-function eshell-parse-arguments 'eshell)
(declare-function ido-completing-read 'ido)
(declare-function package-desc-vers 'package)
(declare-function package-desc-version 'package)
(declare-function package-version-join 'package)
(declare-function view-mode 'view)
(defvar git-commit-previous-winconf)
(defvar magit-commit-buffer-name)
(defvar magit-custom-options)
(defvar magit-log-buffer-name)
(defvar magit-marked-commit)
(defvar magit-process-buffer-name)
(defvar magit-reflog-buffer-name)
(defvar magit-refresh-args)
(defvar magit-stash-buffer-name)
(defvar magit-status-buffer-name)
(defvar magit-this-process)
(defvar package-alist)
;;;; Compatibility
(eval-and-compile
;; Added in Emacs 24.3
(unless (fboundp 'user-error)
(defalias 'user-error 'error))
;; Added in Emacs 24.3 (mirrors/emacs@b335efc3).
(unless (fboundp 'setq-local)
(defmacro setq-local (var val)
"Set variable VAR to value VAL in current buffer."
(list 'set (list 'make-local-variable (list 'quote var)) val)))
;; Added in Emacs 24.3 (mirrors/emacs@b335efc3).
(unless (fboundp 'defvar-local)
(defmacro defvar-local (var val &optional docstring)
"Define VAR as a buffer-local variable with default value VAL.
Like `defvar' but additionally marks the variable as being automatically
buffer-local wherever it is set."
(declare (debug defvar) (doc-string 3))
(list 'progn (list 'defvar var val docstring)
(list 'make-variable-buffer-local (list 'quote var)))))
;; Added in Emacs 24.1
(unless (fboundp 'run-hook-wrapped)
(defun run-hook-wrapped-1 (hook fns wrap-function &rest args)
(cl-loop for fn in fns
if (and (eq fn t)
(local-variable-p hook)
(default-boundp hook)
(apply 'run-hook-wrapped-1 nil
(default-value hook) wrap-function args))
return it
else if (and (functionp fn) (apply wrap-function fn args))
return it))
(defun run-hook-wrapped (hook wrap-function &rest args)
"Run HOOK, passing each function through WRAP-FUNCTION.
I.e. instead of calling each function FUN directly with arguments ARGS,
it calls WRAP-FUNCTION with arguments FUN and ARGS.
As soon as a call to WRAP-FUNCTION returns non-nil, `run-hook-wrapped'
aborts and returns that value."
(when (boundp hook)
(let ((fns (symbol-value hook)))
(apply 'run-hook-wrapped-1 hook
(if (functionp fns) (list fns) fns)
wrap-function args)))))
)
;;; Settings
;;;; Custom Groups
(defgroup magit nil
"Controlling Git from Emacs."
:group 'tools)
(defgroup magit-process nil
"Git and other external processes used by Magit."
:group 'magit)
(defgroup magit-modes nil
"Modes provided by Magit."
:group 'magit)
(defgroup magit-status nil
"Inspect and manipulate Git repositories."
:group 'magit-modes)
(defgroup magit-diff nil
"Inspect and manipulate Git diffs."
:group 'magit-modes)
(defgroup magit-commit nil
"Inspect and manipulate Git commits."
:group 'magit-modes)
(defgroup magit-log nil
"Inspect and manipulate Git history."
:group 'magit-modes)
(defgroup magit-extensions nil
"Extensions to Magit."
:group 'magit)
(defgroup magit-faces nil
"Faces used by Magit."
:group 'magit
:group 'faces)
(when (featurep 'gitattributes-mode)
(custom-add-to-group 'magit-modes 'gitattributes-mode 'custom-group))
(when (featurep 'git-commit-mode)
(custom-add-to-group 'magit-modes 'git-commit 'custom-group)
(custom-add-to-group 'magit-faces 'git-commit-faces 'custom-group))
(when (featurep 'git-rebase-mode)
(custom-add-to-group 'magit-modes 'git-rebase 'custom-group)
(custom-add-to-group 'magit-faces 'git-rebase-faces 'custom-group))
(custom-add-to-group 'magit 'vc-follow-symlinks 'custom-variable)
;;;; Custom Options
;;;;; Processes
(defcustom magit-git-executable
(or (and (eq system-type 'windows-nt)
;; On Windows asking for "git" from $PATH might also return
;; a "git.exe" or "git.cmd". Using "bin/git.exe" directly
;; is faster than using one of the wrappers "cmd/git.exe"
;; or "cmd/git.cmd". The wrappers are likely to come
;; earlier on $PATH, and so we have to exlicitly use
;; the former.
(let ((exe (executable-find "git.exe")))
(when exe
(let ((alt (directory-file-name (file-name-directory exe))))
(if (and (equal (file-name-nondirectory alt) "cmd")
(setq alt (expand-file-name
(convert-standard-filename "bin/git.exe")
(file-name-directory alt)))
(file-executable-p alt))
alt
exe)))))
;; When the only cost is finding the executable, then it it
;; better not to cache the full path. It might not be installed
;; in the same location on machines whose repositories are
;; accessed using Tramp.
"git")
"The Git executable used by Magit."
:group 'magit-process
:type 'string)
(defcustom magit-git-standard-options
'("--no-pager" "-c" "core.preloadindex=true")
"Standard options when running Git.
Be careful what you add here, especially if you are using
tramp to connect to servers with ancient Git versions."
:group 'magit-process
:type '(repeat string))
(defcustom magit-gitk-executable
(or (and (eq system-type 'windows-nt)
(let ((exe (expand-file-name
"gitk" (file-name-nondirectory magit-git-executable))))
(and (file-executable-p exe) exe)))
(executable-find "gitk") "gitk")
"The Gitk executable."
:group 'magit-process
:set-after '(magit-git-executable)
:type 'string)
(defun magit-locate-emacsclient ()
"Search for a suitable Emacsclient executable."
(let ((path (cl-copy-list exec-path)) fixup client)
(when invocation-directory
(setq path (cons (directory-file-name invocation-directory) path))
(when (eq system-type 'darwin)
(setq fixup (expand-file-name "bin" invocation-directory))
(when (file-directory-p fixup)
(push fixup path))
(when (string-match "^Emacs-\\(powerpc\\|i386\\|x86_64\\)-\\(.+\\)"
invocation-name)
(setq fixup (expand-file-name
(format "bin-%s-%s"
(match-string 1 invocation-name)
(match-string 2 invocation-name))
invocation-directory))
(when (file-directory-p fixup)
(push fixup path)))
(when (string-match-p "Cellar" invocation-directory)
(setq fixup (expand-file-name "../../../bin" invocation-directory))
(when (file-directory-p fixup)
(push fixup path))))
(setq path (delete-dups path)))
(setq client (magit-locate-emacsclient-1 path 3))
(if client
(shell-quote-argument client)
(display-warning 'magit (format "\
Cannot determine a suitable Emacsclient
Determining an Emacsclient executable suitable for the
current Emacs instance failed. For more information
please see https://github.com/magit/magit/wiki/Emacsclient."))
nil)))
(defun magit-take (n l) ; until we get to use `-take' from dash
(let (r) (dotimes (_ n) (and l (push (pop l) r))) (nreverse r)))
(defun magit-locate-emacsclient-1 (path depth)
(let* ((version-lst (magit-take depth (split-string emacs-version "\\.")))
(version-reg (concat "^" (mapconcat #'identity version-lst "\\."))))
(or (locate-file-internal
"emacsclient" path
(cl-mapcan
(lambda (v) (cl-mapcar (lambda (e) (concat v e)) exec-suffixes))
(nconc (cl-mapcon (lambda (v)
(setq v (mapconcat #'identity (reverse v) "."))
(list v (concat "-" v)))
(reverse version-lst))
(list "")))
(lambda (exec)
(ignore-errors
(string-match-p version-reg (magit-emacsclient-version exec)))))
(and (> depth 1)
(magit-locate-emacsclient-1 path (1- depth))))))
(defun magit-emacsclient-version (exec)
(cadr (split-string (car (process-lines exec "--version")))))
(defcustom magit-emacsclient-executable (magit-locate-emacsclient)
"The Emacsclient executable.
If the default is nil, or commiting or rebasing is somehow broken,
please see https://github.com/magit/magit/wiki/Emacsclient."
:package-version '(magit . "1.4.0")
:group 'magit-process
:type '(choice (string :tag "Executable")
(const :tag "Don't use Emacsclient" nil)))
(defcustom magit-process-connection-type (not (eq system-type 'cygwin))
"Connection type used for the git process.
If nil, use pipes: this is usually more efficient, and works on Cygwin.
If t, use ptys: this enables magit to prompt for passphrases when needed."
:group 'magit-process
:type '(choice (const :tag "pipe" nil)
(const :tag "pty" t)))
(defcustom magit-process-popup-time -1
"Popup the process buffer if a command takes longer than this many seconds."
:group 'magit-process
:type '(choice (const :tag "Never" -1)
(const :tag "Immediately" 0)
(integer :tag "After this many seconds")))
(defcustom magit-process-log-max 32
"Maximum number of sections to keep in a process log buffer.
When adding a new section would go beyond the limit set here,
then the older half of the sections are remove. Sections that
belong to processes that are still running are never removed."
:package-version '(magit . "1.4.0")
:group 'magit-process
:type 'integer)
(defcustom magit-process-quote-curly-braces
(and (eq system-type 'windows-nt)
(let ((case-fold-search t))
(string-match-p "cygwin" magit-git-executable))
t)
"Whether curly braces should be quoted when calling git.
This may be necessary when using Windows. On all other system
types this must always be nil.
We are not certain when quoting is needed, but it appears it is
needed when using Cygwin Git but not when using stand-alone Git.
The default value is set based on that assumptions. If this
turns out to be wrong you can customize this option but please
also comment on issue #816."
:package-version '(magit . "1.4.0")
:group 'magit-process
:set-after '(magit-git-executable)
:type 'boolean)
(defcustom magit-process-yes-or-no-prompt-regexp
" [\[(]\\([Yy]\\(?:es\\)?\\)[/|]\\([Nn]o?\\)[\])] ?[?:] ?$"
"Regexp matching Yes-or-No prompts of git and its subprocesses."
:package-version '(magit . "1.4.0")
:group 'magit-process
:type 'regexp)
(defcustom magit-process-password-prompt-regexps
'("^\\(Enter \\)?[Pp]assphrase\\( for \\(RSA \\)?key '.*'\\)?: ?$"
"^\\(Enter \\)?[Pp]assword\\( for '.*'\\)?: ?$"
"^.*'s password: ?$"
"^Yubikey for .*: ?$")
"List of regexps matching password prompts of git and its subprocesses."
:package-version '(magit . "1.4.0")
:group 'magit-process
:type '(repeat (regexp)))
(defcustom magit-process-username-prompt-regexps
'("^Username for '.*': ?$")
"List of regexps matching username prompts of git and its subprocesses."
:package-version '(magit . "1.4.0")
:group 'magit-process
:type '(repeat (regexp)))
(defconst magit-server-window-type
'(choice
(const :tag "Use selected window"
:match (lambda (widget value)
(not (functionp value)))
nil)
(function-item :tag "Display in new frame" switch-to-buffer-other-frame)
(function-item :tag "Use pop-to-buffer" pop-to-buffer)
(function :tag "Other function")))
(defcustom magit-server-window-for-commit 'pop-to-buffer
"Function used to select a window for displaying commit message buffers.
It should take one argument (a buffer) and display and select it.
A common value is `pop-to-buffer'. It can also be nil in which
case the selected window is used."
:package-version '(magit . "1.4.0")
:group 'magit-process
:type magit-server-window-type)
(defcustom magit-server-window-for-rebase server-window
"Function used to select a window for displaying interactive rebase buffers.
It should take one argument (a buffer) and display and select it.
A common value is `pop-to-buffer'. It can also be nil in which
case the selected window is used."
:package-version '(magit . "1.4.0")
:group 'magit-process
:set-after '(server-window)
:type magit-server-window-type)
;;;;; Staging
(defcustom magit-stage-all-confirm t
"Whether to require confirmation before staging all changes.
This reduces the risk of accidentally losing the index. If
nothing at all is staged yet, then always stage without requiring
confirmation, because it can be undone without the risk of losing
a carefully crafted index."
:package-version '(magit . "1.4.0")
:group 'magit
:type 'boolean)
(defcustom magit-unstage-all-confirm t
"Whether to require confirmation before unstaging all changes.
This reduces the risk of accidentally losing of the index. If
there are no staged changes at all, then always unstage without
confirmation, because it can be undone without the risk of losing
a carefully crafted index."
:package-version '(magit . "1.4.0")
:group 'magit
:type 'boolean)
(defcustom magit-revert-item-confirm t
"Whether to require confirmation before reverting hunks.
If you disable this, consider enabling `magit-revert-backup'
instead."
:group 'magit
:type 'boolean)
(defcustom magit-revert-backup nil
"Whether to backup a hunk before reverting it.
The hunk is stored in \".git/magit/reverted.diff\" and can be
applied using `magit-revert-undo'. Older hunks are available
in the same directory as numbered backup files and have to be
applied manually. Only individual hunks are backed up; when
a complete file is reverted (which requires confirmation) no
backup is created."
:package-version '(magit . "1.4.0")
:group 'magit
:type 'boolean)
(defcustom magit-save-some-buffers t
"Whether certain commands save modified buffers before running.
nil don't save buffers.
t ask which buffers to save.
`dontask' save all buffers without asking."
:group 'magit
:type '(choice (const :tag "Never" nil)
(const :tag "Ask" t)
(const :tag "Save without asking" dontask)))
(defcustom magit-save-some-buffers-predicate
'magit-save-buffers-predicate-tree-only
"A predicate function to decide whether to save a buffer.
Used by function `magit-save-some-buffers' when the variable of
the same name is non-nil."
:group 'magit
:type '(radio (function-item magit-save-buffers-predicate-tree-only)
(function-item magit-save-buffers-predicate-all)
(function :tag "Other")))
(defcustom magit-rewrite-inclusive t
"Whether magit includes the selected base commit in a rewrite operation.
t means both the selected commit as well as any subsequent
commits will be rewritten. This is magit's default behaviour,
equivalent to 'git rebase -i ${REV}~1'
A'---B'---C'---D'
^
nil means the selected commit will be literally used as 'base',
so only subsequent commits will be rewritten. This is consistent
with git-rebase, equivalent to 'git rebase -i ${REV}', yet more
cumbersome to use from the status buffer.
A---B'---C'---D'
^"
:group 'magit
:type '(choice (const :tag "Always" t)
(const :tag "Never" nil)
(const :tag "Ask" ask)))
;;;;; Highlighting
(defun magit-set-variable-and-refresh (symbol value)
"Set SYMBOL to VALUE and call `magit-refresh-all'."
(set-default symbol value)
;; If magit isn't fully loaded yet no buffer that might
;; need refreshing can exist and we can take a shortcut.
;; We also don't want everything to repeatedly refresh
;; when evaluating this file.
(when (and (featurep 'magit) (not buffer-file-name))
(magit-refresh-all)))
(defcustom magit-highlight-whitespace t
"Specify where to highlight whitespace errors.
See `magit-highlight-trailing-whitespace',
`magit-highlight-indentation'. The symbol t means in all diffs,
`status' means only in the status buffer, and nil means nowhere."
:group 'magit
:set 'magit-set-variable-and-refresh
:type '(choice (const :tag "Always" t)
(const :tag "Never" nil)
(const :tag "In status buffer" status)))
(defcustom magit-highlight-trailing-whitespace t
"Whether to highlight whitespace at the end of a line in diffs.
Used only when `magit-highlight-whitespace' is non-nil."
:group 'magit
:set 'magit-set-variable-and-refresh
:type 'boolean)
(defcustom magit-highlight-indentation nil
"Highlight the \"wrong\" indentation style.
Used only when `magit-highlight-whitespace' is non-nil.
The value is a list of cons cells. The car is a regular
expression, and the cdr is the value that applies to repositories
whose directory matches the regular expression. If more than one
item matches, then the *last* item in the list applies. So, the
default value should come first in the list.
If the value is `tabs', highlight indentation with tabs. If the
value is an integer, highlight indentation with at least that
many spaces. Otherwise, highlight neither."
:group 'magit
:set 'magit-set-variable-and-refresh
:type `(repeat (cons (string :tag "Directory regexp")
(choice (const :tag "Tabs" tabs)
(integer :tag "Spaces" :value ,tab-width)
(const :tag "Neither" nil))))) ;^FIXME
(defcustom magit-item-highlight-face 'magit-item-highlight
"The face used to highlight the current section.
By default the highlighting of the current section is done using
the background color specified by face `magit-item-highlight'.
If you don't want to use the background to do the highlighting,
this *might* by as easy as customizing that face. However if you
are using a theme, which in turn sets the background color of
that face then, due to limitations in face inheritance when using
themes, you might be forced to use another face.
Unfortunately it is only possible to override a face attribute,
set by a theme, but not to drop it entirely. This means that one
has to explicitly use the `default' background color, to make it
appear *as if* the background wasn't used.
One reason you might want to *not* use the background, is that
doing so forces the use of overlays for parts of diffs and for
refnames. Using overlays potentially degrades performance when
generating large diffs. Also see option `magit-use-overlays'."
:package-version '(magit . "1.4.0")
:group 'magit
:group 'magit-faces
:type '(choice (const magit-item-highlight)
(const bold)
(face :tag "Other face")
(const :tag "Don't highlight" nil)))
(defcustom magit-use-overlays
(not (eq magit-item-highlight-face 'bold))
"Whether to use overlays to highlight various diff components.
This has to be non-nil if the current section is highlighted by
changing the background color. Otherwise background colors that
hold semantic meaning, like that of the added and removed lines
in diffs, as well as section headings, would be shadowed by the
highlighting.
To select the face used for highlighting customize the option
`magit-item-highlight-face'. If you set that to `bold' or some
other face that does not use the background then you can set this
option to nil. Doing so could potentially improve performance
when generating large diffs."
:package-version '(magit . "1.4.0")
:group 'magit
:group 'magit-faces
:set-after '(magit-item-highlight-face)
:type 'boolean)
(define-obsolete-variable-alias 'magit-diff-use-overlays
'magit-use-overlays "1.4.0")
;;;;; Completion
(defcustom magit-completing-read-function 'magit-builtin-completing-read
"Function to be called when requesting input from the user."
:group 'magit
:type '(radio (function-item magit-ido-completing-read)
(function-item magit-builtin-completing-read)
(function :tag "Other")))
(defcustom magit-remote-ref-format 'remote-slash-branch
"How to format refs when autocompleting, in particular for remotes.
Autocompletion is used by functions like `magit-checkout',
`magit-interactive-rebase' and others which offer branch name
completion.
`remote-slash-branch' Format refs as \"remote/branch\".
`branch-then-remote' Format refs as \"branch (remote)\"."
:package-version '(magit . "1.4.0")
:group 'magit
:type '(choice (const :tag "branch (remote)" branch-then-remote)
(const :tag "remote/branch" remote-slash-branch)))
(defcustom magit-repo-dirs nil
"Directories containing Git repositories.
Magit will look into these directories for Git repositories and
offer them as choices for `magit-status'."
:group 'magit
:type '(repeat directory))
(defcustom magit-repo-dirs-depth 3
"The maximum depth to look for Git repos.
When looking for a Git repository below the directories in
`magit-repo-dirs', Magit will only descend this many levels
deep."
:group 'magit
:type 'integer)
;;;;; Modes
;;;;;; Common
(defcustom magit-mode-hook nil
"Hook run when entering a Magit mode derived mode."
:options '(magit-load-config-extensions)
:group 'magit-modes
:type 'hook)
(defcustom magit-show-xref-buttons '(magit-diff-mode magit-commit-mode)
"List of modes whose buffers should contain history buttons.
Currently only `magit-diff-mode' and `magit-commit-mode' are
supported."
:package-version '(magit . "1.4.0")
:group 'magit-modes
:type '(repeat (choice (const magit-diff-mode)
(const magit-commit-mode))))
(defcustom magit-show-child-count nil
"Whether to append the number of childen to section headings."
:package-version '(magit . "1.4.0")
:group 'magit-modes
:type 'boolean)
(defvar magit-status-line-align-to 9)
(defcustom magit-restore-window-configuration nil
"Whether quitting a Magit buffer restores previous window configuration.
Function `magit-mode-display-buffer' is used to display and
select Magit buffers. Unless the buffer was already displayed in
a window of the selected frame it also stores the previous window
configuration. If this option is non-nil that configuration will
later be restored by `magit-mode-quit-window', provided the
buffer has not since been displayed in another frame.
This works best when only two windows are usually displayed in a
frame. If this isn't the case setting this to t might often lead
to undesirable behaviour. Also quitting a Magit buffer while
another Magit buffer that was created earlier is still displayed
will cause that buffer to be hidden, which might or might not be
what you want."
:package-version '(magit . "1.4.0")
:group 'magit-modes
:type 'boolean)
(defcustom magit-refs-namespaces
'(("^\\(HEAD\\)$" magit-log-head-label-head nil)
("^refs/tags/\\(.+\\)" magit-log-head-label-tags nil)
("^refs/heads/\\(.+\\)" magit-log-head-label-local nil)
("^refs/remotes/\\(.+\\)" magit-log-head-label-remote nil)
("^refs/bisect/\\(bad\\)" magit-log-head-label-bisect-bad nil)
("^refs/bisect/\\(skip.*\\)" magit-log-head-label-bisect-skip nil)
("^refs/bisect/\\(good.*\\)" magit-log-head-label-bisect-good nil)
("^refs/wip/\\(.+\\)" magit-log-head-label-wip nil)
("^refs/patches/\\(.+\\)" magit-log-head-label-patches nil)
("^\\(bad\\):" magit-log-head-label-bisect-bad nil)
("^\\(skip\\):" magit-log-head-label-bisect-skip nil)
("^\\(good\\):" magit-log-head-label-bisect-good nil)
("\\(.+\\)" magit-log-head-label-default nil))
"How different refs should be formatted for display.
Each entry controls how a certain type of ref is displayed, and
has the form (REGEXP FACE FORMATTER). REGEXP is a regular
expression used to match full refs. The first entry whose REGEXP
matches the reference is used. The first regexp submatch becomes
the \"label\" that represents the ref and is propertized with
font FONT. If FORMATTER is non-nil it should be a function that
takes two arguments, the full ref and the face. It is supposed
to return a propertized label that represents the ref.
Currently this variable is only used in logs and the branch
manager but it will be used in more places in the future."
:package-version '(magit . "1.4.0")
:group 'magit-modes
:type '(repeat
(list regexp
face
(choice (const :tag "first submatch is label" nil)
(function :tag "format using function")))))
;;;;;; Status
(defcustom magit-status-mode-hook nil
"Hook run when the `magit-status' buffer is created."
:group 'magit-status
:type 'hook)
(defcustom magit-status-sections-hook
'(magit-insert-status-local-line
magit-insert-status-remote-line
magit-insert-status-head-line
magit-insert-status-tags-line
magit-insert-status-merge-line
magit-insert-status-rebase-lines
magit-insert-empty-line
magit-insert-rebase-sequence
magit-insert-bisect-output
magit-insert-bisect-rest
magit-insert-bisect-log
magit-insert-stashes
magit-insert-untracked-files
magit-insert-pending-commits
magit-insert-unstaged-changes
magit-insert-staged-changes
magit-insert-unpulled-commits
magit-insert-unpushed-commits)
"Hook run to insert sections into the status buffer.
This option allows reordering the sections and adding sections
that are by default displayed in other Magit buffers. Doing the
latter is currently not recommended because not all functions
that insert sections have been adapted yet. Only inserters that
take no argument can be used and some functions exist that begin
with the `magit-insert-' prefix but do not insert a section.
Note that there are already plans to improve this and to add
similar hooks for other Magit modes."
:package-version '(magit . "1.4.0")
:group 'magit-status
:type 'hook)
(defcustom magit-status-buffer-switch-function 'pop-to-buffer
"Function for `magit-status' to use for switching to the status buffer.
The function is given one argument, the status buffer."
:group 'magit-status
:type '(radio (function-item switch-to-buffer)
(function-item pop-to-buffer)
(function :tag "Other")))
(defcustom magit-status-show-sequence-help t
"Whether to show instructions on how to proceed a stopped action.
When this is non-nil and a commit failed to apply during a merge
or rebase, then show instructions on how to continue."
:package-version '(magit . "1.4.0")
:group 'magit-status
:type 'boolean)
(defcustom magit-status-tags-line-subject 'head
"Whether tag or head is the subject on tags line in status buffer.
This controls how the words \"ahead\" and \"behind\" are used on
the tags line in the status buffer. The tags line does not
actually display complete sentences, but when thinking about when
to use which term, it helps imagining it did. This option
controls whether the tag names should be considered the subjects
or objects in these sentences.
`tag' The previous tag is *behind* HEAD by N commits.
The next tag is *ahead* of HEAD by N commits.
`head' HEAD is *ahead* of the previous tag by N commits.
HEAD is *behind* the next tag by N commits.
If the value is `tag' the commit counts are fontified; otherwise
they are not (due to semantic considerations)."
:package-version '(magit . "1.4.0")
:group 'magit-status
:type '(choice (const :tag "tags are the subjects" tag)
(const :tag "head is the subject" head)))
;;;;;; Diff
(defun magit-set-default-diff-options (symbol value)
"Set the default for `magit-diff-options' based on popup value.
Also set the local value in all Magit buffers and refresh them.
\n(fn)" ; The arguments are an internal implementation detail.
(interactive (list 'magit-diff-options magit-custom-options))
(set-default symbol value)
(when (and (featurep 'magit) (not buffer-file-name))
(dolist (buffer (buffer-list))
(when (derived-mode-p 'magit-mode)
(with-current-buffer buffer
(with-no-warnings
(setq-local magit-diff-options value))
(magit-mode-refresh-buffer))))))
(defcustom magit-diff-options nil
"Git options used to display diffs.
For more information about the options see man:git-diff.
This variable can be conveniently set in Magit buffers
using `magit-key-mode-popup-diff-options' (bound to \
\\<magit-mode-map>\\[magit-key-mode-popup-diff-options]).
Please note that not all of these options are supported by older
versions of Git, which could become a problem if you use tramp to
access repositories on a system with such a version. If you see
whitespace where you would have expected a diff, this likely is
the cause, and the only (currently) workaround is to not make the
problematic option a member of the default value."
:package-version '(magit . "1.4.0")
:group 'magit-diff
:set 'magit-set-default-diff-options
:type '(set :greedy t
(const :tag
"--minimal Show smallest possible diff"
"--minimal")
(const :tag
"--patience Use patience diff algorithm"
"--patience")
(const :tag
"--histogram Use histogram diff algorithm"
"--histogram")
(const :tag
"--ignore-space-change Ignore whitespace changes"
"--ignore-space-change")
(const :tag
"--ignore-all-space Ignore all whitespace"
"--ignore-all-space")
(const :tag
"--function-context Show surrounding functions"
"--function-context")))
(put 'magit-diff-options 'permanent-local t)
(defcustom magit-show-diffstat t
"Whether to show diffstat in diff and commit buffers."
:package-version '(magit . "1.4.0")
:group 'magit-diff
:group 'magit-commit
:type 'boolean)
(defcustom magit-diff-refine-hunk nil
"Show fine (word-granularity) differences within diff hunks.
There are three possible settings:
nil never show fine differences
t show fine differences for the selected diff hunk only
`all' show fine differences for all displayed diff hunks"
:group 'magit-diff
:type '(choice (const :tag "Never" nil)
(const :tag "Selected only" t)
(const :tag "All" all))
:set 'magit-set-variable-and-refresh)
;;;;;; Commit
(defcustom magit-commit-ask-to-stage t
"Whether to ask to stage everything when committing and nothing is staged."
:package-version '(magit . "1.4.0")
:group 'magit-commit
:type 'boolean)
(defcustom magit-commit-extend-override-date nil
"Whether using `magit-commit-extend' changes the committer date."
:package-version '(magit . "1.4.0")
:group 'magit-commit
:type 'boolean)
(defcustom magit-commit-reword-override-date nil
"Whether using `magit-commit-reword' changes the committer date."
:package-version '(magit . "1.4.0")
:group 'magit-commit
:type 'boolean)
(defcustom magit-commit-squash-commit nil
"Whether to target the marked or current commit when squashing.
When this is nil then the command `magit-commit-fixup' and
`magit-commit-squash' always require that the user explicitly
selects a commit. This is also the case when these commands are
used with a prefix argument, in which case this option is ignored.
Otherwise this controls which commit to target, either the
current or marked commit. Or if both can be used, which should
be preferred."
:package-version '(magit . "1.4.0")
:group 'magit-commit
:type
'(choice
(const :tag "Always prompt" nil)
(const :tag "Prefer current commit, else use marked" current-or-marked)
(const :tag "Prefer marked commit, else use current" marked-or-current)
(const :tag "Use current commit, if any" current)
(const :tag "Use marked commit, if any" marked)))
(defcustom magit-expand-staged-on-commit nil
"Whether to expand staged changes when creating a commit.
When this is non-nil and the current buffer is the status buffer
expand the section containing staged changes. If this is `full'
always expand all subsections; if it is t subsections that were
previously hidden remain hidden.
In the event that expanding very large patches takes a long time
\\<global-map>\\[keyboard-quit] can be used to abort that step.
This is especially useful when you would normally not look at the
changes, e.g. because you are committing some binary files."
:package-version '(magit . "1.4.0")
:group 'magit-commit
:type '(choice (const :tag "Expand all subsections" full)
(const :tag "Expand top section" t)
(const :tag "Don't expand" nil)))
;;;;;; Log
(defcustom magit-log-auto-more nil
"Insert more log entries automatically when moving past the last entry.
Only considered when moving past the last entry with
`magit-goto-*-section' commands."
:group 'magit-log
:type 'boolean)
(defcustom magit-log-cutoff-length 100
"The maximum number of commits to show in the log and whazzup buffers."
:group 'magit-log
:type 'integer)
(defcustom magit-log-infinite-length 99999
"Number of log used to show as maximum for `magit-log-cutoff-length'."
:group 'magit-log
:type 'integer)
(defcustom magit-log-format-graph-function nil
"Function used to format graphs in log buffers.
The function is called with one argument, the propertized graph
of a single line in as a string. It has to return the formatted
string. This option can also be nil, in which case the graph is
inserted as is."
:package-version '(magit . "1.4.0")
:group 'magit-log
:type '(choice (const :tag "insert as is" nil)
(function-item magit-log-format-unicode-graph)
function))
(defcustom magit-log-format-unicode-graph-alist
'((?/ . ?╱) (?| . ?│) (?\\ . ?╲) (?* . ?◆) (?o . ?◇))
"Alist used by `magit-log-format-unicode-graph' to translate chars."
:package-version '(magit . "1.4.0")
:group 'magit-log
:type '(repeat (cons :format "%v\n"
(character :format "replace %v ")
(character :format "with %v"))))
(defcustom magit-log-show-gpg-status nil
"Display signature verification information as part of the log."
:package-version '(magit . "1.4.0")
:group 'magit-log
:type 'boolean)
(defcustom magit-log-show-margin t
"Whether to use a margin when showing `oneline' logs.
When non-nil the author name and date are displayed in the margin
of the log buffer if that contains a `oneline' log. This can be
toggled temporarily using the command `magit-log-toggle-margin'."
:package-version '(magit . "1.4.0")
:group 'magit-log
:type 'boolean)
(put 'magit-log-show-margin 'permanent-local t)
(defcustom magit-log-margin-spec '(25 nil magit-duration-spec)
"How to format the margin for `oneline' logs.
When the log buffer contains a `oneline' log, then it optionally
uses the right margin to display the author name and author date.
This is also supported in the reflog buffer.
Logs that are shown together with other non-log information (e.g.
in the status buffer) are never accompanied by a margin. The
same applies to `long' logs, in this case because that would be
redundant.
This option controls how that margin is formatted, the other
option affecting this is `magit-log-show-margin'; if that is nil
then no margin is displayed at all. To toggle this temporarily
use the command `magit-log-show-margin'.
The value has the form (WIDTH CHARACTERP DURATION-SPEC). The
width of the margin is controlled using WIDTH, an integer. When
CHARACTERP is non-nil time units are shown as single characters,
otherwise the full name of the unit is displayed. DURATION-SPEC
has to be a variable, its value controls which time units are
used, how many seconds they contain, and what their names are."
:package-version '(magit . "1.4.0")
:group 'magit-log
:type '(list (integer :tag "Margin width")
(choice :tag "Time unit style"
(const :tag "Character" t)
(const :tag "Word" nil))
(variable :tag "Duration spec variable")))
(defcustom magit-duration-spec
`((?Y "year" "years" ,(round (* 60 60 24 365.2425)))
(?M "month" "months" ,(round (* 60 60 24 30.436875)))
(?w "week" "weeks" ,(* 60 60 24 7))
(?d "day" "days" ,(* 60 60 24))
(?h "hour" "hours" ,(* 60 60))
(?m "minute" "minutes" 60)
(?s "second" "seconds" 1))
"Units used to display durations in a human format.
The value is a list of time units, beginning with the longest.
Each element has the form ((CHAR UNIT UNITS SECONDS)..). UNIT
is the time unit, UNITS is the plural of that unit. CHAR is a
character that can be used as abbreviation and must be unique
amoung all elements. SECONDS is the number of seconds in one
UNIT. Also see option `magit-log-margin-spec'."
:package-version '(magit . "1.4.0")
:group 'magit-log
:type '(repeat (list (character :tag "Unit character")
(string :tag "Unit singular string")
(string :tag "Unit plural string")
(integer :tag "Seconds in unit"))))
(defcustom magit-ellipsis #x2026 ; "horizontal ellipsis"
"Character appended to abreviated text.
Currently this is used only in the log margin, but might later
be used elsewhere too. Filenames that were abbreviated by Git
are left as-is."
:package-version '(magit . "1.4.0")
:group 'magit-log
:type 'character)
;;;;;; Others
(defcustom magit-auto-revert-mode-lighter " MRev"
"String to display when Magit-Auto-Revert mode is active."
:group 'magit-modes)
(define-minor-mode magit-auto-revert-mode
"Toggle global Magit-Auto-Revert mode.
With prefix ARG, enable Magit-Auto-Revert mode if ARG is positive;
otherwise, disable it. If called from Lisp, enable the mode if
ARG is omitted or nil.
Magit-Auto-Revert mode is a global minor mode that, after Magit
has run a Git command, reverts buffers associated with files that
have changed on disk and are tracked in the current Git repository."
:group 'magit-modes
:lighter magit-auto-revert-mode-lighter
:global t
:init-value t)
(defcustom magit-merge-warn-dirty-worktree t
"Whether to issue a warning when attempting to start a merge in a dirty worktree."
:package-version '(magit . "1.4.0")
:group 'magit-modes
:type 'boolean)
(defcustom magit-push-hook '(magit-push-dwim)
"Hook run by `magit-push' to actually do the work.
See `magit-push' and `magit-push-dwim' for more information."
:package-version '(magit . "1.4.0")
:group 'magit-modes
:type 'hook)
(defcustom magit-set-upstream-on-push nil
"Whether `magit-push' may set upstream when pushing a branch.
This only applies if the branch does not have an upstream set yet.
nil don't use --set-upstream.
t ask if --set-upstream should be used.
`dontask' always use --set-upstream.
`refuse' refuse to push unless a remote branch has already been set."
:group 'magit-modes
:type '(choice (const :tag "Never" nil)
(const :tag "Ask" t)
(const :tag "Ask if not set" askifnotset)
(const :tag "Refuse" refuse)
(const :tag "Always" dontask)))
(defcustom magit-wazzup-sections-hook
'(magit-insert-wazzup-head-line
magit-insert-empty-line
magit-insert-wazzup-branches)
"Hook run to insert sections into the wazzup buffer."
:package-version '(magit . "1.4.0")
:group 'magit-modes
:type 'hook)
(defcustom magit-cherry-sections-hook
'(magit-insert-cherry-head-line
magit-insert-cherry-upstream-line
magit-insert-cherry-help-lines
magit-insert-empty-line
magit-insert-cherry-commits)
"Hook run to insert sections into the cherry buffer."
:package-version '(magit . "1.4.0")
:group 'magit-modes
:type 'hook)
;;;; Custom Faces
(defface magit-section-title
'((t :inherit header-line))
"Face for section titles."
:group 'magit-faces)
(defface magit-branch
'((((class color) (background light))
:background "Grey85"
:foreground "LightSkyBlue4")
(((class color) (background dark))
:background "Grey13"
:foreground "LightSkyBlue1"))
"Face for branches."
:group 'magit-faces)
(defface magit-tag
'((((class color) (background light))
:background "LemonChiffon1"
:foreground "goldenrod4")
(((class color) (background dark))
:background "LemonChiffon1"
:foreground "goldenrod4"))
"Face for tags."
:group 'magit-faces)
(defface magit-diff-file-header
'((t :inherit diff-file-header))
"Face for diff file header lines."
:group 'magit-faces)
(defface magit-diff-hunk-header
'((t :inherit diff-hunk-header))
"Face for diff hunk header lines."
:group 'magit-faces)
(defface magit-diff-add
'((t :inherit diff-added))
"Face for lines in a diff that have been added."
:group 'magit-faces)
(defface magit-diff-del
'((t :inherit diff-removed))
"Face for lines in a diff that have been deleted."
:group 'magit-faces)
(defface magit-diff-none
'((t :inherit diff-context))
"Face for lines in a diff that are unchanged."
:group 'magit-faces)
(defface magit-diff-merge-current
'((t :inherit font-lock-preprocessor-face))
"Face for merge conflict marker 'current' line."
:group 'magit-faces)
(defface magit-diff-merge-separator
'((t :inherit font-lock-preprocessor-face))
"Face for merge conflict marker seperator."
:group 'magit-faces)
(defface magit-diff-merge-diff3-separator
'((t :inherit font-lock-preprocessor-face))
"Face for merge conflict marker seperator."
:group 'magit-faces)
(defface magit-diff-merge-proposed
'((t :inherit font-lock-preprocessor-face))
"Face for merge conflict marker 'proposed' line."
:group 'magit-faces)
(defface magit-log-graph
'((((class color) (background light))
:foreground "grey11")
(((class color) (background dark))
:foreground "grey80"))
"Face for the graph element of the log output."
:group 'magit-faces)
(defface magit-log-sha1
'((((class color) (background light))
:foreground "firebrick")
(((class color) (background dark))
:foreground "tomato"))
"Face for the sha1 element of the log output."
:group 'magit-faces)
(defface magit-log-author
'((((class color) (background light))
:foreground "firebrick")
(((class color) (background dark))
:foreground "tomato"))
"Face for the author element of the log output."
:group 'magit-faces)
(defface magit-log-date
'((t))
"Face for the date element of the log output."
:group 'magit-faces)
(defface magit-log-message
'((t))
"Face for the message element of the log output."
:group 'magit-faces)
(defface magit-cherry-unmatched
'((t :foreground "cyan"))
"Face for unmatched cherry commits.")
(defface magit-cherry-equivalent
'((t :foreground "magenta"))
"Face for equivalent cherry commits.")
(defface magit-item-highlight
'((t :inherit secondary-selection))
"Face for highlighting the current item."
:group 'magit-faces)
(defface magit-item-mark
'((t :inherit highlight))
"Face for highlighting marked item."
:group 'magit-faces)
(defface magit-log-head-label-bisect-good
'((((class color) (background light))
:box t
:background "light green"
:foreground "dark olive green")
(((class color) (background dark))
:box t
:background "light green"
:foreground "dark olive green"))
"Face for good bisect refs."
:group 'magit-faces)
(defface magit-log-head-label-bisect-skip
'((((class color) (background light))
:box t
:background "light goldenrod"
:foreground "dark goldenrod")
(((class color) (background dark))
:box t
:background "light goldenrod"
:foreground "dark goldenrod"))
"Face for skipped bisect refs."
:group 'magit-faces)
(defface magit-log-head-label-bisect-bad
'((((class color) (background light))
:box t
:background "IndianRed1"
:foreground "IndianRed4")
(((class color) (background dark))
:box t
:background "IndianRed1"
:foreground "IndianRed4"))
"Face for bad bisect refs."
:group 'magit-faces)
(defface magit-log-head-label-remote
'((((class color) (background light))
:box t
:background "Grey85"
:foreground "OliveDrab4")
(((class color) (background dark))
:box t
:background "Grey11"
:foreground "DarkSeaGreen2"))
"Face for remote branch head labels shown in log buffer."
:group 'magit-faces)
(defface magit-log-head-label-tags
'((((class color) (background light))
:box t
:background "LemonChiffon1"
:foreground "goldenrod4")
(((class color) (background dark))
:box t
:background "LemonChiffon1"
:foreground "goldenrod4"))
"Face for tag labels shown in log buffer."
:group 'magit-faces)
(defface magit-log-head-label-patches
'((((class color) (background light))
:box t
:background "IndianRed1"
:foreground "IndianRed4")
(((class color) (background dark))
:box t
:background "IndianRed1"
:foreground "IndianRed4"))
"Face for Stacked Git patches."
:group 'magit-faces)
(defface magit-whitespace-warning-face
'((t :inherit trailing-whitespace))
"Face for highlighting whitespace errors in Magit diffs."
:group 'magit-faces)
(defface magit-log-head-label-local
'((((class color) (background light))
:box t
:background "Grey85"
:foreground "LightSkyBlue4")
(((class color) (background dark))
:box t
:background "Grey13"
:foreground "LightSkyBlue1"))
"Face for local branch head labels shown in log buffer."
:group 'magit-faces)
(defface magit-log-head-label-head
'((((class color) (background light))
:box t
:background "Grey70"
:foreground "Black")
(((class color) (background dark))
:box t
:background "Grey20"
:foreground "White"))
"Face for working branch head labels shown in log buffer."
:group 'magit-faces)
(defface magit-log-head-label-default
'((((class color) (background light))
:box t
:background "Grey50")
(((class color) (background dark))
:box t
:background "Grey50"))
"Face for unknown ref labels shown in log buffer."
:group 'magit-faces)
(defface magit-log-head-label-wip
'((((class color) (background light))
:box t
:background "Grey95"
:foreground "LightSkyBlue3")
(((class color) (background dark))
:box t
:background "Grey07"
:foreground "LightSkyBlue4"))
"Face for git-wip labels shown in log buffer."
:group 'magit-faces)
(defface magit-signature-good
'((t :foreground "green"))
"Face for good signatures."
:group 'magit-faces)
(defface magit-signature-bad
'((t :foreground "red"))
"Face for bad signatures."
:group 'magit-faces)
(defface magit-signature-untrusted
'((t :foreground "cyan"))
"Face for good untrusted signatures."
:group 'magit-faces)
(defface magit-signature-none
'((t :inherit magit-log-message))
"Face for unsigned commits."
:group 'magit-faces)
(defface magit-log-reflog-label-commit
'((((class color) (background light))
:box t
:background "LemonChiffon1"
:foreground "goldenrod4")
(((class color) (background dark))
:box t
:background "LemonChiffon1"
:foreground "goldenrod4"))
"Face for reflog subject labels shown in reflog buffer."
:group 'magit-faces)
(defface magit-log-reflog-label-amend
'((t :inherit magit-log-reflog-label-commit))
"Face for reflog subject labels shown in reflog buffer."
:group 'magit-faces)
(defface magit-log-reflog-label-merge
'((t :inherit magit-log-reflog-label-commit))
"Face for reflog subject labels shown in reflog buffer."
:group 'magit-faces)
(defface magit-log-reflog-label-checkout
'((((class color) (background light))
:box t
:background "Grey85"
:foreground "LightSkyBlue4")
(((class color) (background dark))
:box t
:background "Grey13"
:foreground "LightSkyBlue1"))
"Face for reflog subject labels shown in reflog buffer."
:group 'magit-faces)
(defface magit-log-reflog-label-reset
'((((class color) (background light))
:box t
:background "IndianRed1"
:foreground "IndianRed4")
(((class color) (background dark))
:box t
:background "IndianRed1"
:foreground "IndianRed4"))
"Face for reflog subject labels shown in reflog buffer."
:group 'magit-faces)
(defface magit-log-reflog-label-rebase
'((((class color) (background light))
:box t
:background "Grey85"
:foreground "OliveDrab4")
(((class color) (background dark))
:box t
:background "Grey11"
:foreground "DarkSeaGreen2"))
"Face for reflog subject labels shown in reflog buffer."
:group 'magit-faces)
(defface magit-log-reflog-label-cherry-pick
'((((class color) (background light))
:box t
:background "light green"
:foreground "dark olive green")
(((class color) (background dark))
:box t
:background "light green"
:foreground "dark olive green"))
"Face for reflog subject labels shown in reflog buffer."
:group 'magit-faces)
(defface magit-log-reflog-label-remote
'((((class color) (background light))
:box t
:background "Grey50")
(((class color) (background dark))
:box t
:background "Grey50"))
"Face for reflog subject labels shown in reflog buffer."
:group 'magit-faces)
(defface magit-log-reflog-label-other
'((((class color) (background light))
:box t
:background "Grey50")
(((class color) (background dark))
:box t
:background "Grey50"))
"Face for reflog subject labels shown in reflog buffer."
:group 'magit-faces)
(defface magit-process-ok
'((t :inherit magit-section-title
:foreground "green"))
"Face for zero exit-status."
:group 'magit-faces)
(defface magit-process-ng
'((t :inherit magit-section-title
:foreground "red"))
"Face for non-zero exit-status."
:group 'magit-faces)
;;;; Keymaps
;; Not an option to avoid advertising it.
(defvar magit-rigid-key-bindings nil
"Use rigid key bindings instead of thematic key popups.
If you enable this a lot of functionality is lost. You most
likely don't want that. This variable only has an effect if
set before loading libary `magit'.")
(when (boundp 'git-commit-mode-map)
(define-key git-commit-mode-map (kbd "C-c C-d") 'magit-diff-staged))
(defvar magit-mode-map
(let ((map (make-keymap)))
(suppress-keymap map t)
(define-key map (kbd "n") 'magit-goto-next-section)
(define-key map (kbd "p") 'magit-goto-previous-section)
(define-key map (kbd "^") 'magit-goto-parent-section)
(define-key map (kbd "M-n") 'magit-goto-next-sibling-section)
(define-key map (kbd "M-p") 'magit-goto-previous-sibling-section)
(define-key map (kbd "TAB") 'magit-toggle-section)
(define-key map (kbd "<backtab>") 'magit-expand-collapse-section)
(define-key map (kbd "1") 'magit-show-level-1)
(define-key map (kbd "2") 'magit-show-level-2)
(define-key map (kbd "3") 'magit-show-level-3)
(define-key map (kbd "4") 'magit-show-level-4)
(define-key map (kbd "M-1") 'magit-show-level-1-all)
(define-key map (kbd "M-2") 'magit-show-level-2-all)
(define-key map (kbd "M-3") 'magit-show-level-3-all)
(define-key map (kbd "M-4") 'magit-show-level-4-all)
(define-key map (kbd "M-h") 'magit-show-only-files)
(define-key map (kbd "M-H") 'magit-show-only-files-all)
(define-key map (kbd "M-s") 'magit-show-level-4)
(define-key map (kbd "M-S") 'magit-show-level-4-all)
(define-key map (kbd "g") 'magit-refresh)
(define-key map (kbd "G") 'magit-refresh-all)
(define-key map (kbd "?") 'magit-key-mode-popup-dispatch)
(define-key map (kbd ":") 'magit-git-command)
(define-key map (kbd "C-x 4 a") 'magit-add-change-log-entry-other-window)
(define-key map (kbd "L") 'magit-add-change-log-entry)
(define-key map (kbd "RET") 'magit-visit-item)
(define-key map (kbd "C-<return>") 'magit-dired-jump)
(define-key map (kbd "SPC") 'magit-show-item-or-scroll-up)
(define-key map (kbd "DEL") 'magit-show-item-or-scroll-down)
(define-key map (kbd "C-w") 'magit-copy-item-as-kill)
(cond (magit-rigid-key-bindings
(define-key map (kbd "c") 'magit-commit)
(define-key map (kbd "m") 'magit-merge)
(define-key map (kbd "b") 'magit-checkout)
(define-key map (kbd "M") 'magit-branch-manager)
(define-key map (kbd "r") 'undefined)
(define-key map (kbd "f") 'magit-fetch-current)
(define-key map (kbd "F") 'magit-pull)
(define-key map (kbd "J") 'magit-apply-mailbox)
(define-key map (kbd "!") 'magit-git-command-topdir)
(define-key map (kbd "P") 'magit-push)
(define-key map (kbd "t") 'magit-tag)
(define-key map (kbd "l") 'magit-log)
(define-key map (kbd "o") 'magit-submodule-update)
(define-key map (kbd "B") 'undefined)
(define-key map (kbd "z") 'magit-stash))
(t
(define-key map (kbd "c") 'magit-key-mode-popup-committing)
(define-key map (kbd "m") 'magit-key-mode-popup-merging)
(define-key map (kbd "b") 'magit-key-mode-popup-branching)
(define-key map (kbd "M") 'magit-key-mode-popup-remoting)
(define-key map (kbd "r") 'magit-key-mode-popup-rewriting)
(define-key map (kbd "f") 'magit-key-mode-popup-fetching)
(define-key map (kbd "F") 'magit-key-mode-popup-pulling)
(define-key map (kbd "J") 'magit-key-mode-popup-apply-mailbox)
(define-key map (kbd "!") 'magit-key-mode-popup-running)
(define-key map (kbd "P") 'magit-key-mode-popup-pushing)
(define-key map (kbd "t") 'magit-key-mode-popup-tagging)
(define-key map (kbd "l") 'magit-key-mode-popup-logging)
(define-key map (kbd "o") 'magit-key-mode-popup-submodule)
(define-key map (kbd "B") 'magit-key-mode-popup-bisecting)
(define-key map (kbd "z") 'magit-key-mode-popup-stashing)))
(define-key map (kbd "$") 'magit-process)
(define-key map (kbd "E") 'magit-interactive-rebase)
(define-key map (kbd "R") 'magit-rebase-step)
(define-key map (kbd "e") 'magit-ediff)
(define-key map (kbd "w") 'magit-wazzup)
(define-key map (kbd "y") 'magit-cherry)
(define-key map (kbd "q") 'magit-mode-quit-window)
(define-key map (kbd "x") 'magit-reset-head)
(define-key map (kbd "v") 'magit-revert-item)
(define-key map (kbd "a") 'magit-apply-item)
(define-key map (kbd "A") 'magit-cherry-pick-item)
(define-key map (kbd "d") 'magit-diff-working-tree)
(define-key map (kbd "D") 'magit-diff)
(define-key map (kbd "-") 'magit-diff-smaller-hunks)
(define-key map (kbd "+") 'magit-diff-larger-hunks)
(define-key map (kbd "0") 'magit-diff-default-hunks)
(define-key map (kbd "h") 'magit-key-mode-popup-diff-options)
(define-key map (kbd "H") 'magit-diff-toggle-refine-hunk)
(define-key map (kbd "S") 'magit-stage-all)
(define-key map (kbd "U") 'magit-unstage-all)
(define-key map (kbd "X") 'magit-reset-working-tree)
(define-key map (kbd "C-c C-c") 'magit-key-mode-popup-dispatch)
(define-key map (kbd "C-c C-e") 'magit-key-mode-popup-dispatch)
map)
"Parent keymap for all keymaps of modes derived from `magit-mode'.")
(defvar magit-commit-mode-map
(let ((map (make-sparse-keymap)))
(set-keymap-parent map magit-mode-map)
(define-key map (kbd "C-c C-b") 'magit-go-backward)
(define-key map (kbd "C-c C-f") 'magit-go-forward)
(define-key map (kbd "SPC") 'scroll-up)
(define-key map (kbd "DEL") 'scroll-down)
(define-key map (kbd "j") 'magit-jump-to-diffstats)
map)
"Keymap for `magit-commit-mode'.")
(defvar magit-status-mode-map
(let ((map (make-sparse-keymap)))
(set-keymap-parent map magit-mode-map)
(define-key map (kbd "s") 'magit-stage-item)
(define-key map (kbd "u") 'magit-unstage-item)
(define-key map (kbd "i") 'magit-ignore-item)
(define-key map (kbd "I") 'magit-ignore-item-locally)
(define-key map (kbd "j") 'magit-section-jump-map)
(define-key map (kbd ".") 'magit-mark-item)
(define-key map (kbd "=") 'magit-diff-with-mark)
(define-key map (kbd "k") 'magit-discard-item)
(define-key map (kbd "C") 'magit-commit-add-log)
map)
"Keymap for `magit-status-mode'.")
(eval-after-load 'dired-x
'(define-key magit-status-mode-map [remap dired-jump] 'magit-dired-jump))
(defvar magit-log-mode-map
(let ((map (make-sparse-keymap)))
(set-keymap-parent map magit-mode-map)
(define-key map (kbd ".") 'magit-mark-item)
(define-key map (kbd "=") 'magit-diff-with-mark)
(define-key map (kbd "e") 'magit-log-show-more-entries)
(define-key map (kbd "h") 'magit-log-toggle-margin)
map)
"Keymap for `magit-log-mode'.")
(defvar magit-cherry-mode-map
(let ((map (make-sparse-keymap)))
(set-keymap-parent map magit-mode-map)
map)
"Keymap for `magit-cherry-mode'.")
(defvar magit-reflog-mode-map
(let ((map (make-sparse-keymap)))
(set-keymap-parent map magit-log-mode-map)
map)
"Keymap for `magit-reflog-mode'.")
(defvar magit-diff-mode-map
(let ((map (make-sparse-keymap)))
(set-keymap-parent map magit-mode-map)
(define-key map (kbd "C-c C-b") 'magit-go-backward)
(define-key map (kbd "C-c C-f") 'magit-go-forward)
(define-key map (kbd "SPC") 'scroll-up)
(define-key map (kbd "DEL") 'scroll-down)
(define-key map (kbd "j") 'magit-jump-to-diffstats)
map)
"Keymap for `magit-diff-mode'.")
(defvar magit-wazzup-mode-map
(let ((map (make-sparse-keymap)))
(set-keymap-parent map magit-mode-map)
(define-key map (kbd ".") 'magit-mark-item)
(define-key map (kbd "=") 'magit-diff-with-mark)
(define-key map (kbd "i") 'magit-ignore-item)
map)
"Keymap for `magit-wazzup-mode'.")
(defvar magit-branch-manager-mode-map
(let ((map (make-sparse-keymap)))
(set-keymap-parent map magit-mode-map)
(define-key map (kbd "c") 'magit-create-branch)
(define-key map (kbd "a") 'magit-add-remote)
(define-key map (kbd "r") 'magit-rename-item)
(define-key map (kbd "k") 'magit-discard-item)
(define-key map (kbd "T") 'magit-change-what-branch-tracks)
map)
"Keymap for `magit-branch-manager-mode'.")
(defvar magit-process-mode-map
(let ((map (make-sparse-keymap)))
(set-keymap-parent map magit-mode-map)
map)
"Keymap for `magit-process-mode'.")
(defvar magit-section-jump-map
(let ((map (make-sparse-keymap)))
(define-key map (kbd "z") 'magit-jump-to-stashes)
(define-key map (kbd "n") 'magit-jump-to-untracked)
(define-key map (kbd "u") 'magit-jump-to-unstaged)
(define-key map (kbd "s") 'magit-jump-to-staged)
(define-key map (kbd "f") 'magit-jump-to-unpulled)
(define-key map (kbd "p") 'magit-jump-to-unpushed)
(define-key map (kbd "r") 'magit-jump-to-pending)
map)
"Submap for jumping to sections in `magit-status-mode'.")
(fset 'magit-section-jump-map magit-section-jump-map)
(easy-menu-define magit-mode-menu magit-mode-map
"Magit menu"
'("Magit"
["Refresh" magit-refresh t]
["Refresh all" magit-refresh-all t]
"---"
["Stage" magit-stage-item t]
["Stage all" magit-stage-all t]
["Unstage" magit-unstage-item t]
["Unstage all" magit-unstage-all t]
["Commit" magit-key-mode-popup-committing t]
["Add log entry" magit-commit-add-log t]
["Tag" magit-tag t]
"---"
["Diff working tree" magit-diff-working-tree t]
["Diff" magit-diff t]
("Log"
["Short Log" magit-log t]
["Long Log" magit-log-long t]
["Reflog" magit-reflog t]
["Extended..." magit-key-mode-popup-logging t])
"---"
["Cherry pick" magit-cherry-pick-item t]
["Apply" magit-apply-item t]
["Revert" magit-revert-item t]
"---"
["Ignore" magit-ignore-item t]
["Ignore locally" magit-ignore-item-locally t]
["Discard" magit-discard-item t]
["Reset head" magit-reset-head t]
["Reset working tree" magit-reset-working-tree t]
["Stash" magit-stash t]
["Snapshot" magit-stash-snapshot t]
"---"
["Branch..." magit-checkout t]
["Merge" magit-merge t]
["Interactive resolve" magit-interactive-resolve t]
["Rebase" magit-rebase-step t]
("Rewrite"
["Start" magit-rewrite-start t]
["Stop" magit-rewrite-stop t]
["Finish" magit-rewrite-finish t]
["Abort" magit-rewrite-abort t]
["Set used" magit-rewrite-set-used t]
["Set unused" magit-rewrite-set-unused t])
"---"
["Push" magit-push t]
["Pull" magit-pull t]
["Remote update" magit-remote-update t]
("Submodule"
["Submodule update" magit-submodule-update t]
["Submodule update and init" magit-submodule-update-init t]
["Submodule init" magit-submodule-init t]
["Submodule sync" magit-submodule-sync t])
"---"
("Extensions")
"---"
["Display Git output" magit-process t]
["Quit Magit" magit-mode-quit-window t]))
;;; Utilities (1)
;;;; Minibuffer Input
(defun magit-ido-completing-read
(prompt choices &optional predicate require-match initial-input hist def)
"ido-based completing-read almost-replacement."
(require 'ido)
(let ((reply (ido-completing-read
prompt
(if (consp (car choices))
(mapcar #'car choices)
choices)
predicate require-match initial-input hist def)))
(or (and (consp (car choices))
(cdr (assoc reply choices)))
reply)))
(defun magit-builtin-completing-read
(prompt choices &optional predicate require-match initial-input hist def)
"Magit wrapper for standard `completing-read' function."
(let ((reply (completing-read
(if (and def (> (length prompt) 2)
(string-equal ": " (substring prompt -2)))
(format "%s (default %s): " (substring prompt 0 -2) def)
prompt)
choices predicate require-match initial-input hist def)))
(if (string= reply "")
(if require-match
(user-error "Nothing selected")
nil)
reply)))
(defun magit-completing-read
(prompt collection &optional predicate require-match initial-input hist def)
"Call function in `magit-completing-read-function' to read user input.
Read `completing-read' documentation for the meaning of the argument."
(funcall magit-completing-read-function
(concat prompt ": ") collection predicate
require-match initial-input hist def))
(defvar magit-gpg-secret-key-hist nil)
(defun magit-read-gpg-secret-key (prompt)
(let ((keys (mapcar
(lambda (key)
(list (epg-sub-key-id (car (epg-key-sub-key-list key)))
(let ((id-obj (car (epg-key-user-id-list key)))
(id-str nil))
(when id-obj
(setq id-str (epg-user-id-string id-obj))
(if (stringp id-str)
id-str
(epg-decode-dn id-obj))))))
(epg-list-keys (epg-make-context epa-protocol) nil t))))
(magit-completing-read prompt keys nil nil nil 'magit-gpg-secret-key-hist
(car (or magit-gpg-secret-key-hist keys)))))
;;;; Various Utilities
(defmacro magit-bind-match-strings (varlist &rest body)
(declare (indent 1))
(let ((i 0))
`(let ,(mapcar (lambda (var)
(list var (list 'match-string (cl-incf i))))
varlist)
,@body)))
(defun magit-file-line (file)
"Return the first line of FILE as a string."
(when (file-regular-p file)
(with-temp-buffer
(insert-file-contents file)
(buffer-substring-no-properties (point-min)
(line-end-position)))))
(defun magit-file-lines (file &optional keep-empty-lines)
"Return a list of strings containing one element per line in FILE.
Unless optional argument KEEP-EMPTY-LINES is t, trim all empty lines."
(when (file-regular-p file)
(with-temp-buffer
(insert-file-contents file)
(split-string (buffer-string) "\n" (not keep-empty-lines)))))
(defvar-local magit-file-name ()
"Name of file the buffer shows a different version of.")
(defun magit-buffer-file-name (&optional relative)
(let* ((topdir (magit-get-top-dir))
(filename (or buffer-file-name
(when (buffer-base-buffer)
(with-current-buffer (buffer-base-buffer)
buffer-file-name))
(when magit-file-name
(expand-file-name magit-file-name topdir)))))
(when filename
(setq filename (file-truename filename))
(if relative
(file-relative-name filename topdir)
filename))))
(defun magit-format-duration (duration spec width)
(cl-destructuring-bind (char unit units weight)
(car spec)
(let ((cnt (round (/ duration weight 1.0))))
(if (or (not (cdr spec))
(>= (/ duration weight) 1))
(if (= width 1)
(format "%3i%c" cnt char)
(format (format "%%3i %%-%is" width) cnt
(if (= cnt 1) unit units)))
(magit-format-duration duration (cdr spec) width)))))
(defun magit-flatten-onelevel (list)
(cl-mapcan (lambda (elt)
(cond ((consp elt) (copy-sequence elt))
(elt (list elt))))
list))
(defun magit-insert (string face &rest args)
(if magit-use-overlays
(let ((start (point)))
(insert string)
(let ((ov (make-overlay start (point) nil t)))
(overlay-put ov 'face face)
;; (overlay-put ov 'priority 10)
(overlay-put ov 'evaporate t)))
(insert (propertize string 'face face)))
(apply #'insert args))
(defun magit-put-face-property (start end face)
(if magit-use-overlays
(let ((ov (make-overlay start end nil t)))
(overlay-put ov 'face face)
;; (overlay-put ov 'priority 10)
(overlay-put ov 'evaporate t))
(put-text-property start end 'face face)))
;;;; Buffer Margins
(defun magit-set-buffer-margin (width enable)
(let ((window (get-buffer-window)))
(when window
(with-selected-window window
(set-window-margins nil (car (window-margins)) (if enable width 0))
(let ((fn (apply-partially
(lambda (width)
(let ((window (get-buffer-window)))
(when window
(with-selected-window window
(set-window-margins nil (car (window-margins))
width)))))
width)))
(if enable
(add-hook 'window-configuration-change-hook fn nil t)
(remove-hook 'window-configuration-change-hook fn t)))))))
(defun magit-make-margin-overlay (&rest strings)
(let ((o (make-overlay (point) (line-end-position) nil t)))
(overlay-put o 'evaporate t)
(overlay-put o 'before-string
(propertize "o" 'display
(list '(margin right-margin)
(apply #'concat strings))))))
(defvar-local magit-log-margin-timeunit-width nil)
(defun magit-log-margin-set-timeunit-width ()
(cl-destructuring-bind (width characterp duration-spec)
magit-log-margin-spec
(setq magit-log-margin-timeunit-width
(if characterp
1
(apply 'max (mapcar (lambda (e)
(max (length (nth 1 e))
(length (nth 2 e))))
(symbol-value duration-spec)))))))
;;;; Emacsclient Support
(defmacro magit-with-emacsclient (server-window &rest body)
"Arrange for Git to use Emacsclient as \"the git editor\".
Git processes that use \"the editor\" have to be asynchronous.
The use of this macro ensures that such processes inside BODY use
Emacsclient as \"the editor\" by setting the environment variable
$GIT_EDITOR accordingly around calls to Git and starting the
server if necessary."
(declare (indent 1))
`(let* ((process-environment process-environment)
(magit-process-popup-time -1))
;; Make sure the client is usable.
(magit-assert-emacsclient "use `magit-with-emacsclient'")
;; Make sure server-use-tcp's value is valid.
(unless (featurep 'make-network-process '(:family local))
(setq server-use-tcp t))
;; Make sure the server is running.
(unless server-process
(when (server-running-p server-name)
(setq server-name (format "server%s" (emacs-pid)))
(when (server-running-p server-name)
(server-force-delete server-name)))
(server-start))
;; Tell Git to use the client.
(setenv "GIT_EDITOR"
(concat magit-emacsclient-executable
;; Tell the client where the server file is.
(and (not server-use-tcp)
(concat " --socket-name="
(expand-file-name server-name
server-socket-dir)))))
(when server-use-tcp
(setenv "EMACS_SERVER_FILE"
(expand-file-name server-name server-auth-dir)))
;; As last resort fallback to a new Emacs instance.
(setenv "ALTERNATE_EDITOR"
(expand-file-name invocation-name invocation-directory))
;; Git has to be called asynchronously in BODY or we create a
;; dead lock. By the time Emacsclient is called the dynamic
;; binding is no longer in effect and our primitives don't
;; support callbacks. Temporarily set the default value and
;; restore the old value using a timer.
(let ((window ,server-window))
(unless (equal window server-window)
(run-at-time "1 sec" nil
(apply-partially (lambda (value)
(setq server-window value))
server-window))
(setq-default server-window window)))
,@body))
(defun magit-use-emacsclient-p ()
(and magit-emacsclient-executable
(not (tramp-tramp-file-p default-directory))))
(defun magit-assert-emacsclient (action)
(unless magit-emacsclient-executable
(user-error "Cannot %s when `magit-emacsclient-executable' is nil" action))
(when (tramp-tramp-file-p default-directory)
(user-error "Cannot %s when accessing repository using tramp" action)))
;;;; Git Config
(defun magit-get (&rest keys)
"Return the value of Git config entry specified by KEYS."
(magit-git-string "config" (mapconcat 'identity keys ".")))
(defun magit-get-all (&rest keys)
"Return all values of the Git config entry specified by KEYS."
(magit-git-lines "config" "--get-all" (mapconcat 'identity keys ".")))
(defun magit-get-boolean (&rest keys)
"Return the boolean value of Git config entry specified by KEYS."
(magit-git-true "config" "--bool" (mapconcat 'identity keys ".")))
(defun magit-set (val &rest keys)
"Set Git config settings specified by KEYS to VAL."
(if val
(magit-git-string "config" (mapconcat 'identity keys ".") val)
(magit-git-string "config" "--unset" (mapconcat 'identity keys "."))))
;;;; Git Low-Level
(defun magit-git-repo-p (dir)
(file-exists-p (expand-file-name ".git" dir)))
(defun magit-git-dir (&optional path)
"Return absolute path to the GIT_DIR for the current repository.
If optional PATH is non-nil it has to be a path relative to the
GIT_DIR and its absolute path is returned"
(let ((gitdir (magit-git-string "rev-parse" "--git-dir")))
(when gitdir
(setq gitdir (file-name-as-directory
(magit-expand-git-file-name gitdir)))
(if path
(expand-file-name (convert-standard-filename path) gitdir)
gitdir))))
(defun magit-no-commit-p ()
"Return non-nil if there is no commit in the current git repository."
(not (magit-git-string "rev-list" "-1" "HEAD")))
(defun magit-get-top-dir (&optional directory)
"Return the top directory for the current repository.
Determine the repository which contains `default-directory' in
either its work tree or git control directory and return its top
directory. If there is no top directory, because the repository
is bare, return the control directory instead.
If optional DIRECTORY is non-nil then return the top directory of
the repository that contains that instead. DIRECTORY has to be
an existing directory."
(setq directory (if directory
(file-name-as-directory
(expand-file-name directory))
default-directory))
(unless (file-directory-p directory)
(error "%s isn't an existing directory" directory))
(let* ((default-directory directory)
(top (magit-git-string "rev-parse" "--show-toplevel")))
(if top
(file-name-as-directory (magit-expand-git-file-name top))
(let ((gitdir (magit-git-dir)))
(when gitdir
(if (magit-bare-repo-p)
gitdir
(file-name-directory (directory-file-name gitdir))))))))
(defun magit-expand-git-file-name (filename)
(when (tramp-tramp-file-p default-directory)
(setq filename (file-relative-name filename
(with-parsed-tramp-file-name
default-directory nil
localname))))
(expand-file-name filename))
(defun magit-file-relative-name (file)
"Return the path of FILE relative to the repository root.
If FILE isn't inside a Git repository then return nil."
(setq file (file-truename file))
(let ((topdir (magit-get-top-dir (file-name-directory file))))
(and topdir (substring file (length topdir)))))
(defun magit-bare-repo-p ()
"Return t if the current repository is bare."
(magit-git-true "rev-parse" "--is-bare-repository"))
(defun magit-get-ref (ref)
(magit-git-string "symbolic-ref" "-q" ref))
(defun magit-get-current-branch ()
(let ((head (magit-get-ref "HEAD")))
(when (and head (string-match "^refs/heads/" head))
(substring head 11))))
(defun magit-get-remote/branch (&optional branch verify)
"Return the remote-tracking branch of BRANCH used for pulling.
Return a string of the form \"REMOTE/BRANCH\".
If optional BRANCH is nil return the remote-tracking branch of
the current branch. If optional VERIFY is non-nil verify that
the remote branch exists; else return nil."
(save-match-data
(let (remote remote-branch remote/branch)
(and (or branch (setq branch (magit-get-current-branch)))
(setq remote (magit-get "branch" branch "remote"))
(setq remote-branch (magit-get "branch" branch "merge"))
(string-match "^refs/heads/\\(.+\\)" remote-branch)
(setq remote/branch
(concat remote "/" (match-string 1 remote-branch)))
(or (not verify)
(magit-git-success "rev-parse" "--verify" remote/branch))
remote/branch))))
(defun magit-get-tracked-branch (&optional branch qualified pretty)
"Return the name of the tracking branch the local branch name BRANCH.
If optional QUALIFIED is non-nil return the full branch path,
otherwise try to shorten it to a name (which may fail). If
optional PRETTY is non-nil additionally format the branch name
according to option `magit-remote-ref-format'."
(unless branch
(setq branch (magit-get-current-branch)))
(when branch
(let ((remote (magit-get "branch" branch "remote"))
(merge (magit-get "branch" branch "merge")))
(when (and (not merge)
(not (equal remote ".")))
(setq merge branch))
(when (and remote merge)
(if (string= remote ".")
(cond (qualified merge)
((string-match "^refs/heads/" merge)
(substring merge 11))
((string-match "^refs/" merge)
merge))
(let* ((fetch (mapcar (lambda (f) (split-string f "[+:]" t))
(magit-get-all "remote" remote "fetch")))
(match (cadr (assoc merge fetch))))
(unless match
(let* ((prefix (nreverse (split-string merge "/")))
(unique (list (car prefix))))
(setq prefix (cdr prefix))
(setq fetch
(cl-mapcan
(lambda (f)
(cl-destructuring-bind (from to) f
(setq from (nreverse (split-string from "/")))
(when (equal (car from) "*")
(list (list (cdr from) to)))))
fetch))
(while (and prefix (not match))
(if (setq match (cadr (assoc prefix fetch)))
(setq match (concat (substring match 0 -1)
(mapconcat 'identity unique "/")))
(push (car prefix) unique)
(setq prefix (cdr prefix))))))
(cond ((not match) nil)
(qualified match)
((string-match "^refs/remotes/" match)
(if pretty
(magit-format-ref match)
(substring match 13)))
(t match))))))))
(defun magit-get-previous-branch ()
"Return the refname of the previously checked out branch.
Return nil if the previously checked out branch no longer exists."
(magit-name-rev (magit-git-string "rev-parse" "--verify" "@{-1}")))
(defun magit-get-current-tag (&optional with-distance-p)
"Return the closest tag reachable from \"HEAD\".
If optional WITH-DISTANCE-P is non-nil then return (TAG COMMITS),
if it is `dirty' return (TAG COMMIT DIRTY). COMMITS is the number
of commits in \"HEAD\" but not in TAG and DIRTY is t if there are
uncommitted changes, nil otherwise."
(let ((tag (magit-git-string "describe" "--long" "--tags"
(and (eq with-distance-p 'dirty) "--dirty"))))
(save-match-data
(when tag
(string-match
"\\(.+\\)-\\(?:0[0-9]*\\|\\([0-9]+\\)\\)-g[0-9a-z]+\\(-dirty\\)?$" tag)
(if with-distance-p
(list (match-string 1 tag)
(string-to-number (or (match-string 2 tag) "0"))
(and (match-string 3 tag) t))
(match-string 1 tag))))))
(defun magit-get-next-tag (&optional with-distance-p)
"Return the closest tag from which \"HEAD\" is reachable.
If no such tag can be found or if the distance is 0 (in which
case it is the current tag, not the next) return nil instead.
If optional WITH-DISTANCE-P is non-nil then return (TAG COMMITS)
where COMMITS is the number of commits in TAG but not in \"HEAD\"."
(let ((rev (magit-git-string "describe" "--contains" "HEAD")))
(save-match-data
(when (and rev (string-match "^[^^~]+" rev))
(let ((tag (match-string 0 rev)))
(unless (equal tag (magit-get-current-tag))
(if with-distance-p
(list tag (car (magit-rev-diff-count tag "HEAD")))
tag)))))))
(defun magit-get-remote (branch)
"Return the name of the remote for BRANCH.
If branch is nil or it has no remote, but a remote named
\"origin\" exists, return that. Otherwise, return nil."
(let ((remote (or (and branch (magit-get "branch" branch "remote"))
(and (magit-get "remote" "origin" "url") "origin"))))
(unless (string= remote "")
remote)))
(defun magit-get-current-remote ()
"Return the name of the remote for the current branch.
If there is no current branch, or no remote for that branch,
but a remote named \"origin\" is configured, return that.
Otherwise, return nil."
(magit-get-remote (magit-get-current-branch)))
(defun magit-ref-exists-p (ref)
(magit-git-success "show-ref" "--verify" ref))
(defun magit-rev-parse (&rest args)
"Execute `git rev-parse ARGS', returning first line of output.
If there is no output return nil."
(apply #'magit-git-string "rev-parse" args))
(defun magit-ref-ambiguous-p (ref)
"Return whether or not REF is ambiguous."
;; An ambiguous ref does not cause `git rev-parse --abbrev-ref'
;; to exits with a non-zero status. But there is nothing on
;; stdout in that case.
(not (magit-git-string "rev-parse" "--abbrev-ref" ref)))
(defun magit-rev-diff-count (a b)
"Return the commits in A but not B and vice versa.
Return a list of two integers: (A>B B>A)."
(mapcar 'string-to-number
(split-string (magit-git-string "rev-list"
"--count" "--left-right"
(concat a "..." b))
"\t")))
(defun magit-name-rev (rev &optional no-trim)
"Return a human-readable name for REV.
Unlike `git name-rev', this will remove \"tags/\" and \"remotes/\"
prefixes if that can be done unambiguously (unless optional arg
NO-TRIM is non-nil). In addition, it will filter out revs
involving HEAD."
(when rev
(let ((name (magit-git-string "name-rev" "--no-undefined" "--name-only" rev)))
;; There doesn't seem to be a way of filtering HEAD out from name-rev,
;; so we have to do it manually.
;; HEAD-based names are too transient to allow.
(when (and (stringp name)
(string-match "^\\(.*\\<HEAD\\)\\([~^].*\\|$\\)" name))
(let ((head-ref (match-string 1 name))
(modifier (match-string 2 name)))
;; Sometimes when name-rev gives a HEAD-based name,
;; rev-parse will give an actual branch or remote name.
(setq name (concat (magit-git-string "rev-parse" "--abbrev-ref" head-ref)
modifier))
;; If rev-parse doesn't give us what we want, just use the SHA.
(when (or (null name) (string-match-p "\\<HEAD\\>" name))
(setq name (magit-rev-parse rev)))))
(setq rev (or name rev))
(when (string-match "^\\(?:tags\\|remotes\\)/\\(.*\\)" rev)
(let ((plain-name (match-string 1 rev)))
(unless (or no-trim (magit-ref-ambiguous-p plain-name))
(setq rev plain-name))))
rev)))
(defun magit-file-uptodate-p (file)
(magit-git-success "diff" "--quiet" "--" file))
(defun magit-anything-staged-p ()
(magit-git-failure "diff" "--quiet" "--cached"))
(defun magit-anything-unstaged-p ()
(magit-git-failure "diff" "--quiet"))
(defun magit-anything-modified-p ()
(or (magit-anything-staged-p)
(magit-anything-unstaged-p)))
(defun magit-commit-parents (commit)
(cdr (split-string (magit-git-string "rev-list" "-1" "--parents" commit))))
(defun magit-assert-one-parent (commit command)
(when (> (length (magit-commit-parents commit)) 1)
(user-error "Cannot %s a merge commit" command)))
(defun magit-decode-git-path (path)
(if (eq (aref path 0) ?\")
(string-as-multibyte (read path))
path))
(defun magit-abbrev-length ()
(string-to-number (or (magit-get "core.abbrev") "7")))
(defun magit-abbrev-arg ()
(format "--abbrev=%d" (magit-abbrev-length)))
;;;; Git Revisions
(defvar magit-uninteresting-refs
'("^refs/stash$"
"^refs/remotes/[^/]+/HEAD$"
"^refs/remotes/[^/]+/top-bases$"
"^refs/top-bases$"))
(cl-defun magit-list-interesting-refs (&optional uninteresting
(refs nil srefs))
(cl-loop for ref in (if srefs
refs
(mapcar (lambda (l)
(cadr (split-string l " ")))
(magit-git-lines "show-ref")))
with label
unless (or (cl-loop for i in
(cl-typecase uninteresting
(null magit-uninteresting-refs)
(list uninteresting)
(string (cons (format "^refs/heads/%s$"
uninteresting)
magit-uninteresting-refs)))
thereis (string-match i ref))
(not (setq label (magit-format-ref ref))))
collect (cons label ref)))
(defun magit-format-ref (ref)
(cond ((string-match "refs/heads/\\(.*\\)" ref)
(match-string 1 ref))
((string-match "refs/tags/\\(.*\\)" ref)
(format (if (eq magit-remote-ref-format 'branch-then-remote)
"%s (tag)"
"%s")
(match-string 1 ref)))
((string-match "refs/remotes/\\([^/]+\\)/\\(.+\\)" ref)
(if (eq magit-remote-ref-format 'branch-then-remote)
(format "%s (%s)"
(match-string 2 ref)
(match-string 1 ref))
(substring ref 13)))
(t ref)))
(defvar magit-read-file-hist nil)
(defun magit-read-file-from-rev (revision &optional default)
(unless revision
(setq revision "HEAD"))
(let ((default-directory (magit-get-top-dir)))
(magit-completing-read
(format "Retrieve file from %s" revision)
(magit-git-lines "ls-tree" "-r" "-t" "--name-only" revision)
nil 'require-match
nil 'magit-read-file-hist
(or default (magit-buffer-file-name t)))))
(defun magit-read-file-trace (ignored)
(let ((file (magit-read-file-from-rev "HEAD"))
(trace (read-string "Trace: ")))
(if (string-match
"^\\(/.+/\\|:[^:]+\\|[0-9]+,[-+]?[0-9]+\\)\\(:\\)?$" trace)
(concat trace (or (match-string 2 trace) ":") file)
(user-error "Trace is invalid, see man git-log"))))
(defvar magit-read-rev-history nil
"The history of inputs to `magit-read-rev' and `magit-read-tag'.")
(defun magit-read-tag (prompt &optional require-match)
(magit-completing-read prompt (magit-git-lines "tag") nil
require-match nil 'magit-read-rev-history))
(defun magit-read-rev (prompt &optional default uninteresting noselection)
(let* ((interesting-refs
(mapcar (lambda (elt)
(setcdr elt (replace-regexp-in-string
"^refs/heads/" "" (cdr elt)))
elt)
(magit-list-interesting-refs uninteresting)))
(reply (magit-completing-read prompt interesting-refs nil nil nil
'magit-read-rev-history default))
(rev (or (cdr (assoc reply interesting-refs)) reply)))
(when (equal rev ".")
(setq rev magit-marked-commit))
(unless (or rev noselection)
(user-error "No rev selected"))
rev))
(defun magit-read-rev-with-default (prompt)
(magit-read-rev prompt
(let ((branch (or (magit-guess-branch) "HEAD")))
(when branch
(if (string-match "^refs/\\(.*\\)" branch)
(match-string 1 branch)
branch)))))
(defun magit-read-rev-range (op &optional def-beg def-end)
(let ((beg (magit-read-rev (format "%s range or start" op) def-beg)))
(save-match-data
(if (string-match "^\\(.+\\)\\.\\.\\(.+\\)$" beg)
(match-string 0 beg)
(let ((end (magit-read-rev (format "%s end" op) def-end nil t)))
(if end (concat beg ".." end) beg))))))
(defun magit-read-stash (prompt)
(let ((n (read-number prompt 0))
(l (1- (length (magit-git-lines "stash" "list")))))
(if (> n l)
(user-error "No stash older than stash@{%i}" l)
(format "stash@{%i}" n))))
(defun magit-read-remote (prompt &optional default require-match)
(magit-completing-read prompt (magit-git-lines "remote")
nil require-match nil nil
(or default (magit-guess-remote))))
(defun magit-read-remote-branch (prompt remote &optional default)
(let ((branch (magit-completing-read
prompt
(cl-mapcan
(lambda (b)
(and (not (string-match " -> " b))
(string-match (format "^ *%s/\\(.*\\)$"
(regexp-quote remote)) b)
(list (match-string 1 b))))
(magit-git-lines "branch" "-r"))
nil nil nil nil default)))
(unless (string= branch "")
branch)))
(defun magit-format-ref-label (ref)
(cl-destructuring-bind (re face fn)
(cl-find-if (lambda (ns)
(string-match (car ns) ref))
magit-refs-namespaces)
(if fn
(funcall fn ref face)
(propertize (or (match-string 1 ref) ref) 'face face))))
(defun magit-format-ref-labels (string)
(save-match-data
(mapconcat 'magit-format-ref-label
(mapcar 'cdr
(magit-list-interesting-refs
nil (split-string string "\\(tag: \\|[(), ]\\)" t)))
" ")))
(defun magit-insert-ref-labels (string)
(save-match-data
(dolist (ref (split-string string "\\(tag: \\|[(), ]\\)" t) " ")
(cl-destructuring-bind (re face fn)
(cl-find-if (lambda (elt) (string-match (car elt) ref))
magit-refs-namespaces)
(if fn
(let ((text (funcall fn ref face)))
(magit-insert text (get-text-property 1 'face text) ?\s))
(magit-insert (or (match-string 1 ref) ref) face ?\s))))))
(defun magit-format-rev-summary (rev)
(let ((s (magit-git-string "log" "-1"
(concat "--pretty=format:%h %s") rev)))
(when s
(string-match " " s)
(put-text-property 0 (match-beginning 0) 'face 'magit-log-sha1 s)
s)))
;;; Magit Api
;;;; Section Api
;;;;; Section Core
(cl-defstruct magit-section
type info
beginning content-beginning end
hidden needs-refresh-on-show highlight
diff-status diff-file2 diff-range
process
parent children)
(defvar-local magit-root-section nil
"The root section in the current buffer.
All other sections are descendants of this section. The value
of this variable is set by `magit-with-section' and you should
never modify it.")
(put 'magit-root-section 'permanent-local t)
;;;;; Section Creation
(defvar magit-with-section--parent nil
"For use by `magit-with-section' only.")
(defvar magit-with-section--oldroot nil
"For use by `magit-with-section' only.")
(defmacro magit-with-section (arglist &rest body)
"\n\n(fn (NAME TYPE &optional INFO HEADING NOHIGHLIGHT COLLAPSE) &rest ARGS)"
(declare (indent 1) (debug ((form form &optional form form form) body)))
(let ((s (car arglist)))
`(let ((,s (make-magit-section
:type ',(nth 1 arglist)
:info ,(nth 2 arglist)
:highlight (not ,(nth 4 arglist))
:beginning (point-marker)
:content-beginning (point-marker)
:parent magit-with-section--parent)))
(setf (magit-section-hidden ,s)
(let ((old (and magit-with-section--oldroot
(magit-find-section (magit-section-path ,s)
magit-with-section--oldroot))))
(if old
(magit-section-hidden old)
,(nth 5 arglist))))
(let ((magit-with-section--parent ,s)
(magit-with-section--oldroot
(or magit-with-section--oldroot
(unless magit-with-section--parent
(prog1 magit-root-section
(setq magit-root-section ,s))))))
,@body)
(when ,s
(set-marker-insertion-type (magit-section-content-beginning ,s) t)
(let ((heading ,(nth 3 arglist)))
(when heading
(save-excursion
(goto-char (magit-section-beginning ,s))
(insert
(if (string-match-p "\n$" heading)
(substring heading 0 -1)
(propertize
(let (c)
(if (and magit-show-child-count
(string-match-p ":$" heading)
(> (setq c (length (magit-section-children ,s))) 0))
(format "%s (%s):" (substring heading 0 -1) c)
heading))
'face 'magit-section-title)))
(insert "\n"))))
(set-marker-insertion-type (magit-section-beginning ,s) t)
(goto-char (max (point) ; smaller if there is no content
(magit-section-content-beginning ,s)))
(setf (magit-section-end ,s) (point-marker))
(save-excursion
(goto-char (magit-section-beginning ,s))
(let ((end (magit-section-end ,s)))
(while (< (point) end)
(let ((next (or (next-single-property-change
(point) 'magit-section)
end)))
(unless (get-text-property (point) 'magit-section)
(put-text-property (point) next 'magit-section ,s))
(goto-char next)))))
(if (eq ,s magit-root-section)
(magit-section-set-hidden magit-root-section nil)
(setf (magit-section-children (magit-section-parent ,s))
(nconc (magit-section-children (magit-section-parent ,s))
(list ,s)))))
,s)))
(defmacro magit-cmd-insert-section (arglist washer program &rest args)
"\n\n(fn (TYPE &optional HEADING) WASHER PROGRAM &rest ARGS)"
(declare (indent 2))
`(magit-with-section (section ,(car arglist)
',(car arglist)
,(cadr arglist) t)
(apply #'process-file ,program nil (list t nil) nil
(magit-flatten-onelevel (list ,@args)))
(unless (eq (char-before) ?\n)
(insert "\n"))
(save-restriction
(narrow-to-region (magit-section-content-beginning section) (point))
(goto-char (point-min))
(funcall ,washer)
(goto-char (point-max)))
(let ((parent (magit-section-parent section))
(head-beg (magit-section-beginning section))
(body-beg (magit-section-content-beginning section)))
(if (= (point) body-beg)
(if (not parent)
(insert "(empty)\n")
(delete-region head-beg body-beg)
(setq section nil))
(insert "\n")))))
(defmacro magit-git-insert-section (arglist washer &rest args)
"\n\n(fn (TYPE &optional HEADING) WASHER &rest ARGS)"
(declare (indent 2))
`(magit-cmd-insert-section ,arglist
,washer
magit-git-executable
magit-git-standard-options ,@args))
(defmacro magit-insert-line-section (arglist line)
"\n\n(fn (TYPE &optional INFO) line)"
(declare (indent 1))
(let ((l (cl-gensym "line")))
`(let ((,l (concat ,line "\n")))
(when (string-match "^\\([^:]+\\):\\( \\)" ,l)
(setq ,l (replace-match
(make-string (max 1 (- magit-status-line-align-to
(length (match-string 1 ,l))))
?\s)
t t ,l 2)))
(magit-with-section (section ,(car arglist) ',(car arglist) ,l t)
(setf (magit-section-info section) ,(cadr arglist))))))
;;;;; Section Searching
(defun magit-find-section (path top)
"Find the section at the path PATH in subsection of section TOP."
(if (null path)
top
(let ((secs (magit-section-children top)))
(while (and secs (not (equal (car path)
(magit-section-info (car secs)))))
(setq secs (cdr secs)))
(when (car secs)
(magit-find-section (cdr path) (car secs))))))
(defun magit-section-path (section)
"Return the path of SECTION."
(let ((parent (magit-section-parent section)))
(when parent
(append (magit-section-path parent)
(list (magit-section-info section))))))
(defun magit-find-section-after (pos)
"Find the first section that begins after POS."
(magit-find-section-after* pos (list magit-root-section)))
(defun magit-find-section-after* (pos secs)
"Find the first section that begins after POS in the list SECS
\(including children of sections in SECS)."
(while (and secs
(<= (magit-section-beginning (car secs)) pos))
(setq secs (if (magit-section-hidden (car secs))
(cdr secs)
(append (magit-section-children (car secs))
(cdr secs)))))
(car secs))
(defun magit-find-section-before (pos)
"Return the last section that begins before POS."
(let ((section (magit-find-section-at pos)))
(cl-do* ((current (or (magit-section-parent section)
section)
next)
(next (unless (magit-section-hidden current)
(magit-find-section-before*
pos (magit-section-children current)))
(unless (magit-section-hidden current)
(magit-find-section-before*
pos (magit-section-children current)))))
((null next) current))))
(defun magit-find-section-before* (pos secs)
"Find the last section that begins before POS in the list SECS."
(let ((prev nil))
(while (and secs
(< (magit-section-beginning (car secs)) pos))
(setq prev (car secs))
(setq secs (cdr secs)))
prev))
(defun magit-current-section ()
"Return the Magit section at point."
(magit-find-section-at (point)))
(defun magit-find-section-at (pos)
"Return the Magit section at POS."
(or (get-text-property pos 'magit-section)
magit-root-section))
;;;;; Section Jumping
(defun magit-goto-next-section ()
"Go to the next section."
(interactive)
(let ((next (magit-find-section-after (point))))
(if next
(magit-goto-section next)
(message "No next section"))))
(defun magit-goto-previous-section ()
"Go to the previous section."
(interactive)
(if (eq (point) 1)
(message "No previous section")
(magit-goto-section (magit-find-section-before (point)))))
(defun magit-goto-parent-section ()
"Go to the parent section."
(interactive)
(let ((parent (magit-section-parent (magit-current-section))))
(when parent
(goto-char (magit-section-beginning parent)))))
(defun magit-goto-next-sibling-section ()
"Go to the next sibling section."
(interactive)
(let* ((section (magit-current-section))
(parent (magit-section-parent section))
(next (and parent (magit-find-section-after*
(1- (magit-section-end section))
(magit-section-children parent)))))
(if next
(magit-goto-section next)
(magit-goto-next-section))))
(defun magit-goto-previous-sibling-section ()
"Go to the previous sibling section."
(interactive)
(let* ((section (magit-current-section))
(parent (magit-section-parent section))
(prev (and parent (magit-find-section-before*
(magit-section-beginning section)
(magit-section-children parent)))))
(if prev
(magit-goto-section prev)
(magit-goto-previous-section))))
(defun magit-goto-section (section)
(goto-char (magit-section-beginning section))
(cond
((and magit-log-auto-more
(eq (magit-section-type section) 'longer))
(magit-log-show-more-entries)
(forward-line -1)
(magit-goto-next-section))
((and (eq (magit-section-type section) 'commit)
(derived-mode-p 'magit-log-mode)
(or (eq (car magit-refresh-args) 'oneline)
(get-buffer-window magit-commit-buffer-name)))
(magit-show-commit (magit-section-info section) t))))
(defun magit-goto-section-at-path (path)
"Go to the section described by PATH."
(let ((sec (magit-find-section path magit-root-section)))
(if sec
(goto-char (magit-section-beginning sec))
(message "No such section"))))
(defmacro magit-define-section-jumper (sym title)
"Define an interactive function to go to section SYM.
TITLE is the displayed title of the section."
(let ((fun (intern (format "magit-jump-to-%s" sym))))
`(progn
(defun ,fun (&optional expand) ,(format "\
Jump to section '%s'.
With a prefix argument also expand it." title)
(interactive "P")
(if (magit-goto-section-at-path '(,sym))
(when expand
(with-local-quit
(if (eq magit-expand-staged-on-commit 'full)
(magit-show-level 4 nil)
(magit-expand-section)))
(recenter 0))
(message ,(format "Section '%s' wasn't found" title))))
(put ',fun 'definition-name ',sym))))
(magit-define-section-jumper stashes "Stashes")
(magit-define-section-jumper untracked "Untracked files")
(magit-define-section-jumper unstaged "Unstaged changes")
(magit-define-section-jumper staged "Staged changes")
(magit-define-section-jumper unpulled "Unpulled commits")
(magit-define-section-jumper unpushed "Unpushed commits")
(magit-define-section-jumper diffstats "Diffstats")
;;;;; Section Hooks
(defun magit-add-section-hook (hook function &optional at append local)
"Add to the value of section hook HOOK the function FUNCTION.
Add FUNCTION at the beginning of the hook list unless optional
APPEND is non-nil, in which case FUNCTION is added at the end.
If FUNCTION already is a member then move it to the new location.
If optional AT is non-nil and a member of the hook list, then add
FUNCTION next to that instead. Add before or after AT depending
on APPEND. If only FUNCTION is a member of the list, then leave
it where ever it already is.
If optional LOCAL is non-nil, then modify the hook's buffer-local
value rather than its global value. This makes the hook local by
copying the default value. That copy is then modified.
HOOK should be a symbol. If HOOK is void, it is first set to nil.
HOOK's value must not be a single hook function. FUNCTION should
be a function that takes no arguments and inserts one or multiple
sections at point, moving point forward. FUNCTION may choose not
to insert its section(s), when doing so would not make sense. It
should not be abused for other side-effects. To remove FUNCTION
again use `remove-hook'."
(or (boundp hook) (set hook nil))
(or (default-boundp hook) (set-default hook nil))
(let ((value (if local
(if (local-variable-p hook)
(symbol-value hook)
(unless (local-variable-if-set-p hook)
(make-local-variable hook))
(copy-sequence (default-value hook)))
(default-value hook))))
(if at
(when (setq at (member at value))
(setq value (delq function value))
(if append
(push function (cdr at))
(push (car at) (cdr at))
(setcar at function)))
(setq value (delq function value)))
(unless (member function value)
(setq value (if append
(append value (list function))
(cons function value))))
(if local
(set hook value)
(set-default hook value))))
;;;;; Section Utilities
(defun magit-map-sections (function section)
"Apply FUNCTION to SECTION and recursively its subsections."
(funcall function section)
(mapc (apply-partially 'magit-map-sections function)
(magit-section-children section)))
(defun magit-wash-sequence (function)
"Repeatedly call FUNCTION until it returns nil or eob is reached.
FUNCTION has to move point forward or return nil."
(while (and (not (eobp)) (funcall function))))
(defun magit-section-parent-info (section)
(setq section (magit-section-parent section))
(when section (magit-section-info section)))
(defun magit-section-siblings (section &optional direction)
(let ((parent (magit-section-parent section)))
(when parent
(let ((siblings (magit-section-children parent)))
(cl-ecase direction
(prev (member section (reverse siblings)))
(next (member section siblings))
(nil siblings))))))
(defun magit-section-region-siblings (&optional key)
(let ((beg (magit-find-section-at (region-beginning)))
(end (magit-find-section-at (region-end))))
(if (eq beg end)
(list (if key (funcall key beg) beg))
(goto-char (region-end))
(when (bolp)
(setq end (magit-find-section-at (1- (point)))))
(while (> (length (magit-section-path beg))
(length (magit-section-path end)))
(setq beg (magit-section-parent beg)))
(while (> (length (magit-section-path end))
(length (magit-section-path beg)))
(setq end (magit-section-parent end)))
(let* ((parent (magit-section-parent beg))
(siblings (magit-section-children parent)))
(if (eq parent (magit-section-parent end))
(mapcar (or key #'identity)
(cl-intersection (memq beg siblings)
(memq end (reverse siblings))))
(user-error "Ambitious cross-section region"))))))
(defun magit-diff-section-for-diffstat (section)
(let ((file (magit-section-info section)))
(cl-find-if (lambda (s)
(and (eq (magit-section-type s) 'diff)
(string-equal (magit-section-info s) file)))
(magit-section-children magit-root-section))))
;;;;; Section Visibility
(defun magit-section-set-hidden (section hidden)
"Hide SECTION if HIDDEN is not nil, show it otherwise."
(setf (magit-section-hidden section) hidden)
(if (and (not hidden)
(magit-section-needs-refresh-on-show section))
(magit-refresh)
(let ((inhibit-read-only t)
(beg (save-excursion
(goto-char (magit-section-beginning section))
(forward-line)
(point)))
(end (magit-section-end section)))
(when (< beg end)
(put-text-property beg end 'invisible hidden)))
(unless hidden
(dolist (c (magit-section-children section))
(magit-section-set-hidden c (magit-section-hidden c))))))
(defun magit-section-any-hidden (section)
"Return true if SECTION or any of its children is hidden."
(or (magit-section-hidden section)
(let ((kids (magit-section-children section)))
(while (and kids (not (magit-section-any-hidden (car kids))))
(setq kids (cdr kids)))
kids)))
(defun magit-section-collapse (section)
"Show SECTION and hide all its children."
(dolist (c (magit-section-children section))
(setf (magit-section-hidden c) t))
(magit-section-set-hidden section nil))
(defun magit-section-expand (section)
"Show SECTION and all its children."
(dolist (c (magit-section-children section))
(setf (magit-section-hidden c) nil))
(magit-section-set-hidden section nil))
(defun magit-section-expand-all-aux (section)
"Show recursively all SECTION's children."
(dolist (c (magit-section-children section))
(setf (magit-section-hidden c) nil)
(magit-section-expand-all-aux c)))
(defun magit-section-expand-all (section)
"Show SECTION and all its children."
(magit-section-expand-all-aux section)
(magit-section-set-hidden section nil))
(defun magit-section-hideshow (flag-or-func)
"Show or hide current section depending on FLAG-OR-FUNC.
If FLAG-OR-FUNC is a function, it will be ran on current section.
IF FLAG-OR-FUNC is a boolean, the section will be hidden if it is
true, shown otherwise."
(let ((section (magit-current-section)))
(when (magit-section-parent section)
(goto-char (magit-section-beginning section))
(if (functionp flag-or-func)
(funcall flag-or-func section)
(magit-section-set-hidden section flag-or-func)))))
(defun magit-show-section ()
"Show current section."
(interactive)
(magit-section-hideshow nil))
(defun magit-hide-section ()
"Hide current section."
(interactive)
(magit-section-hideshow t))
(defun magit-collapse-section ()
"Hide all subsection of current section."
(interactive)
(magit-section-hideshow #'magit-section-collapse))
(defun magit-expand-section ()
"Show all subsection of current section."
(interactive)
(magit-section-hideshow #'magit-section-expand))
(defun magit-toggle-file-section ()
"Like `magit-toggle-section' but toggle at file granularity."
(interactive)
(when (eq (magit-section-type (magit-current-section)) 'hunk)
(magit-goto-parent-section))
(magit-toggle-section))
(defun magit-toggle-section ()
"Toggle hidden status of current section."
(interactive)
(magit-section-hideshow
(lambda (s)
(magit-section-set-hidden s (not (magit-section-hidden s))))))
(defun magit-expand-collapse-section ()
"Toggle hidden status of subsections of current section."
(interactive)
(magit-section-hideshow
(lambda (s)
(cond ((magit-section-any-hidden s)
(magit-section-expand-all s))
(t
(magit-section-collapse s))))))
(defun magit-cycle-section ()
"Cycle between expanded, hidden and collapsed state for current section.
Hidden: only the first line of the section is shown
Collapsed: only the first line of the subsection is shown
Expanded: everything is shown."
(interactive)
(magit-section-hideshow
(lambda (s)
(cond ((magit-section-hidden s)
(magit-section-collapse s))
((with-no-warnings
(cl-notany #'magit-section-hidden (magit-section-children s)))
(magit-section-set-hidden s t))
(t
(magit-section-expand s))))))
(defun magit-section-lineage (section)
"Return list of parent, grand-parents... for SECTION."
(when section
(cons section (magit-section-lineage (magit-section-parent section)))))
(defun magit-section-show-level (section level threshold path)
(magit-section-set-hidden section (>= level threshold))
(when (and (< level threshold)
(not (magit-no-commit-p)))
(if path
(magit-section-show-level (car path) (1+ level) threshold (cdr path))
(dolist (c (magit-section-children section))
(magit-section-show-level c (1+ level) threshold nil)))))
(defun magit-show-level (level all)
"Show section whose level is less than LEVEL, hide the others.
If ALL is non nil, do this in all sections, otherwise do it only
on ancestors and descendants of current section."
(if all
(magit-section-show-level magit-root-section 0 level nil)
(let ((path (reverse (magit-section-lineage (magit-current-section)))))
(magit-section-show-level (car path) 0 level (cdr path)))))
(defun magit-show-only-files ()
"Show section that are files, but not their subsection.
Do this in on ancestors and descendants of current section."
(interactive)
(if (derived-mode-p 'magit-status-mode)
(call-interactively 'magit-show-level-2)
(call-interactively 'magit-show-level-1)))
(defun magit-show-only-files-all ()
"Show section that are files, but not their subsection.
Do this for all sections"
(interactive)
(if (derived-mode-p 'magit-status-mode)
(call-interactively 'magit-show-level-2-all)
(call-interactively 'magit-show-level-1-all)))
(defmacro magit-define-level-shower-1 (level all)
"Define an interactive function to show function of level LEVEL.
If ALL is non nil, this function will affect all section,
otherwise it will affect only ancestors and descendants of
current section."
(let ((fun (intern (format "magit-show-level-%s%s"
level (if all "-all" ""))))
(doc (format "Show sections on level %s." level)))
`(defun ,fun ()
,doc
(interactive)
(magit-show-level ,level ,all))))
(defmacro magit-define-level-shower (level)
"Define two interactive function to show function of level LEVEL.
One for all, one for current lineage."
`(progn
(magit-define-level-shower-1 ,level nil)
(magit-define-level-shower-1 ,level t)))
(magit-define-level-shower 1)
(magit-define-level-shower 2)
(magit-define-level-shower 3)
(magit-define-level-shower 4)
;;;;; Section Highlighting
(defvar-local magit-highlighted-section nil)
(defvar-local magit-highlight-overlay nil)
(defun magit-highlight-section ()
"Highlight current section.
If its HIGHLIGHT slot is nil, then don't highlight it."
(let ((section (magit-current-section))
(refinep (lambda ()
(and magit-highlighted-section
(eq magit-diff-refine-hunk t)
(eq (magit-section-type magit-highlighted-section)
'hunk)))))
(unless (eq section magit-highlighted-section)
(when (funcall refinep)
(magit-diff-unrefine-hunk magit-highlighted-section))
(setq magit-highlighted-section section)
(unless magit-highlight-overlay
(overlay-put (setq magit-highlight-overlay (make-overlay 1 1))
'face magit-item-highlight-face))
(cond ((and section (magit-section-highlight section))
(when (funcall refinep)
(magit-diff-refine-hunk section))
(move-overlay magit-highlight-overlay
(magit-section-beginning section)
(magit-section-end section)
(current-buffer)))
(t
(delete-overlay magit-highlight-overlay))))))
;;;;; Section Actions
(defun magit-section-context-type (section)
(cons (magit-section-type section)
(let ((parent (magit-section-parent section)))
(when parent
(magit-section-context-type parent)))))
(defun magit-section-match-1 (l1 l2)
(or (null l1)
(if (eq (car l1) '*)
(or (magit-section-match-1 (cdr l1) l2)
(and l2
(magit-section-match-1 l1 (cdr l2))))
(and l2
(equal (car l1) (car l2))
(magit-section-match-1 (cdr l1) (cdr l2))))))
(defun magit-section-match (condition &optional section)
(unless section
(setq section (magit-current-section)))
(cond ((eq condition t) t)
((not section) nil)
((listp condition)
(cl-find t condition :test
(lambda (_ condition)
(magit-section-match condition section))))
(t
(magit-section-match-1 (if (symbolp condition)
(list condition)
(append condition nil))
(magit-section-context-type section)))))
(defmacro magit-section-case (slots &rest clauses)
(declare (indent 1))
`(let* ((it (magit-current-section))
,@(mapcar
(lambda (slot)
`(,slot
(and it (,(intern (format "magit-section-%s" slot)) it))))
slots))
(cond ,@(mapcar (lambda (clause)
`((magit-section-match ',(car clause) it)
,@(cdr clause)))
clauses))))
(defconst magit-section-action-success
(make-symbol "magit-section-action-success"))
(defmacro magit-section-action (opname slots &rest clauses)
(declare (indent 2) (debug (sexp &rest (sexp body))))
(let ((value (cl-gensym "value")))
`(let ((,value
(or (run-hook-wrapped
',(intern (format "magit-%s-hook" opname))
(lambda (fn section)
(when (magit-section-match
(or (get fn 'magit-section-action-context)
(error "%s undefined for %s"
'magit-section-action-context fn))
section)
(funcall fn (magit-section-info section))))
(magit-current-section))
(magit-section-case ,slots
,@clauses
(t (user-error
(if (magit-current-section)
,(format "Cannot %s this section" opname)
,(format "Nothing to %s here" opname))))))))
(unless (eq ,value magit-section-action-success)
,value))))
;;;; Process Api
;;;;; Process Commands
(defun magit-process ()
"Display Magit process buffer."
(interactive)
(let ((buf (magit-process-buffer)))
(if (buffer-live-p buf)
(pop-to-buffer buf)
(user-error "Process buffer doesn't exist"))))
(defun magit-process-kill ()
"Kill the process at point."
(interactive)
(magit-section-case (info)
(process (if (eq (process-status info) 'run)
(when (yes-or-no-p "Kill this process? ")
(kill-process info))
(user-error "Process isn't running")))))
(defvar magit-git-command-history nil)
;;;###autoload
(defun magit-git-command (args directory)
"Execute a Git subcommand asynchronously, displaying the output.
With a prefix argument run Git in the root of the current
repository. Non-interactively run Git in DIRECTORY with ARGS."
(interactive (magit-git-command-read-args))
(require 'eshell)
(magit-mode-display-buffer (magit-process-buffer nil t)
'magit-process-mode 'pop-to-buffer)
(goto-char (point-max))
(let ((default-directory directory))
(magit-run-git-async
(with-temp-buffer
(insert args)
(mapcar 'eval (eshell-parse-arguments (point-min)
(point-max)))))))
(defun magit-git-command-topdir (args directory)
"Execute a Git subcommand asynchronously, displaying the output.
Run Git in the root of the current repository.
\n(fn)" ; arguments are for internal use
(interactive (magit-git-command-read-args t))
(magit-git-command args directory))
(defun magit-git-command-read-args (&optional root)
(let ((dir (if (or root current-prefix-arg)
(or (magit-get-top-dir)
(user-error "Not inside a Git repository"))
default-directory)))
(list (read-string (format "Git subcommand (in %s): "
(abbreviate-file-name dir))
nil 'magit-git-command-history)
dir)))
;;;;; Process Mode
(define-derived-mode magit-process-mode magit-mode "Magit Process"
"Mode for looking at git process output.")
(defvar magit-process-buffer-name "*magit-process*"
"Name of buffer where output of processes is put.")
(defun magit-process-buffer (&optional topdir create)
(or (magit-mode-get-buffer magit-process-buffer-name
'magit-process-mode topdir)
(with-current-buffer (magit-mode-get-buffer-create
magit-process-buffer-name
'magit-process-mode topdir)
(magit-process-mode)
(let* ((inhibit-read-only t)
(s (magit-with-section (section processbuf nil nil t)
(insert "\n"))))
(set-marker-insertion-type (magit-section-beginning s) nil)
(set-marker-insertion-type (magit-section-content-beginning s) nil)
(current-buffer)))))
;;;;; Synchronous Processes
(defun magit-git-exit-code (&rest args)
"Execute Git with ARGS, returning its exit code."
(apply #'process-file magit-git-executable nil nil nil
(append magit-git-standard-options
(magit-flatten-onelevel args))))
(defun magit-git-success (&rest args)
"Execute Git with ARGS, returning t if its exit code is 0."
(= (apply #'magit-git-exit-code args) 0))
(defun magit-git-failure (&rest args)
"Execute Git with ARGS, returning t if its exit code is 1."
(= (apply #'magit-git-exit-code args) 1))
(defun magit-git-string (&rest args)
"Execute Git with ARGS, returning the first line of its output.
If there is no output return nil. If the output begins with a
newline return an empty string."
(with-temp-buffer
(apply #'process-file magit-git-executable nil (list t nil) nil
(append magit-git-standard-options
(magit-flatten-onelevel args)))
(unless (= (point-min) (point-max))
(goto-char (point-min))
(buffer-substring-no-properties
(line-beginning-position)
(line-end-position)))))
(defun magit-git-true (&rest args)
"Execute Git with ARGS, returning t if it prints \"true\".
Return t if the first (and usually only) output line is the
string \"true\", otherwise return nil."
(equal (apply #'magit-git-string args) "true"))
(defun magit-git-false (&rest args)
"Execute Git with ARGS, returning t if it prints \"false\".
Return t if the first (and usually only) output line is the
string \"false\", otherwise return nil."
(equal (apply #'magit-git-string args) "false"))
(defun magit-git-insert (&rest args)
"Execute Git with ARGS, inserting its output at point."
(apply #'process-file magit-git-executable nil (list t nil) nil
(append magit-git-standard-options
(magit-flatten-onelevel args))))
(defun magit-git-lines (&rest args)
"Execute Git with ARGS, returning its output as a list of lines.
Empty lines anywhere in the output are omitted."
(with-temp-buffer
(apply #'process-file magit-git-executable nil (list t nil) nil
(append magit-git-standard-options
(magit-flatten-onelevel args)))
(split-string (buffer-string) "\n" 'omit-nulls)))
(defun magit-run-git (&rest args)
"Call Git synchronously in a separate process, and refresh.
The arguments ARGS specify command line arguments. The first
level of ARGS is flattened, so each member of ARGS has to be a
string or a list of strings.
Option `magit-git-executable' specifies which Git executable is
used. The arguments in option `magit-git-standard-options' are
prepended to ARGS.
After Git returns, the current buffer (if it is a Magit buffer)
as well as the current repository's status buffer are refreshed.
Unmodified buffers visiting files that are tracked in the current
repository are reverted if `magit-auto-revert-mode' is active.
Process output goes into a new section in a buffer specified by
variable `magit-process-buffer-name'."
(apply #'magit-call-git (magit-process-quote-arguments args))
(magit-refresh))
(defun magit-call-git (&rest args)
"Call Git synchronously in a separate process.
The arguments ARGS specify command line arguments. The first
level of ARGS is flattened, so each member of ARGS has to be a
string or a list of strings.
Option `magit-git-executable' specifies which Git executable is
used. The arguments in option `magit-git-standard-options' are
prepended to ARGS.
Process output goes into a new section in a buffer specified by
variable `magit-process-buffer-name'."
(apply #'magit-call-process magit-git-executable
(append magit-git-standard-options args)))
(defun magit-call-process (program &rest args)
"Call PROGRAM synchronously in a separate process.
The arguments ARGS specify command line arguments. The first
level of ARGS is flattened, so each member of ARGS has to be a
string or a list of strings.
Process output goes into a new section in a buffer specified by
variable `magit-process-buffer-name'."
(setq args (magit-flatten-onelevel args))
(cl-destructuring-bind (process-buf . section)
(magit-process-setup program args)
(magit-process-finish
(let ((inhibit-read-only t))
(apply #'process-file program nil process-buf nil args))
process-buf (current-buffer) default-directory section)))
(defun magit-run-git-with-input (input &rest args)
"Call Git in a separate process.
The first argument, INPUT, has to be a buffer or the name of an
existing buffer. The content of that buffer is used as the
process' standard input.
The remaining arguments, ARGS, specify command line arguments.
The first level of ARGS is flattened, so each member of ARGS has
to be a string or a list of strings.
Option `magit-git-executable' specifies which Git executable is
used. The arguments in option `magit-git-standard-options' are
prepended to ARGS.
After Git returns, the current buffer (if it is a Magit buffer)
as well as the current repository's status buffer are refreshed.
Unmodified buffers visiting files that are tracked in the current
repository are reverted if `magit-auto-revert-mode' is active.
This function actually starts a asynchronous process, but it then
waits for that process to return."
(apply #'magit-start-git input args)
(magit-process-wait)
(magit-refresh))
(defun magit-run-git-with-logfile (file &rest args)
"Call Git in a separate process and log its output.
And log the output to FILE. This function might have a
short halflive. See `magit-run-git' for more information."
(apply #'magit-start-git nil args)
(process-put magit-this-process 'logfile file)
(set-process-filter magit-this-process 'magit-process-logfile-filter)
(magit-process-wait)
(magit-refresh))
;;;;; Asynchronous Processes
(defvar magit-this-process nil)
(defun magit-run-git-async (&rest args)
"Start Git, prepare for refresh, and return the process object.
If optional argument INPUT is non-nil, it has to be a buffer or
the name of an existing buffer. The content of that buffer is
used as the process' standard input.
The remaining arguments, ARGS, specify command line arguments.
The first level of ARGS is flattened, so each member of ARGS has
to be a string or a list of strings.
Display the command line arguments in the echo area.
After Git returns some buffers are refreshed: the buffer that was
current when `magit-start-process' was called (if it is a Magit
buffer and still alive), as well as the respective Magit status
buffer. Unmodified buffers visiting files that are tracked in
the current repository are reverted if `magit-auto-revert-mode'
is active.
See `magit-start-process' for more information."
(message "Running %s %s" magit-git-executable
(mapconcat 'identity (magit-flatten-onelevel args) " "))
(apply #'magit-start-git nil args))
(defun magit-start-git (&optional input &rest args)
"Start Git, prepare for refresh, and return the process object.
If optional argument INPUT is non-nil, it has to be a buffer or
the name of an existing buffer. The buffer content becomes the
processes standard input.
The remaining arguments, ARGS, specify command line arguments.
The first level of ARGS is flattened, so each member of ARGS has
to be a string or a list of strings.
After Git returns some buffers are refreshed: the buffer that was
current when `magit-start-process' was called (if it is a Magit
buffer and still alive), as well as the respective Magit status
buffer. Unmodified buffers visiting files that are tracked in
the current repository are reverted if `magit-auto-revert-mode'
is active.
See `magit-start-process' for more information."
(apply #'magit-start-process magit-git-executable input
(append magit-git-standard-options
(magit-process-quote-arguments args))))
(defun magit-start-process (program &optional input &rest args)
"Start PROGRAM, prepare for refresh, and return the process object.
If optional argument INPUT is non-nil, it has to be a buffer or
the name of an existing buffer. The buffer content becomes the
processes standard input.
The remaining arguments, ARGS, specify command line arguments.
The first level of ARGS is flattened, so each member of ARGS has
to be a string or a list of strings.
The process is started using `start-file-process' and then setup
to use the sentinel `magit-process-sentinel' and the filter
`magit-process-filter'. Information required by these functions
is stored in the process object. When this function returns the
process has not started to run yet so it is possible to override
the sentinel and filter.
After the process returns, `magit-process-sentinel' refreshes the
buffer that was current when `magit-start-process' was called (if
it is a Magit buffer and still alive), as well as the respective
Magit status buffer. Unmodified buffers visiting files that are
tracked in the current repository are reverted if
`magit-auto-revert-mode' is active."
(setq args (magit-flatten-onelevel args))
(cl-destructuring-bind (process-buf . section)
(magit-process-setup program args)
(let* ((process-connection-type
;; Don't use a pty, because it would set icrnl
;; which would modify the input (issue #20).
(and (not input) magit-process-connection-type))
(process (apply 'start-file-process
(file-name-nondirectory program)
process-buf program args)))
(set-process-sentinel process #'magit-process-sentinel)
(set-process-filter process #'magit-process-filter)
(set-process-buffer process process-buf)
(process-put process 'section section)
(process-put process 'command-buf (current-buffer))
(process-put process 'default-dir default-directory)
(setf (magit-section-process section) process)
(with-current-buffer process-buf
(set-marker (process-mark process) (point)))
(when input
(with-current-buffer input
(process-send-region process (point-min) (point-max))
(process-send-eof process)))
(setq magit-this-process process)
(setf (magit-section-info section) process)
(magit-process-display-buffer process)
process)))
;;;;; Process Internals
(defun magit-process-setup (program args)
(magit-process-set-mode-line program args)
(let ((buf (magit-process-buffer)))
(if buf
(magit-process-truncate-log buf)
(setq buf (magit-process-buffer nil t)))
(with-current-buffer buf
(goto-char (1- (point-max)))
(let* ((inhibit-read-only t)
(magit-with-section--parent magit-root-section)
;; Kids, don't do this ^^^^ at home.
(s (magit-with-section
(section process nil
(mapconcat 'identity (cons program args) " "))
(insert "\n"))))
(set-marker-insertion-type (magit-section-content-beginning s) nil)
(insert "\n")
(backward-char 2)
(cons (current-buffer) s)))))
(defun magit-process-truncate-log (buffer)
(with-current-buffer buffer
(let* ((head nil)
(tail (magit-section-children magit-root-section))
(count (length tail)))
(when (> (1+ count) magit-process-log-max)
(while (and (cdr tail)
(> count (/ magit-process-log-max 2)))
(let* ((inhibit-read-only t)
(section (car tail))
(process (magit-section-process section)))
(cond ((not process))
((memq (process-status process) '(exit signal))
(delete-region (magit-section-beginning section)
(1+ (magit-section-end section)))
(cl-decf count))
(t
(push section head))))
(pop tail))
(setf (magit-section-children magit-root-section)
(nconc (reverse head) tail))))))
(defun magit-process-sentinel (process event)
"Default sentinel used by `magit-start-process'."
(when (memq (process-status process) '(exit signal))
(setq event (substring event 0 -1))
(magit-process-unset-mode-line)
(when (string-match "^finished" event)
(message (concat (capitalize (process-name process)) " finished")))
(magit-process-finish process)
(when (eq process magit-this-process)
(setq magit-this-process nil))
(magit-refresh (and (buffer-live-p (process-get process 'command-buf))
(process-get process 'command-buf)))))
(defun magit-process-filter (proc string)
"Default filter used by `magit-start-process'."
(with-current-buffer (process-buffer proc)
(let ((inhibit-read-only t))
(magit-process-yes-or-no-prompt proc string)
(magit-process-username-prompt proc string)
(magit-process-password-prompt proc string)
(goto-char (process-mark proc))
(setq string (propertize string 'invisible
(magit-section-hidden
(process-get proc 'section))))
;; Find last ^M in string. If one was found, ignore everything
;; before it and delete the current line.
(let ((ret-pos (length string)))
(while (and (>= (setq ret-pos (1- ret-pos)) 0)
(/= ?\r (aref string ret-pos))))
(cond ((>= ret-pos 0)
(goto-char (line-beginning-position))
(delete-region (point) (line-end-position))
(insert-and-inherit (substring string (+ ret-pos 1))))
(t
(insert-and-inherit string))))
(set-marker (process-mark proc) (point)))))
(defun magit-process-logfile-filter (process string)
"Special filter used by `magit-run-git-with-logfile'."
(magit-process-filter process string)
(let ((file (process-get process 'logfile)))
(with-temp-file file
(when (file-exists-p file)
(insert-file-contents file)
(goto-char (point-max)))
(insert string)
(write-region (point-min) (point-max) file))))
(defun magit-process-yes-or-no-prompt (proc string)
"Forward yes-or-no prompts to the user."
(let ((beg (string-match magit-process-yes-or-no-prompt-regexp string))
(max-mini-window-height 30))
(when beg
(process-send-string
proc
(downcase
(concat (match-string (if (yes-or-no-p (substring string 0 beg)) 1 2)
string)
"\n"))))))
(defun magit-process-password-prompt (proc string)
"Forward password prompts to the user."
(let ((prompt (magit-process-match-prompt
magit-process-password-prompt-regexps string)))
(when prompt
(process-send-string proc (concat (read-passwd prompt) "\n")))))
(defun magit-process-username-prompt (proc string)
"Forward username prompts to the user."
(let ((prompt (magit-process-match-prompt
magit-process-username-prompt-regexps string)))
(when prompt
(process-send-string proc
(concat (read-string prompt nil nil
(user-login-name))
"\n")))))
(defun magit-process-match-prompt (prompts string)
(when (cl-find-if (lambda (regex)
(string-match regex string))
prompts)
(let ((prompt (match-string 0 string)))
(cond ((string-match ": $" prompt) prompt)
((string-match ":$" prompt) (concat prompt " "))
(t (concat prompt ": "))))))
(defun magit-process-wait ()
(while (and magit-this-process
(eq (process-status magit-this-process) 'run))
(sit-for 0.1 t)))
(defun magit-process-set-mode-line (program args)
(when (equal program magit-git-executable)
(setq args (nthcdr (1+ (length magit-git-standard-options)) args)))
(magit-map-magit-buffers
(apply-partially (lambda (s)
(setq mode-line-process s))
(concat " " program
(and args (concat " " (car args)))))))
(defun magit-process-unset-mode-line ()
(magit-map-magit-buffers (lambda () (setq mode-line-process nil))))
(defvar magit-process-error-message-re
(concat "^\\(?:error\\|fatal\\|git\\): \\(.*\\)" paragraph-separate))
(defun magit-process-finish (arg &optional process-buf command-buf
default-dir section)
(unless (integerp arg)
(setq process-buf (process-buffer arg)
command-buf (process-get arg 'command-buf)
default-dir (process-get arg 'default-dir)
section (process-get arg 'section)
arg (process-exit-status arg)))
(when (featurep 'dired)
(dired-uncache default-dir))
(when (buffer-live-p process-buf)
(with-current-buffer process-buf
(let ((inhibit-read-only t)
(mark (magit-section-beginning section)))
(set-marker-insertion-type mark nil)
(goto-char mark)
(insert (propertize (format "%3s " arg)
'magit-section section
'face (if (= arg 0)
'magit-process-ok
'magit-process-ng))))))
(unless (= arg 0)
(message ; `error' would prevent refresh
"%s ... [%s buffer %s for details]"
(or (and (buffer-live-p process-buf)
(with-current-buffer process-buf
(save-excursion
(goto-char (magit-section-end section))
(when (re-search-backward
magit-process-error-message-re
(magit-section-content-beginning section)
t)
(match-string 1)))))
"Git failed")
(let ((key (and (buffer-live-p command-buf)
(with-current-buffer command-buf
(car (where-is-internal
'magit-process-display-buffer))))))
(if key (format "Hit %s to see" (key-description key)) "See"))
(buffer-name process-buf)))
arg)
(defun magit-process-display-buffer (process)
(when (process-live-p process)
(let ((buf (process-buffer process)))
(cond ((not (buffer-live-p buf)))
((= magit-process-popup-time 0)
(pop-to-buffer buf))
((> magit-process-popup-time 0)
(run-with-timer magit-process-popup-time nil
(lambda (p)
(when (eq (process-status p) 'run)
(let ((buf (process-buffer p)))
(when (buffer-live-p buf)
(pop-to-buffer buf)))))
process))))))
(defun magit-process-quote-arguments (args)
"Quote each argument in list ARGS as an argument to Git.
Except when `magit-process-quote-curly-braces' is non-nil ARGS is
returned unchanged. This is required to works around strangeness
of the Windows \"Powershell\"."
(if magit-process-quote-curly-braces
(mapcar (apply-partially 'replace-regexp-in-string
"{\\([0-9]+\\)}" "\\\\{\\1\\\\}")
(magit-flatten-onelevel args))
args))
;;;; Mode Api
;;;;; Mode Foundation
(define-derived-mode magit-mode special-mode "Magit"
"Parent major mode from which Magit major modes inherit.
Please see the manual for a complete description of Magit.
\\{magit-mode-map}"
(buffer-disable-undo)
(setq truncate-lines t)
(add-hook 'pre-command-hook #'magit-remember-point nil t)
(add-hook 'post-command-hook #'magit-correct-point-after-command t t)
(add-hook 'post-command-hook #'magit-highlight-section t t)
;; Emacs' normal method of showing trailing whitespace gives weird
;; results when `magit-whitespace-warning-face' is different from
;; `trailing-whitespace'.
(when (and magit-highlight-whitespace
magit-highlight-trailing-whitespace)
(setq show-trailing-whitespace nil)))
(defvar-local magit-refresh-function nil)
(put 'magit-refresh-function 'permanent-local t)
(defvar-local magit-refresh-args nil)
(put 'magit-refresh-args 'permanent-local t)
(defmacro magit-mode-setup
(buffer switch-func mode refresh-func &rest refresh-args)
"Display and select BUFFER, turn on MODE, and refresh a first time.
Display BUFFER using `magit-mode-display-buffer', then turn on
MODE in BUFFER, set the local value of `magit-refresh-function'
to REFRESH-FUNC and that of `magit-refresh-args' to REFRESH-ARGS
and finally \"refresh\" a first time. All arguments are
evaluated before switching to BUFFER."
(let ((mode-symb (cl-gensym "mode-symb"))
(toplevel (cl-gensym "toplevel"))
(init-args (cl-gensym "init-args"))
(buf-symb (cl-gensym "buf-symb")))
`(let* ((,mode-symb ,mode)
(,toplevel (magit-get-top-dir))
(,init-args (list ,mode-symb ,refresh-func ,@refresh-args))
(,buf-symb (magit-mode-display-buffer
,buffer ,mode-symb ,switch-func)))
(if ,toplevel
(with-current-buffer ,buf-symb
(apply #'magit-mode-init ,toplevel ,init-args))
(user-error "Not inside a Git repository")))))
(defun magit-mode-init (dir mode refresh-func &rest refresh-args)
"Turn on MODE and refresh in the current buffer.
Turn on MODE, set the local value of `magit-refresh-function' to
REFRESH-FUNC and that of `magit-refresh-args' to REFRESH-ARGS and
finally \"refresh\" a first time.
Also see `magit-mode-setup', a more convenient variant."
(cl-case mode
(magit-commit-mode
(magit-setup-xref (cons #'magit-show-commit refresh-args))
(goto-char (point-min)))
(magit-diff-mode
(magit-setup-xref (cons #'magit-diff refresh-args))
(goto-char (point-min))))
(setq default-directory dir
magit-refresh-function refresh-func
magit-refresh-args refresh-args)
(funcall mode)
(magit-mode-refresh-buffer))
(defvar-local magit-previous-window-configuration nil)
(put 'magit-previous-window-configuration 'permanent-local t)
(defun magit-mode-display-buffer (buffer mode &optional switch-function)
"Display BUFFER in some window and select it.
BUFFER may be a buffer or a string, the name of a buffer. Return
the buffer.
Unless BUFFER is already displayed in the selected frame store the
previous window configuration as a buffer local value, so that it
can later be restored by `magit-mode-quit-window'.
Then display and select BUFFER using SWITCH-FUNCTION. If that is
nil either use `pop-to-buffer' if the current buffer's major mode
derives from Magit mode; or else use `switch-to-buffer'.
This is only intended for buffers whose major modes derive from
Magit mode."
(cond ((stringp buffer)
(setq buffer (magit-mode-get-buffer-create buffer mode)))
((not (bufferp buffer))
(signal 'wrong-type-argument (list 'bufferp nil))))
(unless (get-buffer-window buffer (selected-frame))
(with-current-buffer (get-buffer-create buffer)
(setq magit-previous-window-configuration
(current-window-configuration))))
(funcall (or switch-function
(if (derived-mode-p 'magit-mode)
'switch-to-buffer
'pop-to-buffer))
buffer)
buffer)
(defun magit-mode-get-buffer (format mode &optional topdir create)
(if (not (string-match-p "%[Tt]" format))
(funcall (if create #'get-buffer-create #'get-buffer) format)
(unless topdir
(setq topdir (magit-get-top-dir)))
(let ((name (format-spec
format `((?T . ,topdir)
(?t . ,(file-name-nondirectory
(directory-file-name topdir)))))))
(or (cl-find-if
(lambda (buf)
(with-current-buffer buf
(and (or (not mode) (eq major-mode mode))
(equal (expand-file-name default-directory) topdir)
(string-match-p (format "^%s\\(?:<[0-9]+>\\)?$"
(regexp-quote name))
(buffer-name)))))
(buffer-list))
(and create (generate-new-buffer name))))))
(defun magit-mode-get-buffer-create (format mode &optional topdir)
(magit-mode-get-buffer format mode topdir t))
(cl-defun magit-mode-refresh-buffer (&optional (buffer (current-buffer)))
(with-current-buffer buffer
(when magit-refresh-function
(let* ((old-line (line-number-at-pos))
(old-point (point))
(old-section (magit-current-section))
(old-path (and old-section
(magit-section-path (magit-current-section)))))
(beginning-of-line)
(let ((inhibit-read-only t)
(section-line (and old-section
(count-lines
(magit-section-beginning old-section)
(point))))
(line-char (- old-point (point))))
(erase-buffer)
(apply magit-refresh-function
magit-refresh-args)
(let ((s (and old-path (magit-find-section old-path magit-root-section))))
(cond (s
(goto-char (magit-section-beginning s))
(forward-line section-line)
(forward-char line-char))
(t
(save-restriction
(widen)
(goto-char (point-min))
(forward-line (1- old-line)))))))
(magit-highlight-section)
(magit-refresh-marked-commits-in-buffer)))))
(defun magit-mode-quit-window (&optional kill-buffer)
"Bury the current buffer and delete its window.
With a prefix argument, kill the buffer instead.
If `magit-restore-window-configuration' is non-nil and the last
configuration stored by `magit-mode-display-buffer' originates
from the selected frame then restore it after burrying/killing
the buffer. Finally reset the window configuration to nil."
(interactive "P")
(let ((winconf magit-previous-window-configuration)
(buffer (current-buffer))
(frame (selected-frame)))
(quit-window kill-buffer (selected-window))
(when winconf
(when (and magit-restore-window-configuration
(equal frame (window-configuration-frame winconf)))
(set-window-configuration winconf)
(when (buffer-live-p buffer)
(with-current-buffer buffer
(setq magit-previous-window-configuration nil)))))
(run-hook-with-args 'magit-mode-quit-window-hook buffer)))
;;;;; Mode Utilities
(defun magit-map-magit-buffers (func &optional dir)
(dolist (buf (buffer-list))
(with-current-buffer buf
(when (and (derived-mode-p 'magit-mode)
(or (null dir)
(equal default-directory dir)))
(funcall func)))))
;;;;; (section kludges)
(defvar-local magit-last-point nil)
(put 'magit-last-point 'permanent-local t)
(defun magit-remember-point ()
(setq magit-last-point (point)))
(defun magit-invisible-region-end (pos)
(while (and (not (= pos (point-max))) (invisible-p pos))
(setq pos (next-char-property-change pos)))
pos)
(defun magit-invisible-region-start (pos)
(while (and (not (= pos (point-min))) (invisible-p pos))
(setq pos (1- (previous-char-property-change pos))))
pos)
(defun magit-correct-point-after-command ()
"Move point outside of invisible regions.
Emacs often leaves point in invisible regions, it seems. To fix
this, we move point ourselves and never let Emacs do its own
adjustments.
When point has to be moved out of an invisible region, it can be
moved to its end or its beginning. We usually move it to its
end, except when that would move point back to where it was
before the last command."
(when (invisible-p (point))
(let ((end (magit-invisible-region-end (point))))
(goto-char (if (= end magit-last-point)
(magit-invisible-region-start (point))
end))))
(setq disable-point-adjustment t))
;;;;; Buffer History
(defun magit-go-backward ()
"Move backward in current buffer's history."
(interactive)
(if help-xref-stack
(help-xref-go-back (current-buffer))
(user-error "No previous entry in buffer's history")))
(defun magit-go-forward ()
"Move forward in current buffer's history."
(interactive)
(if help-xref-forward-stack
(help-xref-go-forward (current-buffer))
(user-error "No next entry in buffer's history")))
(defun magit-xref-insert-buttons ()
(when (and (or (eq magit-show-xref-buttons t)
(apply 'derived-mode-p magit-show-xref-buttons))
(or help-xref-stack help-xref-forward-stack))
(insert "\n")
(when help-xref-stack
(magit-xref-insert-button help-back-label
'magit-xref-backward))
(when help-xref-forward-stack
(when help-xref-stack
(insert " "))
(magit-xref-insert-button help-forward-label
'magit-xref-forward))))
(defun magit-xref-insert-button (label type)
(magit-with-section (section button label)
(insert-text-button label 'type type
'help-args (list (current-buffer)))))
(define-button-type 'magit-xref-backward
:supertype 'help-back
'mouse-face magit-item-highlight-face
'help-echo (purecopy "mouse-2, RET: go back to previous history entry"))
(define-button-type 'magit-xref-forward
:supertype 'help-forward
'mouse-face magit-item-highlight-face
'help-echo (purecopy "mouse-2, RET: go back to next history entry"))
(defun magit-setup-xref (item)
(when help-xref-stack-item
(push (cons (point) help-xref-stack-item) help-xref-stack)
(setq help-xref-forward-stack nil))
(when (called-interactively-p 'interactive)
(let ((tail (nthcdr 10 help-xref-stack)))
(if tail (setcdr tail nil))))
(setq help-xref-stack-item item))
;;;;; Refresh Machinery
(defun magit-refresh (&optional buffer)
"Refresh some buffers belonging to the current repository.
Refresh the current buffer if its major mode derives from
`magit-mode', and refresh the corresponding status buffer.
If the global `magit-auto-revert-mode' is turned on, then
also revert all unmodified buffers that visit files being
tracked in the current repository."
(interactive (list (current-buffer)))
(unless buffer
(setq buffer (current-buffer)))
(with-current-buffer buffer
(when (derived-mode-p 'magit-mode)
(magit-mode-refresh-buffer buffer))
(let (status)
(when (and (not (eq major-mode 'magit-status-mode))
(setq status (magit-mode-get-buffer
magit-status-buffer-name
'magit-status-mode)))
(magit-mode-refresh-buffer status))))
(when magit-auto-revert-mode
(magit-revert-buffers)))
(defun magit-refresh-all ()
"Refresh all buffers belonging to the current repository.
Refresh all Magit buffers belonging to the current repository.
If the global `magit-auto-revert-mode' is turned on, then also
revert all unmodified buffers that visit files being tracked in
the current repository."
(interactive)
(magit-map-magit-buffers #'magit-mode-refresh-buffer default-directory)
(magit-revert-buffers))
(defun magit-revert-buffers ()
(let ((topdir (magit-get-top-dir)))
(when topdir
(let ((gitdir (magit-git-dir))
(tracked (magit-git-lines "ls-tree" "-r" "--name-only" "HEAD")))
(dolist (buf (buffer-list))
(with-current-buffer buf
(let ((file (buffer-file-name)))
(and file (string-prefix-p topdir file)
(not (string-prefix-p gitdir file))
(member (file-relative-name file topdir) tracked)
(let ((auto-revert-mode t))
(auto-revert-handler)
(run-hooks 'magit-revert-buffer-hook))))))))))
;;; (misplaced)
;;;; Diff Options
(defvar magit-diff-context-lines 3)
(defun magit-diff-U-arg ()
(format "-U%d" magit-diff-context-lines))
(defun magit-diff-smaller-hunks (&optional count)
"Decrease the context for diff hunks by COUNT."
(interactive "p")
(setq magit-diff-context-lines (max 0 (- magit-diff-context-lines count)))
(magit-refresh))
(defun magit-diff-larger-hunks (&optional count)
"Increase the context for diff hunks by COUNT."
(interactive "p")
(setq magit-diff-context-lines (+ magit-diff-context-lines count))
(magit-refresh))
(defun magit-diff-default-hunks ()
"Reset context for diff hunks to the default size."
(interactive)
(setq magit-diff-context-lines 3)
(magit-refresh))
(defun magit-set-diff-options ()
"Set local `magit-diff-options' based on popup state.
And refresh the current Magit buffer."
(interactive)
(setq-local magit-diff-options magit-custom-options)
(magit-refresh))
;; `magit-set-default-diff-options' is defined in "Options"/"Setters".
(defun magit-save-default-diff-options ()
"Set and save the default for `magit-diff-options' based on popup value.
Also set the local value in all Magit buffers and refresh them."
(interactive)
(customize-save-variable 'magit-diff-options magit-custom-options))
(defun magit-reset-diff-options ()
"Reset local `magit-diff-options' to default value.
And refresh the current Magit buffer."
(interactive)
(setq-local magit-diff-options (default-value 'magit-diff-options))
(magit-refresh))
;;;; Raw Diff Washing
(defun magit-insert-diff (section file status)
(let ((beg (point)))
(apply 'magit-git-insert "-c" "diff.submodule=short" "diff"
`(,(magit-diff-U-arg) ,@magit-diff-options "--" ,file))
(unless (eq (char-before) ?\n)
(insert "\n"))
(save-restriction
(narrow-to-region beg (point))
(goto-char beg)
(magit-wash-diff-section section)
(goto-char (point-max)))))
(defun magit-wash-raw-diffs (&optional staged)
(let (previous)
(magit-wash-sequence
(lambda ()
(setq previous (magit-wash-raw-diff previous staged))))))
(defun magit-wash-raw-diff (previous staged)
(when (looking-at
":\\([0-7]+\\) \\([0-7]+\\) [0-9a-f]+ [0-9a-f]+ \\(.\\)[0-9]*\t\\([^\t\n]+\\)$")
(let ((file (magit-decode-git-path (match-string-no-properties 4)))
(status (cl-ecase (string-to-char (match-string-no-properties 3))
(?A 'new)
(?C 'copy)
(?D 'deleted)
(?M 'modified)
(?T 'typechange)
(?U 'unmerged)
(?X 'unknown))))
(delete-region (point) (1+ (line-end-position)))
(unless (or ;; Unmerged files get two entries; we ignore the second.
(equal file previous)
;; Ignore staged, unmerged files.
(and staged (eq status 'unmerged)))
(magit-with-section (section diff file nil nil
(not (derived-mode-p
'magit-diff-mode
'magit-commit-mode)))
(if (not (magit-section-hidden section))
(magit-insert-diff section file status)
(setf (magit-section-diff-status section) status)
(setf (magit-section-needs-refresh-on-show section) t)
(magit-insert-diff-title status file nil))))
file)))
;;; Modes (1)
;;;; Commit Mode
;;;;; Commit Core
(define-derived-mode magit-commit-mode magit-mode "Magit"
"Mode for looking at a git commit.
\\<magit-commit-mode-map>Type `\\[magit-visit-item]` to visit the changed file, \
`\\[magit-toggle-section]` to hide or show a hunk,
`\\[magit-diff-larger-hunks]` and `\\[magit-diff-smaller-hunks]` to change the \
size of the hunks.
Type `\\[magit-apply-item]` to apply a change to your worktree and \
`\\[magit-revert-item]` to reverse it.
\\{magit-commit-mode-map}
Unless shadowed by the mode specific bindings above, bindings
from the parent keymap `magit-mode-map' are also available."
:group 'magit)
(defvar magit-commit-buffer-name "*magit-commit*"
"Name of buffer used to display a commit.")
;;;###autoload
(defun magit-show-commit (commit &optional noselect)
"Show information about COMMIT."
(interactive (list (magit-read-rev-with-default
"Show commit (hash or ref)")))
(when (magit-git-failure "cat-file" "commit" commit)
(user-error "%s is not a commit" commit))
(magit-mode-setup magit-commit-buffer-name
(if noselect 'display-buffer 'pop-to-buffer)
#'magit-commit-mode
#'magit-refresh-commit-buffer
commit))
(defun magit-show-item-or-scroll-up ()
"Update commit or status buffer for item at point.
Either show the commit or stash at point in another buffer,
or if that buffer is already displayed in the current frame
and contains information about that commit or stash, then
instead scroll the buffer up. If there is no commit or
stash at point, then prompt for a commit."
(interactive)
(magit-show-item-or-scroll 'scroll-up))
(defun magit-show-item-or-scroll-down ()
"Update commit or status buffer for item at point.
Either show the commit or stash at point in another buffer,
or if that buffer is already displayed in the current frame
and contains information about that commit or stash, then
instead scroll the buffer down. If there is no commit or
stash at point, then prompt for a commit."
(interactive)
(magit-show-item-or-scroll 'scroll-down))
(defun magit-show-item-or-scroll (fn)
(let (rev cmd buf win)
(magit-section-case (info)
(commit (setq rev info
cmd 'magit-show-commit
buf magit-commit-buffer-name))
(stash (setq rev info
cmd 'magit-diff-stash
buf magit-stash-buffer-name)))
(if rev
(if (and (setq buf (get-buffer buf))
(setq win (get-buffer-window buf))
(with-current-buffer buf
(equal rev (car magit-refresh-args))))
(with-selected-window win
(condition-case err
(funcall fn)
(error
(goto-char (cl-case fn
(scroll-up (point-min))
(scroll-down (point-max)))))))
(funcall cmd rev t))
(call-interactively 'magit-show-commit))))
(defun magit-refresh-commit-buffer (commit)
(magit-git-insert-section (commitbuf nil)
#'magit-wash-commit
"log" "-1" "--decorate=full"
"--pretty=medium" (magit-diff-U-arg)
"--cc" "-p" (and magit-show-diffstat "--stat")
magit-diff-options commit))
;;;;; Commit Washing
(defun magit-wash-commit ()
(looking-at "^commit \\([a-z0-9]+\\)\\(?: \\(.+\\)\\)?$")
(let ((rev (match-string 1))
(refs (match-string 2)))
(delete-region (point) (1+ (line-end-position)))
(magit-with-section
(section headers 'headers
(concat (propertize rev 'face 'magit-log-sha1)
(and refs (concat " "(magit-format-ref-labels refs)))
"\n"))
(while (re-search-forward "^\\([a-z]+\\): +\\(.+\\)$" nil t)
(when (string-match-p (match-string 1) "Merge")
(let ((revs (match-string 2)))
(delete-region (match-beginning 2) (match-end 2))
(dolist (rev (split-string revs))
(magit-insert-commit-button rev)
(insert ?\s)))))
(forward-line)))
(forward-line)
(let ((bound (save-excursion
(when (re-search-forward "^diff" nil t)
(copy-marker (match-beginning 0)))))
(summary (buffer-substring-no-properties
(point) (line-end-position))))
(delete-region (point) (1+ (line-end-position)))
(magit-with-section (section message 'message (concat summary "\n"))
(cond ((re-search-forward "^---" bound t)
(goto-char (match-beginning 0))
(delete-region (match-beginning 0) (match-end 0)))
((re-search-forward "^.[^ ]" bound t)
(goto-char (1- (match-beginning 0)))))))
(forward-line)
(when magit-show-diffstat
(magit-wash-diffstats))
(forward-line)
(magit-wash-diffs))
(defun magit-insert-commit-button (hash)
(magit-with-section (section commit hash)
(insert-text-button hash
'help-echo "Visit commit"
'action (lambda (button)
(save-excursion
(goto-char button)
(magit-visit-item)))
'follow-link t
'mouse-face magit-item-highlight-face
'face 'magit-log-sha1)))
;;;; Status Mode
(define-derived-mode magit-status-mode magit-mode "Magit"
"Mode for looking at git status.
\\<magit-status-mode-map>Type `\\[magit-stage-item]` to stage (add) an item, \
`\\[magit-unstage-item]` to unstage it.
Type `\\[magit-key-mode-popup-committing]` to have a popup to commit, type \
`\\[magit-key-mode-popup-dispatch]` to see others
available popup.
Type `\\[magit-visit-item]` to visit something, and \
`\\[magit-toggle-section]` to show or hide section.
More information can be found in Info node `(magit)Status'
Other key binding:
\\{magit-status-mode-map}"
:group 'magit)
(defvar magit-status-buffer-name "*magit: %t*"
"Name of buffer used to display a repository's status.")
;;;###autoload
(defun magit-status (dir &optional switch-function)
"Open a Magit status buffer for the Git repository containing DIR.
If DIR is not within a Git repository, offer to create a Git
repository in DIR.
Interactively, a prefix argument means to ask the user which Git
repository to use even if `default-directory' is under Git
control. Two prefix arguments means to ignore `magit-repo-dirs'
when asking for user input.
Depending on option `magit-status-buffer-switch-function' the
status buffer is shown in another window (the default) or the
current window. Non-interactively optional SWITCH-FUNCTION
can be used to override this."
(interactive (list (if current-prefix-arg
(magit-read-top-dir
(> (prefix-numeric-value current-prefix-arg)
4))
(or (magit-get-top-dir)
(magit-read-top-dir nil)))))
(magit-save-some-buffers)
(let ((topdir (magit-get-top-dir dir)))
(when (or topdir
(and (yes-or-no-p
(format "There is no Git repository in %s. Create one? "
dir))
(progn
(magit-init dir)
(setq topdir (magit-get-top-dir dir)))))
(let ((default-directory topdir))
(magit-mode-setup magit-status-buffer-name
(or switch-function
magit-status-buffer-switch-function)
#'magit-status-mode
#'magit-refresh-status)))))
(defalias 'magit-status-internal 'magit-status) ; forward compatibility
(defun magit-refresh-status ()
(magit-git-exit-code "update-index" "--refresh")
(magit-with-section (section status 'status nil t)
(run-hooks 'magit-status-sections-hook))
(run-hooks 'magit-refresh-status-hook))
;;; Sections
;;;; Real Sections
(defun magit-insert-stashes ()
;; #1427 Set log.date to work around an issue in Git <1.7.10.3.
(let ((stashes (magit-git-lines "-c" "log.date=default" "stash" "list")))
(when stashes
(magit-with-section (section stashes 'stashes "Stashes:" t)
(dolist (stash stashes)
(string-match "^\\(stash@{\\([0-9]+\\)}\\): \\(.+\\)$" stash)
(let ((stash (match-string 1 stash))
(number (match-string 2 stash))
(message (match-string 3 stash)))
(magit-with-section (section stash stash)
(insert number ": " message "\n"))))
(insert "\n")))))
(defun magit-insert-untracked-files ()
(magit-with-section (section untracked 'untracked "Untracked files:" t)
(let ((files (cl-mapcan
(lambda (f)
(when (eq (aref f 0) ??) (list f)))
(magit-git-lines
"status" "--porcelain"))))
(if (not files)
(setq section nil)
(dolist (file files)
(setq file (magit-decode-git-path (substring file 3)))
(magit-with-section (section file file)
(insert "\t" file "\n")))
(insert "\n")))))
(defun magit-insert-pending-commits ()
(let* ((info (magit-read-rewrite-info))
(pending (cdr (assq 'pending info))))
(when pending
(magit-with-section (section pending 'pending "Pending commits:" t)
(dolist (p pending)
(let* ((commit (car p))
(properties (cdr p))
(used (plist-get properties 'used)))
(magit-with-section (section commit commit)
(insert (magit-git-string
"log" "-1"
(if used
"--pretty=format:. %s"
"--pretty=format:* %s")
commit "--")
"\n")))))
(insert "\n"))))
(defun magit-insert-unstaged-changes ()
(let ((magit-current-diff-range (cons 'index 'working))
(magit-diff-options (copy-sequence magit-diff-options)))
(magit-git-insert-section (unstaged "Unstaged changes:")
#'magit-wash-raw-diffs
"diff-files")))
(defun magit-insert-staged-changes ()
(let ((no-commit (not (magit-git-success "log" "-1" "HEAD"))))
(when (or no-commit (magit-anything-staged-p))
(let ((magit-current-diff-range (cons "HEAD" 'index))
(base (if no-commit
(magit-git-string "mktree")
"HEAD"))
(magit-diff-options (append '("--cached") magit-diff-options)))
(magit-git-insert-section (staged "Staged changes:")
(apply-partially #'magit-wash-raw-diffs t)
"diff-index" "--cached" base)))))
(defun magit-insert-unpulled-or-recent-commits ()
(let ((tracked (magit-get-tracked-branch nil t)))
(if (and tracked
(not (equal (magit-git-string "rev-parse" "HEAD")
(magit-git-string "rev-parse" tracked))))
(magit-insert-unpulled-commits)
(magit-git-insert-section (recent "Recent commits:")
(apply-partially 'magit-wash-log 'unique)
"log" "--format=format:%h %s" "-n" "10"))))
(defun magit-insert-unpulled-commits ()
(let ((tracked (magit-get-tracked-branch nil t)))
(when tracked
(magit-git-insert-section (unpulled "Unpulled commits:")
(apply-partially 'magit-wash-log 'unique)
"log" "--format=format:%h %s" (concat "HEAD.." tracked)))))
(defun magit-insert-unpushed-commits ()
(let ((tracked (magit-get-tracked-branch nil t)))
(when tracked
(magit-git-insert-section (unpushed "Unpushed commits:")
(apply-partially 'magit-wash-log 'unique)
"log" "--format=format:%h %s" (concat tracked "..HEAD")))))
(defun magit-insert-unpulled-cherries ()
(let ((tracked (magit-get-tracked-branch nil t)))
(when tracked
(magit-git-insert-section (unpulled "Unpulled commits:")
(apply-partially 'magit-wash-log 'cherry)
"cherry" "-v" (magit-abbrev-arg) (magit-get-current-branch) tracked))))
(defun magit-insert-unpushed-cherries ()
(let ((tracked (magit-get-tracked-branch nil t)))
(when tracked
(magit-git-insert-section (unpushed "Unpushed commits:")
(apply-partially 'magit-wash-log 'cherry)
"cherry" "-v" (magit-abbrev-arg) tracked))))
;;;; Line Sections
(defun magit-insert-empty-line ()
(insert "\n"))
(defun magit-insert-status-local-line ()
(let ((branch (or (magit-get-current-branch) "(detached)")))
(magit-insert-line-section (branch branch)
(concat "Local: "
(propertize branch 'face 'magit-branch)
" " (abbreviate-file-name default-directory)))))
(defun magit-insert-status-remote-line ()
(let* ((branch (magit-get-current-branch))
(tracked (magit-get-tracked-branch branch)))
(when tracked
(magit-insert-line-section (branch tracked)
(concat "Remote: "
(and (magit-get-boolean "branch" branch "rebase") "onto ")
(magit-format-tracked-line tracked branch))))))
(defun magit-format-tracked-line (tracked branch)
(when tracked
(setq tracked (propertize tracked 'face 'magit-branch))
(let ((remote (magit-get "branch" branch "remote")))
(concat (if (string= "." remote)
(concat "branch " tracked)
(when (string-match (concat "^" remote) tracked)
(setq tracked (substring tracked (1+ (length remote)))))
(concat tracked " @ " remote
" (" (magit-get "remote" remote "url") ")"))))))
(defun magit-insert-status-head-line ()
(let ((hash (magit-git-string "rev-parse" "--verify" "HEAD")))
(if hash
(magit-insert-line-section (commit hash)
(concat "Head: " (magit-format-rev-summary "HEAD")))
(magit-insert-line-section (no-commit)
"Head: nothing committed yet"))))
(defun magit-insert-status-tags-line ()
(let* ((current-tag (magit-get-current-tag t))
(next-tag (magit-get-next-tag t))
(both-tags (and current-tag next-tag t))
(tag-subject (eq magit-status-tags-line-subject 'tag)))
(when (or current-tag next-tag)
(magit-insert-line-section (line)
(concat
(if both-tags "Tags: " "Tag: ")
(and current-tag (apply 'magit-format-status-tag-sentence
tag-subject current-tag))
(and both-tags ", ")
(and next-tag (apply 'magit-format-status-tag-sentence
(not tag-subject) next-tag)))))))
(defun magit-format-status-tag-sentence (behindp tag cnt &rest ignored)
(concat (propertize tag 'face 'magit-tag)
(and (> cnt 0)
(concat (if (eq magit-status-tags-line-subject 'tag)
(concat " (" (propertize (format "%s" cnt)
'face 'magit-branch))
(format " (%i" cnt))
" " (if behindp "behind" "ahead") ")"))))
;;;; Progress Sections
(defun magit-insert-status-merge-line ()
(let ((heads (magit-file-lines (magit-git-dir "MERGE_HEAD"))))
(when heads
(magit-insert-line-section (line)
(concat
"Merging: "
(mapconcat 'identity (mapcar 'magit-name-rev heads) ", ")
(and magit-status-show-sequence-help
"; Resolve conflicts, or press \"m A\" to Abort"))))))
(defun magit-insert-status-rebase-lines ()
(let ((rebase (magit-rebase-info)))
(when rebase
(magit-insert-line-section (line)
(concat (if (nth 4 rebase) "Applying" "Rebasing")
(apply 'format ": onto %s (%s of %s)" rebase)
(and magit-status-show-sequence-help
"; Press \"R\" to Abort, Skip, or Continue")))
(when (and (null (nth 4 rebase)) (nth 3 rebase))
(magit-insert-line-section (line)
(concat "Stopped: "
(magit-format-rev-summary (nth 3 rebase))))))))
(defun magit-insert-rebase-sequence ()
(let ((f (magit-git-dir "rebase-merge/git-rebase-todo")))
(when (file-exists-p f)
(magit-with-section (section rebase-todo 'rebase-todo "Rebasing:" t)
(cl-loop
for line in (magit-file-lines f)
when (string-match
"^\\(pick\\|reword\\|edit\\|squash\\|fixup\\) \\([^ ]+\\) \\(.*\\)$"
line)
do (let ((cmd (match-string 1 line))
(hash (match-string 2 line))
(msg (match-string 3 line)))
(magit-with-section (section commit hash)
(insert cmd " ")
(insert (propertize
(magit-git-string "rev-parse" "--short" hash)
'face 'magit-log-sha1))
(insert " " msg "\n"))))
(insert "\n")))))
(defun magit-insert-bisect-output ()
(when (magit-bisecting-p)
(let ((lines
(or (magit-file-lines (magit-git-dir "BISECT_CMD_OUTPUT"))
(list "Bisecting: (no saved bisect output)"
"It appears you have invoked `git bisect' from a shell."
"There is nothing wrong with that, we just cannot display"
"anything useful here. Consult the shell output instead.")))
(done-re "^[a-z0-9]\\{40\\} is the first bad commit$"))
(magit-with-section
(section bisect-output 'bisect-output
(propertize
(or (and (string-match done-re (car lines)) (pop lines))
(cl-find-if (apply-partially 'string-match done-re)
lines)
(pop lines))
'face 'magit-section-title)
t t)
(dolist (line lines)
(insert line "\n"))))
(insert "\n")))
(defun magit-insert-bisect-rest ()
(when (magit-bisecting-p)
(magit-git-insert-section (bisect-view "Bisect Rest:")
(apply-partially 'magit-wash-log 'bisect-vis)
"bisect" "visualize" "git" "log"
"--pretty=format:%h%d %s" "--decorate=full")))
(defun magit-insert-bisect-log ()
(when (magit-bisecting-p)
(magit-git-insert-section (bisect-log "Bisect Log:")
#'magit-wash-bisect-log
"bisect" "log")))
(defun magit-wash-bisect-log ()
(let (beg)
(while (progn (setq beg (point-marker))
(re-search-forward "^\\(git bisect [^\n]+\n\\)" nil t))
(let ((heading (match-string-no-properties 1)))
(delete-region (match-beginning 0) (match-end 0))
(save-restriction
(narrow-to-region beg (point))
(goto-char (point-min))
(magit-with-section (section bisect-log 'bisect-log heading nil t)
(magit-wash-sequence
(apply-partially 'magit-wash-log-line 'bisect-log
(magit-abbrev-length)))))))
(when (re-search-forward
"# first bad commit: \\[\\([a-z0-9]\\{40\\}\\)\\] [^\n]+\n" nil t)
(let ((hash (match-string-no-properties 1)))
(delete-region (match-beginning 0) (match-end 0))
(magit-with-section
(section 'bisect-log 'bisect-log
(concat hash " is the first bad commit\n")))))))
(defun magit-bisecting-p ()
(file-exists-p (magit-git-dir "BISECT_LOG")))
;;; Utilities (2)
;;;; Save Buffers
(defvar magit-default-directory nil)
(defun magit-save-some-buffers (&optional msg pred topdir)
"Save some buffers if variable `magit-save-some-buffers' is non-nil.
If variable `magit-save-some-buffers' is set to `dontask' then
don't ask the user before saving the buffers, just go ahead and
do it.
Optional argument MSG is displayed in the minibuffer if variable
`magit-save-some-buffers' is nil.
Optional second argument PRED determines which buffers are considered:
If PRED is nil, all the file-visiting buffers are considered.
If PRED is t, then certain non-file buffers will also be considered.
If PRED is a zero-argument function, it indicates for each buffer whether
to consider it or not when called with that buffer current."
(interactive)
(let ((predicate-function (or pred magit-save-some-buffers-predicate))
(magit-default-directory (or topdir default-directory)))
(if magit-save-some-buffers
(save-some-buffers
(eq magit-save-some-buffers 'dontask)
predicate-function)
(when msg
(message msg)))))
(defun magit-save-buffers-predicate-all ()
"Prompt to save all buffers with unsaved changes."
t)
(defun magit-save-buffers-predicate-tree-only ()
"Only prompt to save buffers which are within the current git project.
As determined by the directory passed to `magit-status'."
(and buffer-file-name
(let ((topdir (magit-get-top-dir magit-default-directory)))
(and topdir
(equal (file-remote-p topdir) (file-remote-p buffer-file-name))
;; ^ Avoid needlessly connecting to unrelated tramp remotes.
(string= topdir (magit-get-top-dir
(file-name-directory buffer-file-name)))))))
;;; Porcelain
;;;; Apply
;;;;; Apply Commands
;;;;;; Apply
(defun magit-apply-item ()
"Apply the item at point to the current working tree."
(interactive)
(magit-section-action apply (info)
(([* unstaged] [* staged])
(user-error "Change is already in your working tree"))
(hunk (magit-apply-hunk-item it))
(diff (magit-apply-diff-item it))
(stash (magit-stash-apply info))
(commit (magit-apply-commit info))))
;;;;;; Stage
(defun magit-stage-item (&optional file)
"Add the item at point to the staging area.
With a prefix argument, prompt for a file to be staged instead."
(interactive
(when current-prefix-arg
(list (file-relative-name (read-file-name "File to stage: " nil nil t)
(magit-get-top-dir)))))
(if file
(magit-run-git "add" file)
(magit-section-action stage (info)
([file untracked]
(magit-run-git
(cond
((use-region-p)
(cons "add" (magit-section-region-siblings #'magit-section-info)))
((and (string-match-p "/$" info)
(file-exists-p (expand-file-name ".git" info)))
(let ((repo (read-string
"Add submodule tracking remote repo (empty to abort): "
(let ((default-directory
(file-name-as-directory
(expand-file-name info default-directory))))
(magit-get "remote.origin.url")))))
(if (equal repo "")
(user-error "Abort")
(list "submodule" "add" repo (substring info 0 -1)))))
(t
(list "add" info)))))
(untracked
(magit-run-git "add" "--" (magit-git-lines "ls-files" "--other"
"--exclude-standard")))
([hunk diff unstaged]
(magit-apply-hunk-item it "--cached"))
([diff unstaged]
(magit-run-git "add" "-u"
(if (use-region-p)
(magit-section-region-siblings #'magit-section-info)
info)))
(unstaged
(magit-stage-all))
([* staged]
(user-error "Already staged"))
(hunk (user-error "Can't stage this hunk"))
(diff (user-error "Can't stage this diff")))))
;;;###autoload
(defun magit-stage-all (&optional including-untracked)
"Add all remaining changes in tracked files to staging area.
With a prefix argument, add remaining untracked files as well.
\('git add [-u] .')."
(interactive "P")
(when (or (not magit-stage-all-confirm)
(not (magit-anything-staged-p))
(yes-or-no-p "Stage all changes? "))
(if including-untracked
(magit-run-git "add" ".")
(magit-run-git "add" "-u" "."))))
;;;;;; Unstage
(defun magit-unstage-item ()
"Remove the item at point from the staging area."
(interactive)
(magit-section-action unstage (info)
([hunk diff staged]
(magit-apply-hunk-item it "--reverse" "--cached"))
([diff staged]
(when (eq info 'unmerged)
(user-error "Can't unstage an unmerged file. Resolve it first"))
(let ((files (if (use-region-p)
(magit-section-region-siblings #'magit-section-info)
(list info))))
(if (magit-no-commit-p)
(magit-run-git "rm" "--cached" "--" files)
(magit-run-git "reset" "-q" "HEAD" "--" files))))
(staged
(magit-unstage-all))
([* unstaged]
(user-error "Already unstaged"))
(hunk (user-error "Can't unstage this hunk"))
(diff (user-error "Can't unstage this diff"))))
;;;###autoload
(defun magit-unstage-all ()
"Remove all changes from staging area.
\('git reset --mixed HEAD')."
(interactive)
(when (or (not magit-unstage-all-confirm)
(and (not (magit-anything-unstaged-p))
(not (magit-git-lines "ls-files" "--others" "-t"
"--exclude-standard")))
(yes-or-no-p "Unstage all changes? "))
(magit-run-git "reset" "HEAD" "--")))
;;;;;; Discard
(defun magit-discard-item ()
"Remove the change introduced by the item at point."
(interactive)
(magit-section-action discard (info parent-info)
([file untracked]
(when (yes-or-no-p (format "Delete %s? " info))
(if (and (file-directory-p info)
(not (file-symlink-p info)))
(delete-directory info 'recursive)
(delete-file info))
(magit-refresh)))
(untracked
(when (yes-or-no-p "Delete all untracked files and directories? ")
(magit-run-git "clean" "-df")))
([hunk diff unstaged]
(when (yes-or-no-p (if (use-region-p)
"Discard changes in region? "
"Discard hunk? "))
(magit-apply-hunk-item it "--reverse")))
([hunk diff staged]
(if (magit-file-uptodate-p parent-info)
(when (yes-or-no-p (if (use-region-p)
"Discard changes in region? "
"Discard hunk? "))
(magit-apply-hunk-item it "--reverse" "--index"))
(user-error "Can't discard this hunk. Please unstage it first")))
([diff unstaged]
(magit-discard-diff it nil))
([diff staged]
(if (magit-file-uptodate-p (magit-section-info it))
(magit-discard-diff it t)
(user-error "Can't discard staged changes to this file. \
Please unstage it first")))
(hunk (user-error "Can't discard this hunk"))
(diff (user-error "Can't discard this diff"))
(stash (when (yes-or-no-p "Discard stash? ")
(magit-stash-drop info)))
(branch (when (yes-or-no-p
(if current-prefix-arg
(concat "Force delete branch [" info "]? ")
(concat "Delete branch [" info "]? ")))
(magit-delete-branch info current-prefix-arg)))
(remote (when (yes-or-no-p "Remove remote? ")
(magit-remove-remote info)))))
;;;;;; Revert
(defun magit-revert-item ()
"Revert the item at point.
The change introduced by the item is reversed in the current
working tree."
(interactive)
(magit-section-action revert (info)
([* unstaged] (magit-discard-item))
(commit (when (or (not magit-revert-item-confirm)
(yes-or-no-p "Revert this commit? "))
(magit-revert-commit info)))
(diff (when (or (not magit-revert-item-confirm)
(yes-or-no-p "Revert this diff? "))
(magit-apply-diff-item it "--reverse")))
(hunk (when (or (not magit-revert-item-confirm)
(yes-or-no-p "Revert this hunk? "))
(magit-apply-hunk-item it "--reverse")))))
(defun magit-revert-commit (commit)
(magit-assert-one-parent commit "revert")
(magit-run-git "revert" "--no-commit" commit))
(defconst magit-revert-backup-file "magit/reverted.diff")
(defun magit-revert-undo ()
"Re-apply the previously reverted hunk.
Also see option `magit-revert-backup'."
(interactive)
(let ((file (magit-git-dir magit-revert-backup-file)))
(if (file-readable-p file)
(magit-run-git "apply" file)
(user-error "No backups exist"))
(magit-refresh)))
;;;;; Apply Core
(defun magit-discard-diff (diff stagedp)
(let ((file (magit-section-info diff)))
(cl-case (magit-section-diff-status diff)
(deleted
(when (yes-or-no-p (format "Resurrect %s? " file))
(when stagedp
(magit-run-git "reset" "-q" "--" file))
(magit-run-git "checkout" "--" file)))
(new
(when (yes-or-no-p (format "Delete %s? " file))
(magit-run-git "rm" "-f" "--" file)))
(t
(when (yes-or-no-p (format "Discard changes to %s? " file))
(if stagedp
(magit-run-git "checkout" "HEAD" "--" file)
(magit-run-git "checkout" "--" file)))))))
(defun magit-apply-commit (commit)
(magit-assert-one-parent commit "cherry-pick")
(magit-run-git "cherry-pick" "--no-commit" commit))
(defun magit-apply-diff-item (diff &rest args)
(when (zerop magit-diff-context-lines)
(setq args (cons "--unidiff-zero" args)))
(let ((buf (generate-new-buffer " *magit-input*")))
(unwind-protect
(progn (magit-insert-diff-item-patch diff buf)
(magit-run-git-with-input
buf "apply" args "--ignore-space-change" "-"))
(kill-buffer buf))))
(defun magit-apply-hunk-item (hunk &rest args)
"Apply single hunk or part of a hunk to the index or working file.
This function is the core of magit's stage, unstage, apply, and
revert operations. HUNK (or the portion of it selected by the
region) will be applied to either the index, if \"--cached\" is a
member of ARGS, or to the working file otherwise."
(when (string-match "^diff --cc" (magit-section-parent-info hunk))
(user-error (concat "Cannot un-/stage individual resolution hunks. "
"Please stage the whole file.")))
(let ((use-region (use-region-p)))
(when (zerop magit-diff-context-lines)
(setq args (cons "--unidiff-zero" args))
(when use-region
(user-error (concat "Not enough context to partially apply hunk. "
"Use `+' to increase context."))))
(let ((buf (generate-new-buffer " *magit-input*")))
(unwind-protect
(progn (if use-region
(magit-insert-hunk-item-region-patch
hunk (member "--reverse" args)
(region-beginning) (region-end) buf)
(magit-insert-hunk-item-patch hunk buf))
(magit-revert-backup buf args)
(magit-run-git-with-input
buf "apply" args "--ignore-space-change" "-"))
(kill-buffer buf)))))
(defun magit-insert-diff-item-patch (diff buf)
(magit-insert-region (magit-section-content-beginning diff)
(magit-section-end diff)
buf))
(defun magit-insert-hunk-item-patch (hunk buf)
(magit-diff-item-insert-header (magit-section-parent hunk) buf)
(magit-insert-region (magit-section-beginning hunk)
(magit-section-end hunk)
buf))
(defun magit-insert-hunk-item-region-patch (hunk reverse beg end buf)
(magit-diff-item-insert-header (magit-section-parent hunk) buf)
(save-excursion
(goto-char (magit-section-beginning hunk))
(magit-insert-current-line buf)
(forward-line)
(let ((copy-op (if reverse "+" "-")))
(while (< (point) (magit-section-end hunk))
(cond ((and (<= beg (point)) (< (point) end))
(magit-insert-current-line buf))
((looking-at " ")
(magit-insert-current-line buf))
((looking-at copy-op)
(let ((text (buffer-substring-no-properties
(+ (point) 1) (line-beginning-position 2))))
(with-current-buffer buf
(insert " " text)))))
(forward-line))))
(with-current-buffer buf
(diff-fixup-modifs (point-min) (point-max))))
(defun magit-diff-item-insert-header (diff buf)
(magit-insert-region (magit-section-content-beginning diff)
(if (magit-section-children diff)
(magit-section-beginning
(car (magit-section-children diff)))
(magit-section-end diff))
buf))
(defun magit-insert-region (beg end buf)
(let ((text (buffer-substring-no-properties beg end)))
(with-current-buffer buf
(insert text))))
(defun magit-insert-current-line (buf)
(let ((text (buffer-substring-no-properties
(line-beginning-position) (line-beginning-position 2))))
(with-current-buffer buf
(insert text))))
(defun magit-revert-backup (buffer args)
(when (and magit-revert-backup (member "--reverse" args))
(with-current-buffer buffer
(let ((buffer-file-name (magit-git-dir magit-revert-backup-file))
(make-backup-files t)
(backup-directory-alist nil)
(version-control t)
(kept-old-versions 0)
(kept-new-versions 10))
(make-directory (file-name-directory buffer-file-name) t)
(save-buffer 16)))))
;;;; Visit
(defun magit-visit-item (&optional other-window)
"Visit current item.
With a prefix argument, visit in other window."
(interactive "P")
(magit-section-action visit (info parent-info)
((diff diffstat [file untracked])
(magit-visit-file-item info other-window))
(hunk (magit-visit-file-item parent-info other-window
(magit-hunk-item-target-line it)
(current-column)))
(commit (magit-show-commit info))
(stash (magit-diff-stash info))
(branch (magit-checkout info))))
(defun magit-visit-file-item (file &optional other-window line column)
(unless file
(user-error "Can't get pathname for this file"))
(unless (file-exists-p file)
(user-error "Can't visit deleted file: %s" file))
(if (file-directory-p file)
(progn
(setq file (file-name-as-directory (expand-file-name file)))
(if (equal (magit-get-top-dir (file-name-directory file))
(magit-get-top-dir))
(magit-dired-jump other-window)
(magit-status file (if other-window
'pop-to-buffer
'switch-to-buffer))))
(if other-window
(find-file-other-window file)
(find-file file))
(when line
(goto-char (point-min))
(forward-line (1- line))
(when (> column 0)
(move-to-column (1- column))))))
(defun magit-hunk-item-target-line (hunk)
(save-excursion
(beginning-of-line)
(let ((line (line-number-at-pos)))
(goto-char (magit-section-beginning hunk))
(unless (looking-at "@@+ .* \\+\\([0-9]+\\)\\(,[0-9]+\\)? @@+")
(user-error "Hunk header not found"))
(let ((target (string-to-number (match-string 1))))
(forward-line)
(while (< (line-number-at-pos) line)
;; XXX - deal with combined diffs
(unless (looking-at "-")
(setq target (+ target 1)))
(forward-line))
target))))
;;;###autoload
(defun magit-dired-jump (&optional other-window)
"Visit current item in dired.
With a prefix argument, visit in other window."
(interactive "P")
(require 'dired-x)
(dired-jump other-window
(file-truename
(magit-section-action dired-jump (info parent-info)
([file untracked] info)
((diff diffstat) info)
(hunk parent-info)
(t default-directory)))))
(defvar-local magit-file-log-file nil)
(defvar-local magit-show-current-version nil)
;;;###autoload
(defun magit-show (rev file &optional switch-function)
"Display and select a buffer containing FILE as stored in REV.
Insert the contents of FILE as stored in the revision REV into a
buffer. Then select the buffer using `pop-to-buffer' or with a
prefix argument using `switch-to-buffer'. Non-interactivity use
SWITCH-FUNCTION to switch to the buffer, if that is nil simply
return the buffer, without displaying it."
;; REV may also be one of the symbols `index' or `working' but
;; that is only intended for use by `magit-ediff'.
(interactive
(let (rev file section)
(magit-section-case (info parent)
(commit (setq file magit-file-log-file rev info))
(hunk (setq section parent))
(diff (setq section it)))
(if section
(setq rev (car (magit-diff-range section))
file (magit-section-info section))
(unless rev
(setq rev (magit-get-current-branch))))
(setq rev (magit-read-rev "Retrieve file from revision" rev)
file (cl-case rev
(working (read-file-name "Find file: "))
(index (magit-read-file-from-rev "HEAD" file))
(t (magit-read-file-from-rev rev file))))
(list rev file (if current-prefix-arg
'switch-to-buffer
'pop-to-buffer))))
(let (buffer)
(if (eq rev 'working)
(setq buffer (find-file-noselect file))
(let ((name (format "%s.%s" file
(if (symbolp rev)
(format "@{%s}" rev)
(replace-regexp-in-string "/" ":" rev)))))
(setq buffer (get-buffer name))
(when buffer
(with-current-buffer buffer
(if (and (equal file magit-file-name)
(equal rev magit-show-current-version))
(let ((inhibit-read-only t))
(erase-buffer))
(setq buffer nil))))
(with-current-buffer
(or buffer (setq buffer (create-file-buffer name)))
(setq buffer-read-only t)
(with-silent-modifications
(if (eq rev 'index)
(let ((temp (car (split-string
(magit-git-string "checkout-index"
"--temp" file)
"\t")))
(inhibit-read-only t))
(insert-file-contents temp nil nil nil t)
(delete-file temp))
(magit-git-insert "cat-file" "-p" (concat rev ":" file))))
(let ((buffer-file-name (expand-file-name file (magit-get-top-dir))))
(normal-mode t))
(setq magit-file-name file)
(setq magit-show-current-version rev)
(goto-char (point-min)))))
(when switch-function
(with-current-buffer buffer
(funcall switch-function (current-buffer))))
buffer))
;;;; Act
;;;;; Merging
;;;###autoload
(defun magit-merge (revision &optional do-commit)
"Merge REVISION into the current 'HEAD', leaving changes uncommitted.
With a prefix argument, skip editing the log message and commit.
\('git merge [--no-commit] REVISION')."
(interactive (list (magit-read-rev "Merge"
(or (magit-guess-branch)
(magit-get-previous-branch)))
current-prefix-arg))
(when (or (not (magit-anything-modified-p))
(not magit-merge-warn-dirty-worktree)
(yes-or-no-p
"Running merge in a dirty worktree could cause data loss. Continue?"))
(magit-run-git "merge" revision magit-custom-options
(unless do-commit "--no-commit"))
(when (file-exists-p ".git/MERGE_MSG")
(let ((magit-custom-options nil))
(magit-commit)))))
;;;###autoload
(defun magit-merge-abort ()
"Abort the current merge operation."
(interactive)
(if (file-exists-p (magit-git-dir "MERGE_HEAD"))
(when (yes-or-no-p "Abort merge? ")
(magit-run-git-async "merge" "--abort"))
(user-error "No merge in progress")))
;;;;; Branching
;;;###autoload
(defun magit-checkout (revision)
"Switch 'HEAD' to REVISION and update working tree.
Fails if working tree or staging area contain uncommitted changes.
If REVISION is a remote branch, offer to create a local branch.
\('git checkout [-b] REVISION')."
(interactive
(list (let ((current-branch (magit-get-current-branch))
(default (or (magit-guess-branch)
(magit-get-previous-branch))))
(magit-read-rev (format "Switch from '%s' to" current-branch)
(unless (string= current-branch default)
default)
current-branch))))
(magit-save-some-buffers)
(or (and (string-match "^\\(?:refs/\\)?remotes/\\([^/]+\\)/\\(.+\\)" revision)
(let ((remote (match-string 1 revision))
(branch (match-string 2 revision)))
(and (yes-or-no-p (format "Create local branch for %s? " branch))
(let ((local (read-string
(format "Call local branch (%s): " branch)
nil nil branch)))
(if (magit-ref-exists-p (concat "refs/heads/" local))
(user-error "'%s' already exists" local)
(magit-run-git "checkout" "-b" local revision)
t)))))
(magit-run-git "checkout" revision)))
;;;###autoload
(defun magit-create-branch (branch parent)
"Switch 'HEAD' to new BRANCH at revision PARENT and update working tree.
Fails if working tree or staging area contain uncommitted changes.
\('git checkout -b BRANCH REVISION')."
(interactive
(list (read-string "Create branch: ")
(magit-read-rev "Parent" (or (magit-guess-branch)
(magit-get-current-branch)))))
(cond ((run-hook-with-args-until-success
'magit-create-branch-hook branch parent))
((and branch (not (string= branch "")))
(magit-save-some-buffers)
(magit-run-git "checkout" magit-custom-options
"-b" branch parent))))
;;;###autoload
(defun magit-delete-branch (branch &optional force)
"Delete the BRANCH.
If the branch is the current one, offers to switch to `master' first.
With prefix, forces the removal even if it hasn't been merged.
Works with local or remote branches.
\('git branch [-d|-D] BRANCH' or 'git push <remote-part-of-BRANCH> :refs/heads/BRANCH')."
(interactive (list (magit-read-rev "Branch to delete"
(or (magit-guess-branch)
(magit-get-previous-branch)))
current-prefix-arg))
(if (string-match "^\\(?:refs/\\)?remotes/\\([^/]+\\)/\\(.+\\)" branch)
(magit-run-git-async "push"
(match-string 1 branch)
(concat ":" (match-string 2 branch)))
(let* ((current (magit-get-current-branch))
(is-current (string= branch current))
(is-master (string= branch "master"))
(args (list "branch"
(if force "-D" "-d")
branch)))
(cond
((and is-current is-master)
(message "Cannot delete master branch while it's checked out."))
(is-current
(if (and (magit-ref-exists-p "refs/heads/master")
(y-or-n-p "Cannot delete current branch. Switch to master first? "))
(progn
(magit-checkout "master")
(magit-run-git args))
(message "The current branch was not deleted.")))
(t
(magit-run-git args))))))
;;;###autoload
(defun magit-rename-branch (old new &optional force)
"Rename branch OLD to NEW.
With prefix, forces the rename even if NEW already exists.
\('git branch [-m|-M] OLD NEW')."
(interactive
(let* ((old (magit-read-rev-with-default "Old name"))
(new (read-string "New name: " old)))
(list old new current-prefix-arg)))
(if (or (null new) (string= new "")
(string= old new))
(message "Cannot rename branch \"%s\" to \"%s\"." old new)
(magit-run-git "branch" (if force "-M" "-m") old new)))
(defun magit-guess-branch ()
"Return a branch name depending on the context of cursor.
If no branch is found near the cursor return nil."
(magit-section-case (info parent-info)
(branch info)
([commit wazzup] parent-info)
([commit ] (magit-name-rev info))
([ wazzup] info)))
;;;;; Remoting
;;;###autoload
(defun magit-add-remote (remote url)
"Add the REMOTE and fetch it.
\('git remote add REMOTE URL')."
(interactive (list (read-string "Remote name: ")
(read-string "Remote url: ")))
(magit-run-git-async "remote" "add" "-f" remote url))
;;;###autoload
(defun magit-remove-remote (remote)
"Delete the REMOTE.
\('git remote rm REMOTE')."
(interactive (list (magit-read-remote "Delete remote")))
(magit-run-git "remote" "rm" remote))
;;;###autoload
(defun magit-rename-remote (old new)
"Rename remote OLD to NEW.
\('git remote rename OLD NEW')."
(interactive
(let* ((old (magit-read-remote "Old name"))
(new (read-string "New name: " old)))
(list old new)))
(if (or (null old) (string= old "")
(null new) (string= new "")
(string= old new))
(message "Cannot rename remote \"%s\" to \"%s\"." old new)
(magit-run-git "remote" "rename" old new)))
(defun magit-guess-remote ()
(magit-section-case (info parent-info)
(remote info)
(branch parent-info)
(t (if (string= info ".") info (magit-get-current-remote)))))
;;;;; Rebase
(defun magit-rebase-info ()
"Return a list indicating the state of an in-progress rebase.
The returned list has the form (ONTO DONE TOTAL STOPPED AM).
ONTO is the commit being rebased onto.
DONE and TOTAL are integers with obvious meanings.
STOPPED is the SHA-1 of the commit at which rebase stopped.
AM is non-nil if the current rebase is actually a git-am.
Return nil if there is no rebase in progress."
(let ((m (magit-git-dir "rebase-merge"))
(a (magit-git-dir "rebase-apply")))
(cond
((file-directory-p m) ; interactive
(list
(magit-name-rev (magit-file-line (expand-file-name "onto" m)))
(length (magit-file-lines (expand-file-name "done" m)))
(cl-loop for line in (magit-file-lines
(expand-file-name "git-rebase-todo.backup" m))
count (string-match "^[^#\n]" line))
(magit-file-line (expand-file-name "stopped-sha" m))
nil))
((file-regular-p (expand-file-name "onto" a)) ; non-interactive
(list
(magit-name-rev (magit-file-line (expand-file-name "onto" a)))
(1- (string-to-number (magit-file-line (expand-file-name "next" a))))
(string-to-number (magit-file-line (expand-file-name "last" a)))
(let ((patch-header (magit-file-line
(car (directory-files a t "^[0-9]\\{4\\}$")))))
(when (string-match "^From \\([a-z0-9]\\{40\\}\\) " patch-header)
(match-string 1 patch-header)))
nil))
((file-regular-p (expand-file-name "applying" a)) ; am
(list
(magit-name-rev "HEAD")
(1- (string-to-number (magit-file-line (expand-file-name "next" a))))
(string-to-number (magit-file-line (expand-file-name "last" a)))
(let ((patch-header (magit-file-line
(car (directory-files a t "^[0-9]\\{4\\}$")))))
(when (string-match "^From \\([a-z0-9]\\{40\\}\\) " patch-header)
(match-string 1 patch-header)))
t)))))
(defun magit-rebase-step ()
"Initiate or continue a rebase."
(interactive)
(let ((rebase (magit-rebase-info)))
(if rebase
(let ((cursor-in-echo-area t)
(message-log-max nil)
(am (nth 4 rebase)))
(message "%s in progress. [A]bort, [S]kip, or [C]ontinue? "
(if am "Apply mailbox" "Rebase"))
(cl-case (read-event)
((?A ?a) (magit-run-git-async (if am "am" "rebase") "--abort"))
((?S ?s) (magit-run-git-async (if am "am" "rebase") "--skip"))
((?C ?c) (magit-with-emacsclient magit-server-window-for-commit
(magit-run-git-async (if am "am" "rebase") "--continue")))))
(let* ((branch (magit-get-current-branch))
(rev (magit-read-rev
"Rebase to"
(magit-get-tracked-branch branch)
branch)))
(magit-run-git "rebase" rev)))))
;;;###autoload
(defun magit-interactive-rebase (commit)
"Start a git rebase -i session, old school-style."
(interactive (let ((commit (magit-section-case (info) (commit info))))
(list (if commit
(concat commit "^")
(magit-read-rev "Interactively rebase to"
(magit-guess-branch))))))
(magit-assert-emacsclient "rebase interactively")
(magit-with-emacsclient magit-server-window-for-rebase
(magit-run-git-async "rebase" "-i" commit)))
;;;;; AM
(defun magit-apply-mailbox (&optional file-or-dir)
"Apply a series of patches from a mailbox."
(interactive "fmbox or Maildir file or directory: ")
(magit-with-emacsclient magit-server-window-for-rebase
(magit-run-git-async "am" file-or-dir)))
;;;;; Reset
;;;###autoload
(defun magit-reset-head (revision &optional hard)
"Switch 'HEAD' to REVISION, keeping prior working tree and staging area.
Any differences from REVISION become new changes to be committed.
With prefix argument, all uncommitted changes in working tree
and staging area are lost.
\('git reset [--soft|--hard] REVISION')."
(interactive (list (magit-read-rev (format "%s head to"
(if current-prefix-arg
"Hard reset"
"Reset"))
(or (magit-guess-branch) "HEAD"))
current-prefix-arg))
(magit-run-git "reset" (if hard "--hard" "--soft") revision "--"))
;;;###autoload
(defun magit-reset-head-hard (revision)
"Switch 'HEAD' to REVISION, losing all changes.
Uncomitted changes in both working tree and staging area are lost.
\('git reset --hard REVISION')."
(interactive (list (magit-read-rev (format "Hard reset head to")
(or (magit-guess-branch) "HEAD"))))
(magit-reset-head revision t))
;;;###autoload
(defun magit-reset-working-tree (&optional arg)
"Revert working tree and clear changes from staging area.
\('git reset --hard HEAD').
With a prefix arg, also remove untracked files.
With two prefix args, remove ignored files as well."
(interactive "p")
(let ((include-untracked (>= arg 4))
(include-ignored (>= arg 16)))
(when (yes-or-no-p (format "Discard all uncommitted changes%s%s? "
(if include-untracked
", untracked files"
"")
(if include-ignored
", ignored files"
"")))
(magit-reset-head-hard "HEAD")
(when include-untracked
(magit-run-git "clean" "-fd" (if include-ignored "-x" ""))))))
;;;;; Rewriting
(defun magit-read-rewrite-info ()
(when (file-exists-p (magit-git-dir "magit-rewrite-info"))
(with-temp-buffer
(insert-file-contents (magit-git-dir "magit-rewrite-info"))
(goto-char (point-min))
(read (current-buffer)))))
(defun magit-write-rewrite-info (info)
(with-temp-file (magit-git-dir "magit-rewrite-info")
(prin1 info (current-buffer))
(princ "\n" (current-buffer))))
(defun magit-rewrite-set-commit-property (commit prop value)
(let* ((info (magit-read-rewrite-info))
(pending (cdr (assq 'pending info)))
(p (assoc commit pending)))
(when p
(setf (cdr p) (plist-put (cdr p) prop value))
(magit-write-rewrite-info info)
(magit-refresh))
t))
(add-hook 'magit-apply-hook 'magit-rewrite-apply)
(put 'magit-rewrite-apply 'magit-section-action-context [commit pending])
(defun magit-rewrite-apply (commit)
(magit-apply-commit commit)
(magit-rewrite-set-commit-property commit 'used t))
(add-hook 'magit-cherry-pick-hook 'magit-rewrite-pick)
(put 'magit-rewrite-pick 'magit-section-action-context [commit pending])
(defun magit-rewrite-pick (commit)
(magit-cherry-pick-commit commit)
(magit-rewrite-set-commit-property commit 'used t))
(add-hook 'magit-revert-hook 'magit-rewrite-revert)
(put 'magit-rewrite-revert 'magit-section-action-context [commit pending])
(defun magit-rewrite-revert (commit)
(when (or (not magit-revert-item-confirm)
(yes-or-no-p "Revert this commit? "))
(magit-revert-commit commit)
(magit-rewrite-set-commit-property commit 'used nil)))
(defun magit-rewrite-set-used ()
(interactive)
(magit-section-case (info)
([commit pending]
(magit-rewrite-set-commit-property info 'used t)
(magit-refresh))))
(defun magit-rewrite-set-unused ()
(interactive)
(magit-section-case (info)
([commit pending]
(magit-rewrite-set-commit-property info 'used nil)
(magit-refresh))))
(defun magit-rewrite-start (from &optional onto)
(interactive (list (magit-read-rev-with-default "Rewrite from")))
(when (magit-anything-modified-p)
(user-error "You have uncommitted changes"))
(or (not (magit-read-rewrite-info))
(user-error "Rewrite in progress"))
(let* ((orig (magit-rev-parse "HEAD"))
(base (if (or (eq magit-rewrite-inclusive t)
(and (eq magit-rewrite-inclusive 'ask)
(y-or-n-p "Include selected revision in rewrite? ")))
(or (car (magit-commit-parents from))
(user-error "Can't rewrite a parentless commit"))
from))
(pending (magit-git-lines "rev-list" (concat base ".."))))
(magit-write-rewrite-info `((orig ,orig)
(pending ,@(mapcar #'list pending))))
(magit-run-git "reset" "--hard" base "--")))
(defun magit-rewrite-stop (&optional noconfirm)
(interactive)
(let* ((info (magit-read-rewrite-info)))
(or info
(user-error "No rewrite in progress"))
(when (or noconfirm
(yes-or-no-p "Stop rewrite? "))
(magit-write-rewrite-info nil)
(magit-refresh))))
(defun magit-rewrite-abort ()
(interactive)
(let* ((info (magit-read-rewrite-info))
(orig (cadr (assq 'orig info))))
(or info
(user-error "No rewrite in progress"))
(when (magit-anything-modified-p)
(user-error "You have uncommitted changes"))
(when (yes-or-no-p "Abort rewrite? ")
(magit-write-rewrite-info nil)
(magit-run-git "reset" "--hard" orig "--"))))
(defun magit-rewrite-finish ()
(interactive)
(magit-rewrite-finish-step)
(magit-refresh))
(defun magit-rewrite-finish-step ()
(let ((info (magit-read-rewrite-info)))
(or info
(user-error "No rewrite in progress"))
(let* ((pending (cdr (assq 'pending info)))
(first-unused
(let ((rpend (reverse pending)))
(while (and rpend (plist-get (cdr (car rpend)) 'used))
(setq rpend (cdr rpend)))
(car rpend)))
(commit (car first-unused)))
(cond ((not first-unused)
(magit-rewrite-stop t))
((magit-git-success "cherry-pick" commit)
(magit-rewrite-set-commit-property commit 'used t)
(magit-rewrite-finish-step))
(t
(magit-refresh)
(error "Could not apply %s" commit))))))
(defun magit-rewrite-diff-pending ()
(interactive)
(let* ((info (magit-read-rewrite-info))
(orig (cadr (assq 'orig info))))
(if orig
(magit-diff orig nil "-R")
(user-error "No rewrite in progress"))))
(defun magit-rewrite-diff-pending-transition ()
(interactive)
(message "Please remove magit-insert-pending-changes from your magit-status-sections-hook, or move to magit-rewrite-diff-pending"))
(define-obsolete-function-alias
'magit-insert-pending-changes 'magit-rewrite-diff-pending-transition
"382351845e"
"https://github.com/magit/magit/commit/382351845eca2425713f640f9bb55756c9ddf723")
;;;;; Fetching
;;;###autoload
(defun magit-fetch (remote)
"Fetch from REMOTE."
(interactive (list (magit-read-remote "Fetch remote")))
(magit-run-git-async "fetch" remote magit-custom-options))
;;;###autoload
(defun magit-fetch-current ()
"Run fetch for default remote.
If there is no default remote, ask for one."
(interactive)
(magit-fetch (or (magit-get-current-remote)
(magit-read-remote "Fetch remote"))))
;;;###autoload
(defun magit-remote-update ()
"Update all remotes."
(interactive)
(or (run-hook-with-args-until-success 'magit-remote-update-hook)
(magit-run-git-async "remote" "update" magit-custom-options)))
;;;;; Pulling
;;;###autoload
(defun magit-pull ()
"Run git pull.
If there is no default remote, the user is prompted for one and
its values is saved with git config. If there is no default
merge branch, the user is prompted for one and its values is
saved with git config. With a prefix argument, the default
remote is not used and the user is prompted for a remote. With
two prefix arguments, the default merge branch is not used and
the user is prompted for a merge branch. Values entered by the
user because of prefix arguments are not saved with git config."
(interactive)
(or (run-hook-with-args-until-success 'magit-pull-hook)
(let* ((branch (magit-get-current-branch))
(branch-remote (magit-get-remote branch))
(branch-merge (magit-get "branch" branch "merge"))
(branch-merge-name (and branch-merge
(save-match-data
(string-match "^refs/heads/\\(.+\\)" branch-merge)
(match-string 1 branch-merge))))
(choose-remote (>= (prefix-numeric-value current-prefix-arg) 4))
(choose-branch (>= (prefix-numeric-value current-prefix-arg) 16))
(remote-needed (or choose-remote
(not branch-remote)))
(branch-needed (or choose-branch
(not branch-merge-name)))
(chosen-branch-remote
(if remote-needed
(magit-read-remote "Pull from remote" branch-remote)
branch-remote))
(chosen-branch-merge-name
(if branch-needed
(magit-read-remote-branch (format "Pull branch from remote %s"
chosen-branch-remote)
chosen-branch-remote)
branch-merge-name)))
(when (and (not branch-remote)
(not choose-remote))
(magit-set chosen-branch-remote "branch" branch "remote"))
(when (and (not branch-merge-name)
(not choose-branch))
(magit-set (format "%s" chosen-branch-merge-name)
"branch" branch "merge"))
(magit-run-git-async
"pull" magit-custom-options
(and choose-remote chosen-branch-remote)
(and (or choose-remote choose-branch)
(list (format "refs/heads/%s:refs/remotes/%s/%s"
chosen-branch-merge-name
chosen-branch-remote
chosen-branch-merge-name)))))))
;;;;; Pushing
;;;###autoload
(defun magit-push-tags ()
"Push tags to a remote repository.
Push tags to the current branch's remote. If that isn't set push
to \"origin\" or if that remote doesn't exit but only a single
remote is defined use that. Otherwise or with a prefix argument
ask the user what remote to use."
(interactive)
(let* ((branch (magit-get-current-branch))
(remotes (magit-git-lines "remote"))
(remote (or (and branch (magit-get-remote branch))
(car (member "origin" remotes))
(and (= (length remotes) 1)
(car remotes)))))
(when (or current-prefix-arg (not remote))
(setq remote (magit-read-remote "Push to remote")))
(magit-run-git-async "push" remote "--tags" magit-custom-options)))
;;;###autoload
(defun magit-push ()
"Push the current branch to a remote repository.
This command runs the `magit-push-remote' hook. By default that
means running `magit-push-dwim'. So unless you have customized
the hook this command behaves like this:
With a single prefix argument ask the user what branch to push
to. With two or more prefix arguments also ask the user what
remote to push to. Otherwise use the remote and branch as
configured using the Git variables `branch.<name>.remote' and
`branch.<name>.merge'. If the former is undefined ask the user.
If the latter is undefined push without specifing the remote
branch explicitly.
Also see option `magit-set-upstream-on-push'."
(interactive)
(run-hook-with-args-until-success 'magit-push-hook current-prefix-arg))
(defun magit-push-dwim (arg)
"Push the current branch to a remote repository.
With a single prefix argument ask the user what remote to push
to. With two or more prefix arguments also ask the user the
name of the remote branch to push to.
Otherwise use the remote and branch as configured using the
Git variables `branch.<name>.remote' and `branch.<name>.merge'.
If the former is undefined ask the user. If the latter is
undefined push without specifing the remote branch explicitly.
Also see option `magit-set-upstream-on-push'."
(interactive "P")
(let* ((branch (or (magit-get-current-branch)
(user-error "Don't push a detached head. That's gross")))
(auto-remote (magit-get-remote branch))
(used-remote (if (or arg (not auto-remote))
(magit-read-remote
(format "Push %s to remote" branch) auto-remote)
auto-remote))
(auto-branch (and (equal used-remote auto-remote)
(magit-get "branch" branch "merge")))
(used-branch (if (>= (prefix-numeric-value arg) 16)
(magit-read-remote-branch
(format "Push %s as branch" branch)
used-remote auto-branch)
auto-branch)))
(cond ;; Pushing to what's already configured.
((and auto-branch
(equal auto-branch used-branch)
(equal auto-remote used-remote)))
;; Setting upstream because of magit-custom-options.
((member "-u" magit-custom-options))
;; Two prefix arguments; ignore magit-set-upstream-on-push.
((>= (prefix-numeric-value arg) 16)
(and (yes-or-no-p "Set upstream while pushing? ")
(setq magit-custom-options
(cons "-u" magit-custom-options))))
;; Else honor magit-set-upstream-on-push.
((eq magit-set-upstream-on-push 'refuse)
(user-error "Not pushing since no upstream has been set."))
((or (eq magit-set-upstream-on-push 'dontask)
(and (eq magit-set-upstream-on-push t)
(yes-or-no-p "Set upstream while pushing? ")))
(setq magit-custom-options (cons "-u" magit-custom-options))))
(magit-run-git-async
"push" "-v" used-remote
(if used-branch (format "%s:%s" branch used-branch) branch)
magit-custom-options)))
;;;;; Committing
;;;###autoload
(defun magit-commit (&optional amendp)
"Create a new commit on HEAD.
With a prefix argument amend to the commit at HEAD instead.
\('git commit [--amend]')."
(interactive "P")
(let ((args magit-custom-options))
(when amendp
(setq args (cons "--amend" args)))
(when (setq args (magit-commit-assert args))
(magit-commit-maybe-expand)
(magit-commit-internal "commit" args))))
;;;###autoload
(defun magit-commit-amend ()
"Amend the last commit.
\('git commit --amend')."
(interactive)
(magit-commit-maybe-expand)
(magit-commit-internal "commit" (cons "--amend" magit-custom-options)))
;;;###autoload
(defun magit-commit-extend (&optional override-date)
"Amend the last commit, without editing the message.
With a prefix argument do change the committer date, otherwise
don't. The option `magit-commit-extend-override-date' can be
used to inverse the meaning of the prefix argument.
\('git commit --no-edit --amend [--keep-date]')."
(interactive (list (if current-prefix-arg
(not magit-commit-reword-override-date)
magit-commit-reword-override-date)))
(magit-commit-maybe-expand)
(let ((process-environment process-environment))
(unless override-date
(setenv "GIT_COMMITTER_DATE"
(magit-git-string "log" "-1" "--format:format=%cd")))
(magit-commit-internal "commit" (nconc (list "--no-edit" "--amend")
magit-custom-options))))
;;;###autoload
(defun magit-commit-reword (&optional override-date)
"Reword the last commit, ignoring staged changes.
With a prefix argument do change the committer date, otherwise
don't. The option `magit-commit-rewrite-override-date' can be
used to inverse the meaning of the prefix argument.
Non-interactively respect the optional OVERRIDE-DATE argument
and ignore the option.
\('git commit --only --amend')."
(interactive (list (if current-prefix-arg
(not magit-commit-reword-override-date)
magit-commit-reword-override-date)))
(let ((process-environment process-environment))
(unless override-date
(setenv "GIT_COMMITTER_DATE"
(magit-git-string "log" "-1" "--format:format=%cd")))
(magit-commit-internal "commit" (nconc (list "--only" "--amend")
magit-custom-options))))
(defvar-local magit-commit-squash-args nil)
(defvar-local magit-commit-squash-fixup nil)
(defvar magit-commit-unmark-after-squash t)
;;;###autoload
(defun magit-commit-fixup (&optional commit)
"Create a fixup commit.
With a prefix argument the user is always queried for the commit
to be fixed. Otherwise the current or marked commit may be used
depending on the value of option `magit-commit-squash-commit'.
\('git commit [--no-edit] --fixup=COMMIT')."
(interactive (list (magit-commit-squash-commit)))
(magit-commit-squash commit t))
;;;###autoload
(defun magit-commit-squash (&optional commit fixup)
"Create a squash commit.
With a prefix argument the user is always queried for the commit
to be fixed. Otherwise the current or marked commit may be used
depending on the value of option `magit-commit-squash-commit'.
\('git commit [--no-edit] --fixup=COMMIT')."
(interactive (list (magit-commit-squash-commit)))
(let ((args magit-custom-options))
(cond
((not commit)
(magit-commit-assert args)
(magit-log)
(setq magit-commit-squash-args args
magit-commit-squash-fixup fixup)
(add-hook 'magit-mark-commit-hook 'magit-commit-squash-marked t t)
(add-hook 'magit-mode-quit-window-hook 'magit-commit-squash-abort t t)
(message "Select commit using \".\", or abort using \"q\""))
((setq args (magit-commit-assert args))
(when (eq args t) (setq args nil))
(magit-commit-internal
"commit"
(nconc (list "--no-edit"
(concat (if fixup "--fixup=" "--squash=") commit))
args))))))
(defun magit-commit-squash-commit ()
(unless (or current-prefix-arg
(eq magit-commit-squash-commit nil))
(let ((current (magit-section-case (info) (commit info))))
(cl-ecase magit-commit-squash-commit
(current-or-marked (or current magit-marked-commit))
(marked-or-current (or magit-marked-commit current))
(current current)
(marked magit-marked-commit)))))
(defun magit-commit-squash-marked ()
(when magit-marked-commit
(magit-commit-squash magit-marked-commit magit-commit-squash-fixup))
(when magit-commit-unmark-after-squash
(setq magit-marked-commit nil))
(kill-local-variable 'magit-commit-squash-fixup)
(remove-hook 'magit-mark-commit-hook 'magit-commit-squash-marked t)
(remove-hook 'magit-mode-quit-window-hook 'magit-commit-squash-abort t)
(magit-mode-quit-window))
(defun magit-commit-squash-abort (buffer)
(when (buffer-live-p buffer)
(with-current-buffer buffer
(remove-hook 'magit-mark-commit-hook 'magit-commit-squash-marked t)
(remove-hook 'magit-mode-quit-window-hook 'magit-commit-squash-abort t))))
(defun magit-commit-assert (args)
(cond
((or (magit-anything-staged-p)
(member "--allow-empty" args)
(member "--all" args)
(member "--amend" args))
(or args (list "--")))
((and (magit-rebase-info)
(y-or-n-p "Nothing staged. Continue in-progress rebase? "))
(magit-run-git-async "rebase" "--continue")
nil)
(magit-commit-ask-to-stage
(magit-commit-maybe-expand t)
(when (y-or-n-p "Nothing staged. Stage and commit everything? ")
(magit-run-git "add" "-u" ".")
(or args (list "--"))))
(t
(user-error "Nothing staged. Set --allow-empty, --all, or --amend in popup"))))
(defun magit-commit-maybe-expand (&optional unstaged)
(when (and magit-expand-staged-on-commit
(derived-mode-p 'magit-status-mode))
(if unstaged
(magit-jump-to-unstaged t)
(magit-jump-to-staged t))))
(defun magit-commit-internal (subcmd args)
(setq git-commit-previous-winconf (current-window-configuration))
(if (magit-use-emacsclient-p)
(magit-with-emacsclient magit-server-window-for-commit
(magit-run-git-async subcmd args))
(let ((topdir (magit-get-top-dir))
(editmsg (magit-git-dir (if (equal subcmd "tag")
"TAG_EDITMSG"
"COMMIT_EDITMSG"))))
(when (and (member "--amend" args)
(not (file-exists-p editmsg)))
(with-temp-file editmsg
(magit-git-insert "log" "-1" "--format=format:%B" "HEAD")))
(with-current-buffer (find-file-noselect editmsg)
(funcall (if (functionp magit-server-window-for-commit)
magit-server-window-for-commit
'switch-to-buffer)
(current-buffer))
(add-hook 'git-commit-commit-hook
(apply-partially
(lambda (default-directory editmsg args)
(magit-run-git args)
(ignore-errors (delete-file editmsg)))
topdir editmsg
`(,subcmd
,"--cleanup=strip"
,(concat "--file=" (file-relative-name
(buffer-file-name)
topdir))
,@args))
nil t)))))
(defun magit-commit-add-log ()
"Add a template for the current hunk to the commit message buffer."
(interactive)
(let* ((section (magit-current-section))
(fun (if (eq (magit-section-type section) 'hunk)
(save-window-excursion
(save-excursion
(magit-visit-item)
(add-log-current-defun)))
nil))
(file (magit-section-info
(cl-case (magit-section-type section)
(hunk (magit-section-parent section))
(diff section)
(t (user-error "No change at point")))))
(locate-buffer (lambda ()
(cl-find-if
(lambda (buf)
(with-current-buffer buf
(derived-mode-p 'git-commit-mode)))
(append (buffer-list (selected-frame))
(buffer-list)))))
(buffer (funcall locate-buffer)))
(unless buffer
(unless (magit-commit-assert nil)
(user-error "Abort"))
(magit-commit)
(while (not (setq buffer (funcall locate-buffer)))
(sit-for 0.01)))
(pop-to-buffer buffer)
(goto-char (point-min))
(cond ((not (re-search-forward (format "^\\* %s" (regexp-quote file))
nil t))
;; No entry for file, create it.
(goto-char (point-max))
(forward-comment -1000)
(unless (or (bobp) (looking-back "\\(\\*[^\n]+\\|\n\\)"))
(insert "\n"))
(insert (format "\n* %s" file))
(when fun
(insert (format " (%s)" fun)))
(insert ": "))
(fun
;; found entry for file, look for fun
(let ((limit (save-excursion
(or (and (re-search-forward "^\\* " nil t)
(match-beginning 0))
(progn (goto-char (point-max))
(forward-comment -1000)
(point))))))
(cond ((re-search-forward
(format "(.*\\_<%s\\_>.*):" (regexp-quote fun))
limit t)
;; found it, goto end of current entry
(if (re-search-forward "^(" limit t)
(backward-char 2)
(goto-char limit)))
(t
;; not found, insert new entry
(goto-char limit)
(if (bolp)
(open-line 1)
(newline))
(insert (format "(%s): " fun))))))
(t
;; found entry for file, look for beginning it
(when (looking-at ":")
(forward-char 2))))))
;;;;; Tagging
;;;###autoload
(defun magit-tag (name rev &optional annotate)
"Create a new tag with the given NAME at REV.
With a prefix argument annotate the tag.
\('git tag [--annotate] NAME REV')."
(interactive (list (magit-read-tag "Tag name")
(magit-read-rev "Place tag on"
(or (magit-guess-branch) "HEAD"))
current-prefix-arg))
(let ((args (append magit-custom-options (list name rev))))
(if (or (member "--sign" args)
(member "--annotate" args)
(and annotate (setq args (cons "--annotate" args))))
(magit-commit-internal "tag" args)
(magit-run-git "tag" args))))
;;;###autoload
(defun magit-delete-tag (name)
"Delete the tag with the given NAME.
\('git tag -d NAME')."
(interactive (list (magit-read-tag "Delete Tag" t)))
(magit-run-git "tag" "-d" magit-custom-options name))
;;;;; Stashing
(defvar magit-read-stash-history nil
"The history of inputs to `magit-stash'.")
;;;###autoload
(defun magit-stash (description)
"Create new stash of working tree and staging area named DESCRIPTION.
Working tree and staging area revert to the current 'HEAD'.
With prefix argument, changes in staging area are kept.
\('git stash save [--keep-index] DESCRIPTION')"
(interactive (list (read-string "Stash description: " nil
'magit-read-stash-history)))
(magit-run-git-async "stash" "save" magit-custom-options "--" description))
;;;###autoload
(defun magit-stash-snapshot ()
"Create new stash of working tree and staging area; keep changes in place.
\('git stash save \"Snapshot...\"; git stash apply stash@{0}')"
(interactive)
(magit-call-git "stash" "save" magit-custom-options
(format-time-string
"Snapshot taken at %Y-%m-%d %H:%M:%S"
(current-time)))
(magit-run-git "stash" "apply" "stash@{0}"))
(defun magit-stash-apply (stash)
"Apply a stash on top of the current working tree state.
\('git stash apply stash@{N}')"
(interactive (list (magit-read-stash "Apply stash (number): ")))
(magit-run-git "stash" "apply" stash))
(defun magit-stash-pop (stash)
"Apply a stash on top of working tree state and remove from stash list.
\('git stash pop stash@{N}')"
(interactive (list (magit-read-stash "Pop stash (number): ")))
(magit-run-git "stash" "pop" stash))
(defun magit-stash-drop (stash)
"Remove a stash from the stash list.
\('git stash drop stash@{N}')"
(interactive (list (magit-read-stash "Drop stash (number): ")))
(magit-run-git "stash" "drop" stash))
;;;;; Cherry-Pick
(defun magit-cherry-pick-item ()
"Cherry-pick them item at point."
(interactive)
(magit-section-action cherry-pick (info)
(commit (magit-cherry-pick-commit info))
(stash (magit-stash-pop info))))
(defun magit-cherry-pick-commit (commit)
(magit-assert-one-parent commit "cherry-pick")
(magit-run-git "cherry-pick" commit))
;;;;; Submoduling
;;;###autoload
(defun magit-submodule-update (&optional init)
"Update the submodule of the current git repository.
With a prefix arg, do a submodule update --init."
(interactive "P")
(let ((default-directory (magit-get-top-dir)))
(magit-run-git-async "submodule" "update" (and init "--init"))))
;;;###autoload
(defun magit-submodule-update-init ()
"Update and init the submodule of the current git repository."
(interactive)
(magit-submodule-update t))
;;;###autoload
(defun magit-submodule-init ()
"Initialize the submodules."
(interactive)
(let ((default-directory (magit-get-top-dir)))
(magit-run-git-async "submodule" "init")))
;;;###autoload
(defun magit-submodule-sync ()
"Synchronizes submodule's remote URL configuration."
(interactive)
(let ((default-directory (magit-get-top-dir)))
(magit-run-git-async "submodule" "sync")))
;;;;; Bisecting
;;;###autoload
(defun magit-bisect-start (bad good)
"Start a bisect session.
Bisecting a bug means to find the commit that introduced it.
This command starts such a bisect session by asking for a know
good and a bad commit. To move the session forward use the
other actions from the bisect popup (\
\\<magit-status-mode-map>\\[magit-key-mode-popup-bisecting])."
(interactive
(if (magit-bisecting-p)
(user-error "Already bisecting")
(list (magit-read-rev "Start bisect with known bad revision" "HEAD")
(magit-read-rev "Good revision" (magit-guess-branch)))))
(magit-run-git-bisect "start" (list bad good) t))
;;;###autoload
(defun magit-bisect-reset ()
"After bisecting cleanup bisection state and return to original HEAD."
(interactive)
(when (yes-or-no-p "Reset bisect?")
(magit-run-git "bisect" "reset")
(ignore-errors (delete-file (magit-git-dir "BISECT_CMD_OUTPUT")))))
;;;###autoload
(defun magit-bisect-good ()
"While bisecting, mark the current commit as good.
Use this after you have asserted that the commit does not contain
the bug in question."
(interactive)
(magit-run-git-bisect "good"))
;;;###autoload
(defun magit-bisect-bad ()
"While bisecting, mark the current commit as bad.
Use this after you have asserted that the commit does contain the
bug in question."
(interactive)
(magit-run-git-bisect "bad"))
;;;###autoload
(defun magit-bisect-skip ()
"While bisecting, skip the current commit.
Use this if for some reason the current commit is not a good one
to test. This command lets Git choose a different one."
(interactive)
(magit-run-git-bisect "skip"))
;;;###autoload
(defun magit-bisect-run (cmdline)
"Bisect automatically by running commands after each step."
(interactive (list (read-shell-command "Bisect shell command: ")))
(magit-run-git-bisect "run" (list cmdline)))
(defun magit-run-git-bisect (subcommand &optional args no-assert)
(unless (or no-assert (magit-bisecting-p))
(user-error "Not bisecting"))
(let ((file (magit-git-dir "BISECT_CMD_OUTPUT"))
(default-directory (magit-get-top-dir)))
(ignore-errors (delete-file file))
(magit-run-git-with-logfile file "bisect" subcommand args)
(magit-process-wait)
(magit-refresh)))
;;;;; Logging
;;;###autoload
(defun magit-log (&optional range)
(interactive)
(magit-mode-setup magit-log-buffer-name nil
#'magit-log-mode
#'magit-refresh-log-buffer
'oneline (or range "HEAD") magit-custom-options))
;;;###autoload
(defun magit-log-ranged (range)
(interactive (list (magit-read-rev-range "Log" "HEAD")))
(magit-log range))
;;;###autoload
(defun magit-log-long (&optional range)
(interactive)
(magit-mode-setup magit-log-buffer-name nil
#'magit-log-mode
#'magit-refresh-log-buffer
'long (or range "HEAD") magit-custom-options))
;;;###autoload
(defun magit-log-long-ranged (range)
(interactive (list (magit-read-rev-range "Long Log" "HEAD")))
(magit-log-long range))
;;;###autoload
(defun magit-file-log (file &optional use-graph)
"Display the log for the currently visited file or another one.
With a prefix argument show the log graph."
(interactive
(list (magit-read-file-from-rev (magit-get-current-branch)
(magit-buffer-file-name t))
current-prefix-arg))
(magit-mode-setup magit-log-buffer-name nil
#'magit-log-mode
#'magit-refresh-log-buffer
'oneline "HEAD"
`(,@(and use-graph (list "--graph"))
,@magit-custom-options
"--follow")
file))
;;;###autoload
(defun magit-reflog (ref)
"Display the reflog of the current branch.
With a prefix argument another branch can be chosen."
(interactive (let ((branch (magit-get-current-branch)))
(if (and branch (not current-prefix-arg))
(list branch)
(list (magit-read-rev "Reflog of" branch)))))
(magit-mode-setup magit-reflog-buffer-name nil
#'magit-reflog-mode
#'magit-refresh-reflog-buffer ref))
;;;###autoload
(defun magit-reflog-head ()
"Display the HEAD reflog."
(interactive)
(magit-reflog "HEAD"))
;;; Modes (2)
;;;; Log Mode
;;;;; Log Core
(define-derived-mode magit-log-mode magit-mode "Magit Log"
"Mode for looking at git log.
\\<magit-log-mode-map>Type `\\[magit-visit-item]` to visit a commit, and \
`\\[magit-show-item-or-scroll-up]` to just show it.
Type `\\[magit-log-show-more-entries]` to show more commits, \
and `\\[magit-refresh]` to refresh the log.
Type `\\[magit-diff-working-tree]` to see the diff between current commit and your working tree,
Type `\\[magit-diff]` to see diff between any two version
Type `\\[magit-apply-item]` to apply the change of the current commit to your wortree,
and `\\[magit-cherry-pick-item]` to apply and commit the result.
Type `\\[magit-revert-item]` to revert a commit, and `\\[magit-reset-head]` reset your current head to a commit,
More information can be found in Info node `(magit)History'
Other key binding:
\\{magit-log-mode-map}"
:group 'magit)
(defvar magit-log-buffer-name "*magit-log*"
"Name of buffer used to display log entries.")
(defun magit-refresh-log-buffer (style range args &optional file)
(magit-set-buffer-margin (car magit-log-margin-spec)
(and magit-log-show-margin
(eq (car magit-refresh-args) 'oneline)))
(magit-log-margin-set-timeunit-width)
(setq magit-file-log-file file)
(when (consp range)
(setq range (concat (car range) ".." (cdr range))))
(magit-git-insert-section
(logbuf (concat "Commits"
(and file (concat " for file " file))
(and range (concat " in " range))))
(apply-partially 'magit-wash-log style 'color t)
"log"
(format "--max-count=%d" magit-log-cutoff-length)
"--decorate=full" "--color"
(cl-case style
(long (if magit-log-show-gpg-status
(list "--stat" "--show-signature")
"--stat"))
(oneline (concat "--pretty=format:%h%d "
(and magit-log-show-gpg-status "%G?")
"[%an][%at]%s")))
args range "--" file)
(save-excursion
(goto-char (point-min))
(magit-format-log-margin)))
;;;;; Log Washing
(defconst magit-log-oneline-re
(concat "^"
"\\(?4:\\(?: *[-_/|\\*o.] *\\)+ *\\)?" ; graph
"\\(?:"
"\\(?1:[0-9a-fA-F]+\\) " ; sha1
"\\(?:\\(?3:([^()]+)\\) \\)?" ; refs
"\\(?7:[BGUN]\\)?" ; gpg
"\\[\\(?5:[^]]*\\)\\]" ; author
"\\[\\(?6:[^]]*\\)\\]" ; date
"\\(?2:.*\\)" ; msg
"\\)?$"))
(defconst magit-log-long-re
(concat "^"
"\\(?4:\\(?:[-_/|\\*o.] *\\)+ *\\)?" ; graph
"\\(?:"
"\\(?:commit \\(?1:[0-9a-fA-F]+\\)" ; sha1
"\\(?: \\(?3:([^()]+)\\)\\)?\\)" ; refs
"\\|"
"\\(?2:.+\\)\\)$")) ; "msg"
(defconst magit-log-unique-re
(concat "^"
"\\(?1:[0-9a-fA-F]+\\) " ; sha1
"\\(?2:.*\\)$")) ; msg
(defconst magit-log-cherry-re
(concat "^"
"\\(?8:[-+]\\) " ; cherry
"\\(?1:[0-9a-fA-F]+\\) " ; sha1
"\\(?2:.*\\)$")) ; msg
(defconst magit-log-bisect-vis-re
(concat "^"
"\\(?1:[0-9a-fA-F]+\\) " ; sha1
"\\(?:\\(?3:([^()]+)\\) \\)?" ; refs
"\\(?2:.+\\)$")) ; msg
(defconst magit-log-bisect-log-re
(concat "^# "
"\\(?3:bad:\\|skip:\\|good:\\) " ; "refs"
"\\[\\(?1:[^]]+\\)\\] " ; sha1
"\\(?2:.+\\)$")) ; msg
(defconst magit-log-reflog-re
(concat "^"
"\\(?1:[^ ]+\\) " ; sha1
"\\[\\(?5:[^]]*\\)\\] " ; author
"\\(?6:[^ ]*\\) " ; date
"[^@]+@{\\(?9:[^}]+\\)} " ; refsel
"\\(?10:merge\\|[^:]+\\)?:? ?" ; refsub
"\\(?2:.+\\)?$")) ; msg
(defconst magit-reflog-subject-re
(concat "\\([^ ]+\\) ?" ; command (1)
"\\(\\(?: ?-[^ ]+\\)+\\)?" ; option (2)
"\\(?: ?(\\([^)]+\\))\\)?")) ; type (3)
(defvar magit-log-count nil)
(defun magit-wash-log (style &optional color longer)
(when color
(let ((ansi-color-apply-face-function
(lambda (beg end face)
(when face
(put-text-property beg end 'font-lock-face face)))))
(ansi-color-apply-on-region (point-min) (point-max))))
(when (eq style 'cherry)
(reverse-region (point-min) (point-max)))
(let ((magit-log-count 0))
(magit-wash-sequence (apply-partially 'magit-wash-log-line style
(magit-abbrev-length)))
(when (and longer
(= magit-log-count magit-log-cutoff-length))
(magit-with-section (section longer 'longer)
(insert-text-button "type \"e\" to show more history"
'action (lambda (button)
(magit-log-show-more-entries))
'follow-link t
'mouse-face magit-item-highlight-face)))))
(defun magit-wash-log-line (style abbrev)
(looking-at (cl-ecase style
(oneline magit-log-oneline-re)
(long magit-log-long-re)
(unique magit-log-unique-re)
(cherry magit-log-cherry-re)
(reflog magit-log-reflog-re)
(bisect-vis magit-log-bisect-vis-re)
(bisect-log magit-log-bisect-log-re)))
(magit-bind-match-strings
(hash msg refs graph author date gpg cherry refsel refsub)
(delete-region (point) (point-at-eol))
(when cherry
(magit-insert cherry (if (string= cherry "-")
'magit-cherry-equivalent
'magit-cherry-unmatched) ?\s))
(unless (eq style 'long)
(when (eq style 'bisect-log)
(setq hash (magit-git-string "rev-parse" "--short" hash)))
(if hash
(insert (propertize hash 'face 'magit-log-sha1) ?\s)
(insert (make-string (1+ abbrev) ? ))))
(when graph
(if magit-log-format-graph-function
(insert (funcall magit-log-format-graph-function graph))
(insert graph)))
(when (and hash (eq style 'long))
(magit-insert (if refs hash (magit-rev-parse hash)) 'magit-log-sha1 ?\s))
(when refs
(magit-insert-ref-labels refs))
(when refsub
(insert (format "%-2s " refsel))
(insert (magit-log-format-reflog refsub)))
(when msg
(magit-insert msg (cl-case (and gpg (aref gpg 0))
(?G 'magit-signature-good)
(?B 'magit-signature-bad)
(?U 'magit-signature-untrusted)
(?N 'magit-signature-none)
(t 'magit-log-message))))
(goto-char (line-beginning-position))
(magit-format-log-margin author date)
(if hash
(magit-with-section (section commit hash)
(when (derived-mode-p 'magit-log-mode)
(cl-incf magit-log-count))
(forward-line)
(when (eq style 'long)
(magit-wash-sequence
(lambda ()
(looking-at magit-log-long-re)
(when (match-string 2)
(magit-wash-log-line 'long abbrev))))))
(forward-line)))
t)
(defun magit-log-format-unicode-graph (string)
"Translate ascii characters to unicode characters.
Whether that actually is an improvment depends on the unicode
support of the font in use. The translation is done using the
alist in `magit-log-format-unicode-graph-alist'."
(replace-regexp-in-string
"[/|\\*o ]"
(lambda (str)
(propertize
(string (or (cdr (assq (aref str 0)
magit-log-format-unicode-graph-alist))
(aref str 0)))
'face (get-text-property 0 'face str)))
string))
(defun magit-format-log-margin (&optional author date)
(when magit-log-show-margin
(cl-destructuring-bind (width characterp duration-spec)
magit-log-margin-spec
(if author
(magit-make-margin-overlay
(propertize (truncate-string-to-width
author (- width 1 3 (if characterp 0 1)
magit-log-margin-timeunit-width 1)
nil ?\s (make-string 1 magit-ellipsis))
'face 'magit-log-author)
" "
(propertize (magit-format-duration
(abs (truncate (- (float-time)
(string-to-number date))))
(symbol-value duration-spec)
magit-log-margin-timeunit-width)
'face 'magit-log-date)
(propertize " " 'face 'fringe))
(magit-make-margin-overlay
(propertize (make-string (1- width) ?\s) 'face 'default)
(propertize " " 'face 'fringe))))))
;;;;; Log Commands
(defun magit-log-toggle-margin ()
"Show or hide the log margin.
This command can only be used inside log buffers (usually
*magit-log*) and only if that displays a `oneline' log.
Also see option `magit-log-show-margin'."
(interactive)
(unless (derived-mode-p 'magit-log-mode)
(user-error "The log margin cannot be used outside of log buffers"))
(when (eq (car magit-refresh-args) 'long)
(user-error "The log margin cannot be used with verbose logs"))
(if magit-log-show-margin
(magit-set-buffer-margin (car magit-log-margin-spec)
(not (cdr (window-margins))))
(setq-local magit-log-show-margin t)
(magit-refresh)))
(defun magit-log-show-more-entries (&optional arg)
"Grow the number of log entries shown.
With no prefix optional ARG, show twice as many log entries.
With a numerical prefix ARG, add this number to the number of shown log entries.
With a non numeric prefix ARG, show all entries"
(interactive "P")
(setq-local magit-log-cutoff-length
(cond ((numberp arg) (+ magit-log-cutoff-length arg))
(arg magit-log-infinite-length)
(t (* magit-log-cutoff-length 2))))
(let ((old-point (point)))
(magit-refresh)
(goto-char old-point)))
;;;; Cherry Mode
(define-derived-mode magit-cherry-mode magit-mode "Magit Cherry"
"Mode for looking at commits not merged upstream.
\\<magit-cherry-mode-map>Type `\\[magit-toggle-section]` to show or hide \
section, `\\[magit-visit-item]` to visit an item and \
`\\[magit-show-item-or-scroll-up]` to show it.
Type `\\[magit-diff-working-tree]` to display change with your working tree, \
when `\\[magit-diff]` to display change
between any two commit.
Type `\\[magit-cherry-pick-item]` to cherry-pick a commit, and \
`\\[magit-apply-item]` to apply its change to your
working tree, without committing, and `\\[magit-key-mode-popup-merging]` to \
merge.
`\\[magit-refresh]` will refresh current buffer.
Other key binding:
\\{magit-cherry-mode-map}")
(defvar magit-cherry-buffer-name "*magit-cherry*"
"Name of buffer used to display commits not merged upstream.")
;;;###autoload
(defun magit-cherry (head upstream)
"Show commits in a branch that are not merged in the upstream branch."
(interactive
(let ((head (magit-read-rev "Cherry head" (magit-get-current-branch))))
(list head (magit-read-rev "Cherry upstream"
(magit-get-tracked-branch head nil t)))))
(magit-mode-setup magit-cherry-buffer-name nil
#'magit-cherry-mode
#'magit-refresh-cherry-buffer upstream head))
(defun magit-refresh-cherry-buffer (upstream head)
(magit-with-section (section cherry 'cherry nil t)
(run-hooks 'magit-cherry-sections-hook)))
(defun magit-insert-cherry-head-line ()
(magit-insert-line-section (line)
(concat "Head: "
(propertize (cadr magit-refresh-args) 'face 'magit-branch) " "
(abbreviate-file-name default-directory))))
(defun magit-insert-cherry-upstream-line ()
(magit-insert-line-section (line)
(concat "Upstream: "
(propertize (car magit-refresh-args) 'face 'magit-branch))))
(defun magit-insert-cherry-help-lines ()
(when (derived-mode-p 'magit-cherry-mode)
(insert "\n")
(magit-insert-line-section (line)
(concat (propertize "-" 'face 'magit-cherry-equivalent)
" equivalent exists in both refs"))
(magit-insert-line-section (line)
(concat (propertize "+" 'face 'magit-cherry-unmatched)
" unmatched commit tree"))))
(defun magit-insert-cherry-commits ()
(magit-git-insert-section (cherries "Cherry commits:")
(apply-partially 'magit-wash-log 'cherry)
"cherry" "-v" (magit-abbrev-arg) magit-refresh-args))
;;;; Reflog Mode
(defvar magit-reflog-buffer-name "*magit-reflog*"
"Name of buffer used to display reflog entries.")
(define-derived-mode magit-reflog-mode magit-log-mode "Magit Reflog"
"Mode for looking at git reflog.
\\<magit-reflog-mode-map>Type `\\[magit-visit-item]` to visit a commit, and \
`\\[magit-show-item-or-scroll-up]` to just show it.
Type `\\[magit-diff-working-tree]` to see the diff between current commit and \
your working tree,
Type `\\[magit-diff]` to see the between any two version.
Type `\\[magit-reset-head]` to reset your head to the current commit, and \
`\\[magit-apply-item]` to apply its change
to your working tree and `\\[magit-cherry-pick-item]` to cherry pick it.
More information can be found in Info node `(magit)Reflogs'
Other key binding:
\\{magit-reflog-mode-map}"
:group 'magit)
(defun magit-refresh-reflog-buffer (ref)
(magit-log-margin-set-timeunit-width)
(magit-git-insert-section
(reflogbuf (format "Local history of branch %s" ref))
(apply-partially 'magit-wash-log 'reflog t)
"reflog" "show" "--format=format:%h [%an] %ct %gd %gs"
(format "--max-count=%d" magit-log-cutoff-length) ref))
(defvar magit-reflog-labels
'(("commit" . magit-log-reflog-label-commit)
("amend" . magit-log-reflog-label-amend)
("merge" . magit-log-reflog-label-merge)
("checkout" . magit-log-reflog-label-checkout)
("branch" . magit-log-reflog-label-checkout)
("reset" . magit-log-reflog-label-reset)
("rebase" . magit-log-reflog-label-rebase)
("cherry-pick" . magit-log-reflog-label-cherry-pick)
("initial" . magit-log-reflog-label-commit)
("pull" . magit-log-reflog-label-remote)
("clone" . magit-log-reflog-label-remote)))
(defun magit-log-format-reflog (subject)
(let* ((match (string-match magit-reflog-subject-re subject))
(command (and match (match-string 1 subject)))
(option (and match (match-string 2 subject)))
(type (and match (match-string 3 subject)))
(label (if (string= command "commit")
(or type command)
command))
(text (if (string= command "commit")
label
(mapconcat #'identity
(delq nil (list command option type))
" "))))
(format "%-16s "
(propertize text 'face
(or (cdr (assoc label magit-reflog-labels))
'magit-log-reflog-label-other)))))
;;;; Ediff Support
(defvar magit-ediff-buffers nil
"List of buffers that may be killed by `magit-ediff-restore'.")
(defvar magit-ediff-windows nil
"The window configuration that will be restored when Ediff is finished.")
(defun magit-ediff ()
"View the current DIFF section in ediff."
(interactive)
(let ((diff (magit-current-section)))
(when (eq (magit-section-type (magit-current-section)) 'diffstat)
(setq diff (magit-diff-section-for-diffstat diff)))
(when (magit-section-hidden diff)
;; Range is not set until the first time the diff is visible.
;; This somewhat hackish code makes sure it's been visible at
;; least once.
(magit-toggle-section)
(magit-toggle-section)
(setq diff (magit-current-section)))
(when (eq 'hunk (magit-section-type diff))
(setq diff (magit-section-parent diff)))
(unless (eq 'diff (magit-section-type diff))
(user-error "No diff at this location"))
(let* ((status (magit-section-diff-status diff))
(file1 (magit-section-info diff))
(file2 (magit-section-diff-file2 diff))
(range (magit-diff-range diff)))
(cond
((memq status '(new deleted typechange))
(message "Why ediff a %s file?" status))
((and (eq status 'unmerged)
(eq (cdr range) 'working))
(magit-interactive-resolve file1))
((consp (car range))
(magit-ediff-buffers3 (magit-show (caar range) file2)
(magit-show (cdar range) file2)
(magit-show (cdr range) file1)))
(t
(magit-ediff-buffers (magit-show (car range) file2)
(magit-show (cdr range) file1)))))))
(defun magit-ediff-buffers (a b)
(setq magit-ediff-buffers (list a b))
(setq magit-ediff-windows (current-window-configuration))
(ediff-buffers a b '(magit-ediff-add-cleanup)))
(defun magit-ediff-buffers3 (a b c)
(setq magit-ediff-buffers (list a b c))
(setq magit-ediff-windows (current-window-configuration))
(ediff-buffers3 a b c '(magit-ediff-add-cleanup)))
(defun magit-diff-range (diff)
(if (eq major-mode 'magit-commit-mode)
(let ((revs (split-string
(magit-git-string "rev-list" "-1" "--parents"
(car (last magit-refresh-args))))))
(when (= (length revs) 2)
(cons (cadr revs) (car revs))))
(magit-section-diff-range diff)))
(defun magit-ediff-add-cleanup ()
(make-local-variable 'magit-ediff-buffers)
(setq-default magit-ediff-buffers ())
(make-local-variable 'magit-ediff-windows)
(setq-default magit-ediff-windows ())
(add-hook 'ediff-cleanup-hook 'magit-ediff-restore 'append 'local))
(defun magit-ediff-restore ()
"Kill any buffers in `magit-ediff-buffers' that are not visiting files and
restore the window state that was saved before ediff was called."
(dolist (buffer magit-ediff-buffers)
(when (and (null (buffer-file-name buffer))
(buffer-live-p buffer))
(with-current-buffer buffer
(when (and (eq magit-show-current-version 'index)
(buffer-modified-p))
(magit-save-index)))
(kill-buffer buffer)))
(let ((buf (current-buffer)))
(set-window-configuration magit-ediff-windows)
(set-buffer buf)))
;;;###autoload
(defun magit-save-index ()
"Add the content of current file as if it was the index."
(interactive)
(unless (eq magit-show-current-version 'index)
(user-error "Current buffer doesn't visit the index version of a file"))
(when (y-or-n-p (format "Stage current version of %s? " magit-file-name))
(let ((buf (current-buffer))
(name (magit-git-dir "magit-add-index")))
(with-temp-file name
(insert-buffer-substring buf))
(let ((hash (magit-git-string "hash-object" "-t" "blob" "-w"
(concat "--path=" magit-file-name)
"--" name))
(perm (substring (magit-git-string "ls-files" "-s"
magit-file-name)
0 6)))
(magit-run-git "update-index" "--cacheinfo"
perm hash magit-file-name)))))
;;;###autoload
(defun magit-interactive-resolve (file)
"Resolve a merge conflict using Ediff."
(interactive (list (magit-section-case (info) (diff (cadr info)))))
(require 'ediff)
(let ((merge-status (magit-git-lines "ls-files" "-u" "--" file))
(base-buffer)
(our-buffer (generate-new-buffer (concat file ".current")))
(their-buffer (generate-new-buffer (concat file ".merged")))
(merger-buffer)
(windows (current-window-configuration)))
(unless merge-status
(user-error "Cannot resolve %s" file))
(when (string-match "^[0-9]+ [0-9a-f]+ 1" (car merge-status))
(pop merge-status)
(setq base-buffer (generate-new-buffer (concat file ".base")))
(with-current-buffer base-buffer
(magit-git-insert "cat-file" "blob" (concat ":1:" file))))
;; If the second or third version do not exit, we use an empty buffer for the deleted file
(with-current-buffer our-buffer
(when (string-match "^[0-9]+ [0-9a-f]+ 2" (car merge-status))
(pop merge-status)
(magit-git-insert "cat-file" "blob" (concat ":2:" file)))
(let ((buffer-file-name file))
(normal-mode t)))
(with-current-buffer their-buffer
(when (string-match "^[0-9]+ [0-9a-f]+ 3" (car merge-status))
(magit-git-insert "cat-file" "blob" (concat ":3:" file)))
(let ((buffer-file-name file))
(normal-mode t)))
;; We have now created the 3 buffer with ours, theirs and the ancestor files
(if base-buffer
(setq merger-buffer (ediff-merge-buffers-with-ancestor
our-buffer their-buffer base-buffer nil nil file))
(setq merger-buffer (ediff-merge-buffers our-buffer their-buffer nil nil file)))
(with-current-buffer merger-buffer
(setq ediff-show-clashes-only t)
(setq-local magit-ediff-windows windows)
(make-local-variable 'ediff-quit-hook)
(add-hook 'ediff-quit-hook
(lambda ()
(let ((buffer-A ediff-buffer-A)
(buffer-B ediff-buffer-B)
(buffer-C ediff-buffer-C)
(buffer-Ancestor ediff-ancestor-buffer)
(windows magit-ediff-windows))
(ediff-cleanup-mess)
(kill-buffer buffer-A)
(kill-buffer buffer-B)
(when (bufferp buffer-Ancestor)
(kill-buffer buffer-Ancestor))
(set-window-configuration windows)))))))
;;;; Diff Mode
;;;;; Diff Core
(define-derived-mode magit-diff-mode magit-mode "Magit Diff"
"Mode for looking at a git diff.
\\<magit-diff-mode-map>Type `\\[magit-visit-item]` to visit the changed file, \
`\\[magit-toggle-section]` to hide or show a hunk,
`\\[magit-diff-larger-hunks]` and `\\[magit-diff-smaller-hunks]` to change \
the size of the hunks.
Type `\\[magit-apply-item]` to apply a change to your worktree and \
`\\[magit-revert-item]` to reverse it.
You can also use `\\[magit-ediff]` to see the current change with ediff.
More information can be found in Info node `(magit)Diffing'
\\{magit-diff-mode-map}"
:group 'magit)
(defvar magit-diff-buffer-name "*magit-diff*"
"Name of buffer used to display a diff.")
(defvar magit-stash-buffer-name "*magit-stash*"
"Name of buffer used to display a stash.")
;;;;; Diff Entry Commands
;;;###autoload
(defun magit-diff (range &optional working args)
"Show differences between two commits.
RANGE should be a range (A..B or A...B) but can also be a single
commit. If one side of the range is omitted, then it defaults
to HEAD. If just a commit is given, then changes in the working
tree relative to that commit are shown."
(interactive (list (magit-read-rev-range "Diff")))
(magit-mode-setup magit-diff-buffer-name
#'pop-to-buffer
#'magit-diff-mode
#'magit-refresh-diff-buffer range working args))
;;;###autoload
(defun magit-diff-working-tree (rev)
"Show differences between a commit and the current working tree."
(interactive (list (magit-read-rev-with-default "Diff working tree with")))
(magit-diff (or rev "HEAD") t))
;;;###autoload
(defun magit-diff-staged ()
"Show differences between the index and the HEAD commit."
(interactive)
(magit-diff nil nil (list "--cached")))
;;;###autoload
(defun magit-diff-unstaged ()
"Show differences between the current working tree and index."
(interactive)
(magit-diff nil))
;;;###autoload
(defun magit-diff-stash (stash &optional noselect)
"Show changes in a stash.
A Stash consist of more than just one commit. This command uses
a special diff range so that the stashed changes actually were a
single commit."
(interactive (list (magit-read-stash "Show stash (number): ")))
(magit-mode-setup magit-commit-buffer-name
(if noselect 'display-buffer 'pop-to-buffer)
#'magit-diff-mode
#'magit-refresh-diff-buffer
(concat stash "^2^.." stash)))
(defun magit-diff-with-mark (range)
"Show difference between the marked commit and the one at point.
If there is no commit at point, then prompt for one."
(interactive
(let* ((marked (or magit-marked-commit (user-error "No commit marked")))
(current (magit-get-current-branch))
(is-current (string= (magit-name-rev marked) current))
(commit (or (magit-guess-branch)
(magit-read-rev
(format "Diff marked commit %s with" marked)
(unless is-current current)
current))))
(list (concat marked ".." commit))))
(magit-diff range))
(defun magit-refresh-diff-buffer (range &optional working args)
(let ((magit-current-diff-range
(cond (working (cons range 'working))
((null range) nil)
((consp range)
(prog1 range
(setq range (concat (car range) ".." (cdr range)))))
((string-match "^\\([^.]+\\)\\.\\.\\([^.]\\)$" range)
(cons (match-string 1 range)
(match-string 2 range))))))
(magit-git-insert-section
(diffbuf (cond (working
(format "Changes from %s to working tree" range))
((not range)
(if (member "--cached" args)
"Staged changes"
"Unstaged changes"))
(t
(format "Changes in %s" range))))
#'magit-wash-diffs
"diff" (magit-diff-U-arg)
(and magit-show-diffstat "--patch-with-stat")
range args "--")))
;;;;; Diff Washing
(defconst magit-diff-statline-re
(concat "^ ?"
"\\(.*\\)" ; file
"\\( +| +\\)" ; separator
"\\([0-9]+\\|Bin\\(?: +[0-9]+ -> [0-9]+ bytes\\)?$\\) ?"
"\\(\\+*\\)" ; add
"\\(-*\\)$")) ; del
(defvar magit-current-diff-range nil
"Used internally when setting up magit diff sections.")
(defvar-local magit-diffstat-cached-sections nil)
(put 'magit-diffstat-cached-sections 'permanent-local t)
(defun magit-wash-diffs ()
(magit-wash-diffstats)
(when (re-search-forward "^diff" nil t)
(goto-char (line-beginning-position))
(magit-wash-sequence #'magit-wash-diff))
(goto-char (point-max))
(magit-xref-insert-buttons))
(defun magit-wash-diffstats ()
(let ((beg (point)))
(when (re-search-forward "^ ?\\([0-9]+ +files? change[^\n]*\n\\)" nil t)
(let ((heading (match-string-no-properties 1)))
(delete-region (match-beginning 0) (match-end 0))
(goto-char beg)
(magit-with-section (section diffstats 'diffstats heading)
(magit-wash-sequence #'magit-wash-diffstat)))
(setq magit-diffstat-cached-sections
(nreverse magit-diffstat-cached-sections)))))
(defun magit-wash-diffstat ()
(when (looking-at magit-diff-statline-re)
(magit-bind-match-strings (file sep cnt add del)
(delete-region (point) (1+ (line-end-position)))
(magit-with-section (section diffstat 'diffstat)
(insert " " file sep cnt " ")
(when add (insert (propertize add 'face 'magit-diff-add)))
(when del (insert (propertize del 'face 'magit-diff-del)))
(insert "\n")
(push section magit-diffstat-cached-sections)))))
(defun magit-wash-diff ()
(magit-with-section (section diff (buffer-substring-no-properties
(line-beginning-position)
(line-end-position)))
(setq section (magit-wash-diff-section section))))
(defun magit-wash-diff-section (section)
(cond ((re-search-forward "^\\* Unmerged path \\(.*\\)" nil t)
(forward-line 0)
(let ((file (magit-decode-git-path (match-string-no-properties 1))))
(delete-region (point) (line-end-position))
(insert "\tUnmerged " file "\n")
(setf (magit-section-diff-status section) 'unmerged)
(setf (magit-section-info section) file)
section))
((re-search-forward "^diff" nil t)
(forward-line 0)
(let ((file (cond
((looking-at "^diff --git \\(\".*\"\\) \\(\".*\"\\)$")
(substring (magit-decode-git-path
(match-string-no-properties 2)) 2))
((looking-at "^diff --git ./\\(.*\\) ./\\(.*\\)$")
(match-string-no-properties 2))
((looking-at "^diff --cc +\\(.*\\)$")
(match-string-no-properties 1))))
(end (save-excursion
(forward-line) ;; skip over "diff" line
(if (re-search-forward "^diff\\|^@@" nil t)
(goto-char (match-beginning 0))
(goto-char (point-max)))
(point-marker))))
(when magit-diffstat-cached-sections
(setf (magit-section-info (pop magit-diffstat-cached-sections))
file))
(let ((status (cond
((looking-at "^diff --cc")
'unmerged)
((save-excursion
(re-search-forward "^new file" end t))
'new)
((save-excursion
(re-search-forward "^deleted" end t))
(setf (magit-section-hidden section) t)
'deleted)
((save-excursion
(re-search-forward "^rename" end t))
'renamed)
(t
'modified)))
(file2 (cond
((save-excursion
(re-search-forward "^rename from \\(.*\\)"
end t))
(match-string-no-properties 1)))))
(setf (magit-section-diff-status section) status)
(setf (magit-section-info section) file)
(setf (magit-section-diff-file2 section) (or file2 file))
(setf (magit-section-diff-range section) magit-current-diff-range)
(magit-insert-diff-title status file file2)
(when (re-search-forward
"\\(--- \\(.*\\)\n\\+\\+\\+ \\(.*\\)\n\\)" nil t)
(magit-put-face-property (match-beginning 1) (match-end 1)
'magit-diff-hunk-header)
(magit-put-face-property (match-beginning 2) (match-end 2)
'magit-diff-file-header)
(magit-put-face-property (match-beginning 3) (match-end 3)
'magit-diff-file-header))
(goto-char end)
(magit-wash-sequence #'magit-wash-hunk)))
section)))
(defun magit-insert-diff-title (status file file2)
(insert (format "\t%-10s " (capitalize (symbol-name status)))
file
(if (eq status 'renamed) (format " (from %s)" file2) "")
"\n"))
(defun magit-wash-hunk ()
(when (looking-at "^@@\\(@\\)?.+")
(let ((merging (match-beginning 1)))
(magit-with-section (section hunk (match-string 0))
(magit-put-face-property (point) (line-end-position)
'magit-diff-hunk-header)
(forward-line)
(while (not (or (eobp) (looking-at "^diff\\|^@@")))
(magit-put-face-property
(point) (line-end-position)
(cond
((looking-at "^\\+\\+<<<<<<<") 'magit-diff-merge-current)
((looking-at "^\\+\\+=======") 'magit-diff-merge-separator)
((looking-at "^\\+\\+|||||||") 'magit-diff-merge-diff3-separator)
((looking-at "^\\+\\+>>>>>>>") 'magit-diff-merge-proposed)
((looking-at (if merging "^\\(\\+\\| \\+\\)" "^\\+"))
(magit-diff-highlight-whitespace merging)
'magit-diff-add)
((looking-at (if merging "^\\(-\\| \\-\\)" "^-"))
(magit-diff-highlight-whitespace merging)
'magit-diff-del)
(t
'magit-diff-none)))
(forward-line))
(when (eq magit-diff-refine-hunk 'all)
(magit-diff-refine-hunk section))))
t))
(defun magit-diff-highlight-whitespace (merging)
(when (and magit-highlight-whitespace
(or (derived-mode-p 'magit-status-mode)
(not (eq magit-highlight-whitespace 'status))))
(let ((prefix (if merging "^[-\\+\s]\\{2\\}" "^[-\\+]"))
(indent
(if (local-variable-p 'magit-highlight-indentation)
magit-highlight-indentation
(setq-local
magit-highlight-indentation
(cdr (cl-find-if (lambda (pair)
(string-match-p (car pair) default-directory))
(default-value 'magit-highlight-indentation)
:from-end t))))))
(when (and magit-highlight-trailing-whitespace
(looking-at (concat prefix ".*?\\([ \t]+\\)$")))
(magit-put-face-property (match-beginning 1) (match-end 1)
'magit-whitespace-warning-face))
(when (or (and (eq indent 'tabs)
(looking-at (concat prefix "\\( *\t[ \t]*\\)")))
(and (integerp indent)
(looking-at (format "%s\\([ \t]* \\{%s,\\}[ \t]*\\)"
prefix indent))))
(magit-put-face-property (match-beginning 1) (match-end 1)
'magit-whitespace-warning-face)))))
;;;;; Diff Mode Commands
(defun magit-diff-toggle-refine-hunk (&optional other)
"Turn diff-hunk refining on or off.
If hunk refining is currently on, then hunk refining is turned off.
If hunk refining is off, then hunk refining is turned on, in
`selected' mode (only the currently selected hunk is refined).
With a prefix argument, the \"third choice\" is used instead:
If hunk refining is currently on, then refining is kept on, but
the refining mode (`selected' or `all') is switched.
If hunk refining is off, then hunk refining is turned on, in
`all' mode (all hunks refined).
Customize variable `magit-diff-refine-hunk' to change the default mode."
(interactive "P")
(let ((hunk (and magit-highlighted-section
(eq (magit-section-type magit-highlighted-section) 'hunk)
magit-highlighted-section))
(old magit-diff-refine-hunk))
(setq-local magit-diff-refine-hunk
(if other
(if (eq old 'all) t 'all)
(not old)))
(cond ((or (eq old 'all)
(eq magit-diff-refine-hunk 'all))
(magit-refresh))
((not hunk))
(magit-diff-refine-hunk
(magit-diff-refine-hunk hunk))
(t
(magit-diff-unrefine-hunk hunk)))
(message "magit-diff-refine-hunk: %s" magit-diff-refine-hunk)))
(defun magit-diff-refine-hunk (hunk)
(save-excursion
(goto-char (magit-section-beginning hunk))
;; `diff-refine-hunk' does not handle combined diffs.
(unless (looking-at "@@@")
(diff-refine-hunk))))
(defun magit-diff-unrefine-hunk (hunk)
(remove-overlays (magit-section-beginning hunk)
(magit-section-end hunk)
'diff-mode 'fine))
;;;; Wazzup Mode
(define-derived-mode magit-wazzup-mode magit-mode "Magit Wazzup"
"Mode for looking at git commits not merged into current HEAD.
\\<magit-wazzup-mode-map>Type `\\[magit-toggle-section]` to show or hide \
section, `\\[magit-visit-item]` to visit an item \
`\\[magit-show-item-or-scroll-up]` to show it.
Type `\\[magit-diff-working-tree]` to display change with your working tree, \
and `\\[magit-diff]` to display change
between any two commit.
Type `\\[magit-cherry-pick-item]` to cherry-pick a commit, and \
`\\[magit-apply-item]` to apply its change to your
working tree, without committing, and `\\[magit-key-mode-popup-merging]` \
to merge those change.
Type `\\[magit-refresh]` to refresh current buffer.
More information can be found in Info node `(magit)Wazzup'
\\{magit-wazzup-mode-map}"
:group 'magit)
(defvar magit-wazzup-buffer-name "*magit-wazzup*"
"Name of buffer used to display commits not merged into current HEAD.")
;;;###autoload
(defun magit-wazzup (branch)
"Show a list of branches in a dedicated buffer.
Unlike in the buffer created by `magit-branch-manager' each
branch can be expanded to show a list of commits not merged
into the selected branch."
(interactive
(let ((branch (magit-get-current-branch)))
(list (if current-prefix-arg
(magit-read-rev "Wazzup branch" branch)
branch))))
(magit-mode-setup magit-wazzup-buffer-name nil
#'magit-wazzup-mode
#'magit-refresh-wazzup-buffer branch))
(defun magit-refresh-wazzup-buffer (head)
(magit-with-section (section wazzupbuf 'wazzupbuf nil t)
(run-hooks 'magit-wazzup-sections-hook)))
(defun magit-insert-wazzup-head-line ()
(magit-insert-line-section (line)
(concat "Head: "
(propertize (car magit-refresh-args) 'face 'magit-branch) " "
(abbreviate-file-name default-directory))))
(defun magit-insert-wazzup-branches ()
(dolist (upstream (magit-git-lines "show-ref"))
(setq upstream (cadr (split-string upstream " ")))
(when (and (not (string-match-p "HEAD$" upstream))
(string-match-p "^refs/\\(heads\\|remotes\\)/" upstream))
(magit-insert-wazzup-commits upstream (car magit-refresh-args)))))
(defun magit-insert-wazzup-commits (upstream head)
(let ((count (string-to-number
(magit-git-string "rev-list" "--count" "--right-only"
(concat head "..." upstream)))))
(when (> count 0)
(magit-with-section
(section wazzup upstream
(format "%3s %s\n" count (magit-format-ref-label upstream))
nil t)
(cond
((magit-section-hidden section)
(setf (magit-section-hidden section) t)
(setf (magit-section-needs-refresh-on-show section) t))
(t
(let ((beg (point)))
(magit-git-insert "cherry" "-v" "--abbrev" head upstream)
(save-restriction
(narrow-to-region beg (point))
(goto-char (point-min))
(magit-wash-log 'cherry)))))))))
;;;; Branch Manager Mode
;;;;; (core)
(define-derived-mode magit-branch-manager-mode magit-mode "Magit Branch"
"Mode for looking at git branches.
\\<magit-branch-manager-mode-map>Type `\\[magit-visit-item]` to checkout a branch, `\\[magit-reset-head]' to reset current branch,
you can also merge the branch with `\\[magit-key-mode-popup-merging]`
Type `\\[magit-discard-item]' to delete a branch, or `\\[universal-argument] \\[magit-discard-item]' to force the deletion.
Type `\\[magit-rename-item]' to Rename a branch.
More information can be found in Info node `(magit)The branch list'
\\{magit-branch-manager-mode-map}
Unless shadowed by the mode specific bindings above, bindings
from the parent keymap `magit-mode-map' are also available.")
(defvar magit-branches-buffer-name "*magit-branches*"
"Name of buffer used to display and manage branches.")
;;;###autoload
(defun magit-branch-manager ()
"Show a list of branches in a dedicated buffer."
(interactive)
(if (magit-get-top-dir) ; Kludge for #1215
(magit-mode-setup magit-branches-buffer-name nil
#'magit-branch-manager-mode
#'magit-refresh-branch-manager)
(user-error "There is no Git repository here")))
(defun magit-refresh-branch-manager ()
(magit-git-insert-section (branchbuf nil)
#'magit-wash-branches
"branch" "-vva" magit-custom-options))
;;;;; Branch List Washing
(defconst magit-wash-branch-line-re
(concat "^\\([ *] \\)" ; 1: current branch marker
"\\(.+?\\) +" ; 2: branch name
"\\(?:"
"\\([0-9a-fA-F]+\\)" ; 3: sha1
" "
"\\(?:\\["
"\\([^:\n]+?\\)" ; 4: tracking
"\\(?:: \\)?"
"\\(?:ahead \\([0-9]+\\)\\)?" ; 5: ahead
"\\(?:, \\)?"
"\\(?:behind \\([0-9]+\\)\\)?" ; 6: behind
"\\] \\)?"
"\\(?:.*\\)" ; message
"\\|" ; or
"-> " ; the pointer to
"\\(.+\\)" ; 7: a ref
"\\)\n"))
(defun magit-wash-branch-line (&optional remote-name)
(when (looking-at magit-wash-branch-line-re)
;; ^ Kludge for #1162. v Don't reindent for now.
(let* ((marker (match-string 1))
(branch (match-string 2))
(sha1 (match-string 3))
(tracking (match-string 4))
(ahead (match-string 5))
(behind (match-string 6))
(other-ref (match-string 7))
(branch-face (and (equal marker "* ") 'magit-branch)))
(delete-region (point) (line-beginning-position 2))
(magit-with-section (section branch branch)
(insert (propertize (or sha1 (make-string 7 ? ))
'face 'magit-log-sha1)
" " marker
(propertize (if (string-match-p "^remotes/" branch)
(substring branch 8)
branch)
'face branch-face))
(when other-ref
(insert " -> " (substring other-ref (+ 1 (length remote-name)))))
(when (and tracking
(equal (magit-get-tracked-branch branch t)
(concat "refs/remotes/" tracking)))
(insert " [")
;; getting rid of the tracking branch name if it is
;; the same as the branch name
(let* ((remote (magit-get "branch" branch "remote"))
(merge (substring tracking (+ 1 (length remote)))))
(insert (propertize (if (string= branch merge)
(concat "@ " remote)
(concat merge " @ " remote))
'face 'magit-log-head-label-remote)))
(when (or ahead behind)
(insert ":")
(and ahead (insert "ahead " (propertize ahead 'face branch-face)))
(and ahead behind (insert ", "))
(and behind (insert "behind "
(propertize behind 'face
'magit-log-head-label-remote))))
(insert "]"))
(insert "\n")))))
(defun magit-wash-remote-branches-group (group)
(let* ((remote (car group))
(url (magit-get "remote" remote "url"))
(push-url (magit-get "remote" remote "pushurl"))
(urls (concat url (and push-url (concat ", " push-url))))
(marker (cadr group)))
(magit-with-section
(section remote remote (format "%s (%s):" remote urls) t)
(magit-wash-branches-between-point-and-marker marker remote)
(insert "\n"))))
(defun magit-wash-branches-between-point-and-marker (marker &optional remote-name)
(save-restriction
(narrow-to-region (point) marker)
(magit-wash-sequence
(apply-partially 'magit-wash-branch-line remote-name))))
(defun magit-wash-branches ()
;; get the names of the remotes
(let* ((remotes (magit-git-lines "remote"))
;; get the location of remotes in the buffer
(markers
(append (mapcar (lambda (remote)
(save-excursion
(when (re-search-forward
(format "^ remotes/%s/" remote) nil t)
(beginning-of-line)
(point-marker))))
remotes)
(list (save-excursion
(goto-char (point-max))
(point-marker)))))
;; list of remote elements to display in the buffer
(remote-groups
(cl-loop for remote in remotes
for end-markers on (cdr markers)
for marker = (cl-loop for x in end-markers thereis x)
collect (list remote marker))))
;; actual displaying of information
(magit-with-section (section local "." "Local:" t)
(magit-wash-branches-between-point-and-marker
(cl-loop for x in markers thereis x))
(insert "\n"))
(mapc 'magit-wash-remote-branches-group remote-groups)
;; make sure markers point to nil so that they can be garbage collected
(mapc (lambda (marker)
(when marker
(set-marker marker nil)))
markers)))
;;;;; (commands)
(defun magit-rename-item ()
"Rename the item at point."
(interactive)
(magit-section-action rename ()
(branch (call-interactively 'magit-rename-branch))
(remote (call-interactively 'magit-rename-remote))))
(defun magit-change-what-branch-tracks ()
"Change which remote branch the current branch tracks."
(interactive)
(let* ((branch (magit-guess-branch))
(track (magit-read-rev "Track branch"))
(track-
(cond ((string-match "^\\([^ ]+\\) +(\\(.+\\))$" track)
(cons (match-string 2 track)
(concat "refs/heads/" (match-string 1 track))))
((string-match "^\\(?:refs/remotes/\\)?\\([^/]+\\)/\\(.+\\)"
track)
(cons (match-string 1 track)
(concat "refs/heads/" (match-string 2 track))))
(t
(user-error "Cannot parse the remote and branch name")))))
(magit-set (car track-) "branch" branch "remote")
(magit-set (cdr track-) "branch" branch "merge")
(magit-refresh)))
;;; Miscellaneous
;;;; Miscellaneous Commands
;;;###autoload
(defun magit-init (directory)
"Create or reinitialize a Git repository.
Read directory name and initialize it as new Git repository.
If the directory is below an existing repository, then the user
has to confirm that a new one should be created inside; or when
the directory is the root of the existing repository, whether
it should be reinitialized.
Non-interactively DIRECTORY is always (re-)initialized."
(interactive
(let* ((dir (file-name-as-directory
(expand-file-name
(read-directory-name "Create repository in: "))))
(top (magit-get-top-dir dir)))
(if (and top
(not (yes-or-no-p
(if (string-equal top dir)
(format "Reinitialize existing repository %s? " dir)
(format "%s is a repository. Create another in %s? "
top dir)))))
(user-error "Abort")
(list dir))))
(magit-run-git "init" (expand-file-name directory)))
(defun magit-copy-item-as-kill ()
"Copy sha1 of commit at point into kill ring."
(interactive)
(magit-section-action copy (info)
((branch commit file diff)
(kill-new info)
(message "%s" info))))
(defun magit-ignore-item (edit &optional local)
"Ignore the item at point.
With a prefix argument edit the ignore string."
(interactive "P")
(magit-section-action ignore (info)
([file untracked]
(magit-ignore-file (concat "/" info) edit local)
(magit-refresh))
(diff
(when (yes-or-no-p (format "%s is tracked. Untrack and ignore? " info))
(magit-ignore-file (concat "/" info) edit local)
(magit-run-git "rm" "--cached" info)))))
(defun magit-ignore-item-locally (edit)
"Ignore the item at point locally only.
With a prefix argument edit the ignore string."
(interactive "P")
(magit-ignore-item edit t))
(defun magit-ignore-file (file &optional edit local)
"Add FILE to the list of files to ignore.
If EDIT is non-nil, prompt the user for the string to be ignored
instead of using FILE. The changes are written to .gitignore
except if LOCAL is non-nil in which case they are written to
.git/info/exclude."
(let* ((local-ignore-dir (magit-git-dir "info/"))
(ignore-file (if local
(concat local-ignore-dir "exclude")
".gitignore")))
(when edit
(setq file (magit-ignore-edit-string file)))
(when (and local (not (file-exists-p local-ignore-dir)))
(make-directory local-ignore-dir t))
(with-temp-buffer
(when (file-exists-p ignore-file)
(insert-file-contents ignore-file))
(goto-char (point-max))
(unless (bolp)
(insert "\n"))
(insert file "\n")
(write-region nil nil ignore-file))))
(defun magit-ignore-edit-string (file)
"Prompt the user for the string to be ignored.
A list of predefined values with wildcards is derived from the
filename FILE."
(let* ((extension (concat "*." (file-name-extension file)))
(extension-in-dir (concat (file-name-directory file) extension))
(filename (file-name-nondirectory file))
(completions (list extension extension-in-dir filename file)))
(magit-completing-read "File/pattern to ignore"
completions nil nil nil nil file)))
;;;; Commit Mark
(defvar magit-marked-commit nil)
(defvar-local magit-mark-overlay nil)
(put 'magit-mark-overlay 'permanent-local t)
(defun magit-mark-item (&optional unmark)
"Mark the commit at point.
Some commands act on the marked commit by default or use it as
default when prompting for a commit."
(interactive "P")
(if unmark
(setq magit-marked-commit nil)
(magit-section-action mark (info)
(commit (setq magit-marked-commit
(if (equal magit-marked-commit info) nil info)))))
(magit-refresh-marked-commits)
(run-hooks 'magit-mark-commit-hook))
(defun magit-refresh-marked-commits ()
(magit-map-magit-buffers #'magit-refresh-marked-commits-in-buffer))
(defun magit-refresh-marked-commits-in-buffer ()
(unless magit-mark-overlay
(setq magit-mark-overlay (make-overlay 1 1))
(overlay-put magit-mark-overlay 'face 'magit-item-mark))
(delete-overlay magit-mark-overlay)
(magit-map-sections
(lambda (section)
(when (and (eq (magit-section-type section) 'commit)
(equal (magit-section-info section)
magit-marked-commit))
(move-overlay magit-mark-overlay
(magit-section-beginning section)
(magit-section-end section)
(current-buffer))))
magit-root-section))
;;;; ChangeLog
;;;###autoload
(defun magit-add-change-log-entry (&optional whoami file-name other-window)
"Find change log file and add date entry and item for current change.
This differs from `add-change-log-entry' (which see) in that
it acts on the current hunk in a Magit buffer instead of on
a position in a file-visiting buffer."
(interactive (list current-prefix-arg
(prompt-for-change-log-name)))
(let (buf pos)
(save-window-excursion
(magit-visit-item)
(setq buf (current-buffer)
pos (point)))
(save-excursion
(with-current-buffer buf
(goto-char pos)
(add-change-log-entry whoami file-name other-window)))))
;;;###autoload
(defun magit-add-change-log-entry-other-window (&optional whoami file-name)
"Find change log file in other window and add entry and item.
This differs from `add-change-log-entry-other-window' (which see)
in that it acts on the current hunk in a Magit buffer instead of
on a position in a file-visiting buffer."
(interactive (and current-prefix-arg
(list current-prefix-arg
(prompt-for-change-log-name))))
(magit-add-change-log-entry whoami file-name t))
;;;; Read Repository
(defun magit-read-top-dir (dir)
"Ask the user for a Git repository.
The choices offered by auto-completion will be the repositories
under `magit-repo-dirs'. If `magit-repo-dirs' is nil or DIR is
non-nil, then autocompletion will offer directory names."
(if (and (not dir) magit-repo-dirs)
(let* ((repos (magit-list-repos magit-repo-dirs))
(reply (magit-completing-read "Git repository" repos)))
(file-name-as-directory
(or (cdr (assoc reply repos))
(if (file-directory-p reply)
(expand-file-name reply)
(user-error "Not a repository or a directory: %s" reply)))))
(file-name-as-directory
(read-directory-name "Git repository: "
(or (magit-get-top-dir) default-directory)))))
(defun magit-list-repos (dirs)
(magit-list-repos-remove-conflicts
(cl-loop for dir in dirs
append (cl-loop for repo in
(magit-list-repos* dir magit-repo-dirs-depth)
collect (cons (file-name-nondirectory repo) repo)))))
(defun magit-list-repos* (dir depth)
"Return a list of repos found in DIR, recursing up to DEPTH levels deep."
(if (file-readable-p (expand-file-name ".git" dir))
(list (expand-file-name dir))
(and (> depth 0)
(file-accessible-directory-p dir)
(not (member (file-name-nondirectory dir)
'(".." ".")))
(cl-loop for entry in (directory-files dir t nil t)
append (magit-list-repos* entry (1- depth))))))
(defun magit-list-repos-remove-conflicts (alist)
(let ((dict (make-hash-table :test 'equal))
(alist (delete-dups alist))
(result nil))
(dolist (a alist)
(puthash (car a) (cons (cdr a) (gethash (car a) dict))
dict))
(maphash
(lambda (key value)
(if (= (length value) 1)
(push (cons key (car value)) result)
(let ((sub (magit-list-repos-remove-conflicts
(mapcar
(lambda (entry)
(let ((dir (directory-file-name
(substring entry 0 (- (length key))))))
(cons (concat (file-name-nondirectory dir) "/" key)
entry)))
value))))
(setq result (append result sub)))))
dict)
result))
;;;; External Tools
;;;###autoload
(defun magit-run-git-gui ()
"Run `git gui' for the current git repository."
(interactive)
(let* ((default-directory (magit-get-top-dir)))
(call-process magit-git-executable nil 0 nil "gui")))
;;;###autoload
(defun magit-run-git-gui-blame (commit filename &optional linenum)
"Run `git gui blame' on the given FILENAME and COMMIT.
Interactively run it for the current file and the HEAD, with a
prefix or when the current file cannot be determined let the user
choose. When the current buffer is visiting FILENAME instruct
blame to center around the line point is on."
(interactive
(let (revision filename)
(when (or current-prefix-arg
(not (setq revision "HEAD"
filename (magit-buffer-file-name t))))
(setq revision (magit-read-rev "Retrieve from revision" "HEAD")
filename (magit-read-file-from-rev revision)))
(list revision filename
(and (equal filename
(ignore-errors
(magit-file-relative-name (buffer-file-name))))
(line-number-at-pos)))))
(let ((default-directory (magit-get-top-dir)))
(apply #'call-process magit-git-executable nil 0 nil "gui" "blame"
`(,@(and linenum (list (format "--line=%d" linenum)))
,commit
,filename))))
;;;###autoload
(defun magit-run-gitk (arg)
"Run Gitk for the current git repository.
Without a prefix argument run `gitk --all', with
a prefix argument run gitk without any arguments."
(interactive "P")
(apply #'call-process magit-gitk-executable nil 0 nil
(if arg nil (list "--all"))))
;;;; Maintenance Tools
(defun magit-describe-item ()
"Show information about the section at point.
This command is intended for debugging purposes."
(interactive)
(let* ((section (magit-current-section))
(head-beg (magit-section-beginning section))
(body-beg (magit-section-content-beginning section)))
(message "Section: %s %s%s-%s %S %S"
(magit-section-type section)
(marker-position (magit-section-beginning section))
(if (and body-beg (not (= body-beg head-beg))
(< body-beg (magit-section-end section)))
(format "-%s" (marker-position body-beg))
"")
(marker-position (magit-section-end section))
(magit-section-info section)
(magit-section-context-type section))))
;;;; Magit Extensions
(defun magit-load-config-extensions ()
"Try to load magit extensions that are defined at git config layer.
This can be added to `magit-mode-hook' for example"
(dolist (ext (magit-get-all "magit.extension"))
(let ((sym (intern (format "magit-%s-mode" ext))))
(when (and (fboundp sym)
(not (eq sym 'magit-wip-save-mode)))
(funcall sym 1)))))
;;; magit.el ends soon
(defconst magit-font-lock-keywords
(eval-when-compile
`((,(concat "(\\(" (regexp-opt
'("magit-define-level-shower"
"magit-define-section-jumper"))
"\\)\\>[ \t'\(]*\\(\\sw+\\)?")
(1 font-lock-keyword-face)
(2 font-lock-function-name-face nil t))
(,(concat "(" (regexp-opt
'("magit-with-section"
"magit-cmd-insert-section"
"magit-git-insert-section"
"magit-insert-line-section"
"magit-section-action"
"magit-section-case"
"magit-add-action-clauses"
"magit-bind-match-strings"
"magit-visiting-file-item"
"magit-tests--with-temp-dir"
"magit-tests--with-temp-repo"
"magit-tests--with-temp-clone") t)
"\\>")
. 1)))
"Magit expressions to highlight in Emacs-Lisp mode.
To highlight Magit expressions add something like this to your
init file:
(require 'magit)
(font-lock-add-keywords 'emacs-lisp-mode
magit-font-lock-keywords)")
(defun magit-version (&optional noerror)
"The version of Magit that you're using.\n\n\(fn)"
(interactive)
(let ((toplib (or load-file-name buffer-file-name)))
(unless (and toplib
(equal (file-name-nondirectory toplib) "magit.el"))
(setq toplib (locate-library "magit.el")))
(when toplib
(let* ((dir (file-name-directory toplib))
(static (expand-file-name "magit-version.el" dir))
(gitdir (expand-file-name ".git" dir)))
(cond ((file-exists-p gitdir)
(setq magit-version
(let ((default-directory dir))
(magit-git-string "describe" "--tags" "--dirty")))
(ignore-errors (delete-file static)))
((file-exists-p static)
(load-file static))
((featurep 'package)
(setq magit-version
(or (ignore-errors ; < 24.3.50
(package-version-join
(package-desc-vers
(cdr (assq 'magit package-alist)))))
(ignore-errors ; >= 24.3.50
(package-version-join
(package-desc-version
(cadr (assq 'magit package-alist)))))))))))
(if (stringp magit-version)
(when (called-interactively-p 'any)
(message "magit-%s" magit-version))
(if noerror
(progn (setq magit-version 'error)
(message "Cannot determine Magit's version"))
(user-error "Cannot determine Magit's version")))
magit-version))
(defvar magit-last-seen-setup-instructions "0")
(defun magit-maybe-show-setup-instructions ()
(when (version< magit-last-seen-setup-instructions "1.4.0")
(require 'warnings)
(display-warning :warning "for magit-1.4.0
You have just updated to version 1.4.0 of Magit, and have to
make a choice.
Before running Git, Magit by default reverts all unmodified
buffers which visit files tracked in the current repository.
This can potentially lead to dataloss so you might want to
disable this by adding the following line to your init file:
(setq magit-auto-revert-mode nil)
The risk is not as high as it might seem. If snapshots on Melpa
and Melpa-Stable had this enabled for a long time, so if you did
not experience any dataloss in the past, then you should probably
keep this enabled.
Keeping this mode enabled is only problematic if you, for
example, use `git reset --hard REV' or `magit-reset-head-hard',
and expect Emacs to preserve the old state of some file in a
buffer. If you turn of this mode then file-visiting buffers and
Magit buffer will no longer by in sync, which can be confusing
and complicates many operations. Also note that it is possible
to undo a buffer revert using `C-x u' (`undo').
Then you also have to add the following line to your init file
to prevent this message from being shown again when you restart
Emacs:
(setq magit-last-seen-setup-instructions \"1.4.0\")
You might also want to read the release notes:
https://raw.githubusercontent.com/magit/magit/next/Documentation/RelNotes/1.4.0.txt"))
(when (featurep 'magit-log-edit)
(display-warning :error "magit-log-edit has to be removed
Magit is no longer compatible with the library `magit-log-edit',
which was used in earlier releases. Please remove it, so that
Magit can use the successor `git-commit-mode' without the
obsolete library getting in the way. Then restart Emacs.
You might also want to read:
https://github.com/magit/magit/wiki/Emacsclient")))
(add-hook 'after-init-hook #'magit-maybe-show-setup-instructions)
(provide 'magit)
(cl-eval-when (load eval)
(magit-version t)
(when after-init-time
(magit-maybe-show-setup-instructions)))
(require 'magit-key-mode)
;; Local Variables:
;; coding: utf-8
;; indent-tabs-mode: nil
;; End:
;;; magit.el ends here
Reference in New Issue Copy Permalink