feat: enhance assembly comparison handling to ignore legacy formatting differences

zacateras · zacateras · commit 492c4f6d7e48 · 2026-04-10T16:00:07.000+02:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -36,6 +36,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 - Treat legacy standalone table-level inline `PRIMARY KEY` and `UNIQUE` constraints as compatible during comparison with canonical post-create key-constraint statements.
 - Treat legacy CLR table-valued function return-column collation clauses as compatible during comparison when SQL Server ignores them in the effective return shape.
 - Treat legacy explicit `NULL` tokens on CLR table-valued function return columns as compatible during comparison and preserve them during compatibility reconciliation when the rest of the definition matches.
+- Treat equivalent legacy `Assembly` scripts as compatible during comparison when they differ only by banner comments, wrapped or case-varied hex payload formatting, `PERMISSION_SET` spacing, or quoted versus bracketed `ADD FILE` names.
 - Trailing semicolon differences on `INSERT` statement lines in data scripts are now suppressed during comparison normalization; scripts emitted with and without statement terminators compare as compatible (#47).
 - Legacy `TableData` scripts now compare as compatible when they differ from canonical output only by `SET IDENTITY_INSERT` semicolons or top-level `N'...'` string literal prefixes, including inside multi-line `INSERT ... VALUES (...)` statements.
 - Empty separator lines are now ignored during `status` and `diff`, and whitespace-only separator lines compare as compatible after normalization.
diff --git a/specs/01-cli.md b/specs/01-cli.md
@@ -217,6 +217,7 @@ Behavior:
 - Equivalent `Role` membership statements written as `EXEC sp_addrolemember ...` or `ALTER ROLE ... ADD MEMBER ...` compare as compatible.
 - Equivalent `MessageType` validation synonyms/spacing and equivalent `Contract` and `Service` body formatting and item ordering compare as compatible.
 - Leading SSMS-generated object banner comments on programmable objects (`StoredProcedure`, `View`, `Function`, `Trigger`) compare as compatible.
+- For `Assembly`, comparison ignores leading legacy `--Assembly ...` banner comments and treats wrapped/case-varied `0x...` payloads, spacing-only `PERMISSION_SET` formatting, and `ADD FILE ... AS [name]` versus `AS 'name'` as compatible when the effective assembly definition is otherwise identical.
 - When `data.trackedTables` is configured, `status` also reports data-script differences for tracked tables.
 - Status output MUST report schema and data summaries separately.
 - Exit codes:
@@ -255,6 +256,7 @@ Behavior:
 - Equivalent `Role` membership statements written as `EXEC sp_addrolemember ...` or `ALTER ROLE ... ADD MEMBER ...` compare as compatible.
 - Equivalent `MessageType` validation synonyms/spacing and equivalent `Contract` and `Service` body formatting and item ordering compare as compatible.
 - Leading SSMS-generated object banner comments on programmable objects (`StoredProcedure`, `View`, `Function`, `Trigger`) compare as compatible.
+- For `Assembly`, comparison ignores leading legacy `--Assembly ...` banner comments and treats wrapped/case-varied `0x...` payloads, spacing-only `PERMISSION_SET` formatting, and `ADD FILE ... AS [name]` versus `AS 'name'` as compatible when the effective assembly definition is otherwise identical.
 - Diff output uses a chunked format: only changed lines and their surrounding context are shown, not the entire file.
 - `--context <N>` controls the number of unchanged context lines shown before and after each changed segment (default: 3). Negative values are treated as 0.
 - `--normalized-diff` switches diff rendering to the exact comparison-normalized text used for compatibility evaluation. It is intended for debugging and is off by default.
diff --git a/specs/04-scripting.md b/specs/04-scripting.md
@@ -842,6 +842,7 @@ When compatibility reference files are available, `sqlct` MAY apply reconciliati
 - For `Service`, comparison normalization MAY treat equivalent single-line and multi-line contract-list formatting as compatible and MAY compare contract item ordering as compatible when the emitted contract set is otherwise identical.
 - For CLR table-valued `Function` scripts, comparison normalization MAY treat legacy explicit `NULL` tokens on return-column lines as compatible with canonical return-column lines that omit nullability, including legacy cases where the final return-column line also carries the closing `)` token.
 - For CLR table-valued `Function` scripts, comparison normalization MAY treat legacy `COLLATE <name>` clauses on return-column lines as compatible when SQL Server ignores that collation metadata for the effective return shape.
+- For `Assembly`, comparison normalization MAY ignore leading legacy `--Assembly ...` banner comments and MAY treat wrapped or case-varied `0x...` payload literals, spacing-only `WITH PERMISSION_SET = ...` differences, and `ALTER ASSEMBLY ... ADD FILE ... AS [name]` versus `AS 'name'` as compatible when the effective assembly definition is otherwise identical.
 
 ## 11. Error and Unsupported Behavior
 - Missing SQL object metadata for requested object MUST fail with an error.
diff --git a/src/SqlChangeTracker/Sync/SyncCommandService.cs b/src/SqlChangeTracker/Sync/SyncCommandService.cs
@@ -39,6 +39,8 @@ internal enum ComparisonTarget
 internal sealed class SyncCommandService : ISyncCommandService
 {
     internal const string TableDataObjectType = "TableData";
+    private const string SqlIdentifierTokenPattern = @"(?:\[(?:[^\]]|\]\])+\]|""(?:""""|[^""])+""|[^\s;]+)";
+    private const string SqlStringOrIdentifierTokenPattern = @"(?:\[(?:[^\]]|\]\])+\]|""(?:""""|[^""])+""|'(?:''|[^'])*'|[^\s;]+)";
     private static readonly Regex ScalarUserDefinedTypeScriptRegex = new(
         @"\bCREATE\s+TYPE\b.*\bFROM\b",
         RegexOptions.IgnoreCase | RegexOptions.CultureInvariant | RegexOptions.Singleline | RegexOptions.Compiled);
@@ -75,9 +77,18 @@ internal sealed class SyncCommandService : ISyncCommandService
     private static readonly Regex SsmsObjectHeaderCommentRegex = new(
         @"^\s*/\*{5,}\s*Object:\s+(?:StoredProcedure|Procedure|View|Function|Trigger)\b.*Script Date:.*\*+/\s*$",
         RegexOptions.IgnoreCase | RegexOptions.CultureInvariant | RegexOptions.Compiled);
+    private static readonly Regex AssemblyHeaderCommentRegex = new(
+        @"^\s*--\s*Assembly\b.*$",
+        RegexOptions.IgnoreCase | RegexOptions.CultureInvariant | RegexOptions.Compiled);
     private static readonly Regex CompatibleTextImageOnRegex = new(
         @"^(?<prefix>\)\s*(?:ON\s+(?:\[[^\]]+(?:\]\])*\]|""(?:""""|[^""])+""|[^\s]+)(?:\s*\([^)]+\))?)?)\s+TEXTIMAGE_ON\s+(?<dataSpace>\[[^\]]+(?:\]\])*\]|""(?:""""|[^""])+""|[^\s]+)(?<suffix>\s*)$",
         RegexOptions.IgnoreCase | RegexOptions.CultureInvariant | RegexOptions.Compiled);
+    private static readonly Regex CreateAssemblyBlockRegex = new(
+        $@"^\s*CREATE\s+ASSEMBLY\s+(?<name>{SqlIdentifierTokenPattern})\s+(?:AUTHORIZATION\s+(?<owner>{SqlIdentifierTokenPattern})\s+)?FROM\s+(?<hex>0x(?:[0-9A-Fa-f\\\s])+?)\s+WITH\s+PERMISSION_SET\s*=\s*(?<permission>[A-Za-z_]+)\s*;?\s*$",
+        RegexOptions.IgnoreCase | RegexOptions.CultureInvariant | RegexOptions.Singleline | RegexOptions.Compiled);
+    private static readonly Regex AlterAssemblyAddFileBlockRegex = new(
+        $@"^\s*ALTER\s+ASSEMBLY\s+(?<name>{SqlIdentifierTokenPattern})\s+ADD\s+FILE\s+FROM\s+(?<hex>0x(?:[0-9A-Fa-f\\\s])+?)\s+AS\s+(?<file>{SqlStringOrIdentifierTokenPattern})\s*;?\s*$",
+        RegexOptions.IgnoreCase | RegexOptions.CultureInvariant | RegexOptions.Singleline | RegexOptions.Compiled);
     private static readonly IReadOnlyList<SupportedSqlObjectType> ActiveObjectTypes = SupportedSqlObjectTypes.ActiveSync;
 
     private readonly SqlctConfigReader _configReader;
@@ -1710,6 +1721,12 @@ private static ComparableLine[] BuildComparableLinesForDiff(
             return BuildUserDefinedTypeComparableLinesForDiff(normalized);
         }
 
+        if (string.Equals(objectType, "Assembly", StringComparison.OrdinalIgnoreCase))
+        {
+            var normalized = PrepareScriptForReadableDiffDisplay(script, objectType);
+            return BuildAssemblyComparableLinesForDiff(normalized);
+        }
+
         return null;
     }
 
@@ -1732,6 +1749,11 @@ private static string PrepareScriptForReadableDiffDisplay(string script, string?
             {
                 lines[i] = string.Empty;
             }
+            else if (IsAssemblyObjectTypeForHeaderCommentCompatibility(objectType) &&
+                     AssemblyHeaderCommentRegex.IsMatch(lines[i]))
+            {
+                lines[i] = string.Empty;
+            }
         }
 
         if (IsProgrammableObjectTypeForHeaderCommentCompatibility(objectType))
@@ -1929,6 +1951,37 @@ private static string[] BuildUserDefinedTypeDisplayUnitsForDiff(string script)
         return comparableLines.ToArray();
     }
 
