Fixes

javiercn · javiercn · commit 18667d3262fe · 2024-10-24T18:31:37.000+02:00
diff --git a/src/StaticWebAssetsSdk/Tasks/Data/StaticWebAssetPathPattern.cs b/src/StaticWebAssetsSdk/Tasks/Data/StaticWebAssetPathPattern.cs
@@ -7,12 +7,21 @@ namespace Microsoft.AspNetCore.StaticWebAssets.Tasks;
 
 #if WASM_TASKS
 [DebuggerDisplay($"{{{nameof(GetDebuggerDisplay)}(),nq}}")]
+[System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "IDE0057:Use range operator", Justification = "Can't use range syntax in full framework")]
 internal sealed class StaticWebAssetPathPattern : IEquatable<StaticWebAssetPathPattern>
 #else
 [DebuggerDisplay($"{{{nameof(GetDebuggerDisplay)}(),nq}}")]
 public sealed class StaticWebAssetPathPattern : IEquatable<StaticWebAssetPathPattern>
 #endif
 {
+    private const string FingerprintStart = "#[";
+    private const string FingerprintEnd = "]";
+    private const char FingerprintOptional = '?';
+    private const char FingerprintPreferred = '!';
+    private const char FingerprintValueSeparator = '=';
+    private const char FingerprintParameterStart = '{';
+    private const char FingerprintParameterEnd = '}';
+
     public StaticWebAssetPathPattern(string path) : this(path.AsMemory()) { }
 
     public StaticWebAssetPathPattern(ReadOnlyMemory<char> rawPathMemory) => RawPattern = rawPathMemory;
@@ -61,28 +70,27 @@ public StaticWebAssetPathPattern(List<StaticWebAssetPathSegment> segments)
     public static StaticWebAssetPathPattern Parse(ReadOnlyMemory<char> rawPathMemory, string assetIdentity = null)
     {
         var pattern = new StaticWebAssetPathPattern(rawPathMemory);
-        var nextToken = MemoryExtensions.IndexOf(rawPathMemory.Span, "#[".AsSpan(), StringComparison.OrdinalIgnoreCase);
+        var current = rawPathMemory;
+        var nextToken = MemoryExtensions.IndexOf(current.Span, FingerprintStart.AsSpan(), StringComparison.OrdinalIgnoreCase);
         if (nextToken == -1)
         {
             var literalSegment = new StaticWebAssetPathSegment();
-            literalSegment.Parts.Add(new StaticWebAssetSegmentPart { Name = rawPathMemory, IsLiteral = true });
+            literalSegment.Parts.Add(new StaticWebAssetSegmentPart { Name = current, IsLiteral = true });
             pattern.Segments.Add(literalSegment);
             return pattern;
         }
 
         if (nextToken > 0)
         {
             var literalSegment = new StaticWebAssetPathSegment();
-#if NET9_0_OR_GREATER
-            literalSegment.Parts.Add(new StaticWebAssetSegmentPart { Name = rawPathMemory[..nextToken], IsLiteral = true });
-#else
-            literalSegment.Parts.Add(new StaticWebAssetSegmentPart { Name = rawPathMemory.Slice(0, nextToken), IsLiteral = true });
-#endif
+            literalSegment.Parts.Add(new StaticWebAssetSegmentPart { Name = current.Slice(0, nextToken), IsLiteral = true });
             pattern.Segments.Add(literalSegment);
         }
+
         while (nextToken != -1)
         {
-            var tokenEnd = MemoryExtensions.IndexOf(rawPathMemory.Slice(nextToken).Span, "]".AsSpan(), StringComparison.Ordinal);
+            current = current.Slice(nextToken);
+            var tokenEnd = MemoryExtensions.IndexOf(current.Span, FingerprintEnd.AsSpan(), StringComparison.Ordinal);
             if (tokenEnd == -1)
             {
                 if (assetIdentity != null)
@@ -96,31 +104,36 @@ public static StaticWebAssetPathPattern Parse(ReadOnlyMemory<char> rawPathMemory
                 }
             }
 
-            var tokenExpression = rawPathMemory.Slice(nextToken + 2, tokenEnd - nextToken - 2);
+            var tokenExpression = current.Slice(2, tokenEnd - 2);
 
             var token = new StaticWebAssetPathSegment();
             AddTokenSegmentParts(tokenExpression, token);
             pattern.Segments.Add(token);
 
             // Check if the segment is optional (ends with ? or !)
-            if (tokenEnd < rawPathMemory.Length - 1 && (rawPathMemory.Span[tokenEnd + 1] == '?' || rawPathMemory.Span[tokenEnd + 1] == '!'))
+            if (tokenEnd < current.Length - 1 &&
+                (current.Span[tokenEnd + 1] == FingerprintOptional || current.Span[tokenEnd + 1] == FingerprintPreferred))
             {
                 token.IsOptional = true;
-                if (rawPathMemory.Span[tokenEnd + 1] == '!')
+                if (current.Span[tokenEnd + 1] == FingerprintPreferred)
                 {
                     token.IsPreferred = true;
                 }
                 tokenEnd++;
             }
+            current = current.Slice(tokenEnd + 1);
+            nextToken = MemoryExtensions.IndexOf(current.Span, FingerprintStart.AsSpan(), StringComparison.OrdinalIgnoreCase);
 
-            nextToken = MemoryExtensions.IndexOf(rawPathMemory.Slice(tokenEnd).Span, "#[".AsSpan(), StringComparison.OrdinalIgnoreCase);
-
-            // Add a literal segment if there is more content after the token and before the next one
-            if ((nextToken != -1 && nextToken > tokenEnd + 1) || (nextToken == -1 && tokenEnd < rawPathMemory.Length - 1))
+            if (nextToken == -1 && current.Length > 0)
             {
-                var literalEnd = nextToken == -1 ? rawPathMemory.Length : nextToken;
                 var literalSegment = new StaticWebAssetPathSegment();
-                literalSegment.Parts.Add(new StaticWebAssetSegmentPart { Name = rawPathMemory.Slice(tokenEnd + 1, literalEnd - tokenEnd - 1), IsLiteral = true });
+                literalSegment.Parts.Add(new StaticWebAssetSegmentPart { Name = current, IsLiteral = true });
+                pattern.Segments.Add(literalSegment);
+            }
+            else if (nextToken > 0)
+            {
+                var literalSegment = new StaticWebAssetPathSegment();
+                literalSegment.Parts.Add(new StaticWebAssetSegmentPart { Name = current.Slice(0, nextToken), IsLiteral = true });
                 pattern.Segments.Add(literalSegment);
             }
         }
@@ -170,14 +183,15 @@ public static StaticWebAssetPathPattern Parse(string rawPath, string assetIdenti
                 var missingValue = "";
                 foreach (var tokenName in tokenNames)
                 {
-                    if (!tokens.TryGetValue(staticWebAsset, tokenName.ToString(), out var tokenValue) || string.IsNullOrEmpty(tokenValue))
+                    var tokenNameString = tokenName.ToString();
+                    if (!tokens.TryGetValue(staticWebAsset, tokenNameString, out var tokenValue) || string.IsNullOrEmpty(tokenValue))
                     {
                         foundAllValues = false;
-                        missingValue = tokenName.ToString();
+                        missingValue = tokenNameString;
                         break;
                     }
 
-                    dictionary[tokenName.ToString()] = tokenValue;
+                    dictionary[tokenNameString] = tokenValue;
                 }
 
                 if (!foundAllValues && !segment.IsOptional)
@@ -368,46 +382,50 @@ internal void EmbedTokens(StaticWebAsset staticWebAsset, StaticWebAssetTokenReso
     // The value within the {} represents token variables.
     private static void AddTokenSegmentParts(ReadOnlyMemory<char> tokenExpression, StaticWebAssetPathSegment token)
     {
-        var nextToken = MemoryExtensions.IndexOf(tokenExpression.Span, "{".AsSpan(), StringComparison.Ordinal);
+        var current = tokenExpression;
+        var nextToken = MemoryExtensions.IndexOf(current.Span, FingerprintParameterStart);
         if (nextToken is not (-1) and > 0)
         {
-#if NET9_0_OR_GREATER
-            var literalPart = new StaticWebAssetSegmentPart { Name = tokenExpression[..nextToken], IsLiteral = true };
-#else
-            var literalPart = new StaticWebAssetSegmentPart { Name = tokenExpression.Slice(0, nextToken), IsLiteral = true };
-#endif
+            var literalPart = new StaticWebAssetSegmentPart { Name = current.Slice(0, nextToken), IsLiteral = true };
             token.Parts.Add(literalPart);
         }
+
         while (nextToken != -1)
         {
-            var tokenEnd = MemoryExtensions.IndexOf(tokenExpression.Slice(nextToken).Span, "}".AsSpan(), StringComparison.Ordinal);
+            current = current.Slice(nextToken);
+            var tokenEnd = MemoryExtensions.IndexOf(current.Span, FingerprintParameterEnd);
             if (tokenEnd == -1)
             {
                 throw new InvalidOperationException($"Invalid token expression '{tokenExpression}'. Missing '}}' token.");
             }
 
-            var embeddedValue = MemoryExtensions.IndexOf(tokenExpression.Slice(nextToken).Span, "=".AsSpan(), StringComparison.Ordinal);
+            var embeddedValue = MemoryExtensions.IndexOf(current.Span, FingerprintValueSeparator);
             if (embeddedValue != -1)
             {
                 var tokenPart = new StaticWebAssetSegmentPart
                 {
-                    Name = tokenExpression.Slice(nextToken + 1, embeddedValue - nextToken - 1),
+                    Name = current.Slice(1, embeddedValue - 1),
                     IsLiteral = false,
-                    Value = tokenExpression.Slice(embeddedValue + 1, tokenEnd - embeddedValue - 1)
+                    Value = current.Slice(embeddedValue + 1, tokenEnd - embeddedValue - 1)
                 };
                 token.Parts.Add(tokenPart);
             }
             else
             {
-                var tokenPart = new StaticWebAssetSegmentPart { Name = tokenExpression.Slice(nextToken + 1, tokenEnd - nextToken - 1), IsLiteral = false };
+                var tokenPart = new StaticWebAssetSegmentPart { Name = current.Slice(1, tokenEnd - 1), IsLiteral = false };
                 token.Parts.Add(tokenPart);
             }
 
-            nextToken = MemoryExtensions.IndexOf(tokenExpression.Slice(tokenEnd).Span, "}".AsSpan(), StringComparison.Ordinal);
-            if ((nextToken != -1 && nextToken > tokenEnd + 1) || (nextToken == -1 && tokenEnd < tokenExpression.Length - 1))
+            current = current.Slice(tokenEnd + 1);
+            nextToken = MemoryExtensions.IndexOf(current.Span, FingerprintParameterStart);
+            if (nextToken == -1 && current.Length > 0)
+            {
+                var literalPart = new StaticWebAssetSegmentPart { Name = current, IsLiteral = true };
+                token.Parts.Add(literalPart);
+            }
+            else if (nextToken > 0)
             {
-                var literalEnd = nextToken == -1 ? tokenExpression.Length : nextToken;
-                var literalPart = new StaticWebAssetSegmentPart { Name = tokenExpression.Slice(tokenEnd + 1, literalEnd - tokenEnd - 1), IsLiteral = true };
+                var literalPart = new StaticWebAssetSegmentPart { Name = current.Slice(0, nextToken), IsLiteral = true };
                 token.Parts.Add(literalPart);
             }
         }
diff --git a/src/StaticWebAssetsSdk/Tasks/Data/StaticWebAssetPathSegment.cs b/src/StaticWebAssetsSdk/Tasks/Data/StaticWebAssetPathSegment.cs
@@ -57,7 +57,7 @@ internal ICollection<ReadOnlyMemory<char>> GetTokenNames()
         var result = new HashSet<ReadOnlyMemory<char>>();
         foreach (var part in Parts)
         {
-            if (!part.IsLiteral && part.Value.Length > 0)
+            if (!part.IsLiteral && part.Name.Length > 0)
             {
                 result.Add(part.Name);
             }
diff --git a/src/StaticWebAssetsSdk/Tasks/Data/StaticWebAssetSegmentPart.cs b/src/StaticWebAssetsSdk/Tasks/Data/StaticWebAssetSegmentPart.cs
@@ -1,8 +1,11 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Diagnostics;
+
 namespace Microsoft.AspNetCore.StaticWebAssets.Tasks;
 
+[DebuggerDisplay($"{{{nameof(GetDebuggerDisplay)}(),nq}}")]
 public class StaticWebAssetSegmentPart : IEquatable<StaticWebAssetSegmentPart>
 {
     public ReadOnlyMemory<char> Name { get; set; }
@@ -33,4 +36,6 @@ public override int GetHashCode()
 
     public static bool operator ==(StaticWebAssetSegmentPart left, StaticWebAssetSegmentPart right) => EqualityComparer<StaticWebAssetSegmentPart>.Default.Equals(left, right);
     public static bool operator !=(StaticWebAssetSegmentPart left, StaticWebAssetSegmentPart right) => !(left == right);
+
+    private string GetDebuggerDisplay() => IsLiteral ? Value.ToString() : $"{{{Name}}}";
 }
diff --git a/src/StaticWebAssetsSdk/Tasks/DefineStaticWebAssets.cs b/src/StaticWebAssetsSdk/Tasks/DefineStaticWebAssets.cs
@@ -89,7 +89,7 @@ public override bool Execute()
                 null;
 
             var assetsByRelativePath = new Dictionary<string, List<ITaskItem>>();
-            var fingerprintPatternMatcher = new FingerprintPatternMatcher(Log, FingerprintPatterns);
+            var fingerprintPatternMatcher = new FingerprintPatternMatcher(Log, FingerprintCandidates ? (FingerprintPatterns ?? []) : []);
             var matchContext = StaticWebAssetGlobMatcher.CreateMatchContext();
             for (var i = 0; i < CandidateAssets.Length; i++)
             {
@@ -234,7 +234,7 @@ public override bool Execute()
 
                 if (FingerprintCandidates)
                 {
-                    matchContext.SetPathAndReinitialize(candidate.ItemSpec);
+                    matchContext.SetPathAndReinitialize(relativePathCandidate);
                     relativePathCandidate = StaticWebAsset.Normalize(fingerprintPatternMatcher.AppendFingerprintPattern(matchContext, identity));
                 }
 
diff --git a/src/StaticWebAssetsSdk/Tasks/FingerprintPatternMatcher.cs b/src/StaticWebAssetsSdk/Tasks/FingerprintPatternMatcher.cs
@@ -45,7 +45,7 @@ public string AppendFingerprintPattern(StaticWebAssetGlobMatcher.MatchContext co
 
         var (directoryName, fileName, fileNamePrefix, extension) =
 #if NET9_0_OR_GREATER
-                ComputeFingerprintFragments(relativePathCandidateMemory);
+            ComputeFingerprintFragments(relativePathCandidateMemory);
 #else
             ComputeFingerprintFragments(context.PathString);
 #endif
@@ -55,7 +55,7 @@ public string AppendFingerprintPattern(StaticWebAssetGlobMatcher.MatchContext co
         if (!matchResult.IsMatch)
         {
 #if NET9_0_OR_GREATER
-                var result = Path.Combine(directoryName.ToString(), $"{fileNamePrefix}{DefaultFingerprintExpression}{extension}");
+            var result = Path.Combine(directoryName.ToString(), $"{fileNamePrefix}{DefaultFingerprintExpression}{extension}");
 #else
             var result = Path.Combine(directoryName, $"{fileNamePrefix}{DefaultFingerprintExpression}{extension}");
 #endif
@@ -71,8 +71,8 @@ public string AppendFingerprintPattern(StaticWebAssetGlobMatcher.MatchContext co
             }
             else
             {
-                var stem = GetMatchStem(relativePathCandidateMemory, matchResult.Pattern);
-                var matchExtension = GetMatchExtension(relativePathCandidateMemory, stem);
+                var stem = GetMatchStem(fileName, matchResult.Pattern.AsMemory().Slice(2));
+                var matchExtension = GetMatchExtension(fileName, stem);
 
                 var simpleExtensionResult = Path.Combine(directoryName.ToString(), $"{stem}{expression}{matchExtension}");
                 _log.LogMessage(MessageImportance.Low, "Fingerprinting asset '{0}' as '{1}'", relativePathCandidateMemory, simpleExtensionResult);
@@ -102,11 +102,17 @@ static bool AlreadyContainsFingerprint(ReadOnlyMemory<char> relativePathCandidat
             return false;
         }
 
+#if NET9_0_OR_GREATER
+        static ReadOnlySpan<char> GetMatchExtension(ReadOnlySpan<char> relativePathCandidateMemory, ReadOnlySpan<char> stem) =>
+            relativePathCandidateMemory.Slice(stem.Length);
+        static ReadOnlySpan<char> GetMatchStem(ReadOnlySpan<char> relativePathCandidateMemory, ReadOnlyMemory<char> pattern) =>
+            relativePathCandidateMemory.Slice(0, relativePathCandidateMemory.Length - pattern.Length - 1);
+#else
         static ReadOnlyMemory<char> GetMatchExtension(ReadOnlyMemory<char> relativePathCandidateMemory, ReadOnlyMemory<char> stem) =>
             relativePathCandidateMemory.Slice(stem.Length);
-
-        static ReadOnlyMemory<char> GetMatchStem(ReadOnlyMemory<char> relativePathCandidateMemory, string pattern) =>
+        static ReadOnlyMemory<char> GetMatchStem(ReadOnlyMemory<char> relativePathCandidateMemory, ReadOnlyMemory<char> pattern) =>
             relativePathCandidateMemory.Slice(0, relativePathCandidateMemory.Length - pattern.Length - 1);
+#endif
     }
 
 #if NET9_0_OR_GREATER
@@ -121,13 +127,13 @@ private static FingerprintFragments ComputeFingerprintFragments(
         return new(directoryName, fileName, stem, extension);
     }
 #else
-    private static (string directoryName, string fileName, string fileNamePrefix, string extension) ComputeFingerprintFragments(
+    private static (string directoryName, ReadOnlyMemory<char> fileName, ReadOnlyMemory<char> fileNamePrefix, ReadOnlyMemory<char> extension) ComputeFingerprintFragments(
         string relativePathCandidate)
     {
-        var fileName = Path.GetFileName(relativePathCandidate);
+        var fileName = Path.GetFileName(relativePathCandidate).AsMemory();
         var directoryName = Path.GetDirectoryName(relativePathCandidate);
-        var stem = Path.GetFileNameWithoutExtension(relativePathCandidate);
-        var extension = Path.GetExtension(relativePathCandidate);
+        var stem = Path.GetFileNameWithoutExtension(relativePathCandidate).AsMemory();
+        var extension = Path.GetExtension(relativePathCandidate).AsMemory();
 
         return (directoryName, fileName, stem, extension);
     }
diff --git a/src/StaticWebAssetsSdk/Tasks/Utils/Globbing/PathTokenizer.cs b/src/StaticWebAssetsSdk/Tasks/Utils/Globbing/PathTokenizer.cs
@@ -5,6 +5,7 @@
 
 namespace Microsoft.AspNetCore.StaticWebAssets.Tasks;
 
+#if !NET9_0_OR_GREATER
 public ref struct PathTokenizer(ReadOnlySpan<char> path)
 {
     private readonly ReadOnlySpan<char> _path = path;
@@ -70,3 +71,48 @@ private SegmentCollection(ReadOnlySpan<char> path, List<Segment> segments, int i
         internal SegmentCollection Slice(int segmentIndex) => new (_path, segments, segmentIndex);
     }
 }
+#else
+public ref struct PathTokenizer(ReadOnlySpan<char> path)
+{
+    private readonly ReadOnlySpan<char> _path = path;
+
+    public struct Segment(int start, int length)
+    {
+        public int Start { get; set; } = start;
+        public int Length { get; set; } = length;
+    }
+
+    internal SegmentCollection Fill(List<Segment> segments)
+    {
+        foreach (var range in MemoryExtensions.SplitAny(_path, OSPath.DirectoryPathSeparators.Span))
+        {
+            var length = range.End.Value - range.Start.Value;
+            if (length > 0 &&
+                !_path.Slice(range.Start.Value, length).Equals(".".AsSpan(), StringComparison.Ordinal) &&
+                !_path.Slice(range.Start.Value, length).Equals("..".AsSpan(), StringComparison.Ordinal))
+            {
+                segments.Add(new(range.Start.Value, length));
+            }
+        }
+
+        return new SegmentCollection(_path, segments);
+    }
+
+    public readonly ref struct SegmentCollection(ReadOnlySpan<char> path, List<Segment> segments)
+    {
+        private readonly ReadOnlySpan<char> _path = path;
+        private readonly int _index = 0;
+
+        private SegmentCollection(ReadOnlySpan<char> path, List<Segment> segments, int index) : this(path, segments) =>
+            _index = index;
+
+        public int Count => segments.Count - _index;
+
+        public ReadOnlySpan<char> this[int index] => _path.Slice(segments[index + _index].Start, segments[index + _index].Length);
+
+        public ReadOnlyMemory<char> this[ReadOnlyMemory<char> path, int index] => path.Slice(segments[index + _index].Start, segments[index + _index].Length);
+
+        internal SegmentCollection Slice(int segmentIndex) => new(_path, segments, segmentIndex);
+    }
+}
+#endif
diff --git a/src/StaticWebAssetsSdk/Tasks/Utils/Globbing/StaticWebAssetGlobMatcher.cs b/src/StaticWebAssetsSdk/Tasks/Utils/Globbing/StaticWebAssetGlobMatcher.cs
diff --git a/test/Microsoft.NET.Sdk.Razor.Tests/StaticWebAssets/Globbing/PathTokenizerTest.cs b/test/Microsoft.NET.Sdk.Razor.Tests/StaticWebAssets/Globbing/PathTokenizerTest.cs

Original file line number	Diff line number	Diff line change
`@@ -7,12 +7,21 @@ namespace Microsoft.AspNetCore.StaticWebAssets.Tasks;`
`7`	`7`
`8`	`8`	`#if WASM_TASKS`
`9`	`9`	`[DebuggerDisplay($"{{{nameof(GetDebuggerDisplay)}(),nq}}")]`
	`10`	`+[System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "IDE0057:Use range operator", Justification = "Can't use range syntax in full framework")]`
`10`	`11`	`internal sealed class StaticWebAssetPathPattern : IEquatable<StaticWebAssetPathPattern>`
`11`	`12`	`#else`
`12`	`13`	`[DebuggerDisplay($"{{{nameof(GetDebuggerDisplay)}(),nq}}")]`
`13`	`14`	`public sealed class StaticWebAssetPathPattern : IEquatable<StaticWebAssetPathPattern>`
`14`	`15`	`#endif`
`15`	`16`	`{`
	`17`	`+ private const string FingerprintStart = "#[";`
	`18`	`+ private const string FingerprintEnd = "]";`
	`19`	`+ private const char FingerprintOptional = '?';`
	`20`	`+ private const char FingerprintPreferred = '!';`
	`21`	`+ private const char FingerprintValueSeparator = '=';`
	`22`	`+ private const char FingerprintParameterStart = '{';`
	`23`	`+ private const char FingerprintParameterEnd = '}';`
	`24`	`+`
`16`	`25`	`public StaticWebAssetPathPattern(string path) : this(path.AsMemory()) { }`
`17`	`26`
`18`	`27`	`public StaticWebAssetPathPattern(ReadOnlyMemory<char> rawPathMemory) => RawPattern = rawPathMemory;`
`@@ -61,28 +70,27 @@ public StaticWebAssetPathPattern(List<StaticWebAssetPathSegment> segments)`
`61`	`70`	`public static StaticWebAssetPathPattern Parse(ReadOnlyMemory<char> rawPathMemory, string assetIdentity = null)`
`62`	`71`	`{`
`63`	`72`	`var pattern = new StaticWebAssetPathPattern(rawPathMemory);`
`64`		`- var nextToken = MemoryExtensions.IndexOf(rawPathMemory.Span, "#[".AsSpan(), StringComparison.OrdinalIgnoreCase);`
	`73`	`+ var current = rawPathMemory;`
	`74`	`+ var nextToken = MemoryExtensions.IndexOf(current.Span, FingerprintStart.AsSpan(), StringComparison.OrdinalIgnoreCase);`
`65`	`75`	`if (nextToken == -1)`
`66`	`76`	`{`
`67`	`77`	`var literalSegment = new StaticWebAssetPathSegment();`
`68`		`- literalSegment.Parts.Add(new StaticWebAssetSegmentPart { Name = rawPathMemory, IsLiteral = true });`
	`78`	`+ literalSegment.Parts.Add(new StaticWebAssetSegmentPart { Name = current, IsLiteral = true });`
`69`	`79`	`pattern.Segments.Add(literalSegment);`
`70`	`80`	`return pattern;`
`71`	`81`	`}`
`72`	`82`
`73`	`83`	`if (nextToken > 0)`
`74`	`84`	`{`
`75`	`85`	`var literalSegment = new StaticWebAssetPathSegment();`
`76`		`-#if NET9_0_OR_GREATER`
`77`		`- literalSegment.Parts.Add(new StaticWebAssetSegmentPart { Name = rawPathMemory[..nextToken], IsLiteral = true });`
`78`		`-#else`
`79`		`- literalSegment.Parts.Add(new StaticWebAssetSegmentPart { Name = rawPathMemory.Slice(0, nextToken), IsLiteral = true });`
`80`		`-#endif`
	`86`	`+ literalSegment.Parts.Add(new StaticWebAssetSegmentPart { Name = current.Slice(0, nextToken), IsLiteral = true });`
`81`	`87`	`pattern.Segments.Add(literalSegment);`
`82`	`88`	`}`
	`89`	`+`
`83`	`90`	`while (nextToken != -1)`
`84`	`91`	`{`
`85`		`- var tokenEnd = MemoryExtensions.IndexOf(rawPathMemory.Slice(nextToken).Span, "]".AsSpan(), StringComparison.Ordinal);`
	`92`	`+ current = current.Slice(nextToken);`
	`93`	`+ var tokenEnd = MemoryExtensions.IndexOf(current.Span, FingerprintEnd.AsSpan(), StringComparison.Ordinal);`
`86`	`94`	`if (tokenEnd == -1)`
`87`	`95`	`{`
`88`	`96`	`if (assetIdentity != null)`
`@@ -96,31 +104,36 @@ public static StaticWebAssetPathPattern Parse(ReadOnlyMemory<char> rawPathMemory`
`96`	`104`	`}`
`97`	`105`	`}`
`98`	`106`
`99`		`- var tokenExpression = rawPathMemory.Slice(nextToken + 2, tokenEnd - nextToken - 2);`
	`107`	`+ var tokenExpression = current.Slice(2, tokenEnd - 2);`
`100`	`108`
`101`	`109`	`var token = new StaticWebAssetPathSegment();`
`102`	`110`	`AddTokenSegmentParts(tokenExpression, token);`
`103`	`111`	`pattern.Segments.Add(token);`
`104`	`112`
`105`	`113`	`// Check if the segment is optional (ends with ? or !)`
`106`		`- if (tokenEnd < rawPathMemory.Length - 1 && (rawPathMemory.Span[tokenEnd + 1] == '?' \|\| rawPathMemory.Span[tokenEnd + 1] == '!'))`
	`114`	`+ if (tokenEnd < current.Length - 1 &&`
	`115`	`+ (current.Span[tokenEnd + 1] == FingerprintOptional \|\| current.Span[tokenEnd + 1] == FingerprintPreferred))`
`107`	`116`	`{`
`108`	`117`	`token.IsOptional = true;`
`109`		`- if (rawPathMemory.Span[tokenEnd + 1] == '!')`
	`118`	`+ if (current.Span[tokenEnd + 1] == FingerprintPreferred)`
`110`	`119`	`{`
`111`	`120`	`token.IsPreferred = true;`
`112`	`121`	`}`
`113`	`122`	`tokenEnd++;`
`114`	`123`	`}`
	`124`	`+ current = current.Slice(tokenEnd + 1);`
	`125`	`+ nextToken = MemoryExtensions.IndexOf(current.Span, FingerprintStart.AsSpan(), StringComparison.OrdinalIgnoreCase);`
`115`	`126`
`116`		`- nextToken = MemoryExtensions.IndexOf(rawPathMemory.Slice(tokenEnd).Span, "#[".AsSpan(), StringComparison.OrdinalIgnoreCase);`
`117`		`-`
`118`		`- // Add a literal segment if there is more content after the token and before the next one`
`119`		`- if ((nextToken != -1 && nextToken > tokenEnd + 1) \|\| (nextToken == -1 && tokenEnd < rawPathMemory.Length - 1))`
	`127`	`+ if (nextToken == -1 && current.Length > 0)`
`120`	`128`	`{`
`121`		`- var literalEnd = nextToken == -1 ? rawPathMemory.Length : nextToken;`
`122`	`129`	`var literalSegment = new StaticWebAssetPathSegment();`
`123`		`- literalSegment.Parts.Add(new StaticWebAssetSegmentPart { Name = rawPathMemory.Slice(tokenEnd + 1, literalEnd - tokenEnd - 1), IsLiteral = true });`
	`130`	`+ literalSegment.Parts.Add(new StaticWebAssetSegmentPart { Name = current, IsLiteral = true });`
	`131`	`+ pattern.Segments.Add(literalSegment);`
	`132`	`+ }`
	`133`	`+ else if (nextToken > 0)`
	`134`	`+ {`
	`135`	`+ var literalSegment = new StaticWebAssetPathSegment();`
	`136`	`+ literalSegment.Parts.Add(new StaticWebAssetSegmentPart { Name = current.Slice(0, nextToken), IsLiteral = true });`
`124`	`137`	`pattern.Segments.Add(literalSegment);`
`125`	`138`	`}`
`126`	`139`	`}`
`@@ -170,14 +183,15 @@ public static StaticWebAssetPathPattern Parse(string rawPath, string assetIdenti`
`170`	`183`	`var missingValue = "";`
`171`	`184`	`foreach (var tokenName in tokenNames)`
`172`	`185`	`{`
`173`		`- if (!tokens.TryGetValue(staticWebAsset, tokenName.ToString(), out var tokenValue) \|\| string.IsNullOrEmpty(tokenValue))`
	`186`	`+ var tokenNameString = tokenName.ToString();`
	`187`	`+ if (!tokens.TryGetValue(staticWebAsset, tokenNameString, out var tokenValue) \|\| string.IsNullOrEmpty(tokenValue))`
`174`	`188`	`{`
`175`	`189`	`foundAllValues = false;`
`176`		`- missingValue = tokenName.ToString();`
	`190`	`+ missingValue = tokenNameString;`
`177`	`191`	`break;`
`178`	`192`	`}`
`179`	`193`
`180`		`- dictionary[tokenName.ToString()] = tokenValue;`
	`194`	`+ dictionary[tokenNameString] = tokenValue;`
`181`	`195`	`}`
`182`	`196`
`183`	`197`	`if (!foundAllValues && !segment.IsOptional)`
`@@ -368,46 +382,50 @@ internal void EmbedTokens(StaticWebAsset staticWebAsset, StaticWebAssetTokenReso`
`368`	`382`	`// The value within the {} represents token variables.`
`369`	`383`	`private static void AddTokenSegmentParts(ReadOnlyMemory<char> tokenExpression, StaticWebAssetPathSegment token)`
`370`	`384`	`{`
`371`		`- var nextToken = MemoryExtensions.IndexOf(tokenExpression.Span, "{".AsSpan(), StringComparison.Ordinal);`
	`385`	`+ var current = tokenExpression;`
	`386`	`+ var nextToken = MemoryExtensions.IndexOf(current.Span, FingerprintParameterStart);`
`372`	`387`	`if (nextToken is not (-1) and > 0)`
`373`	`388`	`{`
`374`		`-#if NET9_0_OR_GREATER`
`375`		`- var literalPart = new StaticWebAssetSegmentPart { Name = tokenExpression[..nextToken], IsLiteral = true };`
`376`		`-#else`
`377`		`- var literalPart = new StaticWebAssetSegmentPart { Name = tokenExpression.Slice(0, nextToken), IsLiteral = true };`
`378`		`-#endif`
	`389`	`+ var literalPart = new StaticWebAssetSegmentPart { Name = current.Slice(0, nextToken), IsLiteral = true };`
`379`	`390`	`token.Parts.Add(literalPart);`
`380`	`391`	`}`
	`392`	`+`
`381`	`393`	`while (nextToken != -1)`
`382`	`394`	`{`
`383`		`- var tokenEnd = MemoryExtensions.IndexOf(tokenExpression.Slice(nextToken).Span, "}".AsSpan(), StringComparison.Ordinal);`
	`395`	`+ current = current.Slice(nextToken);`
	`396`	`+ var tokenEnd = MemoryExtensions.IndexOf(current.Span, FingerprintParameterEnd);`
`384`	`397`	`if (tokenEnd == -1)`
`385`	`398`	`{`
`386`	`399`	`throw new InvalidOperationException($"Invalid token expression '{tokenExpression}'. Missing '}}' token.");`
`387`	`400`	`}`
`388`	`401`
`389`		`- var embeddedValue = MemoryExtensions.IndexOf(tokenExpression.Slice(nextToken).Span, "=".AsSpan(), StringComparison.Ordinal);`
	`402`	`+ var embeddedValue = MemoryExtensions.IndexOf(current.Span, FingerprintValueSeparator);`
`390`	`403`	`if (embeddedValue != -1)`
`391`	`404`	`{`
`392`	`405`	`var tokenPart = new StaticWebAssetSegmentPart`
`393`	`406`	`{`
`394`		`- Name = tokenExpression.Slice(nextToken + 1, embeddedValue - nextToken - 1),`
	`407`	`+ Name = current.Slice(1, embeddedValue - 1),`
`395`	`408`	`IsLiteral = false,`
`396`		`- Value = tokenExpression.Slice(embeddedValue + 1, tokenEnd - embeddedValue - 1)`
	`409`	`+ Value = current.Slice(embeddedValue + 1, tokenEnd - embeddedValue - 1)`
`397`	`410`	`};`
`398`	`411`	`token.Parts.Add(tokenPart);`
`399`	`412`	`}`
`400`	`413`	`else`
`401`	`414`	`{`
`402`		`- var tokenPart = new StaticWebAssetSegmentPart { Name = tokenExpression.Slice(nextToken + 1, tokenEnd - nextToken - 1), IsLiteral = false };`
	`415`	`+ var tokenPart = new StaticWebAssetSegmentPart { Name = current.Slice(1, tokenEnd - 1), IsLiteral = false };`
`403`	`416`	`token.Parts.Add(tokenPart);`
`404`	`417`	`}`
`405`	`418`
`406`		`- nextToken = MemoryExtensions.IndexOf(tokenExpression.Slice(tokenEnd).Span, "}".AsSpan(), StringComparison.Ordinal);`
`407`		`- if ((nextToken != -1 && nextToken > tokenEnd + 1) \|\| (nextToken == -1 && tokenEnd < tokenExpression.Length - 1))`
	`419`	`+ current = current.Slice(tokenEnd + 1);`
	`420`	`+ nextToken = MemoryExtensions.IndexOf(current.Span, FingerprintParameterStart);`
	`421`	`+ if (nextToken == -1 && current.Length > 0)`
	`422`	`+ {`
	`423`	`+ var literalPart = new StaticWebAssetSegmentPart { Name = current, IsLiteral = true };`
	`424`	`+ token.Parts.Add(literalPart);`
	`425`	`+ }`
	`426`	`+ else if (nextToken > 0)`
`408`	`427`	`{`
`409`		`- var literalEnd = nextToken == -1 ? tokenExpression.Length : nextToken;`
`410`		`- var literalPart = new StaticWebAssetSegmentPart { Name = tokenExpression.Slice(tokenEnd + 1, literalEnd - tokenEnd - 1), IsLiteral = true };`
	`428`	`+ var literalPart = new StaticWebAssetSegmentPart { Name = current.Slice(0, nextToken), IsLiteral = true };`
`411`	`429`	`token.Parts.Add(literalPart);`
`412`	`430`	`}`
`413`	`431`	`}`
Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ internal ICollection<ReadOnlyMemory<char>> GetTokenNames()`
`57`	`57`	`var result = new HashSet<ReadOnlyMemory<char>>();`
`58`	`58`	`foreach (var part in Parts)`
`59`	`59`	`{`
`60`		`- if (!part.IsLiteral && part.Value.Length > 0)`
	`60`	`+ if (!part.IsLiteral && part.Name.Length > 0)`
`61`	`61`	`{`
`62`	`62`	`result.Add(part.Name);`
`63`	`63`	`}`
Original file line number	Diff line number	Diff line change
`@@ -89,7 +89,7 @@ public override bool Execute()`
`89`	`89`	`null;`
`90`	`90`
`91`	`91`	`var assetsByRelativePath = new Dictionary<string, List<ITaskItem>>();`
`92`		`- var fingerprintPatternMatcher = new FingerprintPatternMatcher(Log, FingerprintPatterns);`
	`92`	`+ var fingerprintPatternMatcher = new FingerprintPatternMatcher(Log, FingerprintCandidates ? (FingerprintPatterns ?? []) : []);`
`93`	`93`	`var matchContext = StaticWebAssetGlobMatcher.CreateMatchContext();`
`94`	`94`	`for (var i = 0; i < CandidateAssets.Length; i++)`
`95`	`95`	`{`
`@@ -234,7 +234,7 @@ public override bool Execute()`
`234`	`234`
`235`	`235`	`if (FingerprintCandidates)`
`236`	`236`	`{`
`237`		`- matchContext.SetPathAndReinitialize(candidate.ItemSpec);`
	`237`	`+ matchContext.SetPathAndReinitialize(relativePathCandidate);`
`238`	`238`	`relativePathCandidate = StaticWebAsset.Normalize(fingerprintPatternMatcher.AppendFingerprintPattern(matchContext, identity));`
`239`	`239`	`}`
`240`	`240`