Add macro for CLI subcommands

cgt_cli/src/clap_utils.rs

@@ -0,0 +1,24 @@
+macro_rules! mk_subcommand {
+    ($($variant:ident => $module:ident),* $(,)?) => {
+        $(mod $module;)*
+
+        #[derive(::clap::Subcommand, Debug)]
+        pub enum Command {
+            $($variant($module::Args),)*
+        }
+
+        #[derive(::clap::Parser, Debug)]
+        pub struct Args {
+            #[clap(subcommand)]
+            command: Command,
+        }
+
+        pub fn run(args: Args) -> ::anyhow::Result<()> {
+            match args.command {
+                $(Command::$variant(args) => $module::run(args),)*
+            }
+        }
+    };
+}
+
+pub(crate) use mk_subcommand;

cgt_cli/src/commands.rs

@@ -1,6 +1,8 @@
-pub(crate) mod amazons;
-pub(crate) mod canonical_form;
-pub(crate) mod domineering;
-pub(crate) mod quicksort;
-pub(crate) mod snort;
-pub(crate) mod wind_up;
+crate::clap_utils::mk_subcommand! {
+    Domineering => domineering,
+    Snort => snort,
+    Quicksort => quicksort,
+    WindUp => wind_up,
+    CanonicalForm => canonical_form,
+    Amazons => amazons,
+}

cgt_cli/src/commands/amazons.rs

