Fix csharp_style_namespace_declarations EditorConfig support for step definition generation

.editorconfig

@@ -20,6 +20,7 @@ tab_width=2
 csharp_new_line_before_members_in_object_initializers=false
 csharp_preferred_modifier_order=public, private, protected, internal, new, abstract, virtual, sealed, override, static, readonly, extern, unsafe, volatile, async:suggestion
 csharp_space_after_cast=false
+csharp_style_namespace_declarations=file_scoped:warning
 csharp_style_var_elsewhere=true:hint
 csharp_style_var_for_built_in_types=true:hint
 csharp_style_var_when_type_is_apparent=true:hint

Reqnroll.VisualStudio/Configuration/CSharpCodeGenerationConfiguration.cs

@@ -0,0 +1,18 @@
+namespace Reqnroll.VisualStudio.Configuration;
+
+public class CSharpCodeGenerationConfiguration
+{
+    /// <summary>
+    /// Specifies the namespace declaration style for generated C# code.
+    /// Uses file-scoped namespaces when set to "file_scoped", otherwise uses block-scoped namespaces.
+    /// </summary>
+    [EditorConfigSetting("csharp_style_namespace_declarations")]
+    public string NamespaceDeclarationStyle { get; set; } = "block_scoped";
+
+    /// <summary>
+    /// Determines if file-scoped namespaces should be used based on the EditorConfig setting.
+    /// </summary>
+    public bool UseFileScopedNamespaces =>
+        NamespaceDeclarationStyle != null &&
+        NamespaceDeclarationStyle.StartsWith("file_scoped", StringComparison.OrdinalIgnoreCase);
+}

Reqnroll.VisualStudio/Editor/Commands/DefineStepsCommand.cs

@@ -1,16 +1,23 @@
 #nullable disable
+
+using System.Text;
+
 namespace Reqnroll.VisualStudio.Editor.Commands;
 
 [Export(typeof(IDeveroomFeatureEditorCommand))]
 public class DefineStepsCommand : DeveroomEditorCommandBase, IDeveroomFeatureEditorCommand
 {
+    private readonly IEditorConfigOptionsProvider _editorConfigOptionsProvider;
+
     [ImportingConstructor]
     public DefineStepsCommand(
         IIdeScope ideScope,
         IBufferTagAggregatorFactoryService aggregatorFactory,
-        IDeveroomTaggerProvider taggerProvider)
+        IDeveroomTaggerProvider taggerProvider,
+        IEditorConfigOptionsProvider editorConfigOptionsProvider)
         : base(ideScope, aggregatorFactory, taggerProvider)
     {
+        _editorConfigOptionsProvider = editorConfigOptionsProvider;
     }
 
     public override DeveroomEditorCommandTargetKey[] Targets => new[]
