Fix EditorConfig parsing bug and add debugging for namespace declaration support

Co-authored-by: 304NotModified <[email protected]>

Author: Copilot

Reqnroll.VisualStudio/Editor/Commands/DefineStepsCommand.cs

@@ -142,6 +142,10 @@ private void SaveAsStepDefinitionClass(IProjectScope projectScope, string combin
         var editorConfigOptions = _editorConfigOptionsProvider.GetEditorConfigOptions(textView);
         editorConfigOptions.UpdateFromEditorConfig(csharpConfig);
 
+        // Debug: Log the configuration values
+        System.Diagnostics.Debug.WriteLine($"[DefineStepsCommand] NamespaceDeclarationStyle: '{csharpConfig.NamespaceDeclarationStyle}'");
+        System.Diagnostics.Debug.WriteLine($"[DefineStepsCommand] UseFileScopedNamespaces: {csharpConfig.UseFileScopedNamespaces}");
+
         // Build template with common structure
         var template = new StringBuilder();
         template.AppendLine("using System;");

Reqnroll.VisualStudio/Editor/Services/EditorConfig/EditorConfigOptions.cs

@@ -19,13 +19,21 @@ public EditorConfigOptions(DocumentOptionSet options)
 
     public TResult GetOption<TResult>(string editorConfigKey, TResult defaultValue)
     {
+        System.Diagnostics.Debug.WriteLine($"[EditorConfigOptions] GetOption: key='{editorConfigKey}', defaultValue='{defaultValue}', type={typeof(TResult).Name}");
+        
         if (_directEditorConfigValues.TryGetValue(editorConfigKey, out var simplifiedValue))
         {
+            System.Diagnostics.Debug.WriteLine($"[EditorConfigOptions] Found value: '{simplifiedValue}' for key '{editorConfigKey}'");
             if (TryConvertFromString(simplifiedValue, defaultValue, out var convertedValue))
             {
+                System.Diagnostics.Debug.WriteLine($"[EditorConfigOptions] Converted value: '{convertedValue}' for key '{editorConfigKey}'");
                 return convertedValue;
             }
         }
+        else
+        {
+            System.Diagnostics.Debug.WriteLine($"[EditorConfigOptions] No value found for key '{editorConfigKey}', returning default: '{defaultValue}'");
+        }
         return defaultValue;
     }
 
@@ -60,7 +68,18 @@ private Dictionary<string, string> ExtractEditorConfigValues()
             var dacOptionsField = optionsAnalyzerConfigOptions?.GetType()?.GetField("Options", BindingFlags.NonPublic | BindingFlags.Instance);
             var optionsCollection = dacOptionsField?.GetValue(optionsAnalyzerConfigOptions) as ImmutableDictionary<string, string>;
             if (optionsCollection != null)
+            {
                 values = new Dictionary<string, string>(optionsCollection);
+                System.Diagnostics.Debug.WriteLine($"[EditorConfigOptions] Extracted {values.Count} EditorConfig values");
+                foreach (var kvp in values)
+                {
+                    System.Diagnostics.Debug.WriteLine($"[EditorConfigOptions] Key: '{kvp.Key}' = '{kvp.Value}'");
+                }
+            }
+            else
+            {
+                System.Diagnostics.Debug.WriteLine("[EditorConfigOptions] No options collection found");
+            }
         }
         catch (Exception ex)
         {

Reqnroll.VisualStudio/Editor/Services/EditorConfig/EditorConfigOptionsExtensions.cs

@@ -21,23 +21,37 @@ public static void UpdateFromEditorConfig<TConfig>(this IEditorConfigOptions edi
     {
         if (config == null) throw new ArgumentNullException(nameof(config));
 
+        System.Diagnostics.Debug.WriteLine($"[UpdateFromEditorConfig] Updating configuration for type: {typeof(TConfig).Name}");
+
         var propertiesWithEditorConfig = typeof(TConfig)
             .GetProperties(BindingFlags.Instance | BindingFlags.Public)
             .Select(p => new
             {
                 PropertyInfo = p,
-                ((EditorConfigSettingAttribute) Attribute.GetCustomAttribute(p, typeof(EditorConfigSettingAttribute)))
+                EditorConfigKey = ((EditorConfigSettingAttribute) Attribute.GetCustomAttribute(p, typeof(EditorConfigSettingAttribute)))
                     ?.EditorConfigSettingName
             })
-            .Where(p => p.EditorConfigSettingName != null);
+            .Where(p => p.EditorConfigKey != null);
 
         foreach (var property in propertiesWithEditorConfig)
         {
             var currentValue = property.PropertyInfo.GetValue(config);
+            System.Diagnostics.Debug.WriteLine($"[UpdateFromEditorConfig] Property: {property.PropertyInfo.Name}, EditorConfigKey: {property.EditorConfigKey}, CurrentValue: {currentValue}");
+            
             var updatedValue = editorConfigOptions.GetOption(property.PropertyInfo.PropertyType,
-                property.EditorConfigSettingName, currentValue);
+                property.EditorConfigKey, currentValue);
+            
+            System.Diagnostics.Debug.WriteLine($"[UpdateFromEditorConfig] UpdatedValue: {updatedValue}");
+            
             if (!Equals(currentValue, updatedValue))
+            {
+                System.Diagnostics.Debug.WriteLine($"[UpdateFromEditorConfig] Setting property {property.PropertyInfo.Name} from '{currentValue}' to '{updatedValue}'");
                 property.PropertyInfo.SetValue(config, updatedValue);
+            }
+            else
+            {
+                System.Diagnostics.Debug.WriteLine($"[UpdateFromEditorConfig] Property {property.PropertyInfo.Name} unchanged: '{currentValue}'");
+            }
         }
     }
 }

