Change behaviour of adding Steps

A step is now considered to live in a dedicated `Resource` package: Creating a
step `Soldering` would create a package `<project>.Resources.Soldering` and put
all related resource files into that project.

Author: seveneleven

Moryx.Cli.sln

@@ -20,6 +20,8 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "SolutionItems", "SolutionIt
 		Directory.Build.targets = Directory.Build.targets
 	EndProjectSection
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Moryx.Cli.Commands.Tests", "src\Tests\Moryx.Cli.Commands.Tests\Moryx.Cli.Commands.Tests.csproj", "{4C082129-3A6D-4A72-80DC-8A9D3A71A79F}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -46,12 +48,17 @@ Global
 		{F6E69A2A-F183-4A01-8629-CEBBB0417ED6}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{F6E69A2A-F183-4A01-8629-CEBBB0417ED6}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{F6E69A2A-F183-4A01-8629-CEBBB0417ED6}.Release|Any CPU.Build.0 = Release|Any CPU
+		{4C082129-3A6D-4A72-80DC-8A9D3A71A79F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{4C082129-3A6D-4A72-80DC-8A9D3A71A79F}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{4C082129-3A6D-4A72-80DC-8A9D3A71A79F}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{4C082129-3A6D-4A72-80DC-8A9D3A71A79F}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
 	GlobalSection(NestedProjects) = preSolution
 		{E65D2591-A889-4F42-A6F5-AECAFB77DBB0} = {6FC4CD2F-8BFA-4EC1-84A9-D3670BA92E4D}
+		{4C082129-3A6D-4A72-80DC-8A9D3A71A79F} = {6FC4CD2F-8BFA-4EC1-84A9-D3670BA92E4D}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {99BD1616-551D-473A-A6DB-6A9C0F030AB7}

src/Moryx.Cli.Commands/AddResources.cs

@@ -9,23 +9,27 @@ public static class AddResources
         public static CommandResult Exec(TemplateSettings settings, IEnumerable<string> resources)
         {
             return CommandBase.Exec(settings, (filenames)
-                => resources.Select(resource => AddThing.Exec(
-                    settings,
-                    new AddConfig
+                => resources.Select(resource =>
+                {
+                    var addConfig = new AddConfig
                     {
                         SolutionName = settings.AppName,
                         ThingName = $"{resource}Resource",
                         Thing = "resource",
-                        ThingPlaceholders = 
-                        [
-                            Template.Template.ResourcePlaceholder, 
+                        ThingPlaceholders =
+                            [
+                                Template.Template.ResourcePlaceholder,
                             Template.Template.ResourcePlaceholder2
-                        ],
-                    },
-                    filenames.Resource()
-                    ))
-                    .ToArray()
-                    .Flatten());
+                            ],
+                    };
+                    return AddThing.Exec(
+                        settings,
+                        addConfig,
+                        filenames.Resource()
+                    );
+                })
+                .ToArray()
+                .Flatten());
         }
     }
 }

src/Moryx.Cli.Commands/AddStep.cs

@@ -1,24 +1,49 @@
-using Moryx.Cli.Template;
+using Microsoft.Build.Construction;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.MSBuild;
+using Moryx.Cli.Commands.Components;
+using Moryx.Cli.Template;
 using Moryx.Cli.Template.Models;
+using Moryx.Configuration;
+using System.Diagnostics;
 
 namespace Moryx.Cli.Commands
 {
     public static class AddStep
     {
         public static CommandResult Exec(TemplateSettings settings, string step)
         {
-            return CommandBase.Exec(settings, (filenames)
-                => AddThing.Exec(
+            return CommandBase.Exec(settings, (filenames) =>
+            {
+                var addConfig = new AddConfig
+                {
+                    SolutionName = settings.AppName,
+                    ThingName = step,
+                    Thing = "step",
+                    ThingPlaceholders = [Template.Template.StepPlaceholder],
+                };
+                var namespacePlaceholder = new Dictionary<string, string> {
+
+                    { $"{Template.Template.AppPlaceholder}.Resources", $"{settings.AppName}.Resources.{step}" },
+                    { $"{settings.AppName}.Resources", $"{settings.AppName}.Resources.{step}" }
+                };
+                var replacements = new StringReplacements(addConfig)
+                    .AddFileNamePatterns(namespacePlaceholder)
+                    .AddContentPatterns(namespacePlaceholder)
+                    ;
+                
+                return AddThing.Exec(
                     settings,
-                    new AddConfig
+                    addConfig,
+                    filenames.Step(),
+                    (createdFiles) =>
                     {
-                        SolutionName = settings.AppName,
-                        ThingName = step,
-                        Thing = "step",
-                        ThingPlaceholders = [Template.Template.StepPlaceholder],
+                        var projectFileName = createdFiles.FirstOrDefault(f => f.EndsWith(".csproj"));
+                        SolutionFileManipulation.AddProjectToSolution(settings, projectFileName);
                     },
-                    filenames.Step()
-                    ));
+                    replacements
+                );
+            });
         }
     }
 }

