clap: use builder pattern and disable derive feature

Author: remi-dupre

Cargo.lock

@@ -15,7 +15,7 @@ bench = ["criterion"]
 
 [dependencies]
 attohttpc = { version = "0.16.0", default_features = false, features = ["tls"] }
-clap = "3.0.0-beta.2"
+clap = { version = "3.0.0-beta.2", default_features = false, features = ["std"] }
 colored = "2.0.0"
 dirs = "3.0.1"
 

Cargo.toml

@@ -2,45 +2,49 @@ pub mod input;
 pub mod parse;
 pub mod utils;
 
-use std::path::PathBuf;
-
 // Reexport some crates for the generated main
 pub use clap;
 pub use colored;
 
 #[cfg(feature = "bench")]
 pub use criterion;
 
-use clap::Clap;
-
-#[derive(Debug, Clap)]
-#[clap(
-    name = "Advent of Code",
-    about = concat!("Main page of the event: https://adventofcode.com/")
-)]
-pub struct Opt {
-    /// Read input from stdin instead of downloading it
-    #[clap(short = 'i', long, conflicts_with = "file")]
-    pub stdin: bool,
-
-    /// Read input from file instead of downloading it
-    #[clap(short, long, conflicts_with = "stdin")]
-    pub file: Option<PathBuf>,
-
-    /// Days to execute. By default all implemented days will run.
-    #[clap(name = "day num", short, long = "day")]
-    pub days: Vec<String>,
-
-    // TODO: better handling of bench CLI
-    /// Run criterion benchmarks
-    #[clap(short, long)]
-    pub bench: bool,
-}
-
-impl Opt {
-    pub fn day_enabled(&self, day: &str) -> bool {
-        day.starts_with("day") && self.days.iter().any(|d| d == &day[3..])
-    }
+use clap::{App, Arg, ValueHint};
+
+pub fn args(year: u16) -> App<'static> {
+    App::new(format!("Advent of Code {}", year))
+        .author("Rémi D. <[email protected]>")
+        .about("Main page of the event: https://adventofcode.com/")
+        .arg(
+            Arg::new("stdin")
+                .short('i')
+                .long("stdin")
+                .conflicts_with("file")
+                .about("Read input from stdin instead of downloading it"),
+        )
+        .arg(
+            Arg::new("file")
+                .takes_value(true)
+                .short('f')
+                .long("file")
+                .conflicts_with("stdin")
+                .value_hint(ValueHint::FilePath)
+                .about("Read input from file instead of downloading it"),
+        )
+        .arg(
+            Arg::new("days")
+                .takes_value(true)
+                .short('d')
+                .long("day")
+                .value_name("day num")
+                .about("Days to execute. By default all implemented days will run"),
+        )
+        .arg(
+            Arg::new("bench")
+                .short('b')
+                .long("bench")
+                .about("Run criterion benchmarks"),
+        )
 }
 
 #[macro_export]
@@ -50,48 +54,50 @@ macro_rules! base_main {
         use std::io::Read;
         use std::time::Instant;
 
-        use $crate::clap::Clap;
         use $crate::{bench_day, extract_day, parse, run_day};
 
         const YEAR: u16 = $year;
 
         fn main() {
-            let mut opt = $crate::Opt::parse();
+            let mut opt = $crate::args(YEAR).get_matches();
 
-            if opt.bench {
+            if opt.is_present("bench") {
                 bench();
             } else {
-                if opt.days.is_empty() {
-                    opt.days = parse!(extract_day {}; $( $tail )*)
-                        .iter()
-                        .map(|s| s[3..].to_string())
-                        .collect();
-                } else {
-                    let days = parse! { extract_day {}; $( $tail )* };
-
-                    let ignored_days: Vec<_> = opt.days
-                        .iter()
-                        .filter(|day| !days.contains(&format!("day{}", day).as_str()))
-                        .map(String::as_str)
-                        .collect();
-
-                    if !ignored_days.is_empty() {
-                        eprintln!(r"/!\ Ignoring unimplemented days: {}", ignored_days.join(", "));
+                let days: Vec<_> = {
+                    if let Some(opt_days) = opt.values_of("days") {
+                        let opt_days: Vec<_> = opt_days.collect();
+                        let days = parse! { extract_day {}; $( $tail )* };
+
+                        let ignored_days: Vec<_> = opt_days
+                            .iter()
+                            .filter(|day| !days.contains(&format!("day{}", day).as_str()))
+                            .copied()
+                            .collect();
+
+                        if !ignored_days.is_empty() {
+                            eprintln!(r"/!\ Ignoring unimplemented days: {}", ignored_days.join(", "));
+                        }
+
+                        opt_days
+                            .into_iter()
+                            .filter(|day| days.contains(&format!("day{}", day).as_str()))
+                            .collect()
+                    } else {
+                        parse!(extract_day {}; $( $tail )*)
+                            .iter()
+                            .map(|s| &s[3..])
+                            .collect()
                     }
+                };
 
-                    opt.days = opt.days
-                        .into_iter()
-                        .filter(|day| days.contains(&format!("day{}", day).as_str()))
-                        .collect();
-                }
-
-                if opt.days.len() > 1 && (opt.stdin || opt.file.is_some()) {
+                if days.len() > 1 && (opt.is_present("stdin") || opt.is_present("file")) {
                     eprintln!(r"/!\ You are using a personalized output over several days which can");
                     eprintln!(r"    be missleading. If you only intend to run solutions for a");
                     eprintln!(r"    specific day, you can specify it by using the `-d DAY_NUM` flag.");
                 }
 
-                for (i, day) in opt.days.iter().enumerate() {
+                for (i, day) in days.iter().enumerate() {
                     parse! {
                         run_day { i, format!("day{}", day), YEAR, opt };
                         $( $tail )*

src/lib.rs

@@ -12,12 +12,12 @@ macro_rules! run_day {
             println!("Day {}", day);
 
             let data = {
-                if $opt.stdin {
+                if $opt.is_present("stdin") {
                     let mut data = String::new();
                     std::io::stdin().read_to_string(&mut data)
                         .expect("failed to read from stdin");
                     data
-                } else if let Some(path) = $opt.file.as_ref() {
+                } else if let Some(path) = $opt.value_of("file") {
                     read_to_string(path)
                         .expect("failed to read specified file")
                 } else {