diff options
25 files changed, 322 insertions, 304 deletions
diff --git a/arg_picker/src/arg.rs b/arg_picker/src/arg.rs index 32824ea..c36fba4 100644 --- a/arg_picker/src/arg.rs +++ b/arg_picker/src/arg.rs @@ -20,7 +20,7 @@ use std::marker::PhantomData; /// than by a `--name` or `-n` flag. /// - `false`: The parameter is a named (flag-based) parameter. /// -/// - `_type`: PhantomData to hold the type parameter. +/// - `_type`: [`PhantomData`] to hold the type parameter. #[derive(Default, Clone, Copy)] pub struct PickerArg<'a, Type> where @@ -35,16 +35,16 @@ where /// Whether the parameter is positional (no flag, matched by position). pub positional: bool, - /// PhantomData to hold the type parameter. + /// [`PhantomData`] to hold the type parameter. pub internal_type: PhantomData<Type>, } -impl<'a, Type> From<&'a PickerArg<'a, Type>> for PickerArg<'a, Type> +impl<'a, Type> From<&'a Self> for PickerArg<'a, Type> where Type: Pickable<'a>, { - fn from(value: &'a PickerArg<'a, Type>) -> Self { - PickerArg { + fn from(value: &'a Self) -> Self { + Self { full: value.full, short: value.short, positional: value.positional, @@ -58,7 +58,8 @@ where Type: Pickable<'a>, { /// Creates a new `PickerArg` with the provided parameters. - pub fn new(full: &'a [&'a str], short: Option<char>, positional: bool) -> Self { + #[must_use] + pub const fn new(full: &'a [&'a str], short: Option<char>, positional: bool) -> Self { Self { full, short, @@ -68,12 +69,14 @@ where } /// Returns the full name list (including aliases). - pub fn full(&self) -> &'a [&'a str] { + #[must_use] + pub const fn full(&self) -> &'a [&'a str] { self.full } /// Returns the short name, if any. - pub fn short(&self) -> Option<char> { + #[must_use] + pub const fn short(&self) -> Option<char> { self.short } @@ -81,7 +84,8 @@ where /// /// If `full` is empty or `short` is `None`, the parameter is considered positional /// regardless of the stored value. - pub fn is_positional(&self) -> bool { + #[must_use] + pub const fn is_positional(&self) -> bool { if self.full.is_empty() && self.short.is_none() { true } else { @@ -90,46 +94,51 @@ where } /// Sets the full name list. - pub fn set_full(&mut self, full: &'a [&'a str]) { + pub const fn set_full(&mut self, full: &'a [&'a str]) { self.full = full; } /// Sets the short name. - pub fn set_short(&mut self, short: Option<char>) { + pub const fn set_short(&mut self, short: Option<char>) { self.short = short; } /// Sets whether the parameter is positional. - pub fn set_positional(&mut self, positional: bool) { + pub const fn set_positional(&mut self, positional: bool) { self.positional = positional; } /// Sets the full name list and returns self. - pub fn with_full(mut self, full: &'a [&'a str]) -> Self { + #[must_use] + pub const fn with_full(mut self, full: &'a [&'a str]) -> Self { self.full = full; self } /// Clears the full name list (sets it to an empty slice) and returns self. - pub fn without_full(mut self) -> Self { + #[must_use] + pub const fn without_full(mut self) -> Self { self.full = &[]; self } /// Sets the short name to the given character and returns self. - pub fn with_short(mut self, short: char) -> Self { + #[must_use] + pub const fn with_short(mut self, short: char) -> Self { self.short = Some(short); self } /// Clears the short name (sets it to None) and returns self. - pub fn without_short(mut self) -> Self { + #[must_use] + pub const fn without_short(mut self) -> Self { self.short = None; self } /// Sets whether the parameter is positional and returns self. - pub fn with_positional(mut self, positional: bool) -> Self { + #[must_use] + pub const fn with_positional(mut self, positional: bool) -> Self { self.positional = positional; self } @@ -137,19 +146,19 @@ where /// Converts this `PickerArg` into a `PickerArgInfo` value. /// /// This is a convenience method equivalent to calling `PickerArgInfo::from(self)`. + #[must_use] pub fn into_info(self) -> PickerArgInfo<'a> { let value = self; - let (long, alias) = match value.full.len() { - 0 => (None, None), - _ => { - let long = Some(value.full[0]); - let alias = if value.full.len() > 1 { - Some(value.full[1..].to_vec()) - } else { - None - }; - (long, alias) - } + let (long, alias) = if value.full.is_empty() { + (None, None) + } else { + let long = Some(value.full[0]); + let alias = if value.full.len() > 1 { + Some(value.full[1..].to_vec()) + } else { + None + }; + (long, alias) }; PickerArgInfo { @@ -169,7 +178,7 @@ where Type: Pickable<'a>, { fn from(value: PickerArg<'a, Type>) -> Self { - let mut result = Vec::new(); + let mut result = Self::new(); let info = PickerArgInfo::from(value); let possible_flags = crate::parselib::build_possible_flags(ParserStyle::global_style(), &info); @@ -231,81 +240,81 @@ impl PickerArgAttr { /// Determines if the given `PickerArg` represents a positional parameter. /// /// If the flag is positional (determined by `flag.is_positional()`), returns - /// `PickerArgAttr::Positional`. Otherwise, invokes the `other` closure to - /// produce and return a `PickerArgAttr`. + /// `Self::Positional`. Otherwise, invokes the `other` closure to + /// produce and return a `Self`. /// /// # Parameters /// /// - `flag`: A reference to the [`PickerArg`] to evaluate. /// - `other`: A closure that returns a [`PickerArgAttr`] when the flag is /// **not** positional. - #[inline(always)] - pub fn positional_or_else<'a, T>( - flag: &PickerArg<'a, T>, - other: fn() -> PickerArgAttr, - ) -> PickerArgAttr + #[inline] + pub fn positional_or_else<'a, T>(flag: &PickerArg<'a, T>, other: fn() -> Self) -> Self where T: Pickable<'a>, { if flag.is_positional() { - PickerArgAttr::Positional + Self::Positional } else { other() } } /// Determines if the given `PickerArg` represents a positional parameter and returns - /// `PickerArgAttr::Positional` if so. Otherwise, returns the provided `default` attribute. + /// `Self::Positional` if so. Otherwise, returns the provided `default` attribute. /// /// # Parameters /// /// - `flag`: A reference to the [`PickerArg`] to evaluate. /// - `default`: The [`PickerArgAttr`] to return if the flag is not positional. - #[inline(always)] - pub fn positional_or<'a, T>(flag: &PickerArg<'a, T>, default: PickerArgAttr) -> PickerArgAttr + #[must_use] + #[inline] + pub const fn positional_or<'a, T>(flag: &PickerArg<'a, T>, default: Self) -> Self where T: Pickable<'a>, { if flag.is_positional() { - PickerArgAttr::Positional + Self::Positional } else { default } } /// Determines if the given `PickerArg` represents a positional parameter and returns - /// `PickerArgAttr::Positional` if so. Otherwise, returns `PickerArgAttr::Single`. + /// `Self::Positional` if so. Otherwise, returns `Self::Single`. /// /// # Parameters /// /// - `flag`: A reference to the [`PickerArg`] to evaluate. - #[inline(always)] - pub fn positional_or_single<'a, T>(flag: &PickerArg<'a, T>) -> PickerArgAttr + #[must_use] + #[inline] + pub const fn positional_or_single<'a, T>(flag: &PickerArg<'a, T>) -> Self where T: Pickable<'a>, { if flag.is_positional() { - PickerArgAttr::Positional + Self::Positional } else { - PickerArgAttr::Single + Self::Single } } /// Determines if the given `PickerArg` represents a positional parameter and returns - /// `PickerArgAttr::PositionalMulti` if so. Otherwise, returns `PickerArgAttr::Multi`. + /// `Self::PositionalMulti` if so. Otherwise, returns `Self::Multi`. /// /// # Parameters /// /// - `flag`: A reference to the [`PickerArg`] to evaluate. - #[inline(always)] - pub fn positional_or_multi<'a, T>(flag: &PickerArg<'a, T>) -> PickerArgAttr + #[must_use] + #[inline] + pub const fn positional_or_multi<'a, T>(flag: &PickerArg<'a, T>) -> Self where T: Pickable<'a>, { if flag.is_positional() { - PickerArgAttr::PositionalMulti + Self::PositionalMulti } else { - PickerArgAttr::Multi + Self::Multi } } } diff --git a/arg_picker/src/builtin/pick_flag.rs b/arg_picker/src/builtin/pick_flag.rs index b642a9a..8afc0fc 100644 --- a/arg_picker/src/builtin/pick_flag.rs +++ b/arg_picker/src/builtin/pick_flag.rs @@ -13,9 +13,9 @@ impl<'a> Pickable<'a> for Flag { fn pick(raw_strs: &[&str]) -> PickerArgResult<Self> { if raw_strs.is_empty() { - PickerArgResult::Parsed(Flag::Inactive) + PickerArgResult::Parsed(Self::Inactive) } else { - PickerArgResult::Parsed(Flag::Active) + PickerArgResult::Parsed(Self::Active) } } } diff --git a/arg_picker/src/builtin/pick_ip_attr.rs b/arg_picker/src/builtin/pick_ip_attr.rs index d68fa15..57ac80e 100644 --- a/arg_picker/src/builtin/pick_ip_attr.rs +++ b/arg_picker/src/builtin/pick_ip_attr.rs @@ -4,36 +4,33 @@ use crate::SinglePickable; impl SinglePickable for IpAddr { fn pick_single(str: Option<&str>) -> crate::PickerArgResult<Self> { - match str { - Some(s) => match s.parse::<IpAddr>() { - Ok(addr) => crate::PickerArgResult::Parsed(addr), - Err(_) => crate::PickerArgResult::NotFound, - }, - None => crate::PickerArgResult::NotFound, - } + str.map_or(crate::PickerArgResult::NotFound, |s| { + s.parse::<Self>() + .map_or(crate::PickerArgResult::NotFound, |addr| { + crate::PickerArgResult::Parsed(addr) + }) + }) } } impl SinglePickable for Ipv4Addr { fn pick_single(str: Option<&str>) -> crate::PickerArgResult<Self> { - match str { - Some(s) => match s.parse::<Ipv4Addr>() { - Ok(addr) => crate::PickerArgResult::Parsed(addr), - Err(_) => crate::PickerArgResult::NotFound, - }, - None => crate::PickerArgResult::NotFound, - } + str.map_or(crate::PickerArgResult::NotFound, |s| { + s.parse::<Self>() + .map_or(crate::PickerArgResult::NotFound, |addr| { + crate::PickerArgResult::Parsed(addr) + }) + }) } } impl SinglePickable for Ipv6Addr { fn pick_single(str: Option<&str>) -> crate::PickerArgResult<Self> { - match str { - Some(s) => match s.parse::<Ipv6Addr>() { - Ok(addr) => crate::PickerArgResult::Parsed(addr), - Err(_) => crate::PickerArgResult::NotFound, - }, - None => crate::PickerArgResult::NotFound, - } + str.map_or(crate::PickerArgResult::NotFound, |s| { + s.parse::<Self>() + .map_or(crate::PickerArgResult::NotFound, |addr| { + crate::PickerArgResult::Parsed(addr) + }) + }) } } diff --git a/arg_picker/src/builtin/pick_numbers.rs b/arg_picker/src/builtin/pick_numbers.rs index a5ab0a9..6cbd4fc 100644 --- a/arg_picker/src/builtin/pick_numbers.rs +++ b/arg_picker/src/builtin/pick_numbers.rs @@ -21,10 +21,7 @@ fn is_int_like(raw: &str) -> bool { if bytes.is_empty() { return false; } - let mut i = 0; - if bytes[0] == b'-' || bytes[0] == b'+' { - i = 1; - } + let i = usize::from(bytes[0] == b'-' || bytes[0] == b'+'); if i >= bytes.len() { return false; } @@ -69,12 +66,12 @@ impl_boundary_check_int! { // Integer-like strings trigger a boundary. impl BoundaryCheck for f32 { fn check_boundary(raw: &str) -> bool { - !is_float_like(raw) || raw.parse::<f32>().is_err() + !is_float_like(raw) || raw.parse::<Self>().is_err() } } impl BoundaryCheck for f64 { fn check_boundary(raw: &str) -> bool { - !is_float_like(raw) || raw.parse::<f64>().is_err() + !is_float_like(raw) || raw.parse::<Self>().is_err() } } diff --git a/arg_picker/src/builtin/pick_pathbuf.rs b/arg_picker/src/builtin/pick_pathbuf.rs index 3bd4410..2b48e3d 100644 --- a/arg_picker/src/builtin/pick_pathbuf.rs +++ b/arg_picker/src/builtin/pick_pathbuf.rs @@ -7,12 +7,8 @@ use crate::{ impl SinglePickable for PathBuf { fn pick_single(str: Option<&str>) -> crate::PickerArgResult<Self> { - match str { - Some(str) => match just_fmt::fmt_path_str(str) { - Ok(formated) => Parsed(PathBuf::from(formated)), - Err(_) => NotFound, - }, - None => NotFound, - } + str.map_or(NotFound, |str| { + just_fmt::fmt_path_str(str).map_or(NotFound, |formated| Parsed(Self::from(formated))) + }) } } diff --git a/arg_picker/src/builtin/pick_paths.rs b/arg_picker/src/builtin/pick_paths.rs index 8e6c0fd..954464b 100644 --- a/arg_picker/src/builtin/pick_paths.rs +++ b/arg_picker/src/builtin/pick_paths.rs @@ -17,7 +17,7 @@ impl SinglePickable for FilePath { match <PathBuf as SinglePickable>::pick_single(str) { Parsed(path) => { if path.exists() && path.is_file() { - Parsed(FilePath::from(path)) + Parsed(Self::from(path)) } else { NotFound } @@ -33,7 +33,7 @@ impl SinglePickable for NoFilePath { match <PathBuf as SinglePickable>::pick_single(str) { Parsed(path) => { if !path.exists() || !path.is_file() { - Parsed(NoFilePath::from(path)) + Parsed(Self::from(path)) } else { NotFound } @@ -49,7 +49,7 @@ impl SinglePickable for DirPath { match <PathBuf as SinglePickable>::pick_single(str) { Parsed(path) => { if path.exists() && path.is_dir() { - Parsed(DirPath::from(path)) + Parsed(Self::from(path)) } else { NotFound } @@ -65,7 +65,7 @@ impl SinglePickable for NoDirPath { match <PathBuf as SinglePickable>::pick_single(str) { Parsed(path) => { if !path.exists() || !path.is_dir() { - Parsed(NoDirPath::from(path)) + Parsed(Self::from(path)) } else { NotFound } @@ -81,7 +81,7 @@ impl SinglePickable for SymlinkPath { match <PathBuf as SinglePickable>::pick_single(str) { Parsed(path) => { if path.exists() && path.is_symlink() { - Parsed(SymlinkPath::from(path)) + Parsed(Self::from(path)) } else { NotFound } @@ -97,7 +97,7 @@ impl SinglePickable for NoSymlinkPath { match <PathBuf as SinglePickable>::pick_single(str) { Parsed(path) => { if !path.exists() || !path.is_symlink() { - Parsed(NoSymlinkPath::from(path)) + Parsed(Self::from(path)) } else { NotFound } @@ -112,10 +112,10 @@ impl SinglePickable for NoPath { fn pick_single(str: Option<&str>) -> PickerArgResult<Self> { match <PathBuf as SinglePickable>::pick_single(str) { Parsed(path) => { - if !path.exists() { - Parsed(NoPath::from(path)) - } else { + if path.exists() { NotFound + } else { + Parsed(Self::from(path)) } } Unparsed => Unparsed, @@ -132,7 +132,7 @@ impl SinglePickable for RecursiveFiles { return NotFound; } if path.is_file() || path.is_symlink() { - return Parsed(RecursiveFiles::from(vec![path])); + return Parsed(Self::from(vec![path])); } let mut entries = Vec::new(); if let Ok(dir_entries) = fs::read_dir(&path) { @@ -145,7 +145,7 @@ impl SinglePickable for RecursiveFiles { } } } - Parsed(RecursiveFiles::from(entries)) + Parsed(Self::from(entries)) } Unparsed => Unparsed, NotFound => NotFound, diff --git a/arg_picker/src/builtin/pick_picker_args.rs b/arg_picker/src/builtin/pick_picker_args.rs index 419cbc8..618960f 100644 --- a/arg_picker/src/builtin/pick_picker_args.rs +++ b/arg_picker/src/builtin/pick_picker_args.rs @@ -15,7 +15,7 @@ impl<'a> Pickable<'a> for PickerArgs<'a> { } fn pick(raw_strs: &[&str]) -> PickerArgResult<Self> { - let remains: Vec<String> = raw_strs.iter().map(|s| s.to_string()).collect(); + let remains: Vec<String> = raw_strs.iter().map(ToString::to_string).collect(); Parsed(PickerArgs::Owned(remains)) } } diff --git a/arg_picker/src/builtin/pick_socket_attr.rs b/arg_picker/src/builtin/pick_socket_attr.rs index 0c0dd71..ba9a410 100644 --- a/arg_picker/src/builtin/pick_socket_attr.rs +++ b/arg_picker/src/builtin/pick_socket_attr.rs @@ -4,36 +4,33 @@ use crate::SinglePickable; impl SinglePickable for SocketAddr { fn pick_single(str: Option<&str>) -> crate::PickerArgResult<Self> { - match str { - Some(s) => match s.parse::<SocketAddr>() { - Ok(addr) => crate::PickerArgResult::Parsed(addr), - Err(_) => crate::PickerArgResult::NotFound, - }, - None => crate::PickerArgResult::NotFound, - } + str.map_or(crate::PickerArgResult::NotFound, |s| { + s.parse::<Self>() + .map_or(crate::PickerArgResult::NotFound, |addr| { + crate::PickerArgResult::Parsed(addr) + }) + }) } } impl SinglePickable for SocketAddrV4 { fn pick_single(str: Option<&str>) -> crate::PickerArgResult<Self> { - match str { - Some(s) => match s.parse::<SocketAddrV4>() { - Ok(addr) => crate::PickerArgResult::Parsed(addr), - Err(_) => crate::PickerArgResult::NotFound, - }, - None => crate::PickerArgResult::NotFound, - } + str.map_or(crate::PickerArgResult::NotFound, |s| { + s.parse::<Self>() + .map_or(crate::PickerArgResult::NotFound, |addr| { + crate::PickerArgResult::Parsed(addr) + }) + }) } } impl SinglePickable for SocketAddrV6 { fn pick_single(str: Option<&str>) -> crate::PickerArgResult<Self> { - match str { - Some(s) => match s.parse::<SocketAddrV6>() { - Ok(addr) => crate::PickerArgResult::Parsed(addr), - Err(_) => crate::PickerArgResult::NotFound, - }, - None => crate::PickerArgResult::NotFound, - } + str.map_or(crate::PickerArgResult::NotFound, |s| { + s.parse::<Self>() + .map_or(crate::PickerArgResult::NotFound, |addr| { + crate::PickerArgResult::Parsed(addr) + }) + }) } } diff --git a/arg_picker/src/builtin/pick_string.rs b/arg_picker/src/builtin/pick_string.rs index c96f667..c7bdd4a 100644 --- a/arg_picker/src/builtin/pick_string.rs +++ b/arg_picker/src/builtin/pick_string.rs @@ -3,9 +3,6 @@ use crate::{SinglePickable, pickable_needed::*}; impl SinglePickable for String { fn pick_single(str: Option<&str>) -> PickerArgResult<Self> { - match str { - Some(str) => PickerArgResult::Parsed(str.to_string()), - None => NotFound, - } + str.map_or(NotFound, |str| PickerArgResult::Parsed(str.to_string())) } } diff --git a/arg_picker/src/infos.rs b/arg_picker/src/infos.rs index c17b6a2..08b2be7 100644 --- a/arg_picker/src/infos.rs +++ b/arg_picker/src/infos.rs @@ -3,9 +3,9 @@ use crate::{Pickable, PickerArg, parselib::ParserStyle}; /// Represents the result of parsing or looking up a value. /// /// This enum is generic over the type being parsed. It models three possible outcomes: -/// - [`Unparsed`](PickerArgResult::Unparsed): The value has not yet been parsed (default). -/// - [`Parsed`](PickerArgResult::Parsed): The value was successfully parsed into `Type`. -/// - [`NotFound`](PickerArgResult::NotFound): The requested value could not be found. +/// - [`Unparsed`](Self::Unparsed): The value has not yet been parsed (default). +/// - [`Parsed`](Self::Parsed): The value was successfully parsed into `Type`. +/// - [`NotFound`](Self::NotFound): The requested value could not be found. #[derive(Default)] pub enum PickerArgResult<Type> { /// The value has not yet been parsed (default). @@ -22,31 +22,25 @@ pub enum PickerArgResult<Type> { impl<Type, E> From<Result<Type, E>> for PickerArgResult<Type> { /// Converts a `Result<Type, E>` into a `PickerArgResult<Type>`. /// - /// - `Ok(value)` maps to [`Parsed(value)`](PickerArgResult::Parsed). - /// - `Err(_)` maps to [`NotFound`](PickerArgResult::NotFound). + /// - `Ok(value)` maps to [`Parsed(value)`](Self::Parsed). + /// - `Err(_)` maps to [`NotFound`](Self::NotFound). fn from(result: Result<Type, E>) -> Self { - match result { - Ok(value) => PickerArgResult::Parsed(value), - Err(_) => PickerArgResult::NotFound, - } + result.map_or_else(|_| Self::NotFound, |value| Self::Parsed(value)) } } impl<Type> From<Option<Type>> for PickerArgResult<Type> { /// Converts an `Option<Type>` into a `PickerArgResult<Type>`. /// - /// - `Some(value)` maps to [`Parsed(value)`](PickerArgResult::Parsed). - /// - `None` maps to [`NotFound`](PickerArgResult::NotFound). + /// - `Some(value)` maps to [`Parsed(value)`](Self::Parsed). + /// - `None` maps to [`NotFound`](Self::NotFound). fn from(option: Option<Type>) -> Self { - match option { - Some(value) => PickerArgResult::Parsed(value), - None => PickerArgResult::NotFound, - } + option.map_or_else(|| Self::NotFound, |value| Self::Parsed(value)) } } impl<Type> PickerArgResult<Type> { - /// Returns `true` if the result is [`Parsed`](PickerArgResult::Parsed). + /// Returns `true` if the result is [`Parsed`](Self::Parsed). /// /// # Examples /// @@ -59,11 +53,11 @@ impl<Type> PickerArgResult<Type> { /// let result: PickerArgResult<i32> = PickerArgResult::NotFound; /// assert!(!result.is_parsed()); /// ``` - pub fn is_parsed(&self) -> bool { - matches!(self, PickerArgResult::Parsed(_)) + pub const fn is_parsed(&self) -> bool { + matches!(self, Self::Parsed(_)) } - /// Returns `true` if the result is [`Parsed`](PickerArgResult::Parsed) or [`NotFound`](PickerArgResult::NotFound). + /// Returns `true` if the result is [`Parsed`](Self::Parsed) or [`NotFound`](Self::NotFound). /// i.e., the value exists (was either found or not yet parsed). /// Typically indicates the value was "found" in some sense. /// @@ -78,11 +72,11 @@ impl<Type> PickerArgResult<Type> { /// let result: PickerArgResult<i32> = PickerArgResult::NotFound; /// assert!(result.is_found()); /// ``` - pub fn is_found(&self) -> bool { - matches!(self, PickerArgResult::Parsed(_) | PickerArgResult::NotFound) + pub const fn is_found(&self) -> bool { + matches!(self, Self::Parsed(_) | Self::NotFound) } - /// Returns `true` if the result is [`Unparsed`](PickerArgResult::Unparsed) or [`NotFound`](PickerArgResult::NotFound). + /// Returns `true` if the result is [`Unparsed`](Self::Unparsed) or [`NotFound`](Self::NotFound). /// /// # Examples /// @@ -95,11 +89,11 @@ impl<Type> PickerArgResult<Type> { /// let result: PickerArgResult<i32> = PickerArgResult::Parsed(10); /// assert!(!result.is_err()); /// ``` - pub fn is_err(&self) -> bool { - !matches!(self, PickerArgResult::Parsed(_)) + pub const fn is_err(&self) -> bool { + !matches!(self, Self::Parsed(_)) } - /// Returns `Some(&Type)` if [`Parsed`](PickerArgResult::Parsed), otherwise `None`. + /// Returns `Some(&Type)` if [`Parsed`](Self::Parsed), otherwise `None`. /// /// # Examples /// @@ -112,18 +106,18 @@ impl<Type> PickerArgResult<Type> { /// let result: PickerArgResult<i32> = PickerArgResult::NotFound; /// assert_eq!(result.parsed(), None); /// ``` - pub fn parsed(&self) -> Option<&Type> { - if let PickerArgResult::Parsed(value) = self { + pub const fn parsed(&self) -> Option<&Type> { + if let Self::Parsed(value) = self { Some(value) } else { None } } - /// Returns the contained [`Parsed`](PickerArgResult::Parsed) value or panics with a given message. + /// Returns the contained [`Parsed`](Self::Parsed) value or panics with a given message. /// /// # Panics - /// Panics if the value is not [`Parsed`](PickerArgResult::Parsed), with a message including the provided `msg`. + /// Panics if the value is not [`Parsed`](Self::Parsed), with a message including the provided `msg`. /// /// # Examples /// @@ -135,15 +129,15 @@ impl<Type> PickerArgResult<Type> { /// ``` pub fn expect(self, msg: &str) -> Type { match self { - PickerArgResult::Parsed(value) => value, + Self::Parsed(value) => value, _ => panic!("{}", msg), } } - /// Returns the contained [`Parsed`](PickerArgResult::Parsed) value or panics. + /// Returns the contained [`Parsed`](Self::Parsed) value or panics. /// /// # Panics - /// Panics if the value is not [`Parsed`](PickerArgResult::Parsed). + /// Panics if the value is not [`Parsed`](Self::Parsed). /// /// # Examples /// @@ -162,17 +156,17 @@ impl<Type> PickerArgResult<Type> { /// ``` pub fn unwrap(self) -> Type { match self { - PickerArgResult::Parsed(value) => value, - PickerArgResult::Unparsed => { + Self::Parsed(value) => value, + Self::Unparsed => { panic!("called `PickerArgResult::unwrap()` on an `Unparsed` value") } - PickerArgResult::NotFound => { + Self::NotFound => { panic!("called `PickerArgResult::unwrap()` on a `NotFound` value") } } } - /// Returns the contained [`Parsed`](PickerArgResult::Parsed) value or a provided `default`. + /// Returns the contained [`Parsed`](Self::Parsed) value or a provided `default`. /// /// # Examples /// @@ -187,12 +181,12 @@ impl<Type> PickerArgResult<Type> { /// ``` pub fn unwrap_or(self, default: Type) -> Type { match self { - PickerArgResult::Parsed(value) => value, + Self::Parsed(value) => value, _ => default, } } - /// Returns the contained [`Parsed`](PickerArgResult::Parsed) value or computes it from a closure. + /// Returns the contained [`Parsed`](Self::Parsed) value or computes it from a closure. /// /// # Examples /// @@ -207,12 +201,12 @@ impl<Type> PickerArgResult<Type> { /// ``` pub fn unwrap_or_else<F: FnOnce() -> Type>(self, f: F) -> Type { match self { - PickerArgResult::Parsed(value) => value, + Self::Parsed(value) => value, _ => f(), } } - /// Returns the contained [`Parsed`](PickerArgResult::Parsed) value or the default value of `Type`. + /// Returns the contained [`Parsed`](Self::Parsed) value or the default value of `Type`. /// /// # Examples /// @@ -230,14 +224,14 @@ impl<Type> PickerArgResult<Type> { Type: Default, { match self { - PickerArgResult::Parsed(value) => value, + Self::Parsed(value) => value, _ => Type::default(), } } /// Converts `PickerArgResult<Type>` into `Option<Type>`. /// - /// Returns `Some(Type)` if [`Parsed`](PickerArgResult::Parsed), otherwise `None`. + /// Returns `Some(Type)` if [`Parsed`](Self::Parsed), otherwise `None`. /// /// # Examples /// @@ -255,12 +249,14 @@ impl<Type> PickerArgResult<Type> { /// ``` pub fn to_option(self) -> Option<Type> { match self { - PickerArgResult::Parsed(value) => Some(value), + Self::Parsed(value) => Some(value), _ => None, } } } +// In PickerArgInfo, positional, optional, multi, and is_flag may coexist. +#[allow(clippy::struct_excessive_bools)] /// Represents metadata about a command-line argument or flag. /// /// This struct stores all relevant information about a tag/argument that can be used @@ -294,17 +290,16 @@ where impl<'a, T: Pickable<'a>> From<&'a PickerArg<'a, T>> for PickerArgInfo<'a> { fn from(value: &'a PickerArg<'a, T>) -> Self { - let (long, alias) = match value.full.len() { - 0 => (None, None), - _ => { - let long = Some(value.full[0]); - let alias = if value.full.len() > 1 { - Some(value.full[1..].to_vec()) - } else { - None - }; - (long, alias) - } + let (long, alias) = if value.full.is_empty() { + (None, None) + } else { + let long = Some(value.full[0]); + let alias = if value.full.len() > 1 { + Some(value.full[1..].to_vec()) + } else { + None + }; + (long, alias) }; Self { @@ -321,7 +316,8 @@ impl<'a, T: Pickable<'a>> From<&'a PickerArg<'a, T>> for PickerArgInfo<'a> { impl<'a> PickerArgInfo<'a> { /// Create a new `PickerTag` with default values. - pub fn new() -> Self { + #[must_use] + pub const fn new() -> Self { Self { short: None, long: None, @@ -334,55 +330,62 @@ impl<'a> PickerArgInfo<'a> { } /// Set the short flag (e.g., `'n'` for `-n`). - pub fn with_short(mut self, short: char) -> Self { + #[must_use] + pub const fn with_short(mut self, short: char) -> Self { self.short = Some(short); self } /// Set the long flag (e.g., `"name"` for `--name`). - pub fn with_long(mut self, long: &'a str) -> Self { + #[must_use] + pub const fn with_long(mut self, long: &'a str) -> Self { self.long = Some(long); self } /// Set aliases for the tag. + #[must_use] pub fn with_alias(mut self, alias: Vec<&'a str>) -> Self { self.alias = Some(alias); self } /// Mark the tag as positional. - pub fn with_positional(mut self, positional: bool) -> Self { + #[must_use] + pub const fn with_positional(mut self, positional: bool) -> Self { self.positional = positional; self } /// Mark the tag as optional. - pub fn with_optional(mut self, optional: bool) -> Self { + #[must_use] + pub const fn with_optional(mut self, optional: bool) -> Self { self.optional = optional; self } /// Mark the tag as multi-value. - pub fn with_multi(mut self, multi: bool) -> Self { + #[must_use] + pub const fn with_multi(mut self, multi: bool) -> Self { self.multi = multi; self } /// Mark the tag as a flag that participates in parsing after `--`. - pub fn with_is_flag(mut self, is_flag: bool) -> Self { + #[must_use] + pub const fn with_is_flag(mut self, is_flag: bool) -> Self { self.is_flag = is_flag; self } /// Set the short flag (e.g., `'n'` for `-n`). - pub fn set_short(&mut self, short: char) -> &mut Self { + pub const fn set_short(&mut self, short: char) -> &mut Self { self.short = Some(short); self } /// Set the long flag (e.g., `"name"` for `--name`). - pub fn set_long(&mut self, long: &'a str) -> &mut Self { + pub const fn set_long(&mut self, long: &'a str) -> &mut Self { self.long = Some(long); self } @@ -394,25 +397,25 @@ impl<'a> PickerArgInfo<'a> { } /// Set whether this tag is positional. - pub fn set_positional(&mut self, positional: bool) -> &mut Self { + pub const fn set_positional(&mut self, positional: bool) -> &mut Self { self.positional = positional; self } /// Set whether this tag is optional. - pub fn set_optional(&mut self, optional: bool) -> &mut Self { + pub const fn set_optional(&mut self, optional: bool) -> &mut Self { self.optional = optional; self } /// Set whether this tag accepts multiple values. - pub fn set_multi(&mut self, multi: bool) -> &mut Self { + pub const fn set_multi(&mut self, multi: bool) -> &mut Self { self.multi = multi; self } /// Set whether this tag participates in parsing after a `--` separator. - pub fn set_is_flag(&mut self, is_flag: bool) -> &mut Self { + pub const fn set_is_flag(&mut self, is_flag: bool) -> &mut Self { self.is_flag = is_flag; self } @@ -437,6 +440,7 @@ impl<'a> PickerArgInfo<'a> { /// let info = PickerArgInfo::new(); /// assert_eq!(info.short_flag(), None); /// ``` + #[must_use] pub fn short_flag(&self) -> Option<String> { let short = self.short?; Some(ParserStyle::global_style().flag_string(short)) @@ -462,13 +466,14 @@ impl<'a> PickerArgInfo<'a> { /// let info = PickerArgInfo::new(); /// assert_eq!(info.long_flag(), None); /// ``` + #[must_use] pub fn long_flag(&self) -> Option<String> { let long = self.long?; Some(ParserStyle::global_style().flag_string(long)) } } -impl<'a> Default for PickerArgInfo<'a> { +impl Default for PickerArgInfo<'_> { fn default() -> Self { Self::new() } diff --git a/arg_picker/src/lib.rs b/arg_picker/src/lib.rs index d292826..06ae959 100644 --- a/arg_picker/src/lib.rs +++ b/arg_picker/src/lib.rs @@ -1,5 +1,9 @@ #![doc = include_str!("../README.md")] #![deny(missing_docs)] +#![deny(clippy::pedantic)] +#![deny(clippy::nursery)] +// Some code requires wildcard imports to reduce boilerplate code +#![allow(clippy::wildcard_imports)] mod builtin; diff --git a/arg_picker/src/parselib.rs b/arg_picker/src/parselib.rs index 0fcd583..edb03bb 100644 --- a/arg_picker/src/parselib.rs +++ b/arg_picker/src/parselib.rs @@ -58,14 +58,16 @@ pub trait Matcher { /// Convenience method that builds masked arguments from `PickerArgs` and a mask, /// then calls `on_match_one`. - fn match_one<'a>(ctx: MatcherContext<'a>) -> Option<usize> { + #[must_use] + fn match_one(ctx: MatcherContext<'_>) -> Option<usize> { let masked_args = build_masked_args(ctx.args, ctx.mask); Self::on_match_one(masked_args.as_slice(), ctx.style, ctx.arg_info) } /// Convenience method that builds masked arguments from `PickerArgs` and a mask, /// then calls `on_match_all`. - fn match_all<'a>(ctx: MatcherContext<'a>) -> Vec<usize> { + #[must_use] + fn match_all(ctx: MatcherContext<'_>) -> Vec<usize> { let masked_args = build_masked_args(ctx.args, ctx.mask); Self::on_match_all(masked_args.as_slice(), ctx.style, ctx.arg_info) } @@ -90,7 +92,7 @@ pub struct MatcherContext<'a> { /// Metadata about the command-line argument/flag being processed. /// /// Contains information such as short form (`-n`), long form (`--name`), - /// aliases, and parsing flags (positional, optional, multi, is_flag). + /// aliases, and parsing flags (positional, optional, multi, `is_flag`). /// Used by matchers to make decisions based on argument characteristics. pub arg_info: &'a PickerArgInfo<'a>, } @@ -126,7 +128,8 @@ impl<'a> From<crate::TagPhaseContext<'a>> for MatcherContext<'a> { /// /// * `mask` - A byte slice where non-zero values indicate claimed arguments. /// * `idx` - The index to check in the mask. -#[inline(always)] +#[inline] +#[must_use] pub fn is_masked(mask: &[u8], idx: usize) -> bool { idx < mask.len() && mask[idx] != 0 } @@ -141,7 +144,8 @@ pub fn is_masked(mask: &[u8], idx: usize) -> bool { /// /// * `args` - The full set of parsed arguments. /// * `mask` - A byte slice where `0` means available and non-zero means already claimed. -#[inline(always)] +#[inline] +#[must_use] pub fn build_masked_args<'a>(args: &'a PickerArgs, mask: &'a [u8]) -> Vec<MaskedArg<'a>> { let mut cidx = 0; args.iter() @@ -150,13 +154,13 @@ pub fn build_masked_args<'a>(args: &'a PickerArgs, mask: &'a [u8]) -> Vec<Masked cidx += 1; // Include args where mask is 0 (available/not yet claimed). // mask[i] = 0 means available; mask[i] != 0 means already claimed. - if !is_masked(mask, idx) { + if is_masked(mask, idx) { + None + } else { Some(MaskedArg { raw: r, raw_idx: idx, }) - } else { - None } }) .collect() diff --git a/arg_picker/src/parselib/arg_matcher.rs b/arg_picker/src/parselib/arg_matcher.rs index 38bb9cc..d26f6fb 100644 --- a/arg_picker/src/parselib/arg_matcher.rs +++ b/arg_picker/src/parselib/arg_matcher.rs @@ -29,7 +29,7 @@ pub struct ArgMatcher; impl ArgMatcher { /// Check whether `raw` matches `flag_str`, optionally with an inline value /// separated by the style's value separator (`=` for Unix, `:` for PowerShell). - #[inline(always)] + #[inline] fn matches(raw: &str, flag_str: &str, case_sensitive: bool, sep: char) -> bool { let eq_match = |r: &str, f: &str| r.len() > f.len() && r.as_bytes().get(f.len()) == Some(&(sep as u8)); @@ -46,7 +46,7 @@ impl ArgMatcher { /// Check whether the argument contains its value inline via the style's /// value separator (eq mode), so no extra mask slot is needed. - #[inline(always)] + #[inline] fn is_inline_value(raw: &str, flag_str: &str, sep: char) -> bool { raw.len() > flag_str.len() && raw.as_bytes().get(flag_str.len()) == Some(&(sep as u8)) } diff --git a/arg_picker/src/parselib/flag_matcher.rs b/arg_picker/src/parselib/flag_matcher.rs index e93d35a..2484cc9 100644 --- a/arg_picker/src/parselib/flag_matcher.rs +++ b/arg_picker/src/parselib/flag_matcher.rs @@ -18,7 +18,7 @@ impl Matcher for FlagMatcher { arg_info: &PickerArgInfo, ) -> Option<usize> { let possible_flags = build_possible_flags(style, arg_info); - let flag_refs: Vec<&str> = possible_flags.iter().map(|s| s.as_str()).collect(); + let flag_refs: Vec<&str> = possible_flags.iter().map(String::as_str).collect(); let end_of_options = seek_end_of_options(args, style); let result = get_seeked_first(multi_seek_eq(args, &flag_refs, style.case_sensitive)); @@ -45,7 +45,7 @@ fn single_pass_match_all( style: &ParserStyle, possible_flags: &[String], ) -> Vec<usize> { - let flag_refs: Vec<&str> = possible_flags.iter().map(|s| s.as_str()).collect(); + let flag_refs: Vec<&str> = possible_flags.iter().map(String::as_str).collect(); let eoo = style.end_of_options; let case_sensitive = style.case_sensitive; @@ -67,12 +67,12 @@ fn single_pass_match_all( // Only match flags before the end-of-options marker. if end_pos.is_none() { - let matched = if case_sensitive { + let is_matched = if case_sensitive { flag_refs.contains(&arg.raw) } else { flag_refs.iter().any(|s| arg.raw.eq_ignore_ascii_case(s)) }; - if matched { + if is_matched { matches.push(arg.raw_idx); } } diff --git a/arg_picker/src/parselib/multi_arg_matcher.rs b/arg_picker/src/parselib/multi_arg_matcher.rs index 748b1be..6791121 100644 --- a/arg_picker/src/parselib/multi_arg_matcher.rs +++ b/arg_picker/src/parselib/multi_arg_matcher.rs @@ -115,7 +115,7 @@ impl Matcher for MultiArgMatcher { } impl MultiArgMatcher { - #[inline(always)] + #[inline] fn flag_match(raw: &str, flag_str: &str, case_sensitive: bool, sep: char) -> bool { let eq = |r: &str, f: &str| r.len() > f.len() && r.as_bytes().get(f.len()) == Some(&(sep as u8)); @@ -130,7 +130,7 @@ impl MultiArgMatcher { } } - #[inline(always)] + #[inline] fn is_eq_match(raw: &str, flags: &[String], case_sensitive: bool, sep: char) -> bool { flags.iter().any(|f| { Self::flag_match(raw, f, case_sensitive, sep) diff --git a/arg_picker/src/parselib/pos_matcher.rs b/arg_picker/src/parselib/pos_matcher.rs index 279e01e..96aceb3 100644 --- a/arg_picker/src/parselib/pos_matcher.rs +++ b/arg_picker/src/parselib/pos_matcher.rs @@ -14,7 +14,7 @@ pub struct PositionalMatcher; impl PositionalMatcher { /// Check whether `raw` looks like a named flag (starts with a prefix). - #[inline(always)] + #[inline] fn is_flag_like(raw: &str, style: &ParserStyle) -> bool { raw.starts_with(style.long_prefix) || raw.starts_with(style.short_prefix) } diff --git a/arg_picker/src/parselib/single_matcher.rs b/arg_picker/src/parselib/single_matcher.rs index 25c4741..d7cf6a4 100644 --- a/arg_picker/src/parselib/single_matcher.rs +++ b/arg_picker/src/parselib/single_matcher.rs @@ -18,12 +18,11 @@ impl SingleMatcher { /// For named args, only complete pairs (flag + value) are kept. /// Flag occurrences without a following value or inline separator /// are dropped so they remain available for other matchers. - #[inline(always)] + #[inline] + #[must_use] pub fn tag(ctx: TagPhaseContext) -> Vec<usize> { if ctx.arg_info.positional { - PositionalMatcher::match_one(ctx.into()) - .map(|i| vec![i]) - .unwrap_or_default() + PositionalMatcher::match_one(ctx.into()).map_or_else(Vec::new, |i| vec![i]) } else { let args = ctx.args; let positions = ArgMatcher::match_all(ctx.into()); diff --git a/arg_picker/src/parselib/style.rs b/arg_picker/src/parselib/style.rs index 36ba8f0..81dfe72 100644 --- a/arg_picker/src/parselib/style.rs +++ b/arg_picker/src/parselib/style.rs @@ -56,7 +56,7 @@ impl<'a> ParserStyle<'a> { /// /// A `String` with the prefix and the flag name combined. #[must_use] - #[inline(always)] + #[inline] pub fn flag_string<F>(&self, flag: F) -> String where F: Into<FlagStr<'a>>, @@ -88,7 +88,7 @@ pub enum FlagStr<'a> { Long(&'a str), } -impl<'a> From<char> for FlagStr<'a> { +impl From<char> for FlagStr<'_> { /// Converts a single character into a `FlagStr::Short`. fn from(c: char) -> Self { FlagStr::Short(c) @@ -129,36 +129,36 @@ impl<'a> From<&'a String> for FlagStr<'a> { #[repr(u8)] #[derive(Default, Clone, Copy, PartialEq, Eq)] pub enum ParserStyleNamingCase { - /// snake_case format: words are separated by underscores, all lowercase. + /// `snake_case` format: words are separated by underscores, all lowercase. /// /// Example: `brew_coffee` #[default] Snake, - /// camelCase format: first word is lowercase, subsequent words are capitalized. + /// `camelCase` format: first word is lowercase, subsequent words are capitalized. /// /// Example: `brewCoffee` Camel, - /// PascalCase format: every word starts with an uppercase letter. + /// `PascalCase` format: every word starts with an uppercase letter. /// /// Example: `BrewCoffee` Pascal, - /// kebab-case format: words are separated by hyphens, all lowercase. + /// `kebab-case` format: words are separated by hyphens, all lowercase. /// /// Example: `brew-coffee` Kebab, - /// dot.case format: words are separated by dots, all lowercase. + /// `dot.case` format: words are separated by dots, all lowercase. /// /// Example: `brew.coffee` Dot, - /// Title Case format: words are separated by spaces, each word capitalized. + /// `Title Case` format: words are separated by spaces, each word capitalized. /// /// Example: `Brew Coffee` Title, - /// lower case format: words are separated by spaces, all lowercase. + /// `lower case` format: words are separated by spaces, all lowercase. /// /// Example: `brew coffee` Lower, - /// UPPER CASE format: words are separated by spaces, all uppercase. + /// `UPPER CASE` format: words are separated by spaces, all uppercase. /// /// Example: `BREW COFFEE` Upper, @@ -187,14 +187,14 @@ impl ParserStyleNamingCase { S: Into<String> + From<String>, { match self { - ParserStyleNamingCase::Camel => just_fmt::camel_case!(s.into()).into(), - ParserStyleNamingCase::Pascal => just_fmt::pascal_case!(s.into()).into(), - ParserStyleNamingCase::Kebab => just_fmt::kebab_case!(s.into()).into(), - ParserStyleNamingCase::Snake => just_fmt::snake_case!(s.into()).into(), - ParserStyleNamingCase::Dot => just_fmt::dot_case!(s.into()).into(), - ParserStyleNamingCase::Title => just_fmt::title_case!(s.into()).into(), - ParserStyleNamingCase::Lower => just_fmt::lower_case!(s.into()).into(), - ParserStyleNamingCase::Upper => just_fmt::upper_case!(s.into()).into(), + Self::Camel => just_fmt::camel_case!(s.into()).into(), + Self::Pascal => just_fmt::pascal_case!(s.into()).into(), + Self::Kebab => just_fmt::kebab_case!(s.into()).into(), + Self::Snake => just_fmt::snake_case!(s.into()).into(), + Self::Dot => just_fmt::dot_case!(s.into()).into(), + Self::Title => just_fmt::title_case!(s.into()).into(), + Self::Lower => just_fmt::lower_case!(s.into()).into(), + Self::Upper => just_fmt::upper_case!(s.into()).into(), } } } @@ -238,7 +238,7 @@ pub const WINDOWS_STYLE: ParserStyle = ParserStyle { static GLOBAL_STYLE: OnceLock<ParserStyle<'static>> = OnceLock::new(); static GLOBAL_STYLE_SET: AtomicBool = AtomicBool::new(false); -impl<'a> ParserStyle<'a> { +impl ParserStyle<'_> { /// Sets the global parser style. /// /// This function can only be called once. Subsequent calls will have no effect. diff --git a/arg_picker/src/parselib/utils.rs b/arg_picker/src/parselib/utils.rs index 47c5b55..dc4e091 100644 --- a/arg_picker/src/parselib/utils.rs +++ b/arg_picker/src/parselib/utils.rs @@ -8,7 +8,7 @@ use crate::{ /// This function generates formatted flag strings (e.g., `-h`, `--help`) from the short flag, /// long flag, and any aliases defined in the argument info. The long flag and alias names /// are converted according to the style's naming case convention before being formatted. -#[inline(always)] +#[must_use] pub fn build_possible_flags(style: &ParserStyle, arg_info: &PickerArgInfo) -> Vec<String> { let mut possible_flags = vec![]; @@ -46,11 +46,7 @@ pub fn seek_single<'a>(raw_strs: &'a [&'a str]) -> Option<&'a str> { 1 => { let s = raw_strs[0]; let sep = ParserStyle::global_style().value_separator; - if let Some(pos) = s.rfind(sep) { - Some(&s[pos + 1..]) - } else { - Some(s) - } + s.rfind(sep).map_or(Some(s), |pos| Some(&s[pos + 1..])) } _ => Some(raw_strs[1]), } @@ -79,7 +75,7 @@ pub fn seek_end_of_options(args: &[MaskedArg], style: &ParserStyle) -> Option<us /// /// Returns the indices of matching arguments. #[must_use] -#[inline(always)] +#[inline] pub fn seek_eq(args: &[MaskedArg], string: &str, case_sensitive: bool) -> Vec<usize> { args.iter() .filter(|arg| { @@ -97,7 +93,7 @@ pub fn seek_eq(args: &[MaskedArg], string: &str, case_sensitive: bool) -> Vec<us /// /// Returns the indices of matching arguments. #[must_use] -#[inline(always)] +#[inline] pub fn seek_contains(args: &[MaskedArg], string: &str, case_sensitive: bool) -> Vec<usize> { args.iter() .filter(|arg| { @@ -115,7 +111,7 @@ pub fn seek_contains(args: &[MaskedArg], string: &str, case_sensitive: bool) -> /// /// Returns the indices of matching arguments. #[must_use] -#[inline(always)] +#[inline] pub fn seek_start_with(args: &[MaskedArg], string: &str, case_sensitive: bool) -> Vec<usize> { args.iter() .filter(|arg| { @@ -133,7 +129,7 @@ pub fn seek_start_with(args: &[MaskedArg], string: &str, case_sensitive: bool) - /// /// Returns the indices of matching arguments. #[must_use] -#[inline(always)] +#[inline] pub fn seek_end_with(args: &[MaskedArg], string: &str, case_sensitive: bool) -> Vec<usize> { args.iter() .filter(|arg| { @@ -151,7 +147,7 @@ pub fn seek_end_with(args: &[MaskedArg], string: &str, case_sensitive: bool) -> /// /// Returns the indices of matching arguments. #[must_use] -#[inline(always)] +#[inline] pub fn multi_seek_eq(args: &[MaskedArg], strings: &[&str], case_sensitive: bool) -> Vec<usize> { args.iter() .filter(|arg| { @@ -169,7 +165,7 @@ pub fn multi_seek_eq(args: &[MaskedArg], strings: &[&str], case_sensitive: bool) /// /// Returns the indices of matching arguments. #[must_use] -#[inline(always)] +#[inline] pub fn multi_seek_contains( args: &[MaskedArg], strings: &[&str], @@ -194,7 +190,7 @@ pub fn multi_seek_contains( /// /// Returns the indices of matching arguments. #[must_use] -#[inline(always)] +#[inline] pub fn multi_seek_start_with( args: &[MaskedArg], strings: &[&str], @@ -219,7 +215,7 @@ pub fn multi_seek_start_with( /// /// Returns the indices of matching arguments. #[must_use] -#[inline(always)] +#[inline] pub fn multi_seek_end_with( args: &[MaskedArg], strings: &[&str], @@ -245,10 +241,10 @@ pub fn multi_seek_end_with( /// This is useful for converting owned `String` vectors into borrowed `&str` slices /// for functions that take `&[&str]` or similar parameters. #[must_use] -#[inline(always)] +#[inline] #[doc(hidden)] pub fn vec_string_to_vec_str(input: &[String]) -> Vec<&str> { - input.iter().map(|s| s.as_str()).collect() + input.iter().map(String::as_str).collect() } /// Converts a `&Vec<String>` into a `Vec<&str>` by borrowing each string's slice. @@ -270,7 +266,7 @@ macro_rules! vec_string_slice { /// /// Returns `Some(index)` if the vector is non-empty, otherwise `None`. #[must_use] -#[inline(always)] +#[inline] pub fn get_seeked_first(seeked: Vec<usize>) -> Option<usize> { seeked.into_iter().next() } diff --git a/arg_picker/src/pickable/multi_pickable.rs b/arg_picker/src/pickable/multi_pickable.rs index 404c23b..c5cd810 100644 --- a/arg_picker/src/pickable/multi_pickable.rs +++ b/arg_picker/src/pickable/multi_pickable.rs @@ -35,7 +35,7 @@ pub trait MultiPickableWithBoundary: Sized { pub struct NoBoundary; impl BoundaryCheck for NoBoundary { - #[inline(always)] + #[inline] fn check_boundary(_raw: &str) -> bool { false } @@ -46,7 +46,7 @@ impl<T: SinglePickable> MultiPickableWithBoundary for Vec<T> { type Checker = NoBoundary; fn pick_multi(raw: Vec<String>) -> PickerArgResult<Self> { - let mut result = Vec::with_capacity(raw.len()); + let mut result = Self::with_capacity(raw.len()); for s in &raw { match T::pick_single(Some(s)) { PickerArgResult::Parsed(v) => result.push(v), @@ -87,6 +87,6 @@ where fn pick(raw_strs: &[&str]) -> PickerArgResult<Self> { let strs = strip_flag(raw_strs); let owned: Vec<String> = strs.iter().map(|&s| s.to_string()).collect(); - <Vec<T> as MultiPickableWithBoundary>::pick_multi(owned) + <Self as MultiPickableWithBoundary>::pick_multi(owned) } } diff --git a/arg_picker/src/picker.rs b/arg_picker/src/picker.rs index f722fb5..a7f0dfb 100644 --- a/arg_picker/src/picker.rs +++ b/arg_picker/src/picker.rs @@ -24,7 +24,8 @@ impl<'a> Picker<'a> { /// This is equivalent to calling `std::env::args().skip(1)`, which /// collects all arguments passed to the program except the first one /// (the executable path). - pub fn from_args() -> Picker<'a, ()> { + #[must_use] + pub fn from_args() -> Self { Self::from_args_skip(1) } @@ -34,7 +35,8 @@ impl<'a> Picker<'a> { /// This method is useful when you want more control over which arguments /// are included. For example, pass `skip = 2` to skip both the program /// name and the first argument. - pub fn from_args_skip(skip: usize) -> Picker<'a, ()> { + #[must_use] + pub fn from_args_skip(skip: usize) -> Self { let args = std::env::args().skip(skip).collect::<Vec<String>>(); Picker { route_phantom: PhantomData, @@ -48,6 +50,7 @@ impl<'a> Picker<'a> { /// while preserving the same underlying arguments. The route type is typically /// used to distinguish different parsing contexts or to carry compile-time /// state information through the picking chain. + #[must_use] pub fn with_route<NewRoute>(self) -> Picker<'a, NewRoute> where Self: Sized, @@ -76,8 +79,8 @@ pub enum PickerArgs<'a> { impl<'a> From<PickerArgs<'a>> for Vec<String> { fn from(value: PickerArgs<'a>) -> Self { match value { - PickerArgs::Slice(items) => items.iter().map(|s| s.to_string()).collect(), - PickerArgs::Vec(items) => items.into_iter().map(|s| s.to_string()).collect(), + PickerArgs::Slice(items) => items.iter().map(ToString::to_string).collect(), + PickerArgs::Vec(items) => items.into_iter().map(ToString::to_string).collect(), PickerArgs::Owned(items) => items, } } @@ -88,12 +91,12 @@ impl<'a> From<&'a PickerArgs<'a>> for Vec<&'a str> { match value { PickerArgs::Slice(items) => items.to_vec(), PickerArgs::Vec(items) => items.clone(), - PickerArgs::Owned(items) => items.iter().map(|s| s.as_str()).collect(), + PickerArgs::Owned(items) => items.iter().map(String::as_str).collect(), } } } -impl<'a> Default for PickerArgs<'a> { +impl Default for PickerArgs<'_> { fn default() -> Self { Self::Vec(vec![]) } @@ -101,7 +104,8 @@ impl<'a> Default for PickerArgs<'a> { impl<'a> PickerArgs<'a> { /// Returns the number of arguments. - pub fn len(&self) -> usize { + #[must_use] + pub const fn len(&self) -> usize { match self { PickerArgs::Slice(items) => items.len(), PickerArgs::Vec(items) => items.len(), @@ -110,11 +114,13 @@ impl<'a> PickerArgs<'a> { } /// Returns `true` if there are no arguments. - pub fn is_empty(&self) -> bool { + #[must_use] + pub const fn is_empty(&self) -> bool { self.len() == 0 } /// Returns an iterator over the arguments, yielding `&str` values. + #[must_use] pub fn iter(&'a self) -> PickerIter<'a> { match self { PickerArgs::Slice(items) => PickerIter::Slice(items.iter()), @@ -124,16 +130,17 @@ impl<'a> PickerArgs<'a> { } /// Returns a reference to the argument at `index`, if it exists. + #[must_use] pub fn get(&self, index: usize) -> Option<&str> { match self { PickerArgs::Slice(items) => items.get(index).copied(), PickerArgs::Vec(items) => items.get(index).copied(), - PickerArgs::Owned(items) => items.get(index).map(|s| s.as_str()), + PickerArgs::Owned(items) => items.get(index).map(String::as_str), } } } -impl<'a> Index<usize> for PickerArgs<'a> { +impl Index<usize> for PickerArgs<'_> { type Output = str; fn index(&self, index: usize) -> &Self::Output { @@ -185,7 +192,7 @@ impl<'a, Route> From<Vec<&'a str>> for Picker<'a, Route> { } } -impl<'a, Route> From<Vec<String>> for Picker<'a, Route> { +impl<Route> From<Vec<String>> for Picker<'_, Route> { fn from(value: Vec<String>) -> Self { Picker { route_phantom: PhantomData, @@ -196,37 +203,42 @@ impl<'a, Route> From<Vec<String>> for Picker<'a, Route> { impl<'a, Route> Picker<'a, Route> { /// Returns a reference to the internal `PickerArgs`. - pub fn args(&self) -> &PickerArgs<'a> { + #[must_use] + pub const fn args(&self) -> &PickerArgs<'a> { &self.args } /// Returns a mutable reference to the internal `PickerArgs`. - pub fn args_mut(&mut self) -> &mut PickerArgs<'a> { + pub const fn args_mut(&mut self) -> &mut PickerArgs<'a> { &mut self.args } /// Consumes `self` and returns the internal `PickerArgs`. + #[must_use] pub fn into_args(self) -> PickerArgs<'a> { self.args } /// Returns the number of arguments. - pub fn len(&self) -> usize { + #[must_use] + pub const fn len(&self) -> usize { self.args.len() } /// Returns `true` if there are no arguments. - pub fn is_empty(&self) -> bool { + #[must_use] + pub const fn is_empty(&self) -> bool { self.args.is_empty() } /// Returns an iterator over the arguments, yielding `&str` values. + #[must_use] pub fn iter(&'a self) -> PickerIter<'a> { self.args.iter() } } -impl<'a, Route> Index<usize> for Picker<'a, Route> { +impl Index<usize> for Picker<'_> { type Output = str; fn index(&self, index: usize) -> &Self::Output { @@ -234,7 +246,7 @@ impl<'a, Route> Index<usize> for Picker<'a, Route> { } } -impl<'a, Route> Index<usize> for &Picker<'a, Route> { +impl<'a, Route> Index<usize> for &'a Picker<'a, Route> { type Output = str; fn index(&self, index: usize) -> &Self::Output { @@ -266,22 +278,20 @@ impl<'a> Iterator for PickerIter<'a> { fn next(&mut self) -> Option<Self::Item> { match self { - PickerIter::Slice(iter) => iter.next().copied(), - PickerIter::Vec(iter) => iter.next().copied(), - PickerIter::Owned(iter) => iter.next().map(|s| s.as_str()), + PickerIter::Slice(iter) | PickerIter::Vec(iter) => iter.next().copied(), + PickerIter::Owned(iter) => iter.next().map(String::as_str), } } fn size_hint(&self) -> (usize, Option<usize>) { match self { - PickerIter::Slice(iter) => iter.size_hint(), - PickerIter::Vec(iter) => iter.size_hint(), + PickerIter::Slice(iter) | PickerIter::Vec(iter) => iter.size_hint(), PickerIter::Owned(iter) => iter.size_hint(), } } } -impl<'a> ExactSizeIterator for PickerIter<'a> {} +impl ExactSizeIterator for PickerIter<'_> {} impl<'a, Route> Picker<'a, Route> { /// Creates a `PickerPattern1` from the given arg to start a picking chain. @@ -473,7 +483,7 @@ impl<'a> IntoPicker<'a> for &'a [&'a str] { impl<'a> IntoPicker<'a> for &'a [String] { fn to_picker(self) -> Picker<'a, ()> { - let vec: Vec<&str> = self.iter().map(|s| s.as_str()).collect(); + let vec: Vec<&str> = self.iter().map(String::as_str).collect(); Picker { route_phantom: PhantomData, args: PickerArgs::Vec(vec), @@ -492,7 +502,7 @@ impl<'a> IntoPicker<'a> for Vec<&'a str> { impl<'a> IntoPicker<'a> for &'a Vec<String> { fn to_picker(self) -> Picker<'a, ()> { - let slice: Vec<&str> = self.iter().map(|s| s.as_str()).collect(); + let slice: Vec<&str> = self.iter().map(String::as_str).collect(); Picker { route_phantom: PhantomData, args: PickerArgs::Vec(slice), @@ -510,7 +520,7 @@ impl<'a> IntoPicker<'a> for Vec<String> { } impl<'a, Route> Picker<'a, Route> { - /// Build the PickerPattern via Arguments + /// Build the `PickerPattern` via Arguments pub fn build_pattern1<N>( args: PickerArgs<'a>, arg: &'a PickerArg<'a, N>, diff --git a/arg_picker/src/picker/patterns.rs b/arg_picker/src/picker/patterns.rs index 5806605..7058d47 100644 --- a/arg_picker/src/picker/patterns.rs +++ b/arg_picker/src/picker/patterns.rs @@ -33,8 +33,7 @@ internal_repeat!(1..=32 => { #[allow(clippy::type_complexity)] pub fn or<F>(mut self, func: F) -> Self where - F: FnMut() -> T$, - F: 'static, + F: 'static + FnMut() -> T$, { self.default_$ = Some(Box::new(func)); self @@ -65,8 +64,7 @@ internal_repeat!(1..=32 => { /// pub fn or_route<F>(mut self, func: F) -> Self where - F: FnMut() -> Route, - F: 'static, + F: 'static + FnMut() -> Route, { self.route_$ = Some(Box::new(func)); self @@ -110,8 +108,7 @@ internal_repeat!(1..=32 => { #[allow(clippy::type_complexity)] pub fn post<F>(mut self, func: F) -> Self where - F: FnMut(T$) -> T$, - F: 'static, + F: 'static + FnMut(T$) -> T$, { self.post_$ = Some(Box::new(func)); self @@ -167,7 +164,6 @@ internal_repeat!(1..32 => { where N: Pickable<'a>, F: FnMut() -> N + 'static, - F: 'static, { self.pick(arg).or(func) } @@ -197,7 +193,6 @@ internal_repeat!(1..32 => { where N: Pickable<'a>, F: FnMut() -> Route + 'static, - F: 'static, { self.pick(arg).or_route(func) } diff --git a/arg_picker/src/value/flag.rs b/arg_picker/src/value/flag.rs index c0673bd..6449d65 100644 --- a/arg_picker/src/value/flag.rs +++ b/arg_picker/src/value/flag.rs @@ -80,9 +80,9 @@ impl Flag { /// [`Active`]: Flag::Active /// [`Inactive`]: Flag::Inactive #[must_use] - #[inline(always)] + #[inline] pub fn bool(&self) -> bool { - *self == Flag::Active + *self == Self::Active } } @@ -101,7 +101,7 @@ impl PartialEq<Flag> for bool { impl From<bool> for Flag { fn from(value: bool) -> Self { - if value { Flag::Active } else { Flag::Inactive } + if value { Self::Active } else { Self::Inactive } } } @@ -127,19 +127,19 @@ impl Deref for Flag { fn deref(&self) -> &bool { match self { - Flag::Active => &true, - Flag::Inactive => &false, + Self::Active => &true, + Self::Inactive => &false, } } } impl Not for Flag { - type Output = Flag; + type Output = Self; - fn not(self) -> Flag { + fn not(self) -> Self { match self { - Flag::Active => Flag::Inactive, - Flag::Inactive => Flag::Active, + Self::Active => Self::Inactive, + Self::Inactive => Self::Active, } } } diff --git a/arg_picker/src/value/paths.rs b/arg_picker/src/value/paths.rs index 403d6cc..d64a09f 100644 --- a/arg_picker/src/value/paths.rs +++ b/arg_picker/src/value/paths.rs @@ -117,7 +117,7 @@ pub struct NoPath { path: PathBuf, } -/// Implements common trait impls (From, AsRef, Deref, DerefMut) for a path wrapper type. +/// Implements common trait impls (`From`, `AsRef`, `Deref`, `DerefMut`) for a path wrapper type. macro_rules! impl_path_traits { ($type:ident) => { impl From<PathBuf> for $type { @@ -227,12 +227,14 @@ impl DerefMut for RecursiveFiles { impl RecursiveFiles { /// Returns the number of file paths. - pub fn len(&self) -> usize { + #[must_use] + pub const fn len(&self) -> usize { self.paths.len() } /// Returns `true` if there are no file paths. - pub fn is_empty(&self) -> bool { + #[must_use] + pub const fn is_empty(&self) -> bool { self.paths.is_empty() } @@ -242,8 +244,17 @@ impl RecursiveFiles { } } -impl From<Vec<RecursiveFiles>> for RecursiveFiles { - fn from(value: Vec<RecursiveFiles>) -> Self { +impl<'a> IntoIterator for &'a RecursiveFiles { + type Item = &'a PathBuf; + type IntoIter = std::slice::Iter<'a, PathBuf>; + + fn into_iter(self) -> Self::IntoIter { + self.iter() + } +} + +impl From<Vec<Self>> for RecursiveFiles { + fn from(value: Vec<Self>) -> Self { Self { paths: value.into_iter().flat_map(|r| r.paths).collect(), } diff --git a/arg_picker/src/value/vec_until.rs b/arg_picker/src/value/vec_until.rs index 04d87ce..6394cbf 100644 --- a/arg_picker/src/value/vec_until.rs +++ b/arg_picker/src/value/vec_until.rs @@ -22,6 +22,7 @@ pub struct VecUntil<T> { impl<T> VecUntil<T> { /// Consumes `self` and returns the underlying [`Vec<T>`]. + #[must_use] pub fn into_inner(self) -> Vec<T> { self.inner } @@ -29,7 +30,7 @@ impl<T> VecUntil<T> { impl<T> From<Vec<T>> for VecUntil<T> { fn from(v: Vec<T>) -> Self { - VecUntil { + Self { inner: v, _marker: PhantomData, } @@ -72,7 +73,7 @@ where PickerArgResult::Unparsed => {} } } - PickerArgResult::Parsed(VecUntil { + PickerArgResult::Parsed(Self { inner, _marker: PhantomData, }) @@ -97,7 +98,7 @@ where return positions; } - let start = if is_positional { 0 } else { 1 }; + let start = usize::from(!is_positional); if start >= positions.len() { return positions; } @@ -118,7 +119,7 @@ where fn pick(raw_strs: &[&str]) -> PickerArgResult<Self> { let strs = strip_flag(raw_strs); let owned: Vec<String> = strs.iter().map(|&s| s.to_string()).collect(); - <VecUntil<T> as MultiPickableWithBoundary>::pick_multi(owned) + <Self as MultiPickableWithBoundary>::pick_multi(owned) } } |