comfy-git-version-macro 0.3.6

Internal macro crate for git-version.
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

use std::process::Command;

/// Remove a trailing newline from a byte string.
fn strip_trailing_newline(mut input: Vec<u8>) -> Vec<u8> {
	if input.len() > 0 && input[input.len() - 1] == b'\n' {
		input.pop();
	}
	input
}

/// Run `git describe` for the current working directory with custom flags to get version information from git.
pub fn describe_cwd() -> std::io::Result<String> {
	let cmd = Command::new("git").arg("describe").args(&["--always", "--long"]).output()?;

	let output = verbose_command_error("git describe", cmd)?;
	let output = strip_trailing_newline(output.stdout);

	Ok(String::from_utf8_lossy(&output).to_string())
}

// /// Get the git directory for the current working directory.
// pub fn git_dir_cwd() -> std::io::Result<PathBuf> {
// 	// Run git rev-parse --git-dir, and capture standard output.
// 	let cmd = Command::new("git")
// 		.args(&["rev-parse", "--git-dir"])
// 		.output()?;
//
// 	let output = verbose_command_error("git rev-parse --git-dir", cmd)?;
// 	let output = strip_trailing_newline(output.stdout);
//
// 	// Parse the output as UTF-8.
// 	let path = std::str::from_utf8(&output)
// 		.map_err(|_| std::io::Error::new(std::io::ErrorKind::Other, "invalid UTF-8 in path to .git directory"))?;
//
// 	Ok(PathBuf::from(path))
// }

// #[test]
// fn test_git_dir() {
// 	use std::path::Path;
//
// 	assert_eq!(
// 		git_dir_cwd().unwrap().canonicalize().unwrap(),
// 		Path::new(env!("CARGO_MANIFEST_DIR")).join("../.git").canonicalize().unwrap()
// 	);
// }

/// Check if a command ran successfully, and if not, return a verbose error.
fn verbose_command_error<C>(command: C, output: std::process::Output) -> std::io::Result<std::process::Output>
where
	C: std::fmt::Display,
{
	// If the command succeeded, just return the output as is.
	if output.status.success() {
		Ok(output)

	// If the command terminated with non-zero exit code, return an error.
	} else if let Some(status) = output.status.code() {
		// Include the first line of stderr in the error message, if it's valid UTF-8 and not empty.
		let message = output.stderr.splitn(2, |c| *c == b'\n').next().unwrap();
		if let Some(message) = String::from_utf8(message.to_vec()).ok().filter(|x| !x.is_empty()) {
			Err(std::io::Error::new(
				std::io::ErrorKind::Other,
				format!("{} failed with status {}: {}", command, status, message),
			))
		} else {
			Err(std::io::Error::new(
				std::io::ErrorKind::Other,
				format!("{} failed with status {}", command, status),
			))
		}

	// The command was killed by a signal.
	} else {
		// Include the signal number on Unix.
		#[cfg(target_family = "unix")]
		{
			use std::os::unix::process::ExitStatusExt;
			let signal = output.status.signal().unwrap();
			Err(std::io::Error::new(
				std::io::ErrorKind::Other,
				format!("{} killed by signal {}", command, signal),
			))
		}
		#[cfg(not(target_family = "unix"))]
		{
			Err(std::io::Error::new(
				std::io::ErrorKind::Other,
				format!("{} killed by signal", command),
			))
		}
	}
}