Support short option bundling

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), bundling: true) 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, bundling: true) 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, bundling: true) 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, bundling: true) 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, bundling: true) 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"], bundling: true) 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, bundling: true) 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

src/option_parser.cr

@@ -112,8 +112,8 @@ class OptionParser
   # and uses it to parse the passed *args* (defaults to `ARGV`).
   #
   # Refer to `#gnu_optional_args?` for the behaviour of the named parameter.
-  def self.parse(args = ARGV, *, gnu_optional_args : Bool = false, &) : self
-    parser = OptionParser.new(gnu_optional_args: gnu_optional_args)
+  def self.parse(args = ARGV, *, gnu_optional_args : Bool = false, bundling : Bool = false, &) : self
+    parser = OptionParser.new(gnu_optional_args: gnu_optional_args, bundling: bundling)
     yield parser
     parser.parse(args)
     parser
@@ -122,7 +122,7 @@ class OptionParser
   # Creates a new parser.
   #
   # Refer to `#gnu_optional_args?` for the behaviour of the named parameter.
-  def initialize(*, @gnu_optional_args : Bool = false)
+  def initialize(*, @gnu_optional_args : Bool = false, @bundling : Bool = false)
     @flags = [] of String
     @handlers = Hash(String, Handler).new
     @stop = false
@@ -133,8 +133,8 @@ class OptionParser
   # Creates a new parser, with its configuration specified in the block.
   #
   # Refer to `#gnu_optional_args?` for the behaviour of the named parameter.
-  def self.new(*, gnu_optional_args : Bool = false, &)
-    new(gnu_optional_args: gnu_optional_args).tap { |parser| yield parser }
+  def self.new(*, gnu_optional_args : Bool = false, bundling : Bool = false, &)
+    new(gnu_optional_args: gnu_optional_args, bundling: bundling).tap { |parser| yield parser }
   end
 
   # Returns whether the GNU convention is followed for optional arguments.
@@ -173,6 +173,27 @@ class OptionParser
   # ```
   property? gnu_optional_args : Bool
 
+  # Returns whether short option bundling is enabled.
+  #
+  # If true, short options can be grouped after a single dash:
+  #
+  # ```
+  # require "option_parser"
+  #
+  # removed = false
+  # forced = false
+  # OptionParser.parse(%w(-rf), bundling: true) do |parser|
+  #   parser.on("-r", "") { removed = true }
+  #   parser.on("-f", "") { forced = true }
+  # end
+  #
+  # {removed, forced} # => {true, true}
+  # ```
+  #
+  # Without `bundling: true`, a token like `-rf` is interpreted as
+  # the flag `-r` with an inline value `f`.
+  property? bundling : Bool
+
   # Establishes the initial message for the help printout.
   # Typically, you want to write here the name of your program,
   # and a one-line template of its invocation.
@@ -401,9 +422,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 bundling? && 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 +468,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]?