Remove defer chaining feature

Author: calebkiage

clap_builder/src/builder/command.rs

@@ -57,18 +57,6 @@ impl DeferFn {
     fn call(self, cmd: Command) -> Command {
         self.0(cmd)
     }
-
-    /// Chain `next_fn` with the current deferred function.
-    ///
-    /// Using this function always allocates memory since it creates a new closure that captures
-    /// `next_fn` & `self.0`
-    #[inline(always)]
-    fn then<F>(self, next_fn: F) -> Self
-    where
-        F: FnOnce(Command) -> Command + Send + Sync + 'static + Clone,
-    {
-        Self::new(move |cmd| next_fn(self.0(cmd)))
-    }
 }
 
 impl fmt::Debug for DeferFn {
@@ -611,11 +599,9 @@ impl Command {
     /// This is useful for large applications to delay definitions of subcommands until they are
     /// being invoked.
     ///
-    /// Calling this function multiple times will chain the calls to each function provided.
+    /// Calling this function multiple times will replace existing deferred calls.
     ///
-    /// This function will allocate on the heap in the following situations:
-    /// 1. when using the chaining feature.
-    /// 2. when the `deferred` argument is a capturing closure
+    /// This function will allocate on the heap if the `deferred` argument is a capturing closure
     ///
     /// # Examples
     ///
@@ -629,21 +615,14 @@ impl Command {
     ///         .defer(|cmd| {
     ///             cmd.arg(arg!(<config> "Required configuration file to use"))
     ///         })
-    ///         .defer(move |cmd| {
-    ///             cmd.version(version)
-    ///         })
     ///     )
     /// # ;
     /// ```
     pub fn defer<F>(mut self, deferred: F) -> Self
     where
         F: FnOnce(Command) -> Command + Send + Sync + 'static + Clone,
     {
-        let defer_fn = match self.deferred {
-            Some(existing_fn) => existing_fn.then(deferred),
-            None => DeferFn::new(deferred),
-        };
-        self.deferred = Some(defer_fn);
+        self.deferred = Some(DeferFn::new(deferred));
         self
     }
 

tests/builder/propagate_globals.rs

@@ -1,7 +1,6 @@
 use clap::{Arg, ArgAction, ArgMatches, Command};
 
 fn get_app() -> Command {
-    let captured_name = "inner1";
     Command::new("myprog")
         .arg(
             Arg::new("GLOBAL_ARG")
@@ -19,8 +18,7 @@ fn get_app() -> Command {
                 .action(ArgAction::Count),
         )
         .subcommand(Command::new("outer")
-            .defer(|cmd| cmd.subcommand(Command::new("inner")))
-            .defer(move |cmd| cmd.subcommand(Command::new(captured_name))))
+            .defer(|cmd| cmd.subcommand(Command::new("inner"))))
 }
 
 fn get_matches(cmd: Command, argv: &'static str) -> ArgMatches {
@@ -39,12 +37,6 @@ fn get_inner_matches(m: &ArgMatches) -> &ArgMatches {
         .expect("could not access inner subcommand")
 }
 
-fn get_inner_capture_matches(m: &ArgMatches) -> &ArgMatches {
-    get_outer_matches(m)
-        .subcommand_matches("inner1")
-        .expect("could not access inner1 subcommand")
-}
-
 fn top_can_access_arg<T: Into<Option<&'static str>>>(m: &ArgMatches, val: T) -> bool {
     m.get_one::<String>("GLOBAL_ARG").map(|v| v.as_str()) == val.into()
 }
@@ -56,13 +48,6 @@ fn inner_can_access_arg<T: Into<Option<&'static str>>>(m: &ArgMatches, val: T) -
         == val.into()
 }
 
-fn inner_capture_can_access_arg<T: Into<Option<&'static str>>>(m: &ArgMatches, val: T) -> bool {
-    get_inner_capture_matches(m)
-        .get_one::<String>("GLOBAL_ARG")
-        .map(|v| v.as_str())
-        == val.into()
-}
-
 fn outer_can_access_arg<T: Into<Option<&'static str>>>(m: &ArgMatches, val: T) -> bool {
     get_outer_matches(m)
         .get_one::<String>("GLOBAL_ARG")
@@ -81,12 +66,6 @@ fn inner_can_access_flag(m: &ArgMatches, present: bool, occurrences: u8) -> bool
         && (m.get_one::<u8>("GLOBAL_FLAG").copied() == Some(occurrences))
 }
 
