portable.rs 97.2%

104 of 107 lines run, 20 of 37 functions · run #378 on main · run missed

//! What the file system of the working copy can represent (spec §7.7),
//! and which paths of a state it cannot.
//!
//! Executable bits and symbolic links exist on Unix only; elsewhere a
//! snapshot keeps the recorded executable bit and reads a symlink written
//! out as a plain file back as the symlink. macOS and Windows file systems
//! ignore case by default and Windows forbids some names, so paths that
//! differ only in case or use such names are reported before they are
//! written.

use std::collections::BTreeMap;

/// Capabilities of the working copy's file system.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Platform {
    pub exec_bits: bool,
    pub symlinks: bool,
    pub case_insensitive: bool,
    /// Windows' name rules: reserved device names, `<>:"\|?*`, trailing dots and spaces.
    pub windows_names: bool,
}

impl Platform {
    /// The platform oxy runs on, with its default file system.
    pub fn current() -> Platform {
        Platform {
            exec_bits: cfg!(unix),
            symlinks: cfg!(unix),
            case_insensitive: cfg!(any(target_os = "macos", target_os = "windows")),
            windows_names: cfg!(target_os = "windows"),
        }
    }

    pub fn windows() -> Platform {
        Platform {
            exec_bits: false,
            symlinks: false,
            case_insensitive: true,
            windows_names: true,
        }
    }

    pub fn macos() -> Platform {
        Platform {
            exec_bits: true,
            symlinks: true,
            case_insensitive: true,
            windows_names: false,
        }
    }

    /// Problems this platform would have with these paths.
    pub fn problems<'a>(&self, paths: impl IntoIterator<Item = &'a str>) -> Vec<String> {
        let paths: Vec<&str> = paths.into_iter().collect();
        let mut out = Vec::new();
        if self.case_insensitive {
            out.extend(
                case_collisions(&paths).into_iter().map(|(a, b)| {
                    format!("{a} and {b} differ only in case; one will hide the other")
                }),
            );
        }
        if self.windows_names {
            out.extend(
                paths
                    .iter()
                    .filter_map(|p| windows_name_problem(p).map(|why| format!("{p}: {why}"))),
            );
        }
        out
    }
}

/// Pairs of paths equal but for case (including a directory's case).
pub fn case_collisions(paths: &[&str]) -> Vec<(String, String)> {
    let mut seen: BTreeMap<String, &str> = BTreeMap::new();
    let mut out = Vec::new();
    // Every prefix counts: `Docs/a` and `docs/b` put two directories in one place.
    let mut prefixes: Vec<&str> = Vec::new();
    for p in paths {
        let mut end = 0;
        for part in p.split('/') {
            end += part.len();
            prefixes.push(&p[..end]);
            end += 1;
        }
    }
    prefixes.sort();
    prefixes.dedup();
    for p in prefixes {
        let key = p.to_lowercase();
        match seen.get(&key) {
            Some(first) if *first != p => out.push((first.to_string(), p.to_string())),
            Some(_) => {}
            None => {
                seen.insert(key, p);
            }
        }
    }
    out
}

