walk.rs 87.6%

211 of 241 lines run, 38 of 61 functions · run #423 on main · run missed

//! Listing the working copy (spec §12.3): every file and symlink under the
//! root, found in parallel. `.oxy` is skipped, and so is a nested
//! repository (a directory holding `.oxy` or `.git`), which is reported
//! instead. `.oxyignore` files exclude paths with gitignore syntax, the
//! nearest file deciding; `.gitignore` and `.ignore` files count too, below
//! `.oxyignore` in the same directory (oxygen#44), so a project coming from
//! Git does not commit what Git ignored, and `.oxyignore` can still say
//! otherwise with `!`.
//!
//! Each directory is read once; a file's stat comes from its directory
//! entry, and results are gathered a directory at a time, so a tree of
//! 100 000 files costs about what its system calls cost.

use super::*;
use ignore::gitignore::{Gitignore, GitignoreBuilder};
use ignore::Match;
use std::sync::{Arc, Mutex};

/// What a stat says about a file that the working copy needs: its size,
/// modification time and executable bit.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) struct Stat {
    pub size: u64,
    pub mtime_ns: u128,
    pub exec: bool,
}

impl Stat {
    pub(crate) fn of(m: &fs::Metadata) -> Stat {
        Stat {
            size: m.len(),
            mtime_ns: super::prompt::mtime_ns(m),
            exec: super::is_executable(m),
        }
    }
}

/// What a listing found, each list in path order.
#[derive(Default)]
pub(crate) struct Listing {
    /// Regular files: path relative to the root (with `/`), full path, stat.
    pub files: Vec<(String, PathBuf, Stat)>,
    /// Symbolic links and their targets.
    pub symlinks: Vec<(String, Vec<u8>)>,
    /// Directories holding a repository of their own.
    pub nested: Vec<PathBuf>,
    /// Every directory listed (the root as ""), with its modification time
    /// read before its entries were: a later change to its entries moves
    /// the time, so a manifest that keeps these can skip reading a
    /// directory whose time has not moved.
    pub dirs: Vec<(String, u128)>,
}

/// The ignore files in force for a directory, innermost first.
#[derive(Clone, Default)]
struct Rules(Option<Arc<(Gitignore, Rules)>>);

impl Rules {
    /// The rules for `dir`, adding its own ignore files if it has any.
    fn enter(&self, dir: &Path, names: &[String]) -> Rules {
        // Later files win: .oxyignore over .ignore over .gitignore.
        let files: Vec<&str> = [".gitignore", ".ignore", ".oxyignore"]
            .into_iter()
            .filter(|f| names.iter().any(|n| n == f))
            .collect();
        if files.is_empty() {
            return self.clone();
        }
        let mut b = GitignoreBuilder::new(dir);
        for f in files {
            // An unreadable or malformed ignore file excludes nothing.
            let _ = b.add(dir.join(f));
        }
        match b.build() {
            Ok(g) if !g.is_empty() => Rules(Some(Arc::new((g, self.clone())))),
            _ => self.clone(),
        }
    }

    fn ignored(&self, path: &Path, is_dir: bool) -> bool {
        let mut at = &self.0;
        while let Some(node) = at {
            match node.0.matched(path, is_dir) {
                Match::Ignore(_) => return true,
                Match::Whitelist(_) => return false,
                Match::None => {}
            }
            at = &(node.1).0;
        }
        false
    }
}

struct Ctx<'a> {
    in_scope: &'a (dyn Fn(&str) -> bool + Sync),
    known: &'a (dyn Fn(&str) -> bool + Sync),
    out: Mutex<Listing>,
    failed: Mutex<Option<String>>,
}

/// List the working copy under `root`; files outside `in_scope` (a sparse
/// checkout's paths) are left out, though every directory is visited.
pub(crate) fn list(root: &Path, in_scope: &(dyn Fn(&str) -> bool + Sync)) -> Result<Listing> {
    list_knowing(root, in_scope, &|_| false)
}