-fn inner_capture_can_access_flag(m: &ArgMatches, present: bool, occurrences: u8) -> bool {
-    let m = get_inner_capture_matches(m);
-    (m.contains_id("GLOBAL_FLAG") == present)
-        && (m.get_one::<u8>("GLOBAL_FLAG").copied() == Some(occurrences))
-}
-
 fn outer_can_access_flag(m: &ArgMatches, present: bool, occurrences: u8) -> bool {
     let m = get_outer_matches(m);
     (m.contains_id("GLOBAL_FLAG") == present)
@@ -100,12 +79,6 @@ fn global_arg_used_top_level() {
     assert!(top_can_access_arg(&m, "some_value"));
     assert!(inner_can_access_arg(&m, "some_value"));
     assert!(outer_can_access_arg(&m, "some_value"));
-
-    let m = get_matches(get_app(), "myprog --global-arg=some_value outer inner1");
-
-    assert!(top_can_access_arg(&m, "some_value"));
-    assert!(inner_capture_can_access_arg(&m, "some_value"));
-    assert!(outer_can_access_arg(&m, "some_value"));
 }
 
 #[test]
@@ -115,12 +88,6 @@ fn global_arg_used_outer() {
     assert!(top_can_access_arg(&m, "some_value"));
     assert!(inner_can_access_arg(&m, "some_value"));
     assert!(outer_can_access_arg(&m, "some_value"));
-
-    let m = get_matches(get_app(), "myprog outer --global-arg=some_value inner1");
-
-    assert!(top_can_access_arg(&m, "some_value"));
-    assert!(inner_capture_can_access_arg(&m, "some_value"));
-    assert!(outer_can_access_arg(&m, "some_value"));
 }
 
 #[test]
@@ -130,12 +97,6 @@ fn global_arg_used_inner() {
     assert!(top_can_access_arg(&m, "some_value"));
     assert!(inner_can_access_arg(&m, "some_value"));
     assert!(outer_can_access_arg(&m, "some_value"));
-
-    let m = get_matches(get_app(), "myprog outer inner1 --global-arg=some_value");
-
-    assert!(top_can_access_arg(&m, "some_value"));
-    assert!(inner_capture_can_access_arg(&m, "some_value"));
-    assert!(outer_can_access_arg(&m, "some_value"));
 }
 
 #[test]
@@ -145,12 +106,6 @@ fn global_arg_default_value() {
     assert!(top_can_access_arg(&m, "default_value"));
     assert!(inner_can_access_arg(&m, "default_value"));
     assert!(outer_can_access_arg(&m, "default_value"));
-
-    let m = get_matches(get_app(), "myprog outer inner1");
-
-    assert!(top_can_access_arg(&m, "default_value"));
-    assert!(inner_capture_can_access_arg(&m, "default_value"));
-    assert!(outer_can_access_arg(&m, "default_value"));
 }
 
 #[test]
@@ -160,12 +115,6 @@ fn global_flag_used_top_level() {
     assert!(top_can_access_flag(&m, true, 1));
     assert!(inner_can_access_flag(&m, true, 1));
     assert!(outer_can_access_flag(&m, true, 1));
-
-    let m = get_matches(get_app(), "myprog --global-flag outer inner1");
-
-    assert!(top_can_access_flag(&m, true, 1));
-    assert!(inner_capture_can_access_flag(&m, true, 1));
-    assert!(outer_can_access_flag(&m, true, 1));
 }
 
 #[test]
@@ -175,12 +124,6 @@ fn global_flag_used_outer() {
     assert!(top_can_access_flag(&m, true, 1));
     assert!(inner_can_access_flag(&m, true, 1));
     assert!(outer_can_access_flag(&m, true, 1));
-
-    let m = get_matches(get_app(), "myprog outer --global-flag inner1");
-
-    assert!(top_can_access_flag(&m, true, 1));
-    assert!(inner_capture_can_access_flag(&m, true, 1));
-    assert!(outer_can_access_flag(&m, true, 1));
 }
 
 #[test]
@@ -190,12 +133,6 @@ fn global_flag_used_inner() {
     assert!(top_can_access_flag(&m, true, 1));
     assert!(inner_can_access_flag(&m, true, 1));
     assert!(outer_can_access_flag(&m, true, 1));
-
-    let m = get_matches(get_app(), "myprog outer inner1 --global-flag");
-
-    assert!(top_can_access_flag(&m, true, 1));
-    assert!(inner_capture_can_access_flag(&m, true, 1));
-    assert!(outer_can_access_flag(&m, true, 1));
 }
 
 #[test]
@@ -205,12 +142,6 @@ fn global_flag_2x_used_top_level() {
     assert!(top_can_access_flag(&m, true, 2));
     assert!(inner_can_access_flag(&m, true, 2));
     assert!(outer_can_access_flag(&m, true, 2));
-
-    let m = get_matches(get_app(), "myprog --global-flag --global-flag outer inner1");
-
-    assert!(top_can_access_flag(&m, true, 2));
-    assert!(inner_capture_can_access_flag(&m, true, 2));
-    assert!(outer_can_access_flag(&m, true, 2));
 }
 
 #[test]
@@ -220,10 +151,4 @@ fn global_flag_2x_used_inner() {
     assert!(top_can_access_flag(&m, true, 2));
     assert!(inner_can_access_flag(&m, true, 2));
     assert!(outer_can_access_flag(&m, true, 2));
-
-    let m = get_matches(get_app(), "myprog outer inner1 --global-flag --global-flag");
-
-    assert!(top_can_access_flag(&m, true, 2));
-    assert!(inner_capture_can_access_flag(&m, true, 2));
-    assert!(outer_can_access_flag(&m, true, 2));
 }

tests/builder/subcommands.rs

@@ -545,11 +545,10 @@ fn cant_have_args_with_multicall() {
 #[test]
 fn multicall_help_flag() {
     static EXPECTED: &str = "\
-Usage: foo bar [value] [value1]
+Usage: foo bar [value]
 
 Arguments:
-  [value]   
-  [value1]  
+  [value]  
 
 Options:
   -h, --help     Print help
@@ -561,8 +560,7 @@ Options:
         .multicall(true)
         .subcommand(Command::new("foo").defer(|cmd| {
             cmd.subcommand(Command::new("bar")
-                .defer(|cmd| cmd.arg(Arg::new("value")))
-                .defer(|cmd| cmd.arg(Arg::new("value1"))))
+                .defer(|cmd| cmd.arg(Arg::new("value"))))
         }));
     utils::assert_output(cmd, "foo bar --help", EXPECTED, false);
 }