walk.rs 87.6%

211 of 241 lines run, 38 of 61 functions · run #266 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) {
        if name == OXY_DIR {
            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	16263×	pub(crate) fn of(m: &fs::Metadata) -> Stat {
30	16263×	Stat {
31	16263×	size: m.len(),
32	16263×	mtime_ns: super::prompt::mtime_ns(m),
33	16263×	exec: super::is_executable(m),
34	16263×	}
35	16263×	}
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	2446×	fn enter(&self, dir: &Path, names: &[String]) -> Rules {
61		// Later files win: .oxyignore over .ignore over .gitignore.
62	2446×	let files: Vec<&str> = [".gitignore", ".ignore", ".oxyignore"]
63	2446×	.into_iter()
64	56396×	.filter(\|f\| names.iter().any(\|n\| n == f))
65	2446×	.collect();
66	2446×	if files.is_empty() {
67	2407×	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	2446×	}
79
80	3983×	fn ignored(&self, path: &Path, is_dir: bool) -> bool {
81	3983×	let mut at = &self.0;
82	4081×	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	3917×	false
91	3983×	}
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	1674×	pub(crate) fn list_knowing(
112	1674×	root: &Path,
113	1674×	in_scope: &(dyn Fn(&str) -> bool + Sync),
114	1674×	known: &(dyn Fn(&str) -> bool + Sync),
115	1674×	) -> Result<Listing> {
116	1674×	let ctx = Ctx {
117	1674×	in_scope,
118	1674×	known,
119	1674×	out: Mutex::new(Listing::default()),
120	1674×	failed: Mutex::new(None),
121	1674×	};
122	1674×	let root_time = fs::metadata(root)
123	1674×	.map(\|m\| super::prompt::mtime_ns(&m))
124	1674×	.unwrap_or(0);
125	1674×	rayon::scope(\|s\| {
126	1674×	visit(
127	1674×	s,
128	1674×	root.to_path_buf(),
129	1674×	String::new(),
130	1674×	root_time,
131		true,
132	1674×	Rules::default(),
133	1674×	&ctx,
134		)
135	1674×	});
136	1674×	if let Some(e) = ctx.failed.into_inner().unwrap_or_else(\|e\| e.into_inner()) {
137	0×	return fail(e);
138	1674×	}
139	1674×	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	67372×	out.files.par_sort_unstable_by(\|a, b\| a.0.cmp(&b.0));
144	1674×	out.symlinks.sort_unstable_by(\|a, b\| a.0.cmp(&b.0));
145	1674×	out.dirs.sort_unstable_by(\|a, b\| a.0.cmp(&b.0));
146	1674×	out.nested.sort_unstable();
147		}
148	1674×	Ok(out)
149	1674×	}
150
151		#[allow(clippy::too_many_arguments)]
152	2485×	fn visit<'s>(
153	2485×	s: &rayon::Scope<'s>,
154	2485×	dir: PathBuf,
155	2485×	rel: String,
156	2485×	mtime: u128,
157	2485×	top: bool,
158	2485×	rules: Rules,
159	2485×	ctx: &'s Ctx<'s>,
160	2485×	) {
161	2485×	let read = \|\| -> std::io::Result<Vec<fs::DirEntry>> { fs::read_dir(&dir)?.collect() };
162	2485×	let entries = match read() {
163	2485×	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	2485×	let names: Vec<String> = entries
173	2485×	.iter()
174	18912×	.map(\|e\| e.file_name().to_string_lossy().into_owned())
175	2485×	.collect();
176	13417×	if !top && names.iter().any(\|n\| n == OXY_DIR \|\| n == ".git") {
177	39×	ctx.out
178	39×	.lock()
179	39×	.unwrap_or_else(\|e\| e.into_inner())
180		.nested
181	39×	.push(dir);
182	39×	return;
183	2446×	}
184	2446×	let rules = rules.enter(&dir, &names);
185	2446×	let mut mine = Listing::default();
186	2446×	mine.dirs.push((rel.clone(), mtime));
187	18830×	for (e, name) in entries.into_iter().zip(names) {
188	18830×	if name == OXY_DIR {
189	1674×	continue;
190	17156×	}
191	17156×	let Ok(ft) = e.file_type() else { continue };
192	17156×	let path = e.path();
193	17156×	let child = if rel.is_empty() {
194	3818×	name
195		} else {
196	13338×	format!("{rel}/{name}")
197		};
198	17156×	if (ft.is_dir() \|\| !(ctx.known)(&child)) && rules.ignored(&path, ft.is_dir()) {
199	60×	continue;
200	17096×	}
201	17096×	if ft.is_dir() {
202	811×	let rules = rules.clone();
203		// The directory's time now, before it is read.
204	811×	let time = e
205	811×	.metadata()
206	811×	.map(\|m\| super::prompt::mtime_ns(&m))
207	811×	.unwrap_or(0);
208	811×	s.spawn(move \|s\| visit(s, path, child, time, false, rules, ctx));
209	16285×	} else if !(ctx.in_scope)(&child) {
210	16266×	} else if ft.is_symlink() {
211	3×	match fs::read_link(&path) {
212	3×	Ok(t) => mine
213	3×	.symlinks
214	3×	.push((child, t.to_string_lossy().as_bytes().to_vec())),
215	0×	Err(e) => {
216	0×	ctx.failed
217	0×	.lock()
218	0×	.unwrap_or_else(\|e\| e.into_inner())
219	0×	.get_or_insert_with(\|\| format!("{}: {e}", path.display()));
220		}
221		}
222	16263×	} else if ft.is_file() {
223	16263×	match e.metadata() {
224	16263×	Ok(m) => mine.files.push((child, path, Stat::of(&m))),
225	0×	Err(e) => {
226	0×	ctx.failed
227	0×	.lock()
228	0×	.unwrap_or_else(\|e\| e.into_inner())
229	0×	.get_or_insert_with(\|\| format!("{}: {e}", path.display()));
230		}
231		}
232	0×	}
233		}
234	2446×	let mut out = ctx.out.lock().unwrap_or_else(\|e\| e.into_inner());
235	2446×	out.files.append(&mut mine.files);
236	2446×	out.symlinks.append(&mut mine.symlinks);
237	2446×	out.dirs.append(&mut mine.dirs);
238	2485×	}
239
240		#[cfg(test)]
241		mod tests {
242		use super::*;
243
244	22×	fn write(root: &Path, rel: &str, text: &str) {
245	22×	let p = root.join(rel);
246	22×	fs::create_dir_all(p.parent().unwrap()).unwrap();
247	22×	fs::write(p, text).unwrap();
248	22×	}
249
250	2×	fn listed(root: &Path, in_scope: &(dyn Fn(&str) -> bool + Sync)) -> (Vec<String>, Vec<String>) {
251	2×	let l = list(root, in_scope).unwrap();
252	2×	let mut files: Vec<String> = l.files.into_iter().map(\|(r, _, _)\| r).collect();
253	2×	files.extend(l.symlinks.into_iter().map(\|(r, _)\| r));
254	2×	files.sort();
255	2×	let mut nested: Vec<String> = l
256	2×	.nested
257	2×	.iter()
258	4×	.map(\|d\| {
259	4×	d.strip_prefix(root)
260	4×	.unwrap()
261	4×	.to_string_lossy()
262	4×	.replace('\\', "/")
263	4×	})
264	2×	.collect();
265	2×	nested.sort();
266	2×	(files, nested)
267	2×	}
268
269		#[test]
270	1×	fn ignore_files_nested_repositories_and_scope() {
271	1×	let dir = tempfile::tempdir().unwrap();
272	1×	let root = dir.path();
273	1×	write(root, ".oxy/config", "");
274	1×	write(root, ".oxyignore", "*.log\nbuild/\n");
275	1×	write(root, ".hidden", "");
276	1×	write(root, "a.txt", "");
277	1×	write(root, "a.log", "");
278	1×	write(root, "build/out.o", "");
279	1×	write(root, "src/main.c", "");
280	1×	write(root, "src/deep/x.log", "");
281		// A nearer file overrides an outer rule, and `.ignore` counts too.
282	1×	write(root, "keep/.oxyignore", "!*.log\n");
283	1×	write(root, "keep/k.log", "");
284	1×	write(root, "other/.ignore", "secret\n");
285	1×	write(root, "other/secret", "");
286	1×	write(root, "other/public", "");
287		// .gitignore counts, below .oxyignore in the same directory.
288	1×	write(root, "gitproj/.gitignore", "build/\n*.tmp\nkeep.tmp\n");
289	1×	write(root, "gitproj/.oxyignore", "!keep.tmp\n");
290	1×	write(root, "gitproj/build/out.bin", "");
291	1×	write(root, "gitproj/x.tmp", "");
292	1×	write(root, "gitproj/keep.tmp", "");
293	1×	write(root, "gitproj/src.c", "");
294		// Nested repositories are reported, not entered.
295	1×	write(root, "sub/.oxy/config", "");
296	1×	write(root, "sub/inner.txt", "");
297	1×	write(root, "vendor/g/.git/HEAD", "");
298		#[cfg(unix)]
299	1×	std::os::unix::fs::symlink("a.txt", root.join("link")).unwrap();
300
301	1×	let (files, nested) = listed(root, &\|_\| true);
302	1×	let mut want = vec![
303		".hidden",
304	1×	".oxyignore",
305	1×	"a.txt",
306	1×	"gitproj/.gitignore",
307	1×	"gitproj/.oxyignore",
308	1×	"gitproj/keep.tmp",
309	1×	"gitproj/src.c",
310	1×	"keep/.oxyignore",
311	1×	"keep/k.log",
312	1×	"other/.ignore",
313	1×	"other/public",
314	1×	"src/main.c",
315		];
316	1×	if cfg!(unix) {
317	1×	want.push("link");
318	1×	}
319	1×	want.sort();
320	1×	assert_eq!(files, want);
321	1×	assert_eq!(nested, vec!["sub", "vendor/g"]);
322
323		// A sparse scope leaves files out but still visits directories.
324	13×	let (files, _) = listed(root, &\|p: &str\| p.starts_with("src/"));
325	1×	assert_eq!(files, vec!["src/main.c"]);
326	1×	}
327		}

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

Keyboard