Matching/templating: Improve flag parsing, multitemplate parsing, naming (allow->chars, lower/upper aliases), or_var -> or-var, map_default -> map-default, schema parsing, and better error messages. Yet to complete template expressions that map/allow/validate, proper two way flag sharing, and making the equals/allow/only stuff symmetrical.

Author: lilith

simplify.md

@@ -19,7 +19,7 @@ Analyze the existing matching tests, and add a test for failures so we know how
 *   **Argument Parsing:**
     *   Matching: Complex type detection (`GetArgType`), `CharacterClass` parsing, diverse argument types (`[...]`, `a|b|c`).
     *   Templating: Simpler string arguments, specific escaping (`\(\)\,`), comma delimiter default, pipe delimiter (`|`) for `equals`.
-*   **Optionality:** Different syntax and slightly different semantics (`:?` in matching vs. `:?`/`:optional`/`:default`/`:or_var` in templating).
+*   **Optionality:** Different syntax and slightly different semantics (`:?` in matching vs. `:?`/`:optional`/`:default`/`:or-var` in templating).
 *   **Query Keys:** Literals only in matching; can contain variables in templating.
 *   **Segment Boundaries:** Core concept in matching (`SegmentBoundary` influencing capture start/end); irrelevant in templating.
 
@@ -50,15 +50,15 @@ Analyze the existing matching tests, and add a test for failures so we know how
 
 *   **Proposal:** Standardize on `:?` (and `:optional` as an alias) in both syntaxes where the concept applies.
 *   **Matching:** Maintain existing `:?` behavior.
-*   **Templating:** Consolidate `:?` and `:optional` to one form. Note that `:default` and `:or_var` still imply optional *handling* (suppressing output on null/empty) which is distinct from the marker itself.
+*   **Templating:** Consolidate `:?` and `:optional` to one form. Note that `:default` and `:or-var` still imply optional *handling* (suppressing output on null/empty) which is distinct from the marker itself.
 *   **Impact:** Minor syntax cleanup and improved consistency.
 
 ### D. Naming Alignment (Conditions vs. Transforms)
 
 *   **Proposal:** Align names where functionality clearly overlaps, potentially using aliases.
     *   Examine `allow`/`only` (matching) vs. `equals` (templating). Direct replacement is hard due to `CharacterClass` vs. string array arguments. Consider adding an `equals(a|b|c)` condition to matching for parity?
-    *   Keep distinct names for clearly different concepts (`or_var`, `map`, `default`).
-    *   Ensure `map_default` (formerly `other`) is consistently named.
+    *   Keep distinct names for clearly different concepts (`or-var`, `map`, `default`).
+    *   Ensure `map-default` (formerly `other`) is consistently named.
 *   **Impact:** Improved clarity, primarily in documentation and code readability. Requires careful analysis of any subtle behavioral differences.
 
 ### E. Enhanced Error Reporting

src/Imageflow.Server/Internal/MiddlewareOptionsServerBuilder.cs

@@ -212,7 +212,7 @@ IEnumerable<IBlobProvider> blobProviders
                     h => WrapUrlEventArgs(h.PathPrefix, h.Handler, true)).ToList()));
         }
 
-        //TODO: Add a layer that can be used to set the cache key basis
+        //TODO: Add a layer that can be used to set the cache key basis ? for licensing ? -> mutating the query should already do that
         builder.AddMediaLayer(new LicensingLayer(licenseChecker));
 
 

src/Imazen.Routing/Matching/ExpressionFlags.cs

@@ -1,11 +1,35 @@
 using System.Collections.ObjectModel;
 using System.Diagnostics.CodeAnalysis;
 using System.Text.RegularExpressions;
+using Microsoft.Extensions.Options;
 
 namespace Imazen.Routing.Matching;
