codegenr 0.0.2

Fast json/yaml/openapi code generator based on handlebars templating.
Documentation 
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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use crate::Options;
use serde_json::Value;
use std::{collections::HashMap, fs::read_to_string};
use structopt::StructOpt;

pub const CODEGENR_CONFIG_FILE: &str = "codegenr.toml";

//https://docs.rs/structopt/latest/structopt/#specifying-argument-types
#[derive(StructOpt, Debug)]
#[structopt(name = "codegenr")]
pub struct Opt {
  // todo later
  // #[structopt(
  //   long,
  //   short,
  //   help = "If set, codegenr keeps running and watch for all concerned files change. And then re-run the generation.",
  //   global = true
  // )]
  // pub watch: bool,
  #[structopt(subcommand)]
  pub cmd: Option<Command>,
}

#[derive(StructOpt, Debug)]
#[structopt(about = "Commands")]
pub enum Command {
  #[structopt(name = "file", help = "Executes all generations from a config file.")]
  FromFile {
    #[structopt(
        long,
        help = "Path to a full codegenr configuration file. If existing, all other command line parameters are ignored",
        default_value = CODEGENR_CONFIG_FILE
      )]
    file: String,
  },
  #[structopt(name = "gen", help = "Executes one generation from command line parameters.")]
  FromLine {
    #[structopt(long, short, help = "Source json/yaml/openapi file.")]
    source: String,
    #[structopt(long, short, help = "Output folder.")]
    output: String,
    #[structopt(
      long,
      short,
      help = "Templates folder(s), in which only one .hbs file should have no `_` as prefix (Underscored templates are partial templates)."
    )]
    templates: Vec<String>,
    #[structopt(
      long,
      short,
      help = "Optional path to a file where the intermediate json representation of resolved source(s) will be output. 
        The resolved json will be output as <file>.resolved.json, the full text rendered result will be output as <file>.rendered.txt."
    )]
    intermediate: Option<String>,
    #[structopt(long, short, help = "Path to custom helper files.")]
    custom_helpers: Vec<String>,
    #[structopt(
        long,
        short,
        help = "Global parameters values formatted `key=value`. Values will be parsed as json or strings if the json parsing fails.",
        parse(try_from_str = parse_key_val)
      )]
    global_parameters: Vec<(String, serde_json::Value)>,
  },
}

impl Default for Command {
  fn default() -> Self {
    Self::FromFile {
      file: CODEGENR_CONFIG_FILE.into(),
    }
  }
}

// From here: https://github.com/TeXitoi/structopt/blob/master/examples/keyvalue.rs
// Parse a single key-value pair
fn parse_key_val(s: &str) -> Result<(String, Value), anyhow::Error> {
  let pos = s
    .find('=')
    .ok_or_else(|| anyhow::anyhow!("Invalid key=value: no `=` found in `{}`.", s))?;
  let value = &s[pos + 1..];
  Ok((
    s[..pos].parse()?,
    value.parse().unwrap_or_else(|_| Value::String(value.to_string())),
  ))
}

impl TryFrom<Command> for HashMap<String, Options> {
  type Error = anyhow::Error;

  fn try_from(cmd: Command) -> Result<Self, Self::Error> {
    match cmd {
      Command::FromFile { file } => {
        let config = read_to_string(&file).map_err(|e| {
          anyhow::anyhow!(
            "Unable to read `{}` file: `{}`. Did you run codegenr in the right directory ?",
            file,
            e
          )
        })?;
        let opts: HashMap<String, Options> =
          toml::from_str(&config).map_err(|e| anyhow::anyhow!("Unable to deserialize `{}` config file: `{}`.", file, e))?;
        Ok(opts)
      }
      Command::FromLine {
        source,
        output,
        templates,
        intermediate,
        custom_helpers,
        global_parameters,
      } => {
        let options = Options {
          source,
          output,
          templates,
          intermediate,
          custom_helpers,
          global_parameters: global_parameters.into_iter().collect(),
        };
        let map = HashMap::<String, Options>::from_iter(std::iter::once(("command_line".into(), options)));
        Ok(map)
      }
    }
  }
}