Fixes #13

**/ is now tokenised as a single token, rather than two tokens (a directory wildcard and a path seperator). This addresses an issue where /**/somefile.txt would tokenise into having 2 path seperator tokens, so wouldnt match against a string with only one like /somefile.txt.

Author: dazinator

src/DotNet.Glob.Benchmarks/Utils/GlobToRegexFormatter.cs

@@ -35,6 +35,10 @@ public string Format(IEnumerable<IGlobToken> tokens)
         public void Visit(WildcardDirectoryToken wildcardDirectoryToken)
         {
             _stringBuilder.Append(".*");
+            if(wildcardDirectoryToken.TrailingPathSeperator != null)
+            {
+                _stringBuilder.Append(@"[/\\]");               
+            }
         }
 
         void IGlobTokenVisitor.Visit(CharacterListToken token)

src/DotNet.Glob.Tests/FormatterTests.cs

@@ -23,8 +23,7 @@ public void Can_Format_Glob_Pattern()
                                 new WildcardToken(),
                                 new CharacterListToken(new char[] { 'a', 'b', 'c' }, false),
                                 new PathSeperatorToken('/'),
-                                new WildcardDirectoryToken(),
-                                new PathSeperatorToken('/'),
+                                new WildcardDirectoryToken('/'),                              
                                 new NumberRangeToken('1', '3', true),
                                 new LiteralToken(".txt"));
 

src/DotNet.Glob.Tests/GlobBuilderTests.cs

@@ -14,7 +14,7 @@ public void Can_Build_Glob_Pattern()
         {
             // 
             // build the following glob pattern using glob builder:
-            //       /foo?\\*[abc][!1-3].txt
+            //       /foo?\\*[abc][!1-3]/**/*.txt
             var tokens = new GlobBuilder()
                 .PathSeperator()
                 .Literal("foo")
@@ -24,13 +24,12 @@ public void Can_Build_Glob_Pattern()
                 .OneOf('a', 'b', 'c')
                 .NumberNotInRange('1', '3')
                 .PathSeperator()
-                .DirectoryWildcard()
-                .PathSeperator()
+                .DirectoryWildcard(PathSeperatorKind.ForwardSlash)              
                 .Wildcard()
                 .Literal(".txt")
                 .Tokens;
 
-            Assert.Equal(12, tokens.Count);
+            Assert.Equal(11, tokens.Count);
             Assert.True(tokens[0] is PathSeperatorToken);
             Assert.True(tokens[1] is LiteralToken);
             Assert.True(tokens[2] is AnyCharacterToken);
@@ -39,10 +38,9 @@ public void Can_Build_Glob_Pattern()
             Assert.True(tokens[5] is CharacterListToken);
             Assert.True(tokens[6] is NumberRangeToken);
             Assert.True(tokens[7] is PathSeperatorToken);
-            Assert.True(tokens[8] is WildcardDirectoryToken);
-            Assert.True(tokens[9] is PathSeperatorToken);
-            Assert.True(tokens[10] is WildcardToken);
-            Assert.True(tokens[11] is LiteralToken);
+            Assert.True(tokens[8] is WildcardDirectoryToken);           
+            Assert.True(tokens[9] is WildcardToken);
+            Assert.True(tokens[10] is LiteralToken);
         }
 
     }

src/DotNet.Glob.Tests/GlobTests.cs

@@ -19,6 +19,7 @@ public class GlobTests
         [InlineData("literal", "fliteral", "foo/literal", "literals", "literals/foo")]
         [InlineData("path/hats*nd", "path/hatsblahn", "path/hatsblahndt")]
         [InlineData("path/?atstand", "path/moatstand", "path/batstands")]
