Merge branch 'js/reverse'
[git] / contrib / emacs / git-blame.el
1 ;;; git-blame.el --- Minor mode for incremental blame for Git  -*- coding: utf-8 -*-
2 ;;
3 ;; Copyright (C) 2007  David Kågedal
4 ;;
5 ;; Authors:    David Kågedal <davidk@lysator.liu.se>
6 ;; Created:    31 Jan 2007
7 ;; Message-ID: <87iren2vqx.fsf@morpheus.local>
8 ;; License:    GPL
9 ;; Keywords:   git, version control, release management
10 ;;
11 ;; Compatibility: Emacs21
12
13
14 ;; This file is *NOT* part of GNU Emacs.
15 ;; This file is distributed under the same terms as GNU Emacs.
16
17 ;; This program is free software; you can redistribute it and/or
18 ;; modify it under the terms of the GNU General Public License as
19 ;; published by the Free Software Foundation; either version 2 of
20 ;; the License, or (at your option) any later version.
21
22 ;; This program is distributed in the hope that it will be
23 ;; useful, but WITHOUT ANY WARRANTY; without even the implied
24 ;; warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
25 ;; PURPOSE.  See the GNU General Public License for more details.
26
27 ;; You should have received a copy of the GNU General Public
28 ;; License along with this program; if not, write to the Free
29 ;; Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
30 ;; MA 02111-1307 USA
31
32 ;; http://www.fsf.org/copyleft/gpl.html
33
34
35 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
36 ;;
37 ;;; Commentary:
38 ;;
39 ;; Here is an Emacs implementation of incremental git-blame.  When you
40 ;; turn it on while viewing a file, the editor buffer will be updated by
41 ;; setting the background of individual lines to a color that reflects
42 ;; which commit it comes from.  And when you move around the buffer, a
43 ;; one-line summary will be shown in the echo area.
44
45 ;;; Installation:
46 ;;
47 ;; To use this package, put it somewhere in `load-path' (or add
48 ;; directory with git-blame.el to `load-path'), and add the following
49 ;; line to your .emacs:
50 ;;
51 ;;    (require 'git-blame)
52 ;;
53 ;; If you do not want to load this package before it is necessary, you
54 ;; can make use of the `autoload' feature, e.g. by adding to your .emacs
55 ;; the following lines
56 ;;
57 ;;    (autoload 'git-blame-mode "git-blame"
58 ;;              "Minor mode for incremental blame for Git." t)
59 ;;
60 ;; Then first use of `M-x git-blame-mode' would load the package.
61
62 ;;; Compatibility:
63 ;;
64 ;; It requires GNU Emacs 21.  If you'are using Emacs 20, try
65 ;; changing this:
66 ;;
67 ;;            (overlay-put ovl 'face (list :background
68 ;;                                         (cdr (assq 'color (cddddr info)))))
69 ;;
70 ;; to
71 ;;
72 ;;            (overlay-put ovl 'face (cons 'background-color
73 ;;                                         (cdr (assq 'color (cddddr info)))))
74
75
76 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
77 ;;
78 ;;; Code:
79
80 (require 'cl)                         ; to use `push', `pop'
81
82 (defun color-scale (l)
83   (let* ((colors ())
84          r g b)
85     (setq r l)
86     (while r
87       (setq g l)
88       (while g
89         (setq b l)
90         (while b
91           (push (concat "#" (car r) (car g) (car b)) colors)
92           (pop b))
93         (pop g))
94       (pop r))
95     colors))
96
97 (defvar git-blame-dark-colors
98   (color-scale '("0c" "04" "24" "1c" "2c" "34" "14" "3c")))
99
100 (defvar git-blame-light-colors
101   (color-scale '("c4" "d4" "cc" "dc" "f4" "e4" "fc" "ec")))
102
103 (defvar git-blame-ancient-color "dark green")
104
105 (defvar git-blame-autoupdate t
106   "*Automatically update the blame display while editing")
107
108 (defvar git-blame-proc nil
109   "The running git-blame process")
110 (make-variable-buffer-local 'git-blame-proc)
111
112 (defvar git-blame-overlays nil
113   "The git-blame overlays used in the current buffer.")
114 (make-variable-buffer-local 'git-blame-overlays)
115
116 (defvar git-blame-cache nil
117   "A cache of git-blame information for the current buffer")
118 (make-variable-buffer-local 'git-blame-cache)
119
120 (defvar git-blame-idle-timer nil
121   "An idle timer that updates the blame")
122 (make-variable-buffer-local 'git-blame-cache)
123
124 (defvar git-blame-update-queue nil
125   "A queue of update requests")
126 (make-variable-buffer-local 'git-blame-update-queue)
127
128 (defvar git-blame-mode nil)
129 (make-variable-buffer-local 'git-blame-mode)
130 (unless (assq 'git-blame-mode minor-mode-alist)
131   (setq minor-mode-alist
132         (cons (list 'git-blame-mode " blame")
133               minor-mode-alist)))
134
135 ;;;###autoload
136 (defun git-blame-mode (&optional arg)
137   "Minor mode for displaying Git blame"
138   (interactive "P")
139   (if arg
140       (setq git-blame-mode (eq arg 1))
141     (setq git-blame-mode (not git-blame-mode)))
142   (make-local-variable 'git-blame-colors)
143   (if git-blame-autoupdate
144       (add-hook 'after-change-functions 'git-blame-after-change nil t)
145     (remove-hook 'after-change-functions 'git-blame-after-change t))
146   (git-blame-cleanup)
147   (if git-blame-mode
148       (progn
149         (let ((bgmode (cdr (assoc 'background-mode (frame-parameters)))))
150           (if (eq bgmode 'dark)
151               (setq git-blame-colors git-blame-dark-colors)
152             (setq git-blame-colors git-blame-light-colors)))
153         (setq git-blame-cache (make-hash-table :test 'equal))
154         (git-blame-run))
155     (cancel-timer git-blame-idle-timer)))
156
157 ;;;###autoload
158 (defun git-reblame ()
159   "Recalculate all blame information in the current buffer"
160   (unless git-blame-mode
161     (error "git-blame is not active"))
162   (interactive)
163   (git-blame-cleanup)
164   (git-blame-run))
165
166 (defun git-blame-run (&optional startline endline)
167   (if git-blame-proc
168       ;; Should maybe queue up a new run here
169       (message "Already running git blame")
170     (let ((display-buf (current-buffer))
171           (blame-buf (get-buffer-create
172                       (concat " git blame for " (buffer-name))))
173           (args '("--incremental" "--contents" "-")))
174       (if startline
175           (setq args (append args
176                              (list "-L" (format "%d,%d" startline endline)))))
177       (setq args (append args
178                          (list (file-name-nondirectory buffer-file-name))))
179       (setq git-blame-proc
180             (apply 'start-process
181                    "git-blame" blame-buf
182                    "git" "blame"
183                    args))
184       (with-current-buffer blame-buf
185         (erase-buffer)
186         (make-local-variable 'git-blame-file)
187         (make-local-variable 'git-blame-current)
188         (setq git-blame-file display-buf)
189         (setq git-blame-current nil))
190       (set-process-filter git-blame-proc 'git-blame-filter)
191       (set-process-sentinel git-blame-proc 'git-blame-sentinel)
192       (process-send-region git-blame-proc (point-min) (point-max))
193       (process-send-eof git-blame-proc))))
194
195 (defun remove-git-blame-text-properties (start end)
196   (let ((modified (buffer-modified-p))
197         (inhibit-read-only t))
198     (remove-text-properties start end '(point-entered nil))
199     (set-buffer-modified-p modified)))
200
201 (defun git-blame-cleanup ()
202   "Remove all blame properties"
203     (mapcar 'delete-overlay git-blame-overlays)
204     (setq git-blame-overlays nil)
205     (remove-git-blame-text-properties (point-min) (point-max)))
206
207 (defun git-blame-update-region (start end)
208   "Rerun blame to get updates between START and END"
209   (let ((overlays (overlays-in start end)))
210     (while overlays
211       (let ((overlay (pop overlays)))
212         (if (< (overlay-start overlay) start)
213             (setq start (overlay-start overlay)))
214         (if (> (overlay-end overlay) end)
215             (setq end (overlay-end overlay)))
216         (setq git-blame-overlays (delete overlay git-blame-overlays))
217         (delete-overlay overlay))))
218   (remove-git-blame-text-properties start end)
219   ;; We can be sure that start and end are at line breaks
220   (git-blame-run (1+ (count-lines (point-min) start))
221                  (count-lines (point-min) end)))
222
223 (defun git-blame-sentinel (proc status)
224   (with-current-buffer (process-buffer proc)
225     (with-current-buffer git-blame-file
226       (setq git-blame-proc nil)
227       (if git-blame-update-queue
228           (git-blame-delayed-update))))
229   ;;(kill-buffer (process-buffer proc))
230   ;;(message "git blame finished")
231   )
232
233 (defvar in-blame-filter nil)
234
235 (defun git-blame-filter (proc str)
236   (save-excursion
237     (set-buffer (process-buffer proc))
238     (goto-char (process-mark proc))
239     (insert-before-markers str)
240     (goto-char 0)
241     (unless in-blame-filter
242       (let ((more t)
243             (in-blame-filter t))
244         (while more
245           (setq more (git-blame-parse)))))))
246
247 (defun git-blame-parse ()
248   (cond ((looking-at "\\([0-9a-f]\\{40\\}\\) \\([0-9]+\\) \\([0-9]+\\) \\([0-9]+\\)\n")
249          (let ((hash (match-string 1))
250                (src-line (string-to-number (match-string 2)))
251                (res-line (string-to-number (match-string 3)))
252                (num-lines (string-to-number (match-string 4))))
253            (setq git-blame-current
254                  (if (string= hash "0000000000000000000000000000000000000000")
255                      nil
256                    (git-blame-new-commit
257                     hash src-line res-line num-lines))))
258          (delete-region (point) (match-end 0))
259          t)
260         ((looking-at "filename \\(.+\\)\n")
261          (let ((filename (match-string 1)))
262            (git-blame-add-info "filename" filename))
263          (delete-region (point) (match-end 0))
264          t)
265         ((looking-at "\\([a-z-]+\\) \\(.+\\)\n")
266          (let ((key (match-string 1))
267                (value (match-string 2)))
268            (git-blame-add-info key value))
269          (delete-region (point) (match-end 0))
270          t)
271         ((looking-at "boundary\n")
272          (setq git-blame-current nil)
273          (delete-region (point) (match-end 0))
274          t)
275         (t
276          nil)))
277
278
279 (defun git-blame-new-commit (hash src-line res-line num-lines)
280   (save-excursion
281     (set-buffer git-blame-file)
282     (let ((info (gethash hash git-blame-cache))
283           (inhibit-point-motion-hooks t)
284           (inhibit-modification-hooks t))
285       (when (not info)
286         (let ((color (pop git-blame-colors)))
287           (unless color
288             (setq color git-blame-ancient-color))
289           (setq info (list hash src-line res-line num-lines
290                            (git-describe-commit hash)
291                            (cons 'color color))))
292         (puthash hash info git-blame-cache))
293       (goto-line res-line)
294       (while (> num-lines 0)
295         (if (get-text-property (point) 'git-blame)
296             (forward-line)
297           (let* ((start (point))
298                  (end (progn (forward-line 1) (point)))
299                  (ovl (make-overlay start end)))
300             (push ovl git-blame-overlays)
301             (overlay-put ovl 'git-blame info)
302             (overlay-put ovl 'help-echo hash)
303             (overlay-put ovl 'face (list :background
304                                          (cdr (assq 'color (nthcdr 5 info)))))
305             ;; the point-entered property doesn't seem to work in overlays
306             ;;(overlay-put ovl 'point-entered
307             ;;             `(lambda (x y) (git-blame-identify ,hash)))
308             (let ((modified (buffer-modified-p)))
309               (put-text-property (if (= start 1) start (1- start)) (1- end)
310                                  'point-entered
311                                  `(lambda (x y) (git-blame-identify ,hash)))
312               (set-buffer-modified-p modified))))
313         (setq num-lines (1- num-lines))))))
314
315 (defun git-blame-add-info (key value)
316   (if git-blame-current
317       (nconc git-blame-current (list (cons (intern key) value)))))
318
319 (defun git-blame-current-commit ()
320   (let ((info (get-char-property (point) 'git-blame)))
321     (if info
322         (car info)
323       (error "No commit info"))))
324
325 (defun git-describe-commit (hash)
326   (with-temp-buffer
327     (call-process "git" nil t nil
328                   "log" "-1" "--pretty=oneline"
329                   hash)
330     (buffer-substring (point-min) (1- (point-max)))))
331
332 (defvar git-blame-last-identification nil)
333 (make-variable-buffer-local 'git-blame-last-identification)
334 (defun git-blame-identify (&optional hash)
335   (interactive)
336   (let ((info (gethash (or hash (git-blame-current-commit)) git-blame-cache)))
337     (when (and info (not (eq info git-blame-last-identification)))
338       (message "%s" (nth 4 info))
339       (setq git-blame-last-identification info))))
340
341 ;; (defun git-blame-after-save ()
342 ;;   (when git-blame-mode
343 ;;     (git-blame-cleanup)
344 ;;     (git-blame-run)))
345 ;; (add-hook 'after-save-hook 'git-blame-after-save)
346
347 (defun git-blame-after-change (start end length)
348   (when git-blame-mode
349     (git-blame-enq-update start end)))
350
351 (defvar git-blame-last-update nil)
352 (make-variable-buffer-local 'git-blame-last-update)
353 (defun git-blame-enq-update (start end)
354   "Mark the region between START and END as needing blame update"
355   ;; Try to be smart and avoid multiple callouts for sequential
356   ;; editing
357   (cond ((and git-blame-last-update
358               (= start (cdr git-blame-last-update)))
359          (setcdr git-blame-last-update end))
360         ((and git-blame-last-update
361               (= end (car git-blame-last-update)))
362          (setcar git-blame-last-update start))
363         (t
364          (setq git-blame-last-update (cons start end))
365          (setq git-blame-update-queue (nconc git-blame-update-queue
366                                              (list git-blame-last-update)))))
367   (unless (or git-blame-proc git-blame-idle-timer)
368     (setq git-blame-idle-timer
369           (run-with-idle-timer 0.5 nil 'git-blame-delayed-update))))
370
371 (defun git-blame-delayed-update ()
372   (setq git-blame-idle-timer nil)
373   (if git-blame-update-queue
374       (let ((first (pop git-blame-update-queue))
375             (inhibit-point-motion-hooks t))
376         (git-blame-update-region (car first) (cdr first)))))
377
378 (provide 'git-blame)
379
380 ;;; git-blame.el ends here