Add FlagCounter property to OptionSpecification

rmunn · rmunn · commit 3354ffbdf597 · 2020-08-20T06:46:40.000+07:00
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)].
diff --git a/src/CommandLine/Core/InstanceBuilder.cs b/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
diff --git a/src/CommandLine/Core/NameLookup.cs b/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;
         }
diff --git a/src/CommandLine/Core/OptionMapper.cs b/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>>(
diff --git a/src/CommandLine/Core/OptionSpecification.cs b/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; }
+        }
     }
 }
diff --git a/src/CommandLine/Core/SpecificationExtensions.cs b/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);
         }
 
diff --git a/src/CommandLine/Core/TypeConverter.cs b/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
diff --git a/src/CommandLine/OptionAttribute.cs b/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.
diff --git a/src/CommandLine/UnParserExtensions.cs b/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)
diff --git a/tests/CommandLine.Tests/Fakes/Options_With_FlagCounter_Switches.cs b/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; }
+    }
+}
diff --git a/tests/CommandLine.Tests/Unit/Core/OptionMapperTests.cs b/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();
diff --git a/tests/CommandLine.Tests/Unit/Core/TypeConverterTests.cs b/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);
 
diff --git a/tests/CommandLine.Tests/Unit/ParserTests.cs b/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()
         {
diff --git a/tests/CommandLine.Tests/Unit/UnParserExtensionsTests.cs b/tests/CommandLine.Tests/Unit/UnParserExtensionsTests.cs

Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ public static NameLookupResult Contains(string name, IEnumerable<OptionSpecifica`
`20`	`20`	`{`
`21`	`21`	`var option = specifications.FirstOrDefault(a => name.MatchName(a.ShortName, a.LongName, comparer));`
`22`	`22`	`if (option == null) return NameLookupResult.NoOptionFound;`
`23`		`- return option.ConversionType == typeof(bool)`
	`23`	`+ return option.ConversionType == typeof(bool) \|\| (option.ConversionType == typeof(int) && option.FlagCounter)`
`24`	`24`	`? NameLookupResult.BooleanOptionFound`
`25`	`25`	`: NameLookupResult.OtherOptionFound;`
`26`	`26`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ public static Result<`
`15`	`15`	`MapValues(`
`16`	`16`	`IEnumerable<SpecificationProperty> propertyTuples,`
`17`	`17`	`IEnumerable<KeyValuePair<string, IEnumerable<string>>> options,`
`18`		`- Func<IEnumerable<string>, Type, bool, Maybe<object>> converter,`
	`18`	`+ Func<IEnumerable<string>, Type, bool, bool, Maybe<object>> converter,`
`19`	`19`	`StringComparer comparer)`
`20`	`20`	`{`
`21`	`21`	`var sequencesAndErrors = propertyTuples`
`@@ -27,7 +27,7 @@ public static Result<`
`27`	`27`	`if (matched.IsJust())`
`28`	`28`	`{`
`29`	`29`	`var matches = matched.GetValueOrDefault(Enumerable.Empty<KeyValuePair<string, IEnumerable<string>>>());`
`30`		`- var values = new HashSet<string>();`
	`30`	`+ var values = new List<string>();`
`31`	`31`	`foreach (var kvp in matches)`
`32`	`32`	`{`
`33`	`33`	`foreach (var value in kvp.Value)`
`@@ -36,7 +36,9 @@ public static Result<`
`36`	`36`	`}`
`37`	`37`	`}`
`38`	`38`
`39`		`- return converter(values, pt.Property.PropertyType, pt.Specification.TargetType != TargetType.Sequence)`
	`39`	`+ bool isFlag = pt.Specification.Tag == SpecificationType.Option && ((OptionSpecification)pt.Specification).FlagCounter;`
	`40`	`+`
	`41`	`+ return converter(values, isFlag ? typeof(bool) : pt.Property.PropertyType, pt.Specification.TargetType != TargetType.Sequence, isFlag)`
`40`	`42`	`.Select(value => Tuple.Create(pt.WithValue(Maybe.Just(value)), Maybe.Nothing<Error>()))`
`41`	`43`	`.GetValueOrDefault(`
`42`	`44`	`Tuple.Create<SpecificationProperty, Maybe<Error>>(`
Original file line number	Diff line number	Diff line change
`@@ -14,18 +14,20 @@ sealed class OptionSpecification : Specification`
`14`	`14`	`private readonly char separator;`
`15`	`15`	`private readonly string setName;`
`16`	`16`	`private readonly string group;`
	`17`	`+ private readonly bool flagCounter;`
`17`	`18`
`18`	`19`	`public OptionSpecification(string shortName, string longName, bool required, string setName, Maybe<int> min, Maybe<int> max,`
`19`	`20`	`char separator, Maybe<object> defaultValue, string helpText, string metaValue, IEnumerable<string> enumValues,`
`20`		`- Type conversionType, TargetType targetType, string group, bool hidden = false)`
	`21`	`+ Type conversionType, TargetType targetType, string group, bool flagCounter = false, bool hidden = false)`
`21`	`22`	`: base(SpecificationType.Option,`
`22`		`- required, min, max, defaultValue, helpText, metaValue, enumValues, conversionType, targetType, hidden)`
	`23`	`+ required, min, max, defaultValue, helpText, metaValue, enumValues, conversionType, conversionType == typeof(int) && flagCounter ? TargetType.Switch : targetType, hidden)`
`23`	`24`	`{`
`24`	`25`	`this.shortName = shortName;`
`25`	`26`	`this.longName = longName;`
`26`	`27`	`this.separator = separator;`
`27`	`28`	`this.setName = setName;`
`28`	`29`	`this.group = group;`
	`30`	`+ this.flagCounter = flagCounter;`
`29`	`31`	`}`
`30`	`32`
`31`	`33`	`public static OptionSpecification FromAttribute(OptionAttribute attribute, Type conversionType, IEnumerable<string> enumValues)`
`@@ -45,13 +47,14 @@ public static OptionSpecification FromAttribute(OptionAttribute attribute, Type`
`45`	`47`	`conversionType,`
`46`	`48`	`conversionType.ToTargetType(),`
`47`	`49`	`attribute.Group,`
	`50`	`+ attribute.FlagCounter,`
`48`	`51`	`attribute.Hidden);`
`49`	`52`	`}`
`50`	`53`
`51`	`54`	`public static OptionSpecification NewSwitch(string shortName, string longName, bool required, string helpText, string metaValue, bool hidden = false)`
`52`	`55`	`{`
`53`	`56`	`return new OptionSpecification(shortName, longName, required, string.Empty, Maybe.Nothing<int>(), Maybe.Nothing<int>(),`
`54`		`- '\0', Maybe.Nothing<object>(), helpText, metaValue, Enumerable.Empty<string>(), typeof(bool), TargetType.Switch, string.Empty, hidden);`
	`57`	`+ '\0', Maybe.Nothing<object>(), helpText, metaValue, Enumerable.Empty<string>(), typeof(bool), TargetType.Switch, string.Empty, false, hidden);`
`55`	`58`	`}`
`56`	`59`
`57`	`60`	`public string ShortName`
`@@ -78,5 +81,13 @@ public string Group`
`78`	`81`	`{`
`79`	`82`	`get { return group; }`
`80`	`83`	`}`
	`84`	`+`
	`85`	`+ /// <summary>`
	`86`	`+ /// Whether this is an int option that counts how many times a flag was set rather than taking a value on the command line`
	`87`	`+ /// </summary>`
	`88`	`+ public bool FlagCounter`
	`89`	`+ {`
	`90`	`+ get { return flagCounter; }`
	`91`	`+ }`
`81`	`92`	`}`
`82`	`93`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,6 +35,7 @@ public static OptionSpecification WithLongName(this OptionSpecification specific`
`35`	`35`	`specification.ConversionType,`
`36`	`36`	`specification.TargetType,`
`37`	`37`	`specification.Group,`
	`38`	`+ specification.FlagCounter,`
`38`	`39`	`specification.Hidden);`
`39`	`40`	`}`
`40`	`41`
Original file line number	Diff line number	Diff line change
`@@ -13,11 +13,13 @@ namespace CommandLine.Core`
`13`	`13`	`{`
`14`	`14`	`static class TypeConverter`
`15`	`15`	`{`
`16`		`- public static Maybe<object> ChangeType(IEnumerable<string> values, Type conversionType, bool scalar, CultureInfo conversionCulture, bool ignoreValueCase)`
	`16`	`+ public static Maybe<object> ChangeType(IEnumerable<string> values, Type conversionType, bool scalar, bool isFlag, CultureInfo conversionCulture, bool ignoreValueCase)`
`17`	`17`	`{`
`18`		`- return scalar`
`19`		`- ? ChangeTypeScalar(values.Last(), conversionType, conversionCulture, ignoreValueCase)`
`20`		`- : ChangeTypeSequence(values, conversionType, conversionCulture, ignoreValueCase);`
	`18`	`+ return isFlag`
	`19`	`+ ? ChangeTypeFlagCounter(values, conversionType, conversionCulture, ignoreValueCase)`
	`20`	`+ : scalar`
	`21`	`+ ? ChangeTypeScalar(values.Last(), conversionType, conversionCulture, ignoreValueCase)`
	`22`	`+ : ChangeTypeSequence(values, conversionType, conversionCulture, ignoreValueCase);`
`21`	`23`	`}`
`22`	`24`
`23`	`25`	`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,`
`46`	`48`	`return result.ToMaybe();`
`47`	`49`	`}`
`48`	`50`
	`51`	`+ private static Maybe<object> ChangeTypeFlagCounter(IEnumerable<string> values, Type conversionType, CultureInfo conversionCulture, bool ignoreValueCase)`
	`52`	`+ {`
	`53`	`+ var converted = values.Select(value => ChangeTypeScalar(value, typeof(bool), conversionCulture, ignoreValueCase));`
	`54`	`+ return converted.Any(maybe => maybe.MatchNothing())`
	`55`	`+ ? Maybe.Nothing<object>()`
	`56`	`+ : Maybe.Just((object)converted.Count(value => value.IsJust()));`
	`57`	`+ }`
	`58`	`+`
`49`	`59`	`private static object ConvertString(string value, Type type, CultureInfo conversionCulture)`
`50`	`60`	`{`
`51`	`61`	`try`