neverest 0.2.0

CLI to synchronize PIM collections: mail, contact, calendar…
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

//! # JSON Schema registry
//!
//! Maps a CLI-invocation key, the command path joined with hyphens and
//! prefixed `neverest-`, to the JSON Schema of that command's `--json`
//! payload. [`JsonSchemaCommand`] writes one file per entry.
//!
//! Every entry is unconditional: the backends are feature-gated but the
//! output shapes are not, so a build with no backend describes the same
//! payloads as one with all of them.
//!
//! [`JsonSchemaCommand`]: pimalaya_cli::clap::commands::JsonSchemaCommand

use std::collections::BTreeMap;

use schemars::schema_for;
use serde_json::Value;

/// Builds the command-to-schema map consumed by `json-schema <DIR>`.
///
/// Each value describes the type the command hands to the printer. The
/// commands confirming rather than reporting are absent: they print a
/// message and have no payload to describe.
pub fn schemas() -> BTreeMap<String, Value> {
    let mut schemas = BTreeMap::new();

    macro_rules! insert {
        ($key:expr, $ty:ty) => {
            schemas.insert(
                $key.to_string(),
                serde_json::to_value(schema_for!($ty)).unwrap(),
            );
        };
    }

    insert!("neverest-check", crate::cli::check::CheckOutput);
    insert!("neverest-configure", crate::cli::configure::ConfigureOutput);
    insert!("neverest-init", crate::cli::init::InitOutput);
    insert!("neverest-sync", crate::sync::report::SyncOutput);
    insert!(
        "neverest-conflict-list",
        crate::conflict::report::ConflictListOutput
    );
    insert!(
        "neverest-conflict-show",
        crate::conflict::report::ConflictShowOutput
    );
    insert!(
        "neverest-conflict-resolve",
        crate::conflict::report::ConflictResolveOutput
    );

    schemas
}

#[cfg(test)]
mod tests {
    use clap::{Command, CommandFactory};

    use super::schemas;
    use crate::cli::main::Cli;

    /// A key naming no command is a schema nobody can ask for, which is what
    /// renaming a subcommand and forgetting the registry leaves behind.
    #[test]
    fn every_registered_key_names_a_command() {
        let mut paths = Vec::new();
        collect(&Cli::command(), String::new(), &mut paths);

        for cmd in schemas().keys() {
            assert!(paths.contains(cmd), "{cmd} names no command");
        }
    }

    /// Walks the parser, naming each subcommand by its full path joined with
    /// hyphens, as the registry keys it.
    fn collect(command: &Command, prefix: String, paths: &mut Vec<String>) {
        let path = match prefix.is_empty() {
            true => command.get_name().to_string(),
            false => format!("{prefix}-{name}", name = command.get_name()),
        };

        for sub in command.get_subcommands() {
            collect(sub, path.clone(), paths);
        }

        paths.push(path);
    }
}