Merge pull request #43 from flycheck/refactor-rust-cargo

Use cargo to find the build target

Author: fmdkdd

Cask

@@ -2,3 +2,8 @@
 (source melpa)
 
 (package-file "flycheck-rust.el")
+
+(development
+ (depends-on "buttercup")               ; BDD test framework for Emacs
+ (depends-on "rust-mode")
+ )

Makefile

@@ -0,0 +1,25 @@
+# Copyright (c) 2016 fmdkdd
+
+# 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 of the License, 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
+# this program.  If not, see <http://www.gnu.org/licenses/>.
+
+CASK = cask
+
+.PHONY: init
+init:
+	$(CASK) install
+	$(CASK) update
+
+.PHONY: test
+test:
+	$(CASK) exec buttercup -L .

README.md

@@ -32,10 +32,6 @@ Usage
 
 Just use Flycheck as usual in your Rust/Cargo projects.
 
-**Note:** You must run `cargo build` initially to install all dependencies.  If
-you add new dependencies to `Cargo.toml` you need to run `cargo build` again.
-Otherwise you will see spurious errors about missing crates.
-
 License
 -------
 

flycheck-rust.el

@@ -35,10 +35,6 @@
 ;; # Usage
 ;;
 ;; Just use Flycheck as usual in your Rust/Cargo projects.
-;;
-;; Note: You must run `cargo build` initially to install all dependencies.  If
-;; you add new dependencies to `Cargo.toml` you need to run `cargo build`
-;; again. Otherwise you will see spurious errors about missing crates.
 
 ;;; Code:
 
