Mirrors/clap
2
0
Fork 0
mirror of https://github.com/clap-rs/clap synced 2024-12-13 22:32:33 +00:00
Code Issues Projects Releases Packages Wiki Activity

Merge pull request #4292 from epage/func

Browse source 
refactor: Use getters internally
This commit is contained in:
Ed Page 2022-09-29 15:50:51 -05:00 committed by GitHub
commit 1e2b791049
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
8 changed files with 71 additions and 67 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
src/builder/arg.rs
View file

@ -50,7 +50,6 @@ use crate::INTERNAL_ERROR_MSG;
/// // Using a usage string (setting a similar argument to the one above) /// // Using a usage string (setting a similar argument to the one above)
/// let input = arg!(-i --input <FILE> "Provides an input file to the program"); /// let input = arg!(-i --input <FILE> "Provides an input file to the program");
/// ``` /// ```
#[allow(missing_debug_implementations)]
#[derive(Default, Clone)] #[derive(Default, Clone)]
pub struct Arg { pub struct Arg {
pub(crate) id: Id, pub(crate) id: Id,
@ -3904,7 +3903,7 @@ impl Arg {
/// assert_eq!(arg.is_positional(), false); /// assert_eq!(arg.is_positional(), false);
/// ``` /// ```
pub fn is_positional(&self) -> bool { pub fn is_positional(&self) -> bool {
self.long.is_none() && self.short.is_none() self.get_long().is_none() && self.get_short().is_none()
} }
/// Reports whether [`Arg::required`] is set /// Reports whether [`Arg::required`] is set
@ -4236,7 +4235,7 @@ impl PartialOrd for Arg {
impl Ord for Arg { impl Ord for Arg {
fn cmp(&self, other: &Arg) -> Ordering { fn cmp(&self, other: &Arg) -> Ordering {
self.id.cmp(&other.id) self.get_id().cmp(other.get_id())
} }
} }

20
src/builder/command.rs
View file

@ -3502,7 +3502,7 @@ impl Command {
.iter() .iter()
.flat_map(|x| x.args.args()), .flat_map(|x| x.args.args()),
) )
.find(|arg| arg.id == *id) .find(|arg| arg.get_id() == id)
.expect( .expect(
"Command::get_arg_conflicts_with: \ "Command::get_arg_conflicts_with: \
The passed arg conflicts with an arg unknown to the cmd", The passed arg conflicts with an arg unknown to the cmd",
@ -3527,7 +3527,11 @@ impl Command {
fn get_subcommands_containing(&self, arg: &Arg) -> Vec<&Self> { fn get_subcommands_containing(&self, arg: &Arg) -> Vec<&Self> {
let mut vec = std::vec::Vec::new(); let mut vec = std::vec::Vec::new();
for idx in 0..self.subcommands.len() { for idx in 0..self.subcommands.len() {
if self.subcommands[idx].args.args().any(|ar| ar.id == arg.id) { if self.subcommands[idx]
.args
.args()
.any(|ar| ar.get_id() == arg.get_id())
{
vec.push(&self.subcommands[idx]); vec.push(&self.subcommands[idx]);
vec.append(&mut self.subcommands[idx].get_subcommands_containing(arg)); vec.append(&mut self.subcommands[idx].get_subcommands_containing(arg));
} }
@ -4107,7 +4111,7 @@ impl Command {
let args_missing_help: Vec<Id> = self let args_missing_help: Vec<Id> = self
.args .args
.args() .args()
.filter(|arg| arg.help.is_none() && arg.long_help.is_none()) .filter(|arg| arg.get_help().is_none() && arg.get_long_help().is_none())
.map(|arg| arg.get_id().clone()) .map(|arg| arg.get_id().clone())
.collect(); .collect();
@ -4353,7 +4357,7 @@ impl Command {
} }
pub(crate) fn find(&self, arg_id: &Id) -> Option<&Arg> { pub(crate) fn find(&self, arg_id: &Id) -> Option<&Arg> {
self.args.args().find(|a| a.id == *arg_id) self.args.args().find(|a| a.get_id() == arg_id)
} }
#[inline] #[inline]
@ -4413,7 +4417,7 @@ impl Command {
#[cfg(debug_assertions)] #[cfg(debug_assertions)]
pub(crate) fn id_exists(&self, id: &Id) -> bool { pub(crate) fn id_exists(&self, id: &Id) -> bool {
self.args.args().any(|x| x.id == *id) || self.groups.iter().any(|x| x.id == *id) self.args.args().any(|x| x.get_id() == id) || self.groups.iter().any(|x| x.id == *id)
} }
/// Iterate through the groups this arg is member of. /// Iterate through the groups this arg is member of.
@ -4443,7 +4447,7 @@ impl Command {
pub(crate) fn required_graph(&self) -> ChildGraph<Id> { pub(crate) fn required_graph(&self) -> ChildGraph<Id> {
let mut reqs = ChildGraph::with_capacity(5); let mut reqs = ChildGraph::with_capacity(5);
for a in self.args.args().filter(|a| a.is_required_set()) { for a in self.args.args().filter(|a| a.is_required_set()) {
reqs.insert(a.id.clone()); reqs.insert(a.get_id().clone());
} }
for group in &self.groups { for group in &self.groups {
if group.required { if group.required {
@ -4506,7 +4510,7 @@ impl Command {
for r in arg.requires.iter().filter_map(&func) { for r in arg.requires.iter().filter_map(&func) {
if let Some(req) = self.find(&r) { if let Some(req) = self.find(&r) {
if !req.requires.is_empty() { if !req.requires.is_empty() {
r_vec.push(&req.id) r_vec.push(req.get_id())
} }
} }
args.push(r); args.push(r);
@ -4571,7 +4575,7 @@ impl Command {
// specified by the user is sent through. If hide_short_help is not included, // specified by the user is sent through. If hide_short_help is not included,
// then items specified with hidden_short_help will also be hidden. // then items specified with hidden_short_help will also be hidden.
let should_long = |v: &Arg| { let should_long = |v: &Arg| {
v.long_help.is_some() v.get_long_help().is_some()
|| v.is_hide_long_help_set() || v.is_hide_long_help_set()
|| v.is_hide_short_help_set() || v.is_hide_short_help_set()
|| v.get_possible_values() || v.get_possible_values()

28
src/builder/debug_asserts.rs
View file

@ -91,7 +91,7 @@ pub(crate) fn assert_app(cmd: &Command) {
} }
// Name conflicts // Name conflicts
if let Some((first, second)) = cmd.two_args_of(|x| x.id == arg.id) { if let Some((first, second)) = cmd.two_args_of(|x| x.get_id() == arg.get_id()) {
panic!( panic!(
"Command {}: Argument names must be unique, but '{}' is in use by more than one argument or group{}", "Command {}: Argument names must be unique, but '{}' is in use by more than one argument or group{}",
cmd.get_name(), cmd.get_name(),
@ -117,7 +117,7 @@ pub(crate) fn assert_app(cmd: &Command) {
// Short conflicts // Short conflicts
if let Some(s) = arg.get_short() { if let Some(s) = arg.get_short() {
if let Some((first, second)) = cmd.two_args_of(|x| x.short == Some(s)) { if let Some((first, second)) = cmd.two_args_of(|x| x.get_short() == Some(s)) {
panic!( panic!(
"Command {}: Short option names must be unique for each argument, \ "Command {}: Short option names must be unique for each argument, \
but '-{}' is in use by both '{}' and '{}'{}", but '-{}' is in use by both '{}' and '{}'{}",
@ -133,7 +133,7 @@ pub(crate) fn assert_app(cmd: &Command) {
// Index conflicts // Index conflicts
if let Some(idx) = arg.index { if let Some(idx) = arg.index {
if let Some((first, second)) = if let Some((first, second)) =
cmd.two_args_of(|x| x.is_positional() && x.index == Some(idx)) cmd.two_args_of(|x| x.is_positional() && x.get_index() == Some(idx))
{ {
panic!( panic!(
"Command {}: Argument '{}' has the same index as '{}' \ "Command {}: Argument '{}' has the same index as '{}' \
@ -242,13 +242,13 @@ pub(crate) fn assert_app(cmd: &Command) {
if arg.is_last_set() { if arg.is_last_set() {
assert!( assert!(
arg.long.is_none(), arg.get_long().is_none(),
"Command {}: Flags or Options cannot have last(true) set. '{}' has both a long and last(true) set.", "Command {}: Flags or Options cannot have last(true) set. '{}' has both a long and last(true) set.",
cmd.get_name(), cmd.get_name(),
arg.get_id() arg.get_id()
); );
assert!( assert!(
arg.short.is_none(), arg.get_short().is_none(),
"Command {}: Flags or Options cannot have last(true) set. '{}' has both a short and last(true) set.", "Command {}: Flags or Options cannot have last(true) set. '{}' has both a short and last(true) set.",
cmd.get_name(), cmd.get_name(),
arg.get_id() arg.get_id()
@ -358,10 +358,12 @@ pub(crate) fn assert_app(cmd: &Command) {
} }
fn duplicate_tip(cmd: &Command, first: &Arg, second: &Arg) -> &'static str { fn duplicate_tip(cmd: &Command, first: &Arg, second: &Arg) -> &'static str {
if !cmd.is_disable_help_flag_set() && (first.id == Id::HELP || second.id == Id::HELP) { if !cmd.is_disable_help_flag_set()
&& (first.get_id() == Id::HELP || second.get_id() == Id::HELP)
{
" (call `cmd.disable_help_flag(true)` to remove the auto-generated `--help`)" " (call `cmd.disable_help_flag(true)` to remove the auto-generated `--help`)"
} else if !cmd.is_disable_version_flag_set() } else if !cmd.is_disable_version_flag_set()
&& (first.id == Id::VERSION || second.id == Id::VERSION) && (first.get_id() == Id::VERSION || second.get_id() == Id::VERSION)
{ {
" (call `cmd.disable_version_flag(true)` to remove the auto-generated `--version`)" " (call `cmd.disable_version_flag(true)` to remove the auto-generated `--version`)"
} else { } else {
@ -546,7 +548,7 @@ fn _verify_positionals(cmd: &Command) -> bool {
} }
// Next we verify that only the highest index has takes multiple arguments (if any) // Next we verify that only the highest index has takes multiple arguments (if any)
let only_highest = |a: &Arg| a.is_multiple() && (a.index.unwrap_or(0) != highest_idx); let only_highest = |a: &Arg| a.is_multiple() && (a.get_index().unwrap_or(0) != highest_idx);
if cmd.get_positionals().any(only_highest) { if cmd.get_positionals().any(only_highest) {
// First we make sure if there is a positional that allows multiple values // First we make sure if there is a positional that allows multiple values
// the one before it (second to last) has one of these: // the one before it (second to last) has one of these:
@ -614,7 +616,7 @@ fn _verify_positionals(cmd: &Command) -> bool {
index than a required positional argument by two or more: {:?} \ index than a required positional argument by two or more: {:?} \
index {:?}", index {:?}",
p.get_id(), p.get_id(),
p.index p.get_index()
); );
} else if p.is_required_set() && !p.is_last_set() { } else if p.is_required_set() && !p.is_last_set() {
// Args that .last(true) don't count since they can be required and have // Args that .last(true) don't count since they can be required and have
@ -643,7 +645,7 @@ fn _verify_positionals(cmd: &Command) -> bool {
"Found non-required positional argument with a lower \ "Found non-required positional argument with a lower \
index than a required positional argument: {:?} index {:?}", index than a required positional argument: {:?} index {:?}",
p.get_id(), p.get_id(),
p.index p.get_index()
); );
} else if p.is_required_set() && !p.is_last_set() { } else if p.is_required_set() && !p.is_last_set() {
// Args that .last(true) don't count since they can be required and have // Args that .last(true) don't count since they can be required and have
@ -682,7 +684,7 @@ fn assert_arg(arg: &Arg) {
// Self conflict // Self conflict
// TODO: this check should be recursive // TODO: this check should be recursive
assert!( assert!(
!arg.blacklist.iter().any(|x| *x == arg.id), !arg.blacklist.iter().any(|x| x == arg.get_id()),
"Argument '{}' cannot conflict with itself", "Argument '{}' cannot conflict with itself",
arg.get_id(), arg.get_id(),
); );
@ -731,9 +733,9 @@ fn assert_arg(arg: &Arg) {
arg.is_takes_value_set(), arg.is_takes_value_set(),
"Argument '{}` is positional, it must take a value{}", "Argument '{}` is positional, it must take a value{}",
arg.get_id(), arg.get_id(),
if arg.id == Id::HELP { if arg.get_id() == Id::HELP {
" (`mut_arg` no longer works with implicit `--help`)" " (`mut_arg` no longer works with implicit `--help`)"
} else if arg.id == Id::VERSION { } else if arg.get_id() == Id::VERSION {
" (`mut_arg` no longer works with implicit `--version`)" " (`mut_arg` no longer works with implicit `--version`)"
} else { } else {
"" ""

8
src/output/help_template.rs
View file

@ -494,7 +494,7 @@ impl<'cmd, 'writer> HelpTemplate<'cmd, 'writer> {
fn long(&mut self, arg: &Arg) { fn long(&mut self, arg: &Arg) {
debug!("HelpTemplate::long"); debug!("HelpTemplate::long");
if let Some(long) = arg.get_long() { if let Some(long) = arg.get_long() {
if arg.short.is_some() { if arg.get_short().is_some() {
self.none(", "); self.none(", ");
} }
self.literal(format!("--{}", long)); self.literal(format!("--{}", long));
@ -516,7 +516,7 @@ impl<'cmd, 'writer> HelpTemplate<'cmd, 'writer> {
let self_len = display_width(&arg.to_string()); let self_len = display_width(&arg.to_string());
// Since we're writing spaces from the tab point we first need to know if we // Since we're writing spaces from the tab point we first need to know if we
// had a long and short, or just short // had a long and short, or just short
let padding = if arg.long.is_some() { let padding = if arg.get_long().is_some() {
// Only account 4 after the val // Only account 4 after the val
TAB_WIDTH TAB_WIDTH
} else { } else {
@ -969,7 +969,7 @@ fn option_sort_key(arg: &Arg) -> (usize, String) {
x.to_string() x.to_string()
} else { } else {
let mut s = '{'.to_string(); let mut s = '{'.to_string();
s.push_str(arg.id.as_str()); s.push_str(arg.get_id().as_str());
s s
}; };
(arg.get_display_order(), key) (arg.get_display_order(), key)
@ -1017,7 +1017,7 @@ fn replace_newline_var(styled: &mut StyledStr) {
} }
fn longest_filter(arg: &Arg) -> bool { fn longest_filter(arg: &Arg) -> bool {
arg.is_takes_value_set() || arg.long.is_some() || arg.short.is_none() arg.is_takes_value_set() || arg.get_long().is_some() || arg.get_short().is_none()
} }
#[cfg(test)] #[cfg(test)]

2
src/output/usage.rs
View file

@ -170,7 +170,7 @@ impl<'cmd> Usage<'cmd> {
debug!("Usage::needs_options_tag:iter Option is required"); debug!("Usage::needs_options_tag:iter Option is required");
continue; continue;
} }
for grp_s in self.cmd.groups_for_arg(&f.id) { for grp_s in self.cmd.groups_for_arg(f.get_id()) {
debug!("Usage::needs_options_tag:iter:iter: grp_s={:?}", grp_s); debug!("Usage::needs_options_tag:iter:iter: grp_s={:?}", grp_s);
if self.cmd.get_groups().any(|g| g.id == grp_s && g.required) { if self.cmd.get_groups().any(|g| g.id == grp_s && g.required) {
debug!("Usage::needs_options_tag:iter:iter: Group is required"); debug!("Usage::needs_options_tag:iter:iter: Group is required");

10
src/parser/arg_matcher.rs
View file

@ -25,8 +25,8 @@ impl ArgMatcher {
matches: ArgMatches { matches: ArgMatches {
#[cfg(debug_assertions)] #[cfg(debug_assertions)]
valid_args: { valid_args: {
let args = _cmd.get_arguments().map(|a| a.id.clone()); let args = _cmd.get_arguments().map(|a| a.get_id().clone());
let groups = _cmd.get_groups().map(|g| g.id.clone()); let groups = _cmd.get_groups().map(|g| g.get_id().clone());
args.chain(groups).collect() args.chain(groups).collect()
}, },
#[cfg(debug_assertions)] #[cfg(debug_assertions)]
@ -130,7 +130,7 @@ impl ArgMatcher {
} }
pub(crate) fn start_custom_arg(&mut self, arg: &Arg, source: ValueSource) { pub(crate) fn start_custom_arg(&mut self, arg: &Arg, source: ValueSource) {
let id = arg.id.clone(); let id = arg.get_id().clone();
debug!( debug!(
"ArgMatcher::start_custom_arg: id={:?}, source={:?}", "ArgMatcher::start_custom_arg: id={:?}, source={:?}",
id, source id, source
@ -153,7 +153,7 @@ impl ArgMatcher {
} }
pub(crate) fn start_occurrence_of_arg(&mut self, arg: &Arg) { pub(crate) fn start_occurrence_of_arg(&mut self, arg: &Arg) {
let id = arg.id.clone(); let id = arg.get_id().clone();
debug!("ArgMatcher::start_occurrence_of_arg: id={:?}", id); debug!("ArgMatcher::start_occurrence_of_arg: id={:?}", id);
let ma = self.entry(id).or_insert(MatchedArg::new_arg(arg)); let ma = self.entry(id).or_insert(MatchedArg::new_arg(arg));
debug_assert_eq!(ma.type_id(), Some(arg.get_value_parser().type_id())); debug_assert_eq!(ma.type_id(), Some(arg.get_value_parser().type_id()));
@ -199,7 +199,7 @@ impl ArgMatcher {
let num_pending = self let num_pending = self
.pending .pending
.as_ref() .as_ref()
.and_then(|p| (p.id == o.id).then(|| p.raw_vals.len())) .and_then(|p| (p.id == *o.get_id()).then(|| p.raw_vals.len()))
.unwrap_or(0); .unwrap_or(0);
debug!( debug!(
"ArgMatcher::needs_more_vals: o={}, pending={}", "ArgMatcher::needs_more_vals: o={}, pending={}",

57
src/parser/parser.rs
View file

@ -286,7 +286,7 @@ impl<'cmd> Parser<'cmd> {
let arg_values = matcher.pending_values_mut(id, None, trailing_values); let arg_values = matcher.pending_values_mut(id, None, trailing_values);
arg_values.push(arg_os.to_value_os().to_os_str().into_owned()); arg_values.push(arg_os.to_value_os().to_os_str().into_owned());
if matcher.needs_more_vals(arg) { if matcher.needs_more_vals(arg) {
ParseResult::Opt(arg.id.clone()) ParseResult::Opt(arg.get_id().clone())
} else { } else {
ParseResult::ValuesDone ParseResult::ValuesDone
} }
@ -308,10 +308,9 @@ impl<'cmd> Parser<'cmd> {
// The last positional argument, or second to last positional // The last positional argument, or second to last positional
// argument may be set to .multiple_values(true) or `.multiple_occurrences(true)` // argument may be set to .multiple_values(true) or `.multiple_occurrences(true)`
let low_index_mults = is_second_to_last let low_index_mults = is_second_to_last
&& self && self.cmd.get_positionals().any(|a| {
.cmd a.is_multiple() && (positional_count != a.get_index().unwrap_or(0))
.get_positionals() })
.any(|a| a.is_multiple() && (positional_count != a.index.unwrap_or(0)))
&& self && self
.cmd .cmd
.get_positionals() .get_positionals()
@ -336,7 +335,7 @@ impl<'cmd> Parser<'cmd> {
if let Some(arg) = self if let Some(arg) = self
.cmd .cmd
.get_positionals() .get_positionals()
.find(|a| a.index == Some(pos_counter)) .find(|a| a.get_index() == Some(pos_counter))
{ {
// If next value looks like a new_arg or it's a // If next value looks like a new_arg or it's a
// subcommand, skip positional argument under current // subcommand, skip positional argument under current
@ -387,7 +386,7 @@ impl<'cmd> Parser<'cmd> {
trailing_values = true; trailing_values = true;
} }
if matcher.pending_arg_id() != Some(&arg.id) || !arg.is_multiple_values_set() { if matcher.pending_arg_id() != Some(arg.get_id()) || !arg.is_multiple_values_set() {
ok!(self.resolve_pending(matcher)); ok!(self.resolve_pending(matcher));
} }
if let Some(_parse_result) = self.check_terminator(arg, arg_os.to_value_os()) { if let Some(_parse_result) = self.check_terminator(arg, arg_os.to_value_os()) {
@ -397,7 +396,7 @@ impl<'cmd> Parser<'cmd> {
); );
} else { } else {
let arg_values = matcher.pending_values_mut( let arg_values = matcher.pending_values_mut(
&arg.id, arg.get_id(),
Some(Identifier::Index), Some(Identifier::Index),
trailing_values, trailing_values,
); );
@ -409,7 +408,7 @@ impl<'cmd> Parser<'cmd> {
pos_counter += 1; pos_counter += 1;
parse_state = ParseState::ValuesDone; parse_state = ParseState::ValuesDone;
} else { } else {
parse_state = ParseState::Pos(arg.id.clone()); parse_state = ParseState::Pos(arg.get_id().clone());
} }
valid_arg_found = true; valid_arg_found = true;
} else if let Some(external_parser) = } else if let Some(external_parser) =
@ -637,8 +636,8 @@ impl<'cmd> Parser<'cmd> {
current_positional.get_id() current_positional.get_id()
); );
if self.cmd[&current_positional.id].is_allow_hyphen_values_set() if self.cmd[current_positional.get_id()].is_allow_hyphen_values_set()
|| (self.cmd[&current_positional.id].is_allow_negative_numbers_set() || (self.cmd[current_positional.get_id()].is_allow_negative_numbers_set()
&& next.is_number()) && next.is_number())
{ {
// If allow hyphen, this isn't a new arg. // If allow hyphen, this isn't a new arg.
@ -784,9 +783,9 @@ impl<'cmd> Parser<'cmd> {
matcher.check_explicit(arg_id, &crate::builder::ArgPredicate::IsPresent) matcher.check_explicit(arg_id, &crate::builder::ArgPredicate::IsPresent)
}) })
.filter(|&n| { .filter(|&n| {
self.cmd self.cmd.find(n).map_or(true, |a| {
.find(n) !(a.is_hide_set() || required.contains(a.get_id()))
.map_or(true, |a| !(a.is_hide_set() || required.contains(&a.id))) })
}) })
.cloned() .cloned()
.collect(); .collect();
@ -1038,8 +1037,8 @@ impl<'cmd> Parser<'cmd> {
debug!("Parser::parse_opt_value: More arg vals required..."); debug!("Parser::parse_opt_value: More arg vals required...");
ok!(self.resolve_pending(matcher)); ok!(self.resolve_pending(matcher));
let trailing_values = false; let trailing_values = false;
matcher.pending_values_mut(&arg.id, Some(ident), trailing_values); matcher.pending_values_mut(arg.get_id(), Some(ident), trailing_values);
Ok(ParseResult::Opt(arg.id.clone())) Ok(ParseResult::Opt(arg.get_id().clone()))
} }
} }
@ -1075,12 +1074,12 @@ impl<'cmd> Parser<'cmd> {
let value_parser = arg.get_value_parser(); let value_parser = arg.get_value_parser();
let val = ok!(value_parser.parse_ref(self.cmd, Some(arg), &raw_val)); let val = ok!(value_parser.parse_ref(self.cmd, Some(arg), &raw_val));
matcher.add_val_to(&arg.id, val, raw_val); matcher.add_val_to(arg.get_id(), val, raw_val);
matcher.add_index_to(&arg.id, self.cur_idx.get()); matcher.add_index_to(arg.get_id(), self.cur_idx.get());
} }
// Increment or create the group "args" // Increment or create the group "args"
for group in self.cmd.groups_for_arg(&arg.id) { for group in self.cmd.groups_for_arg(arg.get_id()) {
matcher.add_val_to( matcher.add_val_to(
&group, &group,
AnyValue::new(arg.get_id().clone()), AnyValue::new(arg.get_id().clone()),
@ -1180,7 +1179,7 @@ impl<'cmd> Parser<'cmd> {
self.cur_idx.set(self.cur_idx.get() + 1); self.cur_idx.set(self.cur_idx.get() + 1);
debug!("Parser::react: cur_idx:={}", self.cur_idx.get()); debug!("Parser::react: cur_idx:={}", self.cur_idx.get());
} }
if matcher.remove(&arg.id) if matcher.remove(arg.get_id())
&& !(self.cmd.is_args_override_self() || arg.overrides.contains(arg.get_id())) && !(self.cmd.is_args_override_self() || arg.overrides.contains(arg.get_id()))
{ {
return Err(ClapError::argument_conflict( return Err(ClapError::argument_conflict(
@ -1223,7 +1222,7 @@ impl<'cmd> Parser<'cmd> {
raw_vals raw_vals
}; };
if matcher.remove(&arg.id) if matcher.remove(arg.get_id())
&& !(self.cmd.is_args_override_self() || arg.overrides.contains(arg.get_id())) && !(self.cmd.is_args_override_self() || arg.overrides.contains(arg.get_id()))
{ {
return Err(ClapError::argument_conflict( return Err(ClapError::argument_conflict(
@ -1244,7 +1243,7 @@ impl<'cmd> Parser<'cmd> {
raw_vals raw_vals
}; };
if matcher.remove(&arg.id) if matcher.remove(arg.get_id())
&& !(self.cmd.is_args_override_self() || arg.overrides.contains(arg.get_id())) && !(self.cmd.is_args_override_self() || arg.overrides.contains(arg.get_id()))
{ {
return Err(ClapError::argument_conflict( return Err(ClapError::argument_conflict(
@ -1269,7 +1268,7 @@ impl<'cmd> Parser<'cmd> {
raw_vals raw_vals
}; };
matcher.remove(&arg.id); matcher.remove(arg.get_id());
self.start_custom_arg(matcher, arg, source); self.start_custom_arg(matcher, arg, source);
ok!(self.push_arg_values(arg, raw_vals, matcher)); ok!(self.push_arg_values(arg, raw_vals, matcher));
Ok(ParseResult::ValuesDone) Ok(ParseResult::ValuesDone)
@ -1366,8 +1365,8 @@ impl<'cmd> Parser<'cmd> {
let mut transitive = Vec::new(); let mut transitive = Vec::new();
for arg_id in matcher.arg_ids() { for arg_id in matcher.arg_ids() {
if let Some(overrider) = self.cmd.find(arg_id) { if let Some(overrider) = self.cmd.find(arg_id) {
if overrider.overrides.contains(&arg.id) { if overrider.overrides.contains(arg.get_id()) {
transitive.push(&overrider.id); transitive.push(overrider.get_id());
} }
} }
} }
@ -1422,7 +1421,7 @@ impl<'cmd> Parser<'cmd> {
fn add_default_value(&self, arg: &Arg, matcher: &mut ArgMatcher) -> ClapResult<()> { fn add_default_value(&self, arg: &Arg, matcher: &mut ArgMatcher) -> ClapResult<()> {
if !arg.default_vals_ifs.is_empty() { if !arg.default_vals_ifs.is_empty() {
debug!("Parser::add_default_value: has conditional defaults"); debug!("Parser::add_default_value: has conditional defaults");
if !matcher.contains(&arg.id) { if !matcher.contains(arg.get_id()) {
for (id, val, default) in arg.default_vals_ifs.iter() { for (id, val, default) in arg.default_vals_ifs.iter() {
let add = if let Some(a) = matcher.get(id) { let add = if let Some(a) = matcher.get(id) {
match val { match val {
@ -1461,7 +1460,7 @@ impl<'cmd> Parser<'cmd> {
"Parser::add_default_value:iter:{}: has default vals", "Parser::add_default_value:iter:{}: has default vals",
arg.get_id() arg.get_id()
); );
if matcher.contains(&arg.id) { if matcher.contains(arg.get_id()) {
debug!("Parser::add_default_value:iter:{}: was used", arg.get_id()); debug!("Parser::add_default_value:iter:{}: was used", arg.get_id());
// do nothing // do nothing
} else { } else {
@ -1502,7 +1501,7 @@ impl<'cmd> Parser<'cmd> {
self.remove_overrides(arg, matcher); self.remove_overrides(arg, matcher);
} }
matcher.start_custom_arg(arg, source); matcher.start_custom_arg(arg, source);
for group in self.cmd.groups_for_arg(&arg.id) { for group in self.cmd.groups_for_arg(arg.get_id()) {
matcher.start_custom_group(group, source); matcher.start_custom_group(group, source);
} }
} }
@ -1514,7 +1513,7 @@ impl<'cmd> Parser<'cmd> {
matcher.start_occurrence_of_arg(arg); matcher.start_occurrence_of_arg(arg);
// Increment or create the group "args" // Increment or create the group "args"
for group in self.cmd.groups_for_arg(&arg.id) { for group in self.cmd.groups_for_arg(arg.get_id()) {
matcher.start_occurrence_of_group(group); matcher.start_occurrence_of_group(group);
} }
} }

8
src/parser/validator.rs
View file

@ -34,7 +34,7 @@ impl<'cmd> Validator<'cmd> {
debug!("Validator::validate: needs_val_of={:?}", a); debug!("Validator::validate: needs_val_of={:?}", a);
let o = &self.cmd[&a]; let o = &self.cmd[&a];
let should_err = if let Some(v) = matcher.args.get(&o.id) { let should_err = if let Some(v) = matcher.args.get(o.get_id()) {
v.all_val_groups_empty() && o.get_min_vals() != 0 v.all_val_groups_empty() && o.get_min_vals() != 0
} else { } else {
true true
@ -220,11 +220,11 @@ impl<'cmd> Validator<'cmd> {
debug!("Validator::gather_requires:iter:{:?}", name); debug!("Validator::gather_requires:iter:{:?}", name);
if let Some(arg) = self.cmd.find(name) { if let Some(arg) = self.cmd.find(name) {
let is_relevant = |(val, req_arg): &(ArgPredicate, Id)| -> Option<Id> { let is_relevant = |(val, req_arg): &(ArgPredicate, Id)| -> Option<Id> {
let required = matcher.check_explicit(&arg.id, val); let required = matcher.check_explicit(arg.get_id(), val);
required.then(|| req_arg.clone()) required.then(|| req_arg.clone())
}; };
for req in self.cmd.unroll_arg_requires(is_relevant, &arg.id) { for req in self.cmd.unroll_arg_requires(is_relevant, arg.get_id()) {
self.required.insert(req); self.required.insert(req);
} }
} else if let Some(g) = self.cmd.find_group(name) { } else if let Some(g) = self.cmd.find_group(name) {
@ -374,7 +374,7 @@ impl<'cmd> Validator<'cmd> {
conflicts: &mut Conflicts, conflicts: &mut Conflicts,
) -> bool { ) -> bool {
debug!("Validator::is_missing_required_ok: {}", a.get_id()); debug!("Validator::is_missing_required_ok: {}", a.get_id());
let conflicts = conflicts.gather_conflicts(self.cmd, matcher, &a.id); let conflicts = conflicts.gather_conflicts(self.cmd, matcher, a.get_id());
!conflicts.is_empty() !conflicts.is_empty()
} }