Merge changes from upstream/master.

Author: jeremymeng

README.md

@@ -2,9 +2,11 @@
 [![Nuget](https://img.shields.io/nuget/dt/commandlineparser.svg)](http://nuget.org/packages/commandlineparser)
 [![Nuget](https://img.shields.io/nuget/v/commandlineparser.svg)](http://nuget.org/packages/commandlineparser)
 [![Nuget](https://img.shields.io/nuget/vpre/commandlineparser.svg)](http://nuget.org/packages/commandlineparser)
+[![Join the gitter chat!](https://badges.gitter.im/gsscoder/commandline.svg)](https://gitter.im/gsscoder/commandline?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
 Command Line Parser Library 2.0.275.0 beta for CLR.
 ===
+
 The Command Line Parser Library offers CLR applications a clean and concise API for manipulating command line arguments and related tasks, such as defining switches, options and verb commands. It allows you to display a help screen with a high degree of customization and a simple way to report syntax errors to the end user.
 
 Everything that is boring and repetitive about parsing command line arguments is delegated to the library, letting developers concentrate on core logic. It's written in **C#** and doesn't depend on other packages.
@@ -82,8 +84,7 @@ class Options {
 
   [Value(0, MetaName = "offset",
     HelpText = "File offset.")]
-  public long? Offset { get; set;}
-  }
+  public long? Offset { get; set; }
 }
 ```
 Consume them:
@@ -146,6 +147,35 @@ int Main(string[] args) {
 }
 ```
 
+**F#:**
+```fsharp
+open CommandLine
+
+[<Verb("add", HelpText = "Add file contents to the index.")>]
+type AddOptions = {
+  // normal options here
+}
+[<Verb("commit", HelpText = "Record changes to the repository.")>]
+type CommitOptions = {
+  // normal options here
+}
+[<Verb("clone", HelpText = "Clone a repository into a new directory.")>]
+type CloneOptions = {
+  // normal options here
+}
+
+[<EntryPoint>]
+let main args =
+  let result = Parser.Default.ParseArguments<AddOptions, CommitOptions, CloneOptions> args
+  match result with
+  | :? CommandLine.Parsed<obj> as command ->
+    match command.Value with
+    | :? AddOptions as opts -> RunAddAndReturnExitCode opts
+    | :? CommitOptions as opts -> RunCommitAndReturnExitCode opts
+    | :? CloneOptions as opts -> RunCloneAndReturnExitCode opts
+  | :? CommandLine.NotParsed<obj> -> 1
+```
+
 Acknowledgements:
 ---
 [![Jet Brains ReSharper](/art/resharper-logo.png)](http://www.jetbrains.com/resharper/)
@@ -266,6 +296,6 @@ Latest Changes:
 Contact:
 ---
 Giacomo Stelluti Scala
-  - gsscoder AT gmail DOT com
+  - gsscoder AT gmail DOT com (_use this for everything that is not available via GitHub features_)
   - [Blog](http://gsscoder.blogspot.it)
   - [Twitter](http://twitter.com/gsscoder)

src/CommandLine/Core/InstanceBuilder.cs

@@ -20,6 +20,7 @@ public static ParserResult<T> Build<T>(
             Func<IEnumerable<string>, IEnumerable<OptionSpecification>, Result<IEnumerable<Token>, Error>> tokenizer,
             IEnumerable<string> arguments,
             StringComparer nameComparer,
+            bool ignoreValueCase,
             CultureInfo parsingCulture,
             IEnumerable<ErrorType> nonFatalErrors)
         {
@@ -60,14 +61,14 @@ public static ParserResult<T> Build<T>(
                     OptionMapper.MapValues(
                         (from pt in specProps where pt.Specification.IsOption() select pt),
                         optionsPartition,
-                        (vals, type, isScalar) => TypeConverter.ChangeType(vals, type, isScalar, parsingCulture),
+                        (vals, type, isScalar) => TypeConverter.ChangeType(vals, type, isScalar, parsingCulture, ignoreValueCase),
                         nameComparer);
 
                 var valueSpecPropsResult =
                     ValueMapper.MapValues(
                         (from pt in specProps where pt.Specification.IsValue() select pt),
                         valuesPartition,
-                        (vals, type, isScalar) => TypeConverter.ChangeType(vals, type, isScalar, parsingCulture));
+                        (vals, type, isScalar) => TypeConverter.ChangeType(vals, type, isScalar, parsingCulture, ignoreValueCase));
 
                 var missingValueErrors = from token in errorsPartition
                                          select
@@ -110,7 +111,7 @@ join sp in specPropsWithValue on prms.Name.ToLower() equals sp.Property.Name.ToL
                 };
 
                 var instance = typeInfo.IsMutable() ? buildMutable() : buildImmutable();
-
+                
                 var validationErrors = specPropsWithValue.Validate(SpecificationPropertyRules.Lookup(tokens));
 
                 var allErrors =

src/CommandLine/Core/InstanceChooser.cs

@@ -60,6 +60,7 @@ private static ParserResult<object> MatchVerb(
                     tokenizer,
                     arguments.Skip(1),
                     nameComparer,
+                    false,
                     parsingCulture,
                     nonFatalErrors)
                 : MakeNotParsed(verbs.Select(v => v.Item2), new BadVerbSelectedError(arguments.First()));

src/CommandLine/Core/SpecificationPropertyRules.cs

@@ -123,13 +123,19 @@ private static Func<IEnumerable<SpecificationProperty>, IEnumerable<Error>> Enfo
                                 where sp.Specification.IsOption()
                                 where sp.Value.IsJust()
                                 select (OptionSpecification)sp.Specification;
-                    var options = from t in tokens
-                                  where t.IsName()
-                                  join o in specs on t.Text equals o.UniqueName() into to
-                                  from o in to.DefaultIfEmpty()
-                                  where o != null
-                                  select new { o.ShortName, o.LongName };
-                    var groups = from x in options
+                    var shortOptions = from t in tokens
+                                       where t.IsName()
+                                       join o in specs on t.Text equals o.ShortName into to
+                                       from o in to.DefaultIfEmpty()
+                                       where o != null
+                                       select new { o.ShortName, o.LongName };
+                    var longOptions = from t in tokens
+                                       where t.IsName()
+                                       join o in specs on t.Text equals o.LongName into to
+                                       from o in to.DefaultIfEmpty()
+                                       where o != null
+                                       select new { o.ShortName, o.LongName };
+                    var groups = from x in shortOptions.Concat(longOptions)
                                  group x by x into g
                                  let count = g.Count()
                                  select new { Value = g.Key, Count = count };

src/CommandLine/Core/TypeConverter.cs

@@ -15,14 +15,14 @@ namespace CommandLine.Core
 {
     static class TypeConverter
     {
-        public static Maybe<object> ChangeType(IEnumerable<string> values, Type conversionType, bool scalar, CultureInfo conversionCulture)
+        public static Maybe<object> ChangeType(IEnumerable<string> values, Type conversionType, bool scalar, CultureInfo conversionCulture, bool ignoreValueCase)
         {
             return scalar
-                ? ChangeTypeScalar(values.Single(), conversionType, conversionCulture)
-                : ChangeTypeSequence(values, conversionType, conversionCulture);
+                ? ChangeTypeScalar(values.Single(), conversionType, conversionCulture, ignoreValueCase)
+                : ChangeTypeSequence(values, conversionType, conversionCulture, ignoreValueCase);
         }
 
-        private static Maybe<object> ChangeTypeSequence(IEnumerable<string> values, Type conversionType, CultureInfo conversionCulture)
+        private static Maybe<object> ChangeTypeSequence(IEnumerable<string> values, Type conversionType, CultureInfo conversionCulture, bool ignoreValueCase)
         {
             var type =
                 conversionType.GetGenericArguments()
@@ -32,22 +32,22 @@ private static Maybe<object> ChangeTypeSequence(IEnumerable<string> values, Type
                                   new InvalidOperationException("Non scalar properties should be sequence of type IEnumerable<T>.")
                     );
 
-            var converted = values.Select(value => ChangeTypeScalar(value, type, conversionCulture));
+            var converted = values.Select(value => ChangeTypeScalar(value, type, conversionCulture, ignoreValueCase));
 
             return converted.Any(a => a.MatchNothing())
                 ? Maybe.Nothing<object>()
                 : Maybe.Just(converted.Select(c => ((Just<object>)c).Value).ToUntypedArray(type));
         }
 
-        private static Maybe<object> ChangeTypeScalar(string value, Type conversionType, CultureInfo conversionCulture)
+        private static Maybe<object> ChangeTypeScalar(string value, Type conversionType, CultureInfo conversionCulture, bool ignoreValueCase)
         {
-            var result = ChangeTypeScalarImpl(value, conversionType, conversionCulture);
+            var result = ChangeTypeScalarImpl(value, conversionType, conversionCulture, ignoreValueCase);
             result.Match((_,__) => { }, e => e.First().RethrowWhenAbsentIn(
                 new[] { typeof(InvalidCastException), typeof(FormatException), typeof(OverflowException) }));
             return result.ToMaybe();
         }
 
-        private static Result<object, Exception> ChangeTypeScalarImpl(string value, Type conversionType, CultureInfo conversionCulture)
+        private static Result<object, Exception> ChangeTypeScalarImpl(string value, Type conversionType, CultureInfo conversionCulture, bool ignoreValueCase)
         {
             Func<object> changeType = () =>
             {
@@ -76,7 +76,7 @@ private static Result<object, Exception> ChangeTypeScalarImpl(string value, Type
 
                 return value.IsBooleanString()
                     ? value.ToBoolean() : conversionType.GetTypeInfo().IsEnum
-                        ? value.ToEnum(conversionType) : safeChangeType();
+                        ? value.ToEnum(conversionType, ignoreValueCase) : safeChangeType();
             };
 
             Func<object> makeType = () =>
@@ -98,12 +98,12 @@ private static Result<object, Exception> ChangeTypeScalarImpl(string value, Type
                     : makeType);
         }
 
-        private static object ToEnum(this string value, Type conversionType)
+        private static object ToEnum(this string value, Type conversionType, bool ignoreValueCase)
         {
             object parsedValue;
             try
             {
-                parsedValue = Enum.Parse(conversionType, value);
+                parsedValue = Enum.Parse(conversionType, value, ignoreValueCase);
             }
             catch (ArgumentException)
             {

src/CommandLine/Parser.cs

@@ -97,6 +97,7 @@ public ParserResult<T> ParseArguments<T>(IEnumerable<string> args)
                     (arguments, optionSpecs) => Tokenize(arguments, optionSpecs, settings),
                     args,
                     settings.NameComparer,
+                    settings.CaseInsensitiveEnumValues,
                     settings.ParsingCulture,
                     HandleUnknownArguments(settings.IgnoreUnknownArguments)),
                 settings);
@@ -125,6 +126,7 @@ public ParserResult<T> ParseArguments<T>(Func<T> factory, IEnumerable<string> ar
                     (arguments, optionSpecs) => Tokenize(arguments, optionSpecs, settings),
                     args,
                     settings.NameComparer,
+                    settings.CaseInsensitiveEnumValues,
                     settings.ParsingCulture,
                     HandleUnknownArguments(settings.IgnoreUnknownArguments)),
                 settings);

src/CommandLine/ParserSettings.cs

@@ -15,6 +15,7 @@ public class ParserSettings : IDisposable
     {
         private bool disposed;
         private bool caseSensitive;
+        private bool caseInsensitiveEnumValues;
         private TextWriter helpWriter;
         private bool ignoreUnknownArguments;
         private CultureInfo parsingCulture;
@@ -26,6 +27,7 @@ public class ParserSettings : IDisposable
         public ParserSettings()
         {
             caseSensitive = true;
+            caseInsensitiveEnumValues = false;
             parsingCulture = CultureInfo.InvariantCulture;
         }
 
@@ -48,6 +50,16 @@ public bool CaseSensitive
             set { PopsicleSetter.Set(Consumed, ref caseSensitive, value); }
         }
 
+        /// <summary>
+        /// Gets or sets a value indicating whether perform case sensitive comparisons of <i>values</i>.
+        /// Note that case insensitivity only applies to <i>values</i>, not the parameters.
+        /// </summary>
+        public bool CaseInsensitiveEnumValues
+        {
+            get { return caseInsensitiveEnumValues; }
+            set { PopsicleSetter.Set(Consumed, ref caseInsensitiveEnumValues, value); }
+        }
+
         /// <summary>
         /// Gets or sets the culture used when parsing arguments to typed properties.
         /// </summary>

src/CommandLine/Text/HelpText.cs

@@ -35,7 +35,7 @@ public class HelpText
         /// Initializes a new instance of the <see cref="CommandLine.Text.HelpText"/> class.
         /// </summary>
         public HelpText()
-            : this(SentenceBuilder.CreateDefault(), string.Empty, string.Empty)
+            : this(SentenceBuilder.Create(), string.Empty, string.Empty)
         {
         }
 
@@ -58,7 +58,7 @@ public HelpText(SentenceBuilder sentenceBuilder)
         /// <param name="heading">An heading string or an instance of <see cref="CommandLine.Text.HeadingInfo"/>.</param>
         /// <exception cref="System.ArgumentException">Thrown when parameter <paramref name="heading"/> is null or empty string.</exception>
         public HelpText(string heading)
-            : this(SentenceBuilder.CreateDefault(), heading, string.Empty)
+            : this(SentenceBuilder.Create(), heading, string.Empty)
         {
         }
 
@@ -81,7 +81,7 @@ public HelpText(SentenceBuilder sentenceBuilder, string heading)
         /// <param name="copyright">A string with copyright or an instance of <see cref="CommandLine.Text.CopyrightInfo"/>.</param>
         /// <exception cref="System.ArgumentNullException">Thrown when one or more parameters are null or empty strings.</exception>
         public HelpText(string heading, string copyright)
-            : this(SentenceBuilder.CreateDefault(), heading, copyright)
+            : this(SentenceBuilder.Create(), heading, copyright)
         {
         }
 

src/CommandLine/Text/MultiLineTextAttribute.cs

@@ -150,7 +150,7 @@ public string Line5
         internal HelpText AddToHelpText(HelpText helpText, Func<string, HelpText> func)
         {
             var strArray = new[] { line1, line2, line3, line4, line5 };
-            return strArray.Aggregate(helpText, (current, line) => func(line));
+            return strArray.Take(GetLastLineWithText(strArray)).Aggregate(helpText, (current, line) => func(line));
         }
 
         internal HelpText AddToHelpText(HelpText helpText, bool before)

src/CommandLine/Text/SentenceBuilder.cs

@@ -15,15 +15,19 @@ namespace CommandLine.Text
     public abstract class SentenceBuilder
     {
         /// <summary>
-        /// Create the default instance of <see cref="CommandLine.Text.SentenceBuilder"/>,
-        /// localized in English.
+        /// Create instance of <see cref="CommandLine.Text.SentenceBuilder"/>,
         /// </summary>
-        /// <returns>The default <see cref="CommandLine.Text.SentenceBuilder"/> instance.</returns>
-        public static SentenceBuilder CreateDefault()
+        /// <returns>The <see cref="CommandLine.Text.SentenceBuilder"/> instance.</returns>
+        public static SentenceBuilder Create()
         {
-            return new DefaultSentenceBuilder();
+            return Factory();
         }
 
+        /// <summary>
+        /// Factory to allow custom SentenceBuilder injection
+        /// </summary>
+        public static Func<SentenceBuilder> Factory { get; set; } = () => new DefaultSentenceBuilder();
+
         /// <summary>
         /// Gets a delegate that returns the word 'required'.
         /// </summary>

tests/CommandLine.Tests/Fakes/Simple_Options.cs

@@ -9,6 +9,9 @@ public class Simple_Options
         [Option(HelpText = "Define a string value here.")]
         public string StringValue { get; set; }
 
+        [Option('s', "shortandlong", HelpText = "Example with both short and long name.")]
+        public string ShortAndLong { get; set; }
+
         [Option('i', Min = 3, Max = 4, HelpText = "Define a int sequence here.")]
         public IEnumerable<int> IntSequence { get; set; }