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)
 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
 (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)
 (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)
         (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))
   (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)
   (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)
   (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 ()
            "(bisecting; unknown error occured)"))))
 
 (defun magit-bisect-start ()
-  "Start a bisect session."
+  "Start a bisect session"
   (interactive)
   (if (magit--bisecting-p)
       (error "Already bisecting"))
   (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 ()
     (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 ()
   (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 ()
   (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"))
   (interactive)
   (unless (magit--bisecting-p 'running)
     (error "Not bisecting"))
@@ -119,7 +96,7 @@ match REQUIRED-STATUS."
   (magit--bisect-cmd "skip"))
 
 (defun magit-bisect-log ()
   (magit--bisect-cmd "skip"))
 
 (defun magit-bisect-log ()
-  "Show the bisect log."
+  "Show the bisect log"
   (interactive)
   (unless (magit--bisecting-p)
     (error "Not bisecting"))
   (interactive)
   (unless (magit--bisecting-p)
     (error "Not bisecting"))
@@ -127,7 +104,7 @@ match REQUIRED-STATUS."
   (magit-display-process))
 
 (defun magit-bisect-visualize ()
   (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"))
   (interactive)
   (unless (magit--bisecting-p)
     (error "Not bisecting"))
@@ -144,7 +121,7 @@ match REQUIRED-STATUS."
   "Previously run bisect commands.")
 
 (defun magit-bisect-run (command)
   "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): "
   (interactive
    (list
     (read-from-minibuffer "Run command (like this): "
@@ -216,4 +193,3 @@ match REQUIRED-STATUS."
                             (abbreviate-file-name default-directory)))))))))
 
 (provide 'magit-bisect)
                             (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
 
 ;; 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>
 ;; 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
 
 ;; 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:
 
 
 ;;; 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:
 
 
 ;;; Code:
 
-(eval-when-compile (require 'cl-lib))
+(eval-when-compile (require 'cl))
 (require 'magit)
 (require 'magit)
-(require 'easymenu)
 
 (defface magit-blame-header
   '((t :inherit magit-header))
 
 (defface magit-blame-header
   '((t :inherit magit-header))
     map)
   "Keymap for an annotated section.\\{magit-blame-map}")
 
     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)
 
 (defvar magit-blame-buffer-read-only)
 (make-variable-buffer-local 'magit-blame-buffer-read-only)
 
     (if sha1
         (magit-show-commit sha1))))
 
     (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."
   "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
   (save-excursion
-    (goto-char beg)
+    (goto-char BEG)
     (catch 'found
     (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."
 
 (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
 
 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)))
   (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)
 
 (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
 
 (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 '()
 
 (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.")
 
 (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")
       ("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")
       ("-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
      (actions
       ("F" "Pull" magit-pull))
      (switches
-      ("-f" "Force" "--force")
       ("-r" "Rebase" "--rebase")))
 
     (branching
       ("-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)
       ("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
 
     (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)))
       ("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))))
       ("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'."
 
 (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)
     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
   (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)
 
 (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))
   (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)
     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)
 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)
 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)
   (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)
   (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
   (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
       ;; 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)
          (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)
 (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)
     (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)))
   (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)))
 
                                  (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))
 
     (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))))
 
         (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)
 (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)
 
 (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
   (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)
 
 (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)
 
 (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
   (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)
     (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)
 (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))
         (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)
     (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 (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))
 
   (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
   (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."
 
 (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)
      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)))
   (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)
   (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)))
   (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)
    (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
   (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-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-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)
 ;; 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)
 ;;; Code:
 
 (require 'magit)
-(eval-when-compile (require 'cl-lib))
+(eval-when-compile
+  (require 'cl))
 
 ;;; Customizables:
 
 
 ;;; 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
 (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)
   (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) 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
 ;; 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)
 ;; 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:
 
 
 ;;; 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)
 
 ;;; Code:
 
 (require 'magit)
-
 (eval-when-compile
 (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
 
 
 ;; 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
   (interactive
    (list (read-string "SVN revision: ")
          (if current-prefix-arg
            sha))
       (error "Revision %s could not be mapped to a commit" rev))))
 
            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: ")
   (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)
   (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)
   (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))))
 
 (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))))))
 
               " @ "
               (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)
   (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
 
 (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 "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))
 
   ;; 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
 
 ;; 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)
 ;; 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:
 
 
 ;;; 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)
 
 ;;; 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."
 
 (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:
   "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)
 
   :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:
   "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))
 
   :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.
 
 (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
   :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
 
 ;;;###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"))))
 
         (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 ()
 (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))))))
 
       (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.
 ;;; 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) 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) 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) 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) 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) 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) 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) 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) 2008, 2009 Marcin Bachry.
