packslip 1.0.1

A vendor-neutral signed release manifest: what shipped, and how to verify it
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

//! Glue for the binary: turn a usage-rs parse result into either the parsed
//! command or the help, version, or failure text a user expects, with
//! clap's exit codes.

use std::ffi::{OsStr, OsString};

use eyre::Result;
use usage_rs::RunWith;

/// Borrow `argv` as the slice of `OsStr` that usage-rs parses.
pub fn argv(args: &[OsString]) -> Vec<&OsStr> {
    args.iter().map(OsString::as_os_str).collect()
}

/// Unwrap a parse result, or print help, version, or a usage failure and exit.
///
/// `argv` is the full command line including the program name at index 0.
/// Exit codes follow clap: 0 for help and version, 2 for a usage error.
pub fn unwrap_or_exit<T>(
    spec: &usage_rs::spec::Spec<'_>,
    argv: &[&OsStr],
    result: Result<T, usage_rs::Error<'_, '_>>,
) -> T {
    match result {
        Ok(cli) => cli,
        Err(err) => exit_with_usage_error(spec, argv.get(1..).unwrap_or_default(), err),
    }
}

fn exit_with_usage_error(
    spec: &usage_rs::spec::Spec<'_>,
    args: &[&OsStr],
    err: usage_rs::Error<'_, '_>,
) -> ! {
    match err {
        usage_rs::Error::Help { cmd, long } => {
            if let Some(page) = usage_rs::help::render(spec, cmd, long) {
                print!("{page}");
            }
            std::process::exit(0)
        }
        usage_rs::Error::HelpAll { cmd } => {
            if let Some(page) = usage_rs::help::render_all(spec, cmd) {
                print!("{page}");
            }
            std::process::exit(0)
        }
        usage_rs::Error::MissingArgsHelp { cmd } => {
            if let Some(page) = usage_rs::help::render(spec, cmd, false) {
                eprint!("{page}");
            }
            std::process::exit(2)
        }
        usage_rs::Error::Version { long } => {
            let version = if long {
                spec.long_version.or(spec.version)
            } else {
                spec.version
            }
            .unwrap_or_default();
            println!("{} {version}", spec.name);
            std::process::exit(0)
        }
        err => {
            eprint!("{}", usage_rs::render_failure(spec, args, &err));
            std::process::exit(2)
        }
    }
}

/// Show the version
#[derive(Debug, usage_rs::Args)]
#[usage(visible_alias = "v")]
pub struct Version {
    /// Print as JSON
    #[usage(short = 'J', long)]
    json: bool,
}

/// The binary's identity, handed to commands that print it.
#[derive(Debug, Clone, Copy)]
pub struct BinInfo {
    pub name: &'static str,
    pub version: &'static str,
}

impl AsRef<BinInfo> for BinInfo {
    fn as_ref(&self) -> &BinInfo {
        self
    }
}

impl<Ctx: AsRef<BinInfo>> RunWith<Ctx> for Version {
    type Output = Result<()>;

    fn run_with(self, ctx: Ctx) -> Self::Output {
        let bin = ctx.as_ref();
        if self.json {
            let json = serde_json::json!({
                "name": bin.name,
                "version": bin.version,
                "os": std::env::consts::OS,
                "arch": std::env::consts::ARCH,
            });
            println!("{}", serde_json::to_string_pretty(&json)?);
        } else {
            println!("{} {}", bin.name, bin.version);
        }
        Ok(())
    }
}