Add multi-instance option support

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/SpecificationPropertyRules.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()