[WIP] subcommand parser

Author: nobu

lib/optparse.rb

@@ -1149,6 +1149,7 @@ def initialize(banner = nil, width = 32, indent = ' ' * 4)
     @default_argv = ARGV
     @require_exact = false
     @raise_unknown = true
+    @subparsers = nil
     add_officious
     yield self if block_given?
   end
@@ -1171,6 +1172,12 @@ def self.terminate(arg = nil)
     throw :terminate, arg
   end
 
+  def subparser(name, *rest, &block)
+    parser = self.class.new(*rest)
+    (@subparsers ||= CompletingHash.new)[name] = [parser, block]
+    parser
+  end
+
   @stack = [DefaultList]
   def self.top() DefaultList end
 
@@ -1626,12 +1633,18 @@ def order(*argv, into: nil, &nonopt)
   # Non-option arguments remain in +argv+.
   #
   def order!(argv = default_argv, into: nil, &nonopt)
-    setter = ->(name, val) {into[name.to_sym] = val} if into
+    setter = into.extend(SymSetter).method(:sym_set) if into
     parse_in_order(argv, setter, &nonopt)
   end
 
+  module SymSetter
+    def sym_set(name, val)
+      self[name.to_sym] = val
+    end
+  end
+
   def parse_in_order(argv = default_argv, setter = nil, &nonopt)  # :nodoc:
-    opt, arg, val, rest = nil
+    opt, arg, val, rest, sub = nil
     nonopt ||= proc {|a| throw :terminate, a}
     argv.unshift(arg) if arg = catch(:terminate) {
       while arg = argv.shift
@@ -1699,6 +1712,17 @@ def parse_in_order(argv = default_argv, setter = nil, &nonopt)  # :nodoc:
 
         # non-option argument
         else
+          # sub-command
+          if (key, (sub, block) = @subparsers&.complete(arg))
+            block.call if block
+            if setter
+              into = setter.receiver.class.new.extend(SymSetter)
+              setter.call(key, into)
+              setter = into.method(:sym_set)
+            end
+            return sub.parse_in_order(argv, setter, &nonopt)
+          end
+
           catch(:prune) do
             visit(:each_option) do |sw0|
               sw = sw0
@@ -1716,7 +1740,7 @@ def parse_in_order(argv = default_argv, setter = nil, &nonopt)  # :nodoc:
 
     argv
   end
-  private :parse_in_order
+  protected :parse_in_order
 
   #
   # Parses command line arguments +argv+ in permutation mode and returns
@@ -1735,6 +1759,9 @@ def permute(*argv, into: nil)
   # Non-option arguments remain in +argv+.
   #
   def permute!(argv = default_argv, into: nil)
+    if @subparsers
+      raise "cannot parse in permutation mode with subparsers"
+    end
     nonopts = []
     order!(argv, into: into, &nonopts.method(:<<))
     argv[0, 0] = nonopts
@@ -1758,7 +1785,7 @@ def parse(*argv, into: nil)
   # Non-option arguments remain in +argv+.
   #
   def parse!(argv = default_argv, into: nil)
-    if ENV.include?('POSIXLY_CORRECT')
+    if @subparsers or ENV.include?('POSIXLY_CORRECT')
       order!(argv, into: into)
     else
       permute!(argv, into: into)

sample/optparse/subcommand.rb

@@ -0,0 +1,23 @@
+#! /usr/bin/ruby
+# contributed by Minero Aoki.
+
+require 'optparse'
+
+opts = {}
+parser = OptionParser.new
+parser.on('-i') { opts["i"] = true }
+parser.on('-o') { puts["o"] = true }
+
+parser.subparser('add') {opts[:add] = {}}
+  .on('-i') { opts[:add]["i"] = true }
+parser.subparser('del') {opts[:del] = {}}.then do |sub|
+  sub.on('-i') { opts[:del]["i"] = true }
+end
+parser.subparser('list') {opts[:list] = {}}.then do |sub|
+  sub.on('-iN', Integer) {|i| opts[:list]["i"] = i }
+end
+
+h = {}
+p parser.parse!(ARGV, into: h)
+p h
+p opts