etdl-cli 0.1.3

ETDL CLI: compile and validate .etdl documents with IEC 61025 fault tree and IEC 62502 event tree analysis, generating Rust for microservices
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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

use clap::{Parser, Subcommand};
use std::path::PathBuf;

#[derive(Parser)]
#[command(name = "etdl", version, about = "ETDL parser, validator, and compiler")]
struct Cli {
    #[command(subcommand)]
    command: Command,
}

#[derive(Subcommand)]
enum Command {
    Compile {
        #[arg(help = "Path to .etdl document")]
        file: PathBuf,

        #[arg(long, default_value = "rust", help = "Target language for code generation")]
        target: String,

        #[arg(long, default_value = ".", help = "Output directory for generated code")]
        out_dir: PathBuf,
    },
    Validate {
        #[arg(help = "Path(s) to .etdl document(s)")]
        files: Vec<PathBuf>,
    },
    Version,
}

fn main() {
    let cli = Cli::parse();

    match cli.command {
        Command::Compile {
            file,
            target,
            out_dir,
        } => {
            if let Err(e) = cmd_compile(&file, &target, &out_dir) {
                eprintln!("error: {}", e);
                std::process::exit(1);
            }
        }
        Command::Validate { files } => {
            let exit_code = cmd_validate(&files);
            std::process::exit(exit_code);
        }
        Command::Version => {
            println!("etdl {}", env!("CARGO_PKG_VERSION"));
        }
    }
}

fn cmd_compile(file: &PathBuf, target: &str, out_dir: &PathBuf) -> Result<(), String> {
    if target != "rust" {
        return Err(format!("unsupported target language '{}'; supported: rust", target));
    }

    let doc = etdl_parser::parse_document_from_file(file)?;

    let base_dir = file.parent().unwrap_or(std::path::Path::new("."));

    let registry = etdl_parser::load_asyncapi_imports(&doc, base_dir)?;

    let compiler = etdl_compiler::Compiler::new();
    let result = compiler.compile(&doc, &registry);

    let error_count = result.diagnostics.iter().filter(|d| d.is_error()).count();
    let warning_count = result.diagnostics.iter().filter(|d| !d.is_error()).count();

    for diag in &result.diagnostics {
        let level = if diag.is_error() { "ERROR" } else { "WARNING" };
        eprintln!("[{}] {}: {}", level, diag.code, diag.message);
    }

    if let Some(ref output) = result.rust_output {
        let stem = file.file_stem().unwrap_or_default().to_string_lossy();
        let out_path = out_dir.join(format!("{}.rs", stem));

        let out_dir_exists = out_dir.exists();
        if !out_dir_exists {
            std::fs::create_dir_all(out_dir).map_err(|e| {
                format!("cannot create output directory: {}", e)
            })?;
        }

        std::fs::write(&out_path, output).map_err(|e| {
            format!("cannot write generated code to {}: {}", out_path.display(), e)
        })?;

        println!(
            "compiled '{}' to '{}' ({} errors, {} warnings)",
            file.display(),
            out_path.display(),
            error_count,
            warning_count
        );
    } else {
        eprintln!(
            "compilation failed with {} errors and {} warnings",
            error_count, warning_count
        );
        std::process::exit(1);
    }

    Ok(())
}

fn cmd_validate(files: &[PathBuf]) -> i32 {
    let mut worst_exit = 0;

    for file in files {
        let doc = match etdl_parser::parse_document_from_file(file) {
            Ok(doc) => doc,
            Err(e) => {
                eprintln!("[ERROR] {}: {}", file.display(), e);
                worst_exit = 1;
                continue;
            }
        };

        let base_dir = file.parent().unwrap_or(std::path::Path::new("."));
        let registry = match etdl_parser::load_asyncapi_imports(&doc, base_dir) {
            Ok(registry) => registry,
            Err(e) => {
                eprintln!("[ERROR] {}: {}", file.display(), e);
                worst_exit = 1;
                continue;
            }
        };

        let compiler = etdl_compiler::Compiler::new();
        let diagnostics = compiler.validate(&doc, &registry);

        let error_count = diagnostics.iter().filter(|d| d.is_error()).count();
        let warning_count = diagnostics.iter().filter(|d| !d.is_error()).count();

        for diag in &diagnostics {
            let level = if diag.is_error() { "ERROR" } else { "WARNING" };
            println!("[{}] {}: {}", level, diag.code, diag.message);
        }

        if error_count == 0 {
            println!(
                "document '{}' is valid ({} errors, {} warnings)",
                file.display(),
                error_count,
                warning_count
            );
        } else {
            eprintln!(
                "document '{}' has {} validation errors",
                file.display(),
                error_count
            );
            worst_exit = 1;
        }
    }

    worst_exit
}