/// Why Windows would refuse a path, if it would.
pub fn windows_name_problem(path: &str) -> Option<&'static str> {
    const RESERVED: &[&str] = &[
        "CON", "PRN", "AUX", "NUL", "COM1", "COM2", "COM3", "COM4", "COM5", "COM6", "COM7", "COM8",
        "COM9", "LPT1", "LPT2", "LPT3", "LPT4", "LPT5", "LPT6", "LPT7", "LPT8", "LPT9",
    ];
    for part in path.split('/') {
        if part
            .chars()
            .any(|c| matches!(c, '<' | '>' | ':' | '"' | '\\' | '|' | '?' | '*') || (c as u32) < 32)
        {
            return Some("contains a character Windows does not allow in names");
        }
        if part.ends_with('.') || part.ends_with(' ') {
            return Some("a name ending in a dot or space cannot be created on Windows");
        }
        let stem = part.split('.').next().unwrap_or("").to_ascii_uppercase();
        if RESERVED.contains(&stem.as_str()) {
            return Some("a reserved device name on Windows");
        }
    }
    None
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn collisions_and_names() {
        assert_eq!(
            case_collisions(&["README.md", "readme.md", "src/a.rs"]),
            vec![("README.md".into(), "readme.md".into())]
        );
        assert_eq!(
            case_collisions(&["Docs/a", "docs/b"]),
            vec![("Docs".into(), "docs".into())]
        );
        assert!(case_collisions(&["a/b", "a/c", "b"]).is_empty());
        assert!(windows_name_problem("src/con.rs").is_some());
        assert!(windows_name_problem("notes/a:b.txt").is_some());
        assert!(windows_name_problem("trailing./x").is_some());
        assert!(windows_name_problem("src/console.rs").is_none());
        let w = Platform::windows();
        assert_eq!(w.problems(["A.txt", "a.txt", "aux.c"]).len(), 2);
        assert!(Platform {
            exec_bits: true,
            symlinks: true,
            case_insensitive: false,
            windows_names: false
        }
        .problems(["A", "a"])
        .is_empty());
    }
}

