mirror of https://github.com/Chizi123/.emacs.d.git

Chizi123
2018-11-21 5ddac8bd2392ec5b64392e8750d725029bf5aa79
commit | author | age
5cb5f7 1 ;;; magit-blame.el --- blame support for Magit  -*- lexical-binding: t -*-
C 2
3 ;; Copyright (C) 2012-2018  The Magit Project Contributors
4 ;;
5 ;; You should have received a copy of the AUTHORS.md file which
6 ;; lists all contributors.  If not, see http://magit.vc/authors.
7
8 ;; Author: Jonas Bernoulli <jonas@bernoul.li>
9 ;; Maintainer: Jonas Bernoulli <jonas@bernoul.li>
10
11 ;; Magit is free software; you can redistribute it and/or modify it
12 ;; under the terms of the GNU General Public License as published by
13 ;; the Free Software Foundation; either version 3, or (at your option)
14 ;; any later version.
15 ;;
16 ;; Magit is distributed in the hope that it will be useful, but WITHOUT
17 ;; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
18 ;; or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
19 ;; License for more details.
20 ;;
21 ;; You should have received a copy of the GNU General Public License
22 ;; along with Magit.  If not, see http://www.gnu.org/licenses.
23
24 ;;; Commentary:
25
26 ;; Annotates each line in file-visiting buffer with information from
27 ;; the revision which last modified the line.
28
29 ;;; Code:
30
31 (eval-when-compile
32   (require 'subr-x))
33
34 (require 'magit)
35
36 ;;; Options
37
38 (defgroup magit-blame nil
39   "Blame support for Magit."
40   :link '(info-link "(magit)Blaming")
41   :group 'magit-modes)
42
43 (defcustom magit-blame-styles
44   '((headings
45      (heading-format   . "%-20a %C %s\n"))
46     (margin
47      (margin-format    . (" %s%f" " %C %a" " %H"))
48      (margin-width     . 42)
49      (margin-face      . magit-blame-margin)
50      (margin-body-face . (magit-blame-dimmed)))
51     (highlight
52      (highlight-face   . magit-blame-highlight))
53     (lines
54      (show-lines       . t)))
55   "List of styles used to visualize blame information.
56
57 Each entry has the form (IDENT (KEY . VALUE)...).  IDENT has
58 to be a symbol uniquely identifing the style.  The following
59 KEYs are recognized:
60
61  `show-lines'
62     Whether to prefix each chunk of lines with a thin line.
63     This has no effect if `heading-format' is non-nil.
64  `highlight-face'
65     Face used to highlight the first line of each chunk.
66     If this is nil, then those lines are not highlighted.
67  `heading-format'
68     String specifing the information to be shown above each
69     chunk of lines.  It must end with a newline character.
70  `margin-format'
71     String specifing the information to be shown in the left
72     buffer margin.  It must NOT end with a newline character.
73     This can also be a list of formats used for the lines at
74     the same positions within the chunk.  If the chunk has
75     more lines than formats are specified, then the last is
76     repeated.
77  `margin-width'
78     Width of the margin, provided `margin-format' is non-nil.
79  `margin-face'
80     Face used in the margin, provided `margin-format' is
81     non-nil.  This face is used in combination with the faces
82     that are specific to the used %-specs.  If this is nil,
83     then `magit-blame-margin' is used.
84  `margin-body-face'
85     Face used in the margin for all but first line of a chunk.
86     This face is used in combination with the faces that are
87     specific to the used %-specs.  This can also be a list of
88     faces (usually one face), in which case only these faces
89     are used and the %-spec faces are ignored.  A good value
90     might be `(magit-blame-dimmed)'.  If this is nil, then
91     the same face as for the first line is used.
92
93 The following %-specs can be used in `heading-format' and
94 `margin-format':
95
96   %H    hash              using face `magit-blame-hash'
97   %s    summary           using face `magit-blame-summary'
98   %a    author            using face `magit-blame-name'
99   %A    author time       using face `magit-blame-date'
100   %c    committer         using face `magit-blame-name'
101   %C    committer time    using face `magit-blame-date'
102
103 Additionally if `margin-format' ends with %f, then the string
104 that is displayed in the margin is made at least `margin-width'
105 characters wide, which may be desirable if the used face sets
106 the background color.
107
108 The style used in the current buffer can be cycled from the blame
109 popup.  Blame commands (except `magit-blame-echo') use the first
110 style as the initial style when beginning to blame in a buffer."
111   :package-version '(magit . "2.13.0")
112   :group 'magit-blame
113   :type 'string)
114
115 (defcustom magit-blame-echo-style 'lines
116   "The blame visualization style used by `magit-blame-echo'.
117 A symbol that has to be used as the identifier for one of the
118 styles defined in `magit-blame-styles'."
119   :package-version '(magit . "2.13.0")
120   :group 'magit-blame
121   :type 'symbol)
122
123 (defcustom magit-blame-time-format "%F %H:%M"
124   "Format for time strings in blame headings."
125   :group 'magit-blame
126   :type 'string)
127
128 (defcustom magit-blame-read-only t
129   "Whether to initially make the blamed buffer read-only."
130   :package-version '(magit . "2.13.0")
131   :group 'magit-blame
132   :type 'boolean)
133
134 (defcustom magit-blame-disable-modes '(fci-mode yascroll-bar-mode)
135   "List of modes not compatible with Magit-Blame mode.
136 This modes are turned off when Magit-Blame mode is turned on,
137 and then turned on again when turning off the latter."
138   :group 'magit-blame
139   :type '(repeat (symbol :tag "Mode")))
140
141 (defcustom magit-blame-mode-lighter " Blame"
142   "The mode-line lighter of the Magit-Blame mode."
143   :group 'magit-blame
144   :type '(choice (const :tag "No lighter" "") string))
145
146 (defcustom magit-blame-goto-chunk-hook
147   '(magit-blame-maybe-update-revision-buffer
148     magit-blame-maybe-show-message)
149   "Hook run after point entered another chunk."
150   :package-version '(magit . "2.13.0")
151   :group 'magit-blame
152   :type 'hook
153   :get 'magit-hook-custom-get
154   :options '(magit-blame-maybe-update-revision-buffer
155              magit-blame-maybe-show-message))
156
157 ;;; Faces
158
159 (defface magit-blame-highlight
160   '((((class color) (background light))
161      :background "grey80"
162      :foreground "black")
163     (((class color) (background dark))
164      :background "grey25"
165      :foreground "white"))
166   "Face used for highlighting when blaming.
167 Also see option `magit-blame-styles'."
168   :group 'magit-faces)
169
170 (defface magit-blame-margin
171   '((t :inherit magit-blame-highlight
172        :weight normal
173        :slant normal))
174   "Face used for the blame margin by default when blaming.
175 Also see option `magit-blame-styles'."
176   :group 'magit-faces)
177
178 (defface magit-blame-dimmed
179   '((t :inherit magit-dimmed
180        :weight normal
181        :slant normal))
182   "Face used for the blame margin in some cases when blaming.
183 Also see option `magit-blame-styles'."
184   :group 'magit-faces)
185
186 (defface magit-blame-heading
187   '((t :inherit magit-blame-highlight
188        :weight normal
189        :slant normal))
190   "Face used for blame headings by default when blaming.
191 Also see option `magit-blame-styles'."
192   :group 'magit-faces)
193
194 (defface magit-blame-summary nil
195   "Face used for commit summaries when blaming."
196   :group 'magit-faces)
197
198 (defface magit-blame-hash nil
199   "Face used for commit hashes when blaming."
200   :group 'magit-faces)
201
202 (defface magit-blame-name nil
203   "Face used for author and committer names when blaming."
204   :group 'magit-faces)
205
206 (defface magit-blame-date nil
207   "Face used for dates when blaming."
208   :group 'magit-faces)
209
210 ;;; Chunks
211
212 (defclass magit-blame-chunk ()
213   (;; <orig-rev> <orig-line> <final-line> <num-lines>
214    (orig-rev   :initarg :orig-rev)
215    (orig-line  :initarg :orig-line)
216    (final-line :initarg :final-line)
217    (num-lines  :initarg :num-lines)
218    ;; previous <prev-rev> <prev-file>
219    (prev-rev   :initform nil)
220    (prev-file  :initform nil)
221    ;; filename <orig-file>
222    (orig-file)))
223
224 (defun magit-current-blame-chunk (&optional type)
225   (or (and (not (and type (not (eq type magit-blame-type))))
226            (magit-blame-chunk-at (point)))
227       (and type
228            (let ((rev  (or magit-buffer-refname magit-buffer-revision))
229                  (file (magit-file-relative-name nil (not magit-buffer-file-name)))
230                  (line (format "%i,+1" (line-number-at-pos))))
231              (unless file
232                (error "Buffer does not visit a tracked file"))
233              (with-temp-buffer
234                (magit-with-toplevel
235                  (magit-git-insert
236                   "blame" "--porcelain"
237                   (if (memq magit-blame-type '(final removal))
238                       (cons "--reverse" (magit-blame-arguments))
239                     (magit-blame-arguments))
240                   "-L" line rev "--" file)
241                  (goto-char (point-min))
242                  (car (magit-blame--parse-chunk type))))))))
243
244 (defun magit-blame-chunk-at (pos)
245   (--some (overlay-get it 'magit-blame-chunk)
246           (overlays-at pos)))
247
248 (defun magit-blame--overlay-at (&optional pos key)
249   (unless pos
250     (setq pos (point)))
251   (--first (overlay-get it (or key 'magit-blame-chunk))
252            (nconc (overlays-at pos)
253                   (overlays-in pos pos))))
254
255 ;;; Keymaps
256
257 (defvar magit-blame-mode-map
258   (let ((map (make-sparse-keymap)))
259     (define-key map (kbd "C-c C-q") 'magit-blame-quit)
260     map)
261   "Keymap for `magit-blame-mode'.
262 Note that most blaming key bindings are defined
263 in `magit-blame-read-only-mode-map' instead.")
264
265 (defvar magit-blame-read-only-mode-map
266   (let ((map (make-sparse-keymap)))
267     (cond ((featurep 'jkl)
268            (define-key map [return]    'magit-show-commit)
269            (define-key map (kbd   "i") 'magit-blame-previous-chunk)
270            (define-key map (kbd   "I") 'magit-blame-previous-chunk-same-commit)
271            (define-key map (kbd   "k") 'magit-blame-next-chunk)
272            (define-key map (kbd   "K") 'magit-blame-next-chunk-same-commit)
273            (define-key map (kbd   "j") 'magit-blame-addition)
274            (define-key map (kbd   "l") 'magit-blame-removal)
275            (define-key map (kbd   "f") 'magit-blame-reverse)
276            (define-key map (kbd   "b") 'magit-blame-popup))
277           (t
278            (define-key map (kbd "C-m") 'magit-show-commit)
279            (define-key map (kbd   "p") 'magit-blame-previous-chunk)
280            (define-key map (kbd   "P") 'magit-blame-previous-chunk-same-commit)
281            (define-key map (kbd   "n") 'magit-blame-next-chunk)
282            (define-key map (kbd   "N") 'magit-blame-next-chunk-same-commit)
283            (define-key map (kbd   "b") 'magit-blame-addition)
284            (define-key map (kbd   "r") 'magit-blame-removal)
285            (define-key map (kbd   "f") 'magit-blame-reverse)
286            (define-key map (kbd   "B") 'magit-blame-popup)))
287     (define-key map (kbd   "c") 'magit-blame-cycle-style)
288     (define-key map (kbd   "q") 'magit-blame-quit)
289     (define-key map (kbd "M-w") 'magit-blame-copy-hash)
290     (define-key map (kbd "SPC") 'magit-diff-show-or-scroll-up)
291     (define-key map (kbd "DEL") 'magit-diff-show-or-scroll-down)
292     map)
293   "Keymap for `magit-blame-read-only-mode'.")
294
295 ;;; Modes
296 ;;;; Variables
297
298 (defvar-local magit-blame-buffer-read-only nil)
299 (defvar-local magit-blame-cache nil)
300 (defvar-local magit-blame-disabled-modes nil)
301 (defvar-local magit-blame-process nil)
302 (defvar-local magit-blame-recursive-p nil)
303 (defvar-local magit-blame-type nil)
304 (defvar-local magit-blame-separator nil)
305 (defvar-local magit-blame-previous-chunk nil)
306
307 (defvar-local magit-blame--style nil)
308
309 (defsubst magit-blame--style-get (key)
310   (cdr (assoc key (cdr magit-blame--style))))
311
312 ;;;; Base Mode
313
314 (define-minor-mode magit-blame-mode
315   "Display blame information inline."
316   :lighter magit-blame-mode-lighter
317   (cond (magit-blame-mode
318          (when (called-interactively-p 'any)
319            (setq magit-blame-mode nil)
320            (user-error
321             (concat "Don't call `magit-blame-mode' directly; "
322                     "instead use `magit-blame' or `magit-blame-popup'")))
323          (add-hook 'after-save-hook     'magit-blame--run t t)
324          (add-hook 'post-command-hook   'magit-blame-goto-chunk-hook t t)
325          (add-hook 'before-revert-hook  'magit-blame--remove-overlays t t)
326          (add-hook 'after-revert-hook   'magit-blame--run t t)
327          (add-hook 'read-only-mode-hook 'magit-blame-toggle-read-only t t)
328          (setq magit-blame-buffer-read-only buffer-read-only)
329          (when (or magit-blame-read-only magit-buffer-file-name)
330            (read-only-mode 1))
331          (dolist (mode magit-blame-disable-modes)
332            (when (and (boundp mode) (symbol-value mode))
333              (funcall mode -1)
334              (push mode magit-blame-disabled-modes)))
335          (setq magit-blame-separator (magit-blame--format-separator))
336          (unless magit-blame--style
337            (setq magit-blame--style (car magit-blame-styles)))
338          (magit-blame--update-margin))
339         (t
340          (when (process-live-p magit-blame-process)
341            (kill-process magit-blame-process)
342            (while magit-blame-process
343              (sit-for 0.01))) ; avoid racing the sentinal
344          (remove-hook 'after-save-hook     'magit-blame--run t)
345          (remove-hook 'post-command-hook   'magit-blame-goto-chunk-hook t)
346          (remove-hook 'before-revert-hook  'magit-blame--remove-overlays t)
347          (remove-hook 'after-revert-hook   'magit-blame--run t)
348          (remove-hook 'read-only-mode-hook 'magit-blame-toggle-read-only t)
349          (unless magit-blame-buffer-read-only
350            (read-only-mode -1))
351          (magit-blame-read-only-mode -1)
352          (dolist (mode magit-blame-disabled-modes)
353            (funcall mode 1))
354          (kill-local-variable 'magit-blame-disabled-modes)
355          (kill-local-variable 'magit-blame-type)
356          (kill-local-variable 'magit-blame--style)
357          (magit-blame--update-margin)
358          (magit-blame--remove-overlays))))
359
360 (defun magit-blame-goto-chunk-hook ()
361   (let ((chunk (magit-blame-chunk-at (point))))
362     (when (cl-typep chunk 'magit-blame-chunk)
363       (unless (eq chunk magit-blame-previous-chunk)
364         (run-hooks 'magit-blame-goto-chunk-hook))
365       (setq magit-blame-previous-chunk chunk))))
366
367 (defun magit-blame-toggle-read-only ()
368   (magit-blame-read-only-mode (if buffer-read-only 1 -1)))
369
370 ;;;; Read-Only Mode
371
372 (define-minor-mode magit-blame-read-only-mode
373   "Provide keybindings for Magit-Blame mode.
374
375 This minor-mode provides the key bindings for Magit-Blame mode,
376 but only when Read-Only mode is also enabled because these key
377 bindings would otherwise conflict badly with regular bindings.
378
379 When both Magit-Blame mode and Read-Only mode are enabled, then
380 this mode gets automatically enabled too and when one of these
381 modes is toggled, then this mode also gets toggled automatically.
382
383 \\{magit-blame-read-only-mode-map}")
384
385 ;;;; Kludges
386
387 (defun magit-blame-put-keymap-before-view-mode ()
388   "Put `magit-blame-read-only-mode' ahead of `view-mode' in `minor-mode-map-alist'."
389   (--when-let (assq 'magit-blame-read-only-mode
390                     (cl-member 'view-mode minor-mode-map-alist :key #'car))
391     (setq minor-mode-map-alist
392           (cons it (delq it minor-mode-map-alist))))
393   (remove-hook 'view-mode-hook #'magit-blame-put-keymap-before-view-mode))
394
395 (add-hook 'view-mode-hook #'magit-blame-put-keymap-before-view-mode)
396
397 ;;; Process
398
399 (defun magit-blame--run ()
400   (magit-with-toplevel
401     (unless magit-blame-mode
402       (magit-blame-mode 1))
403     (message "Blaming...")
404     (magit-blame-run-process
405      (or magit-buffer-refname magit-buffer-revision)
406      (magit-file-relative-name nil (not magit-buffer-file-name))
407      (if (memq magit-blame-type '(final removal))
408          (cons "--reverse" (magit-blame-arguments))
409        (magit-blame-arguments))
410      (list (line-number-at-pos (window-start))
411            (line-number-at-pos (1- (window-end nil t)))))
412     (set-process-sentinel magit-this-process
413                           'magit-blame-process-quickstart-sentinel)))
414
415 (defun magit-blame-run-process (revision file args &optional lines)
416   (let ((process (magit-parse-git-async
417                   "blame" "--incremental" args
418                   (and lines (list "-L" (apply #'format "%s,%s" lines)))
419                   revision "--" file)))
420     (set-process-filter   process 'magit-blame-process-filter)
421     (set-process-sentinel process 'magit-blame-process-sentinel)
422     (process-put process 'arguments (list revision file args))
423     (setq magit-blame-cache (make-hash-table :test 'equal))
424     (setq magit-blame-process process)))
425
426 (defun magit-blame-process-quickstart-sentinel (process event)
427   (when (memq (process-status process) '(exit signal))
428     (magit-blame-process-sentinel process event t)
429     (magit-blame-assert-buffer process)
430     (with-current-buffer (process-get process 'command-buf)
431       (when magit-blame-mode
432         (let ((default-directory (magit-toplevel)))
433           (apply #'magit-blame-run-process
434                  (process-get process 'arguments)))))))
435
436 (defun magit-blame-process-sentinel (process _event &optional quiet)
437   (let ((status (process-status process)))
438     (when (memq status '(exit signal))
439       (kill-buffer (process-buffer process))
440       (if (and (eq status 'exit)
441                (zerop (process-exit-status process)))
442           (unless quiet
443             (message "Blaming...done"))
444         (magit-blame-assert-buffer process)
445         (with-current-buffer (process-get process 'command-buf)
446           (if magit-blame-mode
447               (progn (magit-blame-mode -1)
448                      (message "Blaming...failed"))
449             (message "Blaming...aborted"))))
450       (kill-local-variable 'magit-blame-process))))
451
452 (defun magit-blame-process-filter (process string)
453   (internal-default-process-filter process string)
454   (let ((buf  (process-get process 'command-buf))
455         (pos  (process-get process 'parsed))
456         (mark (process-mark process))
457         type cache)
458     (with-current-buffer buf
459       (setq type  magit-blame-type)
460       (setq cache magit-blame-cache))
461     (with-current-buffer (process-buffer process)
462       (goto-char pos)
463       (while (and (< (point) mark)
464                   (save-excursion (re-search-forward "^filename .+\n" nil t)))
465         (pcase-let* ((`(,chunk ,revinfo)
466                       (magit-blame--parse-chunk type))
467                      (rev (oref chunk orig-rev)))
468           (if revinfo
469               (puthash rev revinfo cache)
470             (setq revinfo
471                   (or (gethash rev cache)
472                       (puthash rev (magit-blame--commit-alist rev) cache))))
473           (magit-blame--make-overlays buf chunk revinfo))
474         (process-put process 'parsed (point))))))
475
476 (defun magit-blame--parse-chunk (type)
477   (let (chunk revinfo)
478     (looking-at "^\\(.\\{40\\}\\) \\([0-9]+\\) \\([0-9]+\\) \\([0-9]+\\)")
479     (with-slots (orig-rev orig-file prev-rev prev-file)
480         (setq chunk (magit-blame-chunk
481                      :orig-rev                     (match-string 1)
482                      :orig-line  (string-to-number (match-string 2))
483                      :final-line (string-to-number (match-string 3))
484                      :num-lines  (string-to-number (match-string 4))))
485       (forward-line)
486       (let (done)
487         (while (not done)
488           (cond ((looking-at "^filename \\(.+\\)")
489                  (setq done t)
490                  (setf orig-file (match-string 1)))
491                 ((looking-at "^previous \\(.\\{40\\}\\) \\(.+\\)")
492                  (setf prev-rev  (match-string 1))
493                  (setf prev-file (match-string 2)))
494                 ((looking-at "^\\([^ ]+\\) \\(.+\\)")
495                  (push (cons (match-string 1)
496                              (match-string 2)) revinfo)))
497           (forward-line)))
498       (when (and (eq type 'removal) prev-rev)
499         (cl-rotatef orig-rev  prev-rev)
500         (cl-rotatef orig-file prev-file)
501         (setq revinfo nil)))
502     (list chunk revinfo)))
503
504 (defun magit-blame--commit-alist (rev)
505   (cl-mapcar 'cons
506              '("summary"
507                "author" "author-time" "author-tz"
508                "committer" "committer-time" "committer-tz")
509              (split-string (magit-rev-format "%s\v%an\v%ad\v%cn\v%cd" rev
510                                              "--date=format:%s\v%z")
511                            "\v")))
512
513 (defun magit-blame-assert-buffer (process)
514   (unless (buffer-live-p (process-get process 'command-buf))
515     (kill-process process)
516     (user-error "Buffer being blamed has been killed")))
517
518 ;;; Display
519
520 (defun magit-blame--make-overlays (buf chunk revinfo)
521   (with-current-buffer buf
522     (save-excursion
523       (save-restriction
524         (widen)
525         (goto-char (point-min))
526         (forward-line (1- (oref chunk final-line)))
527         (let ((beg (point))
528               (end (save-excursion
529                      (forward-line (oref chunk num-lines))
530                      (point))))
531           (magit-blame--remove-overlays beg end)
532           (magit-blame--make-margin-overlays chunk revinfo beg end)
533           (magit-blame--make-heading-overlay chunk revinfo beg end)
534           (magit-blame--make-highlight-overlay   chunk beg))))))
535
536 (defun magit-blame--make-margin-overlays (chunk revinfo _beg end)
537   (save-excursion
538     (let ((line 0))
539       (while (< (point) end)
540         (magit-blame--make-margin-overlay chunk revinfo line)
541         (forward-line)
542         (cl-incf line)))))
543
544 (defun magit-blame--make-margin-overlay (chunk revinfo line)
545   (let* ((end (line-end-position))
546          ;; If possible avoid putting this on the first character
547          ;; of the line to avoid a conflict with the line overlay.
548          (beg (min (1+ (line-beginning-position)) end))
549          (ov  (make-overlay beg end)))
550     (overlay-put ov 'magit-blame-chunk chunk)
551     (overlay-put ov 'magit-blame-revinfo revinfo)
552     (overlay-put ov 'magit-blame-margin line)
553     (magit-blame--update-margin-overlay ov)))
554
555 (defun magit-blame--make-heading-overlay (chunk revinfo beg end)
556   (let ((ov (make-overlay beg end)))
557     (overlay-put ov 'magit-blame-chunk chunk)
558     (overlay-put ov 'magit-blame-revinfo revinfo)
559     (overlay-put ov 'magit-blame-heading t)
560     (magit-blame--update-heading-overlay ov)))
561
562 (defun magit-blame--make-highlight-overlay (chunk beg)
563   (let ((ov (make-overlay beg (1+ (line-end-position)))))
564     (overlay-put ov 'magit-blame-chunk chunk)
565     (overlay-put ov 'magit-blame-highlight t)
566     (magit-blame--update-highlight-overlay ov)))
567
568 (defun magit-blame--update-margin ()
569   (setq left-margin-width (or (magit-blame--style-get 'margin-width) 0))
570   (set-window-buffer (selected-window) (current-buffer)))
571
572 (defun magit-blame--update-overlays ()
573   (save-restriction
574     (widen)
575     (dolist (ov (overlays-in (point-min) (point-max)))
576       (cond ((overlay-get ov 'magit-blame-heading)
577              (magit-blame--update-heading-overlay ov))
578             ((overlay-get ov 'magit-blame-margin)
579              (magit-blame--update-margin-overlay ov))
580             ((overlay-get ov 'magit-blame-highlight)
581              (magit-blame--update-highlight-overlay ov))))))
582
583 (defun magit-blame--update-margin-overlay (ov)
584   (overlay-put
585    ov 'before-string
586    (and (magit-blame--style-get 'margin-width)
587         (propertize
588          "o" 'display
589          (list (list 'margin 'left-margin)
590                (let ((line   (overlay-get ov 'magit-blame-margin))
591                      (format (magit-blame--style-get 'margin-format))
592                      (face   (magit-blame--style-get 'margin-face)))
593                  (magit-blame--format-string
594                   ov
595                   (or (and (atom format)
596                            format)
597                       (nth line format)
598                       (car (last format)))
599                   (or (and (not (zerop line))
600                            (magit-blame--style-get 'margin-body-face))
601                       face
602                       'magit-blame-margin))))))))
603
604 (defun magit-blame--update-heading-overlay (ov)
605   (overlay-put
606    ov 'before-string
607    (--if-let (magit-blame--style-get 'heading-format)
608        (magit-blame--format-string ov it 'magit-blame-heading)
609      (and (magit-blame--style-get 'show-lines)
610           (or (not (magit-blame--style-get 'margin-format))
611               (save-excursion
612                 (goto-char (overlay-start ov))
613                 ;; Special case of the special case described in
614                 ;; `magit-blame--make-margin-overlay'.  For empty
615                 ;; lines it is not possible to show both overlays
616                 ;; without the line being to high.
617                 (not (= (point) (line-end-position)))))
618           magit-blame-separator))))
619
620 (defun magit-blame--update-highlight-overlay (ov)
621   (overlay-put ov 'face (magit-blame--style-get 'highlight-face)))
622
623 (defun magit-blame--format-string (ov format face)
624   (let* ((chunk   (overlay-get ov 'magit-blame-chunk))
625          (revinfo (overlay-get ov 'magit-blame-revinfo))
626          (key     (list format face))
627          (string  (cdr (assoc key revinfo))))
628     (unless string
629       (setq string
630             (and format
631                  (magit-blame--format-string-1 (oref chunk orig-rev)
632                                                revinfo format face)))
633       (nconc revinfo (list (cons key string))))
634     string))
635
636 (defun magit-blame--format-string-1 (rev revinfo format face)
637   (let ((str
638          (if (equal rev "0000000000000000000000000000000000000000")
639              (propertize (concat (if (string-prefix-p "\s" format) "\s" "")
640                                  "Not Yet Committed"
641                                  (if (string-suffix-p "\n" format) "\n" ""))
642                          'face face)
643            (magit--format-spec
644             (propertize format 'face face)
645             (cl-flet* ((p0 (s f)
646                            (propertize s 'face (if face
647                                                    (if (listp face)
648                                                        face
649                                                      (list f face))
650                                                  f)))
651                        (p1 (k f)
652                            (p0 (cdr (assoc k revinfo)) f))
653                        (p2 (k1 k2 f)
654                            (p0 (magit-blame--format-time-string
655                                 (cdr (assoc k1 revinfo))
656                                 (cdr (assoc k2 revinfo)))
657                                f)))
658               `((?H . ,(p0 rev         'magit-blame-hash))
659                 (?s . ,(p1 "summary"   'magit-blame-summary))
660                 (?a . ,(p1 "author"    'magit-blame-name))
661                 (?c . ,(p1 "committer" 'magit-blame-name))
662                 (?A . ,(p2 "author-time"    "author-tz"    'magit-blame-date))
663                 (?C . ,(p2 "committer-time" "committer-tz" 'magit-blame-date))
664                 (?f . "")))))))
665     (if-let ((width (and (string-suffix-p "%f" format)
666                          (magit-blame--style-get 'margin-width))))
667         (concat str
668                 (propertize (make-string (max 0 (- width (length str))) ?\s)
669                             'face face))
670       str)))
671
672 (defun magit-blame--format-separator ()
673   (propertize
674    (concat (propertize "\s" 'display '(space :height (2)))
675            (propertize "\n" 'line-height t))
676    'face (list :background
677                (face-attribute 'magit-blame-heading :background nil t))))
678
679 (defun magit-blame--format-time-string (time tz)
680   (let* ((time-format (or (magit-blame--style-get 'time-format)
681                           magit-blame-time-format))
682          (tz-in-second (and (not (version< emacs-version "25"))
683                             (string-match "%z" time-format)
684                             (car (last (parse-time-string tz))))))
685     (format-time-string time-format
686                         (seconds-to-time (string-to-number time))
687                         tz-in-second)))
688
689 (defun magit-blame--remove-overlays (&optional beg end)
690   (save-restriction
691     (widen)
692     (dolist (ov (overlays-in (or beg (point-min))
693                              (or end (point-max))))
694       (when (overlay-get ov 'magit-blame-chunk)
695         (delete-overlay ov)))))
696
697 (defun magit-blame-maybe-show-message ()
698   (when (magit-blame--style-get 'show-message)
699     (let ((message-log-max 0))
700       (if-let ((msg (cdr (assq 'heading
701                                (gethash (oref (magit-current-blame-chunk)
702                                               orig-rev)
703                                         magit-blame-cache)))))
704           (progn (setq msg (substring msg 0 -1))
705                  (set-text-properties 0 (length msg) nil msg)
706                  (message msg))
707         (message "Commit data not available yet.  Still blaming.")))))
708
709 ;;; Commands
710
711 ;;;###autoload
712 (defun magit-blame-echo ()
713   "For each line show the revision in which it was added.
714 Show the information about the chunk at point in the echo area
715 when moving between chunks.  Unlike other blaming commands, do
716 not turn on `read-only-mode'."
717   (interactive)
718   (when magit-buffer-file-name
719     (user-error "Blob buffers aren't supported"))
720   (setq-local magit-blame--style
721               (assq magit-blame-echo-style magit-blame-styles))
722   (setq-local magit-blame-disable-modes
723               (cons 'eldoc-mode magit-blame-disable-modes))
724   (if (not magit-blame-mode)
725       (let ((magit-blame-read-only nil))
726         (magit-blame-addition))
727     (read-only-mode -1)
728     (magit-blame--update-overlays)))
729
730 ;;;###autoload
731 (defun magit-blame-addition ()
732   "For each line show the revision in which it was added."
733   (interactive)
734   (magit-blame--pre-blame-assert 'addition)
735   (magit-blame--pre-blame-setup  'addition)
736   (magit-blame--run))
737
738 ;;;###autoload
739 (defun magit-blame-removal ()
740   "For each line show the revision in which it was removed."
741   (interactive)
742   (unless magit-buffer-file-name
743     (user-error "Only blob buffers can be blamed in reverse"))
744   (magit-blame--pre-blame-assert 'removal)
745   (magit-blame--pre-blame-setup  'removal)
746   (magit-blame--run))
747
748 ;;;###autoload
749 (defun magit-blame-reverse ()
750   "For each line show the last revision in which it still exists."
751   (interactive)
752   (unless magit-buffer-file-name
753     (user-error "Only blob buffers can be blamed in reverse"))
754   (magit-blame--pre-blame-assert 'final)
755   (magit-blame--pre-blame-setup  'final)
756   (magit-blame--run))
757
758 (defun magit-blame--pre-blame-assert (type)
759   (unless (magit-toplevel)
760     (magit--not-inside-repository-error))
761   (if (and magit-blame-mode
762            (eq type magit-blame-type))
763       (if-let ((chunk (magit-current-blame-chunk)))
764           (unless (oref chunk prev-rev)
765             (user-error "Chunk has no further history"))
766         (user-error "Commit data not available yet.  Still blaming."))
767     (unless (magit-file-relative-name nil (not magit-buffer-file-name))
768       (if buffer-file-name
769           (user-error "Buffer isn't visiting a tracked file")
770         (user-error "Buffer isn't visiting a file")))))
771
772 (defun magit-blame--pre-blame-setup (type)
773   (when magit-blame-mode
774     (if (eq type magit-blame-type)
775         (let ((style magit-blame--style))
776           (magit-blame-visit-other-file)
777           (setq-local magit-blame--style style)
778           (setq-local magit-blame-recursive-p t)
779           ;; Set window-start for the benefit of quickstart.
780           (redisplay))
781       (magit-blame--remove-overlays)))
782   (setq magit-blame-type type))
783
784 (defun magit-blame-visit-other-file ()
785   "Visit another blob related to the current chunk."
786   (interactive)
787   (with-slots (prev-rev prev-file orig-line)
788       (magit-current-blame-chunk)
789     (unless prev-rev
790       (user-error "Chunk has no further history"))
791     (magit-with-toplevel
792       (magit-find-file prev-rev prev-file))
793     ;; TODO Adjust line like magit-diff-visit-file.
794     (goto-char (point-min))
795     (forward-line (1- orig-line))))
796
797 (defun magit-blame-visit-file ()
798   "Visit the blob related to the current chunk."
799   (interactive)
800   (with-slots (orig-rev orig-file orig-line)
801       (magit-current-blame-chunk)
802     (magit-with-toplevel
803       (magit-find-file orig-rev orig-file))
804     (goto-char (point-min))
805     (forward-line (1- orig-line))))
806
807 (defun magit-blame-quit ()
808   "Turn off Magit-Blame mode.
809 If the buffer was created during a recursive blame,
810 then also kill the buffer."
811   (interactive)
812   (magit-blame-mode -1)
813   (when magit-blame-recursive-p
814     (kill-buffer)))
815
816 (defun magit-blame-next-chunk ()
817   "Move to the next chunk."
818   (interactive)
819   (--if-let (next-single-char-property-change (point) 'magit-blame-chunk)
820       (goto-char it)
821     (user-error "No more chunks")))
822
823 (defun magit-blame-previous-chunk ()
824   "Move to the previous chunk."
825   (interactive)
826   (--if-let (previous-single-char-property-change (point) 'magit-blame-chunk)
827       (goto-char it)
828     (user-error "No more chunks")))
829
830 (defun magit-blame-next-chunk-same-commit (&optional previous)
831   "Move to the next chunk from the same commit.\n\n(fn)"
832   (interactive)
833   (if-let ((rev (oref (magit-current-blame-chunk) orig-rev)))
834       (let ((pos (point)) ov)
835         (save-excursion
836           (while (and (not ov)
837                       (not (= pos (if previous (point-min) (point-max))))
838                       (setq pos (funcall
839                                  (if previous
840                                      'previous-single-char-property-change
841                                    'next-single-char-property-change)
842                                  pos 'magit-blame-chunk)))
843             (--when-let (magit-blame--overlay-at pos)
844               (when (equal (oref (magit-blame-chunk-at pos) orig-rev) rev)
845                 (setq ov it)))))
846         (if ov
847             (goto-char (overlay-start ov))
848           (user-error "No more chunks from same commit")))
849     (user-error "This chunk hasn't been blamed yet")))
850
851 (defun magit-blame-previous-chunk-same-commit ()
852   "Move to the previous chunk from the same commit."
853   (interactive)
854   (magit-blame-next-chunk-same-commit 'previous-single-char-property-change))
855
856 (defun magit-blame-cycle-style ()
857   "Change how blame information is visualized.
858 Cycle through the elements of option `magit-blame-styles'."
859   (interactive)
860   (setq magit-blame--style
861         (or (cadr (cl-member (car magit-blame--style)
862                              magit-blame-styles :key #'car))
863             (car magit-blame-styles)))
864   (magit-blame--update-margin)
865   (magit-blame--update-overlays))
866
867 (defun magit-blame-copy-hash ()
868   "Save hash of the current chunk's commit to the kill ring.
869
870 When the region is active, then save the region's content
871 instead of the hash, like `kill-ring-save' would."
872   (interactive)
873   (if (use-region-p)
874       (copy-region-as-kill nil nil 'region)
875     (kill-new (message "%s" (oref (magit-current-blame-chunk) orig-rev)))))
876
877 ;;; Popup
878
879 ;;;###autoload (autoload 'magit-blame-popup "magit-blame" nil t)
880 (magit-define-popup magit-blame-popup
881   "Popup console for blame commands."
882   :man-page "git-blame"
883   :switches '((?w "Ignore whitespace" "-w")
884               (?r "Do not treat root commits as boundaries" "--root"))
885   :options  '((?M "Detect lines moved or copied within a file" "-M")
886               (?C "Detect lines moved or copied between files" "-C"))
887   :actions  '("Actions"
888               (?b "Show commits adding lines" magit-blame-addition)
889               (?r (lambda ()
890                     (with-current-buffer magit-pre-popup-buffer
891                       (and (not buffer-file-name)
892                            (propertize "Show commits removing lines"
893                                        'face 'default))))
894                   magit-blame-removal)
895               (?f (lambda ()
896                     (with-current-buffer magit-pre-popup-buffer
897                       (and (not buffer-file-name)
898                            (propertize "Show last commits that still have lines"
899                                        'face 'default))))
900                   magit-blame-reverse)
901               (lambda ()
902                 (and (with-current-buffer magit-pre-popup-buffer
903                        magit-blame-mode)
904                      (propertize "Refresh" 'face 'magit-popup-heading)))
905               (?c "Cycle style" magit-blame-cycle-style))
906   :default-arguments '("-w")
907   :max-action-columns 1
908   :default-action 'magit-blame-addition)
909
910 ;;; Utilities
911
912 (defun magit-blame-maybe-update-revision-buffer ()
913   (unless magit--update-revision-buffer
914     (setq magit--update-revision-buffer nil)
915     (when-let ((chunk  (magit-current-blame-chunk))
916                (commit (oref chunk orig-rev))
917                (buffer (magit-mode-get-buffer 'magit-revision-mode nil t)))
918       (setq magit--update-revision-buffer (list commit buffer))
919       (run-with-idle-timer
920        magit-update-other-window-delay nil
921        (lambda ()
922          (pcase-let ((`(,rev ,buf) magit--update-revision-buffer))
923            (setq magit--update-revision-buffer nil)
924            (when (buffer-live-p buf)
925              (let ((magit-display-buffer-noselect t))
926                (apply #'magit-show-commit rev (magit-diff-arguments))))))))))
927
928 ;;; _
929 (provide 'magit-blame)
930 ;;; magit-blame.el ends here