Merge pull request #20 from PHOENIXCONTACT/fix/states-creation

seveneleven · web-flow · commit 22330f43077a · 2025-11-12T13:01:30.000+01:00
Create `States` more properly
diff --git a/global.json b/global.json
diff --git a/src/Moryx.Cli.Commands/AddStates.cs b/src/Moryx.Cli.Commands/AddStates.cs
@@ -19,15 +19,15 @@ internal static CommandResult Exec(Template template, string resource, IEnumerab
 
         private static CommandResult Add(Template template, string resource, IEnumerable<string> states)
         {
-            var resourceFile = FindResource(template.Settings, resource);
-            if (string.IsNullOrEmpty(resourceFile))
+            var resourceFileName = FindResource(template.Settings, resource);
+            if (string.IsNullOrEmpty(resourceFileName))
             {
                 return CommandResult.WithError($"`{resource}` not found. Make sure that a type `{resource}` exists in the project.");
             }
 
-
+            var resourceFile = CSharpFile.FromFile(resourceFileName);
             var dictionary = template.StateBaseFile(resource);
-            var targetPath = Path.Combine(Path.GetDirectoryName(resourceFile)!, "States");
+            var targetPath = Path.Combine(Path.GetDirectoryName(resourceFileName)!, "States");
             var newStateBaseFileName = Path.Combine(
                 targetPath,
                 Path.GetFileName(dictionary.FirstOrDefault().Value));
@@ -38,9 +38,11 @@ private static CommandResult Add(Template template, string resource, IEnumerable
             {
                 var files = template.WriteFilesToDisk(dictionary);
 
+                var stateBaseVars = template.ReplaceVariables(template.Configuration.Add.StateBase, "", new Dictionary<string, string>{ { Template.ResourceKey, resource} });
                 Template.ReplacePlaceHoldersInsideFiles(
                     files,
-                    template.Configuration.Add.StateBase.Replacements);
+                    stateBaseVars
+                    );
 
                 if (!states.Any())
                 {
@@ -81,13 +83,18 @@ private static CommandResult Add(Template template, string resource, IEnumerable
                     if (!File.Exists(filename))
                     {
                         var files = template.WriteFilesToDisk(stateFiles);
+                        var stateVars = template.ReplaceVariables(template.Configuration.Add.State, state, new Dictionary<string, string> { { Template.ResourceKey, resource } });
 
                         Template.ReplacePlaceHoldersInsideFiles(
                             files,
-                            template.Configuration.Add.State.Replacements);
+                            stateVars);
 
                         stateBaseTemplate = stateBaseTemplate.AddState(stateType);
 
+                        var stateTemplate = StateTemplate.FromFile(filename);
+                        stateTemplate.NamespaceName = resourceFile.NamespaceName + ".States";
+                        stateTemplate.SaveToFile(filename);
+
                         msg.Add($"Successfully added {stateType} state");
                     }
                     else
@@ -101,6 +108,7 @@ private static CommandResult Add(Template template, string resource, IEnumerable
                 }
             }
 
+            stateBaseTemplate.NamespaceName = resourceFile.NamespaceName + ".States";
             stateBaseTemplate.SaveToFile(newStateBaseFileName);
 
             UpdateResource(
diff --git a/src/Moryx.Cli.Commands/Components/ProjectFileManipulation.cs b/src/Moryx.Cli.Commands/Components/ProjectFileManipulation.cs
@@ -10,8 +10,12 @@ internal class ProjectFileManipulation
 
         public static void AddProjectReference(string targetProjectFileName, string referenceProjectFileName)
         {
+            var targetProjectDirectory = Path.GetDirectoryName(targetProjectFileName);
+            var referenceProjectDirectory = Path.GetDirectoryName(referenceProjectFileName);
+            if(targetProjectDirectory == null || referenceProjectDirectory == null)
+                return;
 
-            var referencePath = Path.GetRelativePath(Path.GetDirectoryName(targetProjectFileName), Path.GetDirectoryName(referenceProjectFileName));
+            var referencePath = Path.GetRelativePath(targetProjectDirectory, referenceProjectDirectory);
             referencePath = Path.Combine(referencePath, Path.GetFileName(referenceProjectFileName));
 
             var projectFile = LoadXml(targetProjectFileName);
diff --git a/src/Moryx.Cli.Commands/ExecCommand.cs b/src/Moryx.Cli.Commands/ExecCommand.cs
@@ -1,6 +1,5 @@
 ﻿using System.Net;
 using Moryx.Cli.Commands.Options;
-using System.Net;
 using System.Net.Http.Json;
 
 namespace Moryx.Cli.Commands
diff --git a/src/Moryx.Cli.Templates/Components/CSharpFile.cs b/src/Moryx.Cli.Templates/Components/CSharpFile.cs
@@ -8,7 +8,7 @@ public class CSharpFile : CSharpFileBase
     {
         private SyntaxNode _root;
         
-        private NamespaceDeclarationSyntax? _namespaceDeclaration;
+        private BaseNamespaceDeclarationSyntax? _namespaceDeclaration;
         
         public List<string> Types { get; private set; }
 
@@ -23,21 +23,25 @@ public string NamespaceName
         }
 
 
-        public CSharpFile(string content) : base(content)
+        public  CSharpFile(string content) : base(content)
         {
             _root = _syntaxTree.GetRoot();
             Types = ScanTypes();
             _namespaceDeclaration = ScanNamespace();
         }
 
         public static CSharpFile FromFile(string fileName)
+        {
+            return new CSharpFile(ReadContent(fileName));
+        }
+
+        protected static string ReadContent(string fileName)
         {
             if (!File.Exists(fileName))
             {
                 throw new FileNotFoundException(fileName);
             }
-            var content = File.ReadAllText(fileName);
-            return new CSharpFile(content);
+            return File.ReadAllText(fileName);
         }
 
         public List<string> ScanTypes()
@@ -49,18 +53,23 @@ public List<string> ScanTypes()
                 .ToList();
         }
 
-        private NamespaceDeclarationSyntax? ScanNamespace()
+        private BaseNamespaceDeclarationSyntax? ScanNamespace()
         {
             var root = _syntaxTree.GetRoot() as CompilationUnitSyntax;
-
-            return root?.DescendantNodes().OfType<NamespaceDeclarationSyntax>().FirstOrDefault();
+            var nds = root?.DescendantNodes().OfType<NamespaceDeclarationSyntax>().FirstOrDefault();
+            if(nds != null)
+            {
+                return nds;
+            }
+            return root?.DescendantNodes().OfType<FileScopedNamespaceDeclarationSyntax>().FirstOrDefault();
         }
 
         private void UpdateNamespace(string @namespace)
         {
             if (_namespaceDeclaration != null)
             {
-                var newNamespace = SyntaxFactory.NamespaceDeclaration(SyntaxFactory.ParseName(@namespace)).NormalizeWhitespace();
+                var newName = SyntaxFactory.ParseName(@namespace);
+                var newNamespace = _namespaceDeclaration.WithName(newName);
                 _root = _root.ReplaceNode(_namespaceDeclaration, newNamespace);
                 _content = _root.ToFullString();
             }
diff --git a/src/Moryx.Cli.Templates/StateBaseTemplate/StateBaseTemplate.Constructor.cs b/src/Moryx.Cli.Templates/StateBaseTemplate/StateBaseTemplate.Constructor.cs
@@ -1,4 +1,5 @@
-﻿namespace Moryx.Cli.Templates.StateBaseTemplate
+﻿
+namespace Moryx.Cli.Templates.StateBaseTemplate
 {
     public partial class StateBaseTemplate
     {
diff --git a/src/Moryx.Cli.Templates/StateBaseTemplate/StateBaseTemplate.cs b/src/Moryx.Cli.Templates/StateBaseTemplate/StateBaseTemplate.cs
@@ -7,7 +7,7 @@
 
 namespace Moryx.Cli.Templates.StateBaseTemplate
 {
-    public partial class StateBaseTemplate : CSharpFileBase
+    public partial class StateBaseTemplate : CSharpFile
     {
         private const string StateDefinitionAttributeName = "StateDefinition";
         private const string IsInitialParameterName = "IsInitial";
@@ -19,10 +19,9 @@ public StateBaseTemplate(string content) : base(content)
 
         public IEnumerable<StateDefinition> StateDeclarations { get; private set; } = [];
 
-        public static StateBaseTemplate FromFile(string fileName)
+        public new static StateBaseTemplate FromFile(string fileName)
         {
-            var content = File.ReadAllText(fileName);
-            return new StateBaseTemplate(content);
+            return new StateBaseTemplate(ReadContent(fileName));
         }
 
         private void Parse(SyntaxTree syntaxTree)
diff --git a/src/Moryx.Cli.Templates/StateTemplate/StateTemplate.cs b/src/Moryx.Cli.Templates/StateTemplate/StateTemplate.cs
@@ -8,22 +8,17 @@
 
 namespace Moryx.Cli.Templates.StateTemplate
 {
-    public class StateTemplate : CSharpFileBase
+    public class StateTemplate : CSharpFile
     {
         private const string StateContextInterface = "IStateContext";
 
         public StateTemplate(string content) : base(content)
         {
         }
 
-        public static StateTemplate FromFile(string fileName)
+        public static new StateTemplate FromFile(string fileName)
         {
-            if (!File.Exists(fileName))
-            {
-                throw new FileNotFoundException(fileName);
-            }
-            var content = File.ReadAllText(fileName);
-            return new StateTemplate(content);
+            return new StateTemplate(ReadContent(fileName));
         }
 
         public StateTemplate ImplementIStateContext(string resource)
@@ -43,7 +38,7 @@ public StateTemplate ImplementIStateContext(string resource)
             return new StateTemplate(root.ToFullString());
         }
 
-        
+
 
         private SyntaxNode TryToAddInitializing(SyntaxNode root, string context)
         {
@@ -91,8 +86,12 @@ private SyntaxNode AddStateProperty(SyntaxNode root, string context)
             var stateProperty = SyntaxFactory
                 .PropertyDeclaration(SyntaxFactory.ParseTypeName(context.StateBase()), "State")
                 .AddModifiers(SyntaxFactory.Token(SyntaxKind.InternalKeyword))
-                .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken))
-                .WithExpressionBody(SyntaxFactory.ArrowExpressionClause(SyntaxFactory.ParseExpression($"({context.StateBase()})CurrentState")))
+                .AddAccessorListAccessors(
+                    SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
+                        .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)),
+                    SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration)
+                        .AddModifiers(SyntaxFactory.Token(SyntaxKind.PrivateKeyword))
+                        .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)))
                 .NormalizeWhitespace()
                 ;
 
@@ -103,7 +102,7 @@ private SyntaxNode AddStateProperty(SyntaxNode root, string context)
         private static SyntaxNode UpdateClassDefinition(SyntaxNode root, string context)
         {
             var contextClass = root.FindClass(context);
-            if(contextClass == null)
+            if (contextClass == null)
                 return root;
 
             if (!contextClass.BaseList?.Types.Any(t => ((IdentifierNameSyntax)t.Type).Identifier.ValueText == StateContextInterface) ?? false)
diff --git a/src/Moryx.Cli.Templates/Template.cs b/src/Moryx.Cli.Templates/Template.cs
@@ -32,7 +32,7 @@ namespace Moryx.Cli.Templates
     public class Template
     {
         private const string IdentifierKey = "{id}";
-        private const string ResourceKey = "{resource}";
+        public const string ResourceKey = "{resource}";
         private const string SolutionNameKey = "{solutionname}";
         private const string TemplateFileExtension = ".moryxtpl";
         private readonly List<string> _fileNames;

Original file line number	Diff line number	Diff line change
`@@ -19,15 +19,15 @@ internal static CommandResult Exec(Template template, string resource, IEnumerab`
`19`	`19`
`20`	`20`	`private static CommandResult Add(Template template, string resource, IEnumerable<string> states)`
`21`	`21`	`{`
`22`		`- var resourceFile = FindResource(template.Settings, resource);`
`23`		`- if (string.IsNullOrEmpty(resourceFile))`
	`22`	`+ var resourceFileName = FindResource(template.Settings, resource);`
	`23`	`+ if (string.IsNullOrEmpty(resourceFileName))`
`24`	`24`	`{`
`25`	`25`	return CommandResult.WithError($"`{resource}` not found. Make sure that a type `{resource}` exists in the project.");
`26`	`26`	`}`
`27`	`27`
`28`		`-`
	`28`	`+ var resourceFile = CSharpFile.FromFile(resourceFileName);`
`29`	`29`	`var dictionary = template.StateBaseFile(resource);`
`30`		`- var targetPath = Path.Combine(Path.GetDirectoryName(resourceFile)!, "States");`
	`30`	`+ var targetPath = Path.Combine(Path.GetDirectoryName(resourceFileName)!, "States");`
`31`	`31`	`var newStateBaseFileName = Path.Combine(`
`32`	`32`	`targetPath,`
`33`	`33`	`Path.GetFileName(dictionary.FirstOrDefault().Value));`
`@@ -38,9 +38,11 @@ private static CommandResult Add(Template template, string resource, IEnumerable`
`38`	`38`	`{`
`39`	`39`	`var files = template.WriteFilesToDisk(dictionary);`
`40`	`40`
	`41`	`+ var stateBaseVars = template.ReplaceVariables(template.Configuration.Add.StateBase, "", new Dictionary<string, string>{ { Template.ResourceKey, resource} });`
`41`	`42`	`Template.ReplacePlaceHoldersInsideFiles(`
`42`	`43`	`files,`
`43`		`- template.Configuration.Add.StateBase.Replacements);`
	`44`	`+ stateBaseVars`
	`45`	`+ );`
`44`	`46`
`45`	`47`	`if (!states.Any())`
`46`	`48`	`{`
`@@ -81,13 +83,18 @@ private static CommandResult Add(Template template, string resource, IEnumerable`
`81`	`83`	`if (!File.Exists(filename))`
`82`	`84`	`{`
`83`	`85`	`var files = template.WriteFilesToDisk(stateFiles);`
	`86`	`+ var stateVars = template.ReplaceVariables(template.Configuration.Add.State, state, new Dictionary<string, string> { { Template.ResourceKey, resource } });`
`84`	`87`
`85`	`88`	`Template.ReplacePlaceHoldersInsideFiles(`
`86`	`89`	`files,`
`87`		`- template.Configuration.Add.State.Replacements);`
	`90`	`+ stateVars);`
`88`	`91`
`89`	`92`	`stateBaseTemplate = stateBaseTemplate.AddState(stateType);`
`90`	`93`
	`94`	`+ var stateTemplate = StateTemplate.FromFile(filename);`
	`95`	`+ stateTemplate.NamespaceName = resourceFile.NamespaceName + ".States";`
	`96`	`+ stateTemplate.SaveToFile(filename);`
	`97`	`+`
`91`	`98`	`msg.Add($"Successfully added {stateType} state");`
`92`	`99`	`}`
`93`	`100`	`else`
`@@ -101,6 +108,7 @@ private static CommandResult Add(Template template, string resource, IEnumerable`
`101`	`108`	`}`
`102`	`109`	`}`
`103`	`110`
	`111`	`+ stateBaseTemplate.NamespaceName = resourceFile.NamespaceName + ".States";`
`104`	`112`	`stateBaseTemplate.SaveToFile(newStateBaseFileName);`
`105`	`113`
`106`	`114`	`UpdateResource(`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ public class CSharpFile : CSharpFileBase`
`8`	`8`	`{`
`9`	`9`	`private SyntaxNode _root;`
`10`	`10`
`11`		`- private NamespaceDeclarationSyntax? _namespaceDeclaration;`
	`11`	`+ private BaseNamespaceDeclarationSyntax? _namespaceDeclaration;`
`12`	`12`
`13`	`13`	`public List<string> Types { get; private set; }`
`14`	`14`
`@@ -23,21 +23,25 @@ public string NamespaceName`
`23`	`23`	`}`
`24`	`24`
`25`	`25`
`26`		`- public CSharpFile(string content) : base(content)`
	`26`	`+ public CSharpFile(string content) : base(content)`
`27`	`27`	`{`
`28`	`28`	`_root = _syntaxTree.GetRoot();`
`29`	`29`	`Types = ScanTypes();`
`30`	`30`	`_namespaceDeclaration = ScanNamespace();`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`public static CSharpFile FromFile(string fileName)`
	`34`	`+ {`
	`35`	`+ return new CSharpFile(ReadContent(fileName));`
	`36`	`+ }`
	`37`	`+`
	`38`	`+ protected static string ReadContent(string fileName)`
`34`	`39`	`{`
`35`	`40`	`if (!File.Exists(fileName))`
`36`	`41`	`{`
`37`	`42`	`throw new FileNotFoundException(fileName);`
`38`	`43`	`}`
`39`		`- var content = File.ReadAllText(fileName);`
`40`		`- return new CSharpFile(content);`
	`44`	`+ return File.ReadAllText(fileName);`
`41`	`45`	`}`
`42`	`46`
`43`	`47`	`public List<string> ScanTypes()`
`@@ -49,18 +53,23 @@ public List<string> ScanTypes()`
`49`	`53`	`.ToList();`
`50`	`54`	`}`
`51`	`55`
`52`		`- private NamespaceDeclarationSyntax? ScanNamespace()`
	`56`	`+ private BaseNamespaceDeclarationSyntax? ScanNamespace()`
`53`	`57`	`{`
`54`	`58`	`var root = _syntaxTree.GetRoot() as CompilationUnitSyntax;`
`55`		`-`
`56`		`- return root?.DescendantNodes().OfType<NamespaceDeclarationSyntax>().FirstOrDefault();`
	`59`	`+ var nds = root?.DescendantNodes().OfType<NamespaceDeclarationSyntax>().FirstOrDefault();`
	`60`	`+ if(nds != null)`
	`61`	`+ {`
	`62`	`+ return nds;`
	`63`	`+ }`
	`64`	`+ return root?.DescendantNodes().OfType<FileScopedNamespaceDeclarationSyntax>().FirstOrDefault();`
`57`	`65`	`}`
`58`	`66`
`59`	`67`	`private void UpdateNamespace(string @namespace)`
`60`	`68`	`{`
`61`	`69`	`if (_namespaceDeclaration != null)`
`62`	`70`	`{`
`63`		`- var newNamespace = SyntaxFactory.NamespaceDeclaration(SyntaxFactory.ParseName(@namespace)).NormalizeWhitespace();`
	`71`	`+ var newName = SyntaxFactory.ParseName(@namespace);`
	`72`	`+ var newNamespace = _namespaceDeclaration.WithName(newName);`
`64`	`73`	`_root = _root.ReplaceNode(_namespaceDeclaration, newNamespace);`
`65`	`74`	`_content = _root.ToFullString();`
`66`	`75`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`		`-namespace Moryx.Cli.Templates.StateBaseTemplate`
	`1`	`+`
	`2`	`+namespace Moryx.Cli.Templates.StateBaseTemplate`
`2`	`3`	`{`
`3`	`4`	`public partial class StateBaseTemplate`
`4`	`5`	`{`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@`
`7`	`7`
`8`	`8`	`namespace Moryx.Cli.Templates.StateBaseTemplate`
`9`	`9`	`{`
`10`		`- public partial class StateBaseTemplate : CSharpFileBase`
	`10`	`+ public partial class StateBaseTemplate : CSharpFile`
`11`	`11`	`{`
`12`	`12`	`private const string StateDefinitionAttributeName = "StateDefinition";`
`13`	`13`	`private const string IsInitialParameterName = "IsInitial";`
`@@ -19,10 +19,9 @@ public StateBaseTemplate(string content) : base(content)`
`19`	`19`
`20`	`20`	`public IEnumerable<StateDefinition> StateDeclarations { get; private set; } = [];`
`21`	`21`
`22`		`- public static StateBaseTemplate FromFile(string fileName)`
	`22`	`+ public new static StateBaseTemplate FromFile(string fileName)`
`23`	`23`	`{`
`24`		`- var content = File.ReadAllText(fileName);`
`25`		`- return new StateBaseTemplate(content);`
	`24`	`+ return new StateBaseTemplate(ReadContent(fileName));`
`26`	`25`	`}`
`27`	`26`
`28`	`27`	`private void Parse(SyntaxTree syntaxTree)`
Original file line number	Diff line number	Diff line change
`@@ -8,22 +8,17 @@`
`8`	`8`
`9`	`9`	`namespace Moryx.Cli.Templates.StateTemplate`
`10`	`10`	`{`
`11`		`- public class StateTemplate : CSharpFileBase`
	`11`	`+ public class StateTemplate : CSharpFile`
`12`	`12`	`{`
`13`	`13`	`private const string StateContextInterface = "IStateContext";`
`14`	`14`
`15`	`15`	`public StateTemplate(string content) : base(content)`
`16`	`16`	`{`
`17`	`17`	`}`
`18`	`18`
`19`		`- public static StateTemplate FromFile(string fileName)`
	`19`	`+ public static new StateTemplate FromFile(string fileName)`
`20`	`20`	`{`
`21`		`- if (!File.Exists(fileName))`
`22`		`- {`
`23`		`- throw new FileNotFoundException(fileName);`
`24`		`- }`
`25`		`- var content = File.ReadAllText(fileName);`
`26`		`- return new StateTemplate(content);`
	`21`	`+ return new StateTemplate(ReadContent(fileName));`
`27`	`22`	`}`
`28`	`23`
`29`	`24`	`public StateTemplate ImplementIStateContext(string resource)`
`@@ -43,7 +38,7 @@ public StateTemplate ImplementIStateContext(string resource)`
`43`	`38`	`return new StateTemplate(root.ToFullString());`
`44`	`39`	`}`
`45`	`40`
`46`		`-`
	`41`	`+`
`47`	`42`
`48`	`43`	`private SyntaxNode TryToAddInitializing(SyntaxNode root, string context)`
`49`	`44`	`{`
`@@ -91,8 +86,12 @@ private SyntaxNode AddStateProperty(SyntaxNode root, string context)`
`91`	`86`	`var stateProperty = SyntaxFactory`
`92`	`87`	`.PropertyDeclaration(SyntaxFactory.ParseTypeName(context.StateBase()), "State")`
`93`	`88`	`.AddModifiers(SyntaxFactory.Token(SyntaxKind.InternalKeyword))`
`94`		`- .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken))`
`95`		`- .WithExpressionBody(SyntaxFactory.ArrowExpressionClause(SyntaxFactory.ParseExpression($"({context.StateBase()})CurrentState")))`
	`89`	`+ .AddAccessorListAccessors(`
	`90`	`+ SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)`
	`91`	`+ .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)),`
	`92`	`+ SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration)`
	`93`	`+ .AddModifiers(SyntaxFactory.Token(SyntaxKind.PrivateKeyword))`
	`94`	`+ .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)))`
`96`	`95`	`.NormalizeWhitespace()`
`97`	`96`	`;`
`98`	`97`
`@@ -103,7 +102,7 @@ private SyntaxNode AddStateProperty(SyntaxNode root, string context)`
`103`	`102`	`private static SyntaxNode UpdateClassDefinition(SyntaxNode root, string context)`
`104`	`103`	`{`
`105`	`104`	`var contextClass = root.FindClass(context);`
`106`		`- if(contextClass == null)`
	`105`	`+ if (contextClass == null)`
`107`	`106`	`return root;`
`108`	`107`
`109`	`108`	`if (!contextClass.BaseList?.Types.Any(t => ((IdentifierNameSyntax)t.Type).Identifier.ValueText == StateContextInterface) ?? false)`
Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,7 @@ namespace Moryx.Cli.Templates`
`32`	`32`	`public class Template`
`33`	`33`	`{`
`34`	`34`	`private const string IdentifierKey = "{id}";`
`35`		`- private const string ResourceKey = "{resource}";`
	`35`	`+ public const string ResourceKey = "{resource}";`
`36`	`36`	`private const string SolutionNameKey = "{solutionname}";`
`37`	`37`	`private const string TemplateFileExtension = ".moryxtpl";`
`38`	`38`	`private readonly List<string> _fileNames;`