Allow cargo-fmt to handle formatting individual files.

Adds an additional command line option ``--src-file`` / ``-s``

Tests were added in ``src/cargo-fmt/test/mod.rs`` and integration tests
were added to ``tests/cargo-fmt/main.rs``

Author: ytmimi

src/cargo-fmt/main.rs

@@ -44,6 +44,10 @@ pub struct Opts {
     #[structopt(short = "p", long = "package", value_name = "package")]
     packages: Vec<String>,
 
+    /// Specify a source file to format
+    #[structopt(short = "s", long = "src-file", value_name = "src-file")]
+    src_files: Vec<PathBuf>,
+
     /// Specify path to Cargo.toml
     #[structopt(long = "manifest-path", value_name = "manifest-path")]
     manifest_path: Option<String>,
@@ -89,6 +93,16 @@ fn execute() -> i32 {
 
     let opts = Opts::from_iter(args);
 
+    if !opts.src_files.is_empty() & !opts.packages.is_empty() {
+        print_usage_to_stderr("cannot format source files and packages at the same time");
+        return FAILURE;
+    }
+
+    if !opts.src_files.is_empty() & opts.format_all {
+        print_usage_to_stderr("cannot format all packages when specifying source files");
+        return FAILURE;
+    }
+
     let verbosity = match (opts.verbose, opts.quiet) {
         (false, false) => Verbosity::Normal,
         (false, true) => Verbosity::Quiet,
@@ -314,17 +328,23 @@ pub enum CargoFmtStrategy {
     /// Format every packages and dependencies.
     All,
     /// Format packages that are specified by the command line argument.
-    Some(Vec<String>),
+    Packages(Vec<String>),
     /// Format the root packages only.
     Root,
+    /// Format individual source files specified by the command line arguments.
+    SourcFiles(Vec<PathBuf>),
 }
 
 impl CargoFmtStrategy {
     pub fn from_opts(opts: &Opts) -> CargoFmtStrategy {
+        if !opts.src_files.is_empty() {
+            return CargoFmtStrategy::SourcFiles(opts.src_files.clone());
+        }
+
         match (opts.format_all, opts.packages.is_empty()) {
             (false, true) => CargoFmtStrategy::Root,
             (true, _) => CargoFmtStrategy::All,
-            (false, false) => CargoFmtStrategy::Some(opts.packages.clone()),
+            (false, false) => CargoFmtStrategy::Packages(opts.packages.clone()),
         }
     }
 }
@@ -341,9 +361,12 @@ fn get_targets(
         CargoFmtStrategy::All => {
             get_targets_recursive(manifest_path, &mut targets, &mut BTreeSet::new())?
         }
-        CargoFmtStrategy::Some(ref hitlist) => {
+        CargoFmtStrategy::Packages(ref hitlist) => {
             get_targets_with_hitlist(manifest_path, hitlist, &mut targets)?
         }
+        CargoFmtStrategy::SourcFiles(ref src_files) => {
+            get_targets_from_src_files(manifest_path, &src_files, &mut targets)?
+        }
     }
 
     if targets.is_empty() {
@@ -356,6 +379,44 @@ fn get_targets(
     }
 }
 
+fn get_targets_from_src_files(
+    manifest_path: Option<&Path>,
+    src_files: &[PathBuf],
+    targets: &mut BTreeSet<Target>,
+) -> Result<(), io::Error> {
+    let metadata = get_cargo_metadata(manifest_path)?;
+    let mut src_file_target_map: BTreeMap<PathBuf, (String, String)> = BTreeMap::new();
+
+    // Map each targt to it's parent directory.
+    for target in metadata.packages.iter().map(|p| p.targets.iter()).flatten() {
+        let path = fs::canonicalize(&target.src_path)?
+            .parent()
+            .expect("Target src_path should have a parent directory")
+            .to_owned();
+
+        src_file_target_map.insert(path, (target.kind[0].clone(), target.edition.clone()));
+    }
+
+    // Given the path to a source file, traverse it's ancestors until we find one that's
+    // in the target map we just constructed, at which point we add it to the targets set.
+    // This ensures that we only support formatting arbitrary files within a package.
+    for file_path in src_files {
+        let canonicalize = fs::canonicalize(file_path)?;
+        for path in canonicalize.ancestors() {
+            if let Some((kind, edition)) = src_file_target_map.get(path) {
+                targets.insert(Target {
+                    path: file_path.to_owned(),
+                    kind: kind.clone(),
+                    edition: edition.clone(),
+                });
+                break;
+            }
+        }
+    }
+
+    Ok(())
+}
+
 fn get_targets_root_only(
     manifest_path: Option<&Path>,
     targets: &mut BTreeSet<Target>,

src/cargo-fmt/test/mod.rs

@@ -16,6 +16,7 @@ fn default_options() {
     assert_eq!(false, o.format_all);
     assert_eq!(None, o.manifest_path);
     assert_eq!(None, o.message_format);
+    assert!(o.src_files.is_empty());
 }
 
 #[test]
@@ -27,6 +28,10 @@ fn good_options() {
         "p1",
         "-p",
         "p2",
+        "-s",
+        "a.rs",
+        "-s",
+        "b.rs",
         "--message-format",
         "short",
         "--check",
@@ -39,6 +44,13 @@ fn good_options() {
     assert_eq!(false, o.version);
     assert_eq!(true, o.check);
     assert_eq!(vec!["p1", "p2"], o.packages);
+    assert_eq!(
+        vec!["a.rs", "b.rs"],
+        o.src_files
+            .iter()
+            .map(|p| p.display().to_string())
+            .collect::<Vec<String>>()
+    );
     assert_eq!(vec!["--edition", "2018"], o.rustfmt_options);
     assert_eq!(false, o.format_all);
     assert_eq!(Some(String::from("short")), o.message_format);
@@ -90,6 +102,20 @@ fn multiple_packages_one_by_one() {
     assert_eq!(3, o.packages.len());
 }
 
+#[test]
+fn multiple_source_files_one_by_one() {
+    let o = Opts::from_iter(&[
+        "test",
+        "-s",
+        "src/a.rs",
+        "--src-file",
+        "src/b.rs",
+        "-s",
+        "src/c.rs",
+    ]);
+    assert_eq!(3, o.src_files.len());
+}
+
 #[test]
 fn multiple_packages_grouped() {
     let o = Opts::from_iter(&[
@@ -104,6 +130,20 @@ fn multiple_packages_grouped() {
     assert_eq!(4, o.packages.len());
 }
 
+#[test]
+fn multiple_source_files_grouped() {
+    let o = Opts::from_iter(&[
+        "test",
+        "--src-file",
+        "src/a.rs",
+        "src/b.rs",
+        "-s",
+        "src/c.rs",
+        "src/d.rs",
+    ]);
+    assert_eq!(4, o.src_files.len());
+}
+
 #[test]
 fn empty_packages_1() {
     assert!(Opts::clap().get_matches_from_safe(&["test", "-p"]).is_err());
@@ -135,3 +175,35 @@ fn empty_packages_4() {
             .is_err()
     );
 }
+
+#[test]
+fn empty_source_files_1() {
+    assert!(Opts::clap().get_matches_from_safe(&["test", "-s"]).is_err());
+}
+
+#[test]
+fn empty_source_files_2() {
+    assert!(
+        Opts::clap()
+            .get_matches_from_safe(&["test", "-s", "--", "--check"])
+            .is_err()
+    );
+}
+
+#[test]
+fn empty_source_files_3() {
+    assert!(
+        Opts::clap()
+            .get_matches_from_safe(&["test", "-s", "--verbose"])
+            .is_err()
+    );
+}
+
+#[test]
+fn empty_source_files_4() {
+    assert!(
+        Opts::clap()
+            .get_matches_from_safe(&["test", "-s", "--check"])
+            .is_err()
+    );
+}

tests/cargo-fmt/main.rs

@@ -1,6 +1,7 @@
 // Integration tests for cargo-fmt.
 
 use std::env;
+use std::path::PathBuf;
 use std::process::Command;
 
 /// Run the cargo-fmt executable and return its output.
@@ -71,3 +72,70 @@ fn rustfmt_help() {
     assert_that!(&["--", "-h"], contains("Format Rust code"));
     assert_that!(&["--", "--help=config"], contains("Configuration Options:"));
 }
+
+fn extend_path<'a, P: AsRef<std::path::Path>>(root: P, relative_path: &str) -> PathBuf {
+    let mut new_path = root.as_ref().to_owned();
+
+    for part in relative_path.split("/") {
+        new_path = new_path.join(part)
+    }
+
+    new_path
+}
+
+#[test]
+fn specify_source_files_when_running_cargo_fmt() {
+    // assumes tests are envoked from the root of the rustfmt project
+    let rustfmt_root = env::current_dir().unwrap();
+    let cargo_project_root = extend_path(
+        rustfmt_root, "tests/cargo-fmt/source/workspaces/path-dep-above/e"
+    );
+
+    let path =
+        &extend_path(cargo_project_root, "src/main.rs")
+            .display()
+            .to_string();
+
+    // test that we can run cargo-fmt on a single src file
+    assert_that!(&["-v", "--check", "-s", path], contains(path));
+}
+
+
+#[test]
+fn specify_multiple_source_files_in_a_workspace_when_running_cargo_fmt() {
+    // assumes tests are envoked from the root of the rustfmt project
+    let rustfmt_root = env::current_dir().unwrap();
+    let cargo_workspace_root = extend_path(
+        rustfmt_root, "tests/cargo-fmt/source/workspaces/path-dep-above/ws"
+    );
+    let workspace_path1 =
+        &extend_path(&cargo_workspace_root, "a/src/main.rs")
+            .display()
+            .to_string();
+
+    let workspace_path2 =
+        &extend_path(&cargo_workspace_root, "b/src/main.rs")
+            .display()
+            .to_string();
+
+    let args = ["-v", "--check", "-s", workspace_path1, workspace_path2];
+
+    let (stdout, _) = cargo_fmt(&args);
+
+    // test that we can run cargo-fmt on a multiple src files withing a cargo workspace
+    assert!(stdout.contains(&format!("{:?}", workspace_path1)));
+    assert!(stdout.contains(&format!("{:?}", workspace_path2)));
+}
+
+
+#[test]
+fn formatting_source_files_and_packages_at_the_same_time_is_not_supported() {
+    let (_, stderr) = cargo_fmt(&["--check", "-s", "src/main.rs", "-p", "p1", "-p2"]);
+    assert!(stderr.starts_with("cannot format source files and packages at the same time"))
+}
+
+#[test]
+fn formatting_source_files_and_using_package_related_arguments_is_not_supported() {
+    let (_, stderr) = cargo_fmt(&["--check", "--all", "-s", "src/main.rs"]);
+    assert!(stderr.starts_with("cannot format all packages when specifying source files"))
+}