Support diff in CLI

Author: MattKotsenas

README.md

@@ -120,10 +120,19 @@ this command:
 dotnet tool install SquiggleCop.Tool
 ```
 
-then generate a baseline like this:
+To generate or diff a new baseline, run the `generate` command like this:
 
-```powershell
-dotnet squigglecop generate ./path/to/diagnostics.sarif --auto-baseline
+```
+Usage: dotnet squigglecop generate [--auto-baseline] [--output <String>] [--context <Int32>] [--help] sarif
+
+Arguments:
+  0: sarif    The SARIF log to generate a baseline for (Required)
+
+Options:
+  -a, --auto-baseline      Automatically update baseline if necessary
+  -o, --output <String>    The output path for the baseline file
+  -c, --context <Int32>    Number of context lines to use in the diff (Default: 3)
+  -h, --help               Show help message
 ```
 
 ### MSBuild Tasks

src/Common/BaselineDiff.cs

@@ -3,23 +3,30 @@
 namespace SquiggleCop.Common;
 
 /// <summary>
-/// A record that represents the differences between two baselines.
+/// A class that represents the differences between two baselines.
 /// </summary>
-public record class BaselineDiff
+public class BaselineDiff
 {
+    private readonly DiffPaneModel _model;
+
     /// <summary>
     /// Creates a new instance of <see cref="BaselineDiff"/>.
     /// </summary>
     /// <param name="model">
-    /// The <see cref="SideBySideDiffModel"/> model that contains the differences.
+    /// The <see cref="DiffPaneModel"/> model that contains the differences.
     /// </param>
-    public BaselineDiff(SideBySideDiffModel model)
+    public BaselineDiff(DiffPaneModel model)
     {
-        HasDifferences = model.OldText.HasDifferences || model.NewText.HasDifferences;
+        _model = model;
     }
 
     /// <summary>
     /// <see langword="true"/> if the two baselines have differences; otherwise, <see langword="false"/>.
     /// </summary>
-    public bool HasDifferences { get; }
+    public bool HasDifferences => _model.HasDifferences;
+
+    /// <summary>
+    /// The lines that represent the differences between the two baselines.
+    /// </summary>
+    public IReadOnlyList<DiffPiece> Lines => _model.Lines;
 }

src/Common/BaselineDiffer.cs

@@ -1,4 +1,6 @@
-using DiffPlex.DiffBuilder;
+using DiffPlex;
+using DiffPlex.Chunkers;
+using DiffPlex.DiffBuilder;
 using DiffPlex.DiffBuilder.Model;
 
 namespace SquiggleCop.Common;
@@ -11,7 +13,8 @@ namespace SquiggleCop.Common;
 /// </remarks>
 public class BaselineDiffer
 {
-    private readonly SideBySideDiffBuilder _diffBuilder = SideBySideDiffBuilder.Instance;
+    private readonly InlineDiffBuilder _diffBuilder = InlineDiffBuilder.Instance;
+    private readonly IChunker _chunker = new LineChunker();
 
     /// <summary>
     /// Diffs two baselines.
@@ -21,7 +24,7 @@ public class BaselineDiffer
     /// <returns>A <see cref="BaselineDiff"/> that holds the results of the diff.</returns>
     public BaselineDiff Diff(string expected, string actual)
     {
-        SideBySideDiffModel diff = _diffBuilder.BuildDiffModel(expected, actual, ignoreWhitespace: false, ignoreCase: false);
+        DiffPaneModel diff = _diffBuilder.BuildDiffModel(expected, actual, ignoreWhitespace: false, ignoreCase: false, _chunker);
         return new BaselineDiff(diff);
     }
 }

src/Tool/AppBuilder.cs renamed to src/Tool/App.cs

@@ -1,4 +1,8 @@
-using Cocona;
+using System.ComponentModel.DataAnnotations;
+using System.Globalization;
+using System.IO;
+
+using Cocona;
 using Cocona.Application;
 using Cocona.Builder;
 
