Infer targets from subdirectories

src/cargo/util/toml/targets.rs

@@ -5,6 +5,7 @@
 //!  * `src/bin/*.rs` are binaries
 //!  * `examples/*.rs` are examples
 //!  * `tests/*.rs` are integration tests
+//!  * `benches/*.rs` are benchmarks
 //!
 //! It is a bit tricky because we need match explicit information from `Cargo.toml`
 //! with implicit info in directory layout.
@@ -218,8 +219,11 @@ fn clean_examples(toml_examples: Option<&Vec<TomlExampleTarget>>,
                   package_root: &Path,
                   errors: &mut Vec<String>)
                   -> CargoResult<Vec<Target>> {
+
+    let inferred = infer_from_directory(&package_root.join("examples"));
+
     let targets = clean_targets("example", "example",
-                                toml_examples, inferred_examples(package_root),
+                                toml_examples, inferred,
                                 package_root, errors)?;
 
     let mut result = Vec::new();
@@ -241,8 +245,11 @@ fn clean_examples(toml_examples: Option<&Vec<TomlExampleTarget>>,
 fn clean_tests(toml_tests: Option<&Vec<TomlTestTarget>>,
                package_root: &Path,
                errors: &mut Vec<String>) -> CargoResult<Vec<Target>> {
+
+    let inferred = infer_from_directory(&package_root.join("tests"));
+
     let targets = clean_targets("test", "test",
-                                toml_tests, inferred_tests(package_root),
+                                toml_tests, inferred,
                                 package_root, errors)?;
 
     let mut result = Vec::new();
@@ -272,8 +279,10 @@ fn clean_benches(toml_benches: Option<&Vec<TomlBenchTarget>>,
         Some(legacy_path)
     };
 
+    let inferred = infer_from_directory(&package_root.join("benches"));
+
     let targets = clean_targets_with_legacy_path("benchmark", "bench",
-                                                 toml_benches, inferred_benches(package_root),
+                                                 toml_benches, inferred,
                                                  package_root,
                                                  errors,
                                                  &mut legacy_bench_path)?;
@@ -359,41 +368,9 @@ fn inferred_bins(package_root: &Path, package_name: &str) -> Vec<(String, PathBu
     }
     result.extend(infer_from_directory(&package_root.join("src").join("bin")));
 
-    if let Ok(entries) = fs::read_dir(&package_root.join("src").join("bin")) {
-        let multifile_bins = entries
-            .filter_map(|e| e.ok())
-            .filter(is_not_dotfile)
-            .filter(|e| match e.file_type() {
-                Ok(t) if t.is_dir() => true,
-                _ => false
-            })
-            .filter_map(|entry| {
-                let dir = entry.path();
-                let main = dir.join("main.rs");
-                let name = dir.file_name().and_then(|n| n.to_str());
-                match (main.exists(), name) {
-                    (true, Some(name)) => Some((name.to_owned(), main)),
-                    _ => None
-                }
-            });
-        result.extend(multifile_bins);
-    }
-
     result
 }
 
-fn inferred_examples(package_root: &Path) -> Vec<(String, PathBuf)> {
-    infer_from_directory(&package_root.join("examples"))
-}
-
-fn inferred_tests(package_root: &Path) -> Vec<(String, PathBuf)> {
-    infer_from_directory(&package_root.join("tests"))
-}
-
-fn inferred_benches(package_root: &Path) -> Vec<(String, PathBuf)> {
-    infer_from_directory(&package_root.join("benches"))
-}
-
 fn infer_from_directory(directory: &Path) -> Vec<(String, PathBuf)> {
     let entries = match fs::read_dir(directory) {
         Err(_) => return Vec::new(),
@@ -403,15 +380,42 @@ fn infer_from_directory(directory: &Path) -> Vec<(String, PathBuf)> {
     entries
         .filter_map(|e| e.ok())
         .filter(is_not_dotfile)
-        .map(|e| e.path())
-        .filter(|f| f.extension().and_then(|s| s.to_str()) == Some("rs"))
-        .filter_map(|f| {
-            f.file_stem().and_then(|s| s.to_str())
-                .map(|s| (s.to_owned(), f.clone()))
-        })
+        .filter_map(infer_any)
         .collect()
 }
 
+
+fn infer_any(entry: DirEntry) -> Option<(String, PathBuf)> {
+    if entry.path().extension().and_then(|p| p.to_str()) == Some("rs") {
+        infer_file(entry)
+    } else if entry.file_type().map(|t| t.is_dir()).ok() == Some(true) {
+        infer_subdirectory(entry)
+    } else {
+        None
+    }
+}
+
+
+fn infer_file(entry: DirEntry) -> Option<(String, PathBuf)> {
+    let path = entry.path();
+    path
+        .file_stem()
+        .and_then(|p| p.to_str()) 
+        .map(|p| (p.to_owned(), path.clone()))
+}
+
+
+fn infer_subdirectory(entry: DirEntry) -> Option<(String, PathBuf)> {
+    let path = entry.path();
+    let main = path.join("main.rs");
+    let name = path.file_name().and_then(|n| n.to_str());
+    match (name, main.exists()) {
+        (Some(name), true) => Some((name.to_owned(), main)),
+        _ => None
+    }
+}
+
+
 fn is_not_dotfile(entry: &DirEntry) -> bool {
     entry.file_name().to_str().map(|s| s.starts_with('.')) == Some(false)
 }

src/doc/manifest.md

@@ -532,7 +532,8 @@ each file you want to build.
 
 Your project can optionally contain folders named `examples`, `tests`, and
 `benches`, which Cargo will treat as containing examples,
-integration tests, and benchmarks respectively.
+integration tests, and benchmarks respectively. Analogous to `bin` targets, they
+may be composed of single files or directories with a `main.rs` file.
 
 ```notrust
 ▾ src/           # directory containing source files
@@ -544,10 +545,16 @@ integration tests, and benchmarks respectively.
     main.rs
 ▾ examples/      # (optional) examples
   *.rs
+  ▾ */           # (optional) directories containing multi-file examples
+    main.rs
 ▾ tests/         # (optional) integration tests
   *.rs
+  ▾ */           # (optional) directories containing multi-file tests
+    main.rs
 ▾ benches/       # (optional) benchmarks
   *.rs
+  ▾ */           # (optional) directories containing multi-file benchmarks
+    main.rs
 ```
 
 To structure your code after you've created the files and folders for your

tests/build.rs

@@ -3495,7 +3495,7 @@ fn dir_and_file_with_same_name_in_bin() {
         .file("src/bin/foo.rs", "fn main() {}")
         .file("src/bin/foo/main.rs", "fn main() {}");
 
-    assert_that(p.cargo_process("build"), 
+    assert_that(p.cargo_process("build"),
                 execs().with_status(101)
                        .with_stderr_contains("\
 [..]found duplicate binary name foo, but all binary targets must have a unique name[..]
@@ -3521,6 +3521,77 @@ fn inferred_path_in_src_bin_foo() {
     assert_that(&p.bin("bar"), existing_file());
 }
 
+#[test]
+fn inferred_examples() {
+    let p = project("foo")
+        .file("Cargo.toml", r#"
+            [package]
+            name = "foo"
+            version = "0.1.0"
+            authors = []
+        "#)
+        .file("src/lib.rs", "fn main() {}")
+        .file("examples/bar.rs", "fn main() {}")
+        .file("examples/baz/main.rs", "fn main() {}");
+
+    assert_that(p.cargo_process("test"), execs().with_status(0));
+    assert_that(&p.bin("examples/bar"), existing_file());
+    assert_that(&p.bin("examples/baz"), existing_file());
+}
+
+#[test]
+fn inferred_tests() {
+    let p = project("foo")
+        .file("Cargo.toml", r#"
+            [package]
+            name = "foo"
+            version = "0.1.0"
+            authors = []
+        "#)
+        .file("src/lib.rs", "fn main() {}")
+        .file("tests/bar.rs", "fn main() {}")
+        .file("tests/baz/main.rs", "fn main() {}");
+
+    assert_that(
+        p.cargo_process("test").arg("--test=bar").arg("--test=baz"),
+        execs().with_status(0));
+}
+
+#[test]
+fn inferred_benchmark() {
+    let p = project("foo")
+        .file("Cargo.toml", r#"
+            [package]
+            name = "foo"
+            version = "0.1.0"
+            authors = []
+        "#)
+        .file("src/lib.rs", "fn main() {}")
+        .file("benches/bar.rs", "fn main() {}");
+
+    assert_that(
+        p.cargo_process("bench").arg("--bench=bar"),
+        execs().with_status(0));
+}
+
+#[test]
+fn inferred_benchmark_from_directory() {
+    //FIXME: merge with `inferred_benchmark` after fixing #4504
+    let p = project("foo")
+        .file("Cargo.toml", r#"
+            [package]
+            name = "foo"
+            version = "0.1.0"
+            authors = []
+        "#)
+        .file("src/lib.rs", "fn main() {}")
+        .file("benches/bar/main.rs", "fn main() {}");
+
+    assert_that(
+        p.cargo_process("bench").arg("--bench=bar"),
+        execs().with_status(0));
+}
+
 #[test]
 fn same_metadata_different_directory() {
     // A top-level crate built in two different workspaces should have the