Merge branch 'develop' into ViktorHofer-netstandard20

ericnewton76 · ericnewton76 · commit 6cc3cbd2f690 · 2019-01-09T16:39:00.000-05:00
diff --git a/README.md b/README.md
@@ -37,7 +37,7 @@ __This library provides _hassle free_ command line parsing with a constantly upd
 
 You can utilize the parser library in several ways:
 
-- Install via Nuget/Paket
+- Install via Nuget/Paket: [https://www.nuget.org/packages/CommandLineParser/](https://www.nuget.org/packages/CommandLineParser/)
 - Integrate directly into your project by copying the .cs files into your project.
 - ILMerge during your build process.
 
@@ -98,7 +98,7 @@ class Options
   public bool Verbose { get; set; }
   
   [Option("stdin",
-	Default = false
+	Default = false,
 	HelpText = "Read from stdin")]
   public bool stdin { get; set; }
 
diff --git a/src/CommandLine/Core/InstanceBuilder.cs b/src/CommandLine/Core/InstanceBuilder.cs
@@ -20,18 +20,22 @@ public static ParserResult<T> Build<T>(
             StringComparer nameComparer,
             bool ignoreValueCase,
             CultureInfo parsingCulture,
+            bool autoHelp,
+            bool autoVersion,
             IEnumerable<ErrorType> nonFatalErrors)
         {
             var typeInfo = factory.MapValueOrDefault(f => f().GetType(), typeof(T));
 
             var specProps = typeInfo.GetSpecifications(pi => SpecificationProperty.Create(
-                    Specification.FromProperty(pi), pi, Maybe.Nothing<object>()));
+                    Specification.FromProperty(pi), pi, Maybe.Nothing<object>()))
+                .Memorize();
 
             var specs = from pt in specProps select pt.Specification;
 
             var optionSpecs = specs
                 .ThrowingValidate(SpecificationGuards.Lookup)
-                .OfType<OptionSpecification>();
+                .OfType<OptionSpecification>()
+                .Memorize();
 
             Func<T> makeDefault = () =>
                 typeof(T).IsMutable()
