geno 0.4.0

A cross-language schema compiler that generates type definitions and serialization code from a simple, declarative schema language.
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

use anyhow::{Context, bail};
use clap::Parser;
use duct::cmd;
use geno::GenoAstBuilder;
use std::{
    fs::{self, File},
    io::{Write, stdout},
    path::PathBuf,
    process::exit,
};

#[derive(Parser)]
#[command(
    name = "geno",
    version,
    about = "Geno schema compiler",
    long_about = "Geno is a schema compiler for generating source code from a schema definition."
)]
struct Cli {
    /// Input .geno file
    #[arg(value_name = "INPUT_FILE")]
    input_path: PathBuf,

    /// Output file path for the generated source code, or STDOUT if not provided
    #[arg(value_name = "OUTPUT_FILE", short = 'o', long)]
    output_path: Option<PathBuf>,

    /// Intermediate AST file path for debugging. Program will write the AST
    /// to this file in MessagePack format then exit.
    #[arg(value_name = "AST_FILE", short = 't', long)]
    ast_path: Option<PathBuf>,

    /// Output source code format (e.g. -f dart-json or -f rust-rmp)
    #[arg(value_name = "FORMAT", short = 'f', long)]
    format: Option<String>,

    #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
    extra_args: Vec<String>,
}

fn main() {
    match run() {
        Ok(code) => exit(code),
        Err(root_err) => {
            for err in root_err.chain() {
                eprintln!("error: {}", err);
            }
            exit(1);
        }
    }
}

fn run() -> anyhow::Result<i32> {
    let cli = match Cli::try_parse() {
        Ok(cli) => cli,
        Err(err) => {
            // This prints the error message from clap
            eprintln!("{}", err);
            return Ok(0);
        }
    };

    // Parse the input string into an AST
    let ast_builder = GenoAstBuilder::new(cli.input_path)?;
    let reader = |path: &_| std::fs::read_to_string(path);
    let ast = ast_builder.build(&reader)?;

    // Validate the AST
    ast.validate()?;

    // If the user specified an AST output path, write the AST to that file and exit
    if let Some(ast_path) = cli.ast_path {
        let mut file = File::create(&ast_path).context(format!(
            "Could not create AST file '{}'",
            ast_path.to_string_lossy()
        ))?;

        rmp_serde::encode::write(&mut file, &ast)
            .context("Failed to serialize AST to MessagePack")?;
        return Ok(0);
    }

    let format = match cli.format {
        Some(s) => s,
        None => bail!("No output format specified"),
    };

    let extra_args: Vec<&str> = cli.extra_args.iter().map(|s| s.as_str()).collect();
    let cmd_expr = if std::env::var("GENO_DEBUG").is_ok() {
        cmd(
            "cargo",
            itertools::concat(vec![
                vec!["run", "--bin", &format!("geno-{}", format), "--"],
                extra_args,
            ]),
        )
    } else {
        cmd(format!("geno-{}", format), extra_args)
    };
    let ast_bytes = rmp_serde::to_vec(&ast).context("Failed to serialize AST to MessagePack")?;
    let output = cmd_expr
        .stdin_bytes(ast_bytes)
        .stdout_capture()
        .read()
        .with_context(|| format!("Failed to run AST formatter '{:?}'", cmd_expr))?;

    match cli.output_path {
        Some(path) => {
            fs::write(path, output)?;
        }
        None => {
            stdout().write(output.as_bytes())?;
        }
    };

    Ok(0)
}