@@ -1,21 +1,3 @@
-use anyhow::Result;
-use clap::{self, Parser, Subcommand};
-
-mod evaluate;
-
-#[derive(Subcommand, Debug)]
-pub enum Command {
-    Evaluate(evaluate::Args),
-}
-
-#[derive(Parser, Debug)]
-pub struct Args {
-    #[clap(subcommand)]
-    pub command: Command,
-}
-
-pub fn run(args: Args) -> Result<()> {
-    match args.command {
-        Command::Evaluate(args) => evaluate::run(args),
-    }
+crate::clap_utils::mk_subcommand! {
+    Evaluate => evaluate,
 }

cgt_cli/src/commands/canonical_form.rs

@@ -1,21 +1,3 @@
-use anyhow::Result;
-use clap::{self, Parser, Subcommand};
-
-mod sum;
-
-#[derive(Subcommand, Debug)]
-pub enum Command {
-    Sum(sum::Args),
-}
-
-#[derive(Parser, Debug)]
-pub struct Args {
-    #[clap(subcommand)]
-    pub command: Command,
-}
-
-pub fn run(args: Args) -> Result<()> {
-    match args.command {
-        Command::Sum(args) => sum::run(args),
-    }
+crate::clap_utils::mk_subcommand! {
+    Sum => sum,
 }

cgt_cli/src/commands/domineering.rs

@@ -1,31 +1,8 @@
-use anyhow::Result;
-use clap::{self, Parser, Subcommand};
-
 mod common;
-mod evaluate;
-mod exhaustive_search;
-mod genetic_search;
-mod latex_table;
-
-#[derive(Subcommand, Debug)]
-pub enum Command {
-    ExhaustiveSearch(exhaustive_search::Args),
-    GeneticSearch(genetic_search::Args),
-    Evaluate(evaluate::Args),
-    LatexTable(latex_table::Args),
-}
-
-#[derive(Parser, Debug)]
-pub struct Args {
-    #[clap(subcommand)]
-    pub command: Command,
-}
 
-pub fn run(args: Args) -> Result<()> {
-    match args.command {
-        Command::ExhaustiveSearch(args) => exhaustive_search::run(args),
-        Command::GeneticSearch(args) => genetic_search::run(args),
-        Command::Evaluate(args) => evaluate::run(args),
-        Command::LatexTable(args) => latex_table::run(args),
-    }
+crate::clap_utils::mk_subcommand! {
+    ExhaustiveSearch => exhaustive_search,
+    GeneticSearch => genetic_search,
+    Evaluate => evaluate,
+    LatexTable => latex_table,
 }

cgt_cli/src/commands/domineering/genetic_search.rs

@@ -1,5 +1,5 @@
 use crate::{
-    domineering::common::DomineeringResult,
+    commands::domineering::common::DomineeringResult,
     io::{FileOrStderr, FileOrStdout},
 };
 use anyhow::{bail, Context, Result};

cgt_cli/src/commands/quicksort.rs

@@ -1,21 +1,3 @@
-use anyhow::Result;
-use clap::{self, Parser, Subcommand};
-
-mod range;
-
-#[derive(Subcommand, Debug)]
-pub enum Command {
-    Range(range::Args),
-}
-
-#[derive(Parser, Debug)]
-pub struct Args {
-    #[clap(subcommand)]
-    pub command: Command,
-}
-
-pub fn run(args: Args) -> Result<()> {
-    match args.command {
-        Command::Range(args) => range::run(args),
-    }
+crate::clap_utils::mk_subcommand! {
+    Range => range,
 }

cgt_cli/src/commands/snort.rs

@@ -1,31 +1,8 @@
-use anyhow::Result;
-use clap::{self, Parser, Subcommand};
-
 mod common;
-pub mod genetic;
-pub mod graph;
-pub mod latex;
-pub mod three_caterpillar;
-
-#[derive(Subcommand, Debug)]
-pub enum Command {
-    Genetic(genetic::Args),
-    Latex(latex::Args),
-    Graph(graph::Args),
-    ThreeCaterpillar(three_caterpillar::Args),
-}
-
-#[derive(Parser, Debug)]
-pub struct Args {
-    #[clap(subcommand)]
-    pub command: Command,
-}
 
-pub fn run(args: Args) -> Result<()> {
-    match args.command {
-        Command::Genetic(args) => genetic::run(args),
-        Command::Latex(args) => latex::run(args),
-        Command::Graph(args) => graph::run(args),
-        Command::ThreeCaterpillar(args) => three_caterpillar::run(args),
-    }
+crate::clap_utils::mk_subcommand! {
+    Genetic => genetic,
+    Latex => latex,
+    Graph => graph,
+    ThreeCaterpillar => three_caterpillar,
 }

cgt_cli/src/commands/snort/genetic.rs

@@ -1,4 +1,4 @@
-use crate::{io::FileOrStderr, snort::common::Log};
+use crate::{commands::snort::common::Log, io::FileOrStderr};
 use anyhow::{Context, Result};
 use cgt::{
     genetic_algorithm::{Algorithm, GeneticAlgorithm, Scored},

cgt_cli/src/commands/snort/graph.rs

@@ -1,4 +1,4 @@
-use crate::snort::common::{analyze_position, Edge};
+use crate::commands::snort::common::{analyze_position, Edge};
 use anyhow::Result;
 use cgt::{
     graph::undirected::Graph,

cgt_cli/src/commands/snort/latex.rs

@@ -1,6 +1,6 @@
 use crate::{
+    commands::snort::common::Log,
     io::{FileOrStdin, FileOrStdout},
-    snort::common::Log,
 };
 use anyhow::{bail, Context, Result};
 use cgt::numeric::rational::Rational;

cgt_cli/src/commands/wind_up.rs

@@ -1,21 +1,3 @@
-use anyhow::Result;
-use clap::{self, Parser, Subcommand};
-
-mod range;
-
-#[derive(Subcommand, Debug)]
-pub enum Command {
-    Range(range::Args),
-}
-
-#[derive(Parser, Debug)]
-pub struct Args {
-    #[clap(subcommand)]
-    pub command: Command,
-}
-
-pub fn run(args: Args) -> Result<()> {
-    match args.command {
-        Command::Range(args) => range::run(args),
-    }
+crate::clap_utils::mk_subcommand! {
+    Range => range,
 }

cgt_cli/src/main.rs

@@ -1,38 +1,16 @@
 use crate::commands::*;
 use anyhow::Result;
-use clap::{self, Parser, Subcommand};
+use clap::Parser;
 
+pub(crate) mod clap_utils;
 mod commands;
 mod io;
 
 #[cfg(not(windows))]
 #[global_allocator]
 static ALLOC: jemallocator::Jemalloc = jemallocator::Jemalloc;
 
-#[derive(Subcommand, Debug)]
-enum Command {
-    Domineering(domineering::Args),
-    Snort(snort::Args),
-    Quicksort(quicksort::Args),
-    WindUp(wind_up::Args),
-    CanonicalForm(canonical_form::Args),
-    Amazons(amazons::Args),
-}
-
-#[derive(Parser)]
-struct Args {
-    #[clap(subcommand)]
-    command: Command,
-}
-
 fn main() -> Result<()> {
     let args = Args::parse();
-    match args.command {
-        Command::Domineering(args) => domineering::run(args),
-        Command::Snort(args) => snort::run(args),
-        Command::Quicksort(args) => quicksort::run(args),
-        Command::WindUp(args) => wind_up::run(args),
-        Command::CanonicalForm(args) => canonical_form::run(args),
-        Command::Amazons(args) => amazons::run(args),
-    }
+    crate::commands::run(args)
 }