-;; Copyright (C) 2011 Marco Craveiro.
 ;; Copyright (C) 2008, 2009 Marius Vollmer.
 ;; Copyright (C) 2010 Mark Hepburn.
 ;; 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) 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 Oscar Fuentes.
-;; Copyright (C) 2010 Paul Stadig.
 ;; Copyright (C) 2009 Pavel Holejsovsky.
 ;; 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) 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 Remco van 't Veer.
 ;; Copyright (C) 2009 René Stadler.
-;; Copyright (C) 2010 Robert Boone.
 ;; Copyright (C) 2010 Robin Green.
 ;; 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) 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) 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>
 
 ;; Original Author: Marius Vollmer <marius.vollmer@nokia.com>
 ;; Former Maintainer: Phil Jackson <phil@shellarchive.co.uk>
 ;;   - Peter J Weisberg
 ;;   - Yann Hodique
 ;;   - Rémi Vanicat
 ;;   - Peter J Weisberg
 ;;   - Yann Hodique
 ;;   - Rémi Vanicat
-;; Version: 1.2.0-233-gc18cd5a
+;; Version: 1.2.0
 ;; Keywords: tools
 
 ;; 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)
 ;; 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:
 
 
 ;;; Code:
 
-(eval-when-compile
-  (require 'grep))
-
-(require 'cl-lib)
-
+(eval-when-compile (require 'cl))
 (require 'log-edit)
 (require 'easymenu)
 (require 'diff-mode)
 (require 'log-edit)
 (require 'easymenu)
 (require 'diff-mode)
-(require 'ansi-color)
 
 ;; Silences byte-compiler warnings
 (eval-and-compile
 
 ;; 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 view-mode 'view)
 (eval-when-compile (require 'iswitchb))
-(declare-function iswitchb-read-buffer 'iswitchb)
 (eval-when-compile (require 'ido))
 (eval-when-compile (require 'ido))
-(declare-function ido-completing-read 'ido)
 (eval-when-compile (require 'ediff))
 (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.
 
 ;; 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))
 
   (defalias 'magit-set-variable-and-refresh 'set-default))
 
-\f
+;;; Code:
 (defgroup magit nil
   "Controlling Git from Emacs."
   :prefix "magit-"
 (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.
 
 (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
   :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.
 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)
 
 --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
                  (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)
   :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."
 
 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)
   :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
 
 (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].
 
 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
   :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
 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)
   :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)
 
   :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
 (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)
 
   :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
 (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.
 
 `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)))
   :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
                  (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,
 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)
   :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
   :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
 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)
 
                  (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-"
 (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)
 
   "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."
 (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)
 
   "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."
 (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)
 
   "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).")
 (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-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)
 (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 "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)
     (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 "+") '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
     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))
 
     (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)
 
 (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))
 
 (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)
 
 (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)
     (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)
           (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))))))
         (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)
 
   (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)
       (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)
       `(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)
   (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)
       (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)
 ;;; 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))
 
   (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 ()
   (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)))
                                            (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)
 (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)))
                                                   (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)))
         (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))
 
                      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)
                                      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 ()
            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)))))
                                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)))
 
 (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 ()
   (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 ()
   (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
 (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)))
   (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)
   (= (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)))
   (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))
             (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
                   (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)
               (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))
   (let ((return-value nil))
     (with-temp-buffer
       (magit-git-insert (list "ls-tree" "-r" treeish))
@@ -1383,13 +1223,6 @@ those."
         nil
       rev)))
 
         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)))
 (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.
 
 ;; 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)
 
   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-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.
 
 (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
 
 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)
        ,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)
   (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)))
 (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)
         ((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)
 
 (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
   (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))
          (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)
          (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))
   (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)
          (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"))))
 
         (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.
 (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
 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.
 
 (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))
   (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)
 (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))
 
     (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))
    (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))))))
 
             (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))
 
 (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.
 
 (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)
   (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.
 
 (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)
 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,
   "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)))
   (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.
 
 (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.
   `(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)))
 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))
            ;; 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'."
 
 (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)
         '()))))
 
 (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) '*)
   ;;; 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*"))
         (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)))
     `(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))
 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
     `(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.
 
 (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))))
 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.
 
 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.
   (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))
 (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))
     (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)
         (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)
 
 (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)
   (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)
       (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
   (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))))
 
 (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))
 
 (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)
           (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)
             (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.
 
 (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)
   (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.
   "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."
 `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
   (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 ()
          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)))
 
   (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)))
 (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)
         (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)
 (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)
                        ((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))))
                           (goto-char (match-beginning 0))
                         (goto-char (point-max)))
                       (point-marker))))
