mirror of https://github.com/Chizi123/.emacs.d.git

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