Refactor Project API to reflect changes upstream

projectile-project-root no longer returns `default-directory` if not in
a project (it returns nil). As such, doom-project-* functions (and their
uses) have been refactored.

+ doom-project-p & doom-project-root are aliases for
  projectile-project-p & projectile-project-root.
+ doom-project-{p,root,name,expand} now has a DIR argument (for
  consistency, since projectile-project-name and
  projectile-project-expand do not).
+ The nocache parameter is no longer necessary, as projectile's caching
  behavior is now more sane.
+ Removed some projectile advice/hacks that are no longer necessary.
+ Updated unit tests

core/autoload/buffers.el

@@ -65,7 +65,7 @@ scratch buffer. See `doom-fallback-buffer-name' to change this."
 
 If no project is active, return all buffers."
   (let ((buffers (doom-buffer-list)))
-    (if-let* ((project-root (if (doom-project-p) (doom-project-root))))
+    (if-let* ((project-root (doom-project-root)))
         (cl-loop for buf in buffers
                  if (projectile-project-buffer-p buf project-root)
                  collect buf)

core/autoload/files.el

@@ -88,8 +88,8 @@ MATCH is a string regexp. Only entries that match it will be included."
       (recentf-add-file new-path))
     (recentf-remove-if-non-kept old-path))
   (when (and (bound-and-true-p projectile-mode)
-             (projectile-project-p)
+             (doom-project-p)
-             (projectile-file-cached-p old-path (doom-project-root 'nocache)))
+             (projectile-file-cached-p old-path (doom-project-root)))
     (projectile-purge-file-from-cache old-path))
   (when (bound-and-true-p save-place-mode)
     (save-place-forget-unreadable-files)))
@@ -111,7 +111,7 @@ MATCH is a string regexp. Only entries that match it will be included."
                             (list new-path))))
          (new-path-dir (file-name-directory new-path))
          (project-root (doom-project-root))
-         (short-new-name (if (file-in-directory-p new-path project-root)
+         (short-new-name (if (and project-root (file-in-directory-p new-path project-root))
                              (file-relative-name new-path project-root)
                            (abbreviate-file-name new-path))))
     (unless (file-directory-p new-path-dir)

core/autoload/projects.el

@@ -38,33 +38,23 @@ they are absolute."
 ;; Library
 
 ;;;###autoload
-(defun doom-project-p (&optional nocache)
+(defalias 'doom-project-p #'projectile-project-p)
-  "Return t if this buffer is currently in a project.
-If NOCACHE, don't fetch a cached answer."
-  (if nocache
-      (without-project-cache! (doom-project-p nil))
-    (let ((projectile-require-project-root t))
-      (and (projectile-project-p) t))))
 
 ;;;###autoload
-(defun doom-project-name (&optional nocache)
+(defalias 'doom-project-root #'projectile-project-root)
-  "Return the name of the current project.
-If NOCACHE, don't fetch a cached answer."
-  (if nocache
-      (without-project-cache! (doom-project-name nil))
-    (projectile-project-name)))
 
 ;;;###autoload
-(defun doom-project-root (&optional nocache)
+(defun doom-project-name (&optional dir)
-  "Returns the root of your project, or `default-directory' if none was found.
+  "Return the name of the current project."
-If NOCACHE, don't fetch a cached answer."
+  (let ((project-root (projectile-project-root dir)))
-  (if nocache
+    (if project-root
-      (without-project-cache! (doom-project-root nil))
+        (funcall projectile-project-name-function project-root)
-    (let (projectile-require-project-root)
+      "-")))
-      (projectile-project-root))))
 
 ;;;###autoload
-(defalias 'doom-project-expand #'projectile-expand-root)
+(defun doom-project-expand (name &optional dir)
+  "Expand NAME to project root."
+  (expand-file-name name (projectile-project-root dir)))
 
 ;;;###autoload
 (defun doom-project-find-file (dir)

core/core-projects.el

@@ -45,30 +45,14 @@
                     projectile-project-root-files)
             projectile-project-root-files-bottom-up nil)))
 
