Fix date math rounding to respect inclusive/exclusive bracket boundaries

Previously, TwoPartFormatParser always passed isUpperLimit=false for the
start side and isUpperLimit=true for the end side of a range, regardless
of bracket type. This is only correct for inclusive [...] brackets.

Per Elasticsearch conventions, rounding behavior must change based on
whether each boundary is inclusive or exclusive:

  - Inclusive min ([): rounds down (start of period)  — gte semantics
  - Exclusive min ({): rounds up (end of period)      — gt semantics
  - Inclusive max (]): rounds up (end of period)       — lte semantics
  - Exclusive max (}): rounds down (start of period)   — lt semantics

This means [now/d TO now/d] correctly produces the entire day (start to
end), while {now/d TO now/d} collapses, and mixed brackets like
[now/d TO now/d} produce start-of-day to start-of-day.

Changes:
- Pre-scan closing bracket before parsing parts so isUpperLimit is known
  upfront (uses a simple backwards char scan, no extra regex)
- Pass bracket-aware isUpperLimit to part parsers; wildcard parsers
  still receive positional isUpperLimit (false=min, true=max) since they
  use it for position semantics rather than rounding
- Allow mixed bracket pairs ([..}, {..]) per Elasticsearch Lucene syntax
- Add comprehensive tests for all four bracket combinations with /d, /M,
  /h rounding and mixed date math operations
- Document rounding behavior in README with reference table and common
  date range patterns

Ref: FoundatioFx/Foundatio.Lucene@a8426ab
Co-authored-by: Cursor <cursoragent@cursor.com>

Author: niemyjski

README.md

@@ -70,6 +70,61 @@ Examples:
 - `2025-01-01T01:25:35Z||+3d/d` - January 4th, 2025 (start of day) in UTC
 - `2023-06-15T14:30:00+05:00||+1M-2d` - One month minus 2 days from the specified date/time in +05:00 timezone
 
