update magit
authorJoerg Jaspert <joerg@ganneff.de>
Thu, 22 Aug 2013 09:15:39 +0000 (11:15 +0200)
committerJoerg Jaspert <joerg@ganneff.de>
Thu, 22 Aug 2013 09:15:55 +0000 (11:15 +0200)
12 files changed:
.emacs.d/config/emacs.org
.emacs.d/elisp/magit/magit-autoloads.el [new file with mode: 0644]
.emacs.d/elisp/magit/magit-bisect.el
.emacs.d/elisp/magit/magit-blame.el
.emacs.d/elisp/magit/magit-key-mode.el
.emacs.d/elisp/magit/magit-pkg.el [new file with mode: 0644]
.emacs.d/elisp/magit/magit-stgit.el
.emacs.d/elisp/magit/magit-svn.el
.emacs.d/elisp/magit/magit-topgit.el
.emacs.d/elisp/magit/magit-wip.el
.emacs.d/elisp/magit/magit.el
.emacs.d/elisp/magit/rebase-mode.el

index c6952e7..90675fe 100644 (file)
@@ -2623,7 +2623,7 @@ Saner regex syntax
 magit is a mode for interacting with git.
 #+BEGIN_SRC emacs-lisp tangle:yes
 (require 'magitload)
-(require 'magit-svn)
+;(require 'magit-svn)
 (global-set-key (kbd "C-x g") 'magit-status)
 (setq magit-commit-signoff t)
 #+END_SRC
diff --git a/.emacs.d/elisp/magit/magit-autoloads.el b/.emacs.d/elisp/magit/magit-autoloads.el
new file mode 100644 (file)
index 0000000..62f2741
--- /dev/null
@@ -0,0 +1,158 @@
+;;; magit-autoloads.el --- automatically extracted autoloads
+;;
+;;; Code:
+(add-to-list 'load-path (or (file-name-directory #$) (car load-path)))
+\f
+;;;### (autoloads nil "magit" "magit.el" (21012 47854 0 0))
+;;; Generated autoloads from magit.el
+
+(autoload 'magit-status "magit" "\
+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.
+
+\(fn DIR)" t nil)
+
+;;;***
+\f
+;;;### (autoloads nil "magit-blame" "magit-blame.el" (21012 47854
+;;;;;;  0 0))
+;;; Generated autoloads from magit-blame.el
+
+(autoload 'magit-blame-mode "magit-blame" "\
+Display blame information inline.
+
+\(fn &optional ARG)" t nil)
+
+;;;***
+\f
+;;;### (autoloads nil "magit-stgit" "magit-stgit.el" (21012 47854
+;;;;;;  0 0))
+;;; Generated autoloads from magit-stgit.el
+
+(autoload 'magit-stgit-mode "magit-stgit" "\
+StGit support for Magit
+
+\(fn &optional ARG)" t nil)
+
+(autoload 'turn-on-magit-stgit "magit-stgit" "\
+Unconditionally turn on `magit-stgit-mode'.
+
+\(fn)" nil nil)
+
+;;;***
+\f
+;;;### (autoloads nil "magit-svn" "magit-svn.el" (21012 47854 0 0))
+;;; Generated autoloads from magit-svn.el
+
+(autoload 'magit-svn-mode "magit-svn" "\
+SVN support for Magit
+
+\(fn &optional ARG)" t nil)
+
+(autoload 'turn-on-magit-svn "magit-svn" "\
+Unconditionally turn on `magit-svn-mode'.
+
+\(fn)" nil nil)
+
+;;;***
+\f
+;;;### (autoloads nil "magit-topgit" "magit-topgit.el" (21012 47854
+;;;;;;  0 0))
+;;; Generated autoloads from magit-topgit.el
+
+(autoload 'magit-topgit-mode "magit-topgit" "\
+Topgit support for Magit
+
+\(fn &optional ARG)" t nil)
+
+(autoload 'turn-on-magit-topgit "magit-topgit" "\
+Unconditionally turn on `magit-topgit-mode'.
+
+\(fn)" nil nil)
+
+;;;***
+\f
+;;;### (autoloads nil "magit-wip" "magit-wip.el" (21012 47854 0 0))
+;;; Generated autoloads from magit-wip.el
+
+(defvar magit-wip-mode nil "\
+Non-nil if Magit-Wip mode is enabled.
+See the command `magit-wip-mode' for a description of this minor mode.
+Setting this variable directly does not take effect;
+either customize it (see the info node `Easy Customization')
+or call the function `magit-wip-mode'.")
+
+(custom-autoload 'magit-wip-mode "magit-wip" nil)
+
+(autoload 'magit-wip-mode "magit-wip" "\
+In Magit log buffers; give wip refs a special appearance.
+
+\(fn &optional ARG)" t nil)
+
+(autoload 'magit-wip-save-mode "magit-wip" "\
+Magit support for committing to a work-in-progress ref.
+
+When this minor mode is turned on and a file is saved inside a writable
+git repository then it is also committed to a special work-in-progress
+ref.
+
+\(fn &optional ARG)" t nil)
+
+(defvar global-magit-wip-save-mode nil "\
+Non-nil if Global-Magit-Wip-Save mode is enabled.
+See the command `global-magit-wip-save-mode' for a description of this minor mode.
+Setting this variable directly does not take effect;
+either customize it (see the info node `Easy Customization')
+or call the function `global-magit-wip-save-mode'.")
+
+(custom-autoload 'global-magit-wip-save-mode "magit-wip" nil)
+
+(autoload 'global-magit-wip-save-mode "magit-wip" "\
+Toggle Magit-Wip-Save mode in all buffers.
+With prefix ARG, enable Global-Magit-Wip-Save mode if ARG is positive;
+otherwise, disable it.  If called from Lisp, enable the mode if
+ARG is omitted or nil.
+
+Magit-Wip-Save mode is enabled in all buffers where
+`turn-on-magit-wip-save' would do it.
+See `magit-wip-save-mode' for more information on Magit-Wip-Save mode.
+
+\(fn &optional ARG)" t nil)
+
+;;;***
+\f
+;;;### (autoloads nil "rebase-mode" "rebase-mode.el" (21012 47854
+;;;;;;  0 0))
+;;; Generated autoloads from rebase-mode.el
+
+(autoload 'rebase-mode "rebase-mode" "\
+Major mode for editing of a Git rebase file.
+
+Rebase files are generated when you run 'git rebase -i' or run
+`magit-interactive-rebase'.  They describe how Git should perform
+the rebase.  See the documentation for git-rebase (e.g., by
+running 'man git-rebase' at the command line) for details.
+
+\(fn)" t nil)
+
+(add-to-list 'auto-mode-alist '("git-rebase-todo" . rebase-mode))
+
+;;;***
+\f
+;;;### (autoloads nil nil ("magit-bisect.el" "magit-key-mode.el"
+;;;;;;  "magit-pkg.el") (21012 47854 582944 232000))
+
+;;;***
+\f
+;; Local Variables:
+;; version-control: never
+;; no-byte-compile: t
+;; no-update-autoloads: t
+;; End:
+;;; magit-autoloads.el ends here
index 9310466..cdb6455 100644 (file)
@@ -1,26 +1,3 @@
-;;; magit-bisect.el --- bisect support for Magit
-
-;; Copyright (C) 2011  Moritz Bunkus
-
-;; 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:
-
-;; Control git-bisect from Magit.
-
-;;; Code:
-
 (require 'magit)
 
 (defvar magit--bisect-last-pos)
@@ -44,7 +21,7 @@ match REQUIRED-STATUS."
         (list :status (if (magit--bisecting-p) 'running 'not-running)))))
 
 (defun magit--bisect-cmd (&rest args)
-  "Run `git bisect ...' and update the status buffer."
+  "Run `git bisect ...' and update the status buffer"
   (with-current-buffer (magit-find-status-buffer)
     (let* ((output (apply 'magit-git-lines (append '("bisect") args)))
            (cmd (car args))
@@ -67,7 +44,7 @@ match REQUIRED-STATUS."
   (magit-refresh))
 
 (defun magit--bisect-info-for-status (branch)
-  "Return bisect info suitable for display in the status buffer."
+  "Return bisect info suitable for display in the status buffer"
   (let* ((info (magit--bisect-info))
          (status (plist-get info :status)))
     (cond ((eq status 'not-running)
@@ -82,7 +59,7 @@ match REQUIRED-STATUS."
            "(bisecting; unknown error occured)"))))
 
 (defun magit-bisect-start ()
-  "Start a bisect session."
+  "Start a bisect session"
   (interactive)
   (if (magit--bisecting-p)
       (error "Already bisecting"))
@@ -91,21 +68,21 @@ match REQUIRED-STATUS."
     (magit--bisect-cmd "start" bad good)))
 
 (defun magit-bisect-reset ()
-  "Quit a bisect session."
+  "Quit a bisect session"
   (interactive)
   (unless (magit--bisecting-p)
     (error "Not bisecting"))
   (magit--bisect-cmd "reset"))
 
 (defun magit-bisect-good ()
-  "Tell git that the current revision is good during a bisect session."
+  "Tell git that the current revision is good during a bisect session"
   (interactive)
   (unless (magit--bisecting-p 'running)
     (error "Not bisecting"))
   (magit--bisect-cmd "good"))
 
 (defun magit-bisect-bad ()
-  "Tell git that the current revision is bad during a bisect session."
+  "Tell git that the current revision is bad during a bisect session"
   (interactive)
   (unless (magit--bisecting-p 'running)
     (error "Not bisecting"))
@@ -119,7 +96,7 @@ match REQUIRED-STATUS."
   (magit--bisect-cmd "skip"))
 
 (defun magit-bisect-log ()
-  "Show the bisect log."
+  "Show the bisect log"
   (interactive)
   (unless (magit--bisecting-p)
     (error "Not bisecting"))
@@ -127,7 +104,7 @@ match REQUIRED-STATUS."
   (magit-display-process))
 
 (defun magit-bisect-visualize ()
-  "Show the remaining suspects with gitk."
+  "Show the remaining suspects with gitk"
   (interactive)
   (unless (magit--bisecting-p)
     (error "Not bisecting"))
@@ -144,7 +121,7 @@ match REQUIRED-STATUS."
   "Previously run bisect commands.")
 
 (defun magit-bisect-run (command)
-  "Bisect automatically by running commands after each step."
+  "Bisect automatically by running commands after each step"
   (interactive
    (list
     (read-from-minibuffer "Run command (like this): "
@@ -216,4 +193,3 @@ match REQUIRED-STATUS."
                             (abbreviate-file-name default-directory)))))))))
 
 (provide 'magit-bisect)
-;;; magit-bisect.el ends here
index e17f068..8518dcb 100644 (file)
@@ -1,4 +1,4 @@
-;;; magit-blame.el --- blame support for Magit
+;;; magit-blame.el --- blame support for magit
 
 ;; Copyright (C) 2012  Rüdiger Sonderfeld
 ;; Copyright (C) 2012  Yann Hodique
@@ -9,6 +9,7 @@
 ;; Copyright (C) 2008  Marius Vollmer
 
 ;; Author: Yann Hodique <yann.hodique@gmail.com>
+;; Keywords:
 
 ;; Magit is free software; you can redistribute it and/or modify it
 ;; under the terms of the GNU General Public License as published by
 
 ;;; Commentary:
 
-;; Control git-blame from Magit.
-;; This code has been backported from Egg (Magit fork) to Magit.
+;; This code has been backported from Egg (Magit fork) to Magit
 
 ;;; Code:
 
-(eval-when-compile (require 'cl-lib))
+(eval-when-compile (require 'cl))
 (require 'magit)
-(require 'easymenu)
 
 (defface magit-blame-header
   '((t :inherit magit-header))
     map)
   "Keymap for an annotated section.\\{magit-blame-map}")
 
-(easy-menu-define magit-blame-mode-menu magit-blame-map
-  "Magit blame menu"
-  '("Blame"
-    ["Locate Commit" magit-blame-locate-commit t]
-    ["Next" magit-blame-next-chunk t]
-    ["Previous" magit-blame-previous-chunk t]
-    "---"
-    ["Quit" magit-blame-mode t]))
-
 (defvar magit-blame-buffer-read-only)
 (make-variable-buffer-local 'magit-blame-buffer-read-only)
 
     (if sha1
         (magit-show-commit sha1))))
 
-(defun magit-find-next-overlay-change (beg end prop)
+(defun magit-find-next-overlay-change (BEG END PROP)
   "Return the next position after BEG where an overlay matching a
 property PROP starts or ends. If there are no matching overlay
 boundaries from BEG to END, the return value is nil."
-  (when (> beg end)
-    (let ((swap beg))
-      (setq beg end end swap)))
   (save-excursion
-    (goto-char beg)
+    (goto-char BEG)
     (catch 'found
-      (let ((ov-pos beg))
-        ;; iterate through overlay changes from BEG to END
-        (while (< ov-pos end)
-          (let* ((next-ov-pos (next-overlay-change ov-pos))
-                 ;; search for an overlay with a PROP property
-                 (next-ov
-                  (let ((overlays (overlays-at next-ov-pos)))
-                    (while (and overlays
-                                (not (overlay-get (car overlays) prop)))
-                      (setq overlays (cdr overlays)))
-                    (car overlays))))
-            (if next-ov
-                ;; found the next overlay with prop PROP at next-ov-pos
-                (throw 'found next-ov-pos)
-              ;; no matching overlay found, keep looking
-              (setq ov-pos next-ov-pos))))))))
+      (flet ((overlay-change (pos)
+                             (if (< BEG END) (next-overlay-change pos)
+                               (previous-overlay-change pos)))
+             (within-bounds-p (pos)
+                              (if (< BEG END) (< pos END)
+                                (> pos END))))
+        (let ((ov-pos BEG))
+          ;; iterate through overlay changes from BEG to END
+          (while (within-bounds-p ov-pos)
+            (let* ((next-ov-pos (overlay-change ov-pos))
+                   ;; search for an overlay with a PROP property
+                   (next-ov
+                    (let ((overlays (overlays-at next-ov-pos)))
+                      (while (and overlays
+                                  (not (overlay-get (car overlays) PROP)))
+                        (setq overlays (cdr overlays)))
+                      (car overlays))))
+              (if next-ov
+                  ;; found the next overlay with prop PROP at next-ov-pos
+                  (throw 'found next-ov-pos)
+                ;; no matching overlay found, keep looking
+                (setq ov-pos next-ov-pos)))))))))
 
 (defun magit-blame-next-chunk (pos)
   "Go to the next blame chunk."
@@ -186,8 +179,8 @@ boundaries from BEG to END, the return value is nil."
 
 The second argument TZ can be used to add the timezone in (-)HHMM
 format to UNIXTIME.  UNIXTIME should be either a number
-containing seconds since epoch or Emacs's (HIGH LOW . IGNORED)
-format."
+containing seconds since epoch or Emacs's (HIGH LOW
+. IGNORED) format."
   (when (numberp tz)
     (unless (numberp unixtime)
       (setq unixtime (float-time unixtime)))
index 8976883..2fcf296 100644 (file)
@@ -1,50 +1,19 @@
-;;; magit-key-mode.el --- interactively tune git invocation
-
-;; Copyright (C) 2010  Phil Jackson
-
-;; 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:
-
-;; This library implements `magit-key-mode' which is used throughout
-;; Magit to let the user interactively select the command, switches
-;; and options to call Git with.  It can be though of as a way to
-;; provide "postfix" arguments.
-
-;;; Code:
-
 (require 'magit)
 
-(eval-when-compile (require 'cl-lib))
+(eval-when-compile (require 'cl))
 
 (defvar magit-key-mode-key-maps '()
   "This will be filled lazily with proper `define-key' built
-keymaps as they're requested.")
+  keymaps as they're requested.")
 
-(defvar magit-key-mode-buf-name "*magit-key: %s*"
-  "Format string to create the name of the magit-key buffer.")
+(defvar magit-key-mode-buf-name "*magit-key*"
+  "Name of the buffer.")
 
-(defvar magit-key-mode-last-buffer nil
-  "Store the last magit-key buffer used.")
-
-(defvar magit-key-mode-current-args nil
-  "A hash-table of current argument set (which will eventually
-make it to the git command-line).")
+(defvar magit-key-mode-current-args '()
+  "Will contain the arguments to be passed to git.")
 
 (defvar magit-key-mode-current-options '()
-  "Current option set (which will eventually make it to the git
-command-line).")
+  "Will contain the arguments to be passed to git.")
 
 (defvar magit-log-mode-window-conf nil
   "Will hold the pre-menu configuration of magit.")
@@ -61,7 +30,6 @@ command-line).")
       ("rh" "Ranged reflog" magit-reflog-ranged))
      (switches
       ("-m" "Only merge commits" "--merges")
-      ("-do" "Date Order" "--date-order")
       ("-f" "First parent" "--first-parent")
       ("-i" "Case insensitive patterns" "-i")
       ("-pr" "Pickaxe regex" "--pickaxe-regex")
@@ -108,7 +76,6 @@ command-line).")
      (actions
       ("F" "Pull" magit-pull))
      (switches
-      ("-f" "Force" "--force")
       ("-r" "Rebase" "--rebase")))
 
     (branching
@@ -118,21 +85,12 @@ command-line).")
       ("c" "Create" magit-create-branch)
       ("r" "Rename" magit-move-branch)
       ("k" "Delete" magit-delete-branch)
-      ("b" "Checkout" magit-checkout))
-     (switches
-      ("-m" "Merged to HEAD" "--merged")
-      ("-M" "Merged to master" "--merged=master")
-      ("-n" "Not merged to HEAD" "--no-merged")
-      ("-N" "Not merged to master" "--no-merged=master"))
-     (arguments
-      ("=c" "Contains" "--contains=" magit-read-rev-with-default)
-      ("=m" "Merged" "--merged=" magit-read-rev-with-default)
-      ("=n" "Not merged" "--no-merged=" magit-read-rev-with-default)))
+      ("b" "Checkout" magit-checkout)))
 
     (remoting
      (man-page "git-remote")
      (actions
-      ("v" "Remote manager" magit-branch-manager)
+      ("v" "Branch manager" magit-branch-manager)
       ("a" "Add" magit-add-remote)
       ("r" "Rename" magit-rename-remote)
       ("k" "Remove" magit-remove-remote)))
@@ -194,9 +152,9 @@ command-line).")
       ("s" "Start" magit-bisect-start)
       ("u" "Run" magit-bisect-run)
       ("v" "Visualize" magit-bisect-visualize))))
-  "Holds the key, help, function mapping for the log-mode.
-If you modify this make sure you reset `magit-key-mode-key-maps'
-to nil.")
+  "Holds the key, help, function mapping for the log-mode. If you
+  modify this make sure you reset `magit-key-mode-key-maps' to
+  nil.")
 
 (defun magit-key-mode-delete-group (group)
   "Delete a group from `magit-key-mode-key-maps'."
@@ -212,18 +170,17 @@ to nil.")
     magit-key-mode-groups))
 
 (defun magit-key-mode-add-group (group)
-  "Add a new group to `magit-key-mode-key-maps'.
-If there already is a group of that name then this will
-completely remove it and put in its place an empty one of the
-same name."
+  "Add a new group to `magit-key-mode-key-maps'. If there's
+already a group of that name then this will completely remove it
+and put in its place an empty one of the same name."
   (when (assoc group magit-key-mode-groups)
     (magit-key-mode-delete-group group))
   (setq magit-key-mode-groups
-        (cons (list group (list 'actions) (list 'switches)) magit-key-mode-groups)))
+        (cons (list group (list 'actions)) magit-key-mode-groups)))
 
 (defun magit-key-mode-key-defined-p (for-group key)
-  "Return t if KEY is defined as any option within FOR-GROUP.
-The option may be a switch, argument or action."
+  "If KEY is defined as any of switch, argument or action within
+FOR-GROUP then return t"
   (catch 'result
     (let ((options (magit-key-mode-options-for-group for-group)))
       (dolist (type '(actions switches arguments))
@@ -244,31 +201,31 @@ The option may be a switch, argument or action."
     things))
 
 (defun magit-key-mode-insert-argument (for-group key desc arg read-func)
-  "Add a new binding KEY in FOR-GROUP which will use READ-FUNC
-to receive input to apply to argument ARG git is run.  DESC should
+  "Add a new binding (KEY) in FOR-GROUP which will use READ-FUNC
+to receive input to apply to argument ARG git is run. DESC should
 be a brief description of the binding."
   (magit-key-mode-update-group for-group 'arguments key desc arg read-func))
 
 (defun magit-key-mode-insert-switch (for-group key desc switch)
-  "Add a new binding KEY in FOR-GROUP which will add SWITCH to git's
-command line when it runs.  DESC should be a brief description of
+  "Add a new binding (KEY) in FOR-GROUP which will add SWITCH to git's
+command line when it runs. DESC should be a brief description of
 the binding."
   (magit-key-mode-update-group for-group 'switches key desc switch))
 
 (defun magit-key-mode-insert-action (for-group key desc func)
-  "Add a new binding KEY in FOR-GROUP which will run command FUNC.
-DESC should be a brief description of the binding."
+  "Add a new binding (KEY) in FOR-GROUP which will run command
+FUNC. DESC should be a brief description of the binding."
   (magit-key-mode-update-group for-group 'actions key desc func))
 
 (defun magit-key-mode-options-for-group (for-group)
-  "Retrieve the options for the group FOR-GROUP.
-This includes switches, commands and arguments."
+  "Retrieve the options (switches, commands and arguments) for
+the group FOR-GROUP."
   (or (cdr (assoc for-group magit-key-mode-groups))
       (error "Unknown group '%s'" for-group)))
 
 (defun magit-key-mode-help (for-group)
-  "Provide help for a key within FOR-GROUP.
-The user is prompted for the key."
+  "Provide help for a key (which the user is prompted for) within
+FOR-GROUP."
   (let* ((opts (magit-key-mode-options-for-group for-group))
          (man-page (cadr (assoc 'man-page opts)))
          (seq (read-key-sequence
@@ -283,28 +240,17 @@ The user is prompted for the key."
       ;; if there is "?" show a man page if there is one
       ((equal seq "?")
        (if man-page
-           (man man-page)
+         (man man-page)
          (error "No man page associated with `%s'" for-group)))
       (t (error "No help associated with `%s'" seq)))))
 
 (defun magit-key-mode-exec-at-point ()
   "Run action/args/option at point."
   (interactive)
-  (let ((key (or (get-text-property (point) 'key-group-executor)
-                 (error "Nothing at point to do."))))
-    (call-interactively (lookup-key (current-local-map) key))))
-
-(defun magit-key-mode-build-exec-point-alist ()
-  (save-excursion
-    (goto-char (point-min))
-    (let* ((exec (get-text-property (point) 'key-group-executor))
-           (exec-alist (if exec `((,exec . ,(point))) nil)))
-      (cl-do nil ((eobp) (nreverse exec-alist))
-        (when (not (eq exec (get-text-property (point) 'key-group-executor)))
-          (setq exec (get-text-property (point) 'key-group-executor))
-          (when exec (push (cons exec (point)) exec-alist)))
-        (forward-char)))))
-
+  (let* ((key (or (get-text-property (point) 'key-group-executor)
+                  (error "Nothing at point to do.")))
+         (def (lookup-key (current-local-map) key)))
+    (call-interactively def)))
 (defun magit-key-mode-jump-to-next-exec ()
   "Jump to the next action/args/option point."
   (interactive)
@@ -318,8 +264,8 @@ The user is prompted for the key."
     (skip-chars-forward " ")))
 
 (defun magit-key-mode-build-keymap (for-group)
-  "Construct a normal looking keymap for the key mode to use.
-Put it in `magit-key-mode-key-maps' for fast lookup."
+  "Construct a normal looking keymap for the key mode to use and
+put it in magit-key-mode-key-maps for fast lookup."
   (let* ((options (magit-key-mode-options-for-group for-group))
          (actions (cdr (assoc 'actions options)))
          (switches (cdr (assoc 'switches options)))
@@ -343,22 +289,25 @@ Put it in `magit-key-mode-key-maps' for fast lookup."
                                  (interactive)
                                  (magit-key-mode-help ',for-group)))
 
-    (let ((defkey (lambda (k action)
-                    (when (and (lookup-key map (car k))
-                               (not (numberp (lookup-key map (car k)))))
-                      (message "Warning: overriding binding for `%s' in %S"
-                               (car k) for-group)
-                      (ding)
-                      (sit-for 2))
-                    (define-key map (car k)
-                      `(lambda () (interactive) ,action)))))
-      (dolist (k actions)
-        (funcall defkey k `(magit-key-mode-command ',(nth 2 k))))
-      (dolist (k switches)
-        (funcall defkey k `(magit-key-mode-add-option ',for-group ,(nth 2 k))))
-      (dolist (k arguments)
-        (funcall defkey k `(magit-key-mode-add-argument
-                            ',for-group ,(nth 2 k) ',(nth 3 k)))))
+    (flet ((defkey (k action)
+             (when (and (lookup-key map (car k))
+                        (not (numberp (lookup-key map (car k)))))
+               (message "Warning: overriding binding for `%s' in %S"
+                        (car k) for-group)
+               (ding)
+               (sit-for 2))
+             (define-key map (car k)
+               `(lambda () (interactive) ,action))))
+      (when actions
+        (dolist (k actions)
+          (defkey k `(magit-key-mode-command ',(nth 2 k)))))
+      (when switches
+        (dolist (k switches)
+          (defkey k `(magit-key-mode-add-option ',for-group ,(nth 2 k)))))
+      (when arguments
+        (dolist (k arguments)
+          (defkey k `(magit-key-mode-add-argument
+                      ',for-group ,(nth 2 k) ',(nth 3 k))))))
 
     (push (cons for-group map) magit-key-mode-key-maps)
     map))
@@ -381,13 +330,22 @@ command that's eventually invoked.")
         (call-interactively func))
       (magit-key-mode-kill-buffer))))
 
+(defvar magit-key-mode-current-args nil
+  "A hash-table of current argument set (which will eventually
+  make it to the git command-line).")
+
 (defun magit-key-mode-add-argument (for-group arg-name input-func)
   (let ((input (funcall input-func (concat arg-name ": "))))
     (puthash arg-name input magit-key-mode-current-args)
-    (magit-key-mode-redraw for-group)))
+   (magit-key-mode-redraw for-group)))
+
+(defvar magit-key-mode-current-options '()
+  "Current option set (which will eventually make it to the git
+  command-line).")
 
 (defun magit-key-mode-add-option (for-group option-name)
-  "Toggles the appearance of OPTION-NAME in `magit-key-mode-current-options'."
+  "Toggles the appearance of OPTION-NAME in
+`magit-key-mode-current-options'."
   (if (not (member option-name magit-key-mode-current-options))
       (add-to-list 'magit-key-mode-current-options option-name)
     (setq magit-key-mode-current-options
@@ -396,21 +354,22 @@ command that's eventually invoked.")
 
 (defun magit-key-mode-kill-buffer ()
   (interactive)
-  (kill-buffer magit-key-mode-last-buffer))
+  (kill-buffer magit-key-mode-buf-name))
+
+(defvar magit-log-mode-window-conf nil
+  "Pre-popup window configuration.")
 
 (defun magit-key-mode (for-group &optional original-opts)
-  "Mode for magit key selection.
-All commands, switches and options can be toggled/actioned with
-the key combination highlighted before the description."
+  "Mode for magit key selection. All commands, switches and
+options can be toggled/actioned with the key combination
+highlighted before the description."
   (interactive)
   ;; save the window config to restore it as was (no need to make this
   ;; buffer local)
   (setq magit-log-mode-window-conf
         (current-window-configuration))
   ;; setup the mode, draw the buffer
-  (let ((buf (get-buffer-create (format magit-key-mode-buf-name
-                                        (symbol-name for-group)))))
-    (setq magit-key-mode-last-buffer buf)
+  (let ((buf (get-buffer-create magit-key-mode-buf-name)))
     (delete-other-windows)
     (split-window-vertically)
     (other-window 1)
@@ -437,8 +396,6 @@ the key combination highlighted before the description."
 (defun magit-key-mode-redraw (for-group)
   "(re)draw the magit key buffer."
   (let ((buffer-read-only nil)
-        (current-exec (get-text-property (point) 'key-group-executor))
-        (new-exec-pos)
         (old-point (point))
         (is-first (zerop (buffer-size)))
         (actions-p nil))
@@ -448,15 +405,10 @@ the key combination highlighted before the description."
     (setq actions-p (magit-key-mode-draw for-group))
     (delete-trailing-whitespace)
     (setq mode-name "magit-key-mode" major-mode 'magit-key-mode)
-    (when current-exec
-      (setq new-exec-pos (cdr (assoc current-exec (magit-key-mode-build-exec-point-alist)))))
     (if (and is-first actions-p)
       (progn (goto-char actions-p)
              (magit-key-mode-jump-to-next-exec))
-      (if new-exec-pos
-          (progn (goto-char new-exec-pos)
-                 (skip-chars-forward " "))
-          (goto-char old-point))))
+      (goto-char old-point)))
   (setq buffer-read-only t)
   (fit-window-to-buffer))
 
@@ -465,7 +417,8 @@ the key combination highlighted before the description."
   (insert (propertize header 'face 'font-lock-keyword-face) "\n"))
 
 (defvar magit-key-mode-args-in-cols nil
-  "When true, draw arguments in columns as with switches and options.")
+  "When true, draw arguments in columns as with switches and
+  options.")
 
 (defun magit-key-mode-draw-args (args)
   "Draw the args part of the menu."
@@ -510,9 +463,9 @@ the key combination highlighted before the description."
      one-col-each)))
 
 (defun magit-key-mode-draw-in-cols (strings one-col-each)
-  "Given a list of strings, print in columns (using `insert').
-If ONE-COL-EACH is true then don't columify, but rather, draw
-each item on one line."
+  "Given a list of strings, print in columns (using `insert'). If
+ONE-COL-EACH is true then don't columify, but rather, draw each
+item on one line."
   (let ((longest-act (apply 'max (mapcar 'length strings))))
     (while strings
       (let ((str (car strings)))
@@ -530,8 +483,9 @@ each item on one line."
   (insert "\n"))
 
 (defun magit-key-mode-draw (for-group)
-  "Draw actions, switches and parameters.
-Return the point before the actions part, if any, nil otherwise."
+  "Function used to draw actions, switches and parameters.
+
+Returns the point before the actions part, if any."
   (let* ((options (magit-key-mode-options-for-group for-group))
          (switches (cdr (assoc 'switches options)))
          (arguments (cdr (assoc 'arguments options)))
@@ -550,7 +504,7 @@ Return the point before the actions part, if any, nil otherwise."
    (intern (concat "magit-key-mode-popup-" (symbol-name group)))))
 
 (defun magit-key-mode-generate (group)
-  "Generate the key-group menu for GROUP."
+  "Generate the key-group menu for GROUP"
   (let ((opts (magit-key-mode-options-for-group group)))
     (eval
      `(defun ,(intern (concat "magit-key-mode-popup-" (symbol-name group))) nil
@@ -565,4 +519,3 @@ Return the point before the actions part, if any, nil otherwise."
       magit-key-mode-groups)
 
 (provide 'magit-key-mode)
-;;; magit-key-mode.el ends here
diff --git a/.emacs.d/elisp/magit/magit-pkg.el b/.emacs.d/elisp/magit/magit-pkg.el
new file mode 100644 (file)
index 0000000..982f2c9
--- /dev/null
@@ -0,0 +1 @@
+(define-package "magit" "1.2.0" "Control Git from Emacs." 'nil)
index ed49baf..b105b71 100644 (file)
@@ -1,7 +1,7 @@
 ;;; magit-stgit.el --- StGit plug-in for Magit
 
 ;; Copyright (C) 2011  Lluis Vilanova
-
+;;
 ;; 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)
@@ -40,7 +40,8 @@
 ;;; Code:
 
 (require 'magit)
-(eval-when-compile (require 'cl-lib))
+(eval-when-compile
+  (require 'cl))
 
 ;;; Customizables:
 
 (defun magit-stgit-refresh ()
   "Refresh the contents of a patch in an StGit series.
 If there is no marked patch in the series, refreshes the current
-patch.  Otherwise, refreshes the marked patch."
+patch.
+Otherwise, refreshes the marked patch."
   (interactive)
   (if magit-stgit--marked-patch
       (magit-run magit-stgit-executable "refresh" "-p" magit-stgit--marked-patch)
index 0c54f9d..d08c048 100644 (file)
@@ -3,12 +3,11 @@
 ;; Copyright (C) 2008  Alex Ott
 ;; Copyright (C) 2009  Alexey Voinov
 ;; Copyright (C) 2009  John Wiegley
-;; Copyright (C) 2013  Leonardo Etcheverry
 ;; Copyright (C) 2008  Linh Dang
 ;; Copyright (C) 2008  Marcin Bachry
 ;; Copyright (C) 2008, 2009  Marius Vollmer
 ;; Copyright (C) 2010  Yann Hodique
-
+;;
 ;; 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)
 
 ;;; Commentary:
 
-;; This plug-in provides git-svn functionality as a separate component
-;; of Magit.
+;; This plug-in provides git-svn functionality as a separate component of Magit
 
 ;;; Code:
 
 (require 'magit)
-
 (eval-when-compile
-  (require 'cl-lib)
-  (require 'find-lisp))
-
-(defcustom magit-svn-externals-dir ".git_externals"
-  "Directory from repository root that stores cloned SVN externals."
-  :group 'magit
-  :type 'string)
+  (require 'cl))
 
 ;; git svn commands
 
-(magit-define-command svn-find-rev (rev &optional branch)
-  "Find commit for svn REVISION in BRANCH."
+(defun magit-svn-find-rev (rev &optional branch)
   (interactive
    (list (read-string "SVN revision: ")
          (if current-prefix-arg
            sha))
       (error "Revision %s could not be mapped to a commit" rev))))
 
-(magit-define-command svn-create-branch (name)
-  "Create svn branch NAME."
+(defun magit-svn-create-branch (name)
   (interactive "sBranch name: ")
-  (apply 'magit-run-git "svn" "branch" (append magit-custom-options (list name))))
+  (magit-run-git "svn" "branch" name))
 
-(magit-define-command svn-create-tag (name)
-  "Create svn tag NAME."
-  (interactive "sTag name: ")
-  (apply 'magit-run-git "svn" "tag" (append magit-custom-options (list name))))
-
-(magit-define-command svn-rebase ()
-  "Run git-svn rebase."
+(defun magit-svn-rebase ()
   (interactive)
-  (apply 'magit-run-git-async "svn" "rebase" magit-custom-options))
+  (magit-run-git-async "svn" "rebase"))
 
-(magit-define-command svn-dcommit ()
-  "Run git-svn dcommit."
+(defun magit-svn-dcommit ()
   (interactive)
-  (apply 'magit-run-git-async "svn" "dcommit" magit-custom-options))
-
-(magit-define-command svn-remote-update ()
-  "Run git-svn fetch."
-  (interactive)
-  (when (magit-svn-enabled)
-    (magit-run-git-async "svn" "fetch")))
+  (magit-run-git-async "svn" "dcommit"))
 
 (defun magit-svn-enabled ()
   (not (null (magit-svn-get-ref-info t))))
@@ -197,26 +173,10 @@ If USE-CACHE is non nil, use the cached information."
               " @ "
               (cdr (assoc 'revision svn-info))))))
 
-(defun magit-svn-fetch-externals()
-  "Loops through all external repos found by `magit-svn-external-directories'
-   and runs git svn fetch, and git svn rebase on each of them."
+(defun magit-svn-remote-update ()
   (interactive)
-  (let ((externals (magit-svn-external-directories)))
-    (if (not externals)
-        (message "No SVN Externals found. Check magit-svn-externals-dir.")
-      (dolist (external externals)
-        (let ((default-directory (file-name-directory external)))
-          (magit-run-git "svn" "fetch")
-          (magit-run-git "svn" "rebase")))
-      (magit-refresh))))
-
-(defun magit-svn-external-directories()
-  "Returns all .git directories within `magit-svn-externals-dir'."
-  (require 'find-lisp)
-  (find-lisp-find-files-internal (expand-file-name magit-svn-externals-dir)
-                                 '(lambda(file dir)
-                                    (string-equal file ".git"))
-                                 'find-lisp-default-directory-predicate))
+  (when (magit-svn-enabled)
+    (magit-run-git-async "svn" "fetch")))
 
 (easy-menu-define magit-svn-extension-menu
   nil
@@ -242,9 +202,6 @@ If USE-CACHE is non nil, use the cached information."
   (magit-key-mode-insert-action 'svn "f" "Fetch" 'magit-svn-remote-update)
   (magit-key-mode-insert-action 'svn "s" "Find rev" 'magit-svn-find-rev)
   (magit-key-mode-insert-action 'svn "B" "Create branch" 'magit-svn-create-branch)
-  (magit-key-mode-insert-action 'svn "T" "Create tag" 'magit-svn-create-tag)
-  (magit-key-mode-insert-action 'svn "x" "Fetch Externals" 'magit-svn-fetch-externals)
-  (magit-key-mode-insert-switch 'svn "-n" "Dry run" "--dry-run")
 
   ;; generate and bind the menu popup function
   (magit-key-mode-generate 'svn))
index fe66042..6f0080c 100644 (file)
@@ -2,7 +2,7 @@
 
 ;; Copyright (C) 2010  Nathan Weizenbaum
 ;; Copyright (C) 2010  Yann Hodique
-
+;;
 ;; 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)
 
 ;;; Commentary:
 
-;; This plug-in provides topgit functionality as a separate component
-;; of Magit.
+;; This plug-in provides topgit functionality as a separate component of Magit
 
 ;;; Code:
 
 (require 'magit)
-(eval-when-compile (require 'cl-lib))
+(eval-when-compile
+  (require 'cl))
 
 (defcustom magit-topgit-executable "tg"
   "The name of the TopGit executable."
index 6367b3d..5c19840 100644 (file)
   "Commit message for git-wip commits.
 
 The following `format'-like specs are supported:
-%f the full name of the file being saved
-#g the root of the git repository
-%r the name of the file being saved,
-   relative to the repository root."
+%f the full name of the file being saved, and
+%r the name of the file being saved, relative to the repository root
+%g the root of the git repository."
   :group 'magit
   :type 'string)
 
@@ -97,10 +96,9 @@ The following `format'-like specs are supported:
   "Message shown in the echo area after creating a git-wip commit.
 
 The following `format'-like specs are supported:
-%f the full name of the file being saved
-#g the root of the git repository
-%r the name of the file being saved,
-   relative to the repository root."
+%f the full name of the file being saved, and
+%r the name of the file being saved, relative to the repository root.
+%g the root of the git repository."
   :group 'magit
   :type '(choice (const :tag "No message" nil) string))
 
@@ -110,13 +108,13 @@ The following `format'-like specs are supported:
 (define-minor-mode magit-wip-save-mode
   "Magit support for committing to a work-in-progress ref.
 
-When this minor mode is turned on and a file is saved inside a
-writable git repository then it is also committed to a special
-work-in-progress ref."
+When this minor mode is turned on and a file is saved inside a writable
+git repository then it is also committed to a special work-in-progress
+ref."
   :lighter magit-wip-save-mode-lighter
   (if magit-wip-save-mode
-      (add-hook  'after-save-hook 'magit-wip-save t t)
-    (remove-hook 'after-save-hook 'magit-wip-save t)))
+      (add-hook  'after-save-hook 'magit-wip-save-safe t t)
+    (remove-hook 'after-save-hook 'magit-wip-save-safe t)))
 
 ;;;###autoload
 (define-globalized-minor-mode global-magit-wip-save-mode
@@ -131,23 +129,23 @@ work-in-progress ref."
         (magit-wip-save-mode 1)
       (message "Git command 'git wip' cannot be found"))))
 
+(defun magit-wip-save-safe ()
+  (condition-case err
+      (magit-wip-save)
+    (error
+     (message "Magit WIP got an error: %S" err))))
+
 (defun magit-wip-save ()
-  (let* ((filename (expand-file-name (file-truename (buffer-file-name))))
-         (filedir  (file-name-directory filename))
-         (toplevel (magit-get-top-dir filedir))
-         (blobname (file-relative-name filename toplevel))
-         (spec `((?f . ,filename)
-                 (?r . ,blobname)
-                 (?g . ,toplevel))))
-    (when (and toplevel (file-writable-p toplevel)
-               (not (member blobname
-                            (let ((default-directory filedir))
-                              (magit-git-lines
-                               "ls-files" "--other" "--ignored"
-                               "--exclude-standard" "--full-name")))))
-      (magit-run-git-async "wip" "save"
-                           (format-spec magit-wip-commit-message spec)
-                           "--editor" "--" filename)
+  (let* ((top-dir (magit-get-top-dir default-directory))
+         (name (file-truename (buffer-file-name)))
+         (spec `((?r . ,(file-relative-name name top-dir))
+                 (?f . ,(buffer-file-name))
+                 (?g . ,top-dir))))
+    (when (and top-dir (file-writable-p top-dir))
+      (save-excursion ; kludge see https://github.com/magit/magit/issues/441
+        (magit-run-git "wip" "save"
+                       (format-spec magit-wip-commit-message spec)
+                       "--editor" "--" name))
       (when magit-wip-echo-area-message
         (message (format-spec magit-wip-echo-area-message spec))))))
 
index 5d5af97..121ec9c 100644 (file)
 ;;; magit.el --- control Git from Emacs
 
 ;; Copyright (C) 2010 Aaron Culich.
-;; Copyright (C) 2010, 2011 Alan Falloon.
+;; Copyright (C) 2010 Alan Falloon.
 ;; Copyright (C) 2008, 2010 Alex Ott.
 ;; Copyright (C) 2008, 2009, 2010 Alexey Voinov.
-;; Copyright (C) 2011 Andreas Fuchs.
-;; Copyright (C) 2012 Andreas Liljeqvist.
-;; Copyright (C) 2011 Andreas Rottmann.
-;; Copyright (C) 2011 Andrew Kirkpatrick.
-;; Copyright (C) 2011 Andrey Smirnov.
-;; Copyright (C) 2011 Bastian Beischer.
 ;; Copyright (C) 2010 Ben Walton.
-;; Copyright (C) 2012 Bradley Wright.
-;; Copyright (C) 2012 Brandon W Maister.
-;; Copyright (C) 2010, 2011 Brian Warner.
-;; Copyright (C) 2012 Bryan Shell.
 ;; Copyright (C) 2010 Chris Bernard.
-;; Copyright (C) 2012 Chris Done.
-;; Copyright (C) 2011 Chris Moore.
-;; Copyright (C) 2012 Christian Dietrich.
 ;; Copyright (C) 2010 Christian Kluge.
-;; Copyright (C) 2012 Christopher Monsanto.
-;; Copyright (C) 2011 Craig Andera.
-;; Copyright (C) 2012 Dale Hagglund.
-;; Copyright (C) 2012 Damien Cassou.
-;; Copyright (C) 2010 Daniel Brockman.
 ;; Copyright (C) 2008 Daniel Farina.
-;; Copyright (C) 2012 Daniel Hackney.
-;; Copyright (C) 2010, 2011 Dave Abrahams.
 ;; Copyright (C) 2010 David Abrahams.
 ;; Copyright (C) 2009 David Wallin.
-;; Copyright (C) 2011 Dominique Quatravaux.
-;; Copyright (C) 2011 Eli Barzilay.
-;; Copyright (C) 2011, 2012 Eric Davis.
-;; Copyright (C) 2011 George Kadianakis.
-;; Copyright (C) 2011 Graham Clark.
-;; Copyright (C) 2009, 2010, 2011 Hannu Koivisto.
-;; Copyright (C) 2012 Hans-Peter Deifel.
+;; Copyright (C) 2009, 2010 Hannu Koivisto.
 ;; Copyright (C) 2009 Ian Eure.
-;; Copyright (C) 2011 Jasper St. Pierre.
-;; Copyright (C) 2011 Jeff Bellegarde.
-;; Copyright (C) 2009, 2012 Jesse Alama.
-;; Copyright (C) 2009, 2010, 2012 John Wiegley.
-;; Copyright (C) 2012, 2013 Jonas Bernoulli.
-;; Copyright (C) 2012 Jonathan Roes.
-;; Copyright (C) 2011 Julien Danjou.
-;; Copyright (C) 2012 Justin Caratzas.
-;; Copyright (C) 2011 Kimberly Wolk.
-;; Copyright (C) 2010, 2011 Leo.
-;; Copyright (C) 2012 Leonardo Etcheverry.
-;; Copyright (C) 2011 Lluís Vilanova.
-;; Copyright (C) 2011 Luke Amdor.
-;; Copyright (C) 2011 Luís Borges de Oliveira.
-;; Copyright (C) 2010, 2011 Marc Herbert.
+;; Copyright (C) 2009 Jesse Alama.
+;; Copyright (C) 2009 John Wiegley.
+;; Copyright (C) 2010 Leo.
 ;; Copyright (C) 2008, 2009 Marcin Bachry.
-;; Copyright (C) 2011 Marco Craveiro.
 ;; Copyright (C) 2008, 2009 Marius Vollmer.
 ;; Copyright (C) 2010 Mark Hepburn.
-;; Copyright (C) 2012 Miles Bader.
-;; Copyright (C) 2010, 2011, 2012 Moritz Bunkus.
+;; Copyright (C) 2010 Moritz Bunkus.
 ;; Copyright (C) 2010 Nathan Weizenbaum.
-;; Copyright (C) 2012 Nic Ferier.
-;; Copyright (C) 2012 Nick Alcock.
-;; Copyright (C) 2011, 2012 Nicolas Dudebout.
-;; Copyright (C) 2011 Ole Arndt.
 ;; Copyright (C) 2010 Oscar Fuentes.
-;; Copyright (C) 2010 Paul Stadig.
 ;; Copyright (C) 2009 Pavel Holejsovsky.
-;; Copyright (C) 2011, 2012 Peter J. Weisberg.
-;; Copyright (C) 2009, 2010, 2011, 2013 Phil Jackson.
+;; Copyright (C) 2011-2012 Peter J Weisberg
+;; Copyright (C) 2009, 2010 Phil Jackson.
 ;; Copyright (C) 2010 Philip Weaver.
-;; Copyright (C) 2011 Pieter Praet.
-;; Copyright (C) 2012 Raimon Grau.
-;; Copyright (C) 2010, 2011, 2012 Ramkumar Ramachandra.
+;; Copyright (C) 2010 Ramkumar Ramachandra.
 ;; Copyright (C) 2010 Remco van 't Veer.
 ;; Copyright (C) 2009 René Stadler.
-;; Copyright (C) 2010 Robert Boone.
 ;; Copyright (C) 2010 Robin Green.
-;; Copyright (C) 2010, 2011 Roger Crew.
-;; Copyright (C) 2012 Romain Francoise.
-;; Copyright (C) 2012 Ron Parker.
-;; Copyright (C) 2012 Ryan C. Thompson.
-;; Copyright (C) 2009, 2010, 2011, 2012, 2013 Rémi Vanicat.
-;; Copyright (C) 2011, 2012 Rüdiger Sonderfeld.
-;; Copyright (C) 2012 Samuel Bronson.
+;; Copyright (C) 2010 Roger Crew.
+;; Copyright (C) 2009, 2010, 2011 Rémi Vanicat.
 ;; Copyright (C) 2010 Sean Bryant.
 ;; Copyright (C) 2009, 2011 Steve Purcell.
-;; Copyright (C) 2012 Steven Chow.
-;; Copyright (C) 2012 Suhail Shergill.
-;; Copyright (C) 2012, 2013 Takafumi Arakaki.
-;; Copyright (C) 2010 Thomas Jost.
-;; Copyright (C) 2011 Tibor Simko.
-;; Copyright (C) 2010, 2012 Timo Juhani Lindfors.
-;; Copyright (C) 2010, 2011 Tom Feist.
-;; Copyright (C) 2010, 2011, 2012, 2013 Yann Hodique.
-;; Copyright (C) 2010 oscar.
-;; Copyright (C) 2012 rabio.
-;; Copyright (C) 2010, 2011 Ævar Arnfjörð Bjarmason.
+;; Copyright (C) 2010 Timo Juhani Lindfors.
+;; Copyright (C) 2010, 2011 Yann Hodique.
+;; Copyright (C) 2010 Ævar Arnfjörð Bjarmason.
 ;; Copyright (C) 2010 Óscar Fuentes.
-;; Copyright (C) 2011 Štěpán Němec.
 
 ;; Original Author: Marius Vollmer <marius.vollmer@nokia.com>
 ;; Former Maintainer: Phil Jackson <phil@shellarchive.co.uk>
 ;;   - Peter J Weisberg
 ;;   - Yann Hodique
 ;;   - Rémi Vanicat
-;; Version: 1.2.0-233-gc18cd5a
+;; Version: 1.2.0
 ;; Keywords: tools
 
+;;
 ;; 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)
 
 ;;; Code:
 
-(eval-when-compile
-  (require 'grep))
-
-(require 'cl-lib)
-
+(eval-when-compile (require 'cl))
 (require 'log-edit)
 (require 'easymenu)
 (require 'diff-mode)
-(require 'ansi-color)
 
 ;; Silences byte-compiler warnings
 (eval-and-compile
-  (unless (fboundp 'declare-function)
-    (defmacro declare-function (&rest args))))
+  (unless (fboundp 'declare-function) (defmacro declare-function (&rest args))))
 
-(eval-when-compile (require 'view))
+(eval-when-compile  (require 'view))
 (declare-function view-mode 'view)
 (eval-when-compile (require 'iswitchb))
-(declare-function iswitchb-read-buffer 'iswitchb)
 (eval-when-compile (require 'ido))
-(declare-function ido-completing-read 'ido)
 (eval-when-compile (require 'ediff))
-(declare-function ediff-cleanup-mess 'ediff)
-(eval-when-compile (require 'eshell))
-(declare-function eshell-parse-arguments 'eshell)
 
 ;; Dummy to be used by the defcustoms when first loading the file.
-(cl-eval-when (load eval)
+(eval-when (load eval)
   (defalias 'magit-set-variable-and-refresh 'set-default))
 
-\f
+;;; Code:
 (defgroup magit nil
   "Controlling Git from Emacs."
   :prefix "magit-"
@@ -201,35 +129,29 @@ offer them as choices for `magit-status'."
 
 (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."
+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)
 
 (defcustom magit-set-upstream-on-push nil
-  "Whether `magit-push' may use --set-upstream when pushing a branch.
+  "Non-nil means that `magit-push' may use --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.
+Setting this to t will ask if --set-upstream should be used.
+Setting it to 'dontask will always use --set-upstream.
+Setting it to 'refuse will refuse to push unless a remote branch has already been set.
 
 --set-upstream is supported with git > 1.7.0"
   :group 'magit
   :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-save-some-buffers t
-  "Whether \\[magit-status] saves modified buffers before running.
-
-nil        don't save buffers.
-t          ask which buffers to save.
-`dontask'  save all buffers without asking."
+  "Non-nil means that \\[magit-status] will save modified buffers before running.
+Setting this to t will ask which buffers to save, setting it to 'dontask will
+save all modified buffers without asking."
   :group 'magit
   :type '(choice (const :tag "Never" nil)
                  (const :tag "Ask" t)
@@ -241,6 +163,7 @@ t          ask which buffers to save.
 
 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)
@@ -248,24 +171,23 @@ the same name is non-nil."
 
 (defcustom magit-default-tracking-name-function
   'magit-default-tracking-name-remote-plus-branch
-  "Function used to generate default tracking branch names
+  "Specifies the function to use to generate default tracking branch names
 when doing a \\[magit-checkout].
 
-The default is `magit-default-tracking-name-remote-plus-branch',
-which generates a tracking name of the form \"REMOTE-BRANCHNAME\"."
+The default is magit-default-tracking-name-remote-plus-branch,
+which generates a tracking name of the form 'REMOTE-BRANCHNAME'."
   :group 'magit
   :type '(radio (function-item magit-default-tracking-name-remote-plus-branch)
                 (function-item magit-default-tracking-name-branch-only)
                 (function :tag "Other")))
 
 (defcustom magit-commit-all-when-nothing-staged 'ask
-  "Determine what \\[magit-log-edit] does when nothing is staged.
-
+  "Determines what \\[magit-log-edit] does when nothing is staged.
 Setting this to nil will make it do nothing, setting it to t will
-arrange things so that the actual commit command will use the
-\"--all\" option, setting it to `ask' will first ask for
-confirmation whether to do this, and setting it to `ask-stage'
-will cause all changes to be staged, after a confirmation."
+arrange things so that the actual commit command will use the \"--all\" option,
+setting it to 'ask will first ask for confirmation whether to do this,
+and setting it to 'ask-stage will cause all changes to be staged,
+after a confirmation."
   :group 'magit
   :type '(choice (const :tag "No" nil)
                  (const :tag "Always" t)
@@ -277,11 +199,6 @@ will cause all changes to be staged, after a confirmation."
   :group 'magit
   :type 'boolean)
 
-(defcustom magit-commit-gpgsign nil
-  "Use GPG to sign commits."
-  :group 'magit
-  :type 'boolean)
-
 (defcustom magit-sha1-abbrev-length 7
   "The number of digits to show when a sha1 is displayed in abbreviated form."
   :group 'magit
@@ -305,16 +222,6 @@ Only considered when moving past the last entry with
   :group 'magit
   :type 'boolean)
 
-(defcustom magit-log-show-author-date t
-  "Show author and date for each commit in short log mode."
-  :group 'magit
-  :type 'boolean)
-
-(defcustom magit-log-show-gpg-status nil
-  "Display signature verification information as part of the log."
-  :group 'magit
-  :type 'boolean)
-
 (defcustom magit-process-popup-time -1
   "Popup the process buffer if a command takes longer than this many seconds."
   :group 'magit
@@ -339,11 +246,11 @@ Autocompletion is used by functions like `magit-checkout',
 `magit-interactive-rebase' and others which offer branch name
 completion.
 
-The value 'name-then-remote means remotes will be of the form
-\"name (remote)\", while the value 'remote-slash-name means that
-they'll be of the form \"remote/name\".  I.e. something that's
-listed as \"remotes/upstream/next\" by \"git branch -l -a\" will
-be \"upstream/next\"."
+The value 'name-then-remote means remotes will be of the
+form \"name (remote)\", while the value 'remote-slash-name
+means that they'll be of the form \"remote/name\".  I.e. something that's
+listed as \"remotes/upstream/next\" by \"git branch -l -a\"
+will be \"upstream/next\"."
   :group 'magit
   :type '(choice (const :tag "name (remote)" branch-then-remote)
                  (const :tag "remote/name" remote-slash-branch)))
@@ -407,10 +314,10 @@ cumbersome to use from the status buffer.
                  (const :tag "Ask"   ask)))
 
 (defcustom magit-highlight-whitespace t
-  "Specify where to highlight whitespace errors.
+  "Specifies 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."
+'status means only in the status buffer, and nil means nowhere."
   :group 'magit
   :type '(choice (const :tag "Always" t)
                  (const :tag "Never" nil)
@@ -418,7 +325,7 @@ See `magit-highlight-trailing-whitespace',
   :set 'magit-set-variable-and-refresh)
 
 (defcustom magit-highlight-trailing-whitespace t
-  "Whether to highlight whitespace at the end of a line in diffs.
+  "Highlight whitespace at the end of a line in diffs.
 Used only when `magit-highlight-whitespace' is non-nil."
   :group 'magit
   :type 'boolean
@@ -461,7 +368,11 @@ There are three possible settings:
                  (const :tag "All" all))
   :set 'magit-set-variable-and-refresh)
 
-\f
+(defvar magit-current-indentation nil
+  "Indentation highlight used in the current buffer.
+This is calculated from `magit-highlight-indentation'.")
+(make-variable-buffer-local 'magit-current-indentation)
+
 (defgroup magit-faces nil
   "Customize the appearance of Magit."
   :prefix "magit-"
@@ -500,26 +411,6 @@ Many Magit faces inherit from this one by default."
   "Face for lines in a diff that have been added."
   :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-diff-none
   '((t :inherit diff-context))
   "Face for lines in a diff that are unchanged."
@@ -546,25 +437,6 @@ Many Magit faces inherit from this one by default."
   "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-author-date-cutoff
-  '((t :inherit magit-log-author
-       :bold t))
-  "Face for the author element's cutoff mark."
-  :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."
@@ -645,35 +517,6 @@ Many Magit faces inherit from this one by default."
   "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-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-valid-signature
-  (if (require 'epa nil t)
-      '((t :inherit epa-validity-high))
-    '((t :weight bold :foreground "PaleTurquoise")))
-  "Face for valid gpg signatures."
-  :group 'magit-faces)
-\f
 (defvar magit-custom-options '()
   "List of custom options to pass to Git.
 Do not customize this (used in the `magit-key-mode' implementation).")
@@ -702,20 +545,28 @@ operation after commit).")
 
 (defvar magit-tmp-buffer-name " *magit-tmp*")
 
-(defvar magit-read-file-hist nil)
-
-(defvar magit-current-indentation nil
-  "Indentation highlight used in the current buffer.
-This is calculated from `magit-highlight-indentation'.")
-(make-variable-buffer-local 'magit-current-indentation)
-
-(defvar magit-bug-report-url
-  "http://github.com/magit/magit/issues")
+(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)
 
-(defconst magit-version "1.2.0-233-gc18cd5a"
-  "The version of Magit that you're using.")
+(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)
 
-\f
 (defvar magit-mode-map
   (let ((map (make-keymap)))
     (suppress-keymap map t)
@@ -759,7 +610,6 @@ This is calculated from `magit-highlight-indentation'.")
     (define-key map (kbd "B") 'magit-key-mode-popup-bisecting)
     (define-key map (kbd "F") 'magit-key-mode-popup-pulling)
     (define-key map (kbd "l") 'magit-key-mode-popup-logging)
-    (define-key map (kbd "o") 'magit-key-mode-popup-submodule)
     (define-key map (kbd "$") 'magit-display-process)
     (define-key map (kbd "c") 'magit-log-edit)
     (define-key map (kbd "E") 'magit-interactive-rebase)
@@ -777,7 +627,6 @@ This is calculated from `magit-highlight-indentation'.")
     (define-key map (kbd "+") 'magit-diff-larger-hunks)
     (define-key map (kbd "0") 'magit-diff-default-hunks)
     (define-key map (kbd "h") 'magit-toggle-diff-refine-hunk)
-    (define-key map (kbd "M-g") 'magit-goto-diffstats)
     map))
 
 (defvar magit-commit-mode-map
@@ -828,28 +677,21 @@ This is calculated from `magit-highlight-indentation'.")
     (define-key map (kbd "T") 'magit-change-what-branch-tracks)
     map))
 
-(defvar magit-diffstat-keymap
-  (let ((map (make-sparse-keymap)))
-    (define-key map (kbd "e") 'magit-diffstat-ediff)
-    map))
+(defvar magit-bug-report-url
+  "http://github.com/magit/magit/issues")
 
-(defconst magit-bug-report-buffer "*magit-bug-report*"
-  "The buffer in which Magit output bug report messages.")
+(defconst magit-version "1.2.0"
+  "The version of Magit that you're using.")
 
 (defun magit-bug-report (str)
-  "Asks the user to submit a bug report about the error described
-in STR."
-  (with-current-buffer (get-buffer-create magit-bug-report-buffer)
-    (erase-buffer)
-    (insert (format
-             (concat
-              "Magit unknown error: %s\n Please, with as much"
-              " information as possible, file a bug at\n %s\n"
-              "- Magit: %s\n"
-              "- Emacs: %s")
-             str magit-bug-report-url
-             magit-version (emacs-version))))
-  (switch-to-buffer-other-window magit-bug-report-buffer))
+  "Asks the user to submit a bug report about the error described in STR."
+;; XXX - should propose more information to be included.
+  (message (concat
+            "Unknown error: %s\n"
+            "Please, with as much information as possible, file a bug at\n"
+            "%s\n"
+            "You are using Magit version %s.")
+           str magit-bug-report-url magit-version))
 
 (defun magit-buffer-switch (buf)
   (if (string-match "magit" (buffer-name))
@@ -893,7 +735,7 @@ in STR."
 
 (eval-and-compile
   (defun magit-max-args-internal (function)
-    "Return the maximum number of arguments accepted by FUNCTION."
+    "Returns the maximum number of arguments accepted by FUNCTION."
     (if (symbolp function)
         (setq function (symbol-function function)))
     (if (subrp function)
@@ -905,7 +747,7 @@ in STR."
           (setq function (cdr function)))
       (let ((arglist (if (byte-code-function-p function)
                          (aref function 0)
-                       (cadr function))))
+                       (second function))))
         (if (memq '&rest arglist)
             most-positive-fixnum
           (length (remq '&optional arglist))))))
@@ -916,15 +758,16 @@ in STR."
 
   (unless (fboundp 'string-match-p)
     (defun string-match-p (regexp string &optional start)
-      "Same as `string-match' but don't change the match data."
+      "Same as `string-match' except this function does not
+change the match data."
       (let ((inhibit-changing-match-data t))
         (string-match regexp string start))))
 
   (if (fboundp 'with-silent-modifications)
       (defalias 'magit-with-silent-modifications 'with-silent-modifications)
     (defmacro magit-with-silent-modifications (&rest body)
-      "Execute body without changing `buffer-modified-p'.
-Also, do not record undo information."
+      "Execute body without changing `buffer-modified-p'. Also, do not
+record undo information."
       `(set-buffer-modified-p
         (prog1 (buffer-modified-p)
           (let ((buffer-undo-list t)
@@ -935,9 +778,10 @@ Also, do not record undo information."
   (if (>= (magit-max-args-internal 'delete-directory) 2)
       (defalias 'magit-delete-directory 'delete-directory)
     (defun magit-delete-directory (directory &optional recursive)
-      "Delete a directory named DIRECTORY.
-If RECURSIVE is non-nil, recursively delete all of DIRECTORY's
-contents as well.  Don't follow symlinks."
+      "Deletes a directory named DIRECTORY.  If RECURSIVE is non-nil,
+recursively delete all of DIRECTORY's contents as well.
+
+Does not follow symlinks."
       (if (or (file-symlink-p directory)
               (not (file-directory-p directory)))
           (delete-file directory)
@@ -950,7 +794,7 @@ contents as well.  Don't follow symlinks."
 ;;; Utilities
 
 (defun magit-set-variable-and-refresh (symbol value)
-  "Set SYMBOL to VALUE and call `magit-refresh-all'."
+  "Set SYMBOL to VALUE and call `magit-refresh-all'"
   (set-default symbol value)
   (magit-refresh-all))
 
@@ -960,7 +804,7 @@ contents as well.  Don't follow symlinks."
   (require 'iswitchb)
   (let ((iswitchb-make-buflist-hook
          (lambda ()
-           (setq iswitchb-temp-buflist (if (consp (car choices))
+           (setq iswitchb-temp-buflist (if (consp (first choices))
                                            (mapcar #'car choices)
                                          choices)))))
     (iswitchb-read-buffer prompt (or initial-input def) require-match)))
@@ -968,11 +812,11 @@ contents as well.  Don't follow symlinks."
 (defun magit-ido-completing-read (prompt choices &optional predicate require-match initial-input hist def)
   "ido-based completing-read almost-replacement."
   (require 'ido)
-  (let ((selected (ido-completing-read prompt (if (consp (car choices))
+  (let ((selected (ido-completing-read prompt (if (consp (first choices))
                                                   (mapcar #'car choices)
                                                 choices)
                                        predicate require-match initial-input hist def)))
-    (if (consp (car choices))
+    (if (consp (first choices))
         (or (cdr (assoc selected choices))
             selected)
       selected)))
@@ -986,12 +830,9 @@ contents as well.  Don't follow symlinks."
                      prompt)
                    choices predicate require-match initial-input hist def))
 
-(defun magit-completing-read (prompt collection &optional predicate require-match
+(defun magit-completing-read (prompt choices &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 prompt collection predicate require-match
+  (funcall magit-completing-read-function prompt choices predicate require-match
            initial-input hist def))
 
 (defun magit-use-region-p ()
@@ -1037,7 +878,7 @@ Read `completing-read' documentation for the meaning of the argument."
                                cmd
                                nil (list t nil) nil
                                args)))))
-    (ansi-color-apply cmd-output)))
+    (replace-regexp-in-string "\e\\[.*?m" "" cmd-output)))
 
 (defun magit-git-string (&rest args)
   (magit-trim-line (magit-git-output args)))
@@ -1107,7 +948,7 @@ Read `completing-read' documentation for the meaning of the argument."
   (file-exists-p (expand-file-name ".git" dir)))
 
 (defun magit-git-dir ()
-  "Return the .git directory for the current repository."
+  "Returns the .git directory for the current repository."
   (concat (expand-file-name (magit-git-string "rev-parse" "--git-dir")) "/"))
 
 (defun magit-no-commit-p ()
@@ -1158,7 +999,7 @@ Read `completing-read' documentation for the meaning of the argument."
 (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."
+\"origin\" exists, return that. Otherwise, return nil."
   (let ((remote (or (and branch (magit-get "branch" branch "remote"))
                     (and (magit-get "remote" "origin" "url") "origin"))))
     (if (string= remote "") nil remote)))
@@ -1174,10 +1015,10 @@ Otherwise, return nil."
   (= (magit-git-exit-code "show-ref" "--verify" ref) 0))
 
 (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."
+  "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-nill, 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)))
@@ -1314,7 +1155,7 @@ argument or a list of strings used as regexps."
             (cond ((and (functionp uninteresting)
                         (funcall uninteresting ref)))
                   ((and (not (functionp uninteresting))
-                        (cl-loop for i in uninteresting thereis (string-match i ref))))
+                        (loop for i in uninteresting thereis (string-match i ref))))
                   (t
                    (let ((fmt-ref (magit-format-ref ref)))
                      (when fmt-ref
@@ -1347,9 +1188,8 @@ according to `magit-remote-ref-format'"
               (match-string 2 ref))))))
 
 (defun magit-tree-contents (treeish)
-  "Return a list of all files under TREEISH.
-TREEISH can be a tree, a commit, or any reference to one of
-those."
+  "Returns a list of all files under TREEISH.  TREEISH can be a tree,
+a commit, or any reference to one of those."
   (let ((return-value nil))
     (with-temp-buffer
       (magit-git-insert (list "ls-tree" "-r" treeish))
@@ -1383,13 +1223,6 @@ those."
         nil
       rev)))
 
-(defun magit-read-rev-with-default (prompt &optional no-trim uninteresting)
-  "Ask user for revision like `magit-read-rev' but default is set
-appropriately depending on context.  If NO-TRIM is non-nil, strip
-off prefixes such as \"ref/remotes/\" (see `magit-name-rev').
-PROMPT and UNINTERESTING are passed to `magit-read-rev'."
-  (magit-read-rev prompt (magit-default-rev no-trim) uninteresting))
-
 (defun magit-read-rev-range (op &optional def-beg def-end)
   (let ((beg (magit-read-rev (format "%s start" op)
                              def-beg)))
@@ -1482,7 +1315,7 @@ DEF is the default value."
 ;; identifies what kind of object it represents (if any), and the
 ;; parent and grand-parent, etc provide the context.
 
-(cl-defstruct magit-section
+(defstruct magit-section
   parent title beginning end children hidden type info
   needs-refresh-on-show)
 
@@ -1495,20 +1328,11 @@ DEF is the default value."
 
 (defvar magit-section-hidden-default nil)
 
-(defvar magit-show-diffstat t
-  "If non-nil, diff and commit log will display diffstat.")
-
-(defvar magit-diffstat-cached-sections)
-(make-variable-buffer-local 'magit-diffstat-cached-sections)
-(put 'magit-diffstat-cached-sections 'permanent-local t)
-
-
 (defun magit-new-section (title type)
   "Create a new section with title TITLE and type TYPE in current buffer.
 
-If `magit-top-section' buffer local value is nil, the new section
-will be the new top-section; otherwise the new-section will be a
-child of the current top-section.
+If not `magit-top-section' exist, the new section will be the new top-section
+otherwise, the new-section will be a child of the current top-section.
 
 If TYPE is nil, the section won't be highlighted."
   (let* ((s (make-magit-section :parent magit-top-section
@@ -1554,8 +1378,8 @@ If TYPE is nil, the section won't be highlighted."
        ,s)))
 
 (defun magit-set-section (title type start end)
-  "Create a new section of title TITLE and type TYPE.
-Use the specified START and END positions."
+  "Create a new section of title TITLE and type TYPE with specified start and
+end positions."
   (let ((section (magit-new-section title type)))
     (setf (magit-section-beginning section) start)
     (setf (magit-section-end section) end)
@@ -1628,13 +1452,13 @@ Use the specified START and END positions."
 (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 (if (not (magit-section-hidden current))
-                       (magit-find-section-before* pos (magit-section-children current)))
-                   (if (not (magit-section-hidden current))
-                       (magit-find-section-before* pos (magit-section-children current)))))
+    (do* ((current (or (magit-section-parent section)
+                       section)
+                   next)
+          (next (if (not (magit-section-hidden current))
+                    (magit-find-section-before* pos (magit-section-children current)))
+                (if (not (magit-section-hidden current))
+                    (magit-find-section-before* pos (magit-section-children current)))))
         ((null next) current))))
 
 (defun magit-find-section-before* (pos secs)
@@ -1700,8 +1524,9 @@ CMD is an external command that will be run with ARGS as arguments."
 
 (defun magit-git-section (section-title-and-type
                           buffer-title washer &rest args)
-  "Run Git and put its result in a new section.
-See `magit-insert-section' for meaning of the arguments"
+  "Run git and put its result in a new section.
+
+see `magit-insert-section' for meaning of the arguments"
   (apply #'magit-insert-section
          section-title-and-type
          buffer-title
@@ -1738,7 +1563,7 @@ See `magit-insert-section' for meaning of the arguments"
          (section (magit-current-section))
          (end (- (magit-section-end section) 1))
          (parent (magit-section-parent section))
-         (siblings (and parent (magit-section-children parent)))
+         (siblings (magit-section-children parent))
          (next-sibling (magit-find-section-after* end siblings)))
     (if next-sibling
         (magit-goto-section next-sibling)
@@ -1750,7 +1575,7 @@ See `magit-insert-section' for meaning of the arguments"
   (let* ((section (magit-current-section))
          (beginning (magit-section-beginning section))
          (parent (magit-section-parent section))
-         (siblings (and parent (magit-section-children parent)))
+         (siblings (magit-section-children parent))
          (previous-sibling (magit-find-section-before* beginning siblings)))
     (if previous-sibling
         (magit-goto-section previous-sibling)
@@ -1775,33 +1600,9 @@ See `magit-insert-section' for meaning of the arguments"
         (goto-char (magit-section-beginning sec))
       (message "No such section"))))
 
-
-(defun magit-goto-diff-section-at-file (file)
-  "Go to the section containing by the pathname, FILE"
-  (let ((pos (catch 'diff-section-found
-               (dolist (sec (magit-section-children magit-top-section))
-                 (when (and (eq (magit-section-type sec) 'diff)
-                            (string-equal (magit-diff-item-file sec) file))
-                   (throw 'diff-section-found
-                          (magit-section-beginning sec)))))))
-    (when pos
-      (goto-char pos))))
-
-(defun magit-goto-diffstats ()
-  "Go to the diffstats section if exists"
-  (interactive)
-  (let ((pos (catch 'section-found
-               (dolist (sec (magit-section-children magit-top-section))
-                 (when (eq (magit-section-type sec) 'diffstats)
-                   (throw 'section-found
-                          (magit-section-beginning sec)))))))
-    (if pos
-      (goto-char pos)
-      (if (called-interactively-p 'interactive)
-          (message "No diffstats section found")))))
-
 (defun magit-for-all-sections (func &optional top)
   "Run FUNC on TOP and recursively on all its children.
+
 Default value for TOP is `magit-top-section'"
   (let ((section (or top magit-top-section)))
     (when section
@@ -1861,9 +1662,8 @@ Default value for TOP is `magit-top-section'"
 (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."
+If FLAG-OR-FUNC is a function, it will be ran on current section
+IF FLAG-OR-FUNC is a Boolean value, the section will be hidden if its true, shown otherwise"
   (let ((section (magit-current-section)))
     (when (magit-section-parent section)
       (goto-char (magit-section-beginning section))
@@ -1894,7 +1694,7 @@ true, shown otherwise."
 (defun magit-toggle-file-section ()
   "Like `magit-toggle-section' but toggle at file granularity."
   (interactive)
-  (when (eq 'hunk (car (magit-section-context-type (magit-current-section))))
+  (when (eq 'hunk (first (magit-section-context-type (magit-current-section))))
     (magit-goto-parent-section))
   (magit-toggle-section))
 
@@ -1926,16 +1726,15 @@ Expanded: everything is shown."
    (lambda (s)
      (cond ((magit-section-hidden s)
             (magit-section-collapse s))
-           ((with-no-warnings
-              (cl-notany #'magit-section-hidden (magit-section-children s)))
+           ((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-lineage (s)
+  "Return list of parent, grand-parents... for section S."
+  (when s
+    (cons s (magit-section-lineage (magit-section-parent s)))))
 
 (defun magit-section-show-level (section level threshold path)
   (magit-section-set-hidden section (>= level threshold))
@@ -1948,8 +1747,8 @@ Expanded: everything is shown."
 
 (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 is non nil, do this in all sections,
+otherwise do it only on ancestors and descendants of current section."
   (magit-with-refresh
     (if all
         (magit-section-show-level magit-top-section 0 level nil)
@@ -1967,6 +1766,7 @@ Do this in on ancestors and descendants of current section."
 
 (defun magit-show-only-files-all ()
   "Show section that are files, but not there subsection.
+
 Do this for all sections"
   (interactive)
   (if (derived-mode-p 'magit-status-mode)
@@ -1977,8 +1777,7 @@ Do this for all sections"
   "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."
+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)))
@@ -1989,13 +1788,14 @@ current section."
 
 (defmacro magit-define-level-shower (level)
   "Define two interactive function to show function of level LEVEL.
-One for all, one for current lineage."
+one for all, one for current lineage."
   `(progn
      (magit-define-level-shower-1 ,level nil)
      (magit-define-level-shower-1 ,level t)))
 
 (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)))
         (doc (format "Jump to section `%s'." title)))
@@ -2037,7 +1837,7 @@ Refinements can be undone with `magit-unrefine-section'."
            ;; diff-mode machinery.
            (save-excursion
              (goto-char (magit-section-beginning magit-highlighted-section))
-             (magit-maybe-diff-refine-hunk))))))
+             (diff-refine-hunk))))))
 
 (defun magit-unrefine-section (section)
   "Remove refinements to the display of SECTION done by `magit-refine-section'."
@@ -2086,12 +1886,11 @@ Refinements can be undone with `magit-unrefine-section'."
         '()))))
 
 (defun magit-prefix-p (prefix list)
-  "Return non-nil if PREFIX is a prefix of LIST.
+  "Returns non-nil if PREFIX is a prefix of LIST.  PREFIX and LIST should both be
+lists.
 
-PREFIX and LIST should both be lists.  If the car of PREFIX is
-the symbol `*', then return non-nil if the cdr of PREFIX is a
-sublist of LIST (as if `*' matched zero or more arbitrary
-elements of LIST)"
+If the car of PREFIX is the symbol '*, then return non-nil if the cdr of PREFIX
+is a sublist of LIST (as if '* matched zero or more arbitrary elements of LIST)"
   ;;; Very schemish...
   (or (null prefix)
       (if (eq (car prefix) '*)
@@ -2124,7 +1923,7 @@ and throws an error otherwise."
         (info (cadr head))
         (type (make-symbol "*type*"))
         (context (make-symbol "*context*"))
-        (opname (car (cddr head))))
+        (opname (caddr head)))
     `(let* ((,section (magit-current-section))
             (,info (and ,section (magit-section-info ,section)))
             (,type (and ,section (magit-section-type ,section)))
@@ -2162,8 +1961,8 @@ OPNAME is mandatory and specifies the operation to which to add
 the actions."
   (declare (indent 1))
   (let ((section (car head))
-        (info (nth 1 head))
-        (type (nth 2 head)))
+        (info (cadr head))
+        (type (caddr head)))
     `(add-hook ',(intern (format "magit-%s-action-hook" type))
                (lambda ()
                  ,(macroexpand
@@ -2175,6 +1974,7 @@ the actions."
 
 (defun magit-wash-sequence (func)
   "Run FUNC until end of buffer is reached.
+
 FUNC should leave point at the end of the modified region"
   (while (and (not (eobp))
               (funcall func))))
@@ -2184,13 +1984,11 @@ FUNC should leave point at the end of the modified region"
 It will define the magit-SYM function having ARGLIST as argument.
 It will also define the magit-SYM-command-hook variable.
 
-The defined function will call the function in the hook in order
-until one return non nil. If they all return nil then body will
-be called.
+The defined function will call the function in the hook in
+order until one return non nil. If they all return nil then body will be called.
 
-It is used to define hookable magit command: command defined by
-this function can be enriched by magit extension like
-magit-topgit and magit-svn"
+It is used to define hookable magit command: command defined by this
+function can be enriched by magit extension like magit-topgit and magit-svn"
   (declare (indent defun)
            (debug (&define name lambda-list
                            [&optional stringp]        ; Match the doc string, if present.
@@ -2339,11 +2137,9 @@ magit-topgit and magit-svn"
 (defun magit-process-sentinel (process event)
   (let ((msg (format "%s %s." (process-name process) (substring event 0 -1)))
         (successp (string-match "^finished" event))
-        (key (if (buffer-live-p magit-process-client-buffer)
-                 (with-current-buffer magit-process-client-buffer
-                   (key-description (car (where-is-internal
-                                          'magit-display-process))))
-               "M-x magit-display-process")))
+        (key (with-current-buffer magit-process-client-buffer
+               (key-description (car (where-is-internal
+                                      'magit-display-process))))))
     (with-current-buffer (process-buffer process)
       (let ((inhibit-read-only t))
         (goto-char (point-max))
@@ -2355,13 +2151,10 @@ magit-topgit and magit-svn"
         (dired-uncache default-directory)))
     (setq magit-process nil)
     (magit-set-mode-line-process nil)
-    (when (and (buffer-live-p magit-process-client-buffer)
-               (with-current-buffer magit-process-client-buffer
-                 (derived-mode-p 'magit-mode)))
-      (magit-refresh-buffer magit-process-client-buffer))))
+    (magit-refresh-buffer magit-process-client-buffer)))
 
 (defun magit-password (proc string)
-  "Check if git/ssh asks for a password and ask the user for it."
+  "Checks if git/ssh asks for a password and ask the user for it."
   (let (ask)
     (cond ((or (string-match "^Enter passphrase for key '\\\(.*\\\)': $" string)
                (string-match "^\\\(.*\\\)'s password:" string)
@@ -2373,7 +2166,7 @@ magit-topgit and magit-svn"
       (process-send-string proc (concat (read-passwd ask nil) "\n")))))
 
 (defun magit-username (proc string)
-  "Check if git asks for a username and ask the user for it."
+  "Checks if git asks for a username and ask the user for it."
   (when (string-match "^Username for '\\\(.*\\\)':" string)
     (process-send-string proc
                          (concat
@@ -2601,13 +2394,12 @@ Please see the manual for a complete description of Magit.
 
 (defun magit-find-buffer (submode &optional dir)
   (let ((topdir (magit-get-top-dir (or dir default-directory))))
-    (cl-find-if (lambda (buf)
-                  (with-current-buffer buf
-                    (and (eq major-mode submode)
-                         default-directory
-                         (equal (expand-file-name default-directory)
-                                topdir))))
-                (buffer-list))))
+    (dolist (buf (buffer-list))
+      (if (with-current-buffer buf
+            (and (eq major-mode submode)
+                 default-directory
+                 (equal (expand-file-name default-directory) topdir)))
+          (return buf)))))
 
 (defun magit-find-status-buffer (&optional dir)
   (magit-find-buffer 'magit-status-mode dir))
@@ -2693,15 +2485,14 @@ Please see the manual for a complete description of Magit.
           (funcall func)
         (when magit-refresh-needing-buffers
           (magit-revert-buffers dir)
-          (dolist (b (if (memq status-buffer magit-refresh-needing-buffers)
-                         (cons status-buffer magit-refresh-needing-buffers)
-                       magit-refresh-needing-buffers))
+          (dolist (b (adjoin status-buffer
+                             magit-refresh-needing-buffers))
             (magit-refresh-buffer b)))))))
 
 (defun magit-need-refresh (&optional buffer)
-  "Mark BUFFER as needing to be refreshed.
-If optional BUFFER is nil, use the current buffer."
-  (cl-pushnew (or buffer (current-buffer)) magit-refresh-needing-buffers :test 'eq))
+  "Mark BUFFER as needing to be refreshed.  If BUFFER is nil, use the
+current buffer."
+  (pushnew (or buffer (current-buffer)) magit-refresh-needing-buffers :test 'eq))
 
 (defun magit-refresh ()
   "Refresh current buffer to match repository state.
@@ -2776,6 +2567,7 @@ in the corresponding directories."
   (magit-refresh))
 
 (defun magit-toggle-diff-refine-hunk (&optional other)
+  (interactive "P")
   "Turn diff-hunk refining on or off.
 
 If hunk refining is currently on, then hunk refining is turned off.
@@ -2789,7 +2581,6 @@ If hunk refining is off, then hunk refining is turned on, in
 `all' mode (all hunks refined).
 
 Customize `magit-diff-refine-hunk' to change the default mode."
-  (interactive "P")
   (let* ((old magit-diff-refine-hunk)
          (new
           (if other
@@ -2821,135 +2612,15 @@ Customize `magit-diff-refine-hunk' to change the default mode."
          nil)))
 
 (defun magit-wash-diffs ()
-  (magit-wash-diffstats)
   (magit-wash-sequence #'magit-wash-diff-or-other-file))
 
 (defun magit-wash-diff-or-other-file ()
   (or (magit-wash-diff)
       (magit-wash-other-file)))
 
-(defun magit-diffstat-ediff ()
-  (interactive)
-  (magit-goto-diff-section-at-file
-   (magit-diff-item-file (magit-current-section)))
-  (call-interactively 'magit-ediff))
-
-(defun magit-wash-diffstat (&optional guess)
-  (let ((entry-regexp "^ ?\\(.*?\\)\\( +| +.*\\)$"))
-    (when (looking-at entry-regexp)
-      (let ((file (match-string-no-properties 1))
-            (remaining (match-string-no-properties 2)))
-        (delete-region (point) (+ (line-end-position) 1))
-        (magit-with-section "diffstat" 'diffstat
-          ;;(magit-set-section-info 'incomplete)
-
-          ;; diffstat entries will look like
-          ;;
-          ;; ' PSEUDO-FILE-NAME | +++---'
-          ;;
-          ;; Since PSEUDO-FILE-NAME is not always real pathname, we
-          ;; don't know the pathname yet.  Thus, section info will be
-          ;; (diffstat FILE incomplete MARKER-BEGIN MARKER-END) for
-          ;; now, where MARKER-BEGIN points the beginning of the
-          ;; PSEUDO-FILE-NAME, MARKER-END points the end of the
-          ;; PSEUDO-FILE-NAME, and FILE will be abbreviated filename.
-          ;; Later in `magit-wash-diff-or-other-file`, the section
-          ;; info will be updated.
-
-          ;; Note that FILE is the 2nd element of the section-info;
-          ;; this is intentional, so that `magit-diff-item-file` can
-          ;; return the FILE part.
-
-           ;; (list 'diffstat
-           ;;       (or (and (> (length file) 3)
-           ;;                (string-equal (substring file 0 3) "...")
-           ;;                (message "got the invalid file here")
-           ;;                'truncated)
-           ;;           file)))
-
-          (insert " ")
-          (let ((f-begin (point-marker)) f-end)
-            (insert file)
-            (setq f-end (point-marker))
-
-            (magit-set-section-info (list 'diffstat
-                                          file 'incomplete f-begin f-end))
-            (insert remaining)
-            (magit-put-line-property 'keymap magit-diffstat-keymap)
-
-            (insert "\n")
-            (add-to-list 'magit-diffstat-cached-sections
-                         magit-top-section))
-
-          ;; (insert (propertize (concat " "
-          ;;                             (propertize file
-          ;;                                         'face
-          ;;                                         'magit-diff-file-header)
-          ;;                             remaining)
-          ;;                     'keymap
-          ;;                     magit-diffstat-keymap)
-          ;;         "\n")
-          )))))
-
-(defun magit-wash-diffstats ()
-  (let ((entry-regexp "^ ?\\(.*?\\)\\( +| +.*\\)$")
-        (title-regexp "^ ?\\([0-9]+ +files? change.*\\)\n+")
-        (pos (point)))
-    (save-restriction
-      (save-match-data
-        (when (and (looking-at entry-regexp)
-                   (re-search-forward title-regexp nil t))
-          (let ((title-line (match-string-no-properties 1))
-                (stat-end (point-marker)))
-            (delete-region (match-beginning 0) (match-end 0))
-            (narrow-to-region pos stat-end)
-            (goto-char (point-min))
-            (magit-with-section "diffstats" 'diffstats
-              (insert title-line)
-              ;;(magit-put-line-property 'face 'magit-section-title)
-              (insert "\n")
-
-              (set (make-local-variable 'magit-diffstat-cached-sections)
-                   nil)
-
-              (magit-wash-sequence #'magit-wash-diffstat))
-            (setq magit-diffstat-cached-sections
-                  (nreverse magit-diffstat-cached-sections))
-            (insert "\n")))))))
-
-(defun magit-wash-diffstats-postwork (file &optional section)
-  (let ((sec (or section
-                 (and (boundp 'magit-diffstat-cached-sections)
-                      (pop magit-diffstat-cached-sections)))))
-    (when sec
-      (let* ((info (magit-section-info sec))
-             (begin (nth 3 info))
-             (end (nth 4 info)))
-        (put-text-property begin end
-                          'face 'magit-diff-file-header)
-        (magit-set-section-info (list 'diffstat file 'completed)
-                                sec)))))
-
-(defun magit-diffstat-item-kind (diffstat)
-  (car (magit-section-info diffstat)))
-
-(defun magit-diffstat-item-file (diffstat)
-  (let ((file (cadr (magit-section-info diffstat))))
-    ;; Git diffstat may shorten long pathname with the prefix "..."
-    ;; (e.g. ".../long/sub/dir/file" or "...longfilename")
-    (save-match-data
-      (if (string-match "\\`\\.\\.\\." file)
-          nil
-        file))))
-
-(defun magit-diffstat-item-status (diffstat)
-  "Return 'completed or 'incomplete depending on the processed status"
-  (caddr (magit-section-info diffstat)))
-
 (defun magit-wash-other-file ()
   (if (looking-at "^? \\(.*\\)$")
       (let ((file (match-string-no-properties 1)))
-        (magit-wash-diffstats-postwork file)
         (delete-region (point) (+ (line-end-position) 1))
         (magit-with-section file 'file
           (magit-set-section-info file)
@@ -2962,7 +2633,7 @@ Customize `magit-diff-refine-hunk' to change the default mode."
 (defvar magit-indentation-level 1)
 
 (defun magit-insert-diff-title (status file file2)
-  (let ((status-text (cl-case status
+  (let ((status-text (case status
                        ((unmerged)
                         (format "Unmerged   %s" file))
                        ((new)
@@ -3017,8 +2688,6 @@ Customize `magit-diff-refine-hunk' to change the default mode."
                           (goto-char (match-beginning 0))
                         (goto-char (point-max)))
                       (point-marker))))
-           (magit-wash-diffstats-postwork file)
-
            (let* ((status (cond
                            ((looking-at "^diff --cc")
                             'unmerged)
@@ -3070,7 +2739,7 @@ Customize `magit-diff-refine-hunk' to change the default mode."
   (cadr (magit-section-info diff)))
 
 (defun magit-diff-item-file2 (diff)
-  (car (cddr (magit-section-info diff))))
+  (caddr (magit-section-info diff)))
 
 (defun magit-diff-item-range (diff)
   (nth 3 (magit-section-info diff)))
@@ -3088,17 +2757,8 @@ Customize `magit-diff-refine-hunk' to change the default mode."
                              (looking-at "^diff\\|^@@")))
                (magit-highlight-line-whitespace)
                (let ((prefix (buffer-substring-no-properties
-                              (point) (min (+ (point) n-columns) (point-max))))
-                     (line (buffer-substring-no-properties (point) (line-end-position))))
-                 (cond ((string-match "^[\\+]+<<<<<<< " line)
-                        (magit-put-line-property 'face 'magit-diff-merge-current))
-                       ((string-match "^[\\+]+=======" line)
-                        (magit-put-line-property 'face 'magit-diff-merge-separator))
-                       ((string-match "^[\\+]+|||||||" line)
-                        (magit-put-line-property 'face 'magit-diff-merge-diff3-separator))
-                       ((string-match "^[\\+]+>>>>>>> " line)
-                        (magit-put-line-property 'face 'magit-diff-merge-proposed))
-                       ((string-match "\\+" prefix)
+                              (point) (min (+ (point) n-columns) (point-max)))))
+                 (cond ((string-match "\\+" prefix)
                         (magit-put-line-property 'face 'magit-diff-add))
                        ((string-match "-" prefix)
                         (magit-put-line-property 'face 'magit-diff-del))
@@ -3109,19 +2769,11 @@ Customize `magit-diff-refine-hunk' to change the default mode."
            (when (eq magit-diff-refine-hunk 'all)
              (save-excursion
                (goto-char hunk-start-pos)
-               (magit-maybe-diff-refine-hunk))))
+               (diff-refine-hunk))))
          t)
         (t
          nil)))
 
-(defun magit-looking-at-combined-diff-p ()
-  (looking-at "@@@"))
-
-(defun magit-maybe-diff-refine-hunk ()
-  ;; diff-refine-hunk can't handle git's combined diff output (--cc)
-  (unless (magit-looking-at-combined-diff-p)
-    (diff-refine-hunk)))
-
 (defvar magit-diff-options nil)
 
 (defun magit-insert-diff (file status)
@@ -3157,7 +2809,7 @@ Customize `magit-diff-refine-hunk' to change the default mode."
        ":\\([0-7]+\\) \\([0-7]+\\) [0-9a-f]+ [0-9a-f]+ \\(.\\)[0-9]*\t\\([^\t\n]+\\)$")
       (let ((old-perm (match-string-no-properties 1))
             (new-perm (match-string-no-properties 2))
-            (status (cl-case (string-to-char (match-string-no-properties 3))
+            (status (case (string-to-char (match-string-no-properties 3))
                       (?A 'new)
                       (?D 'deleted)
                       (?M 'modified)
@@ -3260,46 +2912,20 @@ Customize `magit-diff-refine-hunk' to change the default mode."
           (forward-line))
         target))))
 
-(defvar magit-file-name ()
-  "Name of file the buffer shows a different version of.")
-(make-variable-buffer-local 'magit-file-name)
-
-(defvar magit-show-current-version ()
-  "Which version of MAGIT-FILE-NAME is shown in this buffer.")
-(make-variable-buffer-local 'magit-show-current-version)
-
-(defun magit-save-index ()
-  "Add the content of current file as if it was the index."
-  (interactive)
-  (unless (eq magit-show-current-version 'index)
-    (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 (concat (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)))))
-
 (defun magit-show (commit filename &optional select prefix)
-  "Return a buffer containing the file FILENAME, as stored in COMMIT.
-
-COMMIT may be one of the following:
-- A string with the name of a commit, such as \"HEAD\" or
-  \"dae86e\".  See 'git help revisions' for syntax.
-- The symbol 'index, indicating that you want the version in
-  Git's index or staging area.
-- The symbol 'working, indicating that you want the version in
-  the working directory.  In this case you'll get a buffer
-  visiting the file.  If there's already a buffer visiting that
-  file, you'll get that one.
-
-When called interactively or when SELECT is non-nil, make the
-buffer active, either in another window or (with a prefix
-argument) in the current window."
+  "Returns a buffer containing the contents of the file FILENAME, as stored in
+COMMIT.  COMMIT may be one of the following:
+
+- A string with the name of a commit, such as \"head\" or \"dae86e\".  See 'git
+  help revisions' for syntax.
+- The symbol 'index, indicating that you want the version in Git's index or
+  staging area.
+- The symbol 'working, indicating that you want the version in the working
+  directory.  In this case you'll get a buffer visiting the file.  If there's
+  already a buffer visiting that file, you'll get that one.
+
+When called interactively or when SELECT is non-nil, make the buffer active,
+either in another window or (with a prefix argument) in the current window."
   (interactive (let* ((revision (magit-read-rev "Retrieve file from revision"))
                       (filename (magit-read-file-from-rev revision)))
                  (list revision filename t current-prefix-arg)))
@@ -3324,9 +2950,7 @@ argument) in the current window."
                                    (concat commit ":" filename)))))))
       (with-current-buffer buffer
         (let ((buffer-file-name filename))
-          (normal-mode)
-          (setq magit-file-name filename)
-          (setq magit-show-current-version commit))
+          (normal-mode))
         (goto-char (point-min)))
       (if select
           (if prefix
@@ -3402,14 +3026,14 @@ member of ARGS, or to the working file otherwise."
 
 ;;; Logs and Commits
 
-;; Note: making this a plain defcustom would probably let users break
-;; the parser too easily
+                                        ; Note: making this a plain defcustom would probably let users break
+                                        ; the parser too easily
 (defvar magit-git-log-options
   (list
    "--pretty=format:* %h %s"
    (format "--abbrev=%s" magit-sha1-abbrev-length)))
-;; --decorate=full otherwise some ref prefixes are stripped
-;;  '("--pretty=format:* %H%d %s" "--decorate=full"))
+                                        ; --decorate=full otherwise some ref prefixes are stripped
+                                        ;  '("--pretty=format:* %H%d %s" "--decorate=full"))
 
 ;;
 ;; Regexps for parsing ref names
@@ -3461,7 +3085,7 @@ Evaluate (man \"git-check-ref-format\") for details")
 
 (defconst magit-log-oneline-re
   (concat
-   "^\\(\\(?:[---_\\*|/.] ?\\)+ *\\)?"             ; graph   (1)
+   "^\\([_\\*|/ -.]+\\)?"                          ; graph   (1)
    "\\(?:"
    "\\([0-9a-fA-F]+\\)"                            ; sha1    (2)
    "\\(?:"                                         ; refs    (3)
@@ -3473,13 +3097,7 @@ Evaluate (man \"git-check-ref-format\") for details")
    "\\)"
    "\\)?"
    "\\)?"
-   " ?"
-   "\\(?:"
-   "\\([BG]\\)?"                                    ; gpg     (4)
-   "\\(\\[.*?\\]\\)"                                ; author  (5)
-   "\\(\\[.*?\\]\\)"                                ; date    (6)
-   "\\)?"
-   "\\(.+\\)?$"                                     ; msg     (7)
+   " ?\\(.*\\)$"                                   ; msg     (4)
    ))
 
 (defconst magit-log-longline-re
@@ -3487,9 +3105,8 @@ Evaluate (man \"git-check-ref-format\") for details")
    ;; use \0 delimiter (from -z option) to identify commits. this prevents
    ;; commit messages containing lines like "commit 00000" from polluting the
    ;; display
-   "\\(?:\\`\\|\0\\)"
-   "\\(\\(?:[---_\\*|/.] ?\\)+ *\\)"               ; graph   (1)
-   "\\(?:"
+   "\\(?:\\(?:\\`\\|\0\\)"
+   "\\([_\\*|/ -.]+\\)?"                           ; graph   (1)
    "commit "
    "\\([0-9a-fA-F]+\\)"                            ; sha1    (2)
    "\\(?:"                                         ; refs    (3)
@@ -3500,8 +3117,8 @@ Evaluate (man \"git-check-ref-format\") for details")
    ")"
    "\\)"
    "\\)?"
-   "\\)?"
-   "\\(.+\\)?$"                                    ; msg     (4)
+   "$\\)?"
+   " ?\\(.*\\)$"                                   ; msg     (4)
    ))
 
 (defvar magit-present-log-line-function 'magit-present-log-line
@@ -3535,8 +3152,8 @@ must return a string which will represent the log line.")
     ("bisect" magit-log-get-bisect-state-color)))
 
 (defun magit-ref-get-label-color (r)
-  (let ((uninteresting (cl-loop for re in magit-uninteresting-refs
-                                thereis (string-match re r))))
+  (let ((uninteresting (loop for re in magit-uninteresting-refs
+                             thereis (string-match re r))))
     (if uninteresting (list nil nil)
       (let* ((ref-re "\\(?:tag: \\)?refs/\\(?:\\([^/]+\\)/\\)?\\(.+\\)")
              (label (and (string-match ref-re r)
@@ -3555,147 +3172,32 @@ must return a string which will represent the log line.")
                            (list r 'magit-log-head-label-default))))))
         res))))
 
-(defun magit-present-log-line (line)
+(defun magit-present-log-line (graph sha1 refs message)
   "The default log line generator."
-  (let ((graph (magit-log-line-chart line))
-        (sha1 (magit-log-line-sha1 line))
-        (refs (magit-log-line-refs line))
-        (author (magit-log-line-author line))
-        (date (magit-log-line-date line))
-        (message (magit-log-line-msg line))
-        (gpg-status (magit-log-line-gpg line)))
-    (let* ((string-refs
-            (when refs
-              (let ((colored-labels
-                     (delete nil
-                             (mapcar (lambda (r)
-                                       (cl-destructuring-bind (label face)
-                                           (magit-ref-get-label-color r)
-                                         (and label
-                                              (propertize label 'face face))))
-                                     refs))))
-                (concat
-                 (mapconcat 'identity colored-labels " ")
-                 " "))))
-           (lhs (concat
-                 (if sha1
-                     (propertize sha1 'face 'magit-log-sha1)
-                   (make-string magit-sha1-abbrev-length ? ))
-                 " "
-                 graph
-                 string-refs
-                 (when message
-                   (font-lock-append-text-property
-                    0 (length message)
-                    'face (if gpg-status
-                              (if (string= gpg-status "B")
-                                  'error
-                                'magit-valid-signature)
-                            'magit-log-message)
-                    message)
-                   message))))
-      (if (and magit-log-show-author-date
-               author date)
-          (magit-log-make-author-date-overlay author date))
-      lhs)))
-
-(defcustom magit-log-author-date-max-length 25
-  "max of author-date margin length."
-  :type 'integer
-  :group 'magit)
-
-(defvar magit-log-author-date-string-length nil
-  "only use in `*magit-log*' buffer.")
-(defvar magit-log-author-string-length nil
-  "only use in `*magit-log*' buffer.")
-(defvar magit-log-date-string-length nil
-  "only use in `*magit-log*' buffer.")
-(defvar magit-log-author-date-overlay nil
-  "only use in `*magit-log*' buffer.")
-
-(defun magit-log-make-author-date-overlay (author date)
-  (let ((overlay (make-overlay (point) (point))))
-    (setq author (propertize author 'face 'magit-log-author)
-          date (delete "ago" (split-string date "[ ,]+"))
-          date (propertize (concat (format "%2s %5s"
-                                           (nth 0 date)
-                                           (nth 1 date))
-                                   (if (nth 2 date)
-                                       (format " %2s %1.1s "
-                                               (nth 2 date)
-                                               (nth 3 date))))
-                           'face 'magit-log-date))
-    (overlay-put overlay 'magit-log-overlay (cons author date))
-    (setq magit-log-author-date-overlay
-          (cons overlay magit-log-author-date-overlay))
-    (if (> (length author) magit-log-author-string-length)
-        (setq magit-log-author-string-length (length author)))
-    (if (> (length date) magit-log-date-string-length)
-        (setq magit-log-date-string-length (length date)))))
-
-(defun magit-log-set-author-date-overlays ()
-  (when magit-log-author-date-overlay
-    (let* ((author-length magit-log-author-string-length)
-           (date-length magit-log-date-string-length)
-           (max-length (if (< (+ author-length date-length 1)
-                              magit-log-author-date-max-length)
-                           (+ author-length date-length 1)
-                         magit-log-author-date-max-length))
-           (author-length (- max-length date-length 1))
-           (author-length-string (number-to-string author-length))
-           (date-length-string (number-to-string date-length))
-           (format-string (concat "%-" author-length-string "s "
-                                  "%-" date-length-string "s")))
-      (mapc
-       #'(lambda (overlay)
-           (let* ((data (overlay-get overlay 'magit-log-overlay))
-                  (author (car data))
-                  (date (cdr data))
-                  (author-date
-                   (format format-string
-                           (if (< author-length (length author))
-                               (concat
-                                (substring author
-                                           0 (1- author-length))
-                                (propertize "-" 'face
-                                            'magit-log-author-date-cutoff))
-                             author)
-                           date)))
-             (overlay-put overlay 'before-string
-                          (propertize " " 'display
-                                      (list '(margin right-margin)
-                                            author-date)))))
-       magit-log-author-date-overlay)
-      (setq magit-log-author-date-string-length max-length))))
-
-(defvar magit-log-buffer-name "*magit-log*"
-  "Buffer name for display of log entries.")
+  (let ((string-refs
+         (when refs
+           (let ((colored-labels
+                  (delete nil
+                          (mapcar (lambda (r)
+                                    (destructuring-bind (label face)
+                                        (magit-ref-get-label-color r)
+                                      (and label
+                                           (propertize label 'face face))))
+                                  refs))))
+             (concat
+              (mapconcat 'identity colored-labels " ")
+              " ")))))
 
-(defun magit-log-display-author-date ()
-  (with-selected-window (get-buffer-window magit-log-buffer-name)
-    (set-window-margins nil
-                        (car (window-margins))
-                        magit-log-author-date-string-length)))
-
-(defun magit-log-initialize-author-date-overlay ()
-  (when (equal magit-log-buffer-name (buffer-name))
-    (set (make-local-variable 'magit-log-author-date-string-length) 0)
-    (set (make-local-variable 'magit-log-author-string-length) 0)
-    (set (make-local-variable 'magit-log-date-string-length) 0)
-    (when magit-log-author-date-overlay
-      (mapc #'delete-overlay magit-log-author-date-overlay)
-      (setq magit-log-author-date-overlay nil)
-      (remove-hook 'window-configuration-change-hook
-                   'magit-log-display-author-date t))))
-
-(defun magit-log-create-author-date-overlay ()
-  (when (equal magit-log-buffer-name (buffer-name))
-    (magit-log-set-author-date-overlays)
-    (magit-log-display-author-date)
-    (when magit-log-author-date-overlay
-      (add-hook 'window-configuration-change-hook
-                'magit-log-display-author-date
-                nil t))))
+    (concat
+     (if sha1
+         (propertize sha1 'face 'magit-log-sha1)
+       (insert-char ? magit-sha1-abbrev-length))
+     " "
+     (when graph
+       (propertize graph 'face 'magit-log-graph))
+     string-refs
+     (when message
+       (propertize message 'face 'magit-log-message)))))
 
 (defvar magit-log-count ()
   "Internal var used to count the number of logs actually added in a buffer.")
@@ -3714,75 +3216,45 @@ insert a line to tell how to insert more of them"
              (magit-with-section "longer"  'longer
                (insert "type \"e\" to show more logs\n")))))))
 
-(cl-defstruct magit-log-line
-  chart sha1 author date msg refs gpg)
-
-(defun magit-parse-log-line (line style)
-  (let ((remove-surrounding-braces
-         (lambda (string)
-           (when string
-             (replace-regexp-in-string "\\(^\\[\\)\\|\\(\\]$\\)" "" string))))
-        (match-style-string
-         (lambda (short-pos long-pos)
-           (match-string (if (eq style 'long) long-pos short-pos) line)))
-        (line-re (cond ((eq style 'long) magit-log-longline-re)
-                         (t magit-log-oneline-re))))
-    (when (string-match line-re line)
-      (make-magit-log-line
-       :chart (funcall match-style-string 1 1)
-       :sha1 (funcall match-style-string 2 2)
-       :author (funcall remove-surrounding-braces
-                        (when (not (eq style 'long)) (match-string 5 line)))
-       :date (funcall remove-surrounding-braces
-                      (when (not (eq style 'long)) (match-string 6 line)))
-       :gpg (when (not (eq style 'long))
-              (match-string 4 line))
-       :msg (funcall match-style-string 7 4)
-       :refs (when (funcall match-style-string 3 3)
-               (delq nil
-                     (mapcar
-                      (lambda (s)
-                        (and (not
-                              (or (string= s "tag:")
-                                  (string= s "HEAD"))) ; as of 1.6.6
-                             s))
-                      (split-string (funcall match-style-string 3 3)
-                                    "[(), ]" t))))))))
-
 (defun magit-wash-log-line (style)
   (beginning-of-line)
-  (let* ((bol (point-at-bol))
-         (eol (point-at-eol))
-         (line (magit-parse-log-line
-                (buffer-substring bol eol)
-                style)))
-    (if line
-        (progn
-          (delete-region bol eol)
-          (insert (funcall magit-present-log-line-function line))
-          (goto-char bol)
-          (let ((sha1 (magit-log-line-sha1 line)))
-            (if sha1
-                (magit-with-section sha1 'commit
-                  (when magit-log-count
-                    (setq magit-log-count (1+ magit-log-count)))
-                  (magit-set-section-info sha1)
-                  (forward-line))
-              (forward-line))))
-      (forward-line))
+  (let ((line-re (cond ((eq style 'long) magit-log-longline-re)
+                       (t magit-log-oneline-re))))
+    (cond
+     ((looking-at line-re)
+      (let ((chart (match-string 1))
+            (sha1 (match-string 2))
+            (msg (match-string 4))
+            (refs (when (match-string 3)
+                    (delq nil
+                          (mapcar
+                           (lambda (s)
+                             (and (not
+                                   (or (string= s "tag:")
+                                       (string= s "HEAD"))) ; as of 1.6.6
+                                  s))
+                           (split-string (match-string 3) "[(), ]" t))))))
+        (delete-region (point-at-bol) (point-at-eol))
+        (insert (funcall magit-present-log-line-function chart sha1 refs msg))
+        (goto-char (point-at-bol))
+        (if sha1
+            (magit-with-section sha1 'commit
+              (when magit-log-count (setq magit-log-count (1+ magit-log-count)))
+              (magit-set-section-info sha1)
+              (forward-line))
+          (forward-line))))
+     (t
+      (forward-line)))
     t))
 
 (defun magit-wash-log (&optional style)
   (let ((magit-old-top-section nil))
-    (magit-log-initialize-author-date-overlay)
-    (magit-wash-sequence (apply-partially 'magit-wash-log-line style))
-    (magit-log-create-author-date-overlay)))
+    (magit-wash-sequence (apply-partially 'magit-wash-log-line style))))
 
 (defvar magit-currently-shown-commit nil)
 
 (defun magit-wash-commit ()
-  (let ((magit-current-diff-range)
-        (merge-commit))
+  (let ((magit-current-diff-range))
     (when (looking-at "^commit \\([0-9a-fA-F]\\{40\\}\\)")
       (setq magit-current-diff-range (match-string 1))
       (add-text-properties (match-beginning 1) (match-end 1)
@@ -3791,8 +3263,7 @@ insert a line to tell how to insert more of them"
      ((search-forward-regexp "^Merge: \\([0-9a-fA-F]+\\) \\([0-9a-fA-F]+\\)$" nil t)
       (setq magit-current-diff-range (cons (cons (match-string 1)
                                                  (match-string 2))
-                                           magit-current-diff-range)
-            merge-commit t)
+                                           magit-current-diff-range))
       (let ((first (magit-set-section nil 'commit (match-beginning 1) (match-end 1)))
             (second (magit-set-section nil 'commit (match-beginning 2) (match-end 2))))
         (magit-set-section-info (match-string 1) first)
@@ -3801,23 +3272,8 @@ insert a line to tell how to insert more of them"
       (make-commit-button (match-beginning 2) (match-end 2)))
      (t
       (setq magit-current-diff-range (cons (concat magit-current-diff-range "^")
-                                           magit-current-diff-range)
-            merge-commit nil)))
-
-    (search-forward-regexp "^$")        ; point at the beginning of log msgs
-
-    (when magit-show-diffstat
-      (let ((pos (point)))
-        (save-excursion
-          (forward-char)
-          (when (search-forward-regexp (if merge-commit "^$" "^---$")
-                                       nil t)
-            (delete-region (match-beginning 0)
-                           (+ (match-end 0) 1))
-            (insert "\n")
-
-            (magit-wash-diffstats)))))
-
+                                           magit-current-diff-range))))
+    (search-forward-regexp "^$")
     (while (and
             (search-forward-regexp "\\(\\b[0-9a-fA-F]\\{4,40\\}\\b\\)\\|\\(^diff\\)" nil 'noerror)
             (not (match-string 2)))
@@ -3871,7 +3327,6 @@ insert a line to tell how to insert more of them"
            "--pretty=medium"
            `(,@(if magit-have-abbrev (list "--no-abbrev-commit"))
              ,@(if magit-have-decorate (list "--decorate=full"))
-             ,@(if magit-show-diffstat (list "--stat"))
              "--cc"
              "-p" ,commit))))
 
@@ -3885,10 +3340,9 @@ insert a line to tell how to insert more of them"
   "Buffer name for displaying commit log messages.")
 
 (defun magit-show-commit (commit &optional scroll inhibit-history select)
-  "Show information about a commit.
-Show it in the buffer named by `magit-commit-buffer-name'.
-COMMIT can be any valid name for a commit in the current Git
-repository.
+  "Show information about a commit in the buffer named by
+`magit-commit-buffer-name'.  COMMIT can be any valid name for a commit
+in the current Git repository.
 
 When called interactively or when SELECT is non-nil, switch to
 the commit buffer using `pop-to-buffer'.
@@ -3936,8 +3390,8 @@ for this argument.)"
 
 (defun magit-show-commit-backward (&optional ignored)
   ;; Ignore argument passed by push-button
-  "Show the commit at the head of `magit-back-navigation-history'
-in `magit-commit-buffer-name'."
+  "Show the commit at the head of `magit-back-navigation-history in
+`magit-commit-buffer-name`."
   (interactive)
   (with-current-buffer magit-commit-buffer-name
     (unless magit-back-navigation-history
@@ -3950,8 +3404,8 @@ in `magit-commit-buffer-name'."
 
 (defun magit-show-commit-forward (&optional ignored)
   ;; Ignore argument passed by push-button
-  "Show the commit at the head of `magit-forward-navigation-history'
-in `magit-commit-buffer-name'."
+  "Show the commit at the head of `magit-forward-navigation-history in
+`magit-commit-buffer-name`."
   (interactive)
   (with-current-buffer magit-commit-buffer-name
     (unless magit-forward-navigation-history
@@ -3996,7 +3450,7 @@ in `magit-commit-buffer-name'."
       (error "No commit marked")))
 
 (defun magit-remote-branch-name (remote branch)
-  "Get the name of the branch BRANCH on remote REMOTE."
+  "Get the name of the branch BRANCH on remote REMOTE"
   (if (string= remote ".")
       branch
     (concat remote "/" branch)))
@@ -4019,18 +3473,17 @@ in `magit-commit-buffer-name'."
 
 (defun magit-remote-branch-for (local-branch &optional fully-qualified-name)
   "Guess the remote branch name that LOCAL-BRANCH is tracking.
-Gives a fully qualified name (e.g., refs/remotes/origin/master)
-if FULLY-QUALIFIED-NAME is non-nil."
-  (let ((merge  (magit-get "branch" local-branch "merge"))
-        (remote (magit-get "branch" local-branch "remote")))
+Gives a fully qualified name (e.g., refs/remotes/origin/master) if
+FULLY-QUALIFIED-NAME is non-nil."
+  (let ((merge (magit-get "branch" local-branch "merge")))
     (save-match-data
-      (when (and merge remote
-                 (string-match "^refs/heads/\\(.+\\)" merge))
-        (concat (when fully-qualified-name
-                  (if (string= "." remote)
-                      "refs/heads/"
-                    (concat "refs/remotes/" remote "/")))
-                (match-string 1 merge))))))
+      (if (and merge (string-match "^refs/heads/\\(.+\\)" merge))
+          (concat (if fully-qualified-name
+                      (let ((remote-name (magit-get "branch" local-branch "remote")))
+                        (if (string= "." remote-name)
+                            "refs/heads/"
+                          (concat "refs/remotes/" remote-name "/"))))
+                  (match-string 1 merge))))))
 
 ;;; Status
 
@@ -4038,17 +3491,20 @@ if FULLY-QUALIFIED-NAME is non-nil."
 
 (defun magit-remote-string (remote remote-branch remote-rebase)
   (cond
-   ((and (string= "." remote) remote-branch)
+   ((string= "." remote)
     (concat
      (when remote-rebase "onto ")
      "branch "
      (propertize remote-branch 'face 'magit-branch)))
-   ((and remote remote-branch)
+   (remote
     (concat
      (when remote-rebase "onto ")
      (propertize remote-branch 'face 'magit-branch)
-     " @ " remote
-     " (" (magit-get "remote" remote "url") ")"))
+     " @ "
+     remote
+     " ("
+     (magit-get "remote" remote "url")
+     ")"))
    (t
     (run-hook-with-args-until-success 'magit-remote-string-hook))))
 
@@ -4098,8 +3554,8 @@ if FULLY-QUALIFIED-NAME is non-nil."
           (magit-insert-unstaged-changes
            (if staged "Unstaged changes:" "Changes:"))
           (magit-insert-staged-changes staged no-commit))
-        (magit-insert-unpushed-commits remote remote-branch))))
-  (run-hooks 'magit-refresh-status-hook))
+        (magit-insert-unpushed-commits remote remote-branch)
+        (run-hooks 'magit-refresh-status-hook)))))
 
 (defun magit-init (dir)
   "Initialize git repository in the DIR directory."
@@ -4129,7 +3585,7 @@ if FULLY-QUALIFIED-NAME is non-nil."
 
 (defun magit-save-some-buffers (&optional msg pred)
   "Save some buffers if variable `magit-save-some-buffers' is non-nil.
-If variable `magit-save-some-buffers' is set to `dontask' then
+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.
 
@@ -4152,32 +3608,33 @@ to consider it or not when called with that buffer current."
         (message msg)))))
 
 (defun magit-save-buffers-predicate-all ()
-  "Prompt to save all buffers with unsaved changes."
+  "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'."
+  "Only prompt to save buffers which are within the current git project (as
+  determined by the dir passed to `magit-status'."
   (and buffer-file-name
        (string= (magit-get-top-dir magit-default-directory)
                 (magit-get-top-dir (file-name-directory buffer-file-name)))))
 
 ;;;###autoload
 (defun magit-status (dir)
-  "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.
+  "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."
+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."
   (interactive (list (if current-prefix-arg
                          (magit-read-top-dir
                           (> (prefix-numeric-value current-prefix-arg)
                              4))
                        (or (magit-get-top-dir default-directory)
                            (magit-read-top-dir nil)))))
+  (magit-save-some-buffers)
   (let ((topdir (magit-get-top-dir dir)))
     (unless topdir
       (when (y-or-n-p (format "There is no Git repository in %S.  Create one? "
@@ -4185,8 +3642,6 @@ when asking for user input."
         (magit-init dir)
         (setq topdir (magit-get-top-dir dir))))
     (when topdir
-      (let ((default-directory topdir))
-        (magit-save-some-buffers))
       (let ((buf (or (magit-find-status-buffer topdir)
                      (generate-new-buffer
                       (concat "*magit: "
@@ -4236,8 +3691,6 @@ at point."
        (magit-apply-hunk-item item "--cached"))
       ((unstaged diff)
        (magit-run-git "add" "-u" (magit-diff-item-file item)))
-      ((unstaged)
-       (magit-stage-all))
       ((staged *)
        (error "Already staged"))
       ((diff diff)
@@ -4266,8 +3719,6 @@ at point."
      (if (magit-no-commit-p)
          (magit-run-git "rm" "--cached" "--" (magit-diff-item-file item))
        (magit-run-git "reset" "-q" "HEAD" "--" (magit-diff-item-file item))))
-    ((staged)
-     (magit-unstage-all))
     ((unstaged *)
      (error "Already unstaged"))
     ((diff diff)
@@ -4302,14 +3753,16 @@ With prefix argument, add remaining untracked files as well.
 ;;; Branches
 
 (defun escape-branch-name (branch)
-  "Escape branch name BRANCH to remove problematic characters."
+  "Escapes branch names to remove problematic characters."
   (replace-regexp-in-string "[/]" "-" branch))
 
-(defun magit-default-tracking-name-remote-plus-branch (remote branch)
+(defun magit-default-tracking-name-remote-plus-branch
+  (remote branch)
   "Use the remote name plus a hyphen plus the escaped branch name for tracking branches."
   (concat remote "-" (escape-branch-name branch)))
 
-(defun magit-default-tracking-name-branch-only (remote branch)
+(defun magit-default-tracking-name-branch-only
+  (remote branch)
   "Use just the escaped branch name for tracking branches."
   (escape-branch-name branch))
 
@@ -4330,7 +3783,7 @@ tracking brach name suggesting a sensible default."
 
 (defun magit-maybe-create-local-tracking-branch (rev)
   "Depending on the users wishes, create a tracking branch for
-REV... maybe."
+rev... maybe."
   (if (string-match "^\\(?:refs/\\)?remotes/\\([^/]+\\)/\\(.+\\)" rev)
       (let* ((remote (match-string 1 rev))
              (branch (match-string 2 rev))
@@ -4380,19 +3833,20 @@ Fails if working tree or staging area contain uncommitted changes.
   (when (and branch (not (string= branch ""))
              parent)
     (magit-save-some-buffers)
-    (apply #'magit-run-git
-           "checkout" "-b"
-           branch
-           (append magit-custom-options (list (magit-rev-to-git parent))))
+    (magit-run-git "checkout" "-b"
+                   branch
+                   (append
+                    magit-custom-options
+                    (magit-rev-to-git parent)))
     (magit-update-vc-modeline default-directory)))
 
 (defun magit-delete-branch (branch &optional force)
-  "Delete the BRANCH.
+  "Deletes a 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-with-default "Branch to delete" 'notrim)
+  (interactive (list (magit-read-rev "Branch to delete" (magit-default-rev 'notrim))
                      current-prefix-arg))
   (let* ((remote (magit-remote-part-of-branch branch))
          (is-current (string= branch (magit-get-current-branch)))
@@ -4401,7 +3855,7 @@ Works with local or remote branches.
                      branch)))
     (cond
      (remote
-      (magit-run-git-async "push" remote (concat ":refs/heads/" (magit-branch-no-remote branch))))
+      (magit-run-git "push" remote (concat ":refs/heads/" (magit-branch-no-remote branch))))
      (is-current
       (when (y-or-n-p "Cannot delete current branch. Switch to master first? ")
           (progn
@@ -4412,10 +3866,10 @@ Works with local or remote branches.
             (apply 'magit-run-git args)))))
 
 (defun magit-move-branch (old new &optional force)
-  "Rename or move branch OLD to NEW.
+  "Renames or moves a branch.
 With prefix, forces the move even if NEW already exists.
 \('git branch [-m|-M] OLD NEW')."
-  (interactive (list (magit-read-rev-with-default "Old name")
+  (interactive (list (magit-read-rev "Old name" (magit-default-rev))
                      (read-string "New name: ")
                      current-prefix-arg))
   (magit-run-git "branch" (if force
@@ -4424,44 +3878,31 @@ With prefix, forces the move even if NEW already exists.
                  (magit-rev-to-git 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."
-  (let ((branch                  ; may be t.  see `magit-section-case'
-         (magit-section-case (item info)
-           ((branch)
-            (magit-section-info (magit-current-section)))
-           ((wazzup commit)
-            (magit-section-info (magit-section-parent item)))
-           ((commit)
-            (magit-name-rev (substring info 0 magit-sha1-abbrev-length)))
-           ((wazzup) info)
-           (t (let ((lines (magit-git-lines "reflog")))
-                (while (and lines
-                            (not (string-match "moving from \\(.+?\\) to"
-                                               (car lines))))
-                  (setq lines (cdr lines)))
-                (when lines
-                  (match-string 1 (car lines))))))))
-    (when (stringp branch)
-      branch)))
+  (magit-section-case (item info)
+    ((branch)
+     (magit-section-info (magit-current-section)))
+    ((wazzup commit)
+     (magit-section-info (magit-section-parent item)))
+    ((commit) (magit-name-rev (substring info 0 magit-sha1-abbrev-length)))
+    ((wazzup) info)))
 
 ;;; Remotes
 
 (defun magit-add-remote (remote url)
-  "Add the REMOTE and fetch it.
+  "Adds a remote and fetches it.
 \('git remote add REMOTE URL')."
   (interactive (list (read-string "Add remote: ")
                      (read-string "URL: ")))
-  (magit-run-git-async "remote" "add" "-f" remote url))
+  (magit-run-git "remote" "add" "-f" remote url))
 
 (defun magit-remove-remote (remote)
-  "Delete the REMOTE.
+  "Deletes a remote.
 \('git remote rm REMOTE')."
   (interactive (list (magit-read-remote "Remote to delete")))
   (magit-run-git "remote" "rm" remote))
 
 (defun magit-rename-remote (old new)
-  "Rename remote OLD to NEW.
+  "Renames a remote.
 \('git remote rename OLD NEW')."
   (interactive (list (magit-read-remote "Old name")
                      (read-string "New name: ")))
@@ -4474,7 +3915,7 @@ If no branch is found near the cursor return nil."
     ((remote)
      info)
     (t
-     (if (string= info ".")
+     (if  (string= info ".")
          info
        (magit-get-current-remote)))))
 
@@ -4485,7 +3926,7 @@ If no branch is found near the cursor return nil."
 With a prefix-arg, the merge will be squashed.
 \('git merge --no-commit [--squash|--no-ff] REVISION')."
   (interactive
-   (list (magit-read-rev-with-default "Merge")))
+   (list (magit-read-rev "Merge" (magit-default-rev))))
   (if revision
       (apply 'magit-run-git
              "merge"
@@ -4495,8 +3936,8 @@ With a prefix-arg, the merge will be squashed.
 ;;; Rebasing
 
 (defun magit-rebase-info ()
-  "Return a list indicating the state of an in-progress rebase.
-If there is no rebase in progress return nil."
+  "Returns a list indicating the state of an in-progress rebase,
+if any."
   (let ((git-dir (magit-git-dir)))
     (cond ((file-exists-p (concat git-dir "rebase-merge"))
            (list
@@ -4509,9 +3950,9 @@ If there is no rebase in progress return nil."
             ;; How many commits we have in total, without the comments
             ;; at the end of git-rebase-todo.backup
             (let ((todo-lines-with-comments (magit-file-lines (concat git-dir "rebase-merge/git-rebase-todo.backup"))))
-              (cl-loop for i in todo-lines-with-comments
-                       until (string= "" i)
-                       count i))))
+              (loop for i in todo-lines-with-comments
+                    until (string= "" i)
+                    count i))))
           ((and (file-exists-p (concat git-dir "rebase-apply"))
                 (file-exists-p (concat git-dir "rebase-apply/onto")))
            ;; we might be here because a non-interactive rebase failed: the
@@ -4545,7 +3986,7 @@ If there is no rebase in progress return nil."
             (message-log-max nil))
         (message "Rebase in progress. [A]bort, [S]kip, or [C]ontinue? ")
         (let ((reply (read-event)))
-          (cl-case reply
+          (case reply
             ((?A ?a)
              (magit-run-git-async "rebase" "--abort"))
             ((?S ?s)
@@ -4671,7 +4112,7 @@ With a prefix arg, also remove untracked files.  With two prefix args, remove ig
                            "diff" (magit-diff-U-arg) "-R" orig)))))
 
 (defun magit-rewrite-start (from &optional onto)
-  (interactive (list (magit-read-rev-with-default "Rewrite from")))
+  (interactive (list (magit-read-rev "Rewrite from" (magit-default-rev))))
   (or (magit-everything-clean-p)
       (error "You have uncommitted changes"))
   (or (not (magit-read-rewrite-info))
@@ -4758,47 +4199,19 @@ If there is no default remote, ask for one."
   (apply 'magit-run-git-async "remote" "update" magit-custom-options))
 
 (magit-define-command 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."
-
+  "Run git pull against the current remote."
   (interactive)
   (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 chosen-branch-remote (format "Pull branch from remote %s" 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"))
-    (apply 'magit-run-git-async "pull" "-v"
-           (append
-            magit-custom-options
-            (when choose-remote
-              (list chosen-branch-remote))
-            (when choose-branch
-               (list (format "refs/heads/%s:refs/remotes/%s/%s" chosen-branch-merge-name chosen-branch-remote chosen-branch-merge-name)))))))
+         (config-branch (and branch (magit-get "branch" branch "merge")))
+         (merge-branch (or (and config-branch (not current-prefix-arg))
+                           (magit-read-remote-branch
+                            branch-remote (format "Pull from: ")))))
+    (when (and branch (not config-branch))
+      (magit-set branch-remote "branch" branch "remote")
+      (magit-set (format "refs/heads/%s" merge-branch)
+                 "branch" branch "merge"))
+    (apply 'magit-run-git-async "pull" "-v" magit-custom-options)))
 
 (eval-when-compile (require 'eshell))
 
@@ -4870,9 +4283,7 @@ option, falling back to something hairy if that is unset."
         (error "Not pushing since no upstream has been set.")
       (let ((set-upstream-on-push (and (not ref-branch)
                                        (or (eq magit-set-upstream-on-push 'dontask)
-                                           (and (or (eq magit-set-upstream-on-push t)
-                                                    (and (not branch-remote)
-                                                         (eq magit-set-upstream-on-push 'askifnotset)))
+                                           (and (eq magit-set-upstream-on-push t)
                                                 (yes-or-no-p "Set upstream while pushing? "))))))
         (if (and (not branch-remote)
                  (not current-prefix-arg))
@@ -4901,7 +4312,6 @@ option, falling back to something hairy if that is unset."
     (define-key map (kbd "C-x #") 'magit-log-edit-commit)
     (define-key map (kbd "C-c C-a") 'magit-log-edit-toggle-amending)
     (define-key map (kbd "C-c C-s") 'magit-log-edit-toggle-signoff)
-    (define-key map (kbd "C-c C-v") 'magit-log-edit-toggle-gpgsign)
     (define-key map (kbd "C-c C-t") 'magit-log-edit-toggle-author)
     (define-key map (kbd "C-c C-e") 'magit-log-edit-toggle-allow-empty)
     (define-key map (kbd "M-p") 'log-edit-previous-comment)
@@ -4915,42 +4325,6 @@ option, falling back to something hairy if that is unset."
 
 (defvar magit-pre-log-edit-window-configuration nil)
 
-(easy-menu-define magit-log-edit-mode-menu magit-log-edit-mode-map
-  "Log Edit menu"
-  '("Log Edit"
-    ["Previous" log-edit-previous-comment t]
-    ["Next" log-edit-next-comment t]
-    "-"
-    ["Amend" magit-log-edit-toggle-amending
-     :style toggle
-     :selected (string= (magit-log-edit-get-field 'amend) "yes")
-     :help "If selected this commit will be an amendment to the previous commit."]
-    ["Sign-Off" magit-log-edit-toggle-signoff
-     :style toggle
-     :selected (let ((sign-off-field (magit-log-edit-get-field 'sign-off)))
-                 (if sign-off-field
-                     (equal sign-off-field "yes")
-                   magit-commit-signoff))
-     :help "If selected a Signed-off-by line will be added."]
-    ["GPG Sign" magit-log-edit-toggle-gpgsign
-     :style toggle
-     :selected (let ((gpg-sign-field (magit-log-edit-get-field 'gpg-sign)))
-                 (if gpg-sign-field
-                     (equal gpg-sign-field "yes")
-                   magit-commit-gpgsign))
-     :help "If selected the commit will be signed."]
-    ["Author" magit-log-edit-toggle-author
-     :style toggle
-     :selected (magit-log-edit-get-field 'author)
-     :help "If selected this commit will include an author."]
-    ["Allow Empty" magit-log-edit-toggle-allow-empty
-     :style toggle
-     :selected (string= (magit-log-edit-get-field 'allow-empty) "yes")
-     :help "If selected the commit is allowed to be empty."]
-    "-"
-    ["Cancel" magit-log-edit-cancel-log-message t]
-    ["Commit" magit-log-edit-commit t]))
-
 (define-derived-mode magit-log-edit-mode text-mode "Magit Log Edit"
   ;; Recognize changelog-style paragraphs
   (set (make-local-variable 'paragraph-start)
@@ -4977,9 +4351,9 @@ option, falling back to something hairy if that is unset."
         (with-current-buffer buf
           (goto-char (point-min))
           (while (looking-at "^\\([A-Za-z0-9-_]+\\): *\\(.+\\)?$")
-            (setq result (cons (cons (intern (downcase (match-string 1)))
-                                     (read (or (match-string 2) "nil")))
-                               result))
+            (setq result (acons (intern (downcase (match-string 1)))
+                                (read (or (match-string 2) "nil"))
+                                result))
             (forward-line))
           (if (not (looking-at (regexp-quote magit-log-header-end)))
               (setq result nil))))
@@ -5029,7 +4403,7 @@ toggled on.  When it's toggled on for the first time, return
         (progn
           (setq yesp (equal (cdr cell) "yes"))
           (rplacd cell (if yesp "no" "yes")))
-      (setq fields (cons (cons name (if default "yes" "no")) fields))
+      (setq fields (acons name (if default "yes" "no") fields))
       (setq yesp (if default 'first)))
     (magit-log-edit-set-fields fields)
     yesp))
@@ -5048,7 +4422,7 @@ toggled on."
         (progn
           (setq fields (assq-delete-all name fields)
                 result (cdr cell)))
-      (setq fields (cons (cons name default) fields)))
+      (setq fields (acons name default fields)))
     (magit-log-edit-set-fields fields)
     result))
 
@@ -5087,10 +4461,6 @@ environment (potentially empty)."
          (sign-off (if sign-off-field
                        (equal (cdr sign-off-field) "yes")
                      magit-commit-signoff))
-         (gpg-sign-field (assq 'gpg-sign fields))
-         (gpg-sign (if gpg-sign-field
-                       (equal (cdr gpg-sign-field) "yes")
-                     magit-commit-gpgsign))
          (tag-rev (cdr (assq 'tag-rev fields)))
          (tag-name (cdr (assq 'tag-name fields)))
          (author (cdr (assq 'author fields)))
@@ -5121,8 +4491,7 @@ environment (potentially empty)."
         (let ((process-environment env))
           (cond (tag-name
                  (apply #'magit-run-git-with-input commit-buf
-                        "tag" (append tag-options
-                                      (list tag-name "-a" "-F" "-" tag-rev))))
+                        "tag" (append tag-options (list tag-name "-a" "-F" "-" tag-rev))))
                 (t
                  (apply #'magit-run-async-with-input commit-buf
                         magit-git-executable
@@ -5130,12 +4499,10 @@ environment (potentially empty)."
                                 '("commit")
                                 magit-custom-options
                                 '("-F" "-")
-                                (when (and commit-all (not allow-empty))
-                                  '("--all"))
-                                (when amend '("--amend"))
-                                (when allow-empty '("--allow-empty"))
-                                (when sign-off '("--signoff"))
-                                (when gpg-sign '("-S")))))))))
+                                (if (and commit-all (not allow-empty)) '("--all") '())
+                                (if amend '("--amend") '())
+                                (if allow-empty '("--allow-empty"))
+                                (if sign-off '("--signoff") '()))))))))
     ;; shouldn't we kill that buffer altogether?
     (erase-buffer)
     (let ((magit-buf magit-buffer-internal))
@@ -5177,12 +4544,6 @@ environment (potentially empty)."
   (interactive)
   (magit-log-edit-toggle-field 'sign-off (not magit-commit-signoff)))
 
-(defun magit-log-edit-toggle-gpgsign ()
-  "Toggle whether this commit will be GPG-signed.
-\(i.e., whether eventual commit does 'git commit -S')"
-  (interactive)
-  (magit-log-edit-toggle-field 'gpg-sign (not magit-commit-gpgsign)))
-
 (defun magit-log-edit-toggle-author ()
   "Toggle whether this commit will include an author.
 \(i.e., whether eventual commit is run with GIT_AUTHOR_NAME and
@@ -5214,7 +4575,7 @@ This means that the eventual commit does 'git commit --allow-empty'."
     (message "Type C-c C-c to %s (C-c C-k to cancel)." operation)))
 
 (defun magit-log-edit (&optional arg)
-  "Bring up a buffer to allow editing of commit messages.
+  "Brings up a buffer to allow editing of commit messages.
 
 Giving a simple prefix arg will amend a previous commit, while
 a double prefix arg will allow creating an empty one.
@@ -5545,20 +4906,11 @@ With a non numeric prefix ARG, show all entries"
              ,(format "--max-count=%s" magit-log-cutoff-length)
              ,"--abbrev-commit"
              ,(format "--abbrev=%s" magit-sha1-abbrev-length)
-             ,@(cond ((eq style 'long) (append
-                                        (list "--stat" "-z")
-                                        (when magit-log-show-gpg-status
-                                          (list "--show-signature"))))
-                     ((eq style 'oneline)
-                      (let ((fmt
-                             (if magit-log-show-gpg-status
-                                 "%h%d %G?[%an][%ar]%s"
-                               "%h%d [%an][%ar]%s")))
-                        (list (format "--pretty=format:%s" fmt))))
+             ,@(cond ((eq style 'long) (list "--stat" "-z"))
+                     ((eq style 'oneline) (list "--pretty=oneline"))
                      (t nil))
              ,@(if magit-have-decorate (list "--decorate=full"))
              ,@(if magit-have-graph (list "--graph"))
-             ,"--color"
              ,@args
              "--"))))
 
@@ -5568,6 +4920,9 @@ With a non numeric prefix ARG, show all entries"
 \\{magit-log-mode-map}"
   :group 'magit)
 
+(defvar magit-log-buffer-name "*magit-log*"
+  "Buffer name for display of log entries.")
+
 (magit-define-command log-ranged ()
   (interactive)
   (magit-log t))
@@ -5683,36 +5038,24 @@ This is only non-nil in reflog buffers.")
         (magit-ediff* (magit-show (car range) file2)
                       (magit-show (cdr range) file1)))))))
 
-(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* (a b &optional c)
   (setq magit-ediff-buffers (list a b c))
   (setq magit-ediff-windows (current-window-configuration))
+  (add-hook 'ediff-quit-hook 'magit-ediff-restore 'append)
   (if c
-      (ediff-buffers3 a b c '(magit-ediff-add-cleanup))
-      (ediff-buffers a b '(magit-ediff-add-cleanup))))
+      (ediff-buffers3 a b c)
+    (ediff-buffers a b)))
 
 (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)))
+    (if (and (null (buffer-file-name buffer))
+             (buffer-live-p buffer))
+        (kill-buffer buffer)))
+  (setq magit-ediff-buffers nil)
+  (set-window-configuration magit-ediff-windows)
+  (remove-hook 'ediff-quit-hook 'magit-ediff-restore))
 
 (defun magit-refresh-diff-buffer (range args)
   (let ((magit-current-diff-range (cond
@@ -5724,13 +5067,10 @@ restore the window state that was saved before ediff was called."
                                     range))))
     (setq magit-current-range range)
     (magit-create-buffer-sections
-      (apply #'magit-git-section
-             'diffbuf
-             (magit-rev-range-describe range "Changes")
-             'magit-wash-diffs
-             "diff" (magit-diff-U-arg)
-             `(,@(if magit-show-diffstat (list "--patch-with-stat"))
-               ,args "--")))))
+      (magit-git-section 'diffbuf
+                         (magit-rev-range-describe range "Changes")
+                         'magit-wash-diffs
+                         "diff" (magit-diff-U-arg) args "--"))))
 
 (define-derived-mode magit-diff-mode magit-mode "Magit Diff"
   "Mode for looking at a git diff.
@@ -5749,7 +5089,7 @@ restore the window state that was saved before ediff was called."
           (magit-mode-init dir 'magit-diff-mode #'magit-refresh-diff-buffer range args)))))
 
 (magit-define-command diff-working-tree (rev)
-  (interactive (list (magit-read-rev-with-default "Diff with")))
+  (interactive (list (magit-read-rev "Diff with" (magit-default-rev))))
   (magit-diff (or rev "HEAD")))
 
 (defun magit-diff-with-mark ()
@@ -5876,7 +5216,8 @@ FILE is the path of the file whose log must be displayed.
 
 `magit-current-range' will be set to the value of RANGE.
 
-STYLE controls the display. It is either `'long',  `'oneline', or something else."
+STYLE controls the display. It is either `'long',  `'oneline', or something else.
+ "
   (magit-configure-have-graph)
   (magit-configure-have-decorate)
   (magit-configure-have-abbrev)
@@ -5918,44 +5259,58 @@ for the file whose log must be displayed."
 (defun magit-show-file-revision ()
   "Open a new buffer showing the current file in the revision at point."
   (interactive)
-  (let ((show-file-from-diff
-         (lambda (item)
-           (switch-to-buffer-other-window
-            (magit-show (cdr (magit-diff-item-range item))
-                        (magit-diff-item-file item))))))
+  (flet ((magit-show-file-from-diff (item)
+                                    (switch-to-buffer-other-window
+                                     (magit-show (cdr (magit-diff-item-range item))
+                                                 (magit-diff-item-file item)))))
     (magit-section-action (item info "show")
       ((commit)
        (let ((current-file (or magit-file-log-file
                                (magit-read-file-from-rev info))))
          (switch-to-buffer-other-window
           (magit-show info current-file))))
-      ((hunk) (funcall show-file-from-diff (magit-hunk-item-diff item)))
-      ((diff) (funcall show-file-from-diff item)))))
+      ((hunk) (magit-show-file-from-diff (magit-hunk-item-diff item)))
+      ((diff) (magit-show-file-from-diff item)))))
 
 ;;; Miscellaneous
 
-(defun magit-edit-ignore-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 to ignore: " completions () () () () file)))
-
-(defun magit-ignore-file (file &optional edit-ignore-string local)
+(defun magit-ignore-modifiable-file (file edit)
+  "Prompt the user for the filename to be added to git ignore.
+\\<minibuffer-local-map>
+The minibuffer's future history (accessible with \\[next-history-element])
+contains predefined values (such as wildcards) that might
+be of interest.
+The history and default value are derived from the filename FILE.
+If EDIT argument is negative, the prompt proposes wildcard by default.
+"
+  (let* ((just-extension (concat "*." (file-name-extension file)))
+         (full-extension (concat (file-name-directory file) just-extension))
+         (just-file (file-name-nondirectory file))
+         ;; change the order in history depending on the negativity of
+         ;; EDIT.
+         (history (if (< (prefix-numeric-value edit) 0)
+                      (list full-extension just-extension file just-file)
+                    (list file full-extension just-extension just-file))))
+    (read-string
+     (format "File to ignore [%s]: " (car history))
+     nil nil history)))
+
+(defun magit-ignore-file (file edit local)
   "Add FILE to the list of files to ignore.
-If EDIT-IGNORE-STRING 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."
+\\<minibuffer-local-map>
+If EDIT is non-`nil', prompt the user for the filename to
+be added to git ignore. In this case, the minibuffer's
+future history (accessible with \\[next-history-element]) contains predefined
+values (such as wildcards) that might be of interest.
+
+If LOCAL is nil, the `.gitignore' file is updated.
+Otherwise, it is `.git/info/exclude'."
   (let* ((local-ignore-dir (concat (magit-git-dir) "info/"))
          (ignore-file (if local
                           (concat local-ignore-dir "exclude")
                         ".gitignore")))
-    (if edit-ignore-string
-      (setq file (magit-edit-ignore-string file)))
+    (if edit
+      (setq file (magit-ignore-modifiable-file file edit)))
     (if (and local (not (file-exists-p local-ignore-dir)))
         (make-directory local-ignore-dir t))
     (with-temp-buffer
@@ -5968,23 +5323,33 @@ written to .git/info/exclude."
       (write-region nil nil ignore-file))
     (magit-need-refresh)))
 
-(defun magit--ignore-item (arg &optional local)
+(defun magit-ignore-item ()
+  "Add FILE to the `.gitignore' list of files to ignore.
+\\<minibuffer-local-map>
+With a prefix argument, prompt the user for the filename to
+be added. In this case, the minibuffer's future history
+\(accessible with \\[next-history-element]) contains predefined values (such as
+wildcards) that might be of interest. If prefix argument is
+negative, the prompt proposes wildcard by default."
   (interactive)
   (magit-section-action (item info "ignore")
     ((untracked file)
-     (magit-ignore-file (concat "/" info) current-prefix-arg local))
+     (magit-ignore-file (concat "/" info) current-prefix-arg nil))
     ((wazzup)
      (magit-wazzup-toggle-ignore info current-prefix-arg))))
 
-(defun magit-ignore-item ()
-  "Ignore the item at point."
-  (interactive)
-  (magit--ignore-item current-prefix-arg))
-
 (defun magit-ignore-item-locally ()
-  "Ignore the item at point locally only."
+  "Add FILE to the `.git/info/exclude' list of files to ignore.
+\\<minibuffer-local-map>
+With a prefix argument, prompt the user for the filename to
+be added. In this case, the minibuffer's future history
+(accessible with \\[next-history-element]) contains predefined values (such as
+wildcards) that might be of interest. If prefix argument is
+negative, the prompt proposes wildcard by default."
   (interactive)
-  (magit--ignore-item current-prefix-arg t))
+  (magit-section-action (item info "ignore")
+    ((untracked file)
+     (magit-ignore-file (concat "/" info) current-prefix-arg t))))
 
 (defun magit-discard-diff (diff stagedp)
   (let ((kind (magit-diff-item-kind diff))
@@ -6052,8 +5417,8 @@ written to .git/info/exclude."
        (magit-run-git "stash" "drop" info)))
     ((branch)
      (when (yes-or-no-p (if current-prefix-arg
-                            (concat "Force delete branch [" info "]? ")
-                          (concat "Delete branch [" info "]? ")))
+                            "Force delete branch?"
+                          "Delete branch? "))
        (magit-delete-branch info current-prefix-arg)))
     ((remote)
      (when (yes-or-no-p "Remove remote? ")
@@ -6100,11 +5465,6 @@ With a prefix argument, visit in other window."
        (dired-jump other-window (file-truename info)))
       ((diff)
        (dired-jump other-window (file-truename (magit-diff-item-file item))))
-      ((diffstat)
-       (let ((file (magit-diffstat-item-file item)))
-         (if file
-             (dired-jump other-window (file-truename file))
-           (error "Can't get the pathname for this file"))))
       ((hunk)
        (dired-jump other-window
                    (file-truename (magit-diff-item-file
@@ -6129,31 +5489,16 @@ With a prefix argument, visit in other window."
               (funcall
                (if other-window 'find-file-other-window 'find-file)
                file)))))
-    ((diffstat)
-     (let ((file (magit-diffstat-item-file item)))
-       (cond ((null file)
-              (error "Can't get pathname for this file"))
-             ((not (file-exists-p file))
-              (error "Can't visit deleted file: %s" file))
-             ((file-directory-p file)
-              (magit-status file))
-             (t
-              (funcall
-               (if other-window 'find-file-other-window 'find-file)
-               file)))))
     ((hunk)
      (let ((file (magit-diff-item-file (magit-hunk-item-diff item)))
-           (line (magit-hunk-item-target-line item))
-           (column (current-column)))
+           (line (magit-hunk-item-target-line item)))
        (if (not (file-exists-p file))
            (error "Can't visit deleted file: %s" file))
        (funcall
         (if other-window 'find-file-other-window 'find-file)
         file)
        (goto-char (point-min))
-       (forward-line (1- line))
-       (when (> column 0)
-         (move-to-column (1- column)))))))
+       (forward-line (1- line))))))
 
 (defun magit-visit-item (&optional other-window)
   "Visit current item.
@@ -6164,8 +5509,6 @@ With a prefix argument, visit in other window."
      (call-interactively 'magit-visit-file-item))
     ((diff)
      (call-interactively 'magit-visit-file-item))
-    ((diffstat)
-     (call-interactively 'magit-visit-file-item))
     ((hunk)
      (call-interactively 'magit-visit-file-item))
     ((commit)
@@ -6228,7 +5571,6 @@ With a prefix argument, visit in other window."
      (message "%s" info))))
 
 (eval-when-compile (require 'server))
-(declare-function server-running-p 'server)
 
 (defun magit-server-running-p ()
   "Test whether server is running (works with < 23 as well).
@@ -6267,10 +5609,8 @@ Return values:
          (commit (and (member 'commit (magit-section-context-type section))
                       (magit-section-info section)))
          (old-editor (getenv "GIT_EDITOR")))
-    (if (executable-find "emacsclient")
-        (setenv "GIT_EDITOR" (concat (executable-find "emacsclient")
-                                     " -s " server-name))
-        (message "Cannot find emacsclient, using default git editor, please check your PATH"))
+    (setenv "GIT_EDITOR" (concat (locate-file "emacsclient" exec-path)
+                                 " -s " server-name))
     (unwind-protect
         (magit-run-git-async "rebase" "-i"
                              (or (and commit (concat commit "^"))
@@ -6282,8 +5622,8 @@ Return values:
   "Magit Branches")
 
 (defun magit-quit-window (&optional kill-buffer)
-  "Bury the buffer and delete its window.
-With a prefix argument, kill the buffer instead."
+  "Bury the buffer and delete its window.  With a prefix argument, kill the
+buffer instead."
   (interactive "P")
   (quit-window kill-buffer (selected-window)))
 
@@ -6307,21 +5647,21 @@ These are the branch names with the remote name stripped."
 (defvar magit-branches-buffer-name "*magit-branches*")
 
 (defun magit--is-branch-at-point-remote ()
-  "Return non-nil if the branch at point is a remote tracking branch."
+  "Return non-nil if the branch at point is a remote tracking branch"
   (magit-remote-part-of-branch (magit--branch-name-at-point)))
 
 (defun magit-remote-part-of-branch (branch)
   (when (string-match-p "^\\(?:refs/\\)?remotes\\/" branch)
-    (cl-loop for remote in (magit-git-lines "remote")
-             when (string-match-p (format "^\\(?:refs/\\)?remotes\\/%s\\/" (regexp-quote remote)) branch) return remote)))
+    (loop for remote in (magit-git-lines "remote")
+          when (string-match-p (format "^\\(?:refs/\\)?remotes\\/%s\\/" (regexp-quote remote)) branch) return remote)))
 
 (defun magit-branch-no-remote (branch)
   (let ((remote (magit-remote-part-of-branch branch)))
     (if remote
         (progn
           ;; This has to match if remote is non-nil
-          (cl-assert (string-match (format "^\\(?:refs/\\)?remotes\\/%s\\/\\(.*\\)" (regexp-quote remote)) branch)
-                     'show-args "Unexpected string-match failure: %s %s")
+          (assert (string-match (format "^\\(?:refs/\\)?remotes\\/%s\\/\\(.*\\)" (regexp-quote remote)) branch)
+                  'show-args "Unexpected string-match failure: %s %s")
           (match-string 1 branch))
       branch)))
 
@@ -6359,44 +5699,43 @@ These are the branch names with the remote name stripped."
          (other-ref      (match-string 7))
          (current (string-match-p "^\\*" current-string)))
 
-    ;; the current line is deleted before being reconstructed
+    ; the current line is deleted before being reconstructed
     (delete-region (point)
                    (line-beginning-position 2))
 
     (magit-with-section branch 'branch
       (magit-set-section-info branch)
       (insert-before-markers
-       ;; sha1
+       ; sha1
        (propertize (or sha1
                        (make-string magit-sha1-abbrev-length ? ))
                    'face 'magit-log-sha1)
        " "
-       ;; current marker
+       ; current marker
        (if current
            "# "
          "  ")
-       ;; branch name
+       ; branch name
        (apply 'propertize (magit-branch-no-remote branch)
               (if current
                   '(face magit-branch)))
-       ;; other ref that this branch is pointing to
+       ; other ref that this branch is pointing to
        (if other-ref
            (concat " -> " (substring other-ref (+ 1 (length remote-name))))
          "")
-       ;; tracking information
+       ; tracking information
        (if (and tracking
                 (equal (magit-remote-branch-for branch t)
                        (concat "refs/remotes/" tracking)))
            (concat " ["
-                   ;; getting rid of the tracking branch name if it is
-                   ;; the same as the branch name
+                   ; getting rid of the tracking branch name if it is the same as the branch name
                    (let* ((tracking-remote (magit-get "branch" branch "remote"))
                           (tracking-branch (substring tracking (+ 1 (length tracking-remote)))))
                      (propertize (if (string= branch tracking-branch)
                                      (concat "@ " tracking-remote)
                                    (concat tracking-branch " @ " tracking-remote))
                                  'face 'magit-log-head-label-remote))
-                   ;; ahead/behind information
+                   ; ahead/behind information
                    (if (or ahead
                            behind)
                        ": "
@@ -6420,13 +5759,13 @@ These are the branch names with the remote name stripped."
        "\n"))))
 
 (defun magit-wash-remote-branches-group (group)
-  (let* ((remote-name (car group))
+  (let* ((remote-name (first group))
          (url (magit-get "remote" remote-name "url"))
          (push-url (magit-get "remote" remote-name "pushurl"))
          (urls (concat url (if push-url
                                (concat ", "push-url)
                              "")))
-         (marker (cadr group)))
+         (marker (second group)))
 
     (magit-with-section (concat "remote:" remote-name) 'remote
       (magit-set-section-info remote-name)
@@ -6443,9 +5782,9 @@ These are the branch names with the remote name stripped."
        #'magit-wash-branch-line))))
 
 (defun magit-wash-branches ()
-  ;; get the names of the remotes
+         ; get the names of the remotes
   (let* ((remotes (magit-git-lines "remote"))
-         ;; get the location of remotes in the buffer
+         ; get the location of remotes in the buffer
          (markers
           (append (mapcar (lambda (remote)
                             (save-excursion
@@ -6457,24 +5796,24 @@ These are the branch names with the remote name stripped."
                   (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
+         ; list of remote elements to display in the buffer
+         (remote-groups (loop for remote in remotes
                               for end-markers on (cdr markers)
-                              for marker = (cl-loop for x in end-markers thereis x)
+                              for marker = (loop for x in end-markers thereis x)
                               collect (list remote marker))))
 
-    ;; actual displaying of information
+    ; actual displaying of information
     (magit-with-section "local" nil
       (insert-before-markers (propertize "Local:" 'face 'magit-section-title) "\n")
       (magit-set-section-info ".")
       (magit-wash-branches-between-point-and-marker
-       (cl-loop for x in markers thereis x)))
+       (loop for x in markers thereis x)))
 
     (insert-before-markers "\n")
 
     (mapc 'magit-wash-remote-branches-group remote-groups)
 
-    ;; make sure markers point to nil so that they can be garbage collected
+    ; make sure markers point to nil so that they can be garbage collected
     (mapc (lambda (marker)
             (when marker
              (set-marker marker nil)))
@@ -6482,12 +5821,10 @@ These are the branch names with the remote name stripped."
 
 (defun magit-refresh-branch-manager ()
   (magit-create-buffer-sections
-    (apply #'magit-git-section
-           "branches" nil 'magit-wash-branches
-           "branch"
-           "-vva"
-           (format "--abbrev=%s" magit-sha1-abbrev-length)
-           magit-custom-options)))
+    (magit-git-section "branches" nil 'magit-wash-branches
+                       "branch"
+                       "-vva"
+                       (format "--abbrev=%s" magit-sha1-abbrev-length))))
 
 (magit-define-command branch-manager ()
   (interactive)
@@ -6552,8 +5889,9 @@ These are the branch names with the remote name stripped."
       (let ((buffer-file-name file))
         (normal-mode)))
     ;; We have now created the 3 buffer with ours, theirs and the ancestor files
-    (with-current-buffer (ediff-merge-buffers-with-ancestor our-buffer their-buffer base-buffer () () file)
-      (setq ediff-show-clashes-only t)
+    (with-current-buffer (ediff-merge-buffers-with-ancestor our-buffer their-buffer base-buffer)
+      (make-local-variable 'magit-ediff-file)
+      (setq magit-ediff-file file)
       (make-local-variable 'magit-ediff-windows)
       (setq magit-ediff-windows windows)
       (make-local-variable 'ediff-quit-hook)
@@ -6563,12 +5901,22 @@ These are the branch names with the remote name stripped."
                         (buffer-B ediff-buffer-B)
                         (buffer-C ediff-buffer-C)
                         (buffer-Ancestor ediff-ancestor-buffer)
+                        (file magit-ediff-file)
+                        (file-buffer)
                         (windows magit-ediff-windows))
                     (ediff-cleanup-mess)
+                    (find-file file)
+                    (setq file-buffer (current-buffer))
+                    (erase-buffer)
+                    (insert-buffer-substring buffer-C)
                     (kill-buffer buffer-A)
                     (kill-buffer buffer-B)
+                    (kill-buffer buffer-C)
                     (when (bufferp buffer-Ancestor) (kill-buffer buffer-Ancestor))
-                    (set-window-configuration windows)))))))
+                    (set-window-configuration windows)
+                    (magit-save-some-buffers
+                     "Conflict resolution finished; you may save the buffer"
+                     (lambda () (eq (current-buffer) file-buffer)))))))))
 
 (defun magit-interactive-resolve-item ()
   (interactive)
@@ -6577,8 +5925,9 @@ These are the branch names with the remote name stripped."
      (magit-interactive-resolve (cadr info)))))
 
 (defun magit-submodule-update (&optional init)
-  "Update the submodule of the current git repository.
-With a prefix arg, do a submodule update --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 default-directory)))
     (apply #'magit-run-git-async "submodule" "update" (if init '("--init") ()))))
@@ -6589,25 +5938,25 @@ With a prefix arg, do a submodule update --init."
   (magit-submodule-update t))
 
 (defun magit-submodule-init ()
-  "Initialize the submodules."
+  "Initialize the submodules"
   (interactive)
   (let ((default-directory (magit-get-top-dir default-directory)))
     (magit-run-git-async "submodule" "init")))
 
 (defun magit-submodule-sync ()
-  "Synchronizes submodule's remote URL configuration."
+  "Synchronizes submodules' remote URL configuration"
   (interactive)
   (let ((default-directory (magit-get-top-dir default-directory)))
     (magit-run-git-async "submodule" "sync")))
 
 (defun magit-run-git-gui ()
-  "Run `git gui' for the current git repository."
+  "Run `git gui' for the current git repository"
   (interactive)
   (let* ((default-directory (magit-get-top-dir default-directory)))
     (magit-start-process "Git Gui" nil magit-git-executable "gui")))
 
 (defun magit-run-gitk ()
-  "Run `gitk --all' for the current git repository."
+  "Run `gitk --all' for the current git repository"
   (interactive)
   (let ((default-directory (magit-get-top-dir default-directory)))
     (cond
@@ -6635,27 +5984,14 @@ With a prefix arg, do a submodule update --init."
       (magit-start-process "Gitk" nil magit-gitk-executable "--all")))))
 
 (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"
+  "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-define-command grep (&optional pattern)
-  (interactive)
-  (let ((pattern (or pattern
-                     (read-string "git grep: "))))
-    (with-current-buffer (generate-new-buffer "*Magit Grep*")
-      (insert magit-git-executable " "
-              (mapconcat 'identity magit-git-standard-options " ")
-              " grep -n "
-              (shell-quote-argument pattern) "\n\n")
-      (magit-git-insert (list "grep" "--line-number" pattern))
-      (grep-mode)
-      (pop-to-buffer (current-buffer)))))
-
 (provide 'magit)
 
 ;; rest of magit core
index c7c12d6..1ccfb54 100644 (file)
@@ -1,8 +1,8 @@
-;;; rebase-mode -- edit git rebase files
+;;; rebase-mode -- edit git rebase files.
 
 ;; Copyright (C) 2010  Phil Jackson
 ;; Copyright (C) 2011  Peter J Weisberg
-
+;;
 ;; 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)
 ;;; Code:
 
 (require 'server)
-(declare-function server-edit "server") 
 
 (defgroup rebase-mode nil
   "Customize Rebase Mode"
-  :group 'tools)
-
-(defcustom rebase-mode-auto-advance nil
-  "If non-nil, moves point forward a line after running an action."
-  :group 'rebase-mode
-  :type 'boolean)
-
-(defgroup rebase-mode-faces nil
-  "Customize Rebase Mode faces."
-  :group 'faces
-  :group 'rebase-mode)
+  :group 'faces)
 
 (defface rebase-mode-killed-action-face
   '((((class color))
      :inherit font-lock-comment-face
      :strike-through t))
   "Action lines in the rebase TODO list that have been commented out."
-  :group 'rebase-mode-faces)
+  :group 'rebase-mode)
 
 (defface rebase-mode-description-face
   '((t :inherit font-lock-comment-face))
-  "Face for one-line commit descriptions."
-  :group 'rebase-mode-faces)
+  "Face for one-line commit descriptions"
+  :group 'rebase-mode)
 
 (defconst rebase-mode-action-line-re
   (rx
                                  (forward-line (* n -1))))
     (define-key map [remap undo] 'rebase-mode-undo)
     map)
-  "Keymap for rebase-mode.
-Note this will be added to by the top-level code which defines
-the edit functions.")
+  "Keymap for rebase-mode.  Note this will be added to by the
+top-level code which defines the edit functions.")
 
 (require 'easymenu)
 (easy-menu-define rebase-mode-menu rebase-mode-map
@@ -174,9 +162,7 @@ that of CHANGE-TO."
       (goto-char (point-at-bol))
       (delete-region (point) (progn (forward-word 1) (point)))
       (insert change-to)
-      (goto-char start)
-      (when rebase-mode-auto-advance
-        (forward-line)))))
+      (goto-char start))))
 
 (defun rebase-mode-looking-at-action ()
   "Return non-nil if looking at an action line."
@@ -196,7 +182,7 @@ that of CHANGE-TO."
   (string-match rebase-mode-exec-line-re (thing-at-point 'line)))
 
 (defun rebase-mode-looking-at-killed-exec ()
-  "Return non-nil if looking at an exec line that has been commented out."
+  "Return non-nil if looking at an exec line that has been commented out"
   (let ((line (thing-at-point 'line)))
     (and (eq (aref line 0) ?#)
          (string-match rebase-mode-exec-line-re line))))
@@ -227,9 +213,8 @@ that of CHANGE-TO."
       (move-to-column col))))
 
 (defun rebase-mode-abort ()
-  "Abort this rebase.
-This is dune by emptying the buffer, saving and closing server
-connection."
+  "Abort this rebase (by emptying the buffer, saving and closing
+server connection)."
   (interactive)
   (when (or (not (buffer-modified-p))
             (y-or-n-p "Abort this rebase? "))
@@ -249,8 +234,8 @@ connection."
     (forward-line)))
 
 (defun rebase-mode-exec (edit)
-  "Prompt the user for a shell command to be executed, and
-add it to the todo list.
+  "Prompt the user for a shell command to be executed, and add it to
+the todo list.
 
 If the cursor is on a commented-out exec line, uncomment the
 current line instead of prompting.
@@ -288,7 +273,8 @@ exec line was commented out, also uncomment it."
   (read-shell-command "Execute: " initial-line))
 
 (defun rebase-mode-undo (&optional arg)
-  "A thin wrapper around `undo', which allows undoing in read-only buffers."
+  "A thin wrapper around `undo', which allows undoing in
+read-only buffers."
   (interactive "P")
   (let ((inhibit-read-only t))
     (undo arg)))
@@ -332,4 +318,5 @@ By default, this is the same except for the \"pick\" command."
              '("git-rebase-todo" . rebase-mode))
 
 (provide 'rebase-mode)
+
 ;;; rebase-mode.el ends here