zenith-tool 0.0.0

The Zenith command-line interface (the `zenith` binary) for the design-document toolchain.
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

//! Dispatch logic for `zenith workspace`.

use std::process::ExitCode;

use crate::cli::{self, WorkspaceArgs};
use crate::commands;

pub(super) fn dispatch_workspace(args: WorkspaceArgs) -> ExitCode {
    match args.command {
        cli::WorkspaceSub::Scratch(scratch_args) => match scratch_args.command {
            cli::ScratchSub::New(a) => {
                let doc_bytes = match std::fs::read(&a.doc) {
                    Ok(b) => b,
                    Err(e) => {
                        eprintln!("error reading '{}': {}", a.doc.display(), e);
                        return ExitCode::from(2);
                    }
                };
                match commands::workspace::scratch_new(&doc_bytes, &a.doc, &a) {
                    Ok(outcome) => {
                        if let Some(w) = &outcome.warning {
                            eprintln!("warning: {w}");
                        }
                        println!("{}", outcome.id);
                        ExitCode::SUCCESS
                    }
                    Err(e) => {
                        eprintln!("{}", e);
                        ExitCode::from(2)
                    }
                }
            }
            cli::ScratchSub::List(a) => match commands::workspace::scratch_list(&a.doc, a.json) {
                Ok(out) => {
                    println!("{}", out);
                    ExitCode::SUCCESS
                }
                Err(e) => {
                    eprintln!("{}", e);
                    ExitCode::from(2)
                }
            },
            cli::ScratchSub::Show(a) => {
                match commands::workspace::scratch_show(&a.doc, &a.candidate, a.json) {
                    Ok(out) => {
                        println!("{}", out);
                        ExitCode::SUCCESS
                    }
                    Err(e) => {
                        eprintln!("{}", e);
                        ExitCode::from(2)
                    }
                }
            }
        },
        cli::WorkspaceSub::Candidate(a) => {
            match commands::workspace::candidate_set_status(&a.doc, &a.candidate, &a.status) {
                Ok(out) => {
                    println!("{}", out);
                    ExitCode::SUCCESS
                }
                Err(e) => {
                    eprintln!("{}", e);
                    ExitCode::from(2)
                }
            }
        }
        cli::WorkspaceSub::Promote(a) => {
            match commands::workspace::promote(&a.doc, &a.candidate, &a.into, &a.id_suffix) {
                Ok(out) => {
                    println!("{}", out);
                    ExitCode::SUCCESS
                }
                Err(e) => {
                    eprintln!("{}", e);
                    ExitCode::from(2)
                }
            }
        }
        cli::WorkspaceSub::Finalize(a) => match commands::workspace::finalize(&a.doc, a.json) {
            Ok(out) => {
                println!("{}", out);
                ExitCode::SUCCESS
            }
            Err(e) => {
                eprintln!("{}", e);
                ExitCode::from(2)
            }
        },
        cli::WorkspaceSub::Bundle(a) => match commands::workspace::bundle_doc(&a.doc, &a.out) {
            Ok(out) => {
                println!("{}", out);
                ExitCode::SUCCESS
            }
            Err(e) => {
                eprintln!("{}", e);
                ExitCode::from(2)
            }
        },
        cli::WorkspaceSub::Unbundle(a) => match commands::workspace::unbundle_doc(&a.bundle) {
            Ok(doc_id) => {
                println!("{}", doc_id);
                ExitCode::SUCCESS
            }
            Err(e) => {
                eprintln!("{}", e);
                ExitCode::from(2)
            }
        },
    }
}