Fix ZeroOrOne with default value (#125)

Co-authored-by: Gustavo Mauricio de Barros <gustavomauriciodebarros@gmail.com>

.editorconfig

@@ -62,7 +62,7 @@ dotnet_style_prefer_simplified_interpolation = true:suggestion
 dotnet_style_readonly_field = true:suggestion
 
 # Parameter preferences
-dotnet_code_quality_unused_parameters = all:suggestion
+dotnet_code_quality_unused_parameters = all:warning
 
 # Suppression preferences
 dotnet_remove_unnecessary_suppression_exclusions = none

src/Parlot/Fluent/Parsers.cs

@@ -29,7 +29,7 @@ public static partial class Parsers
         /// <summary>
         /// Builds a parser that looks for zero or one time the specified parser.
         /// </summary>
-        public static Parser<T> ZeroOrOne<T>(Parser<T> parser, T defaultValue = default) => new ZeroOrOne<T>(parser);
+        public static Parser<T> ZeroOrOne<T>(Parser<T> parser, T defaultValue = default) => new ZeroOrOne<T>(parser, defaultValue);
 
         /// <summary>
         /// Builds a parser that looks for zero or many times the specified parser.

src/Parlot/Fluent/ZeroOrOne.cs

@@ -67,7 +67,7 @@ public CompilationResult Compile(CompilationContext context)
                             : Expression.IfThenElse(
                                 parserCompileResult.Success, 
                                 Expression.Assign(value,  parserCompileResult.Value),
-                                Expression.Assign(value, Expression.Default(typeof(T)))
+                                Expression.Assign(value, Expression.Constant(_defaultValue, typeof(T)))
                             )
                         )
                     );

test/Parlot.Tests/CompileTests.cs

@@ -194,14 +194,23 @@ public void ShouldCompileOneOrMany()
         }
 
         [Fact]
-        public void ShouldCompileZeroOrOne()
+        public void ShouldZeroOrOne()
         {
             var parser = ZeroOrOne(Terms.Text("hello")).Compile();
 
             Assert.Equal("hello", parser.Parse(" hello world hello"));
             Assert.Null(parser.Parse(" foo"));
         }
 
+        [Fact]
+        public void ShouldZeroOrOneWithDefault()
+        {
+            var parser = ZeroOrOne(Terms.Text("hello"), "world").Compile();
+
+            Assert.Equal("world", parser.Parse(" this is an apple"));
+            Assert.Equal("hello", parser.Parse(" hello world"));
+        }
+
         [Fact]
         public void ShouldCompileBetweens()
         {

test/Parlot.Tests/FluentTests.cs

@@ -122,10 +122,10 @@ public void BetweenShouldParseBetweenTwoString()
         [Fact]
         public void TextShouldResetPosition()
         {
-            var code = OneOf(Terms.Text("substract"), Terms.Text("substitute"));
+            var code = OneOf(Terms.Text("subtract"), Terms.Text("substitute"));
 
             Assert.False(code.TryParse("sublime", out _));
-            Assert.True(code.TryParse("substract", out _));
+            Assert.True(code.TryParse("subtract", out _));
             Assert.True(code.TryParse("substitute", out _));
         }
 
@@ -872,5 +872,23 @@ public void ShouldParsePrefix(string expression, double result)
 
             Assert.Equal(result, unary.Parse(expression));
         }
+
+        [Fact]
+        public void ShouldZeroOrOne()
+        {
+            var parser = ZeroOrOne(Terms.Text("hello"));
+
+            Assert.Equal("hello", parser.Parse(" hello world hello"));
+            Assert.Null(parser.Parse(" foo"));
+        }
+
+        [Fact]
+        public void ShouldZeroOrOneWithDefault()
+        {
+            var parser = ZeroOrOne(Terms.Text("hello"), "world");
+
+            Assert.Equal("world", parser.Parse(" this is an apple"));
+            Assert.Equal("hello", parser.Parse(" hello world"));
+        }
     }
 }