@@ -101,7 +108,7 @@ public override bool PreExec(IWpfTextView textView, DeveroomEditorCommandTargetK
         switch (viewModel.Result)
         {
             case CreateStepDefinitionsDialogResult.Create:
-                SaveAsStepDefinitionClass(projectScope, combinedSnippet, viewModel.ClassName, indent, newLine);
+                SaveAsStepDefinitionClass(projectScope, combinedSnippet, viewModel.ClassName, indent, newLine, textView);
                 break;
             case CreateStepDefinitionsDialogResult.CopyToClipboard:
                 Logger.LogVerbose($"Copy to clipboard: {combinedSnippet}");
@@ -114,7 +121,7 @@ public override bool PreExec(IWpfTextView textView, DeveroomEditorCommandTargetK
     }
 
     private void SaveAsStepDefinitionClass(IProjectScope projectScope, string combinedSnippet, string className,
-        string indent, string newLine)
+        string indent, string newLine, IWpfTextView textView)
     {
         string targetFolder = projectScope.ProjectFolder;
         var projectSettings = projectScope.GetProjectSettings();
@@ -130,29 +137,56 @@ private void SaveAsStepDefinitionClass(IProjectScope projectScope, string combin
         var isSpecFlow = projectTraits.HasFlag(ReqnrollProjectTraits.LegacySpecFlow) || projectTraits.HasFlag(ReqnrollProjectTraits.SpecFlowCompatibility);
         var libraryNameSpace = isSpecFlow ? "SpecFlow" : "Reqnroll";
 
-        var template = "using System;" + newLine +
-                       $"using {libraryNameSpace};" + newLine +
-                       newLine +
-                       $"namespace {fileNamespace}" + newLine +
-                       "{" + newLine +
-                       $"{indent}[Binding]" + newLine +
-                       $"{indent}public class {className}" + newLine +
-                       $"{indent}{{" + newLine +
-                       combinedSnippet +
-                       $"{indent}}}" + newLine +
-                       "}" + newLine;
+        // Get C# code generation configuration from EditorConfig
+        var csharpConfig = new CSharpCodeGenerationConfiguration();
+        var editorConfigOptions = _editorConfigOptionsProvider.GetEditorConfigOptions(textView);
+        editorConfigOptions.UpdateFromEditorConfig(csharpConfig);
+
+        // Build template with common structure
+        var template = new StringBuilder();
+        template.AppendLine("using System;");
+        template.AppendLine($"using {libraryNameSpace};");
+        template.AppendLine();
+
+        // Determine indentation level based on namespace style
+        var classIndent = csharpConfig.UseFileScopedNamespaces ? "" : indent;
+
+        // Add namespace declaration
+        if (csharpConfig.UseFileScopedNamespaces)
+        {
+            template.AppendLine($"namespace {fileNamespace};");
+            template.AppendLine();
+        }
+        else
+        {
+            template.AppendLine($"namespace {fileNamespace}");
+            template.AppendLine("{");
+        }
+
+        // Add class declaration (common structure with appropriate indentation)
+        template.AppendLine($"{classIndent}[Binding]");
+        template.AppendLine($"{classIndent}public class {className}");
+        template.AppendLine($"{classIndent}{{");
+        template.Append(combinedSnippet);
+        template.AppendLine($"{classIndent}}}");
+
+        // Close namespace if block-scoped
+        if (!csharpConfig.UseFileScopedNamespaces)
+        {
+            template.AppendLine("}");
+        }
 
         var targetFile = FileDetails
             .FromPath(targetFolder, className + ".cs")
-            .WithCSharpContent(template);
+            .WithCSharpContent(template.ToString());
 
         if (IdeScope.FileSystem.File.Exists(targetFile.FullName))
             if (IdeScope.Actions.ShowSyncQuestion("Overwrite file?",
                     $"The selected step definition file '{targetFile}' already exists. By overwriting the existing file you might lose work. {Environment.NewLine}Do you want to overwrite the file?",
                     defaultButton: MessageBoxResult.No) != MessageBoxResult.Yes)
                 return;
 
-        projectScope.AddFile(targetFile, template);
+        projectScope.AddFile(targetFile, template.ToString());
         projectScope.IdeScope.Actions.NavigateTo(new SourceLocation(targetFile, 9, 1));
         IDiscoveryService discoveryService = projectScope.GetDiscoveryService();
 

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

@@ -26,16 +26,16 @@ public static void UpdateFromEditorConfig<TConfig>(this IEditorConfigOptions edi
             .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);
             var updatedValue = editorConfigOptions.GetOption(property.PropertyInfo.PropertyType,
-                property.EditorConfigSettingName, currentValue);
+                property.EditorConfigKey, currentValue);
             if (!Equals(currentValue, updatedValue))
                 property.PropertyInfo.SetValue(config, updatedValue);
         }

Tests/Reqnroll.VisualStudio.Specs/StepDefinitions/ProjectSystemSteps.cs

@@ -478,7 +478,8 @@ private void PerformCommand(string commandName, string parameter = null,
                 }
             case "Define Steps":
                 {
-                    _invokedCommand = new DefineStepsCommand(_ideScope, aggregatorFactoryService, taggerProvider);
+                    _invokedCommand = new DefineStepsCommand(_ideScope, aggregatorFactoryService, taggerProvider,
+                        new StubEditorConfigOptionsProvider());
                     _invokedCommand.PreExec(_wpfTextView, _invokedCommand.Targets.First());
                     return;
                 }

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

@@ -0,0 +1,154 @@
+using Reqnroll.VisualStudio.Configuration;
+using Reqnroll.VisualStudio.Editor.Services.EditorConfig;
+using Xunit;
+
+namespace Reqnroll.VisualStudio.Tests.Configuration;
+
+public class CSharpCodeGenerationConfigurationTests
+{
+    [Fact]
+    public void UseFileScopedNamespaces_WhenFileScopedSet_ReturnsTrue()
+    {
+        // Arrange
+        var config = new CSharpCodeGenerationConfiguration
+        {
+            NamespaceDeclarationStyle = "file_scoped"
+        };
+
+        // Act & Assert
+        Assert.True(config.UseFileScopedNamespaces);
+    }
+
+    [Fact]
+    public void UseFileScopedNamespaces_WhenFileScopedWithSeveritySet_ReturnsTrue()
+    {
+        // Arrange
+        var config = new CSharpCodeGenerationConfiguration
+        {
+            NamespaceDeclarationStyle = "file_scoped:warning"
+        };
+
+        // Act & Assert
+        Assert.True(config.UseFileScopedNamespaces);
+    }
+
+    [Fact]
+    public void UseFileScopedNamespaces_WhenBlockScopedSet_ReturnsFalse()
+    {
+        // Arrange
+        var config = new CSharpCodeGenerationConfiguration
+        {
+            NamespaceDeclarationStyle = "block_scoped"
+        };
+
+        // Act & Assert
+        Assert.False(config.UseFileScopedNamespaces);
+    }
+
+    [Fact]
+    public void UseFileScopedNamespaces_WhenDefaultValue_ReturnsFalse()
+    {
+        // Arrange
+        var config = new CSharpCodeGenerationConfiguration();
+
+        // Act & Assert
+        Assert.False(config.UseFileScopedNamespaces);
+    }
+
+    [Fact]
+    public void UseFileScopedNamespaces_WhenNullValue_ReturnsFalse()
+    {
+        // Arrange
+        var config = new CSharpCodeGenerationConfiguration
+        {
+            NamespaceDeclarationStyle = null
+        };
+
+        // Act & Assert
+        Assert.False(config.UseFileScopedNamespaces);
+    }
+
+    [Fact]
+    public void UseFileScopedNamespaces_WhenUnknownValue_ReturnsFalse()
+    {
+        // Arrange
+        var config = new CSharpCodeGenerationConfiguration
+        {
+            NamespaceDeclarationStyle = "unknown_style"
+        };
+
+        // 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;
+    }
+}

Tests/Reqnroll.VisualStudio.Tests/Editor/Commands/DefineStepsCommandTests.cs

@@ -6,7 +6,8 @@ public class DefineStepsCommandTests : CommandTestBase<DefineStepsCommand>
 {
     public DefineStepsCommandTests(ITestOutputHelper testOutputHelper)
         : base(testOutputHelper, (ps, tp) =>
-                new DefineStepsCommand(ps.IdeScope, new StubBufferTagAggregatorFactoryService(tp), tp),
+                new DefineStepsCommand(ps.IdeScope, new StubBufferTagAggregatorFactoryService(tp), tp,
+                    new StubEditorConfigOptionsProvider()),
             "ShowProblem: User Notification: ")
     {
     }