CLI Interface for fake-rs

.github/workflows/rust.yml

@@ -3,8 +3,16 @@ name: Rust
 on:
   push:
     branches: [ master ]
+    paths:
+      - "**.rs"
+      - "**/Cargo.toml"
+      - ".github/workflows/**"
   pull_request:
     branches: [ master ]
+    paths:  
+      - "**.rs"
+      - "**/Cargo.toml"
+      - ".github/workflows/**"
 
 jobs:
   build:
@@ -53,4 +61,19 @@ jobs:
       - uses: actions-rs/cargo@v1
         with:
           command: clippy
-          args: --workspace --tests --examples -- -D warnings
+          args: --workspace --tests --examples -- -D warnings
+  cli:
+    name: Fake-CLI
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --release --bin fake --features clap
+      - name: Upload Bin Artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: fake
+          path: target/release/fake
+

README.md

@@ -4,7 +4,7 @@
 [![Docs Status](https://docs.rs/fake/badge.svg)](https://docs.rs/fake)
 [![Latest Version](https://img.shields.io/crates/v/fake.svg)](https://crates.io/crates/fake)
 
-A Rust library for generating fake data.
+A Rust library and command line tool for generating fake data.
 
 ## Installation
 
@@ -15,7 +15,7 @@ Default:
 fake = { version = "3.0.1", features = ["derive"] }
 ```
 
-Available features:
+Available library features:
 
 - `derive`: if you want to use `#[derive(Dummy)]`
 - supported crates feature flags:
@@ -40,6 +40,7 @@ Available features:
 
 ## Usage
 
+### In rust code
 ```rust
 use fake::{Dummy, Fake, Faker};
 use rand::rngs::StdRng;
@@ -107,6 +108,24 @@ fn main() {
 }
 ```
 
+## Command line
+```shell
+Usage: cli [OPTIONS] [COMMAND]
+
+Commands:
+  Name        
+  FirstName   
+  CityPrefix  
+  Password    
+  help
+
+Options:
+  -r, --repeat <repeat>  [default: 1]
+  -l, --locale <locale>  [default: EN]
+  -h, --help             Print help
+  -V, --version          Print version
+```
+
 # Fakers with locale
 
 ## Lorem

fake/Cargo.toml

@@ -2,7 +2,7 @@
 name = "fake"
 version = "3.0.1"
 authors = ["cksac <[email protected]>"]
-description = "An easy to use library for generating fake data like name, number, address, lorem, dates, etc."
+description = "An easy to use library and command line for generating fake data like name, number, address, lorem, dates, etc."
 keywords = ["faker", "data", "generator", "random"]
 license = "MIT OR Apache-2.0"
 readme = "README.md"
@@ -40,6 +40,7 @@ url-escape = { version = "0.1", optional = true }
 bson = { version = "2", optional = true }
 url = { version = "2", optional = true }
 indexmap = { version = "2", optional = true}
+clap = { version = "4.0.32", optional = true, features=["cargo"] }
 
 [dev-dependencies]
 chrono = { version = "0.4", features = ["clock"], default-features = false }
@@ -59,6 +60,7 @@ bigdecimal = ["bigdecimal-rs", "rust_decimal"]
 geo = ["geo-types", "num-traits"]
 http = ["dep:http", "url-escape"]
 bson_oid = ["bson"]
+clap = ["dep:clap"]
 
 [[example]]
 name = "basic"
@@ -81,3 +83,10 @@ required-features = [
 name = "usage"
 path = "examples/usage.rs"
 required-features = ["derive"]
+
+[[bin]]
+name = "fake"
+path = "src/bin/cli/main.rs"
+required-features = [
+    "clap"
+]

fake/src/bin/cli/fake_gen.rs

@@ -0,0 +1,88 @@
+use clap::{builder::StyledStr, ArgMatches};
+use fake::{faker, Fake};
+use rand::Rng;
+#[derive(Clone, Copy, Debug)]
+#[allow(non_camel_case_types)]
+pub enum AVAILABLE_LOCALES {
+    EN,
+    FR_FR,
+    ZH_TW,
+    ZH_CN,
+    JA_JP,
+    AR_SA,
+    PT_BR,
+}
+
+macro_rules! some_rules {
+    ($locale:expr, $module:ident, $fake:ident($($arg:ident)?)) => {
+
+        match $locale {
+            AVAILABLE_LOCALES::EN => {
+                let s = faker::$module::en::$fake($($arg)?);
+                Box::new(move |rng: &mut R| s.fake_with_rng(rng))
+
+            }
+            AVAILABLE_LOCALES::FR_FR => {
+                let s = faker::$module::fr_fr::$fake($($arg)?);
+                Box::new(move |rng: &mut R| s.fake_with_rng(rng))
+
+            }
+            AVAILABLE_LOCALES::ZH_TW => {
+                let s = faker::$module::zh_tw::$fake($($arg)?);
+                Box::new(move |rng: &mut R| s.fake_with_rng(rng))
+
+            }
+            AVAILABLE_LOCALES::ZH_CN => {
+                let s = faker::$module::zh_cn::$fake($($arg)?);
+                Box::new(move |rng: &mut R| s.fake_with_rng(rng))
+
+            }
+            AVAILABLE_LOCALES::AR_SA => {
+                let s = faker::$module::ar_sa::$fake($($arg)?);
+                Box::new(move |rng: &mut R| s.fake_with_rng(rng))
+
+            }
+            AVAILABLE_LOCALES::JA_JP => {
+                let s = faker::$module::ja_jp::$fake($($arg)?);
+                Box::new(move |rng: &mut R| s.fake_with_rng(rng))
+
+            }
+            AVAILABLE_LOCALES::PT_BR => {
+                let s = faker::$module::pt_br::$fake($($arg)?);
+                Box::new(move |rng: &mut R| s.fake_with_rng(rng))
+
+            }
+        }
+    };
+}
+
+pub fn fake_generator<R>(
+    matches: ArgMatches,
+    locale: AVAILABLE_LOCALES,
+    help_message: StyledStr,
+) -> Box<dyn Fn(&mut R) -> String>
+where
+    R: Rng,
+{
+    match matches.subcommand() {
+        Some(("FirstName", _)) => {
+            some_rules!(locale, name, FirstName())
+        }
+        Some(("Name", _)) => {
+            some_rules!(locale, name, Name())
+        }
+        Some(("CityPrefix", _)) => {
+            some_rules!(locale, address, CityPrefix())
+        }
+        Some(("Password", matches)) => {
+            let min = *matches.get_one::<usize>("min").unwrap();
+            let max = *matches.get_one::<usize>("max").unwrap();
+            let range = min..max;
+            some_rules!(locale, internet, Password(range))
+        }
+        _ => {
+            println!("Didn't receive subcommand\n {}", help_message);
+            std::process::exit(0)
+        }
+    }
+}

fake/src/bin/cli/main.rs

@@ -0,0 +1,81 @@
+use clap::{command, value_parser, Arg};
+use rand::Rng;
+use std::io::{self, Write};
+
+mod fake_gen;
+#[allow(non_upper_case_globals)]
+mod names;
+mod subcommands;
+
+const AVAILABLE_LOCALES: [&str; 7] = ["en", "fr_fr", "zh_tw", "zh_cn", "ja_jp", "ar_sa", "pt_br"];
+
+pub use fake_gen::{fake_generator, AVAILABLE_LOCALES};
+pub fn main() {
+    let stdout = io::stdout();
+    let mut buf_stdout = io::BufWriter::new(stdout);
+
+    let mut thread_rng = rand::thread_rng();
+    let args = cli_parser();
+
+    writeln!(
+        buf_stdout,
+        "Generating {} fakes for {:?} locale",
+        args.0.repeats, args.0.locale
+    )
+    .unwrap();
+
+    (0..args.0.repeats).for_each(|_| writeln!(buf_stdout, "{}", args.1(&mut thread_rng)).unwrap());
+}
+
+impl TryFrom<&str> for AVAILABLE_LOCALES {
+    type Error = String;
+    fn try_from(str_val: &str) -> Result<Self, Self::Error> {
+        let str_val = str_val.to_lowercase();
+        let variant =  match str_val.as_str(){
+            "en" => AVAILABLE_LOCALES::EN,
+            "fr_fr" => AVAILABLE_LOCALES::FR_FR,
+            "zh_tw" => AVAILABLE_LOCALES::ZH_TW,
+            "zh_cn" => AVAILABLE_LOCALES::ZH_CN,
+            "ja_jp" => AVAILABLE_LOCALES::JA_JP,
+            "ar_sa" => AVAILABLE_LOCALES::AR_SA,
+            "pt_br" => AVAILABLE_LOCALES::PT_BR,
+            _=> return Err(format!("{} is either an invalid locale or not yet supported.\n The supported locales are: {:?}",str_val,AVAILABLE_LOCALES))
+        };
+        Ok(variant)
+    }
+}
+
+fn cli_parser<R: Rng>() -> (Args, impl Fn(&mut R) -> String) {
+    let mut command = command!()
+        .arg(
+            Arg::new("repeat")
+                .long("repeat")
+                .short('r')
+                .default_value("1")
+                .value_parser(value_parser!(u32)),
+        )
+        .arg(
+            Arg::new("locale")
+                .short('l')
+                .long("locale")
+                .default_value("EN")
+                .value_parser(|value: &str| AVAILABLE_LOCALES::try_from(value)),
+        )
+        .subcommands(subcommands::all_fakegen_commands())
+        .arg_required_else_help(true);
+    let help_message = command.render_help();
+    let matches = command.get_matches();
+    let repeats = *matches.get_one::<u32>("repeat").unwrap();
+    let locale = matches
+        .get_one::<AVAILABLE_LOCALES>("locale")
+        .unwrap()
+        .to_owned();
+
+    let fake_gen = fake_generator::<R>(matches, locale, help_message);
+    (Args { repeats, locale }, fake_gen)
+}
+
+struct Args {
+    repeats: u32,
+    locale: AVAILABLE_LOCALES,
+}

fake/src/bin/cli/names.rs

@@ -0,0 +1 @@
+

fake/src/bin/cli/subcommands.rs

@@ -0,0 +1,30 @@
+use clap::{value_parser, Arg, Command};
+macro_rules! generate_command {
+    ($fake:literal) => {
+        Command::new($fake)
+    };
+    ($fake:literal, range, $min:literal, $max:literal) => {
+        Command::new($fake)
+            .arg(
+                Arg::new("max")
+                    .long("max")
+                    .default_value($max)
+                    .value_parser(value_parser!(usize)),
+            )
+            .arg(
+                Arg::new("min")
+                    .long("min")
+                    .default_value($min)
+                    .value_parser(value_parser!(usize)),
+            )
+    };
+}
+
+pub fn all_fakegen_commands() -> Vec<Command> {
+    vec![
+        generate_command!("Name"),
+        generate_command!("FirstName"),
+        generate_command!("CityPrefix"),
+        generate_command!("Password", range, "10", "20"),
+    ]
+}