@@ -47,86 +43,107 @@
 (require 'seq)
 (require 'json)
 
-(defun flycheck-rust-executable-p (rel-name)
-  "Whether REL-NAME denotes an executable.
-
-REL-NAME is the file relative to the Cargo.toml file."
-  (or (string= "src/main.rs" rel-name)
-      (string-prefix-p "src/bin/" rel-name)))
-
-(defun flycheck-rust-test-p (rel-name)
-  "Whether REL-NAME denotes a test.
-
-REL-NAME is the file relative to the Cargo.toml file."
-  (string-prefix-p "tests/" rel-name))
-
-(defun flycheck-rust-bench-p (rel-name)
-  "Whether REL-NAME denotes a bench.
-
-REL-NAME is the file relative to the Cargo.toml file."
-  (string-prefix-p "benches/" rel-name))
-
-(defun flycheck-rust-example-p (rel-name)
-  "Whether REL-NAME denotes an example.
-
-REL-NAME is the file relative to the Cargo.toml file."
-  (string-prefix-p "examples/" rel-name))
+(defun flycheck-rust-find-manifest (file-name)
+  "Get the Cargo.toml manifest for FILE-NAME.
 
-(defun flycheck-rust-project-root ()
-  "Get the project root for the current buffer.
+FILE-NAME is the path of a file in a cargo project given as a
+string.
 
-Return the directory containing the Cargo file, or nil if there
-is none."
-  (locate-dominating-file (buffer-file-name) "Cargo.toml"))
+See http://doc.crates.io/guide.html for an introduction to the
+Cargo.toml manifest.
 
-(defun flycheck-rust-find-crate-root ()
-  "Get the crate root (the nearest lib.rs or main.rs)
-relative to the current file."
-  (-if-let (lib-crate-dir (locate-dominating-file (buffer-file-name) "lib.rs"))
-      (expand-file-name "lib.rs" lib-crate-dir)
-    (-when-let (exe-crate-dir (locate-dominating-file (buffer-file-name) "main.rs"))
-      (expand-file-name "main.rs" exe-crate-dir))))
+Return the path to the Cargo.toml manifest file, or nil if the
+manifest could not be located."
+  (-when-let (root-dir (locate-dominating-file file-name "Cargo.toml"))
+    (expand-file-name "Cargo.toml" root-dir)))
 
-(defun flycheck-rust-binary-crate-p (project-root)
-  "Determine whether PROJECT-ROOT is a binary crate.
+(defun flycheck-rust-dirs-list (start end)
+  "Return a list of directories from START (inclusive) to END (exclusive).
 
-PROJECT-ROOT is the path to the root directory of the project.
+E.g., if START is '/a/b/c/d' and END is '/a', return the list
+'(/a/b/c/d /a/b/c /a/b) in this order.
 
-Return non-nil if PROJECT-ROOT is a binary crate, nil otherwise."
-  (let ((root-dir (file-name-directory project-root)))
-    (file-exists-p (expand-file-name "src/main.rs" root-dir))))
+START and END are strings representing file paths.  END should be
+above START in the file hierarchy; if not, the list stops at the
+root of the file hierarchy."
+  (let ((dirlist)
+        (dir (expand-file-name start))
+        (end (expand-file-name end)))
+    (while (not (or (equal dir (car dirlist)) ; avoid infinite loop
+                    (file-equal-p dir end)))
+      (push dir dirlist)
+      (setq dir (directory-file-name (file-name-directory dir))))
+    (nreverse dirlist)))
 
-(defun flycheck-rust-find-target (file-name)
-  "Find and return the cargo target associated with the given file.
+(defun flycheck-rust-get-cargo-targets (manifest)
+  "Return the list of available Cargo targets for the given project.
 
-FILE-NAME is the name of the file that is matched against the
-`src_path' value in the list `targets' returned by `cargo
-read-manifest'.  If there is no match, the first target is
-returned by default.
+MANIFEST is the path to the Cargo.toml file of the project.
 
-Return a cons cell (TYPE . NAME), where TYPE is the target
-type (lib or bin), and NAME the target name (usually, the crate
-name)."
-  (let ((json-array-type 'list)
-        (cargo (funcall flycheck-executable-find "cargo")))
+Calls `cargo metadata --no-deps --manifest MANIFEST', parses and
+collects the targets for the current workspace, and returns them
+in a list, or nil if no targets could be found."
+  (let ((cargo (funcall flycheck-executable-find "cargo")))
     (unless cargo
       (user-error "flycheck-rust cannot find `cargo'.  Please \
 make sure that cargo is installed and on your PATH.  See \
 http://www.flycheck.org/en/latest/user/troubleshooting.html for \
 more information on setting your PATH with Emacs."))
-    (-let [(&alist 'targets targets)
-           (with-temp-buffer
-             (call-process cargo nil t nil "read-manifest")
-             (goto-char (point-min))
-             (json-read))]
-      ;; If there is a target that matches the file-name exactly, pick that
-      ;; one.  Otherwise, just pick the first target.
-      (-let [(&alist 'kind (kind) 'name name)
-             (seq-find (lambda (target)
-                         (-let [(&alist 'src_path src_path) target]
-                           (string= file-name src_path)))
-                       targets (car targets))]
-          (cons kind name)))))
+    ;; metadata contains a list of packages, and each package has a list of
+    ;; targets.  We concatenate all targets, regardless of the package.
+    (when-let ((packages (let-alist
+                             (with-temp-buffer
+                               (call-process cargo nil t nil
+                                             "metadata" "--no-deps"
+                                             "--manifest-path" manifest)
+                               (goto-char (point-min))
+                               (let ((json-array-type 'list))
+                                 (json-read)))
+                           .packages)))
+      (seq-mapcat (lambda (pkg)
+                    (let-alist pkg .targets))
+                  packages))))
+
+(defun flycheck-rust-find-cargo-target (file-name)
+  "Return the Cargo build target associated with FILE-NAME.
+
+FILE-NAME is the path of the file that is matched against the
+`src_path' value in the list of `targets' returned by `cargo
+read-manifest'.
+
+Return a cons cell (KIND . NAME) where KIND is the target
+kind (lib, bin, test, example or bench), and NAME the target
+name (usually, the crate name).  If FILE-NAME exactly matches a
+target `src-path', this target is returned.  Otherwise, return
+the closest matching target, or nil if no targets could be found.
+
+See http://doc.crates.io/manifest.html#the-project-layout for a
+description of the conventional Cargo project layout."
+  (-when-let* ((manifest (flycheck-rust-find-manifest file-name))
+               (targets (flycheck-rust-get-cargo-targets manifest)))
+    (let ((target
+           (or
+            ;; If there is a target that matches the file-name exactly, pick
+            ;; that one
+            (seq-find (lambda (target)
+                        (let-alist target (string= file-name .src_path)))
+                      targets)
+            ;; Otherwise find the closest matching target by walking up the tree
+            ;; from FILE-NAME and looking for targets in each directory.  E.g.,
+            ;; the file 'tests/common/a.rs' will look for a target in
+            ;; 'tests/common', then in 'tests/', etc.
+            (car (seq-find
+                  (lambda (pair)
+                    (-let [((&alist 'src_path target-path) . dir) pair]
+                      (file-equal-p dir (file-name-directory target-path))))
+                  ;; build a list of (target . dir) candidates
+                  (-table-flat
+                   'cons targets
+                   (flycheck-rust-dirs-list file-name
+                                            (file-name-directory manifest)))))
+            ;; If all else fails, just pick the first target
+            (car targets))))
+      (let-alist target (cons (car .kind) .name)))))
 
 ;;;###autoload
 (defun flycheck-rust-setup ()
@@ -139,37 +156,10 @@ Flycheck according to the Cargo project layout."
   ;; with `global-flycheck-mode' it will render Emacs unusable (see
   ;; https://github.com/flycheck/flycheck-rust/issues/40#issuecomment-253760883).
   (with-demoted-errors "Error in flycheck-rust-setup: %S"
-    (when (buffer-file-name)
-      (-when-let (root (flycheck-rust-project-root))
-        (pcase-let ((rel-name (file-relative-name (buffer-file-name) root))
-                    (`(,target-type . ,target-name) (flycheck-rust-find-target
-                                                     (buffer-file-name))))
-          ;; These are valid crate roots as by Cargo's layout
-          (if (or (flycheck-rust-executable-p rel-name)
-                  (flycheck-rust-test-p rel-name)
-                  (flycheck-rust-bench-p rel-name)
-                  (flycheck-rust-example-p rel-name)
-                  (string= "src/lib.rs" rel-name))
-              (setq-local flycheck-rust-crate-root rel-name)
-            ;; For other files, the library is either the default library or the
-            ;; executable
-            (setq-local flycheck-rust-crate-root (flycheck-rust-find-crate-root)))
-          ;; Check tests in libraries and integration tests
-          (setq-local flycheck-rust-check-tests
-                      (not (flycheck-rust-executable-p rel-name)))
-          ;; Set the crate type
-          (setq-local flycheck-rust-crate-type
-                      (if (string= target-type "bin")
-                          (progn
-                            ;; If it's binary target, we need to pass the binary
-                            ;; name
-                            (setq-local flycheck-rust-binary-name target-name)
-                            "bin")
-                        "lib"))
-          ;; Find build libraries
-          (setq-local flycheck-rust-library-path
-                      (list (expand-file-name "target/debug" root)
-                            (expand-file-name "target/debug/deps" root))))))))
+    (-when-let* ((file-name (buffer-file-name))
+                 ((kind . name) (flycheck-rust-find-cargo-target file-name)))
+      (setq-local flycheck-rust-crate-type kind)
+      (setq-local flycheck-rust-binary-name name))))
 
 (provide 'flycheck-rust)
 

tests/test-crate/Cargo.toml

@@ -0,0 +1,3 @@
+[package]
+name = "test-crate"
+version = "0.1.0"

tests/test-crate/benches/a.rs

@@ -0,0 +1,110 @@
+;;; test-rust-setup.el -*- lexical-binding: t; -*-
+
+;; Copyright (C) 2016 fmdkdd
+
+;; Author: fmdkdd
+
+;; 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 of the License, 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; Integration tests for `flycheck-rust-setup'.
+
+;;; Code:
+
+(require 'flycheck-rust)
+
+(buttercup-define-matcher :to-equal-one-of (elt &rest seq)
+  (if (member elt seq)
+      (cons t (format "Expected %S not to equal a member of %S" elt seq))
+    (cons nil (format "Expected %S to equal a member of %S" elt seq))))
+
+(defun crate-file (file-name)
+  (expand-file-name file-name "tests/test-crate"))
+
+(describe
+ "`flycheck-rust-find-cargo-target' associates"
+
+ (it "'src/lib.rs' to the library target"
+     (expect
+      (car (flycheck-rust-find-cargo-target (crate-file "src/lib.rs")))
+      :to-equal "lib"))
+
+ (it "'src/a.rs' to the library target"
+     (expect
+      (car (flycheck-rust-find-cargo-target (crate-file "src/a.rs")))
+      :to-equal "lib"))
+
+ (it "'src/main.rs' to the main binary target"
+     (expect
+      (flycheck-rust-find-cargo-target (crate-file "src/main.rs"))
+      :to-equal '("bin" . "test-crate")))
+
+ (it "'src/bin/a.rs' to the 'a' binary target"
+     (expect
+      (flycheck-rust-find-cargo-target (crate-file "src/bin/a.rs"))
+      :to-equal '("bin" . "a")))
+
+ (it "'src/bin/b.rs' to the 'b' binary target"
+     (expect
+      (flycheck-rust-find-cargo-target (crate-file "src/bin/b.rs"))
+      :to-equal '("bin" . "b")))
+
+ (it "'src/bin/support/mod.rs' to the 'b' binary target"
+     (expect
+      (flycheck-rust-find-cargo-target (crate-file "src/bin/support/mod.rs"))
+      :to-equal '("bin" . "b")))
+
+ (it "'tests/a.rs' to the 'a' test target"
+     (expect
+      (flycheck-rust-find-cargo-target (crate-file "tests/a.rs"))
+      :to-equal '("test" . "a")))
+
+ (it "'tests/support/mod.rs' to any test target"
+     (expect
+      (flycheck-rust-find-cargo-target (crate-file "tests/support/mod.rs"))
+      :to-equal-one-of '("test". "a") '("test". "b")))
+
+ (it "'examples/a.rs' to the 'a' example target"
+     (expect
+      (flycheck-rust-find-cargo-target (crate-file "examples/a.rs"))
+      :to-equal '("example" . "a")))
+
+ (it "'examples/b.rs' to the 'b' example target"
+     (expect
+      (flycheck-rust-find-cargo-target (crate-file "examples/b.rs"))
+      :to-equal '("example" . "b")))
+
+ (it "'examples/support/mod.rs' to any example target"
+     (expect
+      (flycheck-rust-find-cargo-target (crate-file "examples/support/mod.rs"))
+      :to-equal-one-of '("example" . "a") '("example" . "b")))
+
+ (it "'benches/a.rs' to the 'a' bench target"
+     (expect
+      (flycheck-rust-find-cargo-target (crate-file "benches/a.rs"))
+      :to-equal '("bench" . "a")))
+
+ (it "'benches/b.rs' to the 'b' bench target"
+     (expect
+      (flycheck-rust-find-cargo-target (crate-file "benches/b.rs"))
+      :to-equal '("bench" . "b")))
+
+ (it "'benches/support/mod.rs' to any bench target"
+     (expect
+      (flycheck-rust-find-cargo-target (crate-file "benches/support/mod.rs"))
+      :to-equal-one-of '("bench" . "a") '("bench" . "b")))
+ )