rustfmt: Add --file-lines flag behind an env var

This adds a `--file-lines` flag that is present if the
RUSTFMT_EXPERIMENTAL_FILE_LINES environment variable is set to "1".  The
argument is parsed and propagated into the config, but so far it is only
an alternative and verbose way to specify files and set `skip_children`.

Refs https://github.com/nrc/rustfmt/issues/434

Author: kamalmarhubi

Cargo.lock

@@ -25,3 +25,4 @@ syntex_syntax = "0.23.0"
 log = "0.3.2"
 env_logger = "0.3.1"
 getopts = "0.2"
+nom = "1.2.1"

Cargo.toml

@@ -12,13 +12,19 @@
 
 #[macro_use]
 extern crate log;
+#[macro_use]
+extern crate nom;
+
 extern crate rustfmt;
 extern crate toml;
 extern crate env_logger;
 extern crate getopts;
 
+use nom::IResult;
+
 use rustfmt::{run, run_from_stdin};
 use rustfmt::config::{Config, WriteMode};
+use rustfmt::config::{FileLinesMap, LineRanges};
 
 use std::env;
 use std::fs::{self, File};
@@ -50,6 +56,10 @@ enum Operation {
         input: String,
         config_path: Option<PathBuf>,
     },
+    /// Format a set of line ranges.
+    FormatLineRanges {
+        file_lines_map: FileLinesMap,
+    },
 }
 
 /// Try to find a project file in the given directory and its parents. Returns the path of a the
@@ -120,7 +130,9 @@ fn match_cli_path_or_file(config_path: Option<PathBuf>,
 
 fn update_config(config: &mut Config, matches: &Matches) -> Result<(), String> {
     config.verbose = matches.opt_present("verbose");
-    config.skip_children = matches.opt_present("skip-children");
+    // `file-lines` implies `skip-children`.
+    config.skip_children = matches.opt_present("skip-children") ||
+                           (file_lines_enabled() && matches.opt_present("file-lines"));
 
     let write_mode = matches.opt_str("write-mode");
     match matches.opt_str("write-mode").map(|wm| WriteMode::from_str(&wm)) {
@@ -133,6 +145,13 @@ fn update_config(config: &mut Config, matches: &Matches) -> Result<(), String> {
     }
 }
 
+fn file_lines_enabled() -> bool {
+    match env::var("RUSTFMT_EXPERIMENTAL_FILE_LINES") {
+        Ok(ref v) if v == "1" => true,
+        _ => false,
+    }
+}
+
 fn execute() -> i32 {
     let mut opts = Options::new();
     opts.optflag("h", "help", "show this message");
@@ -152,6 +171,13 @@ fn execute() -> i32 {
                 "Recursively searches the given path for the rustfmt.toml config file. If not \
                  found reverts to the input file path",
                 "[Path for the configuration file]");
+    if file_lines_enabled() {
+        opts.optmulti("",
+                      "file-lines",
+                      "Format specified line RANGEs in FILE. RANGEs are inclusive of both \
+                       endpoints. May be specified multiple times.",
+                      "FILE:RANGE,RANGE,...");
+    }
 
     let matches = match opts.parse(env::args().skip(1)) {
         Ok(m) => m,
@@ -228,6 +254,27 @@ fn execute() -> i32 {
             }
             0
         }
+        // TODO: figure out what to do with config_path.
+        Operation::FormatLineRanges { file_lines_map } => {
+            for (file, line_ranges) in file_lines_map {
+                let (mut config, config_path) = resolve_config(file.parent().unwrap())
+                                                    .expect(&format!("Error resolving config \
+                                                                      for {}",
+                                                                     file.display()));
+                if let Some(path) = config_path.as_ref() {
+                    println!("Using rustfmt config file {} for {}",
+                             path.display(),
+                             file.display());
+                }
+                if let Err(e) = update_config(&mut config, &matches) {
+                    print_usage(&opts, &e);
+                    return 1;
+                }
+                config.line_ranges = line_ranges;
+                run(&file, &config);
+            }
+            0
+        }
     }
 }
 
@@ -283,6 +330,29 @@ fn determine_operation(matches: &Matches) -> Operation {
                                                   Some(dir)
                                               });
 
+    if file_lines_enabled() && matches.opt_present("file-lines") {
+        let file_lines = matches.opt_strs("file-lines");
+        let mut file_lines_map = FileLinesMap::new();
+        for range_spec in file_lines {
+            let invalid = || {
+                Operation::InvalidInput {
+                    reason: format!("invalid file-lines argument: {}", range_spec),
+                }
+            };
+
+            let (file, line_ranges) = match parse::file_lines_arg(&range_spec) {
+                IResult::Error(_) |
+                IResult::Incomplete(_) => return invalid(),
+                IResult::Done(remaining, _) if !remaining.is_empty() => return invalid(),
+                IResult::Done(_, (file, line_ranges)) => (file, line_ranges),
+            };
+
+            let entry = file_lines_map.entry(file).or_insert(LineRanges(Vec::new()));
+            entry.0.extend(line_ranges.0);
+        }
+        return Operation::FormatLineRanges { file_lines_map: file_lines_map };
+    }
+
     // if no file argument is supplied, read from stdin
     if matches.free.is_empty() {
 
@@ -305,3 +375,59 @@ fn determine_operation(matches: &Matches) -> Operation {
         config_path: config_path,
     }
 }
+
+
+/// Parser for the `file-lines` argument.
+mod parse {
+    use std::path::PathBuf;
+    use std::str::FromStr;
+    use rustfmt::config::{LineRange, LineRanges};
+
+    use nom::digit;
+
+    named!(pub file_lines_arg<&str, (PathBuf, LineRanges)>,
+           chain!(
+               file: map!(
+                   is_not_s!(":"),
+                   PathBuf::from
+               ) ~
+               tag_s!(":") ~
+               line_ranges: line_ranges,
+               || (file, line_ranges)
+           )
+    );
+
+    named!(usize_digit<&str, usize>,
+           map_res!(
+               digit,
+               FromStr::from_str
+           )
+    );
+
+    named!(line_range<&str, LineRange>,
+           map_res!(
+               separated_pair!(
+                   usize_digit,
+                   tag_s!("-"),
+                   usize_digit
+               ),
+               |pair| {
+                   let (lo, hi) = pair;
+                   if lo < hi {
+                       return Err(format!("empty line range: {}-{}", lo, hi));
+                   }
+                   Ok(LineRange { lo: lo, hi: hi })
+               }
+           )
+    );
+
+    named!(line_ranges<&str, LineRanges>,
+           map!(
+               separated_nonempty_list!(
+                   tag_s!(","),
+                   line_range
+               ),
+               LineRanges
+           )
+    );
+}