Add multi-instance option support (#678)

* Add multi-instance option support

Fixes #357

* Fix Appveyor build

It seems Appveyor's C# compiler is old enough that it doesn't know how
to do tuple deconstruction, so we'll avoid doing that. It makes
TokenPartitioner uglier, but no getting around that if we're dealing
with an old C# compiler.

Author: rmunn

src/CommandLine/Core/InstanceBuilder.cs

@@ -24,6 +24,30 @@ public static ParserResult<T> Build<T>(
             bool autoVersion,
             IEnumerable<ErrorType> nonFatalErrors)
         {
+            return Build(
+                factory,
+                tokenizer,
+                arguments,
+                nameComparer,
+                ignoreValueCase,
+                parsingCulture,
+                autoHelp,
+                autoVersion,
+                false,
+                nonFatalErrors);
+        }
+
+        public static ParserResult<T> Build<T>(
+            Maybe<Func<T>> factory,
+            Func<IEnumerable<string>, IEnumerable<OptionSpecification>, Result<IEnumerable<Token>, Error>> tokenizer,
+            IEnumerable<string> arguments,
+            StringComparer nameComparer,
+            bool ignoreValueCase,
+            CultureInfo parsingCulture,
+            bool autoHelp,
+            bool autoVersion,
+            bool allowMultiInstance,
+            IEnumerable<ErrorType> nonFatalErrors)        {
             var typeInfo = factory.MapValueOrDefault(f => f().GetType(), typeof(T));
 
             var specProps = typeInfo.GetSpecifications(pi => SpecificationProperty.Create(
@@ -95,7 +119,7 @@ public static ParserResult<T> Build<T>(
                     instance = BuildImmutable(typeInfo, factory, specProps, specPropsWithValue, setPropertyErrors);
                 }
 
-                var validationErrors = specPropsWithValue.Validate(SpecificationPropertyRules.Lookup(tokens));
+                var validationErrors = specPropsWithValue.Validate(SpecificationPropertyRules.Lookup(tokens, allowMultiInstance));
 
                 var allErrors =
                     tokenizerResult.SuccessMessages()

src/CommandLine/Core/InstanceChooser.cs

@@ -22,6 +22,31 @@ public static ParserResult<object> Choose(
             bool autoHelp,
             bool autoVersion,
             IEnumerable<ErrorType> nonFatalErrors)
+        {
+            return Choose(
+                tokenizer,
+                types,
+                arguments,
+                nameComparer,
+                ignoreValueCase,
+                parsingCulture,
+                autoHelp,
+                autoVersion,
+                false,
+                nonFatalErrors);
+        }
+
+        public static ParserResult<object> Choose(
+            Func<IEnumerable<string>, IEnumerable<OptionSpecification>, Result<IEnumerable<Token>, Error>> tokenizer,
+            IEnumerable<Type> types,
+            IEnumerable<string> arguments,
+            StringComparer nameComparer,
+            bool ignoreValueCase,
+            CultureInfo parsingCulture,
+            bool autoHelp,
+            bool autoVersion,
+            bool allowMultiInstance,
+            IEnumerable<ErrorType> nonFatalErrors)
         {
             var verbs = Verb.SelectFromTypes(types);
             var defaultVerbs = verbs.Where(t => t.Item1.IsDefault);
@@ -46,7 +71,7 @@ bool preprocCompare(string command) =>
                             arguments.Skip(1).FirstOrDefault() ?? string.Empty, nameComparer))
                     : (autoVersion && preprocCompare("version"))
                         ? MakeNotParsed(types, new VersionRequestedError())
-                        : MatchVerb(tokenizer, verbs, defaultVerb, arguments, nameComparer, ignoreValueCase, parsingCulture, autoHelp, autoVersion, nonFatalErrors);
+                        : MatchVerb(tokenizer, verbs, defaultVerb, arguments, nameComparer, ignoreValueCase, parsingCulture, autoHelp, autoVersion, allowMultiInstance, nonFatalErrors);
             }
 
             return arguments.Any()
@@ -92,6 +117,7 @@ private static ParserResult<object> MatchVerb(
             CultureInfo parsingCulture,
             bool autoHelp,
             bool autoVersion,
+            bool allowMultiInstance,
             IEnumerable<ErrorType> nonFatalErrors)
         {
             string firstArg = arguments.First();
@@ -114,7 +140,8 @@ private static ParserResult<object> MatchVerb(
                 ignoreValueCase,
                 parsingCulture,
                 autoHelp,
-                autoVersion,                
+                autoVersion,
+                allowMultiInstance,                
                 nonFatalErrors);
         }
 

src/CommandLine/Core/OptionMapper.cs

@@ -22,26 +22,31 @@ public static Result<
                 .Select(
                     pt =>
                     {
-                        var matched = options.FirstOrDefault(s =>
+                        var matched = options.Where(s =>
                             s.Key.MatchName(((OptionSpecification)pt.Specification).ShortName, ((OptionSpecification)pt.Specification).LongName, comparer)).ToMaybe();
-                        return matched.IsJust()
-                            ? (
-                                from sequence in matched
-                                from converted in
-                                    converter(
-                                        sequence.Value,
-                                        pt.Property.PropertyType,
-                                        pt.Specification.TargetType != TargetType.Sequence)
-                                select Tuple.Create(
-                                    pt.WithValue(Maybe.Just(converted)), Maybe.Nothing<Error>())
-                               )
+                        if (matched.IsJust())
+                        {
+                            var matches = matched.GetValueOrDefault(Enumerable.Empty<KeyValuePair<string, IEnumerable<string>>>());
+                            var values = new HashSet<string>();
+                            foreach (var kvp in matches)
+                            {
+                                foreach (var value in kvp.Value)
+                                {
+                                    values.Add(value);
+                                }
+                            }
+
+                            return converter(values, pt.Property.PropertyType, pt.Specification.TargetType != TargetType.Sequence)
+                                .Select(value => Tuple.Create(pt.WithValue(Maybe.Just(value)), Maybe.Nothing<Error>()))
                                 .GetValueOrDefault(
                                     Tuple.Create<SpecificationProperty, Maybe<Error>>(
                                         pt,
                                         Maybe.Just<Error>(
                                             new BadFormatConversionError(
-                                                ((OptionSpecification)pt.Specification).FromOptionSpecification()))))
-                            : Tuple.Create(pt, Maybe.Nothing<Error>());
+                                                ((OptionSpecification)pt.Specification).FromOptionSpecification()))));
+                        }
+
+                        return Tuple.Create(pt, Maybe.Nothing<Error>());
                     }
                 ).Memoize();
             return Result.Succeed(

src/CommandLine/Core/PartitionExtensions.cs

@@ -0,0 +1,25 @@
+// Copyright 2005-2015 Giacomo Stelluti Scala & Contributors. All rights reserved. See License.md in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using CSharpx;
+
+namespace CommandLine.Core
+{
+    static class PartitionExtensions
+    {
+        public static Tuple<IEnumerable<T>,IEnumerable<T>> PartitionByPredicate<T>(
+            this IEnumerable<T> items,
+            Func<T, bool> pred)
+        {
+            List<T> yes = new List<T>();
+            List<T> no = new List<T>();
+            foreach (T item in items) {
+                List<T> list = pred(item) ? yes : no;
+                list.Add(item);
+            }
+            return Tuple.Create<IEnumerable<T>,IEnumerable<T>>(yes, no);
+        }
+    }
+}

src/CommandLine/Core/Scalar.cs

@@ -13,6 +13,14 @@ static class SpecificationPropertyRules
         public static IEnumerable<Func<IEnumerable<SpecificationProperty>, IEnumerable<Error>>>
             Lookup(
                 IEnumerable<Token> tokens)
+        {
+            return Lookup(tokens, false);
+        }
+
+        public static IEnumerable<Func<IEnumerable<SpecificationProperty>, IEnumerable<Error>>>
+            Lookup(
+                IEnumerable<Token> tokens,
+                bool allowMultiInstance)
         {
             return new List<Func<IEnumerable<SpecificationProperty>, IEnumerable<Error>>>
                 {
@@ -21,7 +29,7 @@ public static IEnumerable<Func<IEnumerable<SpecificationProperty>, IEnumerable<E
                     EnforceMutuallyExclusiveSetAndGroupAreNotUsedTogether(),
                     EnforceRequired(),
                     EnforceRange(),
-                    EnforceSingle(tokens)
+                    EnforceSingle(tokens, allowMultiInstance)
                 };
         }
 
@@ -173,10 +181,15 @@ from s in options
                 };
         }
 
-        private static Func<IEnumerable<SpecificationProperty>, IEnumerable<Error>> EnforceSingle(IEnumerable<Token> tokens)
+        private static Func<IEnumerable<SpecificationProperty>, IEnumerable<Error>> EnforceSingle(IEnumerable<Token> tokens, bool allowMultiInstance)
         {
             return specProps =>
                 {
+                    if (allowMultiInstance)
+                    {
+                        return Enumerable.Empty<Error>();
+                    }
+
                     var specs = from sp in specProps
                                 where sp.Specification.IsOption()
                                 where sp.Value.IsJust()