From 0f3509497df50ae7156872f001b975163079aa0f Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Wed, 18 Sep 2019 16:02:15 +0200
Subject: [PATCH 01/56] feat: replace NDesk.Options by
 System.CommandLine.Experimental

#346
---
 src/Pretzel.Logic/Pretzel.Logic.csproj | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Pretzel.Logic/Pretzel.Logic.csproj b/src/Pretzel.Logic/Pretzel.Logic.csproj
index 6d5e9bec2..78b1a309f 100644
--- a/src/Pretzel.Logic/Pretzel.Logic.csproj
+++ b/src/Pretzel.Logic/Pretzel.Logic.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <ProductVersion>8.0.30703</ProductVersion>
     <TargetFrameworks>net462;netstandard2.0</TargetFrameworks>
@@ -34,11 +34,11 @@
     <PackageReference Include="HtmlAgilityPack" Version="1.11.12" />
     <PackageReference Include="Microsoft.AspNet.Razor" Version="3.2.7" />
     <PackageReference Include="Microsoft.Windows.Compatibility" Version="2.1.1" />
-    <PackageReference Include="NDesk.Options" Version="0.2.1" />
     <PackageReference Include="RazorEngine" Version="3.10.0" />
     <PackageReference Include="SonarAnalyzer.CSharp" Version="7.16.0.8981">
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
+    <PackageReference Include="System.CommandLine.Experimental" Version="0.3.0-alpha.19405.1" />
     <PackageReference Include="System.IO.Abstractions" Version="2.0.0.116" />
     <PackageReference Include="YamlDotNet" Version="6.1.2" />
     <PackageReference Include="System.Composition" Version="1.2.0" />

From e8a5e68f7d5e982a6ca8239cb1c61a3d4db0d752 Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Wed, 18 Sep 2019 16:38:48 +0200
Subject: [PATCH 02/56] feat: CommandParameters use new Option syntax

---
 .../Commands/CommandParameters.cs             | 66 ++++++++++++++-----
 1 file changed, 49 insertions(+), 17 deletions(-)

diff --git a/src/Pretzel.Logic/Commands/CommandParameters.cs b/src/Pretzel.Logic/Commands/CommandParameters.cs
index f12a3dcfe..076a9d876 100644
--- a/src/Pretzel.Logic/Commands/CommandParameters.cs
+++ b/src/Pretzel.Logic/Commands/CommandParameters.cs
@@ -5,6 +5,7 @@
 using Pretzel.Logic.Templating.Context;
 using System;
 using System.Collections.Generic;
+using System.CommandLine;
 using System.Composition;
 using System.IO;
 using System.IO.Abstractions;
@@ -21,23 +22,53 @@ public CommandParameters([ImportMany] IEnumerable<IHaveCommandLineArgs> commandL
         {
             this.fileSystem = fileSystem;
 
-            port = 8080;
-            LaunchBrowser = true;
-
-            Settings = new OptionSet
+            Settings = new[]
+            {
+                new Option(new []{ "template", "t" },"The templating engine to use")
+                {
+                    Argument = new Argument<string>()
+                },
+                new Option(new [] {"port", "p"}, "The port to test the site locally")
+                {
+                    Argument = new Argument<int>(() => 8080)
+                },
+                new Option(new [] {"import", "i"}, "The import type")
+                {
+                    Argument = new Argument<string>()
+                },
+                new Option(new [] {"file", "f"}, "Path to import file")
+                {
+                    Argument = new Argument<string>()
+                },
+                new Option("destination", "The path to the destination site (default _site)")
+                {
+                    Argument = new Argument<string>(() => "_site")
+                },
+                new Option("drafts", "Add the posts in the drafts folder")
                 {
-                    { "t|template=", "The templating engine to use", v => Template = v },
-                    { "p|port=", "The port to test the site locally", p => decimal.TryParse(p, out port) },
-                    { "i|import=", "The import type", v => ImportType = v },
-                    { "f|file=", "Path to import file", v => ImportPath = v },
-                    { "destination=", "The path to the destination site (default _site)", d => DestinationPath = d},
-                    { "drafts", "Add the posts in the drafts folder", v => IncludeDrafts = true },
-                    { "nobrowser", "Do not launch a browser", v => LaunchBrowser = false },
-                    { "withproject", "Includes a layout VS Solution, to give intellisense when editing razor layout files", v => WithProject = (v!=null) },
-                    { "wiki", "Creates a wiki instead of a blog (razor template only)", v => Wiki = (v!=null) },
-                    { "cleantarget", "Delete the target directory (_site by default)", v => CleanTarget = true },
-                    { "n|newposttitle=", "The title of the new post (\"New post\" by default)", v => NewPostTitle = v }
-                };
+                    Argument = new Argument<bool>()
+                },
+                new Option("nobrowser", "Do not launch a browser (false by default)")
+                {
+                    Argument = new Argument<bool>(() => false)
+                },
+                new Option("withproject", "Includes a layout VS Solution, to give intellisense when editing razor layout files")
+                {
+                    Argument = new Argument<bool>()
+                },
+                new Option("wiki", "Creates a wiki instead of a blog (razor template only)")
+                {
+                    Argument = new Argument<bool>()
+                },
+                new Option("cleantarget", "Delete the target directory (_site by default)")
+                {
+                    Argument = new Argument<bool>()
+                },
+                new Option(new [] { "newposttitle", "n" }, "The title of the new post (\"New post\" by default")
+                {
+                    Argument = new Argument<string>(() => "New post")
+                }
+            };
 
             // Allow extensions to register command line args
             foreach (var commandLineExtension in commandLineExtensions)
@@ -76,7 +107,8 @@ public decimal Port
             get { return port; }
         }
 
-        private OptionSet Settings { get; set; }
+        [Export]
+        private IEnumerable<Option> Settings { get; set; }
 
         private readonly IFileSystem fileSystem;
 

From 139b06f2aeaf86e0c365462f339d685297f223ea Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Sat, 21 Sep 2019 12:16:56 +0200
Subject: [PATCH 03/56] feat: basic ground for new command system

#346
---
 src/Pretzel.Logic/Commands/BaseParameters.cs  |  30 ++--
 .../Commands/CommandParameters.cs             |  17 +--
 .../Extensions/AzureHostSupport.cs            |  10 +-
 .../Extensions/VirtualDirectorySupport.cs     |  10 +-
 .../Extensibility/IHaveCommandLineArgs.cs     |   6 +-
 src/Pretzel/Commands/BakeCommand.cs           |  55 ++++++-
 src/Pretzel/Commands/CommandCollection.cs     |  38 +++--
 src/Pretzel/Commands/CommandInfoAttribute.cs  |   7 +
 src/Pretzel/Commands/HungryCommand.cs         |   2 +-
 src/Pretzel/Commands/ImportCommand.cs         |   2 +-
 src/Pretzel/Commands/IngredientCommand.cs     |   2 +-
 src/Pretzel/Commands/RecipeCommand.cs         |   2 +-
 src/Pretzel/Commands/TasteCommand.cs          |   4 +-
 src/Pretzel/Commands/VersionCommand.cs        |   2 +-
 src/Pretzel/Pretzel.csproj                    |   1 +
 src/Pretzel/Program.cs                        | 137 ++++++++++++------
 src/Pretzel/Properties/launchSettings.json    |   2 +-
 17 files changed, 241 insertions(+), 86 deletions(-)

diff --git a/src/Pretzel.Logic/Commands/BaseParameters.cs b/src/Pretzel.Logic/Commands/BaseParameters.cs
index 8b44d12e5..bae966274 100644
--- a/src/Pretzel.Logic/Commands/BaseParameters.cs
+++ b/src/Pretzel.Logic/Commands/BaseParameters.cs
@@ -1,6 +1,6 @@
-using NDesk.Options;
 using System;
 using System.Collections.Generic;
+using System.CommandLine;
 using System.Composition;
 using System.IO.Abstractions;
 using System.Linq;
@@ -9,7 +9,8 @@ namespace Pretzel.Logic.Commands
 {
     public sealed class BaseParameters
     {
-        public OptionSet Options { get; }
+        [Export]
+        public IEnumerable<Option> Options { get; }
 
         public string CommandName { get; }
 
@@ -27,20 +28,31 @@ public sealed class BaseParameters
 
         private BaseParameters(string[] arguments, IFileSystem fileSystem)
         {
-            Options = new OptionSet
+            Options = new []
             {
-                { "help", "Display help mode", p => Help = true },
-                { "debug", "Enable debugging", p => Debug = true },
-                { "safe", "Disable custom plugins", v => Safe = true },
-                { "d|directory=", "[Obsolete, use --source instead] The path to site directory", p => Path = p },
-                { "s|source=", "The path to the source site (default current directory)", p => Path = p }
+                new Option("debug", "Enable debugging")
+                {
+                    Argument = new Argument<bool>()
+                },
+                new Option("safe", "Disable custom plugins")
+                {
+                    Argument = new Argument<bool>()
+                },
+                new Option(new [] { "d", "directory"}, "[Obsolete, use --source instead] The path to site directory")
+                {
+                    Argument = new Argument<string>()
+                },
+                new Option(new [] { "s", "source"}, "The path to the source site (default current directory)")
+                {
+                    Argument = new Argument<string>()
+                }
             };
 
             FileSystem = fileSystem;
 
             CommandName = arguments.Take(1).FirstOrDefault();
 
-            CommandArgs = Options.Parse(arguments.Skip(1));
+            //CommandArgs = Options.Parse(arguments.Skip(1));
 
             SetPath(CommandArgs.FirstOrDefault());
         }
diff --git a/src/Pretzel.Logic/Commands/CommandParameters.cs b/src/Pretzel.Logic/Commands/CommandParameters.cs
index 076a9d876..639a8547e 100644
--- a/src/Pretzel.Logic/Commands/CommandParameters.cs
+++ b/src/Pretzel.Logic/Commands/CommandParameters.cs
@@ -1,4 +1,3 @@
-using NDesk.Options;
 using Pretzel.Logic.Extensibility;
 using Pretzel.Logic.Extensions;
 using Pretzel.Logic.Templating;
@@ -22,7 +21,7 @@ public CommandParameters([ImportMany] IEnumerable<IHaveCommandLineArgs> commandL
         {
             this.fileSystem = fileSystem;
 
-            Settings = new[]
+            Settings = new List<Option>
             {
                 new Option(new []{ "template", "t" },"The templating engine to use")
                 {
@@ -108,7 +107,7 @@ public decimal Port
         }
 
         [Export]
-        private IEnumerable<Option> Settings { get; set; }
+        private List<Option> Settings { get; set; }
 
         private readonly IFileSystem fileSystem;
 
@@ -116,7 +115,7 @@ public void Parse(IEnumerable<string> arguments)
         {
             var argumentList = arguments.ToArray();
 
-            Settings.Parse(argumentList);
+            //Settings.Parse(argumentList);
 
             if (string.IsNullOrEmpty(DestinationPath))
             {
@@ -148,16 +147,16 @@ public void DetectFromDirectory(IDictionary<string, ISiteEngine> engines, SiteCo
 
         public void WriteOptions(TextWriter writer, params string[] args)
         {
-            if (args.Length == 0)
-                Settings.WriteOptionDescriptions(writer);
-            else
-                WriteSubset(writer, args);
+            //if (args.Length == 0)
+            //    Settings.WriteOptionDescriptions(writer);
+            //else
+            //    WriteSubset(writer, args);
         }
 
         private void WriteSubset(TextWriter writer, string[] args)
         {
             var textWriter = new StringWriter();
-            Settings.WriteOptionDescriptions(textWriter);
+            //Settings.WriteOptionDescriptions(textWriter);
             var output = textWriter.ToString();
 
             var strings = RecombineMultilineArgs(output.Split(new[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries));
diff --git a/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs b/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs
index 8ea426f94..3a63a2efb 100644
--- a/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs
+++ b/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs
@@ -1,5 +1,6 @@
-using NDesk.Options;
 using Pretzel.Logic.Extensions;
+using System.Collections.Generic;
+using System.CommandLine;
 using System.Composition;
 using System.IO;
 using System.IO.Abstractions;
@@ -23,9 +24,12 @@ public AzureHostSupport(IFileSystem fileSystem, IAssembly assembly)
             this.assembly = assembly;
         }
 
-        public void UpdateOptions(OptionSet options)
+        public void UpdateOptions(IList<Option> options)
         {
-            options.Add("azure", "Enables deploy to azure support", v => performAzureWorkaround = (v != null));
+            options.Add(new Option("azure", "Enables deploy to azure support")
+            {
+                Argument = new Argument<bool>()
+            });
         }
 
         public string[] GetArguments(string command)
diff --git a/src/Pretzel.Logic/Extensibility/Extensions/VirtualDirectorySupport.cs b/src/Pretzel.Logic/Extensibility/Extensions/VirtualDirectorySupport.cs
index d96817e50..19dfcd921 100644
--- a/src/Pretzel.Logic/Extensibility/Extensions/VirtualDirectorySupport.cs
+++ b/src/Pretzel.Logic/Extensibility/Extensions/VirtualDirectorySupport.cs
@@ -1,8 +1,9 @@
+using System.Collections.Generic;
+using System.CommandLine;
 using System.Composition;
 using System.IO.Abstractions;
 using System.Linq;
 using System.Text.RegularExpressions;
-using NDesk.Options;
 using Pretzel.Logic.Templating.Context;
 
 namespace Pretzel.Logic.Extensibility.Extensions
@@ -42,9 +43,12 @@ public void Transform(SiteContext siteContext)
             }
         }
 
-        public void UpdateOptions(OptionSet options)
+        public void UpdateOptions(IList<Option> options)
         {
-            options.Add("vDir=", "Rewrite url's to work inside the specified virtual directory", v => VirtualDirectory = v);
+            options.Add(new Option("vDir", "Rewrite url's to work inside the specified virtual directory")
+            {
+                Argument = new Argument<string>()
+            });
         }
 
         public string[] GetArguments(string command)
diff --git a/src/Pretzel.Logic/Extensibility/IHaveCommandLineArgs.cs b/src/Pretzel.Logic/Extensibility/IHaveCommandLineArgs.cs
index cb85ed215..8c1f95294 100644
--- a/src/Pretzel.Logic/Extensibility/IHaveCommandLineArgs.cs
+++ b/src/Pretzel.Logic/Extensibility/IHaveCommandLineArgs.cs
@@ -1,10 +1,10 @@
-using NDesk.Options;
+using System.Collections.Generic;
+using System.CommandLine;
 
 namespace Pretzel.Logic.Extensibility
 {
     public interface IHaveCommandLineArgs
     {
-        void UpdateOptions(OptionSet options);
-        string[] GetArguments(string command);
+        void UpdateOptions(IList<Option> options);
     }
 }
diff --git a/src/Pretzel/Commands/BakeCommand.cs b/src/Pretzel/Commands/BakeCommand.cs
index 49c9db042..61af95600 100644
--- a/src/Pretzel/Commands/BakeCommand.cs
+++ b/src/Pretzel/Commands/BakeCommand.cs
@@ -4,15 +4,68 @@
 using Pretzel.Logic.Templating.Context;
 using System;
 using System.Collections.Generic;
+using System.CommandLine;
 using System.Composition;
 using System.Diagnostics;
 using System.IO;
 using System.IO.Abstractions;
+using System.Linq;
 
 namespace Pretzel.Commands
 {
+    [MetadataAttribute]
+    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
+    public sealed class CommandArgumentsAttribute : ExportAttribute
+    {
+        public Type CommandType { get; set; }
+
+        public CommandArgumentsAttribute() : base(typeof(ICommandParameters))
+        {
+        }
+    }
+
+    public interface ICommandParameters
+    {
+        IList<Option> Options { get; }
+    }
+
+    [Shared]
+    [CommandArguments(CommandType = typeof(BakeCommand))]
+    public sealed class BakeCommandParameters : ICommandParameters
+    {
+        //[ImportMany]
+        //public ExportFactory<IHaveCommandLineArgs, CommandArgumentsAttribute>[] ArgumentExtenders { get; set; }
+
+        [Export]
+        public IList<Option> Options { get; set; }
+
+        [OnImportsSatisfied]
+        internal void OnImportsSatisfied()
+        {
+            Options = new List<Option>
+            {
+                new Option(new []{ "--template", "-t" },"The templating engine to use")
+                {
+                    Argument = new Argument<string>()
+                },
+            };
+
+            //var attr = GetType().GetCustomAttributes(typeof(CommandArgumentsAttribute), true).FirstOrDefault();
+
+            //if (attr is CommandArgumentsAttribute commandArgumentAttribute)
+            //{
+            //    foreach (var factory in ArgumentExtenders.Where(a => a.Metadata.CommandType == commandArgumentAttribute.CommandType))
+            //    {
+            //        factory.CreateExport().Value.UpdateOptions(Options);
+            //    }
+            //}
+        }
+    }
+
+
+
     [Shared]
-    [CommandInfo(CommandName = "bake")]
+    [CommandInfo(CommandName = "bake", CommandDescription = "transforming content into a website", CommandType = typeof(BakeCommand))]
     public sealed class BakeCommand : ICommand
     {
 #pragma warning disable 649
diff --git a/src/Pretzel/Commands/CommandCollection.cs b/src/Pretzel/Commands/CommandCollection.cs
index 31ad1c703..5852fabd5 100644
--- a/src/Pretzel/Commands/CommandCollection.cs
+++ b/src/Pretzel/Commands/CommandCollection.cs
@@ -1,8 +1,8 @@
 using System;
 using System.Collections.Generic;
+using System.CommandLine;
 using System.Composition;
 using System.Linq;
-using NDesk.Options;
 using Pretzel.Logic.Commands;
 using Pretzel.Logic.Extensibility;
 
@@ -14,8 +14,12 @@ public sealed class CommandCollection
     {
         [ImportMany]
         public ExportFactory<ICommand, CommandInfoAttribute>[] Commands { get; set; }
+
         [ImportMany]
-        public IEnumerable<Lazy<IHaveCommandLineArgs>> CommandLineExtensions { get; set; }
+        public ExportFactory<ICommandParameters, CommandArgumentsAttribute>[] CommandArguments { get; set; }
+
+        //[ImportMany]
+        //public IEnumerable<Lazy<IHaveCommandLineArgs>> CommandLineExtensions { get; set; }
         [Import]
         public Lazy<CommandParameters> Parameters { get; set; }
 
@@ -31,36 +35,52 @@ public ICommand this[string name]
             }
         }
 
+        [Export]
+        public RootCommand RootCommand { get; set; }
+
         [OnImportsSatisfied]
         public void OnImportsSatisfied()
         {
             commandMap = new Dictionary<string, ICommand>(Commands.Length);
 
+            RootCommand = new RootCommand();
+
             foreach (var command in Commands)
             {
                 if (!commandMap.ContainsKey(command.Metadata.CommandName))
                 {
-                    var export = command.CreateExport();
-                    commandMap.Add(command.Metadata.CommandName, export.Value);
+                    var subCommand = new Command(command.Metadata.CommandName, command.Metadata.CommandDescription);
+
+                    foreach (var commandArguments in CommandArguments.Where(a => a.Metadata.CommandType == command.Metadata.CommandType))
+                    {
+                        foreach(var option in commandArguments.CreateExport().Value.Options)
+                        {
+                            subCommand.AddOption(option);
+                        }
+                    }
+
+                    RootCommand.AddCommand(subCommand);
+                    //var export = command.CreateExport();
+                    //commandMap.Add(command.Metadata.CommandName, export.Value);
                 }
             }
         }
 
-        public void WriteHelp(OptionSet defaultSet)
+        public void WriteHelp(List<Option> defaultSet)
         {
             Console.WriteLine(@"Usage:");
             Console.WriteLine(@"Pretzel.exe command [options]");
             Console.WriteLine();
-            defaultSet.WriteOptionDescriptions(Console.Out);
+            //defaultSet.WriteOptionDescriptions(Console.Out);
             Console.WriteLine();
 
             foreach (var command in commandMap)
             {
                 Console.WriteLine(@"Command: " + command.Key);
                 command.Value.WriteHelp(Console.Out);
-                var extraArgs = CommandLineExtensions.SelectMany(e => e.Value.GetArguments(command.Key)).ToArray();
-                if (extraArgs.Any())
-                    Parameters.Value.WriteOptions(Console.Out, extraArgs);
+                //var extraArgs = CommandLineExtensions.SelectMany(e => e.Value.GetArguments(command.Key)).ToArray();
+                //if (extraArgs.Any())
+                //    Parameters.Value.WriteOptions(Console.Out, extraArgs);
                 Console.WriteLine();
             }
         }
diff --git a/src/Pretzel/Commands/CommandInfoAttribute.cs b/src/Pretzel/Commands/CommandInfoAttribute.cs
index 9127ce6f4..03316b09c 100644
--- a/src/Pretzel/Commands/CommandInfoAttribute.cs
+++ b/src/Pretzel/Commands/CommandInfoAttribute.cs
@@ -9,6 +9,13 @@ public sealed class CommandInfoAttribute : ExportAttribute
     {
         public string CommandName { get; set; }
 
+        public string CommandDescription { get; set; }
+
+        //We need the redundant CommandType cause we have no way to get the concrete type
+        //before creating the export. We only want to create the command the user chose.
+        //This way we can allow extention authors to specify custom arguments.
+        public Type CommandType { get; set; }
+
         public CommandInfoAttribute() : base(typeof(ICommand))
         {
         }
diff --git a/src/Pretzel/Commands/HungryCommand.cs b/src/Pretzel/Commands/HungryCommand.cs
index 877e475ac..1fb3dea53 100644
--- a/src/Pretzel/Commands/HungryCommand.cs
+++ b/src/Pretzel/Commands/HungryCommand.cs
@@ -7,7 +7,7 @@
 namespace Pretzel.Commands
 {
     [Shared]
-    [CommandInfo(CommandName = "hungry")]
+    [CommandInfo(CommandName = "hungry", CommandDescription = "use only when hungry")]
     public sealed class HungryCommand : ICommand
     {
 
diff --git a/src/Pretzel/Commands/ImportCommand.cs b/src/Pretzel/Commands/ImportCommand.cs
index ccd35315e..2d117171d 100644
--- a/src/Pretzel/Commands/ImportCommand.cs
+++ b/src/Pretzel/Commands/ImportCommand.cs
@@ -11,7 +11,7 @@
 namespace Pretzel.Commands
 {
     [Shared]
-    [CommandInfo(CommandName = "import")]
+    [CommandInfo(CommandName = "import", CommandDescription = "import posts from external source")]
     class ImportCommand : ICommand
     {
         readonly static List<string> Importers = new List<string>(new[] { "wordpress", "blogger" });
diff --git a/src/Pretzel/Commands/IngredientCommand.cs b/src/Pretzel/Commands/IngredientCommand.cs
index 36fdf500b..2f6963f80 100644
--- a/src/Pretzel/Commands/IngredientCommand.cs
+++ b/src/Pretzel/Commands/IngredientCommand.cs
@@ -9,7 +9,7 @@
 namespace Pretzel.Commands
 {
     [Shared]
-    [CommandInfo(CommandName = "ingredient")]
+    [CommandInfo(CommandName = "ingredient", CommandDescription = "create a new post")]
     public sealed class IngredientCommand : ICommand
     {
 #pragma warning disable 649
diff --git a/src/Pretzel/Commands/RecipeCommand.cs b/src/Pretzel/Commands/RecipeCommand.cs
index 2fcdfbc16..129bbc5a9 100644
--- a/src/Pretzel/Commands/RecipeCommand.cs
+++ b/src/Pretzel/Commands/RecipeCommand.cs
@@ -12,7 +12,7 @@
 namespace Pretzel.Commands
 {
     [Shared]
-    [CommandInfo(CommandName = "create")]
+    [CommandInfo(CommandName = "create", CommandDescription = "configure a new site")]
     public sealed class RecipeCommand : ICommand
     {
         private static readonly List<string> TemplateEngines = new List<string>(new[] { "Liquid", "Razor" });
diff --git a/src/Pretzel/Commands/TasteCommand.cs b/src/Pretzel/Commands/TasteCommand.cs
index f58324986..8b3c8d243 100644
--- a/src/Pretzel/Commands/TasteCommand.cs
+++ b/src/Pretzel/Commands/TasteCommand.cs
@@ -15,7 +15,7 @@
 namespace Pretzel.Commands
 {
     [Shared]
-    [CommandInfo(CommandName = "taste")]
+    [CommandInfo(CommandName = "taste", CommandDescription = "testing a site locally")]
     public sealed class TasteCommand : ICommand
     {
         private ISiteEngine engine;
@@ -122,7 +122,7 @@ public void Execute(IEnumerable<string> arguments)
 
         private void WatcherOnChanged(string file)
         {
-            if(file.StartsWith(Parameters.Path))
+            if (file.StartsWith(Parameters.Path))
             {
                 var relativeFile = file.Substring(Parameters.Path.Length).ToRelativeFile();
                 if (Generator.IsExcludedPath(relativeFile))
diff --git a/src/Pretzel/Commands/VersionCommand.cs b/src/Pretzel/Commands/VersionCommand.cs
index a84b85224..61bffd7d2 100644
--- a/src/Pretzel/Commands/VersionCommand.cs
+++ b/src/Pretzel/Commands/VersionCommand.cs
@@ -6,7 +6,7 @@
 namespace Pretzel.Commands
 {
     [Shared]
-    [CommandInfo(CommandName = "version")]
+    [CommandInfo(CommandName = "version", CommandDescription = "display current Pretzel version")]
     public sealed class VersionCommand : ICommand
     {
         public void Execute(IEnumerable<string> arguments)
diff --git a/src/Pretzel/Pretzel.csproj b/src/Pretzel/Pretzel.csproj
index 11a92f24c..c5224c903 100644
--- a/src/Pretzel/Pretzel.csproj
+++ b/src/Pretzel/Pretzel.csproj
@@ -12,6 +12,7 @@
     <OutputPath>bin\$(Configuration)\</OutputPath>
     <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
     <ErrorLog>$(OutputPath)\static-analysis.sarif.json</ErrorLog>
+    <LangVersion>latest</LangVersion>
   </PropertyGroup>
   <PropertyGroup>
     <ApplicationIcon>pretzel.ico</ApplicationIcon>
diff --git a/src/Pretzel/Program.cs b/src/Pretzel/Program.cs
index 79d0fd50d..38fd4413a 100644
--- a/src/Pretzel/Program.cs
+++ b/src/Pretzel/Program.cs
@@ -2,19 +2,25 @@
 using Pretzel.Logic.Commands;
 using Pretzel.Logic.Extensions;
 using System;
+using System.Collections.Generic;
+using System.CommandLine;
+using System.CommandLine.Builder;
+using System.CommandLine.Invocation;
 using System.Composition;
 using System.Composition.Hosting;
 using System.IO;
 using System.IO.Abstractions;
 using System.Linq;
 using System.Reflection;
+using System.Threading.Tasks;
 
 namespace Pretzel
 {
+    [Export]
     internal class Program
     {
         [Import]
-        public CommandCollection Commands { get; set; }
+        public CommandCollection CommandCollection { get; set; }
 
         [Export]
         public IFileSystem FileSystem { get; set; } = new FileSystem();
@@ -22,68 +28,119 @@ internal class Program
         [Export("SourcePath")]
         public string SourcePath { get; }
 
-        private BaseParameters parameters { get; }
-
         public Program()
         {
-            parameters = BaseParameters.Parse(Args, FileSystem);
-            SourcePath = parameters.Path;
+            SourcePath = sourcePath;
         }
 
-        private static string[] Args;
-        private static void Main(string[] args)
+        private static string sourcePath;
+        private static async Task<int> Main(string[] args)
         {
-            Args = args;
-            var program = new Program();
+            var rootCommand = new RootCommand
+            {
+                TreatUnmatchedTokensAsErrors = false
+            };
+
+            var globalOptions = new[]
+            {
+                new Option("--debug", "Enable debugging")
+                {
+                    Argument = new Argument<bool>()
+                },
+                new Option("--safe", "Disable custom plugins")
+                {
+                    Argument = new Argument<bool>()
+                },
+                new Option(new[] { "-s", "--source" }, "The path to the source site (default current directory)")
+                {
+                    Argument = new Argument<string>(() => Environment.CurrentDirectory)
+                }
+            };
 
-            program.InitializeTrace();
-            Tracing.Info("starting pretzel...");
-            Tracing.Debug("V{0}", Assembly.GetExecutingAssembly().GetName().Version);
+            foreach (var option in globalOptions)
+            {
+                rootCommand.AddOption(option);
+            }
 
-            using (program.Compose())
+            rootCommand.Handler = CommandHandler.Create(async (bool debug, bool safe, string source) =>
             {
+                sourcePath = source;
+                try
+                {
+                    InitializeTrace(debug);
+                    Tracing.Info("starting pretzel...");
+                    Tracing.Debug("V{0}", Assembly.GetExecutingAssembly().GetName().Version);
+
+                    using (var host = Compose(debug, safe, source))
+                    {
+                        var program = host.GetExport<Program>();
 
-                if (program.parameters.Help || !args.Any())
+                        return await program.Run(globalOptions, args);
+                    }
+                }
+                catch (Exception ex)
                 {
-                    program.ShowHelp();
-                    return;
+                    Tracing.Error(ex.Message);
+                    WaitForClose();
+                    return -1;
                 }
-
-                program.Run();
+            });
+            try
+            {
+                return await rootCommand.InvokeAsync(args);
+            }
+            catch (Exception ex)
+            {
+                Tracing.Error(ex.Message);
+                WaitForClose();
+                return -1;
             }
         }
 
-        private void InitializeTrace()
+        private static void InitializeTrace(bool debug)
         {
             Tracing.SetTrace(ConsoleTrace.Write);
 
-            if (parameters.Debug)
+            if (debug)
             {
                 Tracing.SetMinimalLevel(TraceLevel.Debug);
             }
         }
 
-        private void ShowHelp()
+        private async Task<int> Run(IEnumerable<Option> globalOptions, string[] args)
         {
-            Commands.WriteHelp(parameters.Options);
-            WaitForClose();
-        }
+            try
+            {
+                foreach (var option in globalOptions)
+                {
+                    CommandCollection.RootCommand.AddOption(option);
 
-        private void Run()
-        {
-            if (Commands[parameters.CommandName] == null)
+                    foreach(var command in CommandCollection.RootCommand.OfType<Command>())
+                    {
+                        command.AddOption(option);
+                    }
+                }
+
+                return await CommandCollection.RootCommand.InvokeAsync(args);
+            }
+            catch (Exception ex)
             {
-                Console.WriteLine(@"Can't find command ""{0}""", parameters.CommandName);
-                Commands.WriteHelp(parameters.Options);
-                return;
+                Tracing.Error(ex.Message);
+                WaitForClose();
+                return -1;
             }
+            //if (Commands[parameters.CommandName] == null)
+            //{
+            //    Console.WriteLine(@"Can't find command ""{0}""", parameters.CommandName);
+            //    //Commands.WriteHelp(parameters.Options);
+            //    return -1;
+            //}
 
-            Commands[parameters.CommandName].Execute(parameters.CommandArgs);
-            WaitForClose();
+            //Commands[parameters.CommandName].Execute(parameters.CommandArgs);
         }
 
         [System.Diagnostics.Conditional("DEBUG")]
-        public void WaitForClose()
+        public static void WaitForClose()
         {
             Console.WriteLine(@"Press any key to continue...");
             try
@@ -96,7 +153,7 @@ public void WaitForClose()
             }
         }
 
-        public IDisposable Compose()
+        public static CompositionHost Compose(bool debug, bool safe, string path)
         {
             try
             {
@@ -107,12 +164,10 @@ public IDisposable Compose()
                     .WithAssembly(typeof(Logic.SanityCheck).Assembly)
                     ;
 
-                LoadPlugins(configuration);
+                LoadPlugins(configuration, safe, path);
 
                 var container = configuration.CreateContainer();
 
-                container.SatisfyImports(this);
-
                 return container;
             }
             catch (ReflectionTypeLoadException ex)
@@ -124,11 +179,11 @@ public IDisposable Compose()
             }
         }
 
-        private void LoadPlugins(ContainerConfiguration configuration)
+        private static void LoadPlugins(ContainerConfiguration configuration, bool safe, string path)
         {
-            if (!parameters.Safe)
+            if (!safe)
             {
-                var pluginsPath = Path.Combine(parameters.Path, "_plugins");
+                var pluginsPath = Path.Combine(path, "_plugins");
 
                 if (Directory.Exists(pluginsPath))
                 {
@@ -153,7 +208,7 @@ private void LoadPlugins(ContainerConfiguration configuration)
             }
         }
 
-        private void AddScriptCs(ContainerConfiguration configuration, string pluginsPath)
+        private static void AddScriptCs(ContainerConfiguration configuration, string pluginsPath)
         {
             var pretzelScriptCsPath = Path.Combine(new FileInfo(Assembly.GetEntryAssembly().Location).DirectoryName, "Pretzel.ScriptCs.dll");
             if (File.Exists(pretzelScriptCsPath))
diff --git a/src/Pretzel/Properties/launchSettings.json b/src/Pretzel/Properties/launchSettings.json
index 74bf7ea00..6cb399f0e 100644
--- a/src/Pretzel/Properties/launchSettings.json
+++ b/src/Pretzel/Properties/launchSettings.json
@@ -2,7 +2,7 @@
   "profiles": {
     "Pretzel": {
       "commandName": "Project",
-      "commandLineArgs": "taste",
+      "commandLineArgs": "--safe --debug",
       "workingDirectory": "c:\\f\\git\\Scissors.Blog"
     }
   }

From 1ed61529e50e0eecb64edc2db26d1dda5f3a71b1 Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Sat, 21 Sep 2019 12:31:04 +0200
Subject: [PATCH 04/56] refactor: BuiltInCommands

---
 src/Pretzel.Logic/Commands/BuiltInCommands.cs | 13 ++++++++++
 .../Commands/CommandArgumentsAttribute.cs     | 18 +++++++++++++
 .../Commands/ICommandParameters.cs            | 11 ++++++++
 .../Extensions/AzureHostSupport.cs            | 26 ++++++++++++-------
 src/Pretzel/Commands/BakeCommand.cs           | 21 ++-------------
 src/Pretzel/Commands/CommandCollection.cs     |  4 +--
 src/Pretzel/Commands/HungryCommand.cs         |  3 ++-
 src/Pretzel/Commands/ImportCommand.cs         |  2 +-
 src/Pretzel/Commands/IngredientCommand.cs     |  2 +-
 src/Pretzel/Commands/RecipeCommand.cs         |  2 +-
 src/Pretzel/Commands/TasteCommand.cs          |  2 +-
 src/Pretzel/Commands/VersionCommand.cs        |  3 ++-
 src/Pretzel/Program.cs                        |  5 ++--
 13 files changed, 72 insertions(+), 40 deletions(-)
 create mode 100644 src/Pretzel.Logic/Commands/BuiltInCommands.cs
 create mode 100644 src/Pretzel.Logic/Commands/CommandArgumentsAttribute.cs
 create mode 100644 src/Pretzel.Logic/Commands/ICommandParameters.cs

diff --git a/src/Pretzel.Logic/Commands/BuiltInCommands.cs b/src/Pretzel.Logic/Commands/BuiltInCommands.cs
new file mode 100644
index 000000000..b2fa40de0
--- /dev/null
+++ b/src/Pretzel.Logic/Commands/BuiltInCommands.cs
@@ -0,0 +1,13 @@
+namespace Pretzel.Logic.Commands
+{
+    public static class BuiltInCommands
+    {
+        public const string Bake = "bake";
+        public const string Hungry = "hungry";
+        public const string Import = "import";
+        public const string Ingredient = "ingredient";
+        public const string Create = "create";
+        public const string Taste = "taste";
+        public const string Version = "version";
+    }
+}
diff --git a/src/Pretzel.Logic/Commands/CommandArgumentsAttribute.cs b/src/Pretzel.Logic/Commands/CommandArgumentsAttribute.cs
new file mode 100644
index 000000000..49b1dfc16
--- /dev/null
+++ b/src/Pretzel.Logic/Commands/CommandArgumentsAttribute.cs
@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.CommandLine;
+using System.Composition;
+
+namespace Pretzel.Logic.Commands
+{
+    [MetadataAttribute]
+    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
+    public sealed class CommandArgumentsAttribute : ExportAttribute
+    {
+        public string CommandName { get; set; }
+
+        public CommandArgumentsAttribute() : base(typeof(ICommandParameters))
+        {
+        }
+    }
+}
diff --git a/src/Pretzel.Logic/Commands/ICommandParameters.cs b/src/Pretzel.Logic/Commands/ICommandParameters.cs
new file mode 100644
index 000000000..8d2bfe34a
--- /dev/null
+++ b/src/Pretzel.Logic/Commands/ICommandParameters.cs
@@ -0,0 +1,11 @@
+using System;
+using System.Collections.Generic;
+using System.CommandLine;
+
+namespace Pretzel.Logic.Commands
+{
+    public interface ICommandParameters
+    {
+        IList<Option> Options { get; }
+    }
+}
diff --git a/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs b/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs
index 3a63a2efb..051e3a10a 100644
--- a/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs
+++ b/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs
@@ -1,3 +1,4 @@
+using Pretzel.Logic.Commands;
 using Pretzel.Logic.Extensions;
 using System.Collections.Generic;
 using System.CommandLine;
@@ -9,9 +10,21 @@
 
 namespace Pretzel.Logic.Extensibility.Extensions
 {
+    [CommandArguments(CommandName = "create")]
+    public class AzureHostSupportArguments : IHaveCommandLineArgs
+    {
+        public void UpdateOptions(IList<Option> options)
+        {
+            options.Add(new Option("azure", "Enables deploy to azure support")
+            {
+                Argument = new Argument<bool>()
+            });
+        }
+    }
+
     [Export(typeof(IAdditionalIngredient))]
     [Export(typeof(IHaveCommandLineArgs))]
-    public class AzureHostSupport : IAdditionalIngredient, IHaveCommandLineArgs
+    public class AzureHostSupport : IAdditionalIngredient
     {
         private readonly IFileSystem fileSystem;
         private readonly IAssembly assembly;
@@ -24,13 +37,6 @@ public AzureHostSupport(IFileSystem fileSystem, IAssembly assembly)
             this.assembly = assembly;
         }
 
-        public void UpdateOptions(IList<Option> options)
-        {
-            options.Add(new Option("azure", "Enables deploy to azure support")
-            {
-                Argument = new Argument<bool>()
-            });
-        }
 
         public string[] GetArguments(string command)
         {
@@ -58,7 +64,7 @@ public void MixIn(string directory)
                 var trimStart = directoryToMove.Replace(directory, string.Empty).TrimStart(Path.DirectorySeparatorChar);
                 fileSystem.Directory.Move(directoryToMove, Path.Combine(sourceFolder, trimStart));
             }
-            
+
             fileSystem.File.WriteAllText(Path.Combine(directory, @"Shim.cs"), Properties.RazorAzure.Shim);
             fileSystem.File.WriteAllText(Path.Combine(directory, @"Shim.csproj"), Properties.RazorAzure.ShimProject);
             fileSystem.File.WriteAllText(Path.Combine(directory, @"Shim.sln"), Properties.RazorAzure.ShimSolution);
@@ -66,7 +72,7 @@ public void MixIn(string directory)
             var currentPath = assembly.GetEntryAssemblyLocation();
             var destination = Path.Combine(directory, "Pretzel.exe");
             if (!fileSystem.File.Exists(destination))
-            { 
+            {
                 fileSystem.File.Copy(currentPath, destination);
             }
 
diff --git a/src/Pretzel/Commands/BakeCommand.cs b/src/Pretzel/Commands/BakeCommand.cs
index 61af95600..a5232dbca 100644
--- a/src/Pretzel/Commands/BakeCommand.cs
+++ b/src/Pretzel/Commands/BakeCommand.cs
@@ -13,24 +13,9 @@
 
 namespace Pretzel.Commands
 {
-    [MetadataAttribute]
-    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
-    public sealed class CommandArgumentsAttribute : ExportAttribute
-    {
-        public Type CommandType { get; set; }
-
-        public CommandArgumentsAttribute() : base(typeof(ICommandParameters))
-        {
-        }
-    }
-
-    public interface ICommandParameters
-    {
-        IList<Option> Options { get; }
-    }
 
     [Shared]
-    [CommandArguments(CommandType = typeof(BakeCommand))]
+    [CommandArguments(CommandName = BuiltInCommands.Bake)]
     public sealed class BakeCommandParameters : ICommandParameters
     {
         //[ImportMany]
@@ -62,10 +47,8 @@ internal void OnImportsSatisfied()
         }
     }
 
-
-
     [Shared]
-    [CommandInfo(CommandName = "bake", CommandDescription = "transforming content into a website", CommandType = typeof(BakeCommand))]
+    [CommandInfo(CommandName = BuiltInCommands.Bake, CommandDescription = "transforming content into a website")]
     public sealed class BakeCommand : ICommand
     {
 #pragma warning disable 649
diff --git a/src/Pretzel/Commands/CommandCollection.cs b/src/Pretzel/Commands/CommandCollection.cs
index 5852fabd5..c3606ff8a 100644
--- a/src/Pretzel/Commands/CommandCollection.cs
+++ b/src/Pretzel/Commands/CommandCollection.cs
@@ -18,8 +18,6 @@ public sealed class CommandCollection
         [ImportMany]
         public ExportFactory<ICommandParameters, CommandArgumentsAttribute>[] CommandArguments { get; set; }
 
-        //[ImportMany]
-        //public IEnumerable<Lazy<IHaveCommandLineArgs>> CommandLineExtensions { get; set; }
         [Import]
         public Lazy<CommandParameters> Parameters { get; set; }
 
@@ -51,7 +49,7 @@ public void OnImportsSatisfied()
                 {
                     var subCommand = new Command(command.Metadata.CommandName, command.Metadata.CommandDescription);
 
-                    foreach (var commandArguments in CommandArguments.Where(a => a.Metadata.CommandType == command.Metadata.CommandType))
+                    foreach (var commandArguments in CommandArguments.Where(a => a.Metadata.CommandName == command.Metadata.CommandName))
                     {
                         foreach(var option in commandArguments.CreateExport().Value.Options)
                         {
diff --git a/src/Pretzel/Commands/HungryCommand.cs b/src/Pretzel/Commands/HungryCommand.cs
index 1fb3dea53..8e14705cc 100644
--- a/src/Pretzel/Commands/HungryCommand.cs
+++ b/src/Pretzel/Commands/HungryCommand.cs
@@ -2,12 +2,13 @@
 using System.Collections.Generic;
 using System.Composition;
 using System.IO;
+using Pretzel.Logic.Commands;
 using Pretzel.Logic.Extensions;
 
 namespace Pretzel.Commands
 {
     [Shared]
-    [CommandInfo(CommandName = "hungry", CommandDescription = "use only when hungry")]
+    [CommandInfo(CommandName = BuiltInCommands.Hungry, CommandDescription = "use only when hungry")]
     public sealed class HungryCommand : ICommand
     {
 
diff --git a/src/Pretzel/Commands/ImportCommand.cs b/src/Pretzel/Commands/ImportCommand.cs
index 2d117171d..d4963abc7 100644
--- a/src/Pretzel/Commands/ImportCommand.cs
+++ b/src/Pretzel/Commands/ImportCommand.cs
@@ -11,7 +11,7 @@
 namespace Pretzel.Commands
 {
     [Shared]
-    [CommandInfo(CommandName = "import", CommandDescription = "import posts from external source")]
+    [CommandInfo(CommandName = BuiltInCommands.Import, CommandDescription = "import posts from external source")]
     class ImportCommand : ICommand
     {
         readonly static List<string> Importers = new List<string>(new[] { "wordpress", "blogger" });
diff --git a/src/Pretzel/Commands/IngredientCommand.cs b/src/Pretzel/Commands/IngredientCommand.cs
index 2f6963f80..63fff680f 100644
--- a/src/Pretzel/Commands/IngredientCommand.cs
+++ b/src/Pretzel/Commands/IngredientCommand.cs
@@ -9,7 +9,7 @@
 namespace Pretzel.Commands
 {
     [Shared]
-    [CommandInfo(CommandName = "ingredient", CommandDescription = "create a new post")]
+    [CommandInfo(CommandName = BuiltInCommands.Ingredient, CommandDescription = "create a new post")]
     public sealed class IngredientCommand : ICommand
     {
 #pragma warning disable 649
diff --git a/src/Pretzel/Commands/RecipeCommand.cs b/src/Pretzel/Commands/RecipeCommand.cs
index 129bbc5a9..d1f31b3a2 100644
--- a/src/Pretzel/Commands/RecipeCommand.cs
+++ b/src/Pretzel/Commands/RecipeCommand.cs
@@ -12,7 +12,7 @@
 namespace Pretzel.Commands
 {
     [Shared]
-    [CommandInfo(CommandName = "create", CommandDescription = "configure a new site")]
+    [CommandInfo(CommandName = BuiltInCommands.Create, CommandDescription = "configure a new site")]
     public sealed class RecipeCommand : ICommand
     {
         private static readonly List<string> TemplateEngines = new List<string>(new[] { "Liquid", "Razor" });
diff --git a/src/Pretzel/Commands/TasteCommand.cs b/src/Pretzel/Commands/TasteCommand.cs
index 8b3c8d243..a4b2a0225 100644
--- a/src/Pretzel/Commands/TasteCommand.cs
+++ b/src/Pretzel/Commands/TasteCommand.cs
@@ -15,7 +15,7 @@
 namespace Pretzel.Commands
 {
     [Shared]
-    [CommandInfo(CommandName = "taste", CommandDescription = "testing a site locally")]
+    [CommandInfo(CommandName = BuiltInCommands.Taste, CommandDescription = "testing a site locally")]
     public sealed class TasteCommand : ICommand
     {
         private ISiteEngine engine;
diff --git a/src/Pretzel/Commands/VersionCommand.cs b/src/Pretzel/Commands/VersionCommand.cs
index 61bffd7d2..48d6fac09 100644
--- a/src/Pretzel/Commands/VersionCommand.cs
+++ b/src/Pretzel/Commands/VersionCommand.cs
@@ -1,3 +1,4 @@
+using Pretzel.Logic.Commands;
 using Pretzel.Logic.Extensions;
 using System.Collections.Generic;
 using System.Composition;
@@ -6,7 +7,7 @@
 namespace Pretzel.Commands
 {
     [Shared]
-    [CommandInfo(CommandName = "version", CommandDescription = "display current Pretzel version")]
+    [CommandInfo(CommandName = BuiltInCommands.Version, CommandDescription = "display current Pretzel version")]
     public sealed class VersionCommand : ICommand
     {
         public void Execute(IEnumerable<string> arguments)
diff --git a/src/Pretzel/Program.cs b/src/Pretzel/Program.cs
index 38fd4413a..89d06abfc 100644
--- a/src/Pretzel/Program.cs
+++ b/src/Pretzel/Program.cs
@@ -74,8 +74,9 @@ private static async Task<int> Main(string[] args)
                     using (var host = Compose(debug, safe, source))
                     {
                         var program = host.GetExport<Program>();
-
-                        return await program.Run(globalOptions, args);
+                        var result = await program.Run(globalOptions, args);
+                        WaitForClose();
+                        return result;
                     }
                 }
                 catch (Exception ex)

From 35545f026f2ee393760beaaa00be428bb1d2afce Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Sat, 21 Sep 2019 15:38:42 +0200
Subject: [PATCH 05/56] feat: new CommandParameters almost working

---
 src/Pretzel.Logic/Commands/BParameters.cs     |  64 +++++++++
 src/Pretzel.Logic/Commands/BaseParameters.cs  |  79 -----------
 .../Commands/CommandParameters.cs             |  45 +-----
 .../Commands/ICommandParameters.cs            |   2 +
 .../CommandArgumentsExtentionAttribute.cs     |  16 +++
 .../Extensions/AzureHostSupport.cs            |   9 +-
 .../Extensions/VirtualDirectorySupport.cs     |  51 +++----
 .../Extensibility/IHaveCommandLineArgs.cs     |   4 +
 src/Pretzel/Commands/BakeCommand.cs           | 128 +++++++++++++-----
 src/Pretzel/Commands/CommandCollection.cs     |  96 +++++++------
 src/Pretzel/Commands/HungryCommand.cs         |   6 +-
 src/Pretzel/Commands/ICommand.cs              |   5 +-
 src/Pretzel/Commands/ImportCommand.cs         |  38 +++++-
 src/Pretzel/Commands/IngredientCommand.cs     |  38 ++++--
 src/Pretzel/Commands/RecipeCommand.cs         |  50 +++++--
 src/Pretzel/Commands/TasteCommand.cs          |  58 +++++---
 src/Pretzel/Commands/VersionCommand.cs        |   9 +-
 src/Pretzel/Program.cs                        |  54 +++++---
 src/Pretzel/Properties/launchSettings.json    |   2 +-
 19 files changed, 451 insertions(+), 303 deletions(-)
 create mode 100644 src/Pretzel.Logic/Commands/BParameters.cs
 delete mode 100644 src/Pretzel.Logic/Commands/BaseParameters.cs
 create mode 100644 src/Pretzel.Logic/Extensibility/CommandArgumentsExtentionAttribute.cs

diff --git a/src/Pretzel.Logic/Commands/BParameters.cs b/src/Pretzel.Logic/Commands/BParameters.cs
new file mode 100644
index 000000000..d2f50c242
--- /dev/null
+++ b/src/Pretzel.Logic/Commands/BParameters.cs
@@ -0,0 +1,64 @@
+using Pretzel.Logic.Extensibility;
+using System;
+using System.Collections.Generic;
+using System.CommandLine;
+using System.Composition;
+using System.Linq;
+
+namespace Pretzel.Logic.Commands
+{
+    public interface ICommandParametersExtendable
+    {
+        ExportFactory<IHaveCommandLineArgs, CommandArgumentsExtentionAttribute>[] ArgumentExtenders
+        {
+            get;
+        }
+    }
+
+    public abstract class BParameters : ICommandParameters, ICommandParametersExtendable
+    {
+        [ImportMany]
+        public ExportFactory<IHaveCommandLineArgs, CommandArgumentsExtentionAttribute>[] ArgumentExtenders { get; set; }
+
+        [Export]
+        public IList<Option> Options { get; set; }
+
+        [OnImportsSatisfied]
+        internal void OnImportsSatisfied()
+        {
+            var options = new List<Option>();
+            Options = options;
+            WithOptions(options);
+
+            foreach (var factory in this.GetCommandExtentions())
+            {
+                factory.CreateExport().Value.UpdateOptions(Options);
+            }
+        }
+
+        protected abstract void WithOptions(List<Option> options);
+
+        public virtual void BindingCompleted()
+        {
+        }
+    }
+
+    public static class ICommandParametersExtentions
+    {
+        public static IEnumerable<ExportFactory<IHaveCommandLineArgs, CommandArgumentsExtentionAttribute>> GetCommandExtentions(this ICommandParametersExtendable commandParametersExtendable)
+        {
+            var attr = commandParametersExtendable.GetType().GetCustomAttributes(typeof(CommandArgumentsAttribute), true).FirstOrDefault();
+
+            if (attr is CommandArgumentsAttribute commandArgumentAttribute)
+            {
+                foreach (var factory in commandParametersExtendable.ArgumentExtenders)
+                {
+                    if (factory.Metadata.CommandNames.Contains(commandArgumentAttribute.CommandName))
+                    {
+                        yield return factory;
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/src/Pretzel.Logic/Commands/BaseParameters.cs b/src/Pretzel.Logic/Commands/BaseParameters.cs
deleted file mode 100644
index bae966274..000000000
--- a/src/Pretzel.Logic/Commands/BaseParameters.cs
+++ /dev/null
@@ -1,79 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.CommandLine;
-using System.Composition;
-using System.IO.Abstractions;
-using System.Linq;
-
-namespace Pretzel.Logic.Commands
-{
-    public sealed class BaseParameters
-    {
-        [Export]
-        public IEnumerable<Option> Options { get; }
-
-        public string CommandName { get; }
-
-        public bool Help { get; private set; }
-
-        public bool Debug { get; private set; }
-
-        public bool Safe { get; private set; }
-
-        public string Path { get; private set; }
-
-        public IFileSystem FileSystem { get; private set; }
-
-        public List<string> CommandArgs { get; private set; }
-
-        private BaseParameters(string[] arguments, IFileSystem fileSystem)
-        {
-            Options = new []
-            {
-                new Option("debug", "Enable debugging")
-                {
-                    Argument = new Argument<bool>()
-                },
-                new Option("safe", "Disable custom plugins")
-                {
-                    Argument = new Argument<bool>()
-                },
-                new Option(new [] { "d", "directory"}, "[Obsolete, use --source instead] The path to site directory")
-                {
-                    Argument = new Argument<string>()
-                },
-                new Option(new [] { "s", "source"}, "The path to the source site (default current directory)")
-                {
-                    Argument = new Argument<string>()
-                }
-            };
-
-            FileSystem = fileSystem;
-
-            CommandName = arguments.Take(1).FirstOrDefault();
-
-            //CommandArgs = Options.Parse(arguments.Skip(1));
-
-            SetPath(CommandArgs.FirstOrDefault());
-        }
-
-        public static BaseParameters Parse(string[] arguments, IFileSystem fileSystem)
-        {
-            return new BaseParameters(arguments, fileSystem);
-        }
-
-        private void SetPath(string firstArgument)
-        {
-            // take the first argument after the command
-            if (firstArgument != null && !firstArgument.StartsWith("-") && !firstArgument.StartsWith("/"))
-            {
-                Path = FileSystem.Path.IsPathRooted(firstArgument)
-                    ? firstArgument
-                    : FileSystem.Path.Combine(FileSystem.Directory.GetCurrentDirectory(), firstArgument);
-            }
-            Path = string.IsNullOrWhiteSpace(Path)
-                ? FileSystem.Directory.GetCurrentDirectory()
-                : FileSystem.Path.GetFullPath(Path);
-        }
-    }
-}
diff --git a/src/Pretzel.Logic/Commands/CommandParameters.cs b/src/Pretzel.Logic/Commands/CommandParameters.cs
index 639a8547e..9b490ed7c 100644
--- a/src/Pretzel.Logic/Commands/CommandParameters.cs
+++ b/src/Pretzel.Logic/Commands/CommandParameters.cs
@@ -23,50 +23,7 @@ public CommandParameters([ImportMany] IEnumerable<IHaveCommandLineArgs> commandL
 
             Settings = new List<Option>
             {
-                new Option(new []{ "template", "t" },"The templating engine to use")
-                {
-                    Argument = new Argument<string>()
-                },
-                new Option(new [] {"port", "p"}, "The port to test the site locally")
-                {
-                    Argument = new Argument<int>(() => 8080)
-                },
-                new Option(new [] {"import", "i"}, "The import type")
-                {
-                    Argument = new Argument<string>()
-                },
-                new Option(new [] {"file", "f"}, "Path to import file")
-                {
-                    Argument = new Argument<string>()
-                },
-                new Option("destination", "The path to the destination site (default _site)")
-                {
-                    Argument = new Argument<string>(() => "_site")
-                },
-                new Option("drafts", "Add the posts in the drafts folder")
-                {
-                    Argument = new Argument<bool>()
-                },
-                new Option("nobrowser", "Do not launch a browser (false by default)")
-                {
-                    Argument = new Argument<bool>(() => false)
-                },
-                new Option("withproject", "Includes a layout VS Solution, to give intellisense when editing razor layout files")
-                {
-                    Argument = new Argument<bool>()
-                },
-                new Option("wiki", "Creates a wiki instead of a blog (razor template only)")
-                {
-                    Argument = new Argument<bool>()
-                },
-                new Option("cleantarget", "Delete the target directory (_site by default)")
-                {
-                    Argument = new Argument<bool>()
-                },
-                new Option(new [] { "newposttitle", "n" }, "The title of the new post (\"New post\" by default")
-                {
-                    Argument = new Argument<string>(() => "New post")
-                }
+
             };
 
             // Allow extensions to register command line args
diff --git a/src/Pretzel.Logic/Commands/ICommandParameters.cs b/src/Pretzel.Logic/Commands/ICommandParameters.cs
index 8d2bfe34a..e58bf363d 100644
--- a/src/Pretzel.Logic/Commands/ICommandParameters.cs
+++ b/src/Pretzel.Logic/Commands/ICommandParameters.cs
@@ -7,5 +7,7 @@ namespace Pretzel.Logic.Commands
     public interface ICommandParameters
     {
         IList<Option> Options { get; }
+
+        void BindingCompleted();
     }
 }
diff --git a/src/Pretzel.Logic/Extensibility/CommandArgumentsExtentionAttribute.cs b/src/Pretzel.Logic/Extensibility/CommandArgumentsExtentionAttribute.cs
new file mode 100644
index 000000000..174877482
--- /dev/null
+++ b/src/Pretzel.Logic/Extensibility/CommandArgumentsExtentionAttribute.cs
@@ -0,0 +1,16 @@
+using System;
+using System.Composition;
+
+namespace Pretzel.Logic.Extensibility
+{
+    [MetadataAttribute]
+    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
+    public sealed class CommandArgumentsExtentionAttribute : ExportAttribute
+    {
+        public string[] CommandNames { get; set; }
+
+        public CommandArgumentsExtentionAttribute() : base(typeof(IHaveCommandLineArgs))
+        {
+        }
+    }
+}
diff --git a/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs b/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs
index 051e3a10a..fe029ac8b 100644
--- a/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs
+++ b/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs
@@ -10,7 +10,9 @@
 
 namespace Pretzel.Logic.Extensibility.Extensions
 {
-    [CommandArguments(CommandName = "create")]
+    [Export]
+    [Shared]
+    [CommandArgumentsExtention(CommandNames = new[] { BuiltInCommands.Create })]
     public class AzureHostSupportArguments : IHaveCommandLineArgs
     {
         public void UpdateOptions(IList<Option> options)
@@ -20,10 +22,13 @@ public void UpdateOptions(IList<Option> options)
                 Argument = new Argument<bool>()
             });
         }
+
+        public void BindingCompleted()
+        {
+        }
     }
 
     [Export(typeof(IAdditionalIngredient))]
-    [Export(typeof(IHaveCommandLineArgs))]
     public class AzureHostSupport : IAdditionalIngredient
     {
         private readonly IFileSystem fileSystem;
diff --git a/src/Pretzel.Logic/Extensibility/Extensions/VirtualDirectorySupport.cs b/src/Pretzel.Logic/Extensibility/Extensions/VirtualDirectorySupport.cs
index 19dfcd921..6d75ed028 100644
--- a/src/Pretzel.Logic/Extensibility/Extensions/VirtualDirectorySupport.cs
+++ b/src/Pretzel.Logic/Extensibility/Extensions/VirtualDirectorySupport.cs
@@ -4,13 +4,33 @@
 using System.IO.Abstractions;
 using System.Linq;
 using System.Text.RegularExpressions;
+using Pretzel.Logic.Commands;
 using Pretzel.Logic.Templating.Context;
 
 namespace Pretzel.Logic.Extensibility.Extensions
 {
-    [Export(typeof(IHaveCommandLineArgs))]
+    [Export]
+    [Shared]
+    [CommandArgumentsExtention(CommandNames = new[] { BuiltInCommands.Bake, BuiltInCommands.Taste })]
+    public class VirtualDirectorySupportArguments : IHaveCommandLineArgs
+    {
+        public void UpdateOptions(IList<Option> options)
+        {
+            options.Add(new Option(new [] { "-vDir", "--virtualdirectory"}, "Rewrite url's to work inside the specified virtual directory")
+            {
+                Argument = new Argument<string>()
+            });
+        }
+
+        public void BindingCompleted()
+        {
+        }
+
+        public string VirtualDirectory { get; set; }
+    }
+
     [Export(typeof(ITransform))]
-    public class VirtualDirectorySupport : ITransform, IHaveCommandLineArgs
+    public class VirtualDirectorySupport : ITransform
     {
         readonly IFileSystem fileSystem;
 
@@ -20,14 +40,17 @@ public VirtualDirectorySupport(IFileSystem fileSystem)
             this.fileSystem = fileSystem;
         }
 
+        [Import]
+        public VirtualDirectorySupportArguments Arguments { get; set; }
+
         public void Transform(SiteContext siteContext)
         {
-            if (string.IsNullOrEmpty(VirtualDirectory)) return;
+            if (string.IsNullOrEmpty(Arguments.VirtualDirectory)) return;
 
             var href = new Regex("href=\"(?<url>/.*?)\"", RegexOptions.Compiled);
             var src = new Regex("src=\"(?<url>/.*?)\"", RegexOptions.Compiled);
-            var hrefReplacement = string.Format("href=\"/{0}${{url}}\"", VirtualDirectory);
-            var srcReplacement = string.Format("src=\"/{0}${{url}}\"", VirtualDirectory);
+            var hrefReplacement = string.Format("href=\"/{0}${{url}}\"", Arguments.VirtualDirectory);
+            var srcReplacement = string.Format("src=\"/{0}${{url}}\"", Arguments.VirtualDirectory);
 
             foreach (var page in siteContext.Pages.Where(p => p.OutputFile.EndsWith(".html") || p.OutputFile.EndsWith(".htm") || p.OutputFile.EndsWith(".css")))
             {
@@ -42,23 +65,5 @@ public void Transform(SiteContext siteContext)
                 }
             }
         }
-
-        public void UpdateOptions(IList<Option> options)
-        {
-            options.Add(new Option("vDir", "Rewrite url's to work inside the specified virtual directory")
-            {
-                Argument = new Argument<string>()
-            });
-        }
-
-        public string[] GetArguments(string command)
-        {
-            if (command == "bake" || command == "taste")
-                return new[] { "-vDir" };
-
-            return new string[0];
-        }
-
-        public string VirtualDirectory { get; set; }
     }
 }
diff --git a/src/Pretzel.Logic/Extensibility/IHaveCommandLineArgs.cs b/src/Pretzel.Logic/Extensibility/IHaveCommandLineArgs.cs
index 8c1f95294..28279e5ed 100644
--- a/src/Pretzel.Logic/Extensibility/IHaveCommandLineArgs.cs
+++ b/src/Pretzel.Logic/Extensibility/IHaveCommandLineArgs.cs
@@ -1,10 +1,14 @@
+using System;
 using System.Collections.Generic;
 using System.CommandLine;
+using System.Composition;
 
 namespace Pretzel.Logic.Extensibility
 {
     public interface IHaveCommandLineArgs
     {
         void UpdateOptions(IList<Option> options);
+
+        void BindingCompleted();
     }
 }
diff --git a/src/Pretzel/Commands/BakeCommand.cs b/src/Pretzel/Commands/BakeCommand.cs
index a5232dbca..8f0bb792b 100644
--- a/src/Pretzel/Commands/BakeCommand.cs
+++ b/src/Pretzel/Commands/BakeCommand.cs
@@ -1,50 +1,113 @@
 using Pretzel.Logic.Commands;
 using Pretzel.Logic.Extensibility;
 using Pretzel.Logic.Extensions;
+using Pretzel.Logic.Templating;
 using Pretzel.Logic.Templating.Context;
 using System;
 using System.Collections.Generic;
 using System.CommandLine;
+using System.CommandLine.Invocation;
 using System.Composition;
 using System.Diagnostics;
 using System.IO;
 using System.IO.Abstractions;
 using System.Linq;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
 
 namespace Pretzel.Commands
 {
-
     [Shared]
+    [Export]
     [CommandArguments(CommandName = BuiltInCommands.Bake)]
-    public sealed class BakeCommandParameters : ICommandParameters
+    public sealed class BakeCommandParameters : BakeBaseCommandParameters
     {
-        //[ImportMany]
-        //public ExportFactory<IHaveCommandLineArgs, CommandArgumentsAttribute>[] ArgumentExtenders { get; set; }
+        [ImportingConstructor]
+        public BakeCommandParameters(IFileSystem fileSystem) : base(fileSystem) { }
+    }
 
-        [Export]
-        public IList<Option> Options { get; set; }
+    public abstract class PretzelBaseCommandParameters : BParameters
+    {
+        protected readonly IFileSystem fileSystem;
+        protected PretzelBaseCommandParameters(IFileSystem fileSystem)
+        {
+            this.fileSystem = fileSystem;
+        }
 
-        [OnImportsSatisfied]
-        internal void OnImportsSatisfied()
+        protected override void WithOptions(List<Option> options)
         {
-            Options = new List<Option>
+            options.AddRange(new[]
             {
-                new Option(new []{ "--template", "-t" },"The templating engine to use")
+                new Option(new []{ "-t", "--template" },"The templating engine to use")
                 {
                     Argument = new Argument<string>()
                 },
-            };
+                new Option(new [] { "-d", "--destination" }, "The path to the destination site (default _site)")
+                {
+                    Argument = new Argument<string>(() => "_site")
+                },
+                new Option("--drafts", "Add the posts in the drafts folder")
+                {
+                    Argument = new Argument<bool>()
+                },
+            });
+        }
+        // Default Option that get injected from Program
+        public string Source { get; set; }
+        // Default Option that get injected from Program
+        public bool Debug { get; set; }
+        // Default Option that get injected from Program
+        public bool Safe { get; set; }
+
+
+        public string Template { get; set; }
+        public string Destination { get; set; }
+        public bool Drafts { get; set; }
+        public string Path => Source;
+
+        public override void BindingCompleted()
+        {
+            if (string.IsNullOrEmpty(Destination))
+            {
+                Destination = "_site";
+            }
+            if (!fileSystem.Path.IsPathRooted(Destination))
+            {
+                Destination = fileSystem.Path.Combine(Path, Destination);
+            }
+        }
+
+        public void DetectFromDirectory(IDictionary<string, ISiteEngine> engines, SiteContext context)
+        {
+            foreach (var engine in engines)
+            {
+                if (!engine.Value.CanProcess(context)) continue;
+                Tracing.Info("Recommended engine for directory: '{0}'", engine.Key);
+                Template = engine.Key;
+                return;
+            }
+
+            if (Template == null)
+                Template = "liquid";
+        }
+    }
 
-            //var attr = GetType().GetCustomAttributes(typeof(CommandArgumentsAttribute), true).FirstOrDefault();
+    public abstract class BakeBaseCommandParameters : PretzelBaseCommandParameters
+    {
+        protected BakeBaseCommandParameters(IFileSystem fileSystem) : base(fileSystem) { }
 
-            //if (attr is CommandArgumentsAttribute commandArgumentAttribute)
-            //{
-            //    foreach (var factory in ArgumentExtenders.Where(a => a.Metadata.CommandType == commandArgumentAttribute.CommandType))
-            //    {
-            //        factory.CreateExport().Value.UpdateOptions(Options);
-            //    }
-            //}
+        protected override void WithOptions(List<Option> options)
+        {
+            options.AddRange(new[]
+            {
+                new Option(new [] { "-c", "--cleantarget" }, "Delete the target directory (_site by default)")
+                {
+                    Argument = new Argument<bool>()
+                },
+            });
         }
+
+        public bool CleanTarget { get; set; }
     }
 
     [Shared]
@@ -59,36 +122,34 @@ public sealed class BakeCommand : ICommand
         [Import]
         public SiteContextGenerator Generator { get; set; }
 
-        [Import]
-        public CommandParameters parameters { get; set; }
-
         [ImportMany]
         public IEnumerable<ITransform> transforms { get; set; }
 
+        [Import]
+        public BakeCommandParameters Parameters { get; set; }
+
         [Import]
         public IFileSystem FileSystem { get; set; }
 
 #pragma warning restore 649
 
-        public void Execute(IEnumerable<string> arguments)
+        public async Task Execute()
         {
             Tracing.Info("bake - transforming content into a website");
 
-            parameters.Parse(arguments);
-
-            var siteContext = Generator.BuildContext(parameters.Path, parameters.DestinationPath, parameters.IncludeDrafts);
+            var siteContext = Generator.BuildContext(Parameters.Path, Parameters.Destination, Parameters.Drafts);
 
-            if (parameters.CleanTarget && FileSystem.Directory.Exists(siteContext.OutputFolder))
+            if (Parameters.CleanTarget && FileSystem.Directory.Exists(siteContext.OutputFolder))
             {
                 FileSystem.Directory.Delete(siteContext.OutputFolder, true);
             }
 
-            if (string.IsNullOrWhiteSpace(parameters.Template))
+            if (string.IsNullOrWhiteSpace(Parameters.Template))
             {
-                parameters.DetectFromDirectory(templateEngines.Engines, siteContext);
+                Parameters.DetectFromDirectory(templateEngines.Engines, siteContext);
             }
 
-            var engine = templateEngines[parameters.Template];
+            var engine = templateEngines[Parameters.Template];
             if (engine != null)
             {
                 var watch = new Stopwatch();
@@ -105,13 +166,8 @@ public void Execute(IEnumerable<string> arguments)
             }
             else
             {
-                Tracing.Info("Cannot find engine for input: '{0}'", parameters.Template);
+                Tracing.Info("Cannot find engine for input: '{0}'", Parameters.Template);
             }
         }
-
-        public void WriteHelp(TextWriter writer)
-        {
-            parameters.WriteOptions(writer, "-t", "-p", "-d", "-cleantarget", "-s", "-destination");
-        }
     }
 }
diff --git a/src/Pretzel/Commands/CommandCollection.cs b/src/Pretzel/Commands/CommandCollection.cs
index c3606ff8a..c47026deb 100644
--- a/src/Pretzel/Commands/CommandCollection.cs
+++ b/src/Pretzel/Commands/CommandCollection.cs
@@ -1,13 +1,58 @@
 using System;
 using System.Collections.Generic;
 using System.CommandLine;
+using System.CommandLine.Invocation;
+using System.CommandLine.Binding;
 using System.Composition;
+using System.Dynamic;
 using System.Linq;
 using Pretzel.Logic.Commands;
 using Pretzel.Logic.Extensibility;
+using System.Threading.Tasks;
+using System.Reflection;
 
 namespace Pretzel.Commands
 {
+
+    public class PretzelCommandHandler : ICommandHandler
+    {
+        private ICommandParameters commandParameters;
+        private ExportFactory<ICommand, CommandInfoAttribute> command;
+
+        public PretzelCommandHandler(ICommandParameters commandArguments, ExportFactory<ICommand, CommandInfoAttribute> command)
+        {
+            this.commandParameters = commandArguments;
+            this.command = command;
+        }
+
+        public async Task<int> InvokeAsync(InvocationContext context)
+        {
+            var bindingContext = context.BindingContext;
+
+            new ModelBinder(commandParameters.GetType())
+                .UpdateInstance(commandParameters, bindingContext);
+
+            commandParameters.BindingCompleted();
+
+            if (commandParameters is ICommandParametersExtendable commandParametersExtendable)
+            {
+                foreach (var factory in commandParametersExtendable.GetCommandExtentions())
+                {
+                    var extentedArguments = factory.CreateExport().Value;
+
+                    new ModelBinder(extentedArguments.GetType())
+                        .UpdateInstance(extentedArguments, bindingContext);
+
+                    extentedArguments.BindingCompleted();
+                }
+            }
+
+            await command.CreateExport().Value.Execute();
+
+            return 0;
+        }
+    }
+
     [Export]
     [Shared]
     public sealed class CommandCollection
@@ -21,65 +66,30 @@ public sealed class CommandCollection
         [Import]
         public Lazy<CommandParameters> Parameters { get; set; }
 
-        private Dictionary<string, ICommand> commandMap;
-
-        public ICommand this[string name]
-        {
-            get
-            {
-                ICommand command;
-                commandMap.TryGetValue(name.ToLower(System.Globalization.CultureInfo.InvariantCulture), out command);
-                return command;
-            }
-        }
-
         [Export]
         public RootCommand RootCommand { get; set; }
 
         [OnImportsSatisfied]
         public void OnImportsSatisfied()
         {
-            commandMap = new Dictionary<string, ICommand>(Commands.Length);
-
             RootCommand = new RootCommand();
 
             foreach (var command in Commands)
             {
-                if (!commandMap.ContainsKey(command.Metadata.CommandName))
-                {
-                    var subCommand = new Command(command.Metadata.CommandName, command.Metadata.CommandDescription);
+                var subCommand = new Command(command.Metadata.CommandName, command.Metadata.CommandDescription);
 
-                    foreach (var commandArguments in CommandArguments.Where(a => a.Metadata.CommandName == command.Metadata.CommandName))
+                foreach (var commandArgumentsExport in CommandArguments.Where(a => a.Metadata.CommandName == command.Metadata.CommandName))
+                {
+                    var commandArguments = commandArgumentsExport.CreateExport().Value;
+                    foreach (var option in commandArguments.Options)
                     {
-                        foreach(var option in commandArguments.CreateExport().Value.Options)
-                        {
-                            subCommand.AddOption(option);
-                        }
+                        subCommand.AddOption(option);
                     }
 
-                    RootCommand.AddCommand(subCommand);
-                    //var export = command.CreateExport();
-                    //commandMap.Add(command.Metadata.CommandName, export.Value);
+                    subCommand.Handler = new PretzelCommandHandler(commandArguments, command);
                 }
-            }
-        }
-
-        public void WriteHelp(List<Option> defaultSet)
-        {
-            Console.WriteLine(@"Usage:");
-            Console.WriteLine(@"Pretzel.exe command [options]");
-            Console.WriteLine();
-            //defaultSet.WriteOptionDescriptions(Console.Out);
-            Console.WriteLine();
 
-            foreach (var command in commandMap)
-            {
-                Console.WriteLine(@"Command: " + command.Key);
-                command.Value.WriteHelp(Console.Out);
-                //var extraArgs = CommandLineExtensions.SelectMany(e => e.Value.GetArguments(command.Key)).ToArray();
-                //if (extraArgs.Any())
-                //    Parameters.Value.WriteOptions(Console.Out, extraArgs);
-                Console.WriteLine();
+                RootCommand.AddCommand(subCommand);
             }
         }
     }
diff --git a/src/Pretzel/Commands/HungryCommand.cs b/src/Pretzel/Commands/HungryCommand.cs
index 8e14705cc..89621df85 100644
--- a/src/Pretzel/Commands/HungryCommand.cs
+++ b/src/Pretzel/Commands/HungryCommand.cs
@@ -1,7 +1,9 @@
 using System;
 using System.Collections.Generic;
+using System.CommandLine.Invocation;
 using System.Composition;
 using System.IO;
+using System.Threading.Tasks;
 using Pretzel.Logic.Commands;
 using Pretzel.Logic.Extensions;
 
@@ -11,8 +13,6 @@ namespace Pretzel.Commands
     [CommandInfo(CommandName = BuiltInCommands.Hungry, CommandDescription = "use only when hungry")]
     public sealed class HungryCommand : ICommand
     {
-
-
         private readonly string recipe = @"===== Ingredients ======
 
 == Dough====
@@ -52,7 +52,7 @@ 2 tablespoons baking soda
 
 Eat the pretzels warm, or reheat them in an oven or microwave.";
 
-        public void Execute(IEnumerable<string> arguments)
+        public async Task Execute()
         {
             Tracing.Info(recipe);
         }
diff --git a/src/Pretzel/Commands/ICommand.cs b/src/Pretzel/Commands/ICommand.cs
index 83ef356d4..65ce374d6 100644
--- a/src/Pretzel/Commands/ICommand.cs
+++ b/src/Pretzel/Commands/ICommand.cs
@@ -1,11 +1,10 @@
 using System.Collections.Generic;
-using System.IO;
+using System.Threading.Tasks;
 
 namespace Pretzel.Commands
 {
     public interface ICommand
     {
-        void Execute(IEnumerable<string> arguments);
-        void WriteHelp(TextWriter writer); // TODO: obsolete this?
+        Task Execute();
     }
 }
diff --git a/src/Pretzel/Commands/ImportCommand.cs b/src/Pretzel/Commands/ImportCommand.cs
index d4963abc7..74baeb46c 100644
--- a/src/Pretzel/Commands/ImportCommand.cs
+++ b/src/Pretzel/Commands/ImportCommand.cs
@@ -7,13 +7,45 @@
 using Pretzel.Logic.Extensions;
 using Pretzel.Logic.Import;
 using System.Composition;
+using System.CommandLine;
+using System.CommandLine.Invocation;
+using System.Threading.Tasks;
 
 namespace Pretzel.Commands
 {
+    [Export]
+    [Shared]
+    [CommandArguments(CommandName = BuiltInCommands.Import)]
+    public class ImportParameters : BParameters
+    {
+        protected override void WithOptions(List<Option> options)
+        {
+            options.AddRange(new[]
+            {
+                new Option(new [] {"import", "i"}, "The import type")
+                {
+                    Argument = new Argument<string>()
+                },
+                new Option(new [] {"file", "f"}, "Path to import file")
+                {
+                    Argument = new Argument<string>()
+                },
+            });
+        }
+    }
+
     [Shared]
     [CommandInfo(CommandName = BuiltInCommands.Import, CommandDescription = "import posts from external source")]
     class ImportCommand : ICommand
     {
+        public ICommandHandler CreateCommandHandler()
+        {
+            return CommandHandler.Create<BakeCommandParameters>(x =>
+            {
+
+            });
+        }
+
         readonly static List<string> Importers = new List<string>(new[] { "wordpress", "blogger" });
 
 #pragma warning disable 649
@@ -21,12 +53,10 @@ class ImportCommand : ICommand
         [Import] public CommandParameters Parameters { get; set; }
 #pragma warning restore 649
 
-        public void Execute(IEnumerable<string> arguments)
+        public async Task Execute()
         {
             Tracing.Info("import - import posts from external source");
-
-            Parameters.Parse(arguments);
-
+            
             if (!Importers.Any(e => String.Equals(e, Parameters.ImportType, StringComparison.InvariantCultureIgnoreCase)))
             {
                 Tracing.Info("Requested import type not found: {0}", Parameters.ImportType);
diff --git a/src/Pretzel/Commands/IngredientCommand.cs b/src/Pretzel/Commands/IngredientCommand.cs
index 63fff680f..a7d4a38c1 100644
--- a/src/Pretzel/Commands/IngredientCommand.cs
+++ b/src/Pretzel/Commands/IngredientCommand.cs
@@ -2,12 +2,36 @@
 using Pretzel.Logic.Extensions;
 using Pretzel.Logic.Recipe;
 using System.Collections.Generic;
+using System.CommandLine;
+using System.CommandLine.Invocation;
 using System.Composition;
 using System.IO;
 using System.IO.Abstractions;
+using System.Threading.Tasks;
 
 namespace Pretzel.Commands
 {
+    [Export]
+    [Shared]
+    [CommandArguments(CommandName = BuiltInCommands.Ingredient)]
+    public class IngredientCommandParameters : PretzelBaseCommandParameters
+    {
+        public IngredientCommandParameters(IFileSystem fileSystem) : base(fileSystem) { }
+
+        protected override void WithOptions(List<Option> options)
+        {
+            options.AddRange(new[]
+            {
+                new Option(new [] { "newposttitle", "n" }, "The title of the new post (\"New post\" by default")
+                {
+                    Argument = new Argument<string>(() => "New post")
+                }
+            });
+        }
+
+        public string NewPostTitle { get; set; }
+    }
+
     [Shared]
     [CommandInfo(CommandName = BuiltInCommands.Ingredient, CommandDescription = "create a new post")]
     public sealed class IngredientCommand : ICommand
@@ -18,24 +42,16 @@ public sealed class IngredientCommand : ICommand
         public IFileSystem FileSystem { get; set; }
 
         [Import]
-        public CommandParameters Parameters { get; set; }
+        public IngredientCommandParameters Parameters { get; set; }
 
 #pragma warning restore 649
 
-        public void Execute(IEnumerable<string> arguments)
+        public async Task Execute()
         {
             Tracing.Info("ingredient - create a new post");
 
-            Parameters.Parse(arguments);
-
-            var ingredient = new Ingredient(FileSystem, Parameters.NewPostTitle, Parameters.Path, Parameters.IncludeDrafts);
+            var ingredient = new Ingredient(FileSystem, Parameters.NewPostTitle, Parameters.Path, Parameters.Drafts);
             ingredient.Create();
         }
-
-        public void WriteHelp(TextWriter writer)
-        {
-            writer.Write("   Create a new post\r\n");
-            Parameters.WriteOptions(writer, "newposttitle", "drafts", "-s");
-        }
     }
 }
diff --git a/src/Pretzel/Commands/RecipeCommand.cs b/src/Pretzel/Commands/RecipeCommand.cs
index d1f31b3a2..78c348913 100644
--- a/src/Pretzel/Commands/RecipeCommand.cs
+++ b/src/Pretzel/Commands/RecipeCommand.cs
@@ -1,16 +1,43 @@
-using Pretzel.Logic.Commands;
-using Pretzel.Logic.Extensibility;
-using Pretzel.Logic.Extensions;
-using Pretzel.Logic.Recipe;
 using System;
 using System.Collections.Generic;
+using System.CommandLine;
 using System.Composition;
-using System.IO;
 using System.IO.Abstractions;
 using System.Linq;
+using System.Threading.Tasks;
+using Pretzel.Logic.Commands;
+using Pretzel.Logic.Extensibility;
+using Pretzel.Logic.Extensions;
+using Pretzel.Logic.Recipe;
 
 namespace Pretzel.Commands
 {
+    [Export]
+    [Shared]
+    [CommandArguments(CommandName = BuiltInCommands.Create)]
+    public class RecipeCommandParameters : PretzelBaseCommandParameters
+    {
+        public RecipeCommandParameters(IFileSystem fileSystem) : base(fileSystem) { }
+
+        protected override void WithOptions(List<Option> options)
+        {
+            options.AddRange(new[]
+            {
+                new Option("withproject", "Includes a layout VS Solution, to give intellisense when editing razor layout files")
+                {
+                    Argument = new Argument<bool>()
+                },
+                new Option("wiki", "Creates a wiki instead of a blog (razor template only)")
+                {
+                    Argument = new Argument<bool>()
+                },
+            });
+        }
+
+        public bool WithProject { get; set; }
+        public bool Wiki { get; set; }
+    }
+
     [Shared]
     [CommandInfo(CommandName = BuiltInCommands.Create, CommandDescription = "configure a new site")]
     public sealed class RecipeCommand : ICommand
@@ -23,19 +50,17 @@ public sealed class RecipeCommand : ICommand
         public IFileSystem FileSystem { get; set; }
 
         [Import]
-        public CommandParameters Parameters { get; set; }
+        public RecipeCommandParameters Parameters { get; set; }
 
         [ImportMany]
         public IEnumerable<IAdditionalIngredient> AdditionalIngredients { get; set; }
 
 #pragma warning restore 649
 
-        public void Execute(IEnumerable<string> arguments)
+        public async Task Execute()
         {
             Tracing.Info("create - configure a new site");
 
-            Parameters.Parse(arguments);
-
             var engine = String.IsNullOrWhiteSpace(Parameters.Template)
                              ? TemplateEngines.First()
                              : Parameters.Template;
@@ -48,13 +73,8 @@ public void Execute(IEnumerable<string> arguments)
 
             Tracing.Info("Using {0} Engine", engine);
 
-            var recipe = new Recipe(FileSystem, engine, Parameters.Path, AdditionalIngredients, Parameters.WithProject, Parameters.Wiki, Parameters.IncludeDrafts);
+            var recipe = new Recipe(FileSystem, engine, Parameters.Path, AdditionalIngredients, Parameters.WithProject, Parameters.Wiki, Parameters.Drafts);
             recipe.Create();
         }
-
-        public void WriteHelp(TextWriter writer)
-        {
-            Parameters.WriteOptions(writer, "-t", "-d", "withproject", "wiki", "-s");
-        }
     }
 }
diff --git a/src/Pretzel/Commands/TasteCommand.cs b/src/Pretzel/Commands/TasteCommand.cs
index a4b2a0225..60fb6a0af 100644
--- a/src/Pretzel/Commands/TasteCommand.cs
+++ b/src/Pretzel/Commands/TasteCommand.cs
@@ -7,13 +7,46 @@
 using Pretzel.Modules;
 using System;
 using System.Collections.Generic;
+using System.CommandLine;
+using System.CommandLine.Invocation;
 using System.Composition;
-using System.Diagnostics;
 using System.IO;
 using System.IO.Abstractions;
+using System.Threading.Tasks;
 
 namespace Pretzel.Commands
 {
+    [Export]
+    [Shared]
+    [CommandArguments(CommandName = BuiltInCommands.Taste)]
+    public class TasteParameters : BakeBaseCommandParameters
+    {
+        [ImportingConstructor]
+        public TasteParameters(IFileSystem fileSystem) : base(fileSystem) { }
+
+        protected override void WithOptions(List<Option> options)
+        {
+            base.WithOptions(options);
+            options.AddRange(new[]
+            {
+                new Option(new[] { "port", "p" }, "The port to test the site locally")
+                {
+                    Argument = new Argument<int>(() => 8080)
+                },
+                new Option("nobrowser", "Do not launch a browser (false by default)")
+                {
+                    Argument = new Argument<bool>(() => false)
+                },
+            });
+        }
+
+        public int Port { get; set; }
+
+        public bool NoBrowser { get; set; }
+
+        public bool LaunchBrowser => !NoBrowser;
+    }
+
     [Shared]
     [CommandInfo(CommandName = BuiltInCommands.Taste, CommandDescription = "testing a site locally")]
     public sealed class TasteCommand : ICommand
@@ -28,7 +61,7 @@ public sealed class TasteCommand : ICommand
         public SiteContextGenerator Generator { get; set; }
 
         [Import]
-        public CommandParameters Parameters { get; set; }
+        public TasteParameters Parameters { get; set; }
 
         [ImportMany]
         public IEnumerable<ITransform> Transforms { get; set; }
@@ -41,13 +74,11 @@ public sealed class TasteCommand : ICommand
 
 #pragma warning restore 649
 
-        public void Execute(IEnumerable<string> arguments)
+        public async Task Execute()
         {
             Tracing.Info("taste - testing a site locally");
-
-            Parameters.Parse(arguments);
-
-            var context = Generator.BuildContext(Parameters.Path, Parameters.DestinationPath, Parameters.IncludeDrafts);
+            
+            var context = Generator.BuildContext(Parameters.Path, Parameters.Destination, Parameters.Drafts);
 
             if (Parameters.CleanTarget && FileSystem.Directory.Exists(context.OutputFolder))
             {
@@ -74,11 +105,11 @@ public void Execute(IEnumerable<string> arguments)
             foreach (var t in Transforms)
                 t.Transform(context);
 
-            using (var watcher = new SimpleFileSystemWatcher(Parameters.DestinationPath))
+            using (var watcher = new SimpleFileSystemWatcher(Parameters.Destination))
             {
                 watcher.OnChange(Parameters.Path, WatcherOnChanged);
 
-                using (var w = new WebHost(Parameters.DestinationPath, new FileContentProvider(), Convert.ToInt32(Parameters.Port)))
+                using (var w = new WebHost(Parameters.Destination, new FileContentProvider(), Convert.ToInt32(Parameters.Port)))
                 {
                     try
                     {
@@ -96,7 +127,7 @@ public void Execute(IEnumerable<string> arguments)
                         Tracing.Info("Opening {0} in default browser...", url);
                         try
                         {
-                            Process.Start(url);
+                            System.Diagnostics.Process.Start(url);
                         }
                         catch (Exception)
                         {
@@ -135,7 +166,7 @@ private void WatcherOnChanged(string file)
 
             ((Configuration)Configuration).ReadFromFile();
 
-            var context = Generator.BuildContext(Parameters.Path, Parameters.DestinationPath, Parameters.IncludeDrafts);
+            var context = Generator.BuildContext(Parameters.Path, Parameters.Destination, Parameters.Drafts);
             if (Parameters.CleanTarget && FileSystem.Directory.Exists(context.OutputFolder))
             {
                 FileSystem.Directory.Delete(context.OutputFolder, true);
@@ -144,10 +175,5 @@ private void WatcherOnChanged(string file)
             foreach (var t in Transforms)
                 t.Transform(context);
         }
-
-        public void WriteHelp(TextWriter writer)
-        {
-            Parameters.WriteOptions(writer, "-t", "-d", "-p", "--nobrowser", "-cleantarget", "-s", "-destination");
-        }
     }
 }
diff --git a/src/Pretzel/Commands/VersionCommand.cs b/src/Pretzel/Commands/VersionCommand.cs
index 48d6fac09..d48aca80b 100644
--- a/src/Pretzel/Commands/VersionCommand.cs
+++ b/src/Pretzel/Commands/VersionCommand.cs
@@ -1,8 +1,10 @@
 using Pretzel.Logic.Commands;
 using Pretzel.Logic.Extensions;
 using System.Collections.Generic;
+using System.CommandLine.Invocation;
 using System.Composition;
 using System.Reflection;
+using System.Threading.Tasks;
 
 namespace Pretzel.Commands
 {
@@ -10,14 +12,9 @@ namespace Pretzel.Commands
     [CommandInfo(CommandName = BuiltInCommands.Version, CommandDescription = "display current Pretzel version")]
     public sealed class VersionCommand : ICommand
     {
-        public void Execute(IEnumerable<string> arguments)
+        public async Task Execute()
         {
             Tracing.Info("V{0}", Assembly.GetExecutingAssembly().GetName().Version);
         }
-
-        public void WriteHelp(System.IO.TextWriter writer)
-        {
-            writer.WriteLine("  Display current Pretzel version.");
-        }
     }
 }
diff --git a/src/Pretzel/Program.cs b/src/Pretzel/Program.cs
index 89d06abfc..7ef721fd4 100644
--- a/src/Pretzel/Program.cs
+++ b/src/Pretzel/Program.cs
@@ -25,15 +25,18 @@ internal class Program
         [Export]
         public IFileSystem FileSystem { get; set; } = new FileSystem();
 
-        [Export("SourcePath")]
-        public string SourcePath { get; }
+        //[Export("SourcePath")]
+        //public string SourcePath { get; }
+
+        //public Program()
+        //{
+        //    SourcePath = sourcePath;
+        //}
+
+        //private static string sourcePath;
+
 
-        public Program()
-        {
-            SourcePath = sourcePath;
-        }
 
-        private static string sourcePath;
         private static async Task<int> Main(string[] args)
         {
             var rootCommand = new RootCommand
@@ -53,10 +56,36 @@ private static async Task<int> Main(string[] args)
                 },
                 new Option(new[] { "-s", "--source" }, "The path to the source site (default current directory)")
                 {
-                    Argument = new Argument<string>(() => Environment.CurrentDirectory)
+                    Argument = new Argument<string>()
                 }
             };
 
+            if (args.Length > 1 && !args.Contains("-s") && !args.Contains("--source"))
+            {
+                var fileSystem = new FileSystem();
+                var firstArgument = args[1];
+
+                // take the first argument after the command
+                if (firstArgument != null && !firstArgument.StartsWith("-") && !firstArgument.StartsWith("/"))
+                {
+                    var arguments = args.ToList();
+                    var path = fileSystem.Path.IsPathRooted(firstArgument)
+                        ? firstArgument
+                        : fileSystem.Path.Combine(fileSystem.Directory.GetCurrentDirectory(), firstArgument);
+
+                    arguments[1] = "-s";
+                    arguments.Insert(2, path);
+                    args = arguments.ToArray();
+                }
+
+                Path = string.IsNullOrWhiteSpace(Path)
+                    ? fileSystem.Directory.GetCurrentDirectory()
+                    : fileSystem.Path.GetFullPath(Path);
+
+                Console.WriteLine(Path);
+            }
+            
+
             foreach (var option in globalOptions)
             {
                 rootCommand.AddOption(option);
@@ -64,7 +93,6 @@ private static async Task<int> Main(string[] args)
 
             rootCommand.Handler = CommandHandler.Create(async (bool debug, bool safe, string source) =>
             {
-                sourcePath = source;
                 try
                 {
                     InitializeTrace(debug);
@@ -130,14 +158,6 @@ private async Task<int> Run(IEnumerable<Option> globalOptions, string[] args)
                 WaitForClose();
                 return -1;
             }
-            //if (Commands[parameters.CommandName] == null)
-            //{
-            //    Console.WriteLine(@"Can't find command ""{0}""", parameters.CommandName);
-            //    //Commands.WriteHelp(parameters.Options);
-            //    return -1;
-            //}
-
-            //Commands[parameters.CommandName].Execute(parameters.CommandArgs);
         }
 
         [System.Diagnostics.Conditional("DEBUG")]
diff --git a/src/Pretzel/Properties/launchSettings.json b/src/Pretzel/Properties/launchSettings.json
index 6cb399f0e..2d1e8f010 100644
--- a/src/Pretzel/Properties/launchSettings.json
+++ b/src/Pretzel/Properties/launchSettings.json
@@ -2,7 +2,7 @@
   "profiles": {
     "Pretzel": {
       "commandName": "Project",
-      "commandLineArgs": "--safe --debug",
+      "commandLineArgs": "bake c:\\f\\git --virtualdirectory=Foo",
       "workingDirectory": "c:\\f\\git\\Scissors.Blog"
     }
   }

From 8351e5f4a19f4ba7e81dbaba8a7b65d789a412bf Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Sat, 21 Sep 2019 15:47:57 +0200
Subject: [PATCH 06/56] refactor: removed old Parameter classes

---
 .../{BParameters.cs => BaseParameters.cs}     |   2 +-
 .../Commands/CommandParameters.cs             | 146 ------------------
 src/Pretzel/Commands/BakeCommand.cs           |  11 +-
 src/Pretzel/Commands/ImportCommand.cs         |   2 +-
 src/Pretzel/Program.cs                        |  14 +-
 src/Pretzel/Properties/launchSettings.json    |   4 +-
 6 files changed, 18 insertions(+), 161 deletions(-)
 rename src/Pretzel.Logic/Commands/{BParameters.cs => BaseParameters.cs} (95%)
 delete mode 100644 src/Pretzel.Logic/Commands/CommandParameters.cs

diff --git a/src/Pretzel.Logic/Commands/BParameters.cs b/src/Pretzel.Logic/Commands/BaseParameters.cs
similarity index 95%
rename from src/Pretzel.Logic/Commands/BParameters.cs
rename to src/Pretzel.Logic/Commands/BaseParameters.cs
index d2f50c242..0b91baf21 100644
--- a/src/Pretzel.Logic/Commands/BParameters.cs
+++ b/src/Pretzel.Logic/Commands/BaseParameters.cs
@@ -15,7 +15,7 @@ ExportFactory<IHaveCommandLineArgs, CommandArgumentsExtentionAttribute>[] Argume
         }
     }
 
-    public abstract class BParameters : ICommandParameters, ICommandParametersExtendable
+    public abstract class BaseParameters : ICommandParameters, ICommandParametersExtendable
     {
         [ImportMany]
         public ExportFactory<IHaveCommandLineArgs, CommandArgumentsExtentionAttribute>[] ArgumentExtenders { get; set; }
diff --git a/src/Pretzel.Logic/Commands/CommandParameters.cs b/src/Pretzel.Logic/Commands/CommandParameters.cs
deleted file mode 100644
index 9b490ed7c..000000000
--- a/src/Pretzel.Logic/Commands/CommandParameters.cs
+++ /dev/null
@@ -1,146 +0,0 @@
-using Pretzel.Logic.Extensibility;
-using Pretzel.Logic.Extensions;
-using Pretzel.Logic.Templating;
-using Pretzel.Logic.Templating.Context;
-using System;
-using System.Collections.Generic;
-using System.CommandLine;
-using System.Composition;
-using System.IO;
-using System.IO.Abstractions;
-using System.Linq;
-
-namespace Pretzel.Logic.Commands
-{
-    [Export]
-    [Shared]
-    public class CommandParameters
-    {
-        [ImportingConstructor]
-        public CommandParameters([ImportMany] IEnumerable<IHaveCommandLineArgs> commandLineExtensions, IFileSystem fileSystem)
-        {
-            this.fileSystem = fileSystem;
-
-            Settings = new List<Option>
-            {
-
-            };
-
-            // Allow extensions to register command line args
-            foreach (var commandLineExtension in commandLineExtensions)
-            {
-                commandLineExtension.UpdateOptions(Settings);
-            }
-        }
-
-        [Import("SourcePath")]
-        public string Path { get; set; }
-
-        public string Template { get; private set; }
-
-        public string ImportPath { get; private set; }
-
-        public string ImportType { get; private set; }
-
-        public bool WithProject { get; private set; }
-
-        public bool Wiki { get; private set; }
-
-        public bool IncludeDrafts { get; private set; }
-
-        public bool CleanTarget { get; private set; }
-
-        public bool LaunchBrowser { get; private set; }
-
-        public string DestinationPath { get; private set; }
-
-        public string NewPostTitle { get; internal set; }
-
-        private decimal port;
-
-        public decimal Port
-        {
-            get { return port; }
-        }
-
-        [Export]
-        private List<Option> Settings { get; set; }
-
-        private readonly IFileSystem fileSystem;
-
-        public void Parse(IEnumerable<string> arguments)
-        {
-            var argumentList = arguments.ToArray();
-
-            //Settings.Parse(argumentList);
-
-            if (string.IsNullOrEmpty(DestinationPath))
-            {
-                DestinationPath = "_site";
-            }
-            if (!fileSystem.Path.IsPathRooted(DestinationPath))
-            {
-                DestinationPath = fileSystem.Path.Combine(Path, DestinationPath);
-            }
-            if (string.IsNullOrEmpty(NewPostTitle))
-            {
-                NewPostTitle = "New post";
-            }
-        }
-
-        public void DetectFromDirectory(IDictionary<string, ISiteEngine> engines, SiteContext context)
-        {
-            foreach (var engine in engines)
-            {
-                if (!engine.Value.CanProcess(context)) continue;
-                Tracing.Info("Recommended engine for directory: '{0}'", engine.Key);
-                Template = engine.Key;
-                return;
-            }
-
-            if (Template == null)
-                Template = "liquid";
-        }
-
-        public void WriteOptions(TextWriter writer, params string[] args)
-        {
-            //if (args.Length == 0)
-            //    Settings.WriteOptionDescriptions(writer);
-            //else
-            //    WriteSubset(writer, args);
-        }
-
-        private void WriteSubset(TextWriter writer, string[] args)
-        {
-            var textWriter = new StringWriter();
-            //Settings.WriteOptionDescriptions(textWriter);
-            var output = textWriter.ToString();
-
-            var strings = RecombineMultilineArgs(output.Split(new[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries));
-
-            foreach (var line in strings)
-            {
-                if (args.Any(line.Contains))
-                {
-                    writer.WriteLine(line);
-                }
-            }
-        }
-
-        private IEnumerable<string> RecombineMultilineArgs(string[] split)
-        {
-            for (int i = 0; i < split.Length; i++)
-            {
-                if (i + 1 < split.Length && !split[i + 1].TrimStart().StartsWith("-"))
-                {
-                    yield return split[i] + "\r\n" + split[i + 1];
-                    i++;
-                }
-                else
-                {
-                    yield return split[i];
-                }
-            }
-        }
-    }
-}
diff --git a/src/Pretzel/Commands/BakeCommand.cs b/src/Pretzel/Commands/BakeCommand.cs
index 8f0bb792b..fe11ea66b 100644
--- a/src/Pretzel/Commands/BakeCommand.cs
+++ b/src/Pretzel/Commands/BakeCommand.cs
@@ -26,7 +26,7 @@ public sealed class BakeCommandParameters : BakeBaseCommandParameters
         public BakeCommandParameters(IFileSystem fileSystem) : base(fileSystem) { }
     }
 
-    public abstract class PretzelBaseCommandParameters : BParameters
+    public abstract class PretzelBaseCommandParameters : BaseParameters
     {
         protected readonly IFileSystem fileSystem;
         protected PretzelBaseCommandParameters(IFileSystem fileSystem)
@@ -58,22 +58,27 @@ protected override void WithOptions(List<Option> options)
         public bool Debug { get; set; }
         // Default Option that get injected from Program
         public bool Safe { get; set; }
+        [Obsolete("Use '" + nameof(Source) + "' instead.")]
+        public string Path => Source;
 
 
         public string Template { get; set; }
         public string Destination { get; set; }
         public bool Drafts { get; set; }
-        public string Path => Source;
 
         public override void BindingCompleted()
         {
+            Source = string.IsNullOrWhiteSpace(Source)
+                ? fileSystem.Directory.GetCurrentDirectory()
+                : fileSystem.Path.GetFullPath(Source);
+
             if (string.IsNullOrEmpty(Destination))
             {
                 Destination = "_site";
             }
             if (!fileSystem.Path.IsPathRooted(Destination))
             {
-                Destination = fileSystem.Path.Combine(Path, Destination);
+                Destination = fileSystem.Path.Combine(Source, Destination);
             }
         }
 
diff --git a/src/Pretzel/Commands/ImportCommand.cs b/src/Pretzel/Commands/ImportCommand.cs
index 74baeb46c..ecbfd5a20 100644
--- a/src/Pretzel/Commands/ImportCommand.cs
+++ b/src/Pretzel/Commands/ImportCommand.cs
@@ -16,7 +16,7 @@ namespace Pretzel.Commands
     [Export]
     [Shared]
     [CommandArguments(CommandName = BuiltInCommands.Import)]
-    public class ImportParameters : BParameters
+    public class ImportParameters : BaseParameters
     {
         protected override void WithOptions(List<Option> options)
         {
diff --git a/src/Pretzel/Program.cs b/src/Pretzel/Program.cs
index 7ef721fd4..cc8300fd4 100644
--- a/src/Pretzel/Program.cs
+++ b/src/Pretzel/Program.cs
@@ -73,18 +73,16 @@ private static async Task<int> Main(string[] args)
                         ? firstArgument
                         : fileSystem.Path.Combine(fileSystem.Directory.GetCurrentDirectory(), firstArgument);
 
+                    path = string.IsNullOrWhiteSpace(path)
+                        ? fileSystem.Directory.GetCurrentDirectory()
+                        : fileSystem.Path.GetFullPath(path);
+
                     arguments[1] = "-s";
                     arguments.Insert(2, path);
                     args = arguments.ToArray();
                 }
-
-                Path = string.IsNullOrWhiteSpace(Path)
-                    ? fileSystem.Directory.GetCurrentDirectory()
-                    : fileSystem.Path.GetFullPath(Path);
-
-                Console.WriteLine(Path);
             }
-            
+
 
             foreach (var option in globalOptions)
             {
@@ -144,7 +142,7 @@ private async Task<int> Run(IEnumerable<Option> globalOptions, string[] args)
                 {
                     CommandCollection.RootCommand.AddOption(option);
 
-                    foreach(var command in CommandCollection.RootCommand.OfType<Command>())
+                    foreach (var command in CommandCollection.RootCommand.OfType<Command>())
                     {
                         command.AddOption(option);
                     }
diff --git a/src/Pretzel/Properties/launchSettings.json b/src/Pretzel/Properties/launchSettings.json
index 2d1e8f010..267f0b568 100644
--- a/src/Pretzel/Properties/launchSettings.json
+++ b/src/Pretzel/Properties/launchSettings.json
@@ -2,8 +2,8 @@
   "profiles": {
     "Pretzel": {
       "commandName": "Project",
-      "commandLineArgs": "bake c:\\f\\git --virtualdirectory=Foo",
-      "workingDirectory": "c:\\f\\git\\Scissors.Blog"
+      "commandLineArgs": "bake Scissors.Blog",
+      "workingDirectory": "c:\\f\\git"
     }
   }
 }
\ No newline at end of file

From 4d93f5dfa2cc3f8df51011a7e7c2962b16745e28 Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Sat, 21 Sep 2019 18:24:10 +0200
Subject: [PATCH 07/56] fixed: parameter prefixes

---
 src/Pretzel/Commands/CommandCollection.cs |  5 +---
 src/Pretzel/Commands/HungryCommand.cs     |  1 +
 src/Pretzel/Commands/ImportCommand.cs     | 34 ++++++++++-------------
 src/Pretzel/Commands/IngredientCommand.cs |  2 +-
 src/Pretzel/Commands/RecipeCommand.cs     |  4 +--
 src/Pretzel/Commands/TasteCommand.cs      |  4 +--
 6 files changed, 21 insertions(+), 29 deletions(-)

diff --git a/src/Pretzel/Commands/CommandCollection.cs b/src/Pretzel/Commands/CommandCollection.cs
index c47026deb..8ea266b33 100644
--- a/src/Pretzel/Commands/CommandCollection.cs
+++ b/src/Pretzel/Commands/CommandCollection.cs
@@ -62,10 +62,7 @@ public sealed class CommandCollection
 
         [ImportMany]
         public ExportFactory<ICommandParameters, CommandArgumentsAttribute>[] CommandArguments { get; set; }
-
-        [Import]
-        public Lazy<CommandParameters> Parameters { get; set; }
-
+        
         [Export]
         public RootCommand RootCommand { get; set; }
 
diff --git a/src/Pretzel/Commands/HungryCommand.cs b/src/Pretzel/Commands/HungryCommand.cs
index 89621df85..ef2b70309 100644
--- a/src/Pretzel/Commands/HungryCommand.cs
+++ b/src/Pretzel/Commands/HungryCommand.cs
@@ -10,6 +10,7 @@
 namespace Pretzel.Commands
 {
     [Shared]
+    [Export]
     [CommandInfo(CommandName = BuiltInCommands.Hungry, CommandDescription = "use only when hungry")]
     public sealed class HungryCommand : ICommand
     {
diff --git a/src/Pretzel/Commands/ImportCommand.cs b/src/Pretzel/Commands/ImportCommand.cs
index ecbfd5a20..5575c77fc 100644
--- a/src/Pretzel/Commands/ImportCommand.cs
+++ b/src/Pretzel/Commands/ImportCommand.cs
@@ -16,47 +16,46 @@ namespace Pretzel.Commands
     [Export]
     [Shared]
     [CommandArguments(CommandName = BuiltInCommands.Import)]
-    public class ImportParameters : BaseParameters
+    public class ImportParameters : PretzelBaseCommandParameters
     {
+        [ImportingConstructor]
+        public ImportParameters(IFileSystem fileSystem) : base(fileSystem) { }
+
         protected override void WithOptions(List<Option> options)
         {
             options.AddRange(new[]
             {
-                new Option(new [] {"import", "i"}, "The import type")
+                new Option(new [] {"--importtype", "-i"}, "The import type")
                 {
                     Argument = new Argument<string>()
                 },
-                new Option(new [] {"file", "f"}, "Path to import file")
+                new Option(new [] {"--importfile", "-f"}, "Path to import file")
                 {
                     Argument = new Argument<string>()
                 },
             });
         }
+
+        public string ImportType { get; set; }
+
+        public string ImportFile { get; set; }
     }
 
     [Shared]
     [CommandInfo(CommandName = BuiltInCommands.Import, CommandDescription = "import posts from external source")]
     class ImportCommand : ICommand
     {
-        public ICommandHandler CreateCommandHandler()
-        {
-            return CommandHandler.Create<BakeCommandParameters>(x =>
-            {
-
-            });
-        }
-
         readonly static List<string> Importers = new List<string>(new[] { "wordpress", "blogger" });
 
 #pragma warning disable 649
         [Import] public IFileSystem FileSystem { get; set; }
-        [Import] public CommandParameters Parameters { get; set; }
+        [Import] public ImportParameters Parameters { get; set; }
 #pragma warning restore 649
 
         public async Task Execute()
         {
             Tracing.Info("import - import posts from external source");
-            
+
             if (!Importers.Any(e => String.Equals(e, Parameters.ImportType, StringComparison.InvariantCultureIgnoreCase)))
             {
                 Tracing.Info("Requested import type not found: {0}", Parameters.ImportType);
@@ -65,21 +64,16 @@ public async Task Execute()
 
             if (string.Equals("wordpress", Parameters.ImportType, StringComparison.InvariantCultureIgnoreCase))
             {
-                var wordpressImporter = new WordpressImport(FileSystem, Parameters.Path, Parameters.ImportPath);
+                var wordpressImporter = new WordpressImport(FileSystem, Parameters.Path, Parameters.ImportFile);
                 wordpressImporter.Import();
             }
             else if (string.Equals("blogger", Parameters.ImportType, StringComparison.InvariantCultureIgnoreCase))
             {
-                var bloggerImporter = new BloggerImport(FileSystem, Parameters.Path, Parameters.ImportPath);
+                var bloggerImporter = new BloggerImport(FileSystem, Parameters.Path, Parameters.ImportFile);
                 bloggerImporter.Import();
             }
 
             Tracing.Info("Import complete");
         }
-
-        public void WriteHelp(TextWriter writer)
-        {
-            Parameters.WriteOptions(writer, "-i", "-f");
-        }
     }
 }
diff --git a/src/Pretzel/Commands/IngredientCommand.cs b/src/Pretzel/Commands/IngredientCommand.cs
index a7d4a38c1..9c9737050 100644
--- a/src/Pretzel/Commands/IngredientCommand.cs
+++ b/src/Pretzel/Commands/IngredientCommand.cs
@@ -22,7 +22,7 @@ protected override void WithOptions(List<Option> options)
         {
             options.AddRange(new[]
             {
-                new Option(new [] { "newposttitle", "n" }, "The title of the new post (\"New post\" by default")
+                new Option(new [] { "--newposttitle", "-n" }, "The title of the new post (\"New post\" by default")
                 {
                     Argument = new Argument<string>(() => "New post")
                 }
diff --git a/src/Pretzel/Commands/RecipeCommand.cs b/src/Pretzel/Commands/RecipeCommand.cs
index 78c348913..6fb0d9c78 100644
--- a/src/Pretzel/Commands/RecipeCommand.cs
+++ b/src/Pretzel/Commands/RecipeCommand.cs
@@ -23,11 +23,11 @@ protected override void WithOptions(List<Option> options)
         {
             options.AddRange(new[]
             {
-                new Option("withproject", "Includes a layout VS Solution, to give intellisense when editing razor layout files")
+                new Option(new [] { "-p", "--withproject" }, "Includes a layout VS Solution, to give intellisense when editing razor layout files")
                 {
                     Argument = new Argument<bool>()
                 },
-                new Option("wiki", "Creates a wiki instead of a blog (razor template only)")
+                new Option(new [] { "-w", "--wiki"}, "Creates a wiki instead of a blog (razor template only)")
                 {
                     Argument = new Argument<bool>()
                 },
diff --git a/src/Pretzel/Commands/TasteCommand.cs b/src/Pretzel/Commands/TasteCommand.cs
index 60fb6a0af..a4aacb90f 100644
--- a/src/Pretzel/Commands/TasteCommand.cs
+++ b/src/Pretzel/Commands/TasteCommand.cs
@@ -29,11 +29,11 @@ protected override void WithOptions(List<Option> options)
             base.WithOptions(options);
             options.AddRange(new[]
             {
-                new Option(new[] { "port", "p" }, "The port to test the site locally")
+                new Option(new[] { "--port", "-p" }, "The port to test the site locally")
                 {
                     Argument = new Argument<int>(() => 8080)
                 },
-                new Option("nobrowser", "Do not launch a browser (false by default)")
+                new Option("--nobrowser", "Do not launch a browser (false by default)")
                 {
                     Argument = new Argument<bool>(() => false)
                 },

From cb32029ec98c0cd142901b2186b00d8b478a6bb0 Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Sun, 22 Sep 2019 10:33:53 +0200
Subject: [PATCH 08/56] feat: commands are back and running

---
 src/Pretzel.Logic/Configuration.cs            | 28 +++---
 .../Commands/BakeBaseCommandParameters.cs     | 26 ++++++
 src/Pretzel/Commands/BakeCommand.cs           | 89 -------------------
 src/Pretzel/Commands/CommandCollection.cs     | 37 ++++++--
 src/Pretzel/Commands/HungryCommand.cs         |  6 --
 src/Pretzel/Commands/IngredientCommand.cs     |  1 +
 .../Commands/PretzelBaseCommandParameters.cs  | 85 ++++++++++++++++++
 src/Pretzel/Commands/RecipeCommand.cs         |  1 +
 src/Pretzel/Commands/TasteCommand.cs          |  2 +-
 src/Pretzel/Commands/VersionCommand.cs        |  6 +-
 src/Pretzel/Program.cs                        | 17 +---
 src/Pretzel/Properties/launchSettings.json    |  4 +-
 12 files changed, 165 insertions(+), 137 deletions(-)
 create mode 100644 src/Pretzel/Commands/BakeBaseCommandParameters.cs
 create mode 100644 src/Pretzel/Commands/PretzelBaseCommandParameters.cs

diff --git a/src/Pretzel.Logic/Configuration.cs b/src/Pretzel.Logic/Configuration.cs
index ae1c7973b..3beb9f836 100644
--- a/src/Pretzel.Logic/Configuration.cs
+++ b/src/Pretzel.Logic/Configuration.cs
@@ -1,11 +1,17 @@
 using Pretzel.Logic.Commands;
 using Pretzel.Logic.Extensions;
+using System;
 using System.Collections.Generic;
 using System.Composition;
 using System.IO.Abstractions;
 
 namespace Pretzel.Logic
 {
+    public interface IPathProvider
+    {
+        string Path { get; }
+    }
+
     public interface IConfiguration
     {
         object this[string key] { get; }
@@ -17,6 +23,8 @@ public interface IConfiguration
         IDictionary<string, object> ToDictionary();
 
         IDefaultsConfiguration Defaults { get; }
+
+        void ReadFromFile(string path);
     }
 
     [Shared]
@@ -27,14 +35,11 @@ internal sealed class Configuration : IConfiguration
         public const string DefaultPermalink = "date";
 
         private IDictionary<string, object> _config;
-        private IDefaultsConfiguration _defaultsConfiguration;
         private readonly IFileSystem _fileSystem;
-        private readonly string _configFilePath;
-
         public object this[string key] => _config[key];
 
-        public IDefaultsConfiguration Defaults => _defaultsConfiguration;
-
+        public IDefaultsConfiguration Defaults { get; private set; }
+        
         internal Configuration()
         {
             _config = new Dictionary<string, object>();
@@ -42,11 +47,10 @@ internal Configuration()
         }
 
         [ImportingConstructor]
-        public Configuration(IFileSystem fileSystem, [Import("SourcePath")] string sitePath)
+        public Configuration(IFileSystem fileSystem)
             : this()
         {
             _fileSystem = fileSystem;
-            _configFilePath = _fileSystem.Path.Combine(sitePath, ConfigFileName);
         }
 
         private void EnsureDefaults()
@@ -56,16 +60,16 @@ private void EnsureDefaults()
                 _config.Add("permalink", DefaultPermalink);
             }
 
-            _defaultsConfiguration = new DefaultsConfiguration(_config);
+            Defaults = new DefaultsConfiguration(_config);
         }
 
-        [OnImportsSatisfied]
-        internal void ReadFromFile()
+        public void ReadFromFile(string path)
         {
+            var configFilePath = _fileSystem.Path.Combine(path, ConfigFileName);
             _config = new Dictionary<string, object>();
-            if (_fileSystem.File.Exists(_configFilePath))
+            if (_fileSystem.File.Exists(configFilePath))
             {
-                _config = _fileSystem.File.ReadAllText(_configFilePath).ParseYaml();
+                _config = _fileSystem.File.ReadAllText(configFilePath).ParseYaml();
                 EnsureDefaults();
             }
         }
diff --git a/src/Pretzel/Commands/BakeBaseCommandParameters.cs b/src/Pretzel/Commands/BakeBaseCommandParameters.cs
new file mode 100644
index 000000000..82f77561b
--- /dev/null
+++ b/src/Pretzel/Commands/BakeBaseCommandParameters.cs
@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.CommandLine;
+using System.IO.Abstractions;
+using System.Linq;
+
+namespace Pretzel.Commands
+{
+    public abstract class BakeBaseCommandParameters : PretzelBaseCommandParameters
+    {
+        protected BakeBaseCommandParameters(IFileSystem fileSystem) : base(fileSystem) { }
+
+        protected override void WithOptions(List<Option> options)
+        {
+            options.AddRange(new[]
+            {
+                new Option(new [] { "-c", "--cleantarget" }, "Delete the target directory (_site by default)")
+                {
+                    Argument = new Argument<bool>()
+                },
+            });
+        }
+
+        public bool CleanTarget { get; set; }
+    }
+}
diff --git a/src/Pretzel/Commands/BakeCommand.cs b/src/Pretzel/Commands/BakeCommand.cs
index fe11ea66b..4347d597a 100644
--- a/src/Pretzel/Commands/BakeCommand.cs
+++ b/src/Pretzel/Commands/BakeCommand.cs
@@ -26,95 +26,6 @@ public sealed class BakeCommandParameters : BakeBaseCommandParameters
         public BakeCommandParameters(IFileSystem fileSystem) : base(fileSystem) { }
     }
 
-    public abstract class PretzelBaseCommandParameters : BaseParameters
-    {
-        protected readonly IFileSystem fileSystem;
-        protected PretzelBaseCommandParameters(IFileSystem fileSystem)
-        {
-            this.fileSystem = fileSystem;
-        }
-
-        protected override void WithOptions(List<Option> options)
-        {
-            options.AddRange(new[]
-            {
-                new Option(new []{ "-t", "--template" },"The templating engine to use")
-                {
-                    Argument = new Argument<string>()
-                },
-                new Option(new [] { "-d", "--destination" }, "The path to the destination site (default _site)")
-                {
-                    Argument = new Argument<string>(() => "_site")
-                },
-                new Option("--drafts", "Add the posts in the drafts folder")
-                {
-                    Argument = new Argument<bool>()
-                },
-            });
-        }
-        // Default Option that get injected from Program
-        public string Source { get; set; }
-        // Default Option that get injected from Program
-        public bool Debug { get; set; }
-        // Default Option that get injected from Program
-        public bool Safe { get; set; }
-        [Obsolete("Use '" + nameof(Source) + "' instead.")]
-        public string Path => Source;
-
-
-        public string Template { get; set; }
-        public string Destination { get; set; }
-        public bool Drafts { get; set; }
-
-        public override void BindingCompleted()
-        {
-            Source = string.IsNullOrWhiteSpace(Source)
-                ? fileSystem.Directory.GetCurrentDirectory()
-                : fileSystem.Path.GetFullPath(Source);
-
-            if (string.IsNullOrEmpty(Destination))
-            {
-                Destination = "_site";
-            }
-            if (!fileSystem.Path.IsPathRooted(Destination))
-            {
-                Destination = fileSystem.Path.Combine(Source, Destination);
-            }
-        }
-
-        public void DetectFromDirectory(IDictionary<string, ISiteEngine> engines, SiteContext context)
-        {
-            foreach (var engine in engines)
-            {
-                if (!engine.Value.CanProcess(context)) continue;
-                Tracing.Info("Recommended engine for directory: '{0}'", engine.Key);
-                Template = engine.Key;
-                return;
-            }
-
-            if (Template == null)
-                Template = "liquid";
-        }
-    }
-
-    public abstract class BakeBaseCommandParameters : PretzelBaseCommandParameters
-    {
-        protected BakeBaseCommandParameters(IFileSystem fileSystem) : base(fileSystem) { }
-
-        protected override void WithOptions(List<Option> options)
-        {
-            options.AddRange(new[]
-            {
-                new Option(new [] { "-c", "--cleantarget" }, "Delete the target directory (_site by default)")
-                {
-                    Argument = new Argument<bool>()
-                },
-            });
-        }
-
-        public bool CleanTarget { get; set; }
-    }
-
     [Shared]
     [CommandInfo(CommandName = BuiltInCommands.Bake, CommandDescription = "transforming content into a website")]
     public sealed class BakeCommand : ICommand
diff --git a/src/Pretzel/Commands/CommandCollection.cs b/src/Pretzel/Commands/CommandCollection.cs
index 8ea266b33..add0b5131 100644
--- a/src/Pretzel/Commands/CommandCollection.cs
+++ b/src/Pretzel/Commands/CommandCollection.cs
@@ -10,18 +10,21 @@
 using Pretzel.Logic.Extensibility;
 using System.Threading.Tasks;
 using System.Reflection;
+using Pretzel.Logic;
 
 namespace Pretzel.Commands
 {
 
     public class PretzelCommandHandler : ICommandHandler
     {
-        private ICommandParameters commandParameters;
-        private ExportFactory<ICommand, CommandInfoAttribute> command;
+        private readonly ICommandParameters commandParameters;
+        private readonly ExportFactory<ICommand, CommandInfoAttribute> command;
+        private readonly IConfiguration configuration;
 
-        public PretzelCommandHandler(ICommandParameters commandArguments, ExportFactory<ICommand, CommandInfoAttribute> command)
+        public PretzelCommandHandler(IConfiguration configuration, ICommandParameters commandParameters, ExportFactory<ICommand, CommandInfoAttribute> command)
         {
-            this.commandParameters = commandArguments;
+            this.configuration = configuration;
+            this.commandParameters = commandParameters;
             this.command = command;
         }
 
@@ -29,10 +32,18 @@ public async Task<int> InvokeAsync(InvocationContext context)
         {
             var bindingContext = context.BindingContext;
 
-            new ModelBinder(commandParameters.GetType())
-                .UpdateInstance(commandParameters, bindingContext);
+            if (commandParameters != null)
+            {
+                new ModelBinder(commandParameters.GetType())
+                   .UpdateInstance(commandParameters, bindingContext);
+
+                commandParameters.BindingCompleted();
+            }
 
-            commandParameters.BindingCompleted();
+            if (commandParameters is IPathProvider pathProvider)
+            {
+                configuration.ReadFromFile(pathProvider.Path);
+            }
 
             if (commandParameters is ICommandParametersExtendable commandParametersExtendable)
             {
@@ -62,10 +73,13 @@ public sealed class CommandCollection
 
         [ImportMany]
         public ExportFactory<ICommandParameters, CommandArgumentsAttribute>[] CommandArguments { get; set; }
-        
+
         [Export]
         public RootCommand RootCommand { get; set; }
 
+        [Import]
+        public IConfiguration Configuration { get; set; }
+
         [OnImportsSatisfied]
         public void OnImportsSatisfied()
         {
@@ -78,12 +92,17 @@ public void OnImportsSatisfied()
                 foreach (var commandArgumentsExport in CommandArguments.Where(a => a.Metadata.CommandName == command.Metadata.CommandName))
                 {
                     var commandArguments = commandArgumentsExport.CreateExport().Value;
+
                     foreach (var option in commandArguments.Options)
                     {
                         subCommand.AddOption(option);
                     }
 
-                    subCommand.Handler = new PretzelCommandHandler(commandArguments, command);
+                    subCommand.Handler = new PretzelCommandHandler(Configuration, commandArguments, command);
+                }
+                if(subCommand.Handler == null)
+                {
+                    subCommand.Handler = new PretzelCommandHandler(Configuration, null, command);
                 }
 
                 RootCommand.AddCommand(subCommand);
diff --git a/src/Pretzel/Commands/HungryCommand.cs b/src/Pretzel/Commands/HungryCommand.cs
index ef2b70309..3ae892d0e 100644
--- a/src/Pretzel/Commands/HungryCommand.cs
+++ b/src/Pretzel/Commands/HungryCommand.cs
@@ -57,11 +57,5 @@ public async Task Execute()
         {
             Tracing.Info(recipe);
         }
-
-        public void WriteHelp(TextWriter writer)
-        {
-            writer.Write("   For use only when hungry\r\n");
-        }
-
     }
 }
diff --git a/src/Pretzel/Commands/IngredientCommand.cs b/src/Pretzel/Commands/IngredientCommand.cs
index 9c9737050..b57c9afff 100644
--- a/src/Pretzel/Commands/IngredientCommand.cs
+++ b/src/Pretzel/Commands/IngredientCommand.cs
@@ -16,6 +16,7 @@ namespace Pretzel.Commands
     [CommandArguments(CommandName = BuiltInCommands.Ingredient)]
     public class IngredientCommandParameters : PretzelBaseCommandParameters
     {
+        [ImportingConstructor]
         public IngredientCommandParameters(IFileSystem fileSystem) : base(fileSystem) { }
 
         protected override void WithOptions(List<Option> options)
diff --git a/src/Pretzel/Commands/PretzelBaseCommandParameters.cs b/src/Pretzel/Commands/PretzelBaseCommandParameters.cs
new file mode 100644
index 000000000..65af2a686
--- /dev/null
+++ b/src/Pretzel/Commands/PretzelBaseCommandParameters.cs
@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using System.CommandLine;
+using System.Composition;
+using System.IO.Abstractions;
+using System.Linq;
+using Pretzel.Logic;
+using Pretzel.Logic.Commands;
+using Pretzel.Logic.Extensions;
+using Pretzel.Logic.Templating;
+using Pretzel.Logic.Templating.Context;
+
+namespace Pretzel.Commands
+{
+    public abstract class PretzelBaseCommandParameters : BaseParameters, IPathProvider
+    {
+        protected readonly IFileSystem fileSystem;
+
+        protected PretzelBaseCommandParameters(IFileSystem fileSystem)
+        {
+            this.fileSystem = fileSystem;
+        }
+
+        protected override void WithOptions(List<Option> options)
+        {
+            options.AddRange(new[]
+            {
+                new Option(new []{ "-t", "--template" },"The templating engine to use")
+                {
+                    Argument = new Argument<string>()
+                },
+                new Option(new [] { "-d", "--destination" }, "The path to the destination site (default _site)")
+                {
+                    Argument = new Argument<string>(() => "_site")
+                },
+                new Option("--drafts", "Add the posts in the drafts folder")
+                {
+                    Argument = new Argument<bool>()
+                },
+            });
+        }
+        // Default Option that get injected from Program
+        public string Source { get; set; }
+        // Default Option that get injected from Program
+        public bool Debug { get; set; }
+        // Default Option that get injected from Program
+        public bool Safe { get; set; }
+        [Obsolete("Use '" + nameof(Source) + "' instead.")]
+        public string Path => Source;
+
+        public string Template { get; set; }
+        public string Destination { get; set; }
+        public bool Drafts { get; set; }
+
+        public override void BindingCompleted()
+        {
+            Source = string.IsNullOrWhiteSpace(Source)
+                ? fileSystem.Directory.GetCurrentDirectory()
+                : fileSystem.Path.GetFullPath(Source);
+
+            if (string.IsNullOrEmpty(Destination))
+            {
+                Destination = "_site";
+            }
+            if (!fileSystem.Path.IsPathRooted(Destination))
+            {
+                Destination = fileSystem.Path.Combine(Source, Destination);
+            }
+        }
+
+        public void DetectFromDirectory(IDictionary<string, ISiteEngine> engines, SiteContext context)
+        {
+            foreach (var engine in engines)
+            {
+                if (!engine.Value.CanProcess(context)) continue;
+                Tracing.Info("Recommended engine for directory: '{0}'", engine.Key);
+                Template = engine.Key;
+                return;
+            }
+
+            if (Template == null)
+                Template = "liquid";
+        }
+    }
+}
diff --git a/src/Pretzel/Commands/RecipeCommand.cs b/src/Pretzel/Commands/RecipeCommand.cs
index 6fb0d9c78..5a52cbd9e 100644
--- a/src/Pretzel/Commands/RecipeCommand.cs
+++ b/src/Pretzel/Commands/RecipeCommand.cs
@@ -17,6 +17,7 @@ namespace Pretzel.Commands
     [CommandArguments(CommandName = BuiltInCommands.Create)]
     public class RecipeCommandParameters : PretzelBaseCommandParameters
     {
+        [ImportingConstructor]
         public RecipeCommandParameters(IFileSystem fileSystem) : base(fileSystem) { }
 
         protected override void WithOptions(List<Option> options)
diff --git a/src/Pretzel/Commands/TasteCommand.cs b/src/Pretzel/Commands/TasteCommand.cs
index a4aacb90f..cc6553b80 100644
--- a/src/Pretzel/Commands/TasteCommand.cs
+++ b/src/Pretzel/Commands/TasteCommand.cs
@@ -164,7 +164,7 @@ private void WatcherOnChanged(string file)
 
             Tracing.Info("File change: {0}", file);
 
-            ((Configuration)Configuration).ReadFromFile();
+            Configuration.ReadFromFile(Parameters.Path);
 
             var context = Generator.BuildContext(Parameters.Path, Parameters.Destination, Parameters.Drafts);
             if (Parameters.CleanTarget && FileSystem.Directory.Exists(context.OutputFolder))
diff --git a/src/Pretzel/Commands/VersionCommand.cs b/src/Pretzel/Commands/VersionCommand.cs
index d48aca80b..5981fccd9 100644
--- a/src/Pretzel/Commands/VersionCommand.cs
+++ b/src/Pretzel/Commands/VersionCommand.cs
@@ -1,10 +1,8 @@
-using Pretzel.Logic.Commands;
-using Pretzel.Logic.Extensions;
-using System.Collections.Generic;
-using System.CommandLine.Invocation;
 using System.Composition;
 using System.Reflection;
 using System.Threading.Tasks;
+using Pretzel.Logic.Commands;
+using Pretzel.Logic.Extensions;
 
 namespace Pretzel.Commands
 {
diff --git a/src/Pretzel/Program.cs b/src/Pretzel/Program.cs
index cc8300fd4..afdf207d4 100644
--- a/src/Pretzel/Program.cs
+++ b/src/Pretzel/Program.cs
@@ -25,20 +25,10 @@ internal class Program
         [Export]
         public IFileSystem FileSystem { get; set; } = new FileSystem();
 
-        //[Export("SourcePath")]
-        //public string SourcePath { get; }
-
-        //public Program()
-        //{
-        //    SourcePath = sourcePath;
-        //}
-
-        //private static string sourcePath;
-
-
-
         private static async Task<int> Main(string[] args)
         {
+            var fileSystem = new FileSystem();
+
             var rootCommand = new RootCommand
             {
                 TreatUnmatchedTokensAsErrors = false
@@ -56,13 +46,12 @@ private static async Task<int> Main(string[] args)
                 },
                 new Option(new[] { "-s", "--source" }, "The path to the source site (default current directory)")
                 {
-                    Argument = new Argument<string>()
+                    Argument = new Argument<string>(() => fileSystem.Directory.GetCurrentDirectory())
                 }
             };
 
             if (args.Length > 1 && !args.Contains("-s") && !args.Contains("--source"))
             {
-                var fileSystem = new FileSystem();
                 var firstArgument = args[1];
 
                 // take the first argument after the command
diff --git a/src/Pretzel/Properties/launchSettings.json b/src/Pretzel/Properties/launchSettings.json
index 267f0b568..1691ad031 100644
--- a/src/Pretzel/Properties/launchSettings.json
+++ b/src/Pretzel/Properties/launchSettings.json
@@ -2,8 +2,8 @@
   "profiles": {
     "Pretzel": {
       "commandName": "Project",
-      "commandLineArgs": "bake Scissors.Blog",
-      "workingDirectory": "c:\\f\\git"
+      "commandLineArgs": "hungry",
+      "workingDirectory": "c:\\f\\git\\Scissors.Blog"
     }
   }
 }
\ No newline at end of file

From 00596b52dfaa0218e51de1fd1bf4f94d38aecd28 Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Sun, 22 Sep 2019 10:40:40 +0200
Subject: [PATCH 09/56] refactor: namespace cleanup

---
 .../Commands/BakeBaseCommandParameters.cs     |  2 +-
 src/Pretzel/Commands/BakeCommand.cs           | 16 ++---
 src/Pretzel/Commands/CommandCollection.cs     | 59 +-----------------
 src/Pretzel/Commands/HungryCommand.cs         |  3 -
 src/Pretzel/Commands/ImportCommand.cs         | 10 ++--
 src/Pretzel/Commands/IngredientCommand.cs     |  8 +--
 .../Commands/PretzelBaseCommandParameters.cs  |  9 ++-
 src/Pretzel/Commands/PretzelCommandHandler.cs | 60 +++++++++++++++++++
 src/Pretzel/Commands/RecipeCommand.cs         |  4 --
 src/Pretzel/Commands/TasteCommand.cs          | 17 ++----
 src/Pretzel/Properties/launchSettings.json    |  2 +-
 11 files changed, 87 insertions(+), 103 deletions(-)
 create mode 100644 src/Pretzel/Commands/PretzelCommandHandler.cs

diff --git a/src/Pretzel/Commands/BakeBaseCommandParameters.cs b/src/Pretzel/Commands/BakeBaseCommandParameters.cs
index 82f77561b..5971bfbb8 100644
--- a/src/Pretzel/Commands/BakeBaseCommandParameters.cs
+++ b/src/Pretzel/Commands/BakeBaseCommandParameters.cs
@@ -1,8 +1,8 @@
 using System;
+using System.Linq;
 using System.Collections.Generic;
 using System.CommandLine;
 using System.IO.Abstractions;
-using System.Linq;
 
 namespace Pretzel.Commands
 {
diff --git a/src/Pretzel/Commands/BakeCommand.cs b/src/Pretzel/Commands/BakeCommand.cs
index 4347d597a..2ad4377be 100644
--- a/src/Pretzel/Commands/BakeCommand.cs
+++ b/src/Pretzel/Commands/BakeCommand.cs
@@ -30,25 +30,21 @@ public BakeCommandParameters(IFileSystem fileSystem) : base(fileSystem) { }
     [CommandInfo(CommandName = BuiltInCommands.Bake, CommandDescription = "transforming content into a website")]
     public sealed class BakeCommand : ICommand
     {
-#pragma warning disable 649
-
         [Import]
-        public TemplateEngineCollection templateEngines { get; set; }
+        public TemplateEngineCollection TemplateEngines { get; set; }
 
         [Import]
         public SiteContextGenerator Generator { get; set; }
 
         [ImportMany]
-        public IEnumerable<ITransform> transforms { get; set; }
+        public IEnumerable<ITransform> Transforms { get; set; }
 
         [Import]
         public BakeCommandParameters Parameters { get; set; }
 
         [Import]
         public IFileSystem FileSystem { get; set; }
-
-#pragma warning restore 649
-
+        
         public async Task Execute()
         {
             Tracing.Info("bake - transforming content into a website");
@@ -62,17 +58,17 @@ public async Task Execute()
 
             if (string.IsNullOrWhiteSpace(Parameters.Template))
             {
-                Parameters.DetectFromDirectory(templateEngines.Engines, siteContext);
+                Parameters.DetectFromDirectory(TemplateEngines.Engines, siteContext);
             }
 
-            var engine = templateEngines[Parameters.Template];
+            var engine = TemplateEngines[Parameters.Template];
             if (engine != null)
             {
                 var watch = new Stopwatch();
                 watch.Start();
                 engine.Initialize();
                 engine.Process(siteContext);
-                foreach (var t in transforms)
+                foreach (var t in Transforms)
                     t.Transform(siteContext);
 
                 engine.CompressSitemap(siteContext, FileSystem);
diff --git a/src/Pretzel/Commands/CommandCollection.cs b/src/Pretzel/Commands/CommandCollection.cs
index add0b5131..7593bc71d 100644
--- a/src/Pretzel/Commands/CommandCollection.cs
+++ b/src/Pretzel/Commands/CommandCollection.cs
@@ -1,69 +1,13 @@
 using System;
-using System.Collections.Generic;
 using System.CommandLine;
-using System.CommandLine.Invocation;
-using System.CommandLine.Binding;
 using System.Composition;
-using System.Dynamic;
 using System.Linq;
-using Pretzel.Logic.Commands;
-using Pretzel.Logic.Extensibility;
-using System.Threading.Tasks;
-using System.Reflection;
 using Pretzel.Logic;
+using Pretzel.Logic.Commands;
 
 namespace Pretzel.Commands
 {
 
-    public class PretzelCommandHandler : ICommandHandler
-    {
-        private readonly ICommandParameters commandParameters;
-        private readonly ExportFactory<ICommand, CommandInfoAttribute> command;
-        private readonly IConfiguration configuration;
-
-        public PretzelCommandHandler(IConfiguration configuration, ICommandParameters commandParameters, ExportFactory<ICommand, CommandInfoAttribute> command)
-        {
-            this.configuration = configuration;
-            this.commandParameters = commandParameters;
-            this.command = command;
-        }
-
-        public async Task<int> InvokeAsync(InvocationContext context)
-        {
-            var bindingContext = context.BindingContext;
-
-            if (commandParameters != null)
-            {
-                new ModelBinder(commandParameters.GetType())
-                   .UpdateInstance(commandParameters, bindingContext);
-
-                commandParameters.BindingCompleted();
-            }
-
-            if (commandParameters is IPathProvider pathProvider)
-            {
-                configuration.ReadFromFile(pathProvider.Path);
-            }
-
-            if (commandParameters is ICommandParametersExtendable commandParametersExtendable)
-            {
-                foreach (var factory in commandParametersExtendable.GetCommandExtentions())
-                {
-                    var extentedArguments = factory.CreateExport().Value;
-
-                    new ModelBinder(extentedArguments.GetType())
-                        .UpdateInstance(extentedArguments, bindingContext);
-
-                    extentedArguments.BindingCompleted();
-                }
-            }
-
-            await command.CreateExport().Value.Execute();
-
-            return 0;
-        }
-    }
-
     [Export]
     [Shared]
     public sealed class CommandCollection
@@ -100,6 +44,7 @@ public void OnImportsSatisfied()
 
                     subCommand.Handler = new PretzelCommandHandler(Configuration, commandArguments, command);
                 }
+
                 if(subCommand.Handler == null)
                 {
                     subCommand.Handler = new PretzelCommandHandler(Configuration, null, command);
diff --git a/src/Pretzel/Commands/HungryCommand.cs b/src/Pretzel/Commands/HungryCommand.cs
index 3ae892d0e..7deabbf95 100644
--- a/src/Pretzel/Commands/HungryCommand.cs
+++ b/src/Pretzel/Commands/HungryCommand.cs
@@ -1,8 +1,5 @@
 using System;
-using System.Collections.Generic;
-using System.CommandLine.Invocation;
 using System.Composition;
-using System.IO;
 using System.Threading.Tasks;
 using Pretzel.Logic.Commands;
 using Pretzel.Logic.Extensions;
diff --git a/src/Pretzel/Commands/ImportCommand.cs b/src/Pretzel/Commands/ImportCommand.cs
index 5575c77fc..4c8bac4ef 100644
--- a/src/Pretzel/Commands/ImportCommand.cs
+++ b/src/Pretzel/Commands/ImportCommand.cs
@@ -1,15 +1,13 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.IO;
+using System.CommandLine;
+using System.Composition;
 using System.IO.Abstractions;
+using System.Linq;
+using System.Threading.Tasks;
 using Pretzel.Logic.Commands;
 using Pretzel.Logic.Extensions;
 using Pretzel.Logic.Import;
-using System.Composition;
-using System.CommandLine;
-using System.CommandLine.Invocation;
-using System.Threading.Tasks;
 
 namespace Pretzel.Commands
 {
diff --git a/src/Pretzel/Commands/IngredientCommand.cs b/src/Pretzel/Commands/IngredientCommand.cs
index b57c9afff..1774a8b95 100644
--- a/src/Pretzel/Commands/IngredientCommand.cs
+++ b/src/Pretzel/Commands/IngredientCommand.cs
@@ -1,13 +1,11 @@
-using Pretzel.Logic.Commands;
-using Pretzel.Logic.Extensions;
-using Pretzel.Logic.Recipe;
 using System.Collections.Generic;
 using System.CommandLine;
-using System.CommandLine.Invocation;
 using System.Composition;
-using System.IO;
 using System.IO.Abstractions;
 using System.Threading.Tasks;
+using Pretzel.Logic.Commands;
+using Pretzel.Logic.Extensions;
+using Pretzel.Logic.Recipe;
 
 namespace Pretzel.Commands
 {
diff --git a/src/Pretzel/Commands/PretzelBaseCommandParameters.cs b/src/Pretzel/Commands/PretzelBaseCommandParameters.cs
index 65af2a686..70de92565 100644
--- a/src/Pretzel/Commands/PretzelBaseCommandParameters.cs
+++ b/src/Pretzel/Commands/PretzelBaseCommandParameters.cs
@@ -1,9 +1,8 @@
 using System;
+using System.Linq;
 using System.Collections.Generic;
 using System.CommandLine;
-using System.Composition;
 using System.IO.Abstractions;
-using System.Linq;
 using Pretzel.Logic;
 using Pretzel.Logic.Commands;
 using Pretzel.Logic.Extensions;
@@ -39,11 +38,11 @@ protected override void WithOptions(List<Option> options)
                 },
             });
         }
-        // Default Option that get injected from Program
+        // Default Option that get's injected from Program
         public string Source { get; set; }
-        // Default Option that get injected from Program
+        // Default Option that get's injected from Program
         public bool Debug { get; set; }
-        // Default Option that get injected from Program
+        // Default Option that get's injected from Program
         public bool Safe { get; set; }
         [Obsolete("Use '" + nameof(Source) + "' instead.")]
         public string Path => Source;
diff --git a/src/Pretzel/Commands/PretzelCommandHandler.cs b/src/Pretzel/Commands/PretzelCommandHandler.cs
new file mode 100644
index 000000000..38a7a48ee
--- /dev/null
+++ b/src/Pretzel/Commands/PretzelCommandHandler.cs
@@ -0,0 +1,60 @@
+using System;
+using System.Linq;
+using System.CommandLine.Binding;
+using System.CommandLine.Invocation;
+using System.Composition;
+using System.Threading.Tasks;
+using Pretzel.Logic;
+using Pretzel.Logic.Commands;
+
+namespace Pretzel.Commands
+{
+    public class PretzelCommandHandler : ICommandHandler
+    {
+        private readonly ICommandParameters commandParameters;
+        private readonly ExportFactory<ICommand, CommandInfoAttribute> command;
+        private readonly IConfiguration configuration;
+
+        public PretzelCommandHandler(IConfiguration configuration, ICommandParameters commandParameters, ExportFactory<ICommand, CommandInfoAttribute> command)
+        {
+            this.configuration = configuration;
+            this.commandParameters = commandParameters;
+            this.command = command;
+        }
+
+        public async Task<int> InvokeAsync(InvocationContext context)
+        {
+            var bindingContext = context.BindingContext;
+
+            if (commandParameters != null)
+            {
+                new ModelBinder(commandParameters.GetType())
+                   .UpdateInstance(commandParameters, bindingContext);
+
+                commandParameters.BindingCompleted();
+            }
+
+            if (commandParameters is IPathProvider pathProvider)
+            {
+                configuration.ReadFromFile(pathProvider.Path);
+            }
+
+            if (commandParameters is ICommandParametersExtendable commandParametersExtendable)
+            {
+                foreach (var factory in commandParametersExtendable.GetCommandExtentions())
+                {
+                    var extentedArguments = factory.CreateExport().Value;
+
+                    new ModelBinder(extentedArguments.GetType())
+                        .UpdateInstance(extentedArguments, bindingContext);
+
+                    extentedArguments.BindingCompleted();
+                }
+            }
+
+            await command.CreateExport().Value.Execute();
+
+            return 0;
+        }
+    }
+}
diff --git a/src/Pretzel/Commands/RecipeCommand.cs b/src/Pretzel/Commands/RecipeCommand.cs
index 5a52cbd9e..7f94cb091 100644
--- a/src/Pretzel/Commands/RecipeCommand.cs
+++ b/src/Pretzel/Commands/RecipeCommand.cs
@@ -45,8 +45,6 @@ public sealed class RecipeCommand : ICommand
     {
         private static readonly List<string> TemplateEngines = new List<string>(new[] { "Liquid", "Razor" });
 
-#pragma warning disable 649
-
         [Import]
         public IFileSystem FileSystem { get; set; }
 
@@ -56,8 +54,6 @@ public sealed class RecipeCommand : ICommand
         [ImportMany]
         public IEnumerable<IAdditionalIngredient> AdditionalIngredients { get; set; }
 
-#pragma warning restore 649
-
         public async Task Execute()
         {
             Tracing.Info("create - configure a new site");
diff --git a/src/Pretzel/Commands/TasteCommand.cs b/src/Pretzel/Commands/TasteCommand.cs
index cc6553b80..206cb066f 100644
--- a/src/Pretzel/Commands/TasteCommand.cs
+++ b/src/Pretzel/Commands/TasteCommand.cs
@@ -1,3 +1,9 @@
+using System;
+using System.Collections.Generic;
+using System.CommandLine;
+using System.Composition;
+using System.IO.Abstractions;
+using System.Threading.Tasks;
 using Pretzel.Logic;
 using Pretzel.Logic.Commands;
 using Pretzel.Logic.Extensibility;
@@ -5,14 +11,6 @@
 using Pretzel.Logic.Templating;
 using Pretzel.Logic.Templating.Context;
 using Pretzel.Modules;
-using System;
-using System.Collections.Generic;
-using System.CommandLine;
-using System.CommandLine.Invocation;
-using System.Composition;
-using System.IO;
-using System.IO.Abstractions;
-using System.Threading.Tasks;
 
 namespace Pretzel.Commands
 {
@@ -52,7 +50,6 @@ protected override void WithOptions(List<Option> options)
     public sealed class TasteCommand : ICommand
     {
         private ISiteEngine engine;
-#pragma warning disable 649
 
         [Import]
         public TemplateEngineCollection TemplateEngines { get; set; }
@@ -72,8 +69,6 @@ public sealed class TasteCommand : ICommand
         [Import]
         public IConfiguration Configuration { get; set; }
 
-#pragma warning restore 649
-
         public async Task Execute()
         {
             Tracing.Info("taste - testing a site locally");
diff --git a/src/Pretzel/Properties/launchSettings.json b/src/Pretzel/Properties/launchSettings.json
index 1691ad031..74bf7ea00 100644
--- a/src/Pretzel/Properties/launchSettings.json
+++ b/src/Pretzel/Properties/launchSettings.json
@@ -2,7 +2,7 @@
   "profiles": {
     "Pretzel": {
       "commandName": "Project",
-      "commandLineArgs": "hungry",
+      "commandLineArgs": "taste",
       "workingDirectory": "c:\\f\\git\\Scissors.Blog"
     }
   }

From 395fb170110c174187f7cd876531cbbbd5de1df5 Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Sun, 22 Sep 2019 10:56:16 +0200
Subject: [PATCH 10/56] test: removed noptions

---
 .../VirtualDirectoryTransform.cs              |  13 --
 src/Pretzel.Tests/ConfigurationMock.cs        |   6 +-
 src/Pretzel.Tests/ConfigurationTests.cs       |   4 +-
 .../Extensions/AzureHostSupportTest.cs        |  23 ++-
 .../VirtualDirectorySupportTests.cs           | 161 +++++++++---------
 src/Pretzel.Tests/Pretzel.Tests.csproj        |  10 +-
 .../Context/SiteContextGeneratorTests.cs      |   8 +-
 7 files changed, 110 insertions(+), 115 deletions(-)
 delete mode 100644 src/Pretzel.Logic/VirtualDirectoryTransform.cs

diff --git a/src/Pretzel.Logic/VirtualDirectoryTransform.cs b/src/Pretzel.Logic/VirtualDirectoryTransform.cs
deleted file mode 100644
index e085d2c34..000000000
--- a/src/Pretzel.Logic/VirtualDirectoryTransform.cs
+++ /dev/null
@@ -1,13 +0,0 @@
-using Pretzel.Logic.Minification;
-using Pretzel.Logic.Templating.Context;
-
-namespace Pretzel.Logic
-{
-    public class VirtualDirectoryTransform : ITransform
-    {
-        public void Transform(SiteContext siteContext)
-        {
-            
-        }
-    }
-}
\ No newline at end of file
diff --git a/src/Pretzel.Tests/ConfigurationMock.cs b/src/Pretzel.Tests/ConfigurationMock.cs
index 81225bc89..08bdc90e4 100644
--- a/src/Pretzel.Tests/ConfigurationMock.cs
+++ b/src/Pretzel.Tests/ConfigurationMock.cs
@@ -1,4 +1,4 @@
-using Pretzel.Logic;
+using Pretzel.Logic;
 using Pretzel.Logic.Extensions;
 using System.Collections.Generic;
 
@@ -65,6 +65,10 @@ public IDefaultsConfiguration Defaults
         {
             get { return new DefaultsConfigurationMock(); }
         }
+
+        public void ReadFromFile(string path)
+        {
+        }
     }
 
     internal class DefaultsConfigurationMock : IDefaultsConfiguration
diff --git a/src/Pretzel.Tests/ConfigurationTests.cs b/src/Pretzel.Tests/ConfigurationTests.cs
index 28d9de9fd..2746f7026 100644
--- a/src/Pretzel.Tests/ConfigurationTests.cs
+++ b/src/Pretzel.Tests/ConfigurationTests.cs
@@ -41,8 +41,8 @@ public ConfigurationTests()
             var fileSystem = new MockFileSystem();
             fileSystem.AddFile(@"C:\WebSite\_config.yml", new MockFileData(SampleConfig));
 
-            _sut = new Configuration(fileSystem, @"C:\WebSite");
-            _sut.ReadFromFile();
+            _sut = new Configuration(fileSystem);
+            _sut.ReadFromFile(@"C:\WebSite");
         }
 
         [Fact]
diff --git a/src/Pretzel.Tests/Extensibility/Extensions/AzureHostSupportTest.cs b/src/Pretzel.Tests/Extensibility/Extensions/AzureHostSupportTest.cs
index aaedd2d71..139d84875 100644
--- a/src/Pretzel.Tests/Extensibility/Extensions/AzureHostSupportTest.cs
+++ b/src/Pretzel.Tests/Extensibility/Extensions/AzureHostSupportTest.cs
@@ -1,4 +1,3 @@
-using NDesk.Options;
 using Pretzel.Logic.Extensibility.Extensions;
 using System.IO.Abstractions.TestingHelpers;
 using System.Linq;
@@ -49,15 +48,15 @@ public void GetArguments_Default_Should_Return_Empty_Array(string command)
         [Fact]
         public void UpdateOptions_Should_Add_Azure()
         {
-            var optionSet = new OptionSet();
+            //var optionSet = new OptionSet();
 
-            // act
-            azureHostSupport.UpdateOptions(optionSet);
+            //// act
+            //azureHostSupport.UpdateOptions(optionSet);
 
             // assert
-            Assert.Single(optionSet);
-            Assert.Equal("azure", optionSet[0].Prototype);
-            Assert.NotNull(optionSet[0].Description);
+            //Assert.Single(optionSet);
+            //Assert.Equal("azure", optionSet[0].Prototype);
+            //Assert.NotNull(optionSet[0].Description);
         }
 
         [Fact]
@@ -65,8 +64,8 @@ public void MixIn_AzureNotActivated_NothingHappens()
         {
             // arrange
             fileSystem.AddDirectory(@"c:\website");
-            var optionSet = new OptionSet();
-            azureHostSupport.UpdateOptions(optionSet);
+            //var optionSet = new OptionSet();
+            //azureHostSupport.UpdateOptions(optionSet);
 
             // act
             azureHostSupport.MixIn(@"c:\website");
@@ -86,9 +85,9 @@ public void MixIn_AzureActivated_AllFilesAreIncluded()
             assembly.EntryAssemblyLocation = @"c:\tools\Pretzel.exe";
             fileSystem.AddFile(@"c:\tools\Pretzel.exe", MockFileData.NullObject);
 
-            var optionSet = new OptionSet();
-            azureHostSupport.UpdateOptions(optionSet);
-            optionSet.Parse(new[] { "--azure" });
+            //var optionSet = new OptionSet();
+            //azureHostSupport.UpdateOptions(optionSet);
+            //optionSet.Parse(new[] { "--azure" });
 
             // act
             azureHostSupport.MixIn(@"c:\website");
diff --git a/src/Pretzel.Tests/Extensibility/Extensions/VirtualDirectorySupportTests.cs b/src/Pretzel.Tests/Extensibility/Extensions/VirtualDirectorySupportTests.cs
index 5486c3f7a..b7ba201fb 100644
--- a/src/Pretzel.Tests/Extensibility/Extensions/VirtualDirectorySupportTests.cs
+++ b/src/Pretzel.Tests/Extensibility/Extensions/VirtualDirectorySupportTests.cs
@@ -1,4 +1,3 @@
-using NDesk.Options;
 using NSubstitute;
 using Pretzel.Logic.Extensibility.Extensions;
 using Pretzel.Logic.Templating.Context;
@@ -26,20 +25,20 @@ public void not_processed_when_no_argument_is_passed_in()
             // arrange
             var returnThis = Substitute.For<FileBase>();
             fileSystem.File.Returns(returnThis);
-            var optionSet = new OptionSet();
-            vdirSupport.UpdateOptions(optionSet);
-            optionSet.Parse(new string[0]);
+            //var optionSet = new OptionSet();
+            //vdirSupport.UpdateOptions(optionSet);
+            //optionSet.Parse(new string[0]);
 
             // act
             vdirSupport.Transform(new SiteContext
             {
                 Pages = new List<Page>
-                                                      {
-                                                          new NonProcessedPage
-                                                              {
-                                                                  OutputFile = "Test.html"
-                                                              },
-                                                      }
+                {
+                    new NonProcessedPage
+                    {
+                        OutputFile = "Test.html"
+                    },
+                }
             });
 
             // assert
@@ -52,21 +51,21 @@ public void processes_only_when_vdir_argument_is_passed()
             // arrange
             var returnThis = Substitute.For<FileBase>();
             fileSystem.File.Returns(returnThis);
-            var optionSet = new OptionSet();
-            vdirSupport.UpdateOptions(optionSet);
-            optionSet.Parse(new[] { "--vDir", "something" });
+            //var optionSet = new OptionSet();
+            //vdirSupport.UpdateOptions(optionSet);
+            //optionSet.Parse(new[] { "--vDir", "something" });
 
             // act
             vdirSupport.Transform(new SiteContext
-                                      {
-                                          Pages = new List<Page>
-                                                      {
-                                                          new NonProcessedPage
-                                                              {
-                                                                  OutputFile = "Test.html"
-                                                              },
-                                                      }
-                                      });
+            {
+                Pages = new List<Page>
+                {
+                    new NonProcessedPage
+                    {
+                        OutputFile = "Test.html"
+                    },
+                }
+            });
 
             // assert
             returnThis.Received().ReadAllText("Test.html");
@@ -78,33 +77,33 @@ public void processes_only_css_and_html_files()
             // arrange
             var returnThis = Substitute.For<FileBase>();
             fileSystem.File.Returns(returnThis);
-            var optionSet = new OptionSet();
-            vdirSupport.UpdateOptions(optionSet);
-            optionSet.Parse(new[] { "--vDir", "something" });
+            //var optionSet = new OptionSet();
+            //vdirSupport.UpdateOptions(optionSet);
+            //optionSet.Parse(new[] { "--vDir", "something" });
 
             // act
             vdirSupport.Transform(new SiteContext
-                                      {
-                                          Pages = new List<Page>
-                                                      {
-                                                          new NonProcessedPage
-                                                              {
-                                                                  OutputFile = "Test.bin"
-                                                              },
-                                                              new NonProcessedPage
-                                                              {
-                                                                  OutputFile = "Test.html"
-                                                              },
-                                                              new NonProcessedPage
-                                                              {
-                                                                  OutputFile = "Test.htm"
-                                                              },
-                                                              new NonProcessedPage
-                                                              {
-                                                                  OutputFile = "Test.css"
-                                                              },
-                                                      }
-                                      });
+            {
+                Pages = new List<Page>
+                {
+                    new NonProcessedPage
+                    {
+                        OutputFile = "Test.bin"
+                    },
+                    new NonProcessedPage
+                    {
+                        OutputFile = "Test.html"
+                    },
+                    new NonProcessedPage
+                    {
+                        OutputFile = "Test.htm"
+                    },
+                    new NonProcessedPage
+                    {
+                        OutputFile = "Test.css"
+                    },
+                }
+            });
 
             // assert
             returnThis.DidNotReceive().ReadAllText("Test.bin");
@@ -119,9 +118,9 @@ public void includes_virtual_directory_in_href()
             // arrange
             var returnThis = Substitute.For<FileBase>();
             fileSystem.File.Returns(returnThis);
-            var optionSet = new OptionSet();
-            vdirSupport.UpdateOptions(optionSet);
-            optionSet.Parse(new[] { "--vDir", "something" });
+            //var optionSet = new OptionSet();
+            //vdirSupport.UpdateOptions(optionSet);
+            //optionSet.Parse(new[] { "--vDir", "something" });
 
             const string body = @"<body>
 <a href=""/dir/file.html"" />
@@ -133,12 +132,12 @@ public void includes_virtual_directory_in_href()
             vdirSupport.Transform(new SiteContext
             {
                 Pages = new List<Page>
-                                                      {
-                                                              new NonProcessedPage
-                                                              {
-                                                                  OutputFile = "Test.html"
-                                                              },
-                                                      }
+                {
+                    new NonProcessedPage
+                    {
+                        OutputFile = "Test.html"
+                    },
+                }
             });
 
             // assert
@@ -149,30 +148,30 @@ public void includes_virtual_directory_in_href()
             returnThis.Received().WriteAllText("Test.html", newBody);
         }
 
-        [InlineData("bake")]
-        [InlineData("taste")]
-        [Theory]
-        public void GetArguments_Bake_Or_Taste_Should_Return_VDir(string command)
-        {
-            // act
-            var args = vdirSupport.GetArguments(command);
-
-            // assert
-            Assert.Single(args);
-            Assert.Equal("-vDir", args[0]);
-        }
-
-        [InlineData(null)]
-        [InlineData("")]
-        [InlineData("create")]
-        [Theory]
-        public void GetArguments_Default_Should_Return_Empty_Array(string command)
-        {
-            // act
-            var args = vdirSupport.GetArguments(command);
-
-            // assert
-            Assert.Empty(args);
-        }
+        //[InlineData("bake")]
+        //[InlineData("taste")]
+        //[Theory]
+        //public void GetArguments_Bake_Or_Taste_Should_Return_VDir(string command)
+        //{
+        //    // act
+        //    var args = vdirSupport.GetArguments(command);
+
+        //    // assert
+        //    Assert.Single(args);
+        //    Assert.Equal("-vDir", args[0]);
+        //}
+
+        //[InlineData(null)]
+        //[InlineData("")]
+        //[InlineData("create")]
+        //[Theory]
+        //public void GetArguments_Default_Should_Return_Empty_Array(string command)
+        //{
+        //    // act
+        //    var args = vdirSupport.GetArguments(command);
+
+        //    // assert
+        //    Assert.Empty(args);
+        //}
     }
-}
\ No newline at end of file
+}
diff --git a/src/Pretzel.Tests/Pretzel.Tests.csproj b/src/Pretzel.Tests/Pretzel.Tests.csproj
index 4c4c69951..98e010031 100644
--- a/src/Pretzel.Tests/Pretzel.Tests.csproj
+++ b/src/Pretzel.Tests/Pretzel.Tests.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <ProductVersion>8.0.30703</ProductVersion>
     <TargetFramework>net462</TargetFramework>
@@ -16,7 +16,6 @@
   </PropertyGroup>
   <ItemGroup>
     <PackageReference Include="DotLiquid" Version="2.0.314" />
-    <PackageReference Include="NDesk.Options" Version="0.2.1" />
     <PackageReference Include="NSubstitute" Version="4.2.1" />
     <PackageReference Include="System.IO.Abstractions" Version="2.0.0.116" />
     <PackageReference Include="System.IO.Abstractions.TestingHelpers" Version="2.0.0.116" />
@@ -46,6 +45,13 @@
     <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Remove="Commands\BaseParameterTests.cs" />
+    <Compile Remove="Commands\CommandExtensions.cs" />
+    <Compile Remove="Commands\CommandParameterOutputTests.cs" />
+    <Compile Remove="Commands\CommandParameterTests.cs" />
     <Compile Remove="Templating\Context\PageContextTests.cs" />
   </ItemGroup>
+  <ItemGroup>
+    <Folder Include="Commands\" />
+  </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/src/Pretzel.Tests/Templating/Context/SiteContextGeneratorTests.cs b/src/Pretzel.Tests/Templating/Context/SiteContextGeneratorTests.cs
index 97144ca02..ededca59f 100644
--- a/src/Pretzel.Tests/Templating/Context/SiteContextGeneratorTests.cs
+++ b/src/Pretzel.Tests/Templating/Context/SiteContextGeneratorTests.cs
@@ -361,8 +361,8 @@ public void defaults_in_config_should_be_combined_with_page_frontmatter_in_page_
 # About page
 "));
 
-            var config = new Configuration(fileSystem, @"C:\TestSite");
-            config.ReadFromFile();
+            var config = new Configuration(fileSystem);
+            config.ReadFromFile(@"C:\TestSite");
             var sut = new SiteContextGenerator(fileSystem, new LinkHelper(), config);
 
             // Act
@@ -393,8 +393,8 @@ public void page_frontmatter_should_have_priority_over_defaults_in_config()
 # About page
 "));
 
-            var config = new Configuration(fileSystem, @"C:\TestSite");
-            config.ReadFromFile();
+            var config = new Configuration(fileSystem);
+            config.ReadFromFile(@"C:\TestSite");
             var sut = new SiteContextGenerator(fileSystem, new LinkHelper(), config);
 
             // Act

From 9619f663338da0d6d594fc604f6ae3579b8890b1 Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Mon, 23 Sep 2019 14:46:56 +0200
Subject: [PATCH 11/56] refactor: cleanup namespaces

---
 src/Pretzel.Logic/Commands/BaseParameters.cs  |  2 +-
 .../Commands/CommandArgumentsAttribute.cs     |  2 -
 .../Commands/BakeCommandParametersTests.cs    | 48 +++++++++++++++++++
 src/Pretzel.Tests/Pretzel.Tests.csproj        |  4 +-
 src/Pretzel/Commands/CommandCollection.cs     |  1 -
 src/Pretzel/Commands/CommandInfoAttribute.cs  |  5 --
 6 files changed, 50 insertions(+), 12 deletions(-)
 create mode 100644 src/Pretzel.Tests/Commands/BakeCommandParametersTests.cs

diff --git a/src/Pretzel.Logic/Commands/BaseParameters.cs b/src/Pretzel.Logic/Commands/BaseParameters.cs
index 0b91baf21..5b93d1e3f 100644
--- a/src/Pretzel.Logic/Commands/BaseParameters.cs
+++ b/src/Pretzel.Logic/Commands/BaseParameters.cs
@@ -49,7 +49,7 @@ public static IEnumerable<ExportFactory<IHaveCommandLineArgs, CommandArgumentsEx
         {
             var attr = commandParametersExtendable.GetType().GetCustomAttributes(typeof(CommandArgumentsAttribute), true).FirstOrDefault();
 
-            if (attr is CommandArgumentsAttribute commandArgumentAttribute)
+            if (attr is CommandArgumentsAttribute commandArgumentAttribute && commandParametersExtendable.ArgumentExtenders != null)
             {
                 foreach (var factory in commandParametersExtendable.ArgumentExtenders)
                 {
diff --git a/src/Pretzel.Logic/Commands/CommandArgumentsAttribute.cs b/src/Pretzel.Logic/Commands/CommandArgumentsAttribute.cs
index 49b1dfc16..c433e6a9f 100644
--- a/src/Pretzel.Logic/Commands/CommandArgumentsAttribute.cs
+++ b/src/Pretzel.Logic/Commands/CommandArgumentsAttribute.cs
@@ -1,6 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.CommandLine;
 using System.Composition;
 
 namespace Pretzel.Logic.Commands
diff --git a/src/Pretzel.Tests/Commands/BakeCommandParametersTests.cs b/src/Pretzel.Tests/Commands/BakeCommandParametersTests.cs
new file mode 100644
index 000000000..6714f7612
--- /dev/null
+++ b/src/Pretzel.Tests/Commands/BakeCommandParametersTests.cs
@@ -0,0 +1,48 @@
+using NSubstitute;
+using Pretzel.Commands;
+using System;
+using System.Collections.Generic;
+using System.CommandLine;
+using System.CommandLine.Binding;
+using System.CommandLine.Invocation;
+using System.IO.Abstractions.TestingHelpers;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace Pretzel.Tests.Commands
+{
+    public class BakeCommandParametersTests
+    {
+        readonly IConsole Console = Substitute.For<IConsole>();
+
+        BakeCommandParameters BuildParameters(params string[] args)
+        {
+            var rootCommand = new RootCommand();
+
+            var parameters = new BakeCommandParameters(new MockFileSystem());
+            parameters.OnImportsSatisfied();
+
+            foreach (var option in parameters.Options)
+                rootCommand.AddOption(option);
+            
+            var context = new InvocationContext(new Parser(rootCommand).Parse(args), Console);
+
+            new ModelBinder(typeof(BakeCommandParameters))
+                .UpdateInstance(parameters, context.BindingContext);
+
+            return parameters;
+        }
+
+        [Theory]
+        [InlineData("-c")]
+        [InlineData("--cleantarget")]
+        public void CleanTarget(string argument)
+        {
+            var sut = BuildParameters(argument);
+
+            Assert.True(sut.CleanTarget);
+        }
+    }
+}
diff --git a/src/Pretzel.Tests/Pretzel.Tests.csproj b/src/Pretzel.Tests/Pretzel.Tests.csproj
index 98e010031..92ae23065 100644
--- a/src/Pretzel.Tests/Pretzel.Tests.csproj
+++ b/src/Pretzel.Tests/Pretzel.Tests.csproj
@@ -40,6 +40,7 @@
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\Pretzel.Logic\Pretzel.Logic.csproj" />
+    <ProjectReference Include="..\Pretzel\Pretzel.csproj" />
   </ItemGroup>
   <ItemGroup>
     <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
@@ -51,7 +52,4 @@
     <Compile Remove="Commands\CommandParameterTests.cs" />
     <Compile Remove="Templating\Context\PageContextTests.cs" />
   </ItemGroup>
-  <ItemGroup>
-    <Folder Include="Commands\" />
-  </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/src/Pretzel/Commands/CommandCollection.cs b/src/Pretzel/Commands/CommandCollection.cs
index 7593bc71d..ab691635e 100644
--- a/src/Pretzel/Commands/CommandCollection.cs
+++ b/src/Pretzel/Commands/CommandCollection.cs
@@ -7,7 +7,6 @@
 
 namespace Pretzel.Commands
 {
-
     [Export]
     [Shared]
     public sealed class CommandCollection
diff --git a/src/Pretzel/Commands/CommandInfoAttribute.cs b/src/Pretzel/Commands/CommandInfoAttribute.cs
index 03316b09c..8f57c3d54 100644
--- a/src/Pretzel/Commands/CommandInfoAttribute.cs
+++ b/src/Pretzel/Commands/CommandInfoAttribute.cs
@@ -11,11 +11,6 @@ public sealed class CommandInfoAttribute : ExportAttribute
 
         public string CommandDescription { get; set; }
 
-        //We need the redundant CommandType cause we have no way to get the concrete type
-        //before creating the export. We only want to create the command the user chose.
-        //This way we can allow extention authors to specify custom arguments.
-        public Type CommandType { get; set; }
-
         public CommandInfoAttribute() : base(typeof(ICommand))
         {
         }

From 5572e6d9f0ce7bca37335116d21fd0ee5440882f Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Mon, 23 Sep 2019 15:19:40 +0200
Subject: [PATCH 12/56] test: BakeParameters

---
 .../Commands/BakeCommandParametersTests.cs    | 75 +++++++++++++++++--
 .../Commands/BakeBaseCommandParameters.cs     |  1 +
 .../Commands/PretzelBaseCommandParameters.cs  |  2 +-
 3 files changed, 72 insertions(+), 6 deletions(-)

diff --git a/src/Pretzel.Tests/Commands/BakeCommandParametersTests.cs b/src/Pretzel.Tests/Commands/BakeCommandParametersTests.cs
index 6714f7612..d93fe9f33 100644
--- a/src/Pretzel.Tests/Commands/BakeCommandParametersTests.cs
+++ b/src/Pretzel.Tests/Commands/BakeCommandParametersTests.cs
@@ -1,10 +1,12 @@
 using NSubstitute;
 using Pretzel.Commands;
+using Pretzel.Logic.Commands;
 using System;
 using System.Collections.Generic;
 using System.CommandLine;
 using System.CommandLine.Binding;
 using System.CommandLine.Invocation;
+using System.IO.Abstractions;
 using System.IO.Abstractions.TestingHelpers;
 using System.Linq;
 using System.Text;
@@ -13,27 +15,36 @@
 
 namespace Pretzel.Tests.Commands
 {
-    public class BakeCommandParametersTests
+    public abstract class ParametersTests<T> where T : BaseParameters
     {
         readonly IConsole Console = Substitute.For<IConsole>();
-
-        BakeCommandParameters BuildParameters(params string[] args)
+        protected readonly MockFileSystem fileSystem = new MockFileSystem();
+        protected abstract T CreateParameters(IFileSystem fileSystem);
+        protected T BuildParameters(params string[] args)
         {
             var rootCommand = new RootCommand();
 
-            var parameters = new BakeCommandParameters(new MockFileSystem());
+            var parameters = CreateParameters(fileSystem);
             parameters.OnImportsSatisfied();
 
             foreach (var option in parameters.Options)
                 rootCommand.AddOption(option);
-            
+
             var context = new InvocationContext(new Parser(rootCommand).Parse(args), Console);
 
             new ModelBinder(typeof(BakeCommandParameters))
                 .UpdateInstance(parameters, context.BindingContext);
 
+            parameters.BindingCompleted();
+
             return parameters;
         }
+    }
+
+    public class BakeCommandParametersTests : ParametersTests<BakeCommandParameters>
+    {
+        protected override BakeCommandParameters CreateParameters(IFileSystem fileSystem)
+            => new BakeCommandParameters(fileSystem);
 
         [Theory]
         [InlineData("-c")]
@@ -44,5 +55,59 @@ public void CleanTarget(string argument)
 
             Assert.True(sut.CleanTarget);
         }
+
+        [Theory]
+        [InlineData("--drafts")]
+        public void Drafts(string argument)
+        {
+            var sut = BuildParameters(argument);
+
+            Assert.True(sut.Drafts);
+        }
+
+        [Theory]
+        [InlineData("-t", "liquid")]
+        [InlineData("--template", "razor")]
+        public void Template(string argument, string value)
+        {
+            var sut = BuildParameters(argument, value);
+
+            Assert.Equal(value, sut.Template);
+        }
+
+        [Theory]
+        [InlineData("-d", "foo/_site")]
+        [InlineData("--destination", "bar/mySite")]
+        public void Destination(string argument, string value)
+        {
+            var sut = BuildParameters(argument, value);
+
+            Assert.Equal(fileSystem.Path.Combine(sut.Source, value), sut.Destination);
+        }
+
+        [Theory]
+        [InlineData("-d", @"c:\tmp\_site")]
+        public void DestinationRooted(string argument, string value)
+        {
+            var sut = BuildParameters(argument, value);
+
+            Assert.Equal(value, sut.Destination);
+        }
+
+        [Fact]
+        public void DestinationEmpty()
+        {
+            var sut = BuildParameters("-d");
+
+            Assert.Equal(fileSystem.Path.Combine(sut.Source, "_site"), sut.Destination);
+        }
+
+        [Fact]
+        public void DestinationDefaultValue()
+        {
+            var sut = BuildParameters();
+
+            Assert.Equal(fileSystem.Path.Combine(sut.Source, "_site"), sut.Destination);
+        }
     }
 }
diff --git a/src/Pretzel/Commands/BakeBaseCommandParameters.cs b/src/Pretzel/Commands/BakeBaseCommandParameters.cs
index 5971bfbb8..d8effd6c7 100644
--- a/src/Pretzel/Commands/BakeBaseCommandParameters.cs
+++ b/src/Pretzel/Commands/BakeBaseCommandParameters.cs
@@ -12,6 +12,7 @@ protected BakeBaseCommandParameters(IFileSystem fileSystem) : base(fileSystem) {
 
         protected override void WithOptions(List<Option> options)
         {
+            base.WithOptions(options);
             options.AddRange(new[]
             {
                 new Option(new [] { "-c", "--cleantarget" }, "Delete the target directory (_site by default)")
diff --git a/src/Pretzel/Commands/PretzelBaseCommandParameters.cs b/src/Pretzel/Commands/PretzelBaseCommandParameters.cs
index 70de92565..f88e1d3d0 100644
--- a/src/Pretzel/Commands/PretzelBaseCommandParameters.cs
+++ b/src/Pretzel/Commands/PretzelBaseCommandParameters.cs
@@ -24,7 +24,7 @@ protected override void WithOptions(List<Option> options)
         {
             options.AddRange(new[]
             {
-                new Option(new []{ "-t", "--template" },"The templating engine to use")
+                new Option(new []{ "-t", "--template" }, "The templating engine to use")
                 {
                     Argument = new Argument<string>()
                 },

From bb87e94f6b98093f43301d896799abfed82633bc Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Mon, 23 Sep 2019 15:43:48 +0200
Subject: [PATCH 13/56] test: TasteCommandParameters

---
 .../Commands/BakeCommandParametersTests.cs    |  26 ----
 .../Commands/ParametersTests`1.cs             |  39 ++++++
 .../Commands/TasteCommandParametersTests.cs   | 115 ++++++++++++++++++
 .../Commands/PretzelBaseCommandParameters.cs  |   1 +
 src/Pretzel/Commands/TasteCommand.cs          |  10 +-
 5 files changed, 159 insertions(+), 32 deletions(-)
 create mode 100644 src/Pretzel.Tests/Commands/ParametersTests`1.cs
 create mode 100644 src/Pretzel.Tests/Commands/TasteCommandParametersTests.cs

diff --git a/src/Pretzel.Tests/Commands/BakeCommandParametersTests.cs b/src/Pretzel.Tests/Commands/BakeCommandParametersTests.cs
index d93fe9f33..732c6f887 100644
--- a/src/Pretzel.Tests/Commands/BakeCommandParametersTests.cs
+++ b/src/Pretzel.Tests/Commands/BakeCommandParametersTests.cs
@@ -15,32 +15,6 @@
 
 namespace Pretzel.Tests.Commands
 {
-    public abstract class ParametersTests<T> where T : BaseParameters
-    {
-        readonly IConsole Console = Substitute.For<IConsole>();
-        protected readonly MockFileSystem fileSystem = new MockFileSystem();
-        protected abstract T CreateParameters(IFileSystem fileSystem);
-        protected T BuildParameters(params string[] args)
-        {
-            var rootCommand = new RootCommand();
-
-            var parameters = CreateParameters(fileSystem);
-            parameters.OnImportsSatisfied();
-
-            foreach (var option in parameters.Options)
-                rootCommand.AddOption(option);
-
-            var context = new InvocationContext(new Parser(rootCommand).Parse(args), Console);
-
-            new ModelBinder(typeof(BakeCommandParameters))
-                .UpdateInstance(parameters, context.BindingContext);
-
-            parameters.BindingCompleted();
-
-            return parameters;
-        }
-    }
-
     public class BakeCommandParametersTests : ParametersTests<BakeCommandParameters>
     {
         protected override BakeCommandParameters CreateParameters(IFileSystem fileSystem)
diff --git a/src/Pretzel.Tests/Commands/ParametersTests`1.cs b/src/Pretzel.Tests/Commands/ParametersTests`1.cs
new file mode 100644
index 000000000..4b9e9e0e6
--- /dev/null
+++ b/src/Pretzel.Tests/Commands/ParametersTests`1.cs
@@ -0,0 +1,39 @@
+using System;
+using System.CommandLine;
+using System.CommandLine.Binding;
+using System.CommandLine.Invocation;
+using System.IO.Abstractions;
+using System.IO.Abstractions.TestingHelpers;
+using System.Linq;
+using NSubstitute;
+using Pretzel.Commands;
+using Pretzel.Logic.Commands;
+
+namespace Pretzel.Tests.Commands
+{
+    public abstract class ParametersTests<T> where T : BaseParameters
+    {
+        readonly IConsole Console = Substitute.For<IConsole>();
+        protected readonly MockFileSystem fileSystem = new MockFileSystem();
+        protected abstract T CreateParameters(IFileSystem fileSystem);
+        protected T BuildParameters(params string[] args)
+        {
+            var rootCommand = new RootCommand();
+
+            var parameters = CreateParameters(fileSystem);
+            parameters.OnImportsSatisfied();
+
+            foreach (var option in parameters.Options)
+                rootCommand.AddOption(option);
+
+            var context = new InvocationContext(new Parser(rootCommand).Parse(args), Console);
+
+            new ModelBinder(parameters.GetType())
+                .UpdateInstance(parameters, context.BindingContext);
+
+            parameters.BindingCompleted();
+
+            return parameters;
+        }
+    }
+}
diff --git a/src/Pretzel.Tests/Commands/TasteCommandParametersTests.cs b/src/Pretzel.Tests/Commands/TasteCommandParametersTests.cs
new file mode 100644
index 000000000..7896facff
--- /dev/null
+++ b/src/Pretzel.Tests/Commands/TasteCommandParametersTests.cs
@@ -0,0 +1,115 @@
+using System;
+using System.IO.Abstractions;
+using System.Linq;
+using Pretzel.Commands;
+using Xunit;
+
+namespace Pretzel.Tests.Commands
+{
+    public class TasteCommandParametersTests : ParametersTests<TasteCommandParameters>
+    {
+        protected override TasteCommandParameters CreateParameters(IFileSystem fileSystem)
+            => new TasteCommandParameters(fileSystem);
+
+        [Theory]
+        [InlineData("-c")]
+        [InlineData("--cleantarget")]
+        public void CleanTarget(string argument)
+        {
+            var sut = BuildParameters(argument);
+
+            Assert.True(sut.CleanTarget);
+        }
+
+        [Theory]
+        [InlineData("--drafts")]
+        public void Drafts(string argument)
+        {
+            var sut = BuildParameters(argument);
+
+            Assert.True(sut.Drafts);
+        }
+
+        [Theory]
+        [InlineData("--nobrowser", true)]
+        public void NoBrowser(string argument, bool expectedValue)
+        {
+            var sut = BuildParameters(argument, expectedValue.ToString());
+
+            Assert.Equal(expectedValue, sut.NoBrowser);
+            Assert.Equal(!expectedValue, sut.LaunchBrowser);
+        }
+
+        [Fact]
+        public void NoBrowserDefaultValue()
+        {
+            var sut = BuildParameters();
+
+            Assert.False(sut.NoBrowser);
+            Assert.True(sut.LaunchBrowser);
+        }
+
+        [Theory]
+        [InlineData("--port", 9000)]
+        [InlineData("-p", 9090)]
+        public void Port(string argument, int expectedValue)
+        {
+            var sut = BuildParameters(argument, expectedValue.ToString());
+
+            Assert.Equal(expectedValue, sut.Port);
+        }
+
+        [Fact]
+        public void PortDefaultValue()
+        {
+            var sut = BuildParameters();
+
+            Assert.Equal(8080, sut.Port);
+        }
+
+        [Theory]
+        [InlineData("-t", "liquid")]
+        [InlineData("--template", "razor")]
+        public void Template(string argument, string value)
+        {
+            var sut = BuildParameters(argument, value);
+
+            Assert.Equal(value, sut.Template);
+        }
+
+        [Theory]
+        [InlineData("-d", "foo/_site")]
+        [InlineData("--destination", "bar/mySite")]
+        public void Destination(string argument, string value)
+        {
+            var sut = BuildParameters(argument, value);
+
+            Assert.Equal(fileSystem.Path.Combine(sut.Source, value), sut.Destination);
+        }
+
+        [Theory]
+        [InlineData("-d", @"c:\tmp\_site")]
+        public void DestinationRooted(string argument, string value)
+        {
+            var sut = BuildParameters(argument, value);
+
+            Assert.Equal(value, sut.Destination);
+        }
+
+        [Fact]
+        public void DestinationEmpty()
+        {
+            var sut = BuildParameters("-d");
+
+            Assert.Equal(fileSystem.Path.Combine(sut.Source, "_site"), sut.Destination);
+        }
+
+        [Fact]
+        public void DestinationDefaultValue()
+        {
+            var sut = BuildParameters();
+
+            Assert.Equal(fileSystem.Path.Combine(sut.Source, "_site"), sut.Destination);
+        }
+    }
+}
diff --git a/src/Pretzel/Commands/PretzelBaseCommandParameters.cs b/src/Pretzel/Commands/PretzelBaseCommandParameters.cs
index f88e1d3d0..51b25be65 100644
--- a/src/Pretzel/Commands/PretzelBaseCommandParameters.cs
+++ b/src/Pretzel/Commands/PretzelBaseCommandParameters.cs
@@ -38,6 +38,7 @@ protected override void WithOptions(List<Option> options)
                 },
             });
         }
+
         // Default Option that get's injected from Program
         public string Source { get; set; }
         // Default Option that get's injected from Program
diff --git a/src/Pretzel/Commands/TasteCommand.cs b/src/Pretzel/Commands/TasteCommand.cs
index 206cb066f..49e0c4fa7 100644
--- a/src/Pretzel/Commands/TasteCommand.cs
+++ b/src/Pretzel/Commands/TasteCommand.cs
@@ -17,10 +17,10 @@ namespace Pretzel.Commands
     [Export]
     [Shared]
     [CommandArguments(CommandName = BuiltInCommands.Taste)]
-    public class TasteParameters : BakeBaseCommandParameters
+    public class TasteCommandParameters : BakeBaseCommandParameters
     {
         [ImportingConstructor]
-        public TasteParameters(IFileSystem fileSystem) : base(fileSystem) { }
+        public TasteCommandParameters(IFileSystem fileSystem) : base(fileSystem) { }
 
         protected override void WithOptions(List<Option> options)
         {
@@ -33,15 +33,13 @@ protected override void WithOptions(List<Option> options)
                 },
                 new Option("--nobrowser", "Do not launch a browser (false by default)")
                 {
-                    Argument = new Argument<bool>(() => false)
+                    Argument = new Argument<bool>()
                 },
             });
         }
 
         public int Port { get; set; }
-
         public bool NoBrowser { get; set; }
-
         public bool LaunchBrowser => !NoBrowser;
     }
 
@@ -58,7 +56,7 @@ public sealed class TasteCommand : ICommand
         public SiteContextGenerator Generator { get; set; }
 
         [Import]
-        public TasteParameters Parameters { get; set; }
+        public TasteCommandParameters Parameters { get; set; }
 
         [ImportMany]
         public IEnumerable<ITransform> Transforms { get; set; }

From 9700e0392528b687bd75077dc15b5daf1e523351 Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Mon, 23 Sep 2019 15:52:45 +0200
Subject: [PATCH 14/56] refactor: tests use paramters hierarchy

---
 .../BakeBaseCommandParametersTests`1.cs       | 21 ++++++
 .../Commands/BakeCommandParametersTests.cs    | 66 +------------------
 .../PetzelBaseCommandParametersTests`1.cs     | 65 ++++++++++++++++++
 .../Commands/TasteCommandParametersTests.cs   | 66 +------------------
 4 files changed, 88 insertions(+), 130 deletions(-)
 create mode 100644 src/Pretzel.Tests/Commands/BakeBaseCommandParametersTests`1.cs
 create mode 100644 src/Pretzel.Tests/Commands/PetzelBaseCommandParametersTests`1.cs

diff --git a/src/Pretzel.Tests/Commands/BakeBaseCommandParametersTests`1.cs b/src/Pretzel.Tests/Commands/BakeBaseCommandParametersTests`1.cs
new file mode 100644
index 000000000..12c65162d
--- /dev/null
+++ b/src/Pretzel.Tests/Commands/BakeBaseCommandParametersTests`1.cs
@@ -0,0 +1,21 @@
+using System;
+using System.Linq;
+using Pretzel.Commands;
+using Xunit;
+
+namespace Pretzel.Tests.Commands
+{
+    public abstract class BakeBaseCommandParametersTests<T> : PretzelBaseCommandParametersTests<T>
+        where T : BakeBaseCommandParameters
+    {
+        [Theory]
+        [InlineData("-c")]
+        [InlineData("--cleantarget")]
+        public void CleanTarget(string argument)
+        {
+            var sut = BuildParameters(argument);
+
+            Assert.True(sut.CleanTarget);
+        }  
+    }
+}
diff --git a/src/Pretzel.Tests/Commands/BakeCommandParametersTests.cs b/src/Pretzel.Tests/Commands/BakeCommandParametersTests.cs
index 732c6f887..438595ea2 100644
--- a/src/Pretzel.Tests/Commands/BakeCommandParametersTests.cs
+++ b/src/Pretzel.Tests/Commands/BakeCommandParametersTests.cs
@@ -15,73 +15,9 @@
 
 namespace Pretzel.Tests.Commands
 {
-    public class BakeCommandParametersTests : ParametersTests<BakeCommandParameters>
+    public class BakeCommandParametersTests : BakeBaseCommandParametersTests<BakeCommandParameters>
     {
         protected override BakeCommandParameters CreateParameters(IFileSystem fileSystem)
             => new BakeCommandParameters(fileSystem);
-
-        [Theory]
-        [InlineData("-c")]
-        [InlineData("--cleantarget")]
-        public void CleanTarget(string argument)
-        {
-            var sut = BuildParameters(argument);
-
-            Assert.True(sut.CleanTarget);
-        }
-
-        [Theory]
-        [InlineData("--drafts")]
-        public void Drafts(string argument)
-        {
-            var sut = BuildParameters(argument);
-
-            Assert.True(sut.Drafts);
-        }
-
-        [Theory]
-        [InlineData("-t", "liquid")]
-        [InlineData("--template", "razor")]
-        public void Template(string argument, string value)
-        {
-            var sut = BuildParameters(argument, value);
-
-            Assert.Equal(value, sut.Template);
-        }
-
-        [Theory]
-        [InlineData("-d", "foo/_site")]
-        [InlineData("--destination", "bar/mySite")]
-        public void Destination(string argument, string value)
-        {
-            var sut = BuildParameters(argument, value);
-
-            Assert.Equal(fileSystem.Path.Combine(sut.Source, value), sut.Destination);
-        }
-
-        [Theory]
-        [InlineData("-d", @"c:\tmp\_site")]
-        public void DestinationRooted(string argument, string value)
-        {
-            var sut = BuildParameters(argument, value);
-
-            Assert.Equal(value, sut.Destination);
-        }
-
-        [Fact]
-        public void DestinationEmpty()
-        {
-            var sut = BuildParameters("-d");
-
-            Assert.Equal(fileSystem.Path.Combine(sut.Source, "_site"), sut.Destination);
-        }
-
-        [Fact]
-        public void DestinationDefaultValue()
-        {
-            var sut = BuildParameters();
-
-            Assert.Equal(fileSystem.Path.Combine(sut.Source, "_site"), sut.Destination);
-        }
     }
 }
diff --git a/src/Pretzel.Tests/Commands/PetzelBaseCommandParametersTests`1.cs b/src/Pretzel.Tests/Commands/PetzelBaseCommandParametersTests`1.cs
new file mode 100644
index 000000000..4ccd00456
--- /dev/null
+++ b/src/Pretzel.Tests/Commands/PetzelBaseCommandParametersTests`1.cs
@@ -0,0 +1,65 @@
+using System;
+using System.Linq;
+using Pretzel.Commands;
+using Xunit;
+
+namespace Pretzel.Tests.Commands
+{
+    public abstract class PretzelBaseCommandParametersTests<T> : ParametersTests<T>
+        where T : PretzelBaseCommandParameters
+    {
+        [Theory]
+        [InlineData("--drafts")]
+        public void Drafts(string argument)
+        {
+            var sut = BuildParameters(argument);
+
+            Assert.True(sut.Drafts);
+        }
+
+        [Theory]
+        [InlineData("-t", "liquid")]
+        [InlineData("--template", "razor")]
+        public void Template(string argument, string value)
+        {
+            var sut = BuildParameters(argument, value);
+
+            Assert.Equal(value, sut.Template);
+        }
+
+        [Theory]
+        [InlineData("-d", "foo/_site")]
+        [InlineData("--destination", "bar/mySite")]
+        public void Destination(string argument, string value)
+        {
+            var sut = BuildParameters(argument, value);
+
+            Assert.Equal(fileSystem.Path.Combine(sut.Source, value), sut.Destination);
+        }
+
+        [Theory]
+        [InlineData("-d", @"c:\tmp\_site")]
+        public void DestinationRooted(string argument, string value)
+        {
+            var sut = BuildParameters(argument, value);
+
+            Assert.Equal(value, sut.Destination);
+        }
+
+        [Fact]
+        public void DestinationEmpty()
+        {
+            var sut = BuildParameters("-d");
+
+            Assert.Equal(fileSystem.Path.Combine(sut.Source, "_site"), sut.Destination);
+        }
+
+        [Fact]
+        public void DestinationDefaultValue()
+        {
+            var sut = BuildParameters();
+
+            Assert.Equal(fileSystem.Path.Combine(sut.Source, "_site"), sut.Destination);
+        }
+    }
+}
diff --git a/src/Pretzel.Tests/Commands/TasteCommandParametersTests.cs b/src/Pretzel.Tests/Commands/TasteCommandParametersTests.cs
index 7896facff..b122c5168 100644
--- a/src/Pretzel.Tests/Commands/TasteCommandParametersTests.cs
+++ b/src/Pretzel.Tests/Commands/TasteCommandParametersTests.cs
@@ -6,30 +6,11 @@
 
 namespace Pretzel.Tests.Commands
 {
-    public class TasteCommandParametersTests : ParametersTests<TasteCommandParameters>
+    public class TasteCommandParametersTests : BakeBaseCommandParametersTests<TasteCommandParameters>
     {
         protected override TasteCommandParameters CreateParameters(IFileSystem fileSystem)
             => new TasteCommandParameters(fileSystem);
 
-        [Theory]
-        [InlineData("-c")]
-        [InlineData("--cleantarget")]
-        public void CleanTarget(string argument)
-        {
-            var sut = BuildParameters(argument);
-
-            Assert.True(sut.CleanTarget);
-        }
-
-        [Theory]
-        [InlineData("--drafts")]
-        public void Drafts(string argument)
-        {
-            var sut = BuildParameters(argument);
-
-            Assert.True(sut.Drafts);
-        }
-
         [Theory]
         [InlineData("--nobrowser", true)]
         public void NoBrowser(string argument, bool expectedValue)
@@ -66,50 +47,5 @@ public void PortDefaultValue()
 
             Assert.Equal(8080, sut.Port);
         }
-
-        [Theory]
-        [InlineData("-t", "liquid")]
-        [InlineData("--template", "razor")]
-        public void Template(string argument, string value)
-        {
-            var sut = BuildParameters(argument, value);
-
-            Assert.Equal(value, sut.Template);
-        }
-
-        [Theory]
-        [InlineData("-d", "foo/_site")]
-        [InlineData("--destination", "bar/mySite")]
-        public void Destination(string argument, string value)
-        {
-            var sut = BuildParameters(argument, value);
-
-            Assert.Equal(fileSystem.Path.Combine(sut.Source, value), sut.Destination);
-        }
-
-        [Theory]
-        [InlineData("-d", @"c:\tmp\_site")]
-        public void DestinationRooted(string argument, string value)
-        {
-            var sut = BuildParameters(argument, value);
-
-            Assert.Equal(value, sut.Destination);
-        }
-
-        [Fact]
-        public void DestinationEmpty()
-        {
-            var sut = BuildParameters("-d");
-
-            Assert.Equal(fileSystem.Path.Combine(sut.Source, "_site"), sut.Destination);
-        }
-
-        [Fact]
-        public void DestinationDefaultValue()
-        {
-            var sut = BuildParameters();
-
-            Assert.Equal(fileSystem.Path.Combine(sut.Source, "_site"), sut.Destination);
-        }
     }
 }

From 28f316641b85b4beddacc69fd5c2b720121e4ce9 Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Mon, 23 Sep 2019 15:58:58 +0200
Subject: [PATCH 15/56] test: added IngredientCommandParametersTests

---
 .../IngredientCommandParametersTests.cs       | 32 +++++++++++++++++++
 .../PetzelBaseCommandParametersTests`1.cs     |  1 +
 src/Pretzel/Commands/IngredientCommand.cs     |  1 +
 3 files changed, 34 insertions(+)
 create mode 100644 src/Pretzel.Tests/Commands/IngredientCommandParametersTests.cs

diff --git a/src/Pretzel.Tests/Commands/IngredientCommandParametersTests.cs b/src/Pretzel.Tests/Commands/IngredientCommandParametersTests.cs
new file mode 100644
index 000000000..339c21da5
--- /dev/null
+++ b/src/Pretzel.Tests/Commands/IngredientCommandParametersTests.cs
@@ -0,0 +1,32 @@
+using System;
+using System.IO.Abstractions;
+using System.Linq;
+using Pretzel.Commands;
+using Xunit;
+
+namespace Pretzel.Tests.Commands
+{
+    public class IngredientCommandParametersTests : PretzelBaseCommandParametersTests<IngredientCommandParameters>
+    {
+        protected override IngredientCommandParameters CreateParameters(IFileSystem fileSystem)
+            => new IngredientCommandParameters(fileSystem);
+
+        [Theory]
+        [InlineData("--newposttitle", "My AwesomeBlog")]
+        [InlineData("-n", "This is the second blog")]
+        public void NewPostTitle(string argument, string value)
+        {
+            var sut = BuildParameters(argument, value);
+
+            Assert.Equal(value, sut.NewPostTitle);
+        }
+
+        [Fact]
+        public void NewPostTitleDefaultValue()
+        {
+            var sut = BuildParameters();
+
+            Assert.Equal("New post", sut.NewPostTitle);
+        }
+    }
+}
diff --git a/src/Pretzel.Tests/Commands/PetzelBaseCommandParametersTests`1.cs b/src/Pretzel.Tests/Commands/PetzelBaseCommandParametersTests`1.cs
index 4ccd00456..72a49cffe 100644
--- a/src/Pretzel.Tests/Commands/PetzelBaseCommandParametersTests`1.cs
+++ b/src/Pretzel.Tests/Commands/PetzelBaseCommandParametersTests`1.cs
@@ -1,4 +1,5 @@
 using System;
+using System.IO.Abstractions;
 using System.Linq;
 using Pretzel.Commands;
 using Xunit;
diff --git a/src/Pretzel/Commands/IngredientCommand.cs b/src/Pretzel/Commands/IngredientCommand.cs
index 1774a8b95..aaf0612d4 100644
--- a/src/Pretzel/Commands/IngredientCommand.cs
+++ b/src/Pretzel/Commands/IngredientCommand.cs
@@ -19,6 +19,7 @@ public IngredientCommandParameters(IFileSystem fileSystem) : base(fileSystem) {
 
         protected override void WithOptions(List<Option> options)
         {
+            base.WithOptions(options);
             options.AddRange(new[]
             {
                 new Option(new [] { "--newposttitle", "-n" }, "The title of the new post (\"New post\" by default")

From a99bd03028b599eef502bc9c5636a96bb411ae1a Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Mon, 23 Sep 2019 16:04:02 +0200
Subject: [PATCH 16/56] test: added RecipeCommandParametersTests

---
 ...IngredientCommandParametersTests - Copy.cs | 34 +++++++++++++++++++
 src/Pretzel/Commands/RecipeCommand.cs         |  1 +
 2 files changed, 35 insertions(+)
 create mode 100644 src/Pretzel.Tests/Commands/IngredientCommandParametersTests - Copy.cs

diff --git a/src/Pretzel.Tests/Commands/IngredientCommandParametersTests - Copy.cs b/src/Pretzel.Tests/Commands/IngredientCommandParametersTests - Copy.cs
new file mode 100644
index 000000000..d774d99bd
--- /dev/null
+++ b/src/Pretzel.Tests/Commands/IngredientCommandParametersTests - Copy.cs	
@@ -0,0 +1,34 @@
+using System;
+using System.IO.Abstractions;
+using System.Linq;
+using Pretzel.Commands;
+using Xunit;
+
+namespace Pretzel.Tests.Commands
+{
+    public class RecipeCommandParametersTests : PretzelBaseCommandParametersTests<RecipeCommandParameters>
+    {
+        protected override RecipeCommandParameters CreateParameters(IFileSystem fileSystem)
+            => new RecipeCommandParameters(fileSystem);
+
+        [Theory]
+        [InlineData("--wiki", true)]
+        [InlineData("", false)]
+        public void WithWiki(string argument, bool expectedValue)
+        {
+            var sut = BuildParameters(argument);
+
+            Assert.Equal(expectedValue, sut.Wiki);
+        }
+
+        [Theory]
+        [InlineData("--withproject", true)]
+        [InlineData("", false)]
+        public void WithProject(string argument, bool expectedValue)
+        {
+            var sut = BuildParameters(argument);
+
+            Assert.Equal(expectedValue, sut.WithProject);
+        }
+    }
+}
diff --git a/src/Pretzel/Commands/RecipeCommand.cs b/src/Pretzel/Commands/RecipeCommand.cs
index 7f94cb091..89bf50344 100644
--- a/src/Pretzel/Commands/RecipeCommand.cs
+++ b/src/Pretzel/Commands/RecipeCommand.cs
@@ -22,6 +22,7 @@ public RecipeCommandParameters(IFileSystem fileSystem) : base(fileSystem) { }
 
         protected override void WithOptions(List<Option> options)
         {
+            base.WithOptions(options);
             options.AddRange(new[]
             {
                 new Option(new [] { "-p", "--withproject" }, "Includes a layout VS Solution, to give intellisense when editing razor layout files")

From 63b2cf04d70d18a608c090b80c97012a39288a75 Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Mon, 23 Sep 2019 16:09:29 +0200
Subject: [PATCH 17/56] test: added ImportCommandParametersTests

---
 .../Commands/ImportCommandParametersTests.cs  | 34 +++++++++++++++++++
 ...opy.cs => RecipeCommandParametersTests.cs} |  0
 src/Pretzel/Commands/ImportCommand.cs         |  7 ++--
 3 files changed, 38 insertions(+), 3 deletions(-)
 create mode 100644 src/Pretzel.Tests/Commands/ImportCommandParametersTests.cs
 rename src/Pretzel.Tests/Commands/{IngredientCommandParametersTests - Copy.cs => RecipeCommandParametersTests.cs} (100%)

diff --git a/src/Pretzel.Tests/Commands/ImportCommandParametersTests.cs b/src/Pretzel.Tests/Commands/ImportCommandParametersTests.cs
new file mode 100644
index 000000000..0a9dd5ced
--- /dev/null
+++ b/src/Pretzel.Tests/Commands/ImportCommandParametersTests.cs
@@ -0,0 +1,34 @@
+using System;
+using System.IO.Abstractions;
+using System.Linq;
+using Pretzel.Commands;
+using Xunit;
+
+namespace Pretzel.Tests.Commands
+{
+    public class ImportCommandParametersTests : PretzelBaseCommandParametersTests<ImportCommandParameters>
+    {
+        protected override ImportCommandParameters CreateParameters(IFileSystem fileSystem)
+            => new ImportCommandParameters(fileSystem);
+
+        [Theory]
+        [InlineData("--importtype", "foo")]
+        [InlineData("-i", "bar")]
+        public void ImportType(string argument, string expectedValue)
+        {
+            var sut = BuildParameters(argument, expectedValue);
+
+            Assert.Equal(expectedValue, sut.ImportType);
+        }
+
+        [Theory]
+        [InlineData("--importfile", "baz")]
+        [InlineData("-f", "buzz")]
+        public void ImportFile(string argument, string expectedValue)
+        {
+            var sut = BuildParameters(argument, expectedValue);
+
+            Assert.Equal(expectedValue, sut.ImportFile);
+        }
+    }
+}
diff --git a/src/Pretzel.Tests/Commands/IngredientCommandParametersTests - Copy.cs b/src/Pretzel.Tests/Commands/RecipeCommandParametersTests.cs
similarity index 100%
rename from src/Pretzel.Tests/Commands/IngredientCommandParametersTests - Copy.cs
rename to src/Pretzel.Tests/Commands/RecipeCommandParametersTests.cs
diff --git a/src/Pretzel/Commands/ImportCommand.cs b/src/Pretzel/Commands/ImportCommand.cs
index 4c8bac4ef..90074ed9d 100644
--- a/src/Pretzel/Commands/ImportCommand.cs
+++ b/src/Pretzel/Commands/ImportCommand.cs
@@ -14,13 +14,14 @@ namespace Pretzel.Commands
     [Export]
     [Shared]
     [CommandArguments(CommandName = BuiltInCommands.Import)]
-    public class ImportParameters : PretzelBaseCommandParameters
+    public class ImportCommandParameters : PretzelBaseCommandParameters
     {
         [ImportingConstructor]
-        public ImportParameters(IFileSystem fileSystem) : base(fileSystem) { }
+        public ImportCommandParameters(IFileSystem fileSystem) : base(fileSystem) { }
 
         protected override void WithOptions(List<Option> options)
         {
+            base.WithOptions(options);
             options.AddRange(new[]
             {
                 new Option(new [] {"--importtype", "-i"}, "The import type")
@@ -47,7 +48,7 @@ class ImportCommand : ICommand
 
 #pragma warning disable 649
         [Import] public IFileSystem FileSystem { get; set; }
-        [Import] public ImportParameters Parameters { get; set; }
+        [Import] public ImportCommandParameters Parameters { get; set; }
 #pragma warning restore 649
 
         public async Task Execute()

From 473071df500f39616c18da1544081aaf3d5424bf Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Tue, 24 Sep 2019 13:03:52 +0200
Subject: [PATCH 18/56] refactor: moved files to respective files

---
 src/Pretzel.Logic/Commands/BaseParameters.cs  | 27 -------------------
 .../Commands/ICommandParametersExtendable.cs  | 15 +++++++++++
 .../Commands/ICommandParametersExtentions.cs  | 27 +++++++++++++++++++
 src/Pretzel/Commands/ImportCommand.cs         |  8 +++---
 4 files changed, 46 insertions(+), 31 deletions(-)
 create mode 100644 src/Pretzel.Logic/Commands/ICommandParametersExtendable.cs
 create mode 100644 src/Pretzel.Logic/Commands/ICommandParametersExtentions.cs

diff --git a/src/Pretzel.Logic/Commands/BaseParameters.cs b/src/Pretzel.Logic/Commands/BaseParameters.cs
index 5b93d1e3f..dca004440 100644
--- a/src/Pretzel.Logic/Commands/BaseParameters.cs
+++ b/src/Pretzel.Logic/Commands/BaseParameters.cs
@@ -7,14 +7,6 @@
 
 namespace Pretzel.Logic.Commands
 {
-    public interface ICommandParametersExtendable
-    {
-        ExportFactory<IHaveCommandLineArgs, CommandArgumentsExtentionAttribute>[] ArgumentExtenders
-        {
-            get;
-        }
-    }
-
     public abstract class BaseParameters : ICommandParameters, ICommandParametersExtendable
     {
         [ImportMany]
@@ -42,23 +34,4 @@ public virtual void BindingCompleted()
         {
         }
     }
-
-    public static class ICommandParametersExtentions
-    {
-        public static IEnumerable<ExportFactory<IHaveCommandLineArgs, CommandArgumentsExtentionAttribute>> GetCommandExtentions(this ICommandParametersExtendable commandParametersExtendable)
-        {
-            var attr = commandParametersExtendable.GetType().GetCustomAttributes(typeof(CommandArgumentsAttribute), true).FirstOrDefault();
-
-            if (attr is CommandArgumentsAttribute commandArgumentAttribute && commandParametersExtendable.ArgumentExtenders != null)
-            {
-                foreach (var factory in commandParametersExtendable.ArgumentExtenders)
-                {
-                    if (factory.Metadata.CommandNames.Contains(commandArgumentAttribute.CommandName))
-                    {
-                        yield return factory;
-                    }
-                }
-            }
-        }
-    }
 }
diff --git a/src/Pretzel.Logic/Commands/ICommandParametersExtendable.cs b/src/Pretzel.Logic/Commands/ICommandParametersExtendable.cs
new file mode 100644
index 000000000..38b56f50e
--- /dev/null
+++ b/src/Pretzel.Logic/Commands/ICommandParametersExtendable.cs
@@ -0,0 +1,15 @@
+using System;
+using System.Composition;
+using System.Linq;
+using Pretzel.Logic.Extensibility;
+
+namespace Pretzel.Logic.Commands
+{
+    public interface ICommandParametersExtendable
+    {
+        ExportFactory<IHaveCommandLineArgs, CommandArgumentsExtentionAttribute>[] ArgumentExtenders
+        {
+            get;
+        }
+    }
+}
diff --git a/src/Pretzel.Logic/Commands/ICommandParametersExtentions.cs b/src/Pretzel.Logic/Commands/ICommandParametersExtentions.cs
new file mode 100644
index 000000000..7c3060619
--- /dev/null
+++ b/src/Pretzel.Logic/Commands/ICommandParametersExtentions.cs
@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using System.Composition;
+using System.Linq;
+using Pretzel.Logic.Extensibility;
+
+namespace Pretzel.Logic.Commands
+{
+    public static class ICommandParametersExtentions
+    {
+        public static IEnumerable<ExportFactory<IHaveCommandLineArgs, CommandArgumentsExtentionAttribute>> GetCommandExtentions(this ICommandParametersExtendable commandParametersExtendable)
+        {
+            var attr = commandParametersExtendable.GetType().GetCustomAttributes(typeof(CommandArgumentsAttribute), true).FirstOrDefault();
+
+            if (attr is CommandArgumentsAttribute commandArgumentAttribute && commandParametersExtendable.ArgumentExtenders != null)
+            {
+                foreach (var factory in commandParametersExtendable.ArgumentExtenders)
+                {
+                    if (factory.Metadata.CommandNames.Contains(commandArgumentAttribute.CommandName))
+                    {
+                        yield return factory;
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/src/Pretzel/Commands/ImportCommand.cs b/src/Pretzel/Commands/ImportCommand.cs
index 90074ed9d..639f3cc14 100644
--- a/src/Pretzel/Commands/ImportCommand.cs
+++ b/src/Pretzel/Commands/ImportCommand.cs
@@ -46,10 +46,10 @@ class ImportCommand : ICommand
     {
         readonly static List<string> Importers = new List<string>(new[] { "wordpress", "blogger" });
 
-#pragma warning disable 649
-        [Import] public IFileSystem FileSystem { get; set; }
-        [Import] public ImportCommandParameters Parameters { get; set; }
-#pragma warning restore 649
+        [Import]
+        public IFileSystem FileSystem { get; set; }
+        [Import]
+        public ImportCommandParameters Parameters { get; set; }
 
         public async Task Execute()
         {

From 3610fe7448fa4c567c898defc78a5c2abef984dc Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Tue, 24 Sep 2019 13:15:16 +0200
Subject: [PATCH 19/56] fix: removed wrong PackageReferences

---
 src/Pretzel.Logic/Pretzel.Logic.csproj | 1 -
 src/Pretzel.Tests/Pretzel.Tests.csproj | 1 -
 2 files changed, 2 deletions(-)

diff --git a/src/Pretzel.Logic/Pretzel.Logic.csproj b/src/Pretzel.Logic/Pretzel.Logic.csproj
index 3d570ebff..6384c2fad 100644
--- a/src/Pretzel.Logic/Pretzel.Logic.csproj
+++ b/src/Pretzel.Logic/Pretzel.Logic.csproj
@@ -40,7 +40,6 @@
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
     <PackageReference Include="System.CommandLine.Experimental" Version="0.3.0-alpha.19405.1" />
-    <PackageReference Include="System.IO.Abstractions" Version="2.0.0.116" />
     <PackageReference Include="System.IO.Abstractions" Version="6.0.32" />
     <PackageReference Include="YamlDotNet" Version="6.1.2" />
     <PackageReference Include="System.Composition" Version="1.2.0" />
diff --git a/src/Pretzel.Tests/Pretzel.Tests.csproj b/src/Pretzel.Tests/Pretzel.Tests.csproj
index 5fd5dae13..5066a81fc 100644
--- a/src/Pretzel.Tests/Pretzel.Tests.csproj
+++ b/src/Pretzel.Tests/Pretzel.Tests.csproj
@@ -17,7 +17,6 @@
   <ItemGroup>
     <PackageReference Include="DotLiquid" Version="2.0.314" />
     <PackageReference Include="NSubstitute" Version="4.2.1" />
-    <PackageReference Include="System.IO.Abstractions" Version="6.0.32" />
     <PackageReference Include="System.IO.Abstractions.TestingHelpers" Version="6.0.32" />
     <PackageReference Include="xunit" Version="2.4.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1">

From 21697303209d1a65e5616c8c01959fac62c20a02 Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Tue, 24 Sep 2019 13:31:32 +0200
Subject: [PATCH 20/56] test: AzureHostSupport & VirtualDirectorySupport

---
 .../Extensions/AzureHostSupport.cs            | 14 ++---
 .../Extensions/AzureHostSupportTest.cs        | 51 ++---------------
 .../VirtualDirectorySupportTests.cs           | 55 ++++++-------------
 3 files changed, 29 insertions(+), 91 deletions(-)

diff --git a/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs b/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs
index fe029ac8b..e77f9824b 100644
--- a/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs
+++ b/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs
@@ -23,6 +23,8 @@ public void UpdateOptions(IList<Option> options)
             });
         }
 
+        public bool Azure { get; set; }
+
         public void BindingCompleted()
         {
         }
@@ -33,7 +35,9 @@ public class AzureHostSupport : IAdditionalIngredient
     {
         private readonly IFileSystem fileSystem;
         private readonly IAssembly assembly;
-        private bool performAzureWorkaround;
+
+        [Import]
+        public AzureHostSupportArguments Arguments { get; set; }
 
         [ImportingConstructor]
         public AzureHostSupport(IFileSystem fileSystem, IAssembly assembly)
@@ -42,15 +46,9 @@ public AzureHostSupport(IFileSystem fileSystem, IAssembly assembly)
             this.assembly = assembly;
         }
 
-
-        public string[] GetArguments(string command)
-        {
-            return command == "create" ? new[] { "-azure" } : new string[0];
-        }
-
         public void MixIn(string directory)
         {
-            if (!performAzureWorkaround) return;
+            if (!Arguments.Azure) return;
             // Move everything under the _source folder
             var sourceFolder = Path.Combine(directory, "_source");
             if (!fileSystem.Directory.Exists(sourceFolder))
diff --git a/src/Pretzel.Tests/Extensibility/Extensions/AzureHostSupportTest.cs b/src/Pretzel.Tests/Extensibility/Extensions/AzureHostSupportTest.cs
index e7d4c0832..94a6a14a4 100644
--- a/src/Pretzel.Tests/Extensibility/Extensions/AzureHostSupportTest.cs
+++ b/src/Pretzel.Tests/Extensibility/Extensions/AzureHostSupportTest.cs
@@ -20,53 +20,13 @@ public AzureHostSupportTest()
             azureHostSupport = new AzureHostSupport(fileSystem, assembly);
         }
 
-        [InlineData("create")]
-        [Theory]
-        public void GetArguments_Create_Should_Return_Azure(string command)
-        {
-            // act
-            var args = azureHostSupport.GetArguments(command);
-
-            // assert
-            Assert.Single(args);
-            Assert.Equal("-azure", args[0]);
-        }
-
-        [InlineData(null)]
-        [InlineData("")]
-        [InlineData("bake")]
-        [InlineData("taste")]
-        [Theory]
-        public void GetArguments_Default_Should_Return_Empty_Array(string command)
-        {
-            // act
-            var args = azureHostSupport.GetArguments(command);
-
-            // assert
-            Assert.Empty(args);
-        }
-
-        [Fact]
-        public void UpdateOptions_Should_Add_Azure()
-        {
-            //var optionSet = new OptionSet();
-
-            //// act
-            //azureHostSupport.UpdateOptions(optionSet);
-
-            // assert
-            //Assert.Single(optionSet);
-            //Assert.Equal("azure", optionSet[0].Prototype);
-            //Assert.NotNull(optionSet[0].Description);
-        }
-
         [Fact]
         public void MixIn_AzureNotActivated_NothingHappens()
         {
             // arrange
             fileSystem.AddDirectory(@"c:\website");
-            //var optionSet = new OptionSet();
-            //azureHostSupport.UpdateOptions(optionSet);
+
+            azureHostSupport.Arguments = new AzureHostSupportArguments();
 
             // act
             azureHostSupport.MixIn(@"c:\website");
@@ -86,9 +46,10 @@ public void MixIn_AzureActivated_AllFilesAreIncluded()
             assembly.EntryAssemblyLocation = @"c:\tools\Pretzel.exe";
             fileSystem.AddFile(@"c:\tools\Pretzel.exe", MockFileData.NullObject);
 
-            //var optionSet = new OptionSet();
-            //azureHostSupport.UpdateOptions(optionSet);
-            //optionSet.Parse(new[] { "--azure" });
+            azureHostSupport.Arguments = new AzureHostSupportArguments
+            {
+                Azure = true
+            };
 
             // act
             azureHostSupport.MixIn(@"c:\website");
diff --git a/src/Pretzel.Tests/Extensibility/Extensions/VirtualDirectorySupportTests.cs b/src/Pretzel.Tests/Extensibility/Extensions/VirtualDirectorySupportTests.cs
index b7ba201fb..235a558c4 100644
--- a/src/Pretzel.Tests/Extensibility/Extensions/VirtualDirectorySupportTests.cs
+++ b/src/Pretzel.Tests/Extensibility/Extensions/VirtualDirectorySupportTests.cs
@@ -25,9 +25,8 @@ public void not_processed_when_no_argument_is_passed_in()
             // arrange
             var returnThis = Substitute.For<FileBase>();
             fileSystem.File.Returns(returnThis);
-            //var optionSet = new OptionSet();
-            //vdirSupport.UpdateOptions(optionSet);
-            //optionSet.Parse(new string[0]);
+
+            vdirSupport.Arguments = new VirtualDirectorySupportArguments();
 
             // act
             vdirSupport.Transform(new SiteContext
@@ -51,9 +50,11 @@ public void processes_only_when_vdir_argument_is_passed()
             // arrange
             var returnThis = Substitute.For<FileBase>();
             fileSystem.File.Returns(returnThis);
-            //var optionSet = new OptionSet();
-            //vdirSupport.UpdateOptions(optionSet);
-            //optionSet.Parse(new[] { "--vDir", "something" });
+
+            vdirSupport.Arguments = new VirtualDirectorySupportArguments
+            {
+                VirtualDirectory = "something"
+            };
 
             // act
             vdirSupport.Transform(new SiteContext
@@ -77,9 +78,11 @@ public void processes_only_css_and_html_files()
             // arrange
             var returnThis = Substitute.For<FileBase>();
             fileSystem.File.Returns(returnThis);
-            //var optionSet = new OptionSet();
-            //vdirSupport.UpdateOptions(optionSet);
-            //optionSet.Parse(new[] { "--vDir", "something" });
+
+            vdirSupport.Arguments = new VirtualDirectorySupportArguments
+            {
+                VirtualDirectory = "something"
+            };
 
             // act
             vdirSupport.Transform(new SiteContext
@@ -118,9 +121,11 @@ public void includes_virtual_directory_in_href()
             // arrange
             var returnThis = Substitute.For<FileBase>();
             fileSystem.File.Returns(returnThis);
-            //var optionSet = new OptionSet();
-            //vdirSupport.UpdateOptions(optionSet);
-            //optionSet.Parse(new[] { "--vDir", "something" });
+
+            vdirSupport.Arguments = new VirtualDirectorySupportArguments
+            {
+                VirtualDirectory = "something"
+            };
 
             const string body = @"<body>
 <a href=""/dir/file.html"" />
@@ -147,31 +152,5 @@ public void includes_virtual_directory_in_href()
 </body>";
             returnThis.Received().WriteAllText("Test.html", newBody);
         }
-
-        //[InlineData("bake")]
-        //[InlineData("taste")]
-        //[Theory]
-        //public void GetArguments_Bake_Or_Taste_Should_Return_VDir(string command)
-        //{
-        //    // act
-        //    var args = vdirSupport.GetArguments(command);
-
-        //    // assert
-        //    Assert.Single(args);
-        //    Assert.Equal("-vDir", args[0]);
-        //}
-
-        //[InlineData(null)]
-        //[InlineData("")]
-        //[InlineData("create")]
-        //[Theory]
-        //public void GetArguments_Default_Should_Return_Empty_Array(string command)
-        //{
-        //    // act
-        //    var args = vdirSupport.GetArguments(command);
-
-        //    // assert
-        //    Assert.Empty(args);
-        //}
     }
 }

From 5ec0c82ad5ad8965e3727288c0988f5bf81cb354 Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Tue, 24 Sep 2019 13:41:30 +0200
Subject: [PATCH 21/56] refactor: removed old parameter tests

---
 src/Pretzel.Logic/Pretzel.Logic.csproj        |   1 -
 .../Commands/BaseParameterTests.cs            | 163 -------
 .../Commands/CommandExtensions.cs             |  61 ---
 .../Commands/CommandParameterOutputTests.cs   |  91 ----
 .../Commands/CommandParameterTests.cs         | 456 ------------------
 5 files changed, 772 deletions(-)
 delete mode 100644 src/Pretzel.Tests/Commands/BaseParameterTests.cs
 delete mode 100644 src/Pretzel.Tests/Commands/CommandExtensions.cs
 delete mode 100644 src/Pretzel.Tests/Commands/CommandParameterOutputTests.cs
 delete mode 100644 src/Pretzel.Tests/Commands/CommandParameterTests.cs

diff --git a/src/Pretzel.Logic/Pretzel.Logic.csproj b/src/Pretzel.Logic/Pretzel.Logic.csproj
index 6384c2fad..6a86f459c 100644
--- a/src/Pretzel.Logic/Pretzel.Logic.csproj
+++ b/src/Pretzel.Logic/Pretzel.Logic.csproj
@@ -33,7 +33,6 @@
     <PackageReference Include="HtmlAgilityPack" Version="1.11.12" />
     <PackageReference Include="Microsoft.AspNet.Razor" Version="3.2.7" />
     <PackageReference Include="Microsoft.Windows.Compatibility" Version="2.1.1" />
-    <PackageReference Include="NDesk.Options" Version="0.2.1" />
     <PackageReference Include="NUglify" Version="1.5.13" />
     <PackageReference Include="RazorEngine" Version="3.10.0" />
     <PackageReference Include="SonarAnalyzer.CSharp" Version="7.16.0.8981">
diff --git a/src/Pretzel.Tests/Commands/BaseParameterTests.cs b/src/Pretzel.Tests/Commands/BaseParameterTests.cs
deleted file mode 100644
index 52f3bc2d2..000000000
--- a/src/Pretzel.Tests/Commands/BaseParameterTests.cs
+++ /dev/null
@@ -1,163 +0,0 @@
-using Pretzel.Logic.Commands;
-using System.Collections.Generic;
-using System.IO;
-using System.IO.Abstractions;
-using System.IO.Abstractions.TestingHelpers;
-using Xunit;
-
-namespace Pretzel.Tests
-{
-    public class BaseParameterTests
-    {
-        private const string ExpectedPath = @"D:\Code";
-
-        private readonly IFileSystem FileSystem = new MockFileSystem();
-
-        public BaseParameters GetBaseParameter(string[] args)
-        {
-            return BaseParameters.Parse(args, FileSystem);
-        }
-
-        [Fact]
-        public void WriteOptions_WithNoParametersSpecified_DisplaysAll()
-        {
-            var writer = new StringWriter();
-
-            var subject = GetBaseParameter(new string[0]);
-
-            subject.Options.WriteOptionDescriptions(writer);
-
-            var output = writer.ToString();
-
-            Assert.Contains("--directory=", output);
-            Assert.Contains("--source=", output);
-            Assert.Contains("--debug", output);
-            Assert.Contains("--help", output);
-            Assert.Contains("--safe", output);
-        }
-
-        [Fact]
-        public void Parse_CommandName_IsTheFirstParameter()
-        {
-            var subject = GetBaseParameter(new[] { "bake" });
-            Assert.Equal("bake", subject.CommandName);
-            Assert.Empty(subject.CommandArgs);
-        }
-
-        [Fact]
-        public void Parse_WhenNoParametersSet_MapsPathToCurrentDirectory()
-        {
-            var subject = GetBaseParameter(new[] { "bake" });
-            Assert.Equal(FileSystem.Directory.GetCurrentDirectory(), subject.Path);
-        }
-
-        [Fact]
-        public void Parse_WhenOneParameterSet_MapsToPath()
-        {
-            var subject = GetBaseParameter(new[] { "bake", ExpectedPath });
-            Assert.Equal(ExpectedPath, subject.Path);
-        }
-
-        [Fact]
-        public void Parse_WhenSpecifyingPathUsingShortParameter_MapsToPath()
-        {
-            var subject = GetBaseParameter(new[] { "bake", "--d", ExpectedPath });
-            Assert.Equal(ExpectedPath, subject.Path);
-        }
-
-        [Fact]
-        public void Parse_WhenSpecifyingPathUsingFullParameter_MapsToPath()
-        {
-            var subject = GetBaseParameter(new[] { "bake", "--directory", ExpectedPath });
-            Assert.Equal(ExpectedPath, subject.Path);
-        }
-
-        [Fact]
-        public void Parse_WhenSpecifyingPathUsingShortParameterSingleDash_MapsToPath()
-        {
-            var subject = GetBaseParameter(new[] { "bake", "-d", ExpectedPath });
-            Assert.Equal(ExpectedPath, subject.Path);
-        }
-
-        [Fact]
-        public void Parse_WhenSpecifyingPathUsingFullParameterSingleDash_MapsToPath()
-        {
-            var subject = GetBaseParameter(new[] { "bake", "-directory", ExpectedPath });
-            Assert.Equal(ExpectedPath, subject.Path);
-        }
-
-        [Fact]
-        public void Parse_WhenSpecifyingAllParameters_ResultIsCorrect()
-        {
-            var subject = GetBaseParameter(new[] { "bake", @"-directory=c:\mysite", "-safe", "-help", "-debug" });
-
-            Assert.Equal(@"c:\mysite", subject.Path);
-            Assert.True(subject.Safe);
-            Assert.True(subject.Help);
-            Assert.True(subject.Debug);
-            Assert.Equal("bake", subject.CommandName);
-            Assert.Empty(subject.CommandArgs);
-        }
-
-        [Fact]
-        public void Parse_WhenSpecifyingNoParameters_DefaultVeluesResultIsCorrect()
-        {
-            var args = new List<string>();
-
-            var subject = GetBaseParameter(new[] { "bake" });
-
-            Assert.Equal(FileSystem.Directory.GetCurrentDirectory(), subject.Path);
-            Assert.False(subject.Safe);
-            Assert.False(subject.Help);
-            Assert.False(subject.Debug); Assert.Equal("bake", subject.CommandName);
-            Assert.Empty(subject.CommandArgs);
-        }
-
-        [Fact]
-        public void Parse_WhenOneParameterSet_MapsToPath_RelativePath()
-        {
-            var subject = GetBaseParameter(new[] { "bake", "mySite" });
-
-            Assert.Equal(FileSystem.Path.Combine(FileSystem.Directory.GetCurrentDirectory(), "mySite"), subject.Path);
-        }
-
-        [Fact]
-        public void Parse_WhenSpecifyingSourcePathUsingShortParameter_MapsToPath()
-        {
-            var subject = GetBaseParameter(new[] { "bake", "--s", ExpectedPath });
-            Assert.Equal(ExpectedPath, subject.Path);
-        }
-
-        [Fact]
-        public void Parse_WhenSpecifyingSourcePathUsingFullParameter_MapsToPath()
-        {
-            var subject = GetBaseParameter(new[] { "bake", "--source", ExpectedPath });
-            Assert.Equal(ExpectedPath, subject.Path);
-        }
-
-        [Fact]
-        public void Parse_WhenSpecifyingSourcePathUsingShortParameterSingleDash_MapsToPath()
-        {
-            var subject = GetBaseParameter(new[] { "bake", "-s", ExpectedPath });
-            Assert.Equal(ExpectedPath, subject.Path);
-        }
-
-        [Fact]
-        public void Parse_WhenSpecifyingSourcePathUsingFullParameterSingleDash_MapsToPath()
-        {
-            var subject = GetBaseParameter(new[] { "bake", "-source", ExpectedPath });
-            Assert.Equal(ExpectedPath, subject.Path);
-        }
-
-        [Fact]
-        public void Parse_WhenSpecifyingExtraParams_ThereShouldBeInCommandArgs()
-        {
-            var subject = GetBaseParameter(new[] { "bake", "-cleantarget", "-safe", "-nobrowser", "-p=8888" });
-            Assert.NotNull(subject.CommandArgs);
-            Assert.Equal(3, subject.CommandArgs.Count);
-            Assert.Equal("-cleantarget", subject.CommandArgs[0]);
-            Assert.Equal("-nobrowser", subject.CommandArgs[1]);
-            Assert.Equal("-p=8888", subject.CommandArgs[2]);
-        }
-    }
-}
diff --git a/src/Pretzel.Tests/Commands/CommandExtensions.cs b/src/Pretzel.Tests/Commands/CommandExtensions.cs
deleted file mode 100644
index c9e628a78..000000000
--- a/src/Pretzel.Tests/Commands/CommandExtensions.cs
+++ /dev/null
@@ -1,61 +0,0 @@
-using System.IO;
-using System.Text;
-using NDesk.Options;
-using NSubstitute;
-using Pretzel.Logic.Extensibility;
-using Xunit;
-
-namespace Pretzel.Tests.Commands
-{
-    public class CommandExtensions
-    {
-        [Fact]
-        public void help_includes_dynamically_added_commands()
-        {
-            // arrange
-            var stringBuilder = new StringBuilder();
-            var optionSet = new OptionSet();
-            var extension = Substitute.For<IHaveCommandLineArgs>();
-            extension.When(e=>e.UpdateOptions(Arg.Any<OptionSet>()))
-                .Do(c=>
-                {
-                    var options = c.Arg<OptionSet>();
-
-                    options.Add<int>("newOption=", "description", v => NewOption = v);
-                });
-
-            // act
-            extension.UpdateOptions(optionSet);
-            optionSet.WriteOptionDescriptions(new StringWriter(stringBuilder));
-
-            // assert
-            var help = stringBuilder.ToString();
-            Assert.Contains("--newOption", help);
-            Assert.Contains("description", help);
-        }
-
-        [Fact]
-        public void dynamically_added_option_is_parsed()
-        {
-            // arrange
-            var optionSet = new OptionSet();
-            var extension = Substitute.For<IHaveCommandLineArgs>();
-            extension.When(e => e.UpdateOptions(Arg.Any<OptionSet>()))
-                .Do(c =>
-                {
-                    var options = c.Arg<OptionSet>();
-
-                    options.Add<int>("newOption=", "description", v => NewOption = v);
-                });
-
-            // act
-            extension.UpdateOptions(optionSet);
-            optionSet.Parse(new[] {"--newOption", "1"});
-
-            // assert
-            Assert.Equal(1, NewOption);
-        }
-
-        protected int NewOption { get; set; }
-    }
-}
\ No newline at end of file
diff --git a/src/Pretzel.Tests/Commands/CommandParameterOutputTests.cs b/src/Pretzel.Tests/Commands/CommandParameterOutputTests.cs
deleted file mode 100644
index 8c950b6cb..000000000
--- a/src/Pretzel.Tests/Commands/CommandParameterOutputTests.cs
+++ /dev/null
@@ -1,91 +0,0 @@
-using Pretzel.Logic.Commands;
-using Pretzel.Logic.Extensibility;
-using System.IO;
-using System.IO.Abstractions.TestingHelpers;
-using System.Linq;
-using Xunit;
-
-namespace Pretzel.Tests
-{
-    public class CommandParameterOutputTests
-    {
-        private readonly CommandParameters subject;
-        private readonly StringWriter writer;
-
-        public CommandParameterOutputTests()
-        {
-            subject = new CommandParameters(Enumerable.Empty<IHaveCommandLineArgs>(), new MockFileSystem());
-            writer = new StringWriter();
-        }
-
-        [Fact]
-        public void WriteOptions_WithNoParametersSpecified_DisplaysAll()
-        {
-            subject.WriteOptions(writer);
-
-            var output = writer.ToString();
-
-            Assert.Contains("-t", output);
-            Assert.Contains("--template=", output);
-            Assert.Contains("--port=", output);
-            Assert.Contains("-i", output);
-            Assert.Contains("--import=", output);
-            Assert.Contains("-f", output);
-            Assert.Contains("--file=", output);
-            Assert.Contains("--cleantarget", output);
-            Assert.Contains("--destination", output);
-        }
-
-        [Fact]
-        public void WriteOptions_WithOneParameterSpecified_DisplaysSelection()
-        {
-            subject.WriteOptions(writer, "-t");
-
-            var output = writer.ToString();
-
-            Assert.Contains("-t", output);
-            Assert.Contains("--template=", output);
-        }
-
-        [Fact]
-        public void WriteOptions_WithOneParameterSpecified_IgnoresOthers()
-        {
-            subject.WriteOptions(writer, "-t");
-
-            var output = writer.ToString();
-
-            Assert.DoesNotContain("-p", output);
-            Assert.DoesNotContain("--port=", output);
-            Assert.DoesNotContain("-i", output);
-            Assert.DoesNotContain("--import=", output);
-            Assert.DoesNotContain("-f", output);
-            Assert.DoesNotContain("--file=", output);
-        }
-
-        [Fact]
-        public void WriteOptions_WithTwoParameterSpecified_DisplaysSelection()
-        {
-            subject.WriteOptions(writer, "-t", "-p");
-
-            var output = writer.ToString();
-
-            Assert.Contains("-t", output);
-            Assert.Contains("--template=", output);
-            Assert.Contains("-p", output);
-            Assert.Contains("--port=", output);
-        }
-
-        [Fact]
-        public void WriteOptions_WithTwoParameterSpecified_IgnoresOthers()
-        {
-            subject.WriteOptions(writer, "-t", "-p");
-
-            var output = writer.ToString();
-
-            Assert.DoesNotContain("-i", output);
-            Assert.DoesNotContain("--import=", output);
-            Assert.DoesNotContain("-f", output);
-            Assert.DoesNotContain("--file=", output);
-        }
-    }
-}
diff --git a/src/Pretzel.Tests/Commands/CommandParameterTests.cs b/src/Pretzel.Tests/Commands/CommandParameterTests.cs
deleted file mode 100644
index 952210ab4..000000000
--- a/src/Pretzel.Tests/Commands/CommandParameterTests.cs
+++ /dev/null
@@ -1,456 +0,0 @@
-using NDesk.Options;
-using NSubstitute;
-using Pretzel.Logic;
-using Pretzel.Logic.Commands;
-using Pretzel.Logic.Extensibility;
-using Pretzel.Logic.Templating;
-using Pretzel.Logic.Templating.Context;
-using System.Collections.Generic;
-using System.IO.Abstractions;
-using System.IO.Abstractions.TestingHelpers;
-using System.Linq;
-using Xunit;
-
-namespace Pretzel.Tests
-{
-    public class CommandParameterTests
-    {
-        private readonly CommandParameters subject;
-        private const string ExpectedPath = @"D:\Code";
-        private const string ExpectedImportFile = @"D:\Code\import.xml";
-        private const string ExpectedImportType = "wordpress";
-        private const string ExpectedTemplate = @"jekyll";
-        private const string ExpectedPort = "8000";
-        private const decimal ExpectedPortDecimal = 8000;
-        private const string ExpectedDestinationPath = @"D:\Code\Generated";
-        private const string ExpectedNewPostTitle = @"Post title";
-
-        private readonly IFileSystem FileSystem = new MockFileSystem();
-
-        public CommandParameterTests()
-        {
-            subject = new CommandParameters(Enumerable.Empty<IHaveCommandLineArgs>(), FileSystem) { Path = ExpectedPath };
-        }
-
-        [Fact]
-        public void Parse_WhenSpecifyingTemplateUsingShortParameter_MapsToPath()
-        {
-            var args = new List<string> { "--t", ExpectedTemplate };
-            subject.Parse(args);
-            Assert.Equal(ExpectedTemplate, subject.Template);
-        }
-
-        [Fact]
-        public void Parse_WhenSpecifyingTemplateUsingFullParameter_MapsToPath()
-        {
-            var args = new List<string> { "--template", ExpectedTemplate };
-            subject.Parse(args);
-            Assert.Equal(ExpectedTemplate, subject.Template);
-        }
-
-        [Fact]
-        public void Parse_WhenSpecifyingTemplateUsingShortParameterSingleDash_MapsToPath()
-        {
-            var args = new List<string> { "-t", ExpectedTemplate };
-            subject.Parse(args);
-            Assert.Equal(ExpectedTemplate, subject.Template);
-        }
-
-        [Fact]
-        public void Parse_WhenSpecifyingTemplateUsingFullParameterSingleDash_MapsToPath()
-        {
-            var args = new List<string> { "-template", ExpectedTemplate };
-            subject.Parse(args);
-            Assert.Equal(ExpectedTemplate, subject.Template);
-        }
-
-        [Fact]
-        public void Parse_WhenSpecifyingPortWithoutParamerers_IsGreaterThanZero()
-        {
-            Assert.True(subject.Port > 0);
-        }
-
-        [Fact]
-        public void Parse_WhenSpecifyingPortUsingShortParameter_MapsToPath()
-        {
-            var args = new List<string> { "--p", ExpectedPort };
-            subject.Parse(args);
-            Assert.Equal(ExpectedPortDecimal, subject.Port);
-        }
-
-        [Fact]
-        public void Parse_WhenSpecifyingPortUsingFullParameter_MapsToPath()
-        {
-            var args = new List<string> { "--port", ExpectedPort };
-            subject.Parse(args);
-            Assert.Equal(ExpectedPortDecimal, subject.Port);
-        }
-
-        [Fact]
-        public void Parse_WhenSpecifyingPortUsingShortParameterSingleDash_MapsToPath()
-        {
-            var args = new List<string> { "-p", ExpectedPort };
-            subject.Parse(args);
-            Assert.Equal(ExpectedPortDecimal, subject.Port);
-        }
-
-        [Fact]
-        public void Parse_WhenSpecifyingPortUsingFullParameterSingleDash_MapsToPath()
-        {
-            var args = new List<string> { "-port", ExpectedPort };
-            subject.Parse(args);
-            Assert.Equal(ExpectedPortDecimal, subject.Port);
-        }
-
-        [Fact]
-        public void Parse_WhenSpecifyingImportFileUsingShortParameter_MapsToPath()
-        {
-            var args = new List<string> { "--f", ExpectedImportFile };
-            subject.Parse(args);
-            Assert.Equal(ExpectedImportFile, subject.ImportPath);
-        }
-
-        [Fact]
-        public void Parse_WhenSpecifyingImportFileUsingFullParameter_MapsToPath()
-        {
-            var args = new List<string> { "--file", ExpectedImportFile };
-            subject.Parse(args);
-            Assert.Equal(ExpectedImportFile, subject.ImportPath);
-        }
-
-        [Fact]
-        public void Parse_WhenSpecifyingImportFileUsingShortParameterSingleDash_MapsToPath()
-        {
-            var args = new List<string> { "-f", ExpectedImportFile };
-            subject.Parse(args);
-            Assert.Equal(ExpectedImportFile, subject.ImportPath);
-        }
-
-        [Fact]
-        public void Parse_WhenSpecifyingImportFileUsingFullParameterSingleDash_MapsToPath()
-        {
-            var args = new List<string> { "-file", ExpectedImportFile };
-            subject.Parse(args);
-            Assert.Equal(ExpectedImportFile, subject.ImportPath);
-        }
-
-        [Fact]
-        public void Parse_WhenSpecifyingImportTypeUsingShortParameter_MapsToPath()
-        {
-            var args = new List<string> { "--i", ExpectedImportType };
-            subject.Parse(args);
-            Assert.Equal(ExpectedImportType, subject.ImportType);
-        }
-
-        [Fact]
-        public void Parse_WhenSpecifyingImportTypeUsingFullParameter_MapsToPath()
-        {
-            var args = new List<string> { "--import", ExpectedImportType };
-            subject.Parse(args);
-            Assert.Equal(ExpectedImportType, subject.ImportType);
-        }
-
-        [Fact]
-        public void Parse_WhenSpecifyingImportTypeUsingShortParameterSingleDash_MapsToPath()
-        {
-            var args = new List<string> { "-i", ExpectedImportType };
-            subject.Parse(args);
-            Assert.Equal(ExpectedImportType, subject.ImportType);
-        }
-
-        [Fact]
-        public void Parse_WhenSpecifyingImportTypeUsingFullParameterSingleDash_MapsToPath()
-        {
-            var args = new List<string> { "-import", ExpectedImportType };
-            subject.Parse(args);
-            Assert.Equal(ExpectedImportType, subject.ImportType);
-        }
-
-        [Fact]
-        public void LaunchBrowser_WhenSpecifyingEmptyList_IsTrue()
-        {
-            var args = new List<string>();
-            subject.Parse(args);
-            Assert.True(subject.LaunchBrowser);
-        }
-
-        [Fact]
-        public void LaunchBrowser_WhenSpecifyingNoBrowserDoubleDash_IsFalse()
-        {
-            var args = new List<string> { "--nobrowser" };
-            subject.Parse(args);
-            Assert.False(subject.LaunchBrowser);
-        }
-
-        [Fact]
-        public void LaunchBrowser_WhenSpecifyingNoBrowserSingleDash_IsFalse()
-        {
-            var args = new List<string> { "-nobrowser" };
-            subject.Parse(args);
-            Assert.False(subject.LaunchBrowser);
-        }
-
-        [Fact]
-        public void IncludeDrafts_WhenSpecifyingEmptyList_IsFalse()
-        {
-            var args = new List<string>();
-            subject.Parse(args);
-            Assert.False(subject.IncludeDrafts);
-        }
-
-        [Fact]
-        public void IncludeDrafts_WhenSpecifyingDraftsDoubleDash_IsTrue()
-        {
-            var args = new List<string> { "--drafts" };
-            subject.Parse(args);
-            Assert.True(subject.IncludeDrafts);
-        }
-
-        [Fact]
-        public void IncludeDrafts_WhenSpecifyingDraftsSingleDash_IsTrue()
-        {
-            var args = new List<string> { "-drafts" };
-            subject.Parse(args);
-            Assert.True(subject.IncludeDrafts);
-        }
-
-        [Fact]
-        public void LaunchBrowser_WhenSpecifyingCleanTargetDoubleDash_IsTrue()
-        {
-            var args = new List<string> { "--cleantarget" };
-            subject.Parse(args);
-            Assert.True(subject.CleanTarget);
-        }
-
-        [Fact]
-        public void LaunchBrowser_WhenSpecifyingCleanTargetSingleDash_IsTrue()
-        {
-            var args = new List<string> { "-cleantarget" };
-            subject.Parse(args);
-            Assert.True(subject.CleanTarget);
-        }
-
-        [Fact]
-        public void LaunchBrowser_WhenNotSpecifyingCleanTarget_IsFalse()
-        {
-            var args = new List<string>();
-            subject.Parse(args);
-            Assert.False(subject.CleanTarget);
-        }
-
-        [Fact]
-        public void Parse_WhenSpecifyingNewPostTitleUsingShortParameter_MapsToPath()
-        {
-            var args = new List<string> { "--n", ExpectedNewPostTitle };
-            subject.Parse(args);
-            Assert.Equal(ExpectedNewPostTitle, subject.NewPostTitle);
-        }
-
-        [Fact]
-        public void Parse_WhenSpecifyingNewPostTitleUsingFullParameter_MapsToPath()
-        {
-            var args = new List<string> { "--newposttitle", ExpectedNewPostTitle };
-            subject.Parse(args);
-            Assert.Equal(ExpectedNewPostTitle, subject.NewPostTitle);
-        }
-
-        [Fact]
-        public void Parse_WhenSpecifyingNewPostTitleUsingShortParameterSingleDash_MapsToPath()
-        {
-            var args = new List<string> { "-n", ExpectedNewPostTitle };
-            subject.Parse(args);
-            Assert.Equal(ExpectedNewPostTitle, subject.NewPostTitle);
-        }
-
-        [Fact]
-        public void Parse_WhenSpecifyingNewPostTitleUsingFullParameterSingleDash_MapsToPath()
-        {
-            var args = new List<string> { "-newposttitle", ExpectedNewPostTitle };
-            subject.Parse(args);
-            Assert.Equal(ExpectedNewPostTitle, subject.NewPostTitle);
-        }
-
-        [Fact]
-        public void CommandParameters_WhenSpecifyingAllParameters_ResultIsCorrect()
-        {
-            var args = new List<string> { "-template=jekyll", "-port=8182", "-import=blogger", "-file=BloggerExport.xml", "-drafts", "-nobrowser", "-withproject", "-wiki", "-cleantarget" };
-
-            subject.Parse(args);
-
-            Assert.Equal("jekyll", subject.Template);
-            Assert.Equal(8182, subject.Port);
-            Assert.Equal("blogger", subject.ImportType);
-            Assert.Equal("BloggerExport.xml", subject.ImportPath);
-            Assert.True(subject.IncludeDrafts);
-            Assert.False(subject.LaunchBrowser);
-            Assert.True(subject.WithProject);
-            Assert.True(subject.Wiki);
-            Assert.True(subject.CleanTarget);
-            Assert.Equal(FileSystem.Path.Combine(subject.Path, "_site"), subject.DestinationPath);
-        }
-
-        [Fact]
-        public void CommandParameters_WhenSpecifyingNoParameters_DefaultVeluesResultIsCorrect()
-        {
-            var args = new List<string>();
-
-            subject.Parse(args);
-
-            Assert.Equal(8080, subject.Port);
-            Assert.True(subject.LaunchBrowser);
-            Assert.Null(subject.Template);
-            Assert.Null(subject.ImportType);
-            Assert.Null(subject.ImportPath);
-            Assert.False(subject.IncludeDrafts);
-            Assert.False(subject.WithProject);
-            Assert.False(subject.Wiki);
-            Assert.False(subject.CleanTarget);
-            Assert.Equal(FileSystem.Path.Combine(subject.Path, "_site"), subject.DestinationPath);
-        }
-
-        [Fact]
-        public void CommandParameters_WhenSpecifyingCommandExtension_ExtensionParameterIsParsed()
-        {
-            var extension = Substitute.For<IHaveCommandLineArgs>();
-            extension.When(e => e.UpdateOptions(Arg.Any<OptionSet>()))
-                .Do(c =>
-                {
-                    var options = c.Arg<OptionSet>();
-
-                    options.Add<string>("newOption=", "description", v => NewOption = v);
-                });
-
-            var subject = new CommandParameters(new List<IHaveCommandLineArgs> { extension }, new MockFileSystem()) { Path = ExpectedPath };
-            var args = new List<string> { "-newOption=test" };
-
-            subject.Parse(args);
-
-            Assert.Equal("test", NewOption);
-        }
-
-        protected string NewOption { get; set; }
-
-        [Fact]
-        public void DetectFromDirectory_WhenSpecifyingNoSiteEngines_DefaultValueIsLiquid()
-        {
-            var siteContext = new SiteContext();
-
-            subject.DetectFromDirectory(new Dictionary<string, ISiteEngine>(), siteContext);
-
-            Assert.Equal("liquid", subject.Template);
-        }
-
-        [Fact]
-        public void DetectFromDirectory_WhenSpecifyingTwoSiteEngines_CorrectValueIsPicked()
-        {
-            var siteContext = new SiteContext { Config = new ConfigurationMock(new Dictionary<string, object> { { "pretzel", new Dictionary<string, object> { { "engine", "engine2" } } } }) };
-
-            var siteEngine1 = Substitute.For<ISiteEngine>();
-            siteEngine1.CanProcess(Arg.Any<SiteContext>())
-                .Returns(ci => ci.Arg<SiteContext>().Engine == "engine1");
-
-            var siteEngine2 = Substitute.For<ISiteEngine>();
-            siteEngine2.CanProcess(Arg.Any<SiteContext>())
-                .Returns(ci => ci.Arg<SiteContext>().Engine == "engine2");
-
-            var siteEngines = new Dictionary<string, ISiteEngine>
-            {
-                { "engine1", siteEngine1 },
-                { "engine2", siteEngine2 },
-            };
-
-            subject.DetectFromDirectory(siteEngines, siteContext);
-
-            Assert.Equal("engine2", subject.Template);
-        }
-
-        [Fact]
-        public void DetectFromDirectory_WhenSpecifyingNoPretzelConfig_DefaultValueIsLiquid()
-        {
-            var siteContext = new SiteContext { Config = new Configuration() };
-
-            var siteEngine1 = Substitute.For<ISiteEngine>();
-            siteEngine1.CanProcess(Arg.Any<SiteContext>())
-                .Returns(ci => ci.Arg<SiteContext>().Engine == "engine1");
-
-            var siteEngines = new Dictionary<string, ISiteEngine>
-            {
-                { "engine1", siteEngine1 }
-            };
-
-            subject.DetectFromDirectory(siteEngines, siteContext);
-
-            Assert.Equal("liquid", subject.Template);
-        }
-
-        [Fact]
-        public void DetectFromDirectory_WhenSpecifyingNoEnginInPretzelConfig_DefaultValueIsLiquid()
-        {
-            var siteContext = new SiteContext { Config = new ConfigurationMock(new Dictionary<string, object> { { "pretzel", new Dictionary<string, object> { } } }) };
-
-            var siteEngine1 = Substitute.For<ISiteEngine>();
-            siteEngine1.CanProcess(Arg.Any<SiteContext>())
-                .Returns(ci => ci.Arg<SiteContext>().Engine == "engine1");
-
-            var siteEngines = new Dictionary<string, ISiteEngine>
-            {
-                { "engine1", siteEngine1 }
-            };
-
-            subject.DetectFromDirectory(siteEngines, siteContext);
-
-            Assert.Equal("liquid", subject.Template);
-        }
-
-        [Fact]
-        public void DetectFromDirectory_WhenSpecifyingPretzelConfigSimpleValue_DefaultValueIsLiquid()
-        {
-            var siteContext = new SiteContext { Config = new ConfigurationMock(new Dictionary<string, object> { { "pretzel", 42 } }) };
-
-            var siteEngine1 = Substitute.For<ISiteEngine>();
-            siteEngine1.CanProcess(Arg.Any<SiteContext>())
-                .Returns(ci => ci.Arg<SiteContext>().Engine == "engine1");
-
-            var siteEngines = new Dictionary<string, ISiteEngine>
-            {
-                { "engine1", siteEngine1 }
-            };
-
-            subject.DetectFromDirectory(siteEngines, siteContext);
-
-            Assert.Equal("liquid", subject.Template);
-        }
-
-        [Fact]
-        public void Parse_WhenSpecifyingDestinationPathUsingFullParameter_MapsToPath()
-        {
-            var args = new List<string> { "--destination", ExpectedDestinationPath };
-            subject.Parse(args);
-            Assert.Equal(ExpectedDestinationPath, subject.DestinationPath);
-        }
-
-        [Fact]
-        public void Parse_WhenSpecifyingDestinationPathUsingFullParameterSingleDash_MapsToPath()
-        {
-            var args = new List<string> { "-destination", ExpectedDestinationPath };
-            subject.Parse(args);
-            Assert.Equal(ExpectedDestinationPath, subject.DestinationPath);
-        }
-
-        [Fact]
-        public void Parse_WhenNoParametersSet_MapsDestinationPathTo_siteInCurrentDirectory()
-        {
-            var args = new List<string>();
-            subject.Parse(args);
-            Assert.Equal(FileSystem.Path.Combine(subject.Path, "_site"), subject.DestinationPath);
-        }
-
-        [Fact]
-        public void Parse_WhenNoParametersSet_MapsNewPostTileToNewPost()
-        {
-            var args = new List<string>();
-            subject.Parse(args);
-            Assert.Equal("New post", subject.NewPostTitle);
-        }
-    }
-}

From a7536ab44647e6216621f775e6ab93cc8933efd8 Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Wed, 25 Sep 2019 09:59:21 +0200
Subject: [PATCH 22/56] test: ICommandParametersExtentionsTests

---
 .../ICommandParametersExtentionsTests.cs      | 121 ++++++++++++++++++
 1 file changed, 121 insertions(+)
 create mode 100644 src/Pretzel.Tests/Commands/ICommandParametersExtentionsTests.cs

diff --git a/src/Pretzel.Tests/Commands/ICommandParametersExtentionsTests.cs b/src/Pretzel.Tests/Commands/ICommandParametersExtentionsTests.cs
new file mode 100644
index 000000000..f3c7e74aa
--- /dev/null
+++ b/src/Pretzel.Tests/Commands/ICommandParametersExtentionsTests.cs
@@ -0,0 +1,121 @@
+using Pretzel.Logic.Commands;
+using Pretzel.Logic.Extensibility;
+using System;
+using System.Collections.Generic;
+using System.CommandLine;
+using System.Composition;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+using System.Composition.Hosting;
+
+namespace Pretzel.Tests.Commands
+{
+    public class ICommandParametersExtentionsTests : IDisposable
+    {
+        CompositionHost Container;
+        public ICommandParametersExtentionsTests()
+        {
+            var configuration = new ContainerConfiguration();
+            configuration.WithPart<TestArguments1Class>();
+            configuration.WithPart<TestArguments2Class>();
+            configuration.WithPart<Extender1>();
+            configuration.WithPart<Extender2>();
+            configuration.WithPart<Extender3>();
+            Container = configuration.CreateContainer();
+        }
+
+        [Fact]
+        public void CollectsOnlyCommandsWhereNamesMatch1()
+        {
+            var target1 = Container.GetExport<TestArguments1Class>();
+
+            var extentions = target1.GetCommandExtentions().ToList();
+
+            Assert.Equal(2, extentions.Count);
+            Assert.Contains(extentions, e => e.CreateExport().Value is Extender1);
+            Assert.Contains(extentions, e => e.CreateExport().Value is Extender3);
+
+        }
+
+        [Fact]
+        public void CollectsOnlyCommandsWhereNamesMatch2()
+        {
+            var target1 = Container.GetExport<TestArguments2Class>();
+
+            var extentions = target1.GetCommandExtentions().ToList();
+
+            Assert.Equal(2, extentions.Count);
+            Assert.Contains(extentions, e => e.CreateExport().Value is Extender2);
+            Assert.Contains(extentions, e => e.CreateExport().Value is Extender3);
+
+        }
+
+        public void Dispose()
+            => Container?.Dispose();
+
+        [Export]
+        [Shared]
+        [CommandArguments(CommandName = "test1")]
+        public class TestArguments1Class : ICommandParameters, ICommandParametersExtendable
+        {
+            [ImportMany]
+            public ExportFactory<IHaveCommandLineArgs, CommandArgumentsExtentionAttribute>[] ArgumentExtenders { get; set; }
+
+            public IList<Option> Options => new List<Option>();
+
+            public void BindingCompleted() { }
+        }
+
+        [Export]
+        [Shared]
+        [CommandArguments(CommandName = "test2")]
+        public class TestArguments2Class : ICommandParameters, ICommandParametersExtendable
+        {
+            [ImportMany]
+            public ExportFactory<IHaveCommandLineArgs, CommandArgumentsExtentionAttribute>[] ArgumentExtenders { get; set; }
+
+            public IList<Option> Options => new List<Option>();
+
+            public void BindingCompleted() { }
+        }
+
+        [CommandArgumentsExtention(CommandNames = new[] { "test1" })]
+        public class Extender1 : IHaveCommandLineArgs
+        {
+            public void UpdateOptions(IList<Option> options)
+            {
+            }
+
+            public void BindingCompleted()
+            {
+            }
+        }
+
+        [CommandArgumentsExtention(CommandNames = new[] { "test2" })]
+        public class Extender2 : IHaveCommandLineArgs
+        {
+            public void UpdateOptions(IList<Option> options)
+            {
+            }
+
+            public void BindingCompleted()
+            {
+            }
+        }
+
+        [CommandArgumentsExtention(CommandNames = new[] { "test1", "test2" })]
+        public class Extender3 : IHaveCommandLineArgs
+        {
+            public void UpdateOptions(IList<Option> options)
+            {
+            }
+
+            public void BindingCompleted()
+            {
+            }
+        }
+
+    }
+}

From 8ba9c37ba8619426f9a1419016c58c6aa1b45016 Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Wed, 25 Sep 2019 12:36:03 +0200
Subject: [PATCH 23/56] test: BaseParametersTests

---
 .../Commands/BaseParametersTests.cs           | 58 +++++++++++++++++++
 1 file changed, 58 insertions(+)
 create mode 100644 src/Pretzel.Tests/Commands/BaseParametersTests.cs

diff --git a/src/Pretzel.Tests/Commands/BaseParametersTests.cs b/src/Pretzel.Tests/Commands/BaseParametersTests.cs
new file mode 100644
index 000000000..ab7431b2a
--- /dev/null
+++ b/src/Pretzel.Tests/Commands/BaseParametersTests.cs
@@ -0,0 +1,58 @@
+using Pretzel.Logic.Commands;
+using Pretzel.Logic.Extensibility;
+using System;
+using System.Collections.Generic;
+using System.CommandLine;
+using System.Composition;
+using System.Composition.Hosting;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace Pretzel.Tests.Commands
+{
+    public class BaseParametersTests
+    {
+        [Export]
+        [Shared]
+        [CommandArguments(CommandName = "test")]
+        public class BaseParametersImpl : BaseParameters
+        {
+            protected override void WithOptions(List<Option> options)
+            {
+                options.Add(new Option("-base"));
+            }
+        }
+
+        [Export]
+        [Shared]
+        [CommandArgumentsExtention(CommandNames = new[] { "test" })]
+        public class BaseParametersImplExt : IHaveCommandLineArgs
+        {
+            public void UpdateOptions(IList<Option> options)
+            {
+                options.Add(new Option("-ext"));
+            }
+
+            public void BindingCompleted()
+            {
+            }
+        }
+
+        [Fact]
+        public void ExtentionIsPossible()
+        {
+            var configuration = new ContainerConfiguration();
+            configuration.WithPart<BaseParametersImpl>();
+            configuration.WithPart<BaseParametersImplExt>();
+            using(var container = configuration.CreateContainer())
+            {
+                var sut = container.GetExport<BaseParametersImpl>();
+
+                Assert.Contains(sut.Options, o => o.Name == "base");
+                Assert.Contains(sut.Options, o => o.Name == "ext");
+            }
+        }
+    }
+}

From f8b1ab861642be04f1cd79a0fe9dabb1ec648659 Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Wed, 25 Sep 2019 13:54:45 +0200
Subject: [PATCH 24/56] test: CommandCollection tests

---
 src/Pretzel.Logic/Properties/AssemblyInfo.cs  |   4 +-
 .../Commands/CommandCollectionTests.cs        | 135 ++++++++++++++++++
 src/Pretzel.Tests/Properties/AssemblyInfo.cs  |   2 +-
 src/Pretzel/Commands/CommandCollection.cs     |  26 ++--
 src/Pretzel/Commands/PretzelCommandHandler.cs |  28 ++--
 src/Pretzel/Properties/AssemblyInfo.cs        |   5 +-
 6 files changed, 174 insertions(+), 26 deletions(-)
 create mode 100644 src/Pretzel.Tests/Commands/CommandCollectionTests.cs

diff --git a/src/Pretzel.Logic/Properties/AssemblyInfo.cs b/src/Pretzel.Logic/Properties/AssemblyInfo.cs
index 8f62d7b41..6f610cfdb 100644
--- a/src/Pretzel.Logic/Properties/AssemblyInfo.cs
+++ b/src/Pretzel.Logic/Properties/AssemblyInfo.cs
@@ -1,4 +1,4 @@
-using System.Reflection;
+using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
@@ -8,5 +8,5 @@
 
 // The following GUID is for the ID of the typelib if this project is exposed to COM
 [assembly: Guid("0d958789-078b-4ec7-8491-2850070bf340")]
-[assembly: InternalsVisibleTo("Pretzel.Tests")]
 [assembly: InternalsVisibleTo("Pretzel")]
+[assembly: InternalsVisibleTo("Pretzel.Tests")]
diff --git a/src/Pretzel.Tests/Commands/CommandCollectionTests.cs b/src/Pretzel.Tests/Commands/CommandCollectionTests.cs
new file mode 100644
index 000000000..a27589251
--- /dev/null
+++ b/src/Pretzel.Tests/Commands/CommandCollectionTests.cs
@@ -0,0 +1,135 @@
+using NSubstitute;
+using Pretzel.Commands;
+using Pretzel.Logic;
+using Pretzel.Logic.Commands;
+using System;
+using System.Collections.Generic;
+using System.CommandLine;
+using System.Composition;
+using System.Linq;
+using Xunit;
+
+namespace Pretzel.Tests.Commands
+{
+    public class CommandCollectionTests
+    {
+        [Fact]
+        public void RootCommandGetsCreatedOnImportSatisfied()
+        {
+            var collection = new CommandCollection();
+            collection.OnImportsSatisfied();
+            Assert.NotNull(collection.RootCommand);
+        }
+
+        [Fact]
+        public void SubCommandAreAddedToRootCommand()
+        {
+            var collection = new CommandCollection
+            {
+                Commands = new ExportFactory<Pretzel.Commands.ICommand, CommandInfoAttribute>[]
+                {
+                    new ExportFactory<Pretzel.Commands.ICommand, CommandInfoAttribute>(CreateCommand, new CommandInfoAttribute{ CommandName = "test", CommandDescription = "desc" })
+                }
+            };
+            collection.OnImportsSatisfied();
+
+            Assert.Contains(collection.RootCommand.Children.OfType<Command>(), c => c.Name == "test");
+            Assert.Contains(collection.RootCommand.Children.OfType<Command>(), c => c.Description == "desc");
+        }
+
+        [Fact]
+        public void SubCommandsWithoutArgumentGetsHandler()
+        {
+            var exportFactory = new ExportFactory<Pretzel.Commands.ICommand, CommandInfoAttribute>(
+                CreateCommand,
+                new CommandInfoAttribute
+                {
+                    CommandName = "test",
+                    CommandDescription = "desc"
+                });
+
+            var collection = new CommandCollection
+            {
+                Configuration = Substitute.For<IConfiguration>(),
+                Commands = new ExportFactory<Pretzel.Commands.ICommand, CommandInfoAttribute>[]
+                {
+                    exportFactory
+                }
+            };
+
+            collection.OnImportsSatisfied();
+
+            var command = collection.RootCommand.Children.OfType<Command>().First();
+            Assert.NotNull(command.Handler);
+            Assert.IsType<PretzelCommandHandler>(command.Handler);
+            Assert.Null(((PretzelCommandHandler)command.Handler).CommandParameters);
+            Assert.NotNull(((PretzelCommandHandler)command.Handler).Configuration);
+            Assert.Equal(collection.Configuration, ((PretzelCommandHandler)command.Handler).Configuration);
+            Assert.NotNull(((PretzelCommandHandler)command.Handler).Command);
+            Assert.Equal(exportFactory, ((PretzelCommandHandler)command.Handler).Command);
+        }
+
+        [Fact]
+        public void SubCommandsWithArgumentGetsHandler()
+        {
+            var parameters = Substitute.For<ICommandParameters>();
+            parameters.Options.Returns(new List<Option>
+            {
+                new Option("-i")
+            });
+
+            var commandExportFactory = new ExportFactory<Pretzel.Commands.ICommand, CommandInfoAttribute>(
+                CreateCommand,
+                new CommandInfoAttribute
+                {
+                    CommandName = "test",
+                    CommandDescription = "desc"
+                });
+
+            var argumentExportFactory = new ExportFactory<Logic.Commands.ICommandParameters, Logic.Commands.CommandArgumentsAttribute>(
+                () => CreateArgument(parameters),
+                new Logic.Commands.CommandArgumentsAttribute
+                {
+                    CommandName = "test"
+                });
+
+            var collection = new CommandCollection
+            {
+                Configuration = Substitute.For<IConfiguration>(),
+                Commands = new ExportFactory<Pretzel.Commands.ICommand, CommandInfoAttribute>[]
+                {
+                    commandExportFactory
+                },
+                CommandArguments = new ExportFactory<Logic.Commands.ICommandParameters, Logic.Commands.CommandArgumentsAttribute>[]
+                {
+                    argumentExportFactory,
+                    new ExportFactory<Logic.Commands.ICommandParameters, Logic.Commands.CommandArgumentsAttribute>(
+                    () => CreateArgument(Substitute.For<ICommandParameters>()),
+                    new Logic.Commands.CommandArgumentsAttribute
+                    {
+                        CommandName = "othercommand"
+                    })
+                }
+            };
+
+            collection.OnImportsSatisfied();
+
+            var command = collection.RootCommand.Children.OfType<Command>().First();
+
+            Assert.Single(command.OfType<Option>());
+            Assert.NotNull(command.Handler);
+            Assert.IsType<PretzelCommandHandler>(command.Handler);
+            Assert.NotNull(((PretzelCommandHandler)command.Handler).CommandParameters);
+            Assert.Equal(parameters, ((PretzelCommandHandler)command.Handler).CommandParameters);
+            Assert.NotNull(((PretzelCommandHandler)command.Handler).Configuration);
+            Assert.Equal(collection.Configuration, ((PretzelCommandHandler)command.Handler).Configuration);
+            Assert.NotNull(((PretzelCommandHandler)command.Handler).Command);
+            Assert.Equal(commandExportFactory, ((PretzelCommandHandler)command.Handler).Command);
+        }
+
+        Tuple<Pretzel.Commands.ICommand, Action> CreateCommand()
+            => Tuple.Create(Substitute.For<Pretzel.Commands.ICommand>(), new Action(() => { }));
+        Tuple<ICommandParameters, Action> CreateArgument(ICommandParameters parameters)
+            => Tuple.Create(parameters, new Action(() => { }));
+    }
+}
diff --git a/src/Pretzel.Tests/Properties/AssemblyInfo.cs b/src/Pretzel.Tests/Properties/AssemblyInfo.cs
index afffa2323..64a409eef 100644
--- a/src/Pretzel.Tests/Properties/AssemblyInfo.cs
+++ b/src/Pretzel.Tests/Properties/AssemblyInfo.cs
@@ -1,4 +1,4 @@
-using System.Reflection;
+using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using Xunit;
diff --git a/src/Pretzel/Commands/CommandCollection.cs b/src/Pretzel/Commands/CommandCollection.cs
index ab691635e..31853c379 100644
--- a/src/Pretzel/Commands/CommandCollection.cs
+++ b/src/Pretzel/Commands/CommandCollection.cs
@@ -11,11 +11,21 @@ namespace Pretzel.Commands
     [Shared]
     public sealed class CommandCollection
     {
+        ExportFactory<ICommand, CommandInfoAttribute>[] commands;
         [ImportMany]
-        public ExportFactory<ICommand, CommandInfoAttribute>[] Commands { get; set; }
+        public ExportFactory<ICommand, CommandInfoAttribute>[] Commands
+        {
+            get => commands ?? new ExportFactory<ICommand, CommandInfoAttribute>[] { };
+            set => commands = value;
+        }
 
+        ExportFactory<ICommandParameters, CommandArgumentsAttribute>[] commandArguments;
         [ImportMany]
-        public ExportFactory<ICommandParameters, CommandArgumentsAttribute>[] CommandArguments { get; set; }
+        public ExportFactory<ICommandParameters, CommandArgumentsAttribute>[] CommandArguments
+        {
+            get => commandArguments ?? new ExportFactory<ICommandParameters, CommandArgumentsAttribute>[] { };
+            set => commandArguments = value;
+        }
 
         [Export]
         public RootCommand RootCommand { get; set; }
@@ -24,7 +34,7 @@ public sealed class CommandCollection
         public IConfiguration Configuration { get; set; }
 
         [OnImportsSatisfied]
-        public void OnImportsSatisfied()
+        internal void OnImportsSatisfied()
         {
             RootCommand = new RootCommand();
 
@@ -32,19 +42,19 @@ public void OnImportsSatisfied()
             {
                 var subCommand = new Command(command.Metadata.CommandName, command.Metadata.CommandDescription);
 
-                foreach (var commandArgumentsExport in CommandArguments.Where(a => a.Metadata.CommandName == command.Metadata.CommandName))
+                foreach (var commandArgumentsExport in CommandArguments?.Where(a => a.Metadata.CommandName == command.Metadata.CommandName))
                 {
-                    var commandArguments = commandArgumentsExport.CreateExport().Value;
+                    var args = commandArgumentsExport.CreateExport().Value;
 
-                    foreach (var option in commandArguments.Options)
+                    foreach (var option in args.Options)
                     {
                         subCommand.AddOption(option);
                     }
 
-                    subCommand.Handler = new PretzelCommandHandler(Configuration, commandArguments, command);
+                    subCommand.Handler = new PretzelCommandHandler(Configuration, args, command);
                 }
 
-                if(subCommand.Handler == null)
+                if (subCommand.Handler == null)
                 {
                     subCommand.Handler = new PretzelCommandHandler(Configuration, null, command);
                 }
diff --git a/src/Pretzel/Commands/PretzelCommandHandler.cs b/src/Pretzel/Commands/PretzelCommandHandler.cs
index 38a7a48ee..7958e824a 100644
--- a/src/Pretzel/Commands/PretzelCommandHandler.cs
+++ b/src/Pretzel/Commands/PretzelCommandHandler.cs
@@ -11,35 +11,35 @@ namespace Pretzel.Commands
 {
     public class PretzelCommandHandler : ICommandHandler
     {
-        private readonly ICommandParameters commandParameters;
-        private readonly ExportFactory<ICommand, CommandInfoAttribute> command;
-        private readonly IConfiguration configuration;
+        public ICommandParameters CommandParameters { get; }
+        public ExportFactory<ICommand, CommandInfoAttribute> Command { get; }
+        public IConfiguration Configuration { get; }
 
         public PretzelCommandHandler(IConfiguration configuration, ICommandParameters commandParameters, ExportFactory<ICommand, CommandInfoAttribute> command)
         {
-            this.configuration = configuration;
-            this.commandParameters = commandParameters;
-            this.command = command;
+            Configuration = configuration;
+            CommandParameters = commandParameters;
+            Command = command;
         }
 
         public async Task<int> InvokeAsync(InvocationContext context)
         {
             var bindingContext = context.BindingContext;
 
-            if (commandParameters != null)
+            if (CommandParameters != null)
             {
-                new ModelBinder(commandParameters.GetType())
-                   .UpdateInstance(commandParameters, bindingContext);
+                new ModelBinder(CommandParameters.GetType())
+                   .UpdateInstance(CommandParameters, bindingContext);
 
-                commandParameters.BindingCompleted();
+                CommandParameters.BindingCompleted();
             }
 
-            if (commandParameters is IPathProvider pathProvider)
+            if (CommandParameters is IPathProvider pathProvider)
             {
-                configuration.ReadFromFile(pathProvider.Path);
+                Configuration.ReadFromFile(pathProvider.Path);
             }
 
-            if (commandParameters is ICommandParametersExtendable commandParametersExtendable)
+            if (CommandParameters is ICommandParametersExtendable commandParametersExtendable)
             {
                 foreach (var factory in commandParametersExtendable.GetCommandExtentions())
                 {
@@ -52,7 +52,7 @@ public async Task<int> InvokeAsync(InvocationContext context)
                 }
             }
 
-            await command.CreateExport().Value.Execute();
+            await Command.CreateExport().Value.Execute();
 
             return 0;
         }
diff --git a/src/Pretzel/Properties/AssemblyInfo.cs b/src/Pretzel/Properties/AssemblyInfo.cs
index c6a8328fa..e2dfade9e 100644
--- a/src/Pretzel/Properties/AssemblyInfo.cs
+++ b/src/Pretzel/Properties/AssemblyInfo.cs
@@ -1,4 +1,7 @@
-using System.Reflection;
+using System.Reflection;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 [assembly: ComVisible(false)]
 [assembly: Guid("3c5a833b-daac-49ef-bba8-1000cd0e3c4f")]
+
+[assembly: InternalsVisibleTo("Pretzel.Tests")]

From 745024167821c03e638688729327408bbc45144b Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Wed, 25 Sep 2019 15:09:17 +0200
Subject: [PATCH 25/56] refactor: moved base classes to Logic & rename ICommand
 to IPretzelCommand

---
 .../Commands/BakeBaseCommandParameters.cs        |  2 +-
 .../Commands/CommandInfoAttribute.cs             |  4 ++--
 src/Pretzel.Logic/Commands/ICommand.cs           |  9 +++++++++
 .../Commands/PretzelBaseCommandParameters.cs     |  6 ++----
 .../Commands/BakeBaseCommandParametersTests`1.cs |  2 +-
 .../Commands/CommandCollectionTests.cs           | 16 ++++++++--------
 .../PetzelBaseCommandParametersTests`1.cs        |  2 +-
 src/Pretzel/Commands/BakeCommand.cs              |  4 ++--
 src/Pretzel/Commands/CommandCollection.cs        |  6 +++---
 src/Pretzel/Commands/HungryCommand.cs            |  2 +-
 src/Pretzel/Commands/ICommand.cs                 | 10 ----------
 src/Pretzel/Commands/ImportCommand.cs            |  2 +-
 src/Pretzel/Commands/IngredientCommand.cs        |  2 +-
 src/Pretzel/Commands/PretzelCommandHandler.cs    |  4 ++--
 src/Pretzel/Commands/RecipeCommand.cs            |  2 +-
 src/Pretzel/Commands/TasteCommand.cs             |  2 +-
 src/Pretzel/Commands/VersionCommand.cs           |  2 +-
 17 files changed, 37 insertions(+), 40 deletions(-)
 rename src/{Pretzel => Pretzel.Logic}/Commands/BakeBaseCommandParameters.cs (95%)
 rename src/{Pretzel => Pretzel.Logic}/Commands/CommandInfoAttribute.cs (76%)
 create mode 100644 src/Pretzel.Logic/Commands/ICommand.cs
 rename src/{Pretzel => Pretzel.Logic}/Commands/PretzelBaseCommandParameters.cs (97%)
 delete mode 100644 src/Pretzel/Commands/ICommand.cs

diff --git a/src/Pretzel/Commands/BakeBaseCommandParameters.cs b/src/Pretzel.Logic/Commands/BakeBaseCommandParameters.cs
similarity index 95%
rename from src/Pretzel/Commands/BakeBaseCommandParameters.cs
rename to src/Pretzel.Logic/Commands/BakeBaseCommandParameters.cs
index d8effd6c7..4c83209de 100644
--- a/src/Pretzel/Commands/BakeBaseCommandParameters.cs
+++ b/src/Pretzel.Logic/Commands/BakeBaseCommandParameters.cs
@@ -4,7 +4,7 @@
 using System.CommandLine;
 using System.IO.Abstractions;
 
-namespace Pretzel.Commands
+namespace Pretzel.Logic.Commands
 {
     public abstract class BakeBaseCommandParameters : PretzelBaseCommandParameters
     {
diff --git a/src/Pretzel/Commands/CommandInfoAttribute.cs b/src/Pretzel.Logic/Commands/CommandInfoAttribute.cs
similarity index 76%
rename from src/Pretzel/Commands/CommandInfoAttribute.cs
rename to src/Pretzel.Logic/Commands/CommandInfoAttribute.cs
index 8f57c3d54..a44af80d4 100644
--- a/src/Pretzel/Commands/CommandInfoAttribute.cs
+++ b/src/Pretzel.Logic/Commands/CommandInfoAttribute.cs
@@ -1,7 +1,7 @@
 using System;
 using System.Composition;
 
-namespace Pretzel.Commands
+namespace Pretzel.Logic.Commands
 {
     [MetadataAttribute]
     [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
@@ -11,7 +11,7 @@ public sealed class CommandInfoAttribute : ExportAttribute
 
         public string CommandDescription { get; set; }
 
-        public CommandInfoAttribute() : base(typeof(ICommand))
+        public CommandInfoAttribute() : base(typeof(IPretzelCommand))
         {
         }
     }
diff --git a/src/Pretzel.Logic/Commands/ICommand.cs b/src/Pretzel.Logic/Commands/ICommand.cs
new file mode 100644
index 000000000..05c81181e
--- /dev/null
+++ b/src/Pretzel.Logic/Commands/ICommand.cs
@@ -0,0 +1,9 @@
+using System.Threading.Tasks;
+
+namespace Pretzel.Logic.Commands
+{
+    public interface IPretzelCommand
+    {
+        Task Execute();
+    }
+}
diff --git a/src/Pretzel/Commands/PretzelBaseCommandParameters.cs b/src/Pretzel.Logic/Commands/PretzelBaseCommandParameters.cs
similarity index 97%
rename from src/Pretzel/Commands/PretzelBaseCommandParameters.cs
rename to src/Pretzel.Logic/Commands/PretzelBaseCommandParameters.cs
index 51b25be65..d0a2990b3 100644
--- a/src/Pretzel/Commands/PretzelBaseCommandParameters.cs
+++ b/src/Pretzel.Logic/Commands/PretzelBaseCommandParameters.cs
@@ -1,15 +1,13 @@
 using System;
-using System.Linq;
 using System.Collections.Generic;
 using System.CommandLine;
 using System.IO.Abstractions;
-using Pretzel.Logic;
-using Pretzel.Logic.Commands;
+using System.Linq;
 using Pretzel.Logic.Extensions;
 using Pretzel.Logic.Templating;
 using Pretzel.Logic.Templating.Context;
 
-namespace Pretzel.Commands
+namespace Pretzel.Logic.Commands
 {
     public abstract class PretzelBaseCommandParameters : BaseParameters, IPathProvider
     {
diff --git a/src/Pretzel.Tests/Commands/BakeBaseCommandParametersTests`1.cs b/src/Pretzel.Tests/Commands/BakeBaseCommandParametersTests`1.cs
index 12c65162d..2291b9274 100644
--- a/src/Pretzel.Tests/Commands/BakeBaseCommandParametersTests`1.cs
+++ b/src/Pretzel.Tests/Commands/BakeBaseCommandParametersTests`1.cs
@@ -1,6 +1,6 @@
 using System;
 using System.Linq;
-using Pretzel.Commands;
+using Pretzel.Logic.Commands;
 using Xunit;
 
 namespace Pretzel.Tests.Commands
diff --git a/src/Pretzel.Tests/Commands/CommandCollectionTests.cs b/src/Pretzel.Tests/Commands/CommandCollectionTests.cs
index a27589251..6fad77c73 100644
--- a/src/Pretzel.Tests/Commands/CommandCollectionTests.cs
+++ b/src/Pretzel.Tests/Commands/CommandCollectionTests.cs
@@ -26,9 +26,9 @@ public void SubCommandAreAddedToRootCommand()
         {
             var collection = new CommandCollection
             {
-                Commands = new ExportFactory<Pretzel.Commands.ICommand, CommandInfoAttribute>[]
+                Commands = new ExportFactory<Logic.Commands.IPretzelCommand, CommandInfoAttribute>[]
                 {
-                    new ExportFactory<Pretzel.Commands.ICommand, CommandInfoAttribute>(CreateCommand, new CommandInfoAttribute{ CommandName = "test", CommandDescription = "desc" })
+                    new ExportFactory<Logic.Commands.IPretzelCommand, CommandInfoAttribute>(CreateCommand, new CommandInfoAttribute{ CommandName = "test", CommandDescription = "desc" })
                 }
             };
             collection.OnImportsSatisfied();
@@ -40,7 +40,7 @@ public void SubCommandAreAddedToRootCommand()
         [Fact]
         public void SubCommandsWithoutArgumentGetsHandler()
         {
-            var exportFactory = new ExportFactory<Pretzel.Commands.ICommand, CommandInfoAttribute>(
+            var exportFactory = new ExportFactory<Logic.Commands.IPretzelCommand, CommandInfoAttribute>(
                 CreateCommand,
                 new CommandInfoAttribute
                 {
@@ -51,7 +51,7 @@ public void SubCommandsWithoutArgumentGetsHandler()
             var collection = new CommandCollection
             {
                 Configuration = Substitute.For<IConfiguration>(),
-                Commands = new ExportFactory<Pretzel.Commands.ICommand, CommandInfoAttribute>[]
+                Commands = new ExportFactory<Logic.Commands.IPretzelCommand, CommandInfoAttribute>[]
                 {
                     exportFactory
                 }
@@ -78,7 +78,7 @@ public void SubCommandsWithArgumentGetsHandler()
                 new Option("-i")
             });
 
-            var commandExportFactory = new ExportFactory<Pretzel.Commands.ICommand, CommandInfoAttribute>(
+            var commandExportFactory = new ExportFactory<Logic.Commands.IPretzelCommand, CommandInfoAttribute>(
                 CreateCommand,
                 new CommandInfoAttribute
                 {
@@ -96,7 +96,7 @@ public void SubCommandsWithArgumentGetsHandler()
             var collection = new CommandCollection
             {
                 Configuration = Substitute.For<IConfiguration>(),
-                Commands = new ExportFactory<Pretzel.Commands.ICommand, CommandInfoAttribute>[]
+                Commands = new ExportFactory<Logic.Commands.IPretzelCommand, CommandInfoAttribute>[]
                 {
                     commandExportFactory
                 },
@@ -127,8 +127,8 @@ public void SubCommandsWithArgumentGetsHandler()
             Assert.Equal(commandExportFactory, ((PretzelCommandHandler)command.Handler).Command);
         }
 
-        Tuple<Pretzel.Commands.ICommand, Action> CreateCommand()
-            => Tuple.Create(Substitute.For<Pretzel.Commands.ICommand>(), new Action(() => { }));
+        Tuple<Logic.Commands.IPretzelCommand, Action> CreateCommand()
+            => Tuple.Create(Substitute.For<Logic.Commands.IPretzelCommand>(), new Action(() => { }));
         Tuple<ICommandParameters, Action> CreateArgument(ICommandParameters parameters)
             => Tuple.Create(parameters, new Action(() => { }));
     }
diff --git a/src/Pretzel.Tests/Commands/PetzelBaseCommandParametersTests`1.cs b/src/Pretzel.Tests/Commands/PetzelBaseCommandParametersTests`1.cs
index 72a49cffe..95ba5d1c3 100644
--- a/src/Pretzel.Tests/Commands/PetzelBaseCommandParametersTests`1.cs
+++ b/src/Pretzel.Tests/Commands/PetzelBaseCommandParametersTests`1.cs
@@ -1,7 +1,7 @@
 using System;
 using System.IO.Abstractions;
 using System.Linq;
-using Pretzel.Commands;
+using Pretzel.Logic.Commands;
 using Xunit;
 
 namespace Pretzel.Tests.Commands
diff --git a/src/Pretzel/Commands/BakeCommand.cs b/src/Pretzel/Commands/BakeCommand.cs
index 2ad4377be..84e9975a1 100644
--- a/src/Pretzel/Commands/BakeCommand.cs
+++ b/src/Pretzel/Commands/BakeCommand.cs
@@ -28,7 +28,7 @@ public BakeCommandParameters(IFileSystem fileSystem) : base(fileSystem) { }
 
     [Shared]
     [CommandInfo(CommandName = BuiltInCommands.Bake, CommandDescription = "transforming content into a website")]
-    public sealed class BakeCommand : ICommand
+    public sealed class BakeCommand : IPretzelCommand
     {
         [Import]
         public TemplateEngineCollection TemplateEngines { get; set; }
@@ -44,7 +44,7 @@ public sealed class BakeCommand : ICommand
 
         [Import]
         public IFileSystem FileSystem { get; set; }
-        
+
         public async Task Execute()
         {
             Tracing.Info("bake - transforming content into a website");
diff --git a/src/Pretzel/Commands/CommandCollection.cs b/src/Pretzel/Commands/CommandCollection.cs
index 31853c379..70a07cfed 100644
--- a/src/Pretzel/Commands/CommandCollection.cs
+++ b/src/Pretzel/Commands/CommandCollection.cs
@@ -11,11 +11,11 @@ namespace Pretzel.Commands
     [Shared]
     public sealed class CommandCollection
     {
-        ExportFactory<ICommand, CommandInfoAttribute>[] commands;
+        ExportFactory<IPretzelCommand, CommandInfoAttribute>[] commands;
         [ImportMany]
-        public ExportFactory<ICommand, CommandInfoAttribute>[] Commands
+        public ExportFactory<IPretzelCommand, CommandInfoAttribute>[] Commands
         {
-            get => commands ?? new ExportFactory<ICommand, CommandInfoAttribute>[] { };
+            get => commands ?? new ExportFactory<IPretzelCommand, CommandInfoAttribute>[] { };
             set => commands = value;
         }
 
diff --git a/src/Pretzel/Commands/HungryCommand.cs b/src/Pretzel/Commands/HungryCommand.cs
index 7deabbf95..a6413b8a8 100644
--- a/src/Pretzel/Commands/HungryCommand.cs
+++ b/src/Pretzel/Commands/HungryCommand.cs
@@ -9,7 +9,7 @@ namespace Pretzel.Commands
     [Shared]
     [Export]
     [CommandInfo(CommandName = BuiltInCommands.Hungry, CommandDescription = "use only when hungry")]
-    public sealed class HungryCommand : ICommand
+    public sealed class HungryCommand : IPretzelCommand
     {
         private readonly string recipe = @"===== Ingredients ======
 
diff --git a/src/Pretzel/Commands/ICommand.cs b/src/Pretzel/Commands/ICommand.cs
deleted file mode 100644
index 65ce374d6..000000000
--- a/src/Pretzel/Commands/ICommand.cs
+++ /dev/null
@@ -1,10 +0,0 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-
-namespace Pretzel.Commands
-{
-    public interface ICommand
-    {
-        Task Execute();
-    }
-}
diff --git a/src/Pretzel/Commands/ImportCommand.cs b/src/Pretzel/Commands/ImportCommand.cs
index 639f3cc14..2ff9130b1 100644
--- a/src/Pretzel/Commands/ImportCommand.cs
+++ b/src/Pretzel/Commands/ImportCommand.cs
@@ -42,7 +42,7 @@ protected override void WithOptions(List<Option> options)
 
     [Shared]
     [CommandInfo(CommandName = BuiltInCommands.Import, CommandDescription = "import posts from external source")]
-    class ImportCommand : ICommand
+    class ImportCommand : IPretzelCommand
     {
         readonly static List<string> Importers = new List<string>(new[] { "wordpress", "blogger" });
 
diff --git a/src/Pretzel/Commands/IngredientCommand.cs b/src/Pretzel/Commands/IngredientCommand.cs
index aaf0612d4..bf075262e 100644
--- a/src/Pretzel/Commands/IngredientCommand.cs
+++ b/src/Pretzel/Commands/IngredientCommand.cs
@@ -34,7 +34,7 @@ protected override void WithOptions(List<Option> options)
 
     [Shared]
     [CommandInfo(CommandName = BuiltInCommands.Ingredient, CommandDescription = "create a new post")]
-    public sealed class IngredientCommand : ICommand
+    public sealed class IngredientCommand : IPretzelCommand
     {
 #pragma warning disable 649
 
diff --git a/src/Pretzel/Commands/PretzelCommandHandler.cs b/src/Pretzel/Commands/PretzelCommandHandler.cs
index 7958e824a..32ad5ba13 100644
--- a/src/Pretzel/Commands/PretzelCommandHandler.cs
+++ b/src/Pretzel/Commands/PretzelCommandHandler.cs
@@ -12,10 +12,10 @@ namespace Pretzel.Commands
     public class PretzelCommandHandler : ICommandHandler
     {
         public ICommandParameters CommandParameters { get; }
-        public ExportFactory<ICommand, CommandInfoAttribute> Command { get; }
+        public ExportFactory<IPretzelCommand, CommandInfoAttribute> Command { get; }
         public IConfiguration Configuration { get; }
 
-        public PretzelCommandHandler(IConfiguration configuration, ICommandParameters commandParameters, ExportFactory<ICommand, CommandInfoAttribute> command)
+        public PretzelCommandHandler(IConfiguration configuration, ICommandParameters commandParameters, ExportFactory<IPretzelCommand, CommandInfoAttribute> command)
         {
             Configuration = configuration;
             CommandParameters = commandParameters;
diff --git a/src/Pretzel/Commands/RecipeCommand.cs b/src/Pretzel/Commands/RecipeCommand.cs
index 89bf50344..18a3388a6 100644
--- a/src/Pretzel/Commands/RecipeCommand.cs
+++ b/src/Pretzel/Commands/RecipeCommand.cs
@@ -42,7 +42,7 @@ protected override void WithOptions(List<Option> options)
 
     [Shared]
     [CommandInfo(CommandName = BuiltInCommands.Create, CommandDescription = "configure a new site")]
-    public sealed class RecipeCommand : ICommand
+    public sealed class RecipeCommand : IPretzelCommand
     {
         private static readonly List<string> TemplateEngines = new List<string>(new[] { "Liquid", "Razor" });
 
diff --git a/src/Pretzel/Commands/TasteCommand.cs b/src/Pretzel/Commands/TasteCommand.cs
index 49e0c4fa7..4c33f2f80 100644
--- a/src/Pretzel/Commands/TasteCommand.cs
+++ b/src/Pretzel/Commands/TasteCommand.cs
@@ -45,7 +45,7 @@ protected override void WithOptions(List<Option> options)
 
     [Shared]
     [CommandInfo(CommandName = BuiltInCommands.Taste, CommandDescription = "testing a site locally")]
-    public sealed class TasteCommand : ICommand
+    public sealed class TasteCommand : IPretzelCommand
     {
         private ISiteEngine engine;
 
diff --git a/src/Pretzel/Commands/VersionCommand.cs b/src/Pretzel/Commands/VersionCommand.cs
index 5981fccd9..1004b5538 100644
--- a/src/Pretzel/Commands/VersionCommand.cs
+++ b/src/Pretzel/Commands/VersionCommand.cs
@@ -8,7 +8,7 @@ namespace Pretzel.Commands
 {
     [Shared]
     [CommandInfo(CommandName = BuiltInCommands.Version, CommandDescription = "display current Pretzel version")]
-    public sealed class VersionCommand : ICommand
+    public sealed class VersionCommand : IPretzelCommand
     {
         public async Task Execute()
         {

From 1481584ccbd8d0d82669c08c71e11faf9d388d84 Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Wed, 25 Sep 2019 16:44:27 +0200
Subject: [PATCH 26/56] test: PretzelCommandHandlerTests

---
 .../Commands/PretzelCommandHandlerTests.cs    | 239 ++++++++++++++++++
 1 file changed, 239 insertions(+)
 create mode 100644 src/Pretzel.Tests/Commands/PretzelCommandHandlerTests.cs

diff --git a/src/Pretzel.Tests/Commands/PretzelCommandHandlerTests.cs b/src/Pretzel.Tests/Commands/PretzelCommandHandlerTests.cs
new file mode 100644
index 000000000..91dada9f8
--- /dev/null
+++ b/src/Pretzel.Tests/Commands/PretzelCommandHandlerTests.cs
@@ -0,0 +1,239 @@
+using NSubstitute;
+using Pretzel.Commands;
+using Pretzel.Logic;
+using Pretzel.Logic.Commands;
+using Pretzel.Logic.Extensibility;
+using System;
+using System.Collections.Generic;
+using System.CommandLine;
+using System.CommandLine.Invocation;
+using System.Composition;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace Pretzel.Tests.Commands
+{
+    public class PretzelCommandHandlerTests
+    {
+        public class TestParams : ICommandParameters
+        {
+            public IList<Option> Options => throw new NotImplementedException();
+
+            public void BindingCompleted()
+            {
+            }
+
+            public bool SomeOption { get; set; }
+        }
+
+        [Fact]
+        public async Task CommandParametersGetsBinded()
+        {
+            var rootCommand = new RootCommand();
+            rootCommand.AddOption(new Option("--someoption")
+            {
+                Argument = new Argument<bool>()
+            });
+
+            var context = new InvocationContext(new Parser(rootCommand).Parse("--someoption"), Substitute.For<IConsole>());
+            var testParams = new TestParams();
+            var sut = new PretzelCommandHandler(
+                Substitute.For<IConfiguration>(),
+                testParams,
+                new ExportFactory<IPretzelCommand, CommandInfoAttribute>(
+                    () => Tuple.Create(
+                            Substitute.For<IPretzelCommand>(),
+                            new Action(() => { })
+                        ), new CommandInfoAttribute()));
+
+            await sut.InvokeAsync(context);
+
+            Assert.True(testParams.SomeOption);
+        }
+
+        [Fact]
+        public async Task CommandParameters_BindingCompleted_IsCalled()
+        {
+            var rootCommand = new RootCommand();
+
+            var context = new InvocationContext(new Parser(rootCommand).Parse(string.Empty), Substitute.For<IConsole>());
+            var testParams = Substitute.For<ICommandParameters>();
+
+            var sut = new PretzelCommandHandler(
+              Substitute.For<IConfiguration>(),
+              testParams,
+              new ExportFactory<IPretzelCommand, CommandInfoAttribute>(
+                  () => Tuple.Create(
+                          Substitute.For<IPretzelCommand>(),
+                          new Action(() => { })
+                      ), new CommandInfoAttribute()));
+
+            await sut.InvokeAsync(context);
+
+            testParams.Received().BindingCompleted();
+        }
+
+        [Fact]
+        public async Task Configuration_ReadFromFile_IsCalled_WithPathProvider()
+        {
+            var configuration = Substitute.For<IConfiguration>();
+
+            var rootCommand = new RootCommand();
+            var testParams = Substitute.For<ICommandParameters, IPathProvider>();
+            ((IPathProvider)testParams).Path.Returns("foo");
+
+            var context = new InvocationContext(new Parser(rootCommand).Parse(string.Empty), Substitute.For<IConsole>());
+
+            var sut = new PretzelCommandHandler(
+                configuration,
+                testParams,
+                new ExportFactory<IPretzelCommand, CommandInfoAttribute>(
+                    () => Tuple.Create(
+                            Substitute.For<IPretzelCommand>(),
+                            new Action(() => { })
+                        ), new CommandInfoAttribute()));
+
+            await sut.InvokeAsync(context);
+
+            configuration.Received().ReadFromFile("foo");
+        }
+
+        [CommandArguments(CommandName = nameof(TestParams2))]
+        public class TestParams2 : ICommandParameters, ICommandParametersExtendable
+        {
+            public IList<Option> Options => throw new NotImplementedException();
+
+            public void BindingCompleted()
+            {
+            }
+
+            public class ExtendedArguments : IHaveCommandLineArgs
+            {
+                public bool BindingCompletedCalled { get; private set; }
+                public void BindingCompleted()
+                {
+                    BindingCompletedCalled = true;
+                }
+
+                public void UpdateOptions(IList<Option> options)
+                {
+                    throw new NotImplementedException();
+                }
+
+                public bool OtherOption { get; set; }
+            }
+
+            public readonly ExtendedArguments Args = new ExtendedArguments();
+
+            public ExportFactory<IHaveCommandLineArgs, CommandArgumentsExtentionAttribute>[] ArgumentExtenders => new[]
+            {
+                new ExportFactory<IHaveCommandLineArgs, CommandArgumentsExtentionAttribute>(() => Tuple.Create<IHaveCommandLineArgs, Action>(Args, new Action(() => { })), new CommandArgumentsExtentionAttribute{ CommandNames = new []{ nameof(TestParams2)} })
+            };
+        }
+
+
+        [Fact]
+        public async Task CommandParametersExtentionsGetsBinded()
+        {
+            var rootCommand = new RootCommand();
+            rootCommand.AddOption(new Option("--otheroption")
+            {
+                Argument = new Argument<bool>()
+            });
+
+            var context = new InvocationContext(new Parser(rootCommand).Parse("--otheroption"), Substitute.For<IConsole>());
+            var testParams = new TestParams2();
+            var sut = new PretzelCommandHandler(
+                Substitute.For<IConfiguration>(),
+                testParams,
+                new ExportFactory<IPretzelCommand, CommandInfoAttribute>(
+                    () => Tuple.Create(
+                            Substitute.For<IPretzelCommand>(),
+                            new Action(() => { })
+                        ), new CommandInfoAttribute()));
+
+            await sut.InvokeAsync(context);
+
+            Assert.True(testParams.Args.OtherOption);
+        }
+
+        [Fact]
+        public async Task CommandParametersExtention_BindingCompleted_IsCalled()
+        {
+            var rootCommand = new RootCommand();
+            rootCommand.AddOption(new Option("--otheroption")
+            {
+                Argument = new Argument<bool>()
+            });
+
+            var context = new InvocationContext(new Parser(rootCommand).Parse("--otheroption"), Substitute.For<IConsole>());
+            var testParams = new TestParams2();
+            var sut = new PretzelCommandHandler(
+                Substitute.For<IConfiguration>(),
+                testParams,
+                new ExportFactory<IPretzelCommand, CommandInfoAttribute>(
+                    () => Tuple.Create(
+                            Substitute.For<IPretzelCommand>(),
+                            new Action(() => { })
+                        ), new CommandInfoAttribute()));
+
+            await sut.InvokeAsync(context);
+
+            Assert.True(testParams.Args.BindingCompletedCalled);
+        }
+
+        [Fact]
+        public async Task CommandGetsExecuted()
+        {
+            var rootCommand = new RootCommand();
+
+            var context = new InvocationContext(new Parser(rootCommand).Parse(""), Substitute.For<IConsole>());
+            var command = Substitute.For<IPretzelCommand>();
+
+            var sut = new PretzelCommandHandler(
+                Substitute.For<IConfiguration>(),
+                Substitute.For<ICommandParameters>(),
+                new ExportFactory<IPretzelCommand, CommandInfoAttribute>(
+                    () => Tuple.Create(
+                            command,
+                            new Action(() => { })
+                        ), new CommandInfoAttribute()));
+
+            await sut.InvokeAsync(context);
+
+            await command.Received(1).Execute();
+        }
+
+        [Fact]
+        public async Task ExecutionOrder()
+        {
+            var rootCommand = new RootCommand();
+
+            var context = new InvocationContext(new Parser(rootCommand).Parse(""), Substitute.For<IConsole>());
+            var configuration = Substitute.For<IConfiguration>();
+            var @params = Substitute.For<ICommandParameters, IPathProvider>();
+            ((IPathProvider)@params).Path.Returns("bar");
+            var command = Substitute.For<IPretzelCommand>();
+
+            var sut = new PretzelCommandHandler(
+                configuration,
+                @params,
+                new ExportFactory<IPretzelCommand, CommandInfoAttribute>(
+                    () => Tuple.Create(
+                            command,
+                            new Action(() => { })
+                        ), new CommandInfoAttribute()));
+
+            await sut.InvokeAsync(context);
+
+            Received.InOrder(async () =>
+            {
+                @params.BindingCompleted();
+                configuration.ReadFromFile("bar");
+                await command.Execute();
+            });
+        }
+    }
+}

From d1027f256592e706a9f91c5211e7ec6ef44e78a8 Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Thu, 26 Sep 2019 09:03:31 +0200
Subject: [PATCH 27/56] test: added missing DetectFromDirectory tests

---
 .../PetzelBaseCommandParametersTests`1.cs     | 107 +++++++++++++++++-
 1 file changed, 106 insertions(+), 1 deletion(-)

diff --git a/src/Pretzel.Tests/Commands/PetzelBaseCommandParametersTests`1.cs b/src/Pretzel.Tests/Commands/PetzelBaseCommandParametersTests`1.cs
index 95ba5d1c3..671820876 100644
--- a/src/Pretzel.Tests/Commands/PetzelBaseCommandParametersTests`1.cs
+++ b/src/Pretzel.Tests/Commands/PetzelBaseCommandParametersTests`1.cs
@@ -1,7 +1,11 @@
 using System;
-using System.IO.Abstractions;
+using System.Collections.Generic;
 using System.Linq;
+using NSubstitute;
+using Pretzel.Logic;
 using Pretzel.Logic.Commands;
+using Pretzel.Logic.Templating;
+using Pretzel.Logic.Templating.Context;
 using Xunit;
 
 namespace Pretzel.Tests.Commands
@@ -62,5 +66,106 @@ public void DestinationDefaultValue()
 
             Assert.Equal(fileSystem.Path.Combine(sut.Source, "_site"), sut.Destination);
         }
+
+        [Fact]
+        public void DetectFromDirectory_WhenSpecifyingNoSiteEngines_DefaultValueIsLiquid()
+        {
+            var sut = BuildParameters();
+
+            var siteContext = new SiteContext();
+
+            sut.DetectFromDirectory(new Dictionary<string, ISiteEngine>(), siteContext);
+
+            Assert.Equal("liquid", sut.Template);
+        }
+
+        [Fact]
+        public void DetectFromDirectory_WhenSpecifyingTwoSiteEngines_CorrectValueIsPicked()
+        {
+            var sut = BuildParameters();
+
+            var siteContext = new SiteContext { Config = new ConfigurationMock(new Dictionary<string, object> { { "pretzel", new Dictionary<string, object> { { "engine", "engine2" } } } }) };
+
+            var siteEngine1 = Substitute.For<ISiteEngine>();
+            siteEngine1.CanProcess(Arg.Any<SiteContext>())
+                .Returns(ci => ci.Arg<SiteContext>().Engine == "engine1");
+
+            var siteEngine2 = Substitute.For<ISiteEngine>();
+            siteEngine2.CanProcess(Arg.Any<SiteContext>())
+                .Returns(ci => ci.Arg<SiteContext>().Engine == "engine2");
+
+            var siteEngines = new Dictionary<string, ISiteEngine>
+            {
+                { "engine1", siteEngine1 },
+                { "engine2", siteEngine2 },
+            };
+
+            sut.DetectFromDirectory(siteEngines, siteContext);
+
+            Assert.Equal("engine2", sut.Template);
+        }
+
+        [Fact]
+        public void DetectFromDirectory_WhenSpecifyingNoPretzelConfig_DefaultValueIsLiquid()
+        {
+            var sut = BuildParameters();
+
+            var siteContext = new SiteContext { Config = new Configuration() };
+
+            var siteEngine1 = Substitute.For<ISiteEngine>();
+            siteEngine1.CanProcess(Arg.Any<SiteContext>())
+                .Returns(ci => ci.Arg<SiteContext>().Engine == "engine1");
+
+            var siteEngines = new Dictionary<string, ISiteEngine>
+            {
+                { "engine1", siteEngine1 }
+            };
+
+            sut.DetectFromDirectory(siteEngines, siteContext);
+
+            Assert.Equal("liquid", sut.Template);
+        }
+
+        [Fact]
+        public void DetectFromDirectory_WhenSpecifyingNoEnginInPretzelConfig_DefaultValueIsLiquid()
+        {
+            var sut = BuildParameters();
+
+            var siteContext = new SiteContext { Config = new ConfigurationMock(new Dictionary<string, object> { { "pretzel", new Dictionary<string, object> { } } }) };
+
+            var siteEngine1 = Substitute.For<ISiteEngine>();
+            siteEngine1.CanProcess(Arg.Any<SiteContext>())
+                .Returns(ci => ci.Arg<SiteContext>().Engine == "engine1");
+
+            var siteEngines = new Dictionary<string, ISiteEngine>
+            {
+                { "engine1", siteEngine1 }
+            };
+
+            sut.DetectFromDirectory(siteEngines, siteContext);
+
+            Assert.Equal("liquid", sut.Template);
+        }
+
+        [Fact]
+        public void DetectFromDirectory_WhenSpecifyingPretzelConfigSimpleValue_DefaultValueIsLiquid()
+        {
+            var sut = BuildParameters();
+
+            var siteContext = new SiteContext { Config = new ConfigurationMock(new Dictionary<string, object> { { "pretzel", 42 } }) };
+
+            var siteEngine1 = Substitute.For<ISiteEngine>();
+            siteEngine1.CanProcess(Arg.Any<SiteContext>())
+                .Returns(ci => ci.Arg<SiteContext>().Engine == "engine1");
+
+            var siteEngines = new Dictionary<string, ISiteEngine>
+            {
+                { "engine1", siteEngine1 }
+            };
+
+            sut.DetectFromDirectory(siteEngines, siteContext);
+
+            Assert.Equal("liquid", sut.Template);
+        }
     }
 }

From 630e7a080442915f64ab1abe59e58c6081c22e74 Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Thu, 26 Sep 2019 09:07:50 +0200
Subject: [PATCH 28/56] refactor: removed namespaces

---
 src/Pretzel/Commands/BakeCommand.cs | 13 ++++---------
 1 file changed, 4 insertions(+), 9 deletions(-)

diff --git a/src/Pretzel/Commands/BakeCommand.cs b/src/Pretzel/Commands/BakeCommand.cs
index 84e9975a1..bca60101b 100644
--- a/src/Pretzel/Commands/BakeCommand.cs
+++ b/src/Pretzel/Commands/BakeCommand.cs
@@ -1,19 +1,14 @@
-using Pretzel.Logic.Commands;
-using Pretzel.Logic.Extensibility;
-using Pretzel.Logic.Extensions;
-using Pretzel.Logic.Templating;
-using Pretzel.Logic.Templating.Context;
 using System;
 using System.Collections.Generic;
-using System.CommandLine;
-using System.CommandLine.Invocation;
 using System.Composition;
 using System.Diagnostics;
-using System.IO;
 using System.IO.Abstractions;
 using System.Linq;
-using System.Text.RegularExpressions;
 using System.Threading.Tasks;
+using Pretzel.Logic.Commands;
+using Pretzel.Logic.Extensibility;
+using Pretzel.Logic.Extensions;
+using Pretzel.Logic.Templating.Context;
 
 namespace Pretzel.Commands
 {

From c5cf6069c19235c18aaf916a9bbf13b04f1d49ea Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Thu, 26 Sep 2019 09:09:02 +0200
Subject: [PATCH 29/56] refactor: namespace

---
 src/Pretzel/Commands/IngredientCommand.cs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/Pretzel/Commands/IngredientCommand.cs b/src/Pretzel/Commands/IngredientCommand.cs
index bf075262e..ab8b49da8 100644
--- a/src/Pretzel/Commands/IngredientCommand.cs
+++ b/src/Pretzel/Commands/IngredientCommand.cs
@@ -1,7 +1,9 @@
+using System;
 using System.Collections.Generic;
 using System.CommandLine;
 using System.Composition;
 using System.IO.Abstractions;
+using System.Linq;
 using System.Threading.Tasks;
 using Pretzel.Logic.Commands;
 using Pretzel.Logic.Extensions;

From cea6a0a81e1083cd972cd5050db191a4a5b4a0a2 Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Thu, 26 Sep 2019 09:18:56 +0200
Subject: [PATCH 30/56] refactor: removed redundant pragma warning supression

---
 src/Pretzel/Commands/IngredientCommand.cs | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/src/Pretzel/Commands/IngredientCommand.cs b/src/Pretzel/Commands/IngredientCommand.cs
index ab8b49da8..73926f841 100644
--- a/src/Pretzel/Commands/IngredientCommand.cs
+++ b/src/Pretzel/Commands/IngredientCommand.cs
@@ -38,16 +38,12 @@ protected override void WithOptions(List<Option> options)
     [CommandInfo(CommandName = BuiltInCommands.Ingredient, CommandDescription = "create a new post")]
     public sealed class IngredientCommand : IPretzelCommand
     {
-#pragma warning disable 649
-
         [Import]
         public IFileSystem FileSystem { get; set; }
 
         [Import]
         public IngredientCommandParameters Parameters { get; set; }
 
-#pragma warning restore 649
-
         public async Task Execute()
         {
             Tracing.Info("ingredient - create a new post");

From 10914968dabbafa27d5894eb9590cd63b25d5e1a Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Thu, 26 Sep 2019 09:29:11 +0200
Subject: [PATCH 31/56] refactor: fixed a bunch of warnings

---
 .../Extensions/AzureHostSupport.cs            |  1 +
 .../Extensions/VirtualDirectorySupport.cs     |  1 +
 .../Extensibility/TagFactoryBase.cs           |  2 +-
 src/Pretzel.Logic/Extensions/Tracing.cs       | 16 ++++---------
 src/Pretzel.Logic/SanityCheck.cs              |  3 ++-
 .../Templating/Jekyll/LiquidEngine.cs         |  6 ++---
 .../Templating/JekyllEngineBase.cs            | 24 +++++++++----------
 src/Pretzel/Commands/BakeCommand.cs           |  5 ++--
 src/Pretzel/Commands/HungryCommand.cs         |  4 +++-
 src/Pretzel/Commands/ImportCommand.cs         | 11 +++++----
 src/Pretzel/Commands/IngredientCommand.cs     |  6 +++--
 src/Pretzel/Commands/RecipeCommand.cs         |  9 ++++---
 src/Pretzel/Commands/TasteCommand.cs          | 21 +++++++++-------
 src/Pretzel/Commands/VersionCommand.cs        |  4 +++-
 src/Pretzel/Program.cs                        |  2 ++
 15 files changed, 65 insertions(+), 50 deletions(-)

diff --git a/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs b/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs
index e77f9824b..7395d1e80 100644
--- a/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs
+++ b/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs
@@ -27,6 +27,7 @@ public void UpdateOptions(IList<Option> options)
 
         public void BindingCompleted()
         {
+            //Not used
         }
     }
 
diff --git a/src/Pretzel.Logic/Extensibility/Extensions/VirtualDirectorySupport.cs b/src/Pretzel.Logic/Extensibility/Extensions/VirtualDirectorySupport.cs
index 6d75ed028..320d4e159 100644
--- a/src/Pretzel.Logic/Extensibility/Extensions/VirtualDirectorySupport.cs
+++ b/src/Pretzel.Logic/Extensibility/Extensions/VirtualDirectorySupport.cs
@@ -24,6 +24,7 @@ public void UpdateOptions(IList<Option> options)
 
         public void BindingCompleted()
         {
+            //Not used
         }
 
         public string VirtualDirectory { get; set; }
diff --git a/src/Pretzel.Logic/Extensibility/TagFactoryBase.cs b/src/Pretzel.Logic/Extensibility/TagFactoryBase.cs
index e0f97d26a..1122321b1 100644
--- a/src/Pretzel.Logic/Extensibility/TagFactoryBase.cs
+++ b/src/Pretzel.Logic/Extensibility/TagFactoryBase.cs
@@ -9,7 +9,7 @@ public abstract class TagFactoryBase : DotLiquid.ITagFactory
         
         protected SiteContext SiteContext { get; private set; }
 
-        public TagFactoryBase(string tagName)
+        protected TagFactoryBase(string tagName)
         {
             _tageName = tagName.ToUnderscoreCase();
         }
diff --git a/src/Pretzel.Logic/Extensions/Tracing.cs b/src/Pretzel.Logic/Extensions/Tracing.cs
index 2b14ba9bd..f567c6612 100644
--- a/src/Pretzel.Logic/Extensions/Tracing.cs
+++ b/src/Pretzel.Logic/Extensions/Tracing.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 
 namespace Pretzel.Logic.Extensions
 {
@@ -7,15 +7,9 @@ namespace Pretzel.Logic.Extensions
     /// </summary>
     public static class Tracing
     {
-        private static Action<string, TraceLevel> _trace;
-        private static TraceLevel _minLevel;
-
-        static Tracing()
-        {
-            // Do nothing by default
-            _trace = (message, TraceLevel) => { };
-            _minLevel = TraceLevel.Info;
-        }
+        // Do nothing by default
+        private static Action<string, TraceLevel> _trace = (message, TraceLevel) => { };
+        private static TraceLevel _minLevel = TraceLevel.Info;
 
         internal static void SetTrace(Action<string, TraceLevel> trace)
         {
@@ -69,7 +63,7 @@ public static void Error(string message, params object[] messageParameters)
 
         private static void TraceMessage(string message, object[] messageParameters, TraceLevel messageLevel)
         {
-            if(messageLevel >= _minLevel)
+            if (messageLevel >= _minLevel)
             {
                 _trace(string.Format(message, messageParameters), messageLevel);
             }
diff --git a/src/Pretzel.Logic/SanityCheck.cs b/src/Pretzel.Logic/SanityCheck.cs
index d533a2dc0..812ddf8a6 100644
--- a/src/Pretzel.Logic/SanityCheck.cs
+++ b/src/Pretzel.Logic/SanityCheck.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
@@ -78,6 +78,7 @@ public static List<string> GetFilesLockedBy(Process process)
 
         private static void Ignore()
         {
+            //Ignored
         }
 
         [HandleProcessCorruptedStateExceptions]
diff --git a/src/Pretzel.Logic/Templating/Jekyll/LiquidEngine.cs b/src/Pretzel.Logic/Templating/Jekyll/LiquidEngine.cs
index 951749f08..9fa49f41e 100644
--- a/src/Pretzel.Logic/Templating/Jekyll/LiquidEngine.cs
+++ b/src/Pretzel.Logic/Templating/Jekyll/LiquidEngine.cs
@@ -85,13 +85,13 @@ private Hash CreatePageData(PageContext pageContext)
             return x;
         }
 
-        protected override string RenderTemplate(string templateContents, PageContext pageData)
+        protected override string RenderTemplate(string content, PageContext pageData)
         {
             // Replace all em HTML tags in liquid tags ({{ or {%) by underscores
-            templateContents = emHtmlRegex.Replace(templateContents, "_");
+            content = emHtmlRegex.Replace(content, "_");
 
             var data = CreatePageData(pageData);
-            var template = Template.Parse(templateContents);
+            var template = Template.Parse(content);
             var output = template.Render(data);
 
             return output;
diff --git a/src/Pretzel.Logic/Templating/JekyllEngineBase.cs b/src/Pretzel.Logic/Templating/JekyllEngineBase.cs
index 42eb62a29..3f1bae45d 100644
--- a/src/Pretzel.Logic/Templating/JekyllEngineBase.cs
+++ b/src/Pretzel.Logic/Templating/JekyllEngineBase.cs
@@ -46,7 +46,7 @@ public abstract class JekyllEngineBase : ISiteEngine
 
         protected abstract string RenderTemplate(string content, PageContext pageData);
 
-        public void Process(SiteContext siteContext, bool skipFileOnError = false)
+        public void Process(SiteContext context, bool skipFileOnError = false)
         {
             // Default rendering engine
             if (LightweightMarkupEngine == null)
@@ -56,23 +56,23 @@ public void Process(SiteContext siteContext, bool skipFileOnError = false)
 
             Tracing.Debug("LightweightMarkupEngine: {0}", LightweightMarkupEngine.GetType().Name);
 
-            Context = siteContext;
+            Context = context;
             PreProcess();
 
-            for (int index = 0; index < siteContext.Posts.Count; index++)
+            for (int index = 0; index < context.Posts.Count; index++)
             {
-                var p = siteContext.Posts[index];
-                var previous = GetPrevious(siteContext.Posts, index);
-                var next = GetNext(siteContext.Posts, index);
-                ProcessFile(siteContext.OutputFolder, p, previous, next, skipFileOnError, p.Filepath);
+                var p = context.Posts[index];
+                var previous = GetPrevious(context.Posts, index);
+                var next = GetNext(context.Posts, index);
+                ProcessFile(context.OutputFolder, p, previous, next, skipFileOnError, p.Filepath);
             }
 
-            for (int index = 0; index < siteContext.Pages.Count; index++)
+            for (int index = 0; index < context.Pages.Count; index++)
             {
-                var p = siteContext.Pages[index];
-                var previous = GetPrevious(siteContext.Pages, index);
-                var next = GetNext(siteContext.Pages, index);
-                ProcessFile(siteContext.OutputFolder, p, previous, next, skipFileOnError);
+                var p = context.Pages[index];
+                var previous = GetPrevious(context.Pages, index);
+                var next = GetNext(context.Pages, index);
+                ProcessFile(context.OutputFolder, p, previous, next, skipFileOnError);
             }
         }
 
diff --git a/src/Pretzel/Commands/BakeCommand.cs b/src/Pretzel/Commands/BakeCommand.cs
index bca60101b..621b31063 100644
--- a/src/Pretzel/Commands/BakeCommand.cs
+++ b/src/Pretzel/Commands/BakeCommand.cs
@@ -40,11 +40,11 @@ public sealed class BakeCommand : IPretzelCommand
         [Import]
         public IFileSystem FileSystem { get; set; }
 
-        public async Task Execute()
+        public Task Execute()
         {
             Tracing.Info("bake - transforming content into a website");
 
-            var siteContext = Generator.BuildContext(Parameters.Path, Parameters.Destination, Parameters.Drafts);
+            var siteContext = Generator.BuildContext(Parameters.Source, Parameters.Destination, Parameters.Drafts);
 
             if (Parameters.CleanTarget && FileSystem.Directory.Exists(siteContext.OutputFolder))
             {
@@ -75,6 +75,7 @@ public async Task Execute()
             {
                 Tracing.Info("Cannot find engine for input: '{0}'", Parameters.Template);
             }
+            return Task.CompletedTask;
         }
     }
 }
diff --git a/src/Pretzel/Commands/HungryCommand.cs b/src/Pretzel/Commands/HungryCommand.cs
index a6413b8a8..f2db67883 100644
--- a/src/Pretzel/Commands/HungryCommand.cs
+++ b/src/Pretzel/Commands/HungryCommand.cs
@@ -50,9 +50,11 @@ 2 tablespoons baking soda
 
 Eat the pretzels warm, or reheat them in an oven or microwave.";
 
-        public async Task Execute()
+        public Task Execute()
         {
             Tracing.Info(recipe);
+
+            return Task.CompletedTask;
         }
     }
 }
diff --git a/src/Pretzel/Commands/ImportCommand.cs b/src/Pretzel/Commands/ImportCommand.cs
index 2ff9130b1..55f45f496 100644
--- a/src/Pretzel/Commands/ImportCommand.cs
+++ b/src/Pretzel/Commands/ImportCommand.cs
@@ -51,28 +51,31 @@ class ImportCommand : IPretzelCommand
         [Import]
         public ImportCommandParameters Parameters { get; set; }
 
-        public async Task Execute()
+        public Task Execute()
         {
             Tracing.Info("import - import posts from external source");
 
             if (!Importers.Any(e => String.Equals(e, Parameters.ImportType, StringComparison.InvariantCultureIgnoreCase)))
             {
                 Tracing.Info("Requested import type not found: {0}", Parameters.ImportType);
-                return;
+
+                return Task.CompletedTask;
             }
 
             if (string.Equals("wordpress", Parameters.ImportType, StringComparison.InvariantCultureIgnoreCase))
             {
-                var wordpressImporter = new WordpressImport(FileSystem, Parameters.Path, Parameters.ImportFile);
+                var wordpressImporter = new WordpressImport(FileSystem, Parameters.Source, Parameters.ImportFile);
                 wordpressImporter.Import();
             }
             else if (string.Equals("blogger", Parameters.ImportType, StringComparison.InvariantCultureIgnoreCase))
             {
-                var bloggerImporter = new BloggerImport(FileSystem, Parameters.Path, Parameters.ImportFile);
+                var bloggerImporter = new BloggerImport(FileSystem, Parameters.Source, Parameters.ImportFile);
                 bloggerImporter.Import();
             }
 
             Tracing.Info("Import complete");
+
+            return Task.CompletedTask;
         }
     }
 }
diff --git a/src/Pretzel/Commands/IngredientCommand.cs b/src/Pretzel/Commands/IngredientCommand.cs
index 73926f841..d6b638ecb 100644
--- a/src/Pretzel/Commands/IngredientCommand.cs
+++ b/src/Pretzel/Commands/IngredientCommand.cs
@@ -44,12 +44,14 @@ public sealed class IngredientCommand : IPretzelCommand
         [Import]
         public IngredientCommandParameters Parameters { get; set; }
 
-        public async Task Execute()
+        public Task Execute()
         {
             Tracing.Info("ingredient - create a new post");
 
-            var ingredient = new Ingredient(FileSystem, Parameters.NewPostTitle, Parameters.Path, Parameters.Drafts);
+            var ingredient = new Ingredient(FileSystem, Parameters.NewPostTitle, Parameters.Source, Parameters.Drafts);
             ingredient.Create();
+
+            return Task.CompletedTask;
         }
     }
 }
diff --git a/src/Pretzel/Commands/RecipeCommand.cs b/src/Pretzel/Commands/RecipeCommand.cs
index 18a3388a6..c84ddc128 100644
--- a/src/Pretzel/Commands/RecipeCommand.cs
+++ b/src/Pretzel/Commands/RecipeCommand.cs
@@ -55,7 +55,7 @@ public sealed class RecipeCommand : IPretzelCommand
         [ImportMany]
         public IEnumerable<IAdditionalIngredient> AdditionalIngredients { get; set; }
 
-        public async Task Execute()
+        public Task Execute()
         {
             Tracing.Info("create - configure a new site");
 
@@ -66,13 +66,16 @@ public async Task Execute()
             if (!TemplateEngines.Any(e => String.Equals(e, engine, StringComparison.InvariantCultureIgnoreCase)))
             {
                 Tracing.Info("Requested templating engine not found: {0}", engine);
-                return;
+
+                return Task.CompletedTask;
             }
 
             Tracing.Info("Using {0} Engine", engine);
 
-            var recipe = new Recipe(FileSystem, engine, Parameters.Path, AdditionalIngredients, Parameters.WithProject, Parameters.Wiki, Parameters.Drafts);
+            var recipe = new Recipe(FileSystem, engine, Parameters.Source, AdditionalIngredients, Parameters.WithProject, Parameters.Wiki, Parameters.Drafts);
             recipe.Create();
+
+            return Task.CompletedTask;
         }
     }
 }
diff --git a/src/Pretzel/Commands/TasteCommand.cs b/src/Pretzel/Commands/TasteCommand.cs
index 4c33f2f80..2e11039b5 100644
--- a/src/Pretzel/Commands/TasteCommand.cs
+++ b/src/Pretzel/Commands/TasteCommand.cs
@@ -67,11 +67,11 @@ public sealed class TasteCommand : IPretzelCommand
         [Import]
         public IConfiguration Configuration { get; set; }
 
-        public async Task Execute()
+        public Task Execute()
         {
             Tracing.Info("taste - testing a site locally");
             
-            var context = Generator.BuildContext(Parameters.Path, Parameters.Destination, Parameters.Drafts);
+            var context = Generator.BuildContext(Parameters.Source, Parameters.Destination, Parameters.Drafts);
 
             if (Parameters.CleanTarget && FileSystem.Directory.Exists(context.OutputFolder))
             {
@@ -90,7 +90,7 @@ public async Task Execute()
                 Tracing.Info("template engine {0} not found - (engines: {1})", Parameters.Template,
                                            string.Join(", ", TemplateEngines.Engines.Keys));
 
-                return;
+                return Task.CompletedTask;
             }
 
             engine.Initialize();
@@ -100,7 +100,7 @@ public async Task Execute()
 
             using (var watcher = new SimpleFileSystemWatcher(Parameters.Destination))
             {
-                watcher.OnChange(Parameters.Path, WatcherOnChanged);
+                watcher.OnChange(Parameters.Source, WatcherOnChanged);
 
                 using (var w = new WebHost(Parameters.Destination, new FileContentProvider(), Convert.ToInt32(Parameters.Port)))
                 {
@@ -111,7 +111,8 @@ public async Task Execute()
                     catch (System.Net.Sockets.SocketException)
                     {
                         Tracing.Info("Port {0} is already in use", Parameters.Port);
-                        return;
+
+                        return Task.CompletedTask;
                     }
 
                     var url = string.Format("http://localhost:{0}/", Parameters.Port);
@@ -142,13 +143,15 @@ public async Task Execute()
                     Console.WriteLine();
                 }
             }
+
+            return Task.CompletedTask;
         }
 
         private void WatcherOnChanged(string file)
         {
-            if (file.StartsWith(Parameters.Path))
+            if (file.StartsWith(Parameters.Source))
             {
-                var relativeFile = file.Substring(Parameters.Path.Length).ToRelativeFile();
+                var relativeFile = file.Substring(Parameters.Source.Length).ToRelativeFile();
                 if (Generator.IsExcludedPath(relativeFile))
                 {
                     return;
@@ -157,9 +160,9 @@ private void WatcherOnChanged(string file)
 
             Tracing.Info("File change: {0}", file);
 
-            Configuration.ReadFromFile(Parameters.Path);
+            Configuration.ReadFromFile(Parameters.Source);
 
-            var context = Generator.BuildContext(Parameters.Path, Parameters.Destination, Parameters.Drafts);
+            var context = Generator.BuildContext(Parameters.Source, Parameters.Destination, Parameters.Drafts);
             if (Parameters.CleanTarget && FileSystem.Directory.Exists(context.OutputFolder))
             {
                 FileSystem.Directory.Delete(context.OutputFolder, true);
diff --git a/src/Pretzel/Commands/VersionCommand.cs b/src/Pretzel/Commands/VersionCommand.cs
index 1004b5538..d787d36d9 100644
--- a/src/Pretzel/Commands/VersionCommand.cs
+++ b/src/Pretzel/Commands/VersionCommand.cs
@@ -10,9 +10,11 @@ namespace Pretzel.Commands
     [CommandInfo(CommandName = BuiltInCommands.Version, CommandDescription = "display current Pretzel version")]
     public sealed class VersionCommand : IPretzelCommand
     {
-        public async Task Execute()
+        public Task Execute()
         {
             Tracing.Info("V{0}", Assembly.GetExecutingAssembly().GetName().Version);
+
+            return Task.CompletedTask;
         }
     }
 }
diff --git a/src/Pretzel/Program.cs b/src/Pretzel/Program.cs
index afdf207d4..282836e4a 100644
--- a/src/Pretzel/Program.cs
+++ b/src/Pretzel/Program.cs
@@ -205,9 +205,11 @@ private static void LoadPlugins(ContainerConfiguration configuration, bool safe,
                         }
                         catch (ReflectionTypeLoadException)
                         {
+                            //Cannot load the type
                         }
                         catch (BadImageFormatException)
                         {
+                            //Cannot load the type. It's probably wrong bitness
                         }
                     }
 

From 9bd0c2f413ee18065ebfd49703898ba64a5b28c0 Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Sat, 28 Sep 2019 10:55:55 +0200
Subject: [PATCH 32/56] refactor: renamed IPathProvider to ISourcePathProvider

---
 .../Commands/PretzelBaseCommandParameters.cs      |  2 +-
 src/Pretzel.Logic/Configuration.cs                |  4 ++--
 .../Commands/PretzelCommandHandlerTests.cs        |  8 ++++----
 .../Templating/Jekyll/LiquidEngineTests.cs        | 15 +++++++--------
 src/Pretzel/Commands/PretzelCommandHandler.cs     |  4 ++--
 5 files changed, 16 insertions(+), 17 deletions(-)

diff --git a/src/Pretzel.Logic/Commands/PretzelBaseCommandParameters.cs b/src/Pretzel.Logic/Commands/PretzelBaseCommandParameters.cs
index d0a2990b3..a0c82c2df 100644
--- a/src/Pretzel.Logic/Commands/PretzelBaseCommandParameters.cs
+++ b/src/Pretzel.Logic/Commands/PretzelBaseCommandParameters.cs
@@ -9,7 +9,7 @@
 
 namespace Pretzel.Logic.Commands
 {
-    public abstract class PretzelBaseCommandParameters : BaseParameters, IPathProvider
+    public abstract class PretzelBaseCommandParameters : BaseParameters, ISourcePathProvider
     {
         protected readonly IFileSystem fileSystem;
 
diff --git a/src/Pretzel.Logic/Configuration.cs b/src/Pretzel.Logic/Configuration.cs
index 3beb9f836..89b06cd09 100644
--- a/src/Pretzel.Logic/Configuration.cs
+++ b/src/Pretzel.Logic/Configuration.cs
@@ -7,9 +7,9 @@
 
 namespace Pretzel.Logic
 {
-    public interface IPathProvider
+    public interface ISourcePathProvider
     {
-        string Path { get; }
+        string Source { get; }
     }
 
     public interface IConfiguration
diff --git a/src/Pretzel.Tests/Commands/PretzelCommandHandlerTests.cs b/src/Pretzel.Tests/Commands/PretzelCommandHandlerTests.cs
index 91dada9f8..702f732e0 100644
--- a/src/Pretzel.Tests/Commands/PretzelCommandHandlerTests.cs
+++ b/src/Pretzel.Tests/Commands/PretzelCommandHandlerTests.cs
@@ -81,8 +81,8 @@ public async Task Configuration_ReadFromFile_IsCalled_WithPathProvider()
             var configuration = Substitute.For<IConfiguration>();
 
             var rootCommand = new RootCommand();
-            var testParams = Substitute.For<ICommandParameters, IPathProvider>();
-            ((IPathProvider)testParams).Path.Returns("foo");
+            var testParams = Substitute.For<ICommandParameters, ISourcePathProvider>();
+            ((ISourcePathProvider)testParams).Source.Returns("foo");
 
             var context = new InvocationContext(new Parser(rootCommand).Parse(string.Empty), Substitute.For<IConsole>());
 
@@ -213,8 +213,8 @@ public async Task ExecutionOrder()
 
             var context = new InvocationContext(new Parser(rootCommand).Parse(""), Substitute.For<IConsole>());
             var configuration = Substitute.For<IConfiguration>();
-            var @params = Substitute.For<ICommandParameters, IPathProvider>();
-            ((IPathProvider)@params).Path.Returns("bar");
+            var @params = Substitute.For<ICommandParameters, ISourcePathProvider>();
+            ((ISourcePathProvider)@params).Source.Returns("bar");
             var command = Substitute.For<IPretzelCommand>();
 
             var sut = new PretzelCommandHandler(
diff --git a/src/Pretzel.Tests/Templating/Jekyll/LiquidEngineTests.cs b/src/Pretzel.Tests/Templating/Jekyll/LiquidEngineTests.cs
index 4be598ffd..427214335 100644
--- a/src/Pretzel.Tests/Templating/Jekyll/LiquidEngineTests.cs
+++ b/src/Pretzel.Tests/Templating/Jekyll/LiquidEngineTests.cs
@@ -1,3 +1,10 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.IO.Abstractions;
+using System.IO.Abstractions.TestingHelpers;
+using System.Linq;
+using System.Text;
 using DotLiquid;
 using NSubstitute;
 using Pretzel.Logic;
@@ -8,15 +15,7 @@
 using Pretzel.Logic.Liquid;
 using Pretzel.Logic.Templating.Context;
 using Pretzel.Logic.Templating.Jekyll;
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.IO.Abstractions;
-using System.IO.Abstractions.TestingHelpers;
-using System.Linq;
-using System.Text;
 using Xunit;
-using Xunit.Extensions;
 
 namespace Pretzel.Tests.Templating.Jekyll
 {
diff --git a/src/Pretzel/Commands/PretzelCommandHandler.cs b/src/Pretzel/Commands/PretzelCommandHandler.cs
index 32ad5ba13..85c930dec 100644
--- a/src/Pretzel/Commands/PretzelCommandHandler.cs
+++ b/src/Pretzel/Commands/PretzelCommandHandler.cs
@@ -34,9 +34,9 @@ public async Task<int> InvokeAsync(InvocationContext context)
                 CommandParameters.BindingCompleted();
             }
 
-            if (CommandParameters is IPathProvider pathProvider)
+            if (CommandParameters is ISourcePathProvider pathProvider)
             {
-                Configuration.ReadFromFile(pathProvider.Path);
+                Configuration.ReadFromFile(pathProvider.Source);
             }
 
             if (CommandParameters is ICommandParametersExtendable commandParametersExtendable)

From c354558344c7277d52c754e24d45e81657e7f7be Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Sat, 28 Sep 2019 16:31:57 +0200
Subject: [PATCH 33/56] test: added Program integration & Argument tests

---
 src/Pretzel.Tests/ProgramTests.cs | 142 ++++++++++++++++++++++++++++++
 src/Pretzel/Program.cs            |  98 +++++++++++----------
 2 files changed, 195 insertions(+), 45 deletions(-)
 create mode 100644 src/Pretzel.Tests/ProgramTests.cs

diff --git a/src/Pretzel.Tests/ProgramTests.cs b/src/Pretzel.Tests/ProgramTests.cs
new file mode 100644
index 000000000..7b9a6d0ac
--- /dev/null
+++ b/src/Pretzel.Tests/ProgramTests.cs
@@ -0,0 +1,142 @@
+using System;
+using System.IO.Abstractions;
+using System.IO.Abstractions.TestingHelpers;
+using System.Linq;
+using NSubstitute;
+using Xunit;
+
+namespace Pretzel.Tests
+{
+    public class ProgramTests
+    {
+        IDirectory directory;
+        public ProgramTests()
+        {
+            Program.fileSystem = Substitute.For<IFileSystem>();
+            directory = Substitute.For<IDirectory>();
+            Program.fileSystem.Directory.Returns(directory);
+        }
+
+        [Theory]
+        [InlineData("source", new[] { "s", "source" })]
+        [InlineData("debug", new[] { "debug" })]
+        [InlineData("safe", new[] { "safe" })]
+        public void GlobalOptionsArePresent(string optionName, string[] argumentNames)
+        {
+            Assert.Contains(Program.GlobalOptions, o => o.Name == optionName);
+
+            Assert.Contains(Program.GlobalOptions.First(o => o.Name == optionName).Aliases,
+                alias => argumentNames.Contains(alias)
+            );
+        }
+
+        [Fact]
+        public void SourceDefaultsToCurrentDirectory()
+        {
+            var expectedDirectory = @"C:\foo";
+            directory.GetCurrentDirectory().Returns(expectedDirectory);
+
+            var sourceOption = Program.GlobalOptions.First(o => o.Name == "source");
+
+            Assert.True(sourceOption.Argument.HasDefaultValue);
+            Assert.Equal(expectedDirectory, sourceOption.Argument.GetDefaultValue());
+        }
+
+        [Fact]
+        public void CompositionDoesNotThrow()
+        {
+            using (var compositionHost = Program.Compose(true, true, null))
+            {
+                compositionHost.GetExport<Program>();
+            }
+        }
+
+        public class PatchSourcePath
+        {
+            public PatchSourcePath()
+            {
+                Program.fileSystem = new MockFileSystem();
+            }
+
+            private const string ExpectedPath = @"D:\Code";
+
+            [Fact]
+            public void PatchSourcePath_WhenNoParametersSet_MapsPathToCurrentDirectory()
+            {
+                var result = Program.PatchSourcePath(new[] { "bake" });
+                Assert.Equal(new[] { "bake" }, result);
+            }
+
+            [Fact]
+            public void PatchSourcePath_WhenOneParameterSet_MapsToPath()
+            {
+                var result = Program.PatchSourcePath(new[] { "bake", ExpectedPath });
+                Assert.Equal(new[] { "bake", "-s", ExpectedPath }, result);
+            }
+
+            [Fact]
+            public void PatchSourcePath_WhenOneParameterSet_MapsToPath_RelativePath()
+            {
+                var result = Program.PatchSourcePath(new[] { "bake", "mySite" });
+
+                Assert.Equal(new[]
+                {
+                    "bake",
+                    "-s",
+                    Program.fileSystem.Path.Combine(
+                        Program.fileSystem.Directory.GetCurrentDirectory(),
+                        "mySite"
+                        )
+                }, result);
+            }
+
+            [Fact]
+            public void PatchSourcePath_WhenSpecifyingSourcePathUsingShortParameter_MapsToPath()
+            {
+                var result = Program.PatchSourcePath(new[] { "bake", "--s", ExpectedPath });
+                Assert.Equal(new[]
+                {
+                    "bake",
+                    "--s",
+                    ExpectedPath
+                }, result);
+            }
+
+            [Fact]
+            public void PatchSourcePath_WhenSpecifyingSourcePathUsingFullParameter_MapsToPath()
+            {
+                var result = Program.PatchSourcePath(new[] { "bake", "--source", ExpectedPath });
+                Assert.Equal(new[]
+                {
+                    "bake",
+                    "--source",
+                    ExpectedPath
+                }, result);
+            }
+
+            [Fact]
+            public void PatchSourcePath_WhenSpecifyingSourcePathUsingShortParameterSingleDash_MapsToPath()
+            {
+                var result = Program.PatchSourcePath(new[] { "bake", "-s", ExpectedPath });
+                Assert.Equal(new[]
+                {
+                    "bake",
+                    "-s",
+                    ExpectedPath
+                }, result);
+            }
+
+            [Fact]
+            public void PatchSourcePath_WhenSpecifyingSourcePathUsingFullParameterSingleDash_MapsToPath()
+            {
+                var result = Program.PatchSourcePath(new[] { "bake", "-source", ExpectedPath });
+                Assert.Equal(new[]
+                {
+                    "bake",
+                    "-source",
+                    ExpectedPath
+                }, result);
+            }
+        }
+    }
+}
diff --git a/src/Pretzel/Program.cs b/src/Pretzel/Program.cs
index 282836e4a..78f1cca5a 100644
--- a/src/Pretzel/Program.cs
+++ b/src/Pretzel/Program.cs
@@ -19,61 +19,42 @@ namespace Pretzel
     [Export]
     internal class Program
     {
+#pragma warning disable S2223 // Non-constant static fields should not be visible
+        internal static IFileSystem fileSystem = new FileSystem();
+
+        internal static Option[] GlobalOptions = new[]
+        {
+            new Option("--debug", "Enable debugging")
+            {
+                Argument = new Argument<bool>()
+            },
+            new Option("--safe", "Disable custom plugins")
+            {
+                Argument = new Argument<bool>()
+            },
+            new Option(new[] { "--source", "-source", "-s", "--s" }, "The path to the source site (default current directory)")
+            {
+                Argument = new Argument<string>(() => fileSystem.Directory.GetCurrentDirectory())
+            }
+        };
+#pragma warning restore S2223 // Non-constant static fields should not be visible
+
         [Import]
         public CommandCollection CommandCollection { get; set; }
-
+        
         [Export]
-        public IFileSystem FileSystem { get; set; } = new FileSystem();
+        public IFileSystem FileSystem { get; set; } = fileSystem;
 
         private static async Task<int> Main(string[] args)
         {
-            var fileSystem = new FileSystem();
-
             var rootCommand = new RootCommand
             {
                 TreatUnmatchedTokensAsErrors = false
             };
 
-            var globalOptions = new[]
-            {
-                new Option("--debug", "Enable debugging")
-                {
-                    Argument = new Argument<bool>()
-                },
-                new Option("--safe", "Disable custom plugins")
-                {
-                    Argument = new Argument<bool>()
-                },
-                new Option(new[] { "-s", "--source" }, "The path to the source site (default current directory)")
-                {
-                    Argument = new Argument<string>(() => fileSystem.Directory.GetCurrentDirectory())
-                }
-            };
+            args = PatchSourcePath(args);
 
-            if (args.Length > 1 && !args.Contains("-s") && !args.Contains("--source"))
-            {
-                var firstArgument = args[1];
-
-                // take the first argument after the command
-                if (firstArgument != null && !firstArgument.StartsWith("-") && !firstArgument.StartsWith("/"))
-                {
-                    var arguments = args.ToList();
-                    var path = fileSystem.Path.IsPathRooted(firstArgument)
-                        ? firstArgument
-                        : fileSystem.Path.Combine(fileSystem.Directory.GetCurrentDirectory(), firstArgument);
-
-                    path = string.IsNullOrWhiteSpace(path)
-                        ? fileSystem.Directory.GetCurrentDirectory()
-                        : fileSystem.Path.GetFullPath(path);
-
-                    arguments[1] = "-s";
-                    arguments.Insert(2, path);
-                    args = arguments.ToArray();
-                }
-            }
-
-
-            foreach (var option in globalOptions)
+            foreach (var option in GlobalOptions)
             {
                 rootCommand.AddOption(option);
             }
@@ -89,7 +70,7 @@ private static async Task<int> Main(string[] args)
                     using (var host = Compose(debug, safe, source))
                     {
                         var program = host.GetExport<Program>();
-                        var result = await program.Run(globalOptions, args);
+                        var result = await program.Run(GlobalOptions, args);
                         WaitForClose();
                         return result;
                     }
@@ -113,6 +94,33 @@ private static async Task<int> Main(string[] args)
             }
         }
 
+        internal static string[] PatchSourcePath(string[] args)
+        {
+            if (args.Length > 1 && !args.Contains("-s") && !args.Contains("--source"))
+            {
+                var firstArgument = args[1];
+
+                // take the first argument after the command
+                if (firstArgument != null && !firstArgument.StartsWith("-") && !firstArgument.StartsWith("/"))
+                {
+                    var arguments = args.ToList();
+                    var path = fileSystem.Path.IsPathRooted(firstArgument)
+                        ? firstArgument
+                        : fileSystem.Path.Combine(fileSystem.Directory.GetCurrentDirectory(), firstArgument);
+
+                    path = string.IsNullOrWhiteSpace(path)
+                        ? fileSystem.Directory.GetCurrentDirectory()
+                        : fileSystem.Path.GetFullPath(path);
+
+                    arguments[1] = "-s";
+                    arguments.Insert(2, path);
+                    return arguments.ToArray();
+                }
+            }
+
+            return args;
+        }
+
         private static void InitializeTrace(bool debug)
         {
             Tracing.SetTrace(ConsoleTrace.Write);
@@ -161,7 +169,7 @@ public static void WaitForClose()
             }
         }
 
-        public static CompositionHost Compose(bool debug, bool safe, string path)
+        internal static CompositionHost Compose(bool debug, bool safe, string path)
         {
             try
             {

From 83956a02281dafc528635bfd965ffe4eada23a7f Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Mon, 30 Sep 2019 09:27:33 +0200
Subject: [PATCH 34/56] refactor: renamed files containing generic types

---
 ...mandParametersTests`1.cs => BakeBaseCommandParametersTests.cs} | 0
 .../Commands/{ParametersTests`1.cs => ParametersTests.cs}         | 0
 ...ndParametersTests`1.cs => PetzelBaseCommandParametersTests.cs} | 0
 3 files changed, 0 insertions(+), 0 deletions(-)
 rename src/Pretzel.Tests/Commands/{BakeBaseCommandParametersTests`1.cs => BakeBaseCommandParametersTests.cs} (100%)
 rename src/Pretzel.Tests/Commands/{ParametersTests`1.cs => ParametersTests.cs} (100%)
 rename src/Pretzel.Tests/Commands/{PetzelBaseCommandParametersTests`1.cs => PetzelBaseCommandParametersTests.cs} (100%)

diff --git a/src/Pretzel.Tests/Commands/BakeBaseCommandParametersTests`1.cs b/src/Pretzel.Tests/Commands/BakeBaseCommandParametersTests.cs
similarity index 100%
rename from src/Pretzel.Tests/Commands/BakeBaseCommandParametersTests`1.cs
rename to src/Pretzel.Tests/Commands/BakeBaseCommandParametersTests.cs
diff --git a/src/Pretzel.Tests/Commands/ParametersTests`1.cs b/src/Pretzel.Tests/Commands/ParametersTests.cs
similarity index 100%
rename from src/Pretzel.Tests/Commands/ParametersTests`1.cs
rename to src/Pretzel.Tests/Commands/ParametersTests.cs
diff --git a/src/Pretzel.Tests/Commands/PetzelBaseCommandParametersTests`1.cs b/src/Pretzel.Tests/Commands/PetzelBaseCommandParametersTests.cs
similarity index 100%
rename from src/Pretzel.Tests/Commands/PetzelBaseCommandParametersTests`1.cs
rename to src/Pretzel.Tests/Commands/PetzelBaseCommandParametersTests.cs

From f96c859a307f598b62171f8bbd60eed0aad2efb4 Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Mon, 30 Sep 2019 09:42:53 +0200
Subject: [PATCH 35/56] refactor: removed obsolete parameter

---
 .../Commands/PretzelBaseCommandParameters.cs         |  2 --
 .../VirtualDirectorySupportArgumentsTests.cs         | 12 ++++++++++++
 2 files changed, 12 insertions(+), 2 deletions(-)
 create mode 100644 src/Pretzel.Tests/Extensibility/Extensions/VirtualDirectorySupportArgumentsTests.cs

diff --git a/src/Pretzel.Logic/Commands/PretzelBaseCommandParameters.cs b/src/Pretzel.Logic/Commands/PretzelBaseCommandParameters.cs
index a0c82c2df..f1d2d4eda 100644
--- a/src/Pretzel.Logic/Commands/PretzelBaseCommandParameters.cs
+++ b/src/Pretzel.Logic/Commands/PretzelBaseCommandParameters.cs
@@ -43,8 +43,6 @@ protected override void WithOptions(List<Option> options)
         public bool Debug { get; set; }
         // Default Option that get's injected from Program
         public bool Safe { get; set; }
-        [Obsolete("Use '" + nameof(Source) + "' instead.")]
-        public string Path => Source;
 
         public string Template { get; set; }
         public string Destination { get; set; }
diff --git a/src/Pretzel.Tests/Extensibility/Extensions/VirtualDirectorySupportArgumentsTests.cs b/src/Pretzel.Tests/Extensibility/Extensions/VirtualDirectorySupportArgumentsTests.cs
new file mode 100644
index 000000000..10257e1a7
--- /dev/null
+++ b/src/Pretzel.Tests/Extensibility/Extensions/VirtualDirectorySupportArgumentsTests.cs
@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Pretzel.Tests.Extensibility.Extensions
+{
+    public class VirtualDirectorySupportArgumentsTests
+    {
+    }
+}

From 416377b58a7b06af1ebff4630236c7ebbf419b6d Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Mon, 30 Sep 2019 09:57:03 +0200
Subject: [PATCH 36/56] refactor: Arguments now need to return options

---
 .../Commands/BakeBaseCommandParameters.cs     | 14 ++++-----
 src/Pretzel.Logic/Commands/BaseParameters.cs  |  4 +--
 .../Commands/PretzelBaseCommandParameters.cs  | 29 +++++++++----------
 .../Commands/BaseParametersTests.cs           | 12 ++++----
 src/Pretzel/Commands/ImportCommand.cs         | 22 ++++++--------
 src/Pretzel/Commands/IngredientCommand.cs     | 14 ++++-----
 src/Pretzel/Commands/RecipeCommand.cs         | 22 ++++++--------
 src/Pretzel/Commands/TasteCommand.cs          | 23 +++++++--------
 8 files changed, 58 insertions(+), 82 deletions(-)

diff --git a/src/Pretzel.Logic/Commands/BakeBaseCommandParameters.cs b/src/Pretzel.Logic/Commands/BakeBaseCommandParameters.cs
index 4c83209de..9037abc8f 100644
--- a/src/Pretzel.Logic/Commands/BakeBaseCommandParameters.cs
+++ b/src/Pretzel.Logic/Commands/BakeBaseCommandParameters.cs
@@ -10,17 +10,13 @@ public abstract class BakeBaseCommandParameters : PretzelBaseCommandParameters
     {
         protected BakeBaseCommandParameters(IFileSystem fileSystem) : base(fileSystem) { }
 
-        protected override void WithOptions(List<Option> options)
+        protected override IEnumerable<Option> CreateOptions() => base.CreateOptions().Concat(new[]
         {
-            base.WithOptions(options);
-            options.AddRange(new[]
+            new Option(new [] { "-c", "--cleantarget" }, "Delete the target directory (_site by default)")
             {
-                new Option(new [] { "-c", "--cleantarget" }, "Delete the target directory (_site by default)")
-                {
-                    Argument = new Argument<bool>()
-                },
-            });
-        }
+                Argument = new Argument<bool>()
+            },
+        });
 
         public bool CleanTarget { get; set; }
     }
diff --git a/src/Pretzel.Logic/Commands/BaseParameters.cs b/src/Pretzel.Logic/Commands/BaseParameters.cs
index dca004440..a9f3e7cba 100644
--- a/src/Pretzel.Logic/Commands/BaseParameters.cs
+++ b/src/Pretzel.Logic/Commands/BaseParameters.cs
@@ -20,7 +20,7 @@ internal void OnImportsSatisfied()
         {
             var options = new List<Option>();
             Options = options;
-            WithOptions(options);
+            options.AddRange(CreateOptions());
 
             foreach (var factory in this.GetCommandExtentions())
             {
@@ -28,7 +28,7 @@ internal void OnImportsSatisfied()
             }
         }
 
-        protected abstract void WithOptions(List<Option> options);
+        protected abstract IEnumerable<Option> CreateOptions();
 
         public virtual void BindingCompleted()
         {
diff --git a/src/Pretzel.Logic/Commands/PretzelBaseCommandParameters.cs b/src/Pretzel.Logic/Commands/PretzelBaseCommandParameters.cs
index f1d2d4eda..a7341646a 100644
--- a/src/Pretzel.Logic/Commands/PretzelBaseCommandParameters.cs
+++ b/src/Pretzel.Logic/Commands/PretzelBaseCommandParameters.cs
@@ -18,24 +18,21 @@ protected PretzelBaseCommandParameters(IFileSystem fileSystem)
             this.fileSystem = fileSystem;
         }
 
-        protected override void WithOptions(List<Option> options)
+        protected override IEnumerable<Option> CreateOptions() => new[]
         {
-            options.AddRange(new[]
+            new Option(new []{ "-t", "--template" }, "The templating engine to use")
             {
-                new Option(new []{ "-t", "--template" }, "The templating engine to use")
-                {
-                    Argument = new Argument<string>()
-                },
-                new Option(new [] { "-d", "--destination" }, "The path to the destination site (default _site)")
-                {
-                    Argument = new Argument<string>(() => "_site")
-                },
-                new Option("--drafts", "Add the posts in the drafts folder")
-                {
-                    Argument = new Argument<bool>()
-                },
-            });
-        }
+                Argument = new Argument<string>()
+            },
+            new Option(new [] { "-d", "--destination" }, "The path to the destination site (default _site)")
+            {
+                Argument = new Argument<string>(() => "_site")
+            },
+            new Option("--drafts", "Add the posts in the drafts folder")
+            {
+                Argument = new Argument<bool>()
+            },
+        };
 
         // Default Option that get's injected from Program
         public string Source { get; set; }
diff --git a/src/Pretzel.Tests/Commands/BaseParametersTests.cs b/src/Pretzel.Tests/Commands/BaseParametersTests.cs
index ab7431b2a..0c8a530dc 100644
--- a/src/Pretzel.Tests/Commands/BaseParametersTests.cs
+++ b/src/Pretzel.Tests/Commands/BaseParametersTests.cs
@@ -1,13 +1,11 @@
-using Pretzel.Logic.Commands;
-using Pretzel.Logic.Extensibility;
 using System;
 using System.Collections.Generic;
 using System.CommandLine;
 using System.Composition;
 using System.Composition.Hosting;
 using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+using Pretzel.Logic.Commands;
+using Pretzel.Logic.Extensibility;
 using Xunit;
 
 namespace Pretzel.Tests.Commands
@@ -19,10 +17,10 @@ public class BaseParametersTests
         [CommandArguments(CommandName = "test")]
         public class BaseParametersImpl : BaseParameters
         {
-            protected override void WithOptions(List<Option> options)
+            protected override IEnumerable<Option> CreateOptions() => new[]
             {
-                options.Add(new Option("-base"));
-            }
+                new Option("-base")
+            };
         }
 
         [Export]
diff --git a/src/Pretzel/Commands/ImportCommand.cs b/src/Pretzel/Commands/ImportCommand.cs
index 55f45f496..8275be448 100644
--- a/src/Pretzel/Commands/ImportCommand.cs
+++ b/src/Pretzel/Commands/ImportCommand.cs
@@ -19,21 +19,17 @@ public class ImportCommandParameters : PretzelBaseCommandParameters
         [ImportingConstructor]
         public ImportCommandParameters(IFileSystem fileSystem) : base(fileSystem) { }
 
-        protected override void WithOptions(List<Option> options)
+        protected override IEnumerable<Option> CreateOptions() => base.CreateOptions().Concat(new[]
         {
-            base.WithOptions(options);
-            options.AddRange(new[]
+            new Option(new [] {"--importtype", "-i"}, "The import type")
             {
-                new Option(new [] {"--importtype", "-i"}, "The import type")
-                {
-                    Argument = new Argument<string>()
-                },
-                new Option(new [] {"--importfile", "-f"}, "Path to import file")
-                {
-                    Argument = new Argument<string>()
-                },
-            });
-        }
+                Argument = new Argument<string>()
+            },
+            new Option(new [] {"--importfile", "-f"}, "Path to import file")
+            {
+                Argument = new Argument<string>()
+            }
+        });
 
         public string ImportType { get; set; }
 
diff --git a/src/Pretzel/Commands/IngredientCommand.cs b/src/Pretzel/Commands/IngredientCommand.cs
index d6b638ecb..e855b6a6a 100644
--- a/src/Pretzel/Commands/IngredientCommand.cs
+++ b/src/Pretzel/Commands/IngredientCommand.cs
@@ -19,17 +19,13 @@ public class IngredientCommandParameters : PretzelBaseCommandParameters
         [ImportingConstructor]
         public IngredientCommandParameters(IFileSystem fileSystem) : base(fileSystem) { }
 
-        protected override void WithOptions(List<Option> options)
+        protected override IEnumerable<Option> CreateOptions() => base.CreateOptions().Concat(new[]
         {
-            base.WithOptions(options);
-            options.AddRange(new[]
+            new Option(new [] { "--newposttitle", "-n" }, "The title of the new post (\"New post\" by default")
             {
-                new Option(new [] { "--newposttitle", "-n" }, "The title of the new post (\"New post\" by default")
-                {
-                    Argument = new Argument<string>(() => "New post")
-                }
-            });
-        }
+                Argument = new Argument<string>(() => "New post")
+            }
+        });
 
         public string NewPostTitle { get; set; }
     }
diff --git a/src/Pretzel/Commands/RecipeCommand.cs b/src/Pretzel/Commands/RecipeCommand.cs
index c84ddc128..cbe4f8d56 100644
--- a/src/Pretzel/Commands/RecipeCommand.cs
+++ b/src/Pretzel/Commands/RecipeCommand.cs
@@ -20,21 +20,17 @@ public class RecipeCommandParameters : PretzelBaseCommandParameters
         [ImportingConstructor]
         public RecipeCommandParameters(IFileSystem fileSystem) : base(fileSystem) { }
 
-        protected override void WithOptions(List<Option> options)
+        protected override IEnumerable<Option> CreateOptions() => base.CreateOptions().Concat(new[]
         {
-            base.WithOptions(options);
-            options.AddRange(new[]
+            new Option(new [] { "-p", "--withproject" }, "Includes a layout VS Solution, to give intellisense when editing razor layout files")
             {
-                new Option(new [] { "-p", "--withproject" }, "Includes a layout VS Solution, to give intellisense when editing razor layout files")
-                {
-                    Argument = new Argument<bool>()
-                },
-                new Option(new [] { "-w", "--wiki"}, "Creates a wiki instead of a blog (razor template only)")
-                {
-                    Argument = new Argument<bool>()
-                },
-            });
-        }
+                Argument = new Argument<bool>()
+            },
+            new Option(new [] { "-w", "--wiki"}, "Creates a wiki instead of a blog (razor template only)")
+            {
+                Argument = new Argument<bool>()
+            },
+        });
 
         public bool WithProject { get; set; }
         public bool Wiki { get; set; }
diff --git a/src/Pretzel/Commands/TasteCommand.cs b/src/Pretzel/Commands/TasteCommand.cs
index 2e11039b5..e4e0e5b44 100644
--- a/src/Pretzel/Commands/TasteCommand.cs
+++ b/src/Pretzel/Commands/TasteCommand.cs
@@ -3,6 +3,7 @@
 using System.CommandLine;
 using System.Composition;
 using System.IO.Abstractions;
+using System.Linq;
 using System.Threading.Tasks;
 using Pretzel.Logic;
 using Pretzel.Logic.Commands;
@@ -22,21 +23,17 @@ public class TasteCommandParameters : BakeBaseCommandParameters
         [ImportingConstructor]
         public TasteCommandParameters(IFileSystem fileSystem) : base(fileSystem) { }
 
-        protected override void WithOptions(List<Option> options)
+        protected override IEnumerable<Option> CreateOptions() => base.CreateOptions().Concat(new[]
         {
-            base.WithOptions(options);
-            options.AddRange(new[]
+            new Option(new[] { "--port", "-p" }, "The port to test the site locally")
             {
-                new Option(new[] { "--port", "-p" }, "The port to test the site locally")
-                {
-                    Argument = new Argument<int>(() => 8080)
-                },
-                new Option("--nobrowser", "Do not launch a browser (false by default)")
-                {
-                    Argument = new Argument<bool>()
-                },
-            });
-        }
+                Argument = new Argument<int>(() => 8080)
+            },
+            new Option("--nobrowser", "Do not launch a browser (false by default)")
+            {
+                Argument = new Argument<bool>()
+            },
+        });
 
         public int Port { get; set; }
         public bool NoBrowser { get; set; }

From 825e85157d257cd3e4d053c56523fc404176e0a0 Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Mon, 30 Sep 2019 10:01:41 +0200
Subject: [PATCH 37/56] feat: allow commands to return result code

---
 src/Pretzel.Logic/Commands/ICommand.cs        | 2 +-
 src/Pretzel/Commands/BakeCommand.cs           | 5 +++--
 src/Pretzel/Commands/HungryCommand.cs         | 4 ++--
 src/Pretzel/Commands/ImportCommand.cs         | 6 +++---
 src/Pretzel/Commands/IngredientCommand.cs     | 4 ++--
 src/Pretzel/Commands/PretzelCommandHandler.cs | 4 +---
 src/Pretzel/Commands/RecipeCommand.cs         | 6 +++---
 src/Pretzel/Commands/TasteCommand.cs          | 8 ++++----
 src/Pretzel/Commands/VersionCommand.cs        | 4 ++--
 9 files changed, 21 insertions(+), 22 deletions(-)

diff --git a/src/Pretzel.Logic/Commands/ICommand.cs b/src/Pretzel.Logic/Commands/ICommand.cs
index 05c81181e..7f0e6493d 100644
--- a/src/Pretzel.Logic/Commands/ICommand.cs
+++ b/src/Pretzel.Logic/Commands/ICommand.cs
@@ -4,6 +4,6 @@ namespace Pretzel.Logic.Commands
 {
     public interface IPretzelCommand
     {
-        Task Execute();
+        Task<int> Execute();
     }
 }
diff --git a/src/Pretzel/Commands/BakeCommand.cs b/src/Pretzel/Commands/BakeCommand.cs
index 621b31063..9f53290bb 100644
--- a/src/Pretzel/Commands/BakeCommand.cs
+++ b/src/Pretzel/Commands/BakeCommand.cs
@@ -40,7 +40,7 @@ public sealed class BakeCommand : IPretzelCommand
         [Import]
         public IFileSystem FileSystem { get; set; }
 
-        public Task Execute()
+        public Task<int> Execute()
         {
             Tracing.Info("bake - transforming content into a website");
 
@@ -74,8 +74,9 @@ public Task Execute()
             else
             {
                 Tracing.Info("Cannot find engine for input: '{0}'", Parameters.Template);
+                return Task.FromResult(1);
             }
-            return Task.CompletedTask;
+            return Task.FromResult(0);
         }
     }
 }
diff --git a/src/Pretzel/Commands/HungryCommand.cs b/src/Pretzel/Commands/HungryCommand.cs
index f2db67883..25f48e335 100644
--- a/src/Pretzel/Commands/HungryCommand.cs
+++ b/src/Pretzel/Commands/HungryCommand.cs
@@ -50,11 +50,11 @@ 2 tablespoons baking soda
 
 Eat the pretzels warm, or reheat them in an oven or microwave.";
 
-        public Task Execute()
+        public Task<int> Execute()
         {
             Tracing.Info(recipe);
 
-            return Task.CompletedTask;
+            return Task.FromResult(0);
         }
     }
 }
diff --git a/src/Pretzel/Commands/ImportCommand.cs b/src/Pretzel/Commands/ImportCommand.cs
index 8275be448..18c7bda0e 100644
--- a/src/Pretzel/Commands/ImportCommand.cs
+++ b/src/Pretzel/Commands/ImportCommand.cs
@@ -47,7 +47,7 @@ class ImportCommand : IPretzelCommand
         [Import]
         public ImportCommandParameters Parameters { get; set; }
 
-        public Task Execute()
+        public Task<int> Execute()
         {
             Tracing.Info("import - import posts from external source");
 
@@ -55,7 +55,7 @@ public Task Execute()
             {
                 Tracing.Info("Requested import type not found: {0}", Parameters.ImportType);
 
-                return Task.CompletedTask;
+                return Task.FromResult(1);
             }
 
             if (string.Equals("wordpress", Parameters.ImportType, StringComparison.InvariantCultureIgnoreCase))
@@ -71,7 +71,7 @@ public Task Execute()
 
             Tracing.Info("Import complete");
 
-            return Task.CompletedTask;
+            return Task.FromResult(0);
         }
     }
 }
diff --git a/src/Pretzel/Commands/IngredientCommand.cs b/src/Pretzel/Commands/IngredientCommand.cs
index e855b6a6a..eb1a0de55 100644
--- a/src/Pretzel/Commands/IngredientCommand.cs
+++ b/src/Pretzel/Commands/IngredientCommand.cs
@@ -40,14 +40,14 @@ public sealed class IngredientCommand : IPretzelCommand
         [Import]
         public IngredientCommandParameters Parameters { get; set; }
 
-        public Task Execute()
+        public Task<int> Execute()
         {
             Tracing.Info("ingredient - create a new post");
 
             var ingredient = new Ingredient(FileSystem, Parameters.NewPostTitle, Parameters.Source, Parameters.Drafts);
             ingredient.Create();
 
-            return Task.CompletedTask;
+            return Task.FromResult(0);
         }
     }
 }
diff --git a/src/Pretzel/Commands/PretzelCommandHandler.cs b/src/Pretzel/Commands/PretzelCommandHandler.cs
index 85c930dec..c6898a005 100644
--- a/src/Pretzel/Commands/PretzelCommandHandler.cs
+++ b/src/Pretzel/Commands/PretzelCommandHandler.cs
@@ -52,9 +52,7 @@ public async Task<int> InvokeAsync(InvocationContext context)
                 }
             }
 
-            await Command.CreateExport().Value.Execute();
-
-            return 0;
+            return await Command.CreateExport().Value.Execute();
         }
     }
 }
diff --git a/src/Pretzel/Commands/RecipeCommand.cs b/src/Pretzel/Commands/RecipeCommand.cs
index cbe4f8d56..175022791 100644
--- a/src/Pretzel/Commands/RecipeCommand.cs
+++ b/src/Pretzel/Commands/RecipeCommand.cs
@@ -51,7 +51,7 @@ public sealed class RecipeCommand : IPretzelCommand
         [ImportMany]
         public IEnumerable<IAdditionalIngredient> AdditionalIngredients { get; set; }
 
-        public Task Execute()
+        public Task<int> Execute()
         {
             Tracing.Info("create - configure a new site");
 
@@ -63,7 +63,7 @@ public Task Execute()
             {
                 Tracing.Info("Requested templating engine not found: {0}", engine);
 
-                return Task.CompletedTask;
+                return Task.FromResult(1);
             }
 
             Tracing.Info("Using {0} Engine", engine);
@@ -71,7 +71,7 @@ public Task Execute()
             var recipe = new Recipe(FileSystem, engine, Parameters.Source, AdditionalIngredients, Parameters.WithProject, Parameters.Wiki, Parameters.Drafts);
             recipe.Create();
 
-            return Task.CompletedTask;
+            return Task.FromResult(0);
         }
     }
 }
diff --git a/src/Pretzel/Commands/TasteCommand.cs b/src/Pretzel/Commands/TasteCommand.cs
index e4e0e5b44..86c45fe00 100644
--- a/src/Pretzel/Commands/TasteCommand.cs
+++ b/src/Pretzel/Commands/TasteCommand.cs
@@ -64,7 +64,7 @@ public sealed class TasteCommand : IPretzelCommand
         [Import]
         public IConfiguration Configuration { get; set; }
 
-        public Task Execute()
+        public Task<int> Execute()
         {
             Tracing.Info("taste - testing a site locally");
             
@@ -87,7 +87,7 @@ public Task Execute()
                 Tracing.Info("template engine {0} not found - (engines: {1})", Parameters.Template,
                                            string.Join(", ", TemplateEngines.Engines.Keys));
 
-                return Task.CompletedTask;
+                return Task.FromResult(1);
             }
 
             engine.Initialize();
@@ -109,7 +109,7 @@ public Task Execute()
                     {
                         Tracing.Info("Port {0} is already in use", Parameters.Port);
 
-                        return Task.CompletedTask;
+                        return Task.FromResult(1);
                     }
 
                     var url = string.Format("http://localhost:{0}/", Parameters.Port);
@@ -141,7 +141,7 @@ public Task Execute()
                 }
             }
 
-            return Task.CompletedTask;
+            return Task.FromResult(0);
         }
 
         private void WatcherOnChanged(string file)
diff --git a/src/Pretzel/Commands/VersionCommand.cs b/src/Pretzel/Commands/VersionCommand.cs
index d787d36d9..d68d3a70f 100644
--- a/src/Pretzel/Commands/VersionCommand.cs
+++ b/src/Pretzel/Commands/VersionCommand.cs
@@ -10,11 +10,11 @@ namespace Pretzel.Commands
     [CommandInfo(CommandName = BuiltInCommands.Version, CommandDescription = "display current Pretzel version")]
     public sealed class VersionCommand : IPretzelCommand
     {
-        public Task Execute()
+        public Task<int> Execute()
         {
             Tracing.Info("V{0}", Assembly.GetExecutingAssembly().GetName().Version);
 
-            return Task.CompletedTask;
+            return Task.FromResult(0);
         }
     }
 }

From 80fe287fc60a77724f6b1cdbee6cff76fb56d8ca Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Mon, 30 Sep 2019 12:24:10 +0200
Subject: [PATCH 38/56] refactor: arguments & command streamlined

---
 ...ameters.cs => BakeBaseCommandArguments.cs} |   4 +-
 ...eParameters.cs => BaseCommandArguments.cs} |  11 +-
 .../Commands/CommandArgumentsAttribute.cs     |   2 +-
 .../Commands/ICommandArguments.cs             |  34 ++++
 .../Commands/ICommandParameters.cs            |  13 --
 .../Commands/ICommandParametersExtendable.cs  |  15 --
 .../Commands/ICommandParametersExtentions.cs  |  27 ----
 ...ters.cs => PretzelBaseCommandArguments.cs} |   4 +-
 src/Pretzel.Logic/Configuration.cs            |   5 +-
 ... => CommandArgumentsExtensionAttribute.cs} |   4 +-
 .../Extensions/AzureHostSupport.cs            |   9 +-
 .../Extensions/VirtualDirectorySupport.cs     |   4 +-
 ...eArgs.cs => ICommandArgumentsExtension.cs} |   3 +-
 .../BakeBaseCommandParametersTests.cs         |   2 +-
 .../Commands/BakeCommandParametersTests.cs    |  18 +--
 .../Commands/BaseParametersTests.cs           |  24 +--
 .../Commands/CommandCollectionTests.cs        | 150 +++++++++++++++++-
 .../ICommandParametersExtentionsTests.cs      | 114 -------------
 .../Commands/ImportCommandParametersTests.cs  |   6 +-
 .../IngredientCommandParametersTests.cs       |   6 +-
 src/Pretzel.Tests/Commands/ParametersTests.cs |   3 +-
 .../PetzelBaseCommandParametersTests.cs       |   2 +-
 .../Commands/PretzelCommandHandlerTests.cs    |  58 ++++---
 .../Commands/RecipeCommandParametersTests.cs  |   6 +-
 .../Commands/TasteCommandParametersTests.cs   |   6 +-
 src/Pretzel.Tests/ConfigurationMock.cs        |   2 +
 .../Extensions/AzureHostSupportTest.cs        |   4 +-
 .../VirtualDirectorySupportArgumentsTests.cs  |   3 -
 .../VirtualDirectorySupportTests.cs           |   7 +-
 src/Pretzel/Commands/BakeCommand.cs           |   6 +-
 src/Pretzel/Commands/CommandCollection.cs     |  32 +++-
 src/Pretzel/Commands/ImportCommand.cs         |   6 +-
 src/Pretzel/Commands/IngredientCommand.cs     |   6 +-
 src/Pretzel/Commands/PretzelCommandHandler.cs |  17 +-
 src/Pretzel/Commands/RecipeCommand.cs         |   6 +-
 src/Pretzel/Commands/TasteCommand.cs          |   6 +-
 src/Pretzel/Program.cs                        |   8 +-
 37 files changed, 310 insertions(+), 323 deletions(-)
 rename src/Pretzel.Logic/Commands/{BakeBaseCommandParameters.cs => BakeBaseCommandArguments.cs} (75%)
 rename src/Pretzel.Logic/Commands/{BaseParameters.cs => BaseCommandArguments.cs} (60%)
 create mode 100644 src/Pretzel.Logic/Commands/ICommandArguments.cs
 delete mode 100644 src/Pretzel.Logic/Commands/ICommandParameters.cs
 delete mode 100644 src/Pretzel.Logic/Commands/ICommandParametersExtendable.cs
 delete mode 100644 src/Pretzel.Logic/Commands/ICommandParametersExtentions.cs
 rename src/Pretzel.Logic/Commands/{PretzelBaseCommandParameters.cs => PretzelBaseCommandArguments.cs} (93%)
 rename src/Pretzel.Logic/Extensibility/{CommandArgumentsExtentionAttribute.cs => CommandArgumentsExtensionAttribute.cs} (63%)
 rename src/Pretzel.Logic/Extensibility/{IHaveCommandLineArgs.cs => ICommandArgumentsExtension.cs} (75%)

diff --git a/src/Pretzel.Logic/Commands/BakeBaseCommandParameters.cs b/src/Pretzel.Logic/Commands/BakeBaseCommandArguments.cs
similarity index 75%
rename from src/Pretzel.Logic/Commands/BakeBaseCommandParameters.cs
rename to src/Pretzel.Logic/Commands/BakeBaseCommandArguments.cs
index 9037abc8f..a06419475 100644
--- a/src/Pretzel.Logic/Commands/BakeBaseCommandParameters.cs
+++ b/src/Pretzel.Logic/Commands/BakeBaseCommandArguments.cs
@@ -6,9 +6,9 @@
 
 namespace Pretzel.Logic.Commands
 {
-    public abstract class BakeBaseCommandParameters : PretzelBaseCommandParameters
+    public abstract class BakeBaseCommandArguments : PretzelBaseCommandArguments
     {
-        protected BakeBaseCommandParameters(IFileSystem fileSystem) : base(fileSystem) { }
+        protected BakeBaseCommandArguments(IFileSystem fileSystem) : base(fileSystem) { }
 
         protected override IEnumerable<Option> CreateOptions() => base.CreateOptions().Concat(new[]
         {
diff --git a/src/Pretzel.Logic/Commands/BaseParameters.cs b/src/Pretzel.Logic/Commands/BaseCommandArguments.cs
similarity index 60%
rename from src/Pretzel.Logic/Commands/BaseParameters.cs
rename to src/Pretzel.Logic/Commands/BaseCommandArguments.cs
index a9f3e7cba..7fd822f29 100644
--- a/src/Pretzel.Logic/Commands/BaseParameters.cs
+++ b/src/Pretzel.Logic/Commands/BaseCommandArguments.cs
@@ -7,13 +7,11 @@
 
 namespace Pretzel.Logic.Commands
 {
-    public abstract class BaseParameters : ICommandParameters, ICommandParametersExtendable
+    public abstract class BaseCommandArguments : ICommandArguments
     {
-        [ImportMany]
-        public ExportFactory<IHaveCommandLineArgs, CommandArgumentsExtentionAttribute>[] ArgumentExtenders { get; set; }
-
         [Export]
         public IList<Option> Options { get; set; }
+        public IList<ICommandArgumentsExtension> Extensions { get; } = new List<ICommandArgumentsExtension>();
 
         [OnImportsSatisfied]
         internal void OnImportsSatisfied()
@@ -21,11 +19,6 @@ internal void OnImportsSatisfied()
             var options = new List<Option>();
             Options = options;
             options.AddRange(CreateOptions());
-
-            foreach (var factory in this.GetCommandExtentions())
-            {
-                factory.CreateExport().Value.UpdateOptions(Options);
-            }
         }
 
         protected abstract IEnumerable<Option> CreateOptions();
diff --git a/src/Pretzel.Logic/Commands/CommandArgumentsAttribute.cs b/src/Pretzel.Logic/Commands/CommandArgumentsAttribute.cs
index c433e6a9f..7cb4750c6 100644
--- a/src/Pretzel.Logic/Commands/CommandArgumentsAttribute.cs
+++ b/src/Pretzel.Logic/Commands/CommandArgumentsAttribute.cs
@@ -9,7 +9,7 @@ public sealed class CommandArgumentsAttribute : ExportAttribute
     {
         public string CommandName { get; set; }
 
-        public CommandArgumentsAttribute() : base(typeof(ICommandParameters))
+        public CommandArgumentsAttribute() : base(typeof(ICommandArguments))
         {
         }
     }
diff --git a/src/Pretzel.Logic/Commands/ICommandArguments.cs b/src/Pretzel.Logic/Commands/ICommandArguments.cs
new file mode 100644
index 000000000..464ff0a36
--- /dev/null
+++ b/src/Pretzel.Logic/Commands/ICommandArguments.cs
@@ -0,0 +1,34 @@
+using Pretzel.Logic.Extensibility;
+using System.Collections.Generic;
+using System.CommandLine;
+
+namespace Pretzel.Logic.Commands
+{
+    /// <summary>
+    /// All commands can have 1 command argument
+    /// </summary>
+    public interface ICommandArguments
+    {
+        /// <summary>
+        /// A list of option that will be used as command line options
+        /// </summary>
+        /// <value>
+        /// The options.
+        /// </value>
+        IList<Option> Options { get; }
+
+        /// <summary>
+        /// A list of extentions the command argument is extended with.
+        /// </summary>
+        /// <value>
+        /// The extensions.
+        /// </value>
+        IList<ICommandArgumentsExtension> Extensions { get; }
+
+        /// <summary>
+        /// Once the command arguments are bound with values from the command line, this method gets called.
+        /// Useful for validation or argument customization before being used by a command
+        /// </summary>
+        void BindingCompleted();
+    }
+}
diff --git a/src/Pretzel.Logic/Commands/ICommandParameters.cs b/src/Pretzel.Logic/Commands/ICommandParameters.cs
deleted file mode 100644
index e58bf363d..000000000
--- a/src/Pretzel.Logic/Commands/ICommandParameters.cs
+++ /dev/null
@@ -1,13 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.CommandLine;
-
-namespace Pretzel.Logic.Commands
-{
-    public interface ICommandParameters
-    {
-        IList<Option> Options { get; }
-
-        void BindingCompleted();
-    }
-}
diff --git a/src/Pretzel.Logic/Commands/ICommandParametersExtendable.cs b/src/Pretzel.Logic/Commands/ICommandParametersExtendable.cs
deleted file mode 100644
index 38b56f50e..000000000
--- a/src/Pretzel.Logic/Commands/ICommandParametersExtendable.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-using System;
-using System.Composition;
-using System.Linq;
-using Pretzel.Logic.Extensibility;
-
-namespace Pretzel.Logic.Commands
-{
-    public interface ICommandParametersExtendable
-    {
-        ExportFactory<IHaveCommandLineArgs, CommandArgumentsExtentionAttribute>[] ArgumentExtenders
-        {
-            get;
-        }
-    }
-}
diff --git a/src/Pretzel.Logic/Commands/ICommandParametersExtentions.cs b/src/Pretzel.Logic/Commands/ICommandParametersExtentions.cs
deleted file mode 100644
index 7c3060619..000000000
--- a/src/Pretzel.Logic/Commands/ICommandParametersExtentions.cs
+++ /dev/null
@@ -1,27 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Composition;
-using System.Linq;
-using Pretzel.Logic.Extensibility;
-
-namespace Pretzel.Logic.Commands
-{
-    public static class ICommandParametersExtentions
-    {
-        public static IEnumerable<ExportFactory<IHaveCommandLineArgs, CommandArgumentsExtentionAttribute>> GetCommandExtentions(this ICommandParametersExtendable commandParametersExtendable)
-        {
-            var attr = commandParametersExtendable.GetType().GetCustomAttributes(typeof(CommandArgumentsAttribute), true).FirstOrDefault();
-
-            if (attr is CommandArgumentsAttribute commandArgumentAttribute && commandParametersExtendable.ArgumentExtenders != null)
-            {
-                foreach (var factory in commandParametersExtendable.ArgumentExtenders)
-                {
-                    if (factory.Metadata.CommandNames.Contains(commandArgumentAttribute.CommandName))
-                    {
-                        yield return factory;
-                    }
-                }
-            }
-        }
-    }
-}
diff --git a/src/Pretzel.Logic/Commands/PretzelBaseCommandParameters.cs b/src/Pretzel.Logic/Commands/PretzelBaseCommandArguments.cs
similarity index 93%
rename from src/Pretzel.Logic/Commands/PretzelBaseCommandParameters.cs
rename to src/Pretzel.Logic/Commands/PretzelBaseCommandArguments.cs
index a7341646a..c606276a0 100644
--- a/src/Pretzel.Logic/Commands/PretzelBaseCommandParameters.cs
+++ b/src/Pretzel.Logic/Commands/PretzelBaseCommandArguments.cs
@@ -9,11 +9,11 @@
 
 namespace Pretzel.Logic.Commands
 {
-    public abstract class PretzelBaseCommandParameters : BaseParameters, ISourcePathProvider
+    public abstract class PretzelBaseCommandArguments : BaseCommandArguments, ISourcePathProvider
     {
         protected readonly IFileSystem fileSystem;
 
-        protected PretzelBaseCommandParameters(IFileSystem fileSystem)
+        protected PretzelBaseCommandArguments(IFileSystem fileSystem)
         {
             this.fileSystem = fileSystem;
         }
diff --git a/src/Pretzel.Logic/Configuration.cs b/src/Pretzel.Logic/Configuration.cs
index 89b06cd09..a34f4701c 100644
--- a/src/Pretzel.Logic/Configuration.cs
+++ b/src/Pretzel.Logic/Configuration.cs
@@ -1,9 +1,8 @@
-using Pretzel.Logic.Commands;
-using Pretzel.Logic.Extensions;
 using System;
 using System.Collections.Generic;
 using System.Composition;
 using System.IO.Abstractions;
+using Pretzel.Logic.Extensions;
 
 namespace Pretzel.Logic
 {
@@ -39,7 +38,7 @@ internal sealed class Configuration : IConfiguration
         public object this[string key] => _config[key];
 
         public IDefaultsConfiguration Defaults { get; private set; }
-        
+
         internal Configuration()
         {
             _config = new Dictionary<string, object>();
diff --git a/src/Pretzel.Logic/Extensibility/CommandArgumentsExtentionAttribute.cs b/src/Pretzel.Logic/Extensibility/CommandArgumentsExtensionAttribute.cs
similarity index 63%
rename from src/Pretzel.Logic/Extensibility/CommandArgumentsExtentionAttribute.cs
rename to src/Pretzel.Logic/Extensibility/CommandArgumentsExtensionAttribute.cs
index 174877482..bf76e0a6b 100644
--- a/src/Pretzel.Logic/Extensibility/CommandArgumentsExtentionAttribute.cs
+++ b/src/Pretzel.Logic/Extensibility/CommandArgumentsExtensionAttribute.cs
@@ -5,11 +5,11 @@ namespace Pretzel.Logic.Extensibility
 {
     [MetadataAttribute]
     [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
-    public sealed class CommandArgumentsExtentionAttribute : ExportAttribute
+    public sealed class CommandArgumentsExtensionAttribute : ExportAttribute
     {
         public string[] CommandNames { get; set; }
 
-        public CommandArgumentsExtentionAttribute() : base(typeof(IHaveCommandLineArgs))
+        public CommandArgumentsExtensionAttribute() : base(typeof(ICommandArgumentsExtension))
         {
         }
     }
diff --git a/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs b/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs
index 7395d1e80..523a9ca12 100644
--- a/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs
+++ b/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs
@@ -1,19 +1,18 @@
-using Pretzel.Logic.Commands;
-using Pretzel.Logic.Extensions;
 using System.Collections.Generic;
 using System.CommandLine;
 using System.Composition;
 using System.IO;
 using System.IO.Abstractions;
 using System.Linq;
-using System.Reflection;
+using Pretzel.Logic.Commands;
+using Pretzel.Logic.Extensions;
 
 namespace Pretzel.Logic.Extensibility.Extensions
 {
     [Export]
     [Shared]
-    [CommandArgumentsExtention(CommandNames = new[] { BuiltInCommands.Create })]
-    public class AzureHostSupportArguments : IHaveCommandLineArgs
+    [CommandArgumentsExtension(CommandNames = new[] { BuiltInCommands.Create })]
+    public class AzureHostSupportArguments : ICommandArgumentsExtension
     {
         public void UpdateOptions(IList<Option> options)
         {
diff --git a/src/Pretzel.Logic/Extensibility/Extensions/VirtualDirectorySupport.cs b/src/Pretzel.Logic/Extensibility/Extensions/VirtualDirectorySupport.cs
index 320d4e159..8d5363fae 100644
--- a/src/Pretzel.Logic/Extensibility/Extensions/VirtualDirectorySupport.cs
+++ b/src/Pretzel.Logic/Extensibility/Extensions/VirtualDirectorySupport.cs
@@ -11,8 +11,8 @@ namespace Pretzel.Logic.Extensibility.Extensions
 {
     [Export]
     [Shared]
-    [CommandArgumentsExtention(CommandNames = new[] { BuiltInCommands.Bake, BuiltInCommands.Taste })]
-    public class VirtualDirectorySupportArguments : IHaveCommandLineArgs
+    [CommandArgumentsExtension(CommandNames = new[] { BuiltInCommands.Bake, BuiltInCommands.Taste })]
+    public class VirtualDirectorySupportArguments : ICommandArgumentsExtension
     {
         public void UpdateOptions(IList<Option> options)
         {
diff --git a/src/Pretzel.Logic/Extensibility/IHaveCommandLineArgs.cs b/src/Pretzel.Logic/Extensibility/ICommandArgumentsExtension.cs
similarity index 75%
rename from src/Pretzel.Logic/Extensibility/IHaveCommandLineArgs.cs
rename to src/Pretzel.Logic/Extensibility/ICommandArgumentsExtension.cs
index 28279e5ed..d46074964 100644
--- a/src/Pretzel.Logic/Extensibility/IHaveCommandLineArgs.cs
+++ b/src/Pretzel.Logic/Extensibility/ICommandArgumentsExtension.cs
@@ -1,11 +1,10 @@
 using System;
 using System.Collections.Generic;
 using System.CommandLine;
-using System.Composition;
 
 namespace Pretzel.Logic.Extensibility
 {
-    public interface IHaveCommandLineArgs
+    public interface ICommandArgumentsExtension
     {
         void UpdateOptions(IList<Option> options);
 
diff --git a/src/Pretzel.Tests/Commands/BakeBaseCommandParametersTests.cs b/src/Pretzel.Tests/Commands/BakeBaseCommandParametersTests.cs
index 2291b9274..a74709d37 100644
--- a/src/Pretzel.Tests/Commands/BakeBaseCommandParametersTests.cs
+++ b/src/Pretzel.Tests/Commands/BakeBaseCommandParametersTests.cs
@@ -6,7 +6,7 @@
 namespace Pretzel.Tests.Commands
 {
     public abstract class BakeBaseCommandParametersTests<T> : PretzelBaseCommandParametersTests<T>
-        where T : BakeBaseCommandParameters
+        where T : BakeBaseCommandArguments
     {
         [Theory]
         [InlineData("-c")]
diff --git a/src/Pretzel.Tests/Commands/BakeCommandParametersTests.cs b/src/Pretzel.Tests/Commands/BakeCommandParametersTests.cs
index 438595ea2..8e5c9ce68 100644
--- a/src/Pretzel.Tests/Commands/BakeCommandParametersTests.cs
+++ b/src/Pretzel.Tests/Commands/BakeCommandParametersTests.cs
@@ -1,23 +1,13 @@
-using NSubstitute;
-using Pretzel.Commands;
-using Pretzel.Logic.Commands;
 using System;
-using System.Collections.Generic;
-using System.CommandLine;
-using System.CommandLine.Binding;
-using System.CommandLine.Invocation;
 using System.IO.Abstractions;
-using System.IO.Abstractions.TestingHelpers;
 using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Xunit;
+using Pretzel.Commands;
 
 namespace Pretzel.Tests.Commands
 {
-    public class BakeCommandParametersTests : BakeBaseCommandParametersTests<BakeCommandParameters>
+    public class BakeCommandParametersTests : BakeBaseCommandParametersTests<BakeCommandArguments>
     {
-        protected override BakeCommandParameters CreateParameters(IFileSystem fileSystem)
-            => new BakeCommandParameters(fileSystem);
+        protected override BakeCommandArguments CreateParameters(IFileSystem fileSystem)
+            => new BakeCommandArguments(fileSystem);
     }
 }
diff --git a/src/Pretzel.Tests/Commands/BaseParametersTests.cs b/src/Pretzel.Tests/Commands/BaseParametersTests.cs
index 0c8a530dc..aa6085688 100644
--- a/src/Pretzel.Tests/Commands/BaseParametersTests.cs
+++ b/src/Pretzel.Tests/Commands/BaseParametersTests.cs
@@ -5,7 +5,6 @@
 using System.Composition.Hosting;
 using System.Linq;
 using Pretzel.Logic.Commands;
-using Pretzel.Logic.Extensibility;
 using Xunit;
 
 namespace Pretzel.Tests.Commands
@@ -15,41 +14,24 @@ public class BaseParametersTests
         [Export]
         [Shared]
         [CommandArguments(CommandName = "test")]
-        public class BaseParametersImpl : BaseParameters
+        public class BaseParametersImpl : BaseCommandArguments
         {
             protected override IEnumerable<Option> CreateOptions() => new[]
             {
                 new Option("-base")
             };
         }
-
-        [Export]
-        [Shared]
-        [CommandArgumentsExtention(CommandNames = new[] { "test" })]
-        public class BaseParametersImplExt : IHaveCommandLineArgs
-        {
-            public void UpdateOptions(IList<Option> options)
-            {
-                options.Add(new Option("-ext"));
-            }
-
-            public void BindingCompleted()
-            {
-            }
-        }
-
+        
         [Fact]
         public void ExtentionIsPossible()
         {
             var configuration = new ContainerConfiguration();
             configuration.WithPart<BaseParametersImpl>();
-            configuration.WithPart<BaseParametersImplExt>();
             using(var container = configuration.CreateContainer())
             {
                 var sut = container.GetExport<BaseParametersImpl>();
 
-                Assert.Contains(sut.Options, o => o.Name == "base");
-                Assert.Contains(sut.Options, o => o.Name == "ext");
+                Assert.NotNull(sut.Options);
             }
         }
     }
diff --git a/src/Pretzel.Tests/Commands/CommandCollectionTests.cs b/src/Pretzel.Tests/Commands/CommandCollectionTests.cs
index 6fad77c73..e12fcd203 100644
--- a/src/Pretzel.Tests/Commands/CommandCollectionTests.cs
+++ b/src/Pretzel.Tests/Commands/CommandCollectionTests.cs
@@ -2,11 +2,14 @@
 using Pretzel.Commands;
 using Pretzel.Logic;
 using Pretzel.Logic.Commands;
+using Pretzel.Logic.Extensibility;
 using System;
 using System.Collections.Generic;
 using System.CommandLine;
 using System.Composition;
+using System.Composition.Hosting;
 using System.Linq;
+using System.Threading.Tasks;
 using Xunit;
 
 namespace Pretzel.Tests.Commands
@@ -72,7 +75,7 @@ public void SubCommandsWithoutArgumentGetsHandler()
         [Fact]
         public void SubCommandsWithArgumentGetsHandler()
         {
-            var parameters = Substitute.For<ICommandParameters>();
+            var parameters = Substitute.For<ICommandArguments>();
             parameters.Options.Returns(new List<Option>
             {
                 new Option("-i")
@@ -86,7 +89,7 @@ public void SubCommandsWithArgumentGetsHandler()
                     CommandDescription = "desc"
                 });
 
-            var argumentExportFactory = new ExportFactory<Logic.Commands.ICommandParameters, Logic.Commands.CommandArgumentsAttribute>(
+            var argumentExportFactory = new ExportFactory<Logic.Commands.ICommandArguments, Logic.Commands.CommandArgumentsAttribute>(
                 () => CreateArgument(parameters),
                 new Logic.Commands.CommandArgumentsAttribute
                 {
@@ -100,11 +103,11 @@ public void SubCommandsWithArgumentGetsHandler()
                 {
                     commandExportFactory
                 },
-                CommandArguments = new ExportFactory<Logic.Commands.ICommandParameters, Logic.Commands.CommandArgumentsAttribute>[]
+                CommandArguments = new ExportFactory<Logic.Commands.ICommandArguments, Logic.Commands.CommandArgumentsAttribute>[]
                 {
                     argumentExportFactory,
-                    new ExportFactory<Logic.Commands.ICommandParameters, Logic.Commands.CommandArgumentsAttribute>(
-                    () => CreateArgument(Substitute.For<ICommandParameters>()),
+                    new ExportFactory<Logic.Commands.ICommandArguments, Logic.Commands.CommandArgumentsAttribute>(
+                    () => CreateArgument(Substitute.For<ICommandArguments>()),
                     new Logic.Commands.CommandArgumentsAttribute
                     {
                         CommandName = "othercommand"
@@ -129,7 +132,142 @@ public void SubCommandsWithArgumentGetsHandler()
 
         Tuple<Logic.Commands.IPretzelCommand, Action> CreateCommand()
             => Tuple.Create(Substitute.For<Logic.Commands.IPretzelCommand>(), new Action(() => { }));
-        Tuple<ICommandParameters, Action> CreateArgument(ICommandParameters parameters)
+        Tuple<ICommandArguments, Action> CreateArgument(ICommandArguments parameters)
             => Tuple.Create(parameters, new Action(() => { }));
+
+
+        public class ICommandParametersExtentionsTests : IDisposable
+        {
+            CompositionHost Container;
+            public ICommandParametersExtentionsTests()
+            {
+                var configuration = new ContainerConfiguration();
+                configuration.WithPart<CommandCollection>();
+                configuration.WithPart<TestCommand1>();
+                configuration.WithPart<TestCommand2>();
+                configuration.WithPart<TestCommandArguments1>();
+                configuration.WithPart<TestCommandArguments2>();
+                configuration.WithPart<Extender1>();
+                configuration.WithPart<Extender2>();
+                configuration.WithPart<Extender3>();
+                configuration.WithPart<ConfigurationMock>();
+                Container = configuration.CreateContainer();
+            }
+
+            [Fact]
+            public void CollectsOnlyCommandsWhereNamesMatch1()
+            {
+                Container.GetExport<CommandCollection>();
+                var target = Container.GetExport<TestCommandArguments1>();
+                
+                Assert.Equal(2, target.Extensions.Count);
+                Assert.Contains(target.Extensions, e => e is Extender1);
+                Assert.Contains(target.Extensions, e => e is Extender3);
+            }
+
+            [Fact]
+            public void CollectsOnlyCommandsWhereNamesMatch2()
+            {
+                Container.GetExport<CommandCollection>();
+                var target = Container.GetExport<TestCommandArguments2>();
+                
+                Assert.Equal(2, target.Extensions.Count);
+                Assert.Contains(target.Extensions, e => e is Extender2);
+                Assert.Contains(target.Extensions, e => e is Extender3);
+
+            }
+
+            public void Dispose()
+                => Container?.Dispose();
+
+            [Export]
+            [Shared]
+            [CommandArguments(CommandName = "test1")]
+            public class TestCommandArguments1 : ICommandArguments
+            {
+                [ImportMany]
+                public ExportFactory<ICommandArgumentsExtension, CommandArgumentsExtensionAttribute>[] ArgumentExtensions { get; set; }
+
+                public IList<Option> Options => new List<Option>();
+
+                public IList<ICommandArgumentsExtension> Extensions { get; } = new List<ICommandArgumentsExtension>();
+
+                public void BindingCompleted() { }
+            }
+
+            [Export]
+            [Shared]
+            [CommandInfo(CommandName = "test1")]
+            public class TestCommand1 : IPretzelCommand
+            {
+                public Task<int> Execute()
+                {
+                    return Task.FromResult(0);
+                }
+            }
+
+            [Export]
+            [Shared]
+            [CommandArguments(CommandName = "test2")]
+            public class TestCommandArguments2 : ICommandArguments
+            {
+                [ImportMany]
+                public ExportFactory<ICommandArgumentsExtension, CommandArgumentsExtensionAttribute>[] ArgumentExtensions { get; set; }
+
+                public IList<Option> Options => new List<Option>();
+
+                public IList<ICommandArgumentsExtension> Extensions { get; } = new List<ICommandArgumentsExtension>();
+
+                public void BindingCompleted() { }
+            }
+
+            [Export]
+            [Shared]
+            [CommandInfo(CommandName = "test2")]
+            public class TestCommand2 : IPretzelCommand
+            {
+                public Task<int> Execute()
+                {
+                    return Task.FromResult(0);
+                }
+            }
+
+            [CommandArgumentsExtension(CommandNames = new[] { "test1" })]
+            public class Extender1 : ICommandArgumentsExtension
+            {
+                public void UpdateOptions(IList<Option> options)
+                {
+                }
+
+                public void BindingCompleted()
+                {
+                }
+            }
+
+            [CommandArgumentsExtension(CommandNames = new[] { "test2" })]
+            public class Extender2 : ICommandArgumentsExtension
+            {
+                public void UpdateOptions(IList<Option> options)
+                {
+                }
+
+                public void BindingCompleted()
+                {
+                }
+            }
+
+            [CommandArgumentsExtension(CommandNames = new[] { "test1", "test2" })]
+            public class Extender3 : ICommandArgumentsExtension
+            {
+                public void UpdateOptions(IList<Option> options)
+                {
+                }
+
+                public void BindingCompleted()
+                {
+                }
+            }
+
+        }
     }
 }
diff --git a/src/Pretzel.Tests/Commands/ICommandParametersExtentionsTests.cs b/src/Pretzel.Tests/Commands/ICommandParametersExtentionsTests.cs
index f3c7e74aa..430d6de21 100644
--- a/src/Pretzel.Tests/Commands/ICommandParametersExtentionsTests.cs
+++ b/src/Pretzel.Tests/Commands/ICommandParametersExtentionsTests.cs
@@ -1,121 +1,7 @@
-using Pretzel.Logic.Commands;
-using Pretzel.Logic.Extensibility;
 using System;
-using System.Collections.Generic;
-using System.CommandLine;
-using System.Composition;
 using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Xunit;
-using System.Composition.Hosting;
 
 namespace Pretzel.Tests.Commands
 {
-    public class ICommandParametersExtentionsTests : IDisposable
-    {
-        CompositionHost Container;
-        public ICommandParametersExtentionsTests()
-        {
-            var configuration = new ContainerConfiguration();
-            configuration.WithPart<TestArguments1Class>();
-            configuration.WithPart<TestArguments2Class>();
-            configuration.WithPart<Extender1>();
-            configuration.WithPart<Extender2>();
-            configuration.WithPart<Extender3>();
-            Container = configuration.CreateContainer();
-        }
 
-        [Fact]
-        public void CollectsOnlyCommandsWhereNamesMatch1()
-        {
-            var target1 = Container.GetExport<TestArguments1Class>();
-
-            var extentions = target1.GetCommandExtentions().ToList();
-
-            Assert.Equal(2, extentions.Count);
-            Assert.Contains(extentions, e => e.CreateExport().Value is Extender1);
-            Assert.Contains(extentions, e => e.CreateExport().Value is Extender3);
-
-        }
-
-        [Fact]
-        public void CollectsOnlyCommandsWhereNamesMatch2()
-        {
-            var target1 = Container.GetExport<TestArguments2Class>();
-
-            var extentions = target1.GetCommandExtentions().ToList();
-
-            Assert.Equal(2, extentions.Count);
-            Assert.Contains(extentions, e => e.CreateExport().Value is Extender2);
-            Assert.Contains(extentions, e => e.CreateExport().Value is Extender3);
-
-        }
-
-        public void Dispose()
-            => Container?.Dispose();
-
-        [Export]
-        [Shared]
-        [CommandArguments(CommandName = "test1")]
-        public class TestArguments1Class : ICommandParameters, ICommandParametersExtendable
-        {
-            [ImportMany]
-            public ExportFactory<IHaveCommandLineArgs, CommandArgumentsExtentionAttribute>[] ArgumentExtenders { get; set; }
-
-            public IList<Option> Options => new List<Option>();
-
-            public void BindingCompleted() { }
-        }
-
-        [Export]
-        [Shared]
-        [CommandArguments(CommandName = "test2")]
-        public class TestArguments2Class : ICommandParameters, ICommandParametersExtendable
-        {
-            [ImportMany]
-            public ExportFactory<IHaveCommandLineArgs, CommandArgumentsExtentionAttribute>[] ArgumentExtenders { get; set; }
-
-            public IList<Option> Options => new List<Option>();
-
-            public void BindingCompleted() { }
-        }
-
-        [CommandArgumentsExtention(CommandNames = new[] { "test1" })]
-        public class Extender1 : IHaveCommandLineArgs
-        {
-            public void UpdateOptions(IList<Option> options)
-            {
-            }
-
-            public void BindingCompleted()
-            {
-            }
-        }
-
-        [CommandArgumentsExtention(CommandNames = new[] { "test2" })]
-        public class Extender2 : IHaveCommandLineArgs
-        {
-            public void UpdateOptions(IList<Option> options)
-            {
-            }
-
-            public void BindingCompleted()
-            {
-            }
-        }
-
-        [CommandArgumentsExtention(CommandNames = new[] { "test1", "test2" })]
-        public class Extender3 : IHaveCommandLineArgs
-        {
-            public void UpdateOptions(IList<Option> options)
-            {
-            }
-
-            public void BindingCompleted()
-            {
-            }
-        }
-
-    }
 }
diff --git a/src/Pretzel.Tests/Commands/ImportCommandParametersTests.cs b/src/Pretzel.Tests/Commands/ImportCommandParametersTests.cs
index 0a9dd5ced..afa4bec6e 100644
--- a/src/Pretzel.Tests/Commands/ImportCommandParametersTests.cs
+++ b/src/Pretzel.Tests/Commands/ImportCommandParametersTests.cs
@@ -6,10 +6,10 @@
 
 namespace Pretzel.Tests.Commands
 {
-    public class ImportCommandParametersTests : PretzelBaseCommandParametersTests<ImportCommandParameters>
+    public class ImportCommandParametersTests : PretzelBaseCommandParametersTests<ImportCommandArguments>
     {
-        protected override ImportCommandParameters CreateParameters(IFileSystem fileSystem)
-            => new ImportCommandParameters(fileSystem);
+        protected override ImportCommandArguments CreateParameters(IFileSystem fileSystem)
+            => new ImportCommandArguments(fileSystem);
 
         [Theory]
         [InlineData("--importtype", "foo")]
diff --git a/src/Pretzel.Tests/Commands/IngredientCommandParametersTests.cs b/src/Pretzel.Tests/Commands/IngredientCommandParametersTests.cs
index 339c21da5..e5c99a604 100644
--- a/src/Pretzel.Tests/Commands/IngredientCommandParametersTests.cs
+++ b/src/Pretzel.Tests/Commands/IngredientCommandParametersTests.cs
@@ -6,10 +6,10 @@
 
 namespace Pretzel.Tests.Commands
 {
-    public class IngredientCommandParametersTests : PretzelBaseCommandParametersTests<IngredientCommandParameters>
+    public class IngredientCommandParametersTests : PretzelBaseCommandParametersTests<IngredientCommandArguments>
     {
-        protected override IngredientCommandParameters CreateParameters(IFileSystem fileSystem)
-            => new IngredientCommandParameters(fileSystem);
+        protected override IngredientCommandArguments CreateParameters(IFileSystem fileSystem)
+            => new IngredientCommandArguments(fileSystem);
 
         [Theory]
         [InlineData("--newposttitle", "My AwesomeBlog")]
diff --git a/src/Pretzel.Tests/Commands/ParametersTests.cs b/src/Pretzel.Tests/Commands/ParametersTests.cs
index 4b9e9e0e6..3b9efbc15 100644
--- a/src/Pretzel.Tests/Commands/ParametersTests.cs
+++ b/src/Pretzel.Tests/Commands/ParametersTests.cs
@@ -6,12 +6,11 @@
 using System.IO.Abstractions.TestingHelpers;
 using System.Linq;
 using NSubstitute;
-using Pretzel.Commands;
 using Pretzel.Logic.Commands;
 
 namespace Pretzel.Tests.Commands
 {
-    public abstract class ParametersTests<T> where T : BaseParameters
+    public abstract class ParametersTests<T> where T : BaseCommandArguments
     {
         readonly IConsole Console = Substitute.For<IConsole>();
         protected readonly MockFileSystem fileSystem = new MockFileSystem();
diff --git a/src/Pretzel.Tests/Commands/PetzelBaseCommandParametersTests.cs b/src/Pretzel.Tests/Commands/PetzelBaseCommandParametersTests.cs
index 671820876..8bcb41e84 100644
--- a/src/Pretzel.Tests/Commands/PetzelBaseCommandParametersTests.cs
+++ b/src/Pretzel.Tests/Commands/PetzelBaseCommandParametersTests.cs
@@ -11,7 +11,7 @@
 namespace Pretzel.Tests.Commands
 {
     public abstract class PretzelBaseCommandParametersTests<T> : ParametersTests<T>
-        where T : PretzelBaseCommandParameters
+        where T : PretzelBaseCommandArguments
     {
         [Theory]
         [InlineData("--drafts")]
diff --git a/src/Pretzel.Tests/Commands/PretzelCommandHandlerTests.cs b/src/Pretzel.Tests/Commands/PretzelCommandHandlerTests.cs
index 702f732e0..38f1b400e 100644
--- a/src/Pretzel.Tests/Commands/PretzelCommandHandlerTests.cs
+++ b/src/Pretzel.Tests/Commands/PretzelCommandHandlerTests.cs
@@ -1,31 +1,32 @@
-using NSubstitute;
-using Pretzel.Commands;
-using Pretzel.Logic;
-using Pretzel.Logic.Commands;
-using Pretzel.Logic.Extensibility;
 using System;
 using System.Collections.Generic;
 using System.CommandLine;
 using System.CommandLine.Invocation;
 using System.Composition;
 using System.Linq;
-using System.Text;
 using System.Threading.Tasks;
+using NSubstitute;
+using Pretzel.Commands;
+using Pretzel.Logic;
+using Pretzel.Logic.Commands;
+using Pretzel.Logic.Extensibility;
 using Xunit;
 
 namespace Pretzel.Tests.Commands
 {
     public class PretzelCommandHandlerTests
     {
-        public class TestParams : ICommandParameters
+        public class TestArguments : ICommandArguments
         {
-            public IList<Option> Options => throw new NotImplementedException();
+            public IList<Option> Options => new List<Option>();
 
             public void BindingCompleted()
             {
             }
 
             public bool SomeOption { get; set; }
+
+            public IList<ICommandArgumentsExtension> Extensions => new List<ICommandArgumentsExtension>();
         }
 
         [Fact]
@@ -38,7 +39,8 @@ public async Task CommandParametersGetsBinded()
             });
 
             var context = new InvocationContext(new Parser(rootCommand).Parse("--someoption"), Substitute.For<IConsole>());
-            var testParams = new TestParams();
+            var testParams = new TestArguments();
+
             var sut = new PretzelCommandHandler(
                 Substitute.For<IConfiguration>(),
                 testParams,
@@ -59,11 +61,11 @@ public async Task CommandParameters_BindingCompleted_IsCalled()
             var rootCommand = new RootCommand();
 
             var context = new InvocationContext(new Parser(rootCommand).Parse(string.Empty), Substitute.For<IConsole>());
-            var testParams = Substitute.For<ICommandParameters>();
+            var testArgument = Substitute.For<ICommandArguments>();
 
             var sut = new PretzelCommandHandler(
               Substitute.For<IConfiguration>(),
-              testParams,
+              testArgument,
               new ExportFactory<IPretzelCommand, CommandInfoAttribute>(
                   () => Tuple.Create(
                           Substitute.For<IPretzelCommand>(),
@@ -72,7 +74,7 @@ public async Task CommandParameters_BindingCompleted_IsCalled()
 
             await sut.InvokeAsync(context);
 
-            testParams.Received().BindingCompleted();
+            testArgument.Received().BindingCompleted();
         }
 
         [Fact]
@@ -81,14 +83,14 @@ public async Task Configuration_ReadFromFile_IsCalled_WithPathProvider()
             var configuration = Substitute.For<IConfiguration>();
 
             var rootCommand = new RootCommand();
-            var testParams = Substitute.For<ICommandParameters, ISourcePathProvider>();
-            ((ISourcePathProvider)testParams).Source.Returns("foo");
+            var testArgument = Substitute.For<ICommandArguments, ISourcePathProvider>();
+            ((ISourcePathProvider)testArgument).Source.Returns("foo");
 
             var context = new InvocationContext(new Parser(rootCommand).Parse(string.Empty), Substitute.For<IConsole>());
 
             var sut = new PretzelCommandHandler(
                 configuration,
-                testParams,
+                testArgument,
                 new ExportFactory<IPretzelCommand, CommandInfoAttribute>(
                     () => Tuple.Create(
                             Substitute.For<IPretzelCommand>(),
@@ -100,16 +102,16 @@ public async Task Configuration_ReadFromFile_IsCalled_WithPathProvider()
             configuration.Received().ReadFromFile("foo");
         }
 
-        [CommandArguments(CommandName = nameof(TestParams2))]
-        public class TestParams2 : ICommandParameters, ICommandParametersExtendable
+        [CommandArguments(CommandName = nameof(TestArguments2))]
+        public class TestArguments2 : ICommandArguments
         {
-            public IList<Option> Options => throw new NotImplementedException();
+            public IList<Option> Options { get; } = new List<Option>();
 
             public void BindingCompleted()
             {
             }
 
-            public class ExtendedArguments : IHaveCommandLineArgs
+            public class ExtendedArguments : ICommandArgumentsExtension
             {
                 public bool BindingCompletedCalled { get; private set; }
                 public void BindingCompleted()
@@ -127,10 +129,12 @@ public void UpdateOptions(IList<Option> options)
 
             public readonly ExtendedArguments Args = new ExtendedArguments();
 
-            public ExportFactory<IHaveCommandLineArgs, CommandArgumentsExtentionAttribute>[] ArgumentExtenders => new[]
+            public ExportFactory<ICommandArgumentsExtension, CommandArgumentsExtensionAttribute>[] ArgumentExtensions => new[]
             {
-                new ExportFactory<IHaveCommandLineArgs, CommandArgumentsExtentionAttribute>(() => Tuple.Create<IHaveCommandLineArgs, Action>(Args, new Action(() => { })), new CommandArgumentsExtentionAttribute{ CommandNames = new []{ nameof(TestParams2)} })
+                new ExportFactory<ICommandArgumentsExtension, CommandArgumentsExtensionAttribute>(() => Tuple.Create<ICommandArgumentsExtension, Action>(Args, new Action(() => { })), new CommandArgumentsExtensionAttribute{ CommandNames = new []{ nameof(TestArguments2)} })
             };
+
+            public IList<ICommandArgumentsExtension> Extensions { get; } = new List<ICommandArgumentsExtension>();
         }
 
 
@@ -144,7 +148,10 @@ public async Task CommandParametersExtentionsGetsBinded()
             });
 
             var context = new InvocationContext(new Parser(rootCommand).Parse("--otheroption"), Substitute.For<IConsole>());
-            var testParams = new TestParams2();
+            var testParams = new TestArguments2();
+
+            testParams.Extensions.Add(testParams.Args);
+
             var sut = new PretzelCommandHandler(
                 Substitute.For<IConfiguration>(),
                 testParams,
@@ -169,7 +176,8 @@ public async Task CommandParametersExtention_BindingCompleted_IsCalled()
             });
 
             var context = new InvocationContext(new Parser(rootCommand).Parse("--otheroption"), Substitute.For<IConsole>());
-            var testParams = new TestParams2();
+            var testParams = new TestArguments2();
+            testParams.Extensions.Add(testParams.Args);
             var sut = new PretzelCommandHandler(
                 Substitute.For<IConfiguration>(),
                 testParams,
@@ -194,7 +202,7 @@ public async Task CommandGetsExecuted()
 
             var sut = new PretzelCommandHandler(
                 Substitute.For<IConfiguration>(),
-                Substitute.For<ICommandParameters>(),
+                Substitute.For<ICommandArguments>(),
                 new ExportFactory<IPretzelCommand, CommandInfoAttribute>(
                     () => Tuple.Create(
                             command,
@@ -213,7 +221,7 @@ public async Task ExecutionOrder()
 
             var context = new InvocationContext(new Parser(rootCommand).Parse(""), Substitute.For<IConsole>());
             var configuration = Substitute.For<IConfiguration>();
-            var @params = Substitute.For<ICommandParameters, ISourcePathProvider>();
+            var @params = Substitute.For<ICommandArguments, ISourcePathProvider>();
             ((ISourcePathProvider)@params).Source.Returns("bar");
             var command = Substitute.For<IPretzelCommand>();
 
diff --git a/src/Pretzel.Tests/Commands/RecipeCommandParametersTests.cs b/src/Pretzel.Tests/Commands/RecipeCommandParametersTests.cs
index d774d99bd..49190011f 100644
--- a/src/Pretzel.Tests/Commands/RecipeCommandParametersTests.cs
+++ b/src/Pretzel.Tests/Commands/RecipeCommandParametersTests.cs
@@ -6,10 +6,10 @@
 
 namespace Pretzel.Tests.Commands
 {
-    public class RecipeCommandParametersTests : PretzelBaseCommandParametersTests<RecipeCommandParameters>
+    public class RecipeCommandParametersTests : PretzelBaseCommandParametersTests<RecipeCommandArguments>
     {
-        protected override RecipeCommandParameters CreateParameters(IFileSystem fileSystem)
-            => new RecipeCommandParameters(fileSystem);
+        protected override RecipeCommandArguments CreateParameters(IFileSystem fileSystem)
+            => new RecipeCommandArguments(fileSystem);
 
         [Theory]
         [InlineData("--wiki", true)]
diff --git a/src/Pretzel.Tests/Commands/TasteCommandParametersTests.cs b/src/Pretzel.Tests/Commands/TasteCommandParametersTests.cs
index b122c5168..f8982a71a 100644
--- a/src/Pretzel.Tests/Commands/TasteCommandParametersTests.cs
+++ b/src/Pretzel.Tests/Commands/TasteCommandParametersTests.cs
@@ -6,10 +6,10 @@
 
 namespace Pretzel.Tests.Commands
 {
-    public class TasteCommandParametersTests : BakeBaseCommandParametersTests<TasteCommandParameters>
+    public class TasteCommandParametersTests : BakeBaseCommandParametersTests<TasteCommandArguments>
     {
-        protected override TasteCommandParameters CreateParameters(IFileSystem fileSystem)
-            => new TasteCommandParameters(fileSystem);
+        protected override TasteCommandArguments CreateParameters(IFileSystem fileSystem)
+            => new TasteCommandArguments(fileSystem);
 
         [Theory]
         [InlineData("--nobrowser", true)]
diff --git a/src/Pretzel.Tests/ConfigurationMock.cs b/src/Pretzel.Tests/ConfigurationMock.cs
index 08bdc90e4..0d85bca2c 100644
--- a/src/Pretzel.Tests/ConfigurationMock.cs
+++ b/src/Pretzel.Tests/ConfigurationMock.cs
@@ -1,9 +1,11 @@
 using Pretzel.Logic;
 using Pretzel.Logic.Extensions;
 using System.Collections.Generic;
+using System.Composition;
 
 namespace Pretzel.Tests
 {
+    [Export(typeof(IConfiguration))]
     public sealed class ConfigurationMock : IConfiguration
     {
         private IDictionary<string, object> _config;
diff --git a/src/Pretzel.Tests/Extensibility/Extensions/AzureHostSupportTest.cs b/src/Pretzel.Tests/Extensibility/Extensions/AzureHostSupportTest.cs
index 94a6a14a4..9528b8aa7 100644
--- a/src/Pretzel.Tests/Extensibility/Extensions/AzureHostSupportTest.cs
+++ b/src/Pretzel.Tests/Extensibility/Extensions/AzureHostSupportTest.cs
@@ -1,9 +1,7 @@
-using Pretzel.Logic.Extensibility.Extensions;
-using System.Collections.Generic;
 using System.IO.Abstractions.TestingHelpers;
 using System.Linq;
+using Pretzel.Logic.Extensibility.Extensions;
 using Xunit;
-using Xunit.Extensions;
 
 namespace Pretzel.Tests.Extensibility.Extensions
 {
diff --git a/src/Pretzel.Tests/Extensibility/Extensions/VirtualDirectorySupportArgumentsTests.cs b/src/Pretzel.Tests/Extensibility/Extensions/VirtualDirectorySupportArgumentsTests.cs
index 10257e1a7..15d8e11f4 100644
--- a/src/Pretzel.Tests/Extensibility/Extensions/VirtualDirectorySupportArgumentsTests.cs
+++ b/src/Pretzel.Tests/Extensibility/Extensions/VirtualDirectorySupportArgumentsTests.cs
@@ -1,8 +1,5 @@
 using System;
-using System.Collections.Generic;
 using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace Pretzel.Tests.Extensibility.Extensions
 {
diff --git a/src/Pretzel.Tests/Extensibility/Extensions/VirtualDirectorySupportTests.cs b/src/Pretzel.Tests/Extensibility/Extensions/VirtualDirectorySupportTests.cs
index 235a558c4..0fad9cdcc 100644
--- a/src/Pretzel.Tests/Extensibility/Extensions/VirtualDirectorySupportTests.cs
+++ b/src/Pretzel.Tests/Extensibility/Extensions/VirtualDirectorySupportTests.cs
@@ -1,10 +1,9 @@
+using System.Collections.Generic;
+using System.IO.Abstractions;
 using NSubstitute;
 using Pretzel.Logic.Extensibility.Extensions;
 using Pretzel.Logic.Templating.Context;
-using System.Collections.Generic;
-using System.IO.Abstractions;
 using Xunit;
-using Xunit.Extensions;
 
 namespace Pretzel.Tests.Extensibility.Extensions
 {
@@ -73,7 +72,7 @@ public void processes_only_when_vdir_argument_is_passed()
         }
 
         [Fact]
-        public void processes_only_css_and_html_files() 
+        public void processes_only_css_and_html_files()
         {
             // arrange
             var returnThis = Substitute.For<FileBase>();
diff --git a/src/Pretzel/Commands/BakeCommand.cs b/src/Pretzel/Commands/BakeCommand.cs
index 9f53290bb..184564a80 100644
--- a/src/Pretzel/Commands/BakeCommand.cs
+++ b/src/Pretzel/Commands/BakeCommand.cs
@@ -15,10 +15,10 @@ namespace Pretzel.Commands
     [Shared]
     [Export]
     [CommandArguments(CommandName = BuiltInCommands.Bake)]
-    public sealed class BakeCommandParameters : BakeBaseCommandParameters
+    public sealed class BakeCommandArguments : BakeBaseCommandArguments
     {
         [ImportingConstructor]
-        public BakeCommandParameters(IFileSystem fileSystem) : base(fileSystem) { }
+        public BakeCommandArguments(IFileSystem fileSystem) : base(fileSystem) { }
     }
 
     [Shared]
@@ -35,7 +35,7 @@ public sealed class BakeCommand : IPretzelCommand
         public IEnumerable<ITransform> Transforms { get; set; }
 
         [Import]
-        public BakeCommandParameters Parameters { get; set; }
+        public BakeCommandArguments Parameters { get; set; }
 
         [Import]
         public IFileSystem FileSystem { get; set; }
diff --git a/src/Pretzel/Commands/CommandCollection.cs b/src/Pretzel/Commands/CommandCollection.cs
index 70a07cfed..be3b3c0d9 100644
--- a/src/Pretzel/Commands/CommandCollection.cs
+++ b/src/Pretzel/Commands/CommandCollection.cs
@@ -4,6 +4,7 @@
 using System.Linq;
 using Pretzel.Logic;
 using Pretzel.Logic.Commands;
+using Pretzel.Logic.Extensibility;
 
 namespace Pretzel.Commands
 {
@@ -19,14 +20,28 @@ public ExportFactory<IPretzelCommand, CommandInfoAttribute>[] Commands
             set => commands = value;
         }
 
-        ExportFactory<ICommandParameters, CommandArgumentsAttribute>[] commandArguments;
+        ExportFactory<ICommandArguments, CommandArgumentsAttribute>[] commandArguments;
         [ImportMany]
-        public ExportFactory<ICommandParameters, CommandArgumentsAttribute>[] CommandArguments
+        public ExportFactory<ICommandArguments, CommandArgumentsAttribute>[] CommandArguments
         {
-            get => commandArguments ?? new ExportFactory<ICommandParameters, CommandArgumentsAttribute>[] { };
+            get => commandArguments ?? new ExportFactory<ICommandArguments, CommandArgumentsAttribute>[] { };
             set => commandArguments = value;
         }
 
+        ExportFactory<ICommandArgumentsExtension, CommandArgumentsExtensionAttribute>[] argumentExtensions;
+        [ImportMany]
+        public ExportFactory<ICommandArgumentsExtension, CommandArgumentsExtensionAttribute>[] ArgumentExtensions
+        {
+            get
+            {
+                return argumentExtensions ?? new ExportFactory<ICommandArgumentsExtension, CommandArgumentsExtensionAttribute>[] { };
+            }
+            set
+            {
+                argumentExtensions = value;
+            }
+        }
+
         [Export]
         public RootCommand RootCommand { get; set; }
 
@@ -46,6 +61,17 @@ internal void OnImportsSatisfied()
                 {
                     var args = commandArgumentsExport.CreateExport().Value;
 
+                    foreach (var argumentExtensionsExport in ArgumentExtensions.Where(a => a.Metadata.CommandNames.Contains(commandArgumentsExport.Metadata.CommandName)))
+                    {
+                        var arugumentExtension = argumentExtensionsExport.CreateExport().Value;
+                        args.Extensions.Add(arugumentExtension);
+                    }
+
+                    foreach(var arugumentExtension in args.Extensions)
+                    {
+                        arugumentExtension.UpdateOptions(args.Options);
+                    }
+
                     foreach (var option in args.Options)
                     {
                         subCommand.AddOption(option);
diff --git a/src/Pretzel/Commands/ImportCommand.cs b/src/Pretzel/Commands/ImportCommand.cs
index 18c7bda0e..661c8beaf 100644
--- a/src/Pretzel/Commands/ImportCommand.cs
+++ b/src/Pretzel/Commands/ImportCommand.cs
@@ -14,10 +14,10 @@ namespace Pretzel.Commands
     [Export]
     [Shared]
     [CommandArguments(CommandName = BuiltInCommands.Import)]
-    public class ImportCommandParameters : PretzelBaseCommandParameters
+    public class ImportCommandArguments : PretzelBaseCommandArguments
     {
         [ImportingConstructor]
-        public ImportCommandParameters(IFileSystem fileSystem) : base(fileSystem) { }
+        public ImportCommandArguments(IFileSystem fileSystem) : base(fileSystem) { }
 
         protected override IEnumerable<Option> CreateOptions() => base.CreateOptions().Concat(new[]
         {
@@ -45,7 +45,7 @@ class ImportCommand : IPretzelCommand
         [Import]
         public IFileSystem FileSystem { get; set; }
         [Import]
-        public ImportCommandParameters Parameters { get; set; }
+        public ImportCommandArguments Parameters { get; set; }
 
         public Task<int> Execute()
         {
diff --git a/src/Pretzel/Commands/IngredientCommand.cs b/src/Pretzel/Commands/IngredientCommand.cs
index eb1a0de55..91dadb6d6 100644
--- a/src/Pretzel/Commands/IngredientCommand.cs
+++ b/src/Pretzel/Commands/IngredientCommand.cs
@@ -14,10 +14,10 @@ namespace Pretzel.Commands
     [Export]
     [Shared]
     [CommandArguments(CommandName = BuiltInCommands.Ingredient)]
-    public class IngredientCommandParameters : PretzelBaseCommandParameters
+    public class IngredientCommandArguments : PretzelBaseCommandArguments
     {
         [ImportingConstructor]
-        public IngredientCommandParameters(IFileSystem fileSystem) : base(fileSystem) { }
+        public IngredientCommandArguments(IFileSystem fileSystem) : base(fileSystem) { }
 
         protected override IEnumerable<Option> CreateOptions() => base.CreateOptions().Concat(new[]
         {
@@ -38,7 +38,7 @@ public sealed class IngredientCommand : IPretzelCommand
         public IFileSystem FileSystem { get; set; }
 
         [Import]
-        public IngredientCommandParameters Parameters { get; set; }
+        public IngredientCommandArguments Parameters { get; set; }
 
         public Task<int> Execute()
         {
diff --git a/src/Pretzel/Commands/PretzelCommandHandler.cs b/src/Pretzel/Commands/PretzelCommandHandler.cs
index c6898a005..a8f711d48 100644
--- a/src/Pretzel/Commands/PretzelCommandHandler.cs
+++ b/src/Pretzel/Commands/PretzelCommandHandler.cs
@@ -11,11 +11,11 @@ namespace Pretzel.Commands
 {
     public class PretzelCommandHandler : ICommandHandler
     {
-        public ICommandParameters CommandParameters { get; }
+        public ICommandArguments CommandParameters { get; }
         public ExportFactory<IPretzelCommand, CommandInfoAttribute> Command { get; }
         public IConfiguration Configuration { get; }
 
-        public PretzelCommandHandler(IConfiguration configuration, ICommandParameters commandParameters, ExportFactory<IPretzelCommand, CommandInfoAttribute> command)
+        public PretzelCommandHandler(IConfiguration configuration, ICommandArguments commandParameters, ExportFactory<IPretzelCommand, CommandInfoAttribute> command)
         {
             Configuration = configuration;
             CommandParameters = commandParameters;
@@ -39,17 +39,12 @@ public async Task<int> InvokeAsync(InvocationContext context)
                 Configuration.ReadFromFile(pathProvider.Source);
             }
 
-            if (CommandParameters is ICommandParametersExtendable commandParametersExtendable)
+            foreach (var argumentsExtension in CommandParameters.Extensions)
             {
-                foreach (var factory in commandParametersExtendable.GetCommandExtentions())
-                {
-                    var extentedArguments = factory.CreateExport().Value;
+                new ModelBinder(argumentsExtension.GetType())
+                    .UpdateInstance(argumentsExtension, bindingContext);
 
-                    new ModelBinder(extentedArguments.GetType())
-                        .UpdateInstance(extentedArguments, bindingContext);
-
-                    extentedArguments.BindingCompleted();
-                }
+                argumentsExtension.BindingCompleted();
             }
 
             return await Command.CreateExport().Value.Execute();
diff --git a/src/Pretzel/Commands/RecipeCommand.cs b/src/Pretzel/Commands/RecipeCommand.cs
index 175022791..bda7c2b03 100644
--- a/src/Pretzel/Commands/RecipeCommand.cs
+++ b/src/Pretzel/Commands/RecipeCommand.cs
@@ -15,10 +15,10 @@ namespace Pretzel.Commands
     [Export]
     [Shared]
     [CommandArguments(CommandName = BuiltInCommands.Create)]
-    public class RecipeCommandParameters : PretzelBaseCommandParameters
+    public class RecipeCommandArguments : PretzelBaseCommandArguments
     {
         [ImportingConstructor]
-        public RecipeCommandParameters(IFileSystem fileSystem) : base(fileSystem) { }
+        public RecipeCommandArguments(IFileSystem fileSystem) : base(fileSystem) { }
 
         protected override IEnumerable<Option> CreateOptions() => base.CreateOptions().Concat(new[]
         {
@@ -46,7 +46,7 @@ public sealed class RecipeCommand : IPretzelCommand
         public IFileSystem FileSystem { get; set; }
 
         [Import]
-        public RecipeCommandParameters Parameters { get; set; }
+        public RecipeCommandArguments Parameters { get; set; }
 
         [ImportMany]
         public IEnumerable<IAdditionalIngredient> AdditionalIngredients { get; set; }
diff --git a/src/Pretzel/Commands/TasteCommand.cs b/src/Pretzel/Commands/TasteCommand.cs
index 86c45fe00..4a77ee5fb 100644
--- a/src/Pretzel/Commands/TasteCommand.cs
+++ b/src/Pretzel/Commands/TasteCommand.cs
@@ -18,10 +18,10 @@ namespace Pretzel.Commands
     [Export]
     [Shared]
     [CommandArguments(CommandName = BuiltInCommands.Taste)]
-    public class TasteCommandParameters : BakeBaseCommandParameters
+    public class TasteCommandArguments : BakeBaseCommandArguments
     {
         [ImportingConstructor]
-        public TasteCommandParameters(IFileSystem fileSystem) : base(fileSystem) { }
+        public TasteCommandArguments(IFileSystem fileSystem) : base(fileSystem) { }
 
         protected override IEnumerable<Option> CreateOptions() => base.CreateOptions().Concat(new[]
         {
@@ -53,7 +53,7 @@ public sealed class TasteCommand : IPretzelCommand
         public SiteContextGenerator Generator { get; set; }
 
         [Import]
-        public TasteCommandParameters Parameters { get; set; }
+        public TasteCommandArguments Parameters { get; set; }
 
         [ImportMany]
         public IEnumerable<ITransform> Transforms { get; set; }
diff --git a/src/Pretzel/Program.cs b/src/Pretzel/Program.cs
index 78f1cca5a..cca05bd75 100644
--- a/src/Pretzel/Program.cs
+++ b/src/Pretzel/Program.cs
@@ -1,10 +1,6 @@
-using Pretzel.Commands;
-using Pretzel.Logic.Commands;
-using Pretzel.Logic.Extensions;
 using System;
 using System.Collections.Generic;
 using System.CommandLine;
-using System.CommandLine.Builder;
 using System.CommandLine.Invocation;
 using System.Composition;
 using System.Composition.Hosting;
@@ -13,6 +9,8 @@
 using System.Linq;
 using System.Reflection;
 using System.Threading.Tasks;
+using Pretzel.Commands;
+using Pretzel.Logic.Extensions;
 
 namespace Pretzel
 {
@@ -41,7 +39,7 @@ internal class Program
 
         [Import]
         public CommandCollection CommandCollection { get; set; }
-        
+
         [Export]
         public IFileSystem FileSystem { get; set; } = fileSystem;
 

From dd1f584a230d93d041f6034ba65d37ebea7d4e78 Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Mon, 30 Sep 2019 13:23:56 +0200
Subject: [PATCH 39/56] feat: command arguments are now passed to commands

---
 .../Commands/CommandInfoAttribute.cs          |  2 +-
 src/Pretzel.Logic/Commands/ICommand.cs        | 13 +++++-
 .../Commands/CommandCollectionTests.cs        | 30 ++++++-------
 .../Commands/PretzelCommandHandlerTests.cs    | 43 +++++++++---------
 src/Pretzel/Commands/BakeCommand.cs           | 21 ++++-----
 src/Pretzel/Commands/CommandCollection.cs     |  6 +--
 src/Pretzel/Commands/HungryCommand.cs         | 11 ++++-
 src/Pretzel/Commands/ImportCommand.cs         | 18 ++++----
 src/Pretzel/Commands/IngredientCommand.cs     | 11 ++---
 src/Pretzel/Commands/PretzelCommandHandler.cs | 22 ++++-----
 src/Pretzel/Commands/RecipeCommand.cs         | 13 +++---
 src/Pretzel/Commands/TasteCommand.cs          | 45 +++++++++----------
 src/Pretzel/Commands/VersionCommand.cs        | 12 ++++-
 13 files changed, 129 insertions(+), 118 deletions(-)

diff --git a/src/Pretzel.Logic/Commands/CommandInfoAttribute.cs b/src/Pretzel.Logic/Commands/CommandInfoAttribute.cs
index a44af80d4..e9647e7be 100644
--- a/src/Pretzel.Logic/Commands/CommandInfoAttribute.cs
+++ b/src/Pretzel.Logic/Commands/CommandInfoAttribute.cs
@@ -11,7 +11,7 @@ public sealed class CommandInfoAttribute : ExportAttribute
 
         public string CommandDescription { get; set; }
 
-        public CommandInfoAttribute() : base(typeof(IPretzelCommand))
+        public CommandInfoAttribute() : base(typeof(ICommand))
         {
         }
     }
diff --git a/src/Pretzel.Logic/Commands/ICommand.cs b/src/Pretzel.Logic/Commands/ICommand.cs
index 7f0e6493d..d553db70b 100644
--- a/src/Pretzel.Logic/Commands/ICommand.cs
+++ b/src/Pretzel.Logic/Commands/ICommand.cs
@@ -2,8 +2,17 @@
 
 namespace Pretzel.Logic.Commands
 {
-    public interface IPretzelCommand
+    public interface ICommand
     {
-        Task<int> Execute();
+        Task<int> Execute(ICommandArguments arguments);
     }
+
+    public abstract class Command<T> : ICommand where T : ICommandArguments
+    {
+        public Task<int> Execute(ICommandArguments arguments)
+            => Execute((T)arguments);
+
+        protected abstract Task<int> Execute(T arguments);
+    }
+
 }
diff --git a/src/Pretzel.Tests/Commands/CommandCollectionTests.cs b/src/Pretzel.Tests/Commands/CommandCollectionTests.cs
index e12fcd203..61c888d06 100644
--- a/src/Pretzel.Tests/Commands/CommandCollectionTests.cs
+++ b/src/Pretzel.Tests/Commands/CommandCollectionTests.cs
@@ -29,9 +29,9 @@ public void SubCommandAreAddedToRootCommand()
         {
             var collection = new CommandCollection
             {
-                Commands = new ExportFactory<Logic.Commands.IPretzelCommand, CommandInfoAttribute>[]
+                Commands = new ExportFactory<Logic.Commands.ICommand, CommandInfoAttribute>[]
                 {
-                    new ExportFactory<Logic.Commands.IPretzelCommand, CommandInfoAttribute>(CreateCommand, new CommandInfoAttribute{ CommandName = "test", CommandDescription = "desc" })
+                    new ExportFactory<Logic.Commands.ICommand, CommandInfoAttribute>(CreateCommand, new CommandInfoAttribute{ CommandName = "test", CommandDescription = "desc" })
                 }
             };
             collection.OnImportsSatisfied();
@@ -43,7 +43,7 @@ public void SubCommandAreAddedToRootCommand()
         [Fact]
         public void SubCommandsWithoutArgumentGetsHandler()
         {
-            var exportFactory = new ExportFactory<Logic.Commands.IPretzelCommand, CommandInfoAttribute>(
+            var exportFactory = new ExportFactory<Logic.Commands.ICommand, CommandInfoAttribute>(
                 CreateCommand,
                 new CommandInfoAttribute
                 {
@@ -54,7 +54,7 @@ public void SubCommandsWithoutArgumentGetsHandler()
             var collection = new CommandCollection
             {
                 Configuration = Substitute.For<IConfiguration>(),
-                Commands = new ExportFactory<Logic.Commands.IPretzelCommand, CommandInfoAttribute>[]
+                Commands = new ExportFactory<Logic.Commands.ICommand, CommandInfoAttribute>[]
                 {
                     exportFactory
                 }
@@ -65,7 +65,7 @@ public void SubCommandsWithoutArgumentGetsHandler()
             var command = collection.RootCommand.Children.OfType<Command>().First();
             Assert.NotNull(command.Handler);
             Assert.IsType<PretzelCommandHandler>(command.Handler);
-            Assert.Null(((PretzelCommandHandler)command.Handler).CommandParameters);
+            Assert.Null(((PretzelCommandHandler)command.Handler).CommandArguments);
             Assert.NotNull(((PretzelCommandHandler)command.Handler).Configuration);
             Assert.Equal(collection.Configuration, ((PretzelCommandHandler)command.Handler).Configuration);
             Assert.NotNull(((PretzelCommandHandler)command.Handler).Command);
@@ -81,7 +81,7 @@ public void SubCommandsWithArgumentGetsHandler()
                 new Option("-i")
             });
 
-            var commandExportFactory = new ExportFactory<Logic.Commands.IPretzelCommand, CommandInfoAttribute>(
+            var commandExportFactory = new ExportFactory<Logic.Commands.ICommand, CommandInfoAttribute>(
                 CreateCommand,
                 new CommandInfoAttribute
                 {
@@ -99,7 +99,7 @@ public void SubCommandsWithArgumentGetsHandler()
             var collection = new CommandCollection
             {
                 Configuration = Substitute.For<IConfiguration>(),
-                Commands = new ExportFactory<Logic.Commands.IPretzelCommand, CommandInfoAttribute>[]
+                Commands = new ExportFactory<Logic.Commands.ICommand, CommandInfoAttribute>[]
                 {
                     commandExportFactory
                 },
@@ -122,16 +122,16 @@ public void SubCommandsWithArgumentGetsHandler()
             Assert.Single(command.OfType<Option>());
             Assert.NotNull(command.Handler);
             Assert.IsType<PretzelCommandHandler>(command.Handler);
-            Assert.NotNull(((PretzelCommandHandler)command.Handler).CommandParameters);
-            Assert.Equal(parameters, ((PretzelCommandHandler)command.Handler).CommandParameters);
+            Assert.NotNull(((PretzelCommandHandler)command.Handler).CommandArguments);
+            Assert.Equal(parameters, ((PretzelCommandHandler)command.Handler).CommandArguments);
             Assert.NotNull(((PretzelCommandHandler)command.Handler).Configuration);
             Assert.Equal(collection.Configuration, ((PretzelCommandHandler)command.Handler).Configuration);
             Assert.NotNull(((PretzelCommandHandler)command.Handler).Command);
             Assert.Equal(commandExportFactory, ((PretzelCommandHandler)command.Handler).Command);
         }
 
-        Tuple<Logic.Commands.IPretzelCommand, Action> CreateCommand()
-            => Tuple.Create(Substitute.For<Logic.Commands.IPretzelCommand>(), new Action(() => { }));
+        Tuple<Logic.Commands.ICommand, Action> CreateCommand()
+            => Tuple.Create(Substitute.For<Logic.Commands.ICommand>(), new Action(() => { }));
         Tuple<ICommandArguments, Action> CreateArgument(ICommandArguments parameters)
             => Tuple.Create(parameters, new Action(() => { }));
 
@@ -198,9 +198,9 @@ public void BindingCompleted() { }
             [Export]
             [Shared]
             [CommandInfo(CommandName = "test1")]
-            public class TestCommand1 : IPretzelCommand
+            public class TestCommand1 : Logic.Commands.ICommand
             {
-                public Task<int> Execute()
+                public Task<int> Execute(ICommandArguments arguments)
                 {
                     return Task.FromResult(0);
                 }
@@ -224,9 +224,9 @@ public void BindingCompleted() { }
             [Export]
             [Shared]
             [CommandInfo(CommandName = "test2")]
-            public class TestCommand2 : IPretzelCommand
+            public class TestCommand2 : Logic.Commands.ICommand
             {
-                public Task<int> Execute()
+                public Task<int> Execute(ICommandArguments arguments)
                 {
                     return Task.FromResult(0);
                 }
diff --git a/src/Pretzel.Tests/Commands/PretzelCommandHandlerTests.cs b/src/Pretzel.Tests/Commands/PretzelCommandHandlerTests.cs
index 38f1b400e..a4a26c654 100644
--- a/src/Pretzel.Tests/Commands/PretzelCommandHandlerTests.cs
+++ b/src/Pretzel.Tests/Commands/PretzelCommandHandlerTests.cs
@@ -44,9 +44,9 @@ public async Task CommandParametersGetsBinded()
             var sut = new PretzelCommandHandler(
                 Substitute.For<IConfiguration>(),
                 testParams,
-                new ExportFactory<IPretzelCommand, CommandInfoAttribute>(
+                new ExportFactory<Logic.Commands.ICommand, CommandInfoAttribute>(
                     () => Tuple.Create(
-                            Substitute.For<IPretzelCommand>(),
+                            Substitute.For<Logic.Commands.ICommand>(),
                             new Action(() => { })
                         ), new CommandInfoAttribute()));
 
@@ -66,9 +66,9 @@ public async Task CommandParameters_BindingCompleted_IsCalled()
             var sut = new PretzelCommandHandler(
               Substitute.For<IConfiguration>(),
               testArgument,
-              new ExportFactory<IPretzelCommand, CommandInfoAttribute>(
+              new ExportFactory<Logic.Commands.ICommand, CommandInfoAttribute>(
                   () => Tuple.Create(
-                          Substitute.For<IPretzelCommand>(),
+                          Substitute.For<Logic.Commands.ICommand>(),
                           new Action(() => { })
                       ), new CommandInfoAttribute()));
 
@@ -91,9 +91,9 @@ public async Task Configuration_ReadFromFile_IsCalled_WithPathProvider()
             var sut = new PretzelCommandHandler(
                 configuration,
                 testArgument,
-                new ExportFactory<IPretzelCommand, CommandInfoAttribute>(
+                new ExportFactory<Logic.Commands.ICommand, CommandInfoAttribute>(
                     () => Tuple.Create(
-                            Substitute.For<IPretzelCommand>(),
+                            Substitute.For<Logic.Commands.ICommand>(),
                             new Action(() => { })
                         ), new CommandInfoAttribute()));
 
@@ -155,9 +155,9 @@ public async Task CommandParametersExtentionsGetsBinded()
             var sut = new PretzelCommandHandler(
                 Substitute.For<IConfiguration>(),
                 testParams,
-                new ExportFactory<IPretzelCommand, CommandInfoAttribute>(
+                new ExportFactory<Logic.Commands.ICommand, CommandInfoAttribute>(
                     () => Tuple.Create(
-                            Substitute.For<IPretzelCommand>(),
+                            Substitute.For<Logic.Commands.ICommand>(),
                             new Action(() => { })
                         ), new CommandInfoAttribute()));
 
@@ -181,9 +181,9 @@ public async Task CommandParametersExtention_BindingCompleted_IsCalled()
             var sut = new PretzelCommandHandler(
                 Substitute.For<IConfiguration>(),
                 testParams,
-                new ExportFactory<IPretzelCommand, CommandInfoAttribute>(
+                new ExportFactory<Logic.Commands.ICommand, CommandInfoAttribute>(
                     () => Tuple.Create(
-                            Substitute.For<IPretzelCommand>(),
+                            Substitute.For<Logic.Commands.ICommand>(),
                             new Action(() => { })
                         ), new CommandInfoAttribute()));
 
@@ -198,12 +198,13 @@ public async Task CommandGetsExecuted()
             var rootCommand = new RootCommand();
 
             var context = new InvocationContext(new Parser(rootCommand).Parse(""), Substitute.For<IConsole>());
-            var command = Substitute.For<IPretzelCommand>();
+            var command = Substitute.For<Logic.Commands.ICommand>();
+            var arguments = Substitute.For<ICommandArguments>();
 
             var sut = new PretzelCommandHandler(
                 Substitute.For<IConfiguration>(),
-                Substitute.For<ICommandArguments>(),
-                new ExportFactory<IPretzelCommand, CommandInfoAttribute>(
+                arguments,
+                new ExportFactory<Logic.Commands.ICommand, CommandInfoAttribute>(
                     () => Tuple.Create(
                             command,
                             new Action(() => { })
@@ -211,7 +212,7 @@ public async Task CommandGetsExecuted()
 
             await sut.InvokeAsync(context);
 
-            await command.Received(1).Execute();
+            await command.Received(1).Execute(arguments);
         }
 
         [Fact]
@@ -221,14 +222,14 @@ public async Task ExecutionOrder()
 
             var context = new InvocationContext(new Parser(rootCommand).Parse(""), Substitute.For<IConsole>());
             var configuration = Substitute.For<IConfiguration>();
-            var @params = Substitute.For<ICommandArguments, ISourcePathProvider>();
-            ((ISourcePathProvider)@params).Source.Returns("bar");
-            var command = Substitute.For<IPretzelCommand>();
+            var arguments = Substitute.For<ICommandArguments, ISourcePathProvider>();
+            ((ISourcePathProvider)arguments).Source.Returns("bar");
+            var command = Substitute.For<Logic.Commands.ICommand>();
 
             var sut = new PretzelCommandHandler(
                 configuration,
-                @params,
-                new ExportFactory<IPretzelCommand, CommandInfoAttribute>(
+                arguments,
+                new ExportFactory<Logic.Commands.ICommand, CommandInfoAttribute>(
                     () => Tuple.Create(
                             command,
                             new Action(() => { })
@@ -238,9 +239,9 @@ public async Task ExecutionOrder()
 
             Received.InOrder(async () =>
             {
-                @params.BindingCompleted();
+                arguments.BindingCompleted();
                 configuration.ReadFromFile("bar");
-                await command.Execute();
+                await command.Execute(arguments);
             });
         }
     }
diff --git a/src/Pretzel/Commands/BakeCommand.cs b/src/Pretzel/Commands/BakeCommand.cs
index 184564a80..a9fc1917c 100644
--- a/src/Pretzel/Commands/BakeCommand.cs
+++ b/src/Pretzel/Commands/BakeCommand.cs
@@ -23,7 +23,7 @@ public BakeCommandArguments(IFileSystem fileSystem) : base(fileSystem) { }
 
     [Shared]
     [CommandInfo(CommandName = BuiltInCommands.Bake, CommandDescription = "transforming content into a website")]
-    public sealed class BakeCommand : IPretzelCommand
+    public sealed class BakeCommand : Command<BakeCommandArguments>
     {
         [Import]
         public TemplateEngineCollection TemplateEngines { get; set; }
@@ -33,30 +33,27 @@ public sealed class BakeCommand : IPretzelCommand
 
         [ImportMany]
         public IEnumerable<ITransform> Transforms { get; set; }
-
-        [Import]
-        public BakeCommandArguments Parameters { get; set; }
-
+        
         [Import]
         public IFileSystem FileSystem { get; set; }
 
-        public Task<int> Execute()
+        protected override Task<int> Execute(BakeCommandArguments arguments)
         {
             Tracing.Info("bake - transforming content into a website");
 
-            var siteContext = Generator.BuildContext(Parameters.Source, Parameters.Destination, Parameters.Drafts);
+            var siteContext = Generator.BuildContext(arguments.Source, arguments.Destination, arguments.Drafts);
 
-            if (Parameters.CleanTarget && FileSystem.Directory.Exists(siteContext.OutputFolder))
+            if (arguments.CleanTarget && FileSystem.Directory.Exists(siteContext.OutputFolder))
             {
                 FileSystem.Directory.Delete(siteContext.OutputFolder, true);
             }
 
-            if (string.IsNullOrWhiteSpace(Parameters.Template))
+            if (string.IsNullOrWhiteSpace(arguments.Template))
             {
-                Parameters.DetectFromDirectory(TemplateEngines.Engines, siteContext);
+                arguments.DetectFromDirectory(TemplateEngines.Engines, siteContext);
             }
 
-            var engine = TemplateEngines[Parameters.Template];
+            var engine = TemplateEngines[arguments.Template];
             if (engine != null)
             {
                 var watch = new Stopwatch();
@@ -73,7 +70,7 @@ public Task<int> Execute()
             }
             else
             {
-                Tracing.Info("Cannot find engine for input: '{0}'", Parameters.Template);
+                Tracing.Info("Cannot find engine for input: '{0}'", arguments.Template);
                 return Task.FromResult(1);
             }
             return Task.FromResult(0);
diff --git a/src/Pretzel/Commands/CommandCollection.cs b/src/Pretzel/Commands/CommandCollection.cs
index be3b3c0d9..840e06355 100644
--- a/src/Pretzel/Commands/CommandCollection.cs
+++ b/src/Pretzel/Commands/CommandCollection.cs
@@ -12,11 +12,11 @@ namespace Pretzel.Commands
     [Shared]
     public sealed class CommandCollection
     {
-        ExportFactory<IPretzelCommand, CommandInfoAttribute>[] commands;
+        ExportFactory<Logic.Commands.ICommand, CommandInfoAttribute>[] commands;
         [ImportMany]
-        public ExportFactory<IPretzelCommand, CommandInfoAttribute>[] Commands
+        public ExportFactory<Logic.Commands.ICommand, CommandInfoAttribute>[] Commands
         {
-            get => commands ?? new ExportFactory<IPretzelCommand, CommandInfoAttribute>[] { };
+            get => commands ?? new ExportFactory<Logic.Commands.ICommand, CommandInfoAttribute>[] { };
             set => commands = value;
         }
 
diff --git a/src/Pretzel/Commands/HungryCommand.cs b/src/Pretzel/Commands/HungryCommand.cs
index 25f48e335..34a0dfae1 100644
--- a/src/Pretzel/Commands/HungryCommand.cs
+++ b/src/Pretzel/Commands/HungryCommand.cs
@@ -1,4 +1,6 @@
 using System;
+using System.Collections.Generic;
+using System.CommandLine;
 using System.Composition;
 using System.Threading.Tasks;
 using Pretzel.Logic.Commands;
@@ -6,10 +8,15 @@
 
 namespace Pretzel.Commands
 {
+    public class HungryCommandArguments : BaseCommandArguments
+    {
+        protected override IEnumerable<Option> CreateOptions() => Array.Empty<Option>();
+    }
+
     [Shared]
     [Export]
     [CommandInfo(CommandName = BuiltInCommands.Hungry, CommandDescription = "use only when hungry")]
-    public sealed class HungryCommand : IPretzelCommand
+    public sealed class HungryCommand : Command<HungryCommandArguments>
     {
         private readonly string recipe = @"===== Ingredients ======
 
@@ -50,7 +57,7 @@ 2 tablespoons baking soda
 
 Eat the pretzels warm, or reheat them in an oven or microwave.";
 
-        public Task<int> Execute()
+        protected override Task<int> Execute(HungryCommandArguments arguments)
         {
             Tracing.Info(recipe);
 
diff --git a/src/Pretzel/Commands/ImportCommand.cs b/src/Pretzel/Commands/ImportCommand.cs
index 661c8beaf..bbdf8083d 100644
--- a/src/Pretzel/Commands/ImportCommand.cs
+++ b/src/Pretzel/Commands/ImportCommand.cs
@@ -38,34 +38,32 @@ protected override IEnumerable<Option> CreateOptions() => base.CreateOptions().C
 
     [Shared]
     [CommandInfo(CommandName = BuiltInCommands.Import, CommandDescription = "import posts from external source")]
-    class ImportCommand : IPretzelCommand
+    class ImportCommand : Command<ImportCommandArguments>
     {
         readonly static List<string> Importers = new List<string>(new[] { "wordpress", "blogger" });
 
         [Import]
         public IFileSystem FileSystem { get; set; }
-        [Import]
-        public ImportCommandArguments Parameters { get; set; }
 
-        public Task<int> Execute()
+        protected override Task<int> Execute(ImportCommandArguments arguments)
         {
             Tracing.Info("import - import posts from external source");
 
-            if (!Importers.Any(e => String.Equals(e, Parameters.ImportType, StringComparison.InvariantCultureIgnoreCase)))
+            if (!Importers.Any(e => String.Equals(e, arguments.ImportType, StringComparison.InvariantCultureIgnoreCase)))
             {
-                Tracing.Info("Requested import type not found: {0}", Parameters.ImportType);
+                Tracing.Info("Requested import type not found: {0}", arguments.ImportType);
 
                 return Task.FromResult(1);
             }
 
-            if (string.Equals("wordpress", Parameters.ImportType, StringComparison.InvariantCultureIgnoreCase))
+            if (string.Equals("wordpress", arguments.ImportType, StringComparison.InvariantCultureIgnoreCase))
             {
-                var wordpressImporter = new WordpressImport(FileSystem, Parameters.Source, Parameters.ImportFile);
+                var wordpressImporter = new WordpressImport(FileSystem, arguments.Source, arguments.ImportFile);
                 wordpressImporter.Import();
             }
-            else if (string.Equals("blogger", Parameters.ImportType, StringComparison.InvariantCultureIgnoreCase))
+            else if (string.Equals("blogger", arguments.ImportType, StringComparison.InvariantCultureIgnoreCase))
             {
-                var bloggerImporter = new BloggerImport(FileSystem, Parameters.Source, Parameters.ImportFile);
+                var bloggerImporter = new BloggerImport(FileSystem, arguments.Source, arguments.ImportFile);
                 bloggerImporter.Import();
             }
 
diff --git a/src/Pretzel/Commands/IngredientCommand.cs b/src/Pretzel/Commands/IngredientCommand.cs
index 91dadb6d6..e2fe93a7e 100644
--- a/src/Pretzel/Commands/IngredientCommand.cs
+++ b/src/Pretzel/Commands/IngredientCommand.cs
@@ -32,19 +32,16 @@ protected override IEnumerable<Option> CreateOptions() => base.CreateOptions().C
 
     [Shared]
     [CommandInfo(CommandName = BuiltInCommands.Ingredient, CommandDescription = "create a new post")]
-    public sealed class IngredientCommand : IPretzelCommand
+    public sealed class IngredientCommand : Command<IngredientCommandArguments>
     {
         [Import]
         public IFileSystem FileSystem { get; set; }
-
-        [Import]
-        public IngredientCommandArguments Parameters { get; set; }
-
-        public Task<int> Execute()
+        
+        protected override Task<int> Execute(IngredientCommandArguments arguments)
         {
             Tracing.Info("ingredient - create a new post");
 
-            var ingredient = new Ingredient(FileSystem, Parameters.NewPostTitle, Parameters.Source, Parameters.Drafts);
+            var ingredient = new Ingredient(FileSystem, arguments.NewPostTitle, arguments.Source, arguments.Drafts);
             ingredient.Create();
 
             return Task.FromResult(0);
diff --git a/src/Pretzel/Commands/PretzelCommandHandler.cs b/src/Pretzel/Commands/PretzelCommandHandler.cs
index a8f711d48..d9a7306c8 100644
--- a/src/Pretzel/Commands/PretzelCommandHandler.cs
+++ b/src/Pretzel/Commands/PretzelCommandHandler.cs
@@ -11,14 +11,14 @@ namespace Pretzel.Commands
 {
     public class PretzelCommandHandler : ICommandHandler
     {
-        public ICommandArguments CommandParameters { get; }
-        public ExportFactory<IPretzelCommand, CommandInfoAttribute> Command { get; }
+        public ICommandArguments CommandArguments { get; }
+        public ExportFactory<ICommand, CommandInfoAttribute> Command { get; }
         public IConfiguration Configuration { get; }
 
-        public PretzelCommandHandler(IConfiguration configuration, ICommandArguments commandParameters, ExportFactory<IPretzelCommand, CommandInfoAttribute> command)
+        public PretzelCommandHandler(IConfiguration configuration, ICommandArguments commandParameters, ExportFactory<ICommand, CommandInfoAttribute> command)
         {
             Configuration = configuration;
-            CommandParameters = commandParameters;
+            CommandArguments = commandParameters;
             Command = command;
         }
 
@@ -26,20 +26,20 @@ public async Task<int> InvokeAsync(InvocationContext context)
         {
             var bindingContext = context.BindingContext;
 
-            if (CommandParameters != null)
+            if (CommandArguments != null)
             {
-                new ModelBinder(CommandParameters.GetType())
-                   .UpdateInstance(CommandParameters, bindingContext);
+                new ModelBinder(CommandArguments.GetType())
+                   .UpdateInstance(CommandArguments, bindingContext);
 
-                CommandParameters.BindingCompleted();
+                CommandArguments.BindingCompleted();
             }
 
-            if (CommandParameters is ISourcePathProvider pathProvider)
+            if (CommandArguments is ISourcePathProvider pathProvider)
             {
                 Configuration.ReadFromFile(pathProvider.Source);
             }
 
-            foreach (var argumentsExtension in CommandParameters.Extensions)
+            foreach (var argumentsExtension in CommandArguments.Extensions)
             {
                 new ModelBinder(argumentsExtension.GetType())
                     .UpdateInstance(argumentsExtension, bindingContext);
@@ -47,7 +47,7 @@ public async Task<int> InvokeAsync(InvocationContext context)
                 argumentsExtension.BindingCompleted();
             }
 
-            return await Command.CreateExport().Value.Execute();
+            return await Command.CreateExport().Value.Execute(CommandArguments);
         }
     }
 }
diff --git a/src/Pretzel/Commands/RecipeCommand.cs b/src/Pretzel/Commands/RecipeCommand.cs
index bda7c2b03..55da89dab 100644
--- a/src/Pretzel/Commands/RecipeCommand.cs
+++ b/src/Pretzel/Commands/RecipeCommand.cs
@@ -38,26 +38,23 @@ protected override IEnumerable<Option> CreateOptions() => base.CreateOptions().C
 
     [Shared]
     [CommandInfo(CommandName = BuiltInCommands.Create, CommandDescription = "configure a new site")]
-    public sealed class RecipeCommand : IPretzelCommand
+    public sealed class RecipeCommand : Command<RecipeCommandArguments>
     {
         private static readonly List<string> TemplateEngines = new List<string>(new[] { "Liquid", "Razor" });
 
         [Import]
         public IFileSystem FileSystem { get; set; }
 
-        [Import]
-        public RecipeCommandArguments Parameters { get; set; }
-
         [ImportMany]
         public IEnumerable<IAdditionalIngredient> AdditionalIngredients { get; set; }
 
-        public Task<int> Execute()
+        protected override Task<int> Execute(RecipeCommandArguments arguments)
         {
             Tracing.Info("create - configure a new site");
 
-            var engine = String.IsNullOrWhiteSpace(Parameters.Template)
+            var engine = String.IsNullOrWhiteSpace(arguments.Template)
                              ? TemplateEngines.First()
-                             : Parameters.Template;
+                             : arguments.Template;
 
             if (!TemplateEngines.Any(e => String.Equals(e, engine, StringComparison.InvariantCultureIgnoreCase)))
             {
@@ -68,7 +65,7 @@ public Task<int> Execute()
 
             Tracing.Info("Using {0} Engine", engine);
 
-            var recipe = new Recipe(FileSystem, engine, Parameters.Source, AdditionalIngredients, Parameters.WithProject, Parameters.Wiki, Parameters.Drafts);
+            var recipe = new Recipe(FileSystem, engine, arguments.Source, AdditionalIngredients, arguments.WithProject, arguments.Wiki, arguments.Drafts);
             recipe.Create();
 
             return Task.FromResult(0);
diff --git a/src/Pretzel/Commands/TasteCommand.cs b/src/Pretzel/Commands/TasteCommand.cs
index 4a77ee5fb..2c867168c 100644
--- a/src/Pretzel/Commands/TasteCommand.cs
+++ b/src/Pretzel/Commands/TasteCommand.cs
@@ -42,7 +42,7 @@ protected override IEnumerable<Option> CreateOptions() => base.CreateOptions().C
 
     [Shared]
     [CommandInfo(CommandName = BuiltInCommands.Taste, CommandDescription = "testing a site locally")]
-    public sealed class TasteCommand : IPretzelCommand
+    public sealed class TasteCommand : Command<TasteCommandArguments>
     {
         private ISiteEngine engine;
 
@@ -52,9 +52,6 @@ public sealed class TasteCommand : IPretzelCommand
         [Import]
         public SiteContextGenerator Generator { get; set; }
 
-        [Import]
-        public TasteCommandArguments Parameters { get; set; }
-
         [ImportMany]
         public IEnumerable<ITransform> Transforms { get; set; }
 
@@ -64,27 +61,27 @@ public sealed class TasteCommand : IPretzelCommand
         [Import]
         public IConfiguration Configuration { get; set; }
 
-        public Task<int> Execute()
+        protected override Task<int> Execute(TasteCommandArguments arguments)
         {
             Tracing.Info("taste - testing a site locally");
-            
-            var context = Generator.BuildContext(Parameters.Source, Parameters.Destination, Parameters.Drafts);
 
-            if (Parameters.CleanTarget && FileSystem.Directory.Exists(context.OutputFolder))
+            var context = Generator.BuildContext(arguments.Source, arguments.Destination, arguments.Drafts);
+
+            if (arguments.CleanTarget && FileSystem.Directory.Exists(context.OutputFolder))
             {
                 FileSystem.Directory.Delete(context.OutputFolder, true);
             }
 
-            if (string.IsNullOrWhiteSpace(Parameters.Template))
+            if (string.IsNullOrWhiteSpace(arguments.Template))
             {
-                Parameters.DetectFromDirectory(TemplateEngines.Engines, context);
+                arguments.DetectFromDirectory(TemplateEngines.Engines, context);
             }
 
-            engine = TemplateEngines[Parameters.Template];
+            engine = TemplateEngines[arguments.Template];
 
             if (engine == null)
             {
-                Tracing.Info("template engine {0} not found - (engines: {1})", Parameters.Template,
+                Tracing.Info("template engine {0} not found - (engines: {1})", arguments.Template,
                                            string.Join(", ", TemplateEngines.Engines.Keys));
 
                 return Task.FromResult(1);
@@ -95,11 +92,11 @@ public Task<int> Execute()
             foreach (var t in Transforms)
                 t.Transform(context);
 
-            using (var watcher = new SimpleFileSystemWatcher(Parameters.Destination))
+            using (var watcher = new SimpleFileSystemWatcher(arguments.Destination))
             {
-                watcher.OnChange(Parameters.Source, WatcherOnChanged);
+                watcher.OnChange(arguments.Source, file => WatcherOnChanged(file, arguments));
 
-                using (var w = new WebHost(Parameters.Destination, new FileContentProvider(), Convert.ToInt32(Parameters.Port)))
+                using (var w = new WebHost(arguments.Destination, new FileContentProvider(), Convert.ToInt32(arguments.Port)))
                 {
                     try
                     {
@@ -107,13 +104,13 @@ public Task<int> Execute()
                     }
                     catch (System.Net.Sockets.SocketException)
                     {
-                        Tracing.Info("Port {0} is already in use", Parameters.Port);
+                        Tracing.Info("Port {0} is already in use", arguments.Port);
 
                         return Task.FromResult(1);
                     }
 
-                    var url = string.Format("http://localhost:{0}/", Parameters.Port);
-                    if (Parameters.LaunchBrowser)
+                    var url = string.Format("http://localhost:{0}/", arguments.Port);
+                    if (arguments.LaunchBrowser)
                     {
                         Tracing.Info("Opening {0} in default browser...", url);
                         try
@@ -144,11 +141,11 @@ public Task<int> Execute()
             return Task.FromResult(0);
         }
 
-        private void WatcherOnChanged(string file)
+        private void WatcherOnChanged(string file, TasteCommandArguments arguments)
         {
-            if (file.StartsWith(Parameters.Source))
+            if (file.StartsWith(arguments.Source))
             {
-                var relativeFile = file.Substring(Parameters.Source.Length).ToRelativeFile();
+                var relativeFile = file.Substring(arguments.Source.Length).ToRelativeFile();
                 if (Generator.IsExcludedPath(relativeFile))
                 {
                     return;
@@ -157,10 +154,10 @@ private void WatcherOnChanged(string file)
 
             Tracing.Info("File change: {0}", file);
 
-            Configuration.ReadFromFile(Parameters.Source);
+            Configuration.ReadFromFile(arguments.Source);
 
-            var context = Generator.BuildContext(Parameters.Source, Parameters.Destination, Parameters.Drafts);
-            if (Parameters.CleanTarget && FileSystem.Directory.Exists(context.OutputFolder))
+            var context = Generator.BuildContext(arguments.Source, arguments.Destination, arguments.Drafts);
+            if (arguments.CleanTarget && FileSystem.Directory.Exists(context.OutputFolder))
             {
                 FileSystem.Directory.Delete(context.OutputFolder, true);
             }
diff --git a/src/Pretzel/Commands/VersionCommand.cs b/src/Pretzel/Commands/VersionCommand.cs
index d68d3a70f..80d0bae8a 100644
--- a/src/Pretzel/Commands/VersionCommand.cs
+++ b/src/Pretzel/Commands/VersionCommand.cs
@@ -1,3 +1,6 @@
+using System;
+using System.Collections.Generic;
+using System.CommandLine;
 using System.Composition;
 using System.Reflection;
 using System.Threading.Tasks;
@@ -6,11 +9,16 @@
 
 namespace Pretzel.Commands
 {
+    public class VersionCommandArguments : BaseCommandArguments
+    {
+        protected override IEnumerable<Option> CreateOptions() => Array.Empty<Option>();
+    }
+
     [Shared]
     [CommandInfo(CommandName = BuiltInCommands.Version, CommandDescription = "display current Pretzel version")]
-    public sealed class VersionCommand : IPretzelCommand
+    public sealed class VersionCommand : Command<VersionCommandArguments>
     {
-        public Task<int> Execute()
+        protected override Task<int> Execute(VersionCommandArguments arguments)
         {
             Tracing.Info("V{0}", Assembly.GetExecutingAssembly().GetName().Version);
 

From 8d9846b9a4cf4b636a684224a34c0454eb1967b7 Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Mon, 30 Sep 2019 13:48:29 +0200
Subject: [PATCH 40/56] refactor: commands now specify their arguments

---
 .../Commands/BaseCommandArguments.cs          |  8 +-
 .../Commands/CommandArgumentsAttribute.cs     |  2 -
 .../Commands/CommandInfoAttribute.cs          |  2 +
 .../Commands/BaseParametersTests.cs           |  2 +-
 .../Commands/CommandCollectionTests.cs        | 75 +++++--------------
 src/Pretzel.Tests/Commands/ParametersTests.cs |  2 +-
 .../Commands/PretzelCommandHandlerTests.cs    |  2 +-
 src/Pretzel/Commands/BakeCommand.cs           |  8 +-
 src/Pretzel/Commands/CommandCollection.cs     | 57 ++++++--------
 src/Pretzel/Commands/HungryCommand.cs         |  9 ++-
 src/Pretzel/Commands/ImportCommand.cs         |  8 +-
 src/Pretzel/Commands/IngredientCommand.cs     |  7 +-
 src/Pretzel/Commands/RecipeCommand.cs         |  8 +-
 src/Pretzel/Commands/TasteCommand.cs          |  8 +-
 src/Pretzel/Commands/VersionCommand.cs        |  9 ++-
 15 files changed, 95 insertions(+), 112 deletions(-)

diff --git a/src/Pretzel.Logic/Commands/BaseCommandArguments.cs b/src/Pretzel.Logic/Commands/BaseCommandArguments.cs
index 7fd822f29..66a675002 100644
--- a/src/Pretzel.Logic/Commands/BaseCommandArguments.cs
+++ b/src/Pretzel.Logic/Commands/BaseCommandArguments.cs
@@ -9,15 +9,13 @@ namespace Pretzel.Logic.Commands
 {
     public abstract class BaseCommandArguments : ICommandArguments
     {
+        readonly List<Option> options = new List<Option>();
         [Export]
-        public IList<Option> Options { get; set; }
+        public IList<Option> Options => options;
         public IList<ICommandArgumentsExtension> Extensions { get; } = new List<ICommandArgumentsExtension>();
 
-        [OnImportsSatisfied]
-        internal void OnImportsSatisfied()
+        internal void BuildOptions()
         {
-            var options = new List<Option>();
-            Options = options;
             options.AddRange(CreateOptions());
         }
 
diff --git a/src/Pretzel.Logic/Commands/CommandArgumentsAttribute.cs b/src/Pretzel.Logic/Commands/CommandArgumentsAttribute.cs
index 7cb4750c6..e7f0f3167 100644
--- a/src/Pretzel.Logic/Commands/CommandArgumentsAttribute.cs
+++ b/src/Pretzel.Logic/Commands/CommandArgumentsAttribute.cs
@@ -7,8 +7,6 @@ namespace Pretzel.Logic.Commands
     [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
     public sealed class CommandArgumentsAttribute : ExportAttribute
     {
-        public string CommandName { get; set; }
-
         public CommandArgumentsAttribute() : base(typeof(ICommandArguments))
         {
         }
diff --git a/src/Pretzel.Logic/Commands/CommandInfoAttribute.cs b/src/Pretzel.Logic/Commands/CommandInfoAttribute.cs
index e9647e7be..2ebcfbc09 100644
--- a/src/Pretzel.Logic/Commands/CommandInfoAttribute.cs
+++ b/src/Pretzel.Logic/Commands/CommandInfoAttribute.cs
@@ -11,6 +11,8 @@ public sealed class CommandInfoAttribute : ExportAttribute
 
         public string CommandDescription { get; set; }
 
+        public Type CommandArgumentsType { get; set; }
+
         public CommandInfoAttribute() : base(typeof(ICommand))
         {
         }
diff --git a/src/Pretzel.Tests/Commands/BaseParametersTests.cs b/src/Pretzel.Tests/Commands/BaseParametersTests.cs
index aa6085688..3882c7206 100644
--- a/src/Pretzel.Tests/Commands/BaseParametersTests.cs
+++ b/src/Pretzel.Tests/Commands/BaseParametersTests.cs
@@ -13,7 +13,7 @@ public class BaseParametersTests
     {
         [Export]
         [Shared]
-        [CommandArguments(CommandName = "test")]
+        [CommandArguments]
         public class BaseParametersImpl : BaseCommandArguments
         {
             protected override IEnumerable<Option> CreateOptions() => new[]
diff --git a/src/Pretzel.Tests/Commands/CommandCollectionTests.cs b/src/Pretzel.Tests/Commands/CommandCollectionTests.cs
index 61c888d06..7e59dc7e4 100644
--- a/src/Pretzel.Tests/Commands/CommandCollectionTests.cs
+++ b/src/Pretzel.Tests/Commands/CommandCollectionTests.cs
@@ -27,12 +27,19 @@ public void RootCommandGetsCreatedOnImportSatisfied()
         [Fact]
         public void SubCommandAreAddedToRootCommand()
         {
+            var arguments = Substitute.For<ICommandArguments>();
             var collection = new CommandCollection
             {
                 Commands = new ExportFactory<Logic.Commands.ICommand, CommandInfoAttribute>[]
                 {
-                    new ExportFactory<Logic.Commands.ICommand, CommandInfoAttribute>(CreateCommand, new CommandInfoAttribute{ CommandName = "test", CommandDescription = "desc" })
-                }
+                    new ExportFactory<Logic.Commands.ICommand, CommandInfoAttribute>(CreateCommand, new CommandInfoAttribute
+                    {
+                        CommandName = "test",
+                        CommandDescription = "desc",
+                        CommandArgumentsType = arguments.GetType()
+                    })
+                },
+                CommandArguments = new[] { arguments }
             };
             collection.OnImportsSatisfied();
 
@@ -40,38 +47,6 @@ public void SubCommandAreAddedToRootCommand()
             Assert.Contains(collection.RootCommand.Children.OfType<Command>(), c => c.Description == "desc");
         }
 
-        [Fact]
-        public void SubCommandsWithoutArgumentGetsHandler()
-        {
-            var exportFactory = new ExportFactory<Logic.Commands.ICommand, CommandInfoAttribute>(
-                CreateCommand,
-                new CommandInfoAttribute
-                {
-                    CommandName = "test",
-                    CommandDescription = "desc"
-                });
-
-            var collection = new CommandCollection
-            {
-                Configuration = Substitute.For<IConfiguration>(),
-                Commands = new ExportFactory<Logic.Commands.ICommand, CommandInfoAttribute>[]
-                {
-                    exportFactory
-                }
-            };
-
-            collection.OnImportsSatisfied();
-
-            var command = collection.RootCommand.Children.OfType<Command>().First();
-            Assert.NotNull(command.Handler);
-            Assert.IsType<PretzelCommandHandler>(command.Handler);
-            Assert.Null(((PretzelCommandHandler)command.Handler).CommandArguments);
-            Assert.NotNull(((PretzelCommandHandler)command.Handler).Configuration);
-            Assert.Equal(collection.Configuration, ((PretzelCommandHandler)command.Handler).Configuration);
-            Assert.NotNull(((PretzelCommandHandler)command.Handler).Command);
-            Assert.Equal(exportFactory, ((PretzelCommandHandler)command.Handler).Command);
-        }
-
         [Fact]
         public void SubCommandsWithArgumentGetsHandler()
         {
@@ -86,16 +61,11 @@ public void SubCommandsWithArgumentGetsHandler()
                 new CommandInfoAttribute
                 {
                     CommandName = "test",
-                    CommandDescription = "desc"
-                });
-
-            var argumentExportFactory = new ExportFactory<Logic.Commands.ICommandArguments, Logic.Commands.CommandArgumentsAttribute>(
-                () => CreateArgument(parameters),
-                new Logic.Commands.CommandArgumentsAttribute
-                {
-                    CommandName = "test"
+                    CommandDescription = "desc",
+                    CommandArgumentsType = parameters.GetType()
                 });
 
+         
             var collection = new CommandCollection
             {
                 Configuration = Substitute.For<IConfiguration>(),
@@ -103,15 +73,9 @@ public void SubCommandsWithArgumentGetsHandler()
                 {
                     commandExportFactory
                 },
-                CommandArguments = new ExportFactory<Logic.Commands.ICommandArguments, Logic.Commands.CommandArgumentsAttribute>[]
+                CommandArguments = new Logic.Commands.ICommandArguments[]
                 {
-                    argumentExportFactory,
-                    new ExportFactory<Logic.Commands.ICommandArguments, Logic.Commands.CommandArgumentsAttribute>(
-                    () => CreateArgument(Substitute.For<ICommandArguments>()),
-                    new Logic.Commands.CommandArgumentsAttribute
-                    {
-                        CommandName = "othercommand"
-                    })
+                    parameters
                 }
             };
 
@@ -132,9 +96,6 @@ public void SubCommandsWithArgumentGetsHandler()
 
         Tuple<Logic.Commands.ICommand, Action> CreateCommand()
             => Tuple.Create(Substitute.For<Logic.Commands.ICommand>(), new Action(() => { }));
-        Tuple<ICommandArguments, Action> CreateArgument(ICommandArguments parameters)
-            => Tuple.Create(parameters, new Action(() => { }));
-
 
         public class ICommandParametersExtentionsTests : IDisposable
         {
@@ -182,7 +143,7 @@ public void Dispose()
 
             [Export]
             [Shared]
-            [CommandArguments(CommandName = "test1")]
+            [CommandArguments]
             public class TestCommandArguments1 : ICommandArguments
             {
                 [ImportMany]
@@ -197,7 +158,7 @@ public void BindingCompleted() { }
 
             [Export]
             [Shared]
-            [CommandInfo(CommandName = "test1")]
+            [CommandInfo(CommandName = "test1", CommandArgumentsType = typeof(TestCommandArguments1))]
             public class TestCommand1 : Logic.Commands.ICommand
             {
                 public Task<int> Execute(ICommandArguments arguments)
@@ -208,7 +169,7 @@ public Task<int> Execute(ICommandArguments arguments)
 
             [Export]
             [Shared]
-            [CommandArguments(CommandName = "test2")]
+            [CommandArguments]
             public class TestCommandArguments2 : ICommandArguments
             {
                 [ImportMany]
@@ -223,7 +184,7 @@ public void BindingCompleted() { }
 
             [Export]
             [Shared]
-            [CommandInfo(CommandName = "test2")]
+            [CommandInfo(CommandName = "test2", CommandArgumentsType = typeof(TestCommandArguments2))]
             public class TestCommand2 : Logic.Commands.ICommand
             {
                 public Task<int> Execute(ICommandArguments arguments)
diff --git a/src/Pretzel.Tests/Commands/ParametersTests.cs b/src/Pretzel.Tests/Commands/ParametersTests.cs
index 3b9efbc15..983ffc9ba 100644
--- a/src/Pretzel.Tests/Commands/ParametersTests.cs
+++ b/src/Pretzel.Tests/Commands/ParametersTests.cs
@@ -20,7 +20,7 @@ protected T BuildParameters(params string[] args)
             var rootCommand = new RootCommand();
 
             var parameters = CreateParameters(fileSystem);
-            parameters.OnImportsSatisfied();
+            parameters.BuildOptions();
 
             foreach (var option in parameters.Options)
                 rootCommand.AddOption(option);
diff --git a/src/Pretzel.Tests/Commands/PretzelCommandHandlerTests.cs b/src/Pretzel.Tests/Commands/PretzelCommandHandlerTests.cs
index a4a26c654..272f5da30 100644
--- a/src/Pretzel.Tests/Commands/PretzelCommandHandlerTests.cs
+++ b/src/Pretzel.Tests/Commands/PretzelCommandHandlerTests.cs
@@ -102,7 +102,7 @@ public async Task Configuration_ReadFromFile_IsCalled_WithPathProvider()
             configuration.Received().ReadFromFile("foo");
         }
 
-        [CommandArguments(CommandName = nameof(TestArguments2))]
+        [CommandArguments]
         public class TestArguments2 : ICommandArguments
         {
             public IList<Option> Options { get; } = new List<Option>();
diff --git a/src/Pretzel/Commands/BakeCommand.cs b/src/Pretzel/Commands/BakeCommand.cs
index a9fc1917c..829a19aa8 100644
--- a/src/Pretzel/Commands/BakeCommand.cs
+++ b/src/Pretzel/Commands/BakeCommand.cs
@@ -14,7 +14,7 @@ namespace Pretzel.Commands
 {
     [Shared]
     [Export]
-    [CommandArguments(CommandName = BuiltInCommands.Bake)]
+    [CommandArguments]
     public sealed class BakeCommandArguments : BakeBaseCommandArguments
     {
         [ImportingConstructor]
@@ -22,7 +22,11 @@ public BakeCommandArguments(IFileSystem fileSystem) : base(fileSystem) { }
     }
 
     [Shared]
-    [CommandInfo(CommandName = BuiltInCommands.Bake, CommandDescription = "transforming content into a website")]
+    [CommandInfo(
+        CommandName = BuiltInCommands.Bake,
+        CommandDescription = "transforming content into a website",
+        CommandArgumentsType = typeof(BakeCommandArguments)
+        )]
     public sealed class BakeCommand : Command<BakeCommandArguments>
     {
         [Import]
diff --git a/src/Pretzel/Commands/CommandCollection.cs b/src/Pretzel/Commands/CommandCollection.cs
index 840e06355..1c12d9f22 100644
--- a/src/Pretzel/Commands/CommandCollection.cs
+++ b/src/Pretzel/Commands/CommandCollection.cs
@@ -16,15 +16,15 @@ public sealed class CommandCollection
         [ImportMany]
         public ExportFactory<Logic.Commands.ICommand, CommandInfoAttribute>[] Commands
         {
-            get => commands ?? new ExportFactory<Logic.Commands.ICommand, CommandInfoAttribute>[] { };
+            get => commands ?? Array.Empty<ExportFactory<Logic.Commands.ICommand, CommandInfoAttribute>>();
             set => commands = value;
         }
 
-        ExportFactory<ICommandArguments, CommandArgumentsAttribute>[] commandArguments;
+        ICommandArguments[] commandArguments;
         [ImportMany]
-        public ExportFactory<ICommandArguments, CommandArgumentsAttribute>[] CommandArguments
+        public ICommandArguments[] CommandArguments
         {
-            get => commandArguments ?? new ExportFactory<ICommandArguments, CommandArgumentsAttribute>[] { };
+            get => commandArguments ?? Array.Empty<ICommandArguments>();
             set => commandArguments = value;
         }
 
@@ -32,14 +32,8 @@ public ExportFactory<ICommandArguments, CommandArgumentsAttribute>[] CommandArgu
         [ImportMany]
         public ExportFactory<ICommandArgumentsExtension, CommandArgumentsExtensionAttribute>[] ArgumentExtensions
         {
-            get
-            {
-                return argumentExtensions ?? new ExportFactory<ICommandArgumentsExtension, CommandArgumentsExtensionAttribute>[] { };
-            }
-            set
-            {
-                argumentExtensions = value;
-            }
+            get => argumentExtensions ?? Array.Empty<ExportFactory<ICommandArgumentsExtension, CommandArgumentsExtensionAttribute>>();
+            set => argumentExtensions = value;
         }
 
         [Export]
@@ -52,39 +46,36 @@ public ExportFactory<ICommandArgumentsExtension, CommandArgumentsExtensionAttrib
         internal void OnImportsSatisfied()
         {
             RootCommand = new RootCommand();
-
+            
             foreach (var command in Commands)
             {
                 var subCommand = new Command(command.Metadata.CommandName, command.Metadata.CommandDescription);
 
-                foreach (var commandArgumentsExport in CommandArguments?.Where(a => a.Metadata.CommandName == command.Metadata.CommandName))
-                {
-                    var args = commandArgumentsExport.CreateExport().Value;
-
-                    foreach (var argumentExtensionsExport in ArgumentExtensions.Where(a => a.Metadata.CommandNames.Contains(commandArgumentsExport.Metadata.CommandName)))
-                    {
-                        var arugumentExtension = argumentExtensionsExport.CreateExport().Value;
-                        args.Extensions.Add(arugumentExtension);
-                    }
+                var argument = CommandArguments.First(c => c.GetType() == command.Metadata.CommandArgumentsType);
 
-                    foreach(var arugumentExtension in args.Extensions)
-                    {
-                        arugumentExtension.UpdateOptions(args.Options);
-                    }
+                if (argument is BaseCommandArguments baseCommandArguments)
+                {
+                    baseCommandArguments.BuildOptions();
+                }
 
-                    foreach (var option in args.Options)
-                    {
-                        subCommand.AddOption(option);
-                    }
+                foreach (var argumentExtensionsExport in ArgumentExtensions.Where(a => a.Metadata.CommandNames.Contains(command.Metadata.CommandName)))
+                {
+                    var arugumentExtension = argumentExtensionsExport.CreateExport().Value;
+                    argument.Extensions.Add(arugumentExtension);
+                }
 
-                    subCommand.Handler = new PretzelCommandHandler(Configuration, args, command);
+                foreach (var arugumentExtension in argument.Extensions)
+                {
+                    arugumentExtension.UpdateOptions(argument.Options);
                 }
 
-                if (subCommand.Handler == null)
+                foreach (var option in argument.Options)
                 {
-                    subCommand.Handler = new PretzelCommandHandler(Configuration, null, command);
+                    subCommand.AddOption(option);
                 }
 
+                subCommand.Handler = new PretzelCommandHandler(Configuration, argument, command);
+
                 RootCommand.AddCommand(subCommand);
             }
         }
diff --git a/src/Pretzel/Commands/HungryCommand.cs b/src/Pretzel/Commands/HungryCommand.cs
index 34a0dfae1..910de12bd 100644
--- a/src/Pretzel/Commands/HungryCommand.cs
+++ b/src/Pretzel/Commands/HungryCommand.cs
@@ -8,6 +8,9 @@
 
 namespace Pretzel.Commands
 {
+    [Shared]
+    [Export]
+    [CommandArguments]
     public class HungryCommandArguments : BaseCommandArguments
     {
         protected override IEnumerable<Option> CreateOptions() => Array.Empty<Option>();
@@ -15,7 +18,11 @@ public class HungryCommandArguments : BaseCommandArguments
 
     [Shared]
     [Export]
-    [CommandInfo(CommandName = BuiltInCommands.Hungry, CommandDescription = "use only when hungry")]
+    [CommandInfo(
+        CommandName = BuiltInCommands.Hungry,
+        CommandDescription = "use only when hungry",
+        CommandArgumentsType = typeof(HungryCommandArguments)
+        )]
     public sealed class HungryCommand : Command<HungryCommandArguments>
     {
         private readonly string recipe = @"===== Ingredients ======
diff --git a/src/Pretzel/Commands/ImportCommand.cs b/src/Pretzel/Commands/ImportCommand.cs
index bbdf8083d..729b9e4cb 100644
--- a/src/Pretzel/Commands/ImportCommand.cs
+++ b/src/Pretzel/Commands/ImportCommand.cs
@@ -13,7 +13,7 @@ namespace Pretzel.Commands
 {
     [Export]
     [Shared]
-    [CommandArguments(CommandName = BuiltInCommands.Import)]
+    [CommandArguments]
     public class ImportCommandArguments : PretzelBaseCommandArguments
     {
         [ImportingConstructor]
@@ -37,7 +37,11 @@ protected override IEnumerable<Option> CreateOptions() => base.CreateOptions().C
     }
 
     [Shared]
-    [CommandInfo(CommandName = BuiltInCommands.Import, CommandDescription = "import posts from external source")]
+    [CommandInfo(
+        CommandName = BuiltInCommands.Import,
+        CommandDescription = "import posts from external source",
+        CommandArgumentsType = typeof(ImportCommandArguments)
+        )]
     class ImportCommand : Command<ImportCommandArguments>
     {
         readonly static List<string> Importers = new List<string>(new[] { "wordpress", "blogger" });
diff --git a/src/Pretzel/Commands/IngredientCommand.cs b/src/Pretzel/Commands/IngredientCommand.cs
index e2fe93a7e..19b7f076c 100644
--- a/src/Pretzel/Commands/IngredientCommand.cs
+++ b/src/Pretzel/Commands/IngredientCommand.cs
@@ -13,7 +13,7 @@ namespace Pretzel.Commands
 {
     [Export]
     [Shared]
-    [CommandArguments(CommandName = BuiltInCommands.Ingredient)]
+    [CommandArguments]
     public class IngredientCommandArguments : PretzelBaseCommandArguments
     {
         [ImportingConstructor]
@@ -31,7 +31,10 @@ protected override IEnumerable<Option> CreateOptions() => base.CreateOptions().C
     }
 
     [Shared]
-    [CommandInfo(CommandName = BuiltInCommands.Ingredient, CommandDescription = "create a new post")]
+    [CommandInfo(
+        CommandName = BuiltInCommands.Ingredient,
+        CommandDescription = "create a new post",
+        CommandArgumentsType = typeof(IngredientCommandArguments))]
     public sealed class IngredientCommand : Command<IngredientCommandArguments>
     {
         [Import]
diff --git a/src/Pretzel/Commands/RecipeCommand.cs b/src/Pretzel/Commands/RecipeCommand.cs
index 55da89dab..a3f6c88c2 100644
--- a/src/Pretzel/Commands/RecipeCommand.cs
+++ b/src/Pretzel/Commands/RecipeCommand.cs
@@ -14,7 +14,7 @@ namespace Pretzel.Commands
 {
     [Export]
     [Shared]
-    [CommandArguments(CommandName = BuiltInCommands.Create)]
+    [CommandArguments]
     public class RecipeCommandArguments : PretzelBaseCommandArguments
     {
         [ImportingConstructor]
@@ -37,7 +37,11 @@ protected override IEnumerable<Option> CreateOptions() => base.CreateOptions().C
     }
 
     [Shared]
-    [CommandInfo(CommandName = BuiltInCommands.Create, CommandDescription = "configure a new site")]
+    [CommandInfo(
+        CommandName = BuiltInCommands.Create,
+        CommandDescription = "configure a new site",
+        CommandArgumentsType = typeof(RecipeCommandArguments)
+        )]
     public sealed class RecipeCommand : Command<RecipeCommandArguments>
     {
         private static readonly List<string> TemplateEngines = new List<string>(new[] { "Liquid", "Razor" });
diff --git a/src/Pretzel/Commands/TasteCommand.cs b/src/Pretzel/Commands/TasteCommand.cs
index 2c867168c..f6cf90ab5 100644
--- a/src/Pretzel/Commands/TasteCommand.cs
+++ b/src/Pretzel/Commands/TasteCommand.cs
@@ -17,7 +17,7 @@ namespace Pretzel.Commands
 {
     [Export]
     [Shared]
-    [CommandArguments(CommandName = BuiltInCommands.Taste)]
+    [CommandArguments]
     public class TasteCommandArguments : BakeBaseCommandArguments
     {
         [ImportingConstructor]
@@ -41,7 +41,11 @@ protected override IEnumerable<Option> CreateOptions() => base.CreateOptions().C
     }
 
     [Shared]
-    [CommandInfo(CommandName = BuiltInCommands.Taste, CommandDescription = "testing a site locally")]
+    [CommandInfo(
+        CommandName = BuiltInCommands.Taste,
+        CommandDescription = "testing a site locally",
+        CommandArgumentsType = typeof(TasteCommandArguments)
+        )]
     public sealed class TasteCommand : Command<TasteCommandArguments>
     {
         private ISiteEngine engine;
diff --git a/src/Pretzel/Commands/VersionCommand.cs b/src/Pretzel/Commands/VersionCommand.cs
index 80d0bae8a..2491eeded 100644
--- a/src/Pretzel/Commands/VersionCommand.cs
+++ b/src/Pretzel/Commands/VersionCommand.cs
@@ -9,13 +9,20 @@
 
 namespace Pretzel.Commands
 {
+    [Shared]
+    [Export]
+    [CommandArguments]
     public class VersionCommandArguments : BaseCommandArguments
     {
         protected override IEnumerable<Option> CreateOptions() => Array.Empty<Option>();
     }
 
     [Shared]
-    [CommandInfo(CommandName = BuiltInCommands.Version, CommandDescription = "display current Pretzel version")]
+    [CommandInfo(
+        CommandName = BuiltInCommands.Version,
+        CommandDescription = "display current Pretzel version",
+        CommandArgumentsType = typeof(VersionCommandArguments)
+        )]
     public sealed class VersionCommand : Command<VersionCommandArguments>
     {
         protected override Task<int> Execute(VersionCommandArguments arguments)

From 51fe94048624d9482dc3752ec068699ac943d95f Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Mon, 30 Sep 2019 14:32:53 +0200
Subject: [PATCH 41/56] refactor: CommandArgumentExtenders now need to provide
 own options

---
 src/Pretzel.Logic/Commands/ICommandArguments.cs   |  2 +-
 .../Extensibility/Extensions/AzureHostSupport.cs  | 11 +++++------
 .../Extensions/VirtualDirectorySupport.cs         |  9 +++++----
 .../Extensibility/ICommandArgumentsExtension.cs   | 15 ++++++++++++++-
 .../Commands/CommandCollectionTests.cs            | 12 +++---------
 .../Commands/PretzelCommandHandlerTests.cs        |  5 +----
 src/Pretzel/Commands/CommandCollection.cs         |  3 ++-
 7 files changed, 31 insertions(+), 26 deletions(-)

diff --git a/src/Pretzel.Logic/Commands/ICommandArguments.cs b/src/Pretzel.Logic/Commands/ICommandArguments.cs
index 464ff0a36..771b49389 100644
--- a/src/Pretzel.Logic/Commands/ICommandArguments.cs
+++ b/src/Pretzel.Logic/Commands/ICommandArguments.cs
@@ -5,7 +5,7 @@
 namespace Pretzel.Logic.Commands
 {
     /// <summary>
-    /// All commands can have 1 command argument
+    /// Specifies a command argument for a single command. Implementors should be decorated with the <see cref="CommandArgumentsAttribute"/>
     /// </summary>
     public interface ICommandArguments
     {
diff --git a/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs b/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs
index 523a9ca12..8ad7f7aa9 100644
--- a/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs
+++ b/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs
@@ -14,20 +14,19 @@ namespace Pretzel.Logic.Extensibility.Extensions
     [CommandArgumentsExtension(CommandNames = new[] { BuiltInCommands.Create })]
     public class AzureHostSupportArguments : ICommandArgumentsExtension
     {
-        public void UpdateOptions(IList<Option> options)
+        public IList<Option> Options { get; } = new[]
         {
-            options.Add(new Option("azure", "Enables deploy to azure support")
+            new Option("azure", "Enables deploy to azure support")
             {
                 Argument = new Argument<bool>()
-            });
-        }
-
-        public bool Azure { get; set; }
+            }
+        };
 
         public void BindingCompleted()
         {
             //Not used
         }
+        public bool Azure { get; set; }
     }
 
     [Export(typeof(IAdditionalIngredient))]
diff --git a/src/Pretzel.Logic/Extensibility/Extensions/VirtualDirectorySupport.cs b/src/Pretzel.Logic/Extensibility/Extensions/VirtualDirectorySupport.cs
index 8d5363fae..530a44f65 100644
--- a/src/Pretzel.Logic/Extensibility/Extensions/VirtualDirectorySupport.cs
+++ b/src/Pretzel.Logic/Extensibility/Extensions/VirtualDirectorySupport.cs
@@ -14,13 +14,13 @@ namespace Pretzel.Logic.Extensibility.Extensions
     [CommandArgumentsExtension(CommandNames = new[] { BuiltInCommands.Bake, BuiltInCommands.Taste })]
     public class VirtualDirectorySupportArguments : ICommandArgumentsExtension
     {
-        public void UpdateOptions(IList<Option> options)
+        public IList<Option> Options { get; } = new[]
         {
-            options.Add(new Option(new [] { "-vDir", "--virtualdirectory"}, "Rewrite url's to work inside the specified virtual directory")
+            new Option(new [] { "-vDir", "--virtualdirectory"}, "Rewrite url's to work inside the specified virtual directory")
             {
                 Argument = new Argument<string>()
-            });
-        }
+            }
+        };
 
         public void BindingCompleted()
         {
@@ -28,6 +28,7 @@ public void BindingCompleted()
         }
 
         public string VirtualDirectory { get; set; }
+
     }
 
     [Export(typeof(ITransform))]
diff --git a/src/Pretzel.Logic/Extensibility/ICommandArgumentsExtension.cs b/src/Pretzel.Logic/Extensibility/ICommandArgumentsExtension.cs
index d46074964..249089415 100644
--- a/src/Pretzel.Logic/Extensibility/ICommandArgumentsExtension.cs
+++ b/src/Pretzel.Logic/Extensibility/ICommandArgumentsExtension.cs
@@ -4,10 +4,23 @@
 
 namespace Pretzel.Logic.Extensibility
 {
+    /// <summary>
+    /// Specifies a command arguments extention. Implementors should be decorated with the <see cref="CommandArgumentsExtensionAttribute"/>
+    /// </summary>
     public interface ICommandArgumentsExtension
     {
-        void UpdateOptions(IList<Option> options);
+        /// <summary>
+        /// A list of option that will be used as command line options
+        /// </summary>
+        /// <value>
+        /// The options.
+        /// </value>
+        IList<Option> Options { get; }
 
+        /// <summary>
+        /// Once the command arguments are bound with values from the command line, this method gets called.
+        /// Useful for validation or argument customization before being used by a command
+        /// </summary>
         void BindingCompleted();
     }
 }
diff --git a/src/Pretzel.Tests/Commands/CommandCollectionTests.cs b/src/Pretzel.Tests/Commands/CommandCollectionTests.cs
index 7e59dc7e4..9b89fdb5f 100644
--- a/src/Pretzel.Tests/Commands/CommandCollectionTests.cs
+++ b/src/Pretzel.Tests/Commands/CommandCollectionTests.cs
@@ -196,9 +196,7 @@ public Task<int> Execute(ICommandArguments arguments)
             [CommandArgumentsExtension(CommandNames = new[] { "test1" })]
             public class Extender1 : ICommandArgumentsExtension
             {
-                public void UpdateOptions(IList<Option> options)
-                {
-                }
+                public IList<Option> Options { get; } = Array.Empty<Option>();
 
                 public void BindingCompleted()
                 {
@@ -208,9 +206,7 @@ public void BindingCompleted()
             [CommandArgumentsExtension(CommandNames = new[] { "test2" })]
             public class Extender2 : ICommandArgumentsExtension
             {
-                public void UpdateOptions(IList<Option> options)
-                {
-                }
+                public IList<Option> Options { get; } = Array.Empty<Option>();
 
                 public void BindingCompleted()
                 {
@@ -220,9 +216,7 @@ public void BindingCompleted()
             [CommandArgumentsExtension(CommandNames = new[] { "test1", "test2" })]
             public class Extender3 : ICommandArgumentsExtension
             {
-                public void UpdateOptions(IList<Option> options)
-                {
-                }
+                public IList<Option> Options { get; } = Array.Empty<Option>();
 
                 public void BindingCompleted()
                 {
diff --git a/src/Pretzel.Tests/Commands/PretzelCommandHandlerTests.cs b/src/Pretzel.Tests/Commands/PretzelCommandHandlerTests.cs
index 272f5da30..7206c1a9f 100644
--- a/src/Pretzel.Tests/Commands/PretzelCommandHandlerTests.cs
+++ b/src/Pretzel.Tests/Commands/PretzelCommandHandlerTests.cs
@@ -119,10 +119,7 @@ public void BindingCompleted()
                     BindingCompletedCalled = true;
                 }
 
-                public void UpdateOptions(IList<Option> options)
-                {
-                    throw new NotImplementedException();
-                }
+                public IList<Option> Options { get; } = Array.Empty<Option>();
 
                 public bool OtherOption { get; set; }
             }
diff --git a/src/Pretzel/Commands/CommandCollection.cs b/src/Pretzel/Commands/CommandCollection.cs
index 1c12d9f22..0185aa7ac 100644
--- a/src/Pretzel/Commands/CommandCollection.cs
+++ b/src/Pretzel/Commands/CommandCollection.cs
@@ -66,7 +66,8 @@ internal void OnImportsSatisfied()
 
                 foreach (var arugumentExtension in argument.Extensions)
                 {
-                    arugumentExtension.UpdateOptions(argument.Options);
+                    foreach (var option in arugumentExtension.Options)
+                        argument.Options.Add(option);
                 }
 
                 foreach (var option in argument.Options)

From cd5905f58d9ffbe72f9732667fd8a8ab86a072fb Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Mon, 30 Sep 2019 14:49:19 +0200
Subject: [PATCH 42/56] test: command argument extentsion tests

---
 .../Extensions/AzureHostSupport.cs            |  2 +-
 .../Extensions/VirtualDirectorySupport.cs     |  2 +-
 ...ts.cs => BakeBaseCommandArgumentsTests.cs} |  4 +-
 ...sTests.cs => BakeCommandArgumentsTests.cs} |  4 +-
 .../Commands/BaseCommandArgumentsTests.cs     | 70 +++++++++++++++++++
 .../Commands/BaseParametersTests.cs           | 38 ----------
 ...ests.cs => ImportCommandArgumentsTests.cs} |  8 +--
 ....cs => IngredientCommandArgumentsTests.cs} |  8 +--
 src/Pretzel.Tests/Commands/ParametersTests.cs | 38 ----------
 ...cs => PretzelBaseCommandArgumentsTests.cs} | 24 +++----
 ...ests.cs => RecipeCommandArgumentsTests.cs} |  8 +--
 ...Tests.cs => TasteCommandArgumentsTests.cs} | 12 ++--
 .../AzureHostSupportArgumentsTests.cs         | 21 ++++++
 .../CommandArgumentsExtensionTests.cs         | 36 ++++++++++
 .../VirtualDirectorySupportArgumentsTests.cs  | 15 +++-
 15 files changed, 177 insertions(+), 113 deletions(-)
 rename src/Pretzel.Tests/Commands/{BakeBaseCommandParametersTests.cs => BakeBaseCommandArgumentsTests.cs} (71%)
 rename src/Pretzel.Tests/Commands/{BakeCommandParametersTests.cs => BakeCommandArgumentsTests.cs} (50%)
 create mode 100644 src/Pretzel.Tests/Commands/BaseCommandArgumentsTests.cs
 delete mode 100644 src/Pretzel.Tests/Commands/BaseParametersTests.cs
 rename src/Pretzel.Tests/Commands/{ImportCommandParametersTests.cs => ImportCommandArgumentsTests.cs} (68%)
 rename src/Pretzel.Tests/Commands/{IngredientCommandParametersTests.cs => IngredientCommandArgumentsTests.cs} (66%)
 delete mode 100644 src/Pretzel.Tests/Commands/ParametersTests.cs
 rename src/Pretzel.Tests/Commands/{PetzelBaseCommandParametersTests.cs => PretzelBaseCommandArgumentsTests.cs} (89%)
 rename src/Pretzel.Tests/Commands/{RecipeCommandParametersTests.cs => RecipeCommandArgumentsTests.cs} (69%)
 rename src/Pretzel.Tests/Commands/{TasteCommandParametersTests.cs => TasteCommandArgumentsTests.cs} (69%)
 create mode 100644 src/Pretzel.Tests/Extensibility/Extensions/AzureHostSupportArgumentsTests.cs
 create mode 100644 src/Pretzel.Tests/Extensibility/Extensions/CommandArgumentsExtensionTests.cs

diff --git a/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs b/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs
index 8ad7f7aa9..59bdd2423 100644
--- a/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs
+++ b/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs
@@ -16,7 +16,7 @@ public class AzureHostSupportArguments : ICommandArgumentsExtension
     {
         public IList<Option> Options { get; } = new[]
         {
-            new Option("azure", "Enables deploy to azure support")
+            new Option(new [] { "--azure", "-azure" }, "Enables deploy to azure support")
             {
                 Argument = new Argument<bool>()
             }
diff --git a/src/Pretzel.Logic/Extensibility/Extensions/VirtualDirectorySupport.cs b/src/Pretzel.Logic/Extensibility/Extensions/VirtualDirectorySupport.cs
index 530a44f65..84e958805 100644
--- a/src/Pretzel.Logic/Extensibility/Extensions/VirtualDirectorySupport.cs
+++ b/src/Pretzel.Logic/Extensibility/Extensions/VirtualDirectorySupport.cs
@@ -16,7 +16,7 @@ public class VirtualDirectorySupportArguments : ICommandArgumentsExtension
     {
         public IList<Option> Options { get; } = new[]
         {
-            new Option(new [] { "-vDir", "--virtualdirectory"}, "Rewrite url's to work inside the specified virtual directory")
+            new Option(new [] { "--virtualdirectory", "-vDir" }, "Rewrite url's to work inside the specified virtual directory")
             {
                 Argument = new Argument<string>()
             }
diff --git a/src/Pretzel.Tests/Commands/BakeBaseCommandParametersTests.cs b/src/Pretzel.Tests/Commands/BakeBaseCommandArgumentsTests.cs
similarity index 71%
rename from src/Pretzel.Tests/Commands/BakeBaseCommandParametersTests.cs
rename to src/Pretzel.Tests/Commands/BakeBaseCommandArgumentsTests.cs
index a74709d37..3ce0280eb 100644
--- a/src/Pretzel.Tests/Commands/BakeBaseCommandParametersTests.cs
+++ b/src/Pretzel.Tests/Commands/BakeBaseCommandArgumentsTests.cs
@@ -5,7 +5,7 @@
 
 namespace Pretzel.Tests.Commands
 {
-    public abstract class BakeBaseCommandParametersTests<T> : PretzelBaseCommandParametersTests<T>
+    public abstract class BakeBaseCommandArgumentsTests<T> : PretzelBaseCommandArgumentsTests<T>
         where T : BakeBaseCommandArguments
     {
         [Theory]
@@ -13,7 +13,7 @@ public abstract class BakeBaseCommandParametersTests<T> : PretzelBaseCommandPara
         [InlineData("--cleantarget")]
         public void CleanTarget(string argument)
         {
-            var sut = BuildParameters(argument);
+            var sut = BuildArguments(argument);
 
             Assert.True(sut.CleanTarget);
         }  
diff --git a/src/Pretzel.Tests/Commands/BakeCommandParametersTests.cs b/src/Pretzel.Tests/Commands/BakeCommandArgumentsTests.cs
similarity index 50%
rename from src/Pretzel.Tests/Commands/BakeCommandParametersTests.cs
rename to src/Pretzel.Tests/Commands/BakeCommandArgumentsTests.cs
index 8e5c9ce68..fa58ec78a 100644
--- a/src/Pretzel.Tests/Commands/BakeCommandParametersTests.cs
+++ b/src/Pretzel.Tests/Commands/BakeCommandArgumentsTests.cs
@@ -5,9 +5,9 @@
 
 namespace Pretzel.Tests.Commands
 {
-    public class BakeCommandParametersTests : BakeBaseCommandParametersTests<BakeCommandArguments>
+    public class BakeCommandArgumentsTests : BakeBaseCommandArgumentsTests<BakeCommandArguments>
     {
-        protected override BakeCommandArguments CreateParameters(IFileSystem fileSystem)
+        protected override BakeCommandArguments CreateArguments(IFileSystem fileSystem)
             => new BakeCommandArguments(fileSystem);
     }
 }
diff --git a/src/Pretzel.Tests/Commands/BaseCommandArgumentsTests.cs b/src/Pretzel.Tests/Commands/BaseCommandArgumentsTests.cs
new file mode 100644
index 000000000..0d913aa4d
--- /dev/null
+++ b/src/Pretzel.Tests/Commands/BaseCommandArgumentsTests.cs
@@ -0,0 +1,70 @@
+using System;
+using System.Collections.Generic;
+using System.CommandLine;
+using System.CommandLine.Binding;
+using System.CommandLine.Invocation;
+using System.Composition;
+using System.Composition.Hosting;
+using System.IO.Abstractions;
+using System.IO.Abstractions.TestingHelpers;
+using System.Linq;
+using NSubstitute;
+using Pretzel.Logic.Commands;
+using Xunit;
+
+namespace Pretzel.Tests.Commands
+{
+    public class BaseCommandArgumentsTests
+    {
+        [Export]
+        [Shared]
+        [CommandArguments]
+        public class BaseCommandArgumentsImpl : BaseCommandArguments
+        {
+            protected override IEnumerable<Option> CreateOptions() => new[]
+            {
+                new Option("-base")
+            };
+        }
+        
+        [Fact]
+        public void ExtentionIsPossible()
+        {
+            var configuration = new ContainerConfiguration();
+            configuration.WithPart<BaseCommandArgumentsImpl>();
+            using(var container = configuration.CreateContainer())
+            {
+                var sut = container.GetExport<BaseCommandArgumentsImpl>();
+                sut.BuildOptions();
+                Assert.NotNull(sut.Options);
+                Assert.Equal(1, sut.Options.Count);
+            }
+        }
+    }
+
+    public abstract class BaseCommandArgumentsTests<T> where T : BaseCommandArguments
+    {
+        readonly IConsole Console = Substitute.For<IConsole>();
+        protected readonly MockFileSystem fileSystem = new MockFileSystem();
+        protected abstract T CreateArguments(IFileSystem fileSystem);
+        protected T BuildArguments(params string[] args)
+        {
+            var rootCommand = new RootCommand();
+
+            var arguments = CreateArguments(fileSystem);
+            arguments.BuildOptions();
+
+            foreach (var option in arguments.Options)
+                rootCommand.AddOption(option);
+
+            var context = new InvocationContext(new Parser(rootCommand).Parse(args), Console);
+
+            new ModelBinder(arguments.GetType())
+                .UpdateInstance(arguments, context.BindingContext);
+
+            arguments.BindingCompleted();
+
+            return arguments;
+        }
+    }
+}
diff --git a/src/Pretzel.Tests/Commands/BaseParametersTests.cs b/src/Pretzel.Tests/Commands/BaseParametersTests.cs
deleted file mode 100644
index 3882c7206..000000000
--- a/src/Pretzel.Tests/Commands/BaseParametersTests.cs
+++ /dev/null
@@ -1,38 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.CommandLine;
-using System.Composition;
-using System.Composition.Hosting;
-using System.Linq;
-using Pretzel.Logic.Commands;
-using Xunit;
-
-namespace Pretzel.Tests.Commands
-{
-    public class BaseParametersTests
-    {
-        [Export]
-        [Shared]
-        [CommandArguments]
-        public class BaseParametersImpl : BaseCommandArguments
-        {
-            protected override IEnumerable<Option> CreateOptions() => new[]
-            {
-                new Option("-base")
-            };
-        }
-        
-        [Fact]
-        public void ExtentionIsPossible()
-        {
-            var configuration = new ContainerConfiguration();
-            configuration.WithPart<BaseParametersImpl>();
-            using(var container = configuration.CreateContainer())
-            {
-                var sut = container.GetExport<BaseParametersImpl>();
-
-                Assert.NotNull(sut.Options);
-            }
-        }
-    }
-}
diff --git a/src/Pretzel.Tests/Commands/ImportCommandParametersTests.cs b/src/Pretzel.Tests/Commands/ImportCommandArgumentsTests.cs
similarity index 68%
rename from src/Pretzel.Tests/Commands/ImportCommandParametersTests.cs
rename to src/Pretzel.Tests/Commands/ImportCommandArgumentsTests.cs
index afa4bec6e..bf9350a33 100644
--- a/src/Pretzel.Tests/Commands/ImportCommandParametersTests.cs
+++ b/src/Pretzel.Tests/Commands/ImportCommandArgumentsTests.cs
@@ -6,9 +6,9 @@
 
 namespace Pretzel.Tests.Commands
 {
-    public class ImportCommandParametersTests : PretzelBaseCommandParametersTests<ImportCommandArguments>
+    public class ImportCommandArgumentsTests : PretzelBaseCommandArgumentsTests<ImportCommandArguments>
     {
-        protected override ImportCommandArguments CreateParameters(IFileSystem fileSystem)
+        protected override ImportCommandArguments CreateArguments(IFileSystem fileSystem)
             => new ImportCommandArguments(fileSystem);
 
         [Theory]
@@ -16,7 +16,7 @@ protected override ImportCommandArguments CreateParameters(IFileSystem fileSyste
         [InlineData("-i", "bar")]
         public void ImportType(string argument, string expectedValue)
         {
-            var sut = BuildParameters(argument, expectedValue);
+            var sut = BuildArguments(argument, expectedValue);
 
             Assert.Equal(expectedValue, sut.ImportType);
         }
@@ -26,7 +26,7 @@ public void ImportType(string argument, string expectedValue)
         [InlineData("-f", "buzz")]
         public void ImportFile(string argument, string expectedValue)
         {
-            var sut = BuildParameters(argument, expectedValue);
+            var sut = BuildArguments(argument, expectedValue);
 
             Assert.Equal(expectedValue, sut.ImportFile);
         }
diff --git a/src/Pretzel.Tests/Commands/IngredientCommandParametersTests.cs b/src/Pretzel.Tests/Commands/IngredientCommandArgumentsTests.cs
similarity index 66%
rename from src/Pretzel.Tests/Commands/IngredientCommandParametersTests.cs
rename to src/Pretzel.Tests/Commands/IngredientCommandArgumentsTests.cs
index e5c99a604..93c8a8a5d 100644
--- a/src/Pretzel.Tests/Commands/IngredientCommandParametersTests.cs
+++ b/src/Pretzel.Tests/Commands/IngredientCommandArgumentsTests.cs
@@ -6,9 +6,9 @@
 
 namespace Pretzel.Tests.Commands
 {
-    public class IngredientCommandParametersTests : PretzelBaseCommandParametersTests<IngredientCommandArguments>
+    public class IngredientCommandArgumentsTests : PretzelBaseCommandArgumentsTests<IngredientCommandArguments>
     {
-        protected override IngredientCommandArguments CreateParameters(IFileSystem fileSystem)
+        protected override IngredientCommandArguments CreateArguments(IFileSystem fileSystem)
             => new IngredientCommandArguments(fileSystem);
 
         [Theory]
@@ -16,7 +16,7 @@ protected override IngredientCommandArguments CreateParameters(IFileSystem fileS
         [InlineData("-n", "This is the second blog")]
         public void NewPostTitle(string argument, string value)
         {
-            var sut = BuildParameters(argument, value);
+            var sut = BuildArguments(argument, value);
 
             Assert.Equal(value, sut.NewPostTitle);
         }
@@ -24,7 +24,7 @@ public void NewPostTitle(string argument, string value)
         [Fact]
         public void NewPostTitleDefaultValue()
         {
-            var sut = BuildParameters();
+            var sut = BuildArguments();
 
             Assert.Equal("New post", sut.NewPostTitle);
         }
diff --git a/src/Pretzel.Tests/Commands/ParametersTests.cs b/src/Pretzel.Tests/Commands/ParametersTests.cs
deleted file mode 100644
index 983ffc9ba..000000000
--- a/src/Pretzel.Tests/Commands/ParametersTests.cs
+++ /dev/null
@@ -1,38 +0,0 @@
-using System;
-using System.CommandLine;
-using System.CommandLine.Binding;
-using System.CommandLine.Invocation;
-using System.IO.Abstractions;
-using System.IO.Abstractions.TestingHelpers;
-using System.Linq;
-using NSubstitute;
-using Pretzel.Logic.Commands;
-
-namespace Pretzel.Tests.Commands
-{
-    public abstract class ParametersTests<T> where T : BaseCommandArguments
-    {
-        readonly IConsole Console = Substitute.For<IConsole>();
-        protected readonly MockFileSystem fileSystem = new MockFileSystem();
-        protected abstract T CreateParameters(IFileSystem fileSystem);
-        protected T BuildParameters(params string[] args)
-        {
-            var rootCommand = new RootCommand();
-
-            var parameters = CreateParameters(fileSystem);
-            parameters.BuildOptions();
-
-            foreach (var option in parameters.Options)
-                rootCommand.AddOption(option);
-
-            var context = new InvocationContext(new Parser(rootCommand).Parse(args), Console);
-
-            new ModelBinder(parameters.GetType())
-                .UpdateInstance(parameters, context.BindingContext);
-
-            parameters.BindingCompleted();
-
-            return parameters;
-        }
-    }
-}
diff --git a/src/Pretzel.Tests/Commands/PetzelBaseCommandParametersTests.cs b/src/Pretzel.Tests/Commands/PretzelBaseCommandArgumentsTests.cs
similarity index 89%
rename from src/Pretzel.Tests/Commands/PetzelBaseCommandParametersTests.cs
rename to src/Pretzel.Tests/Commands/PretzelBaseCommandArgumentsTests.cs
index 8bcb41e84..e999c1def 100644
--- a/src/Pretzel.Tests/Commands/PetzelBaseCommandParametersTests.cs
+++ b/src/Pretzel.Tests/Commands/PretzelBaseCommandArgumentsTests.cs
@@ -10,14 +10,14 @@
 
 namespace Pretzel.Tests.Commands
 {
-    public abstract class PretzelBaseCommandParametersTests<T> : ParametersTests<T>
+    public abstract class PretzelBaseCommandArgumentsTests<T> : BaseCommandArgumentsTests<T>
         where T : PretzelBaseCommandArguments
     {
         [Theory]
         [InlineData("--drafts")]
         public void Drafts(string argument)
         {
-            var sut = BuildParameters(argument);
+            var sut = BuildArguments(argument);
 
             Assert.True(sut.Drafts);
         }
@@ -27,7 +27,7 @@ public void Drafts(string argument)
         [InlineData("--template", "razor")]
         public void Template(string argument, string value)
         {
-            var sut = BuildParameters(argument, value);
+            var sut = BuildArguments(argument, value);
 
             Assert.Equal(value, sut.Template);
         }
@@ -37,7 +37,7 @@ public void Template(string argument, string value)
         [InlineData("--destination", "bar/mySite")]
         public void Destination(string argument, string value)
         {
-            var sut = BuildParameters(argument, value);
+            var sut = BuildArguments(argument, value);
 
             Assert.Equal(fileSystem.Path.Combine(sut.Source, value), sut.Destination);
         }
@@ -46,7 +46,7 @@ public void Destination(string argument, string value)
         [InlineData("-d", @"c:\tmp\_site")]
         public void DestinationRooted(string argument, string value)
         {
-            var sut = BuildParameters(argument, value);
+            var sut = BuildArguments(argument, value);
 
             Assert.Equal(value, sut.Destination);
         }
@@ -54,7 +54,7 @@ public void DestinationRooted(string argument, string value)
         [Fact]
         public void DestinationEmpty()
         {
-            var sut = BuildParameters("-d");
+            var sut = BuildArguments("-d");
 
             Assert.Equal(fileSystem.Path.Combine(sut.Source, "_site"), sut.Destination);
         }
@@ -62,7 +62,7 @@ public void DestinationEmpty()
         [Fact]
         public void DestinationDefaultValue()
         {
-            var sut = BuildParameters();
+            var sut = BuildArguments();
 
             Assert.Equal(fileSystem.Path.Combine(sut.Source, "_site"), sut.Destination);
         }
@@ -70,7 +70,7 @@ public void DestinationDefaultValue()
         [Fact]
         public void DetectFromDirectory_WhenSpecifyingNoSiteEngines_DefaultValueIsLiquid()
         {
-            var sut = BuildParameters();
+            var sut = BuildArguments();
 
             var siteContext = new SiteContext();
 
@@ -82,7 +82,7 @@ public void DetectFromDirectory_WhenSpecifyingNoSiteEngines_DefaultValueIsLiquid
         [Fact]
         public void DetectFromDirectory_WhenSpecifyingTwoSiteEngines_CorrectValueIsPicked()
         {
-            var sut = BuildParameters();
+            var sut = BuildArguments();
 
             var siteContext = new SiteContext { Config = new ConfigurationMock(new Dictionary<string, object> { { "pretzel", new Dictionary<string, object> { { "engine", "engine2" } } } }) };
 
@@ -108,7 +108,7 @@ public void DetectFromDirectory_WhenSpecifyingTwoSiteEngines_CorrectValueIsPicke
         [Fact]
         public void DetectFromDirectory_WhenSpecifyingNoPretzelConfig_DefaultValueIsLiquid()
         {
-            var sut = BuildParameters();
+            var sut = BuildArguments();
 
             var siteContext = new SiteContext { Config = new Configuration() };
 
@@ -129,7 +129,7 @@ public void DetectFromDirectory_WhenSpecifyingNoPretzelConfig_DefaultValueIsLiqu
         [Fact]
         public void DetectFromDirectory_WhenSpecifyingNoEnginInPretzelConfig_DefaultValueIsLiquid()
         {
-            var sut = BuildParameters();
+            var sut = BuildArguments();
 
             var siteContext = new SiteContext { Config = new ConfigurationMock(new Dictionary<string, object> { { "pretzel", new Dictionary<string, object> { } } }) };
 
@@ -150,7 +150,7 @@ public void DetectFromDirectory_WhenSpecifyingNoEnginInPretzelConfig_DefaultValu
         [Fact]
         public void DetectFromDirectory_WhenSpecifyingPretzelConfigSimpleValue_DefaultValueIsLiquid()
         {
-            var sut = BuildParameters();
+            var sut = BuildArguments();
 
             var siteContext = new SiteContext { Config = new ConfigurationMock(new Dictionary<string, object> { { "pretzel", 42 } }) };
 
diff --git a/src/Pretzel.Tests/Commands/RecipeCommandParametersTests.cs b/src/Pretzel.Tests/Commands/RecipeCommandArgumentsTests.cs
similarity index 69%
rename from src/Pretzel.Tests/Commands/RecipeCommandParametersTests.cs
rename to src/Pretzel.Tests/Commands/RecipeCommandArgumentsTests.cs
index 49190011f..df3091698 100644
--- a/src/Pretzel.Tests/Commands/RecipeCommandParametersTests.cs
+++ b/src/Pretzel.Tests/Commands/RecipeCommandArgumentsTests.cs
@@ -6,9 +6,9 @@
 
 namespace Pretzel.Tests.Commands
 {
-    public class RecipeCommandParametersTests : PretzelBaseCommandParametersTests<RecipeCommandArguments>
+    public class RecipeCommandArgumentsTests : PretzelBaseCommandArgumentsTests<RecipeCommandArguments>
     {
-        protected override RecipeCommandArguments CreateParameters(IFileSystem fileSystem)
+        protected override RecipeCommandArguments CreateArguments(IFileSystem fileSystem)
             => new RecipeCommandArguments(fileSystem);
 
         [Theory]
@@ -16,7 +16,7 @@ protected override RecipeCommandArguments CreateParameters(IFileSystem fileSyste
         [InlineData("", false)]
         public void WithWiki(string argument, bool expectedValue)
         {
-            var sut = BuildParameters(argument);
+            var sut = BuildArguments(argument);
 
             Assert.Equal(expectedValue, sut.Wiki);
         }
@@ -26,7 +26,7 @@ public void WithWiki(string argument, bool expectedValue)
         [InlineData("", false)]
         public void WithProject(string argument, bool expectedValue)
         {
-            var sut = BuildParameters(argument);
+            var sut = BuildArguments(argument);
 
             Assert.Equal(expectedValue, sut.WithProject);
         }
diff --git a/src/Pretzel.Tests/Commands/TasteCommandParametersTests.cs b/src/Pretzel.Tests/Commands/TasteCommandArgumentsTests.cs
similarity index 69%
rename from src/Pretzel.Tests/Commands/TasteCommandParametersTests.cs
rename to src/Pretzel.Tests/Commands/TasteCommandArgumentsTests.cs
index f8982a71a..40f4f7c07 100644
--- a/src/Pretzel.Tests/Commands/TasteCommandParametersTests.cs
+++ b/src/Pretzel.Tests/Commands/TasteCommandArgumentsTests.cs
@@ -6,16 +6,16 @@
 
 namespace Pretzel.Tests.Commands
 {
-    public class TasteCommandParametersTests : BakeBaseCommandParametersTests<TasteCommandArguments>
+    public class TasteCommandArgumentsTests : BakeBaseCommandArgumentsTests<TasteCommandArguments>
     {
-        protected override TasteCommandArguments CreateParameters(IFileSystem fileSystem)
+        protected override TasteCommandArguments CreateArguments(IFileSystem fileSystem)
             => new TasteCommandArguments(fileSystem);
 
         [Theory]
         [InlineData("--nobrowser", true)]
         public void NoBrowser(string argument, bool expectedValue)
         {
-            var sut = BuildParameters(argument, expectedValue.ToString());
+            var sut = BuildArguments(argument, expectedValue.ToString());
 
             Assert.Equal(expectedValue, sut.NoBrowser);
             Assert.Equal(!expectedValue, sut.LaunchBrowser);
@@ -24,7 +24,7 @@ public void NoBrowser(string argument, bool expectedValue)
         [Fact]
         public void NoBrowserDefaultValue()
         {
-            var sut = BuildParameters();
+            var sut = BuildArguments();
 
             Assert.False(sut.NoBrowser);
             Assert.True(sut.LaunchBrowser);
@@ -35,7 +35,7 @@ public void NoBrowserDefaultValue()
         [InlineData("-p", 9090)]
         public void Port(string argument, int expectedValue)
         {
-            var sut = BuildParameters(argument, expectedValue.ToString());
+            var sut = BuildArguments(argument, expectedValue.ToString());
 
             Assert.Equal(expectedValue, sut.Port);
         }
@@ -43,7 +43,7 @@ public void Port(string argument, int expectedValue)
         [Fact]
         public void PortDefaultValue()
         {
-            var sut = BuildParameters();
+            var sut = BuildArguments();
 
             Assert.Equal(8080, sut.Port);
         }
diff --git a/src/Pretzel.Tests/Extensibility/Extensions/AzureHostSupportArgumentsTests.cs b/src/Pretzel.Tests/Extensibility/Extensions/AzureHostSupportArgumentsTests.cs
new file mode 100644
index 000000000..69eaeeefd
--- /dev/null
+++ b/src/Pretzel.Tests/Extensibility/Extensions/AzureHostSupportArgumentsTests.cs
@@ -0,0 +1,21 @@
+using Pretzel.Logic.Extensibility.Extensions;
+using Xunit;
+
+namespace Pretzel.Tests.Extensibility.Extensions
+{
+    public class AzureHostSupportArgumentsTests : CommandArgumentsExtensionTests<AzureHostSupportArguments>
+    {
+        protected override AzureHostSupportArguments CreateArguments() => new AzureHostSupportArguments();
+
+        [Theory]
+        [InlineData("", false)]
+        [InlineData("--azure", true)]
+        [InlineData("-azure", true)]
+        public void Azure(string argument, bool expectedValue)
+        {
+            var arguments = BuildArguments(argument);
+
+            Assert.Equal(expectedValue, arguments.Azure);
+        }
+    }
+}
diff --git a/src/Pretzel.Tests/Extensibility/Extensions/CommandArgumentsExtensionTests.cs b/src/Pretzel.Tests/Extensibility/Extensions/CommandArgumentsExtensionTests.cs
new file mode 100644
index 000000000..b56684fac
--- /dev/null
+++ b/src/Pretzel.Tests/Extensibility/Extensions/CommandArgumentsExtensionTests.cs
@@ -0,0 +1,36 @@
+using System;
+using System.CommandLine;
+using System.CommandLine.Binding;
+using System.CommandLine.Invocation;
+using System.IO.Abstractions.TestingHelpers;
+using System.Linq;
+using NSubstitute;
+using Pretzel.Logic.Extensibility;
+
+namespace Pretzel.Tests.Extensibility.Extensions
+{
+    public abstract class CommandArgumentsExtensionTests<T> where T : ICommandArgumentsExtension
+    {
+        readonly IConsole Console = Substitute.For<IConsole>();
+        protected readonly MockFileSystem fileSystem = new MockFileSystem();
+        protected abstract T CreateArguments();
+        protected T BuildArguments(params string[] args)
+        {
+            var rootCommand = new RootCommand();
+
+            var arguments = CreateArguments();
+            
+            foreach (var option in arguments.Options)
+                rootCommand.AddOption(option);
+
+            var context = new InvocationContext(new Parser(rootCommand).Parse(args), Console);
+
+            new ModelBinder(arguments.GetType())
+                .UpdateInstance(arguments, context.BindingContext);
+
+            arguments.BindingCompleted();
+
+            return arguments;
+        }
+    }
+}
diff --git a/src/Pretzel.Tests/Extensibility/Extensions/VirtualDirectorySupportArgumentsTests.cs b/src/Pretzel.Tests/Extensibility/Extensions/VirtualDirectorySupportArgumentsTests.cs
index 15d8e11f4..a37250d77 100644
--- a/src/Pretzel.Tests/Extensibility/Extensions/VirtualDirectorySupportArgumentsTests.cs
+++ b/src/Pretzel.Tests/Extensibility/Extensions/VirtualDirectorySupportArgumentsTests.cs
@@ -1,9 +1,22 @@
+using Pretzel.Logic.Extensibility.Extensions;
 using System;
 using System.Linq;
+using Xunit;
 
 namespace Pretzel.Tests.Extensibility.Extensions
 {
-    public class VirtualDirectorySupportArgumentsTests
+    public class VirtualDirectorySupportArgumentsTests : CommandArgumentsExtensionTests<VirtualDirectorySupportArguments>
     {
+        protected override VirtualDirectorySupportArguments CreateArguments() => new VirtualDirectorySupportArguments();
+
+        [Theory]
+        [InlineData("--virtualdirectory", "bar")]
+        [InlineData("-vDir", "foo")]
+        public void VirtualDirectory(string argument, string expectedValue)
+        {
+            var arguments = BuildArguments(argument, expectedValue);
+
+            Assert.Equal(expectedValue, arguments.VirtualDirectory);
+        }
     }
 }

From 0e4e2c0dc0dbc2bb917cd745f3eb8dbdc44b7e5e Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Mon, 30 Sep 2019 14:56:13 +0200
Subject: [PATCH 43/56] docs: added command

---
 src/Pretzel.Logic/Commands/ICommand.cs | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/src/Pretzel.Logic/Commands/ICommand.cs b/src/Pretzel.Logic/Commands/ICommand.cs
index d553db70b..16ff9070f 100644
--- a/src/Pretzel.Logic/Commands/ICommand.cs
+++ b/src/Pretzel.Logic/Commands/ICommand.cs
@@ -2,11 +2,23 @@
 
 namespace Pretzel.Logic.Commands
 {
+    /// <summary>
+    /// Defines a custom command for pretzel. Implementors should be decorated with the <see cref="CommandInfoAttribute"/>
+    /// Also see <see cref="Command{T}"/> for easier implementation.
+    /// </summary>
     public interface ICommand
     {
+        /// <summary>
+        /// Executes the specified command with arguments provided defined in <see cref="CommandInfoAttribute.CommandArgumentsType"/>.
+        /// </summary>
+        /// <param name="arguments">The arguments.</param>
+        /// <returns></returns>
         Task<int> Execute(ICommandArguments arguments);
     }
 
+    /// <summary>
+    /// Defines a custom command for pretzel. Implementors should be decorated with the <see cref="CommandInfoAttribute"/>
+    /// </summary>
     public abstract class Command<T> : ICommand where T : ICommandArguments
     {
         public Task<int> Execute(ICommandArguments arguments)

From fbff53144ef734c67336062ed56f459655ce83cb Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Mon, 30 Sep 2019 16:39:05 +0200
Subject: [PATCH 44/56] feat: extensible argument types

---
 .../Commands/BakeBaseCommandArguments.cs      |  2 +-
 .../Commands/IBakeBaseCommandArguments.cs     | 11 ++++
 .../Commands/IBakeCommandArguments.cs         | 10 ++++
 .../Commands/IImportCommandArguments.cs       | 12 ++++
 .../Commands/IIngredientCommandArguments.cs   | 10 ++++
 .../Commands/IPretzelBaseCommandArguments.cs  | 16 ++++++
 .../Commands/IRecipeCommandArguments.cs       | 11 ++++
 .../Commands/ITasteCommandArguments.cs        | 10 ++++
 .../Commands/PretzelBaseCommandArguments.cs   |  2 +-
 .../CommandArgumentsExtensionAttribute.cs     |  2 +-
 .../Extensions/AzureHostSupport.cs            |  2 +-
 .../Extensions/VirtualDirectorySupport.cs     |  2 +-
 .../Commands/CommandCollectionTests.cs        | 57 ++++++++++++++++++-
 .../Commands/PretzelCommandHandlerTests.cs    |  2 +-
 src/Pretzel/Commands/BakeCommand.cs           |  4 +-
 src/Pretzel/Commands/CommandCollection.cs     |  6 +-
 src/Pretzel/Commands/ImportCommand.cs         |  4 +-
 src/Pretzel/Commands/IngredientCommand.cs     |  6 +-
 src/Pretzel/Commands/RecipeCommand.cs         |  4 +-
 src/Pretzel/Commands/TasteCommand.cs          |  4 +-
 20 files changed, 154 insertions(+), 23 deletions(-)
 create mode 100644 src/Pretzel.Logic/Commands/IBakeBaseCommandArguments.cs
 create mode 100644 src/Pretzel.Logic/Commands/IBakeCommandArguments.cs
 create mode 100644 src/Pretzel.Logic/Commands/IImportCommandArguments.cs
 create mode 100644 src/Pretzel.Logic/Commands/IIngredientCommandArguments.cs
 create mode 100644 src/Pretzel.Logic/Commands/IPretzelBaseCommandArguments.cs
 create mode 100644 src/Pretzel.Logic/Commands/IRecipeCommandArguments.cs
 create mode 100644 src/Pretzel.Logic/Commands/ITasteCommandArguments.cs

diff --git a/src/Pretzel.Logic/Commands/BakeBaseCommandArguments.cs b/src/Pretzel.Logic/Commands/BakeBaseCommandArguments.cs
index a06419475..80a35e092 100644
--- a/src/Pretzel.Logic/Commands/BakeBaseCommandArguments.cs
+++ b/src/Pretzel.Logic/Commands/BakeBaseCommandArguments.cs
@@ -6,7 +6,7 @@
 
 namespace Pretzel.Logic.Commands
 {
-    public abstract class BakeBaseCommandArguments : PretzelBaseCommandArguments
+    public abstract class BakeBaseCommandArguments : PretzelBaseCommandArguments, IBakeBaseCommandArguments
     {
         protected BakeBaseCommandArguments(IFileSystem fileSystem) : base(fileSystem) { }
 
diff --git a/src/Pretzel.Logic/Commands/IBakeBaseCommandArguments.cs b/src/Pretzel.Logic/Commands/IBakeBaseCommandArguments.cs
new file mode 100644
index 000000000..6070cae2f
--- /dev/null
+++ b/src/Pretzel.Logic/Commands/IBakeBaseCommandArguments.cs
@@ -0,0 +1,11 @@
+using System;
+using System.Linq;
+
+namespace Pretzel.Logic.Commands
+{
+    [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+    public interface IBakeBaseCommandArguments : IPretzelBaseCommandArguments
+    {
+        bool CleanTarget { get; }
+    }
+}
diff --git a/src/Pretzel.Logic/Commands/IBakeCommandArguments.cs b/src/Pretzel.Logic/Commands/IBakeCommandArguments.cs
new file mode 100644
index 000000000..2cb707a67
--- /dev/null
+++ b/src/Pretzel.Logic/Commands/IBakeCommandArguments.cs
@@ -0,0 +1,10 @@
+using System;
+using System.Linq;
+
+namespace Pretzel.Logic.Commands
+{
+    public interface IBakeCommandArguments : IBakeBaseCommandArguments
+    {
+
+    }
+}
diff --git a/src/Pretzel.Logic/Commands/IImportCommandArguments.cs b/src/Pretzel.Logic/Commands/IImportCommandArguments.cs
new file mode 100644
index 000000000..f6914209f
--- /dev/null
+++ b/src/Pretzel.Logic/Commands/IImportCommandArguments.cs
@@ -0,0 +1,12 @@
+using System;
+using System.Linq;
+
+namespace Pretzel.Logic.Commands
+{
+    public interface IImportCommandArguments : IPretzelBaseCommandArguments
+    {
+        string ImportType { get; }
+
+        string ImportFile { get; }
+    }
+}
diff --git a/src/Pretzel.Logic/Commands/IIngredientCommandArguments.cs b/src/Pretzel.Logic/Commands/IIngredientCommandArguments.cs
new file mode 100644
index 000000000..69f06dcde
--- /dev/null
+++ b/src/Pretzel.Logic/Commands/IIngredientCommandArguments.cs
@@ -0,0 +1,10 @@
+using System;
+using System.Linq;
+
+namespace Pretzel.Logic.Commands
+{
+    public interface IIngredientCommandArguments : IPretzelBaseCommandArguments
+    {
+        string NewPostTitle { get; }
+    }
+}
diff --git a/src/Pretzel.Logic/Commands/IPretzelBaseCommandArguments.cs b/src/Pretzel.Logic/Commands/IPretzelBaseCommandArguments.cs
new file mode 100644
index 000000000..eb941df3a
--- /dev/null
+++ b/src/Pretzel.Logic/Commands/IPretzelBaseCommandArguments.cs
@@ -0,0 +1,16 @@
+using System;
+using System.Linq;
+
+namespace Pretzel.Logic.Commands
+{
+    [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Advanced)]
+    public interface IPretzelBaseCommandArguments
+    {
+        string Source { get; }
+        bool Debug { get; }
+        bool Safe { get; }
+        string Template { get; }
+        string Destination { get; }
+        bool Drafts { get; }
+    }
+}
diff --git a/src/Pretzel.Logic/Commands/IRecipeCommandArguments.cs b/src/Pretzel.Logic/Commands/IRecipeCommandArguments.cs
new file mode 100644
index 000000000..6e43d91e1
--- /dev/null
+++ b/src/Pretzel.Logic/Commands/IRecipeCommandArguments.cs
@@ -0,0 +1,11 @@
+using System;
+using System.Linq;
+
+namespace Pretzel.Logic.Commands
+{
+    public interface IRecipeCommandArguments : IPretzelBaseCommandArguments
+    {
+        bool WithProject { get; }
+        bool Wiki { get; }
+    }
+}
diff --git a/src/Pretzel.Logic/Commands/ITasteCommandArguments.cs b/src/Pretzel.Logic/Commands/ITasteCommandArguments.cs
new file mode 100644
index 000000000..36af9b545
--- /dev/null
+++ b/src/Pretzel.Logic/Commands/ITasteCommandArguments.cs
@@ -0,0 +1,10 @@
+using System;
+using System.Linq;
+
+namespace Pretzel.Logic.Commands
+{
+    public interface ITasteCommandArguments : IBakeBaseCommandArguments
+    {
+
+    }
+}
diff --git a/src/Pretzel.Logic/Commands/PretzelBaseCommandArguments.cs b/src/Pretzel.Logic/Commands/PretzelBaseCommandArguments.cs
index c606276a0..d9dd2cccb 100644
--- a/src/Pretzel.Logic/Commands/PretzelBaseCommandArguments.cs
+++ b/src/Pretzel.Logic/Commands/PretzelBaseCommandArguments.cs
@@ -9,7 +9,7 @@
 
 namespace Pretzel.Logic.Commands
 {
-    public abstract class PretzelBaseCommandArguments : BaseCommandArguments, ISourcePathProvider
+    public abstract class PretzelBaseCommandArguments : BaseCommandArguments, ISourcePathProvider, IPretzelBaseCommandArguments
     {
         protected readonly IFileSystem fileSystem;
 
diff --git a/src/Pretzel.Logic/Extensibility/CommandArgumentsExtensionAttribute.cs b/src/Pretzel.Logic/Extensibility/CommandArgumentsExtensionAttribute.cs
index bf76e0a6b..57a588344 100644
--- a/src/Pretzel.Logic/Extensibility/CommandArgumentsExtensionAttribute.cs
+++ b/src/Pretzel.Logic/Extensibility/CommandArgumentsExtensionAttribute.cs
@@ -7,7 +7,7 @@ namespace Pretzel.Logic.Extensibility
     [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
     public sealed class CommandArgumentsExtensionAttribute : ExportAttribute
     {
-        public string[] CommandNames { get; set; }
+        public Type[] CommandArgumentTypes { get; set; }
 
         public CommandArgumentsExtensionAttribute() : base(typeof(ICommandArgumentsExtension))
         {
diff --git a/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs b/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs
index 59bdd2423..535e51b0d 100644
--- a/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs
+++ b/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs
@@ -11,7 +11,7 @@ namespace Pretzel.Logic.Extensibility.Extensions
 {
     [Export]
     [Shared]
-    [CommandArgumentsExtension(CommandNames = new[] { BuiltInCommands.Create })]
+    [CommandArgumentsExtension(CommandArgumentTypes = new[] { typeof(IRecipeCommandArguments) })]
     public class AzureHostSupportArguments : ICommandArgumentsExtension
     {
         public IList<Option> Options { get; } = new[]
diff --git a/src/Pretzel.Logic/Extensibility/Extensions/VirtualDirectorySupport.cs b/src/Pretzel.Logic/Extensibility/Extensions/VirtualDirectorySupport.cs
index 84e958805..2be31bb6f 100644
--- a/src/Pretzel.Logic/Extensibility/Extensions/VirtualDirectorySupport.cs
+++ b/src/Pretzel.Logic/Extensibility/Extensions/VirtualDirectorySupport.cs
@@ -11,7 +11,7 @@ namespace Pretzel.Logic.Extensibility.Extensions
 {
     [Export]
     [Shared]
-    [CommandArgumentsExtension(CommandNames = new[] { BuiltInCommands.Bake, BuiltInCommands.Taste })]
+    [CommandArgumentsExtension(CommandArgumentTypes = new[] { typeof(IBakeCommandArguments), typeof(ITasteCommandArguments) })]
     public class VirtualDirectorySupportArguments : ICommandArgumentsExtension
     {
         public IList<Option> Options { get; } = new[]
diff --git a/src/Pretzel.Tests/Commands/CommandCollectionTests.cs b/src/Pretzel.Tests/Commands/CommandCollectionTests.cs
index 9b89fdb5f..1ecf172c6 100644
--- a/src/Pretzel.Tests/Commands/CommandCollectionTests.cs
+++ b/src/Pretzel.Tests/Commands/CommandCollectionTests.cs
@@ -106,11 +106,14 @@ public ICommandParametersExtentionsTests()
                 configuration.WithPart<CommandCollection>();
                 configuration.WithPart<TestCommand1>();
                 configuration.WithPart<TestCommand2>();
+                configuration.WithPart<TestCommand3>();
                 configuration.WithPart<TestCommandArguments1>();
                 configuration.WithPart<TestCommandArguments2>();
+                configuration.WithPart<TestCommandArguments3>();
                 configuration.WithPart<Extender1>();
                 configuration.WithPart<Extender2>();
                 configuration.WithPart<Extender3>();
+                configuration.WithPart<Extender4>();
                 configuration.WithPart<ConfigurationMock>();
                 Container = configuration.CreateContainer();
             }
@@ -135,7 +138,16 @@ public void CollectsOnlyCommandsWhereNamesMatch2()
                 Assert.Equal(2, target.Extensions.Count);
                 Assert.Contains(target.Extensions, e => e is Extender2);
                 Assert.Contains(target.Extensions, e => e is Extender3);
+            }
+
+            [Fact]
+            public void CollectsOnlyCommandsWhereInterfacesAreExported()
+            {
+                Container.GetExport<CommandCollection>();
+                var target = Container.GetExport<ITestCommandArguments3>();
 
+                Assert.Equal(1, target.Extensions.Count);
+                Assert.Contains(target.Extensions, e => e is Extender4);
             }
 
             public void Dispose()
@@ -182,6 +194,7 @@ public class TestCommandArguments2 : ICommandArguments
                 public void BindingCompleted() { }
             }
 
+
             [Export]
             [Shared]
             [CommandInfo(CommandName = "test2", CommandArgumentsType = typeof(TestCommandArguments2))]
@@ -193,7 +206,35 @@ public Task<int> Execute(ICommandArguments arguments)
                 }
             }
 
-            [CommandArgumentsExtension(CommandNames = new[] { "test1" })]
+            public interface ITestCommandArguments3 : ICommandArguments { }
+
+            [Export(typeof(ITestCommandArguments3))]
+            [Shared]
+            [CommandArguments]
+            public class TestCommandArguments3 : ITestCommandArguments3
+            {
+                [ImportMany]
+                public ExportFactory<ICommandArgumentsExtension, CommandArgumentsExtensionAttribute>[] ArgumentExtensions { get; set; }
+
+                public IList<Option> Options => new List<Option>();
+
+                public IList<ICommandArgumentsExtension> Extensions { get; } = new List<ICommandArgumentsExtension>();
+
+                public void BindingCompleted() { }
+            }
+
+            [Export]
+            [Shared]
+            [CommandInfo(CommandName = "test3", CommandArgumentsType = typeof(ITestCommandArguments3))]
+            public class TestCommand3 : Logic.Commands.ICommand
+            {
+                public Task<int> Execute(ICommandArguments arguments)
+                {
+                    return Task.FromResult(0);
+                }
+            }
+
+            [CommandArgumentsExtension(CommandArgumentTypes = new[] { typeof(TestCommandArguments1) })]
             public class Extender1 : ICommandArgumentsExtension
             {
                 public IList<Option> Options { get; } = Array.Empty<Option>();
@@ -203,7 +244,7 @@ public void BindingCompleted()
                 }
             }
 
-            [CommandArgumentsExtension(CommandNames = new[] { "test2" })]
+            [CommandArgumentsExtension(CommandArgumentTypes = new[] { typeof(TestCommandArguments2) })]
             public class Extender2 : ICommandArgumentsExtension
             {
                 public IList<Option> Options { get; } = Array.Empty<Option>();
@@ -213,7 +254,7 @@ public void BindingCompleted()
                 }
             }
 
-            [CommandArgumentsExtension(CommandNames = new[] { "test1", "test2" })]
+            [CommandArgumentsExtension(CommandArgumentTypes = new[] { typeof(TestCommandArguments1), typeof(TestCommandArguments2) })]
             public class Extender3 : ICommandArgumentsExtension
             {
                 public IList<Option> Options { get; } = Array.Empty<Option>();
@@ -223,6 +264,16 @@ public void BindingCompleted()
                 }
             }
 
+            [CommandArgumentsExtension(CommandArgumentTypes = new[] { typeof(ITestCommandArguments3) })]
+            public class Extender4 : ICommandArgumentsExtension
+            {
+                public IList<Option> Options { get; } = Array.Empty<Option>();
+
+                public void BindingCompleted()
+                {
+                }
+            }
+
         }
     }
 }
diff --git a/src/Pretzel.Tests/Commands/PretzelCommandHandlerTests.cs b/src/Pretzel.Tests/Commands/PretzelCommandHandlerTests.cs
index 7206c1a9f..3904c06fa 100644
--- a/src/Pretzel.Tests/Commands/PretzelCommandHandlerTests.cs
+++ b/src/Pretzel.Tests/Commands/PretzelCommandHandlerTests.cs
@@ -128,7 +128,7 @@ public void BindingCompleted()
 
             public ExportFactory<ICommandArgumentsExtension, CommandArgumentsExtensionAttribute>[] ArgumentExtensions => new[]
             {
-                new ExportFactory<ICommandArgumentsExtension, CommandArgumentsExtensionAttribute>(() => Tuple.Create<ICommandArgumentsExtension, Action>(Args, new Action(() => { })), new CommandArgumentsExtensionAttribute{ CommandNames = new []{ nameof(TestArguments2)} })
+                new ExportFactory<ICommandArgumentsExtension, CommandArgumentsExtensionAttribute>(() => Tuple.Create<ICommandArgumentsExtension, Action>(Args, new Action(() => { })), new CommandArgumentsExtensionAttribute{ CommandArgumentTypes = new []{ typeof(TestArguments2)} })
             };
 
             public IList<ICommandArgumentsExtension> Extensions { get; } = new List<ICommandArgumentsExtension>();
diff --git a/src/Pretzel/Commands/BakeCommand.cs b/src/Pretzel/Commands/BakeCommand.cs
index 829a19aa8..67cedf35a 100644
--- a/src/Pretzel/Commands/BakeCommand.cs
+++ b/src/Pretzel/Commands/BakeCommand.cs
@@ -13,9 +13,9 @@
 namespace Pretzel.Commands
 {
     [Shared]
-    [Export]
+    [Export(typeof(IBakeCommandArguments))]
     [CommandArguments]
-    public sealed class BakeCommandArguments : BakeBaseCommandArguments
+    public sealed class BakeCommandArguments : BakeBaseCommandArguments, IBakeCommandArguments
     {
         [ImportingConstructor]
         public BakeCommandArguments(IFileSystem fileSystem) : base(fileSystem) { }
diff --git a/src/Pretzel/Commands/CommandCollection.cs b/src/Pretzel/Commands/CommandCollection.cs
index 0185aa7ac..d7ed834a7 100644
--- a/src/Pretzel/Commands/CommandCollection.cs
+++ b/src/Pretzel/Commands/CommandCollection.cs
@@ -46,19 +46,19 @@ public ExportFactory<ICommandArgumentsExtension, CommandArgumentsExtensionAttrib
         internal void OnImportsSatisfied()
         {
             RootCommand = new RootCommand();
-            
+
             foreach (var command in Commands)
             {
                 var subCommand = new Command(command.Metadata.CommandName, command.Metadata.CommandDescription);
 
-                var argument = CommandArguments.First(c => c.GetType() == command.Metadata.CommandArgumentsType);
+                var argument = CommandArguments.First(c => command.Metadata.CommandArgumentsType.IsAssignableFrom(c.GetType()));
 
                 if (argument is BaseCommandArguments baseCommandArguments)
                 {
                     baseCommandArguments.BuildOptions();
                 }
 
-                foreach (var argumentExtensionsExport in ArgumentExtensions.Where(a => a.Metadata.CommandNames.Contains(command.Metadata.CommandName)))
+                foreach (var argumentExtensionsExport in ArgumentExtensions.Where(a => a.Metadata.CommandArgumentTypes.Any(type => type.IsAssignableFrom(argument.GetType()))))
                 {
                     var arugumentExtension = argumentExtensionsExport.CreateExport().Value;
                     argument.Extensions.Add(arugumentExtension);
diff --git a/src/Pretzel/Commands/ImportCommand.cs b/src/Pretzel/Commands/ImportCommand.cs
index 729b9e4cb..1698496d9 100644
--- a/src/Pretzel/Commands/ImportCommand.cs
+++ b/src/Pretzel/Commands/ImportCommand.cs
@@ -11,10 +11,10 @@
 
 namespace Pretzel.Commands
 {
-    [Export]
     [Shared]
+    [Export(typeof(IImportCommandArguments))]
     [CommandArguments]
-    public class ImportCommandArguments : PretzelBaseCommandArguments
+    public class ImportCommandArguments : PretzelBaseCommandArguments, IImportCommandArguments
     {
         [ImportingConstructor]
         public ImportCommandArguments(IFileSystem fileSystem) : base(fileSystem) { }
diff --git a/src/Pretzel/Commands/IngredientCommand.cs b/src/Pretzel/Commands/IngredientCommand.cs
index 19b7f076c..285133dea 100644
--- a/src/Pretzel/Commands/IngredientCommand.cs
+++ b/src/Pretzel/Commands/IngredientCommand.cs
@@ -11,10 +11,10 @@
 
 namespace Pretzel.Commands
 {
-    [Export]
     [Shared]
+    [Export(typeof(IIngredientCommandArguments))]
     [CommandArguments]
-    public class IngredientCommandArguments : PretzelBaseCommandArguments
+    public class IngredientCommandArguments : PretzelBaseCommandArguments, IIngredientCommandArguments
     {
         [ImportingConstructor]
         public IngredientCommandArguments(IFileSystem fileSystem) : base(fileSystem) { }
@@ -39,7 +39,7 @@ public sealed class IngredientCommand : Command<IngredientCommandArguments>
     {
         [Import]
         public IFileSystem FileSystem { get; set; }
-        
+
         protected override Task<int> Execute(IngredientCommandArguments arguments)
         {
             Tracing.Info("ingredient - create a new post");
diff --git a/src/Pretzel/Commands/RecipeCommand.cs b/src/Pretzel/Commands/RecipeCommand.cs
index a3f6c88c2..bfcea69a3 100644
--- a/src/Pretzel/Commands/RecipeCommand.cs
+++ b/src/Pretzel/Commands/RecipeCommand.cs
@@ -12,10 +12,10 @@
 
 namespace Pretzel.Commands
 {
-    [Export]
     [Shared]
+    [Export(typeof(IRecipeCommandArguments))]
     [CommandArguments]
-    public class RecipeCommandArguments : PretzelBaseCommandArguments
+    public class RecipeCommandArguments : PretzelBaseCommandArguments, IRecipeCommandArguments
     {
         [ImportingConstructor]
         public RecipeCommandArguments(IFileSystem fileSystem) : base(fileSystem) { }
diff --git a/src/Pretzel/Commands/TasteCommand.cs b/src/Pretzel/Commands/TasteCommand.cs
index f6cf90ab5..dbe6119b7 100644
--- a/src/Pretzel/Commands/TasteCommand.cs
+++ b/src/Pretzel/Commands/TasteCommand.cs
@@ -15,10 +15,10 @@
 
 namespace Pretzel.Commands
 {
-    [Export]
     [Shared]
+    [Export(typeof(ITasteCommandArguments))]
     [CommandArguments]
-    public class TasteCommandArguments : BakeBaseCommandArguments
+    public class TasteCommandArguments : BakeBaseCommandArguments, ITasteCommandArguments
     {
         [ImportingConstructor]
         public TasteCommandArguments(IFileSystem fileSystem) : base(fileSystem) { }

From 94659bb8518ded02a33b5bf28bde629745ad4126 Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Sun, 6 Oct 2019 09:27:30 +0200
Subject: [PATCH 45/56] refactor: Program does not need to be exported

---
 src/Pretzel/Program.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Pretzel/Program.cs b/src/Pretzel/Program.cs
index cca05bd75..bc9c21e97 100644
--- a/src/Pretzel/Program.cs
+++ b/src/Pretzel/Program.cs
@@ -14,7 +14,6 @@
 
 namespace Pretzel
 {
-    [Export]
     internal class Program
     {
 #pragma warning disable S2223 // Non-constant static fields should not be visible
@@ -67,7 +66,8 @@ private static async Task<int> Main(string[] args)
 
                     using (var host = Compose(debug, safe, source))
                     {
-                        var program = host.GetExport<Program>();
+                        var program = new Program();
+                        host.SatisfyImports(program);
                         var result = await program.Run(GlobalOptions, args);
                         WaitForClose();
                         return result;

From f4638b6dc4cee18e56e9dbd07371eb853061842f Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Sun, 6 Oct 2019 09:32:02 +0200
Subject: [PATCH 46/56] fix: its not needed to pass the global options to the
 root command

---
 src/Pretzel/Program.cs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/Pretzel/Program.cs b/src/Pretzel/Program.cs
index bc9c21e97..2b94c6187 100644
--- a/src/Pretzel/Program.cs
+++ b/src/Pretzel/Program.cs
@@ -135,8 +135,6 @@ private async Task<int> Run(IEnumerable<Option> globalOptions, string[] args)
             {
                 foreach (var option in globalOptions)
                 {
-                    CommandCollection.RootCommand.AddOption(option);
-
                     foreach (var command in CommandCollection.RootCommand.OfType<Command>())
                     {
                         command.AddOption(option);

From 36b2a686e1d256f5bb82c75ee155f7e5424ce2ed Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Sun, 6 Oct 2019 09:34:55 +0200
Subject: [PATCH 47/56] test: composition uses SatisfyImports

---
 src/Pretzel.Tests/ProgramTests.cs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/Pretzel.Tests/ProgramTests.cs b/src/Pretzel.Tests/ProgramTests.cs
index 7b9a6d0ac..439915dbb 100644
--- a/src/Pretzel.Tests/ProgramTests.cs
+++ b/src/Pretzel.Tests/ProgramTests.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Composition;
 using System.IO.Abstractions;
 using System.IO.Abstractions.TestingHelpers;
 using System.Linq;
@@ -47,7 +48,8 @@ public void CompositionDoesNotThrow()
         {
             using (var compositionHost = Program.Compose(true, true, null))
             {
-                compositionHost.GetExport<Program>();
+                var program = new Program()
+                compositionHost.SatisfyImports(program);
             }
         }
 

From cc101167fa0213ef8fa0dd3eca9fc67886a0e3aa Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Sun, 6 Oct 2019 09:35:40 +0200
Subject: [PATCH 48/56] fix: source and s arguments without additional dashes

---
 src/Pretzel/Program.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Pretzel/Program.cs b/src/Pretzel/Program.cs
index 2b94c6187..fb5552d44 100644
--- a/src/Pretzel/Program.cs
+++ b/src/Pretzel/Program.cs
@@ -29,7 +29,7 @@ internal class Program
             {
                 Argument = new Argument<bool>()
             },
-            new Option(new[] { "--source", "-source", "-s", "--s" }, "The path to the source site (default current directory)")
+            new Option(new[] { "--source", "-s" }, "The path to the source site (default current directory)")
             {
                 Argument = new Argument<string>(() => fileSystem.Directory.GetCurrentDirectory())
             }

From c085ee78159e62e33d96f3398d93b7da8e6212b7 Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Sun, 6 Oct 2019 09:35:59 +0200
Subject: [PATCH 49/56] test: composition uses SatisfyImports

---
 src/Pretzel.Tests/ProgramTests.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Pretzel.Tests/ProgramTests.cs b/src/Pretzel.Tests/ProgramTests.cs
index 439915dbb..5f6446a21 100644
--- a/src/Pretzel.Tests/ProgramTests.cs
+++ b/src/Pretzel.Tests/ProgramTests.cs
@@ -48,7 +48,7 @@ public void CompositionDoesNotThrow()
         {
             using (var compositionHost = Program.Compose(true, true, null))
             {
-                var program = new Program()
+                var program = new Program();
                 compositionHost.SatisfyImports(program);
             }
         }

From c3b99aaacb421d21303c1bd70290c5e886b2794e Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Sun, 6 Oct 2019 09:48:27 +0200
Subject: [PATCH 50/56] fix: RootCommand does not need to be exported

---
 src/Pretzel/Commands/CommandCollection.cs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/Pretzel/Commands/CommandCollection.cs b/src/Pretzel/Commands/CommandCollection.cs
index d7ed834a7..495c42bea 100644
--- a/src/Pretzel/Commands/CommandCollection.cs
+++ b/src/Pretzel/Commands/CommandCollection.cs
@@ -36,7 +36,6 @@ public ExportFactory<ICommandArgumentsExtension, CommandArgumentsExtensionAttrib
             set => argumentExtensions = value;
         }
 
-        [Export]
         public RootCommand RootCommand { get; set; }
 
         [Import]

From b3c12a8858a944197e42307fe4ece0886407a241 Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Sun, 6 Oct 2019 10:58:00 +0200
Subject: [PATCH 51/56] fix: don't use a root command to init the app

---
 src/Pretzel/Program.cs | 72 +++++++++++++++++++++++-------------------
 1 file changed, 40 insertions(+), 32 deletions(-)

diff --git a/src/Pretzel/Program.cs b/src/Pretzel/Program.cs
index fb5552d44..218992b15 100644
--- a/src/Pretzel/Program.cs
+++ b/src/Pretzel/Program.cs
@@ -44,45 +44,28 @@ internal class Program
 
         private static async Task<int> Main(string[] args)
         {
-            var rootCommand = new RootCommand
-            {
-                TreatUnmatchedTokensAsErrors = false
-            };
+            Tracing.SetTrace(ConsoleTrace.Write);
 
             args = PatchSourcePath(args);
 
-            foreach (var option in GlobalOptions)
-            {
-                rootCommand.AddOption(option);
-            }
+            var parseResult = ParseArguments(args);
+            if (parseResult.hasError)
+                return -1;
 
-            rootCommand.Handler = CommandHandler.Create(async (bool debug, bool safe, string source) =>
+            try
             {
-                try
-                {
-                    InitializeTrace(debug);
-                    Tracing.Info("starting pretzel...");
-                    Tracing.Debug("V{0}", Assembly.GetExecutingAssembly().GetName().Version);
+                InitializeTrace(parseResult.debug);
+                Tracing.Info("starting pretzel...");
+                Tracing.Debug("V{0}", Assembly.GetExecutingAssembly().GetName().Version);
 
-                    using (var host = Compose(debug, safe, source))
-                    {
-                        var program = new Program();
-                        host.SatisfyImports(program);
-                        var result = await program.Run(GlobalOptions, args);
-                        WaitForClose();
-                        return result;
-                    }
-                }
-                catch (Exception ex)
+                using (var host = Compose(parseResult.debug, parseResult.safe, parseResult.source))
                 {
-                    Tracing.Error(ex.Message);
+                    var program = new Program();
+                    host.SatisfyImports(program);
+                    var result = await program.Run(GlobalOptions, args);
                     WaitForClose();
-                    return -1;
+                    return result;
                 }
-            });
-            try
-            {
-                return await rootCommand.InvokeAsync(args);
             }
             catch (Exception ex)
             {
@@ -92,6 +75,33 @@ private static async Task<int> Main(string[] args)
             }
         }
 
+        internal static (bool debug, bool safe, string source, bool hasError) ParseArguments(string[] args)
+        {
+            var command = new RootCommand()
+            {
+                TreatUnmatchedTokensAsErrors = false
+            };
+
+            foreach (var option in GlobalOptions)
+                command.AddOption(option);
+
+            var parseResult = new Parser(command).Parse(args);
+
+            if (parseResult.Errors.Count > 0)
+            {
+                foreach (var error in parseResult.Errors)
+                {
+                    Tracing.Error(error.Message);
+                }
+                return (true, true, null, true);
+            }
+            var debug = parseResult.FindResultFor(GlobalOptions.First(m => m.Name == "debug"))?.GetValueOrDefault<bool>() ?? false;
+            var safe = parseResult.FindResultFor(GlobalOptions.First(m => m.Name == "safe"))?.GetValueOrDefault<bool>() ?? false;
+            var source = parseResult.FindResultFor(GlobalOptions.First(m => m.Name == "source"))?.GetValueOrDefault<string>();
+            return (debug, safe, source, false);
+        }
+
+
         internal static string[] PatchSourcePath(string[] args)
         {
             if (args.Length > 1 && !args.Contains("-s") && !args.Contains("--source"))
@@ -121,8 +131,6 @@ internal static string[] PatchSourcePath(string[] args)
 
         private static void InitializeTrace(bool debug)
         {
-            Tracing.SetTrace(ConsoleTrace.Write);
-
             if (debug)
             {
                 Tracing.SetMinimalLevel(TraceLevel.Debug);

From 607bbada6fc3ae6d7ffea9fd261f2d48a664061d Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Mon, 7 Oct 2019 08:37:30 +0200
Subject: [PATCH 52/56] refactor: moved commands to logic and removed redundant
 interfaces

---
 .../Commands/BakeBaseCommandArguments.cs      |  2 +-
 .../Commands/BakeCommand.cs                   |  9 ++++-----
 .../Commands/HungryCommand.cs                 |  3 +--
 .../Commands/IBakeBaseCommandArguments.cs     | 11 ----------
 .../Commands/IBakeCommandArguments.cs         | 10 ----------
 .../Commands/IImportCommandArguments.cs       | 12 -----------
 .../Commands/IIngredientCommandArguments.cs   | 10 ----------
 .../Commands/IPretzelBaseCommandArguments.cs  | 16 ---------------
 .../Commands/IRecipeCommandArguments.cs       | 11 ----------
 .../Commands/ITasteCommandArguments.cs        | 10 ----------
 .../Commands/ImportCommand.cs                 |  9 ++++-----
 .../Commands/IngredientCommand.cs             |  9 ++++-----
 .../Commands/PretzelBaseCommandArguments.cs   |  2 +-
 .../Commands/RecipeCommand.cs                 | 13 ++++++------
 .../Commands/TasteCommand.cs                  | 10 +++++-----
 .../Commands/TemplateEngineCollection.cs      |  4 ++--
 .../Commands/VersionCommand.cs                |  3 +--
 .../Extensions/AzureHostSupport.cs            |  2 +-
 .../Extensions/VirtualDirectorySupport.cs     |  2 +-
 .../Hosting}/FileContentProvider.cs           | 19 +++++++++---------
 .../Hosting}/IWebContent.cs                   |  6 +++---
 .../Hosting}/WebHost.cs                       |  8 ++++----
 .../Modules/IFileSystemWatcher.cs             |  6 +++---
 .../Modules/SimpleFileSystemWatcher.cs        |  2 +-
 src/Pretzel.Logic/Pretzel.Logic.csproj        | 10 ++++++++--
 .../{Recipe => Recipes}/Ingredient.cs         |  8 ++++----
 .../{Recipe => Recipes}/Recipe.cs             |  4 ++--
 .../Commands/BakeCommandArgumentsTests.cs     |  2 +-
 .../Commands/ImportCommandArgumentsTests.cs   |  2 +-
 .../IngredientCommandArgumentsTests.cs        |  2 +-
 .../Commands/RecipeCommandArgumentsTests.cs   |  2 +-
 .../Commands/TasteCommandArgumentsTests.cs    |  2 +-
 src/Pretzel.Tests/Recipe/IngredientTests.cs   | 11 +++++-----
 src/Pretzel.Tests/Recipe/RecipeTests.cs       | 20 +++++++++----------
 src/Pretzel/Pretzel.csproj                    |  8 ++------
 src/Pretzel/Properties/launchSettings.json    |  3 +--
 36 files changed, 90 insertions(+), 173 deletions(-)
 rename src/{Pretzel => Pretzel.Logic}/Commands/BakeCommand.cs (94%)
 rename src/{Pretzel => Pretzel.Logic}/Commands/HungryCommand.cs (98%)
 delete mode 100644 src/Pretzel.Logic/Commands/IBakeBaseCommandArguments.cs
 delete mode 100644 src/Pretzel.Logic/Commands/IBakeCommandArguments.cs
 delete mode 100644 src/Pretzel.Logic/Commands/IImportCommandArguments.cs
 delete mode 100644 src/Pretzel.Logic/Commands/IIngredientCommandArguments.cs
 delete mode 100644 src/Pretzel.Logic/Commands/IPretzelBaseCommandArguments.cs
 delete mode 100644 src/Pretzel.Logic/Commands/IRecipeCommandArguments.cs
 delete mode 100644 src/Pretzel.Logic/Commands/ITasteCommandArguments.cs
 rename src/{Pretzel => Pretzel.Logic}/Commands/ImportCommand.cs (92%)
 rename src/{Pretzel => Pretzel.Logic}/Commands/IngredientCommand.cs (89%)
 rename src/{Pretzel => Pretzel.Logic}/Commands/RecipeCommand.cs (89%)
 rename src/{Pretzel => Pretzel.Logic}/Commands/TasteCommand.cs (97%)
 rename src/{Pretzel => Pretzel.Logic}/Commands/TemplateEngineCollection.cs (95%)
 rename src/{Pretzel => Pretzel.Logic}/Commands/VersionCommand.cs (94%)
 rename src/{Pretzel/WebHost => Pretzel.Logic/Hosting}/FileContentProvider.cs (90%)
 rename src/{Pretzel/WebHost => Pretzel.Logic/Hosting}/IWebContent.cs (84%)
 rename src/{Pretzel/WebHost => Pretzel.Logic/Hosting}/WebHost.cs (95%)
 rename src/{Pretzel => Pretzel.Logic}/Modules/IFileSystemWatcher.cs (72%)
 rename src/{Pretzel => Pretzel.Logic}/Modules/SimpleFileSystemWatcher.cs (97%)
 rename src/Pretzel.Logic/{Recipe => Recipes}/Ingredient.cs (90%)
 rename src/Pretzel.Logic/{Recipe => Recipes}/Recipe.cs (99%)

diff --git a/src/Pretzel.Logic/Commands/BakeBaseCommandArguments.cs b/src/Pretzel.Logic/Commands/BakeBaseCommandArguments.cs
index 80a35e092..a06419475 100644
--- a/src/Pretzel.Logic/Commands/BakeBaseCommandArguments.cs
+++ b/src/Pretzel.Logic/Commands/BakeBaseCommandArguments.cs
@@ -6,7 +6,7 @@
 
 namespace Pretzel.Logic.Commands
 {
-    public abstract class BakeBaseCommandArguments : PretzelBaseCommandArguments, IBakeBaseCommandArguments
+    public abstract class BakeBaseCommandArguments : PretzelBaseCommandArguments
     {
         protected BakeBaseCommandArguments(IFileSystem fileSystem) : base(fileSystem) { }
 
diff --git a/src/Pretzel/Commands/BakeCommand.cs b/src/Pretzel.Logic/Commands/BakeCommand.cs
similarity index 94%
rename from src/Pretzel/Commands/BakeCommand.cs
rename to src/Pretzel.Logic/Commands/BakeCommand.cs
index 67cedf35a..15fba23f5 100644
--- a/src/Pretzel/Commands/BakeCommand.cs
+++ b/src/Pretzel.Logic/Commands/BakeCommand.cs
@@ -5,17 +5,16 @@
 using System.IO.Abstractions;
 using System.Linq;
 using System.Threading.Tasks;
-using Pretzel.Logic.Commands;
 using Pretzel.Logic.Extensibility;
 using Pretzel.Logic.Extensions;
 using Pretzel.Logic.Templating.Context;
 
-namespace Pretzel.Commands
+namespace Pretzel.Logic.Commands
 {
     [Shared]
-    [Export(typeof(IBakeCommandArguments))]
+    [Export]
     [CommandArguments]
-    public sealed class BakeCommandArguments : BakeBaseCommandArguments, IBakeCommandArguments
+    public sealed class BakeCommandArguments : BakeBaseCommandArguments
     {
         [ImportingConstructor]
         public BakeCommandArguments(IFileSystem fileSystem) : base(fileSystem) { }
@@ -37,7 +36,7 @@ public sealed class BakeCommand : Command<BakeCommandArguments>
 
         [ImportMany]
         public IEnumerable<ITransform> Transforms { get; set; }
-        
+
         [Import]
         public IFileSystem FileSystem { get; set; }
 
diff --git a/src/Pretzel/Commands/HungryCommand.cs b/src/Pretzel.Logic/Commands/HungryCommand.cs
similarity index 98%
rename from src/Pretzel/Commands/HungryCommand.cs
rename to src/Pretzel.Logic/Commands/HungryCommand.cs
index 910de12bd..e4a9675c3 100644
--- a/src/Pretzel/Commands/HungryCommand.cs
+++ b/src/Pretzel.Logic/Commands/HungryCommand.cs
@@ -3,10 +3,9 @@
 using System.CommandLine;
 using System.Composition;
 using System.Threading.Tasks;
-using Pretzel.Logic.Commands;
 using Pretzel.Logic.Extensions;
 
-namespace Pretzel.Commands
+namespace Pretzel.Logic.Commands
 {
     [Shared]
     [Export]
diff --git a/src/Pretzel.Logic/Commands/IBakeBaseCommandArguments.cs b/src/Pretzel.Logic/Commands/IBakeBaseCommandArguments.cs
deleted file mode 100644
index 6070cae2f..000000000
--- a/src/Pretzel.Logic/Commands/IBakeBaseCommandArguments.cs
+++ /dev/null
@@ -1,11 +0,0 @@
-using System;
-using System.Linq;
-
-namespace Pretzel.Logic.Commands
-{
-    [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
-    public interface IBakeBaseCommandArguments : IPretzelBaseCommandArguments
-    {
-        bool CleanTarget { get; }
-    }
-}
diff --git a/src/Pretzel.Logic/Commands/IBakeCommandArguments.cs b/src/Pretzel.Logic/Commands/IBakeCommandArguments.cs
deleted file mode 100644
index 2cb707a67..000000000
--- a/src/Pretzel.Logic/Commands/IBakeCommandArguments.cs
+++ /dev/null
@@ -1,10 +0,0 @@
-using System;
-using System.Linq;
-
-namespace Pretzel.Logic.Commands
-{
-    public interface IBakeCommandArguments : IBakeBaseCommandArguments
-    {
-
-    }
-}
diff --git a/src/Pretzel.Logic/Commands/IImportCommandArguments.cs b/src/Pretzel.Logic/Commands/IImportCommandArguments.cs
deleted file mode 100644
index f6914209f..000000000
--- a/src/Pretzel.Logic/Commands/IImportCommandArguments.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-using System;
-using System.Linq;
-
-namespace Pretzel.Logic.Commands
-{
-    public interface IImportCommandArguments : IPretzelBaseCommandArguments
-    {
-        string ImportType { get; }
-
-        string ImportFile { get; }
-    }
-}
diff --git a/src/Pretzel.Logic/Commands/IIngredientCommandArguments.cs b/src/Pretzel.Logic/Commands/IIngredientCommandArguments.cs
deleted file mode 100644
index 69f06dcde..000000000
--- a/src/Pretzel.Logic/Commands/IIngredientCommandArguments.cs
+++ /dev/null
@@ -1,10 +0,0 @@
-using System;
-using System.Linq;
-
-namespace Pretzel.Logic.Commands
-{
-    public interface IIngredientCommandArguments : IPretzelBaseCommandArguments
-    {
-        string NewPostTitle { get; }
-    }
-}
diff --git a/src/Pretzel.Logic/Commands/IPretzelBaseCommandArguments.cs b/src/Pretzel.Logic/Commands/IPretzelBaseCommandArguments.cs
deleted file mode 100644
index eb941df3a..000000000
--- a/src/Pretzel.Logic/Commands/IPretzelBaseCommandArguments.cs
+++ /dev/null
@@ -1,16 +0,0 @@
-using System;
-using System.Linq;
-
-namespace Pretzel.Logic.Commands
-{
-    [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Advanced)]
-    public interface IPretzelBaseCommandArguments
-    {
-        string Source { get; }
-        bool Debug { get; }
-        bool Safe { get; }
-        string Template { get; }
-        string Destination { get; }
-        bool Drafts { get; }
-    }
-}
diff --git a/src/Pretzel.Logic/Commands/IRecipeCommandArguments.cs b/src/Pretzel.Logic/Commands/IRecipeCommandArguments.cs
deleted file mode 100644
index 6e43d91e1..000000000
--- a/src/Pretzel.Logic/Commands/IRecipeCommandArguments.cs
+++ /dev/null
@@ -1,11 +0,0 @@
-using System;
-using System.Linq;
-
-namespace Pretzel.Logic.Commands
-{
-    public interface IRecipeCommandArguments : IPretzelBaseCommandArguments
-    {
-        bool WithProject { get; }
-        bool Wiki { get; }
-    }
-}
diff --git a/src/Pretzel.Logic/Commands/ITasteCommandArguments.cs b/src/Pretzel.Logic/Commands/ITasteCommandArguments.cs
deleted file mode 100644
index 36af9b545..000000000
--- a/src/Pretzel.Logic/Commands/ITasteCommandArguments.cs
+++ /dev/null
@@ -1,10 +0,0 @@
-using System;
-using System.Linq;
-
-namespace Pretzel.Logic.Commands
-{
-    public interface ITasteCommandArguments : IBakeBaseCommandArguments
-    {
-
-    }
-}
diff --git a/src/Pretzel/Commands/ImportCommand.cs b/src/Pretzel.Logic/Commands/ImportCommand.cs
similarity index 92%
rename from src/Pretzel/Commands/ImportCommand.cs
rename to src/Pretzel.Logic/Commands/ImportCommand.cs
index 1698496d9..11098410f 100644
--- a/src/Pretzel/Commands/ImportCommand.cs
+++ b/src/Pretzel.Logic/Commands/ImportCommand.cs
@@ -5,16 +5,15 @@
 using System.IO.Abstractions;
 using System.Linq;
 using System.Threading.Tasks;
-using Pretzel.Logic.Commands;
 using Pretzel.Logic.Extensions;
 using Pretzel.Logic.Import;
 
-namespace Pretzel.Commands
+namespace Pretzel.Logic.Commands
 {
     [Shared]
-    [Export(typeof(IImportCommandArguments))]
+    [Export]
     [CommandArguments]
-    public class ImportCommandArguments : PretzelBaseCommandArguments, IImportCommandArguments
+    public class ImportCommandArguments : PretzelBaseCommandArguments
     {
         [ImportingConstructor]
         public ImportCommandArguments(IFileSystem fileSystem) : base(fileSystem) { }
@@ -53,7 +52,7 @@ protected override Task<int> Execute(ImportCommandArguments arguments)
         {
             Tracing.Info("import - import posts from external source");
 
-            if (!Importers.Any(e => String.Equals(e, arguments.ImportType, StringComparison.InvariantCultureIgnoreCase)))
+            if (!Importers.Any(e => string.Equals(e, arguments.ImportType, StringComparison.InvariantCultureIgnoreCase)))
             {
                 Tracing.Info("Requested import type not found: {0}", arguments.ImportType);
 
diff --git a/src/Pretzel/Commands/IngredientCommand.cs b/src/Pretzel.Logic/Commands/IngredientCommand.cs
similarity index 89%
rename from src/Pretzel/Commands/IngredientCommand.cs
rename to src/Pretzel.Logic/Commands/IngredientCommand.cs
index 285133dea..dd9f5325a 100644
--- a/src/Pretzel/Commands/IngredientCommand.cs
+++ b/src/Pretzel.Logic/Commands/IngredientCommand.cs
@@ -5,16 +5,15 @@
 using System.IO.Abstractions;
 using System.Linq;
 using System.Threading.Tasks;
-using Pretzel.Logic.Commands;
 using Pretzel.Logic.Extensions;
-using Pretzel.Logic.Recipe;
+using Pretzel.Logic.Recipes;
 
-namespace Pretzel.Commands
+namespace Pretzel.Logic.Commands
 {
     [Shared]
-    [Export(typeof(IIngredientCommandArguments))]
+    [Export]
     [CommandArguments]
-    public class IngredientCommandArguments : PretzelBaseCommandArguments, IIngredientCommandArguments
+    public class IngredientCommandArguments : PretzelBaseCommandArguments
     {
         [ImportingConstructor]
         public IngredientCommandArguments(IFileSystem fileSystem) : base(fileSystem) { }
diff --git a/src/Pretzel.Logic/Commands/PretzelBaseCommandArguments.cs b/src/Pretzel.Logic/Commands/PretzelBaseCommandArguments.cs
index d9dd2cccb..c606276a0 100644
--- a/src/Pretzel.Logic/Commands/PretzelBaseCommandArguments.cs
+++ b/src/Pretzel.Logic/Commands/PretzelBaseCommandArguments.cs
@@ -9,7 +9,7 @@
 
 namespace Pretzel.Logic.Commands
 {
-    public abstract class PretzelBaseCommandArguments : BaseCommandArguments, ISourcePathProvider, IPretzelBaseCommandArguments
+    public abstract class PretzelBaseCommandArguments : BaseCommandArguments, ISourcePathProvider
     {
         protected readonly IFileSystem fileSystem;
 
diff --git a/src/Pretzel/Commands/RecipeCommand.cs b/src/Pretzel.Logic/Commands/RecipeCommand.cs
similarity index 89%
rename from src/Pretzel/Commands/RecipeCommand.cs
rename to src/Pretzel.Logic/Commands/RecipeCommand.cs
index bfcea69a3..86b901922 100644
--- a/src/Pretzel/Commands/RecipeCommand.cs
+++ b/src/Pretzel.Logic/Commands/RecipeCommand.cs
@@ -5,17 +5,16 @@
 using System.IO.Abstractions;
 using System.Linq;
 using System.Threading.Tasks;
-using Pretzel.Logic.Commands;
 using Pretzel.Logic.Extensibility;
 using Pretzel.Logic.Extensions;
-using Pretzel.Logic.Recipe;
+using Pretzel.Logic.Recipes;
 
-namespace Pretzel.Commands
+namespace Pretzel.Logic.Commands
 {
     [Shared]
-    [Export(typeof(IRecipeCommandArguments))]
+    [Export]
     [CommandArguments]
-    public class RecipeCommandArguments : PretzelBaseCommandArguments, IRecipeCommandArguments
+    public class RecipeCommandArguments : PretzelBaseCommandArguments
     {
         [ImportingConstructor]
         public RecipeCommandArguments(IFileSystem fileSystem) : base(fileSystem) { }
@@ -56,11 +55,11 @@ protected override Task<int> Execute(RecipeCommandArguments arguments)
         {
             Tracing.Info("create - configure a new site");
 
-            var engine = String.IsNullOrWhiteSpace(arguments.Template)
+            var engine = string.IsNullOrWhiteSpace(arguments.Template)
                              ? TemplateEngines.First()
                              : arguments.Template;
 
-            if (!TemplateEngines.Any(e => String.Equals(e, engine, StringComparison.InvariantCultureIgnoreCase)))
+            if (!TemplateEngines.Any(e => string.Equals(e, engine, StringComparison.InvariantCultureIgnoreCase)))
             {
                 Tracing.Info("Requested templating engine not found: {0}", engine);
 
diff --git a/src/Pretzel/Commands/TasteCommand.cs b/src/Pretzel.Logic/Commands/TasteCommand.cs
similarity index 97%
rename from src/Pretzel/Commands/TasteCommand.cs
rename to src/Pretzel.Logic/Commands/TasteCommand.cs
index dbe6119b7..25f04f0de 100644
--- a/src/Pretzel/Commands/TasteCommand.cs
+++ b/src/Pretzel.Logic/Commands/TasteCommand.cs
@@ -6,19 +6,19 @@
 using System.Linq;
 using System.Threading.Tasks;
 using Pretzel.Logic;
-using Pretzel.Logic.Commands;
 using Pretzel.Logic.Extensibility;
 using Pretzel.Logic.Extensions;
+using Pretzel.Logic.Hosting;
+using Pretzel.Logic.Modules;
 using Pretzel.Logic.Templating;
 using Pretzel.Logic.Templating.Context;
-using Pretzel.Modules;
 
-namespace Pretzel.Commands
+namespace Pretzel.Logic.Commands
 {
     [Shared]
-    [Export(typeof(ITasteCommandArguments))]
+    [Export]
     [CommandArguments]
-    public class TasteCommandArguments : BakeBaseCommandArguments, ITasteCommandArguments
+    public class TasteCommandArguments : BakeBaseCommandArguments
     {
         [ImportingConstructor]
         public TasteCommandArguments(IFileSystem fileSystem) : base(fileSystem) { }
diff --git a/src/Pretzel/Commands/TemplateEngineCollection.cs b/src/Pretzel.Logic/Commands/TemplateEngineCollection.cs
similarity index 95%
rename from src/Pretzel/Commands/TemplateEngineCollection.cs
rename to src/Pretzel.Logic/Commands/TemplateEngineCollection.cs
index a19548096..355e61d41 100644
--- a/src/Pretzel/Commands/TemplateEngineCollection.cs
+++ b/src/Pretzel.Logic/Commands/TemplateEngineCollection.cs
@@ -3,13 +3,13 @@
 using System.Composition;
 using Pretzel.Logic.Templating;
 
-namespace Pretzel.Commands
+namespace Pretzel.Logic.Commands
 {
     [Export]
     [Shared]
     public sealed class TemplateEngineCollection
     {
-        [ImportMany] 
+        [ImportMany]
 #pragma warning disable 649
         public ExportFactory<ISiteEngine, SiteEngineInfoAttribute>[] templateEngineMap { get; set; }
 #pragma warning restore 649
diff --git a/src/Pretzel/Commands/VersionCommand.cs b/src/Pretzel.Logic/Commands/VersionCommand.cs
similarity index 94%
rename from src/Pretzel/Commands/VersionCommand.cs
rename to src/Pretzel.Logic/Commands/VersionCommand.cs
index 2491eeded..1c85ddb90 100644
--- a/src/Pretzel/Commands/VersionCommand.cs
+++ b/src/Pretzel.Logic/Commands/VersionCommand.cs
@@ -4,10 +4,9 @@
 using System.Composition;
 using System.Reflection;
 using System.Threading.Tasks;
-using Pretzel.Logic.Commands;
 using Pretzel.Logic.Extensions;
 
-namespace Pretzel.Commands
+namespace Pretzel.Logic.Commands
 {
     [Shared]
     [Export]
diff --git a/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs b/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs
index 535e51b0d..24aae6379 100644
--- a/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs
+++ b/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs
@@ -11,7 +11,7 @@ namespace Pretzel.Logic.Extensibility.Extensions
 {
     [Export]
     [Shared]
-    [CommandArgumentsExtension(CommandArgumentTypes = new[] { typeof(IRecipeCommandArguments) })]
+    [CommandArgumentsExtension(CommandArgumentTypes = new[] { typeof(RecipeCommandArguments) })]
     public class AzureHostSupportArguments : ICommandArgumentsExtension
     {
         public IList<Option> Options { get; } = new[]
diff --git a/src/Pretzel.Logic/Extensibility/Extensions/VirtualDirectorySupport.cs b/src/Pretzel.Logic/Extensibility/Extensions/VirtualDirectorySupport.cs
index 2be31bb6f..224376b77 100644
--- a/src/Pretzel.Logic/Extensibility/Extensions/VirtualDirectorySupport.cs
+++ b/src/Pretzel.Logic/Extensibility/Extensions/VirtualDirectorySupport.cs
@@ -11,7 +11,7 @@ namespace Pretzel.Logic.Extensibility.Extensions
 {
     [Export]
     [Shared]
-    [CommandArgumentsExtension(CommandArgumentTypes = new[] { typeof(IBakeCommandArguments), typeof(ITasteCommandArguments) })]
+    [CommandArgumentsExtension(CommandArgumentTypes = new[] { typeof(BakeCommandArguments), typeof(TasteCommandArguments) })]
     public class VirtualDirectorySupportArguments : ICommandArgumentsExtension
     {
         public IList<Option> Options { get; } = new[]
diff --git a/src/Pretzel/WebHost/FileContentProvider.cs b/src/Pretzel.Logic/Hosting/FileContentProvider.cs
similarity index 90%
rename from src/Pretzel/WebHost/FileContentProvider.cs
rename to src/Pretzel.Logic/Hosting/FileContentProvider.cs
index d1bb7ed10..fce5a3477 100644
--- a/src/Pretzel/WebHost/FileContentProvider.cs
+++ b/src/Pretzel.Logic/Hosting/FileContentProvider.cs
@@ -1,8 +1,9 @@
-using System;
+using System;
 using System.Linq;
 using System.IO;
+using System.Web;
 
-namespace Pretzel
+namespace Pretzel.Logic.Hosting
 {
     public class FileContentProvider : IWebContent
     {
@@ -96,12 +97,12 @@ public byte[] GetBinaryContent(string request)
 
         private static readonly string[] defaultPages = { "index.html", "index.htm", "default.htm", "default.html", "index.xml" };
 
-    	/// <summary>
-    	/// Get the path for the page to send to the user
-    	/// </summary>
-    	/// <param name="request"> </param>
-    	/// <returns>Path to file</returns>
-    	private string GetRequestedPage(string request)
+        /// <summary>
+        /// Get the path for the page to send to the user
+        /// </summary>
+        /// <param name="request"> </param>
+        /// <returns>Path to file</returns>
+        private string GetRequestedPage(string request)
         {
             string requestString = GetFullPath(request);
 
@@ -126,7 +127,7 @@ private string GetRequestedPage(string request)
         /// <returns>Path to the file</returns>
         private string GetFullPath(string request)
         {
-            return System.Web.HttpUtility.UrlDecode(Path.Combine(basePath + request));
+            return HttpUtility.UrlDecode(Path.Combine(basePath + request));
         }
     }
 }
diff --git a/src/Pretzel/WebHost/IWebContent.cs b/src/Pretzel.Logic/Hosting/IWebContent.cs
similarity index 84%
rename from src/Pretzel/WebHost/IWebContent.cs
rename to src/Pretzel.Logic/Hosting/IWebContent.cs
index f787b0220..476023b91 100644
--- a/src/Pretzel/WebHost/IWebContent.cs
+++ b/src/Pretzel.Logic/Hosting/IWebContent.cs
@@ -1,6 +1,6 @@
-using System;
+using System;
 
-namespace Pretzel
+namespace Pretzel.Logic.Hosting
 {
     public interface IWebContent
     {
@@ -10,4 +10,4 @@ public interface IWebContent
         string GetContent(string request);
         byte[] GetBinaryContent(string request);
     }
-}
\ No newline at end of file
+}
diff --git a/src/Pretzel/WebHost/WebHost.cs b/src/Pretzel.Logic/Hosting/WebHost.cs
similarity index 95%
rename from src/Pretzel/WebHost/WebHost.cs
rename to src/Pretzel.Logic/Hosting/WebHost.cs
index 71c8243a3..a03cfbfc7 100644
--- a/src/Pretzel/WebHost/WebHost.cs
+++ b/src/Pretzel.Logic/Hosting/WebHost.cs
@@ -1,11 +1,11 @@
-using System;
+using System;
 using System.Globalization;
 using System.Threading.Tasks;
 using Pretzel.Logic.Extensions;
 using Owin;
 using Microsoft.Owin.Hosting;
 
-namespace Pretzel
+namespace Pretzel.Logic.Hosting
 {
     public class WebHost : IDisposable
     {
@@ -82,7 +82,7 @@ public void Configuration(IAppBuilder app)
                     {
                         context.Response.ContentType = path.MimeType();
                         var fileContents = Content.GetBinaryContent(path);
-                        context.Response.Headers["Content-Range"] = string.Format("bytes 0-{0}", (fileContents.Length - 1));
+                        context.Response.Headers["Content-Range"] = string.Format("bytes 0-{0}", fileContents.Length - 1);
                         context.Response.Headers["Content-Length"] = fileContents.Length.ToString(CultureInfo.InvariantCulture);
                         return context.Response.WriteAsync(fileContents);
                     }
@@ -91,7 +91,7 @@ public void Configuration(IAppBuilder app)
                     {
                         // if path is a directory without trailing slash, redirects to the same url with a trailing slash
                         context.Response.StatusCode = 301;
-                        context.Response.Headers["location"] = String.Format("http://localhost:{0}{1}/", context.Request.LocalPort, path);
+                        context.Response.Headers["location"] = string.Format("http://localhost:{0}{1}/", context.Request.LocalPort, path);
                         return Task.Delay(0);
                     }
 
diff --git a/src/Pretzel/Modules/IFileSystemWatcher.cs b/src/Pretzel.Logic/Modules/IFileSystemWatcher.cs
similarity index 72%
rename from src/Pretzel/Modules/IFileSystemWatcher.cs
rename to src/Pretzel.Logic/Modules/IFileSystemWatcher.cs
index da8fa7955..2a2d96967 100644
--- a/src/Pretzel/Modules/IFileSystemWatcher.cs
+++ b/src/Pretzel.Logic/Modules/IFileSystemWatcher.cs
@@ -1,9 +1,9 @@
-using System;
+using System;
 
-namespace Pretzel.Modules
+namespace Pretzel.Logic.Modules
 {
     public interface IFileSystemWatcher
     {
         void OnChange(string path, Action<string> fileChangedCallback);
     }
-}
\ No newline at end of file
+}
diff --git a/src/Pretzel/Modules/SimpleFileSystemWatcher.cs b/src/Pretzel.Logic/Modules/SimpleFileSystemWatcher.cs
similarity index 97%
rename from src/Pretzel/Modules/SimpleFileSystemWatcher.cs
rename to src/Pretzel.Logic/Modules/SimpleFileSystemWatcher.cs
index 14bba706a..568ae8647 100644
--- a/src/Pretzel/Modules/SimpleFileSystemWatcher.cs
+++ b/src/Pretzel.Logic/Modules/SimpleFileSystemWatcher.cs
@@ -1,7 +1,7 @@
 using System;
 using System.IO;
 
-namespace Pretzel.Modules
+namespace Pretzel.Logic.Modules
 {
     public class SimpleFileSystemWatcher : IFileSystemWatcher, IDisposable
     {
diff --git a/src/Pretzel.Logic/Pretzel.Logic.csproj b/src/Pretzel.Logic/Pretzel.Logic.csproj
index abf3ece37..6c8648c7c 100644
--- a/src/Pretzel.Logic/Pretzel.Logic.csproj
+++ b/src/Pretzel.Logic/Pretzel.Logic.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <ProductVersion>8.0.30703</ProductVersion>
     <TargetFrameworks>net462;netstandard2.0</TargetFrameworks>
@@ -27,6 +27,11 @@
     <DefineConstants>NETSTANDARD</DefineConstants>
   </PropertyGroup>
   <ItemGroup>
+    <PackageReference Include="Microsoft.Owin" Version="4.0.1" />
+    <PackageReference Include="Microsoft.Owin.Hosting" Version="4.0.1" />
+    <PackageReference Include="Nowin" Version="0.26.0" />
+    <PackageReference Include="Owin" Version="1.0" />
+    <PackageReference Include="Owin.Builder" Version="0.8.5" />
     <PackageReference Include="CommonMark.NET" Version="0.15.1" />
     <PackageReference Include="CsvHelper" Version="12.1.2" />
     <PackageReference Include="dotless.Core" Version="1.6.7" />
@@ -44,9 +49,10 @@
     <PackageReference Include="YamlDotNet" Version="6.1.2" />
     <PackageReference Include="System.Composition" Version="1.2.0" />
   </ItemGroup>
-  <ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == 'net462'">
     <Reference Include="System.Data.DataSetExtensions" />
     <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Web" />
   </ItemGroup>
   <ItemGroup>
     <Compile Update="Properties\Liquid.Designer.cs">
diff --git a/src/Pretzel.Logic/Recipe/Ingredient.cs b/src/Pretzel.Logic/Recipes/Ingredient.cs
similarity index 90%
rename from src/Pretzel.Logic/Recipe/Ingredient.cs
rename to src/Pretzel.Logic/Recipes/Ingredient.cs
index af61f3431..916a0af1d 100644
--- a/src/Pretzel.Logic/Recipe/Ingredient.cs
+++ b/src/Pretzel.Logic/Recipes/Ingredient.cs
@@ -1,9 +1,9 @@
-using System;
+using System;
 using System.IO.Abstractions;
 using Pretzel.Logic.Extensibility.Extensions;
 using Pretzel.Logic.Extensions;
 
-namespace Pretzel.Logic.Recipe
+namespace Pretzel.Logic.Recipes
 {
     public class Ingredient
     {
@@ -25,7 +25,7 @@ public Ingredient(IFileSystem fileSystem, string title, string directory, bool w
 
         public void Create()
         {
-            var postPath = fileSystem.Path.Combine(directory, !this.withDrafts ? @"_posts" : @"_drafts");
+            var postPath = fileSystem.Path.Combine(directory, !withDrafts ? @"_posts" : @"_drafts");
 
             var postName = string.Format("{0}-{1}.md", DateTime.Today.ToString("yyyy-MM-dd"), SlugifyFilter.Slugify(title));
             var pageContents = string.Format("---\r\n layout: post \r\n title: {0}\r\n comments: true\r\n---\r\n", title);
@@ -47,4 +47,4 @@ public void Create()
             Tracing.Info("Created the \"{0}\" post ({1})", title, postName);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/Pretzel.Logic/Recipe/Recipe.cs b/src/Pretzel.Logic/Recipes/Recipe.cs
similarity index 99%
rename from src/Pretzel.Logic/Recipe/Recipe.cs
rename to src/Pretzel.Logic/Recipes/Recipe.cs
index 39bac9fbd..ff7808fdf 100644
--- a/src/Pretzel.Logic/Recipe/Recipe.cs
+++ b/src/Pretzel.Logic/Recipes/Recipe.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Drawing.Imaging;
 using System.IO;
@@ -6,7 +6,7 @@
 using Pretzel.Logic.Extensibility;
 using Pretzel.Logic.Extensions;
 
-namespace Pretzel.Logic.Recipe
+namespace Pretzel.Logic.Recipes
 {
     public class Recipe
     {
diff --git a/src/Pretzel.Tests/Commands/BakeCommandArgumentsTests.cs b/src/Pretzel.Tests/Commands/BakeCommandArgumentsTests.cs
index fa58ec78a..fdb97392a 100644
--- a/src/Pretzel.Tests/Commands/BakeCommandArgumentsTests.cs
+++ b/src/Pretzel.Tests/Commands/BakeCommandArgumentsTests.cs
@@ -1,7 +1,7 @@
 using System;
 using System.IO.Abstractions;
 using System.Linq;
-using Pretzel.Commands;
+using Pretzel.Logic.Commands;
 
 namespace Pretzel.Tests.Commands
 {
diff --git a/src/Pretzel.Tests/Commands/ImportCommandArgumentsTests.cs b/src/Pretzel.Tests/Commands/ImportCommandArgumentsTests.cs
index bf9350a33..231e8768a 100644
--- a/src/Pretzel.Tests/Commands/ImportCommandArgumentsTests.cs
+++ b/src/Pretzel.Tests/Commands/ImportCommandArgumentsTests.cs
@@ -1,7 +1,7 @@
 using System;
 using System.IO.Abstractions;
 using System.Linq;
-using Pretzel.Commands;
+using Pretzel.Logic.Commands;
 using Xunit;
 
 namespace Pretzel.Tests.Commands
diff --git a/src/Pretzel.Tests/Commands/IngredientCommandArgumentsTests.cs b/src/Pretzel.Tests/Commands/IngredientCommandArgumentsTests.cs
index 93c8a8a5d..7d3e50244 100644
--- a/src/Pretzel.Tests/Commands/IngredientCommandArgumentsTests.cs
+++ b/src/Pretzel.Tests/Commands/IngredientCommandArgumentsTests.cs
@@ -1,7 +1,7 @@
 using System;
 using System.IO.Abstractions;
 using System.Linq;
-using Pretzel.Commands;
+using Pretzel.Logic.Commands;
 using Xunit;
 
 namespace Pretzel.Tests.Commands
diff --git a/src/Pretzel.Tests/Commands/RecipeCommandArgumentsTests.cs b/src/Pretzel.Tests/Commands/RecipeCommandArgumentsTests.cs
index df3091698..81a5a5072 100644
--- a/src/Pretzel.Tests/Commands/RecipeCommandArgumentsTests.cs
+++ b/src/Pretzel.Tests/Commands/RecipeCommandArgumentsTests.cs
@@ -1,7 +1,7 @@
 using System;
 using System.IO.Abstractions;
 using System.Linq;
-using Pretzel.Commands;
+using Pretzel.Logic.Commands;
 using Xunit;
 
 namespace Pretzel.Tests.Commands
diff --git a/src/Pretzel.Tests/Commands/TasteCommandArgumentsTests.cs b/src/Pretzel.Tests/Commands/TasteCommandArgumentsTests.cs
index 40f4f7c07..ebae843d9 100644
--- a/src/Pretzel.Tests/Commands/TasteCommandArgumentsTests.cs
+++ b/src/Pretzel.Tests/Commands/TasteCommandArgumentsTests.cs
@@ -1,7 +1,7 @@
 using System;
 using System.IO.Abstractions;
 using System.Linq;
-using Pretzel.Commands;
+using Pretzel.Logic.Commands;
 using Xunit;
 
 namespace Pretzel.Tests.Commands
diff --git a/src/Pretzel.Tests/Recipe/IngredientTests.cs b/src/Pretzel.Tests/Recipe/IngredientTests.cs
index d40c92751..dbde568c3 100644
--- a/src/Pretzel.Tests/Recipe/IngredientTests.cs
+++ b/src/Pretzel.Tests/Recipe/IngredientTests.cs
@@ -2,6 +2,7 @@
 using Pretzel.Logic.Extensibility;
 using Pretzel.Logic.Extensibility.Extensions;
 using Pretzel.Logic.Extensions;
+using Pretzel.Logic.Recipes;
 using System;
 using System.Collections.Generic;
 using System.Globalization;
@@ -38,7 +39,7 @@ public void Post_Is_Created()
             var postTitle = "Post title";
             var postName = string.Format("{0}-{1}.md", DateTime.Today.ToString("yyyy-MM-dd"), SlugifyFilter.Slugify(postTitle));
 
-            var ingredient = new Logic.Recipe.Ingredient(fileSystem, postTitle, BaseSite, false);
+            var ingredient = new Ingredient(fileSystem, postTitle, BaseSite, false);
             ingredient.Create();
 
             Assert.True(fileSystem.File.Exists(fileSystem.Path.Combine(BaseSite + PostsFolder, postName)));
@@ -52,7 +53,7 @@ public void Post_Has_Correct_Content()
             var expectedContent = string.Format("---\r\n layout: post \r\n title: {0}\r\n comments: true\r\n---\r\n", postTitle);
             var postName = string.Format("{0}-{1}.md", DateTime.Today.ToString("yyyy-MM-dd"), SlugifyFilter.Slugify(postTitle));
 
-            var ingredient = new Logic.Recipe.Ingredient(fileSystem, "Post title", BaseSite, false);
+            var ingredient = new Ingredient(fileSystem, "Post title", BaseSite, false);
             ingredient.Create();
 
             Assert.Equal(expectedContent, fileSystem.File.ReadAllText(fileSystem.Path.Combine(BaseSite + PostsFolder, postName)));
@@ -65,7 +66,7 @@ public void Post_Already_Exists()
             var postTitle = "Post title";
             var postName = string.Format("{0}-{1}.md", DateTime.Today.ToString("yyyy-MM-dd"), SlugifyFilter.Slugify(postTitle));
 
-            var ingredient = new Logic.Recipe.Ingredient(fileSystem, postTitle, BaseSite, false);
+            var ingredient = new Ingredient(fileSystem, postTitle, BaseSite, false);
             ingredient.Create();
             ingredient.Create();
 
@@ -75,7 +76,7 @@ public void Post_Already_Exists()
         [Fact]
         public void Post_Folder_Not_Found()
         {
-            var ingredient = new Logic.Recipe.Ingredient(fileSystem, string.Empty, BaseSite, false);
+            var ingredient = new Ingredient(fileSystem, string.Empty, BaseSite, false);
             ingredient.Create();
 
             Assert.Contains(string.Format(@"{0} folder not found", BaseSite + PostsFolder), trace.ToString());
@@ -84,7 +85,7 @@ public void Post_Folder_Not_Found()
         [Fact]
         public void Draft_Folder_Not_Found()
         {
-            var ingredient = new Logic.Recipe.Ingredient(fileSystem, string.Empty, BaseSite, true);
+            var ingredient = new Ingredient(fileSystem, string.Empty, BaseSite, true);
             ingredient.Create();
 
             Assert.Contains(string.Format(@"{0} folder not found", BaseSite + DraftsFolder), trace.ToString());
diff --git a/src/Pretzel.Tests/Recipe/RecipeTests.cs b/src/Pretzel.Tests/Recipe/RecipeTests.cs
index 270993c83..05ad6c421 100644
--- a/src/Pretzel.Tests/Recipe/RecipeTests.cs
+++ b/src/Pretzel.Tests/Recipe/RecipeTests.cs
@@ -30,7 +30,7 @@ public RecipeTests()
         [Fact]
         public void Files_and_Folders_Are_Created_for_Jekyll()
         {
-            var recipe = new Logic.Recipe.Recipe(fileSystem, "liquid", BaseSite, Enumerable.Empty<IAdditionalIngredient>(), false, false);
+            var recipe = new Logic.Recipes.Recipe(fileSystem, "liquid", BaseSite, Enumerable.Empty<IAdditionalIngredient>(), false, false);
             recipe.Create();
 
             Assert.True(fileSystem.Directory.Exists(BaseSite + @"_posts\"));
@@ -62,7 +62,7 @@ public void Files_and_Folders_Are_Created_for_Jekyll()
         [InlineData(false)]
         public void Files_and_Folders_Are_Created_for_Razor(bool wiki)
         {
-            var recipe = new Logic.Recipe.Recipe(fileSystem, "razor", BaseSite, Enumerable.Empty<IAdditionalIngredient>(), false, wiki);
+            var recipe = new Logic.Recipes.Recipe(fileSystem, "razor", BaseSite, Enumerable.Empty<IAdditionalIngredient>(), false, wiki);
             recipe.Create();
 
             Assert.True(fileSystem.Directory.Exists(BaseSite + @"_posts\"));
@@ -106,7 +106,7 @@ public void Files_and_Folders_Are_Created_for_Razor(bool wiki)
         public void Other_Engine_returns_error()
         {
             fileSystem = new MockFileSystem(new Dictionary<string, MockFileData>());
-            var recipe = new Logic.Recipe.Recipe(fileSystem, "Musak", BaseSite, Enumerable.Empty<IAdditionalIngredient>(), false, false);
+            var recipe = new Logic.Recipes.Recipe(fileSystem, "Musak", BaseSite, Enumerable.Empty<IAdditionalIngredient>(), false, false);
 
             recipe.Create();
 
@@ -118,7 +118,7 @@ public void can_mixin_additional_ingredients_for_razor()
         {
             fileSystem = new MockFileSystem(new Dictionary<string, MockFileData>());
             var additionalIngredient = Substitute.For<IAdditionalIngredient>();
-            var recipe = new Logic.Recipe.Recipe(fileSystem, "Razor", BaseSite, new[] { additionalIngredient }, false, false);
+            var recipe = new Logic.Recipes.Recipe(fileSystem, "Razor", BaseSite, new[] { additionalIngredient }, false, false);
             recipe.Create();
 
             additionalIngredient.Received().MixIn(BaseSite);
@@ -129,7 +129,7 @@ public void can_mixin_additional_ingredients_for_liquid()
         {
             fileSystem = new MockFileSystem(new Dictionary<string, MockFileData>());
             var additionalIngredient = Substitute.For<IAdditionalIngredient>();
-            var recipe = new Logic.Recipe.Recipe(fileSystem, "Liquid", BaseSite, new[] { additionalIngredient }, false, false);
+            var recipe = new Logic.Recipes.Recipe(fileSystem, "Liquid", BaseSite, new[] { additionalIngredient }, false, false);
             recipe.Create();
 
             additionalIngredient.Received().MixIn(BaseSite);
@@ -140,7 +140,7 @@ public void additional_ingredients_not_mixed_in_for_other_engine()
         {
             fileSystem = new MockFileSystem(new Dictionary<string, MockFileData>());
             var additionalIngredient = Substitute.For<IAdditionalIngredient>();
-            var recipe = new Logic.Recipe.Recipe(fileSystem, "Musak", BaseSite, new[] { additionalIngredient }, false, false);
+            var recipe = new Logic.Recipes.Recipe(fileSystem, "Musak", BaseSite, new[] { additionalIngredient }, false, false);
             recipe.Create();
 
             additionalIngredient.DidNotReceive().MixIn(BaseSite);
@@ -151,7 +151,7 @@ public void liquid_engine_with_wiki()
         {
             fileSystem = new MockFileSystem(new Dictionary<string, MockFileData>());
 
-            var recipe = new Logic.Recipe.Recipe(fileSystem, "liquid", BaseSite, Enumerable.Empty<IAdditionalIngredient>(), false, true);
+            var recipe = new Logic.Recipes.Recipe(fileSystem, "liquid", BaseSite, Enumerable.Empty<IAdditionalIngredient>(), false, true);
             recipe.Create();
 
             Assert.Contains("Wiki switch not valid with liquid templating engine", trace.ToString());
@@ -162,7 +162,7 @@ public void razor_engine_with_project()
         {
             fileSystem = new MockFileSystem(new Dictionary<string, MockFileData>());
 
-            var recipe = new Logic.Recipe.Recipe(fileSystem, "razor", BaseSite, Enumerable.Empty<IAdditionalIngredient>(), true, false);
+            var recipe = new Logic.Recipes.Recipe(fileSystem, "razor", BaseSite, Enumerable.Empty<IAdditionalIngredient>(), true, false);
             recipe.Create();
 
             Assert.Equal(40, fileSystem.AllPaths.Count());
@@ -194,7 +194,7 @@ public void error_is_traced()
             var fileSystemSubstitute = Substitute.For<IFileSystem>();
             fileSystemSubstitute.File.Returns(fileSubstitute);
 
-            var recipe = new Logic.Recipe.Recipe(fileSystemSubstitute, "liquid", BaseSite, Enumerable.Empty<IAdditionalIngredient>(), false, false);
+            var recipe = new Logic.Recipes.Recipe(fileSystemSubstitute, "liquid", BaseSite, Enumerable.Empty<IAdditionalIngredient>(), false, false);
             recipe.Create();
 
             Assert.Contains(@"Error trying to create template: System.Exception: Error!!!", trace.ToString());
@@ -205,7 +205,7 @@ public void error_is_traced()
         [Fact]
         public void Drafts_Folders_Is_Created()
         {
-            var recipe = new Logic.Recipe.Recipe(fileSystem, "liquid", BaseSite, Enumerable.Empty<IAdditionalIngredient>(), false, false, true);
+            var recipe = new Logic.Recipes.Recipe(fileSystem, "liquid", BaseSite, Enumerable.Empty<IAdditionalIngredient>(), false, false, true);
             recipe.Create();
 
             Assert.True(fileSystem.Directory.Exists(BaseSite + @"_drafts\"));
diff --git a/src/Pretzel/Pretzel.csproj b/src/Pretzel/Pretzel.csproj
index c5224c903..a8dc07422 100644
--- a/src/Pretzel/Pretzel.csproj
+++ b/src/Pretzel/Pretzel.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <Platform Condition=" '$(Platform)' == '' ">x86</Platform>
     <ProductVersion>8.0.30703</ProductVersion>
@@ -24,14 +24,10 @@
     <DebugType>pdbonly</DebugType>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="Microsoft.Owin" Version="4.0.1" />
-    <PackageReference Include="Microsoft.Owin.Hosting" Version="4.0.1" />
-    <PackageReference Include="Nowin" Version="0.26.0" />
-    <PackageReference Include="Owin" Version="1.0" />
-    <PackageReference Include="Owin.Builder" Version="0.8.5" />
     <PackageReference Include="SonarAnalyzer.CSharp" Version="7.16.0.8981">
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
+    <PackageReference Include="System.Runtime.Extensions" Version="4.3.1" />
   </ItemGroup>
   <ItemGroup>
     <Reference Include="System.Data.DataSetExtensions" />
diff --git a/src/Pretzel/Properties/launchSettings.json b/src/Pretzel/Properties/launchSettings.json
index 74bf7ea00..acee9b330 100644
--- a/src/Pretzel/Properties/launchSettings.json
+++ b/src/Pretzel/Properties/launchSettings.json
@@ -2,8 +2,7 @@
   "profiles": {
     "Pretzel": {
       "commandName": "Project",
-      "commandLineArgs": "taste",
-      "workingDirectory": "c:\\f\\git\\Scissors.Blog"
+      "commandLineArgs": "taste -s c:\\f\\git\\Scissors.Blog --debug"
     }
   }
 }
\ No newline at end of file

From 641f690b454fffd8f990a885ec6f16567e1177dc Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Mon, 7 Oct 2019 08:38:39 +0200
Subject: [PATCH 53/56] refactor: removed redundant naming

---
 src/Pretzel.Logic/Commands/BakeCommand.cs      |  6 +++---
 .../Commands/CommandInfoAttribute.cs           |  6 +++---
 src/Pretzel.Logic/Commands/HungryCommand.cs    |  6 +++---
 src/Pretzel.Logic/Commands/ICommand.cs         |  2 +-
 src/Pretzel.Logic/Commands/ImportCommand.cs    |  6 +++---
 .../Commands/IngredientCommand.cs              |  6 +++---
 src/Pretzel.Logic/Commands/RecipeCommand.cs    |  6 +++---
 src/Pretzel.Logic/Commands/TasteCommand.cs     |  6 +++---
 src/Pretzel.Logic/Commands/VersionCommand.cs   |  6 +++---
 .../Commands/CommandCollectionTests.cs         | 18 +++++++++---------
 src/Pretzel/Commands/CommandCollection.cs      |  4 ++--
 11 files changed, 36 insertions(+), 36 deletions(-)

diff --git a/src/Pretzel.Logic/Commands/BakeCommand.cs b/src/Pretzel.Logic/Commands/BakeCommand.cs
index 15fba23f5..45f250f75 100644
--- a/src/Pretzel.Logic/Commands/BakeCommand.cs
+++ b/src/Pretzel.Logic/Commands/BakeCommand.cs
@@ -22,9 +22,9 @@ public BakeCommandArguments(IFileSystem fileSystem) : base(fileSystem) { }
 
     [Shared]
     [CommandInfo(
-        CommandName = BuiltInCommands.Bake,
-        CommandDescription = "transforming content into a website",
-        CommandArgumentsType = typeof(BakeCommandArguments)
+        Name = BuiltInCommands.Bake,
+        Description = "transforming content into a website",
+        ArgumentsType = typeof(BakeCommandArguments)
         )]
     public sealed class BakeCommand : Command<BakeCommandArguments>
     {
diff --git a/src/Pretzel.Logic/Commands/CommandInfoAttribute.cs b/src/Pretzel.Logic/Commands/CommandInfoAttribute.cs
index 2ebcfbc09..4e73582c2 100644
--- a/src/Pretzel.Logic/Commands/CommandInfoAttribute.cs
+++ b/src/Pretzel.Logic/Commands/CommandInfoAttribute.cs
@@ -7,11 +7,11 @@ namespace Pretzel.Logic.Commands
     [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
     public sealed class CommandInfoAttribute : ExportAttribute
     {
-        public string CommandName { get; set; }
+        public string Name { get; set; }
 
-        public string CommandDescription { get; set; }
+        public string Description { get; set; }
 
-        public Type CommandArgumentsType { get; set; }
+        public Type ArgumentsType { get; set; }
 
         public CommandInfoAttribute() : base(typeof(ICommand))
         {
diff --git a/src/Pretzel.Logic/Commands/HungryCommand.cs b/src/Pretzel.Logic/Commands/HungryCommand.cs
index e4a9675c3..3e85d0018 100644
--- a/src/Pretzel.Logic/Commands/HungryCommand.cs
+++ b/src/Pretzel.Logic/Commands/HungryCommand.cs
@@ -18,9 +18,9 @@ public class HungryCommandArguments : BaseCommandArguments
     [Shared]
     [Export]
     [CommandInfo(
-        CommandName = BuiltInCommands.Hungry,
-        CommandDescription = "use only when hungry",
-        CommandArgumentsType = typeof(HungryCommandArguments)
+        Name = BuiltInCommands.Hungry,
+        Description = "use only when hungry",
+        ArgumentsType = typeof(HungryCommandArguments)
         )]
     public sealed class HungryCommand : Command<HungryCommandArguments>
     {
diff --git a/src/Pretzel.Logic/Commands/ICommand.cs b/src/Pretzel.Logic/Commands/ICommand.cs
index 16ff9070f..f9b69e046 100644
--- a/src/Pretzel.Logic/Commands/ICommand.cs
+++ b/src/Pretzel.Logic/Commands/ICommand.cs
@@ -9,7 +9,7 @@ namespace Pretzel.Logic.Commands
     public interface ICommand
     {
         /// <summary>
-        /// Executes the specified command with arguments provided defined in <see cref="CommandInfoAttribute.CommandArgumentsType"/>.
+        /// Executes the specified command with arguments provided defined in <see cref="CommandInfoAttribute.ArgumentsType"/>.
         /// </summary>
         /// <param name="arguments">The arguments.</param>
         /// <returns></returns>
diff --git a/src/Pretzel.Logic/Commands/ImportCommand.cs b/src/Pretzel.Logic/Commands/ImportCommand.cs
index 11098410f..71f960a77 100644
--- a/src/Pretzel.Logic/Commands/ImportCommand.cs
+++ b/src/Pretzel.Logic/Commands/ImportCommand.cs
@@ -37,9 +37,9 @@ protected override IEnumerable<Option> CreateOptions() => base.CreateOptions().C
 
     [Shared]
     [CommandInfo(
-        CommandName = BuiltInCommands.Import,
-        CommandDescription = "import posts from external source",
-        CommandArgumentsType = typeof(ImportCommandArguments)
+        Name = BuiltInCommands.Import,
+        Description = "import posts from external source",
+        ArgumentsType = typeof(ImportCommandArguments)
         )]
     class ImportCommand : Command<ImportCommandArguments>
     {
diff --git a/src/Pretzel.Logic/Commands/IngredientCommand.cs b/src/Pretzel.Logic/Commands/IngredientCommand.cs
index dd9f5325a..957e7ad3d 100644
--- a/src/Pretzel.Logic/Commands/IngredientCommand.cs
+++ b/src/Pretzel.Logic/Commands/IngredientCommand.cs
@@ -31,9 +31,9 @@ protected override IEnumerable<Option> CreateOptions() => base.CreateOptions().C
 
     [Shared]
     [CommandInfo(
-        CommandName = BuiltInCommands.Ingredient,
-        CommandDescription = "create a new post",
-        CommandArgumentsType = typeof(IngredientCommandArguments))]
+        Name = BuiltInCommands.Ingredient,
+        Description = "create a new post",
+        ArgumentsType = typeof(IngredientCommandArguments))]
     public sealed class IngredientCommand : Command<IngredientCommandArguments>
     {
         [Import]
diff --git a/src/Pretzel.Logic/Commands/RecipeCommand.cs b/src/Pretzel.Logic/Commands/RecipeCommand.cs
index 86b901922..8713eae8f 100644
--- a/src/Pretzel.Logic/Commands/RecipeCommand.cs
+++ b/src/Pretzel.Logic/Commands/RecipeCommand.cs
@@ -37,9 +37,9 @@ protected override IEnumerable<Option> CreateOptions() => base.CreateOptions().C
 
     [Shared]
     [CommandInfo(
-        CommandName = BuiltInCommands.Create,
-        CommandDescription = "configure a new site",
-        CommandArgumentsType = typeof(RecipeCommandArguments)
+        Name = BuiltInCommands.Create,
+        Description = "configure a new site",
+        ArgumentsType = typeof(RecipeCommandArguments)
         )]
     public sealed class RecipeCommand : Command<RecipeCommandArguments>
     {
diff --git a/src/Pretzel.Logic/Commands/TasteCommand.cs b/src/Pretzel.Logic/Commands/TasteCommand.cs
index 25f04f0de..2095f086a 100644
--- a/src/Pretzel.Logic/Commands/TasteCommand.cs
+++ b/src/Pretzel.Logic/Commands/TasteCommand.cs
@@ -42,9 +42,9 @@ protected override IEnumerable<Option> CreateOptions() => base.CreateOptions().C
 
     [Shared]
     [CommandInfo(
-        CommandName = BuiltInCommands.Taste,
-        CommandDescription = "testing a site locally",
-        CommandArgumentsType = typeof(TasteCommandArguments)
+        Name = BuiltInCommands.Taste,
+        Description = "testing a site locally",
+        ArgumentsType = typeof(TasteCommandArguments)
         )]
     public sealed class TasteCommand : Command<TasteCommandArguments>
     {
diff --git a/src/Pretzel.Logic/Commands/VersionCommand.cs b/src/Pretzel.Logic/Commands/VersionCommand.cs
index 1c85ddb90..68786b7bc 100644
--- a/src/Pretzel.Logic/Commands/VersionCommand.cs
+++ b/src/Pretzel.Logic/Commands/VersionCommand.cs
@@ -18,9 +18,9 @@ public class VersionCommandArguments : BaseCommandArguments
 
     [Shared]
     [CommandInfo(
-        CommandName = BuiltInCommands.Version,
-        CommandDescription = "display current Pretzel version",
-        CommandArgumentsType = typeof(VersionCommandArguments)
+        Name = BuiltInCommands.Version,
+        Description = "display current Pretzel version",
+        ArgumentsType = typeof(VersionCommandArguments)
         )]
     public sealed class VersionCommand : Command<VersionCommandArguments>
     {
diff --git a/src/Pretzel.Tests/Commands/CommandCollectionTests.cs b/src/Pretzel.Tests/Commands/CommandCollectionTests.cs
index 1ecf172c6..4d859ce05 100644
--- a/src/Pretzel.Tests/Commands/CommandCollectionTests.cs
+++ b/src/Pretzel.Tests/Commands/CommandCollectionTests.cs
@@ -34,9 +34,9 @@ public void SubCommandAreAddedToRootCommand()
                 {
                     new ExportFactory<Logic.Commands.ICommand, CommandInfoAttribute>(CreateCommand, new CommandInfoAttribute
                     {
-                        CommandName = "test",
-                        CommandDescription = "desc",
-                        CommandArgumentsType = arguments.GetType()
+                        Name = "test",
+                        Description = "desc",
+                        ArgumentsType = arguments.GetType()
                     })
                 },
                 CommandArguments = new[] { arguments }
@@ -60,9 +60,9 @@ public void SubCommandsWithArgumentGetsHandler()
                 CreateCommand,
                 new CommandInfoAttribute
                 {
-                    CommandName = "test",
-                    CommandDescription = "desc",
-                    CommandArgumentsType = parameters.GetType()
+                    Name = "test",
+                    Description = "desc",
+                    ArgumentsType = parameters.GetType()
                 });
 
          
@@ -170,7 +170,7 @@ public void BindingCompleted() { }
 
             [Export]
             [Shared]
-            [CommandInfo(CommandName = "test1", CommandArgumentsType = typeof(TestCommandArguments1))]
+            [CommandInfo(Name = "test1", ArgumentsType = typeof(TestCommandArguments1))]
             public class TestCommand1 : Logic.Commands.ICommand
             {
                 public Task<int> Execute(ICommandArguments arguments)
@@ -197,7 +197,7 @@ public void BindingCompleted() { }
 
             [Export]
             [Shared]
-            [CommandInfo(CommandName = "test2", CommandArgumentsType = typeof(TestCommandArguments2))]
+            [CommandInfo(Name = "test2", ArgumentsType = typeof(TestCommandArguments2))]
             public class TestCommand2 : Logic.Commands.ICommand
             {
                 public Task<int> Execute(ICommandArguments arguments)
@@ -225,7 +225,7 @@ public void BindingCompleted() { }
 
             [Export]
             [Shared]
-            [CommandInfo(CommandName = "test3", CommandArgumentsType = typeof(ITestCommandArguments3))]
+            [CommandInfo(Name = "test3", ArgumentsType = typeof(ITestCommandArguments3))]
             public class TestCommand3 : Logic.Commands.ICommand
             {
                 public Task<int> Execute(ICommandArguments arguments)
diff --git a/src/Pretzel/Commands/CommandCollection.cs b/src/Pretzel/Commands/CommandCollection.cs
index 495c42bea..bf2ab7bd8 100644
--- a/src/Pretzel/Commands/CommandCollection.cs
+++ b/src/Pretzel/Commands/CommandCollection.cs
@@ -48,9 +48,9 @@ internal void OnImportsSatisfied()
 
             foreach (var command in Commands)
             {
-                var subCommand = new Command(command.Metadata.CommandName, command.Metadata.CommandDescription);
+                var subCommand = new Command(command.Metadata.Name, command.Metadata.Description);
 
-                var argument = CommandArguments.First(c => command.Metadata.CommandArgumentsType.IsAssignableFrom(c.GetType()));
+                var argument = CommandArguments.First(c => command.Metadata.ArgumentsType.IsAssignableFrom(c.GetType()));
 
                 if (argument is BaseCommandArguments baseCommandArguments)
                 {

From 67a30a4b98ba575f0f4ca2fb4bdb855b7d12bb81 Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Tue, 8 Oct 2019 14:37:02 +0200
Subject: [PATCH 54/56] fix: removed unused built in commands class

---
 src/Pretzel.Logic/Commands/BuiltInCommands.cs | 13 -------------
 1 file changed, 13 deletions(-)
 delete mode 100644 src/Pretzel.Logic/Commands/BuiltInCommands.cs

diff --git a/src/Pretzel.Logic/Commands/BuiltInCommands.cs b/src/Pretzel.Logic/Commands/BuiltInCommands.cs
deleted file mode 100644
index b2fa40de0..000000000
--- a/src/Pretzel.Logic/Commands/BuiltInCommands.cs
+++ /dev/null
@@ -1,13 +0,0 @@
-namespace Pretzel.Logic.Commands
-{
-    public static class BuiltInCommands
-    {
-        public const string Bake = "bake";
-        public const string Hungry = "hungry";
-        public const string Import = "import";
-        public const string Ingredient = "ingredient";
-        public const string Create = "create";
-        public const string Taste = "taste";
-        public const string Version = "version";
-    }
-}

From 1419e28e50b1d072fbd68419dbb3f92b0039bea4 Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Tue, 8 Oct 2019 14:41:19 +0200
Subject: [PATCH 55/56] fix: use attributes instead of build in command
 constants

---
 src/Pretzel.Logic/Commands/BakeCommand.cs       | 2 +-
 src/Pretzel.Logic/Commands/HungryCommand.cs     | 2 +-
 src/Pretzel.Logic/Commands/ImportCommand.cs     | 2 +-
 src/Pretzel.Logic/Commands/IngredientCommand.cs | 2 +-
 src/Pretzel.Logic/Commands/RecipeCommand.cs     | 2 +-
 src/Pretzel.Logic/Commands/TasteCommand.cs      | 2 +-
 src/Pretzel.Logic/Commands/VersionCommand.cs    | 2 +-
 7 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/Pretzel.Logic/Commands/BakeCommand.cs b/src/Pretzel.Logic/Commands/BakeCommand.cs
index 45f250f75..3f1fecd87 100644
--- a/src/Pretzel.Logic/Commands/BakeCommand.cs
+++ b/src/Pretzel.Logic/Commands/BakeCommand.cs
@@ -22,7 +22,7 @@ public BakeCommandArguments(IFileSystem fileSystem) : base(fileSystem) { }
 
     [Shared]
     [CommandInfo(
-        Name = BuiltInCommands.Bake,
+        Name = "bake",
         Description = "transforming content into a website",
         ArgumentsType = typeof(BakeCommandArguments)
         )]
diff --git a/src/Pretzel.Logic/Commands/HungryCommand.cs b/src/Pretzel.Logic/Commands/HungryCommand.cs
index 3e85d0018..534a86af5 100644
--- a/src/Pretzel.Logic/Commands/HungryCommand.cs
+++ b/src/Pretzel.Logic/Commands/HungryCommand.cs
@@ -18,7 +18,7 @@ public class HungryCommandArguments : BaseCommandArguments
     [Shared]
     [Export]
     [CommandInfo(
-        Name = BuiltInCommands.Hungry,
+        Name = "hungry",
         Description = "use only when hungry",
         ArgumentsType = typeof(HungryCommandArguments)
         )]
diff --git a/src/Pretzel.Logic/Commands/ImportCommand.cs b/src/Pretzel.Logic/Commands/ImportCommand.cs
index 71f960a77..6858381de 100644
--- a/src/Pretzel.Logic/Commands/ImportCommand.cs
+++ b/src/Pretzel.Logic/Commands/ImportCommand.cs
@@ -37,7 +37,7 @@ protected override IEnumerable<Option> CreateOptions() => base.CreateOptions().C
 
     [Shared]
     [CommandInfo(
-        Name = BuiltInCommands.Import,
+        Name = "import",
         Description = "import posts from external source",
         ArgumentsType = typeof(ImportCommandArguments)
         )]
diff --git a/src/Pretzel.Logic/Commands/IngredientCommand.cs b/src/Pretzel.Logic/Commands/IngredientCommand.cs
index 957e7ad3d..e78c6ed2b 100644
--- a/src/Pretzel.Logic/Commands/IngredientCommand.cs
+++ b/src/Pretzel.Logic/Commands/IngredientCommand.cs
@@ -31,7 +31,7 @@ protected override IEnumerable<Option> CreateOptions() => base.CreateOptions().C
 
     [Shared]
     [CommandInfo(
-        Name = BuiltInCommands.Ingredient,
+        Name = "ingredient",
         Description = "create a new post",
         ArgumentsType = typeof(IngredientCommandArguments))]
     public sealed class IngredientCommand : Command<IngredientCommandArguments>
diff --git a/src/Pretzel.Logic/Commands/RecipeCommand.cs b/src/Pretzel.Logic/Commands/RecipeCommand.cs
index 8713eae8f..d8a2adac2 100644
--- a/src/Pretzel.Logic/Commands/RecipeCommand.cs
+++ b/src/Pretzel.Logic/Commands/RecipeCommand.cs
@@ -37,7 +37,7 @@ protected override IEnumerable<Option> CreateOptions() => base.CreateOptions().C
 
     [Shared]
     [CommandInfo(
-        Name = BuiltInCommands.Create,
+        Name = "create",
         Description = "configure a new site",
         ArgumentsType = typeof(RecipeCommandArguments)
         )]
diff --git a/src/Pretzel.Logic/Commands/TasteCommand.cs b/src/Pretzel.Logic/Commands/TasteCommand.cs
index 2095f086a..b1e8a4203 100644
--- a/src/Pretzel.Logic/Commands/TasteCommand.cs
+++ b/src/Pretzel.Logic/Commands/TasteCommand.cs
@@ -42,7 +42,7 @@ protected override IEnumerable<Option> CreateOptions() => base.CreateOptions().C
 
     [Shared]
     [CommandInfo(
-        Name = BuiltInCommands.Taste,
+        Name = "taste",
         Description = "testing a site locally",
         ArgumentsType = typeof(TasteCommandArguments)
         )]
diff --git a/src/Pretzel.Logic/Commands/VersionCommand.cs b/src/Pretzel.Logic/Commands/VersionCommand.cs
index 68786b7bc..4519f43d4 100644
--- a/src/Pretzel.Logic/Commands/VersionCommand.cs
+++ b/src/Pretzel.Logic/Commands/VersionCommand.cs
@@ -18,7 +18,7 @@ public class VersionCommandArguments : BaseCommandArguments
 
     [Shared]
     [CommandInfo(
-        Name = BuiltInCommands.Version,
+        Name = "version",
         Description = "display current Pretzel version",
         ArgumentsType = typeof(VersionCommandArguments)
         )]

From 5455afc6a04487827fbc22771437fb6fbdbbb6d8 Mon Sep 17 00:00:00 2001
From: Manuel Grundner <m.grundner@delegate.at>
Date: Tue, 8 Oct 2019 14:58:41 +0200
Subject: [PATCH 56/56] feat: extend command arguments by command name

---
 src/Pretzel.Logic/Commands/BakeCommand.cs     |  3 +-
 .../Commands/CommandInfoAttribute.cs          |  2 ++
 src/Pretzel.Logic/Commands/HungryCommand.cs   |  3 +-
 src/Pretzel.Logic/Commands/ImportCommand.cs   |  5 ++--
 .../Commands/IngredientCommand.cs             |  4 ++-
 src/Pretzel.Logic/Commands/RecipeCommand.cs   |  3 +-
 src/Pretzel.Logic/Commands/TasteCommand.cs    |  3 +-
 src/Pretzel.Logic/Commands/VersionCommand.cs  |  3 +-
 .../CommandArgumentsExtensionAttribute.cs     |  2 +-
 .../Extensions/AzureHostSupport.cs            |  2 +-
 .../Extensions/VirtualDirectorySupport.cs     |  2 +-
 .../Commands/CommandCollectionTests.cs        | 28 +++++++++----------
 .../Commands/PretzelCommandHandlerTests.cs    |  2 +-
 src/Pretzel/Commands/CommandCollection.cs     |  2 +-
 14 files changed, 36 insertions(+), 28 deletions(-)

diff --git a/src/Pretzel.Logic/Commands/BakeCommand.cs b/src/Pretzel.Logic/Commands/BakeCommand.cs
index 3f1fecd87..550503c6e 100644
--- a/src/Pretzel.Logic/Commands/BakeCommand.cs
+++ b/src/Pretzel.Logic/Commands/BakeCommand.cs
@@ -24,7 +24,8 @@ public BakeCommandArguments(IFileSystem fileSystem) : base(fileSystem) { }
     [CommandInfo(
         Name = "bake",
         Description = "transforming content into a website",
-        ArgumentsType = typeof(BakeCommandArguments)
+        ArgumentsType = typeof(BakeCommandArguments),
+        CommandType = typeof(BakeCommand)
         )]
     public sealed class BakeCommand : Command<BakeCommandArguments>
     {
diff --git a/src/Pretzel.Logic/Commands/CommandInfoAttribute.cs b/src/Pretzel.Logic/Commands/CommandInfoAttribute.cs
index 4e73582c2..5106fe238 100644
--- a/src/Pretzel.Logic/Commands/CommandInfoAttribute.cs
+++ b/src/Pretzel.Logic/Commands/CommandInfoAttribute.cs
@@ -13,6 +13,8 @@ public sealed class CommandInfoAttribute : ExportAttribute
 
         public Type ArgumentsType { get; set; }
 
+        public Type CommandType { get; set; }
+
         public CommandInfoAttribute() : base(typeof(ICommand))
         {
         }
diff --git a/src/Pretzel.Logic/Commands/HungryCommand.cs b/src/Pretzel.Logic/Commands/HungryCommand.cs
index 534a86af5..c9c34e7f5 100644
--- a/src/Pretzel.Logic/Commands/HungryCommand.cs
+++ b/src/Pretzel.Logic/Commands/HungryCommand.cs
@@ -20,7 +20,8 @@ public class HungryCommandArguments : BaseCommandArguments
     [CommandInfo(
         Name = "hungry",
         Description = "use only when hungry",
-        ArgumentsType = typeof(HungryCommandArguments)
+        ArgumentsType = typeof(HungryCommandArguments),
+        CommandType = typeof(HungryCommand)
         )]
     public sealed class HungryCommand : Command<HungryCommandArguments>
     {
diff --git a/src/Pretzel.Logic/Commands/ImportCommand.cs b/src/Pretzel.Logic/Commands/ImportCommand.cs
index 6858381de..1e67c032f 100644
--- a/src/Pretzel.Logic/Commands/ImportCommand.cs
+++ b/src/Pretzel.Logic/Commands/ImportCommand.cs
@@ -39,9 +39,10 @@ protected override IEnumerable<Option> CreateOptions() => base.CreateOptions().C
     [CommandInfo(
         Name = "import",
         Description = "import posts from external source",
-        ArgumentsType = typeof(ImportCommandArguments)
+        ArgumentsType = typeof(ImportCommandArguments),
+        CommandType = typeof(ImportCommand)
         )]
-    class ImportCommand : Command<ImportCommandArguments>
+    public sealed class ImportCommand : Command<ImportCommandArguments>
     {
         readonly static List<string> Importers = new List<string>(new[] { "wordpress", "blogger" });
 
diff --git a/src/Pretzel.Logic/Commands/IngredientCommand.cs b/src/Pretzel.Logic/Commands/IngredientCommand.cs
index e78c6ed2b..c7713e1cb 100644
--- a/src/Pretzel.Logic/Commands/IngredientCommand.cs
+++ b/src/Pretzel.Logic/Commands/IngredientCommand.cs
@@ -33,7 +33,9 @@ protected override IEnumerable<Option> CreateOptions() => base.CreateOptions().C
     [CommandInfo(
         Name = "ingredient",
         Description = "create a new post",
-        ArgumentsType = typeof(IngredientCommandArguments))]
+        ArgumentsType = typeof(IngredientCommandArguments),
+        CommandType = typeof(IngredientCommand)
+        )]
     public sealed class IngredientCommand : Command<IngredientCommandArguments>
     {
         [Import]
diff --git a/src/Pretzel.Logic/Commands/RecipeCommand.cs b/src/Pretzel.Logic/Commands/RecipeCommand.cs
index d8a2adac2..e37816273 100644
--- a/src/Pretzel.Logic/Commands/RecipeCommand.cs
+++ b/src/Pretzel.Logic/Commands/RecipeCommand.cs
@@ -39,7 +39,8 @@ protected override IEnumerable<Option> CreateOptions() => base.CreateOptions().C
     [CommandInfo(
         Name = "create",
         Description = "configure a new site",
-        ArgumentsType = typeof(RecipeCommandArguments)
+        ArgumentsType = typeof(RecipeCommandArguments),
+        CommandType = typeof(RecipeCommand)
         )]
     public sealed class RecipeCommand : Command<RecipeCommandArguments>
     {
diff --git a/src/Pretzel.Logic/Commands/TasteCommand.cs b/src/Pretzel.Logic/Commands/TasteCommand.cs
index b1e8a4203..8dfb4b309 100644
--- a/src/Pretzel.Logic/Commands/TasteCommand.cs
+++ b/src/Pretzel.Logic/Commands/TasteCommand.cs
@@ -44,7 +44,8 @@ protected override IEnumerable<Option> CreateOptions() => base.CreateOptions().C
     [CommandInfo(
         Name = "taste",
         Description = "testing a site locally",
-        ArgumentsType = typeof(TasteCommandArguments)
+        ArgumentsType = typeof(TasteCommandArguments),
+        CommandType = typeof(TasteCommand)
         )]
     public sealed class TasteCommand : Command<TasteCommandArguments>
     {
diff --git a/src/Pretzel.Logic/Commands/VersionCommand.cs b/src/Pretzel.Logic/Commands/VersionCommand.cs
index 4519f43d4..70dbab80a 100644
--- a/src/Pretzel.Logic/Commands/VersionCommand.cs
+++ b/src/Pretzel.Logic/Commands/VersionCommand.cs
@@ -20,7 +20,8 @@ public class VersionCommandArguments : BaseCommandArguments
     [CommandInfo(
         Name = "version",
         Description = "display current Pretzel version",
-        ArgumentsType = typeof(VersionCommandArguments)
+        ArgumentsType = typeof(VersionCommandArguments),
+        CommandType = typeof(VersionCommand)
         )]
     public sealed class VersionCommand : Command<VersionCommandArguments>
     {
diff --git a/src/Pretzel.Logic/Extensibility/CommandArgumentsExtensionAttribute.cs b/src/Pretzel.Logic/Extensibility/CommandArgumentsExtensionAttribute.cs
index 57a588344..cadea05ab 100644
--- a/src/Pretzel.Logic/Extensibility/CommandArgumentsExtensionAttribute.cs
+++ b/src/Pretzel.Logic/Extensibility/CommandArgumentsExtensionAttribute.cs
@@ -7,7 +7,7 @@ namespace Pretzel.Logic.Extensibility
     [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
     public sealed class CommandArgumentsExtensionAttribute : ExportAttribute
     {
-        public Type[] CommandArgumentTypes { get; set; }
+        public Type[] CommandTypes { get; set; }
 
         public CommandArgumentsExtensionAttribute() : base(typeof(ICommandArgumentsExtension))
         {
diff --git a/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs b/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs
index 24aae6379..b545eb191 100644
--- a/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs
+++ b/src/Pretzel.Logic/Extensibility/Extensions/AzureHostSupport.cs
@@ -11,7 +11,7 @@ namespace Pretzel.Logic.Extensibility.Extensions
 {
     [Export]
     [Shared]
-    [CommandArgumentsExtension(CommandArgumentTypes = new[] { typeof(RecipeCommandArguments) })]
+    [CommandArgumentsExtension(CommandTypes = new[] { typeof(RecipeCommand) })]
     public class AzureHostSupportArguments : ICommandArgumentsExtension
     {
         public IList<Option> Options { get; } = new[]
diff --git a/src/Pretzel.Logic/Extensibility/Extensions/VirtualDirectorySupport.cs b/src/Pretzel.Logic/Extensibility/Extensions/VirtualDirectorySupport.cs
index 224376b77..5ec2236ed 100644
--- a/src/Pretzel.Logic/Extensibility/Extensions/VirtualDirectorySupport.cs
+++ b/src/Pretzel.Logic/Extensibility/Extensions/VirtualDirectorySupport.cs
@@ -11,7 +11,7 @@ namespace Pretzel.Logic.Extensibility.Extensions
 {
     [Export]
     [Shared]
-    [CommandArgumentsExtension(CommandArgumentTypes = new[] { typeof(BakeCommandArguments), typeof(TasteCommandArguments) })]
+    [CommandArgumentsExtension(CommandTypes = new[] { typeof(BakeCommand), typeof(TasteCommand) })]
     public class VirtualDirectorySupportArguments : ICommandArgumentsExtension
     {
         public IList<Option> Options { get; } = new[]
diff --git a/src/Pretzel.Tests/Commands/CommandCollectionTests.cs b/src/Pretzel.Tests/Commands/CommandCollectionTests.cs
index 4d859ce05..d7e64785f 100644
--- a/src/Pretzel.Tests/Commands/CommandCollectionTests.cs
+++ b/src/Pretzel.Tests/Commands/CommandCollectionTests.cs
@@ -65,7 +65,7 @@ public void SubCommandsWithArgumentGetsHandler()
                     ArgumentsType = parameters.GetType()
                 });
 
-         
+
             var collection = new CommandCollection
             {
                 Configuration = Substitute.For<IConfiguration>(),
@@ -123,7 +123,7 @@ public void CollectsOnlyCommandsWhereNamesMatch1()
             {
                 Container.GetExport<CommandCollection>();
                 var target = Container.GetExport<TestCommandArguments1>();
-                
+
                 Assert.Equal(2, target.Extensions.Count);
                 Assert.Contains(target.Extensions, e => e is Extender1);
                 Assert.Contains(target.Extensions, e => e is Extender3);
@@ -134,7 +134,7 @@ public void CollectsOnlyCommandsWhereNamesMatch2()
             {
                 Container.GetExport<CommandCollection>();
                 var target = Container.GetExport<TestCommandArguments2>();
-                
+
                 Assert.Equal(2, target.Extensions.Count);
                 Assert.Contains(target.Extensions, e => e is Extender2);
                 Assert.Contains(target.Extensions, e => e is Extender3);
@@ -144,7 +144,7 @@ public void CollectsOnlyCommandsWhereNamesMatch2()
             public void CollectsOnlyCommandsWhereInterfacesAreExported()
             {
                 Container.GetExport<CommandCollection>();
-                var target = Container.GetExport<ITestCommandArguments3>();
+                var target = Container.GetExport<TestCommandArguments3>();
 
                 Assert.Equal(1, target.Extensions.Count);
                 Assert.Contains(target.Extensions, e => e is Extender4);
@@ -170,7 +170,7 @@ public void BindingCompleted() { }
 
             [Export]
             [Shared]
-            [CommandInfo(Name = "test1", ArgumentsType = typeof(TestCommandArguments1))]
+            [CommandInfo(Name = "test1", ArgumentsType = typeof(TestCommandArguments1), CommandType = typeof(TestCommand1))]
             public class TestCommand1 : Logic.Commands.ICommand
             {
                 public Task<int> Execute(ICommandArguments arguments)
@@ -197,7 +197,7 @@ public void BindingCompleted() { }
 
             [Export]
             [Shared]
-            [CommandInfo(Name = "test2", ArgumentsType = typeof(TestCommandArguments2))]
+            [CommandInfo(Name = "test2", ArgumentsType = typeof(TestCommandArguments2), CommandType = typeof(TestCommand2))]
             public class TestCommand2 : Logic.Commands.ICommand
             {
                 public Task<int> Execute(ICommandArguments arguments)
@@ -206,12 +206,10 @@ public Task<int> Execute(ICommandArguments arguments)
                 }
             }
 
-            public interface ITestCommandArguments3 : ICommandArguments { }
-
-            [Export(typeof(ITestCommandArguments3))]
+            [Export]
             [Shared]
             [CommandArguments]
-            public class TestCommandArguments3 : ITestCommandArguments3
+            public class TestCommandArguments3 : ICommandArguments
             {
                 [ImportMany]
                 public ExportFactory<ICommandArgumentsExtension, CommandArgumentsExtensionAttribute>[] ArgumentExtensions { get; set; }
@@ -225,7 +223,7 @@ public void BindingCompleted() { }
 
             [Export]
             [Shared]
-            [CommandInfo(Name = "test3", ArgumentsType = typeof(ITestCommandArguments3))]
+            [CommandInfo(Name = "test3", ArgumentsType = typeof(TestCommandArguments3), CommandType = typeof(TestCommand3))]
             public class TestCommand3 : Logic.Commands.ICommand
             {
                 public Task<int> Execute(ICommandArguments arguments)
@@ -234,7 +232,7 @@ public Task<int> Execute(ICommandArguments arguments)
                 }
             }
 
-            [CommandArgumentsExtension(CommandArgumentTypes = new[] { typeof(TestCommandArguments1) })]
+            [CommandArgumentsExtension(CommandTypes = new[] { typeof(TestCommand1) })]
             public class Extender1 : ICommandArgumentsExtension
             {
                 public IList<Option> Options { get; } = Array.Empty<Option>();
@@ -244,7 +242,7 @@ public void BindingCompleted()
                 }
             }
 
-            [CommandArgumentsExtension(CommandArgumentTypes = new[] { typeof(TestCommandArguments2) })]
+            [CommandArgumentsExtension(CommandTypes = new[] { typeof(TestCommand2) })]
             public class Extender2 : ICommandArgumentsExtension
             {
                 public IList<Option> Options { get; } = Array.Empty<Option>();
@@ -254,7 +252,7 @@ public void BindingCompleted()
                 }
             }
 
-            [CommandArgumentsExtension(CommandArgumentTypes = new[] { typeof(TestCommandArguments1), typeof(TestCommandArguments2) })]
+            [CommandArgumentsExtension(CommandTypes = new[] { typeof(TestCommand1), typeof(TestCommand2) })]
             public class Extender3 : ICommandArgumentsExtension
             {
                 public IList<Option> Options { get; } = Array.Empty<Option>();
@@ -264,7 +262,7 @@ public void BindingCompleted()
                 }
             }
 
-            [CommandArgumentsExtension(CommandArgumentTypes = new[] { typeof(ITestCommandArguments3) })]
+            [CommandArgumentsExtension(CommandTypes = new[] { typeof(TestCommand3) })]
             public class Extender4 : ICommandArgumentsExtension
             {
                 public IList<Option> Options { get; } = Array.Empty<Option>();
diff --git a/src/Pretzel.Tests/Commands/PretzelCommandHandlerTests.cs b/src/Pretzel.Tests/Commands/PretzelCommandHandlerTests.cs
index 3904c06fa..ec9a9dfea 100644
--- a/src/Pretzel.Tests/Commands/PretzelCommandHandlerTests.cs
+++ b/src/Pretzel.Tests/Commands/PretzelCommandHandlerTests.cs
@@ -128,7 +128,7 @@ public void BindingCompleted()
 
             public ExportFactory<ICommandArgumentsExtension, CommandArgumentsExtensionAttribute>[] ArgumentExtensions => new[]
             {
-                new ExportFactory<ICommandArgumentsExtension, CommandArgumentsExtensionAttribute>(() => Tuple.Create<ICommandArgumentsExtension, Action>(Args, new Action(() => { })), new CommandArgumentsExtensionAttribute{ CommandArgumentTypes = new []{ typeof(TestArguments2)} })
+                new ExportFactory<ICommandArgumentsExtension, CommandArgumentsExtensionAttribute>(() => Tuple.Create<ICommandArgumentsExtension, Action>(Args, new Action(() => { })), new CommandArgumentsExtensionAttribute{ CommandTypes = new []{ typeof(TestArguments2)} })
             };
 
             public IList<ICommandArgumentsExtension> Extensions { get; } = new List<ICommandArgumentsExtension>();
diff --git a/src/Pretzel/Commands/CommandCollection.cs b/src/Pretzel/Commands/CommandCollection.cs
index bf2ab7bd8..2936e17fe 100644
--- a/src/Pretzel/Commands/CommandCollection.cs
+++ b/src/Pretzel/Commands/CommandCollection.cs
@@ -57,7 +57,7 @@ internal void OnImportsSatisfied()
                     baseCommandArguments.BuildOptions();
                 }
 
-                foreach (var argumentExtensionsExport in ArgumentExtensions.Where(a => a.Metadata.CommandArgumentTypes.Any(type => type.IsAssignableFrom(argument.GetType()))))
+                foreach (var argumentExtensionsExport in ArgumentExtensions.Where(a => a.Metadata.CommandTypes.Any(type => type == command.Metadata.CommandType)))
                 {
                     var arugumentExtension = argumentExtensionsExport.CreateExport().Value;
                     argument.Extensions.Add(arugumentExtension);