@@ -7,13 +11,14 @@
 using Spectre.Console;
 
 using SquiggleCop.Common;
+using SquiggleCop.Tool.Rendering;
 
 namespace SquiggleCop.Tool;
 
 /// <summary>
 /// Configure and create the <see cref="CoconaApp"/>.
 /// </summary>
-public static class AppBuilder
+public static class App
 {
     /// <summary>
     /// Create a new instance of <see cref="CoconaApp"/>.
@@ -44,6 +49,7 @@ public static CoconaApp Create(Action<CoconaAppBuilder> configure)
         builder.Services.AddSingleton<Serializer>();
         builder.Services.AddSingleton<BaselineDiffer>();
         builder.Services.AddSingleton<BaselineWriter>();
+        builder.Services.AddRenderers();
 
         configure(builder);
 
@@ -60,11 +66,14 @@ public static CoconaApp Create(Action<CoconaAppBuilder> configure)
     private static async Task<int> GenerateAsync(
         SarifParser parser,
         Serializer serializer,
+        BaselineDiffer differ,
         BaselineWriter writer,
+        ReportRenderer renderer,
         IAnsiConsole console,
         [Option('a', Description = "Automatically update baseline if necessary")] bool autoBaseline,
         [Argument(Description = "The SARIF log to generate a baseline for")] string sarif,
-        [Option('o', Description = "The output path for the baseline file")] string? output)
+        [Option('o', Description = "The output path for the baseline file")] string? output,
+        [Option('c', Description = "Number of context lines to use in the diff")][Range(1, 100)] int context = 3)
     {
         if (!File.Exists(sarif))
         {
@@ -73,11 +82,6 @@ private static async Task<int> GenerateAsync(
 
         output = ValidateOutputPath(output);
 
-        if (!autoBaseline)
-        {
-            throw new NotImplementedException("Manual baseline creation is not yet implemented. Use `--auto-baseline` and your source control system to review changes for now.");
-        }
-
         try
         {
             IReadOnlyCollection<DiagnosticConfig> configs;
@@ -88,16 +92,24 @@ private static async Task<int> GenerateAsync(
             }
 
             string newBaseline = serializer.Serialize(configs);
-            await writer.WriteAsync(output, newBaseline).ConfigureAwait(false);
+
+            BaselineDiff diff = differ.Diff(await ReadBaselineAsync(output).ConfigureAwait(false), newBaseline);
+
+            renderer.Render(diff, showDiff: !autoBaseline, context);
+
+            if (autoBaseline)
+            {
+                await writer.WriteAsync(output, newBaseline).ConfigureAwait(false);
+                console.MarkupLineInterpolated(CultureInfo.InvariantCulture, $"[green]Baseline generated[/] @ [link=file://{Path.GetFullPath(output)}]{output}[/]");
+                return ExitCodes.Success;
+            }
+
+            return !diff.HasDifferences ? ExitCodes.Success : ExitCodes.BaselineMismatch;
         }
         catch (UnsupportedVersionException ex)
         {
             throw new SarifInvalidException($"SARIF file is invalid. {ex.Message}", ex);
         }
-
-        console.MarkupLine($"[green]Baseline generated[/] @ {output}");
-
-        return ExitCodes.Success;
     }
 
     private static string ValidateOutputPath(string? path)
@@ -112,4 +124,9 @@ private static string ValidateOutputPath(string? path)
 
         return path;
     }
+
+    private static async Task<string> ReadBaselineAsync(string path)
+    {
+        return File.Exists(path) ? await File.ReadAllTextAsync(path).ConfigureAwait(false) : string.Empty;
+    }
 }

src/Tool/ExitCodes.cs

@@ -4,4 +4,5 @@ internal static class ExitCodes
 {
     public static int Success { get; } = 0;
     public static int UnknownError { get; } = -1;
+    public static int BaselineMismatch { get; } = 1;
 }

src/Tool/Program.cs

@@ -1,3 +1,3 @@
 using SquiggleCop.Tool;
 
-await AppBuilder.Create().RunAsync().ConfigureAwait(false);
+await App.Create().RunAsync().ConfigureAwait(false);

