Accept manifest path option

Configurations.md

@@ -1303,7 +1303,7 @@ fn main() {
     });
 
     match lorem {
-        None => if ipsum {
+        None => |ipsum| {
             println!("Hello World");
         },
         Some(dolor) => foo(),
@@ -1324,7 +1324,7 @@ fn main() {
 
     match lorem {
         None => {
-            if ipsum {
+            |ipsum| {
                 println!("Hello World");
             }
         }
@@ -2188,6 +2188,32 @@ If you want to format code that requires edition 2018, add the following to your
 edition = "2018"
 ```
 
+## `normalize_doc_attributes`
+
+Convert `#![doc]` and `#[doc]` attributes to `//!` and `///` doc comments.
+
+- **Default value**: `false`
+- **Possible values**: `true`, `false`
+- **Stable**: No
+
+#### `false` (default):
+
+```rust
+#![doc = "Example documentation"]
+
+#[doc = "Example item documentation"]
+pub enum Foo {}
+```
+
+#### `true`:
+
+```rust
+//! Example documentation
+
+/// Example item documentation
+pub enum Foo {}
+```
+
 ## `emit_mode`
 
 Internal option

README.md

@@ -189,15 +189,15 @@ See [Configurations.md](Configurations.md) for details.
   Example:
 
   ```
-  cargo fmt --emit files
+  cargo fmt -- --emit files
   ```
 
   Options:
 
   | Flag |Description| Nightly Only |
   |:---:|:---:|:---:|
   | files | overwrites output to files | No |
-  | stdout | writes output to stdout | No | 
+  | stdout | writes output to stdout | No |
   | coverage | displays how much of the input file was processed | Yes |
   | checkstyle | emits in a checkstyle format | Yes |
 

src/attr.rs

@@ -10,7 +10,7 @@
 
 //! Format attributes and meta items.
 
-use comment::{contains_comment, rewrite_doc_comment};
+use comment::{contains_comment, rewrite_doc_comment, CommentStyle};
 use config::lists::*;
 use config::IndentStyle;
 use expr::rewrite_literal;
@@ -229,7 +229,8 @@ impl Rewrite for ast::MetaItem {
                                 None,
                                 &inner_meta_item.ident,
                                 shape,
-                            ).map_or(false, |s| s.len() + path.len() + 2 <= shape.width),
+                            )
+                            .map_or(false, |s| s.len() + path.len() + 2 <= shape.width),
                             _ => false,
                         }
                     }
@@ -350,13 +351,34 @@ impl Rewrite for ast::Attribute {
             if contains_comment(snippet) {
                 return Some(snippet.to_owned());
             }
-            // 1 = `[`
-            let shape = shape.offset_left(prefix.len() + 1)?;
-            Some(
-                self.meta()
-                    .and_then(|meta| meta.rewrite(context, shape))
-                    .map_or_else(|| snippet.to_owned(), |rw| format!("{}[{}]", prefix, rw)),
-            )
+
+            if let Some(ref meta) = self.meta() {
+                // This attribute is possibly a doc attribute needing normalization to a doc comment
+                if context.config.normalize_doc_attributes() && meta.check_name("doc") {
+                    if let Some(ref literal) = meta.value_str() {
+                        let comment_style = match self.style {
+                            ast::AttrStyle::Inner => CommentStyle::Doc,
+                            ast::AttrStyle::Outer => CommentStyle::TripleSlash,
+                        };
+
+                        let doc_comment = format!("{}{}", comment_style.opener(), literal);
+                        return rewrite_doc_comment(
+                            &doc_comment,
+                            shape.comment(context.config),
+                            context.config,
+                        );
+                    }
+                }
+
+                // 1 = `[`
+                let shape = shape.offset_left(prefix.len() + 1)?;
+                Some(
+                    meta.rewrite(context, shape)
+                        .map_or_else(|| snippet.to_owned(), |rw| format!("{}[{}]", prefix, rw)),
+                )
+            } else {
+                Some(snippet.to_owned())
+            }
         }
     }
 }

src/bin/main.rs

