Support short option bundling in OPtionParser (#16563)

This enables short option bundling such as with `-rf` which
will with this option trigger separate `-r` and `-f` handlers.

```
require "option_parser"

removed = false
forced = false
OptionParser.parse(%w(-rf)) do |parser|
  parser.on("-r", "") { removed = true }
  parser.on("-f", "") { forced = true }
end

{removed, forced} # => {true, true}
```

Author: Qard

spec/std/option_parser_spec.cr

@@ -248,6 +248,79 @@ describe "OptionParser" do
     expect_doesnt_capture_option [] of String, "-f FLAG"
   end
 
+  describe "bundling" do
+    it "parses bundled boolean short options" do
+      args = %w(-rf)
+      called = [] of String
+      OptionParser.parse(args) do |opts|
+        opts.on("-r", "") { called << "-r" }
+        opts.on("-f", "") { called << "-f" }
+      end
+      called.should eq(%w(-r -f))
+      args.size.should eq(0)
+    end
+
+    it "re-triggers handlers for repeated short flags" do
+      args = %w(-vvv)
+      verbosity = 0
+      OptionParser.parse(args) do |opts|
+        opts.on("-v", "") { verbosity += 1 }
+      end
+      verbosity.should eq(3)
+      args.size.should eq(0)
+    end
+
+    it "uses rest of token as required value and stops bundling" do
+      args = %w(-ovalue -r)
+      value = nil
+      r = false
+      OptionParser.parse(args) do |opts|
+        opts.on("-o VALUE", "") { |v| value = v }
+        opts.on("-r", "") { r = true }
+      end
+      value.should eq("value")
+      r.should be_true
+      args.size.should eq(0)
+    end
+
+    it "assigns remainder as value for later required option" do
+      args = %w(-ab123)
+      a = false
+      b = nil
+      OptionParser.parse(args) do |opts|
+        opts.on("-a", "") { a = true }
+        opts.on("-b VALUE", "") { |v| b = v }
+      end
+      a.should be_true
+      b.should eq("123")
+      args.size.should eq(0)
+    end
+
+    it "raises on invalid option inside bundle" do
+      expect_raises OptionParser::InvalidOption, "Invalid option: -j" do
+        OptionParser.parse(["-rj"]) do |opts|
+          opts.on("-r", "") { }
+        end
+      end
+    end
+
+    it "consumes rest of bundle as argument value when middle option requires argument" do
+      args = %w(-aeb)
+      a = false
+      b = false
+      e = nil
+      OptionParser.parse(args) do |opts|
+        opts.on("-a", "") { a = true }
+        opts.on("-b", "") { b = true }
+        opts.on("-e VALUE", "") { |v| e = v }
+      end
+      a.should be_true
+      b.should be_false
+      e.should eq("b")
+      args.size.should eq(0)
+    end
+  end
+
   describe "gnu_optional_args" do
     it "doesn't get optional argument for short flag after space" do
       flag = nil
@@ -381,7 +454,7 @@ describe "OptionParser" do
   end
 
   it "raises on invalid option if value is given to none value handler (short flag, #9553) " do
-    expect_raises OptionParser::InvalidOption, "Invalid option: -foo" do
+    expect_raises OptionParser::InvalidOption, "Invalid option: -o" do
       OptionParser.parse(["-foo"]) do |opts|
         opts.on("-f", "some flag") { }
       end

src/option_parser.cr

@@ -401,9 +401,12 @@ class OptionParser
           break
         end
 
-        flag, value = parse_arg_to_flag_and_value(arg)
-
-        arg_index = handle_flag(flag, value, arg_index, args, handled_args)
+        if bundled_short_arg?(arg)
+          arg_index = handle_bundled_short_options(arg, arg_index, args, handled_args)
+        else
+          flag, value = parse_arg_to_flag_and_value(arg)
+          arg_index = handle_flag(flag, value, arg_index, args, handled_args)
+        end
 
         arg_index += 1
       end
@@ -444,19 +447,66 @@ class OptionParser
     end
   end
 
+  private def bundled_short_arg?(arg : String) : Bool
+    arg.starts_with?('-') && !arg.starts_with?("--") && arg.size > 2
+  end
+
   # Parses a command-line argument into a flag and optional inline value.
   private def parse_arg_to_flag_and_value(arg : String) : {String, String?}
     if arg.starts_with?("--")
       name, separator, value = arg.partition("=")
       if separator == "="
         return {name, value}
       end
-    elsif arg.starts_with?('-') && arg.size > 2
+    elsif bundled_short_arg?(arg)
       return {arg[0..1], arg[2..]}
     end
     {arg, nil}
   end
 
+  private def handle_bundled_short_options(arg : String, arg_index : Int32, args : Array(String), handled_args : Array(Int32)) : Int32
+    rest = arg[1..]
+    rest.each_char_with_index do |char, index|
+      flag = "-#{char}"
+
+      suffix = index + 1 < rest.bytesize ? rest[(index + 1)..] : nil
+
+      if handler = @handlers[flag]?
+        case handler.value_type
+        in FlagValue::None
+          next_index = handle_flag(flag, nil, arg_index, args, handled_args)
+          return next_index unless next_index == arg_index
+        in FlagValue::Required
+          value = suffix
+          if value && !value.empty?
+            handled_args << arg_index
+            handler.block.call(value)
+          else
+            next_index = handle_flag(flag, nil, arg_index, args, handled_args)
+            return next_index unless next_index == arg_index
+          end
+          return arg_index
+        in FlagValue::Optional
+          value = suffix
+          if value && !value.empty? && gnu_optional_args?
+            handled_args << arg_index
+            handler.block.call(value)
+            return arg_index
+          else
+            next_index = handle_flag(flag, nil, arg_index, args, handled_args)
+            return next_index unless next_index == arg_index
+          end
+        end
+      else
+        @invalid_option.call(flag)
+        return arg_index
+      end
+    end
+
+    handled_args << arg_index
+    arg_index
+  end
+
   # Processes a single flag/subcommand. Matches original behaviour exactly.
   private def handle_flag(flag : String, value : String?, arg_index : Int32, args : Array(String), handled_args : Array(Int32)) : Int32
     return arg_index unless handler = @handlers[flag]?