src/Moryx.Cli.Commands/AddSteps.cs

@@ -9,16 +9,9 @@ public static class AddSteps
         public static CommandResult Exec(TemplateSettings settings, IEnumerable<string> cells)
         {
             return CommandBase.Exec(settings, (filenames) 
-                => cells.Select(step => AddThing.Exec(
+                => cells.Select(step => AddStep.Exec(
                     settings,
-                    new AddConfig
-                    {
-                        SolutionName = settings.AppName,
-                        ThingName = step,
-                        Thing = "step",
-                        ThingPlaceholders = [Template.Template.StepPlaceholder],
-                    },
-                    filenames.Step()
+                    step
                     ))
                     .ToArray()
                     .Flatten());

src/Moryx.Cli.Commands/AddThing.cs

@@ -1,33 +1,45 @@
-using Moryx.Cli.Commands.Extensions;
+using Castle.Components.DictionaryAdapter;
+using Microsoft.CodeAnalysis.FlowAnalysis;
+using Moryx.Cli.Commands.Extensions;
 using Moryx.Cli.Template;
 using Moryx.Cli.Template.Models;
 
 namespace Moryx.Cli.Commands
 {
     public static class AddThing
     {
-        public static CommandResult Exec(TemplateSettings settings, AddConfig config, List<string> resourceNames, Action<IEnumerable<string>>? onAddedFiles = null)
+        /// <summary>
+        /// Retrieves files of a certain category from the template and moves them as defined 
+        /// in <paramref name="filenames"/> to the current project.
+        /// </summary>
+        /// <param name="settings"></param>
+        /// <param name="config"></param>
+        /// <param name="resourceNames"></param>
+        /// <param name="onAddedFiles"></param>
+        /// <returns></returns>
+        public static CommandResult Exec(TemplateSettings settings, AddConfig config, List<string> resourceNames, Action<IEnumerable<string>>? onAddedFiles = null, StringReplacements? replacements = null)
         {
             return CommandBase.Exec(settings, (filenames) =>
             {
                 var projectFilenames = filenames.InitialProjects();
 
                 try
                 {
+                    if(replacements == null)
+                    {
+                        replacements = new StringReplacements(config);
+                    }
                     var dictionary = Template.Template.PrepareFileStructure(config.SolutionName, resourceNames, projectFilenames);
 
                     var files = Template.Template.WriteFilesToDisk(
                         dictionary,
                         settings,
-                        s => s.Replace(config.ThingPlaceholders, config.ThingName).Replace(Template.Template.AppPlaceholder, config.SolutionName));
-
-                    var replaceHolders = config.ThingPlaceholders
-                        .ToDictionary(s => s, s => config.ThingName);
-                    replaceHolders.Add(Template.Template.AppPlaceholder, config.SolutionName);
+                        s => s.Replace(replacements.FileNamePatterns)
+                    );
 
                     Template.Template.ReplacePlaceHoldersInsideFiles(
                         files,
-                        replaceHolders);
+                        replacements.FileContentPatterns);
 
                     onAddedFiles?.Invoke(files);
                 }
@@ -63,4 +75,50 @@ public class AddConfig
         /// </summary>
         public required IEnumerable<string> ThingPlaceholders { get; set; }
     }
+
+    public class StringReplacements
+    {
+        public Dictionary<string, string> FileNamePatterns { get; }
+        public Dictionary<string, string> FileContentPatterns { get; }w
+
+        public StringReplacements(AddConfig config)
+        {
+            FileNamePatterns = CreateDictionary(config);
+            FileContentPatterns = CreateDictionary(config);
+        }
+
+        public Dictionary<string, string> CreateDictionary(AddConfig config)
+        {
+            var result = config.ThingPlaceholders
+                .ToDictionary(s => s, s => config.ThingName);
+
+            result.TryAdd(Template.Template.AppPlaceholder, config.SolutionName);
+            return result;
+        }
+
+
+        public StringReplacements AddFileNamePatterns(Dictionary<string, string> patterns)
+        {
+            foreach (var pattern in patterns)
+            {
+                if (!FileNamePatterns.ContainsKey(pattern.Key))
+                {
+                    FileNamePatterns.Add(pattern.Key, pattern.Value);
+                }
+            }
+            return this;
+        }
+
+        public StringReplacements AddContentPatterns(Dictionary<string, string> patterns)
+        {
+            foreach (var pattern in patterns)
+            {
+                if (!FileContentPatterns.ContainsKey(pattern.Key))
+                {
+                    FileContentPatterns.Add(pattern.Key, pattern.Value);
+                }
+            }
+            return this;
+        }
+    }
 }

src/Moryx.Cli.Commands/CommandResult.cs

@@ -1,17 +1,20 @@
-namespace Moryx.Cli.Commands
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Moryx.Tools;
+
+namespace Moryx.Cli.Commands
 {
     public class CommandResult
     {
         private int ReturnCode { get; set; }
         public string? Success { get; private set; }
         public string? Warning { get; private set; }
-        public string? Error { get; private set; }
+        public IList<string> Errors { get; private set; } = [];
 
-        public static CommandResult WithError(string error) 
+        public static CommandResult WithError(string error)
             => new()
             {
                 Success = null,
-                Error = error,
+                Errors = [error],
                 Warning = null,
                 ReturnCode = 1,
             };
@@ -21,20 +24,29 @@ public static CommandResult IsOk(string message, string? warning = null)
             {
                 Success = message,
                 Warning = warning,
-                Error = null,
                 ReturnCode = 0,
             };
 
+        public CommandResult CouldHaveIssues(IReadOnlyCollection<CommandResult> results)
+        {
+            foreach (var result in results)
+            {
+                result.OnError(Errors.Add);
+            }
+            return this;
+        }
+
         public CommandResult OnError(Action<string> action)
         {
-            if (Error != null)
-                action(Error);
+            if (Errors.Count > 0)
+                foreach (var error in Errors)
+                    action(error);
             return this;
         }
 
         public CommandResult OnSuccess(Action<string, string?> action)
         {
-            if(Success != null)
+            if (Success != null)
                 action(Success, Warning);
             return this;
         }

src/Moryx.Cli.Commands/Components/SolutionFileManipulation.cs

@@ -0,0 +1,50 @@
+using Microsoft.Build.Construction;
+using Microsoft.CodeAnalysis;
+using Moryx.Cli.Template.Models;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Moryx.Cli.Commands.Components
+{
+    internal class SolutionFileManipulation
+    {
+
+
+        public static void AddProjectToSolution(TemplateSettings settings, string? projectFileName)
+        {
+            if (projectFileName == null)
+                return;
+            var solutionFileName = Path.Combine(settings.AppName, $"{settings.AppName}.sln");
+
+
+            // It'd be prefered to utilize Roslyn to add the project to the
+            // solution, but loading the solution/workspace in the first place
+            // involves some analyzing and takes way too much time for being
+            // used in a simple CLI command.
+
+            // This is 'the' GUID used for `.csproj` inside `.sln`s. Got it from
+            // `SolutionFile` of `Microsoft.Build.Construction`
+            const string csharpProjectGuid = "{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}";
+            var guid = Guid.NewGuid().ToString("B").ToUpper();
+
+
+            var filename = Path.GetFileNameWithoutExtension(projectFileName);
+            var relativePath = Path.GetRelativePath(settings.TargetDirectory, projectFileName);
+            var str = $"Project(\"{csharpProjectGuid}\") = \"{filename}\", \"{relativePath}\", \"{{{guid}}}\"\nEndProject\n";
+
+            var lines = File.ReadAllLines(solutionFileName);
+            using var fileWriter = new StreamWriter(solutionFileName);
+            foreach (var line in lines)
+            {
+                if (line.StartsWith("Global"))
+                {
+                    fileWriter.WriteLine(str);
+                }
+                fileWriter.WriteLine(line);
+            }
+        }
+    }
+}