src/Tool/Rendering/DiffPieceExtensions.cs

@@ -0,0 +1,17 @@
+using DiffPlex.DiffBuilder.Model;
+
+namespace SquiggleCop.Tool.Rendering;
+
+internal static class DiffPieceExtensions
+{
+    public static int SearchForEndOfDiffBlock(this IReadOnlyList<DiffPiece> lines, int index)
+    {
+        int i = index;
+        while (i < lines.Count && lines[i].Type != ChangeType.Unchanged)
+        {
+            i++;
+        }
+
+        return i;
+    }
+}

src/Tool/Rendering/DiffRenderer.cs

@@ -0,0 +1,57 @@
+using DiffPlex.DiffBuilder.Model;
+
+using Spectre.Console;
+
+using SquiggleCop.Common;
+
+namespace SquiggleCop.Tool.Rendering;
+
+internal class DiffRenderer
+{
+    private readonly IAnsiConsole _console;
+
+    public DiffRenderer(IAnsiConsole console)
+    {
+        _console = console;
+    }
+
+    public void Render(BaselineDiff diff, int context)
+    {
+        int i = 0;
+        while (i < diff.Lines.Count)
+        {
+            if (diff.Lines[i].Type == ChangeType.Unchanged)
+            {
+                i++;
+                continue;
+            }
+
+            int begin = Math.Max(0, i - context + 1);
+            int end = Math.Min(diff.Lines.Count - 1, diff.Lines.SearchForEndOfDiffBlock(i) + context - 1);
+
+            for (int j = begin; j < end; j++)
+            {
+                RenderLine(diff.Lines[j]);
+            }
+
+            _console.WriteLine();
+            i = end + 2;
+        }
+    }
+
+    private void RenderLine(DiffPiece line)
+    {
+        if (line.Type == ChangeType.Inserted)
+        {
+            _console.MarkupLine($"[green]+{line.Text.EscapeMarkup()}[/]");
+        }
+        else if (line.Type == ChangeType.Deleted)
+        {
+            _console.MarkupLine($"[red]-{line.Text.EscapeMarkup()}[/]");
+        }
+        else
+        {
+            _console.MarkupLine($"[grey]{line.Text.EscapeMarkup()}[/]");
+        }
+    }
+}

src/Tool/Rendering/ReportRenderer.cs

@@ -0,0 +1,44 @@
+using Spectre.Console;
+
+using SquiggleCop.Common;
+
+namespace SquiggleCop.Tool.Rendering;
+
+internal sealed class ReportRenderer
+{
+    private readonly IAnsiConsole _console;
+    private readonly DiffRenderer _diffRenderer;
+
+    public ReportRenderer(IAnsiConsole console, DiffRenderer diffRenderer)
+    {
+        _console = console;
+        _diffRenderer = diffRenderer;
+    }
+
+    public void Render(BaselineDiff diff, bool showDiff, int context)
+    {
+        if (diff.HasDifferences)
+        {
+            _console.Markup("[yellow]Baseline is different[/]");
+
+            if (!showDiff)
+            {
+                _console.MarkupLine("[dim] (auto baselining...)[/]");
+            }
+            else
+            {
+                _console.WriteLine();
+            }
+        }
+        else
+        {
+            _console.MarkupLine("[green]Baseline is up-to-date[/]");
+        }
+        _console.WriteLine();
+
+        if (showDiff)
+        {
+            _diffRenderer.Render(diff, context);
+        }
+    }
+}

src/Tool/Rendering/ServiceCollectionExtensions.cs

@@ -0,0 +1,14 @@
+using Microsoft.Extensions.DependencyInjection;
+
+namespace SquiggleCop.Tool.Rendering;
+
+internal static class ServiceCollectionExtensions
+{
+    public static IServiceCollection AddRenderers(this IServiceCollection services)
+    {
+        services.AddSingleton<DiffRenderer>();
+        services.AddSingleton<ReportRenderer>();
+
+        return services;
+    }
+}