Add setting to interpret options starting with a single dash as long named options

src/CommandLine/Core/GetoptTokenizer.cs

@@ -16,15 +16,22 @@ public static Result<IEnumerable<Token>, Error> Tokenize(
             IEnumerable<string> arguments,
             Func<string, NameLookupResult> nameLookup)
         {
-            return GetoptTokenizer.Tokenize(arguments, nameLookup, ignoreUnknownArguments:false, allowDashDash:true, posixlyCorrect:false);
+            return GetoptTokenizer.Tokenize(
+                arguments,
+                nameLookup,
+                ignoreUnknownArguments: false,
+                allowDashDash: true,
+                posixlyCorrect: false,
+                optionsParseMode: OptionsParseMode.Default);
         }
 
         public static Result<IEnumerable<Token>, Error> Tokenize(
             IEnumerable<string> arguments,
             Func<string, NameLookupResult> nameLookup,
             bool ignoreUnknownArguments,
             bool allowDashDash,
-            bool posixlyCorrect)
+            bool posixlyCorrect,
+            OptionsParseMode optionsParseMode)
         {
             var errors = new List<Error>();
             Action<string> onBadFormatToken = arg => errors.Add(new BadFormatTokenError(arg));
@@ -70,11 +77,31 @@ public static Result<IEnumerable<Token>, Error> Tokenize(
                         break;
 
                     case string arg when arg.StartsWith("--"):
+
+                        if (optionsParseMode == OptionsParseMode.SingleDashOnly)
+                        {
+                            onBadFormatToken(arg);
+                            continue;
+                        }
+
                         tokens.AddRange(TokenizeLongName(arg, nameLookup, onBadFormatToken, onUnknownOption, onConsumeNext));
                         break;
 
                     case string arg when arg.StartsWith("-"):
-                        tokens.AddRange(TokenizeShortName(arg, nameLookup, onUnknownOption, onConsumeNext));
+                        switch(optionsParseMode)
+                        {
+                            case OptionsParseMode.Default:
+                                tokens.AddRange(TokenizeShortName(arg, nameLookup, onUnknownOption, onConsumeNext));
+                                break;
+
+                            case OptionsParseMode.SingleOrDoubleDash:
+                            case OptionsParseMode.SingleDashOnly:
+                                tokens.AddRange(TokenizeLongName(arg, nameLookup, onBadFormatToken, onUnknownOption, onConsumeNext, dashCount: 1));
+                                break;
+
+                            default:
+                                throw new ArgumentOutOfRangeException(nameof(optionsParseMode), optionsParseMode, null);
+                        }
                         break;
 
                     case string arg:
@@ -126,12 +153,23 @@ public static Func<
                     StringComparer nameComparer,
                     bool ignoreUnknownArguments,
                     bool enableDashDash,
-                    bool posixlyCorrect)
+                    bool posixlyCorrect,
+                    OptionsParseMode optionsParseMode)
         {
             return (arguments, optionSpecs) =>
                 {
-                    var tokens = GetoptTokenizer.Tokenize(arguments, name => NameLookup.Contains(name, optionSpecs, nameComparer), ignoreUnknownArguments, enableDashDash, posixlyCorrect);
-                    var explodedTokens = GetoptTokenizer.ExplodeOptionList(tokens, name => NameLookup.HavingSeparator(name, optionSpecs, nameComparer));
+                    var tokens = GetoptTokenizer.Tokenize(
+                        arguments, 
+                        name => NameLookup.Contains(name, optionSpecs, nameComparer),
+                        ignoreUnknownArguments, 
+                        enableDashDash, 
+                        posixlyCorrect,
+                        optionsParseMode);
+
+                    var explodedTokens = GetoptTokenizer.ExplodeOptionList(
+                        tokens, 
+                        name => NameLookup.HavingSeparator(name, optionSpecs, nameComparer));
+
                     return explodedTokens;
                 };
         }
