1 ;;; project.el --- Operations on the current project -*- lexical-binding: t; -*-
3 ;; Copyright (C) 2015-2016 Free Software Foundation, Inc.
5 ;; This file is part of GNU Emacs.
7 ;; GNU Emacs is free software: you can redistribute it and/or modify
8 ;; it under the terms of the GNU General Public License as published by
9 ;; the Free Software Foundation, either version 3 of the License, or
10 ;; (at your option) any later version.
12 ;; GNU Emacs is distributed in the hope that it will be useful,
13 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
14 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 ;; GNU General Public License for more details.
17 ;; You should have received a copy of the GNU General Public License
18 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
22 ;; This file contains generic infrastructure for dealing with
23 ;; projects, some utility functions, and commands using that
26 ;; The goal is to make it easier for Lisp programs to operate on the
27 ;; current project, without having to know which package handles
28 ;; detection of that project type, parsing its config files, etc.
30 ;; NOTE: The project API is still experimental and can change in major,
31 ;; backward-incompatible ways. Everyone is encouraged to try it, and
32 ;; report to us any problems or use cases we hadn't anticipated, by
33 ;; sending an email to emacs-devel, or `M-x report-emacs-bug'.
37 ;; Function `project-current', to determine the current project
38 ;; instance, and 3 (at the moment) generic functions that act on it.
39 ;; This list is to be extended in future versions.
43 ;; `project-combine-directories' and `project-subtract-directories',
44 ;; mainly for use in the abovementioned generics' implementations.
48 ;; `project-find-regexp' and `project-or-external-find-regexp' use the
49 ;; current API, and thus will work in any project that has an adapter.
53 ;; * Reliably cache the list of files in the project, probably using
54 ;; filenotify.el (if supported) to invalidate. And avoiding caching
55 ;; if it's not available (manual cache invalidation is not nice).
57 ;; * Allow the backend to override the file-listing logic? Maybe also
58 ;; to delegate file name completion to an external tool.
60 ;; * Build tool related functionality. Start with a `project-build'
61 ;; command, which should provide completions on tasks to run, and
62 ;; maybe allow entering some additional arguments. This might
63 ;; be handled better with a separate API, though. Then we won't
64 ;; force every project backend to be aware of the build tool(s) the
67 ;; * Command to (re)build the tag files in all project roots. To that
68 ;; end, we might need to add a way to provide file whitelist
69 ;; wildcards for each root to limit etags to certain files (in
70 ;; addition to the blacklist provided by ignores), and/or allow
71 ;; specifying additional tag regexps.
73 ;; * UI for the user to be able to pick the current project for the
74 ;; whole Emacs session, independent of the current directory. Or,
75 ;; in the more advanced case, open a set of projects, and have some
76 ;; project-related commands to use them all. E.g., have a command
77 ;; to search for a regexp across all open projects. Provide a
78 ;; history of projects that were opened in the past (storing it as a
79 ;; list of directories should suffice).
81 ;; * Support for project-local variables: a UI to edit them, and a
82 ;; utility function to retrieve a value. Probably useless without
83 ;; support in various built-in commands. In the API, we might get
84 ;; away with only adding a `project-configuration-directory' method,
85 ;; defaulting to the project root the current file/buffer is in.
86 ;; And prompting otherwise. How to best mix that with backends that
87 ;; want to set/provide certain variables themselves, is up for
94 (defvar project-find-functions (list #'project-try-vc)
95 "Special hook to find the project containing a given directory.
96 Each functions on this hook is called in turn with one
97 argument (the directory) and should return either nil to mean
98 that it is not applicable, or a project instance.")
101 (defun project-current (&optional maybe-prompt dir)
102 "Return the project instance in DIR or `default-directory'.
103 When no project found in DIR, and MAYBE-PROMPT is non-nil, ask
104 the user for a different directory to look in."
105 (unless dir (setq dir default-directory))
106 (let ((pr (project--find-in-directory dir)))
110 (setq dir (read-directory-name "Choose the project directory: " dir nil t)
111 pr (project--find-in-directory dir))
113 (user-error "No project found in `%s'" dir))))
116 (defun project--find-in-directory (dir)
117 (run-hook-with-args-until-success 'project-find-functions dir))
119 (cl-defgeneric project-roots (project)
120 "Return the list of directory roots of the current project.
122 Most often it's just one directory which contains the project
123 build file and everything else in the project. But in more
124 advanced configurations, a project can span multiple directories.
126 The directory names should be absolute.")
128 ;; FIXME: Add MODE argument, like in `ede-source-paths'?
129 (cl-defgeneric project-external-roots (_project)
130 "Return the list of external roots for PROJECT.
132 It's the list of directories outside of the project that are
133 still related to it. If the project deals with source code then,
134 depending on the languages used, this list should include the
135 headers search path, load path, class path, and so on.
137 The rule of thumb for whether to include a directory here, and
138 not in `project-roots', is whether its contents are meant to be
139 edited together with the rest of the project."
142 (cl-defgeneric project-ignores (_project _dir)
143 "Return the list of glob patterns to ignore inside DIR.
144 Patterns can match both regular files and directories.
145 To root an entry, start it with `./'. To match directories only,
146 end it with `/'. DIR must be one of `project-roots' or
147 `project-external-roots'."
149 (defvar grep-find-ignored-files)
154 vc-directory-exclusion-list)
155 grep-find-ignored-files))
157 (cl-defgeneric project-file-completion-table (_project _dirs)
158 "Return a completion table for files in directories DIRS in PROJECT.
159 DIRS is a list of absolute directories; it should be some
160 subset of the project roots and external roots.
161 PROJECT is used to find the project ignores and other project meta-data."
164 (defgroup project-vc nil
165 "Project implementation using the VC package."
169 (defcustom project-vc-ignores nil
170 "List of patterns to include in `project-ignores'."
171 :type '(repeat string)
174 ;; FIXME: Using the current approach, major modes are supposed to set
175 ;; this variable to a buffer-local value. So we don't have access to
176 ;; the "external roots" of language A from buffers of language B, which
177 ;; seems desirable in multi-language projects, at least for some
178 ;; potential uses, like "jump to a file in project or external dirs".
180 ;; We could add a second argument to this function: a file extension,
181 ;; or a language name. Some projects will know the set of languages
182 ;; used in them; for others, like VC-based projects, we'll need
183 ;; auto-detection. I see two options:
185 ;; - That could be implemented as a separate second hook, with a
186 ;; list of functions that return file extensions.
188 ;; - This variable will be turned into a hook with "append" semantics,
189 ;; and each function in it will perform auto-detection when passed
190 ;; nil instead of an actual file extension. Then this hook will, in
191 ;; general, be modified globally, and not from major mode functions.
193 ;; The second option seems simpler, but the first one has the
194 ;; advantage that the user could override the list of languages used
195 ;; in a project via a directory-local variable, thus skipping
196 ;; languages they're not working on personally (in a big project), or
197 ;; working around problems in language detection (the detection logic
198 ;; might be imperfect for the project in question, or it might work
199 ;; too slowly for the user's taste).
200 (defvar project-vc-external-roots-function (lambda () tags-table-list)
201 "Function that returns a list of external roots.
203 It should return a list of directory roots that contain source
204 files related to the current buffer.
206 The directory names should be absolute. Used in the VC project
207 backend implementation of `project-external-roots'.")
209 (defun project-try-vc (dir)
210 (let* ((backend (ignore-errors (vc-responsible-backend dir)))
211 (root (and backend (ignore-errors
212 (vc-call-backend backend 'root dir)))))
213 (and root (cons 'vc root))))
215 (cl-defmethod project-roots ((project (head vc)))
216 (list (cdr project)))
218 (cl-defmethod project-external-roots ((project (head vc)))
219 (project-subtract-directories
220 (project-combine-directories
222 #'file-name-as-directory
223 (funcall project-vc-external-roots-function)))
224 (project-roots project)))
226 (cl-defmethod project-ignores ((project (head vc)) dir)
227 (let* ((root (cdr project))
230 (when (file-equal-p dir root)
231 (setq backend (vc-responsible-backend root))
234 (if (string-match "\\`/" entry)
235 (replace-match "./" t t entry)
237 (vc-call-backend backend 'ignore-completion-table root)))
238 (project--value-in-dir 'project-vc-ignores root)
239 (cl-call-next-method))))
241 (defun project-combine-directories (&rest lists-of-dirs)
242 "Return a sorted and culled list of directory names.
243 Appends the elements of LISTS-OF-DIRS together, removes
244 non-existing directories, as well as directories a parent of
245 whose is already in the list."
249 (file-name-as-directory (expand-file-name dir)))
250 (apply #'append lists-of-dirs))
253 ;; Delete subdirectories from the list.
255 (if (string-prefix-p (car ref) (cadr ref))
256 (setcdr ref (cddr ref))
257 (setq ref (cdr ref))))
258 (cl-delete-if-not #'file-exists-p dirs)))
260 (defun project-subtract-directories (files dirs)
261 "Return a list of elements from FILES that are outside of DIRS.
262 DIRS must contain directory names."
263 ;; Sidestep the issue of expanded/abbreviated file names here.
264 (cl-set-difference files dirs :test #'file-in-directory-p))
266 (defun project--value-in-dir (var dir)
268 (setq default-directory dir)
269 (let ((enable-local-variables :all))
270 (hack-dir-local-variables-non-file-buffer))
273 (declare-function grep-read-files "grep")
274 (declare-function xref--show-xrefs "xref")
275 (declare-function xref-backend-identifier-at-point "xref")
276 (declare-function xref--find-ignores-arguments "xref")
279 (defun project-find-regexp (regexp)
280 "Find all matches for REGEXP in the current project's roots.
281 With \\[universal-argument] prefix, you can specify the directory
282 to search in, and the file name pattern to search for."
283 (interactive (list (project--read-regexp)))
284 (let* ((pr (project-current t))
285 (dirs (if current-prefix-arg
286 (list (read-directory-name "Base directory: "
287 nil default-directory t))
288 (project-roots pr))))
289 (project--find-regexp-in dirs regexp pr)))
292 (defun project-or-external-find-regexp (regexp)
293 "Find all matches for REGEXP in the project roots or external roots.
294 With \\[universal-argument] prefix, you can specify the file name
295 pattern to search for."
296 (interactive (list (project--read-regexp)))
297 (let* ((pr (project-current t))
300 (project-external-roots pr))))
301 (project--find-regexp-in dirs regexp pr)))
303 (defun project--read-regexp ()
304 (let ((id (xref-backend-identifier-at-point (xref-find-backend))))
305 (read-regexp "Find regexp" (and id (regexp-quote id)))))
307 (defun project--find-regexp-in (dirs regexp project)
309 (let* ((files (if current-prefix-arg
310 (grep-read-files regexp)
314 (xref-collect-matches regexp files dir
315 (project-ignores project dir)))
318 (user-error "No matches for: %s" regexp))
319 (xref--show-xrefs xrefs nil)))
322 (defun project-find-file ()
323 "Visit a file (with completion) in the current project's roots.
324 The completion default is the filename at point, if one is
327 (let* ((pr (project-current t))
328 (dirs (project-roots pr)))
329 (project-find-file-in (thing-at-point 'filename) dirs pr)))
332 (defun project-or-external-find-file ()
333 "Visit a file (with completion) in the current project's roots or external roots.
334 The completion default is the filename at point, if one is
337 (let* ((pr (project-current t))
340 (project-external-roots pr))))
341 (project-find-file-in (thing-at-point 'filename) dirs pr)))
343 ;; FIXME: Uniquely abbreviate the roots?
344 (cl-defmethod project-file-completion-table (project dirs)
345 "Default implementation using `find-program'."
351 (format "%s %s %s -type f -print0"
354 (xref--find-ignores-arguments
355 (project-ignores project dir)
356 (expand-file-name dir)))))
357 (split-string (shell-command-to-string command) "\0" t)))
359 (lambda (string pred action)
361 ((eq action 'metadata)
362 '(metadata . ((category . project-file))))
364 (complete-with-action action all-files string pred))))
367 (defun project-find-file-in (filename dirs project)
368 "Complete FILENAME in DIRS in PROJECT, visit the file."
369 ;; FIXME: verify that filename is accepted by the completion table
373 (format "Find file (%s): " filename)
375 (project--file-completion-table project dirs)
376 nil t nil nil filename)))
379 ;;; project.el ends here