- added the ability to treat empty args as help args.

- also added EmptyArgs property to the result to other action could be taken.

Author: siywilliams

FluentCommandLineParser.Tests/FluentCommandLineParser.Tests.csproj

@@ -101,6 +101,7 @@
     <Compile Include="Internals\CommandLineParserEngine\when_args_contains_a_boolean_option_that_ends_with_negative_sign.cs" />
     <Compile Include="Internals\CommandLineParserEngine\when_args_contains_a_boolean_option_that_ends_with_no_sign.cs" />
     <Compile Include="Internals\CommandLineParserEngine\when_args_contains_a_boolean_option_that_ends_with_positive_sign.cs" />
+    <Compile Include="Internals\HelpCommandLineOptionTests.cs" />
     <Compile Include="Internals\TestContextBase.cs" />
     <Compile Include="TestContext\TestContext.cs" />
     <Compile Include="FluentCommandLineParser\TestContext\TestType.cs" />

FluentCommandLineParser.Tests/FluentCommandLineParserTests.cs

@@ -509,6 +509,7 @@ public void Ensure_Can_Specify_Empty_Args()
             var result = parser.Parse(new string[0]);
 
             Assert.IsFalse(result.HasErrors);
+            Assert.IsTrue(result.EmptyArgs);
             Assert.IsFalse(result.Errors.Any());
         }
 
@@ -520,9 +521,40 @@ public void Ensure_Can_Specify_Null_Args()
             var result = parser.Parse(null);
 
             Assert.IsFalse(result.HasErrors);
+            Assert.IsTrue(result.EmptyArgs);
             Assert.IsFalse(result.Errors.Any());
         }
 
+        [Test]
+        public void Ensure_Defaults_Are_Called_When_Empty_Args_Specified()
+        {
+            var parser = CreateFluentParser();
+
+            const int expectedInt = 123;
+            const double expectedDouble = 123.456;
+            const string expectedString = "my string";
+            const bool expectedBool = true;
+
+            int actualInt = 0;
+            double actualDouble = 0;
+            string actualString = null;
+            bool actualBool = false;
+
+            parser.Setup<int>("i").Callback(i => actualInt = i).SetDefault(expectedInt);
+            parser.Setup<string>("s").Callback(s=> actualString = s).SetDefault(expectedString);
+            parser.Setup<bool>("b").Callback(b => actualBool = b).SetDefault(expectedBool);
+            parser.Setup<double>("d").Callback(d => actualDouble = d).SetDefault(expectedDouble);
+
+            var result = parser.Parse(null);
+
+            Assert.IsFalse(result.HasErrors);
+            Assert.IsTrue(result.EmptyArgs);
+            Assert.AreEqual(expectedInt, actualInt);
+            Assert.AreEqual(expectedDouble, actualDouble);
+            Assert.AreEqual(expectedString, actualString);
+            Assert.AreEqual(expectedBool, actualBool);
+        }
+
         #endregion No Args
 
         #region Example

FluentCommandLineParser.Tests/Internals/HelpCommandLineOptionTests.cs

@@ -0,0 +1,67 @@
+#region License
+// HelpCommandLineOptionTests.cs
+// Copyright (c) 2013, Simon Williams
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without modification, are permitted provide
+// d that the following conditions are met:
+// 
+// Redistributions of source code must retain the above copyright notice, this list of conditions and the
+// following disclaimer.
+// 
+// Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
+// the following disclaimer in the documentation and/or other materials provided with the distribution.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED 
+// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A 
+// PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+// TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
+// POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System.Collections.Generic;
+using Fclp.Internals;
+using Machine.Specifications;
+
+namespace Fclp.Tests.Internals
+{
+    sealed class HelpCommandLineOptionTests
+    {
+        abstract class HelpCommandLineOptionTestContext : TestContextBase<HelpCommandLineOption> 
+        {
+            Establish context = () => CreatSut();    
+        }
+
+
+        sealed class ShouldShowHelp
+        {
+            abstract class ShouldShowHelpTestContext : HelpCommandLineOptionTestContext
+            {
+                protected static bool actualResult;
+                protected static IEnumerable<ParsedOption> parsedOptions;
+
+                Because of = () => actualResult = sut.ShouldShowHelp(parsedOptions);
+            }
+
+            class when_the_args_are_empty_and_the_option_is_setup_to_handle_empty_args_like_help_args : ShouldShowHelpTestContext
+            {
+                Establish context = () =>
+                {
+                    parsedOptions = null;
+                    sut.UseForEmptyArgs();
+                };
+
+                It should_return_true = () => actualResult.ShouldBeTrue();
+            }
+            class when_the_args_are_empty_and_the_option_is_not_setup_to_handle_empty_args_like_help_args : ShouldShowHelpTestContext
+            {
+                Establish context = () => parsedOptions = null;
+
+                It should_return_false = () => actualResult.ShouldBeFalse();
+            }
+        }
+    }
+}

FluentCommandLineParser/FluentCommandLineParser.cs

