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
|
// TODO: tests
use std::path::Path;
use crate::Capabilities;
#[cfg(windows)]
impl Default for Capabilities {
fn default() -> Self {
Capabilities {
precompose_unicode: false,
ignore_case: true,
executable_bit: false,
symlink: false,
}
}
}
#[cfg(target_os = "macos")]
impl Default for Capabilities {
fn default() -> Self {
Capabilities {
precompose_unicode: true,
ignore_case: true,
executable_bit: true,
symlink: true,
}
}
}
#[cfg(all(unix, not(target_os = "macos")))]
impl Default for Capabilities {
fn default() -> Self {
Capabilities {
precompose_unicode: false,
ignore_case: false,
executable_bit: true,
symlink: true,
}
}
}
impl Capabilities {
/// try to determine all values in this context by probing them in the given `git_dir`, which
/// should be on the file system the git repository is located on.
/// `git_dir` is a typical git repository, expected to be populated with the typical files like `config`.
///
/// All errors are ignored and interpreted on top of the default for the platform the binary is compiled for.
pub fn probe(git_dir: &Path) -> Self {
let ctx = Capabilities::default();
Capabilities {
symlink: Self::probe_symlink(git_dir).unwrap_or(ctx.symlink),
ignore_case: Self::probe_ignore_case(git_dir).unwrap_or(ctx.ignore_case),
precompose_unicode: Self::probe_precompose_unicode(git_dir).unwrap_or(ctx.precompose_unicode),
executable_bit: Self::probe_file_mode(git_dir).unwrap_or(ctx.executable_bit),
}
}
#[cfg(unix)]
fn probe_file_mode(root: &Path) -> std::io::Result<bool> {
use std::os::unix::fs::{MetadataExt, OpenOptionsExt};
// test it exactly as we typically create executable files, not using chmod.
let test_path = root.join("_test_executable_bit");
let res = std::fs::OpenOptions::new()
.create_new(true)
.write(true)
.mode(0o777)
.open(&test_path)
.and_then(|f| f.metadata().map(|m| m.mode() & 0o100 == 0o100));
std::fs::remove_file(test_path)?;
res
}
#[cfg(not(unix))]
fn probe_file_mode(_root: &Path) -> std::io::Result<bool> {
Ok(false)
}
fn probe_ignore_case(git_dir: &Path) -> std::io::Result<bool> {
std::fs::metadata(git_dir.join("cOnFiG")).map(|_| true).or_else(|err| {
if err.kind() == std::io::ErrorKind::NotFound {
Ok(false)
} else {
Err(err)
}
})
}
fn probe_precompose_unicode(root: &Path) -> std::io::Result<bool> {
let precomposed = "ä";
let decomposed = "a\u{308}";
let precomposed = root.join(precomposed);
std::fs::OpenOptions::new()
.create_new(true)
.write(true)
.open(&precomposed)?;
let res = root.join(decomposed).symlink_metadata().map(|_| true);
std::fs::remove_file(precomposed)?;
res
}
fn probe_symlink(root: &Path) -> std::io::Result<bool> {
let src_path = root.join("__link_src_file");
std::fs::OpenOptions::new()
.create_new(true)
.write(true)
.open(&src_path)?;
let link_path = root.join("__file_link");
if crate::symlink::create(&src_path, &link_path).is_err() {
std::fs::remove_file(&src_path)?;
return Ok(false);
}
let res = std::fs::symlink_metadata(&link_path).map(|m| m.file_type().is_symlink());
let cleanup = crate::symlink::remove(&link_path).or_else(|_| std::fs::remove_file(&link_path));
std::fs::remove_file(&src_path).and(cleanup)?;
res
}
}
|