+#### Rounding with Inclusive/Exclusive Ranges
+
+Rounding behavior changes depending on whether a range boundary is inclusive or exclusive, following [Elasticsearch's conventions](https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-range-query.html#range-query-date-math-rounding):
+
+**Inclusive boundaries** round to maximize the matched range:
+
+- Inclusive min (`[`): rounds **down** (start of period) -- e.g., `[now/d` rounds to start of today
+- Inclusive max (`]`): rounds **up** (end of period) -- e.g., `now/d]` rounds to end of today
+
+**Exclusive boundaries** round to minimize the matched range:
+
+- Exclusive min (`{`): rounds **up** (end of period) -- e.g., `{now/d` rounds to end of today
+- Exclusive max (`}`): rounds **down** (start of period) -- e.g., `now/d}` rounds to start of today
+
+All four bracket combinations are supported (including mixed):
+
+| Query | Rounding | Effective |
+| ----- | -------- | --------- |
+| `[now/d TO now/d]` | min: start, max: end | Entire current day |
+| `[now/d TO now/d}` | min: start, max: start | Empty (start = start) |
+| `{now/d TO now/d]` | min: end, max: end | Empty (end = end) |
+| `[now/M TO now/M]` | min: start of month, max: end of month | Entire current month |
+| `[now/h TO now/h]` | min: start of hour, max: end of hour | Entire current hour |
+
+Common date range patterns:
+
+```text
+// Today (start of day through end of day)
+[now/d TO now/d]
+
+// Yesterday
+[now-1d/d TO now-1d/d]
+
+// This month
+[now/M TO now/M]
+
+// Last month
+[now-1M/M TO now-1M/M]
+
+// Last 7 full days (not including today)
+[now-7d/d TO now-1d/d]
+
+// Last 30 days (rolling, including partial today)
+[now-30d TO now]
+
+// This week
+[now/w TO now/w]
+
+// Last hour
+[now-1h/h TO now-1h/h]
+
+// Last 4 full hours (rounded to hour boundaries)
+[now-4h/h TO now/h]
+```
+
 ### DateMath Utility
 
 For applications that need standalone date math parsing without the range functionality, the `DateMath` utility class provides direct access to Elasticsearch date math expression parsing. Check out our [unit tests](https://github.com/exceptionless/Exceptionless.DateTimeExtensions/blob/main/tests/Exceptionless.DateTimeExtensions.Tests/DateMathTests.cs) for more usage samples.

src/Exceptionless.DateTimeExtensions/FormatParsers/FormatParsers/TwoPartFormatParser.cs

@@ -33,9 +33,35 @@ public DateTimeRange Parse(string content, DateTimeOffset relativeBaseTime)
         if (!begin.Success)
             return null;
 
-        // Capture the opening bracket if present
         string openingBracket = begin.Groups[1].Value;
 
+        // Scan backwards from end of string to find closing bracket character.
+        // This is cheaper than a regex and lets us determine max inclusivity upfront.
+        string closingBracket = "";
+        for (int i = content.Length - 1; i >= 0; i--)
+        {
+            char c = content[i];
+            if (c == ']' || c == '}')
+            {
+                closingBracket = c.ToString();
+                break;
+            }
+
+            if (!Char.IsWhiteSpace(c))
+                break;
+        }
+
+        if (!IsValidBracketPair(openingBracket, closingBracket))
+            return null;
+
+        // Inclusive min ([): round down (start of period) — ">= start"
+        // Exclusive min ({): round up (end of period) — "> end"
+        bool minInclusive = !String.Equals(openingBracket, "{");
+
+        // Inclusive max (]): round up (end of period) — "<= end"
+        // Exclusive max (}): round down (start of period) — "< start"
+        bool maxInclusive = !String.Equals(closingBracket, "}");
+
         index += begin.Length;
         DateTimeOffset? start = null;
         foreach (var parser in Parsers)
@@ -44,7 +70,10 @@ public DateTimeRange Parse(string content, DateTimeOffset relativeBaseTime)
             if (!match.Success)
                 continue;
 
-            start = parser.Parse(match, relativeBaseTime, false);
+            // Wildcard parsers use isUpperLimit for position (min/max), not rounding.
+            // For non-wildcard parsers, bracket inclusivity determines rounding direction.
+            bool isUpperLimit = parser is WildcardPartParser ? false : !minInclusive;
+            start = parser.Parse(match, relativeBaseTime, isUpperLimit);
             if (start == null)
                 continue;
 
@@ -65,7 +94,8 @@ public DateTimeRange Parse(string content, DateTimeOffset relativeBaseTime)
             if (!match.Success)
                 continue;
 
-            end = parser.Parse(match, relativeBaseTime, true);
+            bool isUpperLimit = parser is WildcardPartParser ? true : maxInclusive;
+            end = parser.Parse(match, relativeBaseTime, isUpperLimit);
             if (end == null)
                 continue;
 
@@ -77,20 +107,16 @@ public DateTimeRange Parse(string content, DateTimeOffset relativeBaseTime)
         if (!endMatch.Success)
             return null;
 
-        // Validate bracket matching
-        string closingBracket = endMatch.Groups[1].Value;
-        if (!IsValidBracketPair(openingBracket, closingBracket))
-            return null;
-
         return new DateTimeRange(start ?? DateTime.MinValue, end ?? DateTime.MaxValue);
     }
 
     /// <summary>
-    /// Validates that opening and closing brackets are properly matched.
+    /// Validates that opening and closing brackets form a valid pair.
+    /// Both Elasticsearch bracket types can be mixed: [ with ], [ with }, { with ], { with }.
     /// </summary>
     /// <param name="opening">The opening bracket character</param>
     /// <param name="closing">The closing bracket character</param>
-    /// <returns>True if brackets are properly matched, false otherwise</returns>
+    /// <returns>True if brackets are properly paired, false otherwise</returns>
     private static bool IsValidBracketPair(string opening, string closing)
     {
         // Both empty - valid (no brackets)
@@ -101,8 +127,9 @@ private static bool IsValidBracketPair(string opening, string closing)
         if (String.IsNullOrEmpty(opening) || String.IsNullOrEmpty(closing))
             return false;
 
-        // Check for proper matching pairs
-        return (String.Equals(opening, "[") && String.Equals(closing, "]")) ||
-               (String.Equals(opening, "{") && String.Equals(closing, "}"));
+        // Any valid opening bracket ([, {) can pair with any valid closing bracket (], })
+        bool validOpening = String.Equals(opening, "[") || String.Equals(opening, "{");
+        bool validClosing = String.Equals(closing, "]") || String.Equals(closing, "}");
+        return validOpening && validClosing;
     }
 }

