magit.el 24 KB
Newer Older
1
;;; magit.el --- A Git porcelain inside Emacs  -*- lexical-binding: t; coding: utf-8 -*-
Marius Vollmer's avatar
Marius Vollmer committed
2

Jonas Bernoulli's avatar
Jonas Bernoulli committed
3
;; Copyright (C) 2008-2018  The Magit Project Contributors
4
;;
5 6
;; You should have received a copy of the AUTHORS.md file which
;; lists all contributors.  If not, see http://magit.vc/authors.
7

8
;; Author: Marius Vollmer <marius.vollmer@gmail.com>
9
;; Maintainer: Jonas Bernoulli <jonas@bernoul.li>
10 11
;;	Kyle Meyer        <kyle@kyleam.com>
;;	Noam Postavsky    <npostavs@users.sourceforge.net>
12
;; Former-Maintainers:
13
;;	Nicolas Dudebout  <nicolas.dudebout@gatech.edu>
14 15
;;	Peter J. Weisberg <pj@irregularexpressions.net>
;;	Phil Jackson      <phil@shellarchive.co.uk>
16 17
;;	Rémi Vanicat      <vanicat@debian.org>
;;	Yann Hodique      <yann.hodique@gmail.com>
18

19 20
;; Keywords: git tools vc
;; Homepage: https://github.com/magit/magit
Phil Jackson's avatar
Phil Jackson committed
21

22
;; Magit requires at least GNU Emacs 25.1 and Git 2.0.0.
23

Marius Vollmer's avatar
Marius Vollmer committed
24
;; Magit is free software; you can redistribute it and/or modify it
Marius Vollmer's avatar
Marius Vollmer committed
25 26 27
;; 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.
Marius Vollmer's avatar
Marius Vollmer committed
28
;;
Marius Vollmer's avatar
Marius Vollmer committed
29
;; Magit is distributed in the hope that it will be useful, but WITHOUT
Marius Vollmer's avatar
Marius Vollmer committed
30 31 32
;; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
;; or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
;; License for more details.
Marius Vollmer's avatar
Marius Vollmer committed
33 34
;;
;; You should have received a copy of the GNU General Public License
35
;; along with Magit.  If not, see http://www.gnu.org/licenses.
Marius Vollmer's avatar
Marius Vollmer committed
36

37
;;; Commentary:
Marius Vollmer's avatar
Marius Vollmer committed
38

39
;; Magit is an interface to the version control system Git,
40 41 42 43 44 45 46
;; implemented as an Emacs package.  Magit aspires to be a complete
;; Git porcelain.  While we cannot (yet) claim, that Magit wraps and
;; improves upon each and every Git command, it is complete enough to
;; allow even experienced Git users to perform almost all of their
;; daily version control tasks directly from within Emacs.  While many
;; fine Git clients exist, only Magit and Git itself deserve to be
;; called porcelains.
Marius Vollmer's avatar
Marius Vollmer committed
47

Phil Jackson's avatar
Phil Jackson committed
48
;;; Code:
49

