Cache information about file type

This commit adds a cache that remembers whether a given path is a file or a directory, based on the results of `std::fs::read_dir`. This reduces the number of executed syscalls and improves the performance of the library.

src/lib.rs

@@ -73,7 +73,9 @@ use std::cmp;
 use std::error::Error;
 use std::fmt;
 use std::fs;
+use std::fs::DirEntry;
 use std::io;
+use std::ops::Deref;
 use std::path::{self, Component, Path, PathBuf};
 use std::str::FromStr;
 
@@ -96,8 +98,8 @@ pub struct Paths {
     dir_patterns: Vec<Pattern>,
     require_dir: bool,
     options: MatchOptions,
-    todo: Vec<Result<(PathBuf, usize), GlobError>>,
-    scope: Option<PathBuf>,
+    todo: Vec<Result<(PathWrapper, usize), GlobError>>,
+    scope: Option<PathWrapper>,
 }
 
 /// Return an iterator that produces all the `Path`s that match the given
@@ -242,6 +244,7 @@ pub fn glob_with(pattern: &str, options: MatchOptions) -> Result<Paths, PatternE
     }
 
     let scope = root.map_or_else(|| PathBuf::from("."), to_scope);
+    let scope = PathWrapper::from_path(scope);
 
     let mut dir_patterns = Vec::new();
     let components =
@@ -323,8 +326,45 @@ impl fmt::Display for GlobError {
     }
 }
 
-fn is_dir(p: &Path) -> bool {
-    fs::metadata(p).map(|m| m.is_dir()).unwrap_or(false)
+#[derive(Debug)]
+struct PathWrapper {
+    path: PathBuf,
+    is_dir: Option<bool>,
+}
+
+impl PathWrapper {
+    fn from_dir_entry(path: PathBuf, e: DirEntry) -> Self {
+        Self {
+            path,
+            is_dir: e.file_type().ok().map(|file_type| file_type.is_dir()),
+        }
+    }
+    fn from_path(path: PathBuf) -> Self {
+        Self { path, is_dir: None }
+    }
+
+    fn into_path(self) -> PathBuf {
+        self.path
+    }
+}
+
+impl Deref for PathWrapper {
+    type Target = Path;
+
+    fn deref(&self) -> &Self::Target {
+        self.path.deref()
+    }
+}
+
+impl AsRef<Path> for PathWrapper {
+    fn as_ref(&self) -> &Path {
+        self.path.as_ref()
+    }
+}
+
+fn is_dir(p: &PathWrapper) -> bool {
+    p.is_dir
+        .unwrap_or_else(|| fs::metadata(&p.path).map(|m| m.is_dir()).unwrap_or(false))
 }
 
 /// An alias for a glob iteration result.
@@ -366,7 +406,7 @@ impl Iterator for Paths {
                 if self.require_dir && !is_dir(&path) {
                     continue;
                 }
-                return Some(Ok(path));
+                return Some(Ok(path.into_path()));
             }
 
             if self.dir_patterns[idx].is_recursive {
@@ -394,7 +434,7 @@ impl Iterator for Paths {
                     if next == self.dir_patterns.len() - 1 {
                         // pattern ends in recursive pattern, so return this
                         // directory as a result
-                        return Some(Ok(path));
+                        return Some(Ok(path.into_path()));
                     } else {
                         // advanced to the next pattern for this path
                         idx = next + 1;
@@ -428,7 +468,7 @@ impl Iterator for Paths {
                     // children
 
                     if !self.require_dir || is_dir(&path) {
-                        return Some(Ok(path));
+                        return Some(Ok(path.into_path()));
                     }
                 } else {
                     fill_todo(
@@ -817,10 +857,10 @@ impl Pattern {
 // special-casing patterns to match `.` and `..`, and avoiding `readdir()`
 // calls when there are no metacharacters in the pattern.
 fn fill_todo(
-    todo: &mut Vec<Result<(PathBuf, usize), GlobError>>,
+    todo: &mut Vec<Result<(PathWrapper, usize), GlobError>>,
     patterns: &[Pattern],
     idx: usize,
-    path: &Path,
+    path: &PathWrapper,
     options: MatchOptions,
 ) {
     // convert a pattern that's just many Char(_) to a string
@@ -836,7 +876,7 @@ fn fill_todo(
         Some(s)
     }
 
-    let add = |todo: &mut Vec<_>, next_path: PathBuf| {
+    let add = |todo: &mut Vec<_>, next_path: PathWrapper| {
         if idx + 1 == patterns.len() {
             // We know it's good, so don't make the iterator match this path
             // against the pattern again. In particular, it can't match
@@ -849,7 +889,7 @@ fn fill_todo(
 
     let pattern = &patterns[idx];
     let is_dir = is_dir(path);
-    let curdir = path == Path::new(".");
+    let curdir = path.as_ref() == Path::new(".");
     match pattern_as_str(pattern) {
         Some(s) => {
             // This pattern component doesn't have any metacharacters, so we
@@ -863,6 +903,7 @@ fn fill_todo(
             } else {
                 path.join(&s)
             };
+            let next_path = PathWrapper::from_path(next_path);
             if (special && is_dir)
                 || (!special
                     && (fs::metadata(&next_path).is_ok()
@@ -875,19 +916,21 @@ fn fill_todo(
             let dirs = fs::read_dir(path).and_then(|d| {
                 d.map(|e| {
                     e.map(|e| {
-                        if curdir {
+                        let path = if curdir {
                             PathBuf::from(e.path().file_name().unwrap())
                         } else {
                             e.path()
-                        }
+                        };
+                        PathWrapper::from_dir_entry(path, e)
                     })
                 })
                 .collect::<Result<Vec<_>, _>>()
             });
             match dirs {
                 Ok(mut children) => {
                     if options.require_literal_leading_dot {
-                        children.retain(|x| !x.file_name().unwrap().to_str().unwrap().starts_with("."));
+                        children
+                            .retain(|x| !x.file_name().unwrap().to_str().unwrap().starts_with("."));
                     }
                     children.sort_by(|p1, p2| p2.file_name().cmp(&p1.file_name()));
                     todo.extend(children.into_iter().map(|x| Ok((x, idx))));
@@ -900,7 +943,7 @@ fn fill_todo(
                     if !pattern.tokens.is_empty() && pattern.tokens[0] == Char('.') {
                         for &special in &[".", ".."] {
                             if pattern.matches_with(special, options) {
-                                add(todo, path.join(special));
+                                add(todo, PathWrapper::from_path(path.join(special)));
                             }
                         }
                     }