@@ -42,18 +46,19 @@ public static ParserResult<T> Build<T>(
             Func<IEnumerable<Error>, ParserResult<T>> notParsed =
                 errs => new NotParsed<T>(makeDefault().GetType().ToTypeInfo(), errs);
 
+            var argumentsList = arguments.Memorize();
             Func<ParserResult<T>> buildUp = () =>
             {
-                var tokenizerResult = tokenizer(arguments, optionSpecs);
+                var tokenizerResult = tokenizer(argumentsList, optionSpecs);
 
-                var tokens = tokenizerResult.SucceededWith();
+                var tokens = tokenizerResult.SucceededWith().Memorize();
 
                 var partitions = TokenPartitioner.Partition(
                     tokens,
                     name => TypeLookup.FindTypeDescriptorAndSibling(name, optionSpecs, nameComparer));
-                var optionsPartition = partitions.Item1;
-                var valuesPartition = partitions.Item2;
-                var errorsPartition = partitions.Item3;
+                var optionsPartition = partitions.Item1.Memorize();
+                var valuesPartition = partitions.Item2.Memorize();
+                var errorsPartition = partitions.Item3.Memorize();
 
                 var optionSpecPropsResult =
                     OptionMapper.MapValues(
@@ -65,7 +70,7 @@ public static ParserResult<T> Build<T>(
                 var valueSpecPropsResult =
                     ValueMapper.MapValues(
                         (from pt in specProps where pt.Specification.IsValue() orderby ((ValueSpecification)pt.Specification).Index select pt),
-                        valuesPartition,
+                        valuesPartition,    
                         (vals, type, isScalar) => TypeConverter.ChangeType(vals, type, isScalar, parsingCulture, ignoreValueCase));
 
                 var missingValueErrors = from token in errorsPartition
@@ -75,7 +80,7 @@ public static ParserResult<T> Build<T>(
                                 .FromOptionSpecification());
 
                 var specPropsWithValue =
-                    optionSpecPropsResult.SucceededWith().Concat(valueSpecPropsResult.SucceededWith());
+                    optionSpecPropsResult.SucceededWith().Concat(valueSpecPropsResult.SucceededWith()).Memorize();
 
                 var setPropertyErrors = new List<Error>();                
 
@@ -100,9 +105,13 @@ public static ParserResult<T> Build<T>(
                 {
                     var ctor = typeInfo.GetTypeInfo().GetConstructor((from sp in specProps select sp.Property.PropertyType).ToArray());
                     var values = (from prms in ctor.GetParameters()
-                        join sp in specPropsWithValue on prms.Name.ToLower() equals sp.Property.Name.ToLower()
+                        join sp in specPropsWithValue on prms.Name.ToLower() equals sp.Property.Name.ToLower() into spv
+                        from sp in spv.DefaultIfEmpty()
                         select
-                            sp.Value.GetValueOrDefault(
+                          sp == null
+                            ? specProps.First(s => String.Equals(s.Property.Name, prms.Name, StringComparison.CurrentCultureIgnoreCase))
+                              .Property.PropertyType.GetDefaultValue()
+                            : sp.Value.GetValueOrDefault(
                                 sp.Specification.DefaultValue.GetValueOrDefault(
                                     sp.Specification.ConversionType.CreateDefaultForImmutable()))).ToArray();
                     var immutable = (T)ctor.Invoke(values);
@@ -127,11 +136,13 @@ join sp in specPropsWithValue on prms.Name.ToLower() equals sp.Property.Name.ToL
                 return allErrors.Except(warnings).ToParserResult(instance);
             };
 
-            var preprocessorErrors = arguments.Any()
-                ? arguments.Preprocess(PreprocessorGuards.Lookup(nameComparer))
-                : Enumerable.Empty<Error>();
+            var preprocessorErrors = (
+                    argumentsList.Any()
+                    ? arguments.Preprocess(PreprocessorGuards.Lookup(nameComparer, autoHelp, autoVersion))
+                    : Enumerable.Empty<Error>()
+                ).Memorize();
 
-            var result = arguments.Any()
+            var result = argumentsList.Any()
                 ? preprocessorErrors.Any()
                     ? notParsed(preprocessorErrors)
                     : buildUp()
diff --git a/src/CommandLine/Core/InstanceChooser.cs b/src/CommandLine/Core/InstanceChooser.cs
@@ -19,6 +19,8 @@ public static ParserResult<object> Choose(
             StringComparer nameComparer,
             bool ignoreValueCase,
             CultureInfo parsingCulture,
+            bool autoHelp,
+            bool autoVersion,
             IEnumerable<ErrorType> nonFatalErrors)
         {
             Func<ParserResult<object>> choose = () =>
@@ -31,13 +33,13 @@ public static ParserResult<object> Choose(
 
                 var verbs = Verb.SelectFromTypes(types);
 
-                return preprocCompare("help")
+                return (autoHelp && preprocCompare("help"))
                     ? MakeNotParsed(types,
                         MakeHelpVerbRequestedError(verbs,
                             arguments.Skip(1).FirstOrDefault() ?? string.Empty, nameComparer))
-                    : preprocCompare("version")
+                    : (autoVersion && preprocCompare("version"))
                         ? MakeNotParsed(types, new VersionRequestedError())
-                        : MatchVerb(tokenizer, verbs, arguments, nameComparer, ignoreValueCase, parsingCulture, nonFatalErrors);
+                        : MatchVerb(tokenizer, verbs, arguments, nameComparer, ignoreValueCase, parsingCulture, autoHelp, autoVersion, nonFatalErrors);
             };
 
             return arguments.Any()
@@ -52,6 +54,8 @@ private static ParserResult<object> MatchVerb(
             StringComparer nameComparer,
             bool ignoreValueCase,
             CultureInfo parsingCulture,
+            bool autoHelp,
+            bool autoVersion,
             IEnumerable<ErrorType> nonFatalErrors)
         {
             return verbs.Any(a => nameComparer.Equals(a.Item1.Name, arguments.First()))
@@ -64,6 +68,8 @@ private static ParserResult<object> MatchVerb(
                     nameComparer,
                     ignoreValueCase,
                     parsingCulture,
+                    autoHelp,
+                    autoVersion,
                     nonFatalErrors)
                 : MakeNotParsed(verbs.Select(v => v.Item2), new BadVerbSelectedError(arguments.First()));
         }
diff --git a/src/CommandLine/Core/OptionMapper.cs b/src/CommandLine/Core/OptionMapper.cs
@@ -43,7 +43,7 @@ select Tuple.Create(
                                                 ((OptionSpecification)pt.Specification).FromOptionSpecification()))))
                             : Tuple.Create(pt, Maybe.Nothing<Error>());
                     }
-                );
+                ).Memorize();
             return Result.Succeed(
                 sequencesAndErrors.Select(se => se.Item1),
                 sequencesAndErrors.Select(se => se.Item2).OfType<Just<Error>>().Select(se => se.Value));
diff --git a/src/CommandLine/Core/PreprocessorGuards.cs b/src/CommandLine/Core/PreprocessorGuards.cs
@@ -9,13 +9,14 @@ namespace CommandLine.Core
     static class PreprocessorGuards
     {
         public static IEnumerable<Func<IEnumerable<string>, IEnumerable<Error>>>
-            Lookup(StringComparer nameComparer)
+            Lookup(StringComparer nameComparer, bool autoHelp, bool autoVersion)
         {
-            return new List<Func<IEnumerable<string>, IEnumerable<Error>>>
-                {
-                    HelpCommand(nameComparer),
-                    VersionCommand(nameComparer)
-                };
+            var list = new List<Func<IEnumerable<string>, IEnumerable<Error>>>();
+            if (autoHelp)
+                list.Add(HelpCommand(nameComparer));
+            if (autoVersion)
+                list.Add(VersionCommand(nameComparer));
+            return list;
         }
 
         public static Func<IEnumerable<string>, IEnumerable<Error>> HelpCommand(StringComparer nameComparer)
diff --git a/src/CommandLine/Core/TokenPartitioner.cs b/src/CommandLine/Core/TokenPartitioner.cs
@@ -11,22 +11,20 @@ namespace CommandLine.Core
     static class TokenPartitioner
     {
         public static
-            Tuple<
-                IEnumerable<KeyValuePair<string, IEnumerable<string>>>, // options
-                IEnumerable<string>,                                    // values
-                IEnumerable<Token>                                      // errors
-            > Partition(
+            Tuple<IEnumerable<KeyValuePair<string, IEnumerable<string>>>, IEnumerable<string>, IEnumerable<Token>> Partition(
                 IEnumerable<Token> tokens,
                 Func<string, Maybe<TypeDescriptor>> typeLookup)
         {
+            IEqualityComparer<Token> tokenComparer = ReferenceEqualityComparer.Default;
+
             var tokenList = tokens.Memorize();
-            var switches = Switch.Partition(tokenList, typeLookup).Memorize();
-            var scalars = Scalar.Partition(tokenList, typeLookup).Memorize();
-            var sequences = Sequence.Partition(tokenList, typeLookup).Memorize();
+            var switches = new HashSet<Token>(Switch.Partition(tokenList, typeLookup), tokenComparer);
+            var scalars = new HashSet<Token>(Scalar.Partition(tokenList, typeLookup), tokenComparer);
+            var sequences = new HashSet<Token>(Sequence.Partition(tokenList, typeLookup), tokenComparer);
             var nonOptions = tokenList
-                .Where(t => !switches.Contains(t, ReferenceEqualityComparer.Default))
-                .Where(t => !scalars.Contains(t, ReferenceEqualityComparer.Default))
-                .Where(t => !sequences.Contains(t, ReferenceEqualityComparer.Default)).Memorize();
+                .Where(t => !switches.Contains(t))
+                .Where(t => !scalars.Contains(t))
+                .Where(t => !sequences.Contains(t)).Memorize();
             var values = nonOptions.Where(v => v.IsValue()).Memorize();
             var errors = nonOptions.Except(values, (IEqualityComparer<Token>)ReferenceEqualityComparer.Default).Memorize();
 
diff --git a/src/CommandLine/Core/Tokenizer.cs b/src/CommandLine/Core/Tokenizer.cs
@@ -36,7 +36,7 @@ public static Result<IEnumerable<Token>, Error> Tokenize(
                           select token)
                             .Memorize();
 
-            var normalized = normalize(tokens);
+            var normalized = normalize(tokens).Memorize();
 
             var unkTokens = (from t in normalized where t.IsName() && nameLookup(t.Text) == NameLookupResult.NoOptionFound select t).Memorize();
 
@@ -60,12 +60,12 @@ public static Result<IEnumerable<Token>, Error> ExplodeOptionList(
             Result<IEnumerable<Token>, Error> tokenizerResult,
             Func<string, Maybe<char>> optionSequenceWithSeparatorLookup)
         {
-            var tokens = tokenizerResult.SucceededWith();
+            var tokens = tokenizerResult.SucceededWith().Memorize();
 
             var replaces = tokens.Select((t, i) =>
                 optionSequenceWithSeparatorLookup(t.Text)
                     .MapValueOrDefault(sep => Tuple.Create(i + 1, sep),
-                        Tuple.Create(-1, '\0'))).SkipWhile(x => x.Item1 < 0);
+                        Tuple.Create(-1, '\0'))).SkipWhile(x => x.Item1 < 0).Memorize();
 
             var exploded = tokens.Select((t, i) =>
                         replaces.FirstOrDefault(x => x.Item1 == i).ToMaybe()
diff --git a/src/CommandLine/Parser.cs b/src/CommandLine/Parser.cs
@@ -99,6 +99,8 @@ public ParserResult<T> ParseArguments<T>(IEnumerable<string> args)
                     settings.NameComparer,
                     settings.CaseInsensitiveEnumValues,
                     settings.ParsingCulture,
+                    settings.AutoHelp,
+                    settings.AutoVersion,
                     HandleUnknownArguments(settings.IgnoreUnknownArguments)),
                 settings);
         }
@@ -128,6 +130,8 @@ public ParserResult<T> ParseArguments<T>(Func<T> factory, IEnumerable<string> ar
                     settings.NameComparer,
                     settings.CaseInsensitiveEnumValues,
                     settings.ParsingCulture,
+                    settings.AutoHelp,
+                    settings.AutoVersion,
                     HandleUnknownArguments(settings.IgnoreUnknownArguments)),
                 settings);
         }