+        [InlineData("/**/file.csv", "/file.txt")]
         public void Does_Not_Match(string pattern, params string[] testStrings)
         {
             var glob = Glob.Parse(pattern);
@@ -45,6 +46,10 @@ public void Does_Not_Match(string pattern, params string[] testStrings)
         [InlineData("p?th/*a[bcd]b[e-g]a[1-4][!wxyz][!a-c][!1-3].*", "pAth/fooooacbfa2vd4.txt")]
         [InlineData("path/**/somefile.txt", "path/foo/bar/baz/somefile.txt")]
         [InlineData("p?th/*a[bcd]b[e-g]a[1-4][!wxyz][!a-c][!1-3].*", "pGth/yGKNY6acbea3rm8.")]
+        [InlineData("/**/file.*", "/folder/file.csv")]
+        [InlineData("/**/file.*","/file.txt")]
+        [InlineData("/**/file.*", "/file.txt")]
+        [InlineData("**/file.*", "/file.txt")]
         public void Can_IsMatch(string pattern, params string[] testStrings)
         {
             var glob = Glob.Parse(pattern);
@@ -61,7 +66,7 @@ public void Can_IsMatch(string pattern, params string[] testStrings)
         [Fact]
         public void To_String_Returns_Pattern()
         {
-            var pattern = "p?th/*a[bcd]b[e-g]a[1-4][!wxyz][!a-c][!1-3].*";
+            var pattern = "p?th/*a[bcd]b[e-g]/**/a[1-4][!wxyz][!a-c][!1-3].*";
             var glob = Glob.Parse(pattern);
             var resultPattern = glob.ToString();
             Assert.Equal(pattern, resultPattern);
@@ -72,6 +77,7 @@ public void To_String_Returns_Pattern()
         /// <summary>
         /// Tests for the InMemoryDirectory sub system.
         /// </summary>
+        /// <Remarks>These tests are for another library that I am using to compare againts.</Remarks>       
         [Theory]
         [InlineData("literal", "literal")]
         [InlineData("a/literal", "a/literal")]
@@ -85,8 +91,14 @@ public void To_String_Returns_Pattern()
         [InlineData("p?th/*a[bcd]b[e-g]a[1-4][!wxyz][!a-c][!1-3].*", "pAth/fooooacbfa2vd4.txt")]
         [InlineData("path/**/somefile.txt", "path/foo/bar/baz/somefile.txt")]
         [InlineData("p?th/*a[bcd]b[e-g]a[1-4][!wxyz][!a-c][!1-3].*", "pGth/yGKNY6acbea3rm8.")]
+        [InlineData("/**/file.*", "/folder/file.csv")]
+        //[InlineData("/**/file.*", "/file.txt")]
+        //[InlineData("**/file.*", "/file.txt")]
+        //[InlineData("/**/file.*", "/file.txt")]
         public void Glob_IsMatch(string pattern, params string[] testStrings)
         {
+            // This is a different glob library, I am seeing if it matches the same patterns as my library.
+            // The three tests above commented out show it currently has some limitations, that this library doesn't.
             var glob = new global::Glob.Glob(pattern);
             foreach (var testString in testStrings)
             {

src/DotNet.Glob.Tests/TokeniserTests.cs

@@ -20,7 +20,7 @@ public class TokeniserTests
             typeof(NumberRangeToken), typeof(CharacterListToken), typeof(LetterRangeToken),
             typeof(NumberRangeToken), typeof(LiteralToken),
             typeof(WildcardToken))]
-        [InlineData("path/**/*.*", typeof(LiteralToken), typeof(PathSeperatorToken), typeof(WildcardDirectoryToken), typeof(PathSeperatorToken), typeof(WildcardToken), typeof(LiteralToken), typeof(WildcardToken))]
+        [InlineData("path/**/*.*", typeof(LiteralToken), typeof(PathSeperatorToken), typeof(WildcardDirectoryToken), typeof(WildcardToken), typeof(LiteralToken), typeof(WildcardToken))]
         public void Can_Tokenise_Glob_Pattern(string testString, params Type[] expectedTokens)
         {
             // Arrange

src/DotNet.Glob/Evaluation/WildcardDirectoryTokenEvaluator.cs

@@ -27,6 +27,14 @@ public bool IsMatch(string allChars, int currentPosition, out int newPosition)
             {
                 // The remaining tokens match against a fixed length string, so wildcard **must** consume
                 // a known amount of characters in order for this to have a chance of successful match.
+                // but can't consume past current position!
+                // var matchLength = (allChars.Length - _subEvaluator.ConsumesMinLength);
+                //if(matchLength < currentPosition)
+                //{
+                //    return false;
+                //}
+                //var isMatch = _subEvaluator.IsMatch(allChars, matchLength, out newPosition);
+                //return isMatch;
                 var isMatch = _subEvaluator.IsMatch(allChars, (allChars.Length - _subEvaluator.ConsumesMinLength), out newPosition);
                 return isMatch;
             }

src/DotNet.Glob/Evaluation/WildcardTokenEvaluator.cs

@@ -26,6 +26,14 @@ public bool IsMatch(string allChars, int currentPosition, out int newPosition)
             {
                 // The remaining tokens match against a fixed length string, so wildcard **must** consume
                 // a known amount of characters in order for this to have a chance of successful match.
+                // but can't consume past / behind current position!
+                //var matchLength = (allChars.Length - _subEvaluator.ConsumesMinLength);
+                //if (matchLength < currentPosition)
+                //{
+                //    return false;
+                //}
+                //var isMatch = _subEvaluator.IsMatch(allChars, matchLength, out newPosition);
+                //return isMatch;
                 var isMatch = _subEvaluator.IsMatch(allChars, (allChars.Length - _subEvaluator.ConsumesMinLength), out newPosition);
                 return isMatch;
             }

src/DotNet.Glob/Formatting/GlobTokenFormatter.cs

@@ -29,6 +29,10 @@ public string Format(IEnumerable<IGlobToken> tokens)
         public void Visit(WildcardDirectoryToken wildcardDirectoryToken)
         {
             _stringBuilder.Append("**");
+            if(wildcardDirectoryToken.TrailingPathSeperator != null)
+            {
+                _stringBuilder.Append(wildcardDirectoryToken.TrailingPathSeperator);
+            }
         }
 
         void IGlobTokenVisitor.Visit(CharacterListToken token)

src/DotNet.Glob/GlobBuilder.cs

@@ -63,9 +63,28 @@ public IGlobBuilder Wildcard()
             return this;
         }
 
-        public IGlobBuilder DirectoryWildcard()
+        public IGlobBuilder DirectoryWildcard(PathSeperatorKind? trailingSeperatorKind = PathSeperatorKind.ForwardSlash)
         {
-            _tokens.Add(new WildcardDirectoryToken());
+            if (trailingSeperatorKind == null)
+            {
+                _tokens.Add(new WildcardDirectoryToken(null));
+            }
+            else
+            {
+                switch (trailingSeperatorKind)
+                {
+                    case PathSeperatorKind.BackwardSlash:
+                        _tokens.Add(new WildcardDirectoryToken('\\'));
+                        break;
+                    case PathSeperatorKind.ForwardSlash:
+                        _tokens.Add(new WildcardDirectoryToken('/'));
+                        break;
+                    default:
+                        break;
+                }
+            }
+
+
             return this;
         }
 

src/DotNet.Glob/GlobTokeniser.cs

@@ -18,7 +18,7 @@ public GlobTokeniser()
         public IList<IGlobToken> Tokenise(string globText)
         {
             var tokens = new List<IGlobToken>();
-
+            string starstartpeak;
             using (var reader = new GlobStringReader(globText))
             {
                 while (reader.ReadChar())
@@ -34,7 +34,7 @@ public IList<IGlobToken> Tokenise(string globText)
                     else if (reader.IsWildcardCharacterMatch)
                     {
                         tokens.Add(ReadWildcardToken());
-                    }
+                    }                   
                     else if (reader.IsPathSeperator())
                     {
                         tokens.Add(ReadPathSeperatorToken(reader));
@@ -60,7 +60,15 @@ public IList<IGlobToken> Tokenise(string globText)
         private IGlobToken ReadDirectoryWildcardToken(GlobStringReader reader)
         {
             reader.ReadChar();
-            return new WildcardDirectoryToken();
+
+            if (GlobStringReader.IsPathSeperator(reader.PeekChar()))
+            {
+                reader.ReadChar();
+                return new WildcardDirectoryToken(reader.CurrentChar);
+            }
+
+            return new WildcardDirectoryToken(null); // this shouldn't happen unless a pattern ends with ** which is weird. **sometext is not legal.
+
         }
 
         private IGlobToken ReadLiteralToken(GlobStringReader reader)

src/DotNet.Glob/IGlobBuilder.cs

@@ -9,7 +9,7 @@ public interface IGlobBuilder
         IGlobBuilder Literal(string text);
         IGlobBuilder AnyCharacter();
         IGlobBuilder Wildcard();
-        IGlobBuilder DirectoryWildcard();
+        IGlobBuilder DirectoryWildcard(PathSeperatorKind? trailingSeperatorKind = PathSeperatorKind.ForwardSlash);
         IGlobBuilder OneOf(params char[] characters);
         IGlobBuilder NotOneOf(params char[] characters);
         IGlobBuilder LetterInRange(char start, char end);

src/DotNet.Glob/Token/WildcardDirectoryToken.cs

@@ -2,6 +2,15 @@
 {
     public class WildcardDirectoryToken : IGlobToken
     {
+
+        public WildcardDirectoryToken(char? trailingPathSeperator)
+        {
+            TrailingPathSeperator = trailingPathSeperator;
+        }
+
+        //public PathSeperatorKind? TrailingPathSeperatorKind { get; set; }
+        public char? TrailingPathSeperator { get; set; }
+
         public void Accept(IGlobTokenVisitor Visitor)
         {
             Visitor.Visit(this);