Add FlagCounter property to OptionSpecification

FlagCounter lets an int property count the number of times a flag
appears, e.g. "-v -v -v" would produce the value 3 in an int property
decorated with [Option('v', FlagCounter=true)].

Author: rmunn

src/CommandLine/Core/InstanceBuilder.cs

@@ -88,14 +88,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, ignoreValueCase),
+                        (vals, type, isScalar, isFlag) => TypeConverter.ChangeType(vals, type, isScalar, isFlag, parsingCulture, ignoreValueCase),
                         nameComparer);
 
                 var valueSpecPropsResult =
                     ValueMapper.MapValues(
                         (from pt in specProps where pt.Specification.IsValue() orderby ((ValueSpecification)pt.Specification).Index select pt),
                         valuesPartition,    
-                        (vals, type, isScalar) => TypeConverter.ChangeType(vals, type, isScalar, parsingCulture, ignoreValueCase));
+                        (vals, type, isScalar) => TypeConverter.ChangeType(vals, type, isScalar, false, parsingCulture, ignoreValueCase));
 
                 var missingValueErrors = from token in errorsPartition
                                          select

src/CommandLine/Core/NameLookup.cs

@@ -20,7 +20,7 @@ public static NameLookupResult Contains(string name, IEnumerable<OptionSpecifica
         {
             var option = specifications.FirstOrDefault(a => name.MatchName(a.ShortName, a.LongName, comparer));
             if (option == null) return NameLookupResult.NoOptionFound;
-            return option.ConversionType == typeof(bool)
+            return option.ConversionType == typeof(bool) || (option.ConversionType == typeof(int) && option.FlagCounter)
                 ? NameLookupResult.BooleanOptionFound
                 : NameLookupResult.OtherOptionFound;
         }

src/CommandLine/Core/OptionMapper.cs

@@ -15,7 +15,7 @@ public static Result<
             MapValues(
                 IEnumerable<SpecificationProperty> propertyTuples,
                 IEnumerable<KeyValuePair<string, IEnumerable<string>>> options,
-                Func<IEnumerable<string>, Type, bool, Maybe<object>> converter,
+                Func<IEnumerable<string>, Type, bool, bool, Maybe<object>> converter,
                 StringComparer comparer)
         {
             var sequencesAndErrors = propertyTuples
@@ -27,7 +27,7 @@ public static Result<
                         if (matched.IsJust())
                         {
                             var matches = matched.GetValueOrDefault(Enumerable.Empty<KeyValuePair<string, IEnumerable<string>>>());
-                            var values = new HashSet<string>();
+                            var values = new List<string>();
                             foreach (var kvp in matches)
                             {
                                 foreach (var value in kvp.Value)
@@ -36,7 +36,9 @@ public static Result<
                                 }
                             }
 
-                            return converter(values, pt.Property.PropertyType, pt.Specification.TargetType != TargetType.Sequence)
+                            bool isFlag = pt.Specification.Tag == SpecificationType.Option && ((OptionSpecification)pt.Specification).FlagCounter;
+
+                            return converter(values, isFlag ? typeof(bool) : pt.Property.PropertyType, pt.Specification.TargetType != TargetType.Sequence, isFlag)
                                 .Select(value => Tuple.Create(pt.WithValue(Maybe.Just(value)), Maybe.Nothing<Error>()))
                                 .GetValueOrDefault(
                                     Tuple.Create<SpecificationProperty, Maybe<Error>>(

src/CommandLine/Core/OptionSpecification.cs

@@ -14,18 +14,20 @@ sealed class OptionSpecification : Specification
         private readonly char separator;
         private readonly string setName;
         private readonly string group;
+        private readonly bool flagCounter;
 
         public OptionSpecification(string shortName, string longName, bool required, string setName, Maybe<int> min, Maybe<int> max,
             char separator, Maybe<object> defaultValue, string helpText, string metaValue, IEnumerable<string> enumValues,
-            Type conversionType, TargetType targetType, string group, bool hidden = false)
+            Type conversionType, TargetType targetType, string group, bool flagCounter = false, bool hidden = false)
             : base(SpecificationType.Option,
-                 required, min, max, defaultValue, helpText, metaValue, enumValues, conversionType, targetType, hidden)
+                 required, min, max, defaultValue, helpText, metaValue, enumValues, conversionType, conversionType == typeof(int) && flagCounter ? TargetType.Switch : targetType, hidden)
         {
             this.shortName = shortName;
             this.longName = longName;
             this.separator = separator;
             this.setName = setName;
             this.group = group;
+            this.flagCounter = flagCounter;
         }
 
         public static OptionSpecification FromAttribute(OptionAttribute attribute, Type conversionType, IEnumerable<string> enumValues)
@@ -45,13 +47,14 @@ public static OptionSpecification FromAttribute(OptionAttribute attribute, Type
                 conversionType,
                 conversionType.ToTargetType(),
                 attribute.Group,
+                attribute.FlagCounter,
                 attribute.Hidden);
         }
 
         public static OptionSpecification NewSwitch(string shortName, string longName, bool required, string helpText, string metaValue, bool hidden = false)
         {
             return new OptionSpecification(shortName, longName, required, string.Empty, Maybe.Nothing<int>(), Maybe.Nothing<int>(),
-                '\0', Maybe.Nothing<object>(), helpText, metaValue, Enumerable.Empty<string>(), typeof(bool), TargetType.Switch, string.Empty, hidden);
+                '\0', Maybe.Nothing<object>(), helpText, metaValue, Enumerable.Empty<string>(), typeof(bool), TargetType.Switch, string.Empty, false, hidden);
         }
 
         public string ShortName