/// [`list`], taking files `known` says are tracked without asking the
/// ignore rules, which apply to untracked paths only: on the Linux tree,
/// matching every file against its 400 `.gitignore` files cost more than
/// a manifest lookup.
pub(crate) fn list_knowing(
    root: &Path,
    in_scope: &(dyn Fn(&str) -> bool + Sync),
    known: &(dyn Fn(&str) -> bool + Sync),
) -> Result<Listing> {
    let ctx = Ctx {
        in_scope,
        known,
        out: Mutex::new(Listing::default()),
        failed: Mutex::new(None),
    };
    let root_time = fs::metadata(root)
        .map(|m| super::prompt::mtime_ns(&m))
        .unwrap_or(0);
    rayon::scope(|s| {
        visit(
            s,
            root.to_path_buf(),
            String::new(),
            root_time,
            true,
            Rules::default(),
            &ctx,
        )
    });
    if let Some(e) = ctx.failed.into_inner().unwrap_or_else(|e| e.into_inner()) {
        return fail(e);
    }
    let mut out = ctx.out.into_inner().unwrap_or_else(|e| e.into_inner());
    // In path order, as the maps built from it want.
    {
        use rayon::prelude::*;
        out.files.par_sort_unstable_by(|a, b| a.0.cmp(&b.0));
        out.symlinks.sort_unstable_by(|a, b| a.0.cmp(&b.0));
        out.dirs.sort_unstable_by(|a, b| a.0.cmp(&b.0));
        out.nested.sort_unstable();
    }
    Ok(out)
}

#[allow(clippy::too_many_arguments)]
fn visit<'s>(
    s: &rayon::Scope<'s>,
    dir: PathBuf,
    rel: String,
    mtime: u128,
    top: bool,
    rules: Rules,
    ctx: &'s Ctx<'s>,
) {
    let read = || -> std::io::Result<Vec<fs::DirEntry>> { fs::read_dir(&dir)?.collect() };
    let entries = match read() {
        Ok(e) => e,
        Err(e) => {
            ctx.failed
                .lock()
                .unwrap_or_else(|e| e.into_inner())
                .get_or_insert_with(|| format!("{}: {e}", dir.display()));
            return;
        }
    };
    let names: Vec<String> = entries
        .iter()
        .map(|e| e.file_name().to_string_lossy().into_owned())
        .collect();
    if !top && names.iter().any(|n| n == OXY_DIR || n == ".git") {
        ctx.out
            .lock()
            .unwrap_or_else(|e| e.into_inner())
            .nested
            .push(dir);
        return;
    }
    let rules = rules.enter(&dir, &names);
    let mut mine = Listing::default();
    mine.dirs.push((rel.clone(), mtime));
    for (e, name) in entries.into_iter().zip(names) {
        // `.git` is never content: a side-by-side Git repository
        // (`git.colocate`), or Git's own beside an import.
        if name == OXY_DIR || name.eq_ignore_ascii_case(".git") {
            continue;
        }
        let Ok(ft) = e.file_type() else { continue };
        let path = e.path();
        let child = if rel.is_empty() {
            name
        } else {
            format!("{rel}/{name}")
        };
        if (ft.is_dir() || !(ctx.known)(&child)) && rules.ignored(&path, ft.is_dir()) {
            continue;
        }
        if ft.is_dir() {
            let rules = rules.clone();
            // The directory's time now, before it is read.
            let time = e
                .metadata()
                .map(|m| super::prompt::mtime_ns(&m))
                .unwrap_or(0);
            s.spawn(move |s| visit(s, path, child, time, false, rules, ctx));
        } else if !(ctx.in_scope)(&child) {
        } else if ft.is_symlink() {
            match fs::read_link(&path) {
                Ok(t) => mine
                    .symlinks
                    .push((child, t.to_string_lossy().as_bytes().to_vec())),
                Err(e) => {
                    ctx.failed
                        .lock()
                        .unwrap_or_else(|e| e.into_inner())
                        .get_or_insert_with(|| format!("{}: {e}", path.display()));
                }
            }
        } else if ft.is_file() {
            match e.metadata() {
                Ok(m) => mine.files.push((child, path, Stat::of(&m))),
                Err(e) => {
                    ctx.failed
                        .lock()
                        .unwrap_or_else(|e| e.into_inner())
                        .get_or_insert_with(|| format!("{}: {e}", path.display()));
                }
            }
        }
    }
    let mut out = ctx.out.lock().unwrap_or_else(|e| e.into_inner());
    out.files.append(&mut mine.files);
    out.symlinks.append(&mut mine.symlinks);
    out.dirs.append(&mut mine.dirs);
}

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

    fn write(root: &Path, rel: &str, text: &str) {
        let p = root.join(rel);
        fs::create_dir_all(p.parent().unwrap()).unwrap();
        fs::write(p, text).unwrap();
    }

    fn listed(root: &Path, in_scope: &(dyn Fn(&str) -> bool + Sync)) -> (Vec<String>, Vec<String>) {
        let l = list(root, in_scope).unwrap();
        let mut files: Vec<String> = l.files.into_iter().map(|(r, _, _)| r).collect();
        files.extend(l.symlinks.into_iter().map(|(r, _)| r));
        files.sort();
        let mut nested: Vec<String> = l
            .nested
            .iter()
            .map(|d| {
                d.strip_prefix(root)
                    .unwrap()
                    .to_string_lossy()
                    .replace('\\', "/")
            })
            .collect();
        nested.sort();
        (files, nested)
    }

    #[test]
    fn ignore_files_nested_repositories_and_scope() {
        let dir = tempfile::tempdir().unwrap();
        let root = dir.path();
        write(root, ".oxy/config", "");
        write(root, ".oxyignore", "*.log\nbuild/\n");
        write(root, ".hidden", "");
        write(root, "a.txt", "");
        write(root, "a.log", "");
        write(root, "build/out.o", "");
        write(root, "src/main.c", "");
        write(root, "src/deep/x.log", "");
        // A nearer file overrides an outer rule, and `.ignore` counts too.
        write(root, "keep/.oxyignore", "!*.log\n");
        write(root, "keep/k.log", "");
        write(root, "other/.ignore", "secret\n");
        write(root, "other/secret", "");
        write(root, "other/public", "");
        // .gitignore counts, below .oxyignore in the same directory.
        write(root, "gitproj/.gitignore", "build/\n*.tmp\nkeep.tmp\n");
        write(root, "gitproj/.oxyignore", "!keep.tmp\n");
        write(root, "gitproj/build/out.bin", "");
        write(root, "gitproj/x.tmp", "");
        write(root, "gitproj/keep.tmp", "");
        write(root, "gitproj/src.c", "");
        // Nested repositories are reported, not entered.
        write(root, "sub/.oxy/config", "");
        write(root, "sub/inner.txt", "");
        write(root, "vendor/g/.git/HEAD", "");
        #[cfg(unix)]
        std::os::unix::fs::symlink("a.txt", root.join("link")).unwrap();

        let (files, nested) = listed(root, &|_| true);
        let mut want = vec![
            ".hidden",
            ".oxyignore",
            "a.txt",
            "gitproj/.gitignore",
            "gitproj/.oxyignore",
            "gitproj/keep.tmp",
            "gitproj/src.c",
            "keep/.oxyignore",
            "keep/k.log",
            "other/.ignore",
            "other/public",
            "src/main.c",
        ];
        if cfg!(unix) {
            want.push("link");
        }
        want.sort();
        assert_eq!(files, want);
        assert_eq!(nested, vec!["sub", "vendor/g"]);

        // A sparse scope leaves files out but still visits directories.
        let (files, _) = listed(root, &|p: &str| p.starts_with("src/"));
        assert_eq!(files, vec!["src/main.c"]);
    }
}

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

