stgit.el: Fix problem where standard-output isn't bound correctly

[stgit] / contrib / stgit.el

diff --git a/contrib/stgit.el b/contrib/stgit.el
index 2a14fc6..bbc7eb1 100644 (file)
--- a/contrib/stgit.el
+++ b/contrib/stgit.el
@@ -9,12 +9,17 @@
 ;;
 ;; To start: `M-x stgit'
 
 ;;
 ;; To start: `M-x stgit'
 

+(when (< emacs-major-version 22)
+  (error "Emacs older than 22 is not supported by stgit.el"))
+

 (require 'git nil t)
 (require 'cl)
 (require 'ewoc)
 
 (defun stgit (dir)
 (require 'git nil t)
 (require 'cl)
 (require 'ewoc)
 
 (defun stgit (dir)

-  "Manage StGit patches for the tree in DIR."
+  "Manage StGit patches for the tree in DIR.
+
+See `stgit-mode' for commands available."

   (interactive "DDirectory: \n")
   (switch-to-stgit-buffer (git-get-top-dir dir))
   (stgit-reload))
   (interactive "DDirectory: \n")
   (switch-to-stgit-buffer (git-get-top-dir dir))
   (stgit-reload))


@@ -64,30 +69,29 @@ directory DIR or `default-directory'"
   status name desc empty files-ewoc)
 
 (defun stgit-patch-pp (patch)
   status name desc empty files-ewoc)
 
 (defun stgit-patch-pp (patch)

-  (let ((status (stgit-patch-status patch))
-        (start (point))
-        (name (stgit-patch-name patch)))
-    (case name
-       (:index (insert (propertize "  Index" 'face 'italic)))
-       (:work (insert (propertize "  Work tree" 'face 'italic)))
-       (t (insert (case status
-                    ('applied "+")
-                    ('top ">")
-                    ('unapplied "-"))
-                  (if (memq name stgit-marked-patches)
-                      "*" " ")
-                  (propertize (format "%-30s"
-                                      (symbol-name name))
-                              'face (case status
-                                      ('applied 'stgit-applied-patch-face)
-                                      ('top 'stgit-top-patch-face)
-                                      ('unapplied 'stgit-unapplied-patch-face)
-                                      ('index nil)
-                                      ('work nil)))
-                  "  "
-                  (if (stgit-patch-empty patch) "(empty) " "")
-                  (propertize (or (stgit-patch-desc patch) "")
-                              'face 'stgit-description-face))))
+  (let* ((status (stgit-patch-status patch))
+         (start (point))
+         (name (stgit-patch-name patch))
+         (face (cdr (assq status stgit-patch-status-face-alist))))
+    (insert (case status
+              ('applied "+")
+              ('top ">")
+              ('unapplied "-")
+              (t " "))
+            (if (memq name stgit-marked-patches)
+                "*" " "))
+    (if (memq status '(index work))
+        (insert (propertize (if (eq status 'index) "Index" "Work tree")
+                            'face face))
+      (insert (format "%-30s"
+                      (propertize (symbol-name name)
+                                  'face face
+                                  'syntax-table (string-to-syntax "w")))
+              "  "
+              (if (stgit-patch-empty patch) "(empty) " "")
+              (propertize (or (stgit-patch-desc patch) "")
+                          'face 'stgit-description-face)))
+    (insert "\n")

     (put-text-property start (point) 'entry-type 'patch)
     (when (memq name stgit-expanded-patches)
       (stgit-insert-patch-files patch))
     (put-text-property start (point) 'entry-type 'patch)
     (when (memq name stgit-expanded-patches)
       (stgit-insert-patch-files patch))


@@ -102,7 +106,7 @@ Argument DIR is the repository path."
       (setq default-directory dir)
       (stgit-mode)
       (set (make-local-variable 'stgit-ewoc)
       (setq default-directory dir)
       (stgit-mode)
       (set (make-local-variable 'stgit-ewoc)

-           (ewoc-create #'stgit-patch-pp "Branch:\n" "--"))
+           (ewoc-create #'stgit-patch-pp "Branch:\n\n" "--\n" t))

       (setq buffer-read-only t))
     buf))
 
       (setq buffer-read-only t))
     buf))
 


@@ -175,15 +179,38 @@ Returns nil if there was no output."
   (when stgit-worktree-node
     (ewoc-invalidate (car stgit-worktree-node) (cdr stgit-worktree-node))))
 
   (when stgit-worktree-node
     (ewoc-invalidate (car stgit-worktree-node) (cdr stgit-worktree-node))))
 

+(defun stgit-run-series-insert-index (ewoc)
+  (setq index-node    (cons ewoc (ewoc-enter-last ewoc
+                                                  (make-stgit-patch
+                                                   :status 'index
+                                                   :name :index
+                                                   :desc nil
+                                                   :empty nil)))
+        worktree-node (cons ewoc (ewoc-enter-last ewoc
+                                                  (make-stgit-patch
+                                                   :status 'work
+                                                   :name :work
+                                                   :desc nil
+                                                   :empty nil)))))
+

 (defun stgit-run-series (ewoc)
 (defun stgit-run-series (ewoc)

-  (let ((first-line t))
+  (setq stgit-index-node nil
+        stgit-worktree-node nil)
+  (let ((inserted-index (not stgit-show-worktree))
+        index-node
+        worktree-node
+        all-patchsyms)

     (with-temp-buffer
     (with-temp-buffer

-      (let ((exit-status (stgit-run-silent "series" "--description" "--empty")))
+      (let* ((standard-output (current-buffer))
+             (exit-status (stgit-run-silent "series"
+                                            "--description" "--empty")))

         (goto-char (point-min))
         (if (not (zerop exit-status))
             (cond ((looking-at "stg series: \\(.*\\)")
         (goto-char (point-min))
         (if (not (zerop exit-status))
             (cond ((looking-at "stg series: \\(.*\\)")

+                   (setq inserted-index t)

                    (ewoc-set-hf ewoc (car (ewoc-get-hf ewoc))
                    (ewoc-set-hf ewoc (car (ewoc-get-hf ewoc))

-                                "-- not initialized (run M-x stgit-init)"))
+                                (substitute-command-keys
+                                 "-- not initialized; run \\[stgit-init]")))

                   ((looking-at ".*")
                    (error "Error running stg: %s"
                           (match-string 0))))
                   ((looking-at ".*")
                    (error "Error running stg: %s"
                           (match-string 0))))


@@ -194,46 +221,47 @@ Returns nil if there was no output."
             (let* ((state-str (match-string 2))
                    (state (cond ((string= state-str ">") 'top)
                                 ((string= state-str "+") 'applied)
             (let* ((state-str (match-string 2))
                    (state (cond ((string= state-str ">") 'top)
                                 ((string= state-str "+") 'applied)

-                                ((string= state-str "-") 'unapplied))))
+                                ((string= state-str "-") 'unapplied)))
+                   (name (intern (match-string 4)))
+                   (desc (match-string 5))
+                   (empty (string= (match-string 1) "0")))
+              (unless inserted-index
+                (when (or (eq stgit-show-worktree-mode 'top)
+                          (and (eq stgit-show-worktree-mode 'center)
+                               (eq state 'unapplied)))
+                  (setq inserted-index t)
+                  (stgit-run-series-insert-index ewoc)))
+              (setq all-patchsyms (cons name all-patchsyms))

               (ewoc-enter-last ewoc
                                (make-stgit-patch
                                 :status state
               (ewoc-enter-last ewoc
                                (make-stgit-patch
                                 :status state

-                                :name (intern (match-string 4))
-                                :desc (match-string 5)
-                                :empty (string= (match-string 1) "0"))))
-            (setq first-line nil)
-            (forward-line 1)))))
-    (if stgit-show-worktree
-        (setq stgit-index-node (cons ewoc (ewoc-enter-last ewoc
-                                                           (make-stgit-patch
-                                                            :status 'index
-                                                            :name :index
-                                                            :desc nil
-                                                            :empty nil)))
-              stgit-worktree-node (cons ewoc (ewoc-enter-last ewoc
-                                                              (make-stgit-patch
-                                                               :status 'work
-                                                               :name :work
-                                                               :desc nil
-                                                               :empty nil))))
-      (setq stgit-worktree-node nil))))
-
+                                :name   name
+                                :desc   desc
+                                :empty  empty)))
+            (forward-line 1))))
+      (unless inserted-index
+        (stgit-run-series-insert-index ewoc)))
+    (setq stgit-index-node    index-node
+          stgit-worktree-node worktree-node
+          stgit-marked-patches (intersection stgit-marked-patches
+                                             all-patchsyms))))

 
 (defun stgit-reload ()
   "Update the contents of the StGit buffer."
   (interactive)
   (let ((inhibit-read-only t)
         (curline (line-number-at-pos))
 
 (defun stgit-reload ()
   "Update the contents of the StGit buffer."
   (interactive)
   (let ((inhibit-read-only t)
         (curline (line-number-at-pos))

-        (curpatch (stgit-patch-name-at-point)))
+        (curpatch (stgit-patch-name-at-point))
+        (curfile (stgit-patched-file-at-point)))

     (ewoc-filter stgit-ewoc #'(lambda (x) nil))
     (ewoc-set-hf stgit-ewoc
                  (concat "Branch: "
                          (propertize
     (ewoc-filter stgit-ewoc #'(lambda (x) nil))
     (ewoc-set-hf stgit-ewoc
                  (concat "Branch: "
                          (propertize

-                          (with-temp-buffer
-                            (stgit-run-silent "branch")
-                            (buffer-substring (point-min) (1- (point-max))))
+                          (substring (with-output-to-string
+                                       (stgit-run-silent "branch"))
+                                     0 -1)

                           'face 'stgit-branch-name-face)
                           'face 'stgit-branch-name-face)

-                         "\n")
+                         "\n\n")

                  (if stgit-show-worktree
                      "--"
                    (propertize
                  (if stgit-show-worktree
                      "--"
                    (propertize


@@ -242,19 +270,62 @@ Returns nil if there was no output."
                    'face 'stgit-description-face)))
     (stgit-run-series stgit-ewoc)
     (if curpatch
                    'face 'stgit-description-face)))
     (stgit-run-series stgit-ewoc)
     (if curpatch

-        (stgit-goto-patch curpatch)
+        (stgit-goto-patch curpatch (and curfile (stgit-file-file curfile)))

       (goto-line curline)))
   (stgit-refresh-git-status))
 
       (goto-line curline)))
   (stgit-refresh-git-status))
 

+(defun stgit-set-default (symbol value)
+  "Set default value of SYMBOL to VALUE using `set-default' and
+reload all StGit buffers."
+  (set-default symbol value)
+  (dolist (buf (buffer-list))
+    (with-current-buffer buf
+      (when (eq major-mode 'stgit-mode)
+        (stgit-reload)))))
+

 (defgroup stgit nil
   "A user interface for the StGit patch maintenance tool."
 (defgroup stgit nil
   "A user interface for the StGit patch maintenance tool."

-  :group 'tools)
+  :group 'tools
+  :link '(function-link stgit)
+  :link '(url-link "http://www.procode.org/stgit/"))

 
 

-(defface stgit-description-face
-  '((((background dark)) (:foreground "tan"))
-    (((background light)) (:foreground "dark red")))
-  "The face used for StGit descriptions"
-  :group 'stgit)
+(defcustom stgit-abbreviate-copies-and-renames t
+  "If non-nil, abbreviate copies and renames as \"dir/{old -> new}/file\"
+instead of \"dir/old/file -> dir/new/file\"."
+  :type 'boolean
+  :group 'stgit
+  :set 'stgit-set-default)
+
+(defcustom stgit-default-show-worktree t
+  "Set to non-nil to by default show the working tree in a new stgit buffer.
+
+Use \\<stgit-mode-map>\\[stgit-toggle-worktree] to toggle the this setting in an already-started StGit buffer."
+  :type 'boolean
+  :group 'stgit
+  :link '(variable-link stgit-show-worktree))
+
+(defcustom stgit-find-copies-harder nil
+  "Try harder to find copied files when listing patches.
+
+When not nil, runs git diff-tree with the --find-copies-harder
+flag, which reduces performance."
+  :type 'boolean
+  :group 'stgit
+  :set 'stgit-set-default)
+
+(defcustom stgit-show-worktree-mode 'center
+  "This variable controls where the \"Index\" and \"Work tree\"
+will be shown on in the buffer.
+
+It can be set to 'top (above all patches), 'center (show between
+applied and unapplied patches), and 'bottom (below all patches)."
+  :type '(radio (const :tag "above all patches (top)" top)
+                (const :tag "between applied and unapplied patches (center)"
+                       center)
+                (const :tag "below all patches (bottom)" bottom))
+  :group 'stgit
+  :link '(variable-link stgit-show-worktree)
+  :set 'stgit-set-default)

 
 (defface stgit-branch-name-face
   '((t :inherit bold))
 
 (defface stgit-branch-name-face
   '((t :inherit bold))


@@ -282,10 +353,16 @@ Returns nil if there was no output."
   "The face used for unapplied patch names"
   :group 'stgit)
 
   "The face used for unapplied patch names"
   :group 'stgit)
 

-(defface stgit-modified-file-face
-  '((((class color) (background light)) (:foreground "purple"))
-    (((class color) (background dark)) (:foreground "salmon")))
-  "StGit mode face used for modified file status"
+(defface stgit-description-face
+  '((((background dark)) (:foreground "tan"))
+    (((background light)) (:foreground "dark red")))
+  "The face used for StGit descriptions"
+  :group 'stgit)
+
+(defface stgit-index-work-tree-title-face
+  '((((supports :slant italic)) :slant italic)
+    (t :inherit bold))
+  "StGit mode face used for the \"Index\" and \"Work tree\" titles"

   :group 'stgit)
 
 (defface stgit-unmerged-file-face
   :group 'stgit)
 
 (defface stgit-unmerged-file-face


@@ -300,19 +377,21 @@ Returns nil if there was no output."
   "StGit mode face used for unknown file status"
   :group 'stgit)
 
   "StGit mode face used for unknown file status"
   :group 'stgit)
 

+(defface stgit-ignored-file-face
+  '((((class color) (background light)) (:foreground "grey60"))
+    (((class color) (background dark)) (:foreground "grey40")))
+  "StGit mode face used for ignored files")
+

 (defface stgit-file-permission-face
   '((((class color) (background light)) (:foreground "green" :bold t))
     (((class color) (background dark)) (:foreground "green" :bold t)))
   "StGit mode face used for permission changes."
   :group 'stgit)
 
 (defface stgit-file-permission-face
   '((((class color) (background light)) (:foreground "green" :bold t))
     (((class color) (background dark)) (:foreground "green" :bold t)))
   "StGit mode face used for permission changes."
   :group 'stgit)
 

-(defcustom stgit-expand-find-copies-harder
-  nil
-  "Try harder to find copied files when listing patches.
-
-When not nil, runs git diff-tree with the --find-copies-harder
-flag, which reduces performance."
-  :type 'boolean
+(defface stgit-modified-file-face
+  '((((class color) (background light)) (:foreground "purple"))
+    (((class color) (background dark)) (:foreground "salmon")))
+  "StGit mode face used for modified file status"

   :group 'stgit)
 
 (defconst stgit-file-status-code-strings
   :group 'stgit)
 
 (defconst stgit-file-status-code-strings


@@ -326,9 +405,18 @@ flag, which reduces performance."
             (rename      "Renamed"     stgit-modified-file-face)
             (mode-change "Mode change" stgit-modified-file-face)
             (unmerged    "Unmerged"    stgit-unmerged-file-face)
             (rename      "Renamed"     stgit-modified-file-face)
             (mode-change "Mode change" stgit-modified-file-face)
             (unmerged    "Unmerged"    stgit-unmerged-file-face)

-            (unknown     "Unknown"     stgit-unknown-file-face)))
+            (unknown     "Unknown"     stgit-unknown-file-face)
+            (ignore      "Ignored"     stgit-ignored-file-face)))

   "Alist of code symbols to description strings")
 
   "Alist of code symbols to description strings")
 

+(defconst stgit-patch-status-face-alist
+  '((applied   . stgit-applied-patch-face)
+    (top       . stgit-top-patch-face)
+    (unapplied . stgit-unapplied-patch-face)
+    (index     . stgit-index-work-tree-title-face)
+    (work      . stgit-index-work-tree-title-face))
+  "Alist of face to use for a given patch status")
+

 (defun stgit-file-status-code-as-string (file)
   "Return stgit status code for FILE as a string"
   (let* ((code (assq (stgit-file-status file)
 (defun stgit-file-status-code-as-string (file)
   "Return stgit status code for FILE as a string"
   (let* ((code (assq (stgit-file-status file)


@@ -347,6 +435,7 @@ flag, which reduces performance."
   (let ((code (assoc str '(("A" . add)
                            ("C" . copy)
                            ("D" . delete)
   (let ((code (assoc str '(("A" . add)
                            ("C" . copy)
                            ("D" . delete)

+                           ("I" . ignore)

                            ("M" . modify)
                            ("R" . rename)
                            ("T" . mode-change)
                            ("M" . modify)
                            ("R" . rename)
                            ("T" . mode-change)


@@ -415,21 +504,61 @@ Cf. `stgit-file-type-change-string'."
 (defstruct (stgit-file)
   old-perm new-perm copy-or-rename cr-score cr-from cr-to status file)
 
 (defstruct (stgit-file)
   old-perm new-perm copy-or-rename cr-score cr-from cr-to status file)
 

+(defun stgit-describe-copy-or-rename (file)
+  (let (from to common-head common-tail
+        (arrow (concat " "
+                       (propertize "->" 'face 'stgit-description-face)
+                       " ")))
+
+    (when stgit-abbreviate-copies-and-renames
+      (setq from (split-string (stgit-file-cr-from file) "/")
+            to   (split-string (stgit-file-cr-to   file) "/"))
+
+      (while (and from to (cdr from) (cdr to)
+                  (string-equal (car from) (car to)))
+        (setq common-head (cons (car from) common-head)
+              from        (cdr from)
+              to          (cdr to)))
+      (setq common-head (nreverse common-head)
+            from        (nreverse from)
+            to          (nreverse to))
+      (while (and from to (cdr from) (cdr to)
+                  (string-equal (car from) (car to)))
+        (setq common-tail (cons (car from) common-tail)
+              from        (cdr from)
+              to          (cdr to)))
+      (setq from (nreverse from)
+            to   (nreverse to)))
+
+    (if (or common-head common-tail)
+        (concat (if common-head
+                    (mapconcat #'identity common-head "/")
+                  "")
+                (if common-head "/" "")
+                (propertize "{" 'face 'stgit-description-face)
+                (mapconcat #'identity from "/")
+                arrow
+                (mapconcat #'identity to "/")
+                (propertize "}" 'face 'stgit-description-face)
+                (if common-tail "/" "")
+                (if common-tail
+                    (mapconcat #'identity common-tail "/")
+                  ""))
+      (concat (stgit-file-cr-from file) arrow (stgit-file-cr-to file)))))
+

 (defun stgit-file-pp (file)
   (let ((status (stgit-file-status file))
         (name (if (stgit-file-copy-or-rename file)
 (defun stgit-file-pp (file)
   (let ((status (stgit-file-status file))
         (name (if (stgit-file-copy-or-rename file)

-                  (concat (stgit-file-cr-from file)
-                          (propertize " -> "
-                                      'face 'stgit-description-face)
-                          (stgit-file-cr-to file))
+                  (stgit-describe-copy-or-rename file)

                 (stgit-file-file file)))
         (mode-change (stgit-file-mode-change-string
                       (stgit-file-old-perm file)
                       (stgit-file-new-perm file)))
         (start (point)))
                 (stgit-file-file file)))
         (mode-change (stgit-file-mode-change-string
                       (stgit-file-old-perm file)
                       (stgit-file-new-perm file)))
         (start (point)))

-    (insert (format "    %-12s%1s%s%s\n"
+    (insert (format "    %-12s%s%s%s%s\n"

                     (stgit-file-status-code-as-string file)
                     mode-change
                     (stgit-file-status-code-as-string file)
                     mode-change

+                    (if (zerop (length mode-change)) "" " ")

                     name
                     (propertize (stgit-file-type-change-string
                                  (stgit-file-old-perm file)
                     name
                     (propertize (stgit-file-type-change-string
                                  (stgit-file-old-perm file)


@@ -439,67 +568,105 @@ Cf. `stgit-file-type-change-string'."
                          (list 'entry-type 'file
                                'file-data file))))
 
                          (list 'entry-type 'file
                                'file-data file))))
 

+(defun stgit-find-copies-harder-diff-arg ()
+  "Return the flag to use with `git-diff' depending on the
+`stgit-find-copies-harder' flag."
+  (if stgit-find-copies-harder "--find-copies-harder" "-C"))
+
+(defun stgit-insert-ls-files (args file-flag)
+  (let ((start (point)))
+    (apply 'stgit-run-git
+           (append '("ls-files" "--exclude-standard" "-z") args))
+    (goto-char start)
+    (while (looking-at "\\([^\0]*\\)\0")
+      (let ((name-len (- (match-end 0) (match-beginning 0))))
+        (insert ":0 0 0000000000000000000000000000000000000000 0000000000000000000000000000000000000000 " file-flag "\0")
+        (forward-char name-len)))))
+

 (defun stgit-insert-patch-files (patch)
   "Expand (show modification of) the patch PATCH after the line
 at point."
   (let* ((patchsym (stgit-patch-name patch))
 (defun stgit-insert-patch-files (patch)
   "Expand (show modification of) the patch PATCH after the line
 at point."
   (let* ((patchsym (stgit-patch-name patch))

-         (end (progn (insert "#") (prog1 (point-marker) (forward-char -1))))
-         (args (list "-z" (if stgit-expand-find-copies-harder
-                              "--find-copies-harder"
-                            "-C")))
-         (ewoc (ewoc-create #'stgit-file-pp nil nil t)))
+         (end      (point-marker))
+         (args     (list "-z" (stgit-find-copies-harder-diff-arg)))
+         (ewoc     (ewoc-create #'stgit-file-pp nil nil t)))
+    (set-marker-insertion-type end t)

     (setf (stgit-patch-files-ewoc patch) ewoc)
     (with-temp-buffer
     (setf (stgit-patch-files-ewoc patch) ewoc)
     (with-temp-buffer

-      (apply 'stgit-run-git
-             (cond ((eq patchsym :work)
-                    `("diff-files" ,@args))
-                   ((eq patchsym :index)
-                    `("diff-index" ,@args "--cached" "HEAD"))
-                   (t
-                    `("diff-tree" ,@args "-r" ,(stgit-id patchsym)))))
-      (goto-char (point-min))
-      (unless (or (eobp) (memq patchsym '(:work :index)))
-        (forward-char 41))
-      (while (looking-at ":\\([0-7]+\\) \\([0-7]+\\) [0-9A-Fa-f]\\{40\\} [0-9A-Fa-f]\\{40\\} ")
-        (let ((old-perm (string-to-number (match-string 1) 8))
-              (new-perm (string-to-number (match-string 2) 8)))
-          (goto-char (match-end 0))
-          (let ((file
-                 (cond ((looking-at
-                         "\\([CR]\\)\\([0-9]*\\)\0\\([^\0]*\\)\0\\([^\0]*\\)\0")
-                        (make-stgit-file
-                         :old-perm       old-perm
-                         :new-perm       new-perm
-                         :copy-or-rename t
-                         :cr-score       (string-to-number (match-string 2))
-                         :cr-from        (match-string 3)
-                         :cr-to          (match-string 4)
-                         :status         (stgit-file-status-code (match-string 1))
-                         :file           (match-string 3)))
-                       ((looking-at "\\([ABD-QS-Z]\\)\0\\([^\0]*\\)\0")
-                        (make-stgit-file
-                         :old-perm       old-perm
-                         :new-perm       new-perm
-                         :copy-or-rename nil
-                         :cr-score       nil
-                         :cr-from        nil
-                         :cr-to          nil
-                         :status         (stgit-file-status-code (match-string 1))
-                         :file           (match-string 2))))))
-            (ewoc-enter-last ewoc file))
-          (goto-char (match-end 0))))
-      (unless (ewoc-nth ewoc 0)
-        (ewoc-set-hf ewoc "" (propertize "    <no files>\n"
-                                         'face 'stgit-description-face))))
-    (goto-char end)
-    (delete-char -2)))
-
-(defun stgit-select-file ()
-  (let ((filename (expand-file-name
-                   (stgit-file-file (stgit-patched-file-at-point)))))
+      (let ((standard-output (current-buffer)))
+        (apply 'stgit-run-git
+               (cond ((eq patchsym :work)
+                      `("diff-files" "-0" ,@args))
+                     ((eq patchsym :index)
+                      `("diff-index" ,@args "--cached" "HEAD"))
+                     (t
+                      `("diff-tree" ,@args "-r" ,(stgit-id patchsym)))))
+
+        (when (and (eq patchsym :work))
+          (when stgit-show-ignored
+            (stgit-insert-ls-files '("--ignored" "--others") "I"))
+          (when stgit-show-unknown
+            (stgit-insert-ls-files '("--others") "X"))
+          (sort-regexp-fields nil ":[^\0]*\0\\([^\0]*\\)\0" "\\1"
+                              (point-min) (point-max)))
+
+        (goto-char (point-min))
+        (unless (or (eobp) (memq patchsym '(:work :index)))
+          (forward-char 41))
+        (while (looking-at ":\\([0-7]+\\) \\([0-7]+\\) [0-9A-Fa-f]\\{40\\} [0-9A-Fa-f]\\{40\\} ")
+          (let ((old-perm (string-to-number (match-string 1) 8))
+                (new-perm (string-to-number (match-string 2) 8)))
+            (goto-char (match-end 0))
+            (let ((file
+                   (cond ((looking-at
+                           "\\([CR]\\)\\([0-9]*\\)\0\\([^\0]*\\)\0\\([^\0]*\\)\0")
+                          (let* ((patch-status (stgit-patch-status patch))
+                                 (file-subexp  (if (eq patch-status 'unapplied)
+                                                   3
+                                                 4))
+                                 (file         (match-string file-subexp)))
+                            (make-stgit-file
+                             :old-perm       old-perm
+                             :new-perm       new-perm
+                             :copy-or-rename t
+                             :cr-score       (string-to-number (match-string 2))
+                             :cr-from        (match-string 3)
+                             :cr-to          (match-string 4)
+                             :status         (stgit-file-status-code
+                                              (match-string 1))
+                             :file           file)))
+                         ((looking-at "\\([ABD-QS-Z]\\)\0\\([^\0]*\\)\0")
+                          (make-stgit-file
+                           :old-perm       old-perm
+                           :new-perm       new-perm
+                           :copy-or-rename nil
+                           :cr-score       nil
+                           :cr-from        nil
+                           :cr-to          nil
+                           :status         (stgit-file-status-code
+                                            (match-string 1))
+                           :file           (match-string 2))))))
+              (goto-char (match-end 0))
+              (ewoc-enter-last ewoc file))))
+
+        (unless (ewoc-nth ewoc 0)
+          (ewoc-set-hf ewoc ""
+                       (concat "    "
+                               (propertize "<no files>"
+                                           'face 'stgit-description-face)
+                               "\n")))))
+    (goto-char end)))
+
+(defun stgit-find-file (&optional other-window)
+  (let* ((file (or (stgit-patched-file-at-point)
+                   (error "No file at point")))
+         (filename (expand-file-name (stgit-file-file file))))

     (unless (file-exists-p filename)
       (error "File does not exist"))
     (unless (file-exists-p filename)
       (error "File does not exist"))

-    (find-file filename)))
+    (funcall (if other-window 'find-file-other-window 'find-file)
+             filename)
+    (when (eq (stgit-file-status file) 'unmerged)
+      (smerge-mode 1))))

 
 (defun stgit-select-patch ()
   (let ((patchname (stgit-patch-name-at-point)))
 
 (defun stgit-select-patch ()
   (let ((patchname (stgit-patch-name-at-point)))


@@ -510,26 +677,29 @@ at point."
   (move-to-column (stgit-goal-column)))
 
 (defun stgit-select ()
   (move-to-column (stgit-goal-column)))
 
 (defun stgit-select ()

-  "Expand or collapse the current entry"
+  "With point on a patch, toggle showing files in the patch.
+
+With point on a file, open the associated file. Opens the target
+file for (applied) copies and renames."

   (interactive)
   (case (get-text-property (point) 'entry-type)
     ('patch
      (stgit-select-patch))
     ('file
   (interactive)
   (case (get-text-property (point) 'entry-type)
     ('patch
      (stgit-select-patch))
     ('file

-     (stgit-select-file))
+     (stgit-find-file))

     (t
      (error "No patch or file on line"))))
 
 (defun stgit-find-file-other-window ()
   "Open file at point in other window"
   (interactive)
     (t
      (error "No patch or file on line"))))
 
 (defun stgit-find-file-other-window ()
   "Open file at point in other window"
   (interactive)

-  (let ((patched-file (stgit-patched-file-at-point)))
-    (unless patched-file
-      (error "No file on the current line"))
-    (let ((filename (expand-file-name (stgit-file-file patched-file))))
-      (unless (file-exists-p filename)
-        (error "File does not exist"))
-      (find-file-other-window filename))))
+  (stgit-find-file t))
+
+(defun stgit-find-file-merge ()
+  "Open file at point and merge it using `smerge-ediff'."
+  (interactive)
+  (stgit-find-file t)
+  (smerge-ediff))

 
 (defun stgit-quit ()
   "Hide the stgit buffer."
 
 (defun stgit-quit ()
   "Hide the stgit buffer."


@@ -584,10 +754,20 @@ at point."
   "Keymap for StGit major mode.")
 
 (unless stgit-mode-map
   "Keymap for StGit major mode.")
 
 (unless stgit-mode-map

-  (let ((toggle-map (make-keymap)))
+  (let ((diff-map   (make-keymap))
+        (toggle-map (make-keymap)))
+    (suppress-keymap diff-map)
+    (mapc (lambda (arg) (define-key diff-map (car arg) (cdr arg)))
+          '(("b" .        stgit-diff-base)
+            ("c" .        stgit-diff-combined)
+            ("m" .        stgit-find-file-merge)
+            ("o" .        stgit-diff-ours)
+            ("t" .        stgit-diff-theirs)))

     (suppress-keymap toggle-map)
     (mapc (lambda (arg) (define-key toggle-map (car arg) (cdr arg)))
     (suppress-keymap toggle-map)
     (mapc (lambda (arg) (define-key toggle-map (car arg) (cdr arg)))

-          '(("t" .        stgit-toggle-worktree)))
+          '(("t" .        stgit-toggle-worktree)
+            ("i" .        stgit-toggle-ignored)
+            ("u" .        stgit-toggle-unknown)))

     (setq stgit-mode-map (make-keymap))
     (suppress-keymap stgit-mode-map)
     (mapc (lambda (arg) (define-key stgit-mode-map (car arg) (cdr arg)))
     (setq stgit-mode-map (make-keymap))
     (suppress-keymap stgit-mode-map)
     (mapc (lambda (arg) (define-key stgit-mode-map (car arg) (cdr arg)))


@@ -606,16 +786,17 @@ at point."
             ("\M-{" .     stgit-previous-patch)
             ("\M-}" .     stgit-next-patch)
             ("s" .        stgit-git-status)
             ("\M-{" .     stgit-previous-patch)
             ("\M-}" .     stgit-next-patch)
             ("s" .        stgit-git-status)

-            ("g" .        stgit-reload)
+            ("g" .        stgit-reload-or-repair)

             ("r" .        stgit-refresh)
             ("\C-c\C-r" . stgit-rename)
             ("e" .        stgit-edit)
             ("M" .        stgit-move-patches)
             ("S" .        stgit-squash)
             ("N" .        stgit-new)
             ("r" .        stgit-refresh)
             ("\C-c\C-r" . stgit-rename)
             ("e" .        stgit-edit)
             ("M" .        stgit-move-patches)
             ("S" .        stgit-squash)
             ("N" .        stgit-new)

-            ("R" .        stgit-repair)
-            ("C" .        stgit-commit)
-            ("U" .        stgit-uncommit)
+            ("\C-c\C-c" . stgit-commit)
+            ("\C-c\C-u" . stgit-uncommit)
+            ("U" .        stgit-revert-file)
+            ("R" .        stgit-resolve-file)

             ("\r" .       stgit-select)
             ("o" .        stgit-find-file-other-window)
             ("i" .        stgit-file-toggle-index)
             ("\r" .       stgit-select)
             ("o" .        stgit-find-file-other-window)
             ("i" .        stgit-file-toggle-index)


@@ -623,18 +804,107 @@ at point."
             ("<" .        stgit-pop-next)
             ("P" .        stgit-push-or-pop)
             ("G" .        stgit-goto)
             ("<" .        stgit-pop-next)
             ("P" .        stgit-push-or-pop)
             ("G" .        stgit-goto)

-            ("=" .        stgit-show)
+            ("=" .        stgit-diff)

             ("D" .        stgit-delete)
             ("D" .        stgit-delete)

-            ([(control ?/)] . stgit-undo)
+            ([?\C-/] .    stgit-undo)

             ("\C-_" .     stgit-undo)
             ("\C-_" .     stgit-undo)

+            ([?\C-c ?\C-/] . stgit-redo)
+            ("\C-c\C-_" . stgit-redo)

             ("B" .        stgit-branch)
             ("B" .        stgit-branch)

+            ("\C-c\C-b" . stgit-rebase)

             ("t" .        ,toggle-map)
             ("t" .        ,toggle-map)

+            ("d" .        ,diff-map)

             ("q" .        stgit-quit)))))
 
 (defun stgit-mode ()
   "Major mode for interacting with StGit.
             ("q" .        stgit-quit)))))
 
 (defun stgit-mode ()
   "Major mode for interacting with StGit.

-Commands:
-\\{stgit-mode-map}"
+
+Start StGit using \\[stgit].
+
+Basic commands:
+\\<stgit-mode-map>\
+\\[stgit-help] Show this help text
+\\[stgit-quit] Hide the StGit buffer
+\\[describe-bindings]  Show all key bindings
+
+\\[stgit-reload-or-repair]     Reload the StGit buffer
+\\[universal-argument] \\[stgit-reload-or-repair]      Repair StGit metadata
+
+\\[stgit-undo] Undo most recent StGit operation
+\\[stgit-redo] Undo recent undo
+
+\\[stgit-git-status]   Run `git-status' (if available)
+
+Movement commands:
+\\[stgit-previous-line]        Move to previous line
+\\[stgit-next-line]    Move to next line
+\\[stgit-previous-patch]       Move to previous patch
+\\[stgit-next-patch]   Move to next patch
+
+\\[stgit-mark] Mark patch
+\\[stgit-unmark-up]    Unmark patch and move up
+\\[stgit-unmark-down]  Unmark patch and move down
+
+Commands for patches:
+\\[stgit-select]       Toggle showing changed files in patch
+\\[stgit-refresh]      Refresh patch with changes in index or work tree
+\\[stgit-diff] Show the patch log and diff
+
+\\[stgit-new]  Create a new, empty patch
+\\[stgit-rename]       Rename patch
+\\[stgit-edit] Edit patch description
+\\[stgit-delete]       Delete patch(es)
+
+\\[stgit-push-next]    Push next patch onto stack
+\\[stgit-pop-next]     Pop current patch from stack
+\\[stgit-push-or-pop]  Push or pop patch at point
+\\[stgit-goto] Make current patch current by popping or pushing
+
+\\[stgit-squash]       Squash (meld together) patches
+\\[stgit-move-patches] Move patch(es) to point
+
+\\[stgit-commit]       Commit patch(es)
+\\[stgit-uncommit]     Uncommit patch(es)
+
+Commands for files:
+\\[stgit-select]       Open the file in this window
+\\[stgit-find-file-other-window]       Open the file in another window
+\\[stgit-diff] Show the file's diff
+
+\\[stgit-file-toggle-index]    Toggle change between index and work tree
+\\[stgit-revert-file]  Revert changes to file
+
+Display commands:
+\\[stgit-toggle-worktree]      Toggle showing index and work tree
+\\[stgit-toggle-unknown]       Toggle showing unknown files
+\\[stgit-toggle-ignored]       Toggle showing ignored files
+
+Commands for diffs:
+\\[stgit-diff] Show diff of patch or file
+\\[stgit-diff-base]    Show diff against the merge base
+\\[stgit-diff-ours]    Show diff against our branch
+\\[stgit-diff-theirs]  Show diff against their branch
+
+  With one prefix argument (e.g., \\[universal-argument] \\[stgit-diff]), \
+ignore space changes.
+  With two prefix arguments (e.g., \\[universal-argument] \
+\\[universal-argument] \\[stgit-diff]), ignore all space changes.
+
+Commands for merge conflicts:
+\\[stgit-find-file-merge]      Resolve conflicts using `smerge-ediff'
+\\[stgit-resolve-file] Mark unmerged file as resolved
+
+Commands for branches:
+\\[stgit-branch]       Switch to another branch
+\\[stgit-rebase]       Rebase the current branch
+
+Customization variables:
+`stgit-abbreviate-copies-and-renames'
+`stgit-default-show-worktree'
+`stgit-find-copies-harder'
+`stgit-show-worktree-mode'
+
+See also \\[customize-group] for the \"stgit\" group."

   (kill-all-local-variables)
   (buffer-disable-undo)
   (setq mode-name "StGit"
   (kill-all-local-variables)
   (buffer-disable-undo)
   (setq mode-name "StGit"


@@ -643,10 +913,11 @@ Commands:
   (use-local-map stgit-mode-map)
   (set (make-local-variable 'list-buffers-directory) default-directory)
   (set (make-local-variable 'stgit-marked-patches) nil)
   (use-local-map stgit-mode-map)
   (set (make-local-variable 'list-buffers-directory) default-directory)
   (set (make-local-variable 'stgit-marked-patches) nil)

-  (set (make-local-variable 'stgit-expanded-patches) nil)
+  (set (make-local-variable 'stgit-expanded-patches) (list :work :index))

   (set (make-local-variable 'stgit-show-worktree) stgit-default-show-worktree)
   (set (make-local-variable 'stgit-index-node) nil)
   (set (make-local-variable 'stgit-worktree-node) nil)
   (set (make-local-variable 'stgit-show-worktree) stgit-default-show-worktree)
   (set (make-local-variable 'stgit-index-node) nil)
   (set (make-local-variable 'stgit-worktree-node) nil)

+  (set (make-local-variable 'parse-sexp-lookup-properties) t)

   (set-variable 'truncate-lines 't)
   (add-hook 'after-save-hook 'stgit-update-saved-file)
   (run-hooks 'stgit-mode-hook))
   (set-variable 'truncate-lines 't)
   (add-hook 'after-save-hook 'stgit-update-saved-file)
   (run-hooks 'stgit-mode-hook))


@@ -676,10 +947,16 @@ Commands:
 (defun stgit-patch-at-point (&optional cause-error)
   (get-text-property (point) 'patch-data))
 
 (defun stgit-patch-at-point (&optional cause-error)
   (get-text-property (point) 'patch-data))
 

-(defun stgit-patch-name-at-point (&optional cause-error)
+(defun stgit-patch-name-at-point (&optional cause-error only-patches)

   "Return the patch name on the current line as a symbol.
   "Return the patch name on the current line as a symbol.

-If CAUSE-ERROR is not nil, signal an error if none found."
+If CAUSE-ERROR is not nil, signal an error if none found.
+If ONLY-PATCHES is not nil, only allow real patches, and not
+index or work tree."

   (let ((patch (stgit-patch-at-point)))
   (let ((patch (stgit-patch-at-point)))

+    (and patch
+         only-patches
+         (memq (stgit-patch-status patch) '(work index))
+         (setq patch nil))

     (cond (patch
            (stgit-patch-name patch))
           (cause-error
     (cond (patch
            (stgit-patch-name patch))
           (cause-error


@@ -697,13 +974,26 @@ If CAUSE-ERROR is not nil, signal an error if none found."
           (list patch)
         '()))))
 
           (list patch)
         '()))))
 

-(defun stgit-goto-patch (patchsym)
+(defun stgit-goto-patch (patchsym &optional file)

   "Move point to the line containing patch PATCHSYM.
   "Move point to the line containing patch PATCHSYM.

-If that patch cannot be found, do nothing."
+If that patch cannot be found, do nothing.
+
+If the patch was found and FILE is not nil, instead move to that
+file's line. If FILE cannot be found, stay on the line of
+PATCHSYM."

   (let ((node (ewoc-nth stgit-ewoc 0)))
     (while (and node (not (eq (stgit-patch-name (ewoc-data node))
                               patchsym)))
       (setq node (ewoc-next stgit-ewoc node)))
   (let ((node (ewoc-nth stgit-ewoc 0)))
     (while (and node (not (eq (stgit-patch-name (ewoc-data node))
                               patchsym)))
       (setq node (ewoc-next stgit-ewoc node)))

+    (when (and node file)
+      (let* ((file-ewoc (stgit-patch-files-ewoc (ewoc-data node)))
+             (file-node (ewoc-nth file-ewoc 0)))
+        (while (and file-node (not (equal (stgit-file-file (ewoc-data file-node)) file)))
+          (setq file-node (ewoc-next file-ewoc file-node)))
+        (when file-node
+          (ewoc-goto-node file-ewoc file-node)
+          (move-to-column (stgit-goal-column))
+          (setq node nil))))

     (when node
       (ewoc-goto-node stgit-ewoc node)
       (move-to-column goal-column))))
     (when node
       (ewoc-goto-node stgit-ewoc node)
       (move-to-column goal-column))))


@@ -719,7 +1009,12 @@ If that patch cannot be found, do nothing."
   "Mark the patch under point."
   (interactive)
   (let* ((node (ewoc-locate stgit-ewoc))
   "Mark the patch under point."
   (interactive)
   (let* ((node (ewoc-locate stgit-ewoc))

-         (patch (ewoc-data node)))
+         (patch (ewoc-data node))
+         (name (stgit-patch-name patch)))
+    (when (eq name :work)
+      (error "Cannot mark the work tree"))
+    (when (eq name :index)
+      (error "Cannot mark the index"))

     (stgit-add-mark (stgit-patch-name patch))
     (ewoc-invalidate stgit-ewoc node))
   (stgit-next-patch))
     (stgit-add-mark (stgit-patch-name patch))
     (ewoc-invalidate stgit-ewoc node))
   (stgit-next-patch))


@@ -745,9 +1040,10 @@ If that patch cannot be found, do nothing."
 
 (defun stgit-rename (name)
   "Rename the patch under point to NAME."
 
 (defun stgit-rename (name)
   "Rename the patch under point to NAME."

-  (interactive (list (read-string "Patch name: "
-                                  (symbol-name (stgit-patch-name-at-point t)))))
-  (let ((old-patchsym (stgit-patch-name-at-point t)))
+  (interactive (list
+                (read-string "Patch name: "
+                             (symbol-name (stgit-patch-name-at-point t t)))))
+  (let ((old-patchsym (stgit-patch-name-at-point t t)))

     (stgit-capture-output nil
       (stgit-run "rename" old-patchsym name))
     (let ((name-sym (intern name)))
     (stgit-capture-output nil
       (stgit-run "rename" old-patchsym name))
     (let ((name-sym (intern name)))


@@ -760,6 +1056,16 @@ If that patch cannot be found, do nothing."
       (stgit-reload)
       (stgit-goto-patch name-sym))))
 
       (stgit-reload)
       (stgit-goto-patch name-sym))))
 

+(defun stgit-reload-or-repair (repair)
+  "Update the contents of the StGit buffer (`stgit-reload').
+
+With a prefix argument, repair the StGit metadata if the branch
+was modified with git commands (`stgit-repair')."
+  (interactive "P")
+  (if repair
+      (stgit-repair)
+    (stgit-reload)))
+

 (defun stgit-repair ()
   "Run stg repair."
   (interactive)
 (defun stgit-repair ()
   "Run stg repair."
   (interactive)


@@ -785,19 +1091,124 @@ If that patch cannot be found, do nothing."
   (stgit-capture-output nil (stgit-run "branch" "--" branch))
   (stgit-reload))
 
   (stgit-capture-output nil (stgit-run "branch" "--" branch))
   (stgit-reload))
 

+(defun stgit-available-refs (&optional omit-stgit)
+  "Returns a list of the available git refs.
+If OMIT-STGIT is not nil, filter out \"resf/heads/*.stgit\"."
+  (let* ((output (with-output-to-string
+                   (stgit-run-git-silent "for-each-ref" "--format=%(refname)"
+                                         "refs/tags" "refs/heads"
+                                         "refs/remotes")))
+         (result (split-string output "\n" t)))
+    (mapcar (lambda (s)
+              (if (string-match "^refs/\\(heads\\|tags\\|remotes\\)/" s)
+                  (substring s (match-end 0))
+                s))
+            (if omit-stgit
+                (delete-if (lambda (s)
+                             (string-match "^refs/heads/.*\\.stgit$" s))
+                           result)
+              result))))
+
+(defun stgit-rebase (new-base)
+  "Rebase to NEW-BASE."
+  (interactive (list (completing-read "Rebase to: "
+                                      (stgit-available-refs t))))
+  (stgit-capture-output nil (stgit-run "rebase" new-base))
+  (stgit-reload))
+

 (defun stgit-commit (count)
   "Run stg commit on COUNT commits.
 (defun stgit-commit (count)
   "Run stg commit on COUNT commits.

-Interactively, the prefix argument is used as COUNT."
+Interactively, the prefix argument is used as COUNT.
+A negative COUNT will uncommit instead."

   (interactive "p")
   (interactive "p")

-  (stgit-capture-output nil (stgit-run "commit" "-n" count))
-  (stgit-reload))
+  (if (< count 0)
+      (stgit-uncommit (- count))
+    (stgit-capture-output nil (stgit-run "commit" "-n" count))
+    (stgit-reload)))

 
 (defun stgit-uncommit (count)
   "Run stg uncommit on COUNT commits.
 
 (defun stgit-uncommit (count)
   "Run stg uncommit on COUNT commits.

-Interactively, the prefix argument is used as COUNT."
+Interactively, the prefix argument is used as COUNT.
+A negative COUNT will commit instead."

   (interactive "p")
   (interactive "p")

-  (stgit-capture-output nil (stgit-run "uncommit" "-n" count))
-  (stgit-reload))
+  (if (< count 0)
+      (stgit-commit (- count))
+    (stgit-capture-output nil (stgit-run "uncommit" "-n" count))
+    (stgit-reload)))
+
+(defun stgit-neighbour-file ()
+  "Return the file name of the next file after point, or the
+previous file if point is at the last file within a patch."
+  (let ((old-point (point))
+        neighbour-file)
+    (and (zerop (forward-line 1))
+         (let ((f (stgit-patched-file-at-point)))
+           (and f (setq neighbour-file (stgit-file-file f)))))
+    (goto-char old-point)
+    (unless neighbour-file
+      (and (zerop (forward-line -1))
+           (let ((f (stgit-patched-file-at-point)))
+             (and f (setq neighbour-file (stgit-file-file f)))))
+      (goto-char old-point))
+    neighbour-file))
+
+(defun stgit-revert-file ()
+  "Revert the file at point, which must be in the index or the
+working tree."
+  (interactive)
+  (let* ((patched-file (or (stgit-patched-file-at-point)
+                           (error "No file on the current line")))
+         (patch-name   (stgit-patch-name-at-point))
+         (file-status  (stgit-file-status patched-file))
+         (rm-file      (cond ((stgit-file-copy-or-rename patched-file)
+                              (stgit-file-cr-to patched-file))
+                             ((eq file-status 'add)
+                              (stgit-file-file patched-file))))
+         (co-file      (cond ((eq file-status 'rename)
+                              (stgit-file-cr-from patched-file))
+                             ((not (memq file-status '(copy add)))
+                              (stgit-file-file patched-file))))
+         (next-file    (stgit-neighbour-file)))
+
+    (unless (memq patch-name '(:work :index))
+      (error "No index or working tree file on this line"))
+
+    (when (eq file-status 'ignore)
+      (error "Cannot revert ignored files"))
+
+    (when (eq file-status 'unknown)
+      (error "Cannot revert unknown files"))
+
+    (let ((nfiles (+ (if rm-file 1 0) (if co-file 1 0))))
+      (when (yes-or-no-p (format "Revert %d file%s? "
+                                 nfiles
+                                 (if (= nfiles 1) "" "s")))
+        (stgit-capture-output nil
+          (when rm-file
+            (stgit-run-git "rm" "-f" "-q" "--" rm-file))
+          (when co-file
+            (stgit-run-git "checkout" "HEAD" co-file)))
+        (stgit-reload)
+        (stgit-goto-patch patch-name next-file)))))
+
+(defun stgit-resolve-file ()
+  "Resolve conflict in the file at point."
+  (interactive)
+  (let* ((patched-file (stgit-patched-file-at-point))
+         (patch        (stgit-patch-at-point))
+         (patch-name   (and patch (stgit-patch-name patch)))
+         (status       (and patched-file (stgit-file-status patched-file))))
+
+    (unless (memq patch-name '(:work :index))
+      (error "No index or working tree file on this line"))
+
+    (unless (eq status 'unmerged)
+      (error "No conflict to resolve at the current line"))
+
+    (stgit-capture-output nil
+      (stgit-move-change-to-index (stgit-file-file patched-file)))
+
+    (stgit-reload)))

 
 (defun stgit-push-next (npatches)
   "Push the first unapplied patch.
 
 (defun stgit-push-next (npatches)
   "Push the first unapplied patch.


@@ -849,46 +1260,99 @@ If PATCHSYM is a keyword, returns PATCHSYM unmodified."
        (error "Cannot find commit id for %s" patchsym))
       (match-string 1 result))))
 
        (error "Cannot find commit id for %s" patchsym))
       (match-string 1 result))))
 

-(defun stgit-show ()
-  "Show the patch on the current line."
-  (interactive)
-  (stgit-capture-output "*StGit patch*"
-    (case (get-text-property (point) 'entry-type)
-      ('file
-       (let* ((patched-file (stgit-patched-file-at-point))
-              (patch-name (stgit-patch-name-at-point))
-              (patch-id (stgit-id patch-name))
-              (args (append (and (stgit-file-cr-from patched-file)
-                                 (if stgit-expand-find-copies-harder
-                                     '("--find-copies-harder")
-                                   '("-C")))
-                            (cond ((eq patch-id :index)
-                                   '("--cached"))
-                                  ((eq patch-id :work)
-                                   nil)
-                                  (t
-                                   (list (concat patch-id "^") patch-id)))
-                            '("--")
+(defun stgit-show-patch (unmerged-stage ignore-whitespace)
+  "Show the patch on the current line.
+
+UNMERGED-STAGE is the argument to `git-diff' that that selects
+which stage to diff against in the case of unmerged files."
+  (let ((space-arg (when (numberp ignore-whitespace)
+                     (cond ((> ignore-whitespace 4)
+                            "--ignore-all-space")
+                           ((> ignore-whitespace 1)
+                            "--ignore-space-change"))))
+        (patch-name (stgit-patch-name-at-point t)))
+    (stgit-capture-output "*StGit patch*"
+      (case (get-text-property (point) 'entry-type)
+        ('file
+         (let* ((patched-file (stgit-patched-file-at-point))
+                (patch-id (let ((id (stgit-id patch-name)))
+                            (if (and (eq id :index)
+                                     (eq (stgit-file-status patched-file)
+                                         'unmerged))
+                                :work
+                              id)))
+                (args (append (and space-arg (list space-arg))
+                              (and (stgit-file-cr-from patched-file)
+                                   (list (stgit-find-copies-harder-diff-arg)))
+                              (cond ((eq patch-id :index)
+                                     '("--cached"))
+                                    ((eq patch-id :work)
+                                     (list unmerged-stage))
+                                    (t
+                                     (list (concat patch-id "^") patch-id)))
+                              '("--")

                               (if (stgit-file-copy-or-rename patched-file)
                                   (list (stgit-file-cr-from patched-file)
                                         (stgit-file-cr-to patched-file))
                                 (list (stgit-file-file patched-file))))))
                               (if (stgit-file-copy-or-rename patched-file)
                                   (list (stgit-file-cr-from patched-file)
                                         (stgit-file-cr-to patched-file))
                                 (list (stgit-file-file patched-file))))))

-         (apply 'stgit-run-git "diff" args)))
-      ('patch
-       (stgit-run "show" "-O" "--patch-with-stat" "-O" "-M"
-                  (stgit-patch-name-at-point)))
-      (t
-       (error "No patch or file at point")))
-    (with-current-buffer standard-output
-      (goto-char (point-min))
-      (diff-mode))))
-
-(defun stgit-move-change-to-index (file)
-  "Copies the workspace state of FILE to index, using git add or git rm"
+           (apply 'stgit-run-git "diff" args)))
+        ('patch
+         (let* ((patch-id (stgit-id patch-name)))
+           (if (or (eq patch-id :index) (eq patch-id :work))
+               (apply 'stgit-run-git "diff"
+                      (stgit-find-copies-harder-diff-arg)
+                      (append (and space-arg (list space-arg))
+                              (if (eq patch-id :index)
+                                  '("--cached")
+                                (list unmerged-stage))))
+             (let ((args (append '("show" "-O" "--patch-with-stat" "-O" "-M")
+                                 (and space-arg (list "-O" space-arg))
+                                 (list (stgit-patch-name-at-point)))))
+               (apply 'stgit-run args)))))
+         (t
+          (error "No patch or file at point")))
+      (with-current-buffer standard-output
+        (goto-char (point-min))
+        (diff-mode)))))
+
+(defmacro stgit-define-diff (name diff-arg &optional unmerged-action)
+  `(defun ,name (&optional ignore-whitespace)
+     ,(format "Show the patch on the current line.
+
+%sWith a prefix argument, ignore whitespace. With a prefix argument
+greater than four (e.g., \\[universal-argument] \
+\\[universal-argument] \\[%s]), ignore all whitespace."
+              (if unmerged-action
+                  (format "For unmerged files, %s.\n\n" unmerged-action)
+                "")
+              name)
+     (interactive "p")
+     (stgit-show-patch ,diff-arg ignore-whitespace)))
+
+(stgit-define-diff stgit-diff
+                   "--ours" nil)
+(stgit-define-diff stgit-diff-ours
+                   "--ours"
+                   "diff against our branch")
+(stgit-define-diff stgit-diff-theirs
+                   "--theirs"
+                   "diff against their branch")
+(stgit-define-diff stgit-diff-base
+                   "--base"
+                   "diff against the merge base")
+(stgit-define-diff stgit-diff-combined
+                   "--cc"
+                   "show a combined diff")
+
+(defun stgit-move-change-to-index (file &optional force)
+  "Copies the work tree state of FILE to index, using git add or git rm.
+
+If FORCE is not nil, use --force."

   (let ((op (if (or (file-exists-p file) (file-symlink-p file))
                 '("add") '("rm" "-q"))))
     (stgit-capture-output "*git output*"
   (let ((op (if (or (file-exists-p file) (file-symlink-p file))
                 '("add") '("rm" "-q"))))
     (stgit-capture-output "*git output*"

-      (apply 'stgit-run-git (append op '("--") (list file))))))
+      (apply 'stgit-run-git (append op (and force '("--force"))
+                                    '("--") (list file))))))

 
 (defun stgit-remove-change-from-index (file)
   "Unstages the change in FILE from the index"
 
 (defun stgit-remove-change-from-index (file)
   "Unstages the change in FILE from the index"


@@ -896,25 +1360,43 @@ If PATCHSYM is a keyword, returns PATCHSYM unmodified."
     (stgit-run-git "reset" "-q" "--" file)))
 
 (defun stgit-file-toggle-index ()
     (stgit-run-git "reset" "-q" "--" file)))
 
 (defun stgit-file-toggle-index ()

-  "Move modified file in or out of the index."
+  "Move modified file in or out of the index.
+
+Leaves the point where it is, but moves the mark to where the
+file ended up. You can then jump to the file with \
+\\[exchange-point-and-mark]."

   (interactive)
   (interactive)

-  (let ((patched-file (stgit-patched-file-at-point)))
-    (unless patched-file
-      (error "No file on the current line"))
-    (let ((patch-name (stgit-patch-name-at-point)))
+  (let* ((patched-file   (or (stgit-patched-file-at-point)
+                            (error "No file on the current line")))
+        (patched-status (stgit-file-status patched-file)))
+    (when (eq patched-status 'unmerged)
+      (error (substitute-command-keys "Use \\[stgit-resolve-file] to move an unmerged file to the index")))
+    (let* ((patch      (stgit-patch-at-point))
+           (patch-name (stgit-patch-name patch))
+           (mark-file  (if (eq patched-status 'rename)
+                          (stgit-file-cr-to patched-file)
+                        (stgit-file-file patched-file)))
+           (point-file  (if (eq patched-status 'rename)
+                          (stgit-file-cr-from patched-file)
+                        (stgit-neighbour-file))))
+

       (cond ((eq patch-name :work)
       (cond ((eq patch-name :work)

-             (stgit-move-change-to-index (stgit-file-file patched-file)))
+             (stgit-move-change-to-index (stgit-file-file patched-file)
+                                         (eq patched-status 'ignore)))

             ((eq patch-name :index)
              (stgit-remove-change-from-index (stgit-file-file patched-file)))
             (t
             ((eq patch-name :index)
              (stgit-remove-change-from-index (stgit-file-file patched-file)))
             (t

-             (error "Can only move files in the working tree to index")))))
-  (stgit-refresh-worktree)
-  (stgit-refresh-index))
+             (error "Can only move files between working tree and index")))
+      (stgit-refresh-worktree)
+      (stgit-refresh-index)
+      (stgit-goto-patch (if (eq patch-name :index) :work :index) mark-file)
+      (push-mark nil t t)
+      (stgit-goto-patch patch-name point-file))))

 
 (defun stgit-edit ()
   "Edit the patch on the current line."
   (interactive)
 
 (defun stgit-edit ()
   "Edit the patch on the current line."
   (interactive)

-  (let ((patchsym (stgit-patch-name-at-point t))
+  (let ((patchsym (stgit-patch-name-at-point t t))

         (edit-buf (get-buffer-create "*StGit edit*"))
         (dir default-directory))
     (log-edit 'stgit-confirm-edit t nil edit-buf)
         (edit-buf (get-buffer-create "*StGit edit*"))
         (dir default-directory))
     (log-edit 'stgit-confirm-edit t nil edit-buf)


@@ -984,6 +1466,11 @@ the work tree and index."
                      current-prefix-arg))
   (unless patchsyms
     (error "No patches to delete"))
                      current-prefix-arg))
   (unless patchsyms
     (error "No patches to delete"))

+  (when (memq :index patchsyms)
+    (error "Cannot delete the index"))
+  (when (memq :work  patchsyms)
+    (error "Cannot delete the work tree"))
+

   (let ((npatches (length patchsyms)))
     (when (yes-or-no-p (format "Really delete %d patch%s%s? "
                               npatches
   (let ((npatches (length patchsyms)))
     (when (yes-or-no-p (format "Really delete %d patch%s%s? "
                               npatches


@@ -1005,7 +1492,7 @@ the work tree and index."
 This is either the patch at point, or one of :top and :bottom, if
 the point is after or before the applied patches."
 
 This is either the patch at point, or one of :top and :bottom, if
 the point is after or before the applied patches."
 

-  (let ((patchsym (stgit-patch-name-at-point)))
+  (let ((patchsym (stgit-patch-name-at-point nil t)))

     (cond (patchsym patchsym)
          ((save-excursion (re-search-backward "^>" nil t)) :top)
          (t :bottom))))
     (cond (patchsym patchsym)
          ((save-excursion (re-search-backward "^>" nil t)) :top)
          (t :bottom))))


@@ -1014,7 +1501,7 @@ the point is after or before the applied patches."
   "Returns the list of patches in PATCHSYMS sorted according to
 their position in the patch series, bottommost first.
 
   "Returns the list of patches in PATCHSYMS sorted according to
 their position in the patch series, bottommost first.
 

-PATCHSYMS may not contain duplicate entries."
+PATCHSYMS must not contain duplicate entries."

   (let (sorted-patchsyms
         (series (with-output-to-string
                   (with-current-buffer standard-output
   (let (sorted-patchsyms
         (series (with-output-to-string
                   (with-current-buffer standard-output


@@ -1117,7 +1604,9 @@ deepest patch had before the squash."
 
 (defun stgit-undo (&optional arg)
   "Run stg undo.
 
 (defun stgit-undo (&optional arg)
   "Run stg undo.

-With prefix argument, run it with the --hard flag."
+With prefix argument, run it with the --hard flag.
+
+See also `stgit-redo'."

   (interactive "P")
   (stgit-capture-output nil
     (if arg
   (interactive "P")
   (stgit-capture-output nil
     (if arg


@@ -1125,8 +1614,22 @@ With prefix argument, run it with the --hard flag."
       (stgit-run "undo")))
   (stgit-reload))
 
       (stgit-run "undo")))
   (stgit-reload))
 

+(defun stgit-redo (&optional arg)
+  "Run stg redo.
+With prefix argument, run it with the --hard flag.
+
+See also `stgit-undo'."
+  (interactive "P")
+  (stgit-capture-output nil
+    (if arg
+        (stgit-run "redo" "--hard")
+      (stgit-run "redo")))
+  (stgit-reload))
+

 (defun stgit-refresh (&optional arg)
   "Run stg refresh.
 (defun stgit-refresh (&optional arg)
   "Run stg refresh.

+If the index contains any changes, only refresh from index.
+

 With prefix argument, refresh the marked patch or the patch under point."
   (interactive "P")
   (let ((patchargs (if arg
 With prefix argument, refresh the marked patch or the patch under point."
   (interactive "P")
   (let ((patchargs (if arg


@@ -1138,29 +1641,32 @@ With prefix argument, refresh the marked patch or the patch under point."
                                (t
                                 (cons "-p" patches))))
                      nil)))
                                (t
                                 (cons "-p" patches))))
                      nil)))

+    (unless (stgit-index-empty-p)
+      (setq patchargs (cons "--index" patchargs)))

     (stgit-capture-output nil
       (apply 'stgit-run "refresh" patchargs))
     (stgit-refresh-git-status))
   (stgit-reload))
 
     (stgit-capture-output nil
       (apply 'stgit-run "refresh" patchargs))
     (stgit-refresh-git-status))
   (stgit-reload))
 

-(defcustom stgit-default-show-worktree
-  nil
-  "Set to non-nil to by default show the working tree in a new stgit buffer.
+(defvar stgit-show-worktree nil
+  "If nil, inhibit showing work tree and index in the stgit buffer.

 
 

-This value is used as the default value for `stgit-show-worktree'."
-  :type 'boolean
-  :group 'stgit)
+See also `stgit-show-worktree-mode'.")

 
 

-(defvar stgit-show-worktree nil
-  "Show work tree and index in the stgit buffer.
+(defvar stgit-show-ignored nil
+  "If nil, inhibit showing files ignored by git.")

 
 

-See `stgit-default-show-worktree' for its default value.")
+(defvar stgit-show-unknown nil
+  "If nil, inhibit showing files not registered with git.")

 
 (defun stgit-toggle-worktree (&optional arg)
   "Toggle the visibility of the work tree.
 
 (defun stgit-toggle-worktree (&optional arg)
   "Toggle the visibility of the work tree.

-With arg, show the work tree if arg is positive.
+With ARG, show the work tree if ARG is positive.
+
+Its initial setting is controlled by `stgit-default-show-worktree'.

 
 

-Its initial setting is controlled by `stgit-default-show-worktree'."
+`stgit-show-worktree-mode' controls where on screen the index and
+work tree will show up."

   (interactive)
   (setq stgit-show-worktree
         (if (numberp arg)
   (interactive)
   (setq stgit-show-worktree
         (if (numberp arg)


@@ -1168,4 +1674,28 @@ Its initial setting is controlled by `stgit-default-show-worktree'."
           (not stgit-show-worktree)))
   (stgit-reload))
 
           (not stgit-show-worktree)))
   (stgit-reload))
 

+(defun stgit-toggle-ignored (&optional arg)
+  "Toggle the visibility of files ignored by git in the work
+tree. With ARG, show these files if ARG is positive.
+
+Use \\[stgit-toggle-worktree] to show the work tree."
+  (interactive)
+  (setq stgit-show-ignored
+        (if (numberp arg)
+            (> arg 0)
+          (not stgit-show-ignored)))
+  (stgit-reload))
+
+(defun stgit-toggle-unknown (&optional arg)
+  "Toggle the visibility of files not registered with git in the
+work tree. With ARG, show these files if ARG is positive.
+
+Use \\[stgit-toggle-worktree] to show the work tree."
+  (interactive)
+  (setq stgit-show-unknown
+        (if (numberp arg)
+            (> arg 0)
+          (not stgit-show-unknown)))
+  (stgit-reload))
+

 (provide 'stgit)
 (provide 'stgit)