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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
use std::env;
#[macro_export]
macro_rules! get_version_info {
() => {{
let major = env!("CARGO_PKG_VERSION_MAJOR").parse::<u8>().unwrap();
let minor = env!("CARGO_PKG_VERSION_MINOR").parse::<u8>().unwrap();
let patch = env!("CARGO_PKG_VERSION_PATCH").parse::<u16>().unwrap();
let crate_name = String::from(env!("CARGO_PKG_NAME"));
let host_compiler = option_env!("RUSTC_RELEASE_CHANNEL").map(str::to_string);
let commit_hash = option_env!("GIT_HASH").map(str::to_string);
let commit_date = option_env!("COMMIT_DATE").map(str::to_string);
VersionInfo {
major,
minor,
patch,
host_compiler,
commit_hash,
commit_date,
crate_name,
}
}};
}
pub struct VersionInfo {
pub major: u8,
pub minor: u8,
pub patch: u16,
pub host_compiler: Option<String>,
pub commit_hash: Option<String>,
pub commit_date: Option<String>,
pub crate_name: String,
}
impl std::fmt::Display for VersionInfo {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let hash = self.commit_hash.clone().unwrap_or_default();
let hash_trimmed = hash.trim();
let date = self.commit_date.clone().unwrap_or_default();
let date_trimmed = date.trim();
if (hash_trimmed.len() + date_trimmed.len()) > 0 {
write!(
f,
"{} {}.{}.{} ({} {})",
self.crate_name, self.major, self.minor, self.patch, hash_trimmed, date_trimmed,
)?;
} else {
write!(f, "{} {}.{}.{}", self.crate_name, self.major, self.minor, self.patch)?;
}
Ok(())
}
}
impl std::fmt::Debug for VersionInfo {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(
f,
"VersionInfo {{ crate_name: \"{}\", major: {}, minor: {}, patch: {}",
self.crate_name, self.major, self.minor, self.patch,
)?;
if self.commit_hash.is_some() {
write!(
f,
", commit_hash: \"{}\", commit_date: \"{}\" }}",
self.commit_hash.clone().unwrap_or_default().trim(),
self.commit_date.clone().unwrap_or_default().trim()
)?;
} else {
write!(f, " }}")?;
}
Ok(())
}
}
pub fn get_commit_hash() -> Option<String> {
std::process::Command::new("git")
.args(&["rev-parse", "--short", "HEAD"])
.output()
.ok()
.and_then(|r| String::from_utf8(r.stdout).ok())
}
pub fn get_commit_date() -> Option<String> {
std::process::Command::new("git")
.args(&["log", "-1", "--date=short", "--pretty=format:%cd"])
.output()
.ok()
.and_then(|r| String::from_utf8(r.stdout).ok())
}
pub fn get_channel() -> Option<String> {
match env::var("CFG_RELEASE_CHANNEL") {
Ok(channel) => Some(channel),
Err(_) => {
match std::process::Command::new("rustc")
.arg("-V")
.output()
.ok()
.and_then(|r| String::from_utf8(r.stdout).ok())
{
Some(rustc_output) => {
if rustc_output.contains("beta") {
Some(String::from("beta"))
} else if rustc_output.contains("stable") {
Some(String::from("stable"))
} else {
Some(String::from("nightly"))
}
},
None => Some(String::from("nightly")),
}
},
}
}
#[cfg(test)]
mod test {
use super::*;
#[test]
fn test_struct_local() {
let vi = get_version_info!();
assert_eq!(vi.major, 0);
assert_eq!(vi.minor, 2);
assert_eq!(vi.patch, 0);
assert_eq!(vi.crate_name, "rustc_tools_util");
assert!(vi.commit_hash.is_none());
assert!(vi.commit_date.is_none());
}
#[test]
fn test_display_local() {
let vi = get_version_info!();
assert_eq!(vi.to_string(), "rustc_tools_util 0.2.0");
}
#[test]
fn test_debug_local() {
let vi = get_version_info!();
let s = format!("{:?}", vi);
assert_eq!(
s,
"VersionInfo { crate_name: \"rustc_tools_util\", major: 0, minor: 2, patch: 0 }"
);
}
}