[stgit] / contrib / stgit.el

;; stgit.el: An emacs mode for StGit
;;
;; Copyright (C) 2007 David Kågedal <davidk@lysator.liu.se>
;;
;; To install: put this file on the load-path and place the following
;; in your .emacs file:
;;
;;    (require 'stgit)
;;
;; To start: `M-x stgit'

(defun stgit (dir)
  "Manage stgit patches"
  (interactive "DDirectory: \n")
  (switch-to-stgit-buffer dir)
  (stgit-refresh))

(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 ((buffers (buffer-list)))
    (while (and buffers
                (not (with-current-buffer (car 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)))))

(defun create-stgit-buffer (dir)
  "Create a buffer for showing StGit patches.
Argument DIR is the repository path."
  (let ((buf (create-file-buffer (concat dir "*stgit*")))
        (inhibit-read-only t))
    (with-current-buffer buf
      (setq default-directory dir)
      (stgit-mode)
      (setq buffer-read-only t))
    buf))

(defmacro stgit-capture-output (name &rest body)
  "Capture StGit output and show it in a window at the end"
  `(let ((output-buf (get-buffer-create ,(or name "*StGit output*")))
         (stgit-dir default-directory)
         (inhibit-read-only t))
     (with-current-buffer output-buf
       (erase-buffer)
       (setq default-directory stgit-dir)
       (setq buffer-read-only t))
     (let ((standard-output output-buf))
       ,@body)
     (with-current-buffer output-buf
       (set-buffer-modified-p nil)
       (setq buffer-read-only t)
       (if (< (point-min) (point-max))
           (display-buffer output-buf t)))))
(put 'stgit-capture-output 'lisp-indent-function 1)

(defun stgit-run (&rest args)
  (apply 'call-process "stg" nil standard-output nil args))

(defun stgit-refresh ()
  "Update the contents of the stgit buffer"
  (interactive)
  (let ((inhibit-read-only t)
        (curline (line-number-at-pos))
        (curpatch (stgit-patch-at-point)))
    (erase-buffer)
    (insert "Branch: ")
    (stgit-run "branch")
    (stgit-run "series" "--description")
    (stgit-rescan)
    (if curpatch
        (stgit-goto-patch curpatch)
      (goto-line curline))))

(defface stgit-description-face
  '((((background dark)) (:foreground "tan"))
    (((background light)) (:foreground "dark red")))
  "The face used for StGit desriptions")

(defface stgit-top-patch-face
  '((((background dark)) (:weight bold :foreground "yellow"))
    (((background light)) (:weight bold :foreground "purple"))
    (t (:weight bold)))
  "The face used for the top patch names")

(defface stgit-applied-patch-face
  '((((background dark)) (:foreground "light yellow"))
    (((background light)) (:foreground "purple"))
    (t ()))
  "The face used for applied patch names")

(defface stgit-unapplied-patch-face
  '((((background dark)) (:foreground "gray80"))
    (((background light)) (:foreground "orchid"))
    (t ()))
  "The face used for unapplied patch names")