+public readonly record struct ExpressionFlagParsingOptions(Regex ValidationRegex, bool TrimTrailingExpressionWhitespace,
+bool AllowWhitespaceAfterBrackets,
+bool TrimWhitespaceAroundFlags){
+    public static readonly ExpressionFlagParsingOptions Permissive = new(ExpressionFlags.LatestPermissiveFlagSyntax(), true, true, true);
 
+
+    public static readonly ExpressionFlagParsingOptions LowercaseDash = new(ExpressionFlags.LowercaseDash(), true, true, true);
+
+    // WithValidationRegex
+    public ExpressionFlagParsingOptions WithValidationRegex(Regex validationRegex)
+    {
+        return new ExpressionFlagParsingOptions(validationRegex, TrimTrailingExpressionWhitespace, AllowWhitespaceAfterBrackets, TrimWhitespaceAroundFlags);
+    }
+}
 public partial record ExpressionFlags(ReadOnlyCollection<string> Flags)
 {
+
+    private static ReadOnlyMemory<char> TrimEnd(ReadOnlyMemory<char> text)
+    {
+#if NET6_0_OR_GREATER
+        return text.TrimEnd();
+#else
+        var span = text.Span.TrimEnd();
+        return text.Slice(0, span.Length);
+#endif
+    }
     /// <summary>
     /// Parses the flags from the end of the expression. Syntax is [flag1,flag2,flag3]
     /// </summary>
@@ -14,13 +38,22 @@ public partial record ExpressionFlags(ReadOnlyCollection<string> Flags)
     /// <param name="result"></param>
     /// <param name="error"></param>
     /// <returns></returns>
-    public static bool TryParseFromEnd(ReadOnlyMemory<char> expression, out ReadOnlyMemory<char> remainingExpression, out List<string> result, 
+    public static bool TryParseFromEnd(ReadOnlyMemory<char> expression, out ReadOnlyMemory<char> remainingExpression, out List<string> result,
         [NotNullWhen(false)]
-        out string? error, Regex validationRegex)
+        out string? error, ExpressionFlagParsingOptions options)
     {
         var flags = new List<string>();
+        if (options.TrimTrailingExpressionWhitespace)
+        {
+            expression = TrimEnd(expression);
+        }
+
         var span = expression.Span;
-        
+        if (options.AllowWhitespaceAfterBrackets)
+        {
+            span = span.TrimEnd();
+        }
+
         if (span.Length == 0 || span[^1] != ']')
         {
             //It's ok for there to be none
@@ -37,33 +70,33 @@ public static bool TryParseFromEnd(ReadOnlyMemory<char> expression, out ReadOnly
             remainingExpression = expression;
             return false;
         }
-        remainingExpression = expression[..startAt];
+        remainingExpression = options.TrimTrailingExpressionWhitespace ? TrimEnd(expression[..startAt]) : expression[..startAt];
         var inner = expression[(startAt + 1)..^1];
         var innerSpan = inner.Span;
         while (innerSpan.Length > 0)
         {
             var commaIndex = innerSpan.IndexOf(',');
             if (commaIndex == -1)
             {
-                flags.Add(inner.Span.Trim().ToString());
+                flags.Add(options.TrimWhitespaceAroundFlags ? inner.Span.Trim().ToString() : inner.Span.ToString());
                 break;
             }
-            flags.Add(inner.Span[..commaIndex].Trim().ToString());
+            flags.Add(options.TrimWhitespaceAroundFlags ? inner.Span[..commaIndex].Trim().ToString() : inner.Span[..commaIndex].ToString());
             inner = inner[(commaIndex + 1)..];
             innerSpan = inner.Span;
         }
-        // validate 
+        // validate flags
         foreach (var flag in flags)
         {
-            if (!validationRegex.IsMatch(flag))
+            if (!options.ValidationRegex.IsMatch(flag))
             {
                 result = flags;
-                error = $"Invalid flag '{flag}', it does not match the required format {validationRegex}.";
+                error = $"Invalid flag '{flag}', it does not match the required format {options.ValidationRegex}.";
                 return false;
             }
         }
         // Handle [flag][flag]etc, recursively
-        if (!TryParseFromEnd(remainingExpression, out var remainingExpression2, out var flags2, out error, validationRegex))
+        if (!TryParseFromEnd(remainingExpression, out var remainingExpression2, out var flags2, out error, options))
         {
             remainingExpression = remainingExpression2;
             flags.AddRange(flags2);
@@ -103,4 +136,17 @@ public static bool TryParseFromEnd(ReadOnlyMemory<char> expression, out ReadOnly
 
     public static Regex LowercaseDash() => LowercaseDashVar;
 #endif
+
+    // Allow k/v pairs as well, [a-zA-Z-][a-zA-Z0-9-]*([=][a-zA-Z0-9-]+)?
+#if NET8_0_OR_GREATER
+    [GeneratedRegex(@"^[a-zA-Z-_][a-zA-Z0-9-]*([=][a-zA-Z0-9-_]+)?$")]
+    public static partial Regex LatestPermissiveFlagSyntax();
+#else
+
+    public static readonly Regex LatestPermissiveFlagSyntaxVar =
+        new(@"^[a-zA-Z-_][a-zA-Z0-9-]*([=][a-zA-Z0-9-_]+)?$");
+
+    public static Regex LatestPermissiveFlagSyntax() => LatestPermissiveFlagSyntaxVar;
+#endif
+
 }

src/Imazen.Routing/Matching/ExpressionParsingHelpers.cs

@@ -82,6 +82,38 @@ internal static int FindCharNotEscaped(ReadOnlySpan<char> str,char c, char escap
         }
         return -1;
     }
+    internal static int FindCharNotEscapedAtDepth0(ReadOnlySpan<char> str,char c, char escapeChar, char openChar, char closeChar)
+    {
+        var consecutiveEscapeChars = 0;
+        var depth = 0;
+        for (var i = 0; i < str.Length; i++)
+        {
+            if (str[i] == escapeChar)
+            {
+                consecutiveEscapeChars++;
+                continue;
+            }
+
+            if (consecutiveEscapeChars % 2 == 0)
+            {
+                if (str[i] == c && depth == 0)
+                {
+                    return i;
+                }
+                if (str[i] == openChar)
+                {
+                    depth++;
+                }
+                if (str[i] == closeChar)
+                {
+                    depth--;
+                }
+            }
+            consecutiveEscapeChars = 0;
+
+        }
+        return -1;
+    }
 
 
 #if NET8_0_OR_GREATER
@@ -131,6 +163,27 @@ internal static bool ValidateSegmentName(string name, ReadOnlySpan<char> segment
         return true;
     }
 
+    internal static bool ValidateVariableName(string name, [NotNullWhen(false)]out string? error)
+    {
+        if (name.Length == 0)
+        {
+            error = "Variable names cannot be empty";
+            return false;
+        }
+        if (!ValidSegmentName().IsMatch(name))
+        {
+            error = $"Invalid variable name '{name}'. Names must start with a letter or underscore, and contain only letters, numbers, or underscores";
+            return false;
+        }
+        if (StringCondition.IsReservedName(name))
+        {
+            error = $"Invalid variable name '{name}' - that is a reserved word.";
+            return false;
+        }
+        error = null;
+        return true;
+    }
+
     internal static bool TryReadConditionName(ReadOnlySpan<char> text, 
         [NotNullWhen(true)] out int? conditionNameEnds,
         [NotNullWhen(false)] out string? error)

src/Imazen.Routing/Matching/ExpressionParsingOptions.cs

@@ -40,7 +40,7 @@ internal static ExpressionParsingOptions SubtractFromFlags(List<string> flags, E
     public static ExpressionParsingOptions ParseComplete(ReadOnlyMemory<char> expressionWithFlags, out ReadOnlyMemory<char> remainingExpression)
     {
         if (!ExpressionFlags.TryParseFromEnd(expressionWithFlags, out var expression, out var flags, out var error,
-            ExpressionFlags.LowercaseDash()))
+            ExpressionFlagParsingOptions.Permissive.WithValidationRegex(ExpressionFlags.LowercaseDash())))
         {
             throw new ArgumentException(error, nameof(expressionWithFlags));
         }

src/Imazen.Routing/Matching/MatchSegment.cs

@@ -66,7 +66,7 @@ internal static bool TryParseSegmentExpression(ExpressionParsingOptions options,
             var innerMem = exprMemory[1..^1];
             if (innerMem.Length == 0)
             {
-                error = "Segment {} cannot be empty. Try {*}, {name}, {name:condition1:condition2}";
+                error = "Segment {} cannot be empty. Try {name}, {name:condition1:condition2}";
                 segment = null;
                 return false;
             }

src/Imazen.Routing/Matching/MultiValueMatcher.cs

@@ -73,7 +73,7 @@ public static bool TryParse(ReadOnlyMemory<char> expressionWithFlags,
         [NotNullWhen(true)] out MultiValueMatcher? result, [NotNullWhen(false)] out string? error)
     {
         if (!ExpressionFlags.TryParseFromEnd(expressionWithFlags, out var expression, out var flags, out error,
-            ExpressionFlags.LowercaseDash()))
+            ExpressionFlagParsingOptions.LowercaseDash))
         {
             result = null;
             return false;
@@ -285,4 +285,4 @@ internal MultiMatchResult Match(in MatchingContext context, in ReadOnlyMemory<ch
         return new MultiMatchResult { Success = true, Captures = captures, ExcessQueryKeys = excessKeyNames, OriginalQuery = query };
     }
 
-}
+}