+    private static ComparableLine[] BuildAssemblyComparableLinesForDiff(string script)
+    {
+        var blocks = SplitGoDelimitedBlocks(script);
+        if (blocks.Count == 0)
+        {
+            return Array.Empty<ComparableLine>();
+        }
+
+        var comparableLines = new List<ComparableLine>(blocks.Count * 2);
+        foreach (var block in blocks)
+        {
+            var hasTerminalGo =
+                block.Length > 0 &&
+                string.Equals(block[^1].Trim(), "GO", StringComparison.OrdinalIgnoreCase);
+            var contentLines = hasTerminalGo ? block[..^1] : block;
+            if (contentLines.Any(line => line.Length > 0))
+            {
+                comparableLines.Add(BuildComparableLineForStructuredBlock(
+                    NormalizeAssemblyBlockContentForComparison(contentLines),
+                    string.Join("\n", contentLines)));
+            }
+
+            if (hasTerminalGo)
+            {
+                comparableLines.Add(new ComparableLine("GO", "GO"));
+            }
+        }
+
+        return comparableLines.ToArray();
+    }
+
     private static IReadOnlyList<string> GetDisplayUnitsForTablePostCreatePackage(string package)
     {
         var blocks = SplitGoDelimitedBlocks(package);
@@ -2649,6 +2702,11 @@ internal static string NormalizeForComparison(
             {
                 lines[i] = string.Empty;
             }
+            else if (IsAssemblyObjectTypeForHeaderCommentCompatibility(objectType) &&
+                     AssemblyHeaderCommentRegex.IsMatch(lines[i]))
+            {
+                lines[i] = string.Empty;
+            }
         }
 
         if (IsProgrammableObjectTypeForHeaderCommentCompatibility(objectType))
@@ -2690,6 +2748,11 @@ internal static string NormalizeForComparison(
             joined = NormalizeServiceBrokerScriptForComparison(joined, NormalizeServiceBaseBlockForComparison);
         }
 
+        if (string.Equals(objectType, "Assembly", StringComparison.OrdinalIgnoreCase))
+        {
+            joined = NormalizeAssemblyScriptForComparison(joined);
+        }
+
         if (string.Equals(objectType, "Function", StringComparison.OrdinalIgnoreCase))
         {
             joined = NormalizeClrTableValuedFunctionScriptForComparison(joined);
@@ -2864,6 +2927,11 @@ private static string NormalizeForDiffDisplay(
             {
                 lines[i] = string.Empty;
             }
+            else if (IsAssemblyObjectTypeForHeaderCommentCompatibility(objectType) &&
+                     AssemblyHeaderCommentRegex.IsMatch(lines[i]))
+            {
+                lines[i] = string.Empty;
+            }
         }
 
         if (IsProgrammableObjectTypeForHeaderCommentCompatibility(objectType))
@@ -3061,6 +3129,163 @@ private static string NormalizeServiceBaseBlockForComparison(string baseBlock)
             : rebuilt + " " + suffix;
     }
 
+    private static string NormalizeAssemblyScriptForComparison(string script)
+    {
+        var blocks = SplitGoDelimitedBlocks(script);
+        if (blocks.Count == 0)
+        {
+            return script;
+        }
+
+        var normalizedBlocks = new List<string>(blocks.Count);
+        foreach (var block in blocks)
+        {
+            var hasTerminalGo =
+                block.Length > 0 &&
+                string.Equals(block[^1].Trim(), "GO", StringComparison.OrdinalIgnoreCase);
+            var contentLines = hasTerminalGo ? block[..^1] : block;
+            if (contentLines.Any(line => line.Length > 0))
+            {
+                normalizedBlocks.Add(NormalizeAssemblyBlockContentForComparison(contentLines));
+            }
+
+            if (hasTerminalGo)
+            {
+                normalizedBlocks.Add("GO");
+            }
+        }
+
+        return string.Join("\n", normalizedBlocks);
+    }
+
+    private static string NormalizeAssemblyBlockContentForComparison(IEnumerable<string> blockLines)
+    {
+        var contentLines = blockLines
+            .Select(line => line.Trim())
+            .Where(line => line.Length > 0)
+            .ToArray();
+        if (contentLines.Length == 0)
+        {
+            return string.Empty;
+        }
+
+        if (TryNormalizeCreateAssemblyBlockForComparison(contentLines, out var createAssembly))
+        {
+            return createAssembly;
+        }
+
+        if (TryNormalizeAlterAssemblyAddFileBlockForComparison(contentLines, out var addFileAssembly))
+        {
+            return addFileAssembly;
+        }
+
+        if (contentLines.Length == 1 && IsPermissionStatementLine(contentLines[0]))
+        {
+            return NormalizePermissionStatementForComparison(contentLines[0]);
+        }
+
+        if (contentLines.Length == 1 && IsExtendedPropertyStatementLine(contentLines[0]))
+        {
+            return NormalizeExtendedPropertyStatementForComparison(contentLines[0]);
+        }
+
+        return NormalizeSqlStatementTokensForComparison(string.Join(" ", contentLines));
+    }
+
+    private static bool TryNormalizeCreateAssemblyBlockForComparison(
+        IReadOnlyList<string> contentLines,
+        out string normalized)
+    {
+        var match = CreateAssemblyBlockRegex.Match(string.Join("\n", contentLines));
+        if (!match.Success)
+        {
+            normalized = string.Empty;
+            return false;
+        }
+
+        var normalizedLines = new List<string>
+        {
+            NormalizeSqlStatementTokensForComparison(
+                $"CREATE ASSEMBLY {QuoteIdentifierForComparison(UnquoteSqlIdentifier(match.Groups["name"].Value))}")
+        };
+
+        if (match.Groups["owner"].Success)
+        {
+            normalizedLines.Add(NormalizeSqlStatementTokensForComparison(
+                $"AUTHORIZATION {QuoteIdentifierForComparison(UnquoteSqlIdentifier(match.Groups["owner"].Value))}"));
+        }
+
+        normalizedLines.Add(NormalizeSqlStatementTokensForComparison(
+            $"FROM 0x{NormalizeAssemblyHexLiteralForComparison(match.Groups["hex"].Value)}"));
+        normalizedLines.Add(NormalizeSqlStatementTokensForComparison(
+            $"WITH PERMISSION_SET = {NormalizeAssemblyPermissionSetForComparison(match.Groups["permission"].Value)}"));
+        normalized = string.Join("\n", normalizedLines);
+        return true;
+    }
+
+    private static bool TryNormalizeAlterAssemblyAddFileBlockForComparison(
+        IReadOnlyList<string> contentLines,
+        out string normalized)
+    {
+        var match = AlterAssemblyAddFileBlockRegex.Match(string.Join("\n", contentLines));
+        if (!match.Success)
+        {
+            normalized = string.Empty;
+            return false;
+        }
+
+        normalized = NormalizeSqlStatementTokensForComparison(
+            $"ALTER ASSEMBLY {QuoteIdentifierForComparison(UnquoteSqlIdentifier(match.Groups["name"].Value))} " +
+            $"ADD FILE FROM 0x{NormalizeAssemblyHexLiteralForComparison(match.Groups["hex"].Value)} " +
+            $"AS {NormalizeAssemblyFileTokenForComparison(match.Groups["file"].Value)}");
+        return true;
+    }
+
+    private static string NormalizeAssemblyHexLiteralForComparison(string value)
+    {
+        var hexPrefixIndex = value.IndexOf("0x", StringComparison.OrdinalIgnoreCase);
+        if (hexPrefixIndex < 0)
+        {
+            return value.Trim().ToLowerInvariant();
+        }
+
+        var builder = new StringBuilder(value.Length);
+        for (var i = hexPrefixIndex + 2; i < value.Length; i++)
+        {
+            var current = value[i];
+            if (char.IsWhiteSpace(current) || current == '\\')
+            {
+                continue;
+            }
+
+            if (IsHexDigit(current))
+            {
+                builder.Append(char.ToLowerInvariant(current));
+            }
+        }
+
+        return builder.ToString();
+    }
+
+    private static string NormalizeAssemblyPermissionSetForComparison(string value)
+        => value.Trim().ToUpperInvariant() switch
+        {
+            "SAFE" or "SAFE_ACCESS" => "SAFE",
+            "EXTERNAL_ACCESS" => "EXTERNAL_ACCESS",
+            "UNSAFE" or "UNSAFE_ACCESS" => "UNSAFE",
+            _ => value.Trim().ToUpperInvariant()
+        };
+
+    private static string NormalizeAssemblyFileTokenForComparison(string value)
+    {
+        if (value.Length >= 2 && value[0] == '\'' && value[^1] == '\'')
+        {
+            return QuoteIdentifierForComparison(UnescapeSqlStringLiteral(value[1..^1]));
+        }
+
+        return QuoteIdentifierForComparison(UnquoteSqlIdentifier(value));
+    }
+
     private static string CollapseServiceBrokerWhitespace(string text)
         => Regex.Replace(text, @"\s+", " ", RegexOptions.CultureInvariant).Trim();
 
@@ -3948,6 +4173,9 @@ private static bool IsProgrammableObjectTypeForHeaderCommentCompatibility(string
            || string.Equals(objectType, "Function", StringComparison.OrdinalIgnoreCase)
            || string.Equals(objectType, "Trigger", StringComparison.OrdinalIgnoreCase);
 
+    private static bool IsAssemblyObjectTypeForHeaderCommentCompatibility(string? objectType)
+        => string.Equals(objectType, "Assembly", StringComparison.OrdinalIgnoreCase);
+
     private static bool IsExtendedPropertyStatementLine(string line)
         => ExtendedPropertyStatementRegex.IsMatch(line);
 
diff --git a/tests/SqlChangeTracker.Tests/Sync/SyncCommandServiceTests.cs b/tests/SqlChangeTracker.Tests/Sync/SyncCommandServiceTests.cs
