feat: Add provider MicrosoftVisualStudioThreadingAnalyzers

Author: davidkallesen

src/Atc.CodingRules.AnalyzerProviders/AnalyzerProviderCollector.cs

@@ -19,6 +19,7 @@ public static string[] GetAllBaseRuleProviderNames()
             MicrosoftCodeAnalysisNetAnalyzersProvider.Name,
             MicrosoftCompilerErrorsProvider.Name,
             MicrosoftCompilerErrorsProviderUndocumented.Name,
+            MicrosoftVisualStudioThreadingAnalyzersProvider.Name,
             SecurityCodeScanVs2019Provider.Name,
             StyleCopAnalyzersProvider.Name,
             SonarAnalyzerCSharpProvider.Name,
@@ -51,6 +52,9 @@ public async Task<Collection<AnalyzerProviderBaseRuleData>> CollectAllBaseRules(
         var microsoftCodeAnalysisNetAnalyzersProviderUndocumented = new MicrosoftCompilerErrorsProviderUndocumented(logger, logWithAnsiConsoleMarkup);
         var microsoftCompilerErrorsUndocumentedTask = microsoftCodeAnalysisNetAnalyzersProviderUndocumented.CollectBaseRules(ProviderCollectingMode.ReCollect);
 
+        var microsoftVisualStudioThreadingAnalyzersProvider = new MicrosoftVisualStudioThreadingAnalyzersProvider(logger, logWithAnsiConsoleMarkup);
+        var microsoftVisualStudioThreadingAnalyzersProviderTask = microsoftVisualStudioThreadingAnalyzersProvider.CollectBaseRules(ProviderCollectingMode.ReCollect);
+
         var securityCodeScanVs2019Provider = new SecurityCodeScanVs2019Provider(logger, logWithAnsiConsoleMarkup);
         var securityCodeScanVs2019Task = securityCodeScanVs2019Provider.CollectBaseRules(providerCollectingMode);
 
@@ -67,6 +71,7 @@ await Task.WhenAll(
             microsoftCodeAnalysisNetAnalyzersTask,
             microsoftCompilerErrorsTask,
             microsoftCompilerErrorsUndocumentedTask,
+            microsoftVisualStudioThreadingAnalyzersProviderTask,
             securityCodeScanVs2019Task,
             styleCopAnalyzersTask,
             sonarAnalyzerCSharpTask);
@@ -77,6 +82,7 @@ await Task.WhenAll(
         data.Add(await microsoftCodeAnalysisNetAnalyzersTask);
         data.Add(await microsoftCompilerErrorsTask);
         data.Add(await microsoftCompilerErrorsUndocumentedTask);
+        data.Add(await microsoftVisualStudioThreadingAnalyzersProviderTask);
         data.Add(await securityCodeScanVs2019Task);
         data.Add(await styleCopAnalyzersTask);
         data.Add(await sonarAnalyzerCSharpTask);
@@ -104,6 +110,9 @@ public void CacheCleanup()
         var microsoftCodeAnalysisNetAnalyzersProviderUndocumented = new MicrosoftCompilerErrorsProviderUndocumented(logger);
         microsoftCodeAnalysisNetAnalyzersProviderUndocumented.Cleanup();
 
+        var microsoftVisualStudioThreadingAnalyzersProvider = new MicrosoftVisualStudioThreadingAnalyzersProvider(logger);
+        microsoftVisualStudioThreadingAnalyzersProvider.Cleanup();
+
         var securityCodeScanVs2019Provider = new SecurityCodeScanVs2019Provider(logger);
         securityCodeScanVs2019Provider.Cleanup();
 

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

@@ -0,0 +1,63 @@
+namespace Atc.CodingRules.AnalyzerProviders.Providers;
+
+public class MicrosoftVisualStudioThreadingAnalyzersProvider : AnalyzerProviderBase
+{
+    private const int TableColumnId = 0;
+    private const int TableColumnCategory = 2;
+    private const int TableColumnTitle = 1;
+
+    public MicrosoftVisualStudioThreadingAnalyzersProvider(ILogger logger, bool logWithAnsiConsoleMarkup = false)
+        : base(logger, logWithAnsiConsoleMarkup)
+    {
+    }
+
+    public static string Name => "Microsoft.VisualStudio.Threading.Analyzers";
+
+    public override Uri? DocumentationLink { get; set; } = new ("https://github.com/microsoft/vs-threading/blob/main/doc/analyzers/index.md", 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 = 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/MicrosoftVisualStudioThreadingAnalyzersProviderTests.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 MicrosoftVisualStudioThreadingAnalyzersProviderTests
+{
+    [Theory]
+    [InlineData(ProviderCollectingMode.LocalCache)]
+    [InlineData(ProviderCollectingMode.GitHub)]
+    [InlineData(ProviderCollectingMode.ReCollect)]
+    public async Task CollectBaseRules(ProviderCollectingMode providerCollectingMode)
+    {
+        // Arrange
+        var provider = new MicrosoftVisualStudioThreadingAnalyzersProvider(NullLogger.Instance);
+
+        // Act
+        var actual = await provider.CollectBaseRules(providerCollectingMode);
+
+        // Assert
+        Assert.NotNull(actual);
+        Assert.NotNull(actual.Name);
+        Assert.Equal(MicrosoftVisualStudioThreadingAnalyzersProvider.Name, actual.Name);
+        Assert.NotNull(actual.Rules);
+        Assert.True(actual.Rules.Count >= 23);
+    }
+}