@@ -421,7 +421,8 @@ fn determine_operation(matches: &Matches) -> Result<Operation, ErrorKind> {
             // we will do comparison later, so here tries to canonicalize first
             // to get the expected behavior.
             p.canonicalize().unwrap_or(p)
-        }).collect();
+        })
+        .collect();
 
     Ok(Operation::Format {
         files,

src/cargo-fmt/main.rs

@@ -49,22 +49,10 @@ fn execute() -> i32 {
         "specify package to format (only usable in workspaces)",
         "<package>",
     );
+    opts.optopt("", "manifest-path", "Path to Cargo.toml", "<PATH>");
     opts.optflag("", "version", "print rustfmt version and exit");
     opts.optflag("", "all", "format all packages (only usable in workspaces)");
 
-    // If there is any invalid argument passed to `cargo fmt`, return without formatting.
-    let mut is_package_arg = false;
-    for arg in env::args().skip(2).take_while(|a| a != "--") {
-        if arg.starts_with('-') {
-            is_package_arg = arg.starts_with("--package");
-        } else if !is_package_arg {
-            print_usage_to_stderr(&opts, &format!("Invalid argument: `{}`.", arg));
-            return FAILURE;
-        } else {
-            is_package_arg = false;
-        }
-    }
-
     let matches = match opts.parse(env::args().skip(1).take_while(|a| a != "--")) {
         Ok(m) => m,
         Err(e) => {
@@ -73,6 +61,12 @@ fn execute() -> i32 {
         }
     };
 
+    let invalid_arguments: Vec<&String> = matches.free.iter().take_while(|a| a.to_string() != "--").collect();
+    if !invalid_arguments.is_empty() {
+        print_usage_to_stderr(&opts, &format!("Invalid arguments: {}", matches.free.join(" ")));
+        return FAILURE;
+    }
+
     let verbosity = match (matches.opt_present("v"), matches.opt_present("q")) {
         (false, false) => Verbosity::Normal,
         (false, true) => Verbosity::Quiet,
@@ -92,8 +86,12 @@ fn execute() -> i32 {
         return handle_command_status(get_version(verbosity), &opts);
     }
 
+    let manifest_path = matches
+        .opt_str("manifest-path")
+        .map(|path| PathBuf::from(path));
+    let manifest_path = manifest_path.as_ref().map(AsRef::as_ref);
     let strategy = CargoFmtStrategy::from_matches(&matches);
-    handle_command_status(format_crate(verbosity, &strategy), &opts)
+    handle_command_status(format_crate(verbosity, &strategy, manifest_path), &opts)
 }
 
 macro_rules! print_usage {
@@ -145,15 +143,16 @@ fn get_version(verbosity: Verbosity) -> Result<ExitStatus, io::Error> {
 fn format_crate(
     verbosity: Verbosity,
     strategy: &CargoFmtStrategy,
+    manifest_path: Option<&Path>,
 ) -> Result<ExitStatus, io::Error> {
     let rustfmt_args = get_fmt_args();
     let targets = if rustfmt_args
         .iter()
-        .any(|s| ["--print-config", "-h", "--help", "-V", "--verison"].contains(&s.as_str()))
+        .any(|s| ["--print-config", "-h", "--help", "-V", "--version"].contains(&s.as_str()))
     {
         HashSet::new()
     } else {
-        get_targets(strategy)?
+        get_targets(manifest_path, strategy)?
     };
 
     // Currently only bin and lib files get formatted
@@ -163,7 +162,8 @@ fn format_crate(
             if verbosity == Verbosity::Verbose {
                 println!("[{}] {:?}", t.kind, t.path)
             }
-        }).map(|t| t.path)
+        })
+        .map(|t| t.path)
         .collect();
 
     run_rustfmt(&files, &rustfmt_args, verbosity)
@@ -230,13 +230,20 @@ impl CargoFmtStrategy {
 }
 
 /// Based on the specified `CargoFmtStrategy`, returns a set of main source files.
-fn get_targets(strategy: &CargoFmtStrategy) -> Result<HashSet<Target>, io::Error> {
+fn get_targets(
+    manifest_path: Option<&Path>,
+    strategy: &CargoFmtStrategy,
+) -> Result<HashSet<Target>, io::Error> {
     let mut targets = HashSet::new();
 
     match *strategy {
-        CargoFmtStrategy::Root => get_targets_root_only(&mut targets)?,
-        CargoFmtStrategy::All => get_targets_recursive(None, &mut targets, &mut HashSet::new())?,
-        CargoFmtStrategy::Some(ref hitlist) => get_targets_with_hitlist(hitlist, &mut targets)?,
+        CargoFmtStrategy::Root => get_targets_root_only(manifest_path, &mut targets)?,
+        CargoFmtStrategy::All => {
+            get_targets_recursive(manifest_path, &mut targets, &mut HashSet::new())?
+        }
+        CargoFmtStrategy::Some(ref hitlist) => {
+            get_targets_with_hitlist(manifest_path, hitlist, &mut targets)?
+        }
     }
 
     if targets.is_empty() {
@@ -249,8 +256,11 @@ fn get_targets(strategy: &CargoFmtStrategy) -> Result<HashSet<Target>, io::Error
     }
 }
 
-fn get_targets_root_only(targets: &mut HashSet<Target>) -> Result<(), io::Error> {
-    let metadata = get_cargo_metadata(None)?;
+fn get_targets_root_only(
+    manifest_path: Option<&Path>,
+    targets: &mut HashSet<Target>,
+) -> Result<(), io::Error> {
+    let metadata = get_cargo_metadata(manifest_path)?;
     let current_dir = env::current_dir()?.canonicalize()?;
     let current_dir_manifest = current_dir.join("Cargo.toml");
     let workspace_root_path = PathBuf::from(&metadata.workspace_root).canonicalize()?;
@@ -300,10 +310,11 @@ fn get_targets_recursive(
 }
 
 fn get_targets_with_hitlist(
+    manifest_path: Option<&Path>,
     hitlist: &[String],
     targets: &mut HashSet<Target>,
 ) -> Result<(), io::Error> {
-    let metadata = get_cargo_metadata(None)?;
+    let metadata = get_cargo_metadata(manifest_path)?;
 
     let mut workspace_hitlist: HashSet<&String> = HashSet::from_iter(hitlist);
 
@@ -373,9 +384,6 @@ fn run_rustfmt(
 fn get_cargo_metadata(manifest_path: Option<&Path>) -> Result<cargo_metadata::Metadata, io::Error> {
     match cargo_metadata::metadata(manifest_path) {
         Ok(metadata) => Ok(metadata),
-        Err(..) => Err(io::Error::new(
-            io::ErrorKind::Other,
-            "`cargo manifest` failed.",
-        )),
+        Err(error) => Err(io::Error::new(io::ErrorKind::Other, error.to_string())),
     }
 }