1		//! What the file system of the working copy can represent (spec §7.7),
2		//! and which paths of a state it cannot.
3		//!
4		//! Executable bits and symbolic links exist on Unix only; elsewhere a
5		//! snapshot keeps the recorded executable bit and reads a symlink written
6		//! out as a plain file back as the symlink. macOS and Windows file systems
7		//! ignore case by default and Windows forbids some names, so paths that
8		//! differ only in case or use such names are reported before they are
9		//! written.
10
11		use std::collections::BTreeMap;
12
13		/// Capabilities of the working copy's file system.
14		#[derive(Clone, Copy, Debug, PartialEq, Eq)]
15		pub struct Platform {
16		pub exec_bits: bool,
17		pub symlinks: bool,
18		pub case_insensitive: bool,
19		/// Windows' name rules: reserved device names, `<>:"\\|?*`, trailing dots and spaces.
20		pub windows_names: bool,
21		}
22
23		impl Platform {
24		/// The platform oxy runs on, with its default file system.
25	2774×	pub fn current() -> Platform {
26	2774×	Platform {
27	2774×	exec_bits: cfg!(unix),
28	2774×	symlinks: cfg!(unix),
29	2774×	case_insensitive: cfg!(any(target_os = "macos", target_os = "windows")),
30	2774×	windows_names: cfg!(target_os = "windows"),
31	2774×	}
32	2774×	}
33
34	8×	pub fn windows() -> Platform {
35	8×	Platform {
36	8×	exec_bits: false,
37	8×	symlinks: false,
38	8×	case_insensitive: true,
39	8×	windows_names: true,
40	8×	}
41	8×	}
42
43	1×	pub fn macos() -> Platform {
44	1×	Platform {
45	1×	exec_bits: true,
46	1×	symlinks: true,
47	1×	case_insensitive: true,
48	1×	windows_names: false,
49	1×	}
50	1×	}
51
52		/// Problems this platform would have with these paths.
53	561×	pub fn problems<'a>(&self, paths: impl IntoIterator<Item = &'a str>) -> Vec<String> {
54	561×	let paths: Vec<&str> = paths.into_iter().collect();
55	561×	let mut out = Vec::new();
56	561×	if self.case_insensitive {
57	8×	out.extend(
58	8×	case_collisions(&paths).into_iter().map(\|(a, b)\| {
59	3×	format!("{a} and {b} differ only in case; one will hide the other")
60	3×	}),
61		);
62	553×	}
63	561×	if self.windows_names {
64	7×	out.extend(
65	7×	paths
66	7×	.iter()
67	7×	.filter_map(\|p\| windows_name_problem(p).map(\|why\| format!("{p}: {why}"))),
68		);
69	554×	}
70	561×	out
71	561×	}
72		}
73
74		/// Pairs of paths equal but for case (including a directory's case).
75	11×	pub fn case_collisions(paths: &[&str]) -> Vec<(String, String)> {
76	11×	let mut seen: BTreeMap<String, &str> = BTreeMap::new();
77	11×	let mut out = Vec::new();
78		// Every prefix counts: `Docs/a` and `docs/b` put two directories in one place.
79	11×	let mut prefixes: Vec<&str> = Vec::new();
80	19×	for p in paths {
81	19×	let mut end = 0;
82	26×	for part in p.split('/') {
83	26×	end += part.len();
84	26×	prefixes.push(&p[..end]);
85	26×	end += 1;
86	26×	}
87		}
88	11×	prefixes.sort();
89	11×	prefixes.dedup();
90	23×	for p in prefixes {
91	23×	let key = p.to_lowercase();
92	23×	match seen.get(&key) {
93	5×	Some(first) if *first != p => out.push((first.to_string(), p.to_string())),
94	0×	Some(_) => {}
95	18×	None => {
96	18×	seen.insert(key, p);
97	18×	}
98		}
99		}
100	11×	out
101	11×	}
102
103		/// Why Windows would refuse a path, if it would.
104	11×	pub fn windows_name_problem(path: &str) -> Option<&'static str> {
105		const RESERVED: &[&str] = &[
106		"CON", "PRN", "AUX", "NUL", "COM1", "COM2", "COM3", "COM4", "COM5", "COM6", "COM7", "COM8",
107		"COM9", "LPT1", "LPT2", "LPT3", "LPT4", "LPT5", "LPT6", "LPT7", "LPT8", "LPT9",
108		];
109	15×	for part in path.split('/') {
110	15×	if part
111	15×	.chars()
112	82×	.any(\|c\| matches!(c, '<' \| '>' \| ':' \| '"' \| '\\' \| '\|' \| '?' \| '*') \|\| (c as u32) < 32)
113		{
114	1×	return Some("contains a character Windows does not allow in names");
115	14×	}
116	14×	if part.ends_with('.') \|\| part.ends_with(' ') {
117	1×	return Some("a name ending in a dot or space cannot be created on Windows");
118	13×	}
119	13×	let stem = part.split('.').next().unwrap_or("").to_ascii_uppercase();
120	13×	if RESERVED.contains(&stem.as_str()) {
121	3×	return Some("a reserved device name on Windows");
122	10×	}
123		}
124	6×	None
125	11×	}
126
127		#[cfg(test)]
128		mod tests {
129		use super::*;
130
131		#[test]
132	1×	fn collisions_and_names() {
133	1×	assert_eq!(
134	1×	case_collisions(&["README.md", "readme.md", "src/a.rs"]),
135	1×	vec![("README.md".into(), "readme.md".into())]
136		);
137	1×	assert_eq!(
138	1×	case_collisions(&["Docs/a", "docs/b"]),
139	1×	vec![("Docs".into(), "docs".into())]
140		);
141	1×	assert!(case_collisions(&["a/b", "a/c", "b"]).is_empty());
142	1×	assert!(windows_name_problem("src/con.rs").is_some());
143	1×	assert!(windows_name_problem("notes/a:b.txt").is_some());
144	1×	assert!(windows_name_problem("trailing./x").is_some());
145	1×	assert!(windows_name_problem("src/console.rs").is_none());
146	1×	let w = Platform::windows();
147	1×	assert_eq!(w.problems(["A.txt", "a.txt", "aux.c"]).len(), 2);
148	1×	assert!(Platform {
149	1×	exec_bits: true,
150	1×	symlinks: true,
151	1×	case_insensitive: false,
152	1×	windows_names: false
153	1×	}
154	1×	.problems(["A", "a"])
155	1×	.is_empty());
156	1×	}
157		}

`/`	Search
`g` `c`	Code
`g` `h`	History
`g` `b`	Bookmarks
`g` `t`	Trust
`y`	Permalink to this state (files and trees)
`?`	This sheet

Coverage / crates/oxy-core/src/portable.rs 97.2%

Keyboard