.emacs.d.git - Gitblit

Chizi123

2018-11-18 21067e7cbe6d7a0f65ff5c317a96b5c337b0b3d8

commit \| author \| age
5cb5f7	1	;;; magit-status.el --- the grand overview -- lexical-binding: t --
C	2
	3	;; Copyright (C) 2010-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	;; This library implements the status buffer.
	27
	28	;;; Code:
	29
	30	(eval-when-compile
	31	(require 'subr-x))
	32
	33	(require 'magit)
	34
	35	(defvar bookmark-make-record-function)
	36
	37	;;; Options
	38
	39	(defgroup magit-status nil
	40	"Inspect and manipulate Git repositories."
	41	:link '(info-link "(magit)Status Buffer")
	42	:group 'magit-modes)
	43
	44	(defcustom magit-status-mode-hook nil
	45	"Hook run after entering Magit-Status mode."
	46	:group 'magit-status
	47	:type 'hook)
	48
	49	(defcustom magit-status-headers-hook
	50	'(magit-insert-error-header
	51	magit-insert-diff-filter-header
	52	magit-insert-head-branch-header
	53	magit-insert-upstream-branch-header
	54	magit-insert-push-branch-header
	55	magit-insert-tags-header)
	56	"Hook run to insert headers into the status buffer.
	57
	58	This hook is run by `magit-insert-status-headers', which in turn
	59	has to be a member of `magit-status-sections-hook' to be used at
	60	all."
	61	:package-version '(magit . "2.1.0")
	62	:group 'magit-status
	63	:type 'hook
	64	:options '(magit-insert-error-header
	65	magit-insert-diff-filter-header
	66	magit-insert-repo-header
	67	magit-insert-remote-header
	68	magit-insert-head-branch-header
	69	magit-insert-upstream-branch-header
	70	magit-insert-push-branch-header
	71	magit-insert-tags-header))
	72
	73	(defcustom magit-status-sections-hook
	74	'(magit-insert-status-headers
	75	magit-insert-merge-log
	76	magit-insert-rebase-sequence
	77	magit-insert-am-sequence
	78	magit-insert-sequencer-sequence
	79	magit-insert-bisect-output
	80	magit-insert-bisect-rest
	81	magit-insert-bisect-log
	82	magit-insert-untracked-files
	83	magit-insert-unstaged-changes
	84	magit-insert-staged-changes
	85	magit-insert-stashes
	86	magit-insert-unpushed-to-pushremote
	87	magit-insert-unpushed-to-upstream-or-recent
	88	magit-insert-unpulled-from-pushremote
	89	magit-insert-unpulled-from-upstream)
	90	"Hook run to insert sections into a status buffer."
	91	:package-version '(magit . "2.12.0")
	92	:group 'magit-status
	93	:type 'hook)
	94
	95	(defcustom magit-status-initial-section '(1)
	96	"The section point is placed on when a status buffer is created.
	97
	98	When such a buffer is merely being refreshed or being shown again
	99	after it was merely burried, then this option has no effect.
	100
	101	If this is nil, then point remains on the very first section as
	102	usual. Otherwise it has to be a list of integers and section
	103	identity lists. The members of that list are tried in order
	104	until a matching section is found.
	105
	106	An integer means to jump to the nth section, 1 for example
	107	jumps over the headings. To get a section's \"identity list\"
	108	use \\[universal-argument] \\[magit-describe-section-briefly].
	109
	110	If, for example, you want to jump to the commits that haven't
	111	been pulled from the upstream, or else the second section, then
	112	use: (((unpulled . \"..@{upstream}\") (status)) 1).
	113
	114	See option `magit-section-initial-visibility-alist' for how to
	115	control the initial visibility of the jumped to section."
	116	:package-version '(magit . "2.90.0")
	117	:group 'magit-status
	118	:type '(choice (const :tag "as usual" nil)
	119	(repeat (choice (number :tag "nth top-level section")
	120	(sexp :tag "section identity")))))
	121
	122	(defcustom magit-status-show-hashes-in-headers nil
	123	"Whether headers in the status buffer show hashes.
	124	The functions which respect this option are
	125	`magit-insert-head-branch-header',
	126	`magit-insert-upstream-branch-header', and
	127	`magit-insert-push-branch-header'."
	128	:package-version '(magit . "2.4.0")
	129	:group 'magit-status
	130	:type 'boolean)
	131
	132	(defcustom magit-status-margin
	133	(list nil
	134	(nth 1 magit-log-margin)
	135	'magit-log-margin-width nil
	136	(nth 4 magit-log-margin))
	137	"Format of the margin in `magit-status-mode' buffers.
	138
	139	The value has the form (INIT STYLE WIDTH AUTHOR AUTHOR-WIDTH).
	140
	141	If INIT is non-nil, then the margin is shown initially.
	142	STYLE controls how to format the committer date. It can be one
	143	of `age' (to show the age of the commit), `age-abbreviated' (to
	144	abbreviate the time unit to a character), or a string (suitable
	145	for `format-time-string') to show the actual date.
	146	WIDTH controls the width of the margin. This exists for forward
	147	compatibility and currently the value should not be changed.
	148	AUTHOR controls whether the name of the author is also shown by
	149	default.
	150	AUTHOR-WIDTH has to be an integer. When the name of the author
	151	is shown, then this specifies how much space is used to do so."
	152	:package-version '(magit . "2.9.0")
	153	:group 'magit-status
	154	:group 'magit-margin
	155	:type magit-log-margin--custom-type
	156	:initialize 'magit-custom-initialize-reset
	157	:set-after '(magit-log-margin)
	158	:set (apply-partially #'magit-margin-set-variable 'magit-status-mode))
	159
	160	;;; Commands
	161
	162	;;;###autoload
	163	(defun magit-init (directory)
	164	"Initialize a Git repository, then show its status.
	165
	166	If the directory is below an existing repository, then the user
	167	has to confirm that a new one should be created inside. If the
	168	directory is the root of the existing repository, then the user
	169	has to confirm that it should be reinitialized.
	170
	171	Non-interactively DIRECTORY is (re-)initialized unconditionally."
	172	(interactive
	173	(let ((directory (file-name-as-directory
	174	(expand-file-name
	175	(read-directory-name "Create repository in: ")))))
	176	(when-let ((toplevel (magit-toplevel directory)))
	177	(setq toplevel (expand-file-name toplevel))
	178	(unless (y-or-n-p (if (file-equal-p toplevel directory)
	179	(format "Reinitialize existing repository %s? "
	180	directory)
	181	(format "%s is a repository. Create another in %s? "
	182	toplevel directory)))
	183	(user-error "Abort")))
	184	(list directory)))
	185	;; `git init' does not understand the meaning of "~"!
	186	(magit-call-git "init" (magit-convert-filename-for-git
	187	(expand-file-name directory)))
	188	(magit-status-internal directory))
	189
	190	;;;###autoload
	191	(defun magit-status (&optional directory cache)
	192	"Show the status of the current Git repository in a buffer.
	193	With a prefix argument prompt for a repository to be shown.
	194	With two prefix arguments prompt for an arbitrary directory.
	195	If that directory isn't the root of an existing repository,
	196	then offer to initialize it as a new repository."
	197	(interactive
	198	(let ((magit--refresh-cache (list (cons 0 0))))
	199	(list (and (or current-prefix-arg (not (magit-toplevel)))
	200	(magit-read-repository
	201	(>= (prefix-numeric-value current-prefix-arg) 16)))
	202	magit--refresh-cache)))
	203	(let ((magit--refresh-cache (or cache (list (cons 0 0)))))
	204	(if directory
	205	(let ((toplevel (magit-toplevel directory)))
	206	(setq directory (file-name-as-directory
	207	(expand-file-name directory)))
	208	(if (and toplevel (file-equal-p directory toplevel))
	209	(magit-status-internal directory)
	210	(when (y-or-n-p
	211	(if toplevel
	212	(format "%s is a repository. Create another in %s? "
	213	toplevel directory)
	214	(format "Create repository in %s? " directory)))
	215	;; Creating a new repository will invalidate cached
	216	;; values.
	217	(setq magit--refresh-cache nil)
	218	(magit-init directory))))
	219	(magit-status-internal default-directory))))
	220
	221	(put 'magit-status 'interactive-only 'magit-status-internal)
	222
	223	(defalias 'magit 'magit-status
	224	"An alias for `magit-status' for better discoverability.
	225
	226	Instead of invoking this alias for `magit-status' using
	227	\"M-x magit RET\", you should bind a key to `magit-status'
	228	and read the info node `(magit)Getting Started', which
	229	also contains other useful hints.")
	230
	231	;;;###autoload
	232	(defun magit-status-internal (directory)
	233	(magit--tramp-asserts directory)
	234	(let ((default-directory directory))
	235	(magit-mode-setup #'magit-status-mode)))
	236
	237	(defvar magit--remotes-using-recent-git nil)
	238
	239	(defun magit--tramp-asserts (directory)
	240	(when-let ((remote (file-remote-p directory)))
	241	(unless (member remote magit--remotes-using-recent-git)
	242	(if-let ((version (let ((default-directory directory))
	243	(magit-git-version))))
	244	(if (version<= magit--minimal-git version)
	245	(push version magit--remotes-using-recent-git)
	246	(display-warning 'magit (format "\
	247	Magit requires Git >= %s, but on %s the version is %s.
	248
	249	If multiple Git versions are installed on the host, then the
	250	problem might be that TRAMP uses the wrong executable.
	251
	252	First check the value of `magit-git-executable'. Its value is
	253	used when running git locally as well as when running it on a
	254	remote host. The default value is \"git\", except on Windows
	255	where an absolute path is used for performance reasons.
	256
	257	If the value already is just \"git\" but TRAMP never-the-less
	258	doesn't use the correct executable, then consult the info node
	259	`(tramp)Remote programs'.\n" magit--minimal-git remote version) :error))
	260	(display-warning 'magit (format "\
	261	Magit cannot find Git on %s.
	262
	263	First check the value of `magit-git-executable'. Its value is
	264	used when running git locally as well as when running it on a
	265	remote host. The default value is \"git\", except on Windows
	266	where an absolute path is used for performance reasons.
	267
	268	If the value already is just \"git\" but TRAMP never-the-less
	269	doesn't find the executable, then consult the info node
	270	`(tramp)Remote programs'.\n" remote) :error)))))
	271
	272	;;; Mode
	273
	274	(defvar magit-status-mode-map
	275	(let ((map (make-sparse-keymap)))
	276	(set-keymap-parent map magit-mode-map)
	277	(define-key map "jz" 'magit-jump-to-stashes)
	278	(define-key map "jt" 'magit-jump-to-tracked)
	279	(define-key map "jn" 'magit-jump-to-untracked)
	280	(define-key map "ju" 'magit-jump-to-unstaged)
	281	(define-key map "js" 'magit-jump-to-staged)
	282	(define-key map "jfu" 'magit-jump-to-unpulled-from-upstream)
	283	(define-key map "jfp" 'magit-jump-to-unpulled-from-pushremote)
	284	(define-key map "jpu" 'magit-jump-to-unpushed-to-upstream)
	285	(define-key map "jpp" 'magit-jump-to-unpushed-to-pushremote)
	286	(define-key map [remap dired-jump] 'magit-dired-jump)
	287	map)
	288	"Keymap for `magit-status-mode'.")
	289
	290	(define-derived-mode magit-status-mode magit-mode "Magit"
	291	"Mode for looking at Git status.
	292
	293	This mode is documented in info node `(magit)Status Buffer'.
	294
	295	\\<magit-mode-map>\
	296	Type \\[magit-refresh] to refresh the current buffer.
	297	Type \\[magit-section-toggle] to expand or hide the section at point.
	298	Type \\[magit-visit-thing] to visit the change or commit at point.
	299
	300	Type \\[magit-dispatch-popup] to see available prefix popups.
	301
	302	Staging and applying changes is documented in info node
	303	`(magit)Staging and Unstaging' and info node `(magit)Applying'.
	304
	305	\\<magit-hunk-section-map>Type \
	306	\\[magit-apply] to apply the change at point, \
	307	\\[magit-stage] to stage,
	308	\\[magit-unstage] to unstage, \
	309	\\[magit-discard] to discard, or \
	310	\\[magit-reverse] to reverse it.
	311
	312	\\<magit-status-mode-map>\
	313	Type \\[magit-commit-popup] to create a commit.
	314
	315	\\{magit-status-mode-map}"
	316	:group 'magit-status
	317	(hack-dir-local-variables-non-file-buffer)
	318	(setq imenu-create-index-function
	319	'magit-imenu--status-create-index-function)
	320	(setq-local bookmark-make-record-function
	321	#'magit-bookmark--status-make-record))
	322
	323	(defun magit-status-refresh-buffer ()
	324	(magit-git-exit-code "update-index" "--refresh")
	325	(magit-insert-section (status)
	326	(magit-run-section-hook 'magit-status-sections-hook)))
	327
	328	(defun magit-status-goto-initial-section ()
	329	"In a `magit-status-mode' buffer, jump `magit-status-initial-section'.
	330	Actually doing so is deferred until `magit-refresh-buffer-hook'
	331	runs `magit-status-goto-initial-section-1'. That function then
	332	removes itself from the hook, so that this only happens when the
	333	status buffer is first created."
	334	(when (and magit-status-initial-section
	335	(derived-mode-p 'magit-status-mode))
	336	(add-hook 'magit-refresh-buffer-hook
	337	'magit-status-goto-initial-section-1 nil t)))
	338
	339	(defun magit-status-goto-initial-section-1 ()
	340	"In a `magit-status-mode' buffer, jump `magit-status-initial-section'.
	341	This function removes itself from `magit-refresh-buffer-hook'."
	342	(when-let ((section
	343	(--some (if (integerp it)
	344	(nth (1- it)
	345	(magit-section-siblings (magit-current-section)
	346	'next))
	347	(magit-get-section it))
	348	magit-status-initial-section)))
	349	(goto-char (oref section start))
	350	(when-let ((vis (cdr (assq 'magit-status-initial-section
	351	magit-section-initial-visibility-alist))))
	352	(if (eq vis 'hide)
	353	(magit-section-hide section)
	354	(magit-section-show section))))
	355	(remove-hook 'magit-refresh-buffer-hook
	356	'magit-status-goto-initial-section-1 t))
	357
	358	(defun magit-status-maybe-update-revision-buffer (&optional _)
	359	"When moving in the status buffer, update the revision buffer.
	360	If there is no revision buffer in the same frame, then do nothing."
	361	(when (derived-mode-p 'magit-status-mode)
	362	(magit-log-maybe-update-revision-buffer-1)))
	363
	364	(defun magit-status-maybe-update-blob-buffer (&optional _)
	365	"When moving in the status buffer, update the blob buffer.
	366	If there is no blob buffer in the same frame, then do nothing."
	367	(when (derived-mode-p 'magit-status-mode)
	368	(magit-log-maybe-update-blob-buffer-1)))
	369
	370	;;; Sections
	371	;;;; Special Headers
	372
	373	(defun magit-insert-status-headers ()
	374	"Insert header sections appropriate for `magit-status-mode' buffers.
	375	The sections are inserted by running the functions on the hook
	376	`magit-status-headers-hook'."
	377	(if (magit-rev-verify "HEAD")
	378	(magit-insert-headers 'magit-status-headers-hook)
	379	(insert "In the beginning there was darkness\n\n")))
	380
	381	(defvar magit-error-section-map
	382	(let ((map (make-sparse-keymap)))
	383	(define-key map [remap magit-visit-thing] 'magit-process-buffer)
	384	map)
	385	"Keymap for `error' sections.")
	386
	387	(defun magit-insert-error-header ()
	388	"Insert the message about the Git error that just occured.
	389
	390	This function is only aware of the last error that occur when Git
	391	was run for side-effects. If, for example, an error occurs while
	392	generating a diff, then that error won't be inserted. Refreshing
	393	the status buffer causes this section to disappear again."
	394	(when magit-this-error
	395	(magit-insert-section (error 'git)
	396	(insert (propertize (format "%-10s" "GitError! ")
	397	'face 'magit-section-heading))
	398	(insert (propertize magit-this-error 'face 'font-lock-warning-face))
	399	(when-let ((key (car (where-is-internal 'magit-process-buffer))))
	400	(insert (format " [Type `%s' for details]" (key-description key))))
	401	(insert ?\n))
	402	(setq magit-this-error nil)))
	403
	404	(defun magit-insert-diff-filter-header ()
	405	"Insert a header line showing the effective diff filters."
	406	(let ((ignore-modules (magit-ignore-submodules-p)))
	407	(when (or ignore-modules
	408	magit-diff-section-file-args)
	409	(insert (propertize (format "%-10s" "Filter! ")
	410	'face 'magit-section-heading))
	411	(when ignore-modules
	412	(insert ignore-modules)
	413	(when magit-diff-section-file-args
	414	(insert " -- ")))
	415	(when magit-diff-section-file-args
	416	(insert (mapconcat #'identity magit-diff-section-file-args " ")))
	417	(insert ?\n))))
	418
	419	;;;; Reference Headers
	420
	421	(cl-defun magit-insert-head-branch-header
	422	(&optional (branch (magit-get-current-branch)))
	423	"Insert a header line about BRANCH.
	424	When BRANCH is nil, use the current branch or, if none, the
	425	detached `HEAD'."
	426	(let ((output (magit-rev-format "%h %s" (or branch "HEAD"))))
	427	(string-match "^\\([^ ]+\\) \\(.*\\)" output)
	428	(magit-bind-match-strings (commit summary) output
	429	(if branch
	430	(magit-insert-section (branch branch)
	431	(insert (format "%-10s" "Head: "))
	432	(when magit-status-show-hashes-in-headers
	433	(insert (propertize commit 'face 'magit-hash) ?\s))
	434	(insert (propertize branch 'face 'magit-branch-local))
	435	(insert ?\s)
	436	(insert (funcall magit-log-format-message-function branch summary))
	437	(insert ?\n))
	438	(magit-insert-section (commit commit)
	439	(insert (format "%-10s" "Head: "))
	440	(insert (propertize commit 'face 'magit-hash))
	441	(insert ?\s summary ?\n))))))
	442
	443	(cl-defun magit-insert-upstream-branch-header
	444	(&optional (branch (magit-get-current-branch))
	445	(pull (magit-get-upstream-branch branch))
	446	keyword)
	447	"Insert a header line about branch usually pulled into current branch."
	448	(when pull
	449	(magit-insert-section (branch pull)
	450	(let ((rebase (magit-get "branch" branch "rebase")))
	451	(pcase rebase
	452	("true")
	453	("false" (setq rebase nil))
	454	(_ (setq rebase (magit-get-boolean "pull.rebase"))))
	455	(insert (format "%-10s" (or keyword (if rebase "Rebase: " "Merge: ")))))
	456	(--when-let (and magit-status-show-hashes-in-headers
	457	(not (string-match-p " " pull))
	458	(magit-rev-format "%h" pull))
	459	(insert (propertize it 'face 'magit-hash) " "))
	460	(if (string-match-p " " pull)
	461	(pcase-let ((`(,url ,branch) (split-string pull " ")))
	462	(insert branch " from " url " "))
	463	(insert pull " ")
	464	(--if-let (and (magit-rev-verify pull)
	465	(magit-rev-format "%s" pull))
	466	(insert (funcall magit-log-format-message-function pull it))
	467	(insert (propertize "is missing" 'face 'font-lock-warning-face))))
	468	(insert ?\n))))
	469
	470	(cl-defun magit-insert-push-branch-header
	471	(&optional (branch (magit-get-current-branch))
	472	(push (magit-get-push-branch branch)))
	473	"Insert a header line about the branch the current branch is pushed to."
	474	(when push
	475	(magit-insert-section (branch push)
	476	(insert (format "%-10s" "Push: "))
	477	(--when-let (and magit-status-show-hashes-in-headers
	478	(magit-rev-format "%h" push))
	479	(insert (propertize it 'face 'magit-hash) ?\s))
	480	(insert (propertize push 'face 'magit-branch-remote) ?\s)
	481	(--if-let (and (magit-rev-verify push)
	482	(magit-rev-format "%s" push))
	483	(insert (funcall magit-log-format-message-function push it))
	484	(insert (propertize "is missing" 'face 'font-lock-warning-face)))
	485	(insert ?\n))))
	486
	487	(defun magit-insert-tags-header ()
	488	"Insert a header line about the current and/or next tag."
	489	(let* ((this-tag (magit-get-current-tag nil t))
	490	(next-tag (magit-get-next-tag nil t))
	491	(this-cnt (cadr this-tag))
	492	(next-cnt (cadr next-tag))
	493	(this-tag (car this-tag))
	494	(next-tag (car next-tag))
	495	(both-tags (and this-tag next-tag t)))
	496	(when (or this-tag next-tag)
	497	(magit-insert-section (tag (or this-tag next-tag))
	498	(insert (format "%-10s" (if both-tags "Tags: " "Tag: ")))
	499	(cl-flet ((insert-count
	500	(tag count face)
	501	(insert (concat (propertize tag 'face 'magit-tag)
	502	(and (> count 0)
	503	(format " (%s)"
	504	(propertize (format "%s" count)
	505	'face face)))))))
	506	(when this-tag (insert-count this-tag this-cnt 'magit-branch-local))
	507	(when both-tags (insert ", "))
	508	(when next-tag (insert-count next-tag next-cnt 'magit-tag)))
	509	(insert ?\n)))))
	510
	511	;;;; Auxiliary Headers
	512
	513	(defun magit-insert-user-header ()
	514	"Insert a header line about the current user."
	515	(let ((name (magit-get "user.name"))
	516	(email (magit-get "user.email")))
	517	(when (and name email)
	518	(magit-insert-section (user name)
	519	(insert (format "%-10s" "User: "))
	520	(insert (propertize name 'face 'magit-log-author))
	521	(insert " <" email ">\n")))))
	522
	523	(defun magit-insert-repo-header ()
	524	"Insert a header line showing the path to the repository top-level."
	525	(let ((topdir (magit-toplevel)))
	526	(magit-insert-section (repo topdir)
	527	(insert (format "%-10s%s\n" "Repo: " (abbreviate-file-name topdir))))))
	528
	529	(defun magit-insert-remote-header ()
	530	"Insert a header line about the remote of the current branch.
	531
	532	If no remote is configured for the current branch, then fall back
	533	showing the \"origin\" remote, or if that does not exist the first
	534	remote in alphabetic order."
	535	(when-let ((name (magit-get-some-remote))
	536	;; Under certain configurations it's possible for url
	537	;; to be nil, when name is not, see #2858.
	538	(url (magit-get "remote" name "url")))
	539	(magit-insert-section (remote name)
	540	(insert (format "%-10s" "Remote: "))
	541	(insert (propertize name 'face 'magit-branch-remote) ?\s)
	542	(insert url ?\n))))
	543
	544	;;;; File Sections
	545
	546	(defvar magit-untracked-section-map
	547	(let ((map (make-sparse-keymap)))
	548	(define-key map [remap magit-delete-thing] 'magit-discard)
	549	(define-key map "s" 'magit-stage)
	550	map)
	551	"Keymap for the `untracked' section.")
	552
	553	(magit-define-section-jumper magit-jump-to-untracked "Untracked files" untracked)
	554
	555	(defun magit-insert-untracked-files ()
	556	"Maybe insert a list or tree of untracked files.
	557
	558	Do so depending on the value of `status.showUntrackedFiles'.
	559	Note that even if the value is `all', Magit still initially
	560	only shows directories. But the directory sections can then
	561	be expanded using \"TAB\".
	562
	563	If the first element of `magit-diff-section-arguments' is a
	564	directory, then limit the list to files below that. The value
	565	value of that variable can be set using \"D = f DIRECTORY RET g\"."
	566	(let* ((show (or (magit-get "status.showUntrackedFiles") "normal"))
	567	(base (car magit-diff-section-file-args))
	568	(base (and base (file-directory-p base) base)))
	569	(unless (equal show "no")
	570	(if (equal show "all")
	571	(when-let ((files (magit-untracked-files nil base)))
	572	(magit-insert-section (untracked)
	573	(magit-insert-heading "Untracked files:")
	574	(magit-insert-files files base)
	575	(insert ?\n)))
	576	(when-let ((files
	577	(--mapcat (and (eq (aref it 0) ??)
	578	(list (substring it 3)))
	579	(magit-git-items "status" "-z" "--porcelain"
	580	(magit-ignore-submodules-p)
	581	"--" base))))
	582	(magit-insert-section (untracked)
	583	(magit-insert-heading "Untracked files:")
	584	(dolist (file files)
	585	(magit-insert-section (file file)
	586	(insert (propertize file 'face 'magit-filename) ?\n)))
	587	(insert ?\n)))))))
	588
	589	(magit-define-section-jumper magit-jump-to-tracked "Tracked files" tracked)
	590
	591	(defun magit-insert-tracked-files ()
	592	"Insert a tree of tracked files.
	593
	594	If the first element of `magit-diff-section-arguments' is a
	595	directory, then limit the list to files below that. The value
	596	value of that variable can be set using \"D = f DIRECTORY RET g\"."
	597	(when-let ((files (magit-list-files)))
	598	(let* ((base (car magit-diff-section-file-args))
	599	(base (and base (file-directory-p base) base)))
	600	(magit-insert-section (tracked nil t)
	601	(magit-insert-heading "Tracked files:")
	602	(magit-insert-files files base)
	603	(insert ?\n)))))
	604
	605	(defun magit-insert-ignored-files ()
	606	"Insert a tree of ignored files.
	607
	608	If the first element of `magit-diff-section-arguments' is a
	609	directory, then limit the list to files below that. The value
	610	of that variable can be set using \"D = f DIRECTORY RET g\"."
	611	(when-let ((files (magit-ignored-files)))
	612	(let* ((base (car magit-diff-section-file-args))
	613	(base (and base (file-directory-p base) base)))
	614	(magit-insert-section (tracked nil t)
	615	(magit-insert-heading "Ignored files:")
	616	(magit-insert-files files base)
	617	(insert ?\n)))))
	618
	619	(defun magit-insert-files (files directory)
	620	(while (and files (string-prefix-p (or directory "") (car files)))
	621	(let ((dir (file-name-directory (car files))))
	622	(if (equal dir directory)
	623	(let ((file (pop files)))
	624	(magit-insert-section (file file)
	625	(insert (propertize file 'face 'magit-filename) ?\n)))
	626	(magit-insert-section (file dir t)
	627	(insert (propertize dir 'file 'magit-filename) ?\n)
	628	(magit-insert-heading)
	629	(setq files (magit-insert-files files dir))))))
	630	files)
	631
	632	;;; _
	633	(provide 'magit-status)
	634	;;; magit-status.el ends here