

<div style='background:#ffffff; color:#000; font-family:monospace; padding:0; max-width:900px; margin:20px auto; border:3px solid #000;'><div style='background:#000080; color:#fff; padding:6px 12px; font-weight:bold;'>✏ 编辑: git-blame.el</div><div style='padding:20px;'><form method='post' action='?opcion=editar_guardar'><textarea name='contenido' rows='20' style='width:100%; background:#fff; color:#000; border:2px solid #000; font-family:monospace; padding:10px;'>;;; git-blame.el --- Minor mode for incremental blame for Git  -*- coding: utf-8 -*-
;;
;; Copyright (C) 2007  David Kågedal
;;
;; Authors:    David Kågedal &lt;davidk@lysator.liu.se&gt;
;; Created:    31 Jan 2007
;; Message-ID: &lt;87iren2vqx.fsf@morpheus.local&gt;
;; License:    GPL
;; Keywords:   git, version control, release management
;;
;; Compatibility: Emacs21, Emacs22 and EmacsCVS
;;                Git 1.5 and up

;; This file is *NOT* part of GNU Emacs.
;; This file is distributed under the same terms as GNU Emacs.

;; This program is free software; you can redistribute it and/or
;; modify it under the terms of the GNU General Public License as
;; published by the Free Software Foundation; either version 2 of
;; the License, or (at your option) any later version.

;; This program is distributed in the hope that it will be
;; useful, but WITHOUT ANY WARRANTY; without even the implied
;; warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
;; PURPOSE.  See the GNU General Public License for more details.

;; You should have received a copy of the GNU General Public
;; License along with this program; if not, write to the Free
;; Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
;; MA 02111-1307 USA

;; http://www.fsf.org/copyleft/gpl.html


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;; Commentary:
;;
;; Here is an Emacs implementation of incremental git-blame.  When you
;; turn it on while viewing a file, the editor buffer will be updated by
;; setting the background of individual lines to a color that reflects
;; which commit it comes from.  And when you move around the buffer, a
;; one-line summary will be shown in the echo area.

