d2o 0.1.1

Help to Options - Parse help or manpage texts and generate shell completion scripts
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

pub mod cache;
pub mod cli;
pub mod generators;
pub mod io_handler;
pub mod json_gen;
pub mod layout;
pub mod parser;
pub mod postprocessor;
pub mod subcommand_parser;
pub mod types;

pub use cache::{Cache, CacheEntry, CacheStats, DEFAULT_TTL_SECS};
pub use cli::{Cli, Shell};
pub use generators::{
    BashGenerator, ElvishGenerator, FishGenerator, NushellGenerator, ZshGenerator,
};
pub use io_handler::IoHandler;
pub use json_gen::JsonGenerator;
pub use layout::Layout;
pub use parser::Parser;
pub use postprocessor::Postprocessor;
pub use subcommand_parser::SubcommandParser;
pub use types::*;

use shadow_rs::shadow;
shadow!(build);

/// Get the clap Command with long_version set from shadow-rs build info.
pub fn command_with_version() -> clap::Command {
    use clap::CommandFactory;
    Cli::command().long_version(build::CLAP_LONG_VERSION)
}

#[cfg(test)]
mod h2o_compat_tests {
    use super::*;

    #[test]
    fn h2o_json_schema_compatible() {
        let data = std::fs::read_to_string("tests/golden/h2o.json").expect("read h2o.json");
        let cmd: Command = serde_json::from_str(&data).expect("parse h2o Command JSON");

        assert_eq!(cmd.name, "h2o");
        assert_eq!(cmd.description, "h2o");
        assert!(cmd.usage.contains("--command"));
        assert!(!cmd.options.is_empty());
    }

    #[test]
    fn stack_json_schema_compatible() {
        let data = std::fs::read_to_string("tests/golden/stack.json").expect("read stack.json");
        let cmd: Command = serde_json::from_str(&data).expect("parse stack Command JSON");

        assert_eq!(cmd.name, "stack");
        assert_eq!(cmd.description, "stack");
        assert!(cmd.usage.contains("stack [--help]"));
        assert!(!cmd.options.is_empty());
        assert!(!cmd.subcommands.is_empty());
    }

    #[test]
    fn h2o_json_roundtrip_preserves_structure() {
        use serde_json::Value;

        let data = std::fs::read_to_string("tests/golden/h2o.json").expect("read h2o.json");
        let original: Value = serde_json::from_str(&data).expect("parse original h2o JSON");
        let cmd: Command = serde_json::from_str(&data).expect("parse h2o Command JSON");

        let generated_str = JsonGenerator::generate(&cmd);
        let generated: Value =
            serde_json::from_str(&generated_str).expect("parse generated h2o JSON");

        assert_eq!(original["name"], generated["name"]);
        assert_eq!(original["description"], generated["description"]);
        assert_eq!(original["usage"], generated["usage"]);
        assert_eq!(original["version"], generated["version"]);

        let orig_opts = original["options"].as_array().expect("options array");
        let gen_opts = generated["options"].as_array().expect("options array");
        assert_eq!(orig_opts.len(), gen_opts.len());

        for (o, g) in orig_opts.iter().zip(gen_opts.iter()) {
            assert_eq!(o["names"], g["names"], "option names differ");
            assert_eq!(o["argument"], g["argument"], "option argument differs");
            assert_eq!(
                o["description"], g["description"],
                "option description differs"
            );
        }
    }

    #[test]
    fn stack_json_roundtrip_preserves_top_level_invariants() {
        use serde_json::Value;

        let data = std::fs::read_to_string("tests/golden/stack.json").expect("read stack.json");
        let original: Value = serde_json::from_str(&data).expect("parse original stack JSON");
        let cmd: Command = serde_json::from_str(&data).expect("parse stack Command JSON");

        let generated_str = JsonGenerator::generate(&cmd);
        let generated: Value =
            serde_json::from_str(&generated_str).expect("parse generated stack JSON");

        assert_eq!(original["name"], generated["name"]);
        assert_eq!(original["description"], generated["description"]);
        assert_eq!(original["usage"], generated["usage"]);

        let orig_opts = original["options"].as_array().expect("options array");
        let gen_opts = generated["options"].as_array().expect("options array");
        assert_eq!(orig_opts.len(), gen_opts.len());

        for (o, g) in orig_opts.iter().zip(gen_opts.iter()) {
            assert_eq!(o["names"], g["names"], "option names differ");
            assert_eq!(o["argument"], g["argument"], "option argument differs");
            assert_eq!(
                o["description"], g["description"],
                "option description differs"
            );
        }

        let orig_subs = original["subcommands"]
            .as_array()
            .expect("subcommands array");
        let gen_subs = generated["subcommands"]
            .as_array()
            .expect("subcommands array");
        assert_eq!(orig_subs.len(), gen_subs.len());

        for (o, g) in orig_subs.iter().zip(gen_subs.iter()) {
            assert_eq!(o["name"], g["name"], "subcommand name differs");
            assert_eq!(
                o["description"], g["description"],
                "subcommand description differs"
            );
        }
    }
}