Adding an update_from_args/matches() to clap_derive

[lu-zero]

I have an use-case in which I would like to update some fields of a pre-populated struct with the matches provided by clap.

It seems not possible right now with the current structopt, would it be an interesting addition to clap_derive?

[CreepySkeleton]

Could you please define what "pre-populated" and "update" means? Derive needs all fields, short of those marked as skip, and it will rewrite all of them because it has to.

An example (possibly pseudocode) would help a lot.

[lu-zero]

In sleepy-rust

// some cli
let mainclap = ... ;
// clap_derived subcommand;
let subcommand = MyStruct::clap();
// add the subcommand and get the matches.
let matches = mainclap.subcommand(subcommand).get_matches();
// get the subcommand-specific matches
let my_matches = match matches.subcommand() {
  ("mysubcommand", args) => args,
  _ => ...
};

// create the base struct with a preset, all the values are set once
let mut base = matches.value_of("preset")
    .map(|v| MyStruct::preset(v))
    .unwrap_or_else(Mystruct::default);
// update the values with the ones carried by the matches
base.update_from_matches(my_matches)?;

Keypoint: you do not have to change the code above but just add/remove fields from the struct and the cli will follow up.

[CreepySkeleton]

add/remove fields from the struct

Which fields are you referring to, exactly? How is derive supposed to know which fields to update and which fields to keep as is?

Could you please write an example including the struct, the app, the input, and the expected result from update_from_matches? To make sure we are not speaking past each other.

[lu-zero]

Here is the struct

/// Contains the speed settings.
#[derive(Clone, Copy, Debug, Serialize, Deserialize, StructOpt)]
pub struct SpeedSettings {
  /// Enables inter-frames to have multiple reference frames.
  ///
  /// Enabled is slower.
  #[structopt(long, takes_value = true)]
  pub multiref: bool,
  /// Enables fast deblocking filter.
  #[structopt(long, takes_value = true)]
  pub fast_deblock: bool,
  /// Enables reduced transform set.
  ///
  /// Enabled is faster.
  #[structopt(long, takes_value = true)]
  pub reduced_tx_set: bool,
...

The preset function does something like this:

  pub fn from_preset(speed: usize) -> Self {
    SpeedSettings {
      multiref: Self::multiref_preset(speed),
      fast_deblock: Self::fast_deblock_preset(speed),
      reduced_tx_set: Self::reduced_tx_set_preset(speed),

the main cli would have

-s, --speed <SPEED>
            Speed level (0 is best quality, 10 is fastest)
            Speeds 10 and 0 are extremes and are generally not recommended
             0 :
                multiref = true
                fast_deblock = false
                reduced_tx_set = false
...
             1 :
                multiref = true
                fast_deblock = false
                reduced_tx_set = false

The subcommand would look like:

        --fast-deblock <fast-deblock>            Enables fast deblocking filter
        --multiref <multiref>                    Enables inter-frames to have multiple reference frames
        --reduced-tx-set <reduced-tx-set>        Enables reduced transform set

Assuming we pass

-s 0 speedsetting --reduce-tx-set true

We would get

SpeedSetting { multiref: true, reduce_tx_set: true, ... }

[CreepySkeleton]

Thank you, this was very helpful. I believe the algorithm can be described like following:

INPUTS:

• An old struct already filled by the derive. This struct needs to be updated.
• An ArgMatches instance, the source of updated values.

STEPS:

• For every field in the struct:
  • Check if the updated value is available in ArgMatches. If yes, convert value to the field's type and assign the field with the new value (i.e self.field = matches.value_of("field_id").convert().). If no, do nothing (i.e, leave the old value in place).
  • For flattened fields and subcommands, delegate to corresponding structs recursively (easy enough).

If this is correct, then I have nothing against it. Please open an issue to get early feedback and, perhaps, send a PR. I can mentor it.

[lu-zero]

Great, thank you :)