@@ -173,11 +173,11 @@ public ICommandLineOptionFluent<T> Setup<T>(string shortOption)
 		/// <returns>An <see cref="ICommandLineParserResult"/> representing the results of the parse operation.</returns>
 		public ICommandLineParserResult Parse(string[] args)
 		{
-			var result = new CommandLineParserResult();
-
 			var parsedOptions = this.ParserEngine.Parse(args).ToList();
 
-			if (this.HelpOption.ShouldShowHelp(parsedOptions))
+            var result = new CommandLineParserResult { EmptyArgs = parsedOptions.IsNullOrEmpty() };
+
+		    if (this.HelpOption.ShouldShowHelp(parsedOptions))
 			{
 				result.HelpCalled = true;
 				this.HelpOption.ShowHelp(this.Options);

FluentCommandLineParser/ICommandLineParserResult.cs

@@ -42,6 +42,11 @@ public interface ICommandLineParserResult
 		/// </summary>
 		bool HelpCalled { get; }
 
+        /// <summary>
+        /// Gets whether the parser was called with empty arguments.
+        /// </summary>
+        bool EmptyArgs { get; }
+
 		/// <summary>
 		/// Gets the errors which occurred during the parse operation.
 		/// </summary>

FluentCommandLineParser/IHelpCommandLineOptionFluent.cs

@@ -53,19 +53,28 @@ public interface IHelpCommandLineOptionFluent
         /// <param name="callback">
         /// The callback to execute. If you have also setup the other help callback this will be called last.
         /// </param>
-        /// <returns>A <see cref="ICommandLineOptionFluent{T}"/>.</returns>
+        /// <returns>A <see cref="IHelpCommandLineOptionFluent"/>.</returns>
         IHelpCommandLineOptionFluent Callback(Action callback);
 
 		/// <summary>
 		/// Registers a custom <see cref="ICommandLineOptionFormatter"/> to use to generate the help text.
 		/// </summary>
 		/// <param name="formatter">The custom formatter to use. This must not be <c>null</c>.</param>
+        /// <returns>A <see cref="IHelpCommandLineOptionFluent"/>.</returns>
 		IHelpCommandLineOptionFluent WithCustomFormatter(ICommandLineOptionFormatter formatter);
 
 		/// <summary>
 		/// Provides a custom header to be printed before the registered options.
 		/// </summary>
 		/// <param name="header">The header to use.</param>
+        /// <returns>A <see cref="IHelpCommandLineOptionFluent"/>.</returns>
 		IHelpCommandLineOptionFluent WithHeader(string header);
+
+        /// <summary>
+        /// Specifies that if empty arguments are found then the behaviour should be the same as when any help arguments
+        /// are found.
+        /// </summary>
+        /// <returns>A <see cref="IHelpCommandLineOptionFluent"/>.</returns>
+	    IHelpCommandLineOptionFluent UseForEmptyArgs();
 	}
 }

FluentCommandLineParser/Internals/CommandLineParserResult.cs

@@ -50,7 +50,7 @@ public bool HasErrors
 			get { return this.Errors.Any(); }
 		}
 
-		/// <summary>
+	    /// <summary>
 		/// 
 		/// </summary>
 		internal IList<ICommandLineParserError> Errors { get; set; }
@@ -93,5 +93,10 @@ IEnumerable<ICommandLineOption> ICommandLineParserResult.UnMatchedOptions
 		/// Gets whether the help text was called.
 		/// </summary>
 		public bool HelpCalled { get; set; }
+
+        /// <summary>
+        /// Gets whether the parser was called with empty arguments.
+        /// </summary>
+        public bool EmptyArgs { get; set; }
 	}
 }

FluentCommandLineParser/Internals/HelpCommandLineOption.cs

@@ -56,6 +56,8 @@ public HelpCommandLineOption(IEnumerable<string> helpArgs)
 
 		private Action ReturnCallbackWithoutParser { get; set; }
 
+        private bool ShouldUseForEmptyArgs { get; set; }
+
 		/// <summary>
 		/// Gets or sets any header to display at the top of the printed options.
 		/// </summary>
@@ -119,15 +121,32 @@ public IHelpCommandLineOptionFluent WithHeader(string header)
 			return this;
 		}
 
-		/// <summary>
+        /// <summary>
+        /// Specifies that if empty arguments are found then the behaviour should be the same as when any help arguments
+        /// are found.
+        /// </summary>
+        /// <returns>A <see cref="IHelpCommandLineOptionFluent"/>.</returns>
+	    public IHelpCommandLineOptionFluent UseForEmptyArgs()
+        {
+            this.ShouldUseForEmptyArgs = true;
+            return this;
+        }
+
+	    /// <summary>
 		/// Determines whether the help text should be shown.
 		/// </summary>
 		/// <param name="parsedOptions">The parsed command line arguments</param>
 		/// <returns>true if the parser operation should cease and <see cref="ShowHelp"/> should be called; otherwise false if the parse operation to continue.</returns>
 		public bool ShouldShowHelp(IEnumerable<ParsedOption> parsedOptions)
-		{
-			parsedOptions = parsedOptions ?? new List<ParsedOption>();
-			return this.HelpArgs.Any(helpArg => parsedOptions.Any(cmdArg => helpArg.Equals(cmdArg.Key, StringComparison.CurrentCultureIgnoreCase)));
+	    {
+	        var parsed = parsedOptions != null ? parsedOptions.ToList() : new List<ParsedOption>();
+
+            if (parsed.Any() == false && ShouldUseForEmptyArgs)
+            {
+                return true;
+            }
+
+            return this.HelpArgs.Any(helpArg => parsed.Any(cmdArg => helpArg.Equals(cmdArg.Key, StringComparison.CurrentCultureIgnoreCase)));
 		}
 
 		/// <summary>