stgit.el: Add "t i/u" for showing files ignored by or unknown to git

[stgit] / contrib / stgit.el

diff --git a/contrib/stgit.el b/contrib/stgit.el
index 0c39286..f629593 100644 (file)
--- a/contrib/stgit.el
+++ b/contrib/stgit.el
@@ -42,8 +42,8 @@ directory DIR or `default-directory'"
         (with-current-buffer git-status-buffer
           (git-refresh-status))))))
 
         (with-current-buffer git-status-buffer
           (git-refresh-status))))))
 

-(defun switch-to-stgit-buffer (dir)
-  "Switch to a (possibly new) buffer displaying StGit patches for DIR."
+(defun stgit-find-buffer (dir)
+  "Return the buffer displaying StGit patches for DIR, or nil if none."

   (setq dir (file-name-as-directory dir))
   (let ((buffers (buffer-list)))
     (while (and buffers
   (setq dir (file-name-as-directory dir))
   (let ((buffers (buffer-list)))
     (while (and buffers


@@ -51,32 +51,40 @@ directory DIR or `default-directory'"
                        (and (eq major-mode 'stgit-mode)
                             (string= default-directory dir)))))
       (setq buffers (cdr buffers)))
                        (and (eq major-mode 'stgit-mode)
                             (string= default-directory dir)))))
       (setq buffers (cdr buffers)))

-    (switch-to-buffer (if buffers
-                          (car buffers)
-                        (create-stgit-buffer dir)))))
+    (and buffers (car buffers))))
+
+(defun switch-to-stgit-buffer (dir)
+  "Switch to a (possibly new) buffer displaying StGit patches for DIR."
+  (setq dir (file-name-as-directory dir))
+  (let ((buffer (stgit-find-buffer dir)))
+    (switch-to-buffer (or buffer
+                         (create-stgit-buffer dir)))))
+

 (defstruct (stgit-patch)
   status name desc empty files-ewoc)
 
 (defun stgit-patch-pp (patch)
 (defstruct (stgit-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)))
+  (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 "-")
     (insert (case status
               ('applied "+")
               ('top ">")
               ('unapplied "-")

-              (t "·"))
+              (t " "))

             (if (memq name stgit-marked-patches)
             (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)))
-            "  "
-            (if (stgit-patch-empty patch) "(empty) " "")
-            (propertize (or (stgit-patch-desc patch) "")
-                        'face 'stgit-description-face))
+                "*" " "))
+    (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))
+              "  "
+              (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))


@@ -91,7 +99,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))
 


