From 5011dba2fda6d9d385576165799b4fbcfa16ea32 Mon Sep 17 00:00:00 2001 From: Andrew Gallant Date: Wed, 28 Aug 2019 20:21:34 -0400 Subject: ignore: remove unused parameter --- ignore/src/dir.rs | 325 +++++++++++++++++++-------------------- ignore/src/walk.rs | 437 ++++++++++++++++++++++++++--------------------------- 2 files changed, 373 insertions(+), 389 deletions(-) diff --git a/ignore/src/dir.rs b/ignore/src/dir.rs index 12201f22..e4440fc4 100644 --- a/ignore/src/dir.rs +++ b/ignore/src/dir.rs @@ -14,13 +14,13 @@ // well. use std::collections::HashMap; -use std::ffi::{OsString, OsStr}; +use std::ffi::{OsStr, OsString}; use std::path::{Path, PathBuf}; use std::sync::{Arc, RwLock}; use gitignore::{self, Gitignore, GitignoreBuilder}; -use pathutil::{is_hidden, strip_prefix}; use overrides::{self, Override}; +use pathutil::{is_hidden, strip_prefix}; use types::{self, Types}; use walk::DirEntry; use {Error, Match, PartialErrorBuilder}; @@ -152,10 +152,7 @@ impl Ignore { /// /// Note that this can only be called on an `Ignore` matcher with no /// parents (i.e., `is_root` returns `true`). This will panic otherwise. - pub fn add_parents>( - &self, - path: P, - ) -> (Ignore, Option) { + pub fn add_parents>(&self, path: P) -> (Ignore, Option) { if !self.0.opts.parents && !self.0.opts.git_ignore && !self.0.opts.git_exclude @@ -197,12 +194,11 @@ impl Ignore { errs.maybe_push(err); igtmp.is_absolute_parent = true; igtmp.absolute_base = Some(absolute_base.clone()); - igtmp.has_git = - if self.0.opts.git_ignore { - parent.join(".git").exists() - } else { - false - }; + igtmp.has_git = if self.0.opts.git_ignore { + parent.join(".git").exists() + } else { + false + }; ig = Ignore(Arc::new(igtmp)); compiled.insert(parent.as_os_str().to_os_string(), ig.clone()); } @@ -217,10 +213,7 @@ impl Ignore { /// returned if it exists. /// /// Note that all I/O errors are completely ignored. - pub fn add_child>( - &self, - dir: P, - ) -> (Ignore, Option) { + pub fn add_child>(&self, dir: P) -> (Ignore, Option) { let (ig, err) = self.add_child_path(dir.as_ref()); (Ignore(Arc::new(ig)), err) } @@ -228,64 +221,49 @@ impl Ignore { /// Like add_child, but takes a full path and returns an IgnoreInner. fn add_child_path(&self, dir: &Path) -> (IgnoreInner, Option) { let mut errs = PartialErrorBuilder::default(); - let custom_ig_matcher = - if self.0.custom_ignore_filenames.is_empty() { - Gitignore::empty() - } else { - let (m, err) = - create_gitignore( - &dir, - &self.0.custom_ignore_filenames, - self.0.opts.ignore_case_insensitive, - ); - errs.maybe_push(err); - m - }; - let ig_matcher = - if !self.0.opts.ignore { - Gitignore::empty() - } else { - let (m, err) = - create_gitignore( - &dir, - &[".ignore"], - self.0.opts.ignore_case_insensitive, - ); - errs.maybe_push(err); - m - }; - let gi_matcher = - if !self.0.opts.git_ignore { - Gitignore::empty() - } else { - let (m, err) = - create_gitignore( - &dir, - &[".gitignore"], - self.0.opts.ignore_case_insensitive, - ); - errs.maybe_push(err); - m - }; - let gi_exclude_matcher = - if !self.0.opts.git_exclude { - Gitignore::empty() - } else { - let (m, err) = - create_gitignore( - &dir, - &[".git/info/exclude"], - self.0.opts.ignore_case_insensitive, - ); - errs.maybe_push(err); - m - }; - let has_git = - if self.0.opts.git_ignore { - dir.join(".git").exists() - } else { - false - }; + let custom_ig_matcher = if self.0.custom_ignore_filenames.is_empty() { + Gitignore::empty() + } else { + let (m, err) = create_gitignore( + &dir, + &self.0.custom_ignore_filenames, + self.0.opts.ignore_case_insensitive, + ); + errs.maybe_push(err); + m + }; + let ig_matcher = if !self.0.opts.ignore { + Gitignore::empty() + } else { + let (m, err) = + create_gitignore(&dir, &[".ignore"], self.0.opts.ignore_case_insensitive); + errs.maybe_push(err); + m + }; + let gi_matcher = if !self.0.opts.git_ignore { + Gitignore::empty() + } else { + let (m, err) = + create_gitignore(&dir, &[".gitignore"], self.0.opts.ignore_case_insensitive); + errs.maybe_push(err); + m + }; + let gi_exclude_matcher = if !self.0.opts.git_exclude { + Gitignore::empty() + } else { + let (m, err) = create_gitignore( + &dir, + &[".git/info/exclude"], + self.0.opts.ignore_case_insensitive, + ); + errs.maybe_push(err); + m + }; + let has_git = if self.0.opts.git_ignore { + dir.join(".git").exists() + } else { + false + }; let ig = IgnoreInner { compiled: self.0.compiled.clone(), dir: dir.to_path_buf(), @@ -313,16 +291,16 @@ impl Ignore { let has_custom_ignore_files = !self.0.custom_ignore_filenames.is_empty(); let has_explicit_ignores = !self.0.explicit_ignores.is_empty(); - opts.ignore || opts.git_global || opts.git_ignore - || opts.git_exclude || has_custom_ignore_files - || has_explicit_ignores + opts.ignore + || opts.git_global + || opts.git_ignore + || opts.git_exclude + || has_custom_ignore_files + || has_explicit_ignores } /// Like `matched`, but works with a directory entry instead. - pub fn matched_dir_entry<'a>( - &'a self, - dent: &DirEntry, - ) -> Match> { + pub fn matched_dir_entry<'a>(&'a self, dent: &DirEntry) -> Match> { let m = self.matched(dent.path(), dent.is_dir()); if m.is_none() && self.0.opts.hidden && is_hidden(dent) { return Match::Ignore(IgnoreMatch::hidden()); @@ -334,11 +312,7 @@ impl Ignore { /// ignored or not. /// /// The match contains information about its origin. - fn matched<'a, P: AsRef>( - &'a self, - path: P, - is_dir: bool, - ) -> Match> { + fn matched<'a, P: AsRef>(&'a self, path: P, is_dir: bool) -> Match> { // We need to be careful with our path. If it has a leading ./, then // strip it because it causes nothing but trouble. let mut path = path.as_ref(); @@ -350,9 +324,11 @@ impl Ignore { // return that result immediately. Overrides have the highest // precedence. if !self.0.overrides.is_empty() { - let mat = - self.0.overrides.matched(path, is_dir) - .map(IgnoreMatch::overrides); + let mat = self + .0 + .overrides + .matched(path, is_dir) + .map(IgnoreMatch::overrides); if !mat.is_none() { return mat; } @@ -367,8 +343,7 @@ impl Ignore { } } if !self.0.types.is_empty() { - let mat = - self.0.types.matched(path, is_dir).map(IgnoreMatch::types); + let mat = self.0.types.matched(path, is_dir).map(IgnoreMatch::types); if mat.is_ignore() { return mat; } else if mat.is_whitelist() { @@ -380,61 +355,70 @@ impl Ignore { /// Performs matching only on the ignore files for this directory and /// all parent directories. - fn matched_ignore<'a>( - &'a self, - path: &Path, - is_dir: bool, - ) -> Match> { - let (mut m_custom_ignore, mut m_ignore, mut m_gi, mut m_gi_exclude, mut m_explicit) = - (Match::None, Match::None, Match::None, Match::None, Match::None); + fn matched_ignore<'a>(&'a self, path: &Path, is_dir: bool) -> Match> { + let (mut m_custom_ignore, mut m_ignore, mut m_gi, mut m_gi_exclude, mut m_explicit) = ( + Match::None, + Match::None, + Match::None, + Match::None, + Match::None, + ); let any_git = self.parents().any(|ig| ig.0.has_git); let mut saw_git = false; for ig in self.parents().take_while(|ig| !ig.0.is_absolute_parent) { if m_custom_ignore.is_none() { m_custom_ignore = - ig.0.custom_ignore_matcher.matched(path, is_dir) - .map(IgnoreMatch::gitignore); + ig.0.custom_ignore_matcher + .matched(path, is_dir) + .map(IgnoreMatch::gitignore); } if m_ignore.is_none() { m_ignore = - ig.0.ignore_matcher.matched(path, is_dir) - .map(IgnoreMatch::gitignore); + ig.0.ignore_matcher + .matched(path, is_dir) + .map(IgnoreMatch::gitignore); } if any_git && !saw_git && m_gi.is_none() { m_gi = - ig.0.git_ignore_matcher.matched(path, is_dir) - .map(IgnoreMatch::gitignore); + ig.0.git_ignore_matcher + .matched(path, is_dir) + .map(IgnoreMatch::gitignore); } if any_git && !saw_git && m_gi_exclude.is_none() { m_gi_exclude = - ig.0.git_exclude_matcher.matched(path, is_dir) - .map(IgnoreMatch::gitignore); + ig.0.git_exclude_matcher + .matched(path, is_dir) + .map(IgnoreMatch::gitignore); } saw_git = saw_git || ig.0.has_git; } if self.0.opts.parents { if let Some(abs_parent_path) = self.absolute_base() { let path = abs_parent_path.join(path); - for ig in self.parents().skip_while(|ig|!ig.0.is_absolute_parent) { + for ig in self.parents().skip_while(|ig| !ig.0.is_absolute_parent) { if m_custom_ignore.is_none() { m_custom_ignore = - ig.0.custom_ignore_matcher.matched(&path, is_dir) - .map(IgnoreMatch::gitignore); + ig.0.custom_ignore_matcher + .matched(&path, is_dir) + .map(IgnoreMatch::gitignore); } if m_ignore.is_none() { m_ignore = - ig.0.ignore_matcher.matched(&path, is_dir) - .map(IgnoreMatch::gitignore); + ig.0.ignore_matcher + .matched(&path, is_dir) + .map(IgnoreMatch::gitignore); } if any_git && !saw_git && m_gi.is_none() { m_gi = - ig.0.git_ignore_matcher.matched(&path, is_dir) - .map(IgnoreMatch::gitignore); + ig.0.git_ignore_matcher + .matched(&path, is_dir) + .map(IgnoreMatch::gitignore); } if any_git && !saw_git && m_gi_exclude.is_none() { m_gi_exclude = - ig.0.git_exclude_matcher.matched(&path, is_dir) - .map(IgnoreMatch::gitignore); + ig.0.git_exclude_matcher + .matched(&path, is_dir) + .map(IgnoreMatch::gitignore); } saw_git = saw_git || ig.0.has_git; } @@ -446,16 +430,21 @@ impl Ignore { } m_explicit = gi.matched(&path, is_dir).map(IgnoreMatch::gitignore); } - let m_global = - if any_git { - self.0.git_global_matcher - .matched(&path, is_dir) - .map(IgnoreMatch::gitignore) - } else { - Match::None - }; + let m_global = if any_git { + self.0 + .git_global_matcher + .matched(&path, is_dir) + .map(IgnoreMatch::gitignore) + } else { + Match::None + }; - m_custom_ignore.or(m_ignore).or(m_gi).or(m_gi_exclude).or(m_global).or(m_explicit) + m_custom_ignore + .or(m_ignore) + .or(m_gi) + .or(m_gi_exclude) + .or(m_global) + .or(m_explicit) } /// Returns an iterator over parent ignore matchers, including this one. @@ -535,20 +524,19 @@ impl IgnoreBuilder { /// The matcher returned won't match anything until ignore rules from /// directories are added to it. pub fn build(&self) -> Ignore { - let git_global_matcher = - if !self.opts.git_global { - Gitignore::empty() - } else { - let mut builder = GitignoreBuilder::new(""); - builder - .case_insensitive(self.opts.ignore_case_insensitive) - .unwrap(); - let (gi, err) = builder.build_global(); - if let Some(err) = err { - debug!("{}", err); - } - gi - }; + let git_global_matcher = if !self.opts.git_global { + Gitignore::empty() + } else { + let mut builder = GitignoreBuilder::new(""); + builder + .case_insensitive(self.opts.ignore_case_insensitive) + .unwrap(); + let (gi, err) = builder.build_global(); + if let Some(err) = err { + debug!("{}", err); + } + gi + }; Ignore(Arc::new(IgnoreInner { compiled: Arc::new(RwLock::new(HashMap::new())), @@ -604,9 +592,10 @@ impl IgnoreBuilder { /// later names. pub fn add_custom_ignore_filename>( &mut self, - file_name: S + file_name: S, ) -> &mut IgnoreBuilder { - self.custom_ignore_filenames.push(file_name.as_ref().to_os_string()); + self.custom_ignore_filenames + .push(file_name.as_ref().to_os_string()); self } @@ -678,10 +667,7 @@ impl IgnoreBuilder { /// Process ignore files case insensitively /// /// This is disabled by default. - pub fn ignore_case_insensitive( - &mut self, - yes: bool, - ) -> &mut IgnoreBuilder { + pub fn ignore_case_insensitive(&mut self, yes: bool) -> &mut IgnoreBuilder { self.opts.ignore_case_insensitive = yes; self } @@ -742,19 +728,21 @@ mod tests { } } - fn tmpdir(prefix: &str) -> TempDir { + fn tmpdir() -> TempDir { TempDir::new().unwrap() } #[test] fn explicit_ignore() { - let td = tmpdir("ignore-test-"); + let td = tmpdir(); wfile(td.path().join("not-an-ignore"), "foo\n!bar"); let (gi, err) = Gitignore::new(td.path().join("not-an-ignore")); assert!(err.is_none()); let (ig, err) = IgnoreBuilder::new() - .add_ignore(gi).build().add_child(td.path()); + .add_ignore(gi) + .build() + .add_child(td.path()); assert!(err.is_none()); assert!(ig.matched("foo", false).is_ignore()); assert!(ig.matched("bar", false).is_whitelist()); @@ -763,7 +751,7 @@ mod tests { #[test] fn git_exclude() { - let td = tmpdir("ignore-test-"); + let td = tmpdir(); mkdirp(td.path().join(".git/info")); wfile(td.path().join(".git/info/exclude"), "foo\n!bar"); @@ -776,7 +764,7 @@ mod tests { #[test] fn gitignore() { - let td = tmpdir("ignore-test-"); + let td = tmpdir(); mkdirp(td.path().join(".git")); wfile(td.path().join(".gitignore"), "foo\n!bar"); @@ -789,7 +777,7 @@ mod tests { #[test] fn gitignore_no_git() { - let td = tmpdir("ignore-test-"); + let td = tmpdir(); wfile(td.path().join(".gitignore"), "foo\n!bar"); let (ig, err) = IgnoreBuilder::new().build().add_child(td.path()); @@ -801,7 +789,7 @@ mod tests { #[test] fn ignore() { - let td = tmpdir("ignore-test-"); + let td = tmpdir(); wfile(td.path().join(".ignore"), "foo\n!bar"); let (ig, err) = IgnoreBuilder::new().build().add_child(td.path()); @@ -813,13 +801,14 @@ mod tests { #[test] fn custom_ignore() { - let td = tmpdir("ignore-test-"); + let td = tmpdir(); let custom_ignore = ".customignore"; wfile(td.path().join(custom_ignore), "foo\n!bar"); let (ig, err) = IgnoreBuilder::new() .add_custom_ignore_filename(custom_ignore) - .build().add_child(td.path()); + .build() + .add_child(td.path()); assert!(err.is_none()); assert!(ig.matched("foo", false).is_ignore()); assert!(ig.matched("bar", false).is_whitelist()); @@ -829,14 +818,15 @@ mod tests { // Tests that a custom ignore file will override an .ignore. #[test] fn custom_ignore_over_ignore() { - let td = tmpdir("ignore-test-"); + let td = tmpdir(); let custom_ignore = ".customignore"; wfile(td.path().join(".ignore"), "foo"); wfile(td.path().join(custom_ignore), "!foo"); let (ig, err) = IgnoreBuilder::new() .add_custom_ignore_filename(custom_ignore) - .build().add_child(td.path()); + .build() + .add_child(td.path()); assert!(err.is_none()); assert!(ig.matched("foo", false).is_whitelist()); } @@ -844,7 +834,7 @@ mod tests { // Tests that earlier custom ignore files have lower precedence than later. #[test] fn custom_ignore_precedence() { - let td = tmpdir("ignore-test-"); + let td = tmpdir(); let custom_ignore1 = ".customignore1"; let custom_ignore2 = ".customignore2"; wfile(td.path().join(custom_ignore1), "foo"); @@ -853,7 +843,8 @@ mod tests { let (ig, err) = IgnoreBuilder::new() .add_custom_ignore_filename(custom_ignore1) .add_custom_ignore_filename(custom_ignore2) - .build().add_child(td.path()); + .build() + .add_child(td.path()); assert!(err.is_none()); assert!(ig.matched("foo", false).is_whitelist()); } @@ -861,7 +852,7 @@ mod tests { // Tests that an .ignore will override a .gitignore. #[test] fn ignore_over_gitignore() { - let td = tmpdir("ignore-test-"); + let td = tmpdir(); wfile(td.path().join(".gitignore"), "foo"); wfile(td.path().join(".ignore"), "!foo"); @@ -873,7 +864,7 @@ mod tests { // Tests that exclude has lower precedent than both .ignore and .gitignore. #[test] fn exclude_lowest() { - let td = tmpdir("ignore-test-"); + let td = tmpdir(); wfile(td.path().join(".gitignore"), "!foo"); wfile(td.path().join(".ignore"), "!bar"); mkdirp(td.path().join(".git/info")); @@ -888,7 +879,7 @@ mod tests { #[test] fn errored() { - let td = tmpdir("ignore-test-"); + let td = tmpdir(); wfile(td.path().join(".gitignore"), "{foo"); let (_, err) = IgnoreBuilder::new().build().add_child(td.path()); @@ -897,7 +888,7 @@ mod tests { #[test] fn errored_both() { - let td = tmpdir("ignore-test-"); + let td = tmpdir(); wfile(td.path().join(".gitignore"), "{foo"); wfile(td.path().join(".ignore"), "{bar"); @@ -907,7 +898,7 @@ mod tests { #[test] fn errored_partial() { - let td = tmpdir("ignore-test-"); + let td = tmpdir(); mkdirp(td.path().join(".git")); wfile(td.path().join(".gitignore"), "{foo\nbar"); @@ -918,7 +909,7 @@ mod tests { #[test] fn errored_partial_and_ignore() { - let td = tmpdir("ignore-test-"); + let td = tmpdir(); wfile(td.path().join(".gitignore"), "{foo\nbar"); wfile(td.path().join(".ignore"), "!bar"); @@ -929,7 +920,7 @@ mod tests { #[test] fn not_present_empty() { - let td = tmpdir("ignore-test-"); + let td = tmpdir(); let (_, err) = IgnoreBuilder::new().build().add_child(td.path()); assert!(err.is_none()); @@ -939,7 +930,7 @@ mod tests { fn stops_at_git_dir() { // This tests that .gitignore files beyond a .git barrier aren't // matched, but .ignore files are. - let td = tmpdir("ignore-test-"); + let td = tmpdir(); mkdirp(td.path().join(".git")); mkdirp(td.path().join("foo/.git")); wfile(td.path().join(".gitignore"), "foo"); @@ -960,7 +951,7 @@ mod tests { #[test] fn absolute_parent() { - let td = tmpdir("ignore-test-"); + let td = tmpdir(); mkdirp(td.path().join(".git")); mkdirp(td.path().join("foo")); wfile(td.path().join(".gitignore"), "bar"); @@ -983,7 +974,7 @@ mod tests { #[test] fn absolute_parent_anchored() { - let td = tmpdir("ignore-test-"); + let td = tmpdir(); mkdirp(td.path().join(".git")); mkdirp(td.path().join("src/llvm")); wfile(td.path().join(".gitignore"), "/llvm/\nfoo"); diff --git a/ignore/src/walk.rs b/ignore/src/walk.rs index b3e05f08..e00b29a5 100644 --- a/ignore/src/walk.rs +++ b/ignore/src/walk.rs @@ -4,8 +4,8 @@ use std::fmt; use std::fs::{self, FileType, Metadata}; use std::io; use std::path::{Path, PathBuf}; -use std::sync::Arc; use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering}; +use std::sync::Arc; use std::thread; use std::time::Duration; use std::vec; @@ -182,14 +182,14 @@ impl DirEntryInner { match *self { Stdin => { let err = Error::Io(io::Error::new( - io::ErrorKind::Other, " has no metadata")); + io::ErrorKind::Other, + " has no metadata", + )); Err(err.with_path("")) } - Walkdir(ref x) => { - x.metadata().map_err(|err| { - Error::Io(io::Error::from(err)).with_path(x.path()) - }) - } + Walkdir(ref x) => x + .metadata() + .map_err(|err| Error::Io(io::Error::from(err)).with_path(x.path())), Raw(ref x) => x.metadata(), } } @@ -223,8 +223,8 @@ impl DirEntryInner { #[cfg(unix)] fn ino(&self) -> Option { - use walkdir::DirEntryExt; use self::DirEntryInner::*; + use walkdir::DirEntryExt; match *self { Stdin => None, Walkdir(ref x) => Some(x.ino()), @@ -297,7 +297,8 @@ impl DirEntryRaw { fs::metadata(&self.path) } else { Ok(self.metadata.clone()) - }.map_err(|err| Error::Io(io::Error::from(err)).with_path(&self.path)) + } + .map_err(|err| Error::Io(io::Error::from(err)).with_path(&self.path)) } #[cfg(not(windows))] @@ -306,7 +307,8 @@ impl DirEntryRaw { fs::metadata(&self.path) } else { fs::symlink_metadata(&self.path) - }.map_err(|err| Error::Io(io::Error::from(err)).with_path(&self.path)) + } + .map_err(|err| Error::Io(io::Error::from(err)).with_path(&self.path)) } fn file_type(&self) -> FileType { @@ -314,7 +316,9 @@ impl DirEntryRaw { } fn file_name(&self) -> &OsStr { - self.path.file_name().unwrap_or_else(|| self.path.as_os_str()) + self.path + .file_name() + .unwrap_or_else(|| self.path.as_os_str()) } fn depth(&self) -> usize { @@ -326,10 +330,7 @@ impl DirEntryRaw { self.ino } - fn from_entry( - depth: usize, - ent: &fs::DirEntry, - ) -> Result { + fn from_entry(depth: usize, ent: &fs::DirEntry) -> Result { let ty = ent.file_type().map_err(|err| { let err = Error::Io(io::Error::from(err)).with_path(ent.path()); Error::WithDepth { @@ -387,18 +388,14 @@ impl DirEntryRaw { ty: fs::FileType, ) -> Result { Err(Error::Io(io::Error::new( - io::ErrorKind::Other, "unsupported platform"))) + io::ErrorKind::Other, + "unsupported platform", + ))) } #[cfg(windows)] - fn from_path( - depth: usize, - pb: PathBuf, - link: bool, - ) -> Result { - let md = fs::metadata(&pb).map_err(|err| { - Error::Io(err).with_path(&pb) - })?; + fn from_path(depth: usize, pb: PathBuf, link: bool) -> Result { + let md = fs::metadata(&pb).map_err(|err| Error::Io(err).with_path(&pb))?; Ok(DirEntryRaw { path: pb, ty: md.file_type(), @@ -409,16 +406,10 @@ impl DirEntryRaw { } #[cfg(unix)] - fn from_path( - depth: usize, - pb: PathBuf, - link: bool, - ) -> Result { + fn from_path(depth: usize, pb: PathBuf, link: bool) -> Result { use std::os::unix::fs::MetadataExt; - let md = fs::metadata(&pb).map_err(|err| { - Error::Io(err).with_path(&pb) - })?; + let md = fs::metadata(&pb).map_err(|err| Error::Io(err).with_path(&pb))?; Ok(DirEntryRaw { path: pb, ty: md.file_type(), @@ -430,13 +421,11 @@ impl DirEntryRaw { // Placeholder implementation to allow compiling on non-standard platforms (e.g. wasm32). #[cfg(not(any(windows, unix)))] - fn from_path( - depth: usize, - pb: PathBuf, - link: bool, - ) -> Result { + fn from_path(depth: usize, pb: PathBuf, link: bool) -> Result { Err(Error::Io(io::Error::new( - io::ErrorKind::Other, "unsupported platform"))) + io::ErrorKind::Other, + "unsupported platform", + ))) } } @@ -547,33 +536,34 @@ impl WalkBuilder { let follow_links = self.follow_links; let max_depth = self.max_depth; let sorter = self.sorter.clone(); - let its = self.paths.iter().map(move |p| { - if p == Path::new("-") { - (p.to_path_buf(), None) - } else { - let mut wd = WalkDir::new(p); - wd = wd.follow_links(follow_links || p.is_file()); - wd = wd.same_file_system(self.same_file_system); - if let Some(max_depth) = max_depth { - wd = wd.max_depth(max_depth); - } - if let Some(ref sorter) = sorter { - match sorter.clone() { - Sorter::ByName(cmp) => { - wd = wd.sort_by(move |a, b| { - cmp(a.file_name(), b.file_name()) - }); - } - Sorter::ByPath(cmp) => { - wd = wd.sort_by(move |a, b| { - cmp(a.path(), b.path()) - }); + let its = self + .paths + .iter() + .map(move |p| { + if p == Path::new("-") { + (p.to_path_buf(), None) + } else { + let mut wd = WalkDir::new(p); + wd = wd.follow_links(follow_links || p.is_file()); + wd = wd.same_file_system(self.same_file_system); + if let Some(max_depth) = max_depth { + wd = wd.max_depth(max_depth); + } + if let Some(ref sorter) = sorter { + match sorter.clone() { + Sorter::ByName(cmp) => { + wd = wd.sort_by(move |a, b| cmp(a.file_name(), b.file_name())); + } + Sorter::ByPath(cmp) => { + wd = wd.sort_by(move |a, b| cmp(a.path(), b.path())); + } } } + (p.to_path_buf(), Some(WalkEventIter::from(wd))) } - (p.to_path_buf(), Some(WalkEventIter::from(wd))) - } - }).collect::>().into_iter(); + }) + .collect::>() + .into_iter(); let ig_root = self.ig_builder.build(); Walk { its: its, @@ -657,8 +647,12 @@ impl WalkBuilder { let mut errs = PartialErrorBuilder::default(); errs.maybe_push(builder.add(path)); match builder.build() { - Ok(gi) => { self.ig_builder.add_ignore(gi); } - Err(err) => { errs.push(err); } + Ok(gi) => { + self.ig_builder.add_ignore(gi); + } + Err(err) => { + errs.push(err); + } } errs.into_error_option() } @@ -671,7 +665,7 @@ impl WalkBuilder { /// later names. pub fn add_custom_ignore_filename>( &mut self, - file_name: S + file_name: S, ) -> &mut WalkBuilder { self.ig_builder.add_custom_ignore_filename(file_name); self @@ -808,11 +802,9 @@ impl WalkBuilder { /// by `sort_by_file_name`. /// /// Note that this is not used in the parallel iterator. - pub fn sort_by_file_path( - &mut self, - cmp: F, - ) -> &mut WalkBuilder - where F: Fn(&Path, &Path) -> cmp::Ordering + Send + Sync + 'static + pub fn sort_by_file_path(&mut self, cmp: F) -> &mut WalkBuilder + where + F: Fn(&Path, &Path) -> cmp::Ordering + Send + Sync + 'static, { self.sorter = Some(Sorter::ByPath(Arc::new(cmp))); self @@ -830,7 +822,8 @@ impl WalkBuilder { /// /// Note that this is not used in the parallel iterator. pub fn sort_by_file_name(&mut self, cmp: F) -> &mut WalkBuilder - where F: Fn(&OsStr, &OsStr) -> cmp::Ordering + Send + Sync + 'static + where + F: Fn(&OsStr, &OsStr) -> cmp::Ordering + Send + Sync + 'static, { self.sorter = Some(Sorter::ByName(Arc::new(cmp))); self @@ -1011,7 +1004,11 @@ enum WalkEvent { impl From for WalkEventIter { fn from(it: WalkDir) -> WalkEventIter { - WalkEventIter { depth: 0, it: it.into_iter(), next: None } + WalkEventIter { + depth: 0, + it: it.into_iter(), + next: None, + } } } @@ -1094,10 +1091,10 @@ impl WalkParallel { /// Execute the parallel recursive directory iterator. `mkf` is called /// for each thread used for iteration. The function produced by `mkf` /// is then in turn called for each visited file path. - pub fn run( - self, - mut mkf: F, - ) where F: FnMut() -> Box) -> WalkState + Send + 'static> { + pub fn run(self, mut mkf: F) + where + F: FnMut() -> Box) -> WalkState + Send + 'static>, + { let mut f = mkf(); let threads = self.threads(); // TODO: Figure out how to use a bounded channel here. With an @@ -1114,30 +1111,16 @@ impl WalkParallel { // Note that we only send directories. For files, we send to them the // callback directly. for path in self.paths { - let (dent, root_device) = - if path == Path::new("-") { - (DirEntry::new_stdin(), None) + let (dent, root_device) = if path == Path::new("-") { + (DirEntry::new_stdin(), None) + } else { + let root_device = if !self.same_file_system { + None } else { - let root_device = - if !self.same_file_system { - None - } else { - match device_num(&path) { - Ok(root_device) => Some(root_device), - Err(err) => { - let err = Error::Io(err).with_path(path); - if f(Err(err)).is_quit() { - return; - } - continue; - } - } - }; - match DirEntryRaw::from_path(0, path, false) { - Ok(dent) => { - (DirEntry::new_raw(dent, None), root_device) - } + match device_num(&path) { + Ok(root_device) => Some(root_device), Err(err) => { + let err = Error::Io(err).with_path(path); if f(Err(err)).is_quit() { return; } @@ -1145,11 +1128,22 @@ impl WalkParallel { } } }; + match DirEntryRaw::from_path(0, path, false) { + Ok(dent) => (DirEntry::new_raw(dent, None), root_device), + Err(err) => { + if f(Err(err)).is_quit() { + return; + } + continue; + } + } + }; tx.send(Message::Work(Work { dent: dent, ignore: self.ig_root.clone(), root_device: root_device, - })).unwrap(); + })) + .unwrap(); any_work = true; } // ... but there's no need to start workers if we don't need them. @@ -1341,22 +1335,21 @@ impl Worker { continue; } }; - let descend = - if let Some(root_device) = work.root_device { - match is_same_file_system(root_device, work.dent.path()) { - Ok(true) => true, - Ok(false) => false, - Err(err) => { - if (self.f)(Err(err)).is_quit() { - self.quit_now(); - return; - } - false + let descend = if let Some(root_device) = work.root_device { + match is_same_file_system(root_device, work.dent.path()) { + Ok(true) => true, + Ok(false) => false, + Err(err) => { + if (self.f)(Err(err)).is_quit() { + self.quit_now(); + return; } + false } - } else { - true - }; + } + } else { + true + }; let depth = work.dent.depth(); match (self.f)(Ok(work.dent)) { @@ -1374,12 +1367,7 @@ impl Worker { continue; } for result in readdir { - let state = self.run_one( - &work.ignore, - depth + 1, - work.root_device, - result, - ); + let state = self.run_one(&work.ignore, depth + 1, work.root_device, result); if state.is_quit() { self.quit_now(); return; @@ -1444,23 +1432,24 @@ impl Worker { } } let should_skip_path = should_skip_entry(ig, &dent); - let should_skip_filesize = - if self.max_filesize.is_some() && !dent.is_dir() { - skip_filesize( - self.max_filesize.unwrap(), - dent.path(), - &dent.metadata().ok(), - ) - } else { - false - }; + let should_skip_filesize = if self.max_filesize.is_some() && !dent.is_dir() { + skip_filesize( + self.max_filesize.unwrap(), + dent.path(), + &dent.metadata().ok(), + ) + } else { + false + }; if !should_skip_path && !should_skip_filesize { - self.tx.send(Message::Work(Work { - dent: dent, - ignore: ig.clone(), - root_device: root_device, - })).unwrap(); + self.tx + .send(Message::Work(Work { + dent: dent, + ignore: ig.clone(), + root_device: root_device, + })) + .unwrap(); } WalkState::Continue } @@ -1590,17 +1579,25 @@ fn check_symlink_loop( child_depth: usize, ) -> Result<(), Error> { let hchild = Handle::from_path(child_path).map_err(|err| { - Error::from(err).with_path(child_path).with_depth(child_depth) + Error::from(err) + .with_path(child_path) + .with_depth(child_depth) })?; - for ig in ig_parent.parents().take_while(|ig| !ig.is_absolute_parent()) { + for ig in ig_parent + .parents() + .take_while(|ig| !ig.is_absolute_parent()) + { let h = Handle::from_path(ig.path()).map_err(|err| { - Error::from(err).with_path(child_path).with_depth(child_depth) + Error::from(err) + .with_path(child_path) + .with_depth(child_depth) })?; if hchild == h { return Err(Error::Loop { ancestor: ig.path().to_path_buf(), child: child_path.to_path_buf(), - }.with_depth(child_depth)); + } + .with_depth(child_depth)); } } Ok(()) @@ -1608,14 +1605,10 @@ fn check_symlink_loop( // Before calling this function, make sure that you ensure that is really // necessary as the arguments imply a file stat. -fn skip_filesize( - max_filesize: u64, - path: &Path, - ent: &Option -) -> bool { +fn skip_filesize(max_filesize: u64, path: &Path, ent: &Option) -> bool { let filesize = match *ent { Some(ref md) => Some(md.len()), - None => None + None => None, }; if let Some(fs) = filesize { @@ -1630,10 +1623,7 @@ fn skip_filesize( } } -fn should_skip_entry( - ig: &Ignore, - dent: &DirEntry, -) -> bool { +fn should_skip_entry(ig: &Ignore, dent: &DirEntry) -> bool { let m = ig.matched_dir_entry(dent); if m.is_ignore() { debug!("ignoring {}: {:?}", dent.path().display(), m); @@ -1695,28 +1685,27 @@ fn path_equals(dent: &DirEntry, handle: &Handle) -> Result { /// Returns true if and only if the given path is on the same device as the /// given root device. fn is_same_file_system(root_device: u64, path: &Path) -> Result { - let dent_device = device_num(path) - .map_err(|err| Error::Io(err).with_path(path))?; + let dent_device = device_num(path).map_err(|err| Error::Io(err).with_path(path))?; Ok(root_device == dent_device) } #[cfg(unix)] -fn device_num>(path: P)-> io::Result { +fn device_num>(path: P) -> io::Result { use std::os::unix::fs::MetadataExt; path.as_ref().metadata().map(|md| md.dev()) } - #[cfg(windows)] +#[cfg(windows)] fn device_num>(path: P) -> io::Result { - use winapi_util::{Handle, file}; + use winapi_util::{file, Handle}; let h = Handle::from_path_any(path)?; file::information(h).map(|info| info.volume_serial_number()) } #[cfg(not(any(unix, windows)))] -fn device_num>(_: P)-> io::Result { +fn device_num>(_: P) -> io::Result { Err(io::Error::new( io::ErrorKind::Other, "walkdir: same_file_system option not supported on this platform", @@ -1730,8 +1719,8 @@ mod tests { use std::path::Path; use std::sync::{Arc, Mutex}; - use tests::TempDir; use super::{DirEntry, WalkBuilder, WalkState}; + use tests::TempDir; fn wfile>(path: P, contents: &str) { let mut file = File::create(path).unwrap(); @@ -1778,10 +1767,7 @@ mod tests { paths } - fn walk_collect_parallel( - prefix: &Path, - builder: &WalkBuilder, - ) -> Vec { + fn walk_collect_parallel(prefix: &Path, builder: &WalkBuilder) -> Vec { let mut paths = vec![]; for dent in walk_collect_entries_parallel(builder) { let path = dent.path().strip_prefix(prefix).unwrap(); @@ -1816,15 +1802,11 @@ mod tests { paths } - fn tmpdir(prefix: &str) -> TempDir { + fn tmpdir() -> TempDir { TempDir::new().unwrap() } - fn assert_paths( - prefix: &Path, - builder: &WalkBuilder, - expected: &[&str], - ) { + fn assert_paths(prefix: &Path, builder: &WalkBuilder, expected: &[&str]) { let got = walk_collect(prefix, builder); assert_eq!(got, mkpaths(expected), "single threaded"); let got = walk_collect_parallel(prefix, builder); @@ -1833,20 +1815,22 @@ mod tests { #[test] fn no_ignores() { - let td = tmpdir("walk-test-"); + let td = tmpdir(); mkdirp(td.path().join("a/b/c")); mkdirp(td.path().join("x/y")); wfile(td.path().join("a/b/foo"), ""); wfile(td.path().join("x/y/foo"), ""); - assert_paths(td.path(), &WalkBuilder::new(td.path()), &[ - "x", "x/y", "x/y/foo", "a", "a/b", "a/b/foo", "a/b/c", - ]); + assert_paths( + td.path(), + &WalkBuilder::new(td.path()), + &["x", "x/y", "x/y/foo", "a", "a/b", "a/b/foo", "a/b/c"], + ); } #[test] fn custom_ignore() { - let td = tmpdir("walk-test-"); + let td = tmpdir(); let custom_ignore = ".customignore"; mkdirp(td.path().join("a")); wfile(td.path().join(custom_ignore), "foo"); @@ -1862,7 +1846,7 @@ mod tests { #[test] fn custom_ignore_exclusive_use() { - let td = tmpdir("walk-test-"); + let td = tmpdir(); let custom_ignore = ".customignore"; mkdirp(td.path().join("a")); wfile(td.path().join(custom_ignore), "foo"); @@ -1882,7 +1866,7 @@ mod tests { #[test] fn gitignore() { - let td = tmpdir("walk-test-"); + let td = tmpdir(); mkdirp(td.path().join(".git")); mkdirp(td.path().join("a")); wfile(td.path().join(".gitignore"), "foo"); @@ -1891,14 +1875,16 @@ mod tests { wfile(td.path().join("bar"), ""); wfile(td.path().join("a/bar"), ""); - assert_paths(td.path(), &WalkBuilder::new(td.path()), &[ - "bar", "a", "a/bar", - ]); + assert_paths( + td.path(), + &WalkBuilder::new(td.path()), + &["bar", "a", "a/bar"], + ); } #[test] fn explicit_ignore() { - let td = tmpdir("walk-test-"); + let td = tmpdir(); let igpath = td.path().join(".not-an-ignore"); mkdirp(td.path().join("a")); wfile(&igpath, "foo"); @@ -1914,7 +1900,7 @@ mod tests { #[test] fn explicit_ignore_exclusive_use() { - let td = tmpdir("walk-test-"); + let td = tmpdir(); let igpath = td.path().join(".not-an-ignore"); mkdirp(td.path().join("a")); wfile(&igpath, "foo"); @@ -1926,13 +1912,16 @@ mod tests { let mut builder = WalkBuilder::new(td.path()); builder.standard_filters(false); assert!(builder.add_ignore(&igpath).is_none()); - assert_paths(td.path(), &builder, - &[".not-an-ignore", "bar", "a", "a/bar"]); + assert_paths( + td.path(), + &builder, + &[".not-an-ignore", "bar", "a", "a/bar"], + ); } #[test] fn gitignore_parent() { - let td = tmpdir("walk-test-"); + let td = tmpdir(); mkdirp(td.path().join(".git")); mkdirp(td.path().join("a")); wfile(td.path().join(".gitignore"), "foo"); @@ -1945,7 +1934,7 @@ mod tests { #[test] fn max_depth() { - let td = tmpdir("walk-test-"); + let td = tmpdir(); mkdirp(td.path().join("a/b/c")); wfile(td.path().join("foo"), ""); wfile(td.path().join("a/foo"), ""); @@ -1953,19 +1942,23 @@ mod tests { wfile(td.path().join("a/b/c/foo"), ""); let mut builder = WalkBuilder::new(td.path()); - assert_paths(td.path(), &builder, &[ - "a", "a/b", "a/b/c", "foo", "a/foo", "a/b/foo", "a/b/c/foo", - ]); + assert_paths( + td.path(), + &builder, + &["a", "a/b", "a/b/c", "foo", "a/foo", "a/b/foo", "a/b/c/foo"], + ); assert_paths(td.path(), builder.max_depth(Some(0)), &[]); assert_paths(td.path(), builder.max_depth(Some(1)), &["a", "foo"]); - assert_paths(td.path(), builder.max_depth(Some(2)), &[ - "a", "a/b", "foo", "a/foo", - ]); + assert_paths( + td.path(), + builder.max_depth(Some(2)), + &["a", "a/b", "foo", "a/foo"], + ); } #[test] fn max_filesize() { - let td = tmpdir("walk-test-"); + let td = tmpdir(); mkdirp(td.path().join("a/b")); wfile_size(td.path().join("foo"), 0); wfile_size(td.path().join("bar"), 400); @@ -1975,41 +1968,49 @@ mod tests { wfile_size(td.path().join("a/baz"), 200); let mut builder = WalkBuilder::new(td.path()); - assert_paths(td.path(), &builder, &[ - "a", "a/b", "foo", "bar", "baz", "a/foo", "a/bar", "a/baz", - ]); - assert_paths(td.path(), builder.max_filesize(Some(0)), &[ - "a", "a/b", "foo" - ]); - assert_paths(td.path(), builder.max_filesize(Some(500)), &[ - "a", "a/b", "foo", "bar", "a/bar", "a/baz" - ]); - assert_paths(td.path(), builder.max_filesize(Some(50000)), &[ - "a", "a/b", "foo", "bar", "baz", "a/foo", "a/bar", "a/baz", - ]); + assert_paths( + td.path(), + &builder, + &["a", "a/b", "foo", "bar", "baz", "a/foo", "a/bar", "a/baz"], + ); + assert_paths( + td.path(), + builder.max_filesize(Some(0)), + &["a", "a/b", "foo"], + ); + assert_paths( + td.path(), + builder.max_filesize(Some(500)), + &["a", "a/b", "foo", "bar", "a/bar", "a/baz"], + ); + assert_paths( + td.path(), + builder.max_filesize(Some(50000)), + &["a", "a/b", "foo", "bar", "baz", "a/foo", "a/bar", "a/baz"], + ); } #[cfg(unix)] // because symlinks on windows are weird #[test] fn symlinks() { - let td = tmpdir("walk-test-"); + let td = tmpdir(); mkdirp(td.path().join("a/b")); symlink(td.path().join("a/b"), td.path().join("z")); wfile(td.path().join("a/b/foo"), ""); let mut builder = WalkBuilder::new(td.path()); - assert_paths(td.path(), &builder, &[ - "a", "a/b", "a/b/foo", "z", - ]); - assert_paths(td.path(), &builder.follow_links(true), &[ - "a", "a/b", "a/b/foo", "z", "z/foo", - ]); + assert_paths(td.path(), &builder, &["a", "a/b", "a/b/foo", "z"]); + assert_paths( + td.path(), + &builder.follow_links(true), + &["a", "a/b", "a/b/foo", "z", "z/foo"], + ); } #[cfg(unix)] // because symlinks on windows are weird #[test] fn first_path_not_symlink() { - let td = tmpdir("walk-test-"); + let td = tmpdir(); mkdirp(td.path().join("foo")); let dents = WalkBuilder::new(td.path().join("foo")) @@ -2020,9 +2021,7 @@ mod tests { assert_eq!(1, dents.len()); assert!(!dents[0].path_is_symlink()); - let dents = walk_collect_entries_parallel( - &WalkBuilder::new(td.path().join("foo")), - ); + let dents = walk_collect_entries_parallel(&WalkBuilder::new(td.path().join("foo"))); assert_eq!(1, dents.len()); assert!(!dents[0].path_is_symlink()); } @@ -2030,17 +2029,13 @@ mod tests { #[cfg(unix)] // because symlinks on windows are weird #[test] fn symlink_loop() { - let td = tmpdir("walk-test-"); + let td = tmpdir(); mkdirp(td.path().join("a/b")); symlink(td.path().join("a"), td.path().join("a/b/c")); let mut builder = WalkBuilder::new(td.path()); - assert_paths(td.path(), &builder, &[ - "a", "a/b", "a/b/c", - ]); - assert_paths(td.path(), &builder.follow_links(true), &[ - "a", "a/b", - ]); + assert_paths(td.path(), &builder, &["a", "a/b", "a/b/c"]); + assert_paths(td.path(), &builder.follow_links(true), &["a", "a/b"]); } // It's a little tricky to test the 'same_file_system' option since @@ -2060,7 +2055,7 @@ mod tests { // If our test directory actually isn't a different volume from /sys, // then this test is meaningless and we shouldn't run it. - let td = tmpdir("walk-test-"); + let td = tmpdir(); if device_num(td.path()).unwrap() == device_num("/sys").unwrap() { return; } @@ -2074,8 +2069,6 @@ mod tests { // completely. let mut builder = WalkBuilder::new(td.path()); builder.follow_links(true).same_file_system(true); - assert_paths(td.path(), &builder, &[ - "same_file", "same_file/alink", - ]); + assert_paths(td.path(), &builder, &["same_file", "same_file/alink"]); } } -- cgit v1.2.3