Use Parser.SkipWhiteSpace in SkipWhiteSpace (#44)

sebastienros · May 4, 2021 · a08477a · a08477a
1 parent 74363cb
commit a08477a
Show file tree

Hide file tree

Showing 5 changed files with 55 additions and 4 deletions.
diff --git a/src/Parlot/Character.cs b/src/Parlot/Character.cs
@@ -40,7 +40,10 @@ public static bool IsWhiteSpace(char ch)
         }
 
         public static bool IsWhiteSpaceOrNewLine(char ch)
-            => (ch == '\n') || (ch == '\r') || (ch == '\v') || IsWhiteSpace(ch);
+            => IsNewLine(ch) || IsWhiteSpace(ch);
+
+        public static bool IsNewLine(char ch)
+            => (ch == '\n') || (ch == '\r') || (ch == '\v');
 
         public static char ScanHexEscape(string text, int index, out int length)
         {

diff --git a/src/Parlot/Fluent/ParseContext.cs b/src/Parlot/Fluent/ParseContext.cs
@@ -31,7 +31,6 @@ public ParseContext(Scanner scanner, bool useNewLines = false)
 
         /// <summary>
         /// The parser that is used to parse whitespaces and comments.
-        /// This can also include comments.
         /// </summary>
         public Parser<TextSpan> WhiteSpaceParser { get; set;}
 

diff --git a/src/Parlot/Fluent/SkipWhiteSpace.cs b/src/Parlot/Fluent/SkipWhiteSpace.cs
@@ -44,7 +44,7 @@ public CompilationResult Compile(CompilationContext context)
             result.Body.Add(
                 Expression.Block(
                     parserCompileResult.Variables,
-                    context.SkipWhiteSpace(),
+                    context.ParserSkipWhiteSpace(),
                     Expression.Block(parserCompileResult.Body),
                     Expression.IfThenElse(
                         parserCompileResult.Success,

diff --git a/test/Parlot.Tests/CompileTests.cs b/test/Parlot.Tests/CompileTests.cs
@@ -1,5 +1,4 @@
 using Parlot.Fluent;
-using System;
 using System.Collections.Generic;
 using Xunit;
 using static Parlot.Fluent.Parsers;
@@ -541,5 +540,30 @@ public void SkipWhiteSpaceCompiledShouldResetPosition()
             Assert.True(parser.TryParse(" ab", out var result1));
             Assert.Equal(" ab", result1);
         }
+
+        [Fact]
+        public void SkipWhiteSpaceCompiledShouldResponseParseContextUseNewLines()
+        {
+            // Default behavior, newlines are skipped like any other space. The grammar is not "New Line Aware"
+
+            Assert.True(
+                SkipWhiteSpace(Literals.Text("ab")).Compile()
+                .TryParse(new ParseContext(new Scanner(" \nab"), useNewLines: false), 
+                out var _, out var _));
+
+            // Here newlines are not skipped
+
+            Assert.False(
+                SkipWhiteSpace(Literals.Text("ab")).Compile()
+                .TryParse(new ParseContext(new Scanner(" \nab"), useNewLines: true),
+                out var _, out var _));
+
+            // Here newlines are not skipped, and the grammar reads them explicitly
+
+            Assert.True(
+                SkipWhiteSpace(Literals.WhiteSpace(includeNewLines: true).SkipAnd(Literals.Text("ab"))).Compile()
+                .TryParse(new ParseContext(new Scanner(" \nab"), useNewLines: true),
+                out var _, out var _));
+        }
     }
 }
diff --git a/test/Parlot.Tests/FluentTests.cs b/test/Parlot.Tests/FluentTests.cs
@@ -614,5 +614,30 @@ public void SkipWhiteSpaceShouldResetPosition()
             Assert.True(parser.TryParse(" ab", out var result1));
             Assert.Equal(" ab", result1);
         }
+
+        [Fact]
+        public void SkipWhiteSpaceShouldResponseParseContextUseNewLines()
+        {
+            // Default behavior, newlines are skipped like any other space. The grammar is not "New Line Aware"
+
+            Assert.True(
+                SkipWhiteSpace(Literals.Text("ab"))
+                .TryParse(new ParseContext(new Scanner(" \nab"), useNewLines: false),
+                out var _, out var _));
+
+            // Here newlines are not skipped
+
+            Assert.False(
+                SkipWhiteSpace(Literals.Text("ab"))
+                .TryParse(new ParseContext(new Scanner(" \nab"), useNewLines: true),
+                out var _, out var _));
+
+            // Here newlines are not skipped, and the grammar reads them explicitly
+
+            Assert.True(
+                SkipWhiteSpace(Literals.WhiteSpace(includeNewLines: true).SkipAnd(Literals.Text("ab")))
+                .TryParse(new ParseContext(new Scanner(" \nab"), useNewLines: true),
+                out var _, out var _));
+        }
     }
 }