kutil 0.0.6

Kutil utilities collection
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

use clap::*;

build_info::build_info!(fn build_info);

//
// Version
//

/// Clap command to print version.
#[derive(Args, Clone, Debug)]
pub struct Version {
    /// show this help
    #[arg(long, short = 'h', action = ArgAction::Help)]
    pub help: Option<bool>,

    /// show build information
    #[arg(long)]
    build: bool,
}

impl Version {
    /// Build info.
    pub fn build_info() -> &'static build_info::BuildInfo {
        build_info()
    }

    /// Run command.
    pub fn run<ParserT>(&self)
    where
        ParserT: Parser,
    {
        let command = ParserT::command();
        if let Some(version) = command.get_version() {
            println!("{}: {}", command.get_name(), version);
        }

        if self.build {
            let build_info = build_info();

            if let Some(version_control) = &build_info.version_control
                && let Some(git) = version_control.git()
            {
                println!("\ngit-commit-id: {}", git.commit_id);
                println!("git-commit-timestamp: {}", git.commit_timestamp);

                if let Some(branch) = &git.branch {
                    println!("git-commit-branch: {}", branch);
                }

                if !git.tags.is_empty() {
                    println!("git-commit-tags: {}", git.tags.join(","));
                }

                println!("git-dirty: {}", git.dirty);
            }

            println!("\nbinary-cpu: {}", build_info.target.cpu.arch);
            println!("binary-cpu-bits: {}", build_info.target.cpu.pointer_width);
            println!("binary-cpu-endianness: {}", build_info.target.cpu.endianness.to_string().to_lowercase());

            if !build_info.target.cpu.features.is_empty() {
                println!("binary-cpu-features: {}", build_info.target.cpu.features.join(","));
            }

            println!("binary-os: {}", build_info.target.os);
            println!("binary-architecture: {}", build_info.target.triple);

            println!("\ncompilation-timestamp: {}", build_info.timestamp);
            println!("compilation-profile: {}", build_info.profile);
            println!("compilation-optimization-level: {}", build_info.optimization_level);

            println!("\ncompiler: rustc");
            println!("compiler-version: {}", build_info.compiler.version);
            println!("compiler-channel: {}", build_info.compiler.channel.to_string().to_lowercase());

            if let Some(commit_id) = &build_info.compiler.commit_id {
                println!("compiler-git-commit-id: {}", commit_id);
            }

            if let Some(commit_date) = &build_info.compiler.commit_date {
                println!("compiler-git-commit-date: {}", commit_date);
            }
        }
    }
}