1		//! Listing the working copy (spec §12.3): every file and symlink under the
2		//! root, found in parallel. `.oxy` is skipped, and so is a nested
3		//! repository (a directory holding `.oxy` or `.git`), which is reported
4		//! instead. `.oxyignore` files exclude paths with gitignore syntax, the
5		//! nearest file deciding; `.gitignore` and `.ignore` files count too, below
6		//! `.oxyignore` in the same directory (oxygen#44), so a project coming from
7		//! Git does not commit what Git ignored, and `.oxyignore` can still say
8		//! otherwise with `!`.
9		//!
10		//! Each directory is read once; a file's stat comes from its directory
11		//! entry, and results are gathered a directory at a time, so a tree of
12		//! 100 000 files costs about what its system calls cost.
13
14		use super::*;
15		use ignore::gitignore::{Gitignore, GitignoreBuilder};
16		use ignore::Match;
17		use std::sync::{Arc, Mutex};
18
19		/// What a stat says about a file that the working copy needs: its size,
20		/// modification time and executable bit.
21		#[derive(Clone, Copy, Debug, PartialEq, Eq)]
22		pub(crate) struct Stat {
23		pub size: u64,
24		pub mtime_ns: u128,
25		pub exec: bool,
26		}
27
28		impl Stat {
29	17162×	pub(crate) fn of(m: &fs::Metadata) -> Stat {
30	17162×	Stat {
31	17162×	size: m.len(),
32	17162×	mtime_ns: super::prompt::mtime_ns(m),
33	17162×	exec: super::is_executable(m),
34	17162×	}
35	17162×	}
36		}
37
38		/// What a listing found, each list in path order.
39		#[derive(Default)]
40		pub(crate) struct Listing {
41		/// Regular files: path relative to the root (with `/`), full path, stat.
42		pub files: Vec<(String, PathBuf, Stat)>,
43		/// Symbolic links and their targets.
44		pub symlinks: Vec<(String, Vec<u8>)>,
45		/// Directories holding a repository of their own.
46		pub nested: Vec<PathBuf>,
47		/// Every directory listed (the root as ""), with its modification time
48		/// read before its entries were: a later change to its entries moves
49		/// the time, so a manifest that keeps these can skip reading a
50		/// directory whose time has not moved.
51		pub dirs: Vec<(String, u128)>,
52		}
53
54		/// The ignore files in force for a directory, innermost first.
55		#[derive(Clone, Default)]
56		struct Rules(Option<Arc<(Gitignore, Rules)>>);
57
58		impl Rules {
59		/// The rules for `dir`, adding its own ignore files if it has any.
60	3043×	fn enter(&self, dir: &Path, names: &[String]) -> Rules {
61		// Later files win: .oxyignore over .ignore over .gitignore.
62	3043×	let files: Vec<&str> = [".gitignore", ".ignore", ".oxyignore"]
63	3043×	.into_iter()
64	60977×	.filter(\|f\| names.iter().any(\|n\| n == f))
65	3043×	.collect();
66	3043×	if files.is_empty() {
67	3004×	return self.clone();
68	39×	}
69	39×	let mut b = GitignoreBuilder::new(dir);
70	41×	for f in files {
71	41×	// An unreadable or malformed ignore file excludes nothing.
72	41×	let _ = b.add(dir.join(f));
73	41×	}
74	39×	match b.build() {
75	39×	Ok(g) if !g.is_empty() => Rules(Some(Arc::new((g, self.clone())))),
76	0×	_ => self.clone(),
77		}
78	3043×	}
79
80	4272×	fn ignored(&self, path: &Path, is_dir: bool) -> bool {
81	4272×	let mut at = &self.0;
82	4370×	while let Some(node) = at {
83	164×	match node.0.matched(path, is_dir) {
84	60×	Match::Ignore(_) => return true,
85	6×	Match::Whitelist(_) => return false,
86	98×	Match::None => {}
87		}
88	98×	at = &(node.1).0;
89		}
90	4206×	false
91	4272×	}
92		}
93
94		struct Ctx<'a> {
95		in_scope: &'a (dyn Fn(&str) -> bool + Sync),
96		known: &'a (dyn Fn(&str) -> bool + Sync),
97		out: Mutex<Listing>,
98		failed: Mutex<Option<String>>,
99		}
100
101		/// List the working copy under `root`; files outside `in_scope` (a sparse
102		/// checkout's paths) are left out, though every directory is visited.
103	4×	pub(crate) fn list(root: &Path, in_scope: &(dyn Fn(&str) -> bool + Sync)) -> Result<Listing> {
104	4×	list_knowing(root, in_scope, &\|_\| false)
105	4×	}
106
107		/// [`list`], taking files `known` says are tracked without asking the
108		/// ignore rules, which apply to untracked paths only: on the Linux tree,
109		/// matching every file against its 400 `.gitignore` files cost more than
110		/// a manifest lookup.
111	2176×	pub(crate) fn list_knowing(
112	2176×	root: &Path,
113	2176×	in_scope: &(dyn Fn(&str) -> bool + Sync),
114	2176×	known: &(dyn Fn(&str) -> bool + Sync),
115	2176×	) -> Result<Listing> {
116	2176×	let ctx = Ctx {
117	2176×	in_scope,
118	2176×	known,
119	2176×	out: Mutex::new(Listing::default()),
120	2176×	failed: Mutex::new(None),
121	2176×	};
122	2176×	let root_time = fs::metadata(root)
123	2176×	.map(\|m\| super::prompt::mtime_ns(&m))
124	2176×	.unwrap_or(0);
125	2176×	rayon::scope(\|s\| {
126	2176×	visit(
127	2176×	s,
128	2176×	root.to_path_buf(),
129	2176×	String::new(),
130	2176×	root_time,
131		true,
132	2176×	Rules::default(),
133	2176×	&ctx,
134		)
135	2176×	});
136	2176×	if let Some(e) = ctx.failed.into_inner().unwrap_or_else(\|e\| e.into_inner()) {
137	0×	return fail(e);
138	2176×	}
139	2176×	let mut out = ctx.out.into_inner().unwrap_or_else(\|e\| e.into_inner());
140		// In path order, as the maps built from it want.
141		{
142		use rayon::prelude::*;
143	58939×	out.files.par_sort_unstable_by(\|a, b\| a.0.cmp(&b.0));
144	2176×	out.symlinks.sort_unstable_by(\|a, b\| a.0.cmp(&b.0));
145	2176×	out.dirs.sort_unstable_by(\|a, b\| a.0.cmp(&b.0));
146	2176×	out.nested.sort_unstable();
147		}
148	2176×	Ok(out)
149	2176×	}
150
151		#[allow(clippy::too_many_arguments)]
152	3110×	fn visit<'s>(
153	3110×	s: &rayon::Scope<'s>,
154	3110×	dir: PathBuf,
155	3110×	rel: String,
156	3110×	mtime: u128,
157	3110×	top: bool,
158	3110×	rules: Rules,
159	3110×	ctx: &'s Ctx<'s>,
160	3110×	) {
161	3110×	let read = \|\| -> std::io::Result<Vec<fs::DirEntry>> { fs::read_dir(&dir)?.collect() };
162	3110×	let entries = match read() {
163	3110×	Ok(e) => e,
164	0×	Err(e) => {
165	0×	ctx.failed
166	0×	.lock()
167	0×	.unwrap_or_else(\|e\| e.into_inner())
168	0×	.get_or_insert_with(\|\| format!("{}: {e}", dir.display()));
169	0×	return;
170		}
171		};
172	3110×	let names: Vec<String> = entries
173	3110×	.iter()
174	20495×	.map(\|e\| e.file_name().to_string_lossy().into_owned())
175	3110×	.collect();
176	13574×	if !top && names.iter().any(\|n\| n == OXY_DIR \|\| n == ".git") {
177	67×	ctx.out
178	67×	.lock()
179	67×	.unwrap_or_else(\|e\| e.into_inner())
180		.nested
181	67×	.push(dir);
182	67×	return;
183	3043×	}
184	3043×	let rules = rules.enter(&dir, &names);
185	3043×	let mut mine = Listing::default();
186	3043×	mine.dirs.push((rel.clone(), mtime));
187	20357×	for (e, name) in entries.into_iter().zip(names) {
188		// `.git` is never content: a side-by-side Git repository
189		// (`git.colocate`), or Git's own beside an import.
190	20357×	if name == OXY_DIR \|\| name.eq_ignore_ascii_case(".git") {
191	2179×	continue;
192	18178×	}
193	18178×	let Ok(ft) = e.file_type() else { continue };
194	18178×	let path = e.path();
195	18178×	let child = if rel.is_empty() {
196	4739×	name
197		} else {
198	13439×	format!("{rel}/{name}")
199		};
200	18178×	if (ft.is_dir() \|\| !(ctx.known)(&child)) && rules.ignored(&path, ft.is_dir()) {
201	60×	continue;
202	18118×	}
203	18118×	if ft.is_dir() {
204	934×	let rules = rules.clone();
205		// The directory's time now, before it is read.
206	934×	let time = e
207	934×	.metadata()
208	934×	.map(\|m\| super::prompt::mtime_ns(&m))
209	934×	.unwrap_or(0);
210	934×	s.spawn(move \|s\| visit(s, path, child, time, false, rules, ctx));
211	17184×	} else if !(ctx.in_scope)(&child) {
212	17165×	} else if ft.is_symlink() {
213	3×	match fs::read_link(&path) {
214	3×	Ok(t) => mine
215	3×	.symlinks
216	3×	.push((child, t.to_string_lossy().as_bytes().to_vec())),
217	0×	Err(e) => {
218	0×	ctx.failed
219	0×	.lock()
220	0×	.unwrap_or_else(\|e\| e.into_inner())
221	0×	.get_or_insert_with(\|\| format!("{}: {e}", path.display()));
222		}
223		}
224	17162×	} else if ft.is_file() {
225	17162×	match e.metadata() {
226	17162×	Ok(m) => mine.files.push((child, path, Stat::of(&m))),
227	0×	Err(e) => {
228	0×	ctx.failed
229	0×	.lock()
230	0×	.unwrap_or_else(\|e\| e.into_inner())
231	0×	.get_or_insert_with(\|\| format!("{}: {e}", path.display()));
232		}
233		}
234	0×	}
235		}
236	3043×	let mut out = ctx.out.lock().unwrap_or_else(\|e\| e.into_inner());
237	3043×	out.files.append(&mut mine.files);
238	3043×	out.symlinks.append(&mut mine.symlinks);
239	3043×	out.dirs.append(&mut mine.dirs);
240	3110×	}
241
242		#[cfg(test)]
243		mod tests {
244		use super::*;
245
246	22×	fn write(root: &Path, rel: &str, text: &str) {
247	22×	let p = root.join(rel);
248	22×	fs::create_dir_all(p.parent().unwrap()).unwrap();
249	22×	fs::write(p, text).unwrap();
250	22×	}
251
252	2×	fn listed(root: &Path, in_scope: &(dyn Fn(&str) -> bool + Sync)) -> (Vec<String>, Vec<String>) {
253	2×	let l = list(root, in_scope).unwrap();
254	2×	let mut files: Vec<String> = l.files.into_iter().map(\|(r, _, _)\| r).collect();
255	2×	files.extend(l.symlinks.into_iter().map(\|(r, _)\| r));
256	2×	files.sort();
257	2×	let mut nested: Vec<String> = l
258	2×	.nested
259	2×	.iter()
260	4×	.map(\|d\| {
261	4×	d.strip_prefix(root)
262	4×	.unwrap()
263	4×	.to_string_lossy()
264	4×	.replace('\\', "/")
265	4×	})
266	2×	.collect();
267	2×	nested.sort();
268	2×	(files, nested)
269	2×	}
270
271		#[test]
272	1×	fn ignore_files_nested_repositories_and_scope() {
273	1×	let dir = tempfile::tempdir().unwrap();
274	1×	let root = dir.path();
275	1×	write(root, ".oxy/config", "");
276	1×	write(root, ".oxyignore", "*.log\nbuild/\n");
277	1×	write(root, ".hidden", "");
278	1×	write(root, "a.txt", "");
279	1×	write(root, "a.log", "");
280	1×	write(root, "build/out.o", "");
281	1×	write(root, "src/main.c", "");
282	1×	write(root, "src/deep/x.log", "");
283		// A nearer file overrides an outer rule, and `.ignore` counts too.
284	1×	write(root, "keep/.oxyignore", "!*.log\n");
285	1×	write(root, "keep/k.log", "");
286	1×	write(root, "other/.ignore", "secret\n");
287	1×	write(root, "other/secret", "");
288	1×	write(root, "other/public", "");
289		// .gitignore counts, below .oxyignore in the same directory.
290	1×	write(root, "gitproj/.gitignore", "build/\n*.tmp\nkeep.tmp\n");
291	1×	write(root, "gitproj/.oxyignore", "!keep.tmp\n");
292	1×	write(root, "gitproj/build/out.bin", "");
293	1×	write(root, "gitproj/x.tmp", "");
294	1×	write(root, "gitproj/keep.tmp", "");
295	1×	write(root, "gitproj/src.c", "");
296		// Nested repositories are reported, not entered.
297	1×	write(root, "sub/.oxy/config", "");
298	1×	write(root, "sub/inner.txt", "");
299	1×	write(root, "vendor/g/.git/HEAD", "");
300		#[cfg(unix)]
301	1×	std::os::unix::fs::symlink("a.txt", root.join("link")).unwrap();
302
303	1×	let (files, nested) = listed(root, &\|_\| true);
304	1×	let mut want = vec![
305		".hidden",
306	1×	".oxyignore",
307	1×	"a.txt",
308	1×	"gitproj/.gitignore",
309	1×	"gitproj/.oxyignore",
310	1×	"gitproj/keep.tmp",
311	1×	"gitproj/src.c",
312	1×	"keep/.oxyignore",
313	1×	"keep/k.log",
314	1×	"other/.ignore",
315	1×	"other/public",
316	1×	"src/main.c",
317		];
318	1×	if cfg!(unix) {
319	1×	want.push("link");
320	1×	}
321	1×	want.sort();
322	1×	assert_eq!(files, want);
323	1×	assert_eq!(nested, vec!["sub", "vendor/g"]);
324
325		// A sparse scope leaves files out but still visits directories.
326	13×	let (files, _) = listed(root, &\|p: &str\| p.starts_with("src/"));
327	1×	assert_eq!(files, vec!["src/main.c"]);
328	1×	}
329		}

Coverage / crates/oxy-core/src/repo/walk.rs 87.6%

Keyboard