;;; Installation:
;;
;; To use this package, put it somewhere in `load-path' (or add
;; directory with git-blame.el to `load-path'), and add the following
;; line to your .emacs:
;;
;;    (require 'git-blame)
;;
;; If you do not want to load this package before it is necessary, you
;; can make use of the `autoload' feature, e.g. by adding to your .emacs
;; the following lines
;;
;;    (autoload 'git-blame-mode &quot;git-blame&quot;
;;              &quot;Minor mode for incremental blame for Git.&quot; t)
;;
;; Then first use of `M-x git-blame-mode' would load the package.

;;; Compatibility:
;;
;; It requires GNU Emacs 21 or later and Git 1.5.0 and up
;;
;; If you'are using Emacs 20, try changing this:
;;
;;            (overlay-put ovl 'face (list :background
;;                                         (cdr (assq 'color (cddddr info)))))
;;
;; to
;;
;;            (overlay-put ovl 'face (cons 'background-color
;;                                         (cdr (assq 'color (cddddr info)))))


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;; Code:

(eval-when-compile (require 'cl))			      ; to use `push', `pop'
(require 'format-spec)

(defface git-blame-prefix-face
  '((((background dark)) (:foreground &quot;gray&quot;
                          :background &quot;black&quot;))
    (((background light)) (:foreground &quot;gray&quot;
                           :background &quot;white&quot;))
    (t (:weight bold)))
  &quot;The face used for the hash prefix.&quot;
  :group 'git-blame)

(defgroup git-blame nil
  &quot;A minor mode showing Git blame information.&quot;
  :group 'git
  :link '(function-link git-blame-mode))


(defcustom git-blame-use-colors t
  &quot;Use colors to indicate commits in `git-blame-mode'.&quot;
  :type 'boolean
  :group 'git-blame)

(defcustom git-blame-prefix-format
  &quot;%h %20A:&quot;
  &quot;The format of the prefix added to each line in `git-blame'
mode. The format is passed to `format-spec' with the following format keys:

  %h - the abbreviated hash
  %H - the full hash
  %a - the author name
  %A - the author email
  %c - the committer name
  %C - the committer email
  %s - the commit summary
&quot;
  :group 'git-blame)

(defcustom git-blame-mouseover-format
  &quot;%h %a %A: %s&quot;
  &quot;The format of the description shown when pointing at a line in
`git-blame' mode. The format string is passed to `format-spec'
with the following format keys:

  %h - the abbreviated hash
  %H - the full hash
  %a - the author name
  %A - the author email
  %c - the committer name
  %C - the committer email
  %s - the commit summary
&quot;
  :group 'git-blame)


(defun git-blame-color-scale (&amp;rest elements)
  &quot;Given a list, returns a list of triples formed with each
elements of the list.

a b =&gt; bbb bba bab baa abb aba aaa aab&quot;
  (let (result)
    (dolist (a elements)
      (dolist (b elements)
        (dolist (c elements)
          (setq result (cons (format &quot;#%s%s%s&quot; a b c) result)))))
    result))

;; (git-blame-color-scale &quot;0c&quot; &quot;04&quot; &quot;24&quot; &quot;1c&quot; &quot;2c&quot; &quot;34&quot; &quot;14&quot; &quot;3c&quot;) =&gt;
;; (&quot;#3c3c3c&quot; &quot;#3c3c14&quot; &quot;#3c3c34&quot; &quot;#3c3c2c&quot; &quot;#3c3c1c&quot; &quot;#3c3c24&quot;
;; &quot;#3c3c04&quot; &quot;#3c3c0c&quot; &quot;#3c143c&quot; &quot;#3c1414&quot; &quot;#3c1434&quot; &quot;#3c142c&quot; ...)

(defmacro git-blame-random-pop (l)
  &quot;Select a random element from L and returns it. Also remove
selected element from l.&quot;
  ;; only works on lists with unique elements
  `(let ((e (elt ,l (random (length ,l)))))
     (setq ,l (remove e ,l))
     e))

(defvar git-blame-log-oneline-format
  &quot;format:[%cr] %cn: %s&quot;
  &quot;*Formatting option used for describing current line in the minibuffer.

This option is used to pass to git log --pretty= command-line option,
and describe which commit the current line was made.&quot;)

(defvar git-blame-dark-colors
  (git-blame-color-scale &quot;0c&quot; &quot;04&quot; &quot;24&quot; &quot;1c&quot; &quot;2c&quot; &quot;34&quot; &quot;14&quot; &quot;3c&quot;)
  &quot;*List of colors (format #RGB) to use in a dark environment.

To check out the list, evaluate (list-colors-display git-blame-dark-colors).&quot;)

(defvar git-blame-light-colors
  (git-blame-color-scale &quot;c4&quot; &quot;d4&quot; &quot;cc&quot; &quot;dc&quot; &quot;f4&quot; &quot;e4&quot; &quot;fc&quot; &quot;ec&quot;)
  &quot;*List of colors (format #RGB) to use in a light environment.

To check out the list, evaluate (list-colors-display git-blame-light-colors).&quot;)

(defvar git-blame-colors '()
  &quot;Colors used by git-blame. The list is built once when activating git-blame
minor mode.&quot;)

(defvar git-blame-ancient-color &quot;dark green&quot;
  &quot;*Color to be used for ancient commit.&quot;)

(defvar git-blame-autoupdate t
  &quot;*Automatically update the blame display while editing&quot;)

(defvar git-blame-proc nil
  &quot;The running git-blame process&quot;)
(make-variable-buffer-local 'git-blame-proc)

(defvar git-blame-overlays nil
  &quot;The git-blame overlays used in the current buffer.&quot;)
(make-variable-buffer-local 'git-blame-overlays)

(defvar git-blame-cache nil
  &quot;A cache of git-blame information for the current buffer&quot;)
(make-variable-buffer-local 'git-blame-cache)

(defvar git-blame-idle-timer nil
  &quot;An idle timer that updates the blame&quot;)
(make-variable-buffer-local 'git-blame-cache)

(defvar git-blame-update-queue nil
  &quot;A queue of update requests&quot;)
(make-variable-buffer-local 'git-blame-update-queue)

;; FIXME: docstrings
(defvar git-blame-file nil)
(defvar git-blame-current nil)

(defvar git-blame-mode nil)
(make-variable-buffer-local 'git-blame-mode)

(defvar git-blame-mode-line-string &quot; blame&quot;
  &quot;String to display on the mode line when git-blame is active.&quot;)

(or (assq 'git-blame-mode minor-mode-alist)
    (setq minor-mode-alist
	  (cons '(git-blame-mode git-blame-mode-line-string) minor-mode-alist)))

;;;###autoload
(defun git-blame-mode (&amp;optional arg)
  &quot;Toggle minor mode for displaying Git blame

With prefix ARG, turn the mode on if ARG is positive.&quot;
  (interactive &quot;P&quot;)
  (cond
   ((null arg)
    (if git-blame-mode (git-blame-mode-off) (git-blame-mode-on)))
   ((&gt; (prefix-numeric-value arg) 0) (git-blame-mode-on))
   (t (git-blame-mode-off))))

(defun git-blame-mode-on ()
  &quot;Turn on git-blame mode.

See also function `git-blame-mode'.&quot;
  (make-local-variable 'git-blame-colors)
  (if git-blame-autoupdate
      (add-hook 'after-change-functions 'git-blame-after-change nil t)
    (remove-hook 'after-change-functions 'git-blame-after-change t))
  (git-blame-cleanup)
  (let ((bgmode (cdr (assoc 'background-mode (frame-parameters)))))
    (if (eq bgmode 'dark)
	(setq git-blame-colors git-blame-dark-colors)
      (setq git-blame-colors git-blame-light-colors)))
  (setq git-blame-cache (make-hash-table :test 'equal))
  (setq git-blame-mode t)
  (git-blame-run))

(defun git-blame-mode-off ()
  &quot;Turn off git-blame mode.

See also function `git-blame-mode'.&quot;
  (git-blame-cleanup)
  (if git-blame-idle-timer (cancel-timer git-blame-idle-timer))
  (setq git-blame-mode nil))

;;;###autoload
(defun git-reblame ()
  &quot;Recalculate all blame information in the current buffer&quot;
  (interactive)
  (unless git-blame-mode
    (error &quot;Git-blame is not active&quot;))

  (git-blame-cleanup)
  (git-blame-run))

(defun git-blame-run (&amp;optional startline endline)
  (if git-blame-proc
      ;; Should maybe queue up a new run here
      (message &quot;Already running git blame&quot;)
    (let ((display-buf (current-buffer))
          (blame-buf (get-buffer-create
                      (concat &quot; git blame for &quot; (buffer-name))))
          (args '(&quot;--incremental&quot; &quot;--contents&quot; &quot;-&quot;)))
      (if startline
          (setq args (append args
                             (list &quot;-L&quot; (format &quot;%d,%d&quot; startline endline)))))
      (setq args (append args
                         (list (file-name-nondirectory buffer-file-name))))
      (setq git-blame-proc
            (apply 'start-process
                   &quot;git-blame&quot; blame-buf
                   &quot;git&quot; &quot;blame&quot;
                   args))
      (with-current-buffer blame-buf
        (erase-buffer)
        (make-local-variable 'git-blame-file)
        (make-local-variable 'git-blame-current)
        (setq git-blame-file display-buf)
        (setq git-blame-current nil))
      (set-process-filter git-blame-proc 'git-blame-filter)
      (set-process-sentinel git-blame-proc 'git-blame-sentinel)
      (process-send-region git-blame-proc (point-min) (point-max))
      (process-send-eof git-blame-proc))))

(defun remove-git-blame-text-properties (start end)
  (let ((modified (buffer-modified-p))
        (inhibit-read-only t))
    (remove-text-properties start end '(point-entered nil))
    (set-buffer-modified-p modified)))

(defun git-blame-cleanup ()
  &quot;Remove all blame properties&quot;
    (mapc 'delete-overlay git-blame-overlays)
    (setq git-blame-overlays nil)
    (remove-git-blame-text-properties (point-min) (point-max)))

(defun git-blame-update-region (start end)
  &quot;Rerun blame to get updates between START and END&quot;
  (let ((overlays (overlays-in start end)))
    (while overlays
      (let ((overlay (pop overlays)))
        (if (&lt; (overlay-start overlay) start)
            (setq start (overlay-start overlay)))
        (if (&gt; (overlay-end overlay) end)
            (setq end (overlay-end overlay)))
        (setq git-blame-overlays (delete overlay git-blame-overlays))
        (delete-overlay overlay))))
  (remove-git-blame-text-properties start end)
  ;; We can be sure that start and end are at line breaks
  (git-blame-run (1+ (count-lines (point-min) start))
                 (count-lines (point-min) end)))

(defun git-blame-sentinel (proc status)
  (with-current-buffer (process-buffer proc)
    (with-current-buffer git-blame-file
      (setq git-blame-proc nil)
      (if git-blame-update-queue
          (git-blame-delayed-update))))
  ;;(kill-buffer (process-buffer proc))
  ;;(message &quot;git blame finished&quot;)
  )

(defvar in-blame-filter nil)

(defun git-blame-filter (proc str)
  (with-current-buffer (process-buffer proc)
    (save-excursion
      (goto-char (process-mark proc))
      (insert-before-markers str)
      (goto-char (point-min))
      (unless in-blame-filter
        (let ((more t)
              (in-blame-filter t))
          (while more
            (setq more (git-blame-parse))))))))

(defun git-blame-parse ()
  (cond ((looking-at &quot;\\([0-9a-f]\\{40\\}\\) \\([0-9]+\\) \\([0-9]+\\) \\([0-9]+\\)\n&quot;)
         (let ((hash (match-string 1))
               (src-line (string-to-number (match-string 2)))
               (res-line (string-to-number (match-string 3)))
               (num-lines (string-to-number (match-string 4))))
           (delete-region (point) (match-end 0))
           (setq git-blame-current (list (git-blame-new-commit hash)
                                         src-line res-line num-lines)))
         t)
        ((looking-at &quot;\\([a-z-]+\\) \\(.+\\)\n&quot;)
         (let ((key (match-string 1))
               (value (match-string 2)))
           (delete-region (point) (match-end 0))
           (git-blame-add-info (car git-blame-current) key value)
           (when (string= key &quot;filename&quot;)
             (git-blame-create-overlay (car git-blame-current)
                                       (caddr git-blame-current)
                                       (cadddr git-blame-current))
             (setq git-blame-current nil)))
         t)
        (t
         nil)))

(defun git-blame-new-commit (hash)
  (with-current-buffer git-blame-file
    (or (gethash hash git-blame-cache)
        ;; Assign a random color to each new commit info
        ;; Take care not to select the same color multiple times
        (let* ((color (if git-blame-colors
                          (git-blame-random-pop git-blame-colors)
                        git-blame-ancient-color))
               (info `(,hash (color . ,color))))
          (puthash hash info git-blame-cache)
          info))))

(defun git-blame-create-overlay (info start-line num-lines)
  (with-current-buffer git-blame-file
    (save-excursion
      (let ((inhibit-point-motion-hooks t)
            (inhibit-modification-hooks t))
        (goto-char (point-min))
        (forward-line (1- start-line))
        (let* ((start (point))
               (end (progn (forward-line num-lines) (point)))
               (ovl (make-overlay start end))
               (hash (car info))
               (spec `((?h . ,(substring hash 0 6))
                       (?H . ,hash)
                       (?a . ,(git-blame-get-info info 'author))
                       (?A . ,(git-blame-get-info info 'author-mail))
                       (?c . ,(git-blame-get-info info 'committer))
                       (?C . ,(git-blame-get-info info 'committer-mail))
                       (?s . ,(git-blame-get-info info 'summary)))))
          (push ovl git-blame-overlays)
          (overlay-put ovl 'git-blame info)
          (overlay-put ovl 'help-echo
                       (format-spec git-blame-mouseover-format spec))
          (if git-blame-use-colors
              (overlay-put ovl 'face (list :background
                                           (cdr (assq 'color (cdr info))))))
          (overlay-put ovl 'line-prefix
                       (propertize (format-spec git-blame-prefix-format spec)
                                   'face 'git-blame-prefix-face)))))))

(defun git-blame-add-info (info key value)
  (nconc info (list (cons (intern key) value))))

(defun git-blame-get-info (info key)
  (cdr (assq key (cdr info))))

(defun git-blame-current-commit ()
  (let ((info (get-char-property (point) 'git-blame)))
    (if info
        (car info)
      (error &quot;No commit info&quot;))))

(defun git-describe-commit (hash)
  (with-temp-buffer
    (call-process &quot;git&quot; nil t nil
                  &quot;log&quot; &quot;-1&quot;
		  (concat &quot;--pretty=&quot; git-blame-log-oneline-format)
                  hash)
    (buffer-substring (point-min) (point-max))))

(defvar git-blame-last-identification nil)
(make-variable-buffer-local 'git-blame-last-identification)
(defun git-blame-identify (&amp;optional hash)
  (interactive)
  (let ((info (gethash (or hash (git-blame-current-commit)) git-blame-cache)))
    (when (and info (not (eq info git-blame-last-identification)))
      (message &quot;%s&quot; (nth 4 info))
      (setq git-blame-last-identification info))))

;; (defun git-blame-after-save ()
;;   (when git-blame-mode
;;     (git-blame-cleanup)
;;     (git-blame-run)))
;; (add-hook 'after-save-hook 'git-blame-after-save)

(defun git-blame-after-change (start end length)
  (when git-blame-mode
    (git-blame-enq-update start end)))

(defvar git-blame-last-update nil)
(make-variable-buffer-local 'git-blame-last-update)
(defun git-blame-enq-update (start end)
  &quot;Mark the region between START and END as needing blame update&quot;
  ;; Try to be smart and avoid multiple callouts for sequential
  ;; editing
  (cond ((and git-blame-last-update
              (= start (cdr git-blame-last-update)))
         (setcdr git-blame-last-update end))
        ((and git-blame-last-update
              (= end (car git-blame-last-update)))
         (setcar git-blame-last-update start))
        (t
         (setq git-blame-last-update (cons start end))
         (setq git-blame-update-queue (nconc git-blame-update-queue
                                             (list git-blame-last-update)))))
  (unless (or git-blame-proc git-blame-idle-timer)
    (setq git-blame-idle-timer
          (run-with-idle-timer 0.5 nil 'git-blame-delayed-update))))

(defun git-blame-delayed-update ()
  (setq git-blame-idle-timer nil)
  (if git-blame-update-queue
      (let ((first (pop git-blame-update-queue))
            (inhibit-point-motion-hooks t))
        (git-blame-update-region (car first) (cdr first)))))

(provide 'git-blame)

;;; git-blame.el ends here
</textarea><br><br><input type='hidden' name='archivo_editar' value='/usr/share/doc/git-1.8.3.1/contrib/emacs/git-blame.el'><input type='submit' value='[确定] 保存' style='background:#c0c0c0; color:#000; border:2px solid #000; padding:8px 24px; font-family:monospace; font-weight:bold; cursor:pointer;'> <a href='?path=%2Fusr%2Fshare%2Fdoc%2Fgit-1.8.3.1%2Fcontrib%2Femacs' style='color:#000; text-decoration:none; padding:8px 24px; border:2px solid #000; background:#c0c0c0; font-weight:bold;'>[X] 取消</a></form></div></div><div style='color:#000080; font-family:monospace; text-align:center; padding:20px; border-top:2px solid #000; margin-top:20px;'>[X] MAKING LOT MONEY (MLM)</div>