datagen-rs-cli 0.1.0

The CLI for datagen-rs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

mod util;

use crate::util::cli_progress::{CliProgressRef, CliProgressTrait};
use clap::{Parser, Subcommand};
use datagen_rs::util::helpers::{generate_random_data, read_schema, write_json_schema};
use datagen_rs::util::types::Result;
use datagen_rs_progress_plugin::{PluginWithSchemaResult, ProgressPlugin};
use std::process::exit;

#[derive(Parser)]
#[command(author, version, about, long_about = None)]
struct CommendLineArgs {
    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand)]
enum Commands {
    /// Write the JSON schema to a file
    WriteJsonSchema { path: String },
    /// Generate random data from a schema
    Generate {
        /// The path to the schema file to use
        schema_file: String,
        /// An optional path to write the generated data to.
        /// If not specified, the data will be written to stdout.
        out_file: Option<String>,
    },
}

fn generate_data(
    schema_file: String,
    out_file: Option<String>,
    progress_bar: &CliProgressRef,
) -> Result<()> {
    let progress_bar_copy = progress_bar.clone();
    let PluginWithSchemaResult { schema, plugins } =
        ProgressPlugin::with_schema(read_schema(schema_file)?, move |current, total| {
            progress_bar_copy.increase(current, total);
        })?;

    let generated = generate_random_data(schema, Some(plugins))?;

    if let Some(out_file) = out_file {
        progress_bar.set_message("Writing results to file");
        std::fs::write(out_file, generated)?;
    } else {
        println!("{generated}");
    }

    Ok(())
}

fn main() {
    let args = CommendLineArgs::parse();

    match args.command {
        Commands::Generate {
            schema_file,
            out_file,
        } => {
            let progress_bar = CliProgressRef::default();

            let res = generate_data(schema_file, out_file, &progress_bar);
            progress_bar.finish(res.is_ok());

            if let Err(err) = res {
                eprintln!("Failed to generate data: {}", err);
                exit(1);
            }
        }
        Commands::WriteJsonSchema { path } => {
            if let Err(e) = write_json_schema(path) {
                eprintln!("Failed to write json schema: {}", e);
                exit(1);
            }
        }
    }
}