Add test options

sschmid · Jul 7, 2023 · fb7f45f · fb7f45f
1 parent e71e2fd
commit fb7f45f
Show file tree

Hide file tree

Showing 5 changed files with 74 additions and 6 deletions.
diff --git a/.editorconfig b/.editorconfig
@@ -6,3 +6,4 @@ end_of_line=lf
 trim_trailing_whitespace=true
 insert_final_newline=true
 indent_style=space
+entitas_test_option=true
diff --git a/gen/Entitas.Generators/Component/ComponentGenerator.cs b/gen/Entitas.Generators/Component/ComponentGenerator.cs
@@ -14,13 +14,16 @@ public sealed class ComponentGenerator : IIncrementalGenerator
     {
         public void Initialize(IncrementalGeneratorInitializationContext initContext)
         {
+            var options = initContext.AnalyzerConfigOptionsProvider
+                .Select((provider, _) => new EntitasAnalyzerConfigOptions(provider.GlobalOptions));
+
             var components = initContext.SyntaxProvider
                 .CreateSyntaxProvider(IsComponentCandidate, CreateComponentDeclarations)
                 .Where(static components => components is not null)
                 .SelectMany(static (components, _) => components!.Value);
 
             var fullNameOrContextChanged = components.WithComparer(new FullNameAndContextComparer());
-            initContext.RegisterSourceOutput(fullNameOrContextChanged, OnFullNameOrContextChanged);
+            initContext.RegisterSourceOutput(fullNameOrContextChanged.Combine(options), OnFullNameOrContextChanged);
 
             var fullNameOrMembersOrContextChanged = components.WithComparer(new FullNameAndMembersAndContextComparer());
             initContext.RegisterSourceOutput(fullNameOrMembersOrContextChanged, OnFullNameOrMembersOrContextChanged);
@@ -163,20 +166,22 @@ static bool IsContextInitializationMethodCandidate(SyntaxNode node, Cancellation
                 .ToImmutableArray();
         }
 
-        static void OnFullNameOrContextChanged(SourceProductionContext spc, ComponentDeclaration component)
+        static void OnFullNameOrContextChanged(SourceProductionContext spc, (ComponentDeclaration Component, EntitasAnalyzerConfigOptions Options) pair)
         {
-            ComponentIndex(spc, component);
+            var (component, options) = pair;
+            ComponentIndex(spc, component, options);
             Matcher(spc, component);
         }
 
-        static void ComponentIndex(SourceProductionContext spc, ComponentDeclaration component)
+        static void ComponentIndex(SourceProductionContext spc, ComponentDeclaration component, EntitasAnalyzerConfigOptions options)
         {
             spc.AddSource(
                 GeneratedPath($"{component.FullName}.{component.ContextPrefix}.ComponentIndex"),
                 GeneratedFileHeader(GeneratorSource(nameof(ComponentIndex))) +
                 $"using global::{component.ContextPrefix};\n\n" +
                 NamespaceDeclaration(component.Namespace,
                     $$"""
+                    // {{options.TestValue}}
                     public static class {{component.ContextAwareComponentPrefix}}ComponentIndex
                     {
                         public static ComponentIndex Index;

diff --git a/gen/Entitas.Generators/EntitasAnalyzerConfigOptions.cs b/gen/Entitas.Generators/EntitasAnalyzerConfigOptions.cs
@@ -0,0 +1,25 @@
+using System;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace Entitas.Generators;
+
+public readonly struct EntitasAnalyzerConfigOptions : IEquatable<EntitasAnalyzerConfigOptions>
+{
+    public const string TestValueKey = "entitas_test_option";
+
+    public readonly bool TestValue;
+
+    public EntitasAnalyzerConfigOptions(AnalyzerConfigOptions options)
+    {
+        TestValue = IsTrue(options, TestValueKey);
+    }
+
+    static bool IsTrue(AnalyzerConfigOptions options, string key)
+    {
+        return options.TryGetValue(key, out var value) && value.Equals("true", StringComparison.OrdinalIgnoreCase);
+    }
+
+    public bool Equals(EntitasAnalyzerConfigOptions other) => TestValue == other.TestValue;
+    public override bool Equals(object? obj) => obj is EntitasAnalyzerConfigOptions other && Equals(other);
+    public override int GetHashCode() => TestValue.GetHashCode();
+}
diff --git a/tests/Entitas.Generators.IntegrationTests/ComponentTests.cs b/tests/Entitas.Generators.IntegrationTests/ComponentTests.cs
@@ -36,7 +36,7 @@ public void GetsComponent()
         }
 
         [Fact]
-        public void GettingNonExistingComponentReturnNull()
+        public void GettingNonExistingComponentReturnsNull()
         {
             var entity = _context.CreateEntity();
             entity.GetPosition().Should().BeNull();

diff --git a/tests/Entitas.Generators.Tests/TestHelper.cs b/tests/Entitas.Generators.Tests/TestHelper.cs
@@ -1,10 +1,14 @@
 using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 using FluentAssertions;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.Diagnostics;
 using MyFeature;
 using VerifyXunit;
 
@@ -32,7 +36,14 @@ public static Task Verify(string source, IIncrementalGenerator generator)
                 references,
                 new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
 
-            var driver = CSharpGeneratorDriver.Create(generator).RunGenerators(compilation);
+            var driver = CSharpGeneratorDriver
+                .Create(generator)
+                .WithUpdatedAnalyzerConfigOptions(new TestAnalyzerConfigOptionsProvider(new Dictionary<string, string>
+                {
+                    { EntitasAnalyzerConfigOptions.TestValueKey, "true" }
+                }))
+                .RunGenerators(compilation);
+
             return Verifier.Verify(driver).UseDirectory("snapshots");
         }
 
@@ -50,4 +61,30 @@ public static void AssertUsesGlobalNamespaces(string code)
             }
         }
     }
+
+    sealed class TestAnalyzerConfigOptionsProvider : AnalyzerConfigOptionsProvider
+    {
+        public override AnalyzerConfigOptions GlobalOptions { get; }
+
+        public TestAnalyzerConfigOptionsProvider(Dictionary<string, string> options)
+        {
+            GlobalOptions = new DictionaryAnalyzerConfigOptions(options.ToImmutableDictionary());
+        }
+
+        public override AnalyzerConfigOptions GetOptions(SyntaxTree tree) => DictionaryAnalyzerConfigOptions.Empty;
+        public override AnalyzerConfigOptions GetOptions(AdditionalText textFile) => DictionaryAnalyzerConfigOptions.Empty;
+    }
+
+    sealed class DictionaryAnalyzerConfigOptions : AnalyzerConfigOptions
+    {
+        static readonly ImmutableDictionary<string, string> EmptyDictionary = ImmutableDictionary.Create<string, string>(KeyComparer);
+
+        public static DictionaryAnalyzerConfigOptions Empty { get; } = new DictionaryAnalyzerConfigOptions(EmptyDictionary);
+
+        readonly ImmutableDictionary<string, string> _options;
+
+        public DictionaryAnalyzerConfigOptions(ImmutableDictionary<string, string> options) => _options = options;
+
+        public override bool TryGetValue(string key, [NotNullWhen(true)] out string? value) => _options.TryGetValue(key, out value);
+    }
 }