-           (magit-wash-diffstats-postwork file)
-
            (let* ((status (cond
                            ((looking-at "^diff --cc")
                             'unmerged)
            (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)
   (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)))
 
 (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
                              (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))
                         (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)
            (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)))
 
          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)
 (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))
        ":\\([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)
                       (?A 'new)
                       (?D 'deleted)
                       (?M 'modified)
@@ -3260,46 +2912,20 @@ Customize `magit-diff-refine-hunk' to change the default mode."
           (forward-line))
         target))))
 
           (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)
 (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)))
   (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))
                                    (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
         (goto-char (point-min)))
       (if select
           (if prefix
@@ -3402,14 +3026,14 @@ member of ARGS, or to the working file otherwise."
 
 ;;; Logs and Commits
 
 
 ;;; 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)))
 (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
 
 ;;
 ;; Regexps for parsing ref names
@@ -3461,7 +3085,7 @@ Evaluate (man \"git-check-ref-format\") for details")
 
 (defconst magit-log-oneline-re
   (concat
 
 (defconst magit-log-oneline-re
   (concat
-   "^\\(\\(?:[---_\\*|/.] ?\\)+ *\\)?"             ; graph   (1)
+   "^\\([_\\*|/ -.]+\\)?"                          ; graph   (1)
    "\\(?:"
    "\\([0-9a-fA-F]+\\)"                            ; sha1    (2)
    "\\(?:"                                         ; refs    (3)
    "\\(?:"
    "\\([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
    ))
 
 (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
    ;; 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)
    "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
    ))
 
 (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)
     ("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)
     (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))))
 
                            (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."
   "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.")
 
 (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")))))))
 
              (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)
 (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))
     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 ()
 
 (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)
     (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))
      ((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)
       (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 "^")
       (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)))
     (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"))
            "--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))))
 
              "--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)
   "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'.
 
 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
 
 (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
   (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
 
 (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
   (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)
       (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)))
   (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.
 
 (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
     (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
 
 
 ;;; Status
 
@@ -4038,17 +3491,20 @@ if FULLY-QUALIFIED-NAME is non-nil."
 
 (defun magit-remote-string (remote remote-branch remote-rebase)
   (cond
 
 (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)))
     (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)
     (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))))
 
    (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-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."
 
 (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.
 
 (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.
 
 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 ()
         (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 ()
   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)
   (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
 
 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)))))
   (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? "
   (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
         (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: "
       (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)))
        (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)
       ((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))))
      (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)
     ((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)
 ;;; 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))
 
   (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)))
 
   "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))
 
   "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
 
 (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))
   (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)
   (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)
     (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')."
 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)))
                      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
                      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
      (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)
             (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')."
 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
                      (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 ()
                  (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)
 
 ;;; 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: ")))
 \('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)
 
 (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)
 \('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: ")))
 \('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
     ((remote)
      info)
     (t
-     (if (string= info ".")
+     (if  (string= info ".")
          info
        (magit-get-current-remote)))))
 
          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
 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"
   (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 ()
 ;;; 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
   (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"))))
             ;; 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
           ((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)))
             (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)
             ((?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)
                            "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))
   (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 ()
   (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))
   (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))
 
 
 (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)
         (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))
                                                 (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-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)
     (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)
 
 
 (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)
 (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-_]+\\): *\\(.+\\)?$")
         (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))))
             (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")))
         (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))
       (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)))
         (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))
 
     (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))
          (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)))
          (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
         (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
                 (t
                  (apply #'magit-run-async-with-input commit-buf
                         magit-git-executable
@@ -5130,12 +4499,10 @@ environment (potentially empty)."
                                 '("commit")
                                 magit-custom-options
                                 '("-F" "-")
                                 '("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))
     ;; 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)))
 
   (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
 (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)
     (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.
 
 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)
              ,(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"))
                      (t nil))
              ,@(if magit-have-decorate (list "--decorate=full"))
              ,@(if magit-have-graph (list "--graph"))
-             ,"--color"
              ,@args
              "--"))))
 
              ,@args
              "--"))))
 
@@ -5568,6 +4920,9 @@ With a non numeric prefix ARG, show all entries"
 \\{magit-log-mode-map}"
   :group 'magit)
 
 \\{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))
 (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)))))))
 
         (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))
 (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
   (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)
 
 (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
 
 (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
                                     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.
 
 (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)
           (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 ()
   (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.
 
 
 `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)
   (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)
 (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))))
     (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
 
 
 ;;; 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.
   "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")))
   (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
     (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)))
 
       (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)
   (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))))
 
     ((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 ()
 (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)
   (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))
 
 (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
        (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? ")
        (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))))
        (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
       ((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)))))
               (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)))
     ((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))
        (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.
 
 (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))
      (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)
     ((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))
      (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).
 
 (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")))
          (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 "^"))
     (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)
   "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)))
 
   (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 ()
 (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)
   (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
 
 (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)))
 
           (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)))
 
          (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
     (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)
        " "
        (propertize (or sha1
                        (make-string magit-sha1-abbrev-length ? ))
                    'face 'magit-log-sha1)
        " "
-       ;; current marker
+       ; current marker
        (if current
            "# "
          "  ")
        (if current
            "# "
          "  ")
-       ;; branch name
+       ; branch name
        (apply 'propertize (magit-branch-no-remote branch)
               (if current
                   '(face magit-branch)))
        (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))))
          "")
        (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 " ["
        (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))
                    (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)
                        ": "
                    (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)
        "\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)
                              "")))
          (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)
 
     (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 ()
        #'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"))
   (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
          (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 (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 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))))
 
                               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
     (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)
 
 
     (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)))
     (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
 
 (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)
 
 (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
       (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)
       (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)
                         (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)
                         (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-A)
                     (kill-buffer buffer-B)
+                    (kill-buffer buffer-C)
                     (when (bufferp buffer-Ancestor) (kill-buffer buffer-Ancestor))
                     (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)
 
 (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)
      (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") ()))))
   (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 ()
   (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 ()
   (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 ()
   (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 ()
   (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
   (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 ()
       (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)))))
 
   (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
 (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
 
 ;; 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)
 ;; 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)
 ;;; Code:
 
 (require 'server)
-(declare-function server-edit "server") 
 
 (defgroup rebase-mode nil
   "Customize Rebase Mode"
 
 (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."
 
 (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))
 
 (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
 
 (defconst rebase-mode-action-line-re
   (rx
                                  (forward-line (* n -1))))
     (define-key map [remap undo] 'rebase-mode-undo)
     map)
                                  (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
 
 (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 (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."
 
 (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 ()
   (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))))
   (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 ()
       (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? "))
   (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)
     (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.
 
 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)
   (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)))
   (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)
              '("git-rebase-todo" . rebase-mode))
 
 (provide 'rebase-mode)
+
 ;;; rebase-mode.el ends here
 ;;; rebase-mode.el ends here