diff options
Diffstat (limited to 'clap/src/errors.rs')
| -rw-r--r-- | clap/src/errors.rs | 912 |
1 files changed, 0 insertions, 912 deletions
diff --git a/clap/src/errors.rs b/clap/src/errors.rs deleted file mode 100644 index c6087c0..0000000 --- a/clap/src/errors.rs +++ /dev/null @@ -1,912 +0,0 @@ -// Std -use std::convert::From; -use std::error::Error as StdError; -use std::fmt as std_fmt; -use std::fmt::Display; -use std::io::{self, Write}; -use std::process; -use std::result::Result as StdResult; - -// Internal -use args::AnyArg; -use fmt::{ColorWhen, Colorizer, ColorizerOption}; -use suggestions; - -/// Short hand for [`Result`] type -/// -/// [`Result`]: https://doc.rust-lang.org/std/result/enum.Result.html -pub type Result<T> = StdResult<T, Error>; - -/// Command line argument parser kind of error -#[derive(Debug, Copy, Clone, PartialEq)] -pub enum ErrorKind { - /// Occurs when an [`Arg`] has a set of possible values, - /// and the user provides a value which isn't in that set. - /// - /// # Examples - /// - /// ```rust - /// # use clap::{App, Arg, ErrorKind}; - /// let result = App::new("prog") - /// .arg(Arg::with_name("speed") - /// .possible_value("fast") - /// .possible_value("slow")) - /// .get_matches_from_safe(vec!["prog", "other"]); - /// assert!(result.is_err()); - /// assert_eq!(result.unwrap_err().kind, ErrorKind::InvalidValue); - /// ``` - /// [`Arg`]: ./struct.Arg.html - InvalidValue, - - /// Occurs when a user provides a flag, option, argument or subcommand which isn't defined. - /// - /// # Examples - /// - /// ```rust - /// # use clap::{App, Arg, ErrorKind}; - /// let result = App::new("prog") - /// .arg(Arg::from_usage("--flag 'some flag'")) - /// .get_matches_from_safe(vec!["prog", "--other"]); - /// assert!(result.is_err()); - /// assert_eq!(result.unwrap_err().kind, ErrorKind::UnknownArgument); - /// ``` - UnknownArgument, - - /// Occurs when the user provides an unrecognized [`SubCommand`] which meets the threshold for - /// being similar enough to an existing subcommand. - /// If it doesn't meet the threshold, or the 'suggestions' feature is disabled, - /// the more general [`UnknownArgument`] error is returned. - /// - /// # Examples - /// - #[cfg_attr(not(feature = "suggestions"), doc = " ```no_run")] - #[cfg_attr(feature = "suggestions", doc = " ```")] - /// # use clap::{App, Arg, ErrorKind, SubCommand}; - /// let result = App::new("prog") - /// .subcommand(SubCommand::with_name("config") - /// .about("Used for configuration") - /// .arg(Arg::with_name("config_file") - /// .help("The configuration file to use") - /// .index(1))) - /// .get_matches_from_safe(vec!["prog", "confi"]); - /// assert!(result.is_err()); - /// assert_eq!(result.unwrap_err().kind, ErrorKind::InvalidSubcommand); - /// ``` - /// [`SubCommand`]: ./struct.SubCommand.html - /// [`UnknownArgument`]: ./enum.ErrorKind.html#variant.UnknownArgument - InvalidSubcommand, - - /// Occurs when the user provides an unrecognized [`SubCommand`] which either - /// doesn't meet the threshold for being similar enough to an existing subcommand, - /// or the 'suggestions' feature is disabled. - /// Otherwise the more detailed [`InvalidSubcommand`] error is returned. - /// - /// This error typically happens when passing additional subcommand names to the `help` - /// subcommand. Otherwise, the more general [`UnknownArgument`] error is used. - /// - /// # Examples - /// - /// ```rust - /// # use clap::{App, Arg, ErrorKind, SubCommand}; - /// let result = App::new("prog") - /// .subcommand(SubCommand::with_name("config") - /// .about("Used for configuration") - /// .arg(Arg::with_name("config_file") - /// .help("The configuration file to use") - /// .index(1))) - /// .get_matches_from_safe(vec!["prog", "help", "nothing"]); - /// assert!(result.is_err()); - /// assert_eq!(result.unwrap_err().kind, ErrorKind::UnrecognizedSubcommand); - /// ``` - /// [`SubCommand`]: ./struct.SubCommand.html - /// [`InvalidSubcommand`]: ./enum.ErrorKind.html#variant.InvalidSubcommand - /// [`UnknownArgument`]: ./enum.ErrorKind.html#variant.UnknownArgument - UnrecognizedSubcommand, - - /// Occurs when the user provides an empty value for an option that does not allow empty - /// values. - /// - /// # Examples - /// - /// ```rust - /// # use clap::{App, Arg, ErrorKind}; - /// let res = App::new("prog") - /// .arg(Arg::with_name("color") - /// .long("color") - /// .empty_values(false)) - /// .get_matches_from_safe(vec!["prog", "--color="]); - /// assert!(res.is_err()); - /// assert_eq!(res.unwrap_err().kind, ErrorKind::EmptyValue); - /// ``` - EmptyValue, - - /// Occurs when the user provides a value for an argument with a custom validation and the - /// value fails that validation. - /// - /// # Examples - /// - /// ```rust - /// # use clap::{App, Arg, ErrorKind}; - /// fn is_numeric(val: String) -> Result<(), String> { - /// match val.parse::<i64>() { - /// Ok(..) => Ok(()), - /// Err(..) => Err(String::from("Value wasn't a number!")), - /// } - /// } - /// - /// let result = App::new("prog") - /// .arg(Arg::with_name("num") - /// .validator(is_numeric)) - /// .get_matches_from_safe(vec!["prog", "NotANumber"]); - /// assert!(result.is_err()); - /// assert_eq!(result.unwrap_err().kind, ErrorKind::ValueValidation); - /// ``` - ValueValidation, - - /// Occurs when a user provides more values for an argument than were defined by setting - /// [`Arg::max_values`]. - /// - /// # Examples - /// - /// ```rust - /// # use clap::{App, Arg, ErrorKind}; - /// let result = App::new("prog") - /// .arg(Arg::with_name("arg") - /// .multiple(true) - /// .max_values(2)) - /// .get_matches_from_safe(vec!["prog", "too", "many", "values"]); - /// assert!(result.is_err()); - /// assert_eq!(result.unwrap_err().kind, ErrorKind::TooManyValues); - /// ``` - /// [`Arg::max_values`]: ./struct.Arg.html#method.max_values - TooManyValues, - - /// Occurs when the user provides fewer values for an argument than were defined by setting - /// [`Arg::min_values`]. - /// - /// # Examples - /// - /// ```rust - /// # use clap::{App, Arg, ErrorKind}; - /// let result = App::new("prog") - /// .arg(Arg::with_name("some_opt") - /// .long("opt") - /// .min_values(3)) - /// .get_matches_from_safe(vec!["prog", "--opt", "too", "few"]); - /// assert!(result.is_err()); - /// assert_eq!(result.unwrap_err().kind, ErrorKind::TooFewValues); - /// ``` - /// [`Arg::min_values`]: ./struct.Arg.html#method.min_values - TooFewValues, - - /// Occurs when the user provides a different number of values for an argument than what's - /// been defined by setting [`Arg::number_of_values`] or than was implicitly set by - /// [`Arg::value_names`]. - /// - /// # Examples - /// - /// ```rust - /// # use clap::{App, Arg, ErrorKind}; - /// let result = App::new("prog") - /// .arg(Arg::with_name("some_opt") - /// .long("opt") - /// .takes_value(true) - /// .number_of_values(2)) - /// .get_matches_from_safe(vec!["prog", "--opt", "wrong"]); - /// assert!(result.is_err()); - /// assert_eq!(result.unwrap_err().kind, ErrorKind::WrongNumberOfValues); - /// ``` - /// - /// [`Arg::number_of_values`]: ./struct.Arg.html#method.number_of_values - /// [`Arg::value_names`]: ./struct.Arg.html#method.value_names - WrongNumberOfValues, - - /// Occurs when the user provides two values which conflict with each other and can't be used - /// together. - /// - /// # Examples - /// - /// ```rust - /// # use clap::{App, Arg, ErrorKind}; - /// let result = App::new("prog") - /// .arg(Arg::with_name("debug") - /// .long("debug") - /// .conflicts_with("color")) - /// .arg(Arg::with_name("color") - /// .long("color")) - /// .get_matches_from_safe(vec!["prog", "--debug", "--color"]); - /// assert!(result.is_err()); - /// assert_eq!(result.unwrap_err().kind, ErrorKind::ArgumentConflict); - /// ``` - ArgumentConflict, - - /// Occurs when the user does not provide one or more required arguments. - /// - /// # Examples - /// - /// ```rust - /// # use clap::{App, Arg, ErrorKind}; - /// let result = App::new("prog") - /// .arg(Arg::with_name("debug") - /// .required(true)) - /// .get_matches_from_safe(vec!["prog"]); - /// assert!(result.is_err()); - /// assert_eq!(result.unwrap_err().kind, ErrorKind::MissingRequiredArgument); - /// ``` - MissingRequiredArgument, - - /// Occurs when a subcommand is required (as defined by [`AppSettings::SubcommandRequired`]), - /// but the user does not provide one. - /// - /// # Examples - /// - /// ```rust - /// # use clap::{App, AppSettings, SubCommand, ErrorKind}; - /// let err = App::new("prog") - /// .setting(AppSettings::SubcommandRequired) - /// .subcommand(SubCommand::with_name("test")) - /// .get_matches_from_safe(vec![ - /// "myprog", - /// ]); - /// assert!(err.is_err()); - /// assert_eq!(err.unwrap_err().kind, ErrorKind::MissingSubcommand); - /// # ; - /// ``` - /// [`AppSettings::SubcommandRequired`]: ./enum.AppSettings.html#variant.SubcommandRequired - MissingSubcommand, - - /// Occurs when either an argument or [`SubCommand`] is required, as defined by - /// [`AppSettings::ArgRequiredElseHelp`], but the user did not provide one. - /// - /// # Examples - /// - /// ```rust - /// # use clap::{App, Arg, AppSettings, ErrorKind, SubCommand}; - /// let result = App::new("prog") - /// .setting(AppSettings::ArgRequiredElseHelp) - /// .subcommand(SubCommand::with_name("config") - /// .about("Used for configuration") - /// .arg(Arg::with_name("config_file") - /// .help("The configuration file to use"))) - /// .get_matches_from_safe(vec!["prog"]); - /// assert!(result.is_err()); - /// assert_eq!(result.unwrap_err().kind, ErrorKind::MissingArgumentOrSubcommand); - /// ``` - /// [`SubCommand`]: ./struct.SubCommand.html - /// [`AppSettings::ArgRequiredElseHelp`]: ./enum.AppSettings.html#variant.ArgRequiredElseHelp - MissingArgumentOrSubcommand, - - /// Occurs when the user provides multiple values to an argument which doesn't allow that. - /// - /// # Examples - /// - /// ```rust - /// # use clap::{App, Arg, ErrorKind}; - /// let result = App::new("prog") - /// .arg(Arg::with_name("debug") - /// .long("debug") - /// .multiple(false)) - /// .get_matches_from_safe(vec!["prog", "--debug", "--debug"]); - /// assert!(result.is_err()); - /// assert_eq!(result.unwrap_err().kind, ErrorKind::UnexpectedMultipleUsage); - /// ``` - UnexpectedMultipleUsage, - - /// Occurs when the user provides a value containing invalid UTF-8 for an argument and - /// [`AppSettings::StrictUtf8`] is set. - /// - /// # Platform Specific - /// - /// Non-Windows platforms only (such as Linux, Unix, macOS, etc.) - /// - /// # Examples - /// - #[cfg_attr(not(unix), doc = " ```ignore")] - #[cfg_attr(unix, doc = " ```")] - /// # use clap::{App, Arg, ErrorKind, AppSettings}; - /// # use std::os::unix::ffi::OsStringExt; - /// # use std::ffi::OsString; - /// let result = App::new("prog") - /// .setting(AppSettings::StrictUtf8) - /// .arg(Arg::with_name("utf8") - /// .short("u") - /// .takes_value(true)) - /// .get_matches_from_safe(vec![OsString::from("myprog"), - /// OsString::from("-u"), - /// OsString::from_vec(vec![0xE9])]); - /// assert!(result.is_err()); - /// assert_eq!(result.unwrap_err().kind, ErrorKind::InvalidUtf8); - /// ``` - /// [`AppSettings::StrictUtf8`]: ./enum.AppSettings.html#variant.StrictUtf8 - InvalidUtf8, - - /// Not a true "error" as it means `--help` or similar was used. - /// The help message will be sent to `stdout`. - /// - /// **Note**: If the help is displayed due to an error (such as missing subcommands) it will - /// be sent to `stderr` instead of `stdout`. - /// - /// # Examples - /// - /// ```rust - /// # use clap::{App, Arg, ErrorKind}; - /// let result = App::new("prog") - /// .get_matches_from_safe(vec!["prog", "--help"]); - /// assert!(result.is_err()); - /// assert_eq!(result.unwrap_err().kind, ErrorKind::HelpDisplayed); - /// ``` - HelpDisplayed, - - /// Not a true "error" as it means `--version` or similar was used. - /// The message will be sent to `stdout`. - /// - /// # Examples - /// - /// ```rust - /// # use clap::{App, Arg, ErrorKind}; - /// let result = App::new("prog") - /// .get_matches_from_safe(vec!["prog", "--version"]); - /// assert!(result.is_err()); - /// assert_eq!(result.unwrap_err().kind, ErrorKind::VersionDisplayed); - /// ``` - VersionDisplayed, - - /// Occurs when using the [`value_t!`] and [`values_t!`] macros to convert an argument value - /// into type `T`, but the argument you requested wasn't used. I.e. you asked for an argument - /// with name `config` to be converted, but `config` wasn't used by the user. - /// [`value_t!`]: ./macro.value_t!.html - /// [`values_t!`]: ./macro.values_t!.html - ArgumentNotFound, - - /// Represents an [I/O error]. - /// Can occur when writing to `stderr` or `stdout` or reading a configuration file. - /// [I/O error]: https://doc.rust-lang.org/std/io/struct.Error.html - Io, - - /// Represents a [Format error] (which is a part of [`Display`]). - /// Typically caused by writing to `stderr` or `stdout`. - /// - /// [`Display`]: https://doc.rust-lang.org/std/fmt/trait.Display.html - /// [Format error]: https://doc.rust-lang.org/std/fmt/struct.Error.html - Format, -} - -/// Command Line Argument Parser Error -#[derive(Debug)] -pub struct Error { - /// Formatted error message - pub message: String, - /// The type of error - pub kind: ErrorKind, - /// Any additional information passed along, such as the argument name that caused the error - pub info: Option<Vec<String>>, -} - -impl Error { - /// Should the message be written to `stdout` or not - pub fn use_stderr(&self) -> bool { - match self.kind { - ErrorKind::HelpDisplayed | ErrorKind::VersionDisplayed => false, - _ => true, - } - } - - /// Prints the error to `stderr` and exits with a status of `1` - pub fn exit(&self) -> ! { - if self.use_stderr() { - wlnerr!("{}", self.message); - process::exit(1); - } - let out = io::stdout(); - writeln!(&mut out.lock(), "{}", self.message).expect("Error writing Error to stdout"); - process::exit(0); - } - - #[doc(hidden)] - pub fn write_to<W: Write>(&self, w: &mut W) -> io::Result<()> { write!(w, "{}", self.message) } - - #[doc(hidden)] - pub fn argument_conflict<O, U>( - arg: &AnyArg, - other: Option<O>, - usage: U, - color: ColorWhen, - ) -> Self - where - O: Into<String>, - U: Display, - { - let mut v = vec![arg.name().to_owned()]; - let c = Colorizer::new(ColorizerOption { - use_stderr: true, - when: color, - }); - Error { - message: format!( - "{} The argument '{}' cannot be used with {}\n\n\ - {}\n\n\ - For more information try {}", - c.error("error:"), - c.warning(&*arg.to_string()), - match other { - Some(name) => { - let n = name.into(); - v.push(n.clone()); - c.warning(format!("'{}'", n)) - } - None => c.none("one or more of the other specified arguments".to_owned()), - }, - usage, - c.good("--help") - ), - kind: ErrorKind::ArgumentConflict, - info: Some(v), - } - } - - #[doc(hidden)] - pub fn empty_value<U>(arg: &AnyArg, usage: U, color: ColorWhen) -> Self - where - U: Display, - { - let c = Colorizer::new(ColorizerOption { - use_stderr: true, - when: color, - }); - Error { - message: format!( - "{} The argument '{}' requires a value but none was supplied\ - \n\n\ - {}\n\n\ - For more information try {}", - c.error("error:"), - c.warning(arg.to_string()), - usage, - c.good("--help") - ), - kind: ErrorKind::EmptyValue, - info: Some(vec![arg.name().to_owned()]), - } - } - - #[doc(hidden)] - pub fn invalid_value<B, G, U>( - bad_val: B, - good_vals: &[G], - arg: &AnyArg, - usage: U, - color: ColorWhen, - ) -> Self - where - B: AsRef<str>, - G: AsRef<str> + Display, - U: Display, - { - let c = Colorizer::new(ColorizerOption { - use_stderr: true, - when: color, - }); - let suffix = suggestions::did_you_mean_value_suffix(bad_val.as_ref(), good_vals.iter()); - - let mut sorted = vec![]; - for v in good_vals { - let val = format!("{}", c.good(v)); - sorted.push(val); - } - sorted.sort(); - let valid_values = sorted.join(", "); - Error { - message: format!( - "{} '{}' isn't a valid value for '{}'\n\t\ - [possible values: {}]\n\ - {}\n\n\ - {}\n\n\ - For more information try {}", - c.error("error:"), - c.warning(bad_val.as_ref()), - c.warning(arg.to_string()), - valid_values, - suffix.0, - usage, - c.good("--help") - ), - kind: ErrorKind::InvalidValue, - info: Some(vec![arg.name().to_owned(), bad_val.as_ref().to_owned()]), - } - } - - #[doc(hidden)] - pub fn invalid_subcommand<S, D, N, U>( - subcmd: S, - did_you_mean: D, - name: N, - usage: U, - color: ColorWhen, - ) -> Self - where - S: Into<String>, - D: AsRef<str> + Display, - N: Display, - U: Display, - { - let s = subcmd.into(); - let c = Colorizer::new(ColorizerOption { - use_stderr: true, - when: color, - }); - Error { - message: format!( - "{} The subcommand '{}' wasn't recognized\n\t\ - Did you mean '{}'?\n\n\ - If you believe you received this message in error, try \ - re-running with '{} {} {}'\n\n\ - {}\n\n\ - For more information try {}", - c.error("error:"), - c.warning(&*s), - c.good(did_you_mean.as_ref()), - name, - c.good("--"), - &*s, - usage, - c.good("--help") - ), - kind: ErrorKind::InvalidSubcommand, - info: Some(vec![s]), - } - } - - #[doc(hidden)] - pub fn unrecognized_subcommand<S, N>(subcmd: S, name: N, color: ColorWhen) -> Self - where - S: Into<String>, - N: Display, - { - let s = subcmd.into(); - let c = Colorizer::new(ColorizerOption { - use_stderr: true, - when: color, - }); - Error { - message: format!( - "{} The subcommand '{}' wasn't recognized\n\n\ - {}\n\t\ - {} help <subcommands>...\n\n\ - For more information try {}", - c.error("error:"), - c.warning(&*s), - c.warning("USAGE:"), - name, - c.good("--help") - ), - kind: ErrorKind::UnrecognizedSubcommand, - info: Some(vec![s]), - } - } - - #[doc(hidden)] - pub fn missing_required_argument<R, U>(required: R, usage: U, color: ColorWhen) -> Self - where - R: Display, - U: Display, - { - let c = Colorizer::new(ColorizerOption { - use_stderr: true, - when: color, - }); - Error { - message: format!( - "{} The following required arguments were not provided:{}\n\n\ - {}\n\n\ - For more information try {}", - c.error("error:"), - required, - usage, - c.good("--help") - ), - kind: ErrorKind::MissingRequiredArgument, - info: None, - } - } - - #[doc(hidden)] - pub fn missing_subcommand<N, U>(name: N, usage: U, color: ColorWhen) -> Self - where - N: AsRef<str> + Display, - U: Display, - { - let c = Colorizer::new(ColorizerOption { - use_stderr: true, - when: color, - }); - Error { - message: format!( - "{} '{}' requires a subcommand, but one was not provided\n\n\ - {}\n\n\ - For more information try {}", - c.error("error:"), - c.warning(name), - usage, - c.good("--help") - ), - kind: ErrorKind::MissingSubcommand, - info: None, - } - } - - - #[doc(hidden)] - pub fn invalid_utf8<U>(usage: U, color: ColorWhen) -> Self - where - U: Display, - { - let c = Colorizer::new(ColorizerOption { - use_stderr: true, - when: color, - }); - Error { - message: format!( - "{} Invalid UTF-8 was detected in one or more arguments\n\n\ - {}\n\n\ - For more information try {}", - c.error("error:"), - usage, - c.good("--help") - ), - kind: ErrorKind::InvalidUtf8, - info: None, - } - } - - #[doc(hidden)] - pub fn too_many_values<V, U>(val: V, arg: &AnyArg, usage: U, color: ColorWhen) -> Self - where - V: AsRef<str> + Display + ToOwned, - U: Display, - { - let v = val.as_ref(); - let c = Colorizer::new(ColorizerOption { - use_stderr: true, - when: color, - }); - Error { - message: format!( - "{} The value '{}' was provided to '{}', but it wasn't expecting \ - any more values\n\n\ - {}\n\n\ - For more information try {}", - c.error("error:"), - c.warning(v), - c.warning(arg.to_string()), - usage, - c.good("--help") - ), - kind: ErrorKind::TooManyValues, - info: Some(vec![arg.name().to_owned(), v.to_owned()]), - } - } - - #[doc(hidden)] - pub fn too_few_values<U>( - arg: &AnyArg, - min_vals: u64, - curr_vals: usize, - usage: U, - color: ColorWhen, - ) -> Self - where - U: Display, - { - let c = Colorizer::new(ColorizerOption { - use_stderr: true, - when: color, - }); - Error { - message: format!( - "{} The argument '{}' requires at least {} values, but only {} w{} \ - provided\n\n\ - {}\n\n\ - For more information try {}", - c.error("error:"), - c.warning(arg.to_string()), - c.warning(min_vals.to_string()), - c.warning(curr_vals.to_string()), - if curr_vals > 1 { "ere" } else { "as" }, - usage, - c.good("--help") - ), - kind: ErrorKind::TooFewValues, - info: Some(vec![arg.name().to_owned()]), - } - } - - #[doc(hidden)] - pub fn value_validation(arg: Option<&AnyArg>, err: String, color: ColorWhen) -> Self - { - let c = Colorizer::new(ColorizerOption { - use_stderr: true, - when: color, - }); - Error { - message: format!( - "{} Invalid value{}: {}", - c.error("error:"), - if let Some(a) = arg { - format!(" for '{}'", c.warning(a.to_string())) - } else { - "".to_string() - }, - err - ), - kind: ErrorKind::ValueValidation, - info: None, - } - } - - #[doc(hidden)] - pub fn value_validation_auto(err: String) -> Self { - let n: Option<&AnyArg> = None; - Error::value_validation(n, err, ColorWhen::Auto) - } - - #[doc(hidden)] - pub fn wrong_number_of_values<S, U>( - arg: &AnyArg, - num_vals: u64, - curr_vals: usize, - suffix: S, - usage: U, - color: ColorWhen, - ) -> Self - where - S: Display, - U: Display, - { - let c = Colorizer::new(ColorizerOption { - use_stderr: true, - when: color, - }); - Error { - message: format!( - "{} The argument '{}' requires {} values, but {} w{} \ - provided\n\n\ - {}\n\n\ - For more information try {}", - c.error("error:"), - c.warning(arg.to_string()), - c.warning(num_vals.to_string()), - c.warning(curr_vals.to_string()), - suffix, - usage, - c.good("--help") - ), - kind: ErrorKind::WrongNumberOfValues, - info: Some(vec![arg.name().to_owned()]), - } - } - - #[doc(hidden)] - pub fn unexpected_multiple_usage<U>(arg: &AnyArg, usage: U, color: ColorWhen) -> Self - where - U: Display, - { - let c = Colorizer::new(ColorizerOption { - use_stderr: true, - when: color, - }); - Error { - message: format!( - "{} The argument '{}' was provided more than once, but cannot \ - be used multiple times\n\n\ - {}\n\n\ - For more information try {}", - c.error("error:"), - c.warning(arg.to_string()), - usage, - c.good("--help") - ), - kind: ErrorKind::UnexpectedMultipleUsage, - info: Some(vec![arg.name().to_owned()]), - } - } - - #[doc(hidden)] - pub fn unknown_argument<A, U>(arg: A, did_you_mean: &str, usage: U, color: ColorWhen) -> Self - where - A: Into<String>, - U: Display, - { - let a = arg.into(); - let c = Colorizer::new(ColorizerOption { - use_stderr: true, - when: color, - }); - Error { - message: format!( - "{} Found argument '{}' which wasn't expected, or isn't valid in \ - this context{}\n\ - {}\n\n\ - For more information try {}", - c.error("error:"), - c.warning(&*a), - if did_you_mean.is_empty() { - "\n".to_owned() - } else { - format!("{}\n", did_you_mean) - }, - usage, - c.good("--help") - ), - kind: ErrorKind::UnknownArgument, - info: Some(vec![a]), - } - } - - #[doc(hidden)] - pub fn io_error(e: &Error, color: ColorWhen) -> Self { - let c = Colorizer::new(ColorizerOption { - use_stderr: true, - when: color, - }); - Error { - message: format!("{} {}", c.error("error:"), e.description()), - kind: ErrorKind::Io, - info: None, - } - } - - #[doc(hidden)] - pub fn argument_not_found_auto<A>(arg: A) -> Self - where - A: Into<String>, - { - let a = arg.into(); - let c = Colorizer::new(ColorizerOption { - use_stderr: true, - when: ColorWhen::Auto, - }); - Error { - message: format!( - "{} The argument '{}' wasn't found", - c.error("error:"), - a.clone() - ), - kind: ErrorKind::ArgumentNotFound, - info: Some(vec![a]), - } - } - - /// Create an error with a custom description. - /// - /// This can be used in combination with `Error::exit` to exit your program - /// with a custom error message. - pub fn with_description(description: &str, kind: ErrorKind) -> Self { - let c = Colorizer::new(ColorizerOption { - use_stderr: true, - when: ColorWhen::Auto, - }); - Error { - message: format!("{} {}", c.error("error:"), description), - kind: kind, - info: None, - } - } -} - -impl StdError for Error { - fn description(&self) -> &str { &*self.message } -} - -impl Display for Error { - fn fmt(&self, f: &mut std_fmt::Formatter) -> std_fmt::Result { writeln!(f, "{}", self.message) } -} - -impl From<io::Error> for Error { - fn from(e: io::Error) -> Self { Error::with_description(e.description(), ErrorKind::Io) } -} - -impl From<std_fmt::Error> for Error { - fn from(e: std_fmt::Error) -> Self { - Error::with_description(e.description(), ErrorKind::Format) - } -} |