tests/Exceptionless.DateTimeExtensions.Tests/DateTimeRangeTests.cs

@@ -352,4 +352,89 @@ public void Parse_InvalidDateMathExpressions_ReturnsEmptyRange(string input, str
         Assert.True(range == DateTimeRange.Empty || range.Start != DateTime.MinValue,
             $"{reason}. Input '{input}' should either return empty range or valid fallback parsing");
     }
+
+    [Fact]
+    public void Parse_InclusiveBracketsWithDayRounding_ReturnsFullDay()
+    {
+        // [now/d TO now/d] — inclusive min rounds down, inclusive max rounds up
+        var baseTime = new DateTime(2023, 12, 25, 12, 0, 0);
+        var range = DateTimeRange.Parse("[now/d TO now/d]", baseTime);
+
+        Assert.NotEqual(DateTimeRange.Empty, range);
+        Assert.Equal(baseTime.StartOfDay(), range.Start);
+        Assert.Equal(baseTime.EndOfDay(), range.End);
+    }
+
+    [Fact]
+    public void Parse_ExclusiveBracketsWithDayRounding_InvertsRounding()
+    {
+        // {now/d TO now/d} — exclusive min rounds up (end of day), exclusive max rounds down (start of day)
+        // Since end-of-day > start-of-day, DateTimeRange normalizes to a collapsed range
+        var baseTime = new DateTime(2023, 12, 25, 12, 0, 0);
+        var range = DateTimeRange.Parse("{now/d TO now/d}", baseTime);
+
+        Assert.NotEqual(DateTimeRange.Empty, range);
+        Assert.Equal(baseTime.StartOfDay(), range.Start);
+        Assert.Equal(baseTime.StartOfDay(), range.End);
+    }
+
+    [Fact]
+    public void Parse_InclusiveExclusiveMixedWithDayRounding_StartOfDayToStartOfDay()
+    {
+        // [now/d TO now/d} — inclusive min rounds down (start of day), exclusive max rounds down (start of day)
+        var baseTime = new DateTime(2023, 12, 25, 12, 0, 0);
+        var range = DateTimeRange.Parse("[now/d TO now/d}", baseTime);
+
+        Assert.NotEqual(DateTimeRange.Empty, range);
+        Assert.Equal(baseTime.StartOfDay(), range.Start);
+        Assert.Equal(baseTime.StartOfDay(), range.End);
+    }
+
+    [Fact]
+    public void Parse_ExclusiveInclusiveMixedWithDayRounding_EndOfDayToEndOfDay()
+    {
+        // {now/d TO now/d] — exclusive min rounds up (end of day), inclusive max rounds up (end of day)
+        var baseTime = new DateTime(2023, 12, 25, 12, 0, 0);
+        var range = DateTimeRange.Parse("{now/d TO now/d]", baseTime);
+
+        Assert.NotEqual(DateTimeRange.Empty, range);
+        Assert.Equal(baseTime.EndOfDay(), range.Start);
+        Assert.Equal(baseTime.EndOfDay(), range.End);
+    }
+
+    [Fact]
+    public void Parse_InclusiveBracketsWithMonthRounding_ReturnsFullMonth()
+    {
+        // [now/M TO now/M] — inclusive min rounds to start of month, inclusive max rounds to end of month
+        var baseTime = new DateTime(2023, 12, 25, 12, 0, 0);
+        var range = DateTimeRange.Parse("[now/M TO now/M]", baseTime);
+
+        Assert.NotEqual(DateTimeRange.Empty, range);
+        Assert.Equal(baseTime.StartOfMonth(), range.Start);
+        Assert.Equal(baseTime.EndOfMonth(), range.End);
+    }
+
+    [Fact]
+    public void Parse_InclusiveBracketsWithHourRounding_ReturnsFullHour()
+    {
+        // [now/h TO now/h] — inclusive min rounds to start of hour, inclusive max rounds to end of hour
+        var baseTime = new DateTime(2023, 12, 25, 12, 30, 0);
+        var range = DateTimeRange.Parse("[now/h TO now/h]", baseTime);
+
+        Assert.NotEqual(DateTimeRange.Empty, range);
+        Assert.Equal(baseTime.StartOfHour(), range.Start);
+        Assert.Equal(baseTime.EndOfHour(), range.End);
+    }
+
+    [Fact]
+    public void Parse_MixedBracketsWithDateMathOperations_ParsesCorrectly()
+    {
+        // [now-1d/d TO now/d} — inclusive start rounds down, exclusive end rounds down
+        var baseTime = new DateTime(2023, 12, 25, 12, 0, 0);
+        var range = DateTimeRange.Parse("[now-1d/d TO now/d}", baseTime);
+
+        Assert.NotEqual(DateTimeRange.Empty, range);
+        Assert.Equal(baseTime.AddDays(-1).StartOfDay(), range.Start);
+        Assert.Equal(baseTime.StartOfDay(), range.End);
+    }
 }