-  ;; Restores the old behavior of `projectile-project-root', where it returns
-  ;; `default-directory' if not in a project, at least until I update Doom to
-  ;; deal with this.
-  ;; FIXME Check again after https://github.com/bbatsov/projectile/issues/1296
-  (defun doom*projectile-project-root (project-root)
-    (or project-root
-        default-directory))
-  (advice-add #'projectile-project-root :filter-return #'doom*projectile-project-root)
-
   ;; Projectile root-searching functions can cause an infinite loop on TRAMP
   ;; connections, so disable them.
+  ;; TODO Is this still necessary?
   (defun doom*projectile-locate-dominating-file (orig-fn file name)
     "Don't traverse the file system if on a remote connection."
     (unless (file-remote-p default-directory)
       (funcall orig-fn file name)))
-  (advice-add #'projectile-locate-dominating-file :around #'doom*projectile-locate-dominating-file)
+  (advice-add #'projectile-locate-dominating-file :around #'doom*projectile-locate-dominating-file))
-
-  (defun doom*projectile-cache-current-file (orig-fn)
-    "Don't cache ignored files."
-    (unless (cl-loop for path in (projectile-ignored-directories)
-                     if (string-prefix-p (or buffer-file-name "") (expand-file-name path))
-                     return t)
-      (funcall orig-fn)))
-  (advice-add #'projectile-cache-current-file :around #'doom*projectile-cache-current-file))
 
 
 ;;

core/test/test-core-projects.el

@@ -10,29 +10,21 @@
 
   (describe "project-p"
     (it "Should detect when in a valid project"
-      (let ((buffer-file-name (expand-file-name "init.el" doom-emacs-dir))
+      (expect (doom-project-p doom-emacs-dir)))
-            (default-directory doom-emacs-dir))
-        (expect (doom-project-p))))
     (it "Should detect when not in a valid project"
-      (let ((buffer-file-name (expand-file-name "test" "~"))
+      (expect (doom-project-p (expand-file-name "~")) :to-be nil)))
-            (default-directory (expand-file-name "~")))
-        (expect (doom-project-p) :to-be nil))))
 
   (describe "project-root"
     (it "should resolve to the project's root"
-      (let ((buffer-file-name (expand-file-name "core.el" doom-core-dir))
+      (expect (doom-project-root doom-core-dir) :to-equal doom-emacs-dir))
-            (default-directory doom-core-dir))
-        (expect (doom-project-root) :to-equal doom-emacs-dir)))
     (it "should resolve to the `default-directory'"
-      (let ((buffer-file-name (expand-file-name "test" "/"))
+      (expect (doom-project-root (expand-file-name "~"))
-            (default-directory (expand-file-name "/")))
+              :to-equal (expand-file-name "~"))))
-        (expect (doom-project-root) :to-equal default-directory))))
 
   (describe "project-expand"
     (it "expands to a path relative to the project root"
-      (let ((default-directory doom-core-dir))
+      (expect (doom-project-expand "init.el" doom-core-dir)
-        (expect (doom-project-expand "init.el")
+              :to-equal (expand-file-name "init.el" (doom-project-root doom-core-dir)))))
-                :to-equal (expand-file-name "init.el" (doom-project-root))))))
 
   (describe "project-file-exists-p!"
     (let ((default-directory doom-core-dir))

modules/completion/helm/autoload/helm.el

@@ -13,7 +13,7 @@
   (interactive)
   (call-interactively
    (if (or (file-equal-p default-directory "~")
-           (when-let* ((proot (doom-project-root 'nocache)))
+           (when-let* ((proot (doom-project-root)))
              (file-equal-p proot "~")))
        #'helm-find-files
      #'helm-projectile-find-file)))

modules/completion/ivy/autoload/ivy.el

@@ -217,11 +217,11 @@ The point of this is to avoid Emacs locking up indexing massive file trees."
   (interactive)
   (call-interactively
    (cond ((or (file-equal-p default-directory "~")
-              (when-let* ((proot (doom-project-root 'nocache)))
+              (when-let* ((proot (doom-project-root)))
                 (file-equal-p proot "~")))
           #'counsel-find-file)
 
-         ((doom-project-p 'nocache)
+         ((doom-project-p)
           (let ((files (projectile-current-project-files)))
             (if (<= (length files) ivy-sort-max-size)
                 #'counsel-projectile-find-file

modules/emacs/eshell/autoload/commands.el

@@ -3,9 +3,7 @@
 ;;;###autoload
 (defun eshell/cd-to-project ()
   "Change to the project root of the current directory."
-  (let* ((default-directory (eshell/pwd))
+  (eshell/cd (doom-project-root (eshell/pwd))))
-         (project-root (doom-project-root 'nocache)))
-    (eshell/cd project-root)))
 
 ;;;###autoload
 (defun eshell/quit-and-close (&rest _)

modules/emacs/term/autoload.el

@@ -7,7 +7,7 @@ non-nil, cd into the current project's root."
   (interactive "P")
   (let ((default-directory
           (if arg
-              (doom-project-root 'nocache)
+              (or (doom-project-root) default-directory)
             default-directory)))
     ;; Doom's switch-buffer hooks prevent themselves from triggering when
     ;; switching from buffer A back to A. Because `multi-term' uses `set-buffer'
@@ -22,7 +22,7 @@ non-nil, cd into the current project's root."
   (interactive "P")
   (let ((default-directory
           (if arg
-              (doom-project-root 'nocache)
+              (or (doom-project-root) default-directory)
             default-directory)))
     (pop-to-buffer (save-window-excursion (multi-term)))))
 

modules/feature/eval/autoload/repl.el

@@ -11,7 +11,7 @@
              (unless (buffer-live-p buffer)
                (remhash key +eval-repl-buffers)))
            +eval-repl-buffers)
-  (let* ((project-root (doom-project-root 'nocache))
+  (let* ((project-root (doom-project-root))
          (key (cons major-mode project-root))
          (buffer (gethash key +eval-repl-buffers)))
     (cl-check-type buffer (or buffer null))

modules/feature/lookup/autoload/lookup.el

@@ -288,7 +288,7 @@ Otherwise, falls back on `find-file-at-point'."
            (when (and buffer-file-name (file-equal-p fullpath buffer-file-name))
              (user-error "Already here"))
            (let* ((insert-default-directory t)
-                  (project-root (doom-project-root 'nocache))
+                  (project-root (doom-project-root))
                   (ffap-file-finder
                    (cond ((not (file-directory-p fullpath))
                           #'find-file)

modules/lang/cc/autoload.el

@@ -104,7 +104,7 @@ preceded by the opening brace or a comma (disregarding whitespace in between)."
              (executable-find "rc"))
     (with-temp-buffer
       (message "Reloaded compile commands for rtags daemon")
-      (rtags-call-rc :silent t "-J" (doom-project-root))))
+      (rtags-call-rc :silent t "-J" (or (doom-project-root) default-directory))))
   ;; then irony
   (when (and (featurep 'irony) irony-mode)
     (+cc|irony-init-compile-options)))

modules/lang/org/autoload/org-capture.el

@@ -82,7 +82,7 @@ you're done. This can be called from an external shell script."
      filename
      (or (locate-dominating-file (file-truename default-directory)
                                  filename)
-         (if (doom-project-p 'nocache) (doom-project-root 'nocache))
+         (doom-project-root)
          (user-error "Couldn't detect a project")))))
 
 ;;;###autoload

modules/lang/php/config.el

@@ -49,7 +49,8 @@
     (setq phpactor-working-dir
           (or phpactor-working-dir
               (php-project-get-root-dir)
-              (doom-project-root))))
+              (doom-project-root)
+              default-directory)))
   (advice-add #'phpactor-get-working-dir :before #'+php*project-root)
 
   (map! :map php-mode-map

modules/lang/python/autoload/python.el

@@ -38,7 +38,7 @@ started it."
             (puthash proot
                      (+python--extract-version "Pipenv " v)
                      +python-version-cache))
-        (puthash (doom-project-root)
+        (puthash (or (doom-project-root) default-directory)
                  (+python--extract-version "Python " (car (process-lines "python" "--version")))
                  +python-version-cache))
     (error "Python")))
@@ -53,7 +53,8 @@ started it."
   (setq +python--version
         (or (gethash (or (and (fboundp 'pipenv-project-p)
                               (pipenv-project-p))
-                         (doom-project-root))
+                         (doom-project-root)
+                         default-directory)
                      +python-version-cache)
             (+python-version))))
 

modules/lang/ruby/autoload.el

@@ -27,7 +27,7 @@ pipenv, unless those tools have modified the PATH that Emacs picked up when you
 started it."
   (condition-case _
       (let ((version-str (car (process-lines "ruby" "--version"))))
-        (puthash (doom-project-root)
+        (puthash (or (doom-project-root) default-directory)
                  (format "Ruby %s" (cadr (split-string version-str " ")))
                  +ruby-version-cache))
     (error "Ruby")))
@@ -40,7 +40,8 @@ started it."
 (defun +ruby|update-version (&rest _)
   "Update `+ruby--version' by consulting `+ruby-version' function."
   (setq +ruby--version
-        (or (gethash (doom-project-root) +python-version-cache)
+        (or (gethash (or (doom-project-root) default-directory)
+                     +python-version-cache)
             (+ruby-version))))
 
 ;;;###autoload

modules/tools/macos/autoload.el

@@ -31,7 +31,8 @@
 (+macos!open-with reveal-in-finder "Finder" default-directory)
 
 ;;;###autoload (autoload '+macos/reveal-project-in-finder "tools/macos/autoload" nil t)
-(+macos!open-with reveal-project-in-finder "Finder" (doom-project-root))
+(+macos!open-with reveal-project-in-finder "Finder"
+                  (or (doom-project-root) default-directory))
 
 ;;;###autoload (autoload '+macos/send-to-transmit "tools/macos/autoload" nil t)
 (+macos!open-with send-to-transmit "Transmit")
@@ -43,4 +44,5 @@
 (+macos!open-with send-to-launchbar "LaunchBar")
 
 ;;;###autoload (autoload '+macos/send-project-to-launchbar "tools/macos/autoload" nil t)
-(+macos!open-with send-project-to-launchbar "LaunchBar" (doom-project-root))
+(+macos!open-with send-project-to-launchbar "LaunchBar"
+                  (or (doom-project-root) default-directory))

modules/tools/make/autoload.el

@@ -7,7 +7,7 @@
   "Run a make task in the current project. If multiple makefiles are available,
 you'll be prompted to select one."
   (interactive)
-  (if (doom-project-p 'nocache)
+  (if (doom-project-p)
       (makefile-executor-execute-project-target)
     (let ((makefile (cl-loop with buffer-file = (or buffer-file-name default-directory)
                              for file in (list "Makefile" "makefile")

modules/tools/prodigy/autoload.el

@@ -44,7 +44,7 @@
 (defun +prodigy*services (orig-fn &rest args)
   "Adds a new :project property to prodigy services, which hides the service
 unless invoked from the relevant project."
-  (let ((project-root (downcase (doom-project-root)))
+  (let ((project-root (downcase (or (doom-project-root) default-directory)))
         (services (apply orig-fn args)))
     (if current-prefix-arg
         services

modules/ui/modeline/config.el

@@ -314,7 +314,7 @@ e.g. ~/w/project/src/lib/file.c
 Meant for `+modeline-buffer-path-function'."
   (pcase-let
       ((`(,root-parent ,root ,dir, file)
-        (shrink-path-file-mixed (doom-project-root)
+        (shrink-path-file-mixed (or (doom-project-root) default-directory)
                                 (file-name-directory buffer-file-name)
                                 buffer-file-name)))
     (list (cons root-parent 'font-lock-comment-face)

modules/ui/neotree/autoload.el

@@ -8,7 +8,7 @@
 (defun +neotree/open ()
   "Open the neotree window in the current project."
   (interactive)
-  (let ((project-root (doom-project-root 'nocache)))
+  (let ((project-root (doom-project-root)))
     (require 'neotree)
     (if (neo-global--window-exists-p)
         (neotree-hide)
@@ -19,7 +19,7 @@
   "Open the neotree window in the current project, and find the current file."
   (interactive)
   (let ((path buffer-file-name)
-        (project-root (doom-project-root 'nocache)))
+        (project-root (doom-project-root)))
     (require 'neotree)
     (cond ((and (neo-global--window-exists-p)
                 (get-buffer-window neo-buffer-name t))

modules/ui/treemacs/autoload.el

@@ -10,8 +10,8 @@
       (treemacs-do-remove-project-from-workspace project))
     (with-current-buffer origin-buffer
       (treemacs-do-add-project-to-workspace
-       (treemacs--canonical-path (doom-project-root 'nocache))
+       (treemacs--canonical-path (doom-project-root))
-       (doom-project-name 'nocache))
+       (doom-project-name))
       (setq treemacs--ready-to-follow t)
       (when (or treemacs-follow-after-init treemacs-follow-mode)
         (treemacs--follow)))))