(defun stgit-rescan ()
  "Rescan the status buffer."
  (save-excursion
    (let ((marked ()))
      (goto-char (point-min))
      (while (not (eobp))
        (cond ((looking-at "Branch: \\(.*\\)")
               (put-text-property (match-beginning 1) (match-end 1)
                                  'face 'bold))
              ((looking-at "\\([>+-]\\)\\( \\)\\([^ ]+\\) *| \\(.*\\)")
               (let ((state (match-string 1))
                     (patchsym (intern (match-string 3))))
                 (put-text-property
                  (match-beginning 3) (match-end 3) 'face
                  (cond ((string= state ">") 'stgit-top-patch-face)
                        ((string= state "+") 'stgit-applied-patch-face)
                        ((string= state "-") 'stgit-unapplied-patch-face)))
                 (put-text-property (match-beginning 4) (match-end 4)
                                    'face 'stgit-description-face)
                 (when (memq patchsym stgit-marked-patches)
                   (replace-match "*" nil nil nil 2)
                   (setq marked (cons patchsym marked))))))
        (forward-line 1))
      (setq stgit-marked-patches (nreverse marked)))))

(defvar stgit-mode-hook nil
  "Run after `stgit-mode' is setup.")

(defvar stgit-mode-map nil
  "Keymap for StGit major mode.")

(unless stgit-mode-map
  (setq stgit-mode-map (make-keymap))
  (suppress-keymap stgit-mode-map)
  (define-key stgit-mode-map " "   'stgit-mark)
  (define-key stgit-mode-map "\d" 'stgit-unmark)
  (define-key stgit-mode-map "?"   'stgit-help)
  (define-key stgit-mode-map "h"   'stgit-help)
  (define-key stgit-mode-map "p"   'previous-line)
  (define-key stgit-mode-map "n"   'next-line)
  (define-key stgit-mode-map "g"   'stgit-refresh)
  (define-key stgit-mode-map "r"   'stgit-rename)
  (define-key stgit-mode-map "e"   'stgit-edit)
  (define-key stgit-mode-map "N"   'stgit-new)
  (define-key stgit-mode-map "\C-r"   'stgit-repair)
  (define-key stgit-mode-map "C"   'stgit-commit)
  (define-key stgit-mode-map "U"   'stgit-uncommit)
  (define-key stgit-mode-map ">"   'stgit-push-next)
  (define-key stgit-mode-map "<"   'stgit-pop-next)
  (define-key stgit-mode-map "P"   'stgit-push-or-pop)
  (define-key stgit-mode-map "G"   'stgit-goto)
  (define-key stgit-mode-map "="   'stgit-show))

(defun stgit-mode ()
  "Major mode for interacting with StGit.
Commands:
\\{stgit-mode-map}"
  (kill-all-local-variables)
  (buffer-disable-undo)
  (setq mode-name "StGit"
        major-mode 'stgit-mode
        goal-column 2)
  (use-local-map stgit-mode-map)
  (set (make-local-variable 'list-buffers-directory) default-directory)
  (set (make-local-variable 'stgit-marked-patches) nil)
  (set-variable 'truncate-lines 't)
  (run-hooks 'stgit-mode-hook))

(defun stgit-add-mark (patch)
  (let ((patchsym (intern patch)))
    (setq stgit-marked-patches (cons patchsym stgit-marked-patches))))

(defun stgit-remove-mark (patch)
  (let ((patchsym (intern patch)))
    (setq stgit-marked-patches (delq patchsym stgit-marked-patches))))

(defun stgit-marked-patches ()
  "Return the names of the marked patches."
  (mapcar 'symbol-name stgit-marked-patches))

(defun stgit-patch-at-point ()
  "Return the patch name on the current line"
  (save-excursion
    (beginning-of-line)
    (if (looking-at "[>+-][ *]\\([^ ]*\\)")
        (match-string-no-properties 1)
      nil)))

(defun stgit-goto-patch (patch)
  "Move point to the line containing PATCH"
  (let ((p (point)))
    (goto-char (point-min))
    (if (re-search-forward (concat "^[>+-][ *]" (regexp-quote patch) " ") nil t)
        (progn (move-to-column goal-column)
               t)
      (goto-char p)
      nil)))

(defun stgit-mark ()
  "Mark the patch under point"
  (interactive)
  (let ((patch (stgit-patch-at-point)))
    (stgit-add-mark patch)
    (stgit-refresh))
  (next-line))

(defun stgit-unmark ()
  "Mark the patch on the previous line"
  (interactive)
  (forward-line -1)
  (let ((patch (stgit-patch-at-point)))
    (stgit-remove-mark patch)
    (stgit-refresh)))

(defun stgit-rename (name)
  "Rename the patch under point"
  (interactive (list (read-string "Patch name: " (stgit-patch-at-point))))
  (let ((old-name (stgit-patch-at-point)))
    (unless old-name
      (error "No patch on this line"))
    (stgit-capture-output nil
      (stgit-run "rename" old-name name))
    (stgit-refresh)
    (stgit-goto-patch name)))

(defun stgit-repair ()
  "Run stg repair"
  (interactive)
  (stgit-capture-output nil
   (stgit-run "repair"))
  (stgit-refresh))

(defun stgit-commit ()
  "Run stg commit."
  (interactive)
  (stgit-capture-output nil (stgit-run "commit"))
  (stgit-refresh))

(defun stgit-uncommit (arg)
  "Run stg uncommit. Numeric arg determines number of patches to uncommit."
  (interactive "p")
  (stgit-capture-output nil (stgit-run "uncommit" "-n" (number-to-string arg)))
  (stgit-refresh))

(defun stgit-push-next ()
  "Push the first unapplied patch"
  (interactive)
  (stgit-capture-output nil (stgit-run "push"))
  (stgit-refresh))

(defun stgit-pop-next ()
  "Pop the topmost applied patch"
  (interactive)
  (stgit-capture-output nil (stgit-run "pop"))
  (stgit-refresh))

(defun stgit-applied-at-point ()
  "Is the patch on the current line applied?"
  (save-excursion
    (beginning-of-line)
    (looking-at "[>+]")))

(defun stgit-push-or-pop ()
  "Push or pop the patch on the current line"
  (interactive)
  (let ((patch (stgit-patch-at-point))
        (applied (stgit-applied-at-point)))
    (stgit-capture-output nil
       (stgit-run (if applied "pop" "push") patch))
    (stgit-refresh)))

(defun stgit-goto ()
  "Go to the patch on the current line"
  (interactive)
  (let ((patch (stgit-patch-at-point)))
    (stgit-capture-output nil
       (stgit-run "goto" patch))
    (stgit-refresh)))

(defun stgit-show ()
  "Show the patch on the current line"
  (interactive)
  (stgit-capture-output "*StGit patch*"
    (stgit-run "show" (stgit-patch-at-point))
    (with-current-buffer standard-output
      (goto-char (point-min))
      (diff-mode))))

(defun stgit-edit ()
  "Edit the patch on the current line"
  (interactive)
  (let ((patch (if (stgit-applied-at-point)
                   (stgit-patch-at-point)
                 (error "This patch is not applied")))
        (edit-buf (get-buffer-create "*stgit edit*"))
        (dir default-directory))
    (log-edit 'stgit-confirm-edit t nil edit-buf)
    (set (make-local-variable 'stgit-edit-patch) patch)
    (setq default-directory dir)
    (let ((standard-output edit-buf))
      (stgit-run "edit" "--save-template=-" patch))))

(defun stgit-confirm-edit ()
  (interactive)
  (let ((file (make-temp-file "stgit-edit-")))
    (write-region (point-min) (point-max) file)
    (stgit-capture-output nil
      (stgit-run "edit" "-f" file stgit-edit-patch))
    (with-current-buffer log-edit-parent-buffer
      (stgit-refresh))))

(defun stgit-new ()
  "Create a new patch"
  (interactive)
  (let ((edit-buf (get-buffer-create "*stgit edit*")))
    (log-edit 'stgit-confirm-new t nil edit-buf)))

(defun stgit-confirm-new ()
  (interactive)
  (let ((file (make-temp-file "stgit-edit-"))
        (patch (stgit-create-patch-name
                (buffer-substring (point-min)
                                  (save-excursion (goto-char (point-min))
                                                  (end-of-line)
                                                  (point))))))
    (write-region (point-min) (point-max) file)
    (stgit-capture-output nil
      (stgit-run "new" "-m" "placeholder" patch)
      (stgit-run "edit" "-f" file patch))
    (with-current-buffer log-edit-parent-buffer
      (stgit-refresh))))

(defun stgit-create-patch-name (description)
  "Create a patch name from a long description"
  (let ((patch ""))
    (while (> (length description) 0)
      (cond ((string-match "\\`[a-zA-Z_-]+" description)
             (setq patch (downcase (concat patch (match-string 0 description))))
             (setq description (substring description (match-end 0))))
            ((string-match "\\` +" description)
             (setq patch (concat patch "-"))
             (setq description (substring description (match-end 0))))
            ((string-match "\\`[^a-zA-Z_-]+" description)
             (setq description (substring description (match-end 0))))))
    (cond ((= (length patch) 0)
           "patch")
          ((> (length patch) 20)
           (substring patch 0 20))
          (t patch))))

(defun stgit-help ()
  "Display help for the StGit mode."
  (interactive)
  (describe-function 'stgit-mode))

(provide 'stgit)
Commit	Line	Data
3a59f3db KH	1	;; stgit.el: An emacs mode for StGit
	2	;;
	3	;; Copyright (C) 2007 David Kågedal <davidk@lysator.liu.se>
	4	;;
	5	;; To install: put this file on the load-path and place the following
	6	;; in your .emacs file:
	7	;;
	8	;; (require 'stgit)
	9	;;
	10	;; To start: `M-x stgit'
	11
56d81fe5 DK	12	(defun stgit (dir)
	13	"Manage stgit patches"
	14	(interactive "DDirectory: \n")
	15	(switch-to-stgit-buffer dir)
	16	(stgit-refresh))
	17
	18	(defun switch-to-stgit-buffer (dir)
	19	"Switch to a (possibly new) buffer displaying StGit patches for DIR"
	20	(setq dir (file-name-as-directory dir))
	21	(let ((buffers (buffer-list)))
	22	(while (and buffers
	23	(not (with-current-buffer (car buffers)
	24	(and (eq major-mode 'stgit-mode)
	25	(string= default-directory dir)))))
	26	(setq buffers (cdr buffers)))
	27	(switch-to-buffer (if buffers
	28	(car buffers)
	29	(create-stgit-buffer dir)))))
	30
	31	(defun create-stgit-buffer (dir)
	32	"Create a buffer for showing StGit patches.
	33	Argument DIR is the repository path."
	34	(let ((buf (create-file-buffer (concat dir "stgit")))
	35	(inhibit-read-only t))
	36	(with-current-buffer buf
	37	(setq default-directory dir)
	38	(stgit-mode)
	39	(setq buffer-read-only t))
	40	buf))
	41
	42	(defmacro stgit-capture-output (name &rest body)
	43	"Capture StGit output and show it in a window at the end"
34afb86c DK	44	`(let ((output-buf (get-buffer-create ,(or name "StGit output")))
	45	(stgit-dir default-directory)
	46	(inhibit-read-only t))
56d81fe5	47	(with-current-buffer output-buf
34afb86c DK	48	(erase-buffer)
	49	(setq default-directory stgit-dir)
	50	(setq buffer-read-only t))
56d81fe5 DK	51	(let ((standard-output output-buf))
56d81fe5 DK	52	,@body)
34afb86c DK	53	(with-current-buffer output-buf
	54	(set-buffer-modified-p nil)
	55	(setq buffer-read-only t)
	56	(if (< (point-min) (point-max))
	57	(display-buffer output-buf t)))))
56d81fe5 DK	58	(put 'stgit-capture-output 'lisp-indent-function 1)
	59
	60	(defun stgit-run (&rest args)
	61	(apply 'call-process "stg" nil standard-output nil args))
	62
	63	(defun stgit-refresh ()
	64	"Update the contents of the stgit buffer"
	65	(interactive)
	66	(let ((inhibit-read-only t)
	67	(curline (line-number-at-pos))
	68	(curpatch (stgit-patch-at-point)))
	69	(erase-buffer)
	70	(insert "Branch: ")
	71	(stgit-run "branch")
2870f8b8	72	(stgit-run "series" "--description")
6df83d42	73	(stgit-rescan)
56d81fe5 DK	74	(if curpatch
	75	(stgit-goto-patch curpatch)
	76	(goto-line curline))))
	77
07f464e0 DK	78	(defface stgit-description-face
	79	'((((background dark)) (:foreground "tan"))
	80	(((background light)) (:foreground "dark red")))
	81	"The face used for StGit desriptions")
	82
	83	(defface stgit-top-patch-face
	84	'((((background dark)) (:weight bold :foreground "yellow"))
	85	(((background light)) (:weight bold :foreground "purple"))
	86	(t (:weight bold)))
	87	"The face used for the top patch names")
	88
	89	(defface stgit-applied-patch-face
	90	'((((background dark)) (:foreground "light yellow"))
	91	(((background light)) (:foreground "purple"))
	92	(t ()))
	93	"The face used for applied patch names")
	94
	95	(defface stgit-unapplied-patch-face
	96	'((((background dark)) (:foreground "gray80"))
	97	(((background light)) (:foreground "orchid"))
	98	(t ()))
	99	"The face used for unapplied patch names")
	100
6df83d42 DK	101	(defun stgit-rescan ()
6df83d42 DK	102	"Rescan the status buffer."
07f464e0	103	(save-excursion
6df83d42 DK	104	(let ((marked ()))
	105	(goto-char (point-min))
	106	(while (not (eobp))
	107	(cond ((looking-at "Branch: \\(.*\\)")
	108	(put-text-property (match-beginning 1) (match-end 1)
	109	'face 'bold))
	110	((looking-at "\\([>+-]\\)\\( \\)\\([^ ]+\\) \| \\(.\\)")
	111	(let ((state (match-string 1))
	112	(patchsym (intern (match-string 3))))
	113	(put-text-property
	114	(match-beginning 3) (match-end 3) 'face
	115	(cond ((string= state ">") 'stgit-top-patch-face)
	116	((string= state "+") 'stgit-applied-patch-face)
	117	((string= state "-") 'stgit-unapplied-patch-face)))
	118	(put-text-property (match-beginning 4) (match-end 4)
	119	'face 'stgit-description-face)
	120	(when (memq patchsym stgit-marked-patches)
	121	(replace-match "*" nil nil nil 2)
	122	(setq marked (cons patchsym marked))))))
	123	(forward-line 1))
	124	(setq stgit-marked-patches (nreverse marked)))))
07f464e0	125
56d81fe5 DK	126	(defvar stgit-mode-hook nil
	127	"Run after `stgit-mode' is setup.")
	128
	129	(defvar stgit-mode-map nil
	130	"Keymap for StGit major mode.")
	131
	132	(unless stgit-mode-map
	133	(setq stgit-mode-map (make-keymap))
	134	(suppress-keymap stgit-mode-map)
6df83d42 DK	135	(define-key stgit-mode-map " " 'stgit-mark)
6df83d42 DK	136	(define-key stgit-mode-map "\d" 'stgit-unmark)
0663524d KH	137	(define-key stgit-mode-map "?" 'stgit-help)
0663524d KH	138	(define-key stgit-mode-map "h" 'stgit-help)
9a3bb1f1 DK	139	(define-key stgit-mode-map "p" 'previous-line)
9a3bb1f1 DK	140	(define-key stgit-mode-map "n" 'next-line)
56d81fe5 DK	141	(define-key stgit-mode-map "g" 'stgit-refresh)
56d81fe5 DK	142	(define-key stgit-mode-map "r" 'stgit-rename)
0bca35c8	143	(define-key stgit-mode-map "e" 'stgit-edit)
64c097a0	144	(define-key stgit-mode-map "N" 'stgit-new)
26201d96	145	(define-key stgit-mode-map "\C-r" 'stgit-repair)
c4aad9a7 DK	146	(define-key stgit-mode-map "C" 'stgit-commit)
c4aad9a7 DK	147	(define-key stgit-mode-map "U" 'stgit-uncommit)
56d81fe5	148	(define-key stgit-mode-map ">" 'stgit-push-next)
82a12e6e	149	(define-key stgit-mode-map "<" 'stgit-pop-next)
f9182fca	150	(define-key stgit-mode-map "P" 'stgit-push-or-pop)
c7adf5ef	151	(define-key stgit-mode-map "G" 'stgit-goto)
56d81fe5 DK	152	(define-key stgit-mode-map "=" 'stgit-show))
	153
	154	(defun stgit-mode ()
	155	"Major mode for interacting with StGit.
	156	Commands:
	157	\\{stgit-mode-map}"
	158	(kill-all-local-variables)
	159	(buffer-disable-undo)
	160	(setq mode-name "StGit"
	161	major-mode 'stgit-mode
	162	goal-column 2)
	163	(use-local-map stgit-mode-map)
	164	(set (make-local-variable 'list-buffers-directory) default-directory)
6df83d42	165	(set (make-local-variable 'stgit-marked-patches) nil)
2870f8b8	166	(set-variable 'truncate-lines 't)
56d81fe5 DK	167	(run-hooks 'stgit-mode-hook))
56d81fe5 DK	168
6df83d42 DK	169	(defun stgit-add-mark (patch)
	170	(let ((patchsym (intern patch)))
	171	(setq stgit-marked-patches (cons patchsym stgit-marked-patches))))
	172
	173	(defun stgit-remove-mark (patch)
	174	(let ((patchsym (intern patch)))
	175	(setq stgit-marked-patches (delq patchsym stgit-marked-patches))))
	176
	177	(defun stgit-marked-patches ()
	178	"Return the names of the marked patches."
	179	(mapcar 'symbol-name stgit-marked-patches))
	180
56d81fe5 DK	181	(defun stgit-patch-at-point ()
	182	"Return the patch name on the current line"
	183	(save-excursion
	184	(beginning-of-line)
6df83d42	185	(if (looking-at "[>+-][ ]\\([^ ]\\)")
07f464e0	186	(match-string-no-properties 1)
56d81fe5 DK	187	nil)))
	188
	189	(defun stgit-goto-patch (patch)
	190	"Move point to the line containing PATCH"
	191	(let ((p (point)))
	192	(goto-char (point-min))
6df83d42	193	(if (re-search-forward (concat "^[>+-][ *]" (regexp-quote patch) " ") nil t)
56d81fe5 DK	194	(progn (move-to-column goal-column)
	195	t)
	196	(goto-char p)
	197	nil)))
	198
6df83d42 DK	199	(defun stgit-mark ()
	200	"Mark the patch under point"
	201	(interactive)
	202	(let ((patch (stgit-patch-at-point)))
	203	(stgit-add-mark patch)
	204	(stgit-refresh))
	205	(next-line))
	206
	207	(defun stgit-unmark ()
	208	"Mark the patch on the previous line"
	209	(interactive)
	210	(forward-line -1)
	211	(let ((patch (stgit-patch-at-point)))
	212	(stgit-remove-mark patch)
	213	(stgit-refresh)))
	214
56d81fe5 DK	215	(defun stgit-rename (name)
	216	"Rename the patch under point"
	217	(interactive (list (read-string "Patch name: " (stgit-patch-at-point))))
	218	(let ((old-name (stgit-patch-at-point)))
	219	(unless old-name
	220	(error "No patch on this line"))
	221	(stgit-capture-output nil
	222	(stgit-run "rename" old-name name))
	223	(stgit-refresh)
	224	(stgit-goto-patch name)))
	225
26201d96 DK	226	(defun stgit-repair ()
	227	"Run stg repair"
	228	(interactive)
	229	(stgit-capture-output nil
	230	(stgit-run "repair"))
	231	(stgit-refresh))
	232
c4aad9a7 DK	233	(defun stgit-commit ()
	234	"Run stg commit."
	235	(interactive)
	236	(stgit-capture-output nil (stgit-run "commit"))
	237	(stgit-refresh))
	238
	239	(defun stgit-uncommit (arg)
	240	"Run stg uncommit. Numeric arg determines number of patches to uncommit."
	241	(interactive "p")
	242	(stgit-capture-output nil (stgit-run "uncommit" "-n" (number-to-string arg)))
	243	(stgit-refresh))
	244
56d81fe5	245	(defun stgit-push-next ()
82a12e6e	246	"Push the first unapplied patch"
56d81fe5	247	(interactive)
82a12e6e KH	248	(stgit-capture-output nil (stgit-run "push"))
82a12e6e KH	249	(stgit-refresh))
56d81fe5	250
82a12e6e KH	251	(defun stgit-pop-next ()
82a12e6e KH	252	"Pop the topmost applied patch"
56d81fe5	253	(interactive)
82a12e6e KH	254	(stgit-capture-output nil (stgit-run "pop"))
82a12e6e KH	255	(stgit-refresh))
56d81fe5	256
f9182fca KH	257	(defun stgit-applied-at-point ()
	258	"Is the patch on the current line applied?"
	259	(save-excursion
	260	(beginning-of-line)
	261	(looking-at "[>+]")))
	262
	263	(defun stgit-push-or-pop ()
	264	"Push or pop the patch on the current line"
	265	(interactive)
	266	(let ((patch (stgit-patch-at-point))
	267	(applied (stgit-applied-at-point)))
	268	(stgit-capture-output nil
	269	(stgit-run (if applied "pop" "push") patch))
	270	(stgit-refresh)))
	271
c7adf5ef KH	272	(defun stgit-goto ()
	273	"Go to the patch on the current line"
	274	(interactive)
	275	(let ((patch (stgit-patch-at-point)))
	276	(stgit-capture-output nil
	277	(stgit-run "goto" patch))
	278	(stgit-refresh)))
	279
56d81fe5 DK	280	(defun stgit-show ()
	281	"Show the patch on the current line"
	282	(interactive)
	283	(stgit-capture-output "StGit patch"
	284	(stgit-run "show" (stgit-patch-at-point))
	285	(with-current-buffer standard-output
	286	(goto-char (point-min))
	287	(diff-mode))))
0663524d	288
0bca35c8 DK	289	(defun stgit-edit ()
	290	"Edit the patch on the current line"
	291	(interactive)
	292	(let ((patch (if (stgit-applied-at-point)
	293	(stgit-patch-at-point)
	294	(error "This patch is not applied")))
	295	(edit-buf (get-buffer-create "stgit edit"))
	296	(dir default-directory))
	297	(log-edit 'stgit-confirm-edit t nil edit-buf)
	298	(set (make-local-variable 'stgit-edit-patch) patch)
	299	(setq default-directory dir)
	300	(let ((standard-output edit-buf))
	301	(stgit-run "edit" "--save-template=-" patch))))
	302
	303	(defun stgit-confirm-edit ()
	304	(interactive)
	305	(let ((file (make-temp-file "stgit-edit-")))
	306	(write-region (point-min) (point-max) file)
	307	(stgit-capture-output nil
	308	(stgit-run "edit" "-f" file stgit-edit-patch))
	309	(with-current-buffer log-edit-parent-buffer
	310	(stgit-refresh))))
	311
64c097a0 DK	312	(defun stgit-new ()
	313	"Create a new patch"
	314	(interactive)
	315	(let ((edit-buf (get-buffer-create "stgit edit")))
	316	(log-edit 'stgit-confirm-new t nil edit-buf)))
	317
	318	(defun stgit-confirm-new ()
	319	(interactive)
	320	(let ((file (make-temp-file "stgit-edit-"))
	321	(patch (stgit-create-patch-name
	322	(buffer-substring (point-min)
	323	(save-excursion (goto-char (point-min))
	324	(end-of-line)
	325	(point))))))
	326	(write-region (point-min) (point-max) file)
	327	(stgit-capture-output nil
	328	(stgit-run "new" "-m" "placeholder" patch)
	329	(stgit-run "edit" "-f" file patch))
	330	(with-current-buffer log-edit-parent-buffer
	331	(stgit-refresh))))
	332
	333	(defun stgit-create-patch-name (description)
	334	"Create a patch name from a long description"
	335	(let ((patch ""))
	336	(while (> (length description) 0)
	337	(cond ((string-match "\\`[a-zA-Z_-]+" description)
	338	(setq patch (downcase (concat patch (match-string 0 description))))
	339	(setq description (substring description (match-end 0))))
	340	((string-match "\\` +" description)
	341	(setq patch (concat patch "-"))
	342	(setq description (substring description (match-end 0))))
	343	((string-match "\\`[^a-zA-Z_-]+" description)
	344	(setq description (substring description (match-end 0))))))
	345	(cond ((= (length patch) 0)
	346	"patch")
	347	((> (length patch) 20)
	348	(substring patch 0 20))
	349	(t patch))))
0bca35c8	350
0663524d KH	351	(defun stgit-help ()
	352	"Display help for the StGit mode."
	353	(interactive)
	354	(describe-function 'stgit-mode))
3a59f3db KH	355
3a59f3db KH	356	(provide 'stgit)