@@ -158,6 +162,8 @@ public ParserResult<object> ParseArguments(IEnumerable<string> args, params Type
                     settings.NameComparer,
                     settings.CaseInsensitiveEnumValues,
                     settings.ParsingCulture,
+                    settings.AutoHelp,
+                    settings.AutoVersion,
                     HandleUnknownArguments(settings.IgnoreUnknownArguments)),
                 settings);
         }
diff --git a/src/CommandLine/ParserSettings.cs b/src/CommandLine/ParserSettings.cs
@@ -20,6 +20,8 @@ public class ParserSettings : IDisposable
         private bool caseInsensitiveEnumValues;
         private TextWriter helpWriter;
         private bool ignoreUnknownArguments;
+        private bool autoHelp;
+        private bool autoVersion;
         private CultureInfo parsingCulture;
         private bool enableDashDash;
         private int maximumDisplayWidth;
@@ -31,6 +33,8 @@ public ParserSettings()
         {
             caseSensitive = true;
             caseInsensitiveEnumValues = false;
+            autoHelp = true;
+            autoVersion = true;
             parsingCulture = CultureInfo.InvariantCulture;
             try
             {
@@ -122,6 +126,24 @@ public bool IgnoreUnknownArguments
             set { PopsicleSetter.Set(Consumed, ref ignoreUnknownArguments, value); }
         }
 
+        /// <summary>
+        /// Gets or sets a value indicating whether implicit option or verb 'help' should be supported.
+        /// </summary>
+        public bool AutoHelp
+        {
+            get { return autoHelp; }
+            set { PopsicleSetter.Set(Consumed, ref autoHelp, value); }
+        }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether implicit option or verb 'version' should be supported.
+        /// </summary>
+        public bool AutoVersion
+        {
+            get { return autoVersion; }
+            set { PopsicleSetter.Set(Consumed, ref autoVersion, value); }
+        }
+
         /// <summary>
         /// Gets or sets a value indicating whether enable double dash '--' syntax,
         /// that forces parsing of all subsequent tokens as values.
diff --git a/src/CommandLine/Text/HeadingInfo.cs b/src/CommandLine/Text/HeadingInfo.cs
@@ -57,14 +57,7 @@ public static HeadingInfo Default
             {
                 var title = ReflectionHelper.GetAttribute<AssemblyTitleAttribute>()
                     .MapValueOrDefault(
-                        titleAttribute =>
-                        {
-                            if (titleAttribute.Title.ToLowerInvariant().EndsWith(".dll"))
-                            {
-                                return titleAttribute.Title.Substring(0, titleAttribute.Title.Length - ".dll".Length);
-                            }
-                            return titleAttribute.Title;
-                        },
+                        titleAttribute => titleAttribute.Title,
                         ReflectionHelper.GetAssemblyName());
 
                 var version = ReflectionHelper.GetAttribute<AssemblyInformationalVersionAttribute>()
diff --git a/src/CommandLine/Text/HelpText.cs b/src/CommandLine/Text/HelpText.cs
diff --git a/tests/CommandLine.Tests/Fakes/Options_With_Custom_Help_Option.cs b/tests/CommandLine.Tests/Fakes/Options_With_Custom_Help_Option.cs
diff --git a/tests/CommandLine.Tests/Fakes/Options_With_Custom_Version_Option.cs b/tests/CommandLine.Tests/Fakes/Options_With_Custom_Version_Option.cs
diff --git a/tests/CommandLine.Tests/Unit/Core/InstanceBuilderTests.cs b/tests/CommandLine.Tests/Unit/Core/InstanceBuilderTests.cs
diff --git a/tests/CommandLine.Tests/Unit/Core/InstanceChooserTests.cs b/tests/CommandLine.Tests/Unit/Core/InstanceChooserTests.cs

Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ select Tuple.Create(`
`43`	`43`	`((OptionSpecification)pt.Specification).FromOptionSpecification()))))`
`44`	`44`	`: Tuple.Create(pt, Maybe.Nothing<Error>());`
`45`	`45`	`}`
`46`		`- );`
	`46`	`+ ).Memorize();`
`47`	`47`	`return Result.Succeed(`
`48`	`48`	`sequencesAndErrors.Select(se => se.Item1),`
`49`	`49`	`sequencesAndErrors.Select(se => se.Item2).OfType<Just<Error>>().Select(se => se.Value));`