feat: Add provider NSubstituteAnalyzersProvider

Author: davidkallesen

src/Atc.CodingRules.AnalyzerProviders/AnalyzerProviderCollector.cs

@@ -20,6 +20,7 @@ public static string[] GetAllBaseRuleProviderNames()
             MicrosoftCompilerErrorsProvider.Name,
             MicrosoftCompilerErrorsProviderUndocumented.Name,
             MicrosoftVisualStudioThreadingAnalyzersProvider.Name,
+            NSubstituteAnalyzersProvider.Name,
             SecurityCodeScanVs2019Provider.Name,
             StyleCopAnalyzersProvider.Name,
             SonarAnalyzerCSharpProvider.Name,
@@ -57,6 +58,9 @@ public async Task<Collection<AnalyzerProviderBaseRuleData>> CollectAllBaseRules(
         var microsoftVisualStudioThreadingAnalyzersProvider = new MicrosoftVisualStudioThreadingAnalyzersProvider(logger, logWithAnsiConsoleMarkup);
         var microsoftVisualStudioThreadingAnalyzersProviderTask = microsoftVisualStudioThreadingAnalyzersProvider.CollectBaseRules(ProviderCollectingMode.ReCollect);
 
+        var nSubstituteAnalyzersProvider = new NSubstituteAnalyzersProvider(logger, logWithAnsiConsoleMarkup);
+        var nSubstituteAnalyzersProviderTask = nSubstituteAnalyzersProvider.CollectBaseRules(ProviderCollectingMode.ReCollect);
+
         var securityCodeScanVs2019Provider = new SecurityCodeScanVs2019Provider(logger, logWithAnsiConsoleMarkup);
         var securityCodeScanVs2019Task = securityCodeScanVs2019Provider.CollectBaseRules(providerCollectingMode);
 
@@ -77,6 +81,7 @@ await Task.WhenAll(
             microsoftCompilerErrorsTask,
             microsoftCompilerErrorsUndocumentedTask,
             microsoftVisualStudioThreadingAnalyzersProviderTask,
+            nSubstituteAnalyzersProviderTask,
             securityCodeScanVs2019Task,
             styleCopAnalyzersTask,
             sonarAnalyzerCSharpTask,
@@ -89,6 +94,7 @@ await Task.WhenAll(
         data.Add(await microsoftCompilerErrorsTask);
         data.Add(await microsoftCompilerErrorsUndocumentedTask);
         data.Add(await microsoftVisualStudioThreadingAnalyzersProviderTask);
+        data.Add(await nSubstituteAnalyzersProviderTask);
         data.Add(await securityCodeScanVs2019Task);
         data.Add(await styleCopAnalyzersTask);
         data.Add(await sonarAnalyzerCSharpTask);
@@ -120,6 +126,9 @@ public void CacheCleanup()
         var microsoftVisualStudioThreadingAnalyzersProvider = new MicrosoftVisualStudioThreadingAnalyzersProvider(logger);
         microsoftVisualStudioThreadingAnalyzersProvider.Cleanup();
 
+        var nSubstituteAnalyzersProvider = new NSubstituteAnalyzersProvider(logger);
+        nSubstituteAnalyzersProvider.Cleanup();
+
         var securityCodeScanVs2019Provider = new SecurityCodeScanVs2019Provider(logger);
         securityCodeScanVs2019Provider.Cleanup();
 

src/Atc.CodingRules.AnalyzerProviders/Providers/NSubstituteAnalyzersProvider.cs

@@ -0,0 +1,67 @@
+namespace Atc.CodingRules.AnalyzerProviders.Providers;
+
+public class NSubstituteAnalyzersProvider : AnalyzerProviderBase
+{
+    private const int TableColumnId = 0;
+    private const int TableColumnCategory = 1;
+    private const int TableColumnTitle = 2;
+
+    public NSubstituteAnalyzersProvider(
+        ILogger logger,
+        bool logWithAnsiConsoleMarkup = false)
+        : base(
+            logger,
+            logWithAnsiConsoleMarkup)
+    {
+    }
+
+    public static string Name => "NSubstitute.Analyzers";
+
+    public override Uri? DocumentationLink { get; set; } = new ("https://github.com/nsubstitute/NSubstitute.Analyzers/tree/master/documentation/rules", UriKind.Absolute);
+
+    protected override AnalyzerProviderBaseRuleData CreateData()
+        => new (Name);
+
+    protected override async Task ReCollect(
+        AnalyzerProviderBaseRuleData data)
+    {
+        ArgumentNullException.ThrowIfNull(data);
+
+        var web = new HtmlWeb();
+        var htmlDoc = await web.LoadFromWebAsync(DocumentationLink!.AbsoluteUri).ConfigureAwait(false);
+        var articleNode = htmlDoc.DocumentNode.SelectNodes("//article[@class='markdown-body entry-content container-lg']").First();
+        var articleTableRows = articleNode.SelectNodes("//*//table[1]//tr").ToList();
+
+        foreach (var row in articleTableRows)
+        {
+            if (row.SelectNodes("td") is null)
+            {
+                continue;
+            }
+
+            var cells = row.SelectNodes("td").ToList();
+            if (cells.Count <= 0)
+            {
+                continue;
+            }
+
+            var aHrefNode = cells[TableColumnId].SelectSingleNode("a");
+            if (aHrefNode is null)
+            {
+                continue;
+            }
+
+            var code = aHrefNode.InnerText;
+            var title = HtmlEntity.DeEntitize(cells[TableColumnTitle].InnerText);
+            var link = "https://github.com/" + aHrefNode.Attributes["href"].Value;
+            var category = cells[TableColumnCategory].InnerText;
+
+            data.Rules.Add(
+                new Rule(
+                    code,
+                    title,
+                    link,
+                    category: category));
+        }
+    }
+}

test/Atc.CodingRules.AnalyzerProviders.Tests/Providers/NSubstituteAnalyzersProviderTests.cs

@@ -0,0 +1,26 @@
+namespace Atc.CodingRules.AnalyzerProviders.Tests.Providers;
+
+[Trait(Traits.Category, Traits.Categories.Integration)]
+[Trait(Traits.Category, Traits.Categories.SkipWhenLiveUnitTesting)]
+public class NSubstituteAnalyzersProviderTests
+{
+    [Theory]
+    [InlineData(ProviderCollectingMode.LocalCache)]
+    [InlineData(ProviderCollectingMode.GitHub)]
+    [InlineData(ProviderCollectingMode.ReCollect)]
+    public async Task CollectBaseRules(ProviderCollectingMode providerCollectingMode)
+    {
+        // Arrange
+        var provider = new NSubstituteAnalyzersProvider(NullLogger.Instance);
+
+        // Act
+        var actual = await provider.CollectBaseRules(providerCollectingMode);
+
+        // Assert
+        Assert.NotNull(actual);
+        Assert.NotNull(actual.Name);
+        Assert.Equal(NSubstituteAnalyzersProvider.Name, actual.Name);
+        Assert.NotNull(actual.Rules);
+        Assert.True(actual.Rules.Count >= 23);
+    }
+}