Add half-open range operator (...).

Author: bretcope

Schyntax.Tests/tests.json

@@ -36,6 +36,18 @@
         "date": "2014-12-25T00:00:00.000Z",
         "prev": "2014-12-25T00:00:00.000Z",
         "next": "2015-12-25T00:00:00.000Z"
+      },
+      {
+        "format": "dates(12/25..12/27)",
+        "date": "2014-12-26T00:00:00.000Z",
+        "prev": "2014-12-26T00:00:00.000Z",
+        "next": "2014-12-27T00:00:00.000Z"
+      },
+      {
+        "format": "dates(12/25...12/27)",
+        "date": "2014-12-26T00:00:00.000Z",
+        "prev": "2014-12-26T00:00:00.000Z",
+        "next": "2015-12-25T00:00:00.000Z"
       }
     ]
   },
@@ -310,6 +322,12 @@
         "date": "2014-05-01T00:00:00.000Z",
         "prev": "2014-04-30T00:00:00.000Z",
         "next": "2014-05-02T00:00:00.000Z"
+      },
+      {
+        "format": "dom(20...10)",
+        "date": "2014-05-09T00:00:00.000Z",
+        "prev": "2014-05-09T00:00:00.000Z",
+        "next": "2014-05-20T00:00:00.000Z"
       }
     ]
   },
@@ -741,6 +759,18 @@
         "prev": "2014-07-14T00:00:00.000Z",
         "next": "2014-07-15T00:00:00.000Z"
       },
+      {
+        "format": "dow(mon...sat)",
+        "date": "2014-07-13T00:00:00.000Z",
+        "prev": "2014-07-11T00:00:00.000Z",
+        "next": "2014-07-14T00:00:00.000Z"
+      },
+      {
+        "format": "dow(mon...sat)",
+        "date": "2014-07-14T00:00:00.000Z",
+        "prev": "2014-07-14T00:00:00.000Z",
+        "next": "2014-07-15T00:00:00.000Z"
+      },
       {
         "format": "dow(mon..thu, sat)",
         "date": "2014-07-13T00:00:00.000Z",
@@ -925,6 +955,18 @@
         "prev": "2014-06-25T00:00:00.000Z",
         "next": "2014-06-25T01:00:00.000Z"
       },
+      {
+        "format": "h(0...23)",
+        "date": "2014-06-25T00:00:00.000Z",
+        "prev": "2014-06-25T00:00:00.000Z",
+        "next": "2014-06-25T01:00:00.000Z"
+      },
+      {
+        "format": "h(0...23)",
+        "date": "2014-06-25T22:00:00.000Z",
+        "prev": "2014-06-25T22:00:00.000Z",
+        "next": "2014-06-26T00:00:00.000Z"
+      },
       {
         "format": "h(12..20, 21)",
         "date": "2014-06-25T20:00:00.000Z",
@@ -1229,6 +1271,12 @@
         "prev": "2014-06-25T18:00:00.000Z",
         "next": "2014-06-25T18:01:00.000Z"
       },
+      {
+        "format": "m(0...10)",
+        "date": "2014-06-25T17:20:00.000Z",
+        "prev": "2014-06-25T17:09:00.000Z",
+        "next": "2014-06-25T18:00:00.000Z"
+      },
       {
         "format": "m(12..26, 27)",
         "date": "2014-06-25T18:26:12.326Z",
@@ -1533,6 +1581,12 @@
         "prev": "2014-06-25T18:00:00.000Z",
         "next": "2014-06-25T18:00:01.000Z"
       },