Tests/Reqnroll.VisualStudio.Tests/Configuration/CSharpCodeGenerationConfigurationTests.cs

@@ -1,4 +1,5 @@
 using Reqnroll.VisualStudio.Configuration;
+using Reqnroll.VisualStudio.Editor.Services.EditorConfig;
 using Xunit;
 
 namespace Reqnroll.VisualStudio.Tests.Configuration;
@@ -79,4 +80,75 @@ public void UseFileScopedNamespaces_WhenUnknownValue_ReturnsFalse()
         // Act & Assert
         Assert.False(config.UseFileScopedNamespaces);
     }
+
+    [Fact]
+    public void UpdateFromEditorConfig_WhenFileScopedValue_SetsCorrectValue()
+    {
+        // Arrange
+        var config = new CSharpCodeGenerationConfiguration();
+        var editorConfigOptions = new TestEditorConfigOptions("file_scoped:silent");
+
+        // Act
+        editorConfigOptions.UpdateFromEditorConfig(config);
+
+        // Assert
+        Assert.Equal("file_scoped:silent", config.NamespaceDeclarationStyle);
+        Assert.True(config.UseFileScopedNamespaces);
+    }
+
+    [Fact]
+    public void UpdateFromEditorConfig_WhenBlockScopedValue_SetsCorrectValue()
+    {
+        // Arrange
+        var config = new CSharpCodeGenerationConfiguration();
+        var editorConfigOptions = new TestEditorConfigOptions("block_scoped");
+
+        // Act
+        editorConfigOptions.UpdateFromEditorConfig(config);
+
+        // Assert
+        Assert.Equal("block_scoped", config.NamespaceDeclarationStyle);
+        Assert.False(config.UseFileScopedNamespaces);
+    }
+
+    [Fact]
+    public void UpdateFromEditorConfig_WhenNoValue_KeepsDefault()
+    {
+        // Arrange
+        var config = new CSharpCodeGenerationConfiguration();
+        var editorConfigOptions = new TestEditorConfigOptions(null);
+
+        // Act
+        editorConfigOptions.UpdateFromEditorConfig(config);
+
+        // Assert
+        Assert.Equal("block_scoped", config.NamespaceDeclarationStyle); // Should keep default
+        Assert.False(config.UseFileScopedNamespaces);
+    }
+}
+
+// Test EditorConfig options provider that simulates reading specific values
+public class TestEditorConfigOptions : IEditorConfigOptions
+{
+    private readonly string _namespaceStyle;
+    
+    public TestEditorConfigOptions(string namespaceStyle)
+    {
+        _namespaceStyle = namespaceStyle;
+    }
+
+    public TResult GetOption<TResult>(string editorConfigKey, TResult defaultValue)
+    {
+        if (editorConfigKey == "csharp_style_namespace_declarations" && _namespaceStyle != null)
+        {
+            return (TResult)(object)_namespaceStyle;
+        }
+        
+        return defaultValue;
+    }
+
+    public bool GetBoolOption(string editorConfigKey, bool defaultValue)
+    {
+        return defaultValue;
+    }
 }