@@ -190,9 +228,10 @@ private static IEnumerable<Token> TokenizeLongName(
             Func<string, NameLookupResult> nameLookup,
             Action<string> onBadFormatToken,
             Action<string> onUnknownOption,
-            Action<int> onConsumeNext)
+            Action<int> onConsumeNext,
+            int dashCount = 2)
         {
-            string[] parts = arg.Substring(2).Split(new char[] { '=' }, 2);
+            string[] parts = arg.Substring(dashCount).Split(new char[] { '=' }, 2);
             string name = parts[0];
             string value = (parts.Length > 1) ? parts[1] : null;
             // A parameter like "--stringvalue=" is acceptable, and makes stringvalue be the empty string

src/CommandLine/Core/InstanceBuilder.cs

@@ -22,6 +22,7 @@ public static ParserResult<T> Build<T>(
             CultureInfo parsingCulture,
             bool autoHelp,
             bool autoVersion,
+            OptionsParseMode optionsParseMode,
             IEnumerable<ErrorType> nonFatalErrors)
         {
             return Build(
@@ -34,6 +35,7 @@ public static ParserResult<T> Build<T>(
                 autoHelp,
                 autoVersion,
                 false,
+                optionsParseMode,
                 nonFatalErrors);
         }
 
@@ -47,6 +49,7 @@ public static ParserResult<T> Build<T>(
             bool autoHelp,
             bool autoVersion,
             bool allowMultiInstance,
+            OptionsParseMode optionsParseMode,
             IEnumerable<ErrorType> nonFatalErrors)        {
             var typeInfo = factory.MapValueOrDefault(f => f().GetType(), typeof(T));
 
@@ -137,7 +140,7 @@ public static ParserResult<T> Build<T>(
 
             var preprocessorErrors = (
                     argumentsList.Any()
-                    ? arguments.Preprocess(PreprocessorGuards.Lookup(nameComparer, autoHelp, autoVersion))
+                    ? arguments.Preprocess(PreprocessorGuards.Lookup(nameComparer, autoHelp, autoVersion, optionsParseMode))
                     : Enumerable.Empty<Error>()
                 ).Memoize();
 

src/CommandLine/Core/InstanceChooser.cs

@@ -21,6 +21,7 @@ public static ParserResult<object> Choose(
             CultureInfo parsingCulture,
             bool autoHelp,
             bool autoVersion,
+            OptionsParseMode optionsParseMode,
             IEnumerable<ErrorType> nonFatalErrors)
         {
             return Choose(
@@ -33,6 +34,7 @@ public static ParserResult<object> Choose(
                 autoHelp,
                 autoVersion,
                 false,
+                optionsParseMode,
                 nonFatalErrors);
         }
 
@@ -46,6 +48,7 @@ public static ParserResult<object> Choose(
             bool autoHelp,
             bool autoVersion,
             bool allowMultiInstance,
+            OptionsParseMode optionsParseMode,
             IEnumerable<ErrorType> nonFatalErrors)
         {
             var verbs = Verb.SelectFromTypes(types);
@@ -62,22 +65,23 @@ ParserResult<object> choose()
                 var firstArg = arguments.First();
 
                 bool preprocCompare(string command) =>
-                        nameComparer.Equals(command, firstArg) ||
-                        nameComparer.Equals(string.Concat("--", command), firstArg);
+                        nameComparer.Equals(command, firstArg) 
+                        || optionsParseMode != OptionsParseMode.SingleDashOnly && nameComparer.Equals(string.Concat("--", command), firstArg)
+                        || optionsParseMode != OptionsParseMode.Default && nameComparer.Equals(string.Concat("-", command), firstArg);
 
                 return (autoHelp && preprocCompare("help"))
                     ? MakeNotParsed(types,
                         MakeHelpVerbRequestedError(verbs,
                             arguments.Skip(1).FirstOrDefault() ?? string.Empty, nameComparer))
                     : (autoVersion && preprocCompare("version"))
                         ? MakeNotParsed(types, new VersionRequestedError())
-                        : MatchVerb(tokenizer, verbs, defaultVerb, arguments, nameComparer, ignoreValueCase, parsingCulture, autoHelp, autoVersion, allowMultiInstance, nonFatalErrors);
+                        : MatchVerb(tokenizer, verbs, defaultVerb, arguments, nameComparer, ignoreValueCase, parsingCulture, autoHelp, autoVersion, allowMultiInstance, optionsParseMode, nonFatalErrors);
             }
 
             return arguments.Any()
                 ? choose()
                 : (defaultVerbCount == 1
-                    ? MatchDefaultVerb(tokenizer, verbs, defaultVerb, arguments, nameComparer, ignoreValueCase, parsingCulture, autoHelp, autoVersion, nonFatalErrors)
+                    ? MatchDefaultVerb(tokenizer, verbs, defaultVerb, arguments, nameComparer, ignoreValueCase, parsingCulture, autoHelp, autoVersion, optionsParseMode, nonFatalErrors)
                     : MakeNotParsed(types, new NoVerbSelectedError()));
         }
 
@@ -91,6 +95,7 @@ private static ParserResult<object> MatchDefaultVerb(
             CultureInfo parsingCulture,
             bool autoHelp,
             bool autoVersion,
+            OptionsParseMode optionsParseMode,
             IEnumerable<ErrorType> nonFatalErrors)
         {
             return !(defaultVerb is null)
@@ -103,6 +108,7 @@ private static ParserResult<object> MatchDefaultVerb(
                     parsingCulture,
                     autoHelp,
                     autoVersion,
+                    optionsParseMode,
                     nonFatalErrors)
                 : MakeNotParsed(verbs.Select(v => v.Item2), new BadVerbSelectedError(arguments.First()));
         }
@@ -118,6 +124,7 @@ private static ParserResult<object> MatchVerb(
             bool autoHelp,
             bool autoVersion,
             bool allowMultiInstance,
+            OptionsParseMode optionsParseMode,
             IEnumerable<ErrorType> nonFatalErrors)
         {
             string firstArg = arguments.First();
@@ -129,7 +136,7 @@ private static ParserResult<object> MatchVerb(
 
             if (verbUsed == default)
             {
-                return MatchDefaultVerb(tokenizer, verbs, defaultVerb, arguments, nameComparer, ignoreValueCase, parsingCulture, autoHelp, autoVersion, nonFatalErrors);
+                return MatchDefaultVerb(tokenizer, verbs, defaultVerb, arguments, nameComparer, ignoreValueCase, parsingCulture, autoHelp, autoVersion, optionsParseMode, nonFatalErrors);
             }
             return InstanceBuilder.Build(
                 Maybe.Just<Func<object>>(
@@ -141,7 +148,8 @@ private static ParserResult<object> MatchVerb(
                 parsingCulture,
                 autoHelp,
                 autoVersion,
-                allowMultiInstance,                
+                allowMultiInstance,
+                optionsParseMode,
                 nonFatalErrors);
         }
 

src/CommandLine/Core/PreprocessorGuards.cs

@@ -9,30 +9,31 @@ namespace CommandLine.Core
     static class PreprocessorGuards
     {
         public static IEnumerable<Func<IEnumerable<string>, IEnumerable<Error>>>
-            Lookup(StringComparer nameComparer, bool autoHelp, bool autoVersion)
+            Lookup(StringComparer nameComparer, bool autoHelp, bool autoVersion, OptionsParseMode optionsParseMode)
         {
             var list = new List<Func<IEnumerable<string>, IEnumerable<Error>>>();
             if (autoHelp)
-                list.Add(HelpCommand(nameComparer));
+                list.Add(HelpCommand(nameComparer, optionsParseMode));
             if (autoVersion)
-                list.Add(VersionCommand(nameComparer));
+                list.Add(VersionCommand(nameComparer, optionsParseMode));
             return list;
         }
-
-        public static Func<IEnumerable<string>, IEnumerable<Error>> HelpCommand(StringComparer nameComparer)
+        public static Func<IEnumerable<string>, IEnumerable<Error>> HelpCommand(StringComparer nameComparer, OptionsParseMode optionsParseMode)
         {
             return
                 arguments =>
-                    nameComparer.Equals("--help", arguments.First())
+                    optionsParseMode != OptionsParseMode.SingleDashOnly && nameComparer.Equals("--help", arguments.First())
+                    || optionsParseMode != OptionsParseMode.Default && nameComparer.Equals("-help", arguments.First())
                         ? new Error[] { new HelpRequestedError() }
                         : Enumerable.Empty<Error>();
         }
 
-        public static Func<IEnumerable<string>, IEnumerable<Error>> VersionCommand(StringComparer nameComparer)
+        public static Func<IEnumerable<string>, IEnumerable<Error>> VersionCommand(StringComparer nameComparer, OptionsParseMode optionsParseMode)
         {
             return
                 arguments =>
-                    nameComparer.Equals("--version", arguments.First())
+                    optionsParseMode != OptionsParseMode.SingleDashOnly && nameComparer.Equals("--version", arguments.First())
+                    || optionsParseMode != OptionsParseMode.Default && nameComparer.Equals("-version", arguments.First())
                         ? new Error[] { new VersionRequestedError() }
                         : Enumerable.Empty<Error>();
         }

src/CommandLine/Core/Tokenizer.cs

@@ -22,21 +22,41 @@ public static Result<IEnumerable<Token>, Error> Tokenize(
         public static Result<IEnumerable<Token>, Error> Tokenize(
             IEnumerable<string> arguments,
             Func<string, NameLookupResult> nameLookup,
-            Func<IEnumerable<Token>, IEnumerable<Token>> normalize)
+            Func<IEnumerable<Token>, IEnumerable<Token>> normalize,
+            OptionsParseMode optionsParseMode = OptionsParseMode.Default)
         {
+            var tokens = new List<Token>();
             var errors = new List<Error>();
+
             Action<Error> onError = errors.Add;
 
-            var tokens = (from arg in arguments
-                          from token in !arg.StartsWith("-", StringComparison.Ordinal)
-                               ? new[] { Token.Value(arg) }
-                               : arg.StartsWith("--", StringComparison.Ordinal)
-                                     ? TokenizeLongName(arg, onError)
-                                     : TokenizeShortName(arg, nameLookup)
-                          select token)
-                            .Memoize();
+            foreach (var argument in arguments)
+            {
+                if (!argument.StartsWith("-", StringComparison.Ordinal))
+                {
+                    tokens.Add(Token.Value(argument));
+                }
+                else if (argument.StartsWith("--", StringComparison.Ordinal))
+                {
+                    if (optionsParseMode == OptionsParseMode.SingleDashOnly)
+                    {
+                        onError(new BadFormatTokenError(argument));
+                        continue;
+                    }
+
+                    tokens.AddRange(TokenizeLongName(argument, onError));
+                }
+                else if (optionsParseMode == OptionsParseMode.SingleOrDoubleDash || optionsParseMode == OptionsParseMode.SingleDashOnly)
+                {
+                    tokens.AddRange(TokenizeLongName(argument, onError, dashCount: 1));
+                }
+                else
+                {
+                    tokens.AddRange(TokenizeShortName(argument, nameLookup));
+                }
+            }
 
-            var normalized = normalize(tokens).Memoize();
+            var normalized = normalize(tokens.Memoize()).Memoize();
 
             var unkTokens = (from t in normalized where t.IsName() && nameLookup(t.Text) == NameLookupResult.NoOptionFound select t).Memoize();
 
@@ -123,7 +143,8 @@ public static Func<
             ConfigureTokenizer(
                     StringComparer nameComparer,
                     bool ignoreUnknownArguments,
-                    bool enableDashDash)
+                    bool enableDashDash,
+                    OptionsParseMode optionsParseMode = OptionsParseMode.Default)
         {
             return (arguments, optionSpecs) =>
                 {
@@ -136,8 +157,8 @@ public static Func<
                         ? Tokenizer.PreprocessDashDash(
                                 arguments,
                                 args =>
-                                    Tokenizer.Tokenize(args, name => NameLookup.Contains(name, optionSpecs, nameComparer), normalize))
-                        : Tokenizer.Tokenize(arguments, name => NameLookup.Contains(name, optionSpecs, nameComparer), normalize);
+                                    Tokenizer.Tokenize(args, name => NameLookup.Contains(name, optionSpecs, nameComparer), normalize, optionsParseMode))
+                        : Tokenizer.Tokenize(arguments, name => NameLookup.Contains(name, optionSpecs, nameComparer), normalize, optionsParseMode);
                     var explodedTokens = Tokenizer.ExplodeOptionList(tokens, name => NameLookup.HavingSeparator(name, optionSpecs, nameComparer));
                     return explodedTokens;
                 };
@@ -191,11 +212,12 @@ private static IEnumerable<Token> TokenizeShortName(
 
         private static IEnumerable<Token> TokenizeLongName(
             string value,
-            Action<Error> onError)
+            Action<Error> onError,
+            int dashCount = 2)
         {
-            if (value.Length > 2 && value.StartsWith("--", StringComparison.Ordinal))
+            if (value.Length > dashCount && value.StartsWith(new string('-', dashCount), StringComparison.Ordinal))
             {
-                var text = value.Substring(2);
+                var text = value.Substring(dashCount);
                 var equalIndex = text.IndexOf('=');
                 if (equalIndex <= 0)
                 {

src/CommandLine/OptionsParseMode.cs

@@ -0,0 +1,27 @@
+// Copyright 2005-2015 Giacomo Stelluti Scala & Contributors. All rights reserved. See License.md in the project root for license information.
+
+namespace CommandLine
+{
+    /// <summary>
+    /// Defines how commandline options are being parsed.
+    /// </summary>
+    public enum OptionsParseMode
+    {
+        /// <summary>
+        /// Options that start with a double dash must be defined using its full name. E.g. git rebase --interactive
+        /// Options that start with a single dash are interpreted as list of short named options. E.g. git clean -xdf
+        /// </summary>
+        Default,
+
+        /// <summary>
+        /// Options that start with a single or double dash are interpreted as short or full named option.
+        /// </summary>
+        SingleOrDoubleDash,
+
+        /// <summary>
+        /// Options that start with a single dash are interpreted as short or full named option.
+        /// Options that start with a double dash are considered an invalid input.
+        /// </summary>
+        SingleDashOnly
+    }
+}