my-emacs-d/elpa/git-commit-mode-1.0.0/git-commit-mode.el

;;; git-commit-mode.el --- Major mode for editing git commit messages -*- lexical-binding: t; -*-

;; Copyright (c) 2010-2012  Florian Ragwitz
;; Copyright (c) 2012-2013  Sebastian Wiesner
;; Copyright (C) 2010-2015  The Magit Project Developers

;; Authors: Jonas Bernoulli <jonas@bernoul.li>
;;	Sebastian Wiesner <lunaryorn@gmail.com>
;;	Florian Ragwitz <rafl@debian.org>
;; Maintainer: Jonas Bernoulli <jonas@bernoul.li>
;; Homepage: https://github.com/magit/git-modes
;; Keywords: convenience vc git
;; Package-Version: 1.0.0

;; This file is not part of GNU Emacs.

;; This file 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 3, or (at your option)
;; any later version.

;; This file 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 file.  If not, see <http://www.gnu.org/licenses/>.

;;; Commentary:

;; A major mode for editing Git commit messages.

;;;; Formatting

;; Highlight the formatting of git commit messages and indicate errors according
;; to the guidelines for commit messages (see
;; http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html).
;;
;; Highlight the first line (aka "summary") specially if it exceeds 50
;; characters (configurable using `git-commit-summary-max-length').
;;
;; Enable `auto-fill-mode' and set the `fill-column' to 72 according to the
;; aforementioned guidelines (configurable using `git-commit-fill-column').

;;;; Headers

;; Provide commands to insert standard headers into commit messages.
;;
;; - C-c C-s inserts Signed-off-by (`git-commit-signoff').
;; - C-C C-a inserts Acked-by (`git-commit-ack').
;; - C-c C-t inserts Tested-by (`git-commit-test').
;; - C-c C-r inserts Reviewed-by (`git-commit-review').
;; - C-c C-o inserts Cc (`git-commit-cc').
;; - C-c C-p inserts Reported-by (`git-commit-reported').

;;;; Committing

;; C-c C-c finishes a commit.
;;
;; Check a buffer for stylistic errors before committing, and ask for
;; confirmation before committing with style errors.

;;; Code:

(require 'log-edit)
(require 'ring)
(require 'server)

;;; Options
;;;; Variables

(defgroup git-commit nil
  "Edit Git commit messages."
  :prefix "git-commit-"
  :group 'tools)

(defcustom git-commit-confirm-commit nil
  "Whether to ask for confirmation before committing.

If t, ask for confirmation before creating a commit with style
errors, unless the commit is forced.  If nil, never ask for
confirmation before committing."
  :group 'git-commit
  :type '(choice (const :tag "On style errors" t)
                 (const :tag "Never" nil)))

(defcustom git-commit-mode-hook '(turn-on-auto-fill)
  "Hook run when entering Git Commit mode."
  :options '(turn-on-auto-fill flyspell-mode git-commit-save-message)
  :type 'hook
  :group 'git-commit)

(defcustom git-commit-kill-buffer-hook '(git-commit-save-message)
  "Hook run when killing a Git Commit mode buffer.
This hook is run by both `git-commit-commit'
and `git-commit-abort'."
  :options '(git-commit-save-message)
  :type 'hook
  :group 'git-commit)

(defcustom git-commit-summary-max-length 50
  "Fontify characters beyond this column in summary lines as errors."
  :group 'git-commit
  :type 'number)

(defcustom git-commit-fill-column 72
  "Automatically wrap commit message lines beyond this column."
  :group 'git-commit
  :type 'number)

(defcustom git-commit-known-pseudo-headers
  '("Signed-off-by" "Acked-by" "Cc"
    "Suggested-by" "Reported-by" "Tested-by" "Reviewed-by")
  "A list of git pseudo headers to be highlighted."
  :group 'git-commit
  :type '(repeat string))

;;;; Faces

(defgroup git-commit-faces nil
  "Faces for highlighting Git commit messages."
  :prefix "git-commit-"
  :group 'git-commit
  :group 'faces)

(defface git-commit-summary-face
  '((t :inherit font-lock-type-face))
  "Face used to highlight the summary in git commit messages"
  :group 'git-commit-faces)

(defface git-commit-overlong-summary-face
  '((t :inherit font-lock-warning-face))
  "Face used to highlight overlong parts of git commit message summaries"
  :group 'git-commit-faces)

(defface git-commit-nonempty-second-line-face
  '((t :inherit font-lock-warning-face))
  "Face used to highlight text on the second line of git commit messages"
  :group 'git-commit-faces)

(defface git-commit-note-face
  '((t :inherit font-lock-string-face))
  "Face used to highlight notes in git commit messages"
  :group 'git-commit-faces)

(defface git-commit-pseudo-header-face
  '((t :inherit font-lock-string-face))
  "Font used to hightlight pseudo headers in git commit messages"
  :group 'git-commit-faces)

(defface git-commit-known-pseudo-header-face
  '((t :inherit font-lock-keyword-face))
  "Face used to hightlight common pseudo headers in git commit messages"
  :group 'git-commit-faces)

(defface git-commit-branch-face
  '((t :inherit font-lock-variable-name-face))
  "Face used to highlight the branch name in comments in git commit messages"
  :group 'git-commit-faces)

(defface git-commit-no-branch-face
  '((t :inherit git-commit-branch-face))
  "Face used when a commit is going to be made outside of any branches"
  :group 'git-commit-faces)

(defface git-commit-comment-heading-face
  '((t :inherit git-commit-known-pseudo-header-face))
  "Face used to highlight section headings in the default
comments in git commit messages"
  :group 'git-commit-faces)

(defface git-commit-comment-file-face
  '((t :inherit git-commit-pseudo-header-face))
  "Face used to highlight file names in the default comments in
git commit messages"
  :group 'git-commit-faces)

(defface git-commit-comment-action-face
  '((t :inherit git-commit-branch-face))
  "Face used to highlight what has happened to files in the
default comments in git commit messages"
  :group 'git-commit-faces)

;;; Keymap

(defvar git-commit-mode-map
  (let ((map (make-sparse-keymap)))
    (define-key map (kbd "C-c C-c") 'git-commit-commit)
    (define-key map (kbd "C-c C-k") 'git-commit-abort)
    (define-key map (kbd "C-c C-s") 'git-commit-signoff)
    (define-key map (kbd "C-c C-a") 'git-commit-ack)
    (define-key map (kbd "C-c C-t") 'git-commit-test)
    (define-key map (kbd "C-c C-r") 'git-commit-review)
    (define-key map (kbd "C-c C-o") 'git-commit-cc)
    (define-key map (kbd "C-c C-p") 'git-commit-reported)
    (define-key map (kbd "C-c C-i") 'git-commit-suggested)
    (define-key map (kbd "C-c M-s") 'git-commit-save-message)
    (define-key map (kbd "M-p")     'git-commit-prev-message)
    (define-key map (kbd "M-n")     'git-commit-next-message)
    (define-key map [remap server-edit]          'git-commit-commit)
    (define-key map [remap kill-buffer]          'git-commit-abort)
    (define-key map [remap ido-kill-buffer]      'git-commit-abort)
    (define-key map [remap iswitchb-kill-buffer] 'git-commit-abort)
    ;; Old bindings to avoid confusion
    (define-key map (kbd "C-c C-x s") 'git-commit-signoff)
    (define-key map (kbd "C-c C-x a") 'git-commit-ack)
    (define-key map (kbd "C-c C-x t") 'git-commit-test)
    (define-key map (kbd "C-c C-x r") 'git-commit-review)
    (define-key map (kbd "C-c C-x o") 'git-commit-cc)
    (define-key map (kbd "C-c C-x p") 'git-commit-reported)
    map)
  "Key map used by `git-commit-mode'.")

;;; Menu

(require 'easymenu)
(easy-menu-define git-commit-mode-menu git-commit-mode-map
  "Git Commit Mode Menu"
  '("Commit"
    ["Previous" git-commit-prev-message t]
    ["Next" git-commit-next-message t]
    "-"
    ["Ack" git-commit-ack :active t
     :help "Insert an 'Acked-by' header"]
    ["Sign-Off" git-commit-signoff :active t
     :help "Insert a 'Signed-off-by' header"]
    ["Tested-by" git-commit-test :active t
     :help "Insert a 'Tested-by' header"]
    ["Reviewed-by" git-commit-review :active t
     :help "Insert a 'Reviewed-by' header"]
    ["CC" git-commit-cc t
     :help "Insert a 'Cc' header"]
    ["Reported" git-commit-reported :active t
     :help "Insert a 'Reported-by' header"]
    ["Suggested" git-commit-suggested t
     :help "Insert a 'Suggested-by' header"]
    "-"
    ["Save" git-commit-save-message t]
    ["Cancel" git-commit-abort t]
    ["Commit" git-commit-commit t]))

;;; Committing

(defvar git-commit-commit-hook nil
  "Hook run by `git-commit-commit' unless clients exist.
Only use this if you know what you are doing.")

(defvar git-commit-previous-winconf nil)

(defmacro git-commit-restore-previous-winconf (&rest body)
  "Run BODY and then restore `git-commit-previous-winconf'.
When `git-commit-previous-winconf' is nil or was created from
another frame do nothing."
  (declare (indent 0))
  (let ((winconf (make-symbol "winconf"))
        (frame   (make-symbol "frame")))
    `(let ((,winconf git-commit-previous-winconf)
           (,frame (selected-frame)))
       ,@body
       (when (and ,winconf
                  (equal ,frame (window-configuration-frame ,winconf)))
         (set-window-configuration ,winconf)
         (setq git-commit-previous-winconf nil)))))

(defun git-commit-commit (&optional force)
  "Finish editing the commit message and commit.

Check for stylistic errors in the current commit, and ask the
user for confirmation depending on `git-commit-confirm-commit'.
If FORCE is non-nil or if a raw prefix arg is given, commit
immediately without asking.

Return t, if the commit was successful, or nil otherwise."
  (interactive "P")
  (if (and git-commit-confirm-commit
           (git-commit-has-style-errors-p)
           (not force)
           (not (y-or-n-p "Commit despite stylistic errors?")))
      (message "Commit canceled due to stylistic errors.")
    (save-buffer)
    (run-hooks 'git-commit-kill-buffer-hook)
    (remove-hook 'kill-buffer-query-functions
                 'git-commit-kill-buffer-noop t)
    (git-commit-restore-previous-winconf
      (if (git-commit-buffer-clients)
          (server-edit)
        (run-hook-with-args 'git-commit-commit-hook)
        (kill-buffer)))))

(defun git-commit-abort ()
  "Abort the commit.
The commit message is saved to the kill ring."
  (interactive)
  (when (< emacs-major-version 24)
    ;; Emacsclient doesn't exit with non-zero when -error is used.
    ;; Instead cause Git to error out by feeding it an empty file.
    (erase-buffer))
  (save-buffer)
  (run-hooks 'git-commit-kill-buffer-hook)
  (remove-hook 'kill-buffer-hook 'server-kill-buffer t)
  (remove-hook 'kill-buffer-query-functions 'git-commit-kill-buffer-noop t)
  (git-commit-restore-previous-winconf
    (let ((buffer  (current-buffer))
          (clients (git-commit-buffer-clients)))
      (if clients
          (progn
            (dolist (client clients)
              (ignore-errors
                (server-send-string client "-error Commit aborted by user"))
              (delete-process client))
            (when (buffer-live-p buffer)
              (kill-buffer buffer)))
        (kill-buffer))))
  (accept-process-output nil 0.1)
  (message (concat "Commit aborted."
                   (when (memq 'git-commit-save-message
                               git-commit-kill-buffer-hook)
                     "  Message saved to `log-edit-comment-ring'."))))

(defun git-commit-buffer-clients ()
  (and (fboundp 'server-edit)
       (boundp 'server-buffer-clients)
       server-buffer-clients))

;;; History

(defun git-commit-save-message ()
  "Save current message to `log-edit-comment-ring'."
  (interactive)
  (let ((message (buffer-substring
                  (point-min)
                  (git-commit-find-pseudo-header-position))))
    (when (and (string-match "^\\s-*\\sw" message)
               (or (ring-empty-p log-edit-comment-ring)
                   (not (ring-member log-edit-comment-ring message))))
      ;; if index is nil, we end up cycling back to message we just saved!
      (unless log-edit-comment-ring-index
        (setq log-edit-comment-ring-index 0))
      (ring-insert log-edit-comment-ring message))))

(defun git-commit-prev-message (arg)
  "Cycle backward through message history, after saving current message.
With a numeric prefix ARG, go back ARG comments."
  (interactive "*p")
  (when (and (git-commit-save-message) (> arg 0))
    (setq log-edit-comment-ring-index
          (log-edit-new-comment-index
           arg (ring-length log-edit-comment-ring))))
  (save-restriction
    (narrow-to-region (point-min) (git-commit-find-pseudo-header-position))
    (log-edit-previous-comment arg)))

(defun git-commit-next-message (arg)
  "Cycle forward through message history, after saving current message.
With a numeric prefix ARG, go forward ARG comments."
  (interactive "*p")
  (git-commit-prev-message (- arg)))

;;; Headers

(defun git-commit-find-pseudo-header-position ()
  "Find the position at which commit pseudo headers should be inserted.

Those headers usually live at the end of a commit message, but
before any trailing comments git or the user might have
inserted."
  (save-excursion
    (goto-char (point-max))
    (if (re-search-backward "^[^#\n]" nil t)
        ;; we found last non-empty non-comment line, headers go after
        (forward-line 1)
      ;; there's only blanks & comments, headers go before comments
      (goto-char (point-min))
      (and (re-search-forward "^#" nil t) (forward-line 0)))
    (skip-chars-forward "\n")
    (point)))

(defun git-commit-determine-pre-for-pseudo-header ()
  "Find the characters to insert before the pseudo header.
Returns either zero, one or two newlines after computation.

`point' either points to an empty line (with a non-empty previous
line) or the end of a non-empty line."
  (let ((pre "")
        (prev-line nil))
    (if (not (eq (point) (point-at-bol)))
        (progn
          (setq pre (concat pre "\n"))
          (setq prev-line (thing-at-point 'line)))
      ;; else: (point) is at an empty line
      (when (not (eq (point) (point-min)))
        (setq prev-line
              (save-excursion
                (forward-line -1)
                (thing-at-point 'line)))))

    ;; we have prev-line now; if it doesn't match any known pseudo
    ;; header, add a newline
    (when prev-line
      (if (not (delq nil (mapcar (lambda (pseudo-header)
                                   (string-match pseudo-header prev-line))
                                 git-commit-known-pseudo-headers)))
          (setq pre (concat pre "\n"))))
    pre))

(defun git-commit-insert-header (type name email)
  "Insert a header into the commit message.
The inserted header has the format 'TYPE: NAME <EMAIL>'.

The header is inserted at the position returned by
`git-commit-find-pseudo-header-position'.  When this position
isn't after an existing header or a newline, an extra newline is
inserted before the header."
  (let ((header-at (git-commit-find-pseudo-header-position)))
    (save-excursion
      (goto-char header-at)
      (let ((pre (git-commit-determine-pre-for-pseudo-header)))
        (insert (format "%s%s: %s <%s>\n" pre type name email))))))

(defun git-commit-insert-header-as-self (type)
  "Insert a header with the name and email of the current user.
The inserted header has the format 'TYPE: NAME <EMAIL>'.
Also see `git-commit-insert-header'."
  (git-commit-insert-header
   type
   (or (getenv "GIT_AUTHOR_NAME")
       (getenv "GIT_COMMITTER_NAME")
       (ignore-errors (car (process-lines "git" "config" "user.name")))
       user-full-name)
   (or (getenv "GIT_AUTHOR_EMAIL")
       (getenv "GIT_COMMITTER_EMAIL")
       (getenv "EMAIL")
       (ignore-errors (car (process-lines "git" "config" "user.email")))
       user-mail-address)))

(defmacro git-define-git-commit-self (action header)
  "Create function git-commit-ACTION.
ACTION will be part of the function name.
HEADER is the actual header to be inserted into the comment."
  (let ((func-name (intern (concat "git-commit-" action))))
    `(defun ,func-name ()
       ,(format "Insert a '%s' header at the end of the commit message.

The author name and email address used for the header are
retrieved automatically with the same mechanism git uses."
                header)
       (interactive)
       (git-commit-insert-header-as-self ,header))))

(git-define-git-commit-self "ack"     "Acked-by")
(git-define-git-commit-self "review"  "Reviewed-by")
(git-define-git-commit-self "signoff" "Signed-off-by")
(git-define-git-commit-self "test"    "Tested-by")

(defmacro git-define-git-commit (action header)
  "Create interactive function git-commit-ACTION.
ACTION will be part of the function name.
HEADER is the actual header to be inserted into the comment."
  (let ((func-name (intern (concat "git-commit-" action))))
    `(defun ,func-name (name email)
       ,(format "Insert a '%s' header at the end of the commit message.
The value of the header is determined by NAME and EMAIL.

When called interactively, both NAME and EMAIL are read from the
minibuffer."
                header)
       (interactive
        (list (read-string "Name: ")
              (read-string "Email: ")))
       (git-commit-insert-header ,header name email))))

(git-define-git-commit "cc"        "Cc")
(git-define-git-commit "reported"  "Reported-by")
(git-define-git-commit "suggested" "Suggested-by")

(defconst git-commit-comment-headings-alist
  '(("Not currently on any branch."   . git-commit-no-branch-face)
    ("Changes to be committed:"       . git-commit-comment-heading-face)
    ("Untracked files:"               . git-commit-comment-heading-face)
    ("Changed but not updated:"       . git-commit-comment-heading-face)
    ("Changes not staged for commit:" . git-commit-comment-heading-face)
    ("Unmerged paths:"                . git-commit-comment-heading-face))
  "Headings in message comments.

The `car' of each cell is the heading text, the `cdr' the face to
use for fontification.")

(defun git-commit-summary-regexp ()
  (concat
   ;; Skip empty lines or comments before the summary
   "\\`\\(?:^\\(?:\\s-*\\|\\s<.*\\)\n\\)*"
   ;; The summary line
   (format "\\(.\\{0,%d\\}\\)\\(.*\\)" git-commit-summary-max-length)
   ;; Non-empty non-comment second line
   ;;
   ;; For instant highlighting of non-empty second lines in font-lock,
   ;; the last capturing group must capture the empty string ("") in
   ;; "summary line\n".
   ;; That's why the simpler regex "\\(?:\n\\([^\n#].*\\)\\)?",
   ;; which captures 'nil', can't be used.
   "\\(?:\n\\#\\|\n\\(.*\\)\\)?"))

(defun git-commit-has-style-errors-p ()
  "Check whether the current buffer has style errors.

Return t, if the current buffer has style errors, or nil
otherwise."
  (save-excursion
    (goto-char (point-min))
    (when (re-search-forward (git-commit-summary-regexp) nil t)
      (or (string-match-p ".+" (or (match-string 2) ""))
          (string-match-p "^.+$" (or (match-string 3) ""))))))

;;; Font-Lock

(defun git-commit-mode-summary-font-lock-keywords (&optional errors)
  "Create font lock keywords to fontify the Git summary.

If ERRORS is non-nil create keywords that highlight errors in the
summary line, not the summary line itself."
  (if errors
      `(,(git-commit-summary-regexp)
        (2 'git-commit-overlong-summary-face t t)
        (3 'git-commit-nonempty-second-line-face t t))
    `(,(git-commit-summary-regexp)
      (1 'git-commit-summary-face t))))

(defun git-commit-mode-heading-keywords ()
  "Create font lock keywords to fontify comment headings.

Known comment headings are provided by `git-commit-comment-headings'."
  (mapcar (lambda (cell) `(,(format "^\\s<\\s-+\\(%s\\)$"
                                    (regexp-quote (car cell)))
                           (1 ',(cdr cell) t)))
          git-commit-comment-headings-alist))

(defun git-commit-mode-font-lock-keywords ()
  (append
   `(("^\\s<.*$" . 'font-lock-comment-face)
     ("^\\s<\\s-On branch \\(.*\\)$" (1 'git-commit-branch-face t))
     ("^\\s<\t\\(?:\\([^:\n]+\\):\\s-+\\)?\\(.*\\)$"
      (1 'git-commit-comment-action-face t t)
      (2 'git-commit-comment-file-face t))
     (,(concat "^\\("
               (regexp-opt git-commit-known-pseudo-headers)
               ":\\)\\(\s.*\\)$")
      (1 'git-commit-known-pseudo-header-face)
      (2 'git-commit-pseudo-header-face))
     ("^\\<\\S-+:\\s-.*$" . 'git-commit-pseudo-header-face)
     (eval . (git-commit-mode-summary-font-lock-keywords))
     ("\\[[^\n]+?\\]" (0 'git-commit-note-face t)) ; Notes override summary line
     ;; Warnings from overlong lines and nonempty second line override
     ;; everything
     (eval . (git-commit-mode-summary-font-lock-keywords t)))
   (git-commit-mode-heading-keywords)))

(defun git-commit-font-lock-diff ()
  "Add font lock on diff."
  (save-excursion
    (goto-char (point-min))
    (when (re-search-forward "^diff --git" nil t)
      (let ((beg (match-beginning 0)))
        (let* ((buffer (current-buffer))
               (font-lock-verbose nil)
               (font-lock-support-mode nil)
               (text (with-temp-buffer
                       (insert
                        (with-current-buffer buffer
                          (buffer-substring-no-properties beg (point-max))))
                       (diff-mode)
                       (font-lock-fontify-buffer)
                       (let ((pos (point-min))
                             next)
                         (while (setq next (next-single-property-change pos 'face))
                           (put-text-property pos next 'font-lock-face
                                              (get-text-property pos 'face))
                           (setq pos next)))
                       (buffer-string))))
          (delete-region beg (point-max))
          (insert text))))))

;;; Mode

(defvar git-commit-mode-syntax-table
  (let ((table (make-syntax-table text-mode-syntax-table)))
    (modify-syntax-entry ?#  "<" table)
    (modify-syntax-entry ?\n ">" table)
    (modify-syntax-entry ?\r ">" table)
    table)
  "Syntax table used by `git-commit-mode'.")

;;;###autoload
(define-derived-mode git-commit-mode text-mode "Git Commit"
  "Major mode for editing git commit messages.

This mode helps with editing git commit messages both by
providing commands to do common tasks, and by highlighting the
basic structure of and errors in git commit messages."
  ;; Font locking
  (setq font-lock-defaults (list (git-commit-mode-font-lock-keywords) t))
  (set (make-local-variable 'font-lock-multiline) t)
  (git-commit-font-lock-diff)
  ;; Filling according to the guidelines
  (setq fill-column git-commit-fill-column)
  ;; Recognize changelog-style paragraphs
  (set (make-local-variable 'paragraph-start)
       (concat paragraph-start "\\|*\\|("))
  ;; Treat lines starting with a hash/pound as comments
  (set (make-local-variable 'comment-start) "#")
  (set (make-local-variable 'comment-start-skip)
       (concat "^" (regexp-quote comment-start) "+"
               "\\s-*"))
  (set (make-local-variable 'comment-use-syntax) nil)
  ;; Do not remember point location in commit messages
  (when (boundp 'save-place)
    (setq save-place nil))
  ;; If the commit summary is empty, insert a newline after point
  (when (string= "" (buffer-substring-no-properties
                     (line-beginning-position)
                     (line-end-position)))
    (open-line 1))
  ;; That's what happens when every little detail is commented
  (make-local-variable 'log-edit-comment-ring-index)
  ;; Make sure `git-commit-abort' cannot be by-passed
  (add-hook 'kill-buffer-query-functions
            'git-commit-kill-buffer-noop nil t)
  ;; Make the wrong usage info from `server-execute' go way
  (run-with-timer 0.01 nil (lambda (m) (message "%s" m))
                  (substitute-command-keys
                   (concat "Type \\[git-commit-commit] "
                           (let ((n (buffer-file-name)))
                             (cond ((equal n "TAG_EDITMSG") "to tag")
                                   ((or (equal n "NOTES_EDITMSG")
                                        (equal n "PULLREQ_EDITMSG"))
                                    "when done")
                                   (t "to commit")))
                           " (\\[git-commit-abort] to abort)."))))

(defun git-commit-kill-buffer-noop ()
  (message
   (substitute-command-keys
    "Don't kill this buffer.  Instead abort using \\[git-commit-abort]."))
  nil)

(defun git-commit-mode-flyspell-verify ()
  (not (nth 4 (syntax-ppss)))) ; not inside a comment

(eval-after-load 'flyspell
  '(put 'git-commit-mode 'flyspell-mode-predicate
        'git-commit-mode-flyspell-verify))

;;;###autoload
(add-to-list 'auto-mode-alist '("/MERGE_MSG\\'" . git-commit-mode))
;;;###autoload
(add-to-list 'auto-mode-alist
             '("/\\(?:COMMIT\\|NOTES\\|TAG\\|PULLREQ\\)_EDITMSG\\'"
               . git-commit-mode))

(defun git-commit-auto-mode-enable ()
  (message "git-commit-auto-mode-enable is obsolete and doesn't do anything"))
(make-obsolete 'git-commit-auto-mode-enable "This mode is a noop now" "")

(provide 'git-commit-mode)
;; Local Variables:
;; indent-tabs-mode: nil
;; End:
;;; git-commit-mode.el ends here