+      {
+        "format": "s(0...10)",
+        "date": "2014-06-25T17:50:20.000Z",
+        "prev": "2014-06-25T17:50:09.000Z",
+        "next": "2014-06-25T17:51:00.000Z"
+      },
       {
         "format": "s(12..26, 27)",
         "date": "2014-06-25T18:01:26.000Z",

Schyntax/Internals/IntermediateRepresentation.cs

@@ -72,20 +72,27 @@ internal IrGroup() { }
     public class IrIntegerRange
     {
         public bool IsRange { get; }
+        public bool IsHalfOpen { get; }
         public bool IsSplit { get; }
         public int Start { get; private set; }
         public int End { get; private set; }
         public int Interval { get; }
         public bool HasInterval { get; }
 
-        internal IrIntegerRange(int start, int? end, int interval, bool isSplit)
+        internal IrIntegerRange(int start, int? end, int interval, bool isSplit, bool isHalfOpen)
         {
             Start = start;
-            End = end ?? 0;
-            IsRange = end.HasValue;
+
+            if (end.HasValue)
+            {
+                IsSplit = isSplit;
+                IsHalfOpen = isHalfOpen;
+                IsRange = true;
+                End = end.Value;
+            }
+
             Interval = interval;
             HasInterval = interval != 0;
-            IsSplit = isSplit;
         }
 
         public IrIntegerRange CloneWithRevisedRange(int start, int end)
@@ -102,27 +109,29 @@ public IrIntegerRange CloneWithRevisedRange(int start, int end)
     public class IrDateRange
     {
         public bool IsRange { get; }
+        public bool IsHalfOpen { get; }
         public bool IsSplit { get; }
         public IrDate Start { get; }
         public IrDate End { get; }
         public bool DatesHaveYear { get; }
         public int Interval { get; }
         public bool HasInterval { get; }
 
-        internal IrDateRange(IrDate start, IrDate? end, int interval, bool isSplit)
+        internal IrDateRange(IrDate start, IrDate? end, int interval, bool isSplit, bool isHalfOpen)
         {
             Start = start;
             DatesHaveYear = start.Year != 0;
 
             if (end.HasValue)
             {
                 IsRange = true;
+                IsSplit = isSplit;
+                IsHalfOpen = isHalfOpen;
                 End = end.Value;
             }
 
             Interval = interval;
             HasInterval = interval != 0;
-            IsSplit = isSplit;
         }
     }
 

Schyntax/Internals/IrBuilder.cs

@@ -134,7 +134,7 @@ private static void CompileDateArgument(IrGroup irGroup, ArgumentNode arg)
                 }
             }
 
-            var irArg = new IrDateRange(irStart, irEnd, arg.HasInterval ? arg.IntervalValue : 0, isSplit);
+            var irArg = new IrDateRange(irStart, irEnd, arg.HasInterval ? arg.IntervalValue : 0, isSplit, arg.Range?.IsHalfOpen ?? false);
             (arg.IsExclusion ? irGroup.DatesExcluded : irGroup.Dates).Add(irArg);
         }
 
@@ -206,12 +206,12 @@ private static IrIntegerRange CompileIntegerArgument(ArgumentNode arg, int wildS
                 }
             }
 
-            return new IrIntegerRange(start, end, arg.HasInterval ? arg.IntervalValue : 0, isSplit);
+            return new IrIntegerRange(start, end, arg.HasInterval ? arg.IntervalValue : 0, isSplit, arg.Range?.IsHalfOpen ?? false);
         }
 
         private static IrIntegerRange GetZeroInteger()
         {
-            return new IrIntegerRange(0, null, 0, false);
+            return new IrIntegerRange(0, null, 0, false, false);
         }
     }
 }

Schyntax/Internals/Lexer.cs

@@ -83,7 +83,7 @@ private LexMethod LexExpressionArgument()
                 if (ConsumeNumberDayOrDate(false))
                 {
                     // might be a range
-                    if (ConsumeOptionalTerm(Terms.Range))
+                    if (ConsumeOptionalTerm(Terms.RangeHalfOpen) || ConsumeOptionalTerm(Terms.RangeInclusive))
                         ConsumeNumberDayOrDate(true);
                 }
             }

Schyntax/Internals/Nodes.cs

@@ -94,6 +94,7 @@ public class RangeNode : Node
     {
         public ValueNode Start { get; internal set; }
         public ValueNode End { get; internal set; }
+        public bool IsHalfOpen { get; internal set; }
     }
 
     public abstract class ValueNode : Node

Schyntax/Internals/Parser.cs

@@ -119,7 +119,18 @@ private RangeNode ParseRange(ExpressionType expressionType)
             var range = new RangeNode();
             range.Start = expressionType == ExpressionType.Dates ? (ValueNode)ParseDate() : ParseIntegerValue(expressionType);
 
-            if (IsNext(TokenType.Range))
+            var isRange = false;
+            if (IsNext(TokenType.RangeInclusive))
+            {
+                isRange = true;
+            }
+            else if (IsNext(TokenType.RangeHalfOpen))
+            {
+                isRange = true;
+                range.IsHalfOpen = true;
+            }
+
+            if (isRange)
             {
                 range.AddToken(Advance());
                 range.End = expressionType == ExpressionType.Dates ? (ValueNode)ParseDate() : ParseIntegerValue(expressionType);

Schyntax/Internals/Terms.cs

@@ -5,7 +5,8 @@ namespace Schyntax.Internals
     internal static class Terms
     {
         // literal terminals
-        public static Terminal Range { get; } = new Terminal(TokenType.Range, "..");
+        public static Terminal RangeInclusive { get; } = new Terminal(TokenType.RangeInclusive, "..");
+        public static Terminal RangeHalfOpen { get; } = new Terminal(TokenType.RangeHalfOpen, "...");
         public static Terminal Interval { get; } = new Terminal(TokenType.Interval, "%");
         public static Terminal Not { get; } = new Terminal(TokenType.Not, "!");
         public static Terminal OpenParen { get; } = new Terminal(TokenType.OpenParen, "(");

Schyntax/Internals/Token.cs

@@ -19,7 +19,8 @@ public enum TokenType
         EndOfInput,
 
         // operators
-        Range,
+        RangeInclusive,
+        RangeHalfOpen,
         Interval,
         Not,
         OpenParen,

Schyntax/Internals/Validator.cs

@@ -75,28 +75,7 @@ private void Expression(ExpressionNode expression)
                         " use the wildcard operator \"*\" instead of an interval", Input, arg.IntervalTokenIndex);
                 }
 
