Move `compile_options` to `ArgMatchesExt`

diff --git a/src/bin/cli.rs b/src/bin/cli.rs
index 3703161903351e72296b6b62bc3bf2444d7c2014..54706bc91a52663887453e3b21e813c8d46f0496 100644 (file)
--- a/src/bin/cli.rs
+++ b/src/bin/cli.rs
@@ -85,7 +85,7 @@ fn execute_subcommand(config: &mut Config, args: ArgMatches) -> CliResult {
     match args.subcommand() {
         ("bench", Some(args)) => {
             let ws = args.workspace(config)?;
-            let mut compile_opts = compile_options_from_args(config, args, CompileMode::Bench)?;
+            let mut compile_opts = args.compile_options(config, CompileMode::Bench)?;
             compile_opts.release = true;
 
             let ops = ops::TestOptions {
@@ -115,7 +115,7 @@ fn execute_subcommand(config: &mut Config, args: ArgMatches) -> CliResult {
             if config.cli_unstable().avoid_dev_deps {
                 ws.set_require_optional_deps(false);
             }
-            let compile_opts = compile_options_from_args(config, args, CompileMode::Build)?;
+            let compile_opts = args.compile_options(config, CompileMode::Build)?;
             ops::compile(&ws, &compile_opts)?;
             Ok(())
         }
@@ -131,7 +131,7 @@ fn execute_subcommand(config: &mut Config, args: ArgMatches) -> CliResult {
                 }
             };
             let mode = CompileMode::Check { test };
-            let compile_opts = compile_options_from_args(config, args, mode)?;
+            let compile_opts = args.compile_options(config, mode)?;
             ops::compile(&ws, &compile_opts)?;
             Ok(())
         }
@@ -149,7 +149,7 @@ fn execute_subcommand(config: &mut Config, args: ArgMatches) -> CliResult {
         ("doc", Some(args)) => {
             let ws = args.workspace(config)?;
             let mode = ops::CompileMode::Doc { deps: !args.is_present("no-deps") };
-            let compile_opts = compile_options_from_args(config, args, mode)?;
+            let compile_opts = args.compile_options(config, mode)?;
             let doc_opts = ops::DocOptions {
                 open_result: args.is_present("open"),
                 compile_opts,
@@ -188,7 +188,7 @@ fn execute_subcommand(config: &mut Config, args: ArgMatches) -> CliResult {
             Ok(())
         }
         ("install", Some(args)) => {
-            let mut compile_opts = compile_options_from_args(config, args, CompileMode::Build)?;
+            let mut compile_opts = args.compile_options(config, CompileMode::Build)?;
             compile_opts.release = !args.is_present("debug");
 
             let krates = args.values_of("crate").unwrap_or_default().collect::<Vec<_>>();
@@ -372,8 +372,8 @@ fn execute_subcommand(config: &mut Config, args: ArgMatches) -> CliResult {
         ("run", Some(args)) => {
             let ws = args.workspace(config)?;
 
-            let mut compile_opts = compile_options_from_args_for_single_package(
-                config, args, CompileMode::Build,
+            let mut compile_opts = args.compile_options_for_single_package(
+                config, CompileMode::Build,
             )?;
             if !args.is_present("example") && !args.is_present("bin") {
                 compile_opts.filter = ops::CompileFilter::Default {
@@ -415,8 +415,8 @@ fn execute_subcommand(config: &mut Config, args: ArgMatches) -> CliResult {
                     return Err(CliError::new(err, 101));
                 }
             };
-            let mut compile_opts = compile_options_from_args_for_single_package(
-                config, args, mode,
+            let mut compile_opts = args.compile_options_for_single_package(
+                config, mode,
             )?;
             compile_opts.target_rustc_args = Some(values(args, "args"));
             ops::compile(&ws, &compile_opts)?;
@@ -424,8 +424,8 @@ fn execute_subcommand(config: &mut Config, args: ArgMatches) -> CliResult {
         }
         ("rustdoc", Some(args)) => {
             let ws = args.workspace(config)?;
-            let mut compile_opts = compile_options_from_args_for_single_package(
-                config, args, CompileMode::Doc { deps: false },
+            let mut compile_opts = args.compile_options_for_single_package(
+                config, CompileMode::Doc { deps: false },
             )?;
             compile_opts.target_rustdoc_args = Some(values(args, "args"));
             let doc_opts = ops::DocOptions {
@@ -449,7 +449,7 @@ fn execute_subcommand(config: &mut Config, args: ArgMatches) -> CliResult {
         ("test", Some(args)) => {
             let ws = args.workspace(config)?;
 
-            let mut compile_opts = compile_options_from_args(config, args, CompileMode::Test)?;
+            let mut compile_opts = args.compile_options(config, CompileMode::Test)?;
             let doc = args.is_present("doc");
             if doc {
                 compile_opts.mode = ops::CompileMode::Doctest;

diff --git a/src/bin/command_prelude.rs b/src/bin/command_prelude.rs
index b7df8522af148556a8261eaae74fc52e7ce87eb3..6315368e354eecb7a35f2717faee221f2f48c75e 100644 (file)
--- a/src/bin/command_prelude.rs
+++ b/src/bin/command_prelude.rs
@@ -197,13 +197,84 @@ pub trait ArgMatchesExt {
         self._value_of("target").map(|s| s.to_string())
     }
 
+    fn compile_options<'a>(
+        &self,
+        config: &'a Config,
+        mode: CompileMode
+    ) -> CargoResult<CompileOptions<'a>> {
+        let spec = Packages::from_flags(
+            self._is_present("all"),
+            self._values_of("exclude"),
+            self._values_of("package"),
+        )?;
+
+        let message_format = match self._value_of("message-format") {
+            None => MessageFormat::Human,
+            Some(f) => {
+                if f.eq_ignore_ascii_case("json") {
+                    MessageFormat::Json
+                } else if f.eq_ignore_ascii_case("human") {
+                    MessageFormat::Human
+                } else {
+                    panic!("Impossible message format: {:?}", f)
+                }
+            }
+        };
+
+        let opts = CompileOptions {
+            config,
+            jobs: self.jobs()?,
+            target: self.target(),
+            features: self._values_of("features"),
+            all_features: self._is_present("all-features"),
+            no_default_features: self._is_present("no-default-features"),
+            spec,
+            mode,
+            release: self._is_present("release"),
+            filter: CompileFilter::new(self._is_present("lib"),
+                                       self._values_of("bin"), self._is_present("bins"),
+                                       self._values_of("test"), self._is_present("tests"),
+                                       self._values_of("example"), self._is_present("examples"),
+                                       self._values_of("bench"), self._is_present("benches"),
+                                       self._is_present("all-targets")),
+            message_format,
+            target_rustdoc_args: None,
+            target_rustc_args: None,
+        };
+        Ok(opts)
+    }
+
+    fn compile_options_for_single_package<'a>(
+        &self,
+        config: &'a Config,
+        mode: CompileMode
+    ) -> CargoResult<CompileOptions<'a>> {
+        let mut compile_opts = self.compile_options(config, mode)?;
+        compile_opts.spec = Packages::Packages(self._values_of("package"));
+        Ok(compile_opts)
+    }
+
     fn _value_of(&self, name: &str) -> Option<&str>;
+
+    fn _values_of(&self, name: &str) -> Vec<String>;
+
+    fn _is_present(&self, name: &str) -> bool;
 }
 
 impl<'a> ArgMatchesExt for ArgMatches<'a> {
     fn _value_of(&self, name: &str) -> Option<&str> {
         self.value_of(name)
     }
+
+    fn _values_of(&self, name: &str) -> Vec<String> {
+        self.values_of(name).unwrap_or_default()
+            .map(|s| s.to_string())
+            .collect()
+    }
+
+    fn _is_present(&self, name: &str) -> bool {
+        self.is_present(name)
+    }
 }
 
 pub fn values(args: &ArgMatches, name: &str) -> Vec<String> {
@@ -212,63 +283,6 @@ pub fn values(args: &ArgMatches, name: &str) -> Vec<String> {
         .collect()
 }
 
-pub fn compile_options_from_args<'a>(
-    config: &'a Config,
-    args: &'a ArgMatches<'a>,
-    mode: CompileMode,
-) -> CargoResult<CompileOptions<'a>> {
-    let spec = Packages::from_flags(
-        args.is_present("all"),
-        values(args, "exclude"),
-        values(args, "package"),
-    )?;
-
-    let message_format = match args.value_of("message-format") {
-        None => MessageFormat::Human,
-        Some(f) => {
-            if f.eq_ignore_ascii_case("json") {
-                MessageFormat::Json
-            } else if f.eq_ignore_ascii_case("human") {
-                MessageFormat::Human
-            } else {
-                panic!("Impossible message format: {:?}", f)
-            }
-        }
-    };
-
-    let opts = CompileOptions {
-        config,
-        jobs: args.jobs()?,
-        target: args.target(),
-        features: values(args, "features"),
-        all_features: args.is_present("all-features"),
-        no_default_features: args.is_present("no-default-features"),
-        spec,
-        mode,
-        release: args.is_present("release"),
-        filter: CompileFilter::new(args.is_present("lib"),
-                                   values(args, "bin"), args.is_present("bins"),
-                                   values(args, "test"), args.is_present("tests"),
-                                   values(args, "example"), args.is_present("examples"),
-                                   values(args, "bench"), args.is_present("benches"),
-                                   args.is_present("all-targets")),
-        message_format,
-        target_rustdoc_args: None,
-        target_rustc_args: None,
-    };
-    Ok(opts)
-}
-
-pub fn compile_options_from_args_for_single_package<'a>(
-    config: &'a Config,
-    args: &'a ArgMatches<'a>,
-    mode: CompileMode,
-) -> CargoResult<CompileOptions<'a>> {
-    let mut compile_opts = compile_options_from_args(config, args, mode)?;
-    compile_opts.spec = Packages::Packages(values(args, "package"));
-    Ok(compile_opts)
-}
-
 pub fn new_opts_from_args<'a>(args: &'a ArgMatches<'a>, path: &'a str) -> CargoResult<NewOptions<'a>> {
     let vcs = args.value_of("vcs").map(|vcs| match vcs {
         "git" => VersionControl::Git,