;;; projectile.el --- Manage and navigate projects in Emacs easily -*- lexical-binding: t -*- ;; Copyright © 2011-2021 Bozhidar Batsov ;; Author: Bozhidar Batsov ;; URL: https://github.com/bbatsov/projectile ;; Package-Version: 2.4.0 ;; Package-Commit: bbb7b8d4c498e88046e4e6227990626f2b5dbe1b ;; Keywords: project, convenience ;; Version: 2.4.0 ;; Package-Requires: ((emacs "25.1") (pkg-info "0.4")) ;; This file is NOT part of GNU Emacs. ;; This program is free software; you can redistribute it and/or modify ;; it under the terms of the GNU General Public License as published by ;; the Free Software Foundation; either version 3, or (at your option) ;; any later version. ;; ;; This program is distributed in the hope that it will be useful, ;; but WITHOUT ANY WARRANTY; without even the implied warranty of ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ;; GNU General Public License for more details. ;; ;; You should have received a copy of the GNU General Public License ;; along with GNU Emacs; see the file COPYING. If not, write to the ;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, ;; Boston, MA 02110-1301, USA. ;;; Commentary: ;; ;; This library provides easy project management and navigation. The ;; concept of a project is pretty basic - just a folder containing ;; special file. Currently git, mercurial and bazaar repos are ;; considered projects by default. If you want to mark a folder ;; manually as a project just create an empty .projectile file in ;; it. See the README for more details. ;; ;;; Code: (require 'cl-lib) (require 'thingatpt) (require 'ibuffer) (require 'ibuf-ext) (require 'compile) (require 'grep) (eval-when-compile (require 'find-dired) (require 'subr-x)) (eval-when-compile (defvar ido-mode) (defvar ivy-mode) (defvar helm-mode) (defvar ag-ignore-list) (defvar ggtags-completion-table) (defvar tags-completion-table) (defvar tags-loop-scan) (defvar tags-loop-operate) (defvar eshell-buffer-name) (defvar explicit-shell-file-name)) (declare-function tags-completion-table "etags") (declare-function make-term "term") (declare-function term-mode "term") (declare-function term-char-mode "term") (declare-function term-ansi-make-term "term") (declare-function eshell-search-path "esh-ext") (declare-function vc-dir "vc-dir") (declare-function vc-dir-busy "vc-dir") (declare-function string-trim "subr-x") (declare-function fileloop-continue "fileloop") (declare-function fileloop-initialize-replace "fileloop") (declare-function tramp-archive-file-name-p "tramp-archive") (declare-function ggtags-ensure-project "ext:ggtags") (declare-function ggtags-update-tags "ext:ggtags") (declare-function pkg-info-version-info "ext:pkg-info") (declare-function ripgrep-regexp "ext:ripgrep") (declare-function vterm "ext:vterm") (declare-function vterm-send-return "ext:vterm") (declare-function vterm-send-string "ext:vterm") (defvar grep-files-aliases) (defvar grep-find-ignored-directories) (defvar grep-find-ignored-files) ;;; Customization (defgroup projectile nil "Manage and navigate projects easily." :group 'tools :group 'convenience :link '(url-link :tag "GitHub" "https://github.com/bbatsov/projectile") :link '(url-link :tag "Online Manual" "https://docs.projectile.mx/") :link '(emacs-commentary-link :tag "Commentary" "projectile")) (defcustom projectile-indexing-method (if (eq system-type 'windows-nt) 'native 'alien) "Specifies the indexing method used by Projectile. There are three indexing methods - native, hybrid and alien. The native method is implemented in Emacs Lisp (therefore it is native to Emacs). Its advantage is that it is portable and will work everywhere that Emacs does. Its disadvantage is that it is a bit slow (especially for large projects). Generally it's a good idea to pair the native indexing method with caching. The hybrid indexing method uses external tools (e.g. git, find, etc) to speed up the indexing process. Still, the files will be post-processed by Projectile for sorting/filtering purposes. In this sense that approach is a hybrid between native indexing and alien indexing. The alien indexing method optimizes to the limit the speed of the hybrid indexing method. This means that Projectile will not do any processing of the files returned by the external commands and you're going to get the maximum performance possible. This behaviour makes a lot of sense for most people, as they'd typically be putting ignores in their VCS config and won't care about any additional ignores/unignores/sorting that Projectile might also provide. The disadvantage of the hybrid and alien methods is that they are not well supported on Windows systems. That's why by default alien indexing is the default on all operating systems, except Windows." :group 'projectile :type '(radio (const :tag "Native" native) (const :tag "Hybrid" hybrid) (const :tag "Alien" alien))) (defcustom projectile-enable-caching (eq projectile-indexing-method 'native) "When t enables project files caching. Project caching is automatically enabled by default if you're using the native indexing method." :group 'projectile :type 'boolean) (defcustom projectile-kill-buffers-filter 'kill-all "Determine which buffers are killed by `projectile-kill-buffers'. When the kill-all option is selected, kills each buffer. When the kill-only-files option is selected, kill only the buffer associated to a file. Otherwise, it should be a predicate that takes one argument: the buffer to be killed." :group 'projectile :type '(radio (const :tag "All project buffers" kill-all) (const :tag "Project file buffers" kill-only-files) (function :tag "Predicate"))) (defcustom projectile-file-exists-local-cache-expire nil "Number of seconds before the local file existence cache expires. Local refers to a file on a local file system. A value of nil disables this cache. See `projectile-file-exists-p' for details." :group 'projectile :type '(choice (const :tag "Disabled" nil) (integer :tag "Seconds"))) (defcustom projectile-file-exists-remote-cache-expire (* 5 60) "Number of seconds before the remote file existence cache expires. Remote refers to a file on a remote file system such as tramp. A value of nil disables this cache. See `projectile-file-exists-p' for details." :group 'projectile :type '(choice (const :tag "Disabled" nil) (integer :tag "Seconds"))) (defcustom projectile-files-cache-expire nil "Number of seconds before project files list cache expires. A value of nil means the cache never expires." :group 'projectile :type '(choice (const :tag "Disabled" nil) (integer :tag "Seconds"))) (defcustom projectile-auto-discover t "Whether to discover projects when `projectile-mode' is activated." :group 'projectile :type 'boolean :package-version '(projectile . "2.3.0")) (defcustom projectile-auto-update-cache t "Whether the cache should automatically be updated when files are opened or deleted." :group 'projectile :type 'boolean) (defcustom projectile-require-project-root 'prompt "Require the presence of a project root to operate when true. When set to 'prompt Projectile will ask you to select a project directory if you're not in a project. When nil Projectile will consider the current directory the project root." :group 'projectile :type '(choice (const :tag "No" nil) (const :tag "Yes" t) (const :tag "Prompt for project" prompt))) (defcustom projectile-completion-system 'auto "The completion system to be used by Projectile." :group 'projectile :type '(radio (const :tag "Auto-detect" auto) (const :tag "Ido" ido) (const :tag "Helm" helm) (const :tag "Ivy" ivy) (const :tag "Default" default) (function :tag "Custom function"))) (defcustom projectile-keymap-prefix nil "Projectile keymap prefix." :group 'projectile :type 'string) (make-obsolete-variable 'projectile-keymap-prefix "Use (define-key projectile-mode-map (kbd ...) 'projectile-command-map) instead." "2.0.0") (defcustom projectile-cache-file (expand-file-name "projectile.cache" user-emacs-directory) "The name of Projectile's cache file." :group 'projectile :type 'string) (defcustom projectile-tags-file-name "TAGS" "The tags filename Projectile's going to use." :group 'projectile :type 'string) (defcustom projectile-tags-command "ctags -Re -f \"%s\" %s \"%s\"" "The command Projectile's going to use to generate a TAGS file." :group 'projectile :type 'string) (defcustom projectile-tags-backend 'auto "The tag backend that Projectile should use. If set to 'auto', `projectile-find-tag' will automatically choose which backend to use. Preference order is ggtags -> xref -> etags-select -> `find-tag'. Variable can also be set to specify which backend to use. If selected backend is unavailable, fall back to `find-tag'. If this variable is set to 'auto' and ggtags is available, or if set to 'ggtags', then ggtags will be used for `projectile-regenerate-tags'. For all other settings `projectile-tags-command' will be used." :group 'projectile :type '(radio (const :tag "auto" auto) (const :tag "xref" xref) (const :tag "ggtags" ggtags) (const :tag "etags" etags-select) (const :tag "standard" find-tag)) :package-version '(projectile . "0.14.0")) (defcustom projectile-sort-order 'default "The sort order used for a project's files. Note that files aren't sorted if `projectile-indexing-method' is set to 'alien'." :group 'projectile :type '(radio (const :tag "Default (no sorting)" default) (const :tag "Recently opened files" recentf) (const :tag "Recently active buffers, then recently opened files" recently-active) (const :tag "Access time (atime)" access-time) (const :tag "Modification time (mtime)" modification-time))) (defcustom projectile-verbose t "Echo messages that are not errors." :group 'projectile :type 'boolean) (defcustom projectile-buffers-filter-function nil "A function used to filter the buffers in `projectile-project-buffers'. The function should accept and return a list of Emacs buffers. Two example filter functions are shipped by default - `projectile-buffers-with-file' and `projectile-buffers-with-file-or-process'." :group 'projectile :type 'function) (defcustom projectile-project-name nil "If this value is non-nil, it will be used as project name. It has precedence over function `projectile-project-name-function'." :group 'projectile :type 'string :package-version '(projectile . "0.14.0")) (defcustom projectile-project-name-function 'projectile-default-project-name "A function that receives the project-root and returns the project name. If variable `projectile-project-name' is non-nil, this function will not be used." :group 'projectile :type 'function :package-version '(projectile . "0.14.0")) (defcustom projectile-project-root-files '( "GTAGS" ; GNU Global tags "TAGS" ; etags/ctags are usually in the root of project "configure.ac" ; autoconf new style "configure.in" ; autoconf old style "cscope.out" ; cscope ) "A list of files considered to mark the root of a project. The topmost match has precedence. See `projectile-register-project-type'." :group 'projectile :type '(repeat string)) (defcustom projectile-project-root-files-bottom-up '(".projectile" ; projectile project marker ".git" ; Git VCS root dir ".hg" ; Mercurial VCS root dir ".fslckout" ; Fossil VCS root dir "_FOSSIL_" ; Fossil VCS root DB on Windows ".bzr" ; Bazaar VCS root dir "_darcs" ; Darcs VCS root dir ) "A list of files considered to mark the root of a project. The bottommost (parentmost) match has precedence." :group 'projectile :type '(repeat string)) (defcustom projectile-project-root-files-top-down-recurring '(".svn" ; Svn VCS root dir "CVS" ; Csv VCS root dir "Makefile") "A list of files considered to mark the root of a project. The search starts at the top and descends down till a directory that contains a match file but its parent does not. Thus, it's a bottommost match in the topmost sequence of directories containing a root file." :group 'projectile :type '(repeat string)) (define-obsolete-variable-alias 'projectile-project-root-files-functions 'projectile-project-root-functions "2.4") (defcustom projectile-project-root-functions '(projectile-root-local projectile-root-bottom-up projectile-root-top-down projectile-root-top-down-recurring) "A list of functions for finding project root folders. The functions will be ran until one of them returns a project folder. Reordering the default functions will alter the project discovery algorithm." :group 'projectile :type '(repeat function)) (defcustom projectile-dirconfig-comment-prefix nil "Projectile config file (.projectile) comment start marker. If specified, starting a line in a project's .projectile file with this character marks that line as a comment instead of a pattern. Similar to '#' in .gitignore files." :group 'projectile :type 'character :package-version '(projectile . "2.2.0")) (defcustom projectile-globally-ignored-files (list projectile-tags-file-name) "A list of files globally ignored by projectile. Note that files aren't filtered if `projectile-indexing-method' is set to 'alien'." :group 'projectile :type '(repeat string)) (defcustom projectile-globally-unignored-files nil "A list of files globally unignored by projectile. Regular expressions can be used. Note that files aren't filtered if `projectile-indexing-method' is set to 'alien'." :group 'projectile :type '(repeat string) :package-version '(projectile . "0.14.0")) (defcustom projectile-globally-ignored-file-suffixes nil "A list of file suffixes globally ignored by projectile. Note that files aren't filtered if `projectile-indexing-method' is set to 'alien'." :group 'projectile :type '(repeat string)) (defcustom projectile-globally-ignored-directories '(".idea" ".vscode" ".ensime_cache" ".eunit" ".git" ".hg" ".fslckout" "_FOSSIL_" ".bzr" "_darcs" ".tox" ".svn" ".stack-work" ".ccls-cache" ".cache" ".clangd") "A list of directories globally ignored by projectile. Regular expressions can be used. Strings that don't start with * are only ignored at the top level of the project. Strings that start with * are ignored everywhere in the project, as if there was no *. So note that * when used as a prefix is not a wildcard; it is an indicator that the directory should be ignored at all levels, not just root. Examples: \"tmp\" ignores only ./tmp at the top level of the project, but not ./src/tmp. \"*tmp\" will ignore both ./tmp and ./src/tmp, but not ./not-a-tmp or ./src/not-a-tmp. Note that files aren't filtered if `projectile-indexing-method' is set to 'alien'." :safe (lambda (x) (not (remq t (mapcar #'stringp x)))) :group 'projectile :type '(repeat string)) (defcustom projectile-globally-unignored-directories nil "A list of directories globally unignored by projectile. Note that files aren't filtered if `projectile-indexing-method' is set to 'alien'." :group 'projectile :type '(repeat string) :package-version '(projectile . "0.14.0")) (defcustom projectile-globally-ignored-modes '("erc-mode" "help-mode" "completion-list-mode" "Buffer-menu-mode" "gnus-.*-mode" "occur-mode") "A list of regular expressions for major modes ignored by projectile. If a buffer is using a given major mode, projectile will ignore it for functions working with buffers." :group 'projectile :type '(repeat string)) (defcustom projectile-globally-ignored-buffers nil "A list of buffer-names ignored by projectile. You can use either exact buffer names or regular expressions. If a buffer is in the list projectile will ignore it for functions working with buffers." :group 'projectile :type '(repeat string) :package-version '(projectile . "0.12.0")) (defcustom projectile-find-file-hook nil "Hooks run when a file is opened with `projectile-find-file'." :group 'projectile :type 'hook) (defcustom projectile-find-dir-hook nil "Hooks run when a directory is opened with `projectile-find-dir'." :group 'projectile :type 'hook) (defcustom projectile-switch-project-action 'projectile-find-file "Action invoked after switching projects with `projectile-switch-project'. Any function that does not take arguments will do." :group 'projectile :type 'function) (defcustom projectile-find-dir-includes-top-level nil "If true, add top-level dir to options offered by `projectile-find-dir'." :group 'projectile :type 'boolean) (defcustom projectile-use-git-grep nil "If true, use `vc-git-grep' in git projects." :group 'projectile :type 'boolean) (defcustom projectile-grep-finished-hook nil "Hooks run when `projectile-grep' finishes." :group 'projectile :type 'hook :package-version '(projectile . "0.14.0")) (defcustom projectile-test-prefix-function 'projectile-test-prefix "Function to find test files prefix based on PROJECT-TYPE." :group 'projectile :type 'function) (defcustom projectile-test-suffix-function 'projectile-test-suffix "Function to find test files suffix based on PROJECT-TYPE." :group 'projectile :type 'function) (defcustom projectile-related-files-fn-function 'projectile-related-files-fn "Function to find related files based on PROJECT-TYPE." :group 'projectile :type 'function) (defcustom projectile-dynamic-mode-line t "If true, update the mode-line dynamically. Only file buffers are affected by this, as the update happens via `find-file-hook'. See also `projectile-mode-line-function' and `projectile-update-mode-line'." :group 'projectile :type 'boolean :package-version '(projectile . "2.0.0")) (defcustom projectile-mode-line-function 'projectile-default-mode-line "The function to use to generate project-specific mode-line. The default function adds the project name and type to the mode-line. See also `projectile-update-mode-line'." :group 'projectile :type 'function :package-version '(projectile . "2.0.0")) ;;; Idle Timer (defvar projectile-idle-timer nil "The timer object created when `projectile-enable-idle-timer' is non-nil.") (defcustom projectile-idle-timer-seconds 30 "The idle period to use when `projectile-enable-idle-timer' is non-nil." :group 'projectile :type 'number) (defcustom projectile-idle-timer-hook '(projectile-regenerate-tags) "The hook run when `projectile-enable-idle-timer' is non-nil." :group 'projectile :type '(repeat symbol)) (defcustom projectile-enable-idle-timer nil "Enables idle timer hook `projectile-idle-timer-functions'. When `projectile-enable-idle-timer' is non-nil, the hook `projectile-idle-timer-hook' is run each time Emacs has been idle for `projectile-idle-timer-seconds' seconds and we're in a project." :group 'projectile :set (lambda (symbol value) (set symbol value) (when projectile-idle-timer (cancel-timer projectile-idle-timer)) (setq projectile-idle-timer nil) (when projectile-enable-idle-timer (setq projectile-idle-timer (run-with-idle-timer projectile-idle-timer-seconds t (lambda () (when (projectile-project-p) (run-hooks 'projectile-idle-timer-hook))))))) :type 'boolean) (defvar projectile-projects-cache nil "A hashmap used to cache project file names to speed up related operations.") (defvar projectile-projects-cache-time nil "A hashmap used to record when we populated `projectile-projects-cache'.") (defvar projectile-project-root-cache (make-hash-table :test 'equal) "Cached value of function `projectile-project-root`.") (defvar projectile-project-type-cache (make-hash-table :test 'equal) "A hashmap used to cache project type to speed up related operations.") (defvar projectile-known-projects nil "List of locations where we have previously seen projects. The list of projects is ordered by the time they have been accessed. See also `projectile-remove-known-project', `projectile-cleanup-known-projects' and `projectile-clear-known-projects'.") (defvar projectile-known-projects-on-file nil "List of known projects reference point. Contains a copy of `projectile-known-projects' when it was last synchronized with `projectile-known-projects-file'.") (defcustom projectile-known-projects-file (expand-file-name "projectile-bookmarks.eld" user-emacs-directory) "Name and location of the Projectile's known projects file." :group 'projectile :type 'string) (defcustom projectile-ignored-projects nil "A list of projects not to be added to `projectile-known-projects'." :group 'projectile :type '(repeat :tag "Project list" directory) :package-version '(projectile . "0.11.0")) (defcustom projectile-ignored-project-function nil "Function to decide if a project is added to `projectile-known-projects'. Can be either nil, or a function that takes the truename of the project root as argument and returns non-nil if the project is to be ignored or nil otherwise. This function is only called if the project is not listed in `projectile-ignored-projects'. A suitable candidate would be `file-remote-p' to ignore remote projects." :group 'projectile :type '(choice (const :tag "Nothing" nil) (const :tag "Remote files" file-remote-p) function) :package-version '(projectile . "0.13.0")) (defcustom projectile-track-known-projects-automatically t "Controls whether Projectile will automatically register known projects. When set to nil you'll have always add projects explicitly with `projectile-add-known-project'." :group 'projectile :type 'boolean :package-version '(projectile . "1.0.0")) (defcustom projectile-project-search-path nil "List of folders where projectile is automatically going to look for projects. You can think of something like $PATH, but for projects instead of executables. Examples of such paths might be ~/projects, ~/work, etc." :group 'projectile :type '(repeat directory) :package-version '(projectile . "1.0.0")) (defcustom projectile-git-command "git ls-files -zco --exclude-standard" "Command used by projectile to get the files in a git project." :group 'projectile :type 'string) (defcustom projectile-git-submodule-command "git submodule --quiet foreach 'echo $displaypath' | tr '\\n' '\\0'" "Command used by projectile to list submodules of a given git repository. Set to nil to disable listing submodules contents." :group 'projectile :type 'string) (defcustom projectile-git-ignored-command "git ls-files -zcoi --exclude-standard" "Command used by projectile to get the ignored files in a git project." :group 'projectile :type 'string :package-version '(projectile . "0.14.0")) (defcustom projectile-hg-command "hg locate -f -0 -I ." "Command used by projectile to get the files in a hg project." :group 'projectile :type 'string) (defcustom projectile-fossil-command (concat "fossil ls | " (when (string-equal system-type "windows-nt") "dos2unix | ") "tr '\\n' '\\0'") "Command used by projectile to get the files in a fossil project." :group 'projectile :type 'string) (defcustom projectile-bzr-command "bzr ls -R --versioned -0" "Command used by projectile to get the files in a bazaar project." :group 'projectile :type 'string) (defcustom projectile-darcs-command "darcs show files -0 . " "Command used by projectile to get the files in a darcs project." :group 'projectile :type 'string) (defcustom projectile-svn-command "svn list -R . | grep -v '$/' | tr '\\n' '\\0'" "Command used by projectile to get the files in a svn project." :group 'projectile :type 'string) (defcustom projectile-generic-command (if (executable-find "fd") "fd . -0 --type f --color=never" "find . -type f -print0") "Command used by projectile to get the files in a generic project." :group 'projectile :type 'string) (defcustom projectile-vcs-dirty-state '("edited" "unregistered" "needs-update" "needs-merge" "unlocked-changes" "conflict") "List of states checked by `projectile-browse-dirty-projects'. Possible checked states are: \"edited\", \"unregistered\", \"needs-update\", \"needs-merge\", \"unlocked-changes\" and \"conflict\", as defined in `vc.el'." :group 'projectile :type '(repeat (string)) :package-version '(projectile . "1.0.0")) (defcustom projectile-other-file-alist '( ;; handle C/C++ extensions ("cpp" . ("h" "hpp" "ipp")) ("ipp" . ("h" "hpp" "cpp")) ("hpp" . ("h" "ipp" "cpp" "cc")) ("cxx" . ("h" "hxx" "ixx")) ("ixx" . ("h" "hxx" "cxx")) ("hxx" . ("h" "ixx" "cxx")) ("c" . ("h")) ("m" . ("h")) ("mm" . ("h")) ("h" . ("c" "cc" "cpp" "ipp" "hpp" "cxx" "ixx" "hxx" "m" "mm")) ("cc" . ("h" "hh" "hpp")) ("hh" . ("cc")) ;; OCaml extensions ("ml" . ("mli")) ("mli" . ("ml" "mll" "mly")) ("mll" . ("mli")) ("mly" . ("mli")) ("eliomi" . ("eliom")) ("eliom" . ("eliomi")) ;; vertex shader and fragment shader extensions in glsl ("vert" . ("frag")) ("frag" . ("vert")) ;; handle files with no extension (nil . ("lock" "gpg")) ("lock" . ("")) ("gpg" . ("")) ) "Alist of extensions for switching to file with the same name, using other extensions based on the extension of current file." :type 'alist) (defcustom projectile-create-missing-test-files nil "During toggling, if non-nil enables creating test files if not found. When not-nil, every call to projectile-find-implementation-or-test-* creates test files if not found on the file system. Defaults to nil. It assumes the test/ folder is at the same level as src/." :group 'projectile :type 'boolean) (defcustom projectile-after-switch-project-hook nil "Hooks run right after project is switched." :group 'projectile :type 'hook) (defcustom projectile-before-switch-project-hook nil "Hooks run when right before project is switched." :group 'projectile :type 'hook) (defcustom projectile-current-project-on-switch 'remove "Determines whether to display current project when switching projects. When set to 'remove current project is not included, 'move-to-end will display current project and the end of the list of known projects, 'keep will leave the current project at the default position." :group 'projectile :type '(radio (const :tag "Remove" remove) (const :tag "Move to end" move-to-end) (const :tag "Keep" keep))) (defcustom projectile-max-file-buffer-count nil "Maximum number of file buffers per project that are kept open. If the value is nil, there is no limit to the opend buffers count." :group 'projectile :type 'integer :package-version '(projectile . "2.2.0")) ;;; Version information ;;;###autoload (defun projectile-version (&optional show-version) "Get the Projectile version as string. If called interactively or if SHOW-VERSION is non-nil, show the version in the echo area and the messages buffer. The returned string includes both, the version from package.el and the library version, if both a present and different. If the version number could not be determined, signal an error, if called interactively, or if SHOW-VERSION is non-nil, otherwise just return nil." (interactive (list t)) (if (require 'pkg-info nil t) (let ((version (pkg-info-version-info 'projectile))) (when show-version (message "Projectile %s" version)) version) (error "Cannot determine version without package pkg-info"))) ;;; Misc utility functions (defun projectile-difference (list1 list2) (cl-remove-if (lambda (x) (member x list2)) list1)) (defun projectile-unixy-system-p () "Check to see if unixy text utilities are installed." (cl-every (lambda (x) (executable-find x)) '("grep" "cut" "uniq"))) (defun projectile-symbol-or-selection-at-point () "Get the symbol or selected text at point." (if (use-region-p) (buffer-substring-no-properties (region-beginning) (region-end)) (projectile-symbol-at-point))) (defun projectile-symbol-at-point () "Get the symbol at point and strip its properties." (substring-no-properties (or (thing-at-point 'symbol) ""))) (defun projectile-generate-process-name (process make-new &optional project) "Infer the buffer name for PROCESS or generate a new one if MAKE-NEW is true. The function operates on the current project by default, but you can also specify a project explicitly via the optional PROJECT param." (let* ((project (or project (projectile-acquire-root))) (base-name (format "*%s %s*" process (projectile-project-name project)))) (if make-new (generate-new-buffer-name base-name) base-name))) ;;; Serialization (defun projectile-serialize (data filename) "Serialize DATA to FILENAME. The saved data can be restored with `projectile-unserialize'." (when (file-writable-p filename) (with-temp-file filename (insert (let (print-length) (prin1-to-string data)))))) (defun projectile-unserialize (filename) "Read data serialized by `projectile-serialize' from FILENAME." (with-demoted-errors "Error during file deserialization: %S" (when (file-exists-p filename) (with-temp-buffer (insert-file-contents filename) ;; this will blow up if the contents of the file aren't ;; lisp data structures (read (buffer-string)))))) ;;; Caching (defvar projectile-file-exists-cache (make-hash-table :test 'equal) "Cached `projectile-file-exists-p' results.") (defvar projectile-file-exists-cache-timer nil "Timer for scheduling`projectile-file-exists-cache-cleanup'.") (defun projectile-file-exists-cache-cleanup () "Removed timed out cache entries and reschedules or remove the timer if no more items are in the cache." (let ((now (current-time))) (maphash (lambda (key value) (if (time-less-p (cdr value) now) (remhash key projectile-file-exists-cache))) projectile-file-exists-cache) (setq projectile-file-exists-cache-timer (if (> (hash-table-count projectile-file-exists-cache) 0) (run-with-timer 10 nil 'projectile-file-exists-cache-cleanup))))) (defun projectile-file-exists-p (filename) "Return t if file FILENAME exist. A wrapper around `file-exists-p' with additional caching support." (let* ((file-remote (file-remote-p filename)) (expire-seconds (if file-remote (and projectile-file-exists-remote-cache-expire (> projectile-file-exists-remote-cache-expire 0) projectile-file-exists-remote-cache-expire) (and projectile-file-exists-local-cache-expire (> projectile-file-exists-local-cache-expire 0) projectile-file-exists-local-cache-expire))) (remote-file-name-inhibit-cache (if expire-seconds expire-seconds remote-file-name-inhibit-cache))) (if (not expire-seconds) (file-exists-p filename) (let* ((current-time (current-time)) (cached (gethash filename projectile-file-exists-cache)) (cached-value (if cached (car cached))) (cached-expire (if cached (cdr cached))) (cached-expired (if cached (time-less-p cached-expire current-time) t)) (value (or (and (not cached-expired) cached-value) (if (file-exists-p filename) 'found 'notfound)))) (when (or (not cached) cached-expired) (puthash filename (cons value (time-add current-time (seconds-to-time expire-seconds))) projectile-file-exists-cache)) (unless projectile-file-exists-cache-timer (setq projectile-file-exists-cache-timer (run-with-timer 10 nil 'projectile-file-exists-cache-cleanup))) (equal value 'found))))) ;;;###autoload (defun projectile-invalidate-cache (prompt) "Remove the current project's files from `projectile-projects-cache'. With a prefix argument PROMPT prompts for the name of the project whose cache to invalidate." (interactive "P") (let ((project-root (if prompt (completing-read "Remove cache for: " (hash-table-keys projectile-projects-cache)) (projectile-acquire-root)))) (setq projectile-project-root-cache (make-hash-table :test 'equal)) (remhash project-root projectile-project-type-cache) (remhash project-root projectile-projects-cache) (remhash project-root projectile-projects-cache-time) (projectile-serialize-cache) (when projectile-verbose (message "Invalidated Projectile cache for %s." (propertize project-root 'face 'font-lock-keyword-face)))) (when (fboundp 'recentf-cleanup) (recentf-cleanup))) (defun projectile-time-seconds () "Return the number of seconds since the unix epoch." (cl-destructuring-bind (high low _usec _psec) (current-time) (+ (lsh high 16) low))) (defun projectile-cache-project (project files) "Cache PROJECTs FILES. The cache is created both in memory and on the hard drive." (when projectile-enable-caching (puthash project files projectile-projects-cache) (puthash project (projectile-time-seconds) projectile-projects-cache-time) (projectile-serialize-cache))) ;;;###autoload (defun projectile-purge-file-from-cache (file) "Purge FILE from the cache of the current project." (interactive (list (projectile-completing-read "Remove file from cache: " (projectile-current-project-files)))) (let* ((project-root (projectile-project-root)) (project-cache (gethash project-root projectile-projects-cache))) (if (projectile-file-cached-p file project-root) (progn (puthash project-root (remove file project-cache) projectile-projects-cache) (projectile-serialize-cache) (when projectile-verbose (message "%s removed from cache" file))) (error "%s is not in the cache" file)))) ;;;###autoload (defun projectile-purge-dir-from-cache (dir) "Purge DIR from the cache of the current project." (interactive (list (projectile-completing-read "Remove directory from cache: " (projectile-current-project-dirs)))) (let* ((project-root (projectile-project-root)) (project-cache (gethash project-root projectile-projects-cache))) (puthash project-root (cl-remove-if (lambda (str) (string-prefix-p dir str)) project-cache) projectile-projects-cache))) (defun projectile-file-cached-p (file project) "Check if FILE is already in PROJECT cache." (member file (gethash project projectile-projects-cache))) ;;;###autoload (defun projectile-cache-current-file () "Add the currently visited file to the cache." (interactive) (let ((current-project (projectile-project-root))) (when (and (buffer-file-name) (gethash (projectile-project-root) projectile-projects-cache)) (let* ((abs-current-file (file-truename (buffer-file-name))) (current-file (file-relative-name abs-current-file current-project))) (unless (or (projectile-file-cached-p current-file current-project) (projectile-ignored-directory-p (file-name-directory abs-current-file)) (projectile-ignored-file-p abs-current-file)) (puthash current-project (cons current-file (gethash current-project projectile-projects-cache)) projectile-projects-cache) (projectile-serialize-cache) (message "File %s added to project %s cache." (propertize current-file 'face 'font-lock-keyword-face) (propertize current-project 'face 'font-lock-keyword-face))))))) ;; cache opened files automatically to reduce the need for cache invalidation (defun projectile-cache-files-find-file-hook () "Function for caching files with `find-file-hook'." (let ((project-root (projectile-project-p))) (when (and projectile-enable-caching project-root (not (projectile-ignored-project-p project-root))) (projectile-cache-current-file)))) (defun projectile-track-known-projects-find-file-hook () "Function for caching projects with `find-file-hook'." (when (and projectile-track-known-projects-automatically (projectile-project-p)) (projectile-add-known-project (projectile-project-root)))) (defun projectile-maybe-invalidate-cache (force) "Invalidate if FORCE or project's dirconfig newer than cache." (when (or force (file-newer-than-file-p (projectile-dirconfig-file) projectile-cache-file)) (projectile-invalidate-cache nil))) ;;;###autoload (defun projectile-discover-projects-in-directory (directory) "Discover any projects in DIRECTORY and add them to the projectile cache. This function is not recursive and only adds projects with roots at the top level of DIRECTORY." (interactive (list (read-directory-name "Starting directory: "))) (if (file-exists-p directory) (let ((subdirs (directory-files directory t))) (mapcar (lambda (dir) (when (and (file-directory-p dir) (not (member (file-name-nondirectory dir) '(".." ".")))) (when (projectile-project-p dir) (projectile-add-known-project dir)))) subdirs)) (message "Project search path directory %s doesn't exist" directory))) ;;;###autoload (defun projectile-discover-projects-in-search-path () "Discover projects in `projectile-project-search-path'. Invoked automatically when `projectile-mode' is enabled." (interactive) (mapcar #'projectile-discover-projects-in-directory projectile-project-search-path)) (defun delete-file-projectile-remove-from-cache (filename &optional _trash) (if (and projectile-enable-caching projectile-auto-update-cache (projectile-project-p)) (let* ((project-root (projectile-project-root)) (true-filename (file-truename filename)) (relative-filename (file-relative-name true-filename project-root))) (if (projectile-file-cached-p relative-filename project-root) (projectile-purge-file-from-cache relative-filename))))) ;;; Project root related utilities (defun projectile-parent (path) "Return the parent directory of PATH. PATH may be a file or directory and directory paths may end with a slash." (directory-file-name (file-name-directory (directory-file-name (expand-file-name path))))) (defun projectile-locate-dominating-file (file name) "Look up the directory hierarchy from FILE for a directory containing NAME. Stop at the first parent directory containing a file NAME, and return the directory. Return nil if not found. Instead of a string, NAME can also be a predicate taking one argument \(a directory) and returning a non-nil value if that directory is the one for which we're looking." ;; copied from files.el (stripped comments) emacs-24 bzr branch 2014-03-28 10:20 (setq file (abbreviate-file-name file)) (let ((root nil) try) (while (not (or root (null file) (string-match locate-dominating-stop-dir-regexp file))) (setq try (if (stringp name) (projectile-file-exists-p (expand-file-name name file)) (funcall name file))) (cond (try (setq root file)) ((equal file (setq file (file-name-directory (directory-file-name file)))) (setq file nil)))) (and root (expand-file-name (file-name-as-directory root))))) (defvar-local projectile-project-root nil "Defines a custom Projectile project root. This is intended to be used as a file local variable.") (defun projectile-root-local (_dir) "A simple wrapper around `projectile-project-root'." projectile-project-root) (defun projectile-root-top-down (dir &optional list) "Identify a project root in DIR by top-down search for files in LIST. If LIST is nil, use `projectile-project-root-files' instead. Return the first (topmost) matched directory or nil if not found." (projectile-locate-dominating-file dir (lambda (dir) (cl-find-if (lambda (f) (projectile-file-exists-p (expand-file-name f dir))) (or list projectile-project-root-files))))) (defun projectile-root-bottom-up (dir &optional list) "Identify a project root in DIR by bottom-up search for files in LIST. If LIST is nil, use `projectile-project-root-files-bottom-up' instead. Return the first (bottommost) matched directory or nil if not found." (cl-some (lambda (name) (projectile-locate-dominating-file dir name)) (or list projectile-project-root-files-bottom-up))) (defun projectile-root-top-down-recurring (dir &optional list) "Identify a project root in DIR by recurring top-down search for files in LIST. If LIST is nil, use `projectile-project-root-files-top-down-recurring' instead. Return the last (bottommost) matched directory in the topmost sequence of matched directories. Nil otherwise." (cl-some (lambda (f) (projectile-locate-dominating-file dir (lambda (dir) (and (projectile-file-exists-p (expand-file-name f dir)) (or (string-match locate-dominating-stop-dir-regexp (projectile-parent dir)) (not (projectile-file-exists-p (expand-file-name f (projectile-parent dir))))))))) (or list projectile-project-root-files-top-down-recurring))) (defun projectile-project-root (&optional dir) "Retrieves the root directory of a project if available. If DIR is not supplied its set to the current directory by default." ;; the cached value will be 'none in the case of no project root (this is to ;; ensure it is not reevaluated each time when not inside a project) so use ;; cl-subst to replace this 'none value with nil so a nil value is used ;; instead (let ((dir (or dir default-directory))) ;; Back out of any archives, the project will live on the outside and ;; searching them is slow. (when (and (fboundp 'tramp-archive-file-name-archive) (tramp-archive-file-name-p dir)) (setq dir (file-name-directory (tramp-archive-file-name-archive dir)))) (cl-subst nil 'none ;; The `is-local' and `is-connected' variables are ;; used to fix the behavior where Emacs hangs ;; because of Projectile when you open a file over ;; TRAMP. It basically prevents Projectile from ;; trying to find information about files for which ;; it's not possible to get that information right ;; now. (or (let ((is-local (not (file-remote-p dir))) ;; `true' if the file is local (is-connected (file-remote-p dir nil t))) ;; `true' if the file is remote AND we are connected to the remote (when (or is-local is-connected) ;; Here is where all the magic happens. ;; We run the functions in `projectile-project-root-functions' until we find a project dir. (cl-some (lambda (func) (let* ((cache-key (format "%s-%s" func dir)) (cache-value (gethash cache-key projectile-project-root-cache))) (if (and cache-value (file-exists-p cache-value)) cache-value (let ((value (funcall func (file-truename dir)))) (puthash cache-key value projectile-project-root-cache) value)))) projectile-project-root-functions))) ;; set cached to none so is non-nil so we don't try ;; and look it up again 'none)))) (defun projectile-ensure-project (dir) "Ensure that DIR is non-nil. Useful for commands that expect the presence of a project. Controlled by `projectile-require-project-root'. See also `projectile-acquire-root'." (if dir dir (cond ((eq projectile-require-project-root 'prompt) (projectile-completing-read "Switch to project: " projectile-known-projects)) (projectile-require-project-root (error "Projectile cannot find a project definition in %s" default-directory)) (t default-directory)))) (defun projectile-acquire-root (&optional dir) "Find the current project root, and prompts the user for it if that fails. Provides the common idiom (projectile-ensure-project (projectile-project-root)). Starts the search for the project with DIR." (projectile-ensure-project (projectile-project-root dir))) (defun projectile-project-p (&optional dir) "Check if DIR is a project. Defaults to the current directory if not provided explicitly." (projectile-project-root (or dir default-directory))) (defun projectile-default-project-name (project-root) "Default function used create project name to be displayed based on the value of PROJECT-ROOT." (file-name-nondirectory (directory-file-name project-root))) (defun projectile-project-name (&optional project) "Return project name. If PROJECT is not specified acts on the current project." (or projectile-project-name (let ((project-root (or project (projectile-project-root)))) (if project-root (funcall projectile-project-name-function project-root) "-")))) ;;; Project indexing (defun projectile-get-project-directories (project-dir) "Get the list of PROJECT-DIR directories that are of interest to the user." (mapcar (lambda (subdir) (concat project-dir subdir)) (or (nth 0 (projectile-parse-dirconfig-file)) '("")))) (defun projectile--directory-p (directory) "Checks if DIRECTORY is a string designating a valid directory." (and (stringp directory) (file-directory-p directory))) (defun projectile-dir-files (directory) "List the files in DIRECTORY and in its sub-directories. Files are returned as relative paths to DIRECTORY." (unless (projectile--directory-p directory) (error "Directory %S does not exist" directory)) ;; check for a cache hit first if caching is enabled (let ((files-list (and projectile-enable-caching (gethash directory projectile-projects-cache)))) ;; cache disabled or cache miss (or files-list (let ((vcs (projectile-project-vcs directory))) (pcase projectile-indexing-method ('native (projectile-dir-files-native directory)) ;; use external tools to get the project files ('hybrid (projectile-adjust-files directory vcs (projectile-dir-files-alien directory))) ('alien (projectile-dir-files-alien directory)) (_ (user-error "Unsupported indexing method `%S'" projectile-indexing-method))))))) ;;; Native Project Indexing ;; ;; This corresponds to `projectile-indexing-method' being set to native. (defun projectile-dir-files-native (directory) "Get the files for ROOT under DIRECTORY using just Emacs Lisp." (let ((progress-reporter (make-progress-reporter (format "Projectile is indexing %s" (propertize directory 'face 'font-lock-keyword-face))))) ;; we need the files with paths relative to the project root (mapcar (lambda (file) (file-relative-name file directory)) (projectile-index-directory directory (projectile-filtering-patterns) progress-reporter)))) (defun projectile-index-directory (directory patterns progress-reporter &optional ignored-files ignored-directories globally-ignored-directories) "Index DIRECTORY taking into account PATTERNS. The function calls itself recursively until all sub-directories have been indexed. The PROGRESS-REPORTER is updated while the function is executing. The list of IGNORED-FILES and IGNORED-DIRECTORIES may optionally be provided." ;; we compute the ignored files and directories only once and then we reuse the ;; pre-computed values in the subsequent recursive invocations of the function (let ((ignored-files (or ignored-files (projectile-ignored-files))) (ignored-directories (or ignored-directories (projectile-ignored-directories))) (globally-ignored-directories (or globally-ignored-directories (projectile-globally-ignored-directory-names)))) (apply #'append (mapcar (lambda (f) (let ((local-f (file-name-nondirectory (directory-file-name f)))) (unless (or (and patterns (projectile-ignored-rel-p f directory patterns)) (member local-f '("." ".."))) (progress-reporter-update progress-reporter) (if (file-directory-p f) (unless (projectile-ignored-directory-p (file-name-as-directory f) ignored-directories local-f globally-ignored-directories) (projectile-index-directory f patterns progress-reporter ignored-files ignored-directories globally-ignored-directories)) (unless (projectile-ignored-file-p f ignored-files) (list f)))))) (directory-files directory t))))) ;;; Alien Project Indexing ;; ;; This corresponds to `projectile-indexing-method' being set to hybrid or alien. ;; The only difference between the two methods is that alien doesn't do ;; any post-processing of the files obtained via the external command. (defun projectile-dir-files-alien (directory) "Get the files for DIRECTORY using external tools." (let ((vcs (projectile-project-vcs directory))) (cond ((eq vcs 'git) (nconc (projectile-files-via-ext-command directory (projectile-get-ext-command vcs)) (projectile-get-sub-projects-files directory vcs))) (t (projectile-files-via-ext-command directory (projectile-get-ext-command vcs)))))) (define-obsolete-function-alias 'projectile-dir-files-external 'projectile-dir-files-alien "2.0.0") (define-obsolete-function-alias 'projectile-get-repo-files 'projectile-dir-files-alien "2.0.0") (defun projectile-get-ext-command (vcs) "Determine which external command to invoke based on the project's VCS. Fallback to a generic command when not in a VCS-controlled project." (pcase vcs ('git projectile-git-command) ('hg projectile-hg-command) ('fossil projectile-fossil-command) ('bzr projectile-bzr-command) ('darcs projectile-darcs-command) ('svn projectile-svn-command) (_ projectile-generic-command))) (defun projectile-get-sub-projects-command (vcs) "Get the sub-projects command for VCS. Currently that's supported just for Git (sub-projects being Git sub-modules there)." (pcase vcs ('git projectile-git-submodule-command) (_ ""))) (defun projectile-get-ext-ignored-command (vcs) "Determine which external command to invoke based on the project's VCS." (pcase vcs ('git projectile-git-ignored-command) ;; TODO: Add support for other VCS (_ nil))) (defun projectile-flatten (lst) "Take a nested list LST and return its contents as a single, flat list." (if (and (listp lst) (listp (cdr lst))) (cl-mapcan 'projectile-flatten lst) (list lst))) (defun projectile-get-all-sub-projects (project) "Get all sub-projects for a given project. PROJECT is base directory to start search recursively." (let ((submodules (projectile-get-immediate-sub-projects project))) (cond ((null submodules) nil) (t (nconc submodules (projectile-flatten ;; recursively get sub-projects of each sub-project (mapcar (lambda (s) (projectile-get-all-sub-projects s)) submodules))))))) (defun projectile-get-immediate-sub-projects (path) "Get immediate sub-projects for a given project without recursing. PATH is the vcs root or project root from which to start searching, and should end with an appropriate path delimiter, such as '/' or a '\\'. If the vcs get-sub-projects query returns results outside of path, they are excluded from the results of this function." (let* ((vcs (projectile-project-vcs path)) ;; search for sub-projects under current project `project' (submodules (mapcar (lambda (s) (file-name-as-directory (expand-file-name s path))) (projectile-files-via-ext-command path (projectile-get-sub-projects-command vcs)))) (project-child-folder-regex (concat "\\`" (regexp-quote path)))) ;; If project root is inside of an VCS folder, but not actually an ;; VCS root itself, submodules external to the project will be ;; included in the VCS get sub-projects result. Let's remove them. (cl-remove-if-not (lambda (submodule) (string-match-p project-child-folder-regex submodule)) submodules))) (defun projectile-get-sub-projects-files (project-root _vcs) "Get files from sub-projects for PROJECT-ROOT recursively." (projectile-flatten (mapcar (lambda (sub-project) (let ((project-relative-path (file-name-as-directory (file-relative-name sub-project project-root)))) (mapcar (lambda (file) (concat project-relative-path file)) ;; TODO: Seems we forgot git hardcoded here (projectile-files-via-ext-command sub-project projectile-git-command)))) (projectile-get-all-sub-projects project-root)))) (defun projectile-get-repo-ignored-files (project vcs) "Get a list of the files ignored in the PROJECT using VCS." (let ((cmd (projectile-get-ext-ignored-command vcs))) (when cmd (projectile-files-via-ext-command project cmd)))) (defun projectile-get-repo-ignored-directory (project dir vcs) "Get a list of the files ignored in the PROJECT in the directory DIR. VCS is the VCS of the project." (let ((cmd (projectile-get-ext-ignored-command vcs))) (when cmd (projectile-files-via-ext-command project (concat cmd " " dir))))) (defun projectile-files-via-ext-command (root command) "Get a list of relative file names in the project ROOT by executing COMMAND. If `command' is nil or an empty string, return nil. This allows commands to be disabled. Only text sent to standard output is taken into account." (when (stringp command) (let ((default-directory root)) (with-temp-buffer (shell-command command t "*projectile-files-errors*") (let ((shell-output (buffer-substring (point-min) (point-max)))) (split-string (string-trim shell-output) "\0" t)))))) (defun projectile-adjust-files (project vcs files) "First remove ignored files from FILES, then add back unignored files." (projectile-add-unignored project vcs (projectile-remove-ignored files))) (defun projectile-remove-ignored (files) "Remove ignored files and folders from FILES. If ignored directory prefixed with '*', then ignore all directories/subdirectories with matching filename, otherwise operates relative to project root." (let ((ignored-files (projectile-ignored-files-rel)) (ignored-dirs (projectile-ignored-directories-rel))) (cl-remove-if (lambda (file) (or (cl-some (lambda (f) (string= f (file-name-nondirectory file))) ignored-files) (cl-some (lambda (dir) ;; if the directory is prefixed with '*' then ignore all directories matching that name (if (string-prefix-p "*" dir) ;; remove '*' and trailing slash from ignored directory name (let ((d (substring dir 1 (if (equal (substring dir -1) "/") -1 nil)))) (cl-some (lambda (p) (string= d p)) ;; split path by '/', remove empty strings, and check if any subdirs match name 'd' (delete "" (split-string (or (file-name-directory file) "") "/")))) (string-prefix-p dir file))) ignored-dirs) (cl-some (lambda (suf) (string-suffix-p suf file t)) projectile-globally-ignored-file-suffixes))) files))) (defun projectile-keep-ignored-files (project vcs files) "Filter FILES to retain only those that are ignored." (when files (cl-remove-if-not (lambda (file) (cl-some (lambda (f) (string-prefix-p f file)) files)) (projectile-get-repo-ignored-files project vcs)))) (defun projectile-keep-ignored-directories (project vcs directories) "Get ignored files within each of DIRECTORIES." (when directories (let (result) (dolist (dir directories result) (setq result (append result (projectile-get-repo-ignored-directory project dir vcs)))) result))) (defun projectile-add-unignored (project vcs files) "This adds unignored files to FILES. Useful because the VCS may not return ignored files at all. In this case unignored files will be absent from FILES." (let ((unignored-files (projectile-keep-ignored-files project vcs (projectile-unignored-files-rel))) (unignored-paths (projectile-remove-ignored (projectile-keep-ignored-directories project vcs (projectile-unignored-directories-rel))))) (append files unignored-files unignored-paths))) (defun projectile-buffers-with-file (buffers) "Return only those BUFFERS backed by files." (cl-remove-if-not (lambda (b) (buffer-file-name b)) buffers)) (defun projectile-buffers-with-file-or-process (buffers) "Return only those BUFFERS backed by files or processes." (cl-remove-if-not (lambda (b) (or (buffer-file-name b) (get-buffer-process b))) buffers)) (defun projectile-project-buffers (&optional project) "Get a list of a project's buffers. If PROJECT is not specified the command acts on the current project." (let* ((project-root (or project (projectile-acquire-root))) (all-buffers (cl-remove-if-not (lambda (buffer) (projectile-project-buffer-p buffer project-root)) (buffer-list)))) (if projectile-buffers-filter-function (funcall projectile-buffers-filter-function all-buffers) all-buffers))) (defun projectile-process-current-project-buffers (action) "Process the current project's buffers using ACTION." (let ((project-buffers (projectile-project-buffers))) (dolist (buffer project-buffers) (funcall action buffer)))) (defun projectile-process-current-project-buffers-current (action) "Invoke ACTION on every project buffer with that buffer current. ACTION is called without arguments." (let ((project-buffers (projectile-project-buffers))) (dolist (buffer project-buffers) (with-current-buffer buffer (funcall action))))) (defun projectile-project-buffer-files (&optional project) "Get a list of a project's buffer files. If PROJECT is not specified the command acts on the current project." (let ((project-root (or project (projectile-project-root)))) (mapcar (lambda (buffer) (file-relative-name (buffer-file-name buffer) project-root)) (projectile-buffers-with-file (projectile-project-buffers project))))) (defun projectile-project-buffer-p (buffer project-root) "Check if BUFFER is under PROJECT-ROOT." (with-current-buffer buffer (and (not (string-prefix-p " " (buffer-name buffer))) (not (projectile-ignored-buffer-p buffer)) default-directory (string-equal (file-remote-p default-directory) (file-remote-p project-root)) (not (string-match-p "^http\\(s\\)?://" default-directory)) (string-prefix-p project-root (file-truename default-directory) (eq system-type 'windows-nt))))) (defun projectile-ignored-buffer-p (buffer) "Check if BUFFER should be ignored. Regular expressions can be use." (or (with-current-buffer buffer (cl-some (lambda (name) (string-match-p name (buffer-name))) projectile-globally-ignored-buffers)) (with-current-buffer buffer (cl-some (lambda (mode) (string-match-p (concat "^" mode "$") (symbol-name major-mode))) projectile-globally-ignored-modes)))) (defun projectile-recently-active-files () "Get list of recently active files. Files are ordered by recently active buffers, and then recently opened through use of recentf." (let ((project-buffer-files (projectile-project-buffer-files))) (append project-buffer-files (projectile-difference (projectile-recentf-files) project-buffer-files)))) (defun projectile-project-buffer-names () "Get a list of project buffer names." (mapcar #'buffer-name (projectile-project-buffers))) (defun projectile-prepend-project-name (string) "Prepend the current project's name to STRING." (format "[%s] %s" (projectile-project-name) string)) (defun projectile-read-buffer-to-switch (prompt) "Read the name of a buffer to switch to, prompting with PROMPT. This function excludes the current buffer from the offered choices." (projectile-completing-read prompt (delete (buffer-name (current-buffer)) (projectile-project-buffer-names)))) ;;;###autoload (defun projectile-switch-to-buffer () "Switch to a project buffer." (interactive) (switch-to-buffer (projectile-read-buffer-to-switch "Switch to buffer: "))) ;;;###autoload (defun projectile-switch-to-buffer-other-window () "Switch to a project buffer and show it in another window." (interactive) (switch-to-buffer-other-window (projectile-read-buffer-to-switch "Switch to buffer: "))) ;;;###autoload (defun projectile-switch-to-buffer-other-frame () "Switch to a project buffer and show it in another frame." (interactive) (switch-to-buffer-other-frame (projectile-read-buffer-to-switch "Switch to buffer: "))) ;;;###autoload (defun projectile-display-buffer () "Display a project buffer in another window without selecting it." (interactive) (display-buffer (projectile-completing-read "Display buffer: " (projectile-project-buffer-names)))) ;;;###autoload (defun projectile-project-buffers-other-buffer () "Switch to the most recently selected buffer project buffer. Only buffers not visible in windows are returned." (interactive) (switch-to-buffer (car (projectile-project-buffers-non-visible))) nil t) (defun projectile-project-buffers-non-visible () "Get a list of non visible project buffers." (cl-remove-if-not (lambda (buffer) (not (get-buffer-window buffer 'visible))) (projectile-project-buffers))) ;;;###autoload (defun projectile-multi-occur (&optional nlines) "Do a `multi-occur' in the project's buffers. With a prefix argument, show NLINES of context." (interactive "P") (let ((project (projectile-acquire-root))) (multi-occur (projectile-project-buffers project) (car (occur-read-primary-args)) nlines))) (defun projectile-normalise-paths (patterns) "Remove leading `/' from the elements of PATTERNS." (delq nil (mapcar (lambda (pat) (and (string-prefix-p "/" pat) ;; remove the leading / (substring pat 1))) patterns))) (defun projectile-expand-paths (paths) "Expand the elements of PATHS. Elements containing wildcards are expanded and spliced into the resulting paths. The returned PATHS are absolute, based on the projectile project root." (let ((default-directory (projectile-project-root))) (projectile-flatten (mapcar (lambda (pattern) (or (file-expand-wildcards pattern t) (projectile-expand-root pattern))) paths)))) (defun projectile-normalise-patterns (patterns) "Remove paths from PATTERNS." (cl-remove-if (lambda (pat) (string-prefix-p "/" pat)) patterns)) (defun projectile-make-relative-to-root (files) "Make FILES relative to the project root." (let ((project-root (projectile-project-root))) (mapcar (lambda (f) (file-relative-name f project-root)) files))) (defun projectile-ignored-directory-p (directory &optional ignored-directories local-directory globally-ignored-directories) "Check if DIRECTORY should be ignored. Regular expressions can be used. Pre-computed lists of IGNORED-DIRECTORIES and GLOBALLY-IGNORED-DIRECTORIES and the LOCAL-DIRECTORY name may optionally be provided." (let ((ignored-directories (or ignored-directories (projectile-ignored-directories))) (globally-ignored-directories (or globally-ignored-directories (projectile-globally-ignored-directory-names))) (local-directory (or local-directory (file-name-nondirectory (directory-file-name directory))))) (or (cl-some (lambda (name) (string-match-p name directory)) ignored-directories) (cl-some (lambda (name) (string-match-p name local-directory)) globally-ignored-directories)))) (defun projectile-ignored-file-p (file &optional ignored-files) "Check if FILE should be ignored. Regular expressions can be used. A pre-computed list of IGNORED-FILES may optionally be provided." (cl-some (lambda (name) (string-match-p name file)) (or ignored-files (projectile-ignored-files)))) (defun projectile-check-pattern-p (file pattern) "Check if FILE meets PATTERN." (or (string-suffix-p (directory-file-name pattern) (directory-file-name file)) (member file (file-expand-wildcards pattern t)))) (defun projectile-ignored-rel-p (file directory patterns) "Check if FILE should be ignored relative to DIRECTORY according to PATTERNS: (ignored . unignored)" (let ((default-directory directory)) (and (cl-some (lambda (pat) (projectile-check-pattern-p file pat)) (car patterns)) (cl-notany (lambda (pat) (projectile-check-pattern-p file pat)) (cdr patterns))))) (defun projectile-ignored-files () "Return list of ignored files." (projectile-difference (mapcar #'projectile-expand-root (append projectile-globally-ignored-files (projectile-project-ignored-files))) (projectile-unignored-files))) (defun projectile-globally-ignored-directory-names () "Return list of ignored directory names." (projectile-difference projectile-globally-ignored-directories projectile-globally-unignored-directories)) (defun projectile-ignored-directories () "Return list of ignored directories." (projectile-difference (mapcar #'file-name-as-directory (mapcar #'projectile-expand-root (append projectile-globally-ignored-directories (projectile-project-ignored-directories)))) (projectile-unignored-directories))) (defun projectile-ignored-directories-rel () "Return list of ignored directories, relative to the root." (projectile-make-relative-to-root (projectile-ignored-directories))) (defun projectile-ignored-files-rel () "Return list of ignored files, relative to the root." (projectile-make-relative-to-root (projectile-ignored-files))) (defun projectile-project-ignored-files () "Return list of project ignored files. Unignored files are not included." (cl-remove-if 'file-directory-p (projectile-project-ignored))) (defun projectile-project-ignored-directories () "Return list of project ignored directories. Unignored directories are not included." (cl-remove-if-not 'file-directory-p (projectile-project-ignored))) (defun projectile-paths-to-ignore () "Return a list of ignored project paths." (projectile-normalise-paths (nth 1 (projectile-parse-dirconfig-file)))) (defun projectile-patterns-to-ignore () "Return a list of relative file patterns." (projectile-normalise-patterns (nth 1 (projectile-parse-dirconfig-file)))) (defun projectile-project-ignored () "Return list of project ignored files/directories. Unignored files/directories are not included." (let ((paths (projectile-paths-to-ignore))) (projectile-expand-paths paths))) (defun projectile-unignored-files () "Return list of unignored files." (mapcar #'projectile-expand-root (append projectile-globally-unignored-files (projectile-project-unignored-files)))) (defun projectile-unignored-directories () "Return list of unignored directories." (mapcar #'file-name-as-directory (mapcar #'projectile-expand-root (append projectile-globally-unignored-directories (projectile-project-unignored-directories))))) (defun projectile-unignored-directories-rel () "Return list of unignored directories, relative to the root." (projectile-make-relative-to-root (projectile-unignored-directories))) (defun projectile-unignored-files-rel () "Return list of unignored files, relative to the root." (projectile-make-relative-to-root (projectile-unignored-files))) (defun projectile-project-unignored-files () "Return list of project unignored files." (cl-remove-if 'file-directory-p (projectile-project-unignored))) (defun projectile-project-unignored-directories () "Return list of project unignored directories." (cl-remove-if-not 'file-directory-p (projectile-project-unignored))) (defun projectile-paths-to-ensure () "Return a list of unignored project paths." (projectile-normalise-paths (nth 2 (projectile-parse-dirconfig-file)))) (defun projectile-files-to-ensure () (projectile-flatten (mapcar (lambda (pat) (file-expand-wildcards pat t)) (projectile-patterns-to-ensure)))) (defun projectile-patterns-to-ensure () "Return a list of relative file patterns." (projectile-normalise-patterns (nth 2 (projectile-parse-dirconfig-file)))) (defun projectile-filtering-patterns () (cons (projectile-patterns-to-ignore) (projectile-patterns-to-ensure))) (defun projectile-project-unignored () "Return list of project ignored files/directories." (delete-dups (append (projectile-expand-paths (projectile-paths-to-ensure)) (projectile-expand-paths (projectile-files-to-ensure))))) (defun projectile-dirconfig-file () "Return the absolute path to the project's dirconfig file." (expand-file-name ".projectile" (projectile-project-root))) (defun projectile-parse-dirconfig-file () "Parse project ignore file and return directories to ignore and keep. The return value will be a list of three elements, the car being the list of directories to keep, the cadr being the list of files or directories to ignore, and the caddr being the list of files or directories to ensure. Strings starting with + will be added to the list of directories to keep, and strings starting with - will be added to the list of directories to ignore. For backward compatibility, without a prefix the string will be assumed to be an ignore string." (let (keep ignore ensure (dirconfig (projectile-dirconfig-file))) (when (projectile-file-exists-p dirconfig) (with-temp-buffer (insert-file-contents dirconfig) (while (not (eobp)) (pcase (char-after) ;; ignore comment lines if prefix char has been set ((pred (lambda (leading-char) (and projectile-dirconfig-comment-prefix (eql leading-char projectile-dirconfig-comment-prefix)))) nil) (?+ (push (buffer-substring (1+ (point)) (line-end-position)) keep)) (?- (push (buffer-substring (1+ (point)) (line-end-position)) ignore)) (?! (push (buffer-substring (1+ (point)) (line-end-position)) ensure)) (_ (push (buffer-substring (point) (line-end-position)) ignore))) (forward-line))) (list (mapcar (lambda (f) (file-name-as-directory (string-trim f))) (delete "" (reverse keep))) (mapcar #'string-trim (delete "" (reverse ignore))) (mapcar #'string-trim (delete "" (reverse ensure))))))) (defun projectile-expand-root (name) "Expand NAME to project root. Never use on many files since it's going to recalculate the project-root for every file." (expand-file-name name (projectile-project-root))) (cl-defun projectile-completing-read (prompt choices &key initial-input action) "Present a project tailored PROMPT with CHOICES." (let ((prompt (projectile-prepend-project-name prompt)) res) (setq res (pcase (if (eq projectile-completion-system 'auto) (cond ((bound-and-true-p ido-mode) 'ido) ((bound-and-true-p helm-mode) 'helm) ((bound-and-true-p ivy-mode) 'ivy) (t 'default)) projectile-completion-system) ('default (completing-read prompt choices nil nil initial-input)) ('ido (ido-completing-read prompt choices nil nil initial-input)) ('helm (if (and (fboundp 'helm) (fboundp 'helm-make-source)) (helm :sources (helm-make-source "Projectile" 'helm-source-sync :candidates choices :action (if action (prog1 action (setq action nil)) #'identity)) :prompt prompt :input initial-input :buffer "*helm-projectile*") (user-error "Please install helm"))) ('ivy (if (fboundp 'ivy-read) (ivy-read prompt choices :initial-input initial-input :action (prog1 action (setq action nil)) :caller 'projectile-completing-read) (user-error "Please install ivy"))) (_ (funcall projectile-completion-system prompt choices)))) (if action (funcall action res) res))) (defun projectile-project-files (project-root) "Return a list of files for the PROJECT-ROOT." (let (files) ;; If the cache is too stale, don't use it. (when projectile-files-cache-expire (let ((cache-time (gethash project-root projectile-projects-cache-time))) (when (or (null cache-time) (< (+ cache-time projectile-files-cache-expire) (projectile-time-seconds))) (remhash project-root projectile-projects-cache) (remhash project-root projectile-projects-cache-time)))) ;; Use the cache, if requested and available. (when projectile-enable-caching (setq files (gethash project-root projectile-projects-cache))) ;; Calculate the list of files. (when (null files) (when projectile-enable-caching (message "Projectile is initializing cache for %s ..." project-root)) (setq files (if (eq projectile-indexing-method 'alien) ;; In alien mode we can just skip reading ;; .projectile and find all files in the root dir. (projectile-dir-files-alien project-root) ;; If a project is defined as a list of subfolders ;; then we'll have the files returned for each subfolder, ;; so they are relative to the project root. ;; ;; TODO: That's pretty slow and we need to improve it. ;; One options would be to pass explicitly the subdirs ;; to commands like `git ls-files` which would return ;; files paths relative to the project root. (cl-mapcan (lambda (dir) (mapcar (lambda (f) (file-relative-name (concat dir f) project-root)) (projectile-dir-files dir))) (projectile-get-project-directories project-root)))) ;; Save the cached list. (when projectile-enable-caching (projectile-cache-project project-root files))) ;;; Sorting ;; ;; Files can't be cached in sorted order as some sorting schemes ;; require dynamic data. Sorting is ignored completely when in ;; alien mode. (if (eq projectile-indexing-method 'alien) files (projectile-sort-files files)))) (defun projectile-current-project-files () "Return a list of the files in the current project." (projectile-project-files (projectile-acquire-root))) (defun projectile-process-current-project-files (action) "Process the current project's files using ACTION." (let ((project-files (projectile-current-project-files)) (default-directory (projectile-project-root))) (dolist (filename project-files) (funcall action filename)))) (defun projectile-project-dirs (project) "Return a list of dirs for PROJECT." (delete-dups (delq nil (mapcar #'file-name-directory (projectile-project-files project))))) (defun projectile-current-project-dirs () "Return a list of dirs for the current project." (projectile-project-dirs (projectile-acquire-root))) (defun projectile-get-other-files (file-name &optional flex-matching) "Return a list of other files for FILE-NAME. The list depends on `:related-files-fn' project option and `projectile-other-file-alist'. For the latter, FLEX-MATCHING can be used to match any basename." (if-let ((plist (projectile--related-files-plist-by-kind file-name :other))) (projectile--related-files-from-plist plist) (projectile--other-extension-files file-name (projectile-current-project-files) flex-matching))) (defun projectile--find-other-file (&optional flex-matching ff-variant) "Switch between files with the same name but different extensions. With FLEX-MATCHING, match any file that contains the base name of current file. Other file extensions can be customized with the variable `projectile-other-file-alist'. With FF-VARIANT set to a defun, use that instead of `find-file'. A typical example of such a defun would be `find-file-other-window' or `find-file-other-frame'" (let ((ff (or ff-variant #'find-file)) (other-files (projectile-get-other-files (buffer-file-name) flex-matching))) (if other-files (let ((file-name (projectile--choose-from-candidates other-files))) (funcall ff (expand-file-name file-name (projectile-project-root)))) (error "No other file found")))) ;;; Interactive commands ;;;###autoload (defun projectile-find-other-file (&optional flex-matching) "Switch between files with the same name but different extensions. With FLEX-MATCHING, match any file that contains the base name of current file. Other file extensions can be customized with the variable `projectile-other-file-alist'." (interactive "P") (projectile--find-other-file flex-matching)) ;;;###autoload (defun projectile-find-other-file-other-window (&optional flex-matching) "Switch between files with the same name but different extensions in other window. With FLEX-MATCHING, match any file that contains the base name of current file. Other file extensions can be customized with the variable `projectile-other-file-alist'." (interactive "P") (projectile--find-other-file flex-matching #'find-file-other-window)) ;;;###autoload (defun projectile-find-other-file-other-frame (&optional flex-matching) "Switch between files with the same name but different extensions in other frame. With FLEX-MATCHING, match any file that contains the base name of current file. Other file extensions can be customized with the variable `projectile-other-file-alist'." (interactive "P") (projectile--find-other-file flex-matching #'find-file-other-frame)) (defun projectile--file-name-sans-extensions (file-name) "Return FILE-NAME sans any extensions. The extensions, in a filename, are what follows the first '.', with the exception of a leading '.'" (setq file-name (file-name-nondirectory file-name)) (substring file-name 0 (string-match "\\..*" file-name 1))) (defun projectile--file-name-extensions (file-name) "Return FILE-NAME's extensions. The extensions, in a filename, are what follows the first '.', with the exception of a leading '.'" ;;would it make sense to return nil instead of an empty string if no extensions are found? (setq file-name (file-name-nondirectory file-name)) (let (extensions-start) (substring file-name (if (setq extensions-start (string-match "\\..*" file-name 1)) (1+ extensions-start) (length file-name))))) (defun projectile-associated-file-name-extensions (file-name) "Return projectile-other-file-extensions associated to FILE-NAME's extensions. If no associated other-file-extensions for the complete (nested) extension are found, remove subextensions from FILENAME's extensions until a match is found." (let ((current-extensions (projectile--file-name-extensions (file-name-nondirectory file-name))) associated-extensions) (catch 'break (while (not (string= "" current-extensions)) (if (setq associated-extensions (cdr (assoc current-extensions projectile-other-file-alist))) (throw 'break associated-extensions)) (setq current-extensions (projectile--file-name-extensions current-extensions)))))) (defun projectile--other-extension-files (current-file project-file-list &optional flex-matching) "Narrow to files with the same names but different extensions. Returns a list of possible files for users to choose. With FLEX-MATCHING, match any file that contains the base name of current file" (let* ((file-ext-list (projectile-associated-file-name-extensions current-file)) (fulldirname (if (file-name-directory current-file) (file-name-directory current-file) "./")) (dirname (file-name-nondirectory (directory-file-name fulldirname))) (filename (regexp-quote (projectile--file-name-sans-extensions current-file))) (file-list (mapcar (lambda (ext) (if flex-matching (concat ".*" filename ".*" "\." ext "\\'") (concat "^" filename (unless (equal ext "") (concat "\." ext)) "\\'"))) file-ext-list)) (candidates (cl-remove-if-not (lambda (project-file) (string-match filename project-file)) project-file-list)) (candidates (projectile-flatten (mapcar (lambda (file) (cl-remove-if-not (lambda (project-file) (string-match file (concat (file-name-base project-file) (unless (equal (file-name-extension project-file) nil) (concat "\." (file-name-extension project-file)))))) candidates)) file-list))) (candidates (cl-remove-if-not (lambda (file) (not (backup-file-name-p file))) candidates)) (candidates (cl-sort (copy-sequence candidates) (lambda (file _) (let ((candidate-dirname (file-name-nondirectory (directory-file-name (file-name-directory file))))) (unless (equal fulldirname (file-name-directory file)) (equal dirname candidate-dirname))))))) candidates)) (defun projectile-select-files (project-files &optional invalidate-cache) "Select a list of files based on filename at point. With a prefix arg INVALIDATE-CACHE invalidates the cache first." (projectile-maybe-invalidate-cache invalidate-cache) (let* ((file (if (region-active-p) (buffer-substring (region-beginning) (region-end)) (or (thing-at-point 'filename) ""))) (file (if (string-match "\\.?\\./" file) (file-relative-name (file-truename file) (projectile-project-root)) file)) (files (if file (cl-remove-if-not (lambda (project-file) (string-match file project-file)) project-files) nil))) files)) (defun projectile--find-file-dwim (invalidate-cache &optional ff-variant) "Jump to a project's files using completion based on context. With a INVALIDATE-CACHE invalidates the cache first. With FF-VARIANT set to a defun, use that instead of `find-file'. A typical example of such a defun would be `find-file-other-window' or `find-file-other-frame' Subroutine for `projectile-find-file-dwim' and `projectile-find-file-dwim-other-window'" (let* ((project-root (projectile-acquire-root)) (project-files (projectile-project-files project-root)) (files (projectile-select-files project-files invalidate-cache)) (file (cond ((= (length files) 1) (car files)) ((> (length files) 1) (projectile-completing-read "Switch to: " files)) (t (projectile-completing-read "Switch to: " project-files)))) (ff (or ff-variant #'find-file))) (funcall ff (expand-file-name file project-root)) (run-hooks 'projectile-find-file-hook))) ;;;###autoload (defun projectile-find-file-dwim (&optional invalidate-cache) "Jump to a project's files using completion based on context. With a prefix arg INVALIDATE-CACHE invalidates the cache first. If point is on a filename, Projectile first tries to search for that file in project: - If it finds just a file, it switches to that file instantly. This works even if the filename is incomplete, but there's only a single file in the current project that matches the filename at point. For example, if there's only a single file named \"projectile/projectile.el\" but the current filename is \"projectile/proj\" (incomplete), `projectile-find-file-dwim' still switches to \"projectile/projectile.el\" immediately because this is the only filename that matches. - If it finds a list of files, the list is displayed for selecting. A list of files is displayed when a filename appears more than one in the project or the filename at point is a prefix of more than two files in a project. For example, if `projectile-find-file-dwim' is executed on a filepath like \"projectile/\", it lists the content of that directory. If it is executed on a partial filename like \"projectile/a\", a list of files with character 'a' in that directory is presented. - If it finds nothing, display a list of all files in project for selecting." (interactive "P") (projectile--find-file-dwim invalidate-cache)) ;;;###autoload (defun projectile-find-file-dwim-other-window (&optional invalidate-cache) "Jump to a project's files using completion based on context in other window. With a prefix arg INVALIDATE-CACHE invalidates the cache first. If point is on a filename, Projectile first tries to search for that file in project: - If it finds just a file, it switches to that file instantly. This works even if the filename is incomplete, but there's only a single file in the current project that matches the filename at point. For example, if there's only a single file named \"projectile/projectile.el\" but the current filename is \"projectile/proj\" (incomplete), `projectile-find-file-dwim-other-window' still switches to \"projectile/projectile.el\" immediately because this is the only filename that matches. - If it finds a list of files, the list is displayed for selecting. A list of files is displayed when a filename appears more than one in the project or the filename at point is a prefix of more than two files in a project. For example, if `projectile-find-file-dwim-other-window' is executed on a filepath like \"projectile/\", it lists the content of that directory. If it is executed on a partial filename like \"projectile/a\", a list of files with character 'a' in that directory is presented. - If it finds nothing, display a list of all files in project for selecting." (interactive "P") (projectile--find-file-dwim invalidate-cache #'find-file-other-window)) ;;;###autoload (defun projectile-find-file-dwim-other-frame (&optional invalidate-cache) "Jump to a project's files using completion based on context in other frame. With a prefix arg INVALIDATE-CACHE invalidates the cache first. If point is on a filename, Projectile first tries to search for that file in project: - If it finds just a file, it switches to that file instantly. This works even if the filename is incomplete, but there's only a single file in the current project that matches the filename at point. For example, if there's only a single file named \"projectile/projectile.el\" but the current filename is \"projectile/proj\" (incomplete), `projectile-find-file-dwim-other-frame' still switches to \"projectile/projectile.el\" immediately because this is the only filename that matches. - If it finds a list of files, the list is displayed for selecting. A list of files is displayed when a filename appears more than one in the project or the filename at point is a prefix of more than two files in a project. For example, if `projectile-find-file-dwim-other-frame' is executed on a filepath like \"projectile/\", it lists the content of that directory. If it is executed on a partial filename like \"projectile/a\", a list of files with character 'a' in that directory is presented. - If it finds nothing, display a list of all files in project for selecting." (interactive "P") (projectile--find-file-dwim invalidate-cache #'find-file-other-frame)) (defun projectile--find-file (invalidate-cache &optional ff-variant) "Jump to a project's file using completion. With INVALIDATE-CACHE invalidates the cache first. With FF-VARIANT set to a defun, use that instead of `find-file'. A typical example of such a defun would be `find-file-other-window' or `find-file-other-frame'" (interactive "P") (projectile-maybe-invalidate-cache invalidate-cache) (let* ((project-root (projectile-acquire-root)) (file (projectile-completing-read "Find file: " (projectile-project-files project-root))) (ff (or ff-variant #'find-file))) (when file (funcall ff (expand-file-name file project-root)) (run-hooks 'projectile-find-file-hook)))) ;;;###autoload (defun projectile-find-file (&optional invalidate-cache) "Jump to a project's file using completion. With a prefix arg INVALIDATE-CACHE invalidates the cache first." (interactive "P") (projectile--find-file invalidate-cache)) ;;;###autoload (defun projectile-find-file-other-window (&optional invalidate-cache) "Jump to a project's file using completion and show it in another window. With a prefix arg INVALIDATE-CACHE invalidates the cache first." (interactive "P") (projectile--find-file invalidate-cache #'find-file-other-window)) ;;;###autoload (defun projectile-find-file-other-frame (&optional invalidate-cache) "Jump to a project's file using completion and show it in another frame. With a prefix arg INVALIDATE-CACHE invalidates the cache first." (interactive "P") (projectile--find-file invalidate-cache #'find-file-other-frame)) ;;;###autoload (defun projectile-toggle-project-read-only () "Toggle project read only." (interactive) (let ((inhibit-read-only t) (val (not buffer-read-only)) (default-directory (projectile-acquire-root))) (add-dir-local-variable nil 'buffer-read-only val) (save-buffer) (kill-buffer) (when buffer-file-name (read-only-mode (if val +1 -1)) (message "[%s] read-only-mode is %s" (projectile-project-name) (if val "on" "off"))))) ;;;; Sorting project files (defun projectile-sort-files (files) "Sort FILES according to `projectile-sort-order'." (cl-case projectile-sort-order (default files) (recentf (projectile-sort-by-recentf-first files)) (recently-active (projectile-sort-by-recently-active-first files)) (modification-time (projectile-sort-by-modification-time files)) (access-time (projectile-sort-by-access-time files)))) (defun projectile-sort-by-recentf-first (files) "Sort FILES by a recent first scheme." (let ((project-recentf-files (projectile-recentf-files))) (append project-recentf-files (projectile-difference files project-recentf-files)))) (defun projectile-sort-by-recently-active-first (files) "Sort FILES by most recently active buffers or opened files." (let ((project-recently-active-files (projectile-recently-active-files))) (append project-recently-active-files (projectile-difference files project-recently-active-files)))) (defun projectile-sort-by-modification-time (files) "Sort FILES by modification time." (let ((default-directory (projectile-project-root))) (cl-sort (copy-sequence files) (lambda (file1 file2) (let ((file1-mtime (nth 5 (file-attributes file1))) (file2-mtime (nth 5 (file-attributes file2)))) (not (time-less-p file1-mtime file2-mtime))))))) (defun projectile-sort-by-access-time (files) "Sort FILES by access time." (let ((default-directory (projectile-project-root))) (cl-sort (copy-sequence files) (lambda (file1 file2) (let ((file1-atime (nth 4 (file-attributes file1))) (file2-atime (nth 4 (file-attributes file2)))) (not (time-less-p file1-atime file2-atime))))))) ;;;; Find directory in project functionality (defun projectile--find-dir (invalidate-cache &optional dired-variant) "Jump to a project's directory using completion. With INVALIDATE-CACHE invalidates the cache first. With DIRED-VARIANT set to a defun, use that instead of `dired'. A typical example of such a defun would be `dired-other-window' or `dired-other-frame'" (projectile-maybe-invalidate-cache invalidate-cache) (let* ((project (projectile-acquire-root)) (dir (projectile-complete-dir project)) (dired-v (or dired-variant #'dired))) (funcall dired-v (expand-file-name dir project)) (run-hooks 'projectile-find-dir-hook))) ;;;###autoload (defun projectile-find-dir (&optional invalidate-cache) "Jump to a project's directory using completion. With a prefix arg INVALIDATE-CACHE invalidates the cache first." (interactive "P") (projectile--find-dir invalidate-cache)) ;;;###autoload (defun projectile-find-dir-other-window (&optional invalidate-cache) "Jump to a project's directory in other window using completion. With a prefix arg INVALIDATE-CACHE invalidates the cache first." (interactive "P") (projectile--find-dir invalidate-cache #'dired-other-window)) ;;;###autoload (defun projectile-find-dir-other-frame (&optional invalidate-cache) "Jump to a project's directory in other frame using completion. With a prefix arg INVALIDATE-CACHE invalidates the cache first." (interactive "P") (projectile--find-dir invalidate-cache #'dired-other-frame)) (defun projectile-complete-dir (project) (let ((project-dirs (projectile-project-dirs project))) (projectile-completing-read "Find dir: " (if projectile-find-dir-includes-top-level (append '("./") project-dirs) project-dirs)))) ;;;###autoload (defun projectile-find-test-file (&optional invalidate-cache) "Jump to a project's test file using completion. With a prefix arg INVALIDATE-CACHE invalidates the cache first." (interactive "P") (projectile-maybe-invalidate-cache invalidate-cache) (let ((file (projectile-completing-read "Find test file: " (projectile-current-project-test-files)))) (find-file (expand-file-name file (projectile-project-root))))) (defun projectile-test-files (files) "Return only the test FILES." (cl-remove-if-not 'projectile-test-file-p files)) (defun projectile--merge-related-files-fns (related-files-fns) "Merge multiple RELATED-FILES-FNS into one function." (lambda (path) (let (merged-plist) (dolist (fn related-files-fns merged-plist) (let ((plist (funcall fn path))) (cl-loop for (key value) on plist by #'cddr do (let ((values (if (consp value) value (list value)))) (if (plist-member merged-plist key) (nconc (plist-get merged-plist key) values) (setq merged-plist (plist-put merged-plist key values)))))))))) (defun projectile--related-files-plist (project-root file) "Return a plist containing all related files information for FILE in PROJECT-ROOT." (if-let ((rel-path (if (file-name-absolute-p file) (file-relative-name file project-root) file)) (custom-function (funcall projectile-related-files-fn-function (projectile-project-type)))) (funcall (cond ((functionp custom-function) custom-function) ((consp custom-function) (projectile--merge-related-files-fns custom-function)) (t (error "Unsupported value type of :related-files-fn"))) rel-path))) (defun projectile--related-files-plist-by-kind (file kind) "Return a plist containing :paths and/or :predicate of KIND for FILE." (if-let ((project-root (projectile-project-root)) (plist (projectile--related-files-plist project-root file)) (has-kind? (plist-member plist kind))) (let* ((kind-value (plist-get plist kind)) (values (if (cl-typep kind-value '(or string function)) (list kind-value) kind-value)) (paths (delete-dups (cl-remove-if-not 'stringp values))) (predicates (delete-dups (cl-remove-if-not 'functionp values)))) (append ;; Make sure that :paths exists even with nil if there is no predicates (when (or paths (null predicates)) (list :paths (cl-remove-if-not (lambda (f) (projectile-file-exists-p (expand-file-name f project-root))) paths))) (when predicates (list :predicate (if (= 1 (length predicates)) (car predicates) (lambda (other-file) (cl-some (lambda (predicate) (funcall predicate other-file)) predicates))))))))) (defun projectile--related-files-from-plist (plist) "Return a list of files matching to PLIST from current project files." (let* ((predicate (plist-get plist :predicate)) (paths (plist-get plist :paths))) (delete-dups (append paths (when predicate (cl-remove-if-not predicate (projectile-current-project-files))))))) (defun projectile--related-files-kinds(file) "Return a list o keywords meaning available related kinds for FILE." (if-let ((project-root (projectile-project-root)) (plist (projectile--related-files-plist project-root file))) (cl-loop for key in plist by #'cddr collect key))) (defun projectile--related-files (file kind) "Return a list of related files of KIND for FILE." (projectile--related-files-from-plist (projectile--related-files-plist-by-kind file kind))) (defun projectile--find-related-file (file &optional kind) "Choose a file from files related to FILE as KIND. If KIND is not provided, a list of possible kinds can be chosen." (unless kind (if-let ((available-kinds (projectile--related-files-kinds file))) (setq kind (if (= (length available-kinds) 1) (car available-kinds) (intern (projectile-completing-read "Kind :" available-kinds)))) (error "No related files found"))) (if-let ((candidates (projectile--related-files file kind))) (projectile-expand-root (projectile--choose-from-candidates candidates)) (error "No matching related file as `%s' found for project type `%s'" kind (projectile-project-type)))) ;;;###autoload (defun projectile-find-related-file-other-window () "Open related file in other window." (interactive) (find-file-other-window (projectile--find-related-file (buffer-file-name)))) ;;;###autoload (defun projectile-find-related-file-other-frame () "Open related file in other frame." (interactive) (find-file-other-frame (projectile--find-related-file (buffer-file-name)))) ;;;###autoload (defun projectile-find-related-file() "Open related file." (interactive) (find-file (projectile--find-related-file (buffer-file-name)))) ;;;###autoload (defun projectile-related-files-fn-groups(kind groups) "Generate a related-files-fn which relates as KIND for files in each of GROUPS." (lambda (path) (if-let ((group-found (cl-find-if (lambda (group) (member path group)) groups))) (list kind (cl-remove path group-found :test 'equal))))) ;;;###autoload (defun projectile-related-files-fn-extensions(kind extensions) "Generate a related-files-fn which relates as KIND for files having EXTENSIONS." (lambda (path) (let* ((ext (file-name-extension path)) (basename (file-name-base path)) (basename-regexp (regexp-quote basename))) (when (member ext extensions) (list kind (lambda (other-path) (and (string-match-p basename-regexp other-path) (equal basename (file-name-base other-path)) (let ((other-ext (file-name-extension other-path))) (and (member other-ext extensions) (not (equal other-ext ext))))))))))) ;;;###autoload (defun projectile-related-files-fn-test-with-prefix(extension test-prefix) "Generate a related-files-fn which relates tests and impl for files with EXTENSION based on TEST-PREFIX." (lambda (path) (when (equal (file-name-extension path) extension) (let* ((file-name (file-name-nondirectory path)) (find-impl? (string-prefix-p test-prefix file-name)) (file-name-to-find (if find-impl? (substring file-name (length test-prefix)) (concat test-prefix file-name)))) (list (if find-impl? :impl :test) (lambda (other-path) (and (string-suffix-p file-name-to-find other-path) (equal (file-name-nondirectory other-path) file-name-to-find)))))))) ;;;###autoload (defun projectile-related-files-fn-test-with-suffix(extension test-suffix) "Generate a related-files-fn which relates tests and impl for files with EXTENSION based on TEST-SUFFIX." (lambda (path) (when (equal (file-name-extension path) extension) (let* ((file-name (file-name-nondirectory path)) (dot-ext (concat "." extension)) (suffix-ext (concat test-suffix dot-ext)) (find-impl? (string-suffix-p suffix-ext file-name)) (file-name-to-find (if find-impl? (concat (substring file-name 0 (- (length suffix-ext))) dot-ext) (concat (substring file-name 0 (- (length dot-ext))) suffix-ext)))) (list (if find-impl? :impl :test) (lambda (other-path) (and (string-suffix-p file-name-to-find other-path) (equal (file-name-nondirectory other-path) file-name-to-find)))))))) (defun projectile-test-file-p (file) "Check if FILE is a test file." (let ((kinds (projectile--related-files-kinds file))) (cond ((member :impl kinds) t) ((member :test kinds) nil) (t (or (cl-some (lambda (pat) (string-prefix-p pat (file-name-nondirectory file))) (delq nil (list (funcall projectile-test-prefix-function (projectile-project-type))))) (cl-some (lambda (pat) (string-suffix-p pat (file-name-sans-extension (file-name-nondirectory file)))) (delq nil (list (funcall projectile-test-suffix-function (projectile-project-type)))))))))) (defun projectile-current-project-test-files () "Return a list of test files for the current project." (projectile-test-files (projectile-current-project-files))) (defvar projectile-project-types nil "An alist holding all project types that are known to Projectile. The project types are symbols and they are linked to plists holding the properties of the various project types.") (defun projectile--combine-plists (&rest plists) "Create a single property list from all plists in PLISTS. The process starts by copying the first list, and then setting properties from the other lists. Settings in the last list are the most significant ones and overrule settings in the other lists. nil values are ignored in all but the first plist." (let ((rtn (copy-sequence (pop plists))) p v ls) (while plists (setq ls (pop plists)) (while ls (setq p (pop ls) v (pop ls)) (when v (setq rtn (plist-put rtn p v))))) rtn)) (cl-defun projectile--build-project-plist (marker-files &key project-file compilation-dir configure compile install package test run test-suffix test-prefix src-dir test-dir related-files-fn) "Return a project type plist with the provided arguments. A project type is defined by PROJECT-TYPE, a set of MARKER-FILES, and optional keyword arguments: PROJECT-FILE the main project file in the root project directory. COMPILATION-DIR the directory to run the tests- and compilations in, CONFIGURE which specifies a command that configures the project `%s' in the command will be substituted with (projectile-project-root) before the command is run, COMPILE which specifies a command that builds the project, INSTALL which specifies a command to install the project. PACKAGE which specifies a command to package the project. TEST which specified a command that tests the project, RUN which specifies a command that runs the project, TEST-SUFFIX which specifies test file suffix, and TEST-PREFIX which specifies test file prefix. SRC-DIR which specifies the path to the source relative to the project root. TEST-DIR which specifies the path to the tests relative to the project root. RELATED-FILES-FN which specifies a custom function to find the related files such as test/impl/other files as below: CUSTOM-FUNCTION accepts FILE as relative path from the project root and returns a plist containing :test, :impl or :other as key and the relative path/paths or predicate as value. PREDICATE accepts a relative path as the input." (let ((project-plist (list 'marker-files marker-files 'project-file project-file 'compilation-dir compilation-dir 'configure-command configure 'compile-command compile 'test-command test 'install-command install 'package-command package 'run-command run))) ;; There is no way for the function to distinguish between an ;; explicit argument of nil and an omitted argument. However, the ;; body of the function is free to consider nil an abbreviation ;; for some other meaningful value (when (and project-file (not (member project-file projectile-project-root-files))) (add-to-list 'projectile-project-root-files project-file)) (when test-suffix (plist-put project-plist 'test-suffix test-suffix)) (when test-prefix (plist-put project-plist 'test-prefix test-prefix)) (when src-dir (plist-put project-plist 'src-dir src-dir)) (when test-dir (plist-put project-plist 'test-dir test-dir)) (when related-files-fn (plist-put project-plist 'related-files-fn related-files-fn)) project-plist)) (cl-defun projectile-register-project-type (project-type marker-files &key project-file compilation-dir configure compile install package test run test-suffix test-prefix src-dir test-dir related-files-fn) "Register a project type with projectile. A project type is defined by PROJECT-TYPE, a set of MARKER-FILES, and optional keyword arguments: PROJECT-FILE the main project file in the root project directory. COMPILATION-DIR the directory to run the tests- and compilations in, CONFIGURE which specifies a command that configures the project `%s' in the command will be substituted with (projectile-project-root) before the command is run, COMPILE which specifies a command that builds the project, INSTALL which specifies a command to install the project. PACKAGE which specifies a command to package the project. TEST which specified a command that tests the project, RUN which specifies a command that runs the project, TEST-SUFFIX which specifies test file suffix, and TEST-PREFIX which specifies test file prefix. SRC-DIR which specifies the path to the source relative to the project root. TEST-DIR which specifies the path to the tests relative to the project root. RELATED-FILES-FN which specifies a custom function to find the related files such as test/impl/other files as below: CUSTOM-FUNCTION accepts FILE as relative path from the project root and returns a plist containing :test, :impl or :other as key and the relative path/paths or predicate as value. PREDICATE accepts a relative path as the input." (setq projectile-project-types (cons `(,project-type . ,(projectile--build-project-plist marker-files :project-file project-file :compilation-dir compilation-dir :configure configure :compile compile :install install :package package :test test :run run :test-suffix test-suffix :test-prefix test-prefix :src-dir src-dir :test-dir test-dir :related-files-fn related-files-fn)) projectile-project-types))) (cl-defun projectile-update-project-type (project-type &key marker-files project-file compilation-dir configure compile install package test run test-suffix test-prefix src-dir test-dir related-files-fn) "Update an existing projectile project type. Non-nil passed items will override existing values for the project type given by PROJECT-TYPE. Raise an error if PROJECT-TYPE is not already registered with projectile. The arguments to this function are as for projectile-register-project-type: A project type is defined by PROJECT-TYPE, a set of MARKER-FILES, and optional keyword arguments: MARKER-FILES a set of indicator files for PROJECT-TYPE. PROJECT-FILE the main project file in the root project directory. COMPILATION-DIR the directory to run the tests- and compilations in, CONFIGURE which specifies a command that configures the project `%s' in the command will be substituted with (projectile-project-root) before the command is run, COMPILE which specifies a command that builds the project, INSTALL which specifies a command to install the project. PACKAGE which specifies a command to package the project. TEST which specified a command that tests the project, RUN which specifies a command that runs the project, TEST-SUFFIX which specifies test file suffix, and TEST-PREFIX which specifies test file prefix. SRC-DIR which specifies the path to the source relative to the project root. TEST-DIR which specifies the path to the tests relative to the project root. RELATED-FILES-FN which specifies a custom function to find the related files such as test/impl/other files as below: CUSTOM-FUNCTION accepts FILE as relative path from the project root and returns a plist containing :test, :impl or :other as key and the relative path/paths or predicate as value. PREDICATE accepts a relative path as the input." (if-let ((existing-project-plist (cl-find-if (lambda (p) (eq project-type (car p))) projectile-project-types)) (new-plist (projectile--build-project-plist marker-files :project-file project-file :compilation-dir compilation-dir :configure configure :compile compile :install install :package package :test test :run run :test-suffix test-suffix :test-prefix test-prefix :src-dir src-dir :test-dir test-dir :related-files-fn related-files-fn)) (merged-plist (projectile--combine-plists (cdr existing-project-plist) new-plist)) (project-type-elt (cons project-type merged-plist))) (setq projectile-project-types (mapcar (lambda (p) (if (eq project-type (car p)) project-type-elt p)) projectile-project-types)) (error "No existing project found for: %s" project-type))) (defun projectile-cabal-project-p () "Check if a project contains *.cabal files but no stack.yaml file." (and (projectile-verify-file-wildcard "?*.cabal") (not (projectile-verify-file "stack.yaml")))) (defun projectile-dotnet-project-p () "Check if a project contains a .NET project marker." (or (projectile-verify-file-wildcard "?*.csproj") (projectile-verify-file-wildcard "?*.fsproj"))) (defun projectile-go-project-p () "Check if a project contains Go source files." (or (projectile-verify-file "go.mod") (projectile-verify-file-wildcard "*.go"))) (defcustom projectile-go-project-test-function #'projectile-go-project-p "Function to determine if project's type is go." :group 'projectile :type 'function :package-version '(projectile . "1.0.0")) ;;;; Constant signifying opting out of CMake preset commands. (defconst projectile--cmake-no-preset "*no preset*") (defun projectile--cmake-version () "Compute CMake version." (let* ((string (shell-command-to-string "cmake --version")) (match (string-match "^cmake version \\(.*\\)$" string))) (when match (version-to-list (match-string 1 string))))) (defun projectile--cmake-check-version (version) "Check if CMake version is at least VERSION." (and (version-list-<= version (projectile--cmake-version)))) (defconst projectile--cmake-command-presets-minimum-version-alist '((:configure-command . (3 19)) (:compile-command . (3 20)) (:test-command . (3 20)))) (defun projectile--cmake-command-presets-supported (command-type) "Check if CMake supports presets for COMMAND-TYPE." (let ((minimum-version (cdr (assoc command-type projectile--cmake-command-presets-minimum-version-alist)))) (projectile--cmake-check-version minimum-version))) (defun projectile--cmake-read-preset (filename) "Read CMake preset from FILENAME." (when (file-exists-p filename) (with-temp-buffer (insert-file-contents filename) (when (functionp 'json-parse-buffer) (json-parse-buffer :array-type 'list))))) (defconst projectile--cmake-command-preset-array-id-alist '((:configure-command . "configurePresets") (:compile-command . "buildPresets") (:test-command . "testPresets"))) (defun projectile--cmake-command-preset-array-id (command-type) "Map from COMMAND-TYPE to id of command preset array in CMake preset." (cdr (assoc command-type projectile--cmake-command-preset-array-id-alist))) (defun projectile--cmake-command-presets (filename command-type) "Get CMake COMMAND-TYPE presets from FILENAME." (when-let ((preset (projectile--cmake-read-preset (projectile-expand-root filename)))) (cl-remove-if (lambda (preset) (equal (gethash "hidden" preset) t)) (gethash (projectile--cmake-command-preset-array-id command-type) preset)))) (defun projectile--cmake-all-command-presets (command-type) "Get CMake user and system COMMAND-TYPE presets." (projectile-flatten (mapcar (lambda (filename) (projectile--cmake-command-presets filename command-type)) '("CMakeUserPresets.json" "CMakeSystemPresets.json")))) (defun projectile--cmake-command-preset-names (command-type) "Get names of CMake user and system COMMAND-TYPE presets." (mapcar (lambda (preset) (gethash "name" preset)) (projectile--cmake-all-command-presets command-type))) (defcustom projectile-enable-cmake-presets nil "Enables configuration with CMake presets. When `projectile-enable-cmake-presets' is non-nil, CMake projects can be configured, built and tested using presets." :group 'projectile :type 'boolean :package-version '(projectile . "2.4.0")) (defun projectile--cmake-use-command-presets (command-type) "Test whether or not to use command presets for COMMAND-TYPE. Presets are used if `projectile-enable-cmake-presets' is non-nil, and CMake supports presets for COMMAND-TYPE, and `json-parse-buffer' is available." (and projectile-enable-cmake-presets (projectile--cmake-command-presets-supported command-type) (functionp 'json-parse-buffer))) (defun projectile--cmake-select-command (command-type) "Select a CMake command preset or a manual CMake command. The selection is done like this: - If `projectile--cmake-use-commands-presets' for COMMAND-TYPE returns true, and there is at least one preset available for COMMAND-TYPE, the user is prompted to select a name of a command preset, or opt a manual command by selecting `projectile--cmake-no-preset'. - Else `projectile--cmake-no-preset' is used." (if-let ((use-presets (projectile--cmake-use-command-presets command-type)) (preset-names (projectile--cmake-command-preset-names command-type))) (projectile-completing-read "Use preset: " (append preset-names `(,projectile--cmake-no-preset))) projectile--cmake-no-preset)) (defconst projectile--cmake-manual-command-alist '((:configure-command . "cmake -S . -B build") (:compile-command . "cmake --build build") (:test-command . "cmake --build build --target test"))) (defun projectile--cmake-manual-command (command-type) "Create maunual CMake COMMAND-TYPE command." (cdr (assoc command-type projectile--cmake-manual-command-alist))) (defconst projectile--cmake-preset-command-alist '((:configure-command . "cmake . --preset %s") (:compile-command . "cmake --build --preset %s") (:test-command . "ctest --preset %s"))) (defun projectile--cmake-preset-command (command-type preset) "Create CMake COMMAND-TYPE command using PRESET." (format (cdr (assoc command-type projectile--cmake-preset-command-alist)) preset)) (defun projectile--cmake-command (command-type) "Create a CMake COMMAND-TYPE command. The command is created like this: - If `projectile--cmake-select-command' returns `projectile--cmake-no-preset' a manual COMMAND-TYPE command is created with `projectile--cmake-manual-command'. - Else a preset COMMAND-TYPE command using the selected preset is created with `projectile--cmake-preset-command'." (let ((maybe-preset (projectile--cmake-select-command command-type))) (if (equal maybe-preset projectile--cmake-no-preset) (projectile--cmake-manual-command command-type) (projectile--cmake-preset-command command-type maybe-preset)))) (defun projectile--cmake-configure-command () "CMake configure command." (projectile--cmake-command :configure-command)) (defun projectile--cmake-compile-command () "CMake compile command." (projectile--cmake-command :compile-command)) (defun projectile--cmake-test-command () "CMake test command." (projectile--cmake-command :test-command)) ;;; Project type registration ;; ;; Project type detection happens in a reverse order with respect to ;; project type registration (invocations of `projectile-register-project-type'). ;; ;; As function-based project type detection is pretty slow, so it ;; should be tried at the end if everything else failed (meaning here ;; it should be listed first). ;; ;; Ideally common project types should be checked earlier than exotic ones. ;; Function-based detection project type (projectile-register-project-type 'haskell-cabal #'projectile-cabal-project-p :compile "cabal build" :test "cabal test" :run "cabal run" :test-suffix "Spec") (projectile-register-project-type 'dotnet #'projectile-dotnet-project-p :compile "dotnet build" :run "dotnet run" :test "dotnet test") (projectile-register-project-type 'go projectile-go-project-test-function :compile "go build" :test "go test ./..." :test-suffix "_test") ;; File-based detection project types ;; Universal (projectile-register-project-type 'scons '("SConstruct") :project-file "SConstruct" :compile "scons" :test "scons test" :test-suffix "test") (projectile-register-project-type 'meson '("meson.build") :project-file "meson.build" :compilation-dir "build" :configure "meson %s" :compile "ninja" :test "ninja test") (projectile-register-project-type 'nix '("default.nix") :project-file "default.nix" :compile "nix-build" :test "nix-build") (projectile-register-project-type 'bazel '("WORKSPACE") :project-file "WORKSPACE" :compile "bazel build" :test "bazel test" :run "bazel run") (projectile-register-project-type 'debian '("debian/control") :project-file "debian/control" :compile "debuild -uc -us") ;; Make & CMake (projectile-register-project-type 'make '("Makefile") :project-file "Makefile" :compile "make" :test "make test" :install "make install") (projectile-register-project-type 'cmake '("CMakeLists.txt") :project-file "CMakeLists.txt" :configure #'projectile--cmake-configure-command :compile #'projectile--cmake-compile-command :test #'projectile--cmake-test-command :install "cmake --build build --target install" :package "cmake --build build --target package") ;; PHP (projectile-register-project-type 'php-symfony '("composer.json" "app" "src" "vendor") :project-file "composer.json" :compile "app/console server:run" :test "phpunit -c app " :test-suffix "Test") ;; Erlang & Elixir (projectile-register-project-type 'rebar '("rebar.config") :project-file "rebar.config" :compile "rebar3 compile" :test "rebar3 do eunit,ct" :test-suffix "_SUITE") (projectile-register-project-type 'elixir '("mix.exs") :project-file "mix.exs" :compile "mix compile" :src-dir "lib/" :test "mix test" :test-suffix "_test") ;; JavaScript (projectile-register-project-type 'grunt '("Gruntfile.js") :project-file "Gruntfile.js" :compile "grunt" :test "grunt test") (projectile-register-project-type 'gulp '("gulpfile.js") :project-file "gulpfile.js" :compile "gulp" :test "gulp test") (projectile-register-project-type 'npm '("package.json") :project-file "package.json" :compile "npm install" :test "npm test" :test-suffix ".test") ;; Angular (projectile-register-project-type 'angular '("angular.json" ".angular-cli.json") :project-file "angular.json" :compile "ng build" :run "ng serve" :test "ng test" :test-suffix ".spec") ;; Python (projectile-register-project-type 'django '("manage.py") :project-file "manage.py" :compile "python manage.py runserver" :test "python manage.py test" :test-prefix "test_" :test-suffix"_test") (projectile-register-project-type 'python-pip '("requirements.txt") :project-file "requirements.txt" :compile "python setup.py build" :test "python -m unittest discover" :test-prefix "test_" :test-suffix"_test") (projectile-register-project-type 'python-pkg '("setup.py") :project-file "setup.py" :compile "python setup.py build" :test "python -m unittest discover" :test-prefix "test_" :test-suffix"_test") (projectile-register-project-type 'python-tox '("tox.ini") :project-file "tox.ini" :compile "tox -r --notest" :test "tox" :test-prefix "test_" :test-suffix"_test") (projectile-register-project-type 'python-pipenv '("Pipfile") :project-file "Pipfile" :compile "pipenv run build" :test "pipenv run test" :test-prefix "test_" :test-suffix "_test") (projectile-register-project-type 'python-poetry '("poetry.lock") :project-file "poetry.lock" :compile "poetry build" :test "poetry run python -m unittest discover" :test-prefix "test_" :test-suffix "_test") ;; Java & friends (projectile-register-project-type 'maven '("pom.xml") :project-file "pom.xml" :compile "mvn -B clean install" :test "mvn -B test" :test-suffix "Test" :src-dir "main/src/" :test-dir "main/test/") (projectile-register-project-type 'gradle '("build.gradle") :project-file "build.gradle" :compile "gradle build" :test "gradle test" :test-suffix "Spec") (projectile-register-project-type 'gradlew '("gradlew") :project-file "gradlew" :compile "./gradlew build" :test "./gradlew test" :test-suffix "Spec") (projectile-register-project-type 'grails '("application.properties" "grails-app") :project-file "application.properties" :compile "grails package" :test "grails test-app" :test-suffix "Spec") ;; Scala (projectile-register-project-type 'sbt '("build.sbt") :project-file "build.sbt" :compile "sbt compile" :test "sbt test" :test-suffix "Spec") (projectile-register-project-type 'mill '("build.sc") :project-file "build.sc" :compile "mill all __.compile" :test "mill all __.test" :test-suffix "Test") ;; Clojure (projectile-register-project-type 'lein-test '("project.clj") :project-file "project.clj" :compile "lein compile" :test "lein test" :test-suffix "_test") (projectile-register-project-type 'lein-midje '("project.clj" ".midje.clj") :project-file "project.clj" :compile "lein compile" :test "lein midje" :test-prefix "t_") (projectile-register-project-type 'boot-clj '("build.boot") :project-file "build.boot" :compile "boot aot" :test "boot test" :test-suffix "_test") (projectile-register-project-type 'clojure-cli '("deps.edn") :project-file "deps.edn" :test-suffix "_test") (projectile-register-project-type 'bloop '(".bloop") :project-file ".bloop" :compile "bloop compile root" :test "bloop test --propagate --reporter scalac root" :src-dir "src/main/" :test-dir "src/test/" :test-suffix "Spec") ;; Ruby (projectile-register-project-type 'ruby-rspec '("Gemfile" "lib" "spec") :project-file "Gemfile" :compile "bundle exec rake" :src-dir "lib/" :test "bundle exec rspec" :test-dir "spec/" :test-suffix "_spec") (projectile-register-project-type 'ruby-test '("Gemfile" "lib" "test") :project-file "Gemfile" :compile"bundle exec rake" :src-dir "lib/" :test "bundle exec rake test" :test-suffix "_test") ;; Rails needs to be registered after npm, otherwise `package.json` makes it `npm`. ;; https://github.com/bbatsov/projectile/pull/1191 (projectile-register-project-type 'rails-test '("Gemfile" "app" "lib" "db" "config" "test") :project-file "Gemfile" :compile "bundle exec rails server" :src-dir "lib/" :test "bundle exec rake test" :test-suffix "_test") (projectile-register-project-type 'rails-rspec '("Gemfile" "app" "lib" "db" "config" "spec") :project-file "Gemfile" :compile "bundle exec rails server" :src-dir "lib/" :test "bundle exec rspec" :test-dir "spec/" :test-suffix "_spec") ;; Crystal (projectile-register-project-type 'crystal-spec '("shard.yml") :project-file "shard.yml" :src-dir "src/" :test "crystal spec" :test-dir "spec/" :test-suffix "_spec") ;; Emacs (projectile-register-project-type 'emacs-cask '("Cask") :project-file "Cask" :compile "cask install" :test-prefix "test-" :test-suffix "-test") (projectile-register-project-type 'emacs-eldev (lambda () (or (projectile-verify-file "Eldev") (projectile-verify-file "Eldev-local"))) :project-file "Eldev" :compile "eldev compile" :test "eldev test" :run "eldev emacs" :package "eldev package") ;; R (projectile-register-project-type 'r '("DESCRIPTION") :project-file "DESCRIPTION" :compile "R CMD INSTALL --with-keep.source ." :test (concat "R CMD check -o " temporary-file-directory " .")) ;; Haskell (projectile-register-project-type 'haskell-stack '("stack.yaml") :project-file "stack.yaml" :compile "stack build" :test "stack build --test" :test-suffix "Spec") ;; Rust (projectile-register-project-type 'rust-cargo '("Cargo.toml") :project-file "Cargo.toml" :compile "cargo build" :test "cargo test" :run "cargo run") ;; Racket (projectile-register-project-type 'racket '("info.rkt") :project-file "info.rkt" :test "raco test ." :install "raco pkg install" :package "raco pkg create --source $(pwd)") ;; Dart (projectile-register-project-type 'dart '("pubspec.yaml") :project-file "pubspec.yaml" :compile "pub get" :test "pub run test" :run "dart" :test-suffix "_test.dart") ;; OCaml (projectile-register-project-type 'ocaml-dune '("dune-project") :project-file "dune-project" :compile "dune build" :test "dune runtest") (defvar-local projectile-project-type nil "Buffer local var for overriding the auto-detected project type. Normally you'd set this from .dir-locals.el.") (put 'projectile-project-type 'safe-local-variable #'symbolp) (defun projectile-detect-project-type () "Detect the type of the current project. Fallsback to a generic project type when the type can't be determined." (let ((project-type (or (car (cl-find-if (lambda (project-type-record) (let ((project-type (car project-type-record)) (marker (plist-get (cdr project-type-record) 'marker-files))) (if (functionp marker) (and (funcall marker) project-type) (and (projectile-verify-files marker) project-type)))) projectile-project-types)) 'generic))) (puthash (projectile-project-root) project-type projectile-project-type-cache) project-type)) (defun projectile-project-type (&optional dir) "Determine a project's type based on its structure. When DIR is specified it checks it, otherwise it acts on the current project. The project type is cached for improved performance." (if projectile-project-type projectile-project-type (let* ((dir (or dir default-directory)) (project-root (projectile-project-root dir))) (if project-root (or (gethash project-root projectile-project-type-cache) (projectile-detect-project-type)) ;; if we're not in a project we just return nil nil)))) ;;;###autoload (defun projectile-project-info () "Display info for current project." (interactive) (message "Project dir: %s ## Project VCS: %s ## Project type: %s" (projectile-acquire-root) (projectile-project-vcs) (projectile-project-type))) (defun projectile-verify-files (files) "Check whether all FILES exist in the current project." (cl-every #'projectile-verify-file files)) (defun projectile-verify-file (file) "Check whether FILE exists in the current project." (file-exists-p (projectile-expand-root file))) (defun projectile-verify-file-wildcard (file) "Check whether FILE exists in the current project. Expands wildcards using `file-expand-wildcards' before checking." (file-expand-wildcards (projectile-expand-root file))) (defun projectile-project-vcs (&optional project-root) "Determine the VCS used by the project if any. PROJECT-ROOT is the targeted directory. If nil, use `projectile-project-root'." (or project-root (setq project-root (projectile-acquire-root))) (cond ;; first we check for a VCS marker in the project root itself ((projectile-file-exists-p (expand-file-name ".git" project-root)) 'git) ((projectile-file-exists-p (expand-file-name ".hg" project-root)) 'hg) ((projectile-file-exists-p (expand-file-name ".fslckout" project-root)) 'fossil) ((projectile-file-exists-p (expand-file-name "_FOSSIL_" project-root)) 'fossil) ((projectile-file-exists-p (expand-file-name ".bzr" project-root)) 'bzr) ((projectile-file-exists-p (expand-file-name "_darcs" project-root)) 'darcs) ((projectile-file-exists-p (expand-file-name ".svn" project-root)) 'svn) ;; then we check if there's a VCS marker up the directory tree ;; that covers the case when a project is part of a multi-project repository ;; in those cases you can still the VCS to get a list of files for ;; the project in question ((projectile-locate-dominating-file project-root ".git") 'git) ((projectile-locate-dominating-file project-root ".hg") 'hg) ((projectile-locate-dominating-file project-root ".fslckout") 'fossil) ((projectile-locate-dominating-file project-root "_FOSSIL_") 'fossil) ((projectile-locate-dominating-file project-root ".bzr") 'bzr) ((projectile-locate-dominating-file project-root "_darcs") 'darcs) ((projectile-locate-dominating-file project-root ".svn") 'svn) (t 'none))) (defun projectile--test-name-for-impl-name (impl-file-path) "Determine the name of the test file for IMPL-FILE-PATH." (let* ((project-type (projectile-project-type)) (impl-file-name (file-name-sans-extension (file-name-nondirectory impl-file-path))) (impl-file-ext (file-name-extension impl-file-path)) (test-prefix (funcall projectile-test-prefix-function project-type)) (test-suffix (funcall projectile-test-suffix-function project-type))) (cond (test-prefix (concat test-prefix impl-file-name "." impl-file-ext)) (test-suffix (concat impl-file-name test-suffix "." impl-file-ext)) (t (error "Project type `%s' not supported!" project-type))))) (defun projectile-create-test-file-for (impl-file-path) "Create a test file for IMPL-FILE-PATH." (let* ((test-file (projectile--test-name-for-impl-name impl-file-path)) (project-root (projectile-project-root)) (relative-dir (file-name-directory (file-relative-name impl-file-path project-root))) (src-dir-name (projectile-src-directory (projectile-project-type))) (test-dir-name (projectile-test-directory (projectile-project-type))) (test-dir (expand-file-name (replace-regexp-in-string src-dir-name test-dir-name relative-dir) project-root)) (test-path (expand-file-name test-file test-dir))) (unless (file-exists-p test-path) (progn (unless (file-exists-p test-dir) (make-directory test-dir :create-parents)) test-path)))) (defun projectile-find-implementation-or-test (file-name) "Given a FILE-NAME return the matching implementation or test filename. If `projectile-create-missing-test-files' is non-nil, create the missing test file." (unless file-name (error "The current buffer is not visiting a file")) (if (projectile-test-file-p file-name) ;; find the matching impl file (let ((impl-file (projectile-find-matching-file file-name))) (if impl-file (projectile-expand-root impl-file) (error "No matching source file found for project type `%s'" (projectile-project-type)))) ;; find the matching test file (let ((test-file (projectile-find-matching-test file-name))) (if test-file (projectile-expand-root test-file) (if projectile-create-missing-test-files (projectile-create-test-file-for file-name) (error "No matching test file found for project type `%s'" (projectile-project-type))))))) ;;;###autoload (defun projectile-find-implementation-or-test-other-window () "Open matching implementation or test file in other window." (interactive) (find-file-other-window (projectile-find-implementation-or-test (buffer-file-name)))) ;;;###autoload (defun projectile-find-implementation-or-test-other-frame () "Open matching implementation or test file in other frame." (interactive) (find-file-other-frame (projectile-find-implementation-or-test (buffer-file-name)))) ;;;###autoload (defun projectile-toggle-between-implementation-and-test () "Toggle between an implementation file and its test file." (interactive) (find-file (projectile-find-implementation-or-test (buffer-file-name)))) (defun projectile-project-type-attribute (project-type key &optional default-value) "Return the value of some PROJECT-TYPE attribute identified by KEY. Fallback to DEFAULT-VALUE for missing attributes." (let ((project (alist-get project-type projectile-project-types))) (if (and project (plist-member project key)) (plist-get project key) default-value))) (defun projectile-test-prefix (project-type) "Find default test files prefix based on PROJECT-TYPE." (projectile-project-type-attribute project-type 'test-prefix)) (defun projectile-test-suffix (project-type) "Find default test files suffix based on PROJECT-TYPE." (projectile-project-type-attribute project-type 'test-suffix)) (defun projectile-related-files-fn (project-type) "Find relative file based on PROJECT-TYPE." (projectile-project-type-attribute project-type 'related-files-fn)) (defun projectile-src-directory (project-type) "Find default src directory based on PROJECT-TYPE." (projectile-project-type-attribute project-type 'src-dir "src/")) (defun projectile-test-directory (project-type) "Find default test directory based on PROJECT-TYPE." (projectile-project-type-attribute project-type 'test-dir "test/")) (defun projectile-dirname-matching-count (a b) "Count matching dirnames ascending file paths in A and B." (setq a (reverse (split-string (or (file-name-directory a) "") "/" t)) b (reverse (split-string (or (file-name-directory b) "") "/" t))) (let ((common 0)) (while (and a b (string-equal (pop a) (pop b))) (setq common (1+ common))) common)) (defun projectile-group-file-candidates (file candidates) "Group file candidates by dirname matching count." (cl-sort (copy-sequence (let (value result) (while (setq value (pop candidates)) (let* ((key (projectile-dirname-matching-count file value)) (kv (assoc key result))) (if kv (setcdr kv (cons value (cdr kv))) (push (list key value) result)))) (mapcar (lambda (x) (cons (car x) (nreverse (cdr x)))) (nreverse result)))) (lambda (a b) (> (car a) (car b))))) (defun projectile--best-or-all-candidates-based-on-parents-dirs (file candidates) "Return a list containing the best one one for FILE from CANDIDATES or all CANDIDATES." (let ((grouped-candidates (projectile-group-file-candidates file candidates))) (if (= (length (car grouped-candidates)) 2) (list (car (last (car grouped-candidates)))) (apply #'append (mapcar #'cdr grouped-candidates))))) (defun projectile--impl-to-test-predicate (impl-file) "Return a predicate, which returns t for any test files for IMPL-FILE." (let* ((basename (file-name-sans-extension (file-name-nondirectory impl-file))) (test-prefix (funcall projectile-test-prefix-function (projectile-project-type))) (test-suffix (funcall projectile-test-suffix-function (projectile-project-type))) (prefix-name (when test-prefix (concat test-prefix basename))) (suffix-name (when test-suffix (concat basename test-suffix)))) (lambda (current-file) (let ((name (file-name-sans-extension (file-name-nondirectory current-file)))) (or (string-equal prefix-name name) (string-equal suffix-name name)))))) (defun projectile--find-matching-test (impl-file) "Return a list of test files for IMPL-FILE." (if-let ((plist (projectile--related-files-plist-by-kind impl-file :test))) (projectile--related-files-from-plist plist) (if-let ((predicate (projectile--impl-to-test-predicate impl-file))) (projectile--best-or-all-candidates-based-on-parents-dirs impl-file (cl-remove-if-not predicate (projectile-current-project-files)))))) (defun projectile--test-to-impl-predicate (test-file) "Return a predicate, which returns t for any impl files for TEST-FILE." (let* ((basename (file-name-sans-extension (file-name-nondirectory test-file))) (test-prefix (funcall projectile-test-prefix-function (projectile-project-type))) (test-suffix (funcall projectile-test-suffix-function (projectile-project-type)))) (lambda (current-file) (let ((name (file-name-nondirectory (file-name-sans-extension current-file)))) (or (when test-prefix (string-equal (concat test-prefix name) basename)) (when test-suffix (string-equal (concat name test-suffix) basename))))))) (defun projectile--find-matching-file (test-file) "Return a list of impl files tested by TEST-FILE." (if-let ((plist (projectile--related-files-plist-by-kind test-file :impl))) (projectile--related-files-from-plist plist) (if-let ((predicate (projectile--test-to-impl-predicate test-file))) (projectile--best-or-all-candidates-based-on-parents-dirs test-file (cl-remove-if-not predicate (projectile-current-project-files)))))) (defun projectile--choose-from-candidates (candidates) "Choose one item from CANDIDATES." (if (= (length candidates) 1) (car candidates) (projectile-completing-read "Switch to: " candidates))) (defun projectile-find-matching-test (impl-file) "Compute the name of the test matching IMPL-FILE." (if-let ((candidates (projectile--find-matching-test impl-file))) (projectile--choose-from-candidates candidates))) (defun projectile-find-matching-file (test-file) "Compute the name of a file matching TEST-FILE." (if-let ((candidates (projectile--find-matching-file test-file))) (projectile--choose-from-candidates candidates))) (defun projectile-grep-default-files () "Try to find a default pattern for `projectile-grep'. This is a subset of `grep-read-files', where either a matching entry from `grep-files-aliases' or file name extension pattern is returned." (when buffer-file-name (let* ((fn (file-name-nondirectory buffer-file-name)) (default-alias (let ((aliases (remove (assoc "all" grep-files-aliases) grep-files-aliases)) alias) (while aliases (setq alias (car aliases) aliases (cdr aliases)) (if (string-match (mapconcat #'wildcard-to-regexp (split-string (cdr alias) nil t) "\\|") fn) (setq aliases nil) (setq alias nil))) (cdr alias))) (default-extension (let ((ext (file-name-extension fn))) (and ext (concat "*." ext))))) (or default-alias default-extension)))) (defun projectile--globally-ignored-file-suffixes-glob () "Return ignored file suffixes as a list of glob patterns." (mapcar (lambda (pat) (concat "*" pat)) projectile-globally-ignored-file-suffixes)) (defun projectile--read-search-string-with-default (prefix-label) (let* ((prefix-label (projectile-prepend-project-name prefix-label)) (default-value (projectile-symbol-or-selection-at-point)) (default-label (if (or (not default-value) (string= default-value "")) "" (format " (default %s)" default-value)))) (read-string (format "%s%s: " prefix-label default-label) nil nil default-value))) (defvar projectile-grep-find-ignored-paths) (defvar projectile-grep-find-unignored-paths) (defvar projectile-grep-find-ignored-patterns) (defvar projectile-grep-find-unignored-patterns) (defun projectile-rgrep-default-command (regexp files dir) "Compute the command for \\[rgrep] to use by default. Extension of the Emacs 25.1 implementation of `rgrep-default-command', with which it shares its arglist." (require 'find-dired) ; for `find-name-arg' (grep-expand-template grep-find-template regexp (concat (shell-quote-argument "(") " " find-name-arg " " (mapconcat #'shell-quote-argument (split-string files) (concat " -o " find-name-arg " ")) " " (shell-quote-argument ")")) dir (concat (and grep-find-ignored-directories (concat "-type d " (shell-quote-argument "(") ;; we should use shell-quote-argument here " -path " (mapconcat #'identity (delq nil (mapcar #'(lambda (ignore) (cond ((stringp ignore) (shell-quote-argument (concat "*/" ignore))) ((consp ignore) (and (funcall (car ignore) dir) (shell-quote-argument (concat "*/" (cdr ignore))))))) grep-find-ignored-directories)) " -o -path ") " " (shell-quote-argument ")") " -prune -o ")) (and grep-find-ignored-files (concat (shell-quote-argument "!") " -type d " (shell-quote-argument "(") ;; we should use shell-quote-argument here " -name " (mapconcat #'(lambda (ignore) (cond ((stringp ignore) (shell-quote-argument ignore)) ((consp ignore) (and (funcall (car ignore) dir) (shell-quote-argument (cdr ignore)))))) grep-find-ignored-files " -o -name ") " " (shell-quote-argument ")") " -prune -o ")) (and projectile-grep-find-ignored-paths (concat (shell-quote-argument "(") " -path " (mapconcat (lambda (ignore) (shell-quote-argument (concat "./" ignore))) projectile-grep-find-ignored-paths " -o -path ") " " (shell-quote-argument ")") " -prune -o ")) (and projectile-grep-find-ignored-patterns (concat (shell-quote-argument "(") (and (or projectile-grep-find-unignored-paths projectile-grep-find-unignored-patterns) (concat " " (shell-quote-argument "("))) " -path " (mapconcat (lambda (ignore) (shell-quote-argument (if (string-prefix-p "*" ignore) ignore (concat "*/" ignore)))) projectile-grep-find-ignored-patterns " -o -path ") (and (or projectile-grep-find-unignored-paths projectile-grep-find-unignored-patterns) (concat " " (shell-quote-argument ")") " -a " (shell-quote-argument "!") " " (shell-quote-argument "(") (and projectile-grep-find-unignored-paths (concat " -path " (mapconcat (lambda (ignore) (shell-quote-argument (concat "./" ignore))) projectile-grep-find-unignored-paths " -o -path "))) (and projectile-grep-find-unignored-paths projectile-grep-find-unignored-patterns " -o") (and projectile-grep-find-unignored-patterns (concat " -path " (mapconcat (lambda (ignore) (shell-quote-argument (if (string-prefix-p "*" ignore) ignore (concat "*/" ignore)))) projectile-grep-find-unignored-patterns " -o -path "))) " " (shell-quote-argument ")"))) " " (shell-quote-argument ")") " -prune -o "))))) ;;;###autoload (defun projectile-grep (&optional regexp arg) "Perform rgrep in the project. With a prefix ARG asks for files (globbing-aware) which to grep in. With prefix ARG of `-' (such as `M--'), default the files (without prompt), to `projectile-grep-default-files'. With REGEXP given, don't query the user for a regexp." (interactive "i\nP") (require 'grep) ;; for `rgrep' (let* ((roots (projectile-get-project-directories (projectile-acquire-root))) (search-regexp (or regexp (projectile--read-search-string-with-default "Grep for"))) (files (and arg (or (and (equal current-prefix-arg '-) (projectile-grep-default-files)) (read-string (projectile-prepend-project-name "Grep in: ") (projectile-grep-default-files)))))) (dolist (root-dir roots) (require 'vc-git) ;; for `vc-git-grep' ;; in git projects users have the option to use `vc-git-grep' instead of `rgrep' (if (and (eq (projectile-project-vcs) 'git) projectile-use-git-grep (fboundp 'vc-git-grep)) (vc-git-grep search-regexp (or files "") root-dir) ;; paths for find-grep should relative and without trailing / (let ((grep-find-ignored-files (cl-union (projectile--globally-ignored-file-suffixes-glob) grep-find-ignored-files)) (projectile-grep-find-ignored-paths (append (mapcar (lambda (f) (directory-file-name (file-relative-name f root-dir))) (projectile-ignored-directories)) (mapcar (lambda (file) (file-relative-name file root-dir)) (projectile-ignored-files)))) (projectile-grep-find-unignored-paths (append (mapcar (lambda (f) (directory-file-name (file-relative-name f root-dir))) (projectile-unignored-directories)) (mapcar (lambda (file) (file-relative-name file root-dir)) (projectile-unignored-files)))) (projectile-grep-find-ignored-patterns (projectile-patterns-to-ignore)) (projectile-grep-find-unignored-patterns (projectile-patterns-to-ensure))) (grep-compute-defaults) (cl-letf (((symbol-function 'rgrep-default-command) #'projectile-rgrep-default-command)) (rgrep search-regexp (or files "* .*") root-dir) (when (get-buffer "*grep*") ;; When grep is using a global *grep* buffer rename it to be ;; scoped to the current root to allow multiple concurrent grep ;; operations, one per root (with-current-buffer "*grep*" (rename-buffer (concat "*grep <" root-dir ">*")))))))) (run-hooks 'projectile-grep-finished-hook))) ;;;###autoload (defun projectile-ag (search-term &optional arg) "Run an ag search with SEARCH-TERM in the project. With an optional prefix argument ARG SEARCH-TERM is interpreted as a regular expression." (interactive (list (projectile--read-search-string-with-default (format "Ag %ssearch for" (if current-prefix-arg "regexp " ""))) current-prefix-arg)) (if (require 'ag nil 'noerror) (let ((ag-command (if arg 'ag-regexp 'ag)) (ag-ignore-list (delq nil (delete-dups (append ag-ignore-list (projectile--globally-ignored-file-suffixes-glob) ;; ag supports git ignore files directly (unless (eq (projectile-project-vcs) 'git) (append (projectile-ignored-files-rel) (projectile-ignored-directories-rel) grep-find-ignored-files grep-find-ignored-directories '())))))) ;; reset the prefix arg, otherwise it will affect the ag-command (current-prefix-arg nil)) (funcall ag-command search-term (projectile-acquire-root))) (error "Package 'ag' is not available"))) ;;;###autoload (defun projectile-ripgrep (search-term &optional arg) "Run a Ripgrep search with `SEARCH-TERM' at current project root. With an optional prefix argument ARG SEARCH-TERM is interpreted as a regular expression." (interactive (list (projectile--read-search-string-with-default (format "Ripgrep %ssearch for" (if current-prefix-arg "regexp " ""))) current-prefix-arg)) (if (require 'ripgrep nil 'noerror) (let ((args (mapcar (lambda (val) (concat "--glob !" val)) (append projectile-globally-ignored-files projectile-globally-ignored-directories)))) (ripgrep-regexp search-term (projectile-acquire-root) (if arg args (cons "--fixed-strings" args)))) (error "Package `ripgrep' is not available"))) (defun projectile-tags-exclude-patterns () "Return a string with exclude patterns for ctags." (mapconcat (lambda (pattern) (format "--exclude=\"%s\"" (directory-file-name pattern))) (append (projectile-ignored-directories-rel) (projectile-patterns-to-ignore)) " ")) ;;;###autoload (defun projectile-regenerate-tags () "Regenerate the project's [e|g]tags." (interactive) (if (and (boundp 'ggtags-mode) (memq projectile-tags-backend '(auto ggtags))) (progn (let* ((ggtags-project-root (projectile-acquire-root)) (default-directory ggtags-project-root)) (ggtags-ensure-project) (ggtags-update-tags t))) (let* ((project-root (projectile-acquire-root)) (tags-exclude (projectile-tags-exclude-patterns)) (default-directory project-root) (tags-file (expand-file-name projectile-tags-file-name)) (command (format projectile-tags-command tags-file tags-exclude ;; Use directory file name for MSYS2 compatibility. ;; See https://github.com/bbatsov/projectile/issues/1377 for more details (directory-file-name default-directory))) shell-output exit-code) (with-temp-buffer (setq exit-code (call-process-shell-command command nil (current-buffer)) shell-output (string-trim (buffer-substring (point-min) (point-max))))) (unless (zerop exit-code) (error shell-output)) (visit-tags-table tags-file) (message "Regenerated %s" tags-file)))) (defun projectile-visit-project-tags-table () "Visit the current project's tags table." (when (projectile-project-p) (let ((tags-file (projectile-expand-root projectile-tags-file-name))) (when (file-exists-p tags-file) (with-demoted-errors "Error loading tags-file: %s" (visit-tags-table tags-file t)))))) (defun projectile-determine-find-tag-fn () "Determine which function to use for a call to `projectile-find-tag'." (or (cond ((eq projectile-tags-backend 'auto) (cond ((fboundp 'ggtags-find-tag-dwim) 'ggtags-find-tag-dwim) ((fboundp 'xref-find-definitions) 'xref-find-definitions) ((fboundp 'etags-select-find-tag) 'etags-select-find-tag))) ((eq projectile-tags-backend 'xref) (when (fboundp 'xref-find-definitions) 'xref-find-definitions)) ((eq projectile-tags-backend 'ggtags) (when (fboundp 'ggtags-find-tag-dwim) 'ggtags-find-tag-dwim)) ((eq projectile-tags-backend 'etags-select) (when (fboundp 'etags-select-find-tag) 'etags-select-find-tag))) 'find-tag)) ;;;###autoload (defun projectile-find-tag () "Find tag in project." (interactive) (projectile-visit-project-tags-table) ;; Auto-discover the user's preference for tags (let ((find-tag-fn (projectile-determine-find-tag-fn))) (call-interactively find-tag-fn))) (defmacro projectile-with-default-dir (dir &rest body) "Invoke in DIR the BODY." (declare (debug t) (indent 1)) `(let ((default-directory ,dir)) ,@body)) ;;;###autoload (defun projectile-run-command-in-root () "Invoke `execute-extended-command' in the project's root." (interactive) (projectile-with-default-dir (projectile-acquire-root) (call-interactively #'execute-extended-command))) ;;;###autoload (defun projectile-run-shell-command-in-root () "Invoke `shell-command' in the project's root." (interactive) (projectile-with-default-dir (projectile-acquire-root) (call-interactively #'shell-command))) ;;;###autoload (defun projectile-run-async-shell-command-in-root () "Invoke `async-shell-command' in the project's root." (interactive) (projectile-with-default-dir (projectile-acquire-root) (call-interactively #'async-shell-command))) ;;;###autoload (defun projectile-run-gdb () "Invoke `gdb' in the project's root." (interactive) (projectile-with-default-dir (projectile-acquire-root) (call-interactively 'gdb))) ;;;###autoload (defun projectile-run-shell (&optional arg) "Invoke `shell' in the project's root. Switch to the project specific shell buffer if it already exists. Use a prefix argument ARG to indicate creation of a new process instead." (interactive "P") (let ((project (projectile-acquire-root))) (projectile-with-default-dir project (shell (projectile-generate-process-name "shell" arg project))))) ;;;###autoload (defun projectile-run-eshell (&optional arg) "Invoke `eshell' in the project's root. Switch to the project specific eshell buffer if it already exists. Use a prefix argument ARG to indicate creation of a new process instead." (interactive "P") (let ((project (projectile-acquire-root))) (projectile-with-default-dir project (let ((eshell-buffer-name (projectile-generate-process-name "eshell" arg project))) (eshell))))) ;;;###autoload (defun projectile-run-ielm (&optional arg) "Invoke `ielm' in the project's root. Switch to the project specific ielm buffer if it already exists. Use a prefix argument ARG to indicate creation of a new process instead." (interactive "P") (let* ((project (projectile-acquire-root)) (ielm-buffer-name (projectile-generate-process-name "ielm" arg project))) (if (get-buffer ielm-buffer-name) (switch-to-buffer ielm-buffer-name) (projectile-with-default-dir project (ielm)) ;; ielm's buffer name is hardcoded, so we have to rename it after creation (rename-buffer ielm-buffer-name)))) ;;;###autoload (defun projectile-run-term (&optional arg) "Invoke `term' in the project's root. Switch to the project specific term buffer if it already exists. Use a prefix argument ARG to indicate creation of a new process instead." (interactive "P") (let* ((project (projectile-acquire-root)) (buffer-name (projectile-generate-process-name "term" arg project)) (default-program (or explicit-shell-file-name (getenv "ESHELL") (getenv "SHELL") "/bin/sh"))) (unless (get-buffer buffer-name) (require 'term) (let ((program (read-from-minibuffer "Run program: " default-program))) (projectile-with-default-dir project (set-buffer (term-ansi-make-term buffer-name program)) (term-mode) (term-char-mode)))) (switch-to-buffer buffer-name))) ;;;###autoload (defun projectile-run-vterm (&optional arg) "Invoke `vterm' in the project's root. Switch to the project specific term buffer if it already exists. Use a prefix argument ARG to indicate creation of a new process instead." (interactive "P") (let* ((project (projectile-acquire-root)) (buffer (projectile-generate-process-name "vterm" arg project))) (unless (buffer-live-p (get-buffer buffer)) (unless (require 'vterm nil 'noerror) (error "Package 'vterm' is not available")) (projectile-with-default-dir project (vterm buffer))) (switch-to-buffer buffer))) (defun projectile-files-in-project-directory (directory) "Return a list of files in DIRECTORY." (let* ((project (projectile-acquire-root)) (dir (file-relative-name (expand-file-name directory) project))) (cl-remove-if-not (lambda (f) (string-prefix-p dir f)) (projectile-project-files project)))) (defun projectile-files-from-cmd (cmd directory) "Use a grep-like CMD to search for files within DIRECTORY. CMD should include the necessary search params and should output equivalently to grep -HlI (only unique matching filenames). Returns a list of expanded filenames." (let ((default-directory directory)) (mapcar (lambda (str) (concat directory (if (string-prefix-p "./" str) (substring str 2) str))) (split-string (string-trim (shell-command-to-string cmd)) "\n+" t)))) (defvar projectile-files-with-string-commands '((rg . "rg -lF --no-heading --color never -- ") (ag . "ag --literal --nocolor --noheading -l -- ") (ack . "ack --literal --nocolor -l -- ") (git . "git grep -HlI ") ;; -r: recursive ;; -H: show filename for each match ;; -l: show only file names with matches ;; -I: no binary files (grep . "grep -rHlI %s ."))) (defun projectile-files-with-string (string directory) "Return a list of all files containing STRING in DIRECTORY. Tries to use rg, ag, ack, git-grep, and grep in that order. If those are impossible (for instance on Windows), returns a list of all files in the project." (if (projectile-unixy-system-p) (let* ((search-term (shell-quote-argument string)) (cmd (cond ((executable-find "rg") (concat (cdr (assoc 'rg projectile-files-with-string-commands)) search-term)) ((executable-find "ag") (concat (cdr (assoc 'ag projectile-files-with-string-commands)) search-term)) ((executable-find "ack") (concat (cdr (assoc 'ack projectile-files-with-string-commands)) search-term)) ((and (executable-find "git") (eq (projectile-project-vcs) 'git)) (concat (cdr (assoc 'git projectile-files-with-string-commands)) search-term)) (t (format (cdr (assoc 'grep projectile-files-with-string-commands)) search-term))))) (projectile-files-from-cmd cmd directory)) ;; we have to reject directories as a workaround to work with git submodules (cl-remove-if #'file-directory-p (mapcar #'(lambda (file) (expand-file-name file directory)) (projectile-dir-files directory))))) ;;;###autoload (defun projectile-replace (&optional arg) "Replace literal string in project using non-regexp `tags-query-replace'. With a prefix argument ARG prompts you for a directory on which to run the replacement." (interactive "P") (let* ((directory (if arg (file-name-as-directory (read-directory-name "Replace in directory: ")) (projectile-acquire-root))) (old-text (read-string (projectile-prepend-project-name "Replace: ") (projectile-symbol-or-selection-at-point))) (new-text (read-string (projectile-prepend-project-name (format "Replace %s with: " old-text)))) (files (projectile-files-with-string old-text directory))) (if (fboundp #'fileloop-continue) ;; Emacs 27+ (progn (fileloop-initialize-replace old-text new-text files 'default) (fileloop-continue)) ;; Emacs 25 and 26 ;; ;; Adapted from `tags-query-replace' for literal strings (not regexp) (with-no-warnings (setq tags-loop-scan `(let ,(unless (equal old-text (downcase old-text)) '((case-fold-search nil))) (if (search-forward ',old-text nil t) ;; When we find a match, move back to ;; the beginning of it so ;; perform-replace will see it. (goto-char (match-beginning 0))))) (setq tags-loop-operate `(perform-replace ',old-text ',new-text t nil nil nil multi-query-replace-map)) (tags-loop-continue (or (cons 'list files) t)))))) ;;;###autoload (defun projectile-replace-regexp (&optional arg) "Replace a regexp in the project using `tags-query-replace'. With a prefix argument ARG prompts you for a directory on which to run the replacement." (interactive "P") (let* ((directory (if arg (file-name-as-directory (read-directory-name "Replace regexp in directory: ")) (projectile-acquire-root))) (old-text (read-string (projectile-prepend-project-name "Replace regexp: ") (projectile-symbol-or-selection-at-point))) (new-text (read-string (projectile-prepend-project-name (format "Replace regexp %s with: " old-text)))) (files ;; We have to reject directories as a workaround to work with git submodules. ;; ;; We can't narrow the list of files with ;; `projectile-files-with-string' because those regexp tools ;; don't support Emacs regular expressions. (cl-remove-if #'file-directory-p (mapcar #'(lambda (file) (expand-file-name file directory)) (projectile-dir-files directory))))) ;; FIXME: Probably would fail on Emacs 27+, fourth argument is gone. (with-no-warnings (tags-query-replace old-text new-text nil (cons 'list files))))) ;;;###autoload (defun projectile-kill-buffers () "Kill project buffers. The buffer are killed according to the value of `projectile-kill-buffers-filter'." (interactive) (let* ((project (projectile-acquire-root)) (project-name (projectile-project-name project)) (buffers (projectile-project-buffers project))) (when (yes-or-no-p (format "Are you sure you want to kill %s buffers for '%s'? " (length buffers) project-name)) (dolist (buffer buffers) (when (and ;; we take care not to kill indirect buffers directly ;; as we might encounter them after their base buffers are killed (not (buffer-base-buffer buffer)) (if (functionp projectile-kill-buffers-filter) (funcall projectile-kill-buffers-filter buffer) (pcase projectile-kill-buffers-filter ('kill-all t) ('kill-only-files (buffer-file-name buffer)) (_ (user-error "Invalid projectile-kill-buffers-filter value: %S" projectile-kill-buffers-filter))))) (kill-buffer buffer)))))) ;;;###autoload (defun projectile-save-project-buffers () "Save all project buffers." (interactive) (let* ((project (projectile-acquire-root)) (project-name (projectile-project-name project)) (modified-buffers (cl-remove-if-not (lambda (buf) (and (buffer-file-name buf) (buffer-modified-p buf))) (projectile-project-buffers project)))) (if (null modified-buffers) (message "[%s] No buffers need saving" project-name) (dolist (buf modified-buffers) (with-current-buffer buf (save-buffer))) (message "[%s] Saved %d buffers" project-name (length modified-buffers))))) ;;;###autoload (defun projectile-dired () "Open `dired' at the root of the project." (interactive) (dired (projectile-acquire-root))) ;;;###autoload (defun projectile-dired-other-window () "Open `dired' at the root of the project in another window." (interactive) (dired-other-window (projectile-acquire-root))) ;;;###autoload (defun projectile-dired-other-frame () "Open `dired' at the root of the project in another frame." (interactive) (dired-other-frame (projectile-acquire-root))) ;;;###autoload (defun projectile-vc (&optional project-root) "Open `vc-dir' at the root of the project. For git projects `magit-status-internal' is used if available. For hg projects `monky-status' is used if available. If PROJECT-ROOT is given, it is opened instead of the project root directory of the current buffer file. If interactively called with a prefix argument, the user is prompted for a project directory to open." (interactive (and current-prefix-arg (list (projectile-completing-read "Open project VC in: " projectile-known-projects)))) (unless project-root (setq project-root (projectile-acquire-root))) (let ((vcs (projectile-project-vcs project-root))) (cl-case vcs (git (cond ((fboundp 'magit-status-internal) (magit-status-internal project-root)) ((fboundp 'magit-status) (with-no-warnings (magit-status project-root))) (t (vc-dir project-root)))) (hg (if (fboundp 'monky-status) (monky-status project-root) (vc-dir project-root))) (t (vc-dir project-root))))) ;;;###autoload (defun projectile-recentf () "Show a list of recently visited files in a project." (interactive) (if (boundp 'recentf-list) (find-file (projectile-expand-root (projectile-completing-read "Recently visited files: " (projectile-recentf-files)))) (message "recentf is not enabled"))) (defun projectile-recentf-files () "Return a list of recently visited files in a project." (and (boundp 'recentf-list) (let ((project-root (projectile-acquire-root))) (mapcar (lambda (f) (file-relative-name f project-root)) (cl-remove-if-not (lambda (f) (string-prefix-p project-root (expand-file-name f))) recentf-list))))) (defun projectile-serialize-cache () "Serializes the memory cache to the hard drive." (projectile-serialize projectile-projects-cache projectile-cache-file)) (defvar projectile-configure-cmd-map (make-hash-table :test 'equal) "A mapping between projects and the last configure command used on them.") (defvar projectile-compilation-cmd-map (make-hash-table :test 'equal) "A mapping between projects and the last compilation command used on them.") (defvar projectile-install-cmd-map (make-hash-table :test 'equal) "A mapping between projects and the last install command used on them.") (defvar projectile-package-cmd-map (make-hash-table :test 'equal) "A mapping between projects and the last package command used on them.") (defvar projectile-test-cmd-map (make-hash-table :test 'equal) "A mapping between projects and the last test command used on them.") (defvar projectile-run-cmd-map (make-hash-table :test 'equal) "A mapping between projects and the last run command used on them.") (defvar projectile-project-configure-cmd nil "The command to use with `projectile-configure-project'. It takes precedence over the default command for the project type when set. Should be set via .dir-locals.el.") (defvar projectile-project-compilation-cmd nil "The command to use with `projectile-compile-project'. It takes precedence over the default command for the project type when set. Should be set via .dir-locals.el.") (defvar projectile-project-compilation-dir nil "The directory to use with `projectile-compile-project'. The directory path is relative to the project root. Should be set via .dir-locals.el.") (defvar projectile-project-test-cmd nil "The command to use with `projectile-test-project'. It takes precedence over the default command for the project type when set. Should be set via .dir-locals.el.") (defvar projectile-project-install-cmd nil "The command to use with `projectile-install-project'. It takes precedence over the default command for the project type when set. Should be set via .dir-locals.el.") (defvar projectile-project-package-cmd nil "The command to use with `projectile-package-project'. It takes precedence over the default command for the project type when set. Should be set via .dir-locals.el.") (defvar projectile-project-run-cmd nil "The command to use with `projectile-run-project'. It takes precedence over the default command for the project type when set. Should be set via .dir-locals.el.") (defun projectile-default-generic-command (project-type command-type) "Generic retrieval of COMMAND-TYPEs default cmd-value for PROJECT-TYPE. If found, checks if value is symbol or string. In case of symbol resolves to function `funcall's. Return value of function MUST be string to be executed as command." (let ((command (plist-get (alist-get project-type projectile-project-types) command-type))) (cond ((not command) nil) ((stringp command) command) ((functionp command) (if (fboundp command) (funcall (symbol-function command)))) (t (error "The value for: %s in project-type: %s was neither a function nor a string" command-type project-type))))) (defun projectile-default-configure-command (project-type) "Retrieve default configure command for PROJECT-TYPE." (projectile-default-generic-command project-type 'configure-command)) (defun projectile-default-compilation-command (project-type) "Retrieve default compilation command for PROJECT-TYPE." (projectile-default-generic-command project-type 'compile-command)) (defun projectile-default-compilation-dir (project-type) "Retrieve default compilation directory for PROJECT-TYPE." (projectile-default-generic-command project-type 'compilation-dir)) (defun projectile-default-test-command (project-type) "Retrieve default test command for PROJECT-TYPE." (projectile-default-generic-command project-type 'test-command)) (defun projectile-default-install-command (project-type) "Retrieve default install command for PROJECT-TYPE." (projectile-default-generic-command project-type 'install-command)) (defun projectile-default-package-command (project-type) "Retrieve default package command for PROJECT-TYPE." (projectile-default-generic-command project-type 'package-command)) (defun projectile-default-run-command (project-type) "Retrieve default run command for PROJECT-TYPE." (projectile-default-generic-command project-type 'run-command)) (defun projectile-configure-command (compile-dir) "Retrieve the configure command for COMPILE-DIR. The command is determined like this: - first we check `projectile-configure-cmd-map' for the last configure command that was invoked on the project - then we check for `projectile-project-configure-cmd' supplied via .dir-locals.el - finally we check for the default configure command for a project of that type" (or (gethash compile-dir projectile-configure-cmd-map) projectile-project-configure-cmd (let ((cmd-format-string (projectile-default-configure-command (projectile-project-type)))) (when cmd-format-string (format cmd-format-string (projectile-project-root) compile-dir))))) (defun projectile-compilation-buffer-name (compilation-mode) "Meant to be used for `compilation-buffer-name-function`. Argument COMPILATION-MODE is the name of the major mode used for the compilation buffer." (concat "*" (downcase compilation-mode) "*" (if (projectile-project-p) (concat "<" (projectile-project-name) ">") ""))) (defun projectile-current-project-buffer-p () "Meant to be used for `compilation-save-buffers-predicate`. This indicates whether the current buffer is in the same project as the current window (including returning true if neither is in a project)." (let ((root (with-current-buffer (window-buffer) (projectile-project-root)))) (or (not root) (projectile-project-buffer-p (current-buffer) root)))) (defun projectile-compilation-command (compile-dir) "Retrieve the compilation command for COMPILE-DIR. The command is determined like this: - first we check `projectile-compilation-cmd-map' for the last compile command that was invoked on the project - then we check for `projectile-project-compilation-cmd' supplied via .dir-locals.el - finally we check for the default compilation command for a project of that type" (or (gethash compile-dir projectile-compilation-cmd-map) projectile-project-compilation-cmd (projectile-default-compilation-command (projectile-project-type)))) (defun projectile-test-command (compile-dir) "Retrieve the test command for COMPILE-DIR. The command is determined like this: - first we check `projectile-test-cmd-map' for the last test command that was invoked on the project - then we check for `projectile-project-test-cmd' supplied via .dir-locals.el - finally we check for the default test command for a project of that type" (or (gethash compile-dir projectile-test-cmd-map) projectile-project-test-cmd (projectile-default-test-command (projectile-project-type)))) (defun projectile-install-command (compile-dir) "Retrieve the install command for COMPILE-DIR. The command is determined like this: - first we check `projectile-install-cmd-map' for the last install command that was invoked on the project - then we check for `projectile-project-install-cmd' supplied via .dir-locals.el - finally we check for the default install command for a project of that type" (or (gethash compile-dir projectile-install-cmd-map) projectile-project-install-cmd (projectile-default-install-command (projectile-project-type)))) (defun projectile-package-command (compile-dir) "Retrieve the pacakge command for COMPILE-DIR. The command is determined like this: - first we check `projectile-packgage-cmd-map' for the last install command that was invoked on the project - then we check for `projectile-project-package-cmd' supplied via .dir-locals.el - finally we check for the default package command for a project of that type" (or (gethash compile-dir projectile-package-cmd-map) projectile-project-package-cmd (projectile-default-package-command (projectile-project-type)))) (defun projectile-run-command (compile-dir) "Retrieve the run command for COMPILE-DIR. The command is determined like this: - first we check `projectile-run-cmd-map' for the last run command that was invoked on the project - then we check for `projectile-project-run-cmd' supplied via .dir-locals.el - finally we check for the default run command for a project of that type" (or (gethash compile-dir projectile-run-cmd-map) projectile-project-run-cmd (projectile-default-run-command (projectile-project-type)))) (defun projectile-read-command (prompt command) "Adapted from `compilation-read-command'." (let ((compile-history ;; fetch the command history for the current project (ring-elements (projectile--get-command-history (projectile-acquire-root))))) (read-shell-command prompt command (if (equal (car compile-history) command) '(compile-history . 1) 'compile-history)))) (defun projectile-compilation-dir () "Retrieve the compilation directory for this project." (let* ((type (projectile-project-type)) (directory (or projectile-project-compilation-dir (projectile-default-compilation-dir type)))) (if directory (file-truename (concat (file-name-as-directory (projectile-project-root)) (file-name-as-directory directory))) (projectile-project-root)))) (defun projectile-maybe-read-command (arg default-cmd prompt) "Prompt user for command unless DEFAULT-CMD is an Elisp function." (if (and (or (stringp default-cmd) (null default-cmd)) (or compilation-read-command arg)) (projectile-read-command prompt default-cmd) default-cmd)) (defun projectile-run-compilation (cmd) "Run external or Elisp compilation command CMD." (if (functionp cmd) (funcall cmd) (compile cmd))) (defvar projectile-project-command-history (make-hash-table :test 'equal) "The history of last executed project commands, per project. Projects are indexed by their project-root value.") (defun projectile--get-command-history (project-root) (or (gethash project-root projectile-project-command-history) (puthash project-root (make-ring 16) projectile-project-command-history))) (cl-defun projectile--run-project-cmd (command command-map &key show-prompt prompt-prefix save-buffers) "Run a project COMMAND, typically a test- or compile command. Cache the COMMAND for later use inside the hash-table COMMAND-MAP. Normally you'll be prompted for a compilation command, unless variable `compilation-read-command'. You can force the prompt by setting SHOW-PROMPT. The prompt will be prefixed with PROMPT-PREFIX. If SAVE-BUFFERS is non-nil save all projectile buffers before running the command. The command actually run is returned." (let* ((project-root (projectile-project-root)) (default-directory (projectile-compilation-dir)) (command (projectile-maybe-read-command show-prompt command prompt-prefix))) (when command-map (puthash default-directory command command-map) (ring-insert (projectile--get-command-history project-root) command)) (when save-buffers (save-some-buffers (not compilation-ask-about-save) (lambda () (projectile-project-buffer-p (current-buffer) project-root)))) (unless (file-directory-p default-directory) (mkdir default-directory)) (projectile-run-compilation command) command)) ;;;###autoload (defun projectile-configure-project (arg) "Run project configure command. Normally you'll be prompted for a compilation command, unless variable `compilation-read-command'. You can force the prompt with a prefix ARG." (interactive "P") (let ((command (projectile-configure-command (projectile-compilation-dir)))) (projectile--run-project-cmd command projectile-configure-cmd-map :show-prompt arg :prompt-prefix "Configure command: " :save-buffers t))) ;;;###autoload (defun projectile-compile-project (arg) "Run project compilation command. Normally you'll be prompted for a compilation command, unless variable `compilation-read-command'. You can force the prompt with a prefix ARG." (interactive "P") (let ((command (projectile-compilation-command (projectile-compilation-dir)))) (projectile--run-project-cmd command projectile-compilation-cmd-map :show-prompt arg :prompt-prefix "Compile command: " :save-buffers t))) ;;;###autoload (defun projectile-test-project (arg) "Run project test command. Normally you'll be prompted for a compilation command, unless variable `compilation-read-command'. You can force the prompt with a prefix ARG." (interactive "P") (let ((command (projectile-test-command (projectile-compilation-dir)))) (projectile--run-project-cmd command projectile-test-cmd-map :show-prompt arg :prompt-prefix "Test command: " :save-buffers t))) ;;;###autoload (defun projectile-install-project (arg) "Run project install command. Normally you'll be prompted for a compilation command, unless variable `compilation-read-command'. You can force the prompt with a prefix ARG." (interactive "P") (let ((command (projectile-install-command (projectile-compilation-dir)))) (projectile--run-project-cmd command projectile-install-cmd-map :show-prompt arg :prompt-prefix "Install command: " :save-buffers t))) ;;;###autoload (defun projectile-package-project (arg) "Run project package command. Normally you'll be prompted for a compilation command, unless variable `compilation-read-command'. You can force the prompt with a prefix ARG." (interactive "P") (let ((command (projectile-package-command (projectile-compilation-dir)))) (projectile--run-project-cmd command projectile-package-cmd-map :show-prompt arg :prompt-prefix "Package command: " :save-buffers t))) ;;;###autoload (defun projectile-run-project (arg) "Run project run command. Normally you'll be prompted for a compilation command, unless variable `compilation-read-command'. You can force the prompt with a prefix ARG." (interactive "P") (let ((command (projectile-run-command (projectile-compilation-dir)))) (projectile--run-project-cmd command projectile-run-cmd-map :show-prompt arg :prompt-prefix "Run command: "))) ;;;###autoload (defun projectile-repeat-last-command (show-prompt) "Run last projectile external command. External commands are: `projectile-configure-project', `projectile-compile-project', `projectile-test-project', `projectile-install-project', `projectile-package-project', and `projectile-run-project'. If the prefix argument SHOW_PROMPT is non nil, the command can be edited." (interactive "P") (let* ((project-root (projectile-acquire-root)) (command-history (projectile--get-command-history project-root)) (command (car-safe (ring-elements command-history))) (compilation-read-command show-prompt) executed-command) (unless command (user-error "No command has been run yet for this project")) (setq executed-command (projectile--run-project-cmd command nil :save-buffers t :prompt-prefix "Execute command: ")) (unless (string= command executed-command) (ring-insert command-history executed-command)))) (defun compilation-find-file-projectile-find-compilation-buffer (orig-fun marker filename directory &rest formats) "Try to find a buffer for FILENAME, if we cannot find it, fallback to the original function." (when (and (not (file-exists-p (expand-file-name filename))) (projectile-project-p)) (let* ((root (projectile-project-root)) (dirs (cons "" (projectile-current-project-dirs))) (new-filename (car (cl-remove-if-not #'file-exists-p (mapcar (lambda (f) (expand-file-name filename (expand-file-name f root))) dirs))))) (when new-filename (setq filename new-filename)))) (apply orig-fun `(,marker ,filename ,directory ,@formats))) (defun projectile-open-projects () "Return a list of all open projects. An open project is a project with any open buffers." (delete-dups (delq nil (mapcar (lambda (buffer) (with-current-buffer buffer (when (projectile-project-p) (abbreviate-file-name (projectile-project-root))))) (buffer-list))))) (defun projectile--remove-current-project (projects) "Remove the current project (if any) from the list of PROJECTS." (if-let ((project (projectile-project-root))) (projectile-difference projects (list (abbreviate-file-name project))) projects)) (defun projectile--move-current-project-to-end (projects) "Move current project (if any) to the end of list in the list of PROJECTS." (if-let ((project (projectile-project-root))) (append (projectile--remove-current-project projects) (list (abbreviate-file-name project))) projects)) (defun projectile-relevant-known-projects () "Return a list of known projects." (pcase projectile-current-project-on-switch ('remove (projectile--remove-current-project projectile-known-projects)) ('move-to-end (projectile--move-current-project-to-end projectile-known-projects)) ('keep projectile-known-projects))) (defun projectile-relevant-open-projects () "Return a list of open projects." (let ((open-projects (projectile-open-projects))) (pcase projectile-current-project-on-switch ('remove (projectile--remove-current-project open-projects)) ('move-to-end (projectile--move-current-project-to-end open-projects)) ('keep open-projects)))) ;;;###autoload (defun projectile-switch-project (&optional arg) "Switch to a project we have visited before. Invokes the command referenced by `projectile-switch-project-action' on switch. With a prefix ARG invokes `projectile-commander' instead of `projectile-switch-project-action.'" (interactive "P") (let ((projects (projectile-relevant-known-projects))) (if projects (projectile-completing-read "Switch to project: " projects :action (lambda (project) (projectile-switch-project-by-name project arg))) (user-error "There are no known projects")))) ;;;###autoload (defun projectile-switch-open-project (&optional arg) "Switch to a project we have currently opened. Invokes the command referenced by `projectile-switch-project-action' on switch. With a prefix ARG invokes `projectile-commander' instead of `projectile-switch-project-action.'" (interactive "P") (let ((projects (projectile-relevant-open-projects))) (if projects (projectile-completing-read "Switch to open project: " projects :action (lambda (project) (projectile-switch-project-by-name project arg))) (user-error "There are no open projects")))) (defun projectile-switch-project-by-name (project-to-switch &optional arg) "Switch to project by project name PROJECT-TO-SWITCH. Invokes the command referenced by `projectile-switch-project-action' on switch. With a prefix ARG invokes `projectile-commander' instead of `projectile-switch-project-action.'" ;; let's make sure that the target directory exists and is actually a project ;; we ignore remote folders, as the check breaks for TRAMP unless already connected (unless (or (file-remote-p project-to-switch) (projectile-project-p project-to-switch)) (projectile-remove-known-project project-to-switch) (error "Directory %s is not a project" project-to-switch)) (let ((switch-project-action (if arg 'projectile-commander projectile-switch-project-action))) (run-hooks 'projectile-before-switch-project-hook) (let* ((default-directory project-to-switch) (switched-buffer ;; use a temporary buffer to load PROJECT-TO-SWITCH's dir-locals ;; before calling SWITCH-PROJECT-ACTION (with-temp-buffer (hack-dir-local-variables-non-file-buffer) ;; Normally the project name is determined from the current ;; buffer. However, when we're switching projects, we want to ;; show the name of the project being switched to, rather than ;; the current project, in the minibuffer. This is a simple hack ;; to tell the `projectile-project-name' function to ignore the ;; current buffer and the caching mechanism, and just return the ;; value of the `projectile-project-name' variable. (let ((projectile-project-name (funcall projectile-project-name-function project-to-switch))) (funcall switch-project-action) (current-buffer))))) ;; If switch-project-action switched buffers then with-temp-buffer will ;; have lost that change, so switch back to the correct buffer. (when (buffer-live-p switched-buffer) (switch-to-buffer switched-buffer))) (run-hooks 'projectile-after-switch-project-hook))) ;;;###autoload (defun projectile-find-file-in-directory (&optional directory) "Jump to a file in a (maybe regular) DIRECTORY. This command will first prompt for the directory the file is in." (interactive "DFind file in directory: ") (unless (projectile--directory-p directory) (user-error "Directory %S does not exist" directory)) (let ((default-directory directory)) (if (projectile-project-p) ;; target directory is in a project (let ((file (projectile-completing-read "Find file: " (projectile-dir-files directory)))) (find-file (expand-file-name file directory)) (run-hooks 'projectile-find-file-hook)) ;; target directory is not in a project (projectile-find-file)))) (defun projectile-all-project-files () "Get a list of all files in all projects." (cl-mapcan (lambda (project) (when (file-exists-p project) (mapcar (lambda (file) (expand-file-name file project)) (projectile-project-files project)))) projectile-known-projects)) ;;;###autoload (defun projectile-find-file-in-known-projects () "Jump to a file in any of the known projects." (interactive) (find-file (projectile-completing-read "Find file in projects: " (projectile-all-project-files)))) (defun projectile-keep-project-p (project) "Determine whether we should cleanup (remove) PROJECT or not. It handles the case of remote projects as well. See `projectile--cleanup-known-projects'." ;; Taken from from `recentf-keep-default-predicate' (cond ((file-remote-p project nil t) (file-readable-p project)) ((file-remote-p project)) ((file-readable-p project)))) (defun projectile--cleanup-known-projects () "Remove known projects that don't exist anymore and return a list of projects removed." (projectile-merge-known-projects) (let ((projects-kept (cl-remove-if-not #'projectile-keep-project-p projectile-known-projects)) (projects-removed (cl-remove-if #'projectile-keep-project-p projectile-known-projects))) (setq projectile-known-projects projects-kept) (projectile-merge-known-projects) projects-removed)) ;;;###autoload (defun projectile-cleanup-known-projects () "Remove known projects that don't exist anymore." (interactive) (if-let ((projects-removed (projectile--cleanup-known-projects))) (message "Projects removed: %s" (mapconcat #'identity projects-removed ", ")) (message "No projects needed to be removed."))) ;;;###autoload (defun projectile-clear-known-projects () "Clear both `projectile-known-projects' and `projectile-known-projects-file'." (interactive) (setq projectile-known-projects nil) (projectile-save-known-projects)) ;;;###autoload (defun projectile-reset-known-projects () "Clear known projects and rediscover." (interactive) (projectile-clear-known-projects) (projectile-discover-projects-in-search-path)) ;;;###autoload (defun projectile-remove-known-project (&optional project) "Remove PROJECT from the list of known projects." (interactive (list (projectile-completing-read "Remove from known projects: " projectile-known-projects :action 'projectile-remove-known-project))) (unless (called-interactively-p 'any) (setq projectile-known-projects (cl-remove-if (lambda (proj) (string= project proj)) projectile-known-projects)) (projectile-merge-known-projects) (when projectile-verbose (message "Project %s removed from the list of known projects." project)))) ;;;###autoload (defun projectile-remove-current-project-from-known-projects () "Remove the current project from the list of known projects." (interactive) (projectile-remove-known-project (abbreviate-file-name (projectile-acquire-root)))) (defun projectile-ignored-projects () "A list of projects that should not be save in `projectile-known-projects'." (mapcar #'file-truename projectile-ignored-projects)) (defun projectile-ignored-project-p (project-root) "Return t if PROJECT-ROOT should not be added to `projectile-known-projects'." (or (member project-root (projectile-ignored-projects)) (and (functionp projectile-ignored-project-function) (funcall projectile-ignored-project-function project-root)))) ;;;###autoload (defun projectile-add-known-project (project-root) "Add PROJECT-ROOT to the list of known projects." (interactive (list (read-directory-name "Add to known projects: "))) (unless (projectile-ignored-project-p project-root) (setq projectile-known-projects (delete-dups (cons (file-name-as-directory (abbreviate-file-name project-root)) projectile-known-projects))) (projectile-merge-known-projects))) (defun projectile-load-known-projects () "Load saved projects from `projectile-known-projects-file'. Also set `projectile-known-projects'." (setq projectile-known-projects (projectile-unserialize projectile-known-projects-file)) (setq projectile-known-projects-on-file (and (sequencep projectile-known-projects) (copy-sequence projectile-known-projects)))) (defun projectile-save-known-projects () "Save PROJECTILE-KNOWN-PROJECTS to PROJECTILE-KNOWN-PROJECTS-FILE." (projectile-serialize projectile-known-projects projectile-known-projects-file) (setq projectile-known-projects-on-file (and (sequencep projectile-known-projects) (copy-sequence projectile-known-projects)))) (defun projectile-merge-known-projects () "Merge any change from `projectile-known-projects-file' and save to disk. This enables multiple Emacs processes to make changes without overwriting each other's changes." (let* ((known-now projectile-known-projects) (known-on-last-sync projectile-known-projects-on-file) (known-on-file (projectile-unserialize projectile-known-projects-file)) (removed-after-sync (projectile-difference known-on-last-sync known-now)) (removed-in-other-process (projectile-difference known-on-last-sync known-on-file)) (result (delete-dups (projectile-difference (append known-now known-on-file) (append removed-after-sync removed-in-other-process))))) (setq projectile-known-projects result) (projectile-save-known-projects))) ;;; IBuffer integration (define-ibuffer-filter projectile-files "Show Ibuffer with all buffers in the current project." (:reader (read-directory-name "Project root: " (projectile-project-root)) :description nil) (with-current-buffer buf (let ((directory (file-name-as-directory (expand-file-name qualifier)))) (and (projectile-project-buffer-p buf directory) (equal directory (projectile-project-root)))))) (defun projectile-ibuffer-by-project (project-root) "Open an IBuffer window showing all buffers in PROJECT-ROOT." (let ((project-name (funcall projectile-project-name-function project-root))) (ibuffer nil (format "*%s Buffers*" project-name) (list (cons 'projectile-files project-root))))) ;;;###autoload (defun projectile-ibuffer (prompt-for-project) "Open an IBuffer window showing all buffers in the current project. Let user choose another project when PROMPT-FOR-PROJECT is supplied." (interactive "P") (let ((project-root (if prompt-for-project (projectile-completing-read "Project name: " (projectile-relevant-known-projects)) (projectile-acquire-root)))) (projectile-ibuffer-by-project project-root))) ;;;; projectile-commander (defconst projectile-commander-help-buffer "*Projectile Commander Help*") (defvar projectile-commander-methods nil "List of file-selection methods for the `projectile-commander' command. Each element is a list (KEY DESCRIPTION FUNCTION). DESCRIPTION is a one-line description of what the key selects.") ;;;###autoload (defun projectile-commander () "Execute a Projectile command with a single letter. The user is prompted for a single character indicating the action to invoke. The `?' character describes then available actions. See `def-projectile-commander-method' for defining new methods." (interactive) (let* ((choices (mapcar #'car projectile-commander-methods)) (prompt (concat "Select Projectile command [" choices "]: ")) (ch (read-char-choice prompt choices)) (fn (nth 2 (assq ch projectile-commander-methods)))) (funcall fn))) (defmacro def-projectile-commander-method (key description &rest body) "Define a new `projectile-commander' method. KEY is the key the user will enter to choose this method. DESCRIPTION is a one-line sentence describing how the method. BODY is a series of forms which are evaluated when the find is chosen." (let ((method `(lambda () ,@body))) `(setq projectile-commander-methods (cl-sort (copy-sequence (cons (list ,key ,description ,method) (assq-delete-all ,key projectile-commander-methods))) (lambda (a b) (< (car a) (car b))))))) (def-projectile-commander-method ?? "Commander help buffer." (ignore-errors (kill-buffer projectile-commander-help-buffer)) (with-current-buffer (get-buffer-create projectile-commander-help-buffer) (insert "Projectile Commander Methods:\n\n") (dolist (met projectile-commander-methods) (insert (format "%c:\t%s\n" (car met) (cadr met)))) (goto-char (point-min)) (help-mode) (display-buffer (current-buffer) t)) (projectile-commander)) (defun projectile-commander-bindings () "Setup the keybindings for the Projectile Commander." (def-projectile-commander-method ?f "Find file in project." (projectile-find-file)) (def-projectile-commander-method ?T "Find test file in project." (projectile-find-test-file)) (def-projectile-commander-method ?b "Switch to project buffer." (projectile-switch-to-buffer)) (def-projectile-commander-method ?d "Find directory in project." (projectile-find-dir)) (def-projectile-commander-method ?D "Open project root in dired." (projectile-dired)) (def-projectile-commander-method ?v "Open project root in vc-dir or magit." (projectile-vc)) (def-projectile-commander-method ?V "Browse dirty projects" (projectile-browse-dirty-projects)) (def-projectile-commander-method ?r "Replace a string in the project." (projectile-replace)) (def-projectile-commander-method ?R "Regenerate the project's [e|g]tags." (projectile-regenerate-tags)) (def-projectile-commander-method ?g "Run grep on project." (projectile-grep)) (def-projectile-commander-method ?a "Run ag on project." (call-interactively #'projectile-ag)) (def-projectile-commander-method ?s "Switch project." (projectile-switch-project)) (def-projectile-commander-method ?o "Run multi-occur on project buffers." (projectile-multi-occur)) (def-projectile-commander-method ?j "Find tag in project." (projectile-find-tag)) (def-projectile-commander-method ?k "Kill all project buffers." (projectile-kill-buffers)) (def-projectile-commander-method ?e "Find recently visited file in project." (projectile-recentf))) ;;; Dirty (modified) project check related functionality (defun projectile-check-vcs-status (&optional project-path) "Check the status of the current project. If PROJECT-PATH is a project, check this one instead." (let ((project-path (or project-path (projectile-acquire-root))) (project-status nil)) (save-excursion (vc-dir project-path) ;; wait until vc-dir is done (while (vc-dir-busy) (sleep-for 0 100)) ;; check for status (save-excursion (save-match-data (dolist (check projectile-vcs-dirty-state) (goto-char (point-min)) (when (search-forward check nil t) (setq project-status (cons check project-status)))))) (kill-buffer) project-status))) (defvar projectile-cached-dirty-projects-status nil "Cache of the last dirty projects check.") (defun projectile-check-vcs-status-of-known-projects () "Return the list of dirty projects. The list is composed of sublists~: (project-path, project-status). Raise an error if their is no dirty project." (save-window-excursion (message "Checking for modifications in known projects...") (let ((projects projectile-known-projects) (status ())) (dolist (project projects) (when (and (projectile-keep-project-p project) (not (string= 'none (projectile-project-vcs project)))) (let ((tmp-status (projectile-check-vcs-status project))) (when tmp-status (setq status (cons (list project tmp-status) status)))))) (when (= (length status) 0) (message "No dirty projects have been found")) (setq projectile-cached-dirty-projects-status status) status))) ;;;###autoload (defun projectile-browse-dirty-projects (&optional cached) "Browse dirty version controlled projects. With a prefix argument, or if CACHED is non-nil, try to use the cached dirty project list." (interactive "P") (let ((status (if (and cached projectile-cached-dirty-projects-status) projectile-cached-dirty-projects-status (projectile-check-vcs-status-of-known-projects))) (mod-proj nil)) (while (not (= (length status) 0)) (setq mod-proj (cons (car (pop status)) mod-proj))) (projectile-completing-read "Select project: " mod-proj :action 'projectile-vc))) ;;; Find next/previous project buffer (defun projectile--repeat-until-project-buffer (orig-fun &rest args) "Repeat ORIG-FUN with ARGS until the current buffer is a project buffer." (if (projectile-project-root) (let* ((other-project-buffers (make-hash-table :test 'eq)) (projectile-project-buffers (projectile-project-buffers)) (max-iterations (length (buffer-list))) (counter 0)) (dolist (buffer projectile-project-buffers) (unless (eq buffer (current-buffer)) (puthash buffer t other-project-buffers))) (when (cdr-safe projectile-project-buffers) (while (and (< counter max-iterations) (not (gethash (current-buffer) other-project-buffers))) (apply orig-fun args) (cl-incf counter)))) (apply orig-fun args))) (defun projectile-next-project-buffer () "In selected window switch to the next project buffer. If the current buffer does not belong to a project, call `next-buffer'." (interactive) (projectile--repeat-until-project-buffer #'next-buffer)) (defun projectile-previous-project-buffer () "In selected window switch to the previous project buffer. If the current buffer does not belong to a project, call `previous-buffer'." (interactive) (projectile--repeat-until-project-buffer #'previous-buffer)) ;;; Editing a project's .dir-locals (defun projectile-read-variable () "Prompt for a variable and return its name." (completing-read "Variable: " obarray (lambda (v) (and (boundp v) (not (keywordp v)))) t)) (define-skeleton projectile-skel-variable-cons "Insert a variable-name and a value in a cons-cell." "Value: " "(" (projectile-read-variable) " . " str ")") (define-skeleton projectile-skel-dir-locals "Insert a .dir-locals.el template." nil "((nil . (" ("" '(projectile-skel-variable-cons) \n) resume: ")))") ;;;###autoload (defun projectile-edit-dir-locals () "Edit or create a .dir-locals.el file of the project." (interactive) (let ((file (expand-file-name ".dir-locals.el" (projectile-acquire-root)))) (find-file file) (when (not (file-exists-p file)) (unwind-protect (projectile-skel-dir-locals) (save-buffer))))) ;;; Projectile Minor mode (define-obsolete-variable-alias 'projectile-mode-line-lighter 'projectile-mode-line-prefix "0.12.0") (defcustom projectile-mode-line-prefix " Projectile" "Mode line lighter prefix for Projectile. It's used by `projectile-default-mode-line' when using dynamic mode line lighter and is the only thing shown in the mode line otherwise." :group 'projectile :type 'string :package-version '(projectile . "0.12.0")) (defvar-local projectile--mode-line projectile-mode-line-prefix) (defun projectile-default-mode-line () "Report project name and type in the modeline." (let ((project-name (projectile-project-name)) (project-type (projectile-project-type))) (format "%s[%s%s]" projectile-mode-line-prefix (or project-name "-") (if project-type (format ":%s" project-type) "")))) (defun projectile-update-mode-line () "Update the Projectile mode-line." (let ((mode-line (funcall projectile-mode-line-function))) (setq projectile--mode-line mode-line)) (force-mode-line-update)) (defvar projectile-command-map (let ((map (make-sparse-keymap))) (define-key map (kbd "4 a") #'projectile-find-other-file-other-window) (define-key map (kbd "4 b") #'projectile-switch-to-buffer-other-window) (define-key map (kbd "4 C-o") #'projectile-display-buffer) (define-key map (kbd "4 d") #'projectile-find-dir-other-window) (define-key map (kbd "4 D") #'projectile-dired-other-window) (define-key map (kbd "4 f") #'projectile-find-file-other-window) (define-key map (kbd "4 g") #'projectile-find-file-dwim-other-window) (define-key map (kbd "4 t") #'projectile-find-implementation-or-test-other-window) (define-key map (kbd "5 a") #'projectile-find-other-file-other-frame) (define-key map (kbd "5 b") #'projectile-switch-to-buffer-other-frame) (define-key map (kbd "5 d") #'projectile-find-dir-other-frame) (define-key map (kbd "5 D") #'projectile-dired-other-frame) (define-key map (kbd "5 f") #'projectile-find-file-other-frame) (define-key map (kbd "5 g") #'projectile-find-file-dwim-other-frame) (define-key map (kbd "5 t") #'projectile-find-implementation-or-test-other-frame) (define-key map (kbd "!") #'projectile-run-shell-command-in-root) (define-key map (kbd "&") #'projectile-run-async-shell-command-in-root) (define-key map (kbd "a") #'projectile-find-other-file) (define-key map (kbd "b") #'projectile-switch-to-buffer) (define-key map (kbd "d") #'projectile-find-dir) (define-key map (kbd "D") #'projectile-dired) (define-key map (kbd "e") #'projectile-recentf) (define-key map (kbd "E") #'projectile-edit-dir-locals) (define-key map (kbd "f") #'projectile-find-file) (define-key map (kbd "g") #'projectile-find-file-dwim) (define-key map (kbd "F") #'projectile-find-file-in-known-projects) (define-key map (kbd "i") #'projectile-invalidate-cache) (define-key map (kbd "I") #'projectile-ibuffer) (define-key map (kbd "j") #'projectile-find-tag) (define-key map (kbd "k") #'projectile-kill-buffers) (define-key map (kbd "l") #'projectile-find-file-in-directory) (define-key map (kbd "m") #'projectile-commander) (define-key map (kbd "o") #'projectile-multi-occur) (define-key map (kbd "p") #'projectile-switch-project) (define-key map (kbd "q") #'projectile-switch-open-project) (define-key map (kbd "r") #'projectile-replace) (define-key map (kbd "R") #'projectile-regenerate-tags) (define-key map (kbd "s g") #'projectile-grep) (define-key map (kbd "s r") #'projectile-ripgrep) (define-key map (kbd "s s") #'projectile-ag) (define-key map (kbd "S") #'projectile-save-project-buffers) (define-key map (kbd "t") #'projectile-toggle-between-implementation-and-test) (define-key map (kbd "T") #'projectile-find-test-file) (define-key map (kbd "v") #'projectile-vc) (define-key map (kbd "V") #'projectile-browse-dirty-projects) ;; project lifecycle external commands ;; TODO: Bundle those under some prefix key (define-key map (kbd "C") #'projectile-configure-project) (define-key map (kbd "c") #'projectile-compile-project) (define-key map (kbd "K") #'projectile-package-project) (define-key map (kbd "L") #'projectile-install-project) (define-key map (kbd "P") #'projectile-test-project) (define-key map (kbd "u") #'projectile-run-project) ;; utilities (define-key map (kbd "x e") #'projectile-run-eshell) (define-key map (kbd "x i") #'projectile-run-ielm) (define-key map (kbd "x t") #'projectile-run-term) (define-key map (kbd "x s") #'projectile-run-shell) (define-key map (kbd "x g") #'projectile-run-gdb) (define-key map (kbd "x v") #'projectile-run-vterm) (define-key map (kbd "z") #'projectile-cache-current-file) (define-key map (kbd "") #'projectile-previous-project-buffer) (define-key map (kbd "") #'projectile-next-project-buffer) (define-key map (kbd "ESC") #'projectile-project-buffers-other-buffer) map) "Keymap for Projectile commands after `projectile-keymap-prefix'.") (fset 'projectile-command-map projectile-command-map) (defvar projectile-mode-map (let ((map (make-sparse-keymap))) (when projectile-keymap-prefix (define-key map projectile-keymap-prefix 'projectile-command-map)) (easy-menu-define projectile-mode-menu map "Menu for Projectile" '("Projectile" ["Find file" projectile-find-file] ["Find file in known projects" projectile-find-file-in-known-projects] ["Find test file" projectile-find-test-file] ["Find directory" projectile-find-dir] ["Find file in directory" projectile-find-file-in-directory] ["Find other file" projectile-find-other-file] ["Switch to buffer" projectile-switch-to-buffer] ["Jump between implementation file and test file" projectile-toggle-between-implementation-and-test] ["Kill project buffers" projectile-kill-buffers] ["Save project buffers" projectile-save-project-buffers] ["Recent files" projectile-recentf] ["Previous buffer" projectile-previous-project-buffer] ["Next buffer" projectile-next-project-buffer] "--" ["Toggle project wide read-only" projectile-toggle-project-read-only] ["Edit .dir-locals.el" projectile-edit-dir-locals] "--" ["Switch to project" projectile-switch-project] ["Switch to open project" projectile-switch-open-project] ["Discover projects in directory" projectile-discover-projects-in-directory] ["Clear known projects" projectile-clear-known-projects] ["Reset known projects" projectile-reset-known-projects] ["Browse dirty projects" projectile-browse-dirty-projects] ["Open project in dired" projectile-dired] "--" ["Search in project (grep)" projectile-grep] ["Search in project (ag)" projectile-ag] ["Replace in project" projectile-replace] ["Multi-occur in project" projectile-multi-occur] "--" ["Run GDB" projectile-run-gdb] "--" ["Run shell" projectile-run-shell] ["Run eshell" projectile-run-eshell] ["Run ielm" projectile-run-ielm] ["Run term" projectile-run-term] "--" ["Cache current file" projectile-cache-current-file] ["Invalidate cache" projectile-invalidate-cache] ["Regenerate [e|g]tags" projectile-regenerate-tags] "--" ["Configure project" projectile-configure-project] ["Compile project" projectile-compile-project] ["Test project" projectile-test-project] ["Install project" projectile-install-project] ["Package project" projectile-package-project] ["Run project" projectile-run-project] ["Repeat last external command" projectile-repeat-last-command] "--" ["Project info" projectile-project-info] ["About" projectile-version])) map) "Keymap for Projectile mode.") (defun projectile-find-file-hook-function () "Called by `find-file-hook' when `projectile-mode' is on. The function does pretty much nothing when triggered on remote files as all the operations it normally performs are extremely slow over tramp." (projectile-maybe-limit-project-file-buffers) (unless (file-remote-p default-directory) (when projectile-dynamic-mode-line (projectile-update-mode-line)) (when projectile-auto-update-cache (projectile-cache-files-find-file-hook)) (projectile-track-known-projects-find-file-hook) (projectile-visit-project-tags-table))) (defun projectile-maybe-limit-project-file-buffers () "Limit the opened file buffers for a project. The function simply kills the last buffer, as it's normally called when opening new files." (when projectile-max-file-buffer-count (let ((project-buffers (projectile-project-buffer-files))) (when (> (length project-buffers) projectile-max-file-buffer-count) (kill-buffer (car (last project-buffers))))))) ;;;###autoload (define-minor-mode projectile-mode "Minor mode to assist project management and navigation. When called interactively, toggle `projectile-mode'. With prefix ARG, enable `projectile-mode' if ARG is positive, otherwise disable it. When called from Lisp, enable `projectile-mode' if ARG is omitted, nil or positive. If ARG is `toggle', toggle `projectile-mode'. Otherwise behave as if called interactively. \\{projectile-mode-map}" :lighter projectile--mode-line :keymap projectile-mode-map :group 'projectile :require 'projectile :global t (cond (projectile-mode ;; setup the commander bindings (projectile-commander-bindings) ;; initialize the projects cache if needed (unless projectile-projects-cache (setq projectile-projects-cache (or (projectile-unserialize projectile-cache-file) (make-hash-table :test 'equal)))) (unless projectile-projects-cache-time (setq projectile-projects-cache-time (make-hash-table :test 'equal))) ;; load the known projects (projectile-load-known-projects) ;; update the list of known projects (projectile--cleanup-known-projects) (when projectile-auto-discover (projectile-discover-projects-in-search-path)) (add-hook 'find-file-hook 'projectile-find-file-hook-function) (add-hook 'projectile-find-dir-hook #'projectile-track-known-projects-find-file-hook t) (add-hook 'dired-before-readin-hook #'projectile-track-known-projects-find-file-hook t t) (advice-add 'compilation-find-file :around #'compilation-find-file-projectile-find-compilation-buffer) (advice-add 'delete-file :before #'delete-file-projectile-remove-from-cache)) (t (remove-hook 'find-file-hook #'projectile-find-file-hook-function) (remove-hook 'dired-before-readin-hook #'projectile-track-known-projects-find-file-hook t) (advice-remove 'compilation-find-file #'compilation-find-file-projectile-find-compilation-buffer) (advice-remove 'delete-file #'delete-file-projectile-remove-from-cache)))) ;;; savehist-mode - When `savehist-mode' is t, projectile-project-command-history will be saved. ;; See https://github.com/bbatsov/projectile/issues/1637 for more details (if (bound-and-true-p savehist-loaded) (add-to-list 'savehist-additional-variables 'projectile-project-command-history) (defvar savehist-additional-variables nil) (add-hook 'savehist-mode-hook (lambda() (add-to-list 'savehist-additional-variables 'projectile-project-command-history)))) ;;;###autoload (define-obsolete-function-alias 'projectile-global-mode 'projectile-mode "1.0") (provide 'projectile) ;;; projectile.el ends here