Merge #297
297: uses clap for the CLI r=kbknapp a=kbknapp
Co-authored-by: Kevin K <kbknapp@gmail.com>
diff --git a/Cargo.lock b/Cargo.lock
index b937461..886fb82 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -152,7 +152,7 @@
dependencies = [
"anyhow",
"cargo",
- "docopt",
+ "clap",
"env_logger",
"git2-curl",
"semver",
@@ -220,7 +220,7 @@
"ansi_term",
"atty",
"bitflags",
- "strsim 0.8.0",
+ "strsim",
"textwrap",
"unicode-width",
"vec_map",
@@ -337,18 +337,6 @@
]
[[package]]
-name = "docopt"
-version = "1.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f3f119846c823f9eafcf953a8f6ffb6ed69bf6240883261a7f13b634579a51f"
-dependencies = [
- "lazy_static",
- "regex",
- "serde",
- "strsim 0.10.0",
-]
-
-[[package]]
name = "either"
version = "1.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1036,12 +1024,6 @@
checksum = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"
[[package]]
-name = "strsim"
-version = "0.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
-
-[[package]]
name = "syn"
version = "1.0.80"
source = "registry+https://github.com/rust-lang/crates.io-index"
diff --git a/Cargo.toml b/Cargo.toml
index 1ac8fde..305ff4e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -7,7 +7,7 @@
"Ricky H. <ricky.hosfelt@gmail.com>",
]
categories = ["development-tools", "development-tools::cargo-plugins"]
-edition = "2018"
+edition = "2021"
exclude = ["*.png"]
keywords = [
"cargo",
@@ -30,7 +30,6 @@
[dependencies]
anyhow = "1.0"
cargo = "0.57.0"
-docopt = "1.1.0"
env_logger = "0.9.0"
git2-curl = "0.14.0"
semver = "1.0.0"
@@ -40,6 +39,7 @@
tabwriter = "1.2.1"
tempfile = "3"
toml = "~0.5.0"
+clap = "2.33.3"
[dependencies.termcolor]
optional = true
diff --git a/src/cargo_ops/elaborate_workspace.rs b/src/cargo_ops/elaborate_workspace.rs
index e6b37e4..2f1f016 100644
--- a/src/cargo_ops/elaborate_workspace.rs
+++ b/src/cargo_ops/elaborate_workspace.rs
@@ -66,7 +66,7 @@
) -> CargoResult<ElaborateWorkspace<'ela>> {
// new in cargo 0.54.0
let flag_features: BTreeSet<FeatureValue> = options
- .flag_features
+ .features
.iter()
.map(|feature| FeatureValue::new(InternedString::from(feature)))
.collect();
@@ -118,13 +118,13 @@
pkgs,
pkg_deps,
pkg_status: RefCell::new(HashMap::new()),
- workspace_mode: options.flag_workspace || workspace.current().is_err(),
+ workspace_mode: options.workspace || workspace.current().is_err(),
})
}
/// Determine root package based on current workspace and CLI options
pub fn determine_root(&self, options: &Options) -> CargoResult<PackageId> {
- if let Some(ref root_name) = options.flag_root {
+ if let Some(ref root_name) = options.root {
if let Ok(workspace_root) = self.workspace.current() {
if root_name == workspace_root.name().as_str() {
Ok(workspace_root.package_id())
@@ -239,7 +239,7 @@
self.pkg_status.borrow_mut().insert(path.clone(), status);
// next layer
// this unwrap is safe since we first check if it is None :)
- if options.flag_depth.is_none() || depth < options.flag_depth.unwrap() {
+ if options.depth.is_none() || depth < options.depth.unwrap() {
self.pkg_deps[pkg]
.keys()
.filter(|dep| !path.contains(dep))
@@ -279,7 +279,7 @@
let pkg = path.last().ok_or(OutdatedError::EmptyPath)?;
let name = pkg.name().to_string();
- if options.flag_ignore.contains(&name) {
+ if options.ignore.contains(&name) {
continue;
}
@@ -287,7 +287,7 @@
// generate lines
let status = &self.pkg_status.borrow_mut()[&path];
if (status.compat.is_changed() || status.latest.is_changed())
- && (options.flag_packages.is_empty() || options.flag_packages.contains(&name))
+ && (options.packages.is_empty() || options.packages.contains(&name))
{
// name version compatible latest kind platform
let parent = path.get(path.len() - 2);
@@ -326,7 +326,7 @@
}
// next layer
// this unwrap is safe since we first check if it is None :)
- if options.flag_depth.is_none() || depth < options.flag_depth.unwrap() {
+ if options.depth.is_none() || depth < options.depth.unwrap() {
self.pkg_deps[pkg]
.keys()
.filter(|dep| !path.contains(dep))
@@ -379,7 +379,7 @@
let pkg = path.last().ok_or(OutdatedError::EmptyPath)?;
let name = pkg.name().to_string();
- if options.flag_ignore.contains(&name) {
+ if options.ignore.contains(&name) {
continue;
}
@@ -387,7 +387,7 @@
// generate lines
let status = &self.pkg_status.borrow_mut()[&path];
if (status.compat.is_changed() || status.latest.is_changed())
- && (options.flag_packages.is_empty() || options.flag_packages.contains(&name))
+ && (options.packages.is_empty() || options.packages.contains(&name))
{
// name version compatible latest kind platform
// safely get the parent index
@@ -438,7 +438,7 @@
}
// next layer
// this unwrap is safe since we first check if it is None :)
- if options.flag_depth.is_none() || depth < options.flag_depth.unwrap() {
+ if options.depth.is_none() || depth < options.depth.unwrap() {
self.pkg_deps[pkg]
.keys()
.filter(|dep| !path.contains(dep))
diff --git a/src/cargo_ops/temp_project.rs b/src/cargo_ops/temp_project.rs
index 38acad2..826e89e 100644
--- a/src/cargo_ops/temp_project.rs
+++ b/src/cargo_ops/temp_project.rs
@@ -189,11 +189,11 @@
let mut config = Config::new(shell, cwd, homedir);
config.configure(
0,
- options.flag_verbose == 0,
- options.flag_color.as_deref(),
+ options.verbose == 0,
+ Some(&options.color.to_string().to_ascii_lowercase()),
options.frozen(),
options.locked(),
- options.flag_offline,
+ options.offline,
&cargo_home_path,
&[],
&[],
@@ -396,7 +396,7 @@
} else if find_latest {
// this unwrap is safe since we check if `version_req` is `None` before this
// (which is only `None` if `requirement` is `None`)
- self.options.flag_aggressive
+ self.options.aggressive
|| valid_latest_version(requirement.unwrap(), summary.version())
} else {
// this unwrap is safe since we check if `version_req` is `None` before this
@@ -436,12 +436,7 @@
if self.options.all_features() {
return true;
}
- if !optional
- && self
- .options
- .flag_features
- .contains(&String::from("default"))
- {
+ if !optional && self.options.features.contains(&String::from("default")) {
return true;
}
let features_table = match *features_table {
@@ -450,7 +445,7 @@
};
let mut to_resolve: Vec<&str> = self
.options
- .flag_features
+ .features
.iter()
.filter(|f| !f.is_empty())
.map(String::as_str)
@@ -495,7 +490,7 @@
// In short this allows cargo to build the package with semver minor compatibilities issues
// https://github.com/rust-lang/cargo/issues/6584
// https://github.com/kbknapp/cargo-outdated/issues/230
- if self.options.flag_exclude.contains(&dep_key) {
+ if self.options.exclude.contains(&dep_key) {
continue;
}
@@ -682,13 +677,11 @@
fn warn<T: ::std::fmt::Display>(&self, message: T) -> CargoResult<()> {
let original_verbosity = self.config.shell().verbosity();
- self.config
- .shell()
- .set_verbosity(if self.options.flag_quiet {
- Verbosity::Quiet
- } else {
- Verbosity::Normal
- });
+ self.config.shell().set_verbosity(if self.options.quiet {
+ Verbosity::Quiet
+ } else {
+ Verbosity::Normal
+ });
self.config.shell().warn(message)?;
self.config.shell().set_verbosity(original_verbosity);
Ok(())
diff --git a/src/cli.rs b/src/cli.rs
new file mode 100644
index 0000000..65df241
--- /dev/null
+++ b/src/cli.rs
@@ -0,0 +1,476 @@
+use clap::{
+ arg_enum, crate_version, value_t, value_t_or_exit, App, AppSettings, Arg, ArgMatches,
+ SubCommand,
+};
+
+arg_enum! {
+ #[derive(Copy, Clone, Debug, PartialEq)]
+ pub enum Format {
+ List,
+ Json,
+ }
+}
+
+impl Default for Format {
+ fn default() -> Self { Format::List }
+}
+
+arg_enum! {
+ #[derive(Copy, Clone, Debug, PartialEq)]
+ pub enum Color {
+ Auto,
+ Never,
+ Always
+ }
+}
+
+impl Default for Color {
+ fn default() -> Self { Color::Auto }
+}
+
+/// Options from CLI arguments
+#[derive(Debug, PartialEq, Default)]
+pub struct Options {
+ pub format: Format,
+ pub color: Color,
+ pub features: Vec<String>,
+ pub ignore: Vec<String>,
+ pub exclude: Vec<String>,
+ pub manifest_path: Option<String>,
+ pub quiet: bool,
+ pub verbose: u64,
+ pub exit_code: i32,
+ pub packages: Vec<String>,
+ pub root: Option<String>,
+ pub depth: Option<i32>,
+ pub root_deps_only: bool,
+ pub workspace: bool,
+ pub aggressive: bool,
+ pub offline: bool,
+}
+
+impl Options {
+ pub fn all_features(&self) -> bool { self.features.is_empty() }
+
+ pub fn no_default_features(&self) -> bool {
+ !(self.features.is_empty() || self.features.contains(&"default".to_owned()))
+ }
+
+ pub fn locked(&self) -> bool { false }
+
+ pub fn frozen(&self) -> bool { false }
+}
+
+impl<'a> From<&ArgMatches<'a>> for Options {
+ fn from(m: &ArgMatches<'a>) -> Self {
+ let mut opts = Options {
+ format: value_t_or_exit!(m.value_of("format"), Format),
+ color: value_t_or_exit!(m.value_of("color"), Color),
+ features: m
+ .values_of("features")
+ .map(|vals| {
+ vals.flat_map(|x| x.split_ascii_whitespace().collect::<Vec<_>>())
+ .map(ToOwned::to_owned)
+ .collect()
+ })
+ .unwrap_or_else(Vec::new),
+ ignore: m
+ .values_of("ignore")
+ .map(|vals| {
+ vals.flat_map(|x| x.split_ascii_whitespace().collect::<Vec<_>>())
+ .map(ToOwned::to_owned)
+ .collect()
+ })
+ .unwrap_or_else(Vec::new),
+ exclude: m
+ .values_of("exclude")
+ .map(|vals| {
+ vals.flat_map(|x| x.split_ascii_whitespace().collect::<Vec<_>>())
+ .map(ToOwned::to_owned)
+ .collect()
+ })
+ .unwrap_or_else(Vec::new),
+ manifest_path: m.value_of("manifest-path").map(ToOwned::to_owned),
+ quiet: m.is_present("quiet"),
+ verbose: m.occurrences_of("verbose"),
+ exit_code: value_t!(m, "exit-code", i32).ok().unwrap_or(0),
+ packages: m
+ .values_of("packages")
+ .map(|vals| {
+ vals.flat_map(|x| x.split_ascii_whitespace().collect::<Vec<_>>())
+ .map(ToOwned::to_owned)
+ .collect::<Vec<_>>()
+ })
+ .unwrap_or_else(Vec::new),
+ root: m.value_of("root").map(ToOwned::to_owned),
+ depth: value_t!(m, "depth", i32).ok(),
+ root_deps_only: m.is_present("root-deps-only"),
+ workspace: m.is_present("workspace"),
+ aggressive: m.is_present("aggressive"),
+ offline: m.is_present("offline"),
+ };
+
+ if m.is_present("root-deps-only") {
+ opts.depth = Some(1);
+ }
+
+ opts
+ }
+}
+
+fn build() -> App<'static, 'static> {
+ App::new("cargo-outdated")
+ .bin_name("cargo")
+ .setting(AppSettings::SubcommandRequired)
+ .subcommand(
+ SubCommand::with_name("outdated")
+ .setting(AppSettings::UnifiedHelpMessage)
+ .about("Displays information about project dependency versions")
+ .version(crate_version!())
+ .arg(
+ Arg::with_name("aggressive")
+ .short("a")
+ .long("aggresssive")
+ .help("Ignores channels for latest updates"),
+ )
+ .arg(
+ Arg::with_name("quiet")
+ .short("q")
+ .long("quiet")
+ .help("Suppresses warnings"),
+ )
+ .arg(
+ Arg::with_name("root-deps-only")
+ .short("R")
+ .long("root-deps-only")
+ .help("Only check root dependencies (Equivalent to --depth=1)"),
+ )
+ .arg(
+ Arg::with_name("workspace")
+ .short("w")
+ .long("workspace")
+ .help("Checks updates for all workspace members rather than only the root package"),
+ )
+ .arg(
+ Arg::with_name("offline")
+ .short("o")
+ .long("offline")
+ .help("Run without accessing the network (useful for testing w/ local registries)"),
+ )
+ .arg(
+ Arg::with_name("format")
+ .long("format")
+ .default_value("list")
+ .case_insensitive(true)
+ .possible_values(&Format::variants())
+ .value_name("FORMAT")
+ .help("Output formatting"),
+ )
+ .arg(
+ Arg::with_name("ignore")
+ .short("i")
+ .long("ignore")
+ .help("Dependencies to not print in the output (comma separated or one per '--ignore' argument)")
+ .value_delimiter(",")
+ .number_of_values(1)
+ .multiple(true)
+ .value_name("DEPENDENCIES"),
+ )
+ .arg(
+ Arg::with_name("exclude")
+ .short("x")
+ .long("exclude")
+ .help("Dependencies to exclude from building (comma separated or one per '--exclude' argument)")
+ .value_delimiter(",")
+ .multiple(true)
+ .number_of_values(1)
+ .value_name("DEPENDENCIES"),
+ )
+ .arg(
+ Arg::with_name("verbose")
+ .short("v")
+ .long("verbose")
+ .multiple(true)
+ .help("Use verbose output")
+ )
+ .arg(
+ Arg::with_name("color")
+ .long("color")
+ .possible_values(&Color::variants())
+ .default_value("auto")
+ .value_name("COLOR")
+ .case_insensitive(true)
+ .help("Output coloring")
+ )
+ .arg(
+ Arg::with_name("depth")
+ .short("d")
+ .long("depth")
+ .value_name("NUM")
+ .help("How deep in the dependency chain to search (Defaults to all dependencies when omitted)")
+ )
+ .arg(
+ Arg::with_name("exit-code")
+ .long("exit-code")
+ .help("The exit code to return on new versions found")
+ .default_value("0")
+ .value_name("NUM"))
+ .arg(
+ Arg::with_name("manifest-path")
+ .short("m")
+ .long("manifest-path")
+ .help("Path to the Cargo.toml file to use (Defaults to Cargo.toml in project root)")
+ .value_name("PATH"))
+ .arg(
+ Arg::with_name("root")
+ .short("r")
+ .long("root")
+ .help("Package to treat as the root package")
+ .value_name("ROOT"))
+ .arg(
+ Arg::with_name("packages")
+ .short("p")
+ .long("packages")
+ .help("Packages to inspect for updates (comma separated or one per '--packages' argument)")
+ .value_delimiter(",")
+ .number_of_values(1)
+ .multiple(true)
+ .value_name("PKGS"))
+ .arg(
+ Arg::with_name("features")
+ .long("features")
+ .value_delimiter(",")
+ .help("Space-separated list of features")
+ .multiple(true)
+ .number_of_values(1)
+ .value_name("FEATURES"))
+ )
+}
+
+pub fn parse() -> Options {
+ let matches = build().get_matches();
+
+ Options::from(matches.subcommand_matches("outdated").unwrap())
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+
+ fn options(args: &[&str]) -> Options {
+ let mut argv = vec!["cargo", "outdated"];
+ argv.extend(args);
+ let m = build().get_matches_from(argv);
+ Options::from(m.subcommand_matches("outdated").unwrap())
+ }
+
+ fn options_fail(args: &[&str]) -> clap::Result<ArgMatches<'static>> {
+ let mut argv = vec!["cargo", "outdated"];
+ argv.extend(args);
+ build().get_matches_from_safe(argv)
+ }
+
+ #[test]
+ fn default() {
+ let opts = options(&[]);
+ assert_eq!(Options::default(), opts)
+ }
+
+ #[test]
+ fn root_only() {
+ let opts = options(&["--root-deps-only"]);
+ assert_eq!(
+ Options {
+ depth: Some(1),
+ root_deps_only: true,
+ ..Options::default()
+ },
+ opts
+ )
+ }
+
+ #[test]
+ fn features() {
+ let opts1 = options(&["--features=one,two,three"]);
+ let opts2 = options(&["--features", "one,two,three"]);
+ let opts3 = options(&["--features", "one two three"]);
+ let opts4 = options(&[
+ "--features",
+ "one",
+ "--features",
+ "two",
+ "--features",
+ "three",
+ ]);
+ let opts5 = options(&["--features", "one", "--features", "two,three"]);
+
+ let correct = Options {
+ features: vec!["one".into(), "two".into(), "three".into()],
+ ..Options::default()
+ };
+
+ assert_eq!(correct, opts1);
+ assert_eq!(correct, opts2);
+ assert_eq!(correct, opts3);
+ assert_eq!(correct, opts4);
+ assert_eq!(correct, opts5);
+ }
+
+ #[test]
+ fn features_fail() {
+ let res = options_fail(&["--features", "one", "two"]);
+ assert!(res.is_err());
+ assert_eq!(
+ res.as_ref().unwrap_err().kind,
+ clap::ErrorKind::UnknownArgument,
+ "{:?}",
+ res.as_ref().unwrap_err().kind
+ );
+ }
+
+ #[test]
+ fn exclude() {
+ let opts1 = options(&["--exclude=one,two,three"]);
+ let opts2 = options(&["--exclude", "one,two,three"]);
+ let opts3 = options(&["--exclude", "one two three"]);
+ let opts4 = options(&["--exclude", "one", "--exclude", "two", "--exclude", "three"]);
+ let opts5 = options(&["--exclude", "one", "--exclude", "two,three"]);
+ let correct = Options {
+ exclude: vec!["one".into(), "two".into(), "three".into()],
+ ..Options::default()
+ };
+
+ assert_eq!(correct, opts1);
+ assert_eq!(correct, opts2);
+ assert_eq!(correct, opts3);
+ assert_eq!(correct, opts4);
+ assert_eq!(correct, opts5);
+ }
+
+ #[test]
+ fn exclude_fail() {
+ let res = options_fail(&["--exclude", "one", "two"]);
+ assert!(res.is_err());
+ assert_eq!(
+ res.as_ref().unwrap_err().kind,
+ clap::ErrorKind::UnknownArgument,
+ "{:?}",
+ res.as_ref().unwrap_err().kind
+ );
+ }
+
+ #[test]
+ fn ignore() {
+ let opts1 = options(&["--ignore=one,two,three"]);
+ let opts2 = options(&["--ignore", "one,two,three"]);
+ let opts3 = options(&["--ignore", "one two three"]);
+ let opts4 = options(&["--ignore", "one", "--ignore", "two", "--ignore", "three"]);
+ let opts5 = options(&["--ignore", "one", "--ignore", "two,three"]);
+ let correct = Options {
+ ignore: vec!["one".into(), "two".into(), "three".into()],
+ ..Options::default()
+ };
+
+ assert_eq!(correct, opts1);
+ assert_eq!(correct, opts2);
+ assert_eq!(correct, opts3);
+ assert_eq!(correct, opts4);
+ assert_eq!(correct, opts5);
+ }
+
+ #[test]
+ fn ignore_fail() {
+ let res = options_fail(&["--ignore", "one", "two"]);
+ assert!(res.is_err());
+ assert_eq!(
+ res.as_ref().unwrap_err().kind,
+ clap::ErrorKind::UnknownArgument,
+ "{:?}",
+ res.as_ref().unwrap_err().kind
+ );
+ }
+
+ #[test]
+ fn verbose() {
+ let opts1 = options(&["--verbose", "--verbose", "--verbose"]);
+ let correct = Options {
+ verbose: 3,
+ ..Options::default()
+ };
+
+ assert_eq!(correct, opts1);
+ }
+
+ #[test]
+ fn packages() {
+ let opts1 = options(&["--packages", "one,two"]);
+ let opts2 = options(&["--packages", "one two"]);
+ let opts3 = options(&["--packages", "one", "--packages", "two"]);
+ let correct = Options {
+ packages: vec!["one".into(), "two".into()],
+ ..Options::default()
+ };
+
+ assert_eq!(correct, opts1);
+ assert_eq!(correct, opts2);
+ assert_eq!(correct, opts3);
+ }
+
+ #[test]
+ fn packages_fail() {
+ let res = options_fail(&["--packages", "one", "two"]);
+ assert!(res.is_err());
+ assert_eq!(
+ res.as_ref().unwrap_err().kind,
+ clap::ErrorKind::UnknownArgument,
+ "{:?}",
+ res.as_ref().unwrap_err().kind
+ );
+ }
+
+ #[test]
+ fn format_case() {
+ let opts1 = options(&["--format", "JsOn"]);
+ let correct = Options {
+ format: Format::Json,
+ ..Options::default()
+ };
+
+ assert_eq!(correct, opts1);
+ }
+
+ #[test]
+ fn format_unknown() {
+ let res = options_fail(&["--format", "foobar"]);
+ assert!(res.is_err());
+ assert_eq!(
+ res.as_ref().unwrap_err().kind,
+ clap::ErrorKind::InvalidValue,
+ "{:?}",
+ res.as_ref().unwrap_err().kind
+ );
+ }
+
+ #[test]
+ fn color_case() {
+ let opts1 = options(&["--color", "NeVeR"]);
+ let correct = Options {
+ color: Color::Never,
+ ..Options::default()
+ };
+
+ assert_eq!(correct, opts1);
+ }
+
+ #[test]
+ fn color_unknown() {
+ let res = options_fail(&["--color", "foobar"]);
+ assert!(res.is_err());
+ assert_eq!(
+ res.as_ref().unwrap_err().kind,
+ clap::ErrorKind::InvalidValue,
+ "{:?}",
+ res.as_ref().unwrap_err().kind
+ );
+ }
+}
diff --git a/src/main.rs b/src/main.rs
index 92e39ce..050c9f4 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -6,114 +6,24 @@
#[macro_use]
mod macros;
mod cargo_ops;
+mod cli;
mod error;
-use crate::{
- cargo_ops::{ElaborateWorkspace, TempProject},
- error::OutdatedError,
-};
-
use cargo::core::shell::Verbosity;
use cargo::core::Workspace;
use cargo::ops::needs_custom_http_transport;
use cargo::util::important_paths::find_root_manifest_for_wd;
use cargo::util::{CargoResult, CliError, Config};
-use docopt::Docopt;
-/// usage message for --help
-pub const USAGE: &str = "
-Displays information about project dependency versions
-
-USAGE:
- cargo outdated [options]
-
-Options:
- -a, --aggressive Ignores channels for latest updates
- -h, --help Prints help information
- --format FORMAT Output formatting [default: list]
- [values: list, json]
- -i, --ignore DEPENDENCIES Comma separated list of dependencies to not print in the output
- -x, --exclude DEPENDENCIES Comma separated list of dependencies to exclude from building
- -q, --quiet Suppresses warnings
- -R, --root-deps-only Only check root dependencies (Equivalent to --depth=1)
- -V, --version Prints version information
- -v, --verbose ... Use verbose output
- -w, --workspace Checks updates for all workspace members rather than
- only the root package
- --color COLOR Coloring: auto, always, never [default: auto]
- [values: auto, always, never]
- -d, --depth NUM How deep in the dependency chain to search
- (Defaults to all dependencies when omitted)
- --exit-code NUM The exit code to return on new versions found [default: 0]
- --features FEATURES Space-separated list of features
- -m, --manifest-path FILE Path to the Cargo.toml file to use
- (Defaults to Cargo.toml in project root)
- -p, --packages PKGS Packages to inspect for updates
- -r, --root ROOT Package to treat as the root package
- -o, --offline Run without accessing the network (useful for testing w/ local registries)
-";
-
-/// Options from CLI arguments
-#[derive(serde_derive::Deserialize, Debug, PartialEq, Default)]
-pub struct Options {
- flag_format: Option<String>,
- flag_color: Option<String>,
- flag_features: Vec<String>,
- flag_ignore: Vec<String>,
- flag_exclude: Vec<String>,
- flag_manifest_path: Option<String>,
- flag_quiet: bool,
- flag_verbose: u32,
- flag_exit_code: i32,
- flag_packages: Vec<String>,
- flag_root: Option<String>,
- flag_depth: Option<i32>,
- flag_root_deps_only: bool,
- flag_workspace: bool,
- flag_aggressive: bool,
- flag_offline: bool,
-}
-
-impl Options {
- fn all_features(&self) -> bool { self.flag_features.is_empty() }
-
- fn no_default_features(&self) -> bool {
- !(self.flag_features.is_empty() || self.flag_features.contains(&"default".to_owned()))
- }
-
- fn locked(&self) -> bool { false }
-
- fn frozen(&self) -> bool { false }
-}
+use crate::{
+ cargo_ops::{ElaborateWorkspace, TempProject},
+ cli::{Format, Options},
+ error::OutdatedError,
+};
fn main() {
env_logger::init();
- let options = {
- let mut options: Options = Docopt::new(USAGE)
- .and_then(|d| {
- d.version(Some(
- concat!(env!("CARGO_PKG_NAME"), " v", env!("CARGO_PKG_VERSION")).to_owned(),
- ))
- .deserialize()
- })
- .unwrap_or_else(|e| e.exit());
- fn flat_split(arg: &[String]) -> Vec<String> {
- arg.iter()
- .flat_map(|s| s.split_whitespace())
- .flat_map(|s| s.split(','))
- .filter(|s| !s.is_empty())
- .map(ToString::to_string)
- .collect()
- }
- options.flag_features = flat_split(&options.flag_features);
- options.flag_ignore = flat_split(&options.flag_ignore);
- options.flag_exclude = flat_split(&options.flag_exclude);
- options.flag_packages = flat_split(&options.flag_packages);
- if options.flag_root_deps_only {
- options.flag_depth = Some(1);
- }
- options
- };
+ let options = cli::parse();
let mut config = match Config::default() {
Ok(cfg) => cfg,
@@ -137,7 +47,7 @@
}
}
- let exit_code = options.flag_exit_code;
+ let exit_code = options.exit_code;
let result = execute(options, &mut config);
match result {
Err(e) => {
@@ -165,12 +75,15 @@
config.nightly_features_allowed = true;
config.configure(
- options.flag_verbose,
- options.flag_quiet,
- options.flag_color.as_deref(),
+ options
+ .verbose
+ .try_into()
+ .expect("--verbose used too many times"),
+ options.quiet,
+ Some(&options.color.to_string().to_ascii_lowercase()),
options.frozen(),
options.locked(),
- options.flag_offline,
+ options.offline,
&cargo_home_path,
&[],
&[],
@@ -180,7 +93,7 @@
verbose!(config, "Parsing...", "current workspace");
// the Cargo.toml that we are actually working on
let mut manifest_abspath: std::path::PathBuf;
- let curr_manifest = if let Some(ref manifest_path) = options.flag_manifest_path {
+ let curr_manifest = if let Some(ref manifest_path) = options.manifest_path {
manifest_abspath = manifest_path.into();
if manifest_abspath.is_relative() {
verbose!(config, "Resolving...", "absolute path of manifest");
@@ -192,11 +105,11 @@
};
let curr_workspace = Workspace::new(&curr_manifest, config)?;
verbose!(config, "Resolving...", "current workspace");
- if options.flag_verbose == 0 {
+ if options.verbose == 0 {
config.shell().set_verbosity(Verbosity::Quiet);
}
let ela_curr = ElaborateWorkspace::from_workspace(&curr_workspace, &options)?;
- if options.flag_verbose > 0 {
+ if options.verbose > 0 {
config.shell().set_verbosity(Verbosity::Verbose);
} else {
config.shell().set_verbosity(Verbosity::Normal);
@@ -242,10 +155,9 @@
if ela_curr.workspace_mode {
let mut sum = 0;
- if options.flag_format == Some("list".to_string()) {
- verbose!(config, "Printing...", "Package status in list format");
- } else if options.flag_format == Some("json".to_string()) {
- verbose!(config, "Printing...", "Package status in json format");
+ match options.format {
+ Format::List => verbose!(config, "Printing...", "Package status in list format"),
+ Format::Json => verbose!(config, "Printing...", "Package status in json format"),
}
for member in ela_curr.workspace.members() {
@@ -256,10 +168,13 @@
config,
member.package_id(),
)?;
- if options.flag_format == Some("list".to_string()) {
- sum += ela_curr.print_list(&options, member.package_id(), sum > 0)?;
- } else if options.flag_format == Some("json".to_string()) {
- sum += ela_curr.print_json(&options, member.package_id())?;
+ match options.format {
+ Format::List => {
+ sum += ela_curr.print_list(&options, member.package_id(), sum > 0)?;
+ }
+ Format::Json => {
+ sum += ela_curr.print_json(&options, member.package_id())?;
+ }
}
}
if sum == 0 {
@@ -273,173 +188,15 @@
verbose!(config, "Printing...", "list format");
let mut count = 0;
- if options.flag_format == Some("list".to_string()) {
- count = ela_curr.print_list(&options, root, false)?;
- } else if options.flag_format == Some("json".to_string()) {
- ela_curr.print_json(&options, root)?;
- } else {
- println!("Error, did not specify list or json output formatting");
- std::process::exit(2);
+ match options.format {
+ Format::List => {
+ count = ela_curr.print_list(&options, root, false)?;
+ }
+ Format::Json => {
+ ela_curr.print_json(&options, root)?;
+ }
}
Ok(count)
}
}
-
-#[cfg(test)]
-mod test {
- use super::*;
-
- fn options(args: &[&str]) -> Options {
- let mut argv = vec!["cargo", "outdated"];
- if !args.is_empty() {
- argv.extend(args);
- }
- let mut options: Options = Docopt::new(USAGE)
- .and_then(|d| {
- d.version(Some(
- concat!(env!("CARGO_PKG_NAME"), " v", env!("CARGO_PKG_VERSION")).to_owned(),
- ))
- .argv(argv)
- .deserialize()
- })
- .unwrap_or_else(|e| e.exit());
- fn flat_split(arg: &[String]) -> Vec<String> {
- arg.iter()
- .flat_map(|s| s.split_whitespace())
- .flat_map(|s| s.split(','))
- .filter(|s| !s.is_empty())
- .map(ToString::to_string)
- .collect()
- }
- options.flag_features = flat_split(&options.flag_features);
- options.flag_ignore = flat_split(&options.flag_ignore);
- options.flag_exclude = flat_split(&options.flag_exclude);
- options.flag_packages = flat_split(&options.flag_packages);
- if options.flag_root_deps_only {
- options.flag_depth = Some(1);
- }
- options
- }
-
- #[test]
- fn default() {
- let opts = options(&[]);
- assert_eq!(
- Options {
- flag_format: Some("list".into()),
- flag_color: Some("auto".into()),
- ..Options::default()
- },
- opts
- )
- }
-
- #[test]
- fn root_only() {
- let opts = options(&["--root-deps-only"]);
- assert_eq!(
- Options {
- flag_format: Some("list".into()),
- flag_color: Some("auto".into()),
- flag_depth: Some(1),
- flag_root_deps_only: true,
- ..Options::default()
- },
- opts
- )
- }
-
- #[test]
- fn features() {
- let opts1 = options(&["--features=one,two,three"]);
- let opts2 = options(&["--features", "one,two,three"]);
- let opts3 = options(&["--features", "one two three"]);
- // Not supported
- //let opts4 = options("--features one --features two --features three");
- //let opts5 = options("--features one --features two,three");
- let correct = Options {
- flag_format: Some("list".into()),
- flag_color: Some("auto".into()),
- flag_features: vec!["one".into(), "two".into(), "three".into()],
- ..Options::default()
- };
-
- assert_eq!(correct, opts1);
- assert_eq!(correct, opts2);
- assert_eq!(correct, opts3);
- }
-
- #[test]
- fn exclude() {
- let opts1 = options(&["--exclude=one,two,three"]);
- let opts2 = options(&["--exclude", "one,two,three"]);
- let opts3 = options(&["--exclude", "one two three"]);
- // Not supported
- //let opts4 = options("--exclude one two three");
- //let opts5 = options("--exclude one --exclude two --exclude three");
- //let opts6 = options("--exclude one --exclude two,three");
- let correct = Options {
- flag_format: Some("list".into()),
- flag_color: Some("auto".into()),
- flag_exclude: vec!["one".into(), "two".into(), "three".into()],
- ..Options::default()
- };
-
- assert_eq!(correct, opts1);
- assert_eq!(correct, opts2);
- assert_eq!(correct, opts3);
- }
-
- #[test]
- fn ignore() {
- let opts1 = options(&["--ignore=one,two,three"]);
- let opts2 = options(&["--ignore", "one,two,three"]);
- let opts3 = options(&["--ignore", "one two three"]);
- // Not supported
- //let opts4 = options("--ignore one two three");
- //let opts5 = options("--ignore one --ignore two --ignore three");
- //let opts6 = options("--ignore one --ignore two,three");
- let correct = Options {
- flag_format: Some("list".into()),
- flag_color: Some("auto".into()),
- flag_ignore: vec!["one".into(), "two".into(), "three".into()],
- ..Options::default()
- };
-
- assert_eq!(correct, opts1);
- assert_eq!(correct, opts2);
- assert_eq!(correct, opts3);
- }
-
- #[test]
- fn verbose() {
- let opts1 = options(&["--verbose", "--verbose", "--verbose"]);
- let correct = Options {
- flag_format: Some("list".into()),
- flag_color: Some("auto".into()),
- flag_verbose: 3,
- ..Options::default()
- };
-
- assert_eq!(correct, opts1);
- }
-
- #[test]
- fn packages() {
- let opts1 = options(&["--packages", "one,two"]);
- let opts2 = options(&["--packages", "one two"]);
- // Not Supported
- //let opts3 = options(&["--packages","one","--packages","two"]);
- //let opts4 = options(&["--packages", "one", "two"]);
- let correct = Options {
- flag_format: Some("list".into()),
- flag_color: Some("auto".into()),
- flag_packages: vec!["one".into(), "two".into()],
- ..Options::default()
- };
-
- assert_eq!(correct, opts1);
- assert_eq!(correct, opts2);
- }
-}
