Fixes #587 Support negative numbers as command option values

src/Spectre.Console/Cli/Internal/Parsing/CommandTreeTokenizer.cs

@@ -235,13 +235,34 @@ private static IEnumerable<CommandTreeToken> ScanShortOptions(CommandTreeTokeniz
                     ? new CommandTreeToken(CommandTreeToken.Kind.ShortOption, position, value, $"-{value}")
                     : new CommandTreeToken(CommandTreeToken.Kind.ShortOption, position + result.Count, value, value));
             }
+            else if (result.Count == 0 && char.IsDigit(current))
+            {
+                /* We require short options to be named with letters. Short options that start with a number
+                 * ("-1", "-2ab", "-3..7") may actually mean values (either for options or arguments) and will
+                 * be tokenized as strings. This block handles parsing those cases, but we only allow this
+                 * when the digit is the first character in the token (i.e. "-a1" is always an error), hence the
+                 * result.Count == 0 check above.
+                 */
+                string value = string.Empty;
+                while (!reader.ReachedEnd)
+                {
+                    char c = reader.Peek();
+
+                    if (char.IsWhiteSpace(c))
+                    {
+                        break;
+                    }
+
+                    value += c.ToString(CultureInfo.InvariantCulture);
+                    reader.Read();
+                }
+
+                value = "-" + value; // Prefix with the minus sign that we originally thought to mean a short option
+                result.Add(new CommandTreeToken(CommandTreeToken.Kind.String, position, value, value));
+            }
             else
             {
-                // Create a token representing the short option.
-                var tokenPosition = position + 1 + result.Count;
-                var represntation = current.ToString(CultureInfo.InvariantCulture);
-                var token = new CommandTreeToken(CommandTreeToken.Kind.ShortOption, tokenPosition, represntation, represntation);
-                throw CommandParseException.InvalidShortOptionName(reader.Original, token);
+                ThrowInvalidShortOptionName(current.ToString(CultureInfo.InvariantCulture));
             }
         }
 
@@ -254,6 +275,13 @@ private static IEnumerable<CommandTreeToken> ScanShortOptions(CommandTreeTokeniz
         }
 
         return result;
+
+        void ThrowInvalidShortOptionName(string representation)
+        {
+            var tokenPosition = position + 1 + result.Count;
+            var token = new CommandTreeToken(CommandTreeToken.Kind.ShortOption, tokenPosition, representation, representation);
+            throw CommandParseException.InvalidShortOptionName(reader.Original, token);
+        }
     }
 
     private static CommandTreeToken ScanLongOption(CommandTreeTokenizerContext context, TextBuffer reader, int position)

test/Spectre.Console.Tests/Unit/Cli/CommandAppTests.cs

@@ -134,6 +134,39 @@ public void Should_Pass_Case_4()
         });
     }
 
+    [Fact]
+    public void Should_Pass_Case_4_With_Negative_Integer_Argument()
+    {
+        // Given
+        var app = new CommandAppTester();
+        app.Configure(config =>
+        {
+            config.PropagateExceptions();
+            config.AddBranch<AnimalSettings>("animal", animal =>
+            {
+                animal.AddCommand<DogCommand>("dog");
+            });
+        });
+
+        // When
+        var result = app.Run(new[]
+        {
+            "animal", "4", "dog", "-12", "--good-boy",
+            "--name", "Rufus",
+        });
+
+        // Then
+        result.ExitCode.ShouldBe(0);
+        result.Settings.ShouldBeOfType<DogSettings>().And(dog =>
+        {
+            dog.Legs.ShouldBe(4);
+            dog.Age.ShouldBe(-12);
+            dog.GoodBoy.ShouldBe(true);
+            dog.IsAlive.ShouldBe(false);
+            dog.Name.ShouldBe("Rufus");
+        });
+    }
+
     [Fact]
     public void Should_Pass_Case_5()
     {

test/Spectre.Console.Tests/Unit/Cli/CommandTreeTokenizerTests.cs

@@ -0,0 +1,90 @@
+namespace Spectre.Console.Tests.Unit.Cli;
+
+public static class CommandTreeTokenizerTests
+{
+    public sealed class ShortOptions
+    {
+        [Fact]
+        public void Valueless()
+        {
+            var result = CommandTreeTokenizer.Tokenize(new[] { "-a" });
+            Assert.Empty(result.Remaining);
+            var t = Assert.Single(result.Tokens);
+
+            t.TokenKind.ShouldBe(CommandTreeToken.Kind.ShortOption);
+            t.IsGrouped.ShouldBe(false);
+            t.Position.ShouldBe(0);
+            t.Value.ShouldBe("a");
+            t.Representation.ShouldBe("-a");
+        }
+
+        [Theory]
+        [InlineData("-a:foo")]
+        [InlineData("-a=foo")]
+        public void With_Value(string param)
+        {
+            var result = CommandTreeTokenizer.Tokenize(new[] { param });
+            Assert.Empty(result.Remaining);
+            Assert.Equal(2, result.Tokens.Count);
+
+            var t = result.Tokens.Consume();
+            t.TokenKind.ShouldBe(CommandTreeToken.Kind.ShortOption);
+            t.IsGrouped.ShouldBe(false);
+            t.Position.ShouldBe(0);
+            t.Value.ShouldBe("a");
+            t.Representation.ShouldBe("-a");
+
+            t = result.Tokens.Consume();
+            t.TokenKind.ShouldBe(CommandTreeToken.Kind.String);
+            t.IsGrouped.ShouldBe(false);
+            t.Position.ShouldBe(3);
+            t.Value.ShouldBe("foo");
+            t.Representation.ShouldBe("foo");
+        }
+
+        [Theory]
+        [InlineData("-a:-1.5", null)]
+        [InlineData("-a=-1.5", null)]
+        [InlineData("-a", "-1.5")]
+        public void With_Negative_Numeric_Value(string firstArg, string secondArg)
+        {
+            List<string> args = new List<string>();
+            args.Add(firstArg);
+            if (secondArg != null)
+            {
+                args.Add(secondArg);
+            }
+
+            var result = CommandTreeTokenizer.Tokenize(args);
+            Assert.Empty(result.Remaining);
+            Assert.Equal(2, result.Tokens.Count);
+
+            var t = result.Tokens.Consume();
+            t.TokenKind.ShouldBe(CommandTreeToken.Kind.ShortOption);
+            t.IsGrouped.ShouldBe(false);
+            t.Position.ShouldBe(0);
+            t.Value.ShouldBe("a");
+            t.Representation.ShouldBe("-a");
+
+            t = result.Tokens.Consume();
+            t.TokenKind.ShouldBe(CommandTreeToken.Kind.String);
+            t.IsGrouped.ShouldBe(false);
+            t.Position.ShouldBe(3);
+            t.Value.ShouldBe("-1.5");
+            t.Representation.ShouldBe("-1.5");
+        }
+
+        [Fact]
+        public void With_Negative_Numeric_Prefixed_String_Value()
+        {
+            var result = CommandTreeTokenizer.Tokenize(new[] { "-6..2 " });
+            Assert.Empty(result.Remaining);
+            var t = Assert.Single(result.Tokens);
+            t.TokenKind.ShouldBe(CommandTreeToken.Kind.String);
+            t.IsGrouped.ShouldBe(false);
+            t.Position.ShouldBe(0);
+            t.Value.ShouldBe("-6..2");
+            t.Representation.ShouldBe("-6..2");
+        }
+    }
+}