Merge pull request #9 from remi-dupre/lighter-dependancies

Lighter dependancies

Author: remi-dupre

Cargo.lock

@@ -1,17 +1,23 @@
 [package]
 name = "aoc-main"
 description = "A macro which defines a handful main for the Advent of Code"
-version = "0.2.0"
+version = "0.3.0"
 authors = ["Rémi Dupré <[email protected]>"]
 repository = "https://github.com/remi-dupre/aoc"
 license = "Apache-2.0"
 readme = "README.md"
 keywords = ["advent", "aoc", "macro"]
 edition = "2018"
 
+[features]
+# Criterion is a quite heavy dependencies which will not be used in many cases.
+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"
-criterion = "0.3.3"
 dirs = "3.0.1"
+
+# Optional dependencies
+criterion = { version = "0.3.3", optional = true }

Cargo.toml

@@ -66,6 +66,18 @@ output. Also, the generator can output a structure that contains borrowed data
 from the original input file.
 
 
+Benchmarks
+----------
+
+You can run Criterion benchmarks by running `cargo run --release -- --bench`,
+but first you need to enable the `bench` feature in your *cargo.toml*:
+
+```toml
+[dependencies]
+aoc-main = { version = "*", features = ["bench"] }
+```
+
+
 Fetching your AOC token
 -----------------------
 

README.md

@@ -2,102 +2,119 @@ 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;
-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,
-}
+#[cfg(feature = "bench")]
+pub use criterion;
 
-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]
-macro_rules! main {
+macro_rules! base_main {
     ( year $year: expr; $( $tail: tt )* ) => {
         use std::fs::read_to_string;
         use std::io::Read;
         use std::time::Instant;
 
-        use $crate::clap::Clap;
-        use $crate::criterion::*;
         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();
-            }
-
-            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();
+                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()
+                    }
+                };
 
-                if !ignored_days.is_empty() {
-                    eprintln!(r"/!\ Ignoring unimplemented days: {}", ignored_days.join(", "));
+                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.");
                 }
 
-                opt.days = opt.days
-                    .into_iter()
-                    .filter(|day| days.contains(&format!("day{}", day).as_str()))
-                    .collect();
+                for (i, day) in days.iter().enumerate() {
+                    parse! {
+                        run_day { i, format!("day{}", day), YEAR, opt };
+                        $( $tail )*
+                    };
+                }
             }
+        }
+    }
+}
 
-            if opt.days.len() > 1 && (opt.stdin || opt.file.is_some()) {
-                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.");
-            }
+#[cfg(feature = "bench")]
+#[macro_export]
+macro_rules! main {
+    ( year $year: expr; $( $tail: tt )* ) => {
+        $crate::base_main! { year $year; $( $tail )* }
 
-            for (i, day) in opt.days.iter().enumerate() {
-                parse! {
-                    run_day { i, format!("day{}", day), YEAR, opt };
-                    $( $tail )*
-                };
-            }
-        }
+        use $crate::criterion::Criterion;
 
         fn bench() {
             let mut criterion = Criterion::default().configure_from_args();
@@ -109,5 +126,17 @@ macro_rules! main {
 
             criterion.final_summary();
         }
-    };
+    }
+}
+
+#[cfg(not(feature = "bench"))]
+#[macro_export]
+macro_rules! main {
+    ( year $year: expr; $( $tail: tt )* ) => {
+        $crate::base_main! { year $year; $( $tail )* }
+
+        fn bench() {
+            println!("Benchmarks not available, please enable `bench` feature for cargo-main.");
+        }
+    }
 }