--list-X for registries

Author: AmlingPalantir

operation/src/aggregate.rs

@@ -34,6 +34,7 @@ impl Optionsable for ImplBe2 {
     fn options(opt: &mut OptionsPile<Options>) {
         opt.add_sub(|p| &mut p.aggs.0, aggregator::REGISTRY.labelled_single_options(&["a", "agg", "aggregator"], "aggregators to compute"));
         opt.add_sub(|p| &mut p.aggs.0, aggregator::REGISTRY.labelled_multiple_options(&["a", "agg", "aggregator"]));
+        opt.add(aggregator::REGISTRY.help_options("aggregator"));
         opt.add_sub(|p| &mut p.tru, TwoRecordUnionOption::new_options());
         opt.match_zero(&["incremental"], |p| p.incremental.set(), "Output one record after each input (instead of one at end)");
         opt.match_zero(&["no-incremental"], |p| p.incremental.clear(), "(default)");

operation/src/clumper_options.rs

@@ -18,6 +18,7 @@ impl Optionsable for ClumperOptions {
     fn options(opt: &mut OptionsPile<ClumperOptions>) {
         opt.add_sub(|p| &mut (p.0).0, clumper::REGISTRY.single_options(&["c", "clumper"], "clumpers to bucket by"));
         opt.add_sub(|p| &mut (p.0).0, clumper::REGISTRY.multiple_options(&["c", "clumper"]));
+        opt.add(clumper::REGISTRY.help_options("clumper"));
         opt.match_single(&["k", "key"], |p, a| {
             for a in a.split(',') {
                 (p.0).0.push(clumper::key::Impl::init(&[a])?);

operation/src/decollate.rs

@@ -27,6 +27,7 @@ impl Optionsable for ImplBe2 {
     fn options(opt: &mut OptionsPile<Options>) {
         opt.add_sub(|p| &mut p.deaggs.0, deaggregator::REGISTRY.single_options(&["d", "deagg", "deaggregator"], "deaggregator to ... do"));
         opt.add_sub(|p| &mut p.deaggs.0, deaggregator::REGISTRY.multiple_options(&["d", "deagg", "deaggregator"]));
+        opt.add(deaggregator::REGISTRY.help_options("deaggregator"));
     }
 }
 

operation/src/eval.rs

@@ -90,6 +90,7 @@ impl<B: EvalBe + 'static> Optionsable for EvalBe2<B> {
         opt.match_zero(&["no-invert"], |p| p.invert.clear(), "(default)");
         opt.match_extra_soft(|p, a| p.code.code.maybe_set_str(a), "code to execute");
         opt.match_single(&["engine"], |p, a| p.code.engine.set_str(a), "'engine' to execute code with");
+        opt.add(executor::REGISTRY.help_options("executor"));
         opt.match_zero(&["lua"], |p| p.code.engine.set("lua".to_string()), "evaluate as lua");
         opt.match_zero(&["input-lines"], |p| p.input.set(InputType::Lines()), "provide input as string lines");
         opt.match_zero(&["input-records"], |p| p.input.set(InputType::Records()), "provide input as structured records");

operation/src/sort.rs

@@ -29,6 +29,7 @@ impl Optionsable for ImplBe2 {
 
     fn options(opt: &mut OptionsPile<Options>) {
         opt.add_sub(|p| &mut p.sorts, SortOptions::new_options(&["s", "sort"], "sorts"));
+        opt.add(SortOptions::help_options());
         opt.match_single(&["l", "lex", "lexical"], |p, a| {
             for a in a.split(',') {
                 p.sorts.push(sorts::lexical::Impl::init(&[a])?);

operation/src/sort_options.rs

@@ -18,6 +18,10 @@ impl SortOptions {
         opt.add_sub(|p| &mut (p.0).0, sorts::REGISTRY.multiple_options(aliases));
     }
 
+    pub fn help_options<X: 'static>() -> OptionsPile<X> {
+        return sorts::REGISTRY.help_options("sort");
+    }
+
     pub fn new_options(aliases: &[&str], help: impl ToOptionsHelp) -> OptionsPile<SortOptions> {
         let mut opt = OptionsPile::new();
         Self::options(&mut opt, aliases, help);

operation/src/to_ptable.rs

@@ -48,6 +48,7 @@ impl Optionsable for ImplBe2 {
         opt.match_single(&["v"], |p, a| p.vk.push_split(a), "keys to use as values (default: whatever keys didn't get used otherwise)");
         opt.add_sub(|p| &mut p.xs, SortOptions::new_options(&["xs"], "sorts for x 'records'"));
         opt.add_sub(|p| &mut p.ys, SortOptions::new_options(&["ys"], "sorts for y 'records'"));
+        opt.add(SortOptions::help_options());
     }
 }
 

registry/src/lib.rs

@@ -12,22 +12,26 @@ use validates::ValidationResult;
 
 pub struct Registry<R> {
     map: HashMap<&'static str, (usize, Box<Fn(&[&str]) -> ValidationResult<R> + Send + Sync>)>,
+    aliaseses: Vec<Vec<&'static str>>,
 }
 
 impl<R> Default for Registry<R> {
     fn default() -> Self {
         return Registry {
             map: HashMap::new(),
+            aliaseses: Vec::new(),
         };
     }
 }
 
 impl<R: 'static> Registry<R> {
     pub fn add<I: Registrant<R> + 'static>(&mut self) {
-        for name in I::names() {
+        let names = I::names();
+        for name in names.iter() {
             let prev = self.map.insert(name, (I::argct(), Box::new(I::init)));
             assert!(prev.is_none(), "registry collision for {}", name);
         }
+        self.aliaseses.push(names);
     }
 
     pub fn find(&self, name: &str, args: &[&str]) -> ValidationResult<R> {
@@ -103,6 +107,22 @@ impl<R: 'static> Registry<R> {
         }, help);
         return opt;
     }
+
+    pub fn help_options<X: 'static>(&'static self, type_name: &str) -> OptionsPile<X> {
+        let mut opt = OptionsPile::<X>::new();
+        let aliaseses = &self.aliaseses;
+        opt.match_zero(&[&format!("list-{}", type_name)], move |_p| {
+            return ValidationError::help(aliaseses.iter().map(|aliases| {
+                let (first, rest) = aliases.split_first().unwrap();
+                let mut line = first.to_string();
+                if !rest.is_empty() {
+                    line.push_str(&format!(" [{}]", rest.join(", ")));
+                }
+                return line;
+            }).collect());
+        }, format!("list {}s", type_name));
+        return opt;
+    }
 }
 
 #[macro_export]