Merge pull request #15 from blaenk/recursive

implement recursive wildstars

Author: alexcrichton

src/lib.rs

@@ -30,7 +30,7 @@ use std::io::fs::{mod, PathExtensions};
 use std::path::is_sep;
 use std::string::String;
 
-use PatternToken::{Char, AnyChar, AnySequence, AnyWithin, AnyExcept};
+use PatternToken::{Char, AnyChar, AnySequence, AnyRecursiveSequence, AnyWithin, AnyExcept};
 use CharSpecifier::{SingleChar, CharRange};
 use MatchResult::{Match, SubPatternDoesntMatch, EntirePatternDoesntMatch};
 
@@ -193,6 +193,7 @@ enum PatternToken {
     Char(char),
     AnyChar,
     AnySequence,
+    AnyRecursiveSequence,
     AnyWithin(Vec<CharSpecifier> ),
     AnyExcept(Vec<CharSpecifier> )
 }
@@ -220,6 +221,12 @@ impl Pattern {
      /// of characters, as ordered by Unicode, so e.g. `[0-9]` specifies any
      /// character between 0 and 9 inclusive.
      ///
+     /// A sequence of two `*` characters, `**`, acts like a single `*` except
+     /// that it also matches path separators, making it useful for matching
+     /// on arbitrary subdirectories.
+     ///
+     /// A sequence of more than two consecutive `*` characters is treated literally.
+     ///
      /// The metacharacters `?`, `*`, `[`, `]` can be matched by using brackets
      /// (e.g. `[?]`).  When a `]` occurs immediately following `[` or `[!` then
      /// it is interpreted as being part of, rather then ending, the character
@@ -242,11 +249,23 @@ impl Pattern {
                     i += 1;
                 }
                 '*' => {
-                    // *, **, ***, ****, ... are all equivalent
+                    let old = i;
+
                     while i < chars.len() && chars[i] == '*' {
                         i += 1;
                     }
-                    tokens.push(AnySequence);
+
+                    let count = i - old;
+
+                    if count > 2 {
+                        for _ in range(0u, count) {
+                            tokens.push(Char('*'));
+                        }
+                    } else if count == 2 {
+                        tokens.push(AnyRecursiveSequence);
+                    } else {
+                        tokens.push(AnySequence);
+                    }
                 }
                 '[' => {
 
@@ -364,7 +383,7 @@ impl Pattern {
 
         for (ti, token) in self.tokens.slice_from(i).iter().enumerate() {
             match *token {
-                AnySequence => {
+                AnySequence | AnyRecursiveSequence => {
                     loop {
                         match self.matches_from(prev_char.get(), file, i + ti + 1, options) {
                             SubPatternDoesntMatch => (), // keep trying
@@ -376,9 +395,12 @@ impl Pattern {
                             Some(pair) => pair
                         };
 
-                        if require_literal(c) {
-                            return SubPatternDoesntMatch;
+                        if let AnySequence = *token {
+                            if require_literal(c) {
+                                return SubPatternDoesntMatch;
+                            }
                         }
+
                         prev_char.set(Some(c));
                         file = next;
                     }
@@ -408,7 +430,7 @@ impl Pattern {
                         Char(c2) => {
                             chars_eq(c, c2, options.case_sensitive)
                         }
-                        AnySequence => {
+                        AnySequence | AnyRecursiveSequence => {
                             unreachable!()
                         }
                     };
@@ -628,10 +650,9 @@ mod test {
     }
 
     #[test]
-    fn test_wildcard_optimizations() {
-        assert!(Pattern::new("a*b").matches("a___b"));
+    fn test_wildcards() {
+        assert!(Pattern::new("a*b").matches("a_b"));
         assert!(Pattern::new("a**b").matches("a___b"));
-        assert!(Pattern::new("a***b").matches("a___b"));
         assert!(Pattern::new("a*b*c").matches("abc"));
         assert!(!Pattern::new("a*b*c").matches("abcd"));
         assert!(Pattern::new("a*b*c").matches("a_b_c"));
@@ -642,6 +663,16 @@ mod test {
         assert!(Pattern::new("a*b[xyz]c*d").matches("abxcdbxcddd"));
     }
 
+    #[test]
+    fn test_recursive_wildstars() {
+        let pat = Pattern::new("some/**/needle.txt");
+        assert!(pat.matches("some/one/needle.txt"));
+        assert!(pat.matches("some/one/two/needle.txt"));
+        assert!(pat.matches("some/other/needle.txt"));
+        // more than 2 consecutive wildcards and they're all treated literally
+        assert!(Pattern::new("a***b").matches("a***b"));
+    }
+
     #[test]
     fn test_lots_of_files() {
         // this is a good test because it touches lots of differently named files

tests/glob-std.rs

@@ -71,6 +71,19 @@ fn main() {
     mk_file("xyz/y", false);
     mk_file("xyz/z", false);
 
+    mk_file("r", true);
+    mk_file("r/one", true);
+    mk_file("r/one/a.md", false);
+    mk_file("r/two", true);
+    mk_file("r/two/b.md", false);
+    mk_file("r/three", true);
+    mk_file("r/three/c.md", false);
+
+    assert_eq!(glob_vec("r/**/*.md"), vec!(
+        abs_path("r/one/a.md"),
+        abs_path("r/three/c.md"),
+        abs_path("r/two/b.md")));
+
     assert_eq!(glob_vec(""), Vec::new());
     assert_eq!(glob_vec("."), vec!(os::getcwd().unwrap()));
     assert_eq!(glob_vec(".."), vec!(os::getcwd().unwrap().join("..")));