@@ -149,15 +157,51 @@ Returns nil if there was no output."
   (setq args (stgit-make-run-args args))
   (apply 'call-process "git" nil standard-output nil args))
 
   (setq args (stgit-make-run-args args))
   (apply 'call-process "git" nil standard-output nil args))
 

+(defun stgit-index-empty-p ()
+  "Returns non-nil if the index contains no changes from HEAD."
+  (zerop (stgit-run-git-silent "diff-index" "--cached" "--quiet" "HEAD")))
+
+(defvar stgit-index-node)
+(defvar stgit-worktree-node)
+
+(defun stgit-refresh-index ()
+  (when stgit-index-node
+    (ewoc-invalidate (car stgit-index-node) (cdr stgit-index-node))))
+
+(defun stgit-refresh-worktree ()
+  (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
       (let ((exit-status (stgit-run-silent "series" "--description" "--empty")))
         (goto-char (point-min))
         (if (not (zerop exit-status))
             (cond ((looking-at "stg series: \\(.*\\)")
     (with-temp-buffer
       (let ((exit-status (stgit-run-silent "series" "--description" "--empty")))
         (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))))


@@ -168,16 +212,30 @@ 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)))))))
-
+                                :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."
 
 (defun stgit-reload ()
   "Update the contents of the StGit buffer."


@@ -192,9 +250,14 @@ Returns nil if there was no output."
                           (with-temp-buffer
                             (stgit-run-silent "branch")
                             (buffer-substring (point-min) (1- (point-max))))
                           (with-temp-buffer
                             (stgit-run-silent "branch")
                             (buffer-substring (point-min) (1- (point-max))))

-                          'face 'bold)
-                         "\n")
-                 "--")
+                          'face 'stgit-branch-name-face)
+                         "\n\n")
+                 (if stgit-show-worktree
+                     "--"
+                   (propertize
+                    (substitute-command-keys "--\n\"\\[stgit-toggle-worktree]\"\
+ shows the working tree\n")
+                   'face 'stgit-description-face)))

     (stgit-run-series stgit-ewoc)
     (if curpatch
         (stgit-goto-patch curpatch)
     (stgit-run-series stgit-ewoc)
     (if curpatch
         (stgit-goto-patch curpatch)


@@ -211,6 +274,11 @@ Returns nil if there was no output."
   "The face used for StGit descriptions"
   :group 'stgit)
 
   "The face used for StGit descriptions"
   :group 'stgit)
 

+(defface stgit-branch-name-face
+  '((t :inherit bold))
+  "The face used for the StGit branch name"
+  :group 'stgit)
+

 (defface stgit-top-patch-face
   '((((background dark)) (:weight bold :foreground "yellow"))
     (((background light)) (:weight bold :foreground "purple"))
 (defface stgit-top-patch-face
   '((((background dark)) (:weight bold :foreground "yellow"))
     (((background light)) (:weight bold :foreground "purple"))


@@ -250,12 +318,24 @@ 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)
 

+(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)
+
+

 (defcustom stgit-expand-find-copies-harder
   nil
   "Try harder to find copied files when listing patches.
 (defcustom stgit-expand-find-copies-harder
   nil
   "Try harder to find copied files when listing patches.


@@ -276,9 +356,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)


@@ -297,6 +386,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)


@@ -389,24 +479,52 @@ 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-expand-find-copies-harder' flag."
+  (if stgit-expand-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)
 (defun stgit-insert-patch-files (patch)

-  "Expand (show modification of) the patch with name PATCHSYM (a
-symbol) after the line at point.
-`stgit-expand-find-copies-harder' controls how hard to try to
-find copied files."
-  (insert "\n")
+  "Expand (show modification of) the patch PATCH after the line
+at point."

   (let* ((patchsym (stgit-patch-name patch))
   (let* ((patchsym (stgit-patch-name patch))

-         (end (progn (insert "#") (prog1 (point-marker) (forward-char -1))))
-         (args (list "-r" "-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 "diff-tree"
-             (append args (list (stgit-id patchsym))))
+      (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)))))
+
+      (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))
       (goto-char (point-min))

-      (forward-char 41)
+      (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)))
       (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)))


@@ -414,15 +532,21 @@ find copied files."
           (let ((file
                  (cond ((looking-at
                          "\\([CR]\\)\\([0-9]*\\)\0\\([^\0]*\\)\0\\([^\0]*\\)\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)))
+                        (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
                        ((looking-at "\\([ABD-QS-Z]\\)\0\\([^\0]*\\)\0")
                         (make-stgit-file
                          :old-perm       old-perm


@@ -431,15 +555,18 @@ find copied files."
                          :cr-score       nil
                          :cr-from        nil
                          :cr-to          nil
                          :cr-score       nil
                          :cr-from        nil
                          :cr-to          nil

-                         :status         (stgit-file-status-code (match-string 1))
+                         :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)
                          :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)))
+        (ewoc-set-hf ewoc ""
+                     (concat "    "
+                             (propertize "<no files>"
+                                         'face 'stgit-description-face)
+                             "\n"))))
+    (goto-char end)))

 
 (defun stgit-select-file ()
   (let ((filename (expand-file-name
 
 (defun stgit-select-file ()
   (let ((filename (expand-file-name


@@ -457,7 +584,10 @@ find copied files."
   (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
   (interactive)
   (case (get-text-property (point) 'entry-type)
     ('patch


@@ -531,46 +661,55 @@ find copied files."
   "Keymap for StGit major mode.")
 
 (unless stgit-mode-map
   "Keymap for StGit major mode.")
 
 (unless stgit-mode-map

-  (setq stgit-mode-map (make-keymap))
-  (suppress-keymap stgit-mode-map)
-  (mapc (lambda (arg) (define-key stgit-mode-map (car arg) (cdr arg)))
-        '((" " .        stgit-mark)
-          ("m" .        stgit-mark)
-          ("\d" .       stgit-unmark-up)
-          ("u" .        stgit-unmark-down)
-          ("?" .        stgit-help)
-          ("h" .        stgit-help)
-          ("\C-p" .     stgit-previous-line)
-          ("\C-n" .     stgit-next-line)
-          ([up] .       stgit-previous-line)
-          ([down] .     stgit-next-line)
-          ("p" .        stgit-previous-patch)
-          ("n" .        stgit-next-patch)
-          ("\M-{" .     stgit-previous-patch)
-          ("\M-}" .     stgit-next-patch)
-          ("s" .        stgit-git-status)
-          ("g" .        stgit-reload)
-          ("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)
-          ("\r" .       stgit-select)
-          ("o" .        stgit-find-file-other-window)
-          (">" .        stgit-push-next)
-          ("<" .        stgit-pop-next)
-          ("P" .        stgit-push-or-pop)
-          ("G" .        stgit-goto)
-          ("=" .        stgit-show)
-          ("D" .        stgit-delete)
-          ([(control ?/)] . stgit-undo)
-          ("\C-_" .     stgit-undo)
-          ("B" .        stgit-branch)
-          ("q" .        stgit-quit))))
+  (let ((toggle-map (make-keymap)))
+    (suppress-keymap toggle-map)
+    (mapc (lambda (arg) (define-key toggle-map (car arg) (cdr arg)))
+          '(("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)))
+          `((" " .        stgit-mark)
+            ("m" .        stgit-mark)
+            ("\d" .       stgit-unmark-up)
+            ("u" .        stgit-unmark-down)
+            ("?" .        stgit-help)
+            ("h" .        stgit-help)
+            ("\C-p" .     stgit-previous-line)
+            ("\C-n" .     stgit-next-line)
+            ([up] .       stgit-previous-line)
+            ([down] .     stgit-next-line)
+            ("p" .        stgit-previous-patch)
+            ("n" .        stgit-next-patch)
+            ("\M-{" .     stgit-previous-patch)
+            ("\M-}" .     stgit-next-patch)
+            ("s" .        stgit-git-status)
+            ("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)
+            ("\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)
+            (">" .        stgit-push-next)
+            ("<" .        stgit-pop-next)
+            ("P" .        stgit-push-or-pop)
+            ("G" .        stgit-goto)
+            ("=" .        stgit-show)
+            ("D" .        stgit-delete)
+            ([(control ?/)] . stgit-undo)
+            ("\C-_" .     stgit-undo)
+            ("B" .        stgit-branch)
+            ("t" .        ,toggle-map)
+            ("q" .        stgit-quit)))))

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


@@ -584,10 +723,24 @@ 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-variable 'truncate-lines 't)
   (set-variable 'truncate-lines 't)

+  (add-hook 'after-save-hook 'stgit-update-saved-file)

   (run-hooks 'stgit-mode-hook))
 
   (run-hooks 'stgit-mode-hook))
 

+(defun stgit-update-saved-file ()
+  (let* ((file (expand-file-name buffer-file-name))
+         (dir (file-name-directory file))
+         (gitdir (condition-case nil (git-get-top-dir dir)
+                   (error nil)))
+        (buffer (and gitdir (stgit-find-buffer gitdir))))
+    (when buffer
+      (with-current-buffer buffer
+        (stgit-refresh-worktree)))))
+

 (defun stgit-add-mark (patchsym)
   "Mark the patch PATCHSYM."
   (setq stgit-marked-patches (cons patchsym stgit-marked-patches)))
 (defun stgit-add-mark (patchsym)
   "Mark the patch PATCHSYM."
   (setq stgit-marked-patches (cons patchsym stgit-marked-patches)))


@@ -603,10 +756,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


@@ -646,7 +805,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))


@@ -672,9 +836,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)))


