.emacs.d.git - Gitblit

Chizi123

2018-11-17 c4001ccd1864293b64aa37d83a9d9457eb875e70

commit \| author \| age
5cb5f7	1	;;; projectile.el --- Manage and navigate projects in Emacs easily -- lexical-binding: t --
C	2
	3	;; Copyright © 2011-2018 Bozhidar Batsov <bozhidar@batsov.com>
	4
	5	;; Author: Bozhidar Batsov <bozhidar@batsov.com>
	6	;; URL: https://github.com/bbatsov/projectile
	7	;; Package-Version: 20181106.1631
	8	;; Keywords: project, convenience
	9	;; Version: 1.1.0-snapshot
	10	;; Package-Requires: ((emacs "25.1") (pkg-info "0.4"))
	11
	12	;; This file is NOT part of GNU Emacs.
	13
	14	;; This program is free software; you can redistribute it and/or modify
	15	;; it under the terms of the GNU General Public License as published by
	16	;; the Free Software Foundation; either version 3, or (at your option)
	17	;; any later version.
	18	;;
	19	;; This program is distributed in the hope that it will be useful,
	20	;; but WITHOUT ANY WARRANTY; without even the implied warranty of
	21	;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	22	;; GNU General Public License for more details.
	23	;;
	24	;; You should have received a copy of the GNU General Public License
	25	;; along with GNU Emacs; see the file COPYING. If not, write to the
	26	;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
	27	;; Boston, MA 02110-1301, USA.
	28
	29	;;; Commentary:
	30	;;
	31	;; This library provides easy project management and navigation. The
	32	;; concept of a project is pretty basic - just a folder containing
	33	;; special file. Currently git, mercurial and bazaar repos are
	34	;; considered projects by default. If you want to mark a folder
	35	;; manually as a project just create an empty .projectile file in
	36	;; it. See the README for more details.
	37	;;
	38	;;; Code:
	39
	40	(require 'cl-lib)
	41	(require 'thingatpt)
	42	(require 'ibuffer)
	43	(require 'ibuf-ext)
	44	(require 'compile)
	45	(require 'grep)
	46	(eval-when-compile
	47	(require 'subr-x))
	48
	49	(eval-when-compile
	50	(defvar ag-ignore-list)
	51	(defvar ggtags-completion-table)
	52	(defvar tags-completion-table)
	53	(defvar tags-loop-scan)
	54	(defvar tags-loop-operate)
	55	(defvar eshell-buffer-name)
	56	(defvar explicit-shell-file-name))
	57
	58	(declare-function ggtags-ensure-project "ggtags")
	59	(declare-function ggtags-update-tags "ggtags")
	60	(declare-function pkg-info-version-info "pkg-info")
	61	(declare-function tags-completion-table "etags")
	62	(declare-function make-term "term")
	63	(declare-function term-mode "term")
	64	(declare-function term-char-mode "term")
	65	(declare-function eshell-search-path "esh-ext")
	66	(declare-function vc-dir "vc-dir")
	67	(declare-function vc-dir-busy "vc-dir")
	68	(declare-function ripgrep-regexp "ripgrep")
	69	(declare-function string-trim "subr-x")
	70
	71	(defvar grep-files-aliases)
	72	(defvar grep-find-ignored-directories)
	73	(defvar grep-find-ignored-files)
	74
	75
	76	;;; Customization
	77	(defgroup projectile nil
	78	"Manage and navigate projects easily."
	79	:group 'tools
	80	:group 'convenience
	81	:link '(url-link :tag "GitHub" "https://github.com/bbatsov/projectile")
	82	:link '(url-link :tag "Online Manual" "https://docs.projectile.mx/")
	83	:link '(emacs-commentary-link :tag "Commentary" "projectile"))
	84
	85	(defcustom projectile-indexing-method (if (eq system-type 'windows-nt) 'native 'alien)
	86	"Specifies the indexing method used by Projectile.
	87
	88	There are three indexing methods - native, hybrid and alien.
	89
	90	The native method is implemented in Emacs Lisp (therefore it is
	91	native to Emacs). Its advantage is that it is portable and will
	92	work everywhere that Emacs does. Its disadvantage is that it is a
	93	bit slow (especially for large projects). Generally it's a good
	94	idea to pair the native indexing method with caching.
	95
	96	The hybrid indexing method uses external tools (e.g. git, find,
	97	etc) to speed up the indexing process. Still, the files will be
	98	post-processed by Projectile for sorting/filtering purposes.
	99	In this sense that approach is a hybrid between native and indexing
	100	and alien indexing.
	101
	102	The alien indexing method optimizes to the limit the speed
	103	of the hybrid indexing method. This means that Projectile will
	104	not do any processing of the files returned by the external
	105	commands and you're going to get the maximum performance
	106	possible. This behaviour makes a lot of sense for most people,
	107	as they'd typically be putting ignores in their VCS config and
	108	won't care about any additional ignores/unignores/sorting that
	109	Projectile might also provide.
	110
	111	The disadvantage of the hybrid and alien methods is that they are not well
	112	supported on Windows systems. That's why by default alien indexing is the
	113	default on all operating systems, except Windows."
	114	:group 'projectile
	115	:type '(radio
	116	(const :tag "Native" native)
	117	(const :tag "Hybrid" hybrid)
	118	(const :tag "Alien" alien)))
	119
	120	(defcustom projectile-enable-caching (eq projectile-indexing-method 'native)
	121	"When t enables project files caching.
	122
	123	Project caching is automatically enabled by default if you're
	124	using the native indexing method."
	125	:group 'projectile
	126	:type 'boolean)
	127
	128	(defcustom projectile-kill-buffers-filter 'kill-all
	129	"Determine which buffers are killed by `projectile-kill-buffers'.
	130
	131	When the kill-all option is selected, kills each buffer.
	132
	133	When the kill-only-files option is selected, kill only the buffer
	134	associated to a file.
	135
	136	Otherwise, it should be a predicate that takes one argument: the buffer to
	137	be killed."
	138	:group 'projectile
	139	:type '(radio
	140	(const :tag "All project buffers" kill-all)
	141	(const :tag "Project file buffers" kill-only-files)
	142	(function :tag "Predicate")))
	143
	144	(defcustom projectile-file-exists-local-cache-expire nil
	145	"Number of seconds before the local file existence cache expires.
	146	Local refers to a file on a local file system.
	147
	148	A value of nil disables this cache.
	149	See `projectile-file-exists-p' for details."
	150	:group 'projectile
	151	:type '(choice (const :tag "Disabled" nil)
	152	(integer :tag "Seconds")))
	153
	154	(defcustom projectile-file-exists-remote-cache-expire (* 5 60)
	155	"Number of seconds before the remote file existence cache expires.
	156	Remote refers to a file on a remote file system such as tramp.
	157
	158	A value of nil disables this cache.
	159	See `projectile-file-exists-p' for details."
	160	:group 'projectile
	161	:type '(choice (const :tag "Disabled" nil)
	162	(integer :tag "Seconds")))
	163
	164	(defcustom projectile-files-cache-expire nil
	165	"Number of seconds before project files list cache expires.
	166
	167	A value of nil means the cache never expires."
	168	:group 'projectile
	169	:type '(choice (const :tag "Disabled" nil)
	170	(integer :tag "Seconds")))
	171
	172	(defcustom projectile-require-project-root 'prompt
	173	"Require the presence of a project root to operate when true.
	174	When set to 'prompt Projectile will ask you to select a project
	175	directory if you're not in a project.
	176
	177	When nil Projectile will consider the current directory the project root."
	178	:group 'projectile
	179	:type '(choice (const :tag "No" nil)
	180	(const :tag "Yes" t)
	181	(const :tag "Prompt for project" prompt)))
	182
	183	(defcustom projectile-completion-system 'ido
	184	"The completion system to be used by Projectile."
	185	:group 'projectile
	186	:type '(radio
	187	(const :tag "Ido" ido)
	188	(const :tag "Helm" helm)
	189	(const :tag "Ivy" ivy)
	190	(const :tag "Default" default)
	191	(function :tag "Custom function")))
	192
	193	(defcustom projectile-keymap-prefix nil
	194	"Projectile keymap prefix."
	195	:group 'projectile
	196	:type 'string)
	197
	198	(make-obsolete-variable 'projectile-keymap-prefix "Use (define-key projectile-mode-map (kbd ...) 'projectile-command-map) instead." "1.1.0")
	199
	200	(defcustom projectile-cache-file
	201	(expand-file-name "projectile.cache" user-emacs-directory)
	202	"The name of Projectile's cache file."
	203	:group 'projectile
	204	:type 'string)
	205
	206	(defcustom projectile-tags-file-name "TAGS"
	207	"The tags filename Projectile's going to use."
	208	:group 'projectile
	209	:type 'string)
	210
	211	(defcustom projectile-tags-command "ctags -Re -f \"%s\" %s \"%s\""
	212	"The command Projectile's going to use to generate a TAGS file."
	213	:group 'projectile
	214	:type 'string)
	215
	216	(defcustom projectile-tags-backend 'auto
	217	"The tag backend that Projectile should use.
	218
	219	If set to 'auto', `projectile-find-tag' will automatically choose
	220	which backend to use. Preference order is ggtags -> xref
	221	-> etags-select -> `find-tag'. Variable can also be set to specify which
	222	backend to use. If selected backend is unavailable, fall back to
	223	`find-tag'.
	224
	225	If this variable is set to 'auto' and ggtags is available, or if
	226	set to 'ggtags', then ggtags will be used for
	227	`projectile-regenerate-tags'. For all other settings
	228	`projectile-tags-command' will be used."
	229	:group 'projectile
	230	:type '(radio
	231	(const :tag "auto" auto)
	232	(const :tag "xref" xref)
	233	(const :tag "ggtags" ggtags)
	234	(const :tag "etags" etags-select)
	235	(const :tag "standard" find-tag))
	236	:package-version '(projectile . "0.14.0"))
	237
	238	(defcustom projectile-sort-order 'default
	239	"The sort order used for a project's files."
	240	:group 'projectile
	241	:type '(radio
	242	(const :tag "default" default)
	243	(const :tag "recentf" recentf)
	244	(const :tag "recently active" recently-active)
	245	(const :tag "access time" access-time)
	246	(const :tag "modification time" modification-time)))
	247
	248	(defcustom projectile-verbose t
	249	"Echo messages that are not errors."
	250	:group 'projectile
	251	:type 'boolean)
	252
	253	(defcustom projectile-buffers-filter-function nil
	254	"A function used to filter the buffers in `projectile-project-buffers'.
	255
	256	The function should accept and return a list of Emacs buffers.
	257	Two example filter functions are shipped by default -
	258	`projectile-buffers-with-file' and
	259	`projectile-buffers-with-file-or-process'."
	260	:group 'projectile
	261	:type 'function)
	262
	263	(defcustom projectile-project-name nil
	264	"If this value is non-nil, it will be used as project name.
	265
	266	It has precedence over function `projectile-project-name-function'."
	267	:group 'projectile
	268	:type 'string
	269	:package-version '(projectile . "0.14.0"))
	270
	271	(defcustom projectile-project-name-function 'projectile-default-project-name
	272	"A function that receives the project-root and returns the project name.
	273
	274	If variable `projectile-project-name' is non-nil, this function will not be used."
	275	:group 'projectile
	276	:type 'function
	277	:package-version '(projectile . "0.14.0"))
	278
	279	(defcustom projectile-project-root-files
	280	'("rebar.config" ; Rebar project file
	281	"project.clj" ; Leiningen project file
	282	"build.boot" ; Boot-clj project file
	283	"deps.edn" ; Clojure CLI project file
	284	"SConstruct" ; Scons project file
	285	"pom.xml" ; Maven project file
	286	"build.sbt" ; SBT project file
	287	"gradlew" ; Gradle wrapper script
	288	"build.gradle" ; Gradle project file
	289	".ensime" ; Ensime configuration file
	290	"Gemfile" ; Bundler file
	291	"requirements.txt" ; Pip file
	292	"setup.py" ; Setuptools file
	293	"tox.ini" ; Tox file
	294	"composer.json" ; Composer project file
	295	"Cargo.toml" ; Cargo project file
	296	"mix.exs" ; Elixir mix project file
	297	"stack.yaml" ; Haskell's stack tool based project
	298	"info.rkt" ; Racket package description file
	299	"DESCRIPTION" ; R package description file
	300	"TAGS" ; etags/ctags are usually in the root of project
	301	"GTAGS" ; GNU Global tags
	302	"configure.in" ; autoconf old style
	303	"configure.ac" ; autoconf new style
	304	"cscope.out" ; cscope
	305	)
	306	"A list of files considered to mark the root of a project.
	307	The topmost match has precedence."
	308	:group 'projectile
	309	:type '(repeat string))
	310
	311	(defcustom projectile-project-root-files-bottom-up
	312	'(".projectile" ; projectile project marker
	313	".git" ; Git VCS root dir
	314	".hg" ; Mercurial VCS root dir
	315	".fslckout" ; Fossil VCS root dir
	316	"_FOSSIL_" ; Fossil VCS root DB on Windows
	317	".bzr" ; Bazaar VCS root dir
	318	"_darcs" ; Darcs VCS root dir
	319	)
	320	"A list of files considered to mark the root of a project.
	321	The bottommost (parentmost) match has precedence."
	322	:group 'projectile
	323	:type '(repeat string))
	324
	325	(defcustom projectile-project-root-files-top-down-recurring
	326	'(".svn" ; Svn VCS root dir
	327	"CVS" ; Csv VCS root dir
	328	"Makefile")
	329	"A list of files considered to mark the root of a project.
	330	The search starts at the top and descends down till a directory
	331	that contains a match file but its parent does not. Thus, it's a
	332	bottommost match in the topmost sequence of directories
	333	containing a root file."
	334	:group 'projectile
	335	:type '(repeat string))
	336
	337	(defcustom projectile-project-root-files-functions
	338	'(projectile-root-local
	339	projectile-root-bottom-up
	340	projectile-root-top-down
	341	projectile-root-top-down-recurring)
	342	"A list of functions for finding project roots."
	343	:group 'projectile
	344	:type '(repeat function))
	345
	346	(defcustom projectile-globally-ignored-files
	347	(list projectile-tags-file-name)
	348	"A list of files globally ignored by projectile."
	349	:group 'projectile
	350	:type '(repeat string))
	351
	352	(defcustom projectile-globally-unignored-files nil
	353	"A list of files globally unignored by projectile.
	354
	355	Regular expressions can be used."
	356	:group 'projectile
	357	:type '(repeat string)
	358	:package-version '(projectile . "0.14.0"))
	359
	360	(defcustom projectile-globally-ignored-file-suffixes
	361	nil
	362	"A list of file suffixes globally ignored by projectile."
	363	:group 'projectile
	364	:type '(repeat string))
	365
	366	(defcustom projectile-globally-ignored-directories
	367	'(".idea"
	368	".ensime_cache"
	369	".eunit"
	370	".git"
	371	".hg"
	372	".fslckout"
	373	"_FOSSIL_"
	374	".bzr"
	375	"_darcs"
	376	".tox"
	377	".svn"
	378	".stack-work")
	379	"A list of directories globally ignored by projectile.
	380
	381	Regular expressions can be used."
	382	:safe (lambda (x) (not (remq t (mapcar #'stringp x))))
	383	:group 'projectile
	384	:type '(repeat string))
	385
	386	(defcustom projectile-globally-unignored-directories nil
	387	"A list of directories globally unignored by projectile."
	388	:group 'projectile
	389	:type '(repeat string)
	390	:package-version '(projectile . "0.14.0"))
	391
	392	(defcustom projectile-globally-ignored-modes
	393	'("erc-mode"
	394	"help-mode"
	395	"completion-list-mode"
	396	"Buffer-menu-mode"
	397	"gnus-.*-mode"
	398	"occur-mode")
	399	"A list of regular expressions for major modes ignored by projectile.
	400
	401	If a buffer is using a given major mode, projectile will ignore
	402	it for functions working with buffers."
	403	:group 'projectile
	404	:type '(repeat string))
	405
	406	(defcustom projectile-globally-ignored-buffers nil
	407	"A list of buffer-names ignored by projectile.
	408
	409	You can use either exact buffer names or regular expressions.
	410	If a buffer is in the list projectile will ignore it for
	411	functions working with buffers."
	412	:group 'projectile
	413	:type '(repeat string)
	414	:package-version '(projectile . "0.12.0"))
	415
	416	(defcustom projectile-find-file-hook nil
	417	"Hooks run when a file is opened with `projectile-find-file'."
	418	:group 'projectile
	419	:type 'hook)
	420
	421	(defcustom projectile-find-dir-hook nil
	422	"Hooks run when a directory is opened with `projectile-find-dir'."
	423	:group 'projectile
	424	:type 'hook)
	425
	426	(defcustom projectile-switch-project-action 'projectile-find-file
	427	"Action invoked after switching projects with `projectile-switch-project'.
	428
	429	Any function that does not take arguments will do."
	430	:group 'projectile
	431	:type 'function)
	432
	433	(defcustom projectile-find-dir-includes-top-level nil
	434	"If true, add top-level dir to options offered by `projectile-find-dir'."
	435	:group 'projectile
	436	:type 'boolean)
	437
	438	(defcustom projectile-use-git-grep nil
	439	"If true, use `vc-git-grep' in git projects."
	440	:group 'projectile
	441	:type 'boolean)
	442
	443	(defcustom projectile-grep-finished-hook nil
	444	"Hooks run when `projectile-grep' finishes."
	445	:group 'projectile
	446	:type 'hook
	447	:package-version '(projectile . "0.14.0"))
	448
	449	(defcustom projectile-test-prefix-function 'projectile-test-prefix
	450	"Function to find test files prefix based on PROJECT-TYPE."
	451	:group 'projectile
	452	:type 'function)
	453
	454	(defcustom projectile-test-suffix-function 'projectile-test-suffix
	455	"Function to find test files suffix based on PROJECT-TYPE."
	456	:group 'projectile
	457	:type 'function)
	458
	459	(defcustom projectile-dynamic-mode-line t
	460	"If true, update the mode-line dynamically.
	461	Only file buffers are affected by this, as the update happens via
	462	`find-file-hook'.
	463
	464	See also `projectile-mode-line-function' and `projectile-update-mode-line'."
	465	:group 'projectile
	466	:type 'boolean
	467	:package-version '(projectile . "1.1.0"))
	468
	469	(defcustom projectile-mode-line-function 'projectile-default-mode-line
	470	"The function to use to generate project-specific mode-line.
	471	The default function adds the project name and type to the mode-line.
	472	See also `projectile-update-mode-line'."
	473	:group 'projectile
	474	:type 'function
	475	:package-version '(projectile . "1.1.0"))
	476
	477
	478	;;; Idle Timer
	479	(defvar projectile-idle-timer nil
	480	"The timer object created when `projectile-enable-idle-timer' is non-nil.")
	481
	482	(defcustom projectile-idle-timer-seconds 30
	483	"The idle period to use when `projectile-enable-idle-timer' is non-nil."
	484	:group 'projectile
	485	:type 'number)
	486
	487	(defcustom projectile-idle-timer-hook '(projectile-regenerate-tags)
	488	"The hook run when `projectile-enable-idle-timer' is non-nil."
	489	:group 'projectile
	490	:type '(repeat symbol))
	491
	492	(defcustom projectile-enable-idle-timer nil
	493	"Enables idle timer hook `projectile-idle-timer-functions'.
	494
	495	When `projectile-enable-idle-timer' is non-nil, the hook
	496	`projectile-idle-timer-hook' is run each time Emacs has been idle
	497	for `projectile-idle-timer-seconds' seconds and we're in a
	498	project."
	499	:group 'projectile
	500	:set (lambda (symbol value)
	501	(set symbol value)
	502	(when projectile-idle-timer
	503	(cancel-timer projectile-idle-timer))
	504	(setq projectile-idle-timer nil)
	505	(when projectile-enable-idle-timer
	506	(setq projectile-idle-timer (run-with-idle-timer
	507	projectile-idle-timer-seconds t
	508	(lambda ()
	509	(when (projectile-project-p)
	510	(run-hooks 'projectile-idle-timer-hook)))))))
	511	:type 'boolean)
	512
	513	(defvar projectile-projects-cache nil
	514	"A hashmap used to cache project file names to speed up related operations.")
	515
	516	(defvar projectile-projects-cache-time nil
	517	"A hashmap used to record when we populated `projectile-projects-cache'.")
	518
	519	(defvar projectile-project-root-cache (make-hash-table :test 'equal)
	520	"Cached value of function `projectile-project-root`.")
	521
	522	(defvar projectile-project-type-cache (make-hash-table :test 'equal)
	523	"A hashmap used to cache project type to speed up related operations.")
	524
	525	(defvar projectile-known-projects nil
	526	"List of locations where we have previously seen projects.
	527	The list of projects is ordered by the time they have been accessed.
	528
	529	See also `projectile-remove-known-project',
	530	`projectile-cleanup-known-projects' and `projectile-clear-known-projects'.")
	531
	532	(defvar projectile-known-projects-on-file nil
	533	"List of known projects reference point.
	534
	535	Contains a copy of `projectile-known-projects' when it was last
	536	synchronized with `projectile-known-projects-file'.")
	537
	538	(defcustom projectile-known-projects-file
	539	(expand-file-name "projectile-bookmarks.eld"
	540	user-emacs-directory)
	541	"Name and location of the Projectile's known projects file."
	542	:group 'projectile
	543	:type 'string)
	544
	545	(defcustom projectile-ignored-projects nil
	546	"A list of projects not to be added to `projectile-known-projects'."
	547	:group 'projectile
	548	:type '(repeat :tag "Project list" directory)
	549	:package-version '(projectile . "0.11.0"))
	550
	551	(defcustom projectile-ignored-project-function nil
	552	"Function to decide if a project is added to `projectile-known-projects'.
	553
	554	Can be either nil, or a function that takes the truename of the
	555	project root as argument and returns non-nil if the project is to
	556	be ignored or nil otherwise.
	557
	558	This function is only called if the project is not listed in
	559	`projectile-ignored-projects'.
	560
	561	A suitable candidate would be `file-remote-p' to ignore remote
	562	projects."
	563	:group 'projectile
	564	:type '(choice
	565	(const :tag "Nothing" nil)
	566	(const :tag "Remote files" file-remote-p)
	567	function)
	568	:package-version '(projectile . "0.13.0"))
	569
	570	(defcustom projectile-track-known-projects-automatically t
	571	"Controls whether Projectile will automatically register known projects.
	572
	573	When set to nil you'll have always add projects explicitly with
	574	`projectile-add-known-project'."
	575	:group 'projectile
	576	:type 'boolean
	577	:package-version '(projectile . "1.0.0"))
	578
	579	(defcustom projectile-project-search-path nil
	580	"List of folders where projectile is automatically going to look for projects.
	581	You can think of something like $PATH, but for projects instead of executables.
	582	Examples of such paths might be ~/projects, ~/work, etc."
	583	:group 'projectile
	584	:type 'list
	585	:package-version '(projectile . "1.0.0"))
	586
	587	(defcustom projectile-git-command "git ls-files -zco --exclude-standard"
	588	"Command used by projectile to get the files in a git project."
	589	:group 'projectile
	590	:type 'string)
	591
	592	(defcustom projectile-git-submodule-command "git submodule --quiet foreach 'echo $path' \| tr '\\n' '\\0'"
	593	"Command used by projectile to list submodules of a given git repository.
	594	Set to nil to disable listing submodules contents."
	595	:group 'projectile
	596	:type 'string)
	597
	598	(defcustom projectile-git-ignored-command "git ls-files -zcoi --exclude-standard"
	599	"Command used by projectile to get the ignored files in a git project."
	600	:group 'projectile
	601	:type 'string
	602	:package-version '(projectile . "0.14.0"))
	603
	604	(defcustom projectile-hg-command "hg locate -f -0 -I ."
	605	"Command used by projectile to get the files in a hg project."
	606	:group 'projectile
	607	:type 'string)
	608
	609	(defcustom projectile-fossil-command (concat "fossil ls \| "
	610	(when (string-equal system-type
	611	"windows-nt")
	612	"dos2unix \| ")
	613	"tr '\\n' '\\0'")
	614	"Command used by projectile to get the files in a fossil project."
	615	:group 'projectile
	616	:type 'string)
	617
	618	(defcustom projectile-bzr-command "bzr ls -R --versioned -0"
	619	"Command used by projectile to get the files in a bazaar project."
	620	:group 'projectile
	621	:type 'string)
	622
	623	(defcustom projectile-darcs-command "darcs show files -0 . "
	624	"Command used by projectile to get the files in a darcs project."
	625	:group 'projectile
	626	:type 'string)
	627
	628	(defcustom projectile-svn-command "svn list -R . \| grep -v '$/' \| tr '\\n' '\\0'"
	629	"Command used by projectile to get the files in a svn project."
	630	:group 'projectile
	631	:type 'string)
	632
	633	(defcustom projectile-generic-command "find . -type f -print0"
	634	"Command used by projectile to get the files in a generic project."
	635	:group 'projectile
	636	:type 'string)
	637
	638	(defcustom projectile-vcs-dirty-state '("edited" "unregistered" "needs-update" "needs-merge" "unlocked-changes" "conflict")
	639	"List of states checked by `projectile-browse-dirty-projects'.
	640	Possible checked states are:
	641	\"edited\", \"unregistered\", \"needs-update\", \"needs-merge\",
	642	\"unlocked-changes\" and \"conflict\",
	643	as defined in `vc.el'."
	644	:group 'projectile
	645	:type '(repeat (string))
	646	:package-version '(projectile . "1.0.0"))
	647
	648	(defcustom projectile-other-file-alist
	649	'( ;; handle C/C++ extensions
	650	("cpp" . ("h" "hpp" "ipp"))
	651	("ipp" . ("h" "hpp" "cpp"))
	652	("hpp" . ("h" "ipp" "cpp" "cc"))
	653	("cxx" . ("h" "hxx" "ixx"))
	654	("ixx" . ("h" "hxx" "cxx"))
	655	("hxx" . ("h" "ixx" "cxx"))
	656	("c" . ("h"))
	657	("m" . ("h"))
	658	("mm" . ("h"))
	659	("h" . ("c" "cc" "cpp" "ipp" "hpp" "cxx" "ixx" "hxx" "m" "mm"))
	660	("cc" . ("h" "hh" "hpp"))
	661	("hh" . ("cc"))
	662
	663	;; vertex shader and fragment shader extensions in glsl
	664	("vert" . ("frag"))
	665	("frag" . ("vert"))
	666
	667	;; handle files with no extension
	668	(nil . ("lock" "gpg"))
	669	("lock" . (""))
	670	("gpg" . (""))
	671	)
	672	"Alist of extensions for switching to file with the same name,
	673	using other extensions based on the extension of current
	674	file."
	675	:type 'alist)
	676
	677	(defcustom projectile-create-missing-test-files nil
	678	"During toggling, if non-nil enables creating test files if not found.
	679
	680	When not-nil, every call to projectile-find-implementation-or-test-*
	681	creates test files if not found on the file system. Defaults to nil.
	682	It assumes the test/ folder is at the same level as src/."
	683	:group 'projectile
	684	:type 'boolean)
	685
	686	(defcustom projectile-after-switch-project-hook nil
	687	"Hooks run right after project is switched."
	688	:group 'projectile
	689	:type 'hook)
	690
	691	(defcustom projectile-before-switch-project-hook nil
	692	"Hooks run when right before project is switched."
	693	:group 'projectile
	694	:type 'hook)
	695
	696	(defcustom projectile-current-project-on-switch 'remove
	697	"Determines whether to display current project when switching projects.
	698
	699	When set to 'remove current project is not included, 'move-to-end
	700	will display current project and the end of the list of known
	701	projects, 'keep will leave the current project at the default
	702	position."
	703	:group 'projectile
	704	:type '(radio
	705	(const :tag "Remove" remove)
	706	(const :tag "Move to end" move-to-end)
	707	(const :tag "Keep" keep)))
	708
	709
	710	;;; Version information
	711
	712	;;;###autoload
	713	(defun projectile-version (&optional show-version)
	714	"Get the Projectile version as string.
	715
	716	If called interactively or if SHOW-VERSION is non-nil, show the
	717	version in the echo area and the messages buffer.
	718
	719	The returned string includes both, the version from package.el
	720	and the library version, if both a present and different.
	721
	722	If the version number could not be determined, signal an error,
	723	if called interactively, or if SHOW-VERSION is non-nil, otherwise
	724	just return nil."
	725	(interactive (list t))
	726	(if (require 'pkg-info nil t)
	727	(let ((version (pkg-info-version-info 'projectile)))
	728	(when show-version
	729	(message "Projectile %s" version))
	730	version)
	731	(error "Cannot determine version without package pkg-info")))
	732
	733	;;; Misc utility functions
	734	(defun projectile-difference (list1 list2)
	735	(cl-remove-if
	736	(lambda (x) (member x list2))
	737	list1))
	738
	739	(defun projectile-unixy-system-p ()
	740	"Check to see if unixy text utilities are installed."
	741	(cl-every
	742	(lambda (x) (executable-find x))
	743	'("grep" "cut" "uniq")))
	744
	745	(defun projectile-symbol-or-selection-at-point ()
	746	"Get the symbol or selected text at point."
	747	(if (use-region-p)
	748	(buffer-substring-no-properties (region-beginning) (region-end))
	749	(projectile-symbol-at-point)))
	750
	751	(defun projectile-symbol-at-point ()
	752	"Get the symbol at point and strip its properties."
	753	(substring-no-properties (or (thing-at-point 'symbol) "")))
	754
	755
	756
	757	;;; Serialization
	758	(defun projectile-serialize (data filename)
	759	"Serialize DATA to FILENAME.
	760
	761	The saved data can be restored with `projectile-unserialize'."
	762	(when (file-writable-p filename)
	763	(with-temp-file filename
	764	(insert (let (print-length) (prin1-to-string data))))))
	765
	766	(defun projectile-unserialize (filename)
	767	"Read data serialized by `projectile-serialize' from FILENAME."
	768	(with-demoted-errors
	769	"Error during file deserialization: %S"
	770	(when (file-exists-p filename)
	771	(with-temp-buffer
	772	(insert-file-contents filename)
	773	;; this will blow up if the contents of the file aren't
	774	;; lisp data structures
	775	(read (buffer-string))))))
	776
	777
	778	;;; Caching
	779	(defvar projectile-file-exists-cache
	780	(make-hash-table :test 'equal)
	781	"Cached `projectile-file-exists-p' results.")
	782
	783	(defvar projectile-file-exists-cache-timer nil
	784	"Timer for scheduling`projectile-file-exists-cache-cleanup'.")
	785
	786	(defun projectile-file-exists-cache-cleanup ()
	787	"Removed timed out cache entries and reschedules or remove the
	788	timer if no more items are in the cache."
	789	(let ((now (current-time)))
	790	(maphash (lambda (key value)
	791	(if (time-less-p (cdr value) now)
	792	(remhash key projectile-file-exists-cache)))
	793	projectile-file-exists-cache)
	794	(setq projectile-file-exists-cache-timer
	795	(if (> (hash-table-count projectile-file-exists-cache) 0)
	796	(run-with-timer 10 nil 'projectile-file-exists-cache-cleanup)))))
	797
	798	(defun projectile-file-exists-p (filename)
	799	"Return t if file FILENAME exist.
	800	A wrapper around `file-exists-p' with additional caching support."
	801	(let* ((file-remote (file-remote-p filename))
	802	(expire-seconds
	803	(if file-remote
	804	(and projectile-file-exists-remote-cache-expire
	805	(> projectile-file-exists-remote-cache-expire 0)
	806	projectile-file-exists-remote-cache-expire)
	807	(and projectile-file-exists-local-cache-expire
	808	(> projectile-file-exists-local-cache-expire 0)
	809	projectile-file-exists-local-cache-expire)))
	810	(remote-file-name-inhibit-cache (if expire-seconds
	811	expire-seconds
	812	remote-file-name-inhibit-cache)))
	813	(if (not expire-seconds)
	814	(file-exists-p filename)
	815	(let* ((current-time (current-time))
	816	(cached (gethash filename projectile-file-exists-cache))
	817	(cached-value (if cached (car cached)))
	818	(cached-expire (if cached (cdr cached)))
	819	(cached-expired (if cached (time-less-p cached-expire current-time) t))
	820	(value (or (and (not cached-expired) cached-value)
	821	(if (file-exists-p filename) 'found 'notfound))))
	822	(when (or (not cached) cached-expired)
	823	(puthash filename
	824	(cons value (time-add current-time (seconds-to-time expire-seconds)))
	825	projectile-file-exists-cache))
	826	(unless projectile-file-exists-cache-timer
	827	(setq projectile-file-exists-cache-timer
	828	(run-with-timer 10 nil 'projectile-file-exists-cache-cleanup)))
	829	(equal value 'found)))))
	830
	831	;;;###autoload
	832	(defun projectile-invalidate-cache (prompt)
	833	"Remove the current project's files from `projectile-projects-cache'.
	834
	835	With a prefix argument PROMPT prompts for the name of the project whose cache
	836	to invalidate."
	837	(interactive "P")
	838	(let ((project-root
	839	(if prompt
	840	(completing-read "Remove cache for: "
	841	(hash-table-keys projectile-projects-cache))
	842	(projectile-ensure-project (projectile-project-root)))))
	843	(setq projectile-project-root-cache (make-hash-table :test 'equal))
	844	(remhash project-root projectile-project-type-cache)
	845	(remhash project-root projectile-projects-cache)
	846	(remhash project-root projectile-projects-cache-time)
	847	(projectile-serialize-cache)
	848	(when projectile-verbose
	849	(message "Invalidated Projectile cache for %s."
	850	(propertize project-root 'face 'font-lock-keyword-face))))
	851	(when (fboundp 'recentf-cleanup)
	852	(recentf-cleanup)))
	853
	854	(defun projectile-time-seconds ()
	855	"Return the number of seconds since the unix epoch."
	856	(cl-destructuring-bind (high low _usec _psec) (current-time)
	857	(+ (lsh high 16) low)))
	858
	859	(defun projectile-cache-project (project files)
	860	"Cache PROJECTs FILES.
	861	The cache is created both in memory and on the hard drive."
	862	(when projectile-enable-caching
	863	(puthash project files projectile-projects-cache)
	864	(puthash project (projectile-time-seconds) projectile-projects-cache-time)
	865	(projectile-serialize-cache)))
	866
	867	;;;###autoload
	868	(defun projectile-purge-file-from-cache (file)
	869	"Purge FILE from the cache of the current project."
	870	(interactive
	871	(list (projectile-completing-read
	872	"Remove file from cache: "
	873	(projectile-current-project-files))))
	874	(let* ((project-root (projectile-project-root))
	875	(project-cache (gethash project-root projectile-projects-cache)))
	876	(if (projectile-file-cached-p file project-root)
	877	(progn
	878	(puthash project-root (remove file project-cache) projectile-projects-cache)
	879	(projectile-serialize-cache)
	880	(when projectile-verbose
	881	(message "%s removed from cache" file)))
	882	(error "%s is not in the cache" file))))
	883
	884	;;;###autoload
	885	(defun projectile-purge-dir-from-cache (dir)
	886	"Purge DIR from the cache of the current project."
	887	(interactive
	888	(list (projectile-completing-read
	889	"Remove directory from cache: "
	890	(projectile-current-project-dirs))))
	891	(let* ((project-root (projectile-project-root))
	892	(project-cache (gethash project-root projectile-projects-cache)))
	893	(puthash project-root
	894	(cl-remove-if (lambda (str) (string-prefix-p dir str)) project-cache)
	895	projectile-projects-cache)))
	896
	897	(defun projectile-file-cached-p (file project)
	898	"Check if FILE is already in PROJECT cache."
	899	(member file (gethash project projectile-projects-cache)))
	900
	901	;;;###autoload
	902	(defun projectile-cache-current-file ()
	903	"Add the currently visited file to the cache."
	904	(interactive)
	905	(let ((current-project (projectile-project-root)))
	906	(when (and (buffer-file-name) (gethash (projectile-project-root) projectile-projects-cache))
	907	(let* ((abs-current-file (file-truename (buffer-file-name)))
	908	(current-file (file-relative-name abs-current-file current-project)))
	909	(unless (or (projectile-file-cached-p current-file current-project)
	910	(projectile-ignored-directory-p (file-name-directory abs-current-file))
	911	(projectile-ignored-file-p abs-current-file))
	912	(puthash current-project
	913	(cons current-file (gethash current-project projectile-projects-cache))
	914	projectile-projects-cache)
	915	(projectile-serialize-cache)
	916	(message "File %s added to project %s cache."
	917	(propertize current-file 'face 'font-lock-keyword-face)
	918	(propertize current-project 'face 'font-lock-keyword-face)))))))
	919
	920	;; cache opened files automatically to reduce the need for cache invalidation
	921	(defun projectile-cache-files-find-file-hook ()
	922	"Function for caching files with `find-file-hook'."
	923	(let ((project-root (projectile-project-p)))
	924	(when (and projectile-enable-caching
	925	project-root
	926	(not (projectile-ignored-project-p project-root)))
	927	(projectile-cache-current-file))))
	928
	929	(defun projectile-track-known-projects-find-file-hook ()
	930	"Function for caching projects with `find-file-hook'."
	931	(when (and projectile-track-known-projects-automatically (projectile-project-p))
	932	(projectile-add-known-project (projectile-project-root))))
	933
	934	(defun projectile-maybe-invalidate-cache (force)
	935	"Invalidate if FORCE or project's dirconfig newer than cache."
	936	(when (or force (file-newer-than-file-p (projectile-dirconfig-file)
	937	projectile-cache-file))
	938	(projectile-invalidate-cache nil)))
	939
	940	;;;###autoload
	941	(defun projectile-discover-projects-in-directory (directory)
	942	"Discover any projects in DIRECTORY and add them to the projectile cache.
	943	This function is not recursive and only adds projects with roots
	944	at the top level of DIRECTORY."
	945	(interactive
	946	(list (read-directory-name "Starting directory: ")))
	947	(let ((subdirs (directory-files directory t)))
	948	(mapcar
	949	(lambda (dir)
	950	(when (and (file-directory-p dir)
	951	(not (member (file-name-nondirectory dir) '(".." "."))))
	952	(when (projectile-project-p dir)
	953	(projectile-add-known-project dir))))
	954	subdirs)))
	955
	956	;;;###autoload
	957	(defun projectile-discover-projects-in-search-path ()
	958	"Discover projects in `projectile-project-search-path'.
	959	Invoked automatically when `projectile-mode' is enabled."
	960	(interactive)
	961	(mapcar #'projectile-discover-projects-in-directory projectile-project-search-path))
	962
	963
	964	(defadvice delete-file (before purge-from-projectile-cache (filename &optional trash))
	965	(if (and projectile-enable-caching (projectile-project-p))
	966	(let* ((project-root (projectile-project-root))
	967	(true-filename (file-truename filename))
	968	(relative-filename (file-relative-name true-filename project-root)))
	969	(if (projectile-file-cached-p relative-filename project-root)
	970	(projectile-purge-file-from-cache relative-filename)))))
	971
	972
	973	;;; Project root related utilities
	974	(defun projectile-parent (path)
	975	"Return the parent directory of PATH.
	976	PATH may be a file or directory and directory paths may end with a slash."
	977	(directory-file-name (file-name-directory (directory-file-name (expand-file-name path)))))
	978
	979	(defun projectile-locate-dominating-file (file name)
	980	"Look up the directory hierarchy from FILE for a directory containing NAME.
	981	Stop at the first parent directory containing a file NAME,
	982	and return the directory. Return nil if not found.
	983	Instead of a string, NAME can also be a predicate taking one argument
	984	\(a directory) and returning a non-nil value if that directory is the one for
	985	which we're looking."
	986	;; copied from files.el (stripped comments) emacs-24 bzr branch 2014-03-28 10:20
	987	(setq file (abbreviate-file-name file))
	988	(let ((root nil)
	989	try)
	990	(while (not (or root
	991	(null file)
	992	(string-match locate-dominating-stop-dir-regexp file)))
	993	(setq try (if (stringp name)
	994	(projectile-file-exists-p (expand-file-name name file))
	995	(funcall name file)))
	996	(cond (try (setq root file))
	997	((equal file (setq file (file-name-directory
	998	(directory-file-name file))))
	999	(setq file nil))))
	1000	(and root (expand-file-name (file-name-as-directory root)))))
	1001
	1002	(defvar-local projectile-project-root nil
	1003	"Defines a custom Projectile project root.
	1004	This is intended to be used as a file local variable.")
	1005
	1006	(defun projectile-root-local (_dir)
	1007	"A simple wrapper around `projectile-project-root'."
	1008	projectile-project-root)
	1009
	1010	(defun projectile-root-top-down (dir &optional list)
	1011	"Identify a project root in DIR by top-down search for files in LIST.
	1012	If LIST is nil, use `projectile-project-root-files' instead.
	1013	Return the first (topmost) matched directory or nil if not found."
	1014	(projectile-locate-dominating-file
	1015	dir
	1016	(lambda (dir)
	1017	(cl-find-if (lambda (f) (projectile-file-exists-p (expand-file-name f dir)))
	1018	(or list projectile-project-root-files)))))
	1019
	1020	(defun projectile-root-bottom-up (dir &optional list)
	1021	"Identify a project root in DIR by bottom-up search for files in LIST.
	1022	If LIST is nil, use `projectile-project-root-files-bottom-up' instead.
	1023	Return the first (bottommost) matched directory or nil if not found."
	1024	(cl-some (lambda (name) (projectile-locate-dominating-file dir name))
	1025	(or list projectile-project-root-files-bottom-up)))
	1026
	1027	(defun projectile-root-top-down-recurring (dir &optional list)
	1028	"Identify a project root in DIR by recurring top-down search for files in LIST.
	1029	If LIST is nil, use `projectile-project-root-files-top-down-recurring'
	1030	instead. Return the last (bottommost) matched directory in the
	1031	topmost sequence of matched directories. Nil otherwise."
	1032	(cl-some
	1033	(lambda (f)
	1034	(projectile-locate-dominating-file
	1035	dir
	1036	(lambda (dir)
	1037	(and (projectile-file-exists-p (expand-file-name f dir))
	1038	(or (string-match locate-dominating-stop-dir-regexp (projectile-parent dir))
	1039	(not (projectile-file-exists-p (expand-file-name f (projectile-parent dir)))))))))
	1040	(or list projectile-project-root-files-top-down-recurring)))
	1041
	1042	(defun projectile-project-root (&optional dir)
	1043	"Retrieves the root directory of a project if available.
	1044	If DIR is not supplied its set to the current directory by default."
	1045	;; the cached value will be 'none in the case of no project root (this is to
	1046	;; ensure it is not reevaluated each time when not inside a project) so use
	1047	;; cl-subst to replace this 'none value with nil so a nil value is used
	1048	;; instead
	1049	(let ((dir (or dir default-directory)))
	1050	(cl-subst nil 'none
	1051	;; The `is-local' and `is-connected' variables are
	1052	;; used to fix the behavior where Emacs hangs
	1053	;; because of Projectile when you open a file over
	1054	;; TRAMP. It basically prevents Projectile from
	1055	;; trying to find information about files for which
	1056	;; it's not possible to get that information right
	1057	;; now.
	1058	(or (let ((is-local (not (file-remote-p dir))) ;; `true' if the file is local
	1059	(is-connected (file-remote-p dir nil t))) ;; `true' if the file is remote AND we are connected to the remote
	1060	(when (or is-local is-connected)
	1061	(cl-some
	1062	(lambda (func)
	1063	(let* ((cache-key (format "%s-%s" func dir))
	1064	(cache-value (gethash cache-key projectile-project-root-cache)))
	1065	(if (and cache-value (file-exists-p cache-value))
	1066	cache-value
	1067	(let ((value (funcall func (file-truename dir))))
	1068	(puthash cache-key value projectile-project-root-cache)
	1069	value))))
	1070	projectile-project-root-files-functions)))
	1071	;; set cached to none so is non-nil so we don't try
	1072	;; and look it up again
	1073	'none))))
	1074
	1075	(defun projectile-ensure-project (dir)
	1076	"Ensure that DIR is non-nil.
	1077	Useful for commands that expect the presence of a project.
	1078	Controlled by `projectile-require-project-root'."
	1079	(if dir
	1080	dir
	1081	(cond
	1082	((eq projectile-require-project-root 'prompt) (projectile-completing-read
	1083	"Switch to project: " projectile-known-projects))
	1084	(projectile-require-project-root (error "Projectile can't find a project definition in %s" dir))
	1085	(t default-directory))))
	1086
	1087	(defun projectile-project-p (&optional dir)
	1088	"Check if DIR is a project.
	1089	Defaults to the current directory if not provided
	1090	explicitly."
	1091	(projectile-project-root (or dir default-directory)))
	1092
	1093	(defun projectile-default-project-name (project-root)
	1094	"Default function used create project name to be displayed based on the value of PROJECT-ROOT."
	1095	(file-name-nondirectory (directory-file-name project-root)))
	1096
	1097	(defun projectile-project-name (&optional project)
	1098	"Return project name.
	1099	If PROJECT is not specified acts on the current project."
	1100	(or projectile-project-name
	1101	(let ((project-root (or project (projectile-project-root))))
	1102	(if project-root
	1103	(funcall projectile-project-name-function project-root)
	1104	"-"))))
	1105
	1106
	1107	;;; Project indexing
	1108	(defun projectile-get-project-directories (project-dir)
	1109	"Get the list of PROJECT-DIR directories that are of interest to the user."
	1110	(mapcar (lambda (subdir) (concat project-dir subdir))
	1111	(or (nth 0 (projectile-parse-dirconfig-file)) '(""))))
	1112
	1113	(defun projectile--directory-p (directory)
	1114	"Checks if DIRECTORY is a string designating a valid directory."
	1115	(and (stringp directory) (file-directory-p directory)))
	1116
	1117	(defun projectile-dir-files (directory)
	1118	"List the files in DIRECTORY and in its sub-directories.
	1119	Files are returned as relative paths to DIRECTORY."
	1120	(unless (projectile--directory-p directory)
	1121	(error "Directory %S does not exist" directory))
	1122	;; check for a cache hit first if caching is enabled
	1123	(let ((files-list (and projectile-enable-caching
	1124	(gethash directory projectile-projects-cache))))
	1125	;; cache disabled or cache miss
	1126	(or files-list
	1127	(let ((vcs (projectile-project-vcs directory)))
	1128	(pcase projectile-indexing-method
	1129	('native (projectile-dir-files-native directory))
	1130	;; use external tools to get the project files
	1131	('hybrid (projectile-adjust-files directory vcs (projectile-dir-files-alien directory)))
	1132	('alien (projectile-dir-files-alien directory))
	1133	(_ (user-error "Unsupported indexing method `%S'" projectile-indexing-method)))))))
	1134
	1135	;;; Native Project Indexing
	1136	;;
	1137	;; This corresponds to `projectile-indexing-method' being set to native.
	1138	(defun projectile-dir-files-native (directory)
	1139	"Get the files for ROOT under DIRECTORY using just Emacs Lisp."
	1140	(let ((progress-reporter
	1141	(make-progress-reporter
	1142	(format "Projectile is indexing %s"
	1143	(propertize directory 'face 'font-lock-keyword-face)))))
	1144	;; we need the files with paths relative to the project root
	1145	(mapcar (lambda (file) (file-relative-name file directory))
	1146	(projectile-index-directory directory (projectile-filtering-patterns)
	1147	progress-reporter))))
	1148
	1149	(defun projectile-index-directory (directory patterns progress-reporter)
	1150	"Index DIRECTORY taking into account PATTERNS.
	1151	The function calls itself recursively until all sub-directories
	1152	have been indexed. The PROGRESS-REPORTER is updated while the
	1153	function is executing."
	1154	(apply 'append
	1155	(mapcar
	1156	(lambda (f)
	1157	(unless (or (and patterns (projectile-ignored-rel-p f directory patterns))
	1158	(member (file-name-nondirectory (directory-file-name f))
	1159	'("." ".." ".svn" ".cvs")))
	1160	(progress-reporter-update progress-reporter)
	1161	(if (file-directory-p f)
	1162	(unless (projectile-ignored-directory-p
	1163	(file-name-as-directory f))
	1164	(projectile-index-directory f patterns progress-reporter))
	1165	(unless (projectile-ignored-file-p f)
	1166	(list f)))))
	1167	(directory-files directory t))))
	1168
	1169	;;; Alien Project Indexing
	1170	;;
	1171	;; This corresponds to `projectile-indexing-method' being set to hybrid or alien.
	1172	;; The only difference between the two methods is that alien doesn't do
	1173	;; any post-processing of the files obtained via the external command.
	1174	(defun projectile-dir-files-alien (directory)
	1175	"Get the files for DIRECTORY using external tools."
	1176	(let ((vcs (projectile-project-vcs directory)))
	1177	(cond
	1178	((eq vcs 'git)
	1179	(nconc (projectile-files-via-ext-command directory (projectile-get-ext-command vcs))
	1180	(projectile-get-sub-projects-files directory vcs)))
	1181	(t (projectile-files-via-ext-command directory (projectile-get-ext-command vcs))))))
	1182
	1183	(define-obsolete-function-alias 'projectile-dir-files-external 'projectile-dir-files-alien "1.1")
	1184	(define-obsolete-function-alias 'projectile-get-repo-files 'projectile-dir-files-alien "1.1")
	1185
	1186	(defun projectile-get-ext-command (vcs)
	1187	"Determine which external command to invoke based on the project's VCS.
	1188	Fallback to a generic command when not in a VCS-controlled project."
	1189	(pcase vcs
	1190	('git projectile-git-command)
	1191	('hg projectile-hg-command)
	1192	('fossil projectile-fossil-command)
	1193	('bzr projectile-bzr-command)
	1194	('darcs projectile-darcs-command)
	1195	('svn projectile-svn-command)
	1196	(_ projectile-generic-command)))
	1197
	1198	(defun projectile-get-sub-projects-command (vcs)
	1199	"Get the sub-projects command for VCS.
	1200	Currently that's supported just for Git (sub-projects being Git
	1201	sub-modules there)."
	1202	(pcase vcs
	1203	('git projectile-git-submodule-command)
	1204	(_ "")))
	1205
	1206	(defun projectile-get-ext-ignored-command (vcs)
	1207	"Determine which external command to invoke based on the project's VCS."
	1208	(pcase vcs
	1209	('git projectile-git-ignored-command)
	1210	;; TODO: Add support for other VCS
	1211	(_ nil)))
	1212
	1213	(defun projectile-flatten (lst)
	1214	"Take a nested list LST and return its contents as a single, flat list."
	1215	(if (and (listp lst) (listp (cdr lst)))
	1216	(cl-mapcan 'projectile-flatten lst)
	1217	(list lst)))
	1218
	1219	(defun projectile-get-all-sub-projects (project)
	1220	"Get all sub-projects for a given project.
	1221
	1222	PROJECT is base directory to start search recursively."
	1223	(let ((submodules (projectile-get-immediate-sub-projects project)))
	1224	(cond
	1225	((null submodules)
	1226	nil)
	1227	(t
	1228	(nconc submodules (projectile-flatten
	1229	;; recursively get sub-projects of each sub-project
	1230	(mapcar (lambda (s)
	1231	(projectile-get-all-sub-projects s)) submodules)))))))
	1232
	1233	(defun projectile-get-immediate-sub-projects (path)
	1234	"Get immediate sub-projects for a given project without recursing.
	1235
	1236	PATH is the vcs root or project root from which to start
	1237	searching, and should end with an appropriate path delimiter, such as
	1238	'/' or a '\\'.
	1239
	1240	If the vcs get-sub-projects query returns results outside of path,
	1241	they are excluded from the results of this function."
	1242	(let* ((vcs (projectile-project-vcs path))
	1243	;; search for sub-projects under current project `project'
	1244	(submodules (mapcar
	1245	(lambda (s)
	1246	(file-name-as-directory (expand-file-name s path)))
	1247	(projectile-files-via-ext-command path (projectile-get-sub-projects-command vcs))))
	1248	(project-child-folder-regex
	1249	(concat "\\`"
	1250	(regexp-quote path))))
	1251
	1252	;; If project root is inside of an VCS folder, but not actually an
	1253	;; VCS root itself, submodules external to the project will be
	1254	;; included in the VCS get sub-projects result. Let's remove them.
	1255	(cl-remove-if-not
	1256	(lambda (submodule)
	1257	(string-match-p project-child-folder-regex
	1258	submodule))
	1259	submodules)))
	1260
	1261	(defun projectile-get-sub-projects-files (project-root vcs)
	1262	"Get files from sub-projects for PROJECT-ROOT recursively."
	1263	(projectile-flatten
	1264	(mapcar (lambda (sub-project)
	1265	(mapcar (lambda (file)
	1266	(concat sub-project file))
	1267	;; TODO: Seems we forgot git hardcoded here
	1268	(projectile-files-via-ext-command sub-project projectile-git-command)))
	1269	(projectile-get-all-sub-projects project-root))))
	1270
	1271	(defun projectile-get-repo-ignored-files (project vcs)
	1272	"Get a list of the files ignored in the PROJECT using VCS."
	1273	(let ((cmd (projectile-get-ext-ignored-command vcs)))
	1274	(when cmd
	1275	(projectile-files-via-ext-command project cmd))))
	1276
	1277	(defun projectile-get-repo-ignored-directory (project dir vcs)
	1278	"Get a list of the files ignored in the PROJECT in the directory DIR.
	1279	VCS is the VCS of the project."
	1280	(let ((cmd (projectile-get-ext-ignored-command vcs)))
	1281	(when cmd
	1282	(projectile-files-via-ext-command project (concat cmd " " dir)))))
	1283
	1284	(defun projectile-files-via-ext-command (root command)
	1285	"Get a list of relative file names in the project ROOT by executing COMMAND.
	1286
	1287	If `command' is nil or an empty string, return nil.
	1288	This allows commands to be disabled."
	1289	(when (stringp command)
	1290	(let ((default-directory root))
	1291	(split-string (shell-command-to-string command) "\0" t))))
	1292
	1293	(defun projectile-adjust-files (project vcs files)
	1294	"First remove ignored files from FILES, then add back unignored files."
	1295	(projectile-add-unignored project vcs (projectile-remove-ignored files)))
	1296
	1297	(defun projectile-remove-ignored (files)
	1298	"Remove ignored files and folders from FILES.
	1299
	1300	If ignored directory prefixed with '*', then ignore all
	1301	directories/subdirectories with matching filename,
	1302	otherwise operates relative to project root."
	1303	(let ((ignored-files (projectile-ignored-files-rel))
	1304	(ignored-dirs (projectile-ignored-directories-rel)))
	1305	(cl-remove-if
	1306	(lambda (file)
	1307	(or (cl-some
	1308	(lambda (f)
	1309	(string= f (file-name-nondirectory file)))
	1310	ignored-files)
	1311	(cl-some
	1312	(lambda (dir)
	1313	;; if the directory is prefixed with '*' then ignore all directories matching that name
	1314	(if (string-prefix-p "*" dir)
	1315	;; remove '*' and trailing slash from ignored directory name
	1316	(let ((d (substring dir 1 (if (equal (substring dir -1) "/") -1 nil))))
	1317	(cl-some
	1318	(lambda (p)
	1319	(string= d p))
	1320	;; split path by '/', remove empty strings, and check if any subdirs match name 'd'
	1321	(delete "" (split-string (or (file-name-directory file) "") "/"))))
	1322	(string-prefix-p dir file)))
	1323	ignored-dirs)
	1324	(cl-some
	1325	(lambda (suf)
	1326	(string-suffix-p suf file t))
	1327	projectile-globally-ignored-file-suffixes)))
	1328	files)))
	1329
	1330	(defun projectile-keep-ignored-files (project vcs files)
	1331	"Filter FILES to retain only those that are ignored."
	1332	(when files
	1333	(cl-remove-if-not
	1334	(lambda (file)
	1335	(cl-some (lambda (f) (string-prefix-p f file)) files))
	1336	(projectile-get-repo-ignored-files project vcs))))
	1337
	1338	(defun projectile-keep-ignored-directories (project vcs directories)
	1339	"Get ignored files within each of DIRECTORIES."
	1340	(when directories
	1341	(let (result)
	1342	(dolist (dir directories result)
	1343	(setq result (append result
	1344	(projectile-get-repo-ignored-directory project vcs dir))))
	1345	result)))
	1346
	1347	(defun projectile-add-unignored (project vcs files)
	1348	"This adds unignored files to FILES.
	1349
	1350	Useful because the VCS may not return ignored files at all. In
	1351	this case unignored files will be absent from FILES."
	1352	(let ((unignored-files (projectile-keep-ignored-files
	1353	project
	1354	vcs
	1355	(projectile-unignored-files-rel)))
	1356	(unignored-paths (projectile-remove-ignored
	1357	(projectile-keep-ignored-directories
	1358	project
	1359	vcs
	1360	(projectile-unignored-directories-rel)))))
	1361	(append files unignored-files unignored-paths)))
	1362
	1363	(defun projectile-buffers-with-file (buffers)
	1364	"Return only those BUFFERS backed by files."
	1365	(cl-remove-if-not (lambda (b) (buffer-file-name b)) buffers))
	1366
	1367	(defun projectile-buffers-with-file-or-process (buffers)
	1368	"Return only those BUFFERS backed by files or processes."
	1369	(cl-remove-if-not (lambda (b) (or (buffer-file-name b)
	1370	(get-buffer-process b))) buffers))
	1371
	1372	(defun projectile-project-buffers (&optional project)
	1373	"Get a list of a project's buffers.
	1374	If PROJECT is not specified the command acts on the current project."
	1375	(let* ((project-root (or project (projectile-project-root)))
	1376	(all-buffers (cl-remove-if-not
	1377	(lambda (buffer)
	1378	(projectile-project-buffer-p buffer project-root))
	1379	(buffer-list))))
	1380	(if projectile-buffers-filter-function
	1381	(funcall projectile-buffers-filter-function all-buffers)
	1382	all-buffers)))
	1383
	1384	(defun projectile-process-current-project-buffers (action)
	1385	"Process the current project's buffers using ACTION."
	1386	(let ((project-buffers (projectile-project-buffers)))
	1387	(dolist (buffer project-buffers)
	1388	(funcall action buffer))))
	1389
	1390	(defun projectile-project-buffer-files (&optional project)
	1391	"Get a list of a project's buffer files.
	1392	If PROJECT is not specified the command acts on the current project."
	1393	(let ((project-root (or project (projectile-project-root))))
	1394	(mapcar
	1395	(lambda (buffer)
	1396	(file-relative-name
	1397	(buffer-file-name buffer)
	1398	project-root))
	1399	(projectile-buffers-with-file
	1400	(projectile-project-buffers project)))))
	1401
	1402	(defun projectile-project-buffer-p (buffer project-root)
	1403	"Check if BUFFER is under PROJECT-ROOT."
	1404	(with-current-buffer buffer
	1405	(and (not (string-prefix-p " " (buffer-name buffer)))
	1406	(not (projectile-ignored-buffer-p buffer))
	1407	default-directory
	1408	(string-equal (file-remote-p default-directory)
	1409	(file-remote-p project-root))
	1410	(not (string-match-p "^http\$s\$?://" default-directory))
	1411	(string-prefix-p project-root (file-truename default-directory) (eq system-type 'windows-nt)))))
	1412
	1413	(defun projectile-ignored-buffer-p (buffer)
	1414	"Check if BUFFER should be ignored.
	1415
	1416	Regular expressions can be use."
	1417	(or
	1418	(with-current-buffer buffer
	1419	(cl-some
	1420	(lambda (name)
	1421	(string-match-p name (buffer-name)))
	1422	projectile-globally-ignored-buffers))
	1423	(with-current-buffer buffer
	1424	(cl-some
	1425	(lambda (mode)
	1426	(string-match-p (concat "^" mode "$")
	1427	(symbol-name major-mode)))
	1428	projectile-globally-ignored-modes))))
	1429
	1430	(defun projectile-recently-active-files ()
	1431	"Get list of recently active files.
	1432
	1433	Files are ordered by recently active buffers, and then recently
	1434	opened through use of recentf."
	1435	(let ((project-buffer-files (projectile-project-buffer-files)))
	1436	(append project-buffer-files
	1437	(projectile-difference
	1438	(projectile-recentf-files)
	1439	project-buffer-files))))
	1440
	1441	(defun projectile-project-buffer-names ()
	1442	"Get a list of project buffer names."
	1443	(mapcar #'buffer-name (projectile-project-buffers)))
	1444
	1445	(defun projectile-prepend-project-name (string)
	1446	"Prepend the current project's name to STRING."
	1447	(format "[%s] %s" (projectile-project-name) string))
	1448
	1449	(defun projectile-read-buffer-to-switch (prompt)
	1450	"Read the name of a buffer to switch to, prompting with PROMPT.
	1451
	1452	This function excludes the current buffer from the offered
	1453	choices."
	1454	(projectile-completing-read
	1455	prompt
	1456	(delete (buffer-name (current-buffer))
	1457	(projectile-project-buffer-names))))
	1458
	1459	;;;###autoload
	1460	(defun projectile-switch-to-buffer ()
	1461	"Switch to a project buffer."
	1462	(interactive)
	1463	(switch-to-buffer
	1464	(projectile-read-buffer-to-switch "Switch to buffer: ")))
	1465
	1466	;;;###autoload
	1467	(defun projectile-switch-to-buffer-other-window ()
	1468	"Switch to a project buffer and show it in another window."
	1469	(interactive)
	1470	(switch-to-buffer-other-window
	1471	(projectile-read-buffer-to-switch "Switch to buffer: ")))
	1472
	1473	;;;###autoload
	1474	(defun projectile-switch-to-buffer-other-frame ()
	1475	"Switch to a project buffer and show it in another window."
	1476	(interactive)
	1477	(switch-to-buffer-other-frame
	1478	(projectile-read-buffer-to-switch "Switch to buffer: ")))
	1479
	1480	;;;###autoload
	1481	(defun projectile-display-buffer ()
	1482	"Display a project buffer in another window without selecting it."
	1483	(interactive)
	1484	(display-buffer
	1485	(projectile-completing-read
	1486	"Display buffer: "
	1487	(projectile-project-buffer-names))))
	1488
	1489	;;;###autoload
	1490	(defun projectile-project-buffers-other-buffer ()
	1491	"Switch to the most recently selected buffer project buffer.
	1492	Only buffers not visible in windows are returned."
	1493	(interactive)
	1494	(switch-to-buffer (car (projectile-project-buffers-non-visible))) nil t)
	1495
	1496	(defun projectile-project-buffers-non-visible ()
	1497	"Get a list of non visible project buffers."
	1498	(cl-remove-if-not
	1499	(lambda (buffer)
	1500	(not (get-buffer-window buffer 'visible)))
	1501	(projectile-project-buffers)))
	1502
	1503	;;;###autoload
	1504	(defun projectile-multi-occur (&optional nlines)
	1505	"Do a `multi-occur' in the project's buffers.
	1506	With a prefix argument, show NLINES of context."
	1507	(interactive "P")
	1508	(let ((project (projectile-ensure-project (projectile-project-root))))
	1509	(multi-occur (projectile-project-buffers project)
	1510	(car (occur-read-primary-args))
	1511	nlines)))
	1512
	1513	(defun projectile-normalise-paths (patterns)
	1514	"Remove leading `/' from the elements of PATTERNS."
	1515	(delq nil (mapcar (lambda (pat) (and (string-prefix-p "/" pat)
	1516	;; remove the leading /
	1517	(substring pat 1)))
	1518	patterns)))
	1519
	1520	(defun projectile-expand-paths (paths)
	1521	"Expand the elements of PATHS.
	1522
	1523	Elements containing wildcards are expanded and spliced into the
	1524	resulting paths. The returned PATHS are absolute, based on the
	1525	projectile project root."
	1526	(let ((default-directory (projectile-project-root)))
	1527	(projectile-flatten (mapcar
	1528	(lambda (pattern)
	1529	(or (file-expand-wildcards pattern t)
	1530	(projectile-expand-root pattern)))
	1531	paths))))
	1532
	1533	(defun projectile-normalise-patterns (patterns)
	1534	"Remove paths from PATTERNS."
	1535	(cl-remove-if (lambda (pat) (string-prefix-p "/" pat)) patterns))
	1536
	1537	(defun projectile-make-relative-to-root (files)
	1538	"Make FILES relative to the project root."
	1539	(let ((project-root (projectile-project-root)))
	1540	(mapcar (lambda (f) (file-relative-name f project-root)) files)))
	1541
	1542	(defun projectile-ignored-directory-p (directory)
	1543	"Check if DIRECTORY should be ignored.
	1544
	1545	Regular expressions can be used."
	1546	(cl-some
	1547	(lambda (name)
	1548	(string-match-p name directory))
	1549	(projectile-ignored-directories)))
	1550
	1551	(defun projectile-ignored-file-p (file)
	1552	"Check if FILE should be ignored.
	1553
	1554	Regular expressions can be used."
	1555	(cl-some
	1556	(lambda (name)
	1557	(string-match-p name file))
	1558	(projectile-ignored-files)))
	1559
	1560	(defun projectile-check-pattern-p (file pattern)
	1561	"Check if FILE meets PATTERN."
	1562	(or (string-suffix-p (directory-file-name pattern)
	1563	(directory-file-name file))
	1564	(member file (file-expand-wildcards pattern t))))
	1565
	1566	(defun projectile-ignored-rel-p (file directory patterns)
	1567	"Check if FILE should be ignored relative to DIRECTORY
	1568	according to PATTERNS: (ignored . unignored)"
	1569	(let ((default-directory directory))
	1570	(and (cl-some
	1571	(lambda (pat) (projectile-check-pattern-p file pat))
	1572	(car patterns))
	1573	(cl-notany
	1574	(lambda (pat) (projectile-check-pattern-p file pat))
	1575	(cdr patterns)))))
	1576
	1577	(defun projectile-ignored-files ()
	1578	"Return list of ignored files."
	1579	(projectile-difference
	1580	(mapcar
	1581	#'projectile-expand-root
	1582	(append
	1583	projectile-globally-ignored-files
	1584	(projectile-project-ignored-files)))
	1585	(projectile-unignored-files)))
	1586
	1587	(defun projectile-ignored-directories ()
	1588	"Return list of ignored directories."
	1589	(projectile-difference
	1590	(mapcar
	1591	#'file-name-as-directory
	1592	(mapcar
	1593	#'projectile-expand-root
	1594	(append
	1595	projectile-globally-ignored-directories
	1596	(projectile-project-ignored-directories))))
	1597	(projectile-unignored-directories)))
	1598
	1599	(defun projectile-ignored-directories-rel ()
	1600	"Return list of ignored directories, relative to the root."
	1601	(projectile-make-relative-to-root (projectile-ignored-directories)))
	1602
	1603	(defun projectile-ignored-files-rel ()
	1604	"Return list of ignored files, relative to the root."
	1605	(projectile-make-relative-to-root (projectile-ignored-files)))
	1606
	1607	(defun projectile-project-ignored-files ()
	1608	"Return list of project ignored files.
	1609	Unignored files are not included."
	1610	(cl-remove-if 'file-directory-p (projectile-project-ignored)))
	1611
	1612	(defun projectile-project-ignored-directories ()
	1613	"Return list of project ignored directories.
	1614	Unignored directories are not included."
	1615	(cl-remove-if-not 'file-directory-p (projectile-project-ignored)))
	1616
	1617	(defun projectile-paths-to-ignore ()
	1618	"Return a list of ignored project paths."
	1619	(projectile-normalise-paths (nth 1 (projectile-parse-dirconfig-file))))
	1620
	1621	(defun projectile-patterns-to-ignore ()
	1622	"Return a list of relative file patterns."
	1623	(projectile-normalise-patterns (nth 1 (projectile-parse-dirconfig-file))))
	1624
	1625	(defun projectile-project-ignored ()
	1626	"Return list of project ignored files/directories.
	1627	Unignored files/directories are not included."
	1628	(let ((paths (projectile-paths-to-ignore)))
	1629	(projectile-expand-paths paths)))
	1630
	1631	(defun projectile-unignored-files ()
	1632	"Return list of unignored files."
	1633	(mapcar
	1634	#'projectile-expand-root
	1635	(append
	1636	projectile-globally-unignored-files
	1637	(projectile-project-unignored-files))))
	1638
	1639	(defun projectile-unignored-directories ()
	1640	"Return list of unignored directories."
	1641	(mapcar
	1642	#'file-name-as-directory
	1643	(mapcar
	1644	#'projectile-expand-root
	1645	(append
	1646	projectile-globally-unignored-directories
	1647	(projectile-project-unignored-directories)))))
	1648
	1649	(defun projectile-unignored-directories-rel ()
	1650	"Return list of unignored directories, relative to the root."
	1651	(projectile-make-relative-to-root (projectile-unignored-directories)))
	1652
	1653	(defun projectile-unignored-files-rel ()
	1654	"Return list of unignored files, relative to the root."
	1655	(projectile-make-relative-to-root (projectile-unignored-files)))
	1656
	1657	(defun projectile-project-unignored-files ()
	1658	"Return list of project unignored files."
	1659	(cl-remove-if 'file-directory-p (projectile-project-unignored)))
	1660
	1661	(defun projectile-project-unignored-directories ()
	1662	"Return list of project unignored directories."
	1663	(cl-remove-if-not 'file-directory-p (projectile-project-unignored)))
	1664
	1665	(defun projectile-paths-to-ensure ()
	1666	"Return a list of unignored project paths."
	1667	(projectile-normalise-paths (nth 2 (projectile-parse-dirconfig-file))))
	1668
	1669	(defun projectile-files-to-ensure ()
	1670	(projectile-flatten (mapcar (lambda (pat) (file-expand-wildcards pat t))
	1671	(projectile-patterns-to-ensure))))
	1672
	1673	(defun projectile-patterns-to-ensure ()
	1674	"Return a list of relative file patterns."
	1675	(projectile-normalise-patterns (nth 2 (projectile-parse-dirconfig-file))))
	1676
	1677	(defun projectile-filtering-patterns ()
	1678	(cons (projectile-patterns-to-ignore)
	1679	(projectile-patterns-to-ensure)))
	1680
	1681	(defun projectile-project-unignored ()
	1682	"Return list of project ignored files/directories."
	1683	(delete-dups (append (projectile-expand-paths (projectile-paths-to-ensure))
	1684	(projectile-expand-paths (projectile-files-to-ensure)))))
	1685
	1686
	1687	(defun projectile-dirconfig-file ()
	1688	"Return the absolute path to the project's dirconfig file."
	1689	(expand-file-name ".projectile" (projectile-project-root)))
	1690
	1691	(defun projectile-parse-dirconfig-file ()
	1692	"Parse project ignore file and return directories to ignore and keep.
	1693
	1694	The return value will be a list of three elements, the car being
	1695	the list of directories to keep, the cadr being the list of files
	1696	or directories to ignore, and the caddr being the list of files
	1697	or directories to ensure.
	1698
	1699	Strings starting with + will be added to the list of directories
	1700	to keep, and strings starting with - will be added to the list of
	1701	directories to ignore. For backward compatibility, without a
	1702	prefix the string will be assumed to be an ignore string."
	1703	(let (keep ignore ensure (dirconfig (projectile-dirconfig-file)))
	1704	(when (projectile-file-exists-p dirconfig)
	1705	(with-temp-buffer
	1706	(insert-file-contents dirconfig)
	1707	(while (not (eobp))
	1708	(pcase (char-after)
	1709	(?+ (push (buffer-substring (1+ (point)) (line-end-position)) keep))
	1710	(?- (push (buffer-substring (1+ (point)) (line-end-position)) ignore))
	1711	(?! (push (buffer-substring (1+ (point)) (line-end-position)) ensure))
	1712	(_ (push (buffer-substring (point) (line-end-position)) ignore)))
	1713	(forward-line)))
	1714	(list (mapcar (lambda (f) (file-name-as-directory (string-trim f)))
	1715	(delete "" (reverse keep)))
	1716	(mapcar #'string-trim
	1717	(delete "" (reverse ignore)))
	1718	(mapcar #'string-trim
	1719	(delete "" (reverse ensure)))))))
	1720
	1721	(defun projectile-expand-root (name)
	1722	"Expand NAME to project root.
	1723
	1724	Never use on many files since it's going to recalculate the
	1725	project-root for every file."
	1726	(expand-file-name name (projectile-project-root)))
	1727
	1728	(cl-defun projectile-completing-read (prompt choices &key initial-input action)
	1729	"Present a project tailored PROMPT with CHOICES."
	1730	(let ((prompt (projectile-prepend-project-name prompt))
	1731	res)
	1732	(setq res
	1733	(cond
	1734	((eq projectile-completion-system 'ido)
	1735	(ido-completing-read prompt choices nil nil initial-input))
	1736	((eq projectile-completion-system 'default)
	1737	(completing-read prompt choices nil nil initial-input))
	1738	((eq projectile-completion-system 'helm)
	1739	(if (and (fboundp 'helm)
	1740	(fboundp 'helm-make-source))
	1741	(helm :sources
	1742	(helm-make-source "Projectile" 'helm-source-sync
	1743	:candidates choices
	1744	:action (if action
	1745	(prog1 action
	1746	(setq action nil))
	1747	#'identity))
	1748	:prompt prompt
	1749	:input initial-input
	1750	:buffer "helm-projectile")
	1751	(user-error "Please install helm from \
	1752	https://github.com/emacs-helm/helm")))
	1753	((eq projectile-completion-system 'ivy)
	1754	(if (fboundp 'ivy-read)
	1755	(ivy-read prompt choices
	1756	:initial-input initial-input
	1757	:action (prog1 action
	1758	(setq action nil))
	1759	:caller 'projectile-completing-read)
	1760	(user-error "Please install ivy from \
	1761	https://github.com/abo-abo/swiper")))
	1762	(t (funcall projectile-completion-system prompt choices))))
	1763	(if action
	1764	(funcall action res)
	1765	res)))
	1766
	1767	(defun projectile-project-files (project-root)
	1768	"Return a list of files for the PROJECT-ROOT."
	1769	(let (files)
	1770	;; If the cache is too stale, don't use it.
	1771	(when projectile-files-cache-expire
	1772	(let ((cache-time
	1773	(gethash project-root projectile-projects-cache-time)))
	1774	(when (or (null cache-time)
	1775	(< (+ cache-time projectile-files-cache-expire)
	1776	(projectile-time-seconds)))
	1777	(remhash project-root projectile-projects-cache)
	1778	(remhash project-root projectile-projects-cache-time))))
	1779
	1780	;; Use the cache, if requested and available.
	1781	(when projectile-enable-caching
	1782	(setq files (gethash project-root projectile-projects-cache)))
	1783
	1784	;; Calculate the list of files.
	1785	(when (null files)
	1786	(when projectile-enable-caching
	1787	(message "Projectile is initializing cache..."))
	1788	(setq files
	1789	(if (eq projectile-indexing-method 'alien)
	1790	;; In alien mode we can just skip reading
	1791	;; .projectile and find all files in the root dir.
	1792	(projectile-dir-files-alien project-root)
	1793	;; If a project is defined as a list of subfolders
	1794	;; then we'll have the files returned for each subfolder,
	1795	;; so they are relative to the project root.
	1796	;;
	1797	;; TODO: That's pretty slow and we need to improve it.
	1798	;; One options would be to pass explicitly the subdirs
	1799	;; to commands like `git ls-files` which would return
	1800	;; files paths relative to the project root.
	1801	(cl-mapcan
	1802	(lambda (dir)
	1803	(mapcar (lambda (f)
	1804	(file-relative-name (concat dir f)
	1805	project-root))
	1806	(projectile-dir-files dir)))
	1807	(projectile-get-project-directories project-root))))
	1808
	1809	;; Save the cached list.
	1810	(when projectile-enable-caching
	1811	(projectile-cache-project project-root files)))
	1812
	1813	;;; Sorting
	1814	;;
	1815	;; Files can't be cached in sorted order as some sorting schemes
	1816	;; require dynamic data. Sorting is ignored completely when in
	1817	;; alien mode.
	1818	(if (eq projectile-indexing-method 'alien)
	1819	files
	1820	(projectile-sort-files files))))
	1821
	1822	(defun projectile-current-project-files ()
	1823	"Return a list of the files in the current project."
	1824	(projectile-project-files (projectile-project-root)))
	1825
	1826	(defun projectile-process-current-project-files (action)
	1827	"Process the current project's files using ACTION."
	1828	(let ((project-files (projectile-current-project-files))
	1829	(default-directory (projectile-project-root)))
	1830	(dolist (filename project-files)
	1831	(funcall action filename))))
	1832
	1833	(defun projectile-project-dirs (project)
	1834	"Return a list of dirs for PROJECT."
	1835	(delete-dups
	1836	(delq nil
	1837	(mapcar #'file-name-directory
	1838	(projectile-project-files project)))))
	1839
	1840	(defun projectile-current-project-dirs ()
	1841	"Return a list of dirs for the current project."
	1842	(projectile-project-dirs (projectile-ensure-project (projectile-project-root))))
	1843
	1844	;;; Interactive commands
	1845
	1846	(defun projectile--find-other-file (&optional flex-matching ff-variant)
	1847	"Switch between files with the same name but different extensions.
	1848	With FLEX-MATCHING, match any file that contains the base name of current file.
	1849	Other file extensions can be customized with the variable
	1850	`projectile-other-file-alist'. With FF-VARIANT set to a defun, use that
	1851	instead of `find-file'. A typical example of such a defun would be
	1852	`find-file-other-window' or `find-file-other-frame'"
	1853	(let ((ff (or ff-variant #'find-file))
	1854	(other-files (projectile-get-other-files
	1855	(buffer-file-name)
	1856	(projectile-current-project-files)
	1857	flex-matching)))
	1858	(if other-files
	1859	(let ((file-name (if (= (length other-files) 1)
	1860	(car other-files)
	1861	(projectile-completing-read "Switch to: "
	1862	other-files))))
	1863	(funcall ff (expand-file-name file-name
	1864	(projectile-project-root))))
	1865	(error "No other file found"))))
	1866
	1867	;;;###autoload
	1868	(defun projectile-find-other-file (&optional flex-matching)
	1869	"Switch between files with the same name but different extensions.
	1870	With FLEX-MATCHING, match any file that contains the base name of current file.
	1871	Other file extensions can be customized with the variable `projectile-other-file-alist'."
	1872	(interactive "P")
	1873	(projectile--find-other-file flex-matching))
	1874
	1875	;;;###autoload
	1876	(defun projectile-find-other-file-other-window (&optional flex-matching)
	1877	"Switch between files with the same name but different extensions in other window.
	1878	With FLEX-MATCHING, match any file that contains the base name of current file.
	1879	Other file extensions can be customized with the variable `projectile-other-file-alist'."
	1880	(interactive "P")
	1881	(projectile--find-other-file flex-matching
	1882	#'find-file-other-window))
	1883
	1884	;;;###autoload
	1885	(defun projectile-find-other-file-other-frame (&optional flex-matching)
	1886	"Switch between files with the same name but different extensions in other window.
	1887	With FLEX-MATCHING, match any file that contains the base name of current file.
	1888	Other file extensions can be customized with the variable `projectile-other-file-alist'."
	1889	(interactive "P")
	1890	(projectile--find-other-file flex-matching
	1891	#'find-file-other-frame))
	1892
	1893	(defun projectile--file-name-sans-extensions (file-name)
	1894	"Return FILE-NAME sans any extensions.
	1895	The extensions, in a filename, are what follows the first '.', with the exception of a leading '.'"
	1896	(setq file-name (file-name-nondirectory file-name))
	1897	(substring file-name 0 (string-match "\\..*" file-name 1)))
	1898
	1899	(defun projectile--file-name-extensions (file-name)
	1900	"Return FILE-NAME's extensions.
	1901	The extensions, in a filename, are what follows the first '.', with the exception of a leading '.'"
	1902	;;would it make sense to return nil instead of an empty string if no extensions are found?
	1903	(setq file-name (file-name-nondirectory file-name))
	1904	(let (extensions-start)
	1905	(substring file-name
	1906	(if (setq extensions-start (string-match "\\..*" file-name 1))
	1907	(1+ extensions-start)
	1908	(length file-name)))))
	1909
	1910	(defun projectile-associated-file-name-extensions (file-name)
	1911	"Return projectile-other-file-extensions associated to FILE-NAME's extensions.
	1912	If no associated other-file-extensions for the complete (nested) extension are found, remove subextensions from FILENAME's extensions until a match is found."
	1913	(let ((current-extensions (projectile--file-name-extensions (file-name-nondirectory file-name)))
	1914	associated-extensions)
	1915	(catch 'break
	1916	(while (not (string= "" current-extensions))
	1917	(if (setq associated-extensions (cdr (assoc current-extensions projectile-other-file-alist)))
	1918	(throw 'break associated-extensions))
	1919	(setq current-extensions (projectile--file-name-extensions current-extensions))))))
	1920
	1921	(defun projectile-get-other-files (current-file project-file-list &optional flex-matching)
	1922	"Narrow to files with the same names but different extensions.
	1923	Returns a list of possible files for users to choose.
	1924
	1925	With FLEX-MATCHING, match any file that contains the base name of current file"
	1926	(let* ((file-ext-list (projectile-associated-file-name-extensions current-file))
	1927	(fulldirname (if (file-name-directory current-file)
	1928	(file-name-directory current-file) "./"))
	1929	(dirname (file-name-nondirectory (directory-file-name fulldirname)))
	1930	(filename (regexp-quote (projectile--file-name-sans-extensions current-file)))
	1931	(file-list (mapcar (lambda (ext)
	1932	(if flex-matching
	1933	(concat "." filename "." "\." ext "\\'")
	1934	(concat "^" filename
	1935	(unless (equal ext "")
	1936	(concat "\." ext))
	1937	"\\'")))
	1938	file-ext-list))
	1939	(candidates (cl-remove-if-not
	1940	(lambda (project-file)
	1941	(string-match filename project-file))
	1942	project-file-list))
	1943	(candidates
	1944	(projectile-flatten (mapcar
	1945	(lambda (file)
	1946	(cl-remove-if-not
	1947	(lambda (project-file)
	1948	(string-match file
	1949	(concat (file-name-base project-file)
	1950	(unless (equal (file-name-extension project-file) nil)
	1951	(concat "\." (file-name-extension project-file))))))
	1952	candidates))
	1953	file-list)))
	1954	(candidates
	1955	(cl-remove-if-not (lambda (file) (not (backup-file-name-p file))) candidates))
	1956	(candidates
	1957	(cl-sort (copy-sequence candidates)
	1958	(lambda (file _)
	1959	(let ((candidate-dirname (file-name-nondirectory (directory-file-name (file-name-directory file)))))
	1960	(unless (equal fulldirname (file-name-directory file))
	1961	(equal dirname candidate-dirname)))))))
	1962	candidates))
	1963
	1964	(defun projectile-select-files (project-files &optional invalidate-cache)
	1965	"Select a list of files based on filename at point.
	1966
	1967	With a prefix arg INVALIDATE-CACHE invalidates the cache first."
	1968	(projectile-maybe-invalidate-cache invalidate-cache)
	1969	(let* ((file (if (region-active-p)
	1970	(buffer-substring (region-beginning) (region-end))
	1971	(or (thing-at-point 'filename) "")))
	1972	(file (if (string-match "\\.?\\./" file)
	1973	(file-relative-name (file-truename file) (projectile-project-root))
	1974	file))
	1975	(files (if file
	1976	(cl-remove-if-not
	1977	(lambda (project-file)
	1978	(string-match file project-file))
	1979	project-files)
	1980	nil)))
	1981	files))
	1982
	1983	(defun projectile--find-file-dwim (invalidate-cache &optional ff-variant)
	1984	"Jump to a project's files using completion based on context.
	1985
	1986	With a INVALIDATE-CACHE invalidates the cache first.
	1987
	1988	With FF-VARIANT set to a defun, use that instead of `find-file'.
	1989	A typical example of such a defun would be `find-file-other-window' or
	1990	`find-file-other-frame'
	1991
	1992	Subroutine for `projectile-find-file-dwim' and
	1993	`projectile-find-file-dwim-other-window'"
	1994	(let* ((project-root (projectile-project-root))
	1995	(project-files (projectile-project-files project-root))
	1996	(files (projectile-select-files project-files invalidate-cache))
	1997	(file (cond ((= (length files) 1)
	1998	(car files))
	1999	((> (length files) 1)
	2000	(projectile-completing-read "Switch to: " files))
	2001	(t
	2002	(projectile-completing-read "Switch to: " project-files))))
	2003	(ff (or ff-variant #'find-file)))
	2004	(funcall ff (expand-file-name file project-root))
	2005	(run-hooks 'projectile-find-file-hook)))
	2006
	2007	;;;###autoload
	2008	(defun projectile-find-file-dwim (&optional invalidate-cache)
	2009	"Jump to a project's files using completion based on context.
	2010
	2011	With a prefix arg INVALIDATE-CACHE invalidates the cache first.
	2012
	2013	If point is on a filename, Projectile first tries to search for that
	2014	file in project:
	2015
	2016	- If it finds just a file, it switches to that file instantly. This works even
	2017	if the filename is incomplete, but there's only a single file in the current project
	2018	that matches the filename at point. For example, if there's only a single file named
	2019	\"projectile/projectile.el\" but the current filename is \"projectile/proj\" (incomplete),
	2020	`projectile-find-file-dwim' still switches to \"projectile/projectile.el\" immediately
	2021	because this is the only filename that matches.
	2022
	2023	- If it finds a list of files, the list is displayed for selecting. A list of
	2024	files is displayed when a filename appears more than one in the project or the
	2025	filename at point is a prefix of more than two files in a project. For example,
	2026	if `projectile-find-file-dwim' is executed on a filepath like \"projectile/\", it lists
	2027	the content of that directory. If it is executed on a partial filename like
	2028	\"projectile/a\", a list of files with character 'a' in that directory is presented.
	2029
	2030	- If it finds nothing, display a list of all files in project for selecting."
	2031	(interactive "P")
	2032	(projectile--find-file-dwim invalidate-cache))
	2033
	2034	;;;###autoload
	2035	(defun projectile-find-file-dwim-other-window (&optional invalidate-cache)
	2036	"Jump to a project's files using completion based on context in other window.
	2037
	2038	With a prefix arg INVALIDATE-CACHE invalidates the cache first.
	2039
	2040	If point is on a filename, Projectile first tries to search for that
	2041	file in project:
	2042
	2043	- If it finds just a file, it switches to that file instantly. This works even
	2044	if the filename is incomplete, but there's only a single file in the current project
	2045	that matches the filename at point. For example, if there's only a single file named
	2046	\"projectile/projectile.el\" but the current filename is \"projectile/proj\" (incomplete),
	2047	`projectile-find-file-dwim-other-window' still switches to \"projectile/projectile.el\"
	2048	immediately because this is the only filename that matches.
	2049
	2050	- If it finds a list of files, the list is displayed for selecting. A list of
	2051	files is displayed when a filename appears more than one in the project or the
	2052	filename at point is a prefix of more than two files in a project. For example,
	2053	if `projectile-find-file-dwim-other-window' is executed on a filepath like \"projectile/\", it lists
	2054	the content of that directory. If it is executed on a partial filename
	2055	like \"projectile/a\", a list of files with character 'a' in that directory
	2056	is presented.
	2057
	2058	- If it finds nothing, display a list of all files in project for selecting."
	2059	(interactive "P")
	2060	(projectile--find-file-dwim invalidate-cache #'find-file-other-window))
	2061
	2062	;;;###autoload
	2063	(defun projectile-find-file-dwim-other-frame (&optional invalidate-cache)
	2064	"Jump to a project's files using completion based on context in other frame.
	2065
	2066	With a prefix arg INVALIDATE-CACHE invalidates the cache first.
	2067
	2068	If point is on a filename, Projectile first tries to search for that
	2069	file in project:
	2070
	2071	- If it finds just a file, it switches to that file instantly. This works even
	2072	if the filename is incomplete, but there's only a single file in the current project
	2073	that matches the filename at point. For example, if there's only a single file named
	2074	\"projectile/projectile.el\" but the current filename is \"projectile/proj\" (incomplete),
	2075	`projectile-find-file-dwim-other-frame' still switches to \"projectile/projectile.el\"
	2076	immediately because this is the only filename that matches.
	2077
	2078	- If it finds a list of files, the list is displayed for selecting. A list of
	2079	files is displayed when a filename appears more than one in the project or the
	2080	filename at point is a prefix of more than two files in a project. For example,
	2081	if `projectile-find-file-dwim-other-frame' is executed on a filepath like \"projectile/\", it lists
	2082	the content of that directory. If it is executed on a partial filename
	2083	like \"projectile/a\", a list of files with character 'a' in that directory
	2084	is presented.
	2085
	2086	- If it finds nothing, display a list of all files in project for selecting."
	2087	(interactive "P")
	2088	(projectile--find-file-dwim invalidate-cache #'find-file-other-frame))
	2089
	2090	(defun projectile--find-file (invalidate-cache &optional ff-variant)
	2091	"Jump to a project's file using completion.
	2092	With INVALIDATE-CACHE invalidates the cache first. With FF-VARIANT set to a
	2093	defun, use that instead of `find-file'. A typical example of such a defun
	2094	would be `find-file-other-window' or `find-file-other-frame'"
	2095	(interactive "P")
	2096	(projectile-maybe-invalidate-cache invalidate-cache)
	2097	(let* ((project-root (projectile-ensure-project (projectile-project-root)))
	2098	(file (projectile-completing-read "Find file: "
	2099	(projectile-project-files project-root)))
	2100	(ff (or ff-variant #'find-file)))
	2101	(when file
	2102	(funcall ff (expand-file-name file project-root))
	2103	(run-hooks 'projectile-find-file-hook))))
	2104
	2105	;;;###autoload
	2106	(defun projectile-find-file (&optional invalidate-cache)
	2107	"Jump to a project's file using completion.
	2108	With a prefix arg INVALIDATE-CACHE invalidates the cache first."
	2109	(interactive "P")
	2110	(projectile--find-file invalidate-cache))
	2111
	2112	;;;###autoload
	2113	(defun projectile-find-file-other-window (&optional invalidate-cache)
	2114	"Jump to a project's file using completion and show it in another window.
	2115
	2116	With a prefix arg INVALIDATE-CACHE invalidates the cache first."
	2117	(interactive "P")
	2118	(projectile--find-file invalidate-cache #'find-file-other-window))
	2119
	2120	;;;###autoload
	2121	(defun projectile-find-file-other-frame (&optional invalidate-cache)
	2122	"Jump to a project's file using completion and show it in another frame.
	2123
	2124	With a prefix arg INVALIDATE-CACHE invalidates the cache first."
	2125	(interactive "P")
	2126	(projectile--find-file invalidate-cache #'find-file-other-frame))
	2127
	2128	;;;###autoload
	2129	(defun projectile-toggle-project-read-only ()
	2130	"Toggle project read only."
	2131	(interactive)
	2132	(let ((inhibit-read-only t)
	2133	(val (not buffer-read-only))
	2134	(default-directory (projectile-ensure-project (projectile-project-root))))
	2135	(add-dir-local-variable nil 'buffer-read-only val)
	2136	(save-buffer)
	2137	(kill-buffer)
	2138	(when buffer-file-name
	2139	(read-only-mode (if val +1 -1))
	2140	(message "[%s] read-only-mode is %s" (projectile-project-name) (if val "on" "off")))))
	2141
	2142
	2143	;;;; Sorting project files
	2144	(defun projectile-sort-files (files)
	2145	"Sort FILES according to `projectile-sort-order'."
	2146	(cl-case projectile-sort-order
	2147	(default files)
	2148	(recentf (projectile-sort-by-recentf-first files))
	2149	(recently-active (projectile-sort-by-recently-active-first files))
	2150	(modification-time (projectile-sort-by-modification-time files))
	2151	(access-time (projectile-sort-by-access-time files))))
	2152
	2153	(defun projectile-sort-by-recentf-first (files)
	2154	"Sort FILES by a recent first scheme."
	2155	(let ((project-recentf-files (projectile-recentf-files)))
	2156	(append project-recentf-files
	2157	(projectile-difference files project-recentf-files))))
	2158
	2159	(defun projectile-sort-by-recently-active-first (files)
	2160	"Sort FILES by most recently active buffers or opened files."
	2161	(let ((project-recently-active-files (projectile-recently-active-files)))
	2162	(append project-recently-active-files
	2163	(projectile-difference files project-recently-active-files))))
	2164
	2165	(defun projectile-sort-by-modification-time (files)
	2166	"Sort FILES by modification time."
	2167	(let ((default-directory (projectile-project-root)))
	2168	(cl-sort
	2169	(copy-sequence files)
	2170	(lambda (file1 file2)
	2171	(let ((file1-mtime (nth 5 (file-attributes file1)))
	2172	(file2-mtime (nth 5 (file-attributes file2))))
	2173	(not (time-less-p file1-mtime file2-mtime)))))))
	2174
	2175	(defun projectile-sort-by-access-time (files)
	2176	"Sort FILES by access time."
	2177	(let ((default-directory (projectile-project-root)))
	2178	(cl-sort
	2179	(copy-sequence files)
	2180	(lambda (file1 file2)
	2181	(let ((file1-atime (nth 4 (file-attributes file1)))
	2182	(file2-atime (nth 4 (file-attributes file2))))
	2183	(not (time-less-p file1-atime file2-atime)))))))
	2184
	2185
	2186	;;;; Find directory in project functionality
	2187	(defun projectile--find-dir (invalidate-cache &optional dired-variant)
	2188	"Jump to a project's directory using completion.
	2189
	2190	With INVALIDATE-CACHE invalidates the cache first. With DIRED-VARIANT set to a
	2191	defun, use that instead of `dired'. A typical example of such a defun would be
	2192	`dired-other-window' or `dired-other-frame'"
	2193	(projectile-maybe-invalidate-cache invalidate-cache)
	2194	(let* ((project (projectile-ensure-project (projectile-project-root)))
	2195	(dir (projectile-complete-dir project))
	2196	(dired-v (or dired-variant #'dired)))
	2197	(funcall dired-v (expand-file-name dir project))
	2198	(run-hooks 'projectile-find-dir-hook)))
	2199
	2200	;;;###autoload
	2201	(defun projectile-find-dir (&optional invalidate-cache)
	2202	"Jump to a project's directory using completion.
	2203
	2204	With a prefix arg INVALIDATE-CACHE invalidates the cache first."
	2205	(interactive "P")
	2206	(projectile--find-dir invalidate-cache))
	2207
	2208	;;;###autoload
	2209	(defun projectile-find-dir-other-window (&optional invalidate-cache)
	2210	"Jump to a project's directory in other window using completion.
	2211
	2212	With a prefix arg INVALIDATE-CACHE invalidates the cache first."
	2213	(interactive "P")
	2214	(projectile--find-dir invalidate-cache #'dired-other-window))
	2215
	2216	;;;###autoload
	2217	(defun projectile-find-dir-other-frame (&optional invalidate-cache)
	2218	"Jump to a project's directory in other window using completion.
	2219
	2220	With a prefix arg INVALIDATE-CACHE invalidates the cache first."
	2221	(interactive "P")
	2222	(projectile--find-dir invalidate-cache #'dired-other-frame))
	2223
	2224	(defun projectile-complete-dir (project)
	2225	(let ((project-dirs (projectile-project-dirs project)))
	2226	(projectile-completing-read
	2227	"Find dir: "
	2228	(if projectile-find-dir-includes-top-level
	2229	(append '("./") project-dirs)
	2230	project-dirs))))
	2231
	2232	;;;###autoload
	2233	(defun projectile-find-test-file (&optional invalidate-cache)
	2234	"Jump to a project's test file using completion.
	2235
	2236	With a prefix arg INVALIDATE-CACHE invalidates the cache first."
	2237	(interactive "P")
	2238	(projectile-maybe-invalidate-cache invalidate-cache)
	2239	(let ((file (projectile-completing-read "Find test file: "
	2240	(projectile-current-project-test-files))))
	2241	(find-file (expand-file-name file (projectile-project-root)))))
	2242
	2243	(defun projectile-test-files (files)
	2244	"Return only the test FILES."
	2245	(cl-remove-if-not 'projectile-test-file-p files))
	2246
	2247	(defun projectile-test-file-p (file)
	2248	"Check if FILE is a test file."
	2249	(or (cl-some (lambda (pat) (string-prefix-p pat (file-name-nondirectory file)))
	2250	(delq nil (list (funcall projectile-test-prefix-function (projectile-project-type)))))
	2251	(cl-some (lambda (pat) (string-suffix-p pat (file-name-sans-extension (file-name-nondirectory file))))
	2252	(delq nil (list (funcall projectile-test-suffix-function (projectile-project-type)))))))
	2253
	2254	(defun projectile-current-project-test-files ()
	2255	"Return a list of test files for the current project."
	2256	(projectile-test-files (projectile-current-project-files)))
	2257
	2258	(defvar projectile-project-types nil
	2259	"An alist holding all project types that are known to Projectile.
	2260	The project types are symbols and they are linked to plists holding
	2261	the properties of the various project types.")
	2262
	2263	(cl-defun projectile-register-project-type
	2264	(project-type marker-files &key compilation-dir configure compile test run test-suffix test-prefix src-dir test-dir)
	2265	"Register a project type with projectile.
	2266
	2267	A project type is defined by PROJECT-TYPE, a set of MARKER-FILES,
	2268	and optional keyword arguments:
	2269	COMPILATION-DIR the directory to run the tests- and compilations in,
	2270	CONFIGURE which specifies a command that configures the project
	2271	`%s' in the command will be substituted with (projectile-project-root)
	2272	before the command is run,
	2273	COMPILE which specifies a command that builds the project,
	2274	TEST which specified a command that tests the project,
	2275	RUN which specifies a command that runs the project,
	2276	TEST-SUFFIX which specifies test file suffix, and
	2277	TEST-PREFIX which specifies test file prefix.
	2278	SRC-DIR which specifies the path to the source relative to the project root.
	2279	TEST-DIR which specifies the path to the tests relative to the project root."
	2280	(let ((project-plist (list 'marker-files marker-files
	2281	'compilation-dir compilation-dir
	2282	'configure-command configure
	2283	'compile-command compile
	2284	'test-command test
	2285	'run-command run)))
	2286	;; There is no way for the function to distinguish between an
	2287	;; explicit argument of nil and an omitted argument. However, the
	2288	;; body of the function is free to consider nil an abbreviation
	2289	;; for some other meaningful value
	2290	(when test-suffix
	2291	(plist-put project-plist 'test-suffix test-suffix))
	2292	(when test-prefix
	2293	(plist-put project-plist 'test-prefix test-prefix))
	2294	(when src-dir
	2295	(plist-put project-plist 'src-dir src-dir))
	2296	(when test-dir
	2297	(plist-put project-plist 'test-dir test-dir))
	2298	(setq projectile-project-types
	2299	(cons `(,project-type . ,project-plist)
	2300	projectile-project-types))))
	2301
	2302	(defun projectile-cabal-project-p ()
	2303	"Check if a project contains *.cabal files but no stack.yaml file."
	2304	(and (projectile-verify-file-wildcard "*.cabal")
	2305	(not (projectile-verify-file "stack.yaml"))))
	2306
	2307	(defun projectile-go-project-p ()
	2308	"Check if a project contains Go source files."
	2309	(projectile-verify-file-wildcard "*.go"))
	2310
	2311	(define-obsolete-variable-alias 'projectile-go-function 'projectile-go-project-test-function "1.0.0")
	2312	(defcustom projectile-go-project-test-function #'projectile-go-project-p
	2313	"Function to determine if project's type is go."
	2314	:group 'projectile
	2315	:type 'function)
	2316
	2317	;;; Project type registration
	2318	;;
	2319	;; Project type detection happens in a reverse order with respect to
	2320	;; project type registration (invocations of `projectile-register-project-type').
	2321	;;
	2322	;; As function-based project type detection is pretty slow, so it
	2323	;; should be tried at the end if everything else failed (meaning here
	2324	;; it should be listed first).
	2325	;;
	2326	;; Ideally common project types should be checked earlier than exotic ones.
	2327
	2328	;; Function-based detection project type
	2329	(projectile-register-project-type 'haskell-cabal #'projectile-cabal-project-p
	2330	:compile "cabal build"
	2331	:test "cabal test"
	2332	:test-suffix "Spec")
	2333	(projectile-register-project-type 'go projectile-go-project-test-function
	2334	:compile "go build ./..."
	2335	:test "go test ./..."
	2336	:test-suffix "_test")
	2337	;; File-based detection project types
	2338
	2339	;; Universal
	2340	(projectile-register-project-type 'scons '("SConstruct")
	2341	:compile "scons"
	2342	:test "scons test"
	2343	:test-suffix "test")
	2344	(projectile-register-project-type 'meson '("meson.build")
	2345	:compilation-dir "build"
	2346	:configure "meson %s"
	2347	:compile "ninja"
	2348	:test "ninja test")
	2349	(projectile-register-project-type 'nix '("default.nix")
	2350	:compile "nix-build"
	2351	:test "nix-build")
	2352	;; Make & CMake
	2353	(projectile-register-project-type 'make '("Makefile")
	2354	:compile "make"
	2355	:test "make test")
	2356	(projectile-register-project-type 'cmake '("CMakeLists.txt")
	2357	:configure "cmake %s"
	2358	:compile "cmake --build ."
	2359	:test "ctest")
	2360	;; PHP
	2361	(projectile-register-project-type 'php-symfony '("composer.json" "app" "src" "vendor")
	2362	:compile "app/console server:run"
	2363	:test "phpunit -c app "
	2364	:test-suffix "Test")
	2365	;; Erlang & Elixir
	2366	(projectile-register-project-type 'rebar '("rebar.config")
	2367	:compile "rebar"
	2368	:test "rebar eunit"
	2369	:test-suffix "_SUITE")
	2370	(projectile-register-project-type 'elixir '("mix.exs")
	2371	:compile "mix compile"
	2372	:src-dir "lib/"
	2373	:test "mix test"
	2374	:test-suffix "_test")
	2375	;; JavaScript
	2376	(projectile-register-project-type 'grunt '("Gruntfile.js")
	2377	:compile "grunt"
	2378	:test "grunt test")
	2379	(projectile-register-project-type 'gulp '("gulpfile.js")
	2380	:compile "gulp"
	2381	:test "gulp test")
	2382	(projectile-register-project-type 'npm '("package.json")
	2383	:compile "npm install"
	2384	:test "npm test"
	2385	:test-suffix ".test")
	2386	;; Angular
	2387	(projectile-register-project-type 'angular '("angular.json" ".angular-cli.json")
	2388	:compile "ng build"
	2389	:run "ng serve"
	2390	:test "ng test")
	2391	;; Python
	2392	(projectile-register-project-type 'django '("manage.py")
	2393	:compile "python manage.py runserver"
	2394	:test "python manage.py test"
	2395	:test-prefix "test_"
	2396	:test-suffix"_test")
	2397	(projectile-register-project-type 'python-pip '("requirements.txt")
	2398	:compile "python setup.by build"
	2399	:test "python -m unittest discover"
	2400	:test-prefix "test_"
	2401	:test-suffix"_test")
	2402	(projectile-register-project-type 'python-pkg '("setup.py")
	2403	:compile "python setup.py build"
	2404	:test "python -m unittest discover"
	2405	:test-prefix "test_"
	2406	:test-suffix"_test")
	2407	(projectile-register-project-type 'python-tox '("tox.ini")
	2408	:compile "tox -r --notest"
	2409	:test "tox"
	2410	:test-prefix "test_"
	2411	:test-suffix"_test")
	2412	(projectile-register-project-type 'python-pipenv '("Pipfile")
	2413	:compile "pipenv run build"
	2414	:test "pipenv run test"
	2415	:test-prefix "test_"
	2416	:test-suffix "_test")
	2417	;; Java & friends
	2418	(projectile-register-project-type 'maven '("pom.xml")
	2419	:compile "mvn clean install"
	2420	:test "mvn test"
	2421	:test-suffix "Test"
	2422	:src-dir "main/src/"
	2423	:test-dir "main/test/")
	2424	(projectile-register-project-type 'gradle '("build.gradle")
	2425	:compile "gradle build"
	2426	:test "gradle test"
	2427	:test-suffix "Spec")
	2428	(projectile-register-project-type 'gradlew '("gradlew")
	2429	:compile "./gradlew build"
	2430	:test "./gradlew test"
	2431	:test-suffix "Spec")
	2432	(projectile-register-project-type 'grails '("application.properties" "grails-app")
	2433	:compile "grails package"
	2434	:test "grails test-app"
	2435	:test-suffix "Spec")
	2436	(projectile-register-project-type 'sbt '("build.sbt")
	2437	:compile "sbt compile"
	2438	:test "sbt test"
	2439	:test-suffix "Spec")
	2440	(projectile-register-project-type 'lein-test '("project.clj")
	2441	:compile "lein compile"
	2442	:test "lein test"
	2443	:test-suffix "_test")
	2444	(projectile-register-project-type 'lein-midje '("project.clj" ".midje.clj")
	2445	:compile "lein compile"
	2446	:test "lein midje"
	2447	:test-prefix "t_")
	2448	(projectile-register-project-type 'boot-clj '("build.boot")
	2449	:compile "boot aot"
	2450	:test "boot test"
	2451	:test-suffix "_test")
	2452	(projectile-register-project-type 'clojure-cli '("deps.edn")
	2453	:test-suffix "_test")
	2454	;; Ruby
	2455	(projectile-register-project-type 'ruby-rspec '("Gemfile" "lib" "spec")
	2456	:compile "bundle exec rake"
	2457	:src-dir "lib/"
	2458	:test "bundle exec rspec"
	2459	:test-dir "spec/"
	2460	:test-suffix "_spec")
	2461	(projectile-register-project-type 'ruby-test '("Gemfile" "lib" "test")
	2462	:compile"bundle exec rake"
	2463	:src-dir "lib/"
	2464	:test "bundle exec rake test"
	2465	:test-suffix "_test")
	2466	;; Rails needs to be registered after npm, otherwise `package.json` makes it `npm`.
	2467	;; https://github.com/bbatsov/projectile/pull/1191
	2468	(projectile-register-project-type 'rails-test '("Gemfile" "app" "lib" "db" "config" "test")
	2469	:compile "bundle exec rails server"
	2470	:src-dir "lib/"
	2471	:test "bundle exec rake test"
	2472	:test-suffix "_test")
	2473	(projectile-register-project-type 'rails-rspec '("Gemfile" "app" "lib" "db" "config" "spec")
	2474	:compile "bundle exec rails server"
	2475	:src-dir "lib/"
	2476	:test "bundle exec rspec"
	2477	:test-dir "spec/"
	2478	:test-suffix "_spec")
	2479	;; Crystal
	2480	(projectile-register-project-type 'crystal-spec '("shard.yml")
	2481	:src-dir "src/"
	2482	:test "crystal spec"
	2483	:test-dir "spec/"
	2484	:test-suffix "_spec")
	2485
	2486	;; Emacs
	2487	(projectile-register-project-type 'emacs-cask '("Cask")
	2488	:compile "cask install"
	2489	:test-prefix "test-"
	2490	:test-suffix "-test")
	2491
	2492	;; R
	2493	(projectile-register-project-type 'r '("DESCRIPTION")
	2494	:compile "R CMD INSTALL --with-keep.source ."
	2495	:test (concat "R CMD check -o " temporary-file-directory " ."))
	2496
	2497	;; Haskell
	2498	(projectile-register-project-type 'haskell-stack '("stack.yaml")
	2499	:compile "stack build"
	2500	:test "stack build --test"
	2501	:test-suffix "Spec")
	2502
	2503	;; Rust
	2504	(projectile-register-project-type 'rust-cargo '("Cargo.toml")
	2505	:compile "cargo build"
	2506	:test "cargo test")
	2507
	2508	;; Racket
	2509	(projectile-register-project-type 'racket '("info.rkt")
	2510	:test "raco test .")
	2511
	2512
	2513	(defvar-local projectile-project-type nil
	2514	"Buffer local var for overriding the auto-detected project type.
	2515	Normally you'd set this from .dir-locals.el.")
	2516	(put 'projectile-project-type 'safe-local-variable #'symbolp)
	2517
	2518	(defun projectile-detect-project-type ()
	2519	"Detect the type of the current project.
	2520	Fallsback to a generic project type when the type can't be determined."
	2521	(let ((project-type
	2522	(or (car (cl-find-if
	2523	(lambda (project-type-record)
	2524	(let ((project-type (car project-type-record))
	2525	(marker (plist-get (cdr project-type-record) 'marker-files)))
	2526	(if (listp marker)
	2527	(and (projectile-verify-files marker) project-type)
	2528	(and (funcall marker) project-type))))
	2529	projectile-project-types))
	2530	'generic)))
	2531	(puthash (projectile-project-root) project-type projectile-project-type-cache)
	2532	project-type))
	2533
	2534	(defun projectile-project-type (&optional dir)
	2535	"Determine a project's type based on its structure.
	2536	When DIR is specified it checks it, otherwise it acts
	2537	on the current project.
	2538
	2539	The project type is cached for improved performance."
	2540	(if projectile-project-type
	2541	projectile-project-type
	2542	(let* ((dir (or dir default-directory))
	2543	(project-root (projectile-project-root dir)))
	2544	(if project-root
	2545	(or (gethash project-root projectile-project-type-cache)
	2546	(projectile-detect-project-type))
	2547	;; if we're not in a project we just return nil
	2548	nil))))
	2549
	2550	;;;###autoload
	2551	(defun projectile-project-info ()
	2552	"Display info for current project."
	2553	(interactive)
	2554	(message "Project dir: %s ## Project VCS: %s ## Project type: %s"
	2555	(projectile-project-root)
	2556	(projectile-project-vcs)
	2557	(projectile-project-type)))
	2558
	2559	(defun projectile-verify-files (files)
	2560	"Check whether all FILES exist in the current project."
	2561	(cl-every #'projectile-verify-file files))
	2562
	2563	(defun projectile-verify-file (file)
	2564	"Check whether FILE exists in the current project."
	2565	(file-exists-p (projectile-expand-root file)))
	2566
	2567	(defun projectile-verify-file-wildcard (file)
	2568	"Check whether FILE exists in the current project.
	2569	Expands wildcards using `file-expand-wildcards' before checking."
	2570	(file-expand-wildcards (projectile-expand-root file)))
	2571
	2572	(defun projectile-project-vcs (&optional project-root)
	2573	"Determine the VCS used by the project if any.
	2574	PROJECT-ROOT is the targeted directory. If nil, use
	2575	`projectile-project-root'."
	2576	(or project-root (setq project-root (projectile-project-root)))
	2577	(cond
	2578	((projectile-file-exists-p (expand-file-name ".git" project-root)) 'git)
	2579	((projectile-file-exists-p (expand-file-name ".hg" project-root)) 'hg)
	2580	((projectile-file-exists-p (expand-file-name ".fslckout" project-root)) 'fossil)
	2581	((projectile-file-exists-p (expand-file-name "_FOSSIL_" project-root)) 'fossil)
	2582	((projectile-file-exists-p (expand-file-name ".bzr" project-root)) 'bzr)
	2583	((projectile-file-exists-p (expand-file-name "_darcs" project-root)) 'darcs)
	2584	((projectile-file-exists-p (expand-file-name ".svn" project-root)) 'svn)
	2585	((projectile-locate-dominating-file project-root ".git") 'git)
	2586	((projectile-locate-dominating-file project-root ".hg") 'hg)
	2587	((projectile-locate-dominating-file project-root ".fslckout") 'fossil)
	2588	((projectile-locate-dominating-file project-root "_FOSSIL_") 'fossil)
	2589	((projectile-locate-dominating-file project-root ".bzr") 'bzr)
	2590	((projectile-locate-dominating-file project-root "_darcs") 'darcs)
	2591	((projectile-locate-dominating-file project-root ".svn") 'svn)
	2592	(t 'none)))
	2593
	2594	(defun projectile--test-name-for-impl-name (impl-file-path)
	2595	"Determine the name of the test file for IMPL-FILE-PATH."
	2596	(let* ((project-type (projectile-project-type))
	2597	(impl-file-name (file-name-sans-extension (file-name-nondirectory impl-file-path)))
	2598	(impl-file-ext (file-name-extension impl-file-path))
	2599	(test-prefix (funcall projectile-test-prefix-function project-type))
	2600	(test-suffix (funcall projectile-test-suffix-function project-type)))
	2601	(cond
	2602	(test-prefix (concat test-prefix impl-file-name "." impl-file-ext))
	2603	(test-suffix (concat impl-file-name test-suffix "." impl-file-ext))
	2604	(t (error "Project type `%s' not supported!" project-type)))))
	2605
	2606	(defun projectile-create-test-file-for (impl-file-path)
	2607	"Create a test file for IMPL-FILE-PATH."
	2608	(let* ((test-file (projectile--test-name-for-impl-name impl-file-path))
	2609	(project-root (projectile-project-root))
	2610	(relative-dir (file-name-directory (file-relative-name impl-file-path project-root)))
	2611	(src-dir-name (projectile-src-directory (projectile-project-type)))
	2612	(test-dir-name (projectile-test-directory (projectile-project-type)))
	2613	(test-dir (expand-file-name (replace-regexp-in-string src-dir-name test-dir-name relative-dir) project-root))
	2614	(test-path (expand-file-name test-file test-dir)))
	2615	(unless (file-exists-p test-path)
	2616	(progn (unless (file-exists-p test-dir)
	2617	(make-directory test-dir :create-parents))
	2618	test-path))))
	2619
	2620	(defun projectile-find-implementation-or-test (file-name)
	2621	"Given a FILE-NAME return the matching implementation or test filename.
	2622
	2623	If `projectile-create-missing-test-files' is non-nil, create the missing
	2624	test file."
	2625	(unless file-name (error "The current buffer is not visiting a file"))
	2626	(if (projectile-test-file-p file-name)
	2627	;; find the matching impl file
	2628	(let ((impl-file (projectile-find-matching-file file-name)))
	2629	(if impl-file
	2630	(projectile-expand-root impl-file)
	2631	(error
	2632	"No matching source file found for project type `%s'"
	2633	(projectile-project-type))))
	2634	;; find the matching test file
	2635	(let ((test-file (projectile-find-matching-test file-name)))
	2636	(if test-file
	2637	(projectile-expand-root test-file)
	2638	(if projectile-create-missing-test-files
	2639	(projectile-create-test-file-for file-name)
	2640	(error "No matching test file found for project type `%s'"
	2641	(projectile-project-type)))))))
	2642
	2643	;;;###autoload
	2644	(defun projectile-find-implementation-or-test-other-window ()
	2645	"Open matching implementation or test file in other window."
	2646	(interactive)
	2647	(find-file-other-window
	2648	(projectile-find-implementation-or-test (buffer-file-name))))
	2649
	2650	;;;###autoload
	2651	(defun projectile-find-implementation-or-test-other-frame ()
	2652	"Open matching implementation or test file in other frame."
	2653	(interactive)
	2654	(find-file-other-frame
	2655	(projectile-find-implementation-or-test (buffer-file-name))))
	2656
	2657	;;;###autoload
	2658	(defun projectile-toggle-between-implementation-and-test ()
	2659	"Toggle between an implementation file and its test file."
	2660	(interactive)
	2661	(find-file
	2662	(projectile-find-implementation-or-test (buffer-file-name))))
	2663
	2664
	2665	(defun projectile-project-type-attribute (project-type key &optional default-value)
	2666	"Return the value of some PROJECT-TYPE attribute identified by KEY.
	2667	Fallback to DEFAULT-VALUE for missing attributes."
	2668	(let ((project (alist-get project-type projectile-project-types)))
	2669	(if (and project (plist-member project key))
	2670	(plist-get project key)
	2671	default-value)))
	2672
	2673	(defun projectile-test-prefix (project-type)
	2674	"Find default test files prefix based on PROJECT-TYPE."
	2675	(projectile-project-type-attribute project-type 'test-prefix))
	2676
	2677	(defun projectile-test-suffix (project-type)
	2678	"Find default test files suffix based on PROJECT-TYPE."
	2679	(projectile-project-type-attribute project-type 'test-suffix))
	2680
	2681	(defun projectile-src-directory (project-type)
	2682	"Find default src directory based on PROJECT-TYPE."
	2683	(projectile-project-type-attribute project-type 'src-dir "src/"))
	2684
	2685	(defun projectile-test-directory (project-type)
	2686	"Find default test directory based on PROJECT-TYPE."
	2687	(projectile-project-type-attribute project-type 'test-dir "test/"))
	2688
	2689	(defun projectile-dirname-matching-count (a b)
	2690	"Count matching dirnames ascending file paths."
	2691	(setq a (reverse (split-string (or (file-name-directory a) "") "/" t))
	2692	b (reverse (split-string (or (file-name-directory b) "") "/" t)))
	2693	(let ((common 0))
	2694	(while (and a b (string-equal (pop a) (pop b)))
	2695	(setq common (1+ common)))
	2696	common))
	2697
	2698	(defun projectile-group-file-candidates (file candidates)
	2699	"Group file candidates by dirname matching count."
	2700	(cl-sort (copy-sequence
	2701	(let (value result)
	2702	(while (setq value (pop candidates))
	2703	(let* ((key (projectile-dirname-matching-count file value))
	2704	(kv (assoc key result)))
	2705	(if kv
	2706	(setcdr kv (cons value (cdr kv)))
	2707	(push (list key value) result))))
	2708	(mapcar (lambda (x)
	2709	(cons (car x) (nreverse (cdr x))))
	2710	(nreverse result))))
	2711	(lambda (a b) (> (car a) (car b)))))
	2712
	2713	(defun projectile-find-matching-test (file)
	2714	"Compute the name of the test matching FILE."
	2715	(let* ((basename (file-name-nondirectory (file-name-sans-extension file)))
	2716	(test-prefix (funcall projectile-test-prefix-function (projectile-project-type)))
	2717	(test-suffix (funcall projectile-test-suffix-function (projectile-project-type)))
	2718	(candidates
	2719	(cl-remove-if-not
	2720	(lambda (current-file)
	2721	(let ((name (file-name-nondirectory
	2722	(file-name-sans-extension current-file))))
	2723	(or (when test-prefix
	2724	(string-equal name (concat test-prefix basename)))
	2725	(when test-suffix
	2726	(string-equal name (concat basename test-suffix))))))
	2727	(projectile-current-project-files))))
	2728	(cond
	2729	((null candidates) nil)
	2730	((= (length candidates) 1) (car candidates))
	2731	(t (let ((grouped-candidates (projectile-group-file-candidates file candidates)))
	2732	(if (= (length (car grouped-candidates)) 2)
	2733	(car (last (car grouped-candidates)))
	2734	(projectile-completing-read
	2735	"Switch to: "
	2736	(apply 'append (mapcar 'cdr grouped-candidates)))))))))
	2737
	2738	(defun projectile-find-matching-file (test-file)
	2739	"Compute the name of a file matching TEST-FILE."
	2740	(let* ((basename (file-name-nondirectory (file-name-sans-extension test-file)))
	2741	(test-prefix (funcall projectile-test-prefix-function (projectile-project-type)))
	2742	(test-suffix (funcall projectile-test-suffix-function (projectile-project-type)))
	2743	(candidates
	2744	(cl-remove-if-not
	2745	(lambda (current-file)
	2746	(let ((name (file-name-nondirectory
	2747	(file-name-sans-extension current-file))))
	2748	(or (when test-prefix
	2749	(string-equal (concat test-prefix name) basename))
	2750	(when test-suffix
	2751	(string-equal (concat name test-suffix) basename)))))
	2752	(projectile-current-project-files))))
	2753	(cond
	2754	((null candidates) nil)
	2755	((= (length candidates) 1) (car candidates))
	2756	(t (let ((grouped-candidates (projectile-group-file-candidates test-file candidates)))
	2757	(if (= (length (car grouped-candidates)) 2)
	2758	(car (last (car grouped-candidates)))
	2759	(projectile-completing-read
	2760	"Switch to: "
	2761	(apply 'append (mapcar 'cdr grouped-candidates)))))))))
	2762
	2763	(defun projectile-grep-default-files ()
	2764	"Try to find a default pattern for `projectile-grep'.
	2765	This is a subset of `grep-read-files', where either a matching entry from
	2766	`grep-files-aliases' or file name extension pattern is returned."
	2767	(when buffer-file-name
	2768	(let* ((fn (file-name-nondirectory buffer-file-name))
	2769	(default-alias
	2770	(let ((aliases (remove (assoc "all" grep-files-aliases)
	2771	grep-files-aliases))
	2772	alias)
	2773	(while aliases
	2774	(setq alias (car aliases)
	2775	aliases (cdr aliases))
	2776	(if (string-match (mapconcat
	2777	#'wildcard-to-regexp
	2778	(split-string (cdr alias) nil t)
	2779	"\\\|")
	2780	fn)
	2781	(setq aliases nil)
	2782	(setq alias nil)))
	2783	(cdr alias)))
	2784	(default-extension
	2785	(let ((ext (file-name-extension fn)))
	2786	(and ext (concat "*." ext)))))
	2787	(or default-alias default-extension))))
	2788
	2789	(defun projectile--globally-ignored-file-suffixes-glob ()
	2790	"Return ignored file suffixes as a list of glob patterns."
	2791	(mapcar (lambda (pat) (concat "*" pat)) projectile-globally-ignored-file-suffixes))
	2792
	2793	(defun projectile--read-search-string-with-default (prefix-label)
	2794	(let* ((prefix-label (projectile-prepend-project-name prefix-label))
	2795	(default-value (projectile-symbol-or-selection-at-point))
	2796	(default-label (if (or (not default-value)
	2797	(string= default-value ""))
	2798	""
	2799	(format " (default %s)" default-value))))
	2800	(read-string (format "%s%s: " prefix-label default-label) nil nil default-value)))
	2801
	2802	;;;###autoload
	2803	(defun projectile-grep (&optional regexp arg)
	2804	"Perform rgrep in the project.
	2805
	2806	With a prefix ARG asks for files (globbing-aware) which to grep in.
	2807	With prefix ARG of `-' (such as `M--'), default the files (without prompt),
	2808	to `projectile-grep-default-files'.
	2809
	2810	With REGEXP given, don't query the user for a regexp."
	2811	(interactive "i\nP")
	2812	(require 'grep) ;; for `rgrep'
	2813	(let* ((roots (projectile-get-project-directories (projectile-project-root)))
	2814	(search-regexp (or regexp
	2815	(projectile--read-search-string-with-default "Grep for")))
	2816	(files (and arg (or (and (equal current-prefix-arg '-)
	2817	(projectile-grep-default-files))
	2818	(read-string (projectile-prepend-project-name "Grep in: ")
	2819	(projectile-grep-default-files))))))
	2820	(dolist (root-dir roots)
	2821	(require 'vc-git) ;; for `vc-git-grep'
	2822	;; in git projects users have the option to use `vc-git-grep' instead of `rgrep'
	2823	(if (and (eq (projectile-project-vcs) 'git)
	2824	projectile-use-git-grep
	2825	(fboundp 'vc-git-grep))
	2826	(vc-git-grep search-regexp (or files "") root-dir)
	2827	;; paths for find-grep should relative and without trailing /
	2828	(let ((grep-find-ignored-directories
	2829	(cl-union (mapcar (lambda (f) (directory-file-name (file-relative-name f root-dir)))
	2830	(projectile-ignored-directories))
	2831	grep-find-ignored-directories))
	2832	(grep-find-ignored-files
	2833	(cl-union (append (mapcar (lambda (file)
	2834	(file-relative-name file root-dir))
	2835	(projectile-ignored-files))
	2836	(projectile--globally-ignored-file-suffixes-glob))
	2837	grep-find-ignored-files)))
	2838	(grep-compute-defaults)
	2839	(rgrep search-regexp (or files "* .*") root-dir))))
	2840	(run-hooks 'projectile-grep-finished-hook)))
	2841
	2842	;;;###autoload
	2843	(defun projectile-ag (search-term &optional arg)
	2844	"Run an ag search with SEARCH-TERM in the project.
	2845
	2846	With an optional prefix argument ARG SEARCH-TERM is interpreted as a
	2847	regular expression."
	2848	(interactive
	2849	(list (projectile--read-search-string-with-default
	2850	(format "Ag %ssearch for" (if current-prefix-arg "regexp " "")))
	2851	current-prefix-arg))
	2852	(if (require 'ag nil 'noerror)
	2853	(let ((ag-command (if arg 'ag-regexp 'ag))
	2854	(ag-ignore-list (delq nil
	2855	(delete-dups
	2856	(append
	2857	ag-ignore-list
	2858	(projectile--globally-ignored-file-suffixes-glob)
	2859	;; ag supports git ignore files directly
	2860	(unless (eq (projectile-project-vcs) 'git)
	2861	(append (projectile-ignored-files-rel)
	2862	(projectile-ignored-directories-rel)
	2863	grep-find-ignored-files
	2864	grep-find-ignored-directories
	2865	'()))))))
	2866	;; reset the prefix arg, otherwise it will affect the ag-command
	2867	(current-prefix-arg nil))
	2868	(funcall ag-command search-term (projectile-project-root)))
	2869	(error "Package 'ag' is not available")))
	2870
	2871	;;;###autoload
	2872	(defun projectile-ripgrep (search-term)
	2873	"Run a Ripgrep search with `SEARCH-TERM' at current project root.
	2874
	2875	SEARCH-TERM is a regexp."
	2876	(interactive (list (projectile--read-search-string-with-default
	2877	"Ripgrep search for")))
	2878	(if (require 'ripgrep nil 'noerror)
	2879	(let ((args (mapcar (lambda (val) (concat "--glob !" val))
	2880	(append projectile-globally-ignored-files
	2881	projectile-globally-ignored-directories))))
	2882	(ripgrep-regexp search-term
	2883	(projectile-project-root)
	2884	(if current-prefix-arg
	2885	args
	2886	(cons "--fixed-strings" args))))
	2887	(error "Package `ripgrep' is not available")))
	2888
	2889	(defun projectile-tags-exclude-patterns ()
	2890	"Return a string with exclude patterns for ctags."
	2891	(mapconcat (lambda (pattern) (format "--exclude=\"%s\""
	2892	(directory-file-name pattern)))
	2893	(projectile-ignored-directories-rel) " "))
	2894
	2895	;;;###autoload
	2896	(defun projectile-regenerate-tags ()
	2897	"Regenerate the project's [e\|g]tags."
	2898	(interactive)
	2899	(if (and (boundp 'ggtags-mode)
	2900	(memq projectile-tags-backend '(auto ggtags)))
	2901	(progn
	2902	(let* ((ggtags-project-root (projectile-project-root))
	2903	(default-directory ggtags-project-root))
	2904	(ggtags-ensure-project)
	2905	(ggtags-update-tags t)))
	2906	(let* ((project-root (projectile-project-root))
	2907	(tags-exclude (projectile-tags-exclude-patterns))
	2908	(default-directory project-root)
	2909	(tags-file (expand-file-name projectile-tags-file-name))
	2910	(command (format projectile-tags-command tags-file tags-exclude default-directory))
	2911	shell-output exit-code)
	2912	(with-temp-buffer
	2913	(setq exit-code
	2914	(call-process-shell-command command nil (current-buffer))
	2915	shell-output (string-trim
	2916	(buffer-substring (point-min) (point-max)))))
	2917	(unless (zerop exit-code)
	2918	(error shell-output))
	2919	(visit-tags-table tags-file)
	2920	(message "Regenerated %s" tags-file))))
	2921
	2922	(defun projectile-visit-project-tags-table ()
	2923	"Visit the current project's tags table."
	2924	(when (projectile-project-p)
	2925	(let ((tags-file (projectile-expand-root projectile-tags-file-name)))
	2926	(when (file-exists-p tags-file)
	2927	(with-demoted-errors "Error loading tags-file: %s"
	2928	(visit-tags-table tags-file t))))))
	2929
	2930	(defun projectile-determine-find-tag-fn ()
	2931	"Determine which function to use for a call to `projectile-find-tag'."
	2932	(or
	2933	(cond
	2934	((eq projectile-tags-backend 'auto)
	2935	(cond
	2936	((fboundp 'ggtags-find-tag-dwim)
	2937	'ggtags-find-tag-dwim)
	2938	((fboundp 'xref-find-definitions)
	2939	'xref-find-definitions)
	2940	((fboundp 'etags-select-find-tag)
	2941	'etags-select-find-tag)))
	2942	((eq projectile-tags-backend 'xref)
	2943	(when (fboundp 'xref-find-definitions)
	2944	'xref-find-definitions))
	2945	((eq projectile-tags-backend 'ggtags)
	2946	(when (fboundp 'ggtags-find-tag-dwim)
	2947	'ggtags-find-tag-dwim))
	2948	((eq projectile-tags-backend 'etags-select)
	2949	(when (fboundp 'etags-select-find-tag)
	2950	'etags-select-find-tag)))
	2951	'find-tag))
	2952
	2953	;;;###autoload
	2954	(defun projectile-find-tag ()
	2955	"Find tag in project."
	2956	(interactive)
	2957	(projectile-visit-project-tags-table)
	2958	;; Auto-discover the user's preference for tags
	2959	(let ((find-tag-fn (projectile-determine-find-tag-fn)))
	2960	(call-interactively find-tag-fn)))
	2961
	2962	(defmacro projectile-with-default-dir (dir &rest body)
	2963	"Invoke in DIR the BODY."
	2964	(declare (debug t) (indent 1))
	2965	`(let ((default-directory ,dir))
	2966	,@body))
	2967
	2968	;;;###autoload
	2969	(defun projectile-run-command-in-root ()
	2970	"Invoke `execute-extended-command' in the project's root."
	2971	(interactive)
	2972	(projectile-with-default-dir (projectile-ensure-project (projectile-project-root))
	2973	(call-interactively 'execute-extended-command)))
	2974
	2975	;;;###autoload
	2976	(defun projectile-run-shell-command-in-root ()
	2977	"Invoke `shell-command' in the project's root."
	2978	(interactive)
	2979	(projectile-with-default-dir (projectile-ensure-project (projectile-project-root))
	2980	(call-interactively 'shell-command)))
	2981
	2982	;;;###autoload
	2983	(defun projectile-run-async-shell-command-in-root ()
	2984	"Invoke `async-shell-command' in the project's root."
	2985	(interactive)
	2986	(projectile-with-default-dir (projectile-ensure-project (projectile-project-root))
	2987	(call-interactively 'async-shell-command)))
	2988
	2989	;;;###autoload
	2990	(defun projectile-run-shell ()
	2991	"Invoke `shell' in the project's root.
	2992
	2993	Switch to the project specific shell buffer if it already exists."
	2994	(interactive)
	2995	(projectile-with-default-dir (projectile-ensure-project (projectile-project-root))
	2996	(shell (concat "shell " (projectile-project-name) ""))))
	2997
	2998	;;;###autoload
	2999	(defun projectile-run-eshell ()
	3000	"Invoke `eshell' in the project's root.
	3001
	3002	Switch to the project specific eshell buffer if it already exists."
	3003	(interactive)
	3004	(projectile-with-default-dir (projectile-ensure-project (projectile-project-root))
	3005	(let ((eshell-buffer-name (concat "eshell " (projectile-project-name) "")))
	3006	(eshell))))
	3007
	3008	;;;###autoload
	3009	(defun projectile-run-ielm ()
	3010	"Invoke `ielm' in the project's root.
	3011
	3012	Switch to the project specific ielm buffer if it already exists."
	3013	(interactive)
	3014	(let* ((project (projectile-ensure-project (projectile-project-root)))
	3015	(ielm-buffer-name (format "ielm %s" (projectile-project-name project))))
	3016	(if (get-buffer ielm-buffer-name)
	3017	(switch-to-buffer ielm-buffer-name)
	3018	(projectile-with-default-dir project
	3019	(ielm))
	3020	;; ielm's buffer name is hardcoded, so we have to rename it after creation
	3021	(rename-buffer ielm-buffer-name))))
	3022
	3023	;;;###autoload
	3024	(defun projectile-run-term (program)
	3025	"Invoke `term' in the project's root.
	3026
	3027	Switch to the project specific term buffer if it already exists."
	3028	(interactive (list nil))
	3029	(let* ((project (projectile-ensure-project (projectile-project-root)))
	3030	(term (concat "term " (projectile-project-name project)))
	3031	(buffer (concat "" term "")))
	3032	(unless (get-buffer buffer)
	3033	(require 'term)
	3034	(let ((program (or program
	3035	(read-from-minibuffer "Run program: "
	3036	(or explicit-shell-file-name
	3037	(getenv "ESHELL")
	3038	(getenv "SHELL")
	3039	"/bin/sh")))))
	3040	(projectile-with-default-dir project
	3041	(set-buffer (make-term term program))
	3042	(term-mode)
	3043	(term-char-mode))))
	3044	(switch-to-buffer buffer)))
	3045
	3046	(defun projectile-files-in-project-directory (directory)
	3047	"Return a list of files in DIRECTORY."
	3048	(let* ((project (projectile-ensure-project (projectile-project-root)))
	3049	(dir (file-relative-name (expand-file-name directory)
	3050	project)))
	3051	(cl-remove-if-not
	3052	(lambda (f) (string-prefix-p dir f))
	3053	(projectile-project-files project))))
	3054
	3055	(defun projectile-files-from-cmd (cmd directory)
	3056	"Use a grep-like CMD to search for files within DIRECTORY.
	3057
	3058	CMD should include the necessary search params and should output
	3059	equivalently to grep -HlI (only unique matching filenames).
	3060	Returns a list of expanded filenames."
	3061	(let ((default-directory directory))
	3062	(mapcar (lambda (str)
	3063	(concat directory
	3064	(if (string-prefix-p "./" str)
	3065	(substring str 2)
	3066	str)))
	3067	(split-string
	3068	(string-trim (shell-command-to-string cmd))
	3069	"\n+"
	3070	t))))
	3071
	3072	(defun projectile-files-with-string (string directory)
	3073	"Return a list of all files containing STRING in DIRECTORY.
	3074
	3075	Tries to use ag, ack, git-grep, and grep in that order. If those
	3076	are impossible (for instance on Windows), returns a list of all
	3077	files in the project."
	3078	(if (projectile-unixy-system-p)
	3079	(let* ((search-term (shell-quote-argument string))
	3080	(cmd (cond ((executable-find "ag")
	3081	(concat "ag --literal --nocolor --noheading -l -- "
	3082	search-term))
	3083	((executable-find "ack")
	3084	(concat "ack --literal --noheading --nocolor -l -- "
	3085	search-term))
	3086	((and (executable-find "git")
	3087	(eq (projectile-project-vcs) 'git))
	3088	(concat "git grep -HlI " search-term))
	3089	(t
	3090	;; -r: recursive
	3091	;; -H: show filename for each match
	3092	;; -l: show only file names with matches
	3093	;; -I: no binary files
	3094	(format "grep -rHlI %s ." search-term)))))
	3095	(projectile-files-from-cmd cmd directory))
	3096	;; we have to reject directories as a workaround to work with git submodules
	3097	(cl-remove-if
	3098	#'file-directory-p
	3099	(mapcar #'projectile-expand-root (projectile-dir-files directory)))))
	3100
	3101	;;;###autoload
	3102	(defun projectile-replace (&optional arg)
	3103	"Replace literal string in project using non-regexp `tags-query-replace'.
	3104
	3105	With a prefix argument ARG prompts you for a directory on which
	3106	to run the replacement."
	3107	(interactive "P")
	3108	(let* ((directory (if arg
	3109	(file-name-as-directory
	3110	(read-directory-name "Replace in directory: "))
	3111	(projectile-ensure-project (projectile-project-root))))
	3112	(old-text (read-string
	3113	(projectile-prepend-project-name "Replace: ")
	3114	(projectile-symbol-or-selection-at-point)))
	3115	(new-text (read-string
	3116	(projectile-prepend-project-name
	3117	(format "Replace %s with: " old-text))))
	3118	(files (projectile-files-with-string old-text directory)))
	3119	;; Adapted from `tags-query-replace' for literal strings (not regexp)
	3120	(setq tags-loop-scan `(let ,(unless (equal old-text (downcase old-text))
	3121	'((case-fold-search nil)))
	3122	(if (search-forward ',old-text nil t)
	3123	;; When we find a match, move back to
	3124	;; the beginning of it so
	3125	;; perform-replace will see it.
	3126	(goto-char (match-beginning 0))))
	3127	tags-loop-operate `(perform-replace ',old-text ',new-text t nil nil
	3128	nil multi-query-replace-map))
	3129	(tags-loop-continue (or (cons 'list files) t))))
	3130
	3131	;;;###autoload
	3132	(defun projectile-replace-regexp (&optional arg)
	3133	"Replace a regexp in the project using `tags-query-replace'.
	3134
	3135	With a prefix argument ARG prompts you for a directory on which
	3136	to run the replacement."
	3137	(interactive "P")
	3138	(let* ((directory (if arg
	3139	(file-name-as-directory
	3140	(read-directory-name "Replace regexp in directory: "))
	3141	(projectile-ensure-project (projectile-project-root))))
	3142	(old-text (read-string
	3143	(projectile-prepend-project-name "Replace regexp: ")
	3144	(projectile-symbol-or-selection-at-point)))
	3145	(new-text (read-string
	3146	(projectile-prepend-project-name
	3147	(format "Replace regexp %s with: " old-text))))
	3148	(files
	3149	;; We have to reject directories as a workaround to work with git submodules.
	3150	;;
	3151	;; We can't narrow the list of files with
	3152	;; `projectile-files-with-string' because those regexp tools
	3153	;; don't support Emacs regular expressions.
	3154	(cl-remove-if
	3155	#'file-directory-p
	3156	(mapcar #'projectile-expand-root (projectile-dir-files directory)))))
	3157	(tags-query-replace old-text new-text nil (cons 'list files))))
	3158
	3159	;;;###autoload
	3160	(defun projectile-kill-buffers ()
	3161	"Kill project buffers.
	3162
	3163	The buffer are killed according to the value of
	3164	`projectile-kill-buffers-filter'."
	3165	(interactive)
	3166	(let* ((project (projectile-ensure-project (projectile-project-root)))
	3167	(project-name (projectile-project-name project))
	3168	(buffers (projectile-project-buffers project)))
	3169	(when (yes-or-no-p
	3170	(format "Are you sure you want to kill %s buffers for '%s'? "
	3171	(length buffers) project-name))
	3172	(dolist (buffer buffers)
	3173	(when (and
	3174	;; we take care not to kill indirect buffers directly
	3175	;; as we might encounter them after their base buffers are killed
	3176	(not (buffer-base-buffer buffer))
	3177	(if (functionp projectile-kill-buffers-filter)
	3178	(funcall projectile-kill-buffers-filter buffer)
	3179	(pcase projectile-kill-buffers-filter
	3180	('kill-all t)
	3181	('kill-only-files (buffer-file-name buffer))
	3182	(_ (user-error "Invalid projectile-kill-buffers-filter value: %S" projectile-kill-buffers-filter)))))
	3183	(kill-buffer buffer))))))
	3184
	3185	;;;###autoload
	3186	(defun projectile-save-project-buffers ()
	3187	"Save all project buffers."
	3188	(interactive)
	3189	(let* ((project (projectile-ensure-project (projectile-project-root)))
	3190	(project-name (projectile-project-name project))
	3191	(modified-buffers (cl-remove-if-not (lambda (buf)
	3192	(and (buffer-file-name buf)
	3193	(buffer-modified-p buf)))
	3194	(projectile-project-buffers project))))
	3195	(if (null modified-buffers)
	3196	(message "[%s] No buffers need saving" project-name)
	3197	(dolist (buf modified-buffers)
	3198	(with-current-buffer buf
	3199	(save-buffer)))
	3200	(message "[%s] Saved %d buffers" project-name (length modified-buffers)))))
	3201
	3202	;;;###autoload
	3203	(defun projectile-dired ()
	3204	"Open `dired' at the root of the project."
	3205	(interactive)
	3206	(dired (projectile-ensure-project (projectile-project-root))))
	3207
	3208	;;;###autoload
	3209	(defun projectile-dired-other-window ()
	3210	"Open `dired' at the root of the project in another window."
	3211	(interactive)
	3212	(dired-other-window (projectile-ensure-project (projectile-project-root))))
	3213
	3214	;;;###autoload
	3215	(defun projectile-dired-other-frame ()
	3216	"Open `dired' at the root of the project in another frame."
	3217	(interactive)
	3218	(dired-other-frame (projectile-ensure-project (projectile-project-root))))
	3219
	3220	;;;###autoload
	3221	(defun projectile-vc (&optional project-root)
	3222	"Open `vc-dir' at the root of the project.
	3223
	3224	For git projects `magit-status-internal' is used if available.
	3225	For hg projects `monky-status' is used if available.
	3226
	3227	If PROJECT-ROOT is given, it is opened instead of the project
	3228	root directory of the current buffer file. If interactively
	3229	called with a prefix argument, the user is prompted for a project
	3230	directory to open."
	3231	(interactive (and current-prefix-arg
	3232	(list
	3233	(projectile-completing-read
	3234	"Open project VC in: "
	3235	projectile-known-projects))))
	3236	(or project-root (setq project-root (projectile-project-root)))
	3237	(let ((vcs (projectile-project-vcs project-root)))
	3238	(cl-case vcs
	3239	(git
	3240	(cond ((fboundp 'magit-status-internal)
	3241	(magit-status-internal project-root))
	3242	((fboundp 'magit-status)
	3243	(with-no-warnings (magit-status project-root)))
	3244	(t
	3245	(vc-dir project-root))))
	3246	(hg
	3247	(if (fboundp 'monky-status)
	3248	(monky-status project-root)
	3249	(vc-dir project-root)))
	3250	(t (vc-dir project-root)))))
	3251
	3252	;;;###autoload
	3253	(defun projectile-recentf ()
	3254	"Show a list of recently visited files in a project."
	3255	(interactive)
	3256	(if (boundp 'recentf-list)
	3257	(find-file (projectile-expand-root
	3258	(projectile-completing-read
	3259	"Recently visited files: "
	3260	(projectile-recentf-files))))
	3261	(message "recentf is not enabled")))
	3262
	3263	(defun projectile-recentf-files ()
	3264	"Return a list of recently visited files in a project."
	3265	(and (boundp 'recentf-list)
	3266	(let ((project-root (projectile-ensure-project (projectile-project-root))))
	3267	(mapcar
	3268	(lambda (f) (file-relative-name f project-root))
	3269	(cl-remove-if-not
	3270	(lambda (f) (string-prefix-p project-root f))
	3271	recentf-list)))))
	3272
	3273	(defun projectile-serialize-cache ()
	3274	"Serializes the memory cache to the hard drive."
	3275	(projectile-serialize projectile-projects-cache projectile-cache-file))
	3276
	3277	(defvar projectile-configure-cmd-map
	3278	(make-hash-table :test 'equal)
	3279	"A mapping between projects and the last configure command used on them.")
	3280
	3281	(defvar projectile-compilation-cmd-map
	3282	(make-hash-table :test 'equal)
	3283	"A mapping between projects and the last compilation command used on them.")
	3284
	3285	(defvar projectile-test-cmd-map
	3286	(make-hash-table :test 'equal)
	3287	"A mapping between projects and the last test command used on them.")
	3288
	3289	(defvar projectile-run-cmd-map
	3290	(make-hash-table :test 'equal)
	3291	"A mapping between projects and the last run command used on them.")
	3292
	3293	(defvar projectile-project-configure-cmd nil
	3294	"The command to use with `projectile-configure-project'.
	3295	It takes precedence over the default command for the project type when set.
	3296	Should be set via .dir-locals.el.")
	3297
	3298	(defvar projectile-project-compilation-cmd nil
	3299	"The command to use with `projectile-compile-project'.
	3300	It takes precedence over the default command for the project type when set.
	3301	Should be set via .dir-locals.el.")
	3302
	3303	(defvar projectile-project-compilation-dir nil
	3304	"The directory to use with `projectile-compile-project'.
	3305	The directory path is relative to the project root.
	3306	Should be set via .dir-locals.el.")
	3307
	3308	(defvar projectile-project-test-cmd nil
	3309	"The command to use with `projectile-test-project'.
	3310	It takes precedence over the default command for the project type when set.
	3311	Should be set via .dir-locals.el.")
	3312
	3313	(defvar projectile-project-run-cmd nil
	3314	"The command to use with `projectile-run-project'.
	3315	It takes precedence over the default command for the project type when set.
	3316	Should be set via .dir-locals.el.")
	3317
	3318	(defun projectile-default-generic-command (project-type command-type)
	3319	"Generic retrieval of COMMAND-TYPEs default cmd-value for PROJECT-TYPE.
	3320
	3321	If found, checks if value is symbol or string. In case of symbol
	3322	resolves to function `funcall's. Return value of function MUST
	3323	be string to be executed as command."
	3324	(let ((command (plist-get (alist-get project-type projectile-project-types) command-type)))
	3325	(cond
	3326	((stringp command) command)
	3327	((functionp command)
	3328	(if (fboundp command)
	3329	(funcall (symbol-function command))))
	3330	((and (not command) (eq command-type 'compilation-dir))
	3331	;; `compilation-dir' is special in that it is used as a fallback for the root
	3332	nil)
	3333	(t
	3334	(user-error "The value for: %s in project-type: %s was neither a function nor a string." command-type project-type)))))
	3335
	3336	(defun projectile-default-configure-command (project-type)
	3337	"Retrieve default configure command for PROJECT-TYPE."
	3338	(projectile-default-generic-command project-type 'configure-command))
	3339
	3340	(defun projectile-default-compilation-command (project-type)
	3341	"Retrieve default compilation command for PROJECT-TYPE."
	3342	(projectile-default-generic-command project-type 'compile-command))
	3343
	3344	(defun projectile-default-compilation-dir (project-type)
	3345	"Retrieve default compilation directory for PROJECT-TYPE."
	3346	(projectile-default-generic-command project-type 'compilation-dir))
	3347
	3348	(defun projectile-default-test-command (project-type)
	3349	"Retrieve default test command for PROJECT-TYPE."
	3350	(projectile-default-generic-command project-type 'test-command))
	3351
	3352	(defun projectile-default-run-command (project-type)
	3353	"Retrieve default run command for PROJECT-TYPE."
	3354	(projectile-default-generic-command project-type 'run-command))
	3355
	3356	(defun projectile-configure-command (compile-dir)
	3357	"Retrieve the configure command for COMPILE-DIR.
	3358
	3359	The command is determined like this:
	3360
	3361	- first we check `projectile-configure-cmd-map' for the last
	3362	configure command that was invoked on the project
	3363
	3364	- then we check for `projectile-project-configure-cmd' supplied
	3365	via .dir-locals.el
	3366
	3367	- finally we check for the default configure command for a
	3368	project of that type"
	3369	(or (gethash compile-dir projectile-configure-cmd-map)
	3370	projectile-project-configure-cmd
	3371	(let ((cmd-format-string (projectile-default-configure-command (projectile-project-type))))
	3372	(when cmd-format-string
	3373	(format cmd-format-string (projectile-project-root))))))
	3374
	3375	(defun projectile-compilation-command (compile-dir)
	3376	"Retrieve the compilation command for COMPILE-DIR.
	3377
	3378	The command is determined like this:
	3379
	3380	- first we check `projectile-compilation-cmd-map' for the last
	3381	compile command that was invoked on the project
	3382
	3383	- then we check for `projectile-project-compilation-cmd' supplied
	3384	via .dir-locals.el
	3385
	3386	- finally we check for the default compilation command for a
	3387	project of that type"
	3388	(or (gethash compile-dir projectile-compilation-cmd-map)
	3389	projectile-project-compilation-cmd
	3390	(projectile-default-compilation-command (projectile-project-type))))
	3391
	3392	(defun projectile-test-command (compile-dir)
	3393	"Retrieve the test command for COMPILE-DIR.
	3394
	3395	The command is determined like this:
	3396
	3397	- first we check `projectile-test-cmd-map' for the last
	3398	test command that was invoked on the project
	3399
	3400	- then we check for `projectile-project-test-cmd' supplied
	3401	via .dir-locals.el
	3402
	3403	- finally we check for the default test command for a
	3404	project of that type"
	3405	(or (gethash compile-dir projectile-test-cmd-map)
	3406	projectile-project-test-cmd
	3407	(projectile-default-test-command (projectile-project-type))))
	3408
	3409	(defun projectile-run-command (compile-dir)
	3410	"Retrieve the run command for COMPILE-DIR.
	3411
	3412	The command is determined like this:
	3413
	3414	- first we check `projectile-run-cmd-map' for the last
	3415	run command that was invoked on the project
	3416
	3417	- then we check for `projectile-project-run-cmd' supplied
	3418	via .dir-locals.el
	3419
	3420	- finally we check for the default run command for a
	3421	project of that type"
	3422	(or (gethash compile-dir projectile-run-cmd-map)
	3423	projectile-project-run-cmd
	3424	(projectile-default-run-command (projectile-project-type))))
	3425
	3426	(defun projectile-read-command (prompt command)
	3427	"Adapted from `compilation-read-command'."
	3428	(read-shell-command prompt command
	3429	(if (equal (car compile-history) command)
	3430	'(compile-history . 1)
	3431	'compile-history)))
	3432
	3433	(defun projectile-compilation-dir ()
	3434	"Retrieve the compilation directory for this project."
	3435	(let* ((type (projectile-project-type))
	3436	(directory (or projectile-project-compilation-dir
	3437	(projectile-default-compilation-dir type))))
	3438	(if directory
	3439	(file-truename
	3440	(concat (file-name-as-directory (projectile-project-root))
	3441	(file-name-as-directory directory)))
	3442	(projectile-project-root))))
	3443
	3444	(defun projectile-maybe-read-command (arg default-cmd prompt)
	3445	"Prompt user for command unless DEFAULT-CMD is an Elisp function."
	3446	(if (and (or (stringp default-cmd) (null default-cmd))
	3447	(or compilation-read-command arg))
	3448	(projectile-read-command prompt default-cmd)
	3449	default-cmd))
	3450
	3451	(defun projectile-run-compilation (cmd)
	3452	"Run external or Elisp compilation command CMD."
	3453	(if (functionp cmd)
	3454	(funcall cmd)
	3455	(compile cmd)))
	3456
	3457	(defvar projectile-project-command-history (make-hash-table :test 'equal)
	3458	"The history of last executed project commands, per project.
	3459
	3460	Projects are indexed by their project-root value.")
	3461
	3462	(defun projectile--get-command-history (project-root)
	3463	(or (gethash project-root projectile-project-command-history)
	3464	(puthash project-root
	3465	(make-ring 16)
	3466	projectile-project-command-history)))
	3467
	3468	(cl-defun projectile--run-project-cmd
	3469	(command command-map &key show-prompt prompt-prefix save-buffers)
	3470	"Run a project COMMAND, typically a test- or compile command.
	3471
	3472	Cache the COMMAND for later use inside the hash-table COMMAND-MAP.
	3473
	3474	Normally you'll be prompted for a compilation command, unless
	3475	variable `compilation-read-command'. You can force the prompt
	3476	by setting SHOW-PROMPT. The prompt will be prefixed with PROMPT-PREFIX.
	3477
	3478	If SAVE-BUFFERS is non-nil save all projectile buffers before
	3479	running the command.
	3480
	3481	The command actually run is returned."
	3482	(let* ((project-root (projectile-project-root))
	3483	(default-directory (projectile-compilation-dir))
	3484	(command (projectile-maybe-read-command show-prompt
	3485	command
	3486	prompt-prefix)))
	3487	(when command-map
	3488	(puthash default-directory command command-map)
	3489	(ring-insert (projectile--get-command-history project-root) command))
	3490	(when save-buffers
	3491	(save-some-buffers (not compilation-ask-about-save)
	3492	(lambda ()
	3493	(projectile-project-buffer-p (current-buffer)
	3494	project-root))))
	3495	(unless (file-directory-p default-directory)
	3496	(mkdir default-directory))
	3497	(projectile-run-compilation command)
	3498	command))
	3499
	3500	;;;###autoload
	3501	(defun projectile-configure-project (arg)
	3502	"Run project configure command.
	3503
	3504	Normally you'll be prompted for a compilation command, unless
	3505	variable `compilation-read-command'. You can force the prompt
	3506	with a prefix ARG."
	3507	(interactive "P")
	3508	(let ((command (projectile-configure-command (projectile-compilation-dir))))
	3509	(projectile--run-project-cmd command projectile-configure-cmd-map
	3510	:show-prompt arg
	3511	:prompt-prefix "Configure command: "
	3512	:save-buffers t)))
	3513
	3514	;;;###autoload
	3515	(defun projectile-compile-project (arg)
	3516	"Run project compilation command.
	3517
	3518	Normally you'll be prompted for a compilation command, unless
	3519	variable `compilation-read-command'. You can force the prompt
	3520	with a prefix ARG."
	3521	(interactive "P")
	3522	(let ((command (projectile-compilation-command (projectile-compilation-dir))))
	3523	(projectile--run-project-cmd command projectile-compilation-cmd-map
	3524	:show-prompt arg
	3525	:prompt-prefix "Compile command: "
	3526	:save-buffers t)))
	3527
	3528	;;;###autoload
	3529	(defun projectile-test-project (arg)
	3530	"Run project test command.
	3531
	3532	Normally you'll be prompted for a compilation command, unless
	3533	variable `compilation-read-command'. You can force the prompt
	3534	with a prefix ARG."
	3535	(interactive "P")
	3536	(let ((command (projectile-test-command (projectile-compilation-dir))))
	3537	(projectile--run-project-cmd command projectile-test-cmd-map
	3538	:show-prompt arg
	3539	:prompt-prefix "Test command: "
	3540	:save-buffers t)))
	3541
	3542	;;;###autoload
	3543	(defun projectile-run-project (arg)
	3544	"Run project run command.
	3545
	3546	Normally you'll be prompted for a compilation command, unless
	3547	variable `compilation-read-command'. You can force the prompt
	3548	with a prefix ARG."
	3549	(interactive "P")
	3550	(let ((command (projectile-run-command (projectile-compilation-dir))))
	3551	(projectile--run-project-cmd command projectile-run-cmd-map
	3552	:show-prompt arg
	3553	:prompt-prefix "Run command: ")))
	3554
	3555	;;;###autoload
	3556	(defun projectile-repeat-last-command (show-prompt)
	3557	"Run last projectile external command.
	3558
	3559	External commands are: `projectile-configure-project',
	3560	`projectile-compile-project', `projectile-test-project' and
	3561	`projectile-run-project'.
	3562
	3563	If the prefix argument SHOW_PROMPT is non nil, the command can be edited."
	3564	(interactive "P")
	3565	(let* ((project-root
	3566	(projectile-ensure-project (projectile-project-root)))
	3567	(command-history (projectile--get-command-history project-root))
	3568	(command (car-safe (ring-elements command-history)))
	3569	(compilation-read-command show-prompt)
	3570	executed-command)
	3571	(unless command
	3572	(user-error "No command has been run yet for this project"))
	3573	(setq executed-command
	3574	(projectile--run-project-cmd command
	3575	nil
	3576	:save-buffers t
	3577	:prompt-prefix "Execute command: "))
	3578	(unless (string= command executed-command)
	3579	(ring-insert command-history executed-command))))
	3580
	3581	(defadvice compilation-find-file (around projectile-compilation-find-file)
	3582	"Try to find a buffer for FILENAME, if we cannot find it,
	3583	fallback to the original function."
	3584	(let ((filename (ad-get-arg 1))
	3585	full-filename)
	3586	(ad-set-arg 1
	3587	(or
	3588	(if (file-exists-p (expand-file-name filename))
	3589	filename)
	3590	;; Try to find the filename using projectile
	3591	(and (projectile-project-p)
	3592	(let ((root (projectile-project-root))
	3593	(dirs (cons "" (projectile-current-project-dirs))))
	3594	(when (setq full-filename
	3595	(car (cl-remove-if-not
	3596	#'file-exists-p
	3597	(mapcar
	3598	(lambda (f)
	3599	(expand-file-name
	3600	filename
	3601	(expand-file-name f root)))
	3602	dirs))))
	3603	full-filename)))
	3604	;; Fall back to the old argument
	3605	filename))
	3606	ad-do-it))
	3607
	3608	(defun projectile-open-projects ()
	3609	"Return a list of all open projects.
	3610	An open project is a project with any open buffers."
	3611	(delete-dups
	3612	(delq nil
	3613	(mapcar (lambda (buffer)
	3614	(with-current-buffer buffer
	3615	(when (projectile-project-p)
	3616	(abbreviate-file-name (projectile-project-root)))))
	3617	(buffer-list)))))
	3618
	3619	(defun projectile--remove-current-project (projects)
	3620	"Remove the current project (if any) from the list of PROJECTS."
	3621	(if-let ((project (projectile-project-root)))
	3622	(projectile-difference projects
	3623	(list (abbreviate-file-name project)))
	3624	projects))
	3625
	3626	(defun projectile--move-current-project-to-end (projects)
	3627	"Move current project (if any) to the end of list in the list of PROJECTS."
	3628	(if-let ((project (projectile-project-root)))
	3629	(append
	3630	(projectile--remove-current-project projects)
	3631	(list (abbreviate-file-name project)))
	3632	projects))
	3633
	3634	(defun projectile-relevant-known-projects ()
	3635	"Return a list of known projects."
	3636	(pcase projectile-current-project-on-switch
	3637	('remove (projectile--remove-current-project projectile-known-projects))
	3638	('move-to-end (projectile--move-current-project-to-end projectile-known-projects))
	3639	('keep projectile-known-projects)))
	3640
	3641	(defun projectile-relevant-open-projects ()
	3642	"Return a list of open projects."
	3643	(let ((open-projects (projectile-open-projects)))
	3644	(pcase projectile-current-project-on-switch
	3645	('remove (projectile--remove-current-project open-projects))
	3646	('move-to-end (projectile--move-current-project-to-end open-projects))
	3647	('keep open-projects))))
	3648
	3649	;;;###autoload
	3650	(defun projectile-switch-project (&optional arg)
	3651	"Switch to a project we have visited before.
	3652	Invokes the command referenced by `projectile-switch-project-action' on switch.
	3653	With a prefix ARG invokes `projectile-commander' instead of
	3654	`projectile-switch-project-action.'"
	3655	(interactive "P")
	3656	(let ((projects (projectile-relevant-known-projects)))
	3657	(if projects
	3658	(projectile-completing-read
	3659	"Switch to project: " projects
	3660	:action (lambda (project)
	3661	(projectile-switch-project-by-name project arg)))
	3662	(user-error "There are no known projects"))))
	3663
	3664	;;;###autoload
	3665	(defun projectile-switch-open-project (&optional arg)
	3666	"Switch to a project we have currently opened.
	3667	Invokes the command referenced by `projectile-switch-project-action' on switch.
	3668	With a prefix ARG invokes `projectile-commander' instead of
	3669	`projectile-switch-project-action.'"
	3670	(interactive "P")
	3671	(let ((projects (projectile-relevant-open-projects)))
	3672	(if projects
	3673	(projectile-completing-read
	3674	"Switch to open project: " projects
	3675	:action (lambda (project)
	3676	(projectile-switch-project-by-name project arg)))
	3677	(user-error "There are no open projects"))))
	3678
	3679	(defun projectile-switch-project-by-name (project-to-switch &optional arg)
	3680	"Switch to project by project name PROJECT-TO-SWITCH.
	3681	Invokes the command referenced by `projectile-switch-project-action' on switch.
	3682	With a prefix ARG invokes `projectile-commander' instead of
	3683	`projectile-switch-project-action.'"
	3684	(unless (projectile-project-p project-to-switch)
	3685	(projectile-remove-known-project project-to-switch)
	3686	(error "Directory %s is not a project" project-to-switch))
	3687	(let ((switch-project-action (if arg
	3688	'projectile-commander
	3689	projectile-switch-project-action)))
	3690	(run-hooks 'projectile-before-switch-project-hook)
	3691	(let ((default-directory project-to-switch))
	3692	;; use a temporary buffer to load PROJECT-TO-SWITCH's dir-locals before calling SWITCH-PROJECT-ACTION
	3693	(with-temp-buffer
	3694	(hack-dir-local-variables-non-file-buffer))
	3695	;; Normally the project name is determined from the current
	3696	;; buffer. However, when we're switching projects, we want to
	3697	;; show the name of the project being switched to, rather than
	3698	;; the current project, in the minibuffer. This is a simple hack
	3699	;; to tell the `projectile-project-name' function to ignore the
	3700	;; current buffer and the caching mechanism, and just return the
	3701	;; value of the `projectile-project-name' variable.
	3702	(let ((projectile-project-name (funcall projectile-project-name-function
	3703	project-to-switch)))
	3704	(funcall switch-project-action)))
	3705	(run-hooks 'projectile-after-switch-project-hook)))
	3706
	3707	;;;###autoload
	3708	(defun projectile-find-file-in-directory (&optional directory)
	3709	"Jump to a file in a (maybe regular) DIRECTORY.
	3710
	3711	This command will first prompt for the directory the file is in."
	3712	(interactive "DFind file in directory: ")
	3713	(unless (projectile--directory-p directory)
	3714	(user-error "Directory %S does not exist" directory))
	3715	(let ((default-directory directory))
	3716	(if (projectile-project-p)
	3717	;; target directory is in a project
	3718	(let ((file (projectile-completing-read "Find file: "
	3719	(projectile-dir-files directory))))
	3720	(find-file (expand-file-name file (projectile-project-root)))
	3721	(run-hooks 'projectile-find-file-hook))
	3722	;; target directory is not in a project
	3723	(projectile-find-file))))
	3724
	3725	(defun projectile-all-project-files ()
	3726	"Get a list of all files in all projects."
	3727	(cl-mapcan
	3728	(lambda (project)
	3729	(when (file-exists-p project)
	3730	(mapcar (lambda (file)
	3731	(expand-file-name file project))
	3732	(projectile-project-files project))))
	3733	projectile-known-projects))
	3734
	3735	;;;###autoload
	3736	(defun projectile-find-file-in-known-projects ()
	3737	"Jump to a file in any of the known projects."
	3738	(interactive)
	3739	(find-file (projectile-completing-read "Find file in projects: " (projectile-all-project-files))))
	3740
	3741	(defun projectile-keep-project-p (project)
	3742	"Determine whether we should cleanup (remove) PROJECT or not.
	3743
	3744	It handles the case of remote projects as well.
	3745	See `projectile--cleanup-known-projects'."
	3746	;; Taken from from `recentf-keep-default-predicate'
	3747	(cond
	3748	((file-remote-p project nil t) (file-readable-p project))
	3749	((file-remote-p project))
	3750	((file-readable-p project))))
	3751
	3752	(defun projectile--cleanup-known-projects ()
	3753	"Remove known projects that don't exist anymore and return a list of projects removed."
	3754	(projectile-merge-known-projects)
	3755	(let ((projects-kept (cl-remove-if-not #'projectile-keep-project-p projectile-known-projects))
	3756	(projects-removed (cl-remove-if #'projectile-keep-project-p projectile-known-projects)))
	3757	(setq projectile-known-projects projects-kept)
	3758	(projectile-merge-known-projects)
	3759	projects-removed))
	3760
	3761	;;;###autoload
	3762	(defun projectile-cleanup-known-projects ()
	3763	"Remove known projects that don't exist anymore."
	3764	(interactive)
	3765	(if-let ((projects-removed (projectile--cleanup-known-projects)))
	3766	(message "Projects removed: %s"
	3767	(mapconcat #'identity projects-removed ", "))
	3768	(message "No projects needed to be removed.")))
	3769
	3770	;;;###autoload
	3771	(defun projectile-clear-known-projects ()
	3772	"Clear both `projectile-known-projects' and `projectile-known-projects-file'."
	3773	(interactive)
	3774	(setq projectile-known-projects nil)
	3775	(projectile-save-known-projects))
	3776
	3777	;;;###autoload
	3778	(defun projectile-remove-known-project (&optional project)
	3779	"Remove PROJECT from the list of known projects."
	3780	(interactive (list (projectile-completing-read
	3781	"Remove from known projects: " projectile-known-projects
	3782	:action 'projectile-remove-known-project)))
	3783	(unless (called-interactively-p 'any)
	3784	(setq projectile-known-projects
	3785	(cl-remove-if
	3786	(lambda (proj) (string= project proj))
	3787	projectile-known-projects))
	3788	(projectile-merge-known-projects)
	3789	(when projectile-verbose
	3790	(message "Project %s removed from the list of known projects." project))))
	3791
	3792	;;;###autoload
	3793	(defun projectile-remove-current-project-from-known-projects ()
	3794	"Remove the current project from the list of known projects."
	3795	(interactive)
	3796	(projectile-remove-known-project (abbreviate-file-name (projectile-project-root))))
	3797
	3798	(defun projectile-ignored-projects ()
	3799	"A list of projects that should not be save in `projectile-known-projects'."
	3800	(mapcar #'file-truename projectile-ignored-projects))
	3801
	3802	(defun projectile-ignored-project-p (project-root)
	3803	"Return t if PROJECT-ROOT should not be added to `projectile-known-projects'."
	3804	(or (member project-root (projectile-ignored-projects))
	3805	(and (functionp projectile-ignored-project-function)
	3806	(funcall projectile-ignored-project-function project-root))))
	3807
	3808	(defun projectile-add-known-project (project-root)
	3809	"Add PROJECT-ROOT to the list of known projects."
	3810	(interactive (list (read-directory-name "Add to known projects: ")))
	3811	(unless (projectile-ignored-project-p project-root)
	3812	(setq projectile-known-projects
	3813	(delete-dups
	3814	(cons (file-name-as-directory (abbreviate-file-name project-root))
	3815	projectile-known-projects)))
	3816	(projectile-merge-known-projects)))
	3817
	3818	(defun projectile-load-known-projects ()
	3819	"Load saved projects from `projectile-known-projects-file'.
	3820	Also set `projectile-known-projects'."
	3821	(setq projectile-known-projects
	3822	(projectile-unserialize projectile-known-projects-file))
	3823	(setq projectile-known-projects-on-file
	3824	(and (sequencep projectile-known-projects)
	3825	(copy-sequence projectile-known-projects))))
	3826
	3827	(defun projectile-save-known-projects ()
	3828	"Save PROJECTILE-KNOWN-PROJECTS to PROJECTILE-KNOWN-PROJECTS-FILE."
	3829	(projectile-serialize projectile-known-projects
	3830	projectile-known-projects-file)
	3831	(setq projectile-known-projects-on-file
	3832	(and (sequencep projectile-known-projects)
	3833	(copy-sequence projectile-known-projects))))
	3834
	3835	(defun projectile-merge-known-projects ()
	3836	"Merge any change from `projectile-known-projects-file' and save to disk.
	3837
	3838	This enables multiple Emacs processes to make changes without
	3839	overwriting each other's changes."
	3840	(let* ((known-now projectile-known-projects)
	3841	(known-on-last-sync projectile-known-projects-on-file)
	3842	(known-on-file
	3843	(projectile-unserialize projectile-known-projects-file))
	3844	(removed-after-sync (projectile-difference known-on-last-sync known-now))
	3845	(removed-in-other-process
	3846	(projectile-difference known-on-last-sync known-on-file))
	3847	(result (delete-dups
	3848	(projectile-difference
	3849	(append known-now known-on-file)
	3850	(append removed-after-sync removed-in-other-process)))))
	3851	(setq projectile-known-projects result)
	3852	(projectile-save-known-projects)))
	3853
	3854
	3855	;;; IBuffer integration
	3856	(define-ibuffer-filter projectile-files
	3857	"Show Ibuffer with all buffers in the current project."
	3858	(:reader (read-directory-name "Project root: " (projectile-project-root))
	3859	:description nil)
	3860	(with-current-buffer buf
	3861	(equal (file-name-as-directory (expand-file-name qualifier))
	3862	(projectile-project-root))))
	3863
	3864	(defun projectile-ibuffer-by-project (project-root)
	3865	"Open an IBuffer window showing all buffers in PROJECT-ROOT."
	3866	(let ((project-name (funcall projectile-project-name-function project-root)))
	3867	(ibuffer nil (format "%s Buffers" project-name)
	3868	(list (cons 'projectile-files project-root)))))
	3869
	3870	;;;###autoload
	3871	(defun projectile-ibuffer (prompt-for-project)
	3872	"Open an IBuffer window showing all buffers in the current project.
	3873
	3874	Let user choose another project when PROMPT-FOR-PROJECT is supplied."
	3875	(interactive "P")
	3876	(let ((project-root (if prompt-for-project
	3877	(projectile-completing-read
	3878	"Project name: "
	3879	(projectile-relevant-known-projects))
	3880	(projectile-project-root))))
	3881
	3882	(projectile-ibuffer-by-project project-root)))
	3883
	3884
	3885	;;;; projectile-commander
	3886
	3887	(defconst projectile-commander-help-buffer "Projectile Commander Help")
	3888
	3889	(defvar projectile-commander-methods nil
	3890	"List of file-selection methods for the `projectile-commander' command.
	3891	Each element is a list (KEY DESCRIPTION FUNCTION).
	3892	DESCRIPTION is a one-line description of what the key selects.")
	3893
	3894	;;;###autoload
	3895	(defun projectile-commander ()
	3896	"Execute a Projectile command with a single letter.
	3897	The user is prompted for a single character indicating the action to invoke.
	3898	The `?' character describes then
	3899	available actions.
	3900
	3901	See `def-projectile-commander-method' for defining new methods."
	3902	(interactive)
	3903	(let* ((choices (mapcar #'car projectile-commander-methods))
	3904	(prompt (concat "Select Projectile command [" choices "]: "))
	3905	(ch (read-char-choice prompt choices))
	3906	(fn (nth 2 (assq ch projectile-commander-methods))))
	3907	(funcall fn)))
	3908
	3909	(defmacro def-projectile-commander-method (key description &rest body)
	3910	"Define a new `projectile-commander' method.
	3911
	3912	KEY is the key the user will enter to choose this method.
	3913
	3914	DESCRIPTION is a one-line sentence describing how the method.
	3915
	3916	BODY is a series of forms which are evaluated when the find
	3917	is chosen."
	3918	(let ((method `(lambda ()
	3919	,@body)))
	3920	`(setq projectile-commander-methods
	3921	(cl-sort (copy-sequence
	3922	(cons (list ,key ,description ,method)
	3923	(assq-delete-all ,key projectile-commander-methods)))
	3924	(lambda (a b) (< (car a) (car b)))))))
	3925
	3926	(def-projectile-commander-method ?? "Commander help buffer."
	3927	(ignore-errors (kill-buffer projectile-commander-help-buffer))
	3928	(with-current-buffer (get-buffer-create projectile-commander-help-buffer)
	3929	(insert "Projectile Commander Methods:\n\n")
	3930	(dolist (met projectile-commander-methods)
	3931	(insert (format "%c:\t%s\n" (car met) (cadr met))))
	3932	(goto-char (point-min))
	3933	(help-mode)
	3934	(display-buffer (current-buffer) t))
	3935	(projectile-commander))
	3936
	3937	(defun projectile-commander-bindings ()
	3938	"Setup the keybindings for the Projectile Commander."
	3939	(def-projectile-commander-method ?f
	3940	"Find file in project."
	3941	(projectile-find-file))
	3942
	3943	(def-projectile-commander-method ?T
	3944	"Find test file in project."
	3945	(projectile-find-test-file))
	3946
	3947	(def-projectile-commander-method ?b
	3948	"Switch to project buffer."
	3949	(projectile-switch-to-buffer))
	3950
	3951	(def-projectile-commander-method ?d
	3952	"Find directory in project."
	3953	(projectile-find-dir))
	3954
	3955	(def-projectile-commander-method ?D
	3956	"Open project root in dired."
	3957	(projectile-dired))
	3958
	3959	(def-projectile-commander-method ?v
	3960	"Open project root in vc-dir or magit."
	3961	(projectile-vc))
	3962
	3963	(def-projectile-commander-method ?V
	3964	"Browse dirty projects"
	3965	(projectile-browse-dirty-projects))
	3966
	3967	(def-projectile-commander-method ?r
	3968	"Replace a string in the project."
	3969	(projectile-replace))
	3970
	3971	(def-projectile-commander-method ?R
	3972	"Regenerate the project's [e\|g]tags."
	3973	(projectile-regenerate-tags))
	3974
	3975	(def-projectile-commander-method ?g
	3976	"Run grep on project."
	3977	(projectile-grep))
	3978
	3979	(def-projectile-commander-method ?a
	3980	"Run ag on project."
	3981	(call-interactively 'projectile-ag))
	3982
	3983	(def-projectile-commander-method ?s
	3984	"Switch project."
	3985	(projectile-switch-project))
	3986
	3987	(def-projectile-commander-method ?o
	3988	"Run multi-occur on project buffers."
	3989	(projectile-multi-occur))
	3990
	3991	(def-projectile-commander-method ?j
	3992	"Find tag in project."
	3993	(projectile-find-tag))
	3994
	3995	(def-projectile-commander-method ?k
	3996	"Kill all project buffers."
	3997	(projectile-kill-buffers))
	3998
	3999	(def-projectile-commander-method ?e
	4000	"Find recently visited file in project."
	4001	(projectile-recentf)))
	4002
	4003
	4004	;;; Dirty (modified) project check related functionality
	4005	(defun projectile-check-vcs-status (&optional project-path)
	4006	"Check the status of the current project.
	4007	If PROJECT-PATH is a project, check this one instead."
	4008	(let ((project-path (or project-path (projectile-project-root)))
	4009	(project-status nil))
	4010	(save-excursion
	4011	(vc-dir project-path)
	4012	;; wait until vc-dir is done
	4013	(while (vc-dir-busy) (sleep-for 0 100))
	4014	;; check for status
	4015	(save-excursion
	4016	(save-match-data
	4017	(dolist (check projectile-vcs-dirty-state)
	4018	(goto-char (point-min))
	4019	(when (search-forward check nil t)
	4020	(setq project-status (cons check project-status))))))
	4021	(kill-buffer)
	4022	project-status)))
	4023
	4024	(defvar projectile-cached-dirty-projects-status nil
	4025	"Cache of the last dirty projects check.")
	4026
	4027	(defun projectile-check-vcs-status-of-known-projects ()
	4028	"Return the list of dirty projects.
	4029	The list is composed of sublists~: (project-path, project-status).
	4030	Raise an error if their is no dirty project."
	4031	(save-window-excursion
	4032	(message "Checking for modifications in known projects...")
	4033	(let ((projects projectile-known-projects)
	4034	(status ()))
	4035	(dolist (project projects)
	4036	(when (and (projectile-keep-project-p project) (not (string= 'none (projectile-project-vcs project))))
	4037	(let ((tmp-status (projectile-check-vcs-status project)))
	4038	(when tmp-status
	4039	(setq status (cons (list project tmp-status) status))))))
	4040	(when (= (length status) 0)
	4041	(message "No dirty projects have been found"))
	4042	(setq projectile-cached-dirty-projects-status status)
	4043	status)))
	4044
	4045	;;;###autoload
	4046	(defun projectile-browse-dirty-projects (&optional cached)
	4047	"Browse dirty version controlled projects.
	4048
	4049	With a prefix argument, or if CACHED is non-nil, try to use the cached
	4050	dirty project list."
	4051	(interactive "P")
	4052	(let ((status (if (and cached projectile-cached-dirty-projects-status)
	4053	projectile-cached-dirty-projects-status
	4054	(projectile-check-vcs-status-of-known-projects)))
	4055	(mod-proj nil))
	4056	(while (not (= (length status) 0))
	4057	(setq mod-proj (cons (car (pop status)) mod-proj)))
	4058	(projectile-completing-read "Select project: " mod-proj
	4059	:action 'projectile-vc)))
	4060
	4061
	4062	;;; Find next/previous project buffer
	4063	(defun projectile--repeat-until-project-buffer (orig-fun &rest args)
	4064	"Repeat ORIG-FUN with ARGS until the current buffer is a project buffer."
	4065	(if (projectile-project-root)
	4066	(let* ((other-project-buffers (make-hash-table :test 'eq))
	4067	(projectile-project-buffers (projectile-project-buffers))
	4068	(max-iterations (length (buffer-list)))
	4069	(counter 0))
	4070	(dolist (buffer projectile-project-buffers)
	4071	(unless (eq buffer (current-buffer))
	4072	(puthash buffer t other-project-buffers)))
	4073	(when (cdr-safe projectile-project-buffers)
	4074	(while (and (< counter max-iterations)
	4075	(not (gethash (current-buffer) other-project-buffers)))
	4076	(apply orig-fun args)
	4077	(cl-incf counter))))
	4078	(apply orig-fun args)))
	4079
	4080	(defun projectile-next-project-buffer ()
	4081	"In selected window switch to the next project buffer.
	4082
	4083	If the current buffer does not belong to a project, call `next-buffer'."
	4084	(interactive)
	4085	(projectile--repeat-until-project-buffer #'next-buffer))
	4086
	4087	(defun projectile-previous-project-buffer ()
	4088	"In selected window switch to the previous project buffer.
	4089
	4090	If the current buffer does not belong to a project, call `previous-buffer'."
	4091	(interactive)
	4092	(projectile--repeat-until-project-buffer #'previous-buffer))
	4093
	4094
	4095	;;; Editing a project's .dir-locals
	4096	(defun projectile-read-variable ()
	4097	"Prompt for a variable and return its name."
	4098	(completing-read "Variable: "
	4099	obarray
	4100	'(lambda (v)
	4101	(and (boundp v) (not (keywordp v))))
	4102	t))
	4103
	4104	(define-skeleton projectile-skel-variable-cons
	4105	"Insert a variable-name and a value in a cons-cell."
	4106	"Value: "
	4107	"("
	4108	(projectile-read-variable)
	4109	" . "
	4110	str
	4111	")")
	4112
	4113	(define-skeleton projectile-skel-dir-locals
	4114	"Insert a .dir-locals.el template."
	4115	nil
	4116	"((nil . ("
	4117	("" '(projectile-skel-variable-cons) \n)
	4118	resume:
	4119	")))")
	4120
	4121	;;;###autoload
	4122	(defun projectile-edit-dir-locals ()
	4123	"Edit or create a .dir-locals.el file of the project."
	4124	(interactive)
	4125	(let ((file (expand-file-name ".dir-locals.el" (projectile-project-root))))
	4126	(find-file file)
	4127	(when (not (file-exists-p file))
	4128	(unwind-protect
	4129	(projectile-skel-dir-locals)
	4130	(save-buffer)))))
	4131
	4132
	4133	;;; Projectile Minor mode
	4134	(define-obsolete-variable-alias 'projectile-mode-line-lighter 'projectile-mode-line-prefix)
	4135	(defcustom projectile-mode-line-prefix
	4136	" Projectile"
	4137	"Mode line lighter prefix for Projectile.
	4138	It's used by `projectile-default-mode-line'
	4139	when using dynamic mode line lighter and is the only
	4140	thing shown in the mode line otherwise."
	4141	:group 'projectile
	4142	:type 'string
	4143	:package-version '(projectile . "0.12.0"))
	4144
	4145	(defvar-local projectile--mode-line projectile-mode-line-prefix)
	4146
	4147	(defun projectile-default-mode-line ()
	4148	"Report project name and type in the modeline."
	4149	(let ((project-name (projectile-project-name))
	4150	(project-type (projectile-project-type)))
	4151	(format "%s[%s%s]"
	4152	projectile-mode-line-prefix
	4153	(or project-name "-")
	4154	(if project-type
	4155	(format ":%s" project-type)
	4156	""))))
	4157
	4158	(defun projectile-update-mode-line ()
	4159	"Update the Projectile mode-line."
	4160	(let ((mode-line (funcall projectile-mode-line-function)))
	4161	(setq projectile--mode-line mode-line))
	4162	(force-mode-line-update))
	4163
	4164	(defvar projectile-command-map
	4165	(let ((map (make-sparse-keymap)))
	4166	(define-key map (kbd "4 a") #'projectile-find-other-file-other-window)
	4167	(define-key map (kbd "4 b") #'projectile-switch-to-buffer-other-window)
	4168	(define-key map (kbd "4 C-o") #'projectile-display-buffer)
	4169	(define-key map (kbd "4 d") #'projectile-find-dir-other-window)
	4170	(define-key map (kbd "4 D") #'projectile-dired-other-window)
	4171	(define-key map (kbd "4 f") #'projectile-find-file-other-window)
	4172	(define-key map (kbd "4 g") #'projectile-find-file-dwim-other-window)
	4173	(define-key map (kbd "4 t") #'projectile-find-implementation-or-test-other-window)
	4174	(define-key map (kbd "5 a") #'projectile-find-other-file-other-frame)
	4175	(define-key map (kbd "5 b") #'projectile-switch-to-buffer-other-frame)
	4176	(define-key map (kbd "5 d") #'projectile-find-dir-other-frame)
	4177	(define-key map (kbd "5 D") #'projectile-dired-other-frame)
	4178	(define-key map (kbd "5 f") #'projectile-find-file-other-frame)
	4179	(define-key map (kbd "5 g") #'projectile-find-file-dwim-other-frame)
	4180	(define-key map (kbd "5 t") #'projectile-find-implementation-or-test-other-frame)
	4181	(define-key map (kbd "!") #'projectile-run-shell-command-in-root)
	4182	(define-key map (kbd "&") #'projectile-run-async-shell-command-in-root)
	4183	(define-key map (kbd "a") #'projectile-find-other-file)
	4184	(define-key map (kbd "b") #'projectile-switch-to-buffer)
	4185	(define-key map (kbd "C") #'projectile-configure-project)
	4186	(define-key map (kbd "c") #'projectile-compile-project)
	4187	(define-key map (kbd "d") #'projectile-find-dir)
	4188	(define-key map (kbd "D") #'projectile-dired)
	4189	(define-key map (kbd "e") #'projectile-recentf)
	4190	(define-key map (kbd "E") #'projectile-edit-dir-locals)
	4191	(define-key map (kbd "f") #'projectile-find-file)
	4192	(define-key map (kbd "g") #'projectile-find-file-dwim)
	4193	(define-key map (kbd "F") #'projectile-find-file-in-known-projects)
	4194	(define-key map (kbd "i") #'projectile-invalidate-cache)
	4195	(define-key map (kbd "I") #'projectile-ibuffer)
	4196	(define-key map (kbd "j") #'projectile-find-tag)
	4197	(define-key map (kbd "k") #'projectile-kill-buffers)
	4198	(define-key map (kbd "l") #'projectile-find-file-in-directory)
	4199	(define-key map (kbd "m") #'projectile-commander)
	4200	(define-key map (kbd "o") #'projectile-multi-occur)
	4201	(define-key map (kbd "p") #'projectile-switch-project)
	4202	(define-key map (kbd "q") #'projectile-switch-open-project)
	4203	(define-key map (kbd "P") #'projectile-test-project)
	4204	(define-key map (kbd "r") #'projectile-replace)
	4205	(define-key map (kbd "R") #'projectile-regenerate-tags)
	4206	(define-key map (kbd "s g") #'projectile-grep)
	4207	(define-key map (kbd "s r") #'projectile-ripgrep)
	4208	(define-key map (kbd "s s") #'projectile-ag)
	4209	(define-key map (kbd "S") #'projectile-save-project-buffers)
	4210	(define-key map (kbd "t") #'projectile-toggle-between-implementation-and-test)
	4211	(define-key map (kbd "T") #'projectile-find-test-file)
	4212	(define-key map (kbd "u") #'projectile-run-project)
	4213	(define-key map (kbd "v") #'projectile-vc)
	4214	(define-key map (kbd "V") #'projectile-browse-dirty-projects)
	4215	(define-key map (kbd "x e") #'projectile-run-eshell)
	4216	(define-key map (kbd "x i") #'projectile-run-ielm)
	4217	(define-key map (kbd "x t") #'projectile-run-term)
	4218	(define-key map (kbd "x s") #'projectile-run-shell)
	4219	(define-key map (kbd "z") #'projectile-cache-current-file)
	4220	(define-key map (kbd "<left>") #'projectile-previous-project-buffer)
	4221	(define-key map (kbd "<right>") #'projectile-next-project-buffer)
	4222	(define-key map (kbd "ESC") #'projectile-project-buffers-other-buffer)
	4223	map)
	4224	"Keymap for Projectile commands after `projectile-keymap-prefix'.")
	4225	(fset 'projectile-command-map projectile-command-map)
	4226
	4227	(defvar projectile-mode-map
	4228	(let ((map (make-sparse-keymap)))
	4229	(when projectile-keymap-prefix
	4230	(define-key map projectile-keymap-prefix 'projectile-command-map))
	4231	(easy-menu-define projectile-mode-menu map
	4232	"Menu for Projectile"
	4233	'("Projectile"
	4234	["Find file" projectile-find-file]
	4235	["Find file in known projects" projectile-find-file-in-known-projects]
	4236	["Find test file" projectile-find-test-file]
	4237	["Find directory" projectile-find-dir]
	4238	["Find file in directory" projectile-find-file-in-directory]
	4239	["Find other file" projectile-find-other-file]
	4240	["Switch to buffer" projectile-switch-to-buffer]
	4241	["Jump between implementation file and test file" projectile-toggle-between-implementation-and-test]
	4242	["Kill project buffers" projectile-kill-buffers]
	4243	["Save project buffers" projectile-save-project-buffers]
	4244	["Recent files" projectile-recentf]
	4245	["Previous buffer" projectile-previous-project-buffer]
	4246	["Next buffer" projectile-next-project-buffer]
	4247	"--"
	4248	["Toggle project wide read-only" projectile-toggle-project-read-only]
	4249	["Edit .dir-locals.el" projectile-edit-dir-locals]
	4250	"--"
	4251	["Switch to project" projectile-switch-project]
	4252	["Switch to open project" projectile-switch-open-project]
	4253	["Discover projects in directory" projectile-discover-projects-in-directory]
	4254	["Browse dirty projects" projectile-browse-dirty-projects]
	4255	["Open project in dired" projectile-dired]
	4256	"--"
	4257	["Search in project (grep)" projectile-grep]
	4258	["Search in project (ag)" projectile-ag]
	4259	["Replace in project" projectile-replace]
	4260	["Multi-occur in project" projectile-multi-occur]
	4261	"--"
	4262	["Run shell" projectile-run-shell]
	4263	["Run eshell" projectile-run-eshell]
	4264	["Run ielm" projectile-run-ielm]
	4265	["Run term" projectile-run-term]
	4266	"--"
	4267	["Cache current file" projectile-cache-current-file]
	4268	["Invalidate cache" projectile-invalidate-cache]
	4269	["Regenerate [e\|g]tags" projectile-regenerate-tags]
	4270	"--"
	4271	["Configure project" projectile-configure-project]
	4272	["Compile project" projectile-compile-project]
	4273	["Test project" projectile-test-project]
	4274	["Run project" projectile-run-project]
	4275	["Repeat last external command" projectile-repeat-last-command]
	4276	"--"
	4277	["Project info" projectile-project-info]
	4278	["About" projectile-version]))
	4279	map)
	4280	"Keymap for Projectile mode.")
	4281
	4282	(defun projectile-find-file-hook-function ()
	4283	"Called by `find-file-hook' when `projectile-mode' is on.
	4284
	4285	The function does pretty much nothing when triggered on remote files
	4286	as all the operations it normally performs are extremely slow over
	4287	tramp."
	4288	(unless (file-remote-p default-directory)
	4289	(when projectile-dynamic-mode-line
	4290	(projectile-update-mode-line))
	4291	(projectile-cache-files-find-file-hook)
	4292	(projectile-track-known-projects-find-file-hook)
	4293	(projectile-visit-project-tags-table)))
	4294
	4295	;;;###autoload
	4296	(define-minor-mode projectile-mode
	4297	"Minor mode to assist project management and navigation.
	4298
	4299	When called interactively, toggle `projectile-mode'. With prefix
	4300	ARG, enable `projectile-mode' if ARG is positive, otherwise disable
	4301	it.
	4302
	4303	When called from Lisp, enable `projectile-mode' if ARG is omitted,
	4304	nil or positive. If ARG is `toggle', toggle `projectile-mode'.
	4305	Otherwise behave as if called interactively.
	4306
	4307	\\{projectile-mode-map}"
	4308	:lighter projectile--mode-line
	4309	:keymap projectile-mode-map
	4310	:group 'projectile
	4311	:require 'projectile
	4312	:global t
	4313	(cond
	4314	(projectile-mode
	4315	;; setup the commander bindings
	4316	(projectile-commander-bindings)
	4317	;; initialize the projects cache if needed
	4318	(unless projectile-projects-cache
	4319	(setq projectile-projects-cache
	4320	(or (projectile-unserialize projectile-cache-file)
	4321	(make-hash-table :test 'equal))))
	4322	(unless projectile-projects-cache-time
	4323	(setq projectile-projects-cache-time
	4324	(make-hash-table :test 'equal)))
	4325	;; load the known projects
	4326	(projectile-load-known-projects)
	4327	;; update the list of known projects
	4328	(projectile--cleanup-known-projects)
	4329	(projectile-discover-projects-in-search-path)
	4330	(add-hook 'find-file-hook 'projectile-find-file-hook-function)
	4331	(add-hook 'projectile-find-dir-hook #'projectile-track-known-projects-find-file-hook t)
	4332	(add-hook 'dired-before-readin-hook #'projectile-track-known-projects-find-file-hook t t)
	4333	(ad-activate 'compilation-find-file)
	4334	(ad-activate 'delete-file))
	4335	(t
	4336	(remove-hook 'find-file-hook #'projectile-find-file-hook-function)
	4337	(remove-hook 'dired-before-readin-hook #'projectile-track-known-projects-find-file-hook t)
	4338	(ad-deactivate 'compilation-find-file)
	4339	(ad-deactivate 'delete-file))))
	4340
	4341	;;;###autoload
	4342	(define-obsolete-function-alias 'projectile-global-mode 'projectile-mode "1.0")
	4343
	4344	(provide 'projectile)
	4345
	4346	;;; projectile.el ends here