ever-macro 0.2.0

Helper macro for `ever`, which prints the build information with minimal boilerplate.
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
112
113
114
115
116
117
118
119
120
121
122
123
124

#![recursion_limit = "128"]

extern crate proc_macro;

mod vars;

use proc_macro::TokenStream;
use proc_macro2::Span;
use proc_macro_hack::proc_macro_hack;
use quote::quote;
use syn::{parse_macro_input, LitStr};

#[proc_macro_hack]
pub fn ever(input: TokenStream) -> TokenStream {
    let version_env = if input.is_empty() {
        LitStr::new("EVER", Span::call_site())
    } else {
        parse_macro_input!(input as LitStr)
    };

    let name = vars::package_name();
    let version = vars::package_version();
    let about = vars::package_description();
    let date = vars::build_date();
    let commit = vars::build_commit_hash();
    let user = vars::build_username();
    let host = vars::build_hostname();
    let builddir = vars::build_dir();
    let rustc = vars::rustc_version();
    let mode = vars::build_mode();
    let lock = vars::lock_file();

    let s = quote! {
        match std::env::var(#version_env).as_deref() {
            Ok("1") | Ok("true") => {

                println!(
                r#"{name} {version} ({mode}): {about}

    date:     {date}
    commit:   {commit}
    user:     {user}
    host:     {host}
    builddir: {builddir}
    rustc:    {rustc}"#,
                    name = #name,
                    version = #version,
                    about = #about,
                    date = #date,
                    commit = #commit,
                    user = #user,
                    host = #host,
                    builddir = #builddir,
                    rustc = #rustc,
                    mode = #mode,
                );

                std::process::exit(1);
            }
            Ok("dump_lock") => {
                println!("{}", #lock);
                std::process::exit(1);
            }
            _ => {}
        }
    };

    s.into()
}

#[proc_macro_hack]
pub fn package_name(_: TokenStream) -> TokenStream {
    vars::package_name().into()
}

#[proc_macro_hack]
pub fn package_version(_: TokenStream) -> TokenStream {
    vars::package_version().into()
}

#[proc_macro_hack]
pub fn package_description(_: TokenStream) -> TokenStream {
    vars::package_description().into()
}

#[proc_macro_hack]
pub fn build_date(_: TokenStream) -> TokenStream {
    vars::build_date().into()
}

#[proc_macro_hack]
pub fn build_mode(_: TokenStream) -> TokenStream {
    vars::build_mode().into()
}

#[proc_macro_hack]
pub fn build_commit_hash(_: TokenStream) -> TokenStream {
    vars::build_commit_hash().into()
}

#[proc_macro_hack]
pub fn build_username(_: TokenStream) -> TokenStream {
    vars::build_username().into()
}

#[proc_macro_hack]
pub fn build_hostname(_: TokenStream) -> TokenStream {
    vars::build_hostname().into()
}

#[proc_macro_hack]
pub fn build_dir(_: TokenStream) -> TokenStream {
    vars::build_dir().into()
}

#[proc_macro_hack]
pub fn rustc_version(_: TokenStream) -> TokenStream {
    vars::rustc_version().into()
}

#[proc_macro_hack]
pub fn lock_file(_: TokenStream) -> TokenStream {
    vars::lock_file().into()
}