50 51 52
(require 'cl-lib)
(require 'dash)

53
(require 'with-editor)
54
(require 'git-commit)
55 56 57 58
(require 'magit-core)
(require 'magit-diff)
(require 'magit-apply)
(require 'magit-log)
59
(require 'magit-repos)
60

61
(require 'format-spec)
62
(require 'package nil t) ; used in `magit-version'
63

64
(defconst magit--minimal-git "2.0.0")
65
(defconst magit--minimal-emacs "25.1")
66

67
;;; Faces
68

69 70
(defface magit-header-line
  '((t :inherit magit-section-heading))
71 72 73 74 75 76 77 78 79
  "Face for the `header-line' in some Magit modes.
Note that some modes, such as `magit-log-select-mode', have their
own faces for the `header-line', or for parts of the
`header-line'."
  :group 'magit-faces)

(defface magit-header-line-key
  '((t :inherit magit-popup-key))
  "Face for keys in the `header-line'."
80 81
  :group 'magit-faces)

Jonas Bernoulli's avatar
Jonas Bernoulli committed
82 83 84 85
(defface magit-dimmed
  '((((class color) (background light)) :foreground "grey50")
    (((class color) (background  dark)) :foreground "grey50"))
  "Face for text that shouldn't stand out."
86
  :group 'magit-faces)
87

Jonas Bernoulli's avatar
Jonas Bernoulli committed
88 89 90 91
(defface magit-hash
  '((((class color) (background light)) :foreground "grey60")
    (((class color) (background  dark)) :foreground "grey40"))
  "Face for the sha1 part of the log output."
92 93
  :group 'magit-faces)

94
(defface magit-tag
95 96
  '((((class color) (background light)) :foreground "Goldenrod4")
    (((class color) (background  dark)) :foreground "LightGoldenrod2"))
97
  "Face for tag labels shown in log buffer."
98
  :group 'magit-faces)
99

100
(defface magit-branch-remote
101 102
  '((((class color) (background light)) :foreground "DarkOliveGreen4")
    (((class color) (background  dark)) :foreground "DarkSeaGreen2"))
103
  "Face for remote branch head labels shown in log buffer."
104
  :group 'magit-faces)
105

106 107 108 109 110 111
(defface magit-branch-remote-head
  '((((class color) (background light)) :inherit magit-branch-remote :box t)
    (((class color) (background  dark)) :inherit magit-branch-remote :box t))
  "Face for current branch."
  :group 'magit-faces)

112
(defface magit-branch-local
113 114
  '((((class color) (background light)) :foreground "SkyBlue4")
    (((class color) (background  dark)) :foreground "LightSkyBlue1"))
115
  "Face for local branches."
116 117
  :group 'magit-faces)

118 119
(defface magit-branch-current
  '((((class color) (background light)) :inherit magit-branch-local :box t)
120
    (((class color) (background  dark)) :inherit magit-branch-local :box t))
121
  "Face for current branch."
122 123
  :group 'magit-faces)

124 125 126 127 128 129 130 131
(defface magit-branch-upstream
  '((t :slant italic))
  "Face for upstream branch.
This face is only used in logs and it gets combined
 with `magit-branch-local', `magit-branch-remote'
and/or `magit-branch-remote-head'."
  :group 'magit-faces)

132
(defface magit-head
133
  '((((class color) (background light)) :inherit magit-branch-local)
134
    (((class color) (background  dark)) :inherit magit-branch-local))
135
  "Face for the symbolic ref `HEAD'."
136 137
  :group 'magit-faces)

138
(defface magit-refname
139 140
  '((((class color) (background light)) :foreground "grey30")
    (((class color) (background  dark)) :foreground "grey80"))
141
  "Face for refnames without a dedicated face."
142 143
  :group 'magit-faces)

144 145
(defface magit-refname-stash
  '((t :inherit magit-refname))
146
  "Face for stash refnames."
147 148
  :group 'magit-faces)

149
(defface magit-refname-wip
150
  '((t :inherit magit-refname))
151
  "Face for wip refnames."
152 153
  :group 'magit-faces)

154 155 156 157 158
(defface magit-refname-pullreq
  '((t :inherit magit-refname))
  "Face for pullreq refnames."
  :group 'magit-faces)

159 160 161
(defface magit-keyword
  '((t :inherit font-lock-string-face))
  "Face for parts of commit messages inside brackets."
162 163 164 165 166
  :group 'magit-faces)

(defface magit-keyword-squash
  '((t :inherit font-lock-warning-face))
  "Face for squash! and fixup! keywords in commit messages."
167 168
  :group 'magit-faces)

169 170 171 172 173 174
(defface magit-signature-good
  '((t :foreground "green"))
  "Face for good signatures."
  :group 'magit-faces)

(defface magit-signature-bad
175
  '((t :foreground "red" :weight bold))
176 177 178 179 180 181 182 183
  "Face for bad signatures."
  :group 'magit-faces)

(defface magit-signature-untrusted
  '((t :foreground "cyan"))
  "Face for good untrusted signatures."
  :group 'magit-faces)

184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203
(defface magit-signature-expired
  '((t :foreground "orange"))
  "Face for signatures that have expired."
  :group 'magit-faces)

(defface magit-signature-expired-key
  '((t :inherit magit-signature-expired))
  "Face for signatures made by an expired key."
  :group 'magit-faces)

(defface magit-signature-revoked
  '((t :foreground "violet red"))
  "Face for signatures made by a revoked key."
  :group 'magit-faces)

(defface magit-signature-error
  '((t :foreground "firebrick3"))
  "Face for signatures that cannot be checked (e.g. missing key)."
  :group 'magit-faces)

204 205
(defface magit-cherry-unmatched
  '((t :foreground "cyan"))
206 207
  "Face for unmatched cherry commits."
  :group 'magit-faces)
208 209 210

(defface magit-cherry-equivalent
  '((t :foreground "magenta"))
211 212
  "Face for equivalent cherry commits."
  :group 'magit-faces)
213

214 215 216 217 218
(defface magit-filename
  '((t :weight normal))
  "Face for filenames."
  :group 'magit-faces)

219
;;; Dispatch Popup
220

Jonas Bernoulli's avatar
Jonas Bernoulli committed
221
;;;###autoload (autoload 'magit-dispatch-popup "magit" nil t)
222 223
(magit-define-popup magit-dispatch-popup
  "Popup console for dispatching other popups."
224
  :actions '("Popup and dwim commands"
225 226
             (?A "Cherry-picking"  magit-cherry-pick-popup)
             (?b "Branching"       magit-branch-popup)
227 228 229
             (?B "Bisecting"       magit-bisect-popup)
             (?c "Committing"      magit-commit-popup)
             (?d "Diffing"         magit-diff-popup)
230 231 232
             (?D "Change diffs"    magit-diff-refresh-popup)
             (?e "Ediff dwimming"  magit-ediff-dwim)
             (?E "Ediffing"        magit-ediff-popup)
233 234 235
             (?f "Fetching"        magit-fetch-popup)
             (?F "Pulling"         magit-pull-popup)
             (?l "Logging"         magit-log-popup)
236
             (?L "Change logs"     magit-log-refresh-popup)
237 238
             (?m "Merging"         magit-merge-popup)
             (?M "Remoting"        magit-remote-popup)
239
             (?o "Submodules"      magit-submodule-popup)
240
             (?O "Subtrees"        magit-subtree-popup)
241 242 243
             (?P "Pushing"         magit-push-popup)
             (?r "Rebasing"        magit-rebase-popup)
             (?t "Tagging"         magit-tag-popup)
244
             (?T "Notes"           magit-notes-popup)
245
             (?V "Reverting"       magit-revert-popup)
246 247
             (?w "Apply patches"   magit-am-popup)
             (?W "Format patches"  magit-patch-popup)
248
             (?X "Resetting"       magit-reset-popup)
249
             (?y "Show Refs"       magit-show-refs-popup)
250 251
             (?z "Stashing"        magit-stash-popup)
             (?! "Running"         magit-run-popup)
252
             (?% "Worktree"        magit-worktree-popup)
253 254 255 256
             (lambda ()
               (and (with-current-buffer magit-pre-popup-buffer
                      (derived-mode-p 'magit-mode))
                    (propertize "Applying changes" 'face 'magit-popup-heading)))
257 258 259 260 261 262 263
             (?a "Apply"           magit-apply)
             (?s "Stage"           magit-stage)
             (?u "Unstage"         magit-unstage)
             (?v "Reverse"         magit-reverse)
             (?S "Stage all"       magit-stage-modified)
             (?U "Unstage all"     magit-unstage-all)
             (?k "Discard"         magit-discard)
264 265 266 267
             (lambda ()
               (and (with-current-buffer magit-pre-popup-buffer
                      (derived-mode-p 'magit-mode))
                    (propertize "Essential commands" 'face 'magit-popup-heading)))
268
             (?g  "    refresh current buffer"   magit-refresh)
269
             ;; These bindings only work because of :setup-function.
270 271
             (?\t   "  toggle section at point"  magit-section-toggle)
             (?\r   "  visit thing at point"     magit-visit-thing)
272 273
             ;; This binding has no effect and only appears to do
             ;; so because it is identical to the global binding.
274
             ("C-h m" "show all key bindings"    describe-mode))
275
  :setup-function 'magit-dispatch-popup-setup
276 277 278 279
  :max-action-columns (lambda (heading)
                        (pcase heading
                          ("Popup and dwim commands" 4)
                          ("Applying changes" 3)
280
                          ("Essential commands" 1))))
281

282
(defvar magit-dispatch-popup-map
Jonas Bernoulli's avatar
Jonas Bernoulli committed
283
  (let ((map (make-sparse-keymap)))
284
    (set-keymap-parent map magit-popup-mode-map)
285 286 287 288 289 290
    (cond ((featurep 'jkl)
           (define-key map [tab]    'magit-invoke-popup-action)
           (define-key map [return] 'magit-invoke-popup-action))
          (t
           (define-key map (kbd "C-i") 'magit-invoke-popup-action)
           (define-key map (kbd "C-m") 'magit-invoke-popup-action)))
291 292 293
    map)
  "Keymap used by `magit-dispatch-popup'.")

294 295
(defun magit-dispatch-popup-setup (val def)
  (magit-popup-default-setup val def)
296 297 298 299
  (use-local-map magit-dispatch-popup-map)
  ;; This is necessary for users (i.e. me) who have broken the
  ;; connection between C-i (aka TAB) and tab, and C-m (aka RET)
  ;; and return.
300 301 302 303 304
  (magit-popup-put
   :actions (nconc (magit-popup-get :actions)
                   (list (make-magit-popup-event :key 'tab
                                                 :fun 'magit-section-toggle)
                         (make-magit-popup-event :key 'return
305
                                                 :fun 'magit-visit-thing)))))
306

307
;;; Git Popup
308

309 310 311 312
(defcustom magit-shell-command-verbose-prompt t
  "Whether to show the working directory when reading a command.
This affects `magit-git-command', `magit-git-command-topdir',
`magit-shell-command', and `magit-shell-command-topdir'."
313
  :package-version '(magit . "2.11.0")
314 315 316
  :group 'magit-commands
  :type 'boolean)

317 318
(defvar magit-git-command-history nil)

Jonas Bernoulli's avatar
Jonas Bernoulli committed
319
;;;###autoload (autoload 'magit-run-popup "magit" nil t)
320 321
(magit-define-popup magit-run-popup
  "Popup console for running raw Git commands."
322 323 324
  :actions '((?! "Git Subcommand (in topdir)" magit-git-command-topdir)
             (?k "Gitk"                       magit-run-gitk)
             (?p "Git Subcommand (in pwd)"    magit-git-command)
325
             (?a "Gitk --all"                 magit-run-gitk-all)
326
             (?s "Shell command (in topdir)"  magit-shell-command-topdir)
327 328 329
             (?b "Gitk --branches"            magit-run-gitk-branches)
             (?S "Shell command (in pwd)"     magit-shell-command)
             (?g "Git Gui"                    magit-run-git-gui))
330 331
  :default-action 'magit-git-command
  :max-action-columns 2)
332 333

;;;###autoload
334
(defun magit-git-command (command)
Philipp Stephani's avatar
Philipp Stephani committed
335
  "Execute COMMAND asynchronously; display output.
336 337 338 339 340 341

Interactively, prompt for COMMAND in the minibuffer. \"git \" is
used as initial input, but can be deleted to run another command.

With a prefix argument COMMAND is run in the top-level directory
of the current working tree, otherwise in `default-directory'."
342
  (interactive (list (magit-read-shell-command nil "git ")))
343
  (magit--shell-command command))
344

345
;;;###autoload
346
(defun magit-git-command-topdir (command)
Philipp Stephani's avatar
Philipp Stephani committed
347
  "Execute COMMAND asynchronously; display output.
348 349 350 351 352 353

Interactively, prompt for COMMAND in the minibuffer. \"git \" is
used as initial input, but can be deleted to run another command.

COMMAND is run in the top-level directory of the current
working tree."
354
  (interactive (list (magit-read-shell-command t "git ")))
355
  (magit--shell-command command (magit-toplevel)))
356 357

;;;###autoload
358
(defun magit-shell-command (command)
Philipp Stephani's avatar
Philipp Stephani committed
359
  "Execute COMMAND asynchronously; display output.
360 361 362 363

Interactively, prompt for COMMAND in the minibuffer.  With a
prefix argument COMMAND is run in the top-level directory of
the current working tree, otherwise in `default-directory'."
364
  (interactive (list (magit-read-shell-command)))
365
  (magit--shell-command command))
366 367

;;;###autoload
368
(defun magit-shell-command-topdir (command)
Philipp Stephani's avatar
Philipp Stephani committed
369
  "Execute COMMAND asynchronously; display output.
370 371 372

Interactively, prompt for COMMAND in the minibuffer.  COMMAND
is run in the top-level directory of the current working tree."
373
  (interactive (list (magit-read-shell-command t)))
374 375 376
  (magit--shell-command command (magit-toplevel)))

(defun magit--shell-command (command &optional directory)
377 378 379
  (let ((default-directory (or directory default-directory))
        (process-environment process-environment))
    (push "GIT_PAGER=cat" process-environment)
380 381 382
    (magit-start-process shell-file-name nil
                         shell-command-switch command))
  (magit-process-buffer))
383

384 385 386 387
(defun magit-read-shell-command (&optional toplevel initial-input)
  (let ((dir (abbreviate-file-name
              (if (or toplevel current-prefix-arg)
                  (or (magit-toplevel)
388
                      (magit--not-inside-repository-error))
389 390 391 392
                default-directory))))
    (read-shell-command (if magit-shell-command-verbose-prompt
                            (format "Async shell command in %s: " dir)
                          "Async shell command: ")
393
                        initial-input 'magit-git-command-history)))
394

395
;;; Font-Lock Keywords
396

397 398
(defconst magit-font-lock-keywords
  (eval-when-compile
399 400 401
    `((,(concat "(\\(magit-define-section-jumper\\)\\_>"
                "[ \t'\(]*"
                "\\(\\(?:\\sw\\|\\s_\\)+\\)?")
402 403
       (1 'font-lock-keyword-face)
       (2 'font-lock-function-name-face nil t))
404 405 406
      (,(concat "(" (regexp-opt '("magit-insert-section"
                                  "magit-section-case"
                                  "magit-bind-match-strings"
407
                                  "magit-with-temp-index"
408 409
                                  "magit-with-blob"
                                  "magit-with-toplevel") t)
410
                "\\_>")
411 412 413
       . 1))))

(font-lock-add-keywords 'emacs-lisp-mode magit-font-lock-keywords)
414

415
;;; Version
416

417 418 419 420
(defvar magit-version 'undefined
  "The version of Magit that you're using.
Use the function by the same name instead of this variable.")

421
;;;###autoload
422
(defun magit-version (&optional print-dest)
423
  "Return the version of Magit currently in use.
424
If optional argument PRINT-DEST is non-nil, output
425 426 427 428
stream (interactively, the echo area, or the current buffer with
a prefix argument), also print the used versions of Magit, Git,
and Emacs to it."
  (interactive (list (if current-prefix-arg (current-buffer) t)))
429
  (let ((magit-git-global-arguments nil)
430 431
        (toplib (or load-file-name buffer-file-name))
        debug)
432 433
    (unless (and toplib
                 (equal (file-name-nondirectory toplib) "magit.el"))
434 435
      (setq toplib (locate-library "magit.el")))
    (setq toplib (and toplib (file-chase-links toplib)))
436
    (push toplib debug)
437
    (when toplib
438
      (let* ((topdir (file-name-directory toplib))
439
             (gitdir (expand-file-name
440 441
                      ".git" (file-name-directory
                              (directory-file-name topdir))))
442 443
             (static (locate-library "magit-version.el" nil (list topdir)))
             (static (and static (file-chase-links static))))
444 445 446 447 448 449 450 451 452
        (or (progn
              (push 'repo debug)
              (when (and (file-exists-p gitdir)
                         ;; It is a repo, but is it the Magit repo?
                         (file-exists-p
                          (expand-file-name "../lisp/magit.el" gitdir)))
                (push t debug)
                ;; Inside the repo the version file should only exist
                ;; while running make.
453
                (when (and static (not noninteractive))
454 455 456 457 458 459
                  (ignore-errors (delete-file static)))
                (setq magit-version
                      (let ((default-directory topdir))
                        (magit-git-string "describe" "--tags" "--dirty")))))
            (progn
              (push 'static debug)
460
              (when (and static (file-exists-p static))
461 462 463 464 465 466 467 468 469 470 471
                (push t debug)
                (load-file static)
                magit-version))
            (when (featurep 'package)
              (push 'elpa debug)
              (ignore-errors
                (--when-let (assq 'magit package-alist)
                  (push t debug)
                  (setq magit-version
                        (and (fboundp 'package-desc-version)
                             (package-version-join
472 473 474 475 476 477 478 479
                              (package-desc-version (cadr it))))))))
            (progn
              (push 'debug debug)
              (let ((dirname (file-name-nondirectory
                              (directory-file-name topdir))))
                (when (string-match "\\`magit-\\([0-9]\\{8\\}\\.[0-9]*\\)"
                                    dirname)
                  (setq magit-version (match-string 1 dirname))))))))
480
    (if (stringp magit-version)
481 482 483
        (when print-dest
          (princ (format "Magit %s, Git %s, Emacs %s, %s"
                         (or magit-version "(unknown)")
484 485 486 487 488 489
                         (or (let ((magit-git-debug
                                    (lambda (err)
                                      (display-warning '(magit git)
                                                       err :error))))
                               (magit-git-version t))
                             "(unknown)")
490 491 492
                         emacs-version
                         system-type)
                 print-dest))
493
      (setq debug (reverse debug))
494
      (setq magit-version 'error)
495 496
      (when magit-version
        (push magit-version debug))
497
      (unless (equal (getenv "TRAVIS") "true")
498 499
        ;; The repository is a sparse clone.
        (message "Cannot determine Magit's version %S" debug)))
500 501
    magit-version))

502 503
;;; Debugging Tools

504
(defun magit-debug-git-executable ()
505 506
  "Display a buffer with information about `magit-git-executable'.
See info node `(magit)Debugging Tools' for more information."
507 508 509 510
  (interactive)
  (with-current-buffer (get-buffer-create "*magit-git-debug*")
    (pop-to-buffer (current-buffer))
    (erase-buffer)
511 512
    (insert (concat
             (format "magit-git-executable: %S" magit-git-executable)
513 514
             (and (not (file-name-absolute-p magit-git-executable))
                  (format " [%S]" (executable-find magit-git-executable)))
515 516 517 518
             (format " (%s)\n"
                     (let* ((errmsg nil)
                            (magit-git-debug (lambda (err) (setq errmsg err))))
                       (or (magit-git-version t) errmsg)))))
519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537
    (insert (format "exec-path: %S\n" exec-path))
    (--when-let (cl-set-difference
                 (-filter #'file-exists-p (remq nil (parse-colon-path
                                                     (getenv "PATH"))))
                 (-filter #'file-exists-p (remq nil exec-path))
                 :test #'file-equal-p)
      (insert (format "  entries in PATH, but not in exec-path: %S\n" it)))
    (dolist (execdir exec-path)
      (insert (format "  %s (%s)\n" execdir (car (file-attributes execdir))))
      (when (file-directory-p execdir)
        (dolist (exec (directory-files
                       execdir t (concat
                                  "\\`git" (regexp-opt exec-suffixes) "\\'")))
          (insert (format "    %s (%s)\n" exec
                          (let* ((magit-git-executable exec)
                                 (errmsg nil)
                                 (magit-git-debug (lambda (err) (setq errmsg err))))
                            (or (magit-git-version t) errmsg)))))))))

538
;;; Startup Asserts
539

540
(defun magit-startup-asserts ()
541 542 543 544 545 546 547 548
  (when-let ((val (getenv "GIT_DIR")))
    (setenv "GIT_DIR")
    (message "Magit unset $GIT_DIR (was %S).  See \
https://github.com/magit/magit/wiki/Don't-set-$GIT_DIR-and-alike" val))
  (when-let ((val (getenv "GIT_WORK_TREE")))
    (setenv "GIT_WORK_TREE")
    (message "Magit unset $GIT_WORK_TREE (was %S).  See \
https://github.com/magit/magit/wiki/Don't-set-$GIT_DIR-and-alike" val))
549
  (let ((version (magit-git-version)))
550 551 552 553
    (when (and version
               (version< version magit--minimal-git)
               (not (equal (getenv "TRAVIS") "true")))
      (display-warning 'magit (format "\
554
Magit requires Git >= %s, you are using %s.
555 556 557 558 559 560 561 562 563 564 565 566

If this comes as a surprise to you, because you do actually have
a newer version installed, then that probably means that the
older version happens to appear earlier on the `$PATH'.  If you
always start Emacs from a shell, then that can be fixed in the
shell's init file.  If you start Emacs by clicking on an icon,
or using some sort of application launcher, then you probably
have to adjust the environment as seen by graphical interface.
For X11 something like ~/.xinitrc should work.

If you use Tramp to work inside remote Git repositories, then you
have to make sure a suitable Git is used on the remote machines
567 568
too.\n" magit--minimal-git version) :error)))
  (when (version< emacs-version magit--minimal-emacs)
569
    (display-warning 'magit (format "\
570
Magit requires Emacs >= %s, you are using %s.
571 572 573 574 575 576 577 578

If this comes as a surprise to you, because you do actually have
a newer version installed, then that probably means that the
older version happens to appear earlier on the `$PATH'.  If you
always start Emacs from a shell, then that can be fixed in the
shell's init file.  If you start Emacs by clicking on an icon,
or using some sort of application launcher, then you probably
have to adjust the environment as seen by graphical interface.
579 580
For X11 something like ~/.xinitrc should work.\n"
                                    magit--minimal-emacs emacs-version)
581
                     :error)))
582

583
;;; Loading Libraries
584

Remi Vanicat's avatar
Remi Vanicat committed
585
(provide 'magit)
Roger Crew's avatar
Roger Crew committed
586

587
(cl-eval-when (load eval)
588
  (require 'magit-status)
589
  (require 'magit-refs)
590
  (require 'magit-files)
591
  (require 'magit-collab)
592
  (require 'magit-reset)
593
  (require 'magit-branch)
594 595
  (require 'magit-merge)
  (require 'magit-tag)
596
  (require 'magit-worktree)
597
  (require 'magit-notes)
598 599 600
  (require 'magit-sequence)
  (require 'magit-commit)
  (require 'magit-remote)
601 602 603 604
  (require 'magit-clone)
  (require 'magit-fetch)
  (require 'magit-pull)
  (require 'magit-push)
605 606
  (require 'magit-bisect)
  (require 'magit-stash)
607
  (require 'magit-blame)
608
  (require 'magit-obsolete)
609
  (require 'magit-submodule)
610
  (unless (load "magit-autoloads" t t)
611
    (require 'magit-subtree)
612
    (require 'magit-ediff)
613
    (require 'magit-extras)
614
    (require 'git-rebase)
Yuri Khan's avatar
Yuri Khan committed
615 616 617 618 619
    (require 'magit-imenu)
    (require 'magit-bookmark)))

(eval-after-load 'bookmark
  '(require 'magit-bookmark))
620

621
(if after-init-time
622 623 624 625
    (progn (magit-startup-asserts)
           (magit-version))
  (add-hook 'after-init-hook #'magit-startup-asserts t)
  (add-hook 'after-init-hook #'magit-version t))
626

627
;;; magit.el ends here