Fix csharp_style_namespace_declarations EditorConfig support for step definition generation

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,62 @@ 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 using target .cs file path
+        var targetFilePath = Path.Combine(targetFolder, className + ".cs");
+        var csharpConfig = new CSharpCodeGenerationConfiguration();
+        var editorConfigOptions = _editorConfigOptionsProvider.GetEditorConfigOptionsByPath(targetFilePath);
+        editorConfigOptions.UpdateFromEditorConfig(csharpConfig);
+
+        // Estimate template size for StringBuilder capacity
+        var estimatedSize = 200 + fileNamespace.Length + className.Length + combinedSnippet.Length;
+        var template = new StringBuilder(estimatedSize);
+        template.AppendLine("using System;");
+        template.AppendLine($"using {libraryNameSpace};");
+        template.AppendLine();
+
+        // Determine indentation level based on namespace style
+        var classIndent = csharpConfig.UseFileScopedNamespaces ? "" : indent;
+
+        // Adjust combinedSnippet indentation based on namespace style
+        var adjustedSnippet = csharpConfig.UseFileScopedNamespaces
+            ? AdjustIndentationForFileScopedNamespace(combinedSnippet, indent, newLine)
+            : combinedSnippet;
+        // 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(adjustedSnippet);
+        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();
 
@@ -168,4 +208,31 @@ await discoveryService.BindingRegistryCache
 
         Finished.Set();
     }
+
+    private static string AdjustIndentationForFileScopedNamespace(string snippet, string indent, string newLine)
+    {
+        if (string.IsNullOrEmpty(snippet))
+            return snippet;
+
+        // Split into lines and process each line
+        var lines = snippet.Split(new[] { newLine }, StringSplitOptions.None);
+        var adjustedLines = new string[lines.Length];
+
+        for (int i = 0; i < lines.Length; i++)
+        {
+            var line = lines[i];
+
+            // If line starts with double indentation, reduce it to single indentation
+            if (line.StartsWith(indent + indent))
+            {
+                adjustedLines[i] = indent + line.Substring((indent + indent).Length);
+            }
+            else
+            {
+                adjustedLines[i] = line;
+            }
+        }
+
+        return string.Join(newLine, adjustedLines);
+    }
 }

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);
         }

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

@@ -26,6 +26,21 @@ public IEditorConfigOptions GetEditorConfigOptions(IWpfTextView textView)
         return new EditorConfigOptions(options);
     }
 
+    public IEditorConfigOptions GetEditorConfigOptionsByPath(string filePath)
+    {
+        if (string.IsNullOrEmpty(filePath))
+            return NullEditorConfigOptions.Instance;
+
+        var document = CreateAdHocDocumentByPath(filePath);
+        if (document == null)
+            return NullEditorConfigOptions.Instance;
+
+        var options =
+            ThreadHelper.JoinableTaskFactory.Run(() => document.GetOptionsAsync());
+
+        return new EditorConfigOptions(options);
+    }
+
     private Document GetDocument(IWpfTextView textView) =>
         textView.TextBuffer.GetRelatedDocuments().FirstOrDefault() ??
         CreateAdHocDocument(textView);
@@ -35,10 +50,17 @@ private Document CreateAdHocDocument(IWpfTextView textView)
         var editorFilePath = GetPath(textView);
         if (editorFilePath == null)
             return null;
+        return CreateAdHocDocumentByPath(editorFilePath);
+    }
+
+    private Document CreateAdHocDocumentByPath(string filePath)
+    {
+        if (string.IsNullOrEmpty(filePath))
+            return null;
         var project = _visualStudioWorkspace.CurrentSolution.Projects.FirstOrDefault();
         if (project == null)
             return null;
-        return project.AddDocument(editorFilePath, string.Empty, filePath: editorFilePath);
+        return project.AddDocument(filePath, string.Empty, filePath: filePath);
     }
 
     public static string GetPath(IWpfTextView textView)

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

@@ -3,4 +3,5 @@ namespace Reqnroll.VisualStudio.Editor.Services.EditorConfig;
 public interface IEditorConfigOptionsProvider
 {
     IEditorConfigOptions GetEditorConfigOptions(IWpfTextView textView);
+    IEditorConfigOptions GetEditorConfigOptionsByPath(string filePath);
 }

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;
                 }