tests/Exceptionless.DateTimeExtensions.Tests/FormatParsers/TwoPartFormatParserTests.cs

@@ -33,25 +33,36 @@ public static IEnumerable<object[]> Inputs
                 ["jan to feb",       _now.ChangeMonth(1).StartOfMonth(), _now.ChangeMonth(2).EndOfMonth()],
                 ["5 days ago TO now", _now.SubtractDays(5).StartOfDay(), _now],
 
-                // Elasticsearch bracket syntax
+                // Elasticsearch inclusive bracket syntax [inclusive TO inclusive]
                 ["[2012 TO 2013]",   _now.ChangeYear(2012).StartOfYear(), _now.ChangeYear(2013).EndOfYear()],
-                ["{jan TO feb}",     _now.ChangeMonth(1).StartOfMonth(), _now.ChangeMonth(2).EndOfMonth()],
+                ["[jan TO feb]",     _now.ChangeMonth(1).StartOfMonth(), _now.ChangeMonth(2).EndOfMonth()],
                 ["[2012-2013]",      _now.ChangeYear(2012).StartOfYear(), _now.ChangeYear(2013).EndOfYear()],
 
+                // Elasticsearch exclusive bracket syntax {exclusive TO exclusive}
+                // Exclusive min rounds up (end of period), exclusive max rounds down (start of period)
+                ["{jan TO feb}",     _now.ChangeMonth(1).EndOfMonth(), _now.ChangeMonth(2).StartOfMonth()],
+                ["{2012 TO 2013}",   _now.ChangeYear(2012).EndOfYear(), _now.ChangeYear(2013).StartOfYear()],
+
+                // Mixed bracket syntax [inclusive TO exclusive}
+                ["[2012 TO 2013}",   _now.ChangeYear(2012).StartOfYear(), _now.ChangeYear(2013).StartOfYear()],
+                ["[jan TO feb}",     _now.ChangeMonth(1).StartOfMonth(), _now.ChangeMonth(2).StartOfMonth()],
+
+                // Mixed bracket syntax {exclusive TO inclusive]
+                ["{2012 TO 2013]",   _now.ChangeYear(2012).EndOfYear(), _now.ChangeYear(2013).EndOfYear()],
+                ["{jan TO feb]",     _now.ChangeMonth(1).EndOfMonth(), _now.ChangeMonth(2).EndOfMonth()],
+
                 // Wildcard support
                 ["* TO 2013",        DateTime.MinValue, _now.ChangeYear(2013).EndOfYear()],
                 ["2012 TO *",        _now.ChangeYear(2012).StartOfYear(), DateTime.MaxValue],
                 ["[* TO 2013]",      DateTime.MinValue, _now.ChangeYear(2013).EndOfYear()],
-                ["{2012 TO *}",      _now.ChangeYear(2012).StartOfYear(), DateTime.MaxValue],
+                ["{2012 TO *}",      _now.ChangeYear(2012).EndOfYear(), DateTime.MaxValue],
 
                 // Invalid inputs
                 ["blah",             null, null],
                 ["[invalid",         null, null],
                 ["invalid}",         null, null],
 
                 // Mismatched bracket validation
-                ["{2012 TO 2013]",   null, null], // Opening brace with closing bracket
-                ["[2012 TO 2013}",   null, null], // Opening bracket with closing brace
                 ["}2012 TO 2013{",   null, null], // Wrong orientation
                 ["]2012 TO 2013[",   null, null], // Wrong orientation
                 ["[2012 TO 2013",    null, null], // Missing closing bracket