git style commands

FluentCommandLineParser.Examples/App.config

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+    <startup> 
+
+    <supportedRuntime version="v2.0.50727" sku="Client"/></startup>
+</configuration>

FluentCommandLineParser.Examples/FluentCommandLineParser.Examples.csproj

@@ -0,0 +1,65 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{47A9E194-B92E-4929-A7A8-396BCD46A844}</ProjectGuid>
+    <OutputType>Exe</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>Fclp.Examples</RootNamespace>
+    <AssemblyName>FluentCommandLineParser.Examples</AssemblyName>
+    <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <TargetFrameworkProfile>Client</TargetFrameworkProfile>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Program.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="App.config" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\FluentCommandLineParser\FluentCommandLineParser.csproj">
+      <Project>{74cdfa61-81d8-40f2-b536-949baba15d3e}</Project>
+      <Name>FluentCommandLineParser</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>

FluentCommandLineParser.Examples/Program.cs

@@ -0,0 +1,74 @@
+using System.Collections.Generic;
+
+namespace Fclp.Examples
+{
+    class CommandProgram
+    {
+        // Contains all arguments for the add command
+        class AddArgs
+        {
+            public bool Verbose { get; set; }
+            public bool IgnoreErrors { get; set; }
+            public List<string> Files { get; set; }
+            public List<string> Files2 { get; set; }
+        }
+
+        // Contains all arguments for the remove command
+        class RemoveArgs
+        {
+            public bool Verbose { get; set; }
+            public List<string> Files { get; set; }
+        }
+
+        static void Main(string[] args)
+        {
+            var fclp = new FluentCommandLineParser();
+
+            // use new SetupCommand method to initialise a command
+            var addCmd = fclp.SetupCommand<AddArgs>("add")
+                             .OnSuccess(Add); // executed when the add command is used
+
+            // the standard fclp framework, except against the created command rather than the fclp itself
+            addCmd.Setup(addArgs => addArgs.Verbose)
+                  .As('v', "verbose")
+                  .SetDefault(false)
+                  .WithDescription("Be verbose");
+
+            addCmd.Setup(addArgs => addArgs.IgnoreErrors)
+                  .As("ignore-errors")
+                  .SetDefault(false)
+                  .WithDescription("If some files could not be added, do not abort");
+
+            addCmd.Setup(addArgs => addArgs.Files)
+                  .As('f', "files")
+                  .WithDescription("Files to be tracked")
+                  .UseForOrphanArguments();
+
+            // add the remove command
+            var remCmd = fclp.SetupCommand<RemoveArgs>("rem")
+                             .OnSuccess(Remove); // executed when the remove command is used
+
+            remCmd.Setup(removeArgs => removeArgs.Verbose)
+                     .As('v', "verbose")
+                     .SetDefault(false)
+                     .WithDescription("Be verbose");
+
+            remCmd.Setup(removeArgs => removeArgs.Files)
+                     .As('f', "files")
+                     .WithDescription("Files to be untracked")
+                     .UseForOrphanArguments();
+
+            fclp.Parse(args);
+        }
+
+        static void Add(AddArgs args)
+        {
+            // add was executed
+        }
+
+        static void Remove(RemoveArgs args)
+        {
+            // remove was executed
+        }
+    }
+}

FluentCommandLineParser.Examples/Properties/AssemblyInfo.cs