-                ValueValidator validator;
-                switch (expression.ExpressionType)
-                {
-                    case ExpressionType.Seconds:
-                    case ExpressionType.Minutes:
-                        validator = SecondOrMinute;
-                        break;
-                    case ExpressionType.Hours:
-                        validator = Hour;
-                        break;
-                    case ExpressionType.DaysOfWeek:
-                        validator = DayOfWeek;
-                        break;
-                    case ExpressionType.DaysOfMonth:
-                        validator = DayOfMonth;
-                        break;
-                    case ExpressionType.Dates:
-                        validator = Date;
-                        break;
-                    default:
-                        throw new NotImplementedException("ExpressionType " + expression.ExpressionType + " has not been implemented by the validator.");
-                }
+                var validator = GetValidator(expression.ExpressionType);
 
                 if (arg.IsWildcard)
                 {
@@ -124,14 +103,39 @@ private void Expression(ExpressionNode expression)
             }
         }
 
+        private ValueValidator GetValidator(ExpressionType expType)
+        {
+            switch (expType)
+            {
+                case ExpressionType.Seconds:
+                case ExpressionType.Minutes:
+                    return SecondOrMinute;
+                case ExpressionType.Hours:
+                    return Hour;
+                case ExpressionType.DaysOfWeek:
+                    return DayOfWeek;
+                case ExpressionType.DaysOfMonth:
+                    return DayOfMonth;
+                case ExpressionType.Dates:
+                    return Date;
+                default:
+                    throw new NotImplementedException("ExpressionType " + expType + " has not been implemented by the validator.");
+            }
+        }
+
         private delegate void ValueValidator(ExpressionType expType, ValueNode value);
 
         private void Range(ExpressionType expType, RangeNode range, ValueValidator validator)
         {
             validator(expType, range.Start);
             if (range.End != null)
+            {
                 validator(expType, range.End);
 
+                if (range.IsHalfOpen && ValuesAreEqual(expType, range.Start, range.End))
+                    throw new SchyntaxParseException("Start and end values of a half-open range cannot be equal.", Input, range.Start.Index);
+            }
+
             if (expType == ExpressionType.Dates && range.End != null)
             {
                 // special validation to make the date range is sane
@@ -207,6 +211,29 @@ private int IntegerValue(ExpressionType type, ValueNode value, int min, int max)
             return ival;
         }
 
+        private bool ValuesAreEqual(ExpressionType expType, ValueNode a, ValueNode b)
+        {
+            if (expType == ExpressionType.Dates)
+            {
+                var ad = (DateValueNode)a;
+                var bd = (DateValueNode)b;
+
+                if (ad.Day != bd.Day || ad.Month != bd.Month)
+                    return false;
+
+                if (ad.Year.HasValue && ad.Year != bd.Year)
+                    return false;
+
+                return true;
+            }
+
+            // integer values
+            var ai = ((IntegerValueNode)a).Value;
+            var bi = ((IntegerValueNode)b).Value;
+
+            return ai == bi;
+        }
+
         // returns true if the start date is before or equal to the end date
         private bool IsStartBeforeEnd(DateValueNode start, DateValueNode end)
         {

Schyntax/Schedule.cs

@@ -245,6 +245,14 @@ private static bool InDateRange(IrDateRange range, int year, int month, int dayO
                 return true;
             }
 
+            if (range.IsHalfOpen)
+            {
+                // check if this is the last date in a half-open range
+                var end = range.End;
+                if (end.Day == dayOfMonth && end.Month == month && (!range.DatesHaveYear || end.Year == year))
+                    return false;
+            }
+
             // check if in-between start and end dates.
             if (range.DatesHaveYear)
             {
@@ -357,6 +365,9 @@ private static bool InIntegerRange(IrIntegerRange range, int value, int lengthOf
                 return value == range.Start;
             }
 
+            if (range.IsHalfOpen && value == range.End)
+                return false;
+
             if (range.IsSplit) // range spans across the max value and loops back around
             {
                 if (value <= range.End || value >= range.Start)