Replace string tests with patterns

Author: atifaziz

src/DocoptNet/Docopt.cs

@@ -232,28 +232,33 @@ internal static IList<LeafPattern> ParseArgv(Tokens tokens, ICollection<Option>
             var parsed = new List<LeafPattern>();
             while (tokens.Current() is { } token)
             {
-                if (token == "--")
+                switch (token)
                 {
-                    parsed.AddRange(tokens.Select(Argument.Unnamed));
-                    return parsed;
-                }
-
-                if (token.StartsWith("--"))
-                {
-                    parsed.AddRange(ParseLong(tokens, options));
-                }
-                else if (token.StartsWith("-") && tokens.Current() != "-")
-                {
-                    parsed.AddRange(ParseShorts(tokens, options));
-                }
-                else if (optionsFirst)
-                {
-                    parsed.AddRange(tokens.Select(Argument.Unnamed));
-                    return parsed;
-                }
-                else
-                {
-                    parsed.Add(Argument.Unnamed(tokens.Move()));
+                    case "--":
+                    {
+                        parsed.AddRange(tokens.Select(Argument.Unnamed));
+                        return parsed;
+                    }
+                    case ['-', '-', ..]:
+                    {
+                        parsed.AddRange(ParseLong(tokens, options));
+                        break;
+                    }
+                    case ['-', not '-', ..]:
+                    {
+                        parsed.AddRange(ParseShorts(tokens, options));
+                        break;
+                    }
+                    case var _ when optionsFirst:
+                    {
+                        parsed.AddRange(tokens.Select(Argument.Unnamed));
+                        return parsed;
+                    }
+                    case var _:
+                    {
+                        parsed.Add(Argument.Unnamed(tokens.Move()));
+                        break;
+                    }
                 }
             }
             return parsed;
@@ -369,21 +374,19 @@ static IEnumerable<Pattern> ParseAtom(Tokens tokens, ICollection<Option> options
                     result.Add(new OptionsShortcut());
                     break;
                 default:
-                    if (token.StartsWith("--") && token != "--")
-                    {
-                        return ParseLong(tokens, options);
-                    }
-                    if (token.StartsWith("-") && token != "-" && token != "--")
-                    {
-                        return ParseShorts(tokens, options);
-                    }
-                    if ((token.StartsWith("<") && token.EndsWith(">")) || token.All(char.IsUpper))
-                    {
-                        result.Add(new Argument(tokens.Move()));
-                    }
-                    else
+                    switch (token)
                     {
-                        result.Add(new Command(tokens.Move()));
+                        case ['-', '-', _, ..]:
+                            return ParseLong(tokens, options);
+                        case ['-', not '-', ..]:
+                            return ParseShorts(tokens, options);
+                        case ['<', _, .., '>']:
+                        case var t when t.All(char.IsUpper):
+                            result.Add(new Argument(tokens.Move()));
+                            break;
+                        default:
+                            result.Add(new Command(tokens.Move()));
+                            break;
                     }
                     break;
             }
@@ -395,7 +398,7 @@ static IEnumerable<Option> ParseShorts(Tokens tokens, ICollection<Option> option
             // shorts ::= '-' ( chars )* [ [ ' ' ] chars ] ;
 
             var token = tokens.Move() ?? throw new NullReferenceException();
-            Debug.Assert(token.StartsWith("-") && !token.StartsWith("--"));
+            Debug.Assert(token is ['-', not '-', ..]);
             var left = token.TrimStart(['-']);
             var parsed = new List<Option>();
             while (left != "")
@@ -458,7 +461,7 @@ static IEnumerable<Option> ParseLong(Tokens tokens, ICollection<Option> options)
                 (var ln, "", _) => (ln, false, null),
                 var (ln, _, vs) => (ln, true, vs)
             };
-            Debug.Assert(longName.StartsWith("--"));
+            Debug.Assert(longName is ['-', '-', ..]);
             var similar = options.Where(o => o.LongName == longName).ToList();
             if (tokens.ThrowsInputError && similar.Count == 0)
             {

src/DocoptNet/Internals/Option.cs

@@ -63,15 +63,11 @@ public static Option Parse(string optionDescription)
             var (options, _, description) = optionDescription.Trim().Partition(DescSeparator);
             foreach (var s in options.Split(OptionDelimiters, StringSplitOptions.RemoveEmptyEntries))
             {
-                if (s.StartsWith("--"))
-                    longName = s;
-                else if (s.StartsWith("-"))
+                switch (s)
                 {
-                    shortName = s;
-                }
-                else
-                {
-                    argCount = 1;
+                    case ['-', '-', ..]: longName = s ; break;
+                    case ['-', ..]     : shortName = s; break;
+                    default            : argCount = 1 ; break;
                 }
             }
             if (argCount > 0)

tests/DocoptNet.Tests/CodeGeneration/LanguageAgnosticTests.cs

@@ -100,7 +100,7 @@ e is AssertionException
                 actual = "\"user-error\"";
             }
 
-            if (expected.StartsWith("{"))
+            if (expected is ['{', ..])
             {
                 var expectedDict = JsonConvert.DeserializeObject<Dictionary<string, object>>(expected);
                 Debug.Assert(expectedDict is not null);

tests/DocoptNet.Tests/LanguageAgnosticTests.cs

@@ -34,7 +34,7 @@ public void Test(string doc, string cmdLine, string expected)
                 actual = "\"user-error\"";
             }
 
-            if (expected.StartsWith("{"))
+            if (expected is ['{', ..])
             {
                 var expectedDict = JsonConvert.DeserializeObject<Dictionary<string, object>>(expected);
                 var actualDict = JsonConvert.DeserializeObject<Dictionary<string, object>>(actual);