@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("FluentCommandLineParser.Examples")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("FluentCommandLineParser.Examples")]
+[assembly: AssemblyCopyright("Copyright ©  2015")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("e5d3cab1-0e75-42ba-b39a-516de3b732a6")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

FluentCommandLineParser.Tests/Commands/AddArgs.cs

@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+
+namespace Fclp.Tests.Commands
+{
+    class AddArgs
+    {
+        public bool Verbose { get; set; }
+        public bool IgnoreErrors { get; set; }
+        public List<string> Files { get; set; }
+    }
+}

FluentCommandLineParser.Tests/Commands/CommandTests.cs

@@ -0,0 +1,133 @@
+using System;
+using Fclp.Tests.Extensions;
+using NUnit.Framework;
+
+namespace Fclp.Tests.Commands
+{
+    [TestFixture]
+    public class CommandTests
+    {
+        static Fclp.FluentCommandLineParser SetupParser(Action<AddArgs> addCallback, Action<RemoveArgs> removeCallback)
+        {
+            var fclp = new Fclp.FluentCommandLineParser();
+
+            // use new SetupCommand method to initialise a command
+            var addCmd = fclp.SetupCommand<AddArgs>("add")
+                             .OnSuccess(addCallback); // executed when the add command is used
+
+            // the standard fclp framework, except against the created command rather than the fclp itself
+            addCmd.Setup(addArgs => addArgs.Verbose)
+                  .As('v', "verbose")
+                  .SetDefault(false)
+                  .WithDescription("Be verbose");
+
+            addCmd.Setup(addArgs => addArgs.IgnoreErrors)
+                  .As("ignore-errors")
+                  .SetDefault(false)
+                  .WithDescription("If some files could not be added, do not abort");
+
+            addCmd.Setup(addArgs => addArgs.Files)
+                  .As('f', "files")
+                  .WithDescription("Files to be tracked")
+                  .UseForOrphanArguments();
+
+            // add the remove command
+            var remCmd = fclp.SetupCommand<RemoveArgs>("rem")
+                             .OnSuccess(removeCallback); // executed when the remove command is used
+
+            remCmd.Setup(removeArgs => removeArgs.Verbose)
+                     .As('v', "verbose")
+                     .SetDefault(false)
+                     .WithDescription("Be verbose");
+
+            remCmd.Setup(removeArgs => removeArgs.Files)
+                     .As('f', "files")
+                     .WithDescription("Files to be untracked")
+                     .UseForOrphanArguments();
+
+            return fclp;
+        }
+
+        [Test]
+        public void Add_Command_Usage()
+        {
+            const string args = "add --files a.txt b.txt c.txt --verbose --ignore-errors";
+
+            AddArgs addArgs = null;
+            RemoveArgs removeArgs = null;
+
+            var fclp = SetupParser(x => addArgs = x, x => removeArgs = x);
+
+            var result = fclp.Parse(args.AsCmdArgs());
+
+            Assert.IsFalse(result.HasErrors);
+            Assert.IsNull(removeArgs);
+            Assert.IsNotNull(addArgs);
+            Assert.IsTrue(addArgs.Verbose);
+            Assert.IsTrue(addArgs.IgnoreErrors);
+            Assert.That(addArgs.Files, Is.EquivalentTo(new[] { "a.txt", "b.txt", "c.txt" }));
+        }
+
+        [Test]
+        public void Add_Command_With_Orphan()
+        {
+            const string args = "add a.txt b.txt c.txt --verbose --ignore-errors";
+
+            AddArgs addArgs = null;
+            RemoveArgs removeArgs = null;
+
+            var fclp = SetupParser(x => addArgs = x, x => removeArgs = x);
+
+            var result = fclp.Parse(args.AsCmdArgs());
+
+            Assert.IsFalse(result.HasErrors);
+            Assert.IsNull(removeArgs);
+            Assert.IsNotNull(addArgs);
+            Assert.IsTrue(addArgs.Verbose);
+            Assert.IsTrue(addArgs.IgnoreErrors);
+            Assert.IsNotNull(addArgs.Files);
+            Assert.That(addArgs.Files, Is.EquivalentTo(new[] { "a.txt", "b.txt", "c.txt" }));
+        }
+
+        [Test]
+        public void Add_Command_With_Only_Orphan()
+        {
+            const string args = "add a.txt b.txt c.txt";
+
+            AddArgs addArgs = null;
+            RemoveArgs removeArgs = null;
+
+            var fclp = SetupParser(x => addArgs = x, x => removeArgs = x);
+
+            var result = fclp.Parse(args.AsCmdArgs());
+
+            Assert.IsFalse(result.HasErrors);
+            Assert.IsNull(removeArgs);
+            Assert.IsNotNull(addArgs);
+            Assert.IsFalse(addArgs.Verbose);
+            Assert.IsFalse(addArgs.IgnoreErrors);
+            Assert.IsNotNull(addArgs.Files);
+            Assert.That(addArgs.Files, Is.EquivalentTo(new[] { "a.txt", "b.txt", "c.txt" }));
+        }
+
+        [Test]
+        public void Remove_Command_Usage()
+        {
+            const string args = "rem --files a.txt b.txt c.txt --verbose";
+
+            AddArgs addArgs = null;
+            RemoveArgs removeArgs = null;
+
+            var fclp = SetupParser(x => addArgs = x, x => removeArgs = x);
+
+            var result = fclp.Parse(args.AsCmdArgs());
+
+            Assert.IsFalse(result.HasErrors);
+            Assert.IsNull(addArgs);
+            Assert.IsNotNull(removeArgs);
+            Assert.IsTrue(removeArgs.Verbose);
+            Assert.IsNotNull(removeArgs.Files);
+            Assert.That(removeArgs.Files, Is.EquivalentTo(new[] { "a.txt", "b.txt", "c.txt" }));
+        }
+    }
+}

FluentCommandLineParser.Tests/Commands/RemoveArgs.cs

@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+
+namespace Fclp.Tests.Commands
+{
+    class RemoveArgs
+    {
+        public bool Verbose { get; set; }
+        public List<string> Files { get; set; }
+    }
+}

FluentCommandLineParser.Tests/Extensions/StringExtensions.cs

@@ -0,0 +1,20 @@
+using System.Linq;
+using Fclp.Internals.Extensions;
+
+namespace Fclp.Tests.Extensions
+{
+    public static class StringExtensions
+    {
+        public static string[] AsCmdArgs(this string args)
+        {
+            args = ReplaceWithDoubleQuotes(args);
+            return args.SplitOnWhitespace().ToArray();
+        }
+
+        private static string ReplaceWithDoubleQuotes(string args)
+        {
+            if (args == null) return null;
+            return args.Replace('\'', '"');
+        }
+    }
+}

FluentCommandLineParser.Tests/FluentCommandLineParser.Tests.csproj

@@ -85,6 +85,10 @@
     <Compile Include="Integration\Lists\Int64ListInlineDataAttribute.cs" />
     <Compile Include="UriTests.cs" />
     <Compile Include="CommandLineOptionFormatterTests.cs" />
+    <Compile Include="Commands\AddArgs.cs" />
+    <Compile Include="Commands\CommandTests.cs" />
+    <Compile Include="Commands\RemoveArgs.cs" />
+    <Compile Include="Extensions\StringExtensions.cs" />
     <Compile Include="FluentCommandLineParserBuilderTests.cs" />
     <Compile Include="FluentCommandLineParserMSpecTests.cs" />
     <Compile Include="FluentCommandLineParserTests.cs">

FluentCommandLineParser.Tests/FluentCommandLineParser/when_executing_parse_operation/with_a_parser_engine_that_is_custom.cs

@@ -47,7 +47,7 @@ public class with_a_parser_engine_that_is_custom : FluentCommandLineParserTestCo
 										args = new string[0];
 
 										mockedEngine
-											.Setup(x => x.Parse(args))
+											.Setup(x => x.Parse(args, false))
 											.Returns(Create<ParserEngineResult>())
 											.Verifiable();
 									};
@@ -59,7 +59,7 @@ public class with_a_parser_engine_that_is_custom : FluentCommandLineParserTestCo
 			};
 
 			It should_replace_the_old_engine = () => sut.ParserEngine.ShouldBeTheSameAs(customEngine);
-			It should_be_used_to_parse_the_args = () => mockedEngine.Verify(x => x.Parse(args));
+            It should_be_used_to_parse_the_args = () => mockedEngine.Verify(x => x.Parse(args, false));
 		}
 	}
 }