@@ -78,5 +81,13 @@ public string Group
         {
             get { return group; }
         }
+
+        /// <summary>
+        /// Whether this is an int option that counts how many times a flag was set rather than taking a value on the command line
+        /// </summary>
+        public bool FlagCounter
+        {
+            get { return flagCounter; }
+        }
     }
 }

src/CommandLine/Core/SpecificationExtensions.cs

@@ -35,6 +35,7 @@ public static OptionSpecification WithLongName(this OptionSpecification specific
                 specification.ConversionType,
                 specification.TargetType,
                 specification.Group,
+                specification.FlagCounter,
                 specification.Hidden);
         }
 

src/CommandLine/Core/TypeConverter.cs

@@ -13,11 +13,13 @@ namespace CommandLine.Core
 {
     static class TypeConverter
     {
-        public static Maybe<object> ChangeType(IEnumerable<string> values, Type conversionType, bool scalar, CultureInfo conversionCulture, bool ignoreValueCase)
+        public static Maybe<object> ChangeType(IEnumerable<string> values, Type conversionType, bool scalar, bool isFlag, CultureInfo conversionCulture, bool ignoreValueCase)
         {
-            return scalar
-                ? ChangeTypeScalar(values.Last(), conversionType, conversionCulture, ignoreValueCase)
-                : ChangeTypeSequence(values, conversionType, conversionCulture, ignoreValueCase);
+            return isFlag
+                ? ChangeTypeFlagCounter(values, conversionType, conversionCulture, ignoreValueCase)
+                : scalar
+                    ? ChangeTypeScalar(values.Last(), conversionType, conversionCulture, ignoreValueCase)
+                    : ChangeTypeSequence(values, conversionType, conversionCulture, ignoreValueCase);
         }
 
         private static Maybe<object> ChangeTypeSequence(IEnumerable<string> values, Type conversionType, CultureInfo conversionCulture, bool ignoreValueCase)
@@ -46,6 +48,14 @@ private static Maybe<object> ChangeTypeScalar(string value, Type conversionType,
             return result.ToMaybe();
         }
 
+        private static Maybe<object> ChangeTypeFlagCounter(IEnumerable<string> values, Type conversionType, CultureInfo conversionCulture, bool ignoreValueCase)
+        {
+            var converted = values.Select(value => ChangeTypeScalar(value, typeof(bool), conversionCulture, ignoreValueCase));
+            return converted.Any(maybe => maybe.MatchNothing())
+                ? Maybe.Nothing<object>()
+                : Maybe.Just((object)converted.Count(value => value.IsJust()));
+        }
+
         private static object ConvertString(string value, Type type, CultureInfo conversionCulture)
         {
             try

src/CommandLine/OptionAttribute.cs

@@ -15,6 +15,7 @@ public sealed class OptionAttribute : BaseAttribute
         private readonly string longName;
         private readonly string shortName;
         private string setName;
+        private bool flagCounter;
         private char separator;
         private string group=string.Empty;
 
@@ -96,6 +97,16 @@ public string SetName
             }
         }
 
+        /// <summary>
+        /// If true, this is an int option that counts how many times a flag was set (e.g. "-v -v -v" or "-vvv" would return 3).
+        /// The property must be of type int (signed 32-bit integer).
+        /// </summary>
+        public bool FlagCounter
+        {
+            get { return flagCounter; }
+            set { flagCounter = value; }
+        }
+
         /// <summary>
         /// When applying attribute to <see cref="System.Collections.Generic.IEnumerable{T}"/> target properties,
         /// it allows you to split an argument and consume its content as a sequence.

src/CommandLine/UnParserExtensions.cs

@@ -153,7 +153,9 @@ public static string FormatCommandLine<T>(this Parser parser, T options, Action<
 
             var allOptSpecs = from info in specs.Where(i => i.Specification.Tag == SpecificationType.Option)
                               let o = (OptionSpecification)info.Specification
-                              where o.TargetType != TargetType.Switch || (o.TargetType == TargetType.Switch && ((bool)info.Value))
+                              where o.TargetType != TargetType.Switch ||
+                                   (o.TargetType == TargetType.Switch && o.FlagCounter && ((int)info.Value > 0)) ||
+                                   (o.TargetType == TargetType.Switch && ((bool)info.Value))
                               where !o.Hidden || settings.ShowHidden
                               orderby o.UniqueName()
                               select info;
@@ -176,7 +178,12 @@ orderby v.Index
 
             builder = settings.GroupSwitches && shortSwitches.Any()
                 ? builder.Append('-').Append(string.Join(string.Empty, shortSwitches.Select(
-                    info => ((OptionSpecification)info.Specification).ShortName).ToArray())).Append(' ')
+                    info => {
+                        var o = (OptionSpecification)info.Specification;
+                        return o.FlagCounter
+                            ? string.Concat(Enumerable.Repeat(o.ShortName, (int)info.Value))
+                            : o.ShortName;
+                    }).ToArray())).Append(' ')
                 : builder;
             optSpecs.ForEach(
                 opt =>
@@ -250,24 +257,25 @@ private static char SeperatorOrSpace(this Specification spec)
         private static string FormatOption(OptionSpecification spec, object value, UnParserSettings settings)
         {
             return new StringBuilder()
-                    .Append(spec.FormatName(settings))
+                    .Append(spec.FormatName(value, settings))
                     .AppendWhen(spec.TargetType != TargetType.Switch, FormatValue(spec, value))
                 .ToString();
         }
 
-        private static string FormatName(this OptionSpecification optionSpec, UnParserSettings settings)
+        private static string FormatName(this OptionSpecification optionSpec, object value, UnParserSettings settings)
         {
             // Have a long name and short name not preferred? Go with long! 
             // No short name? Has to be long!
             var longName = (optionSpec.LongName.Length > 0 && !settings.PreferShortName)
                          || optionSpec.ShortName.Length == 0;
 
-            return
+            var formattedName =
                 new StringBuilder(longName
                     ? "--".JoinTo(optionSpec.LongName)
                     : "-".JoinTo(optionSpec.ShortName))
                         .AppendWhen(optionSpec.TargetType != TargetType.Switch, longName && settings.UseEqualToken ? "=" : " ")
                     .ToString();
+            return optionSpec.FlagCounter ? String.Join(" ", Enumerable.Repeat(formattedName, (int)value)) : formattedName;
         }
 
         private static object NormalizeValue(this object value)

tests/CommandLine.Tests/Fakes/Options_With_FlagCounter_Switches.cs

@@ -0,0 +1,13 @@
+// Copyright 2005-2015 Giacomo Stelluti Scala & Contributors. All rights reserved. See License.md in the project root for license information.
+
+namespace CommandLine.Tests.Fakes
+{
+    public class Options_With_FlagCounter_Switches
+    {
+        [Option('v', FlagCounter=true)]
+        public int Verbose { get; set; }
+
+        [Option('s', FlagCounter=true)]
+        public int Silent { get; set; }
+    }
+}

tests/CommandLine.Tests/Unit/Core/OptionMapperTests.cs

@@ -37,7 +37,7 @@ public void Map_boolean_switch_creates_boolean_value()
             var result = OptionMapper.MapValues(
                 specProps.Where(pt => pt.Specification.IsOption()),
                 tokenPartitions,
-                (vals, type, isScalar) => TypeConverter.ChangeType(vals, type, isScalar, CultureInfo.InvariantCulture, false),
+                (vals, type, isScalar, isFlag) => TypeConverter.ChangeType(vals, type, isScalar, isFlag, CultureInfo.InvariantCulture, false),
                 StringComparer.Ordinal
                 );
 
@@ -72,7 +72,7 @@ public void Map_with_multi_instance_scalar()
             var result = OptionMapper.MapValues(
                 specProps.Where(pt => pt.Specification.IsOption()),
                 tokenPartitions,
-                (vals, type, isScalar) => TypeConverter.ChangeType(vals, type, isScalar, CultureInfo.InvariantCulture, false),
+                (vals, type, isScalar, isFlag) => TypeConverter.ChangeType(vals, type, isScalar, isFlag, CultureInfo.InvariantCulture, false),
                 StringComparer.Ordinal);
 
             var property = result.SucceededWith().Single();
@@ -101,7 +101,7 @@ public void Map_with_multi_instance_sequence()
             var result = OptionMapper.MapValues(
                 specProps.Where(pt => pt.Specification.IsOption()),
                 tokenPartitions,
-                (vals, type, isScalar) => TypeConverter.ChangeType(vals, type, isScalar, CultureInfo.InvariantCulture, false),
+                (vals, type, isScalar, isFlag) => TypeConverter.ChangeType(vals, type, isScalar, isFlag, CultureInfo.InvariantCulture, false),
                 StringComparer.Ordinal);
 
             var property = result.SucceededWith().Single();

tests/CommandLine.Tests/Unit/Core/TypeConverterTests.cs

@@ -27,7 +27,7 @@ enum TestFlagEnum
         [MemberData(nameof(ChangeType_scalars_source))]
         public void ChangeType_scalars(string testValue, Type destinationType, bool expectFail, object expectedResult)
         {
-            Maybe<object> result = TypeConverter.ChangeType(new[] {testValue}, destinationType, true, CultureInfo.InvariantCulture, true);
+            Maybe<object> result = TypeConverter.ChangeType(new[] {testValue}, destinationType, true, false, CultureInfo.InvariantCulture, true);
 
             if (expectFail)
             {
@@ -121,11 +121,43 @@ public static IEnumerable<object[]> ChangeType_scalars_source
             }
         }
 
+        [Theory]
+        [MemberData(nameof(ChangeType_flagCounters_source))]
+        public void ChangeType_flagCounters(string[] testValue, Type destinationType, bool expectFail, object expectedResult)
+        {
+            Maybe<object> result = TypeConverter.ChangeType(testValue, destinationType, true, true, CultureInfo.InvariantCulture, true);
+
+            if (expectFail)
+            {
+                result.MatchNothing().Should().BeTrue("should fail parsing");
+            }
+            else
+            {
+                result.MatchJust(out object matchedValue).Should().BeTrue("should parse successfully");
+                Assert.Equal(matchedValue, expectedResult);
+            }
+        }
+
+        public static IEnumerable<object[]> ChangeType_flagCounters_source
+        {
+            get
+            {
+                return new[]
+                {
+                    new object[] {new string[0], typeof (int), false, 0},
+                    new object[] {new[] {"true"}, typeof (int), false, 1},
+                    new object[] {new[] {"true", "true"}, typeof (int), false, 2},
+                    new object[] {new[] {"true", "true", "true"}, typeof (int), false, 3},
+                    new object[] {new[] {"true", "x"}, typeof (int), true, 0},
+                };
+            }
+        }
+
         [Fact]
         public void ChangeType_Scalar_LastOneWins()
         {
             var values = new[] { "100", "200", "300", "400", "500" };
-            var result = TypeConverter.ChangeType(values, typeof(int), true, CultureInfo.InvariantCulture, true);
+            var result = TypeConverter.ChangeType(values, typeof(int), true, false, CultureInfo.InvariantCulture, true);
             result.MatchJust(out var matchedValue).Should().BeTrue("should parse successfully");
             Assert.Equal(500, matchedValue);
 

tests/CommandLine.Tests/Unit/ParserTests.cs

@@ -95,6 +95,36 @@ public void Parse_options_with_short_name(string outputFile, string[] args)
             // Teardown
         }
 
+        [Theory]
+        [InlineData(new string[0], 0, 0)]
+        [InlineData(new[] { "-v" }, 1, 0)]
+        [InlineData(new[] { "-vv" }, 2, 0)]
+        [InlineData(new[] { "-v", "-v" }, 2, 0)]
+        [InlineData(new[] { "-v", "-v", "-v" }, 3, 0)]
+        [InlineData(new[] { "-v", "-vv" }, 3, 0)]
+        [InlineData(new[] { "-vv", "-v" }, 3, 0)]
+        [InlineData(new[] { "-vvv" }, 3, 0)]
+        [InlineData(new[] { "-v", "-s", "-v", "-v" }, 3, 1)]
+        [InlineData(new[] { "-v", "-ss", "-v", "-v" }, 3, 2)]
+        [InlineData(new[] { "-v", "-s", "-sv", "-v" }, 3, 2)]
+        [InlineData(new[] { "-vsvv" }, 3, 1)]
+        [InlineData(new[] { "-vssvv" }, 3, 2)]
+        [InlineData(new[] { "-vsvsv" }, 3, 2)]
+        public void Parse_FlagCounter_options_with_short_name(string[] args, int verboseCount, int silentCount)
+        {
+            // Fixture setup
+            var expectedOptions = new Options_With_FlagCounter_Switches { Verbose = verboseCount, Silent = silentCount };
+            var sut = new Parser(with => with.AllowMultiInstance = true);
+
+            // Exercize system
+            var result = sut.ParseArguments<Options_With_FlagCounter_Switches>(args);
+
+            // Verify outcome
+            // ((NotParsed<Options_With_FlagCounter_Switches>)result).Errors.Should().BeEmpty();
+            ((Parsed<Options_With_FlagCounter_Switches>)result).Value.Should().BeEquivalentTo(expectedOptions);
+            // Teardown
+        }
+
         [Fact]
         public void Parse_repeated_options_with_default_parser()
         {