@@ -687,6 +852,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)


@@ -719,6 +894,62 @@ Interactively, the prefix argument is used as COUNT."
   (stgit-capture-output nil (stgit-run "commit" "-n" count))
   (stgit-reload))
 
   (stgit-capture-output nil (stgit-run "commit" "-n" count))
   (stgit-reload))
 

+(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)))))
+
+    (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)))))
+
+(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-uncommit (count)
   "Run stg uncommit on COUNT commits.
 Interactively, the prefix argument is used as COUNT."
 (defun stgit-uncommit (count)
   "Run stg uncommit on COUNT commits.
 Interactively, the prefix argument is used as COUNT."


@@ -786,10 +1017,13 @@ If PATCHSYM is a keyword, returns PATCHSYM unmodified."
               (patch-name (stgit-patch-name-at-point))
               (patch-id (stgit-id patch-name))
               (args (append (and (stgit-file-cr-from patched-file)
               (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")))
-                            (list (concat patch-id "^") patch-id)
+                                 (list (stgit-find-copies-harder-diff-arg)))
+                            (cond ((eq patch-id :index)
+                                   '("--cached"))
+                                  ((eq patch-id :work)
+                                   nil)
+                                  (t
+                                   (list (concat patch-id "^") patch-id)))

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


@@ -797,18 +1031,57 @@ If PATCHSYM is a keyword, returns PATCHSYM unmodified."
                                 (list (stgit-file-file patched-file))))))
          (apply 'stgit-run-git "diff" args)))
       ('patch
                                 (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)))
+       (let* ((patch-name (stgit-patch-name-at-point))
+              (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)
+                    (and (eq patch-id :index)
+                         '("--cached")))
+           (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))))
 
       (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"
+  (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))))))
+
+(defun stgit-remove-change-from-index (file)
+  "Unstages the change in FILE from the index"
+  (stgit-capture-output "*git output*"
+    (stgit-run-git "reset" "-q" "--" file)))
+
+(defun stgit-file-toggle-index ()
+  "Move modified file in or out of the index."
+  (interactive)
+  (let ((patched-file (stgit-patched-file-at-point)))
+    (unless patched-file
+      (error "No file on the current line"))
+    (when (eq (stgit-file-status patched-file) 'unmerged)
+      (error (substitute-command-keys "Use \\[stgit-resolve-file] to move an unmerged file to the index")))
+    (when (eq (stgit-file-status patched-file) 'ignore)
+      (error "You cannot add ignored files to the index"))
+    (let ((patch-name (stgit-patch-name-at-point)))
+      (cond ((eq patch-name :work)
+             (stgit-move-change-to-index (stgit-file-file patched-file)))
+            ((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))
+

 (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)


@@ -878,6 +1151,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


@@ -1021,6 +1299,8 @@ With prefix argument, run it with the --hard flag."
 
 (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


@@ -1032,9 +1312,83 @@ 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-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).
+
+See also `stgit-show-worktree'."
+  :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)
+
+(defcustom stgit-default-show-worktree
+  nil
+  "Set to non-nil to by default show the working tree in a new stgit buffer.
+
+This value is used as the default value for `stgit-show-worktree'."
+  :type 'boolean
+  :group 'stgit)
+
+(defvar stgit-show-worktree nil
+  "If nil, inhibit showing work tree and index in the stgit buffer.
+
+See also `stgit-show-worktree-mode'.")
+
+(defvar stgit-show-ignored nil
+  "If nil, inhibit showing files ignored by git.")
+
+(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.
+With arg, show the work tree if arg is positive.
+
+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)
+            (> arg 0)
+          (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)