trollop 1.8.2 → 1.9

data/History.txt

@@ -1,3 +1,12 @@
+== 1.9 / 2008-08-20
+* Added 'stop_on_unknown' command to stop parsing on any unknown argument.
+  This is useful for handling sub-commands when you don't know the entire
+  set of commands up front. (E.g. if the initial arguments can change it.)
+* Added a :multi option for parameters, signifying that they can be specified
+  multiple times.
+* Added :ints, :strings, :doubles, and :floats option types, which can take
+  multiple arguments.
+
 == 1.8.2 / 2008-06-25
 * Bugfix for #conflicts and #depends error messages
 

data/Rakefile

@@ -13,8 +13,7 @@ end # thanks to "Mike H"
 Hoe.new('trollop', Trollop::VERSION) do |p|
   p.rubyforge_name = 'trollop'
   p.author = "William Morgan"
-  p.summary = "Trollop is YAFCLAP --- yet another fine commandline argument processing library for Ruby. Trollop is designed to provide the maximal amount of GNU-style argument processing in the minimum number of lines of code (for you, the programmer)."
-
+  p.summary = "Trollop is a commandline option parser for Ruby that just gets out of your way. One line of code per option is all you need to write. For that, you get a nice automatically-generated help page, robust option parsing, command subcompletion, and sensible defaults for everything you don't specify."
   p.description = p.paragraphs_of('README.txt', 4..5, 9..18).join("\n\n").gsub(/== SYNOPSIS/, "Synopsis")
   p.url = "http://trollop.rubyforge.org"
   p.changes = p.paragraphs_of('History.txt', 0..0).join("\n\n")

data/lib/trollop.rb

@@ -5,7 +5,7 @@
 
 module Trollop
 
-VERSION = "1.8.2"
+VERSION = "1.9"
 
 ## Thrown by Parser in the event of a commandline error. Not needed if
 ## you're using the Trollop::options entry.
@@ -30,11 +30,25 @@ PARAM_RE = /^-(-|\.$|[^\d\.])/
 ## methods #opt, #banner and #version, #depends, and #conflicts will
 ## typically be called.
 class Parser
+
+  ## The set of values that indicate a flag type of option when one of
+  ## the values is given to the :type parameter to #opt.
+  FLAG_TYPES = [:flag, :bool, :boolean]
+
+  ## The set of values that indicate an option that takes a single
+  ## parameter when one of the values is given to the :type parameter to
+  ## #opt.
+  SINGLE_ARG_TYPES = [:int, :integer, :string, :double, :float]
+
+  ## The set of values that indicate an option that takes multiple
+  ## parameters when one of the values is given to the :type parameter to
+  ## #opt.
+  MULTI_ARG_TYPES = [:ints, :integers, :strings, :doubles, :floats]
+
   ## The set of values specifiable as the :type parameter to #opt.
-  TYPES = [:flag, :boolean, :bool, :int, :integer, :string, :double, :float]
+  TYPES = FLAG_TYPES + SINGLE_ARG_TYPES + MULTI_ARG_TYPES
 
-  ## :nodoc:
-  INVALID_SHORT_ARG_REGEX = /[\d-]/
+  INVALID_SHORT_ARG_REGEX = /[\d-]/ #:nodoc:
 
   ## The values from the commandline that were not interpreted by #parse.
   attr_reader :leftovers
@@ -53,6 +67,7 @@ class Parser
     @order = []
     @constraints = []
     @stop_words = []
+    @stop_on_unknown = false
 
     #instance_eval(&b) if b # can't take arguments
     cloaker(&b).bind(self).call(*a) if b
@@ -69,11 +84,14 @@ class Parser
   ## * :short: Specify the short form of the argument, i.e. the form
   ##   with one dash. If unspecified, will be automatically derived
   ##   based on the argument name.
-  ## * :type: Require that the argument take a parameter of type
-  ##   'type'. Can by any member of the TYPES constant or a
-  ##   corresponding class (e.g. Integer for :int). If unset, the
-  ##   default argument type is :flag, meaning the argument does not
-  ##   take a parameter. Not necessary if :default: is specified.
+  ## * :type: Require that the argument take a parameter or parameters
+  ##   of type 'type'. For a single parameter, the value can be a
+  ##   member of the SINGLE_ARG_TYPES constant or a corresponding class
+  ##   (e.g. Integer for :int). For multiple parameters, the value can
+  ##   be a member of the MULTI_ARG_TYPES constant. If unset, the
+  ##   default argument type is :flag, meaning that the argument does
+  ##   not take a parameter. The specification of :type is not
+  ##   necessary if :default is given.
   ## * :default: Set the default value for an argument. Without a
   ##   default value, the hash returned by #parse (and thus
   ##   Trollop#options) will not contain the argument unless it is
@@ -81,8 +99,11 @@ class Parser
   ##   automatically from the class of the default value given, if
   ##   any. Specifying a :flag argument on the commandline whose
   ##   default value is true will change its value to false.
-  ## * :required: if set to true, the argument must be provided on the
+  ## * :required: If set to true, the argument must be provided on the
   ##   commandline.
+  ## * :multi: If set to true, allows multiple instances of the
+  ##   option. Otherwise, only a single instance of the option is
+  ##   allowed.
   def opt name, desc="", opts={}
     raise ArgumentError, "you already have an argument named '#{name}'" if @specs.member? name
 
@@ -91,8 +112,11 @@ class Parser
       case opts[:type]
       when :flag, :boolean, :bool; :flag
       when :int, :integer; :int
+      when :ints, :integers; :ints
       when :string; :string
+      when :strings; :strings
       when :double, :float; :float
+      when :doubles, :floats; :floats
       when Class
         case opts[:type].to_s # sigh... there must be a better way to do this
         when 'TrueClass', 'FalseClass'; :flag
@@ -113,6 +137,17 @@ class Parser
       when Numeric; :float
       when TrueClass, FalseClass; :flag
       when String; :string
+      when Array
+        if opts[:default].empty?
+          raise ArgumentError, "multiple argument type cannot be deduced from an empty array for '#{opts[:default][0].class.name}'"
+        end
+        case opts[:default][0]    # the first element determines the types
+        when Integer; :ints
+        when Numeric; :floats
+        when String; :strings
+        else
+          raise ArgumentError, "unsupported multiple argument type '#{opts[:default][0].class.name}'"
+        end
       when nil; nil
       else
         raise ArgumentError, "unsupported argument type '#{opts[:default].class.name}'"
@@ -160,6 +195,9 @@ class Parser
     ## fill in :default for flags
     opts[:default] = false if opts[:type] == :flag && opts[:default].nil?
 
+    ## fill in :multi
+    opts[:multi] ||= false
+
     opts[:desc] ||= desc
     @long[opts[:long]] = name
     @short[opts[:short]] = name if opts[:short]
@@ -201,6 +239,12 @@ class Parser
     @stop_words = [*words].flatten
   end
 
+  ## Similar to stop_on, but stops on any unknown word when encountered (unless
+  ## it is a parameter for an argument).
+  def stop_on_unknown
+    @stop_on_unknown = true
+  end
+
   ## yield successive arg, parameter pairs
   def each_arg args # :nodoc:
     remains = []
@@ -209,19 +253,28 @@ class Parser
     until i >= args.length
       if @stop_words.member? args[i]
         remains += args[i .. -1]
-        break
+        return remains
       end
       case args[i]
       when /^--$/ # arg terminator
         remains += args[(i + 1) .. -1]
-        break
+        return remains
       when /^--(\S+?)=(\S+)$/ # long argument with equals
-        yield "--#{$1}", $2
+        yield "--#{$1}", [$2]
         i += 1
       when /^--(\S+)$/ # long argument
-        if args[i + 1] && args[i + 1] !~ PARAM_RE && !@stop_words.member?(args[i + 1])
-          remains << args[i + 1] unless yield args[i], args[i + 1]
-          i += 2
+        params = collect_argument_parameters(args, i + 1)
+        unless params.empty?
+          num_params_taken = yield args[i], params
+          unless num_params_taken
+            if @stop_on_unknown
+              remains += args[i + 1 .. -1]
+              return remains
+            else
+              remains += params
+            end
+          end
+          i += 1 + num_params_taken
         else # long argument no parameter
           yield args[i], nil
           i += 1
@@ -229,26 +282,44 @@ class Parser
       when /^-(\S+)$/ # one or more short arguments
         shortargs = $1.split(//)
         shortargs.each_with_index do |a, j|
-          if j == (shortargs.length - 1) && args[i + 1] && args[i + 1] !~ PARAM_RE && !@stop_words.member?(args[i + 1])
-            remains << args[i + 1] unless yield "-#{a}", args[i + 1]
-            i += 1 # once more below
+          if j == (shortargs.length - 1)
+            params = collect_argument_parameters(args, i + 1)
+            unless params.empty?
+              num_params_taken = yield "-#{a}", params
+              unless num_params_taken
+                if @stop_on_unknown
+                  remains += args[i + 1 .. -1]
+                  return remains
+                else
+                  remains += params
+                end
+              end
+              i += 1 + num_params_taken
+            else # argument no parameter
+              yield "-#{a}", nil
+              i += 1
+            end
           else
             yield "-#{a}", nil
           end
         end
-        i += 1
       else
-        remains << args[i]
-        i += 1
+        if @stop_on_unknown
+          remains += args[i .. -1]
+          return remains
+        else
+          remains << args[i]
+          i += 1
+        end
       end
     end
+
     remains
   end
 
   def parse cmdline #:nodoc:
     vals = {}
     required = {}
-    found = {}
 
     opt :version, "Print version and exit" if @version unless @specs[:version] || @long["version"]
     opt :help, "Show this message" unless @specs[:help] || @long["help"]
@@ -259,8 +330,8 @@ class Parser
     end
 
     ## resolve symbols
-    args = []
-    @leftovers = each_arg cmdline do |arg, param|
+    given_args = {}
+    @leftovers = each_arg cmdline do |arg, params|
       sym = 
         case arg
         when /^-([^-])$/
@@ -271,57 +342,107 @@ class Parser
           raise CommandlineError, "invalid argument syntax: '#{arg}'"
         end
       raise CommandlineError, "unknown argument '#{arg}'" unless sym
-      raise CommandlineError, "option '#{arg}' specified multiple times" if found[sym]
-      args << [sym, arg, param]
-      found[sym] = true
 
-      @specs[sym][:type] != :flag # take params on all except flags
+      if given_args.include?(sym) && !@specs[sym][:multi]
+        raise CommandlineError, "option '#{arg}' specified multiple times"
+      end
+
+      given_args[sym] ||= {}
+
+      given_args[sym][:arg] = arg
+      given_args[sym][:params] ||= []
+
+      # The block returns the number of parameters taken.
+      num_params_taken = 0
+
+      unless params.nil?
+        if SINGLE_ARG_TYPES.include?(@specs[sym][:type])
+          given_args[sym][:params] << params[0, 1]  # take the first parameter
+          num_params_taken = 1
+        elsif MULTI_ARG_TYPES.include?(@specs[sym][:type])
+          given_args[sym][:params] << params        # take all the parameters
+          num_params_taken = params.size
+        end
+      end
+
+      num_params_taken
     end
 
     ## check for version and help args
-    raise VersionNeeded if args.any? { |sym, *a| sym == :version }
-    raise HelpNeeded if args.any? { |sym, *a| sym == :help }
+    raise VersionNeeded if given_args.include? :version
+    raise HelpNeeded if given_args.include? :help
 
     ## check constraint satisfaction
     @constraints.each do |type, syms|
-      constraint_sym = syms.find { |sym| found[sym] }
+      constraint_sym = syms.find { |sym| given_args[sym] }
       next unless constraint_sym
 
       case type
       when :depends
-        syms.each { |sym| raise CommandlineError, "--#{@specs[constraint_sym][:long]} requires --#{@specs[sym][:long]}" unless found[sym] }
+        syms.each { |sym| raise CommandlineError, "--#{@specs[constraint_sym][:long]} requires --#{@specs[sym][:long]}" unless given_args.include? sym }
       when :conflicts
-        syms.each { |sym| raise CommandlineError, "--#{@specs[constraint_sym][:long]} conflicts with --#{@specs[sym][:long]}" if found[sym] && sym != constraint_sym }
+        syms.each { |sym| raise CommandlineError, "--#{@specs[constraint_sym][:long]} conflicts with --#{@specs[sym][:long]}" if given_args.include?(sym) && (sym != constraint_sym) }
       end
     end
 
     required.each do |sym, val|
-      raise CommandlineError, "option '#{sym}' must be specified" unless found[sym]
+      raise CommandlineError, "option '#{sym}' must be specified" unless given_args.include? sym
     end
 
     ## parse parameters
-    args.each do |sym, arg, param|
-      opts = @specs[sym]
+    given_args.each do |sym, given_data|
+      arg = given_data[:arg]
+      params = given_data[:params]
 
-      raise CommandlineError, "option '#{arg}' needs a parameter" unless param || opts[:type] == :flag
+      opts = @specs[sym]
+      raise CommandlineError, "option '#{arg}' needs a parameter" if params.empty? && opts[:type] != :flag
 
       case opts[:type]
       when :flag
         vals[sym] = !opts[:default]
-      when :int
-        raise CommandlineError, "option '#{arg}' needs an integer" unless param =~ /^\d+$/
-        vals[sym] = param.to_i
-      when :float
-        raise CommandlineError, "option '#{arg}' needs a floating-point number" unless param =~ FLOAT_RE
-        vals[sym] = param.to_f
-      when :string
-        vals[sym] = param.to_s
+      when :int, :ints
+        vals[sym] = params.map { |pg| pg.map { |p| parse_integer_parameter p, arg } }
+      when :float, :floats
+        vals[sym] = params.map { |pg| pg.map { |p| parse_float_parameter p, arg } }
+      when :string, :strings
+        vals[sym] = params.map { |pg| pg.map { |p| p.to_s } }
+      end
+
+      if SINGLE_ARG_TYPES.include?(opts[:type])
+        unless opts[:multi]       # single parameter
+          vals[sym] = vals[sym][0][0]
+        else                      # multiple options, each with a single parameter
+          vals[sym] = vals[sym].map { |p| p[0] }
+        end
+      elsif MULTI_ARG_TYPES.include?(opts[:type]) && !opts[:multi]
+        vals[sym] = vals[sym][0]  # single option, with multiple parameters
       end
+      # else: multiple options, with multiple parameters
     end
 
     vals
   end
 
+  def parse_integer_parameter param, arg #:nodoc:
+    raise CommandlineError, "option '#{arg}' needs an integer" unless param =~ /^\d+$/
+    param.to_i
+  end
+
+  def parse_float_parameter param, arg #:nodoc:
+    raise CommandlineError, "option '#{arg}' needs a floating-point number" unless param =~ FLOAT_RE
+    param.to_f
+  end
+
+  def collect_argument_parameters args, start_at #:nodoc:
+    params = []
+    pos = start_at
+    while args[pos] && args[pos] !~ PARAM_RE && !@stop_words.member?(args[pos]) do
+      params << args[pos]
+      pos += 1
+    end
+    params
+  end
+
   def width #:nodoc:
     @width ||= 
       if $stdout.tty?
@@ -351,8 +472,11 @@ class Parser
         case spec[:type]
         when :flag; ""
         when :int; " <i>"
+        when :ints; " <i+>"
         when :string; " <s>"
+        when :strings; " <s+>"
         when :float; " <f>"
+        when :floats; " <f+>"
         end
     end
 
@@ -427,9 +551,9 @@ class Parser
 end
 
 ## The top-level entry method into Trollop. Creates a Parser object,
-## passes the block to it, then parses ARGV with it, handling any
+## passes the block to it, then parses +args+ with it, handling any
 ## errors or requests for help or version information appropriately
-## (and then exiting). Modifies ARGV in place. Returns a hash of
+## (and then exiting). Modifies +args+ in place. Returns a hash of
 ## option values.
 ##
 ## The block passed in should contain one or more calls to #opt
@@ -437,12 +561,12 @@ end
 ## probably a call to version (Parser#version).
 ##
 ## See the synopsis in README.txt for examples.
-def options *a, &b
+def options args = ARGV, *a, &b
   @p = Parser.new(*a, &b)
   begin
-    vals = @p.parse ARGV
-    ARGV.clear
-    @p.leftovers.each { |l| ARGV << l }
+    vals = @p.parse args
+    args.clear
+    @p.leftovers.each { |l| args << l }
     vals
   rescue CommandlineError => e
     $stderr.puts "Error: #{e.message}."

data/test/test_trollop.rb

@@ -76,20 +76,80 @@ class Trollop < ::Test::Unit::TestCase
 
   ## type is correctly derived from :default
   def test_type_correctly_derived_from_default
-    assert_nothing_raised { @p.opt "goodarg", "desc", :default => 0 }
     assert_raise(ArgumentError) { @p.opt "badarg", "desc", :default => [] }
 
-    assert_nothing_raised { @p.parse(%w(--goodarg 3)) }
-    assert_raise(CommandlineError) { @p.parse(%w(--goodarg 4.2)) }
-    assert_raise(CommandlineError) { @p.parse(%w(--goodarg hello)) }
+    opts = nil
+
+    # single arg: int
+    assert_nothing_raised { @p.opt "argsi", "desc", :default => 0 }
+    assert_nothing_raised { opts = @p.parse("--") }
+    assert_equal 0, opts["argsi"]
+    assert_nothing_raised { opts = @p.parse(%w(--argsi 4)) }
+    assert_equal 4, opts["argsi"]
+    assert_raise(CommandlineError) { @p.parse(%w(--argsi 4.2)) }
+    assert_raise(CommandlineError) { @p.parse(%w(--argsi hello)) }
+
+    # single arg: float
+    assert_nothing_raised { @p.opt "argsf", "desc", :default => 3.14 }
+    assert_nothing_raised { opts = @p.parse("--") }
+    assert_equal 3.14, opts["argsf"]
+    assert_nothing_raised { opts = @p.parse(%w(--argsf 2.41)) }
+    assert_equal 2.41, opts["argsf"]
+    assert_nothing_raised { opts = @p.parse(%w(--argsf 2)) }
+    assert_equal 2, opts["argsf"]
+    assert_raise(CommandlineError) { @p.parse(%w(--argsf hello)) }
+
+    # single arg: string
+    assert_nothing_raised { @p.opt "argss", "desc", :default => "foobar" }
+    assert_nothing_raised { opts = @p.parse("--") }
+    assert_equal "foobar", opts["argss"]
+    assert_nothing_raised { opts = @p.parse(%w(--argss 2.41)) }
+    assert_equal "2.41", opts["argss"]
+    assert_nothing_raised { opts = @p.parse(%w(--argss hello)) }
+    assert_equal "hello", opts["argss"]
+
+    # multi args: ints
+    assert_nothing_raised { @p.opt "argmi", "desc", :default => [3, 5] }
+    assert_nothing_raised { opts = @p.parse("--") }
+    assert_equal [3, 5], opts["argmi"]
+    assert_nothing_raised { opts = @p.parse(%w(--argmi 4)) }
+    assert_equal [4], opts["argmi"]
+    assert_raise(CommandlineError) { @p.parse(%w(--argmi 4.2)) }
+    assert_raise(CommandlineError) { @p.parse(%w(--argmi hello)) }
+
+    # multi args: floats
+    assert_nothing_raised { @p.opt "argmf", "desc", :default => [3.34, 5.21] }
+    assert_nothing_raised { opts = @p.parse("--") }
+    assert_equal [3.34, 5.21], opts["argmf"]
+    assert_nothing_raised { opts = @p.parse(%w(--argmf 2)) }
+    assert_equal [2], opts["argmf"]
+    assert_nothing_raised { opts = @p.parse(%w(--argmf 4.0)) }
+    assert_equal [4.0], opts["argmf"]
+    assert_raise(CommandlineError) { @p.parse(%w(--argmf hello)) }
+
+    # multi args: strings
+    assert_nothing_raised { @p.opt "argms", "desc", :default => %w(hello world) }
+    assert_nothing_raised { opts = @p.parse("--") }
+    assert_equal %w(hello world), opts["argms"]
+    assert_nothing_raised { opts = @p.parse(%w(--argms 3.4)) }
+    assert_equal ["3.4"], opts["argms"]
+    assert_nothing_raised { opts = @p.parse(%w(--argms goodbye)) }
+    assert_equal ["goodbye"], opts["argms"]
   end    
 
   ## :type and :default must match if both are specified
   def test_type_and_default_must_match
-    assert_nothing_raised { @p.opt "goodarg", "desc", :type => :int, :default => 4 }
-    assert_nothing_raised { @p.opt "goodarg2", "desc", :type => :string, :default => "yo" }
     assert_raise(ArgumentError) { @p.opt "badarg", "desc", :type => :int, :default => "hello" }
     assert_raise(ArgumentError) { @p.opt "badarg2", "desc", :type => :String, :default => 4 }
+    assert_raise(ArgumentError) { @p.opt "badarg2", "desc", :type => :String, :default => ["hi"] }
+    assert_raise(ArgumentError) { @p.opt "badarg2", "desc", :type => :ints, :default => [3.14] }
+
+    assert_nothing_raised { @p.opt "argsi", "desc", :type => :int, :default => 4 }
+    assert_nothing_raised { @p.opt "argsf", "desc", :type => :float, :default => 3.14 }
+    assert_nothing_raised { @p.opt "argss", "desc", :type => :string, :default => "yo" }
+    assert_nothing_raised { @p.opt "argmi", "desc", :type => :ints, :default => [4] }
+    assert_nothing_raised { @p.opt "argmf", "desc", :type => :floats, :default => [3.14] }
+    assert_nothing_raised { @p.opt "argms", "desc", :type => :strings, :default => ["yo"] }
   end
 
   def test_long_detects_bad_names
@@ -306,13 +366,180 @@ EOM
     assert_raises(ArgumentError) { @p.opt :arg3, "desc", :short => "-" }
   end
 
-  def test_options_cant_be_set_multiple_times
+  def test_options_cant_be_set_multiple_times_if_not_specified
     @p.opt :arg, "desc", :short => "-x"
     assert_nothing_raised { @p.parse %w(-x) }
     assert_raises(CommandlineError) { @p.parse %w(-x -x) }
     assert_raises(CommandlineError) { @p.parse %w(-xx) }
   end
 
+  def test_options_can_be_set_multiple_times_if_specified
+    assert_nothing_raised do
+      @p.opt :arg, "desc", :short => "-x", :multi => true
+    end
+    assert_nothing_raised { @p.parse %w(-x) }
+    assert_nothing_raised { @p.parse %w(-x -x) }
+    assert_nothing_raised { @p.parse %w(-xx) }
+  end
+
+  def test_short_options_with_multiple_options
+    opts = nil
+
+    assert_nothing_raised do
+       @p.opt :xarg, "desc", :short => "-x", :type => String, :multi => true
+    end
+    assert_nothing_raised { opts = @p.parse %w(-x a -x b) }
+    assert_equal %w(a b), opts[:xarg]
+    assert_equal [], @p.leftovers
+  end
+
+  def short_options_with_multiple_options_does_not_affect_flags_type
+    opts = nil
+
+    assert_nothing_raised do
+      @p.opt :xarg, "desc", :short => "-x", :type => :flag, :multi => true
+    end
+
+    assert_nothing_raised { opts = @p.parse %w(-x a) }
+    assert_equal true, opts[:xarg]
+    assert_equal %w(a), @p.leftovers
+
+    assert_nothing_raised { opts = @p.parse %w(-x a -x b) }
+    assert_equal true, opts[:xarg]
+    assert_equal %w(a b), @p.leftovers
+
+    assert_nothing_raised { opts = @p.parse %w(-xx a -x b) }
+    assert_equal true, opts[:xarg]
+    assert_equal %w(a b), @p.leftovers
+  end
+
+  def test_short_options_with_multiple_arguments
+    opts = nil
+
+    @p.opt :xarg, "desc", :type => :ints
+    assert_nothing_raised { opts = @p.parse %w(-x 3 4 0) }
+    assert_equal [3, 4, 0], opts[:xarg]
+    assert_equal [], @p.leftovers
+
+    @p.opt :yarg, "desc", :type => :floats
+    assert_nothing_raised { opts = @p.parse %w(-y 3.14 4.21 0.66) }
+    assert_equal [3.14, 4.21, 0.66], opts[:yarg]
+    assert_equal [], @p.leftovers
+
+    @p.opt :zarg, "desc", :type => :strings
+    assert_nothing_raised { opts = @p.parse %w(-z a b c) }
+    assert_equal %w(a b c), opts[:zarg]
+    assert_equal [], @p.leftovers
+  end
+
+  def test_short_options_with_multiple_options_and_arguments
+    opts = nil
+
+    @p.opt :xarg, "desc", :type => :ints, :multi => true
+    assert_nothing_raised { opts = @p.parse %w(-x 3 4 5 -x 6 7) }
+    assert_equal [[3, 4, 5], [6, 7]], opts[:xarg]
+    assert_equal [], @p.leftovers
+
+    @p.opt :yarg, "desc", :type => :floats, :multi => true
+    assert_nothing_raised { opts = @p.parse %w(-y 3.14 4.21 5.66 -y 6.99 7.01) }
+    assert_equal [[3.14, 4.21, 5.66], [6.99, 7.01]], opts[:yarg]
+    assert_equal [], @p.leftovers
+
+    @p.opt :zarg, "desc", :type => :strings, :multi => true
+    assert_nothing_raised { opts = @p.parse %w(-z a b c -z d e) }
+    assert_equal [%w(a b c), %w(d e)], opts[:zarg]
+    assert_equal [], @p.leftovers
+  end
+
+  def test_combined_short_options_with_multiple_arguments
+    @p.opt :arg1, "desc", :short => "a"
+    @p.opt :arg2, "desc", :short => "b"
+    @p.opt :arg3, "desc", :short => "c", :type => :ints
+    @p.opt :arg4, "desc", :short => "d", :type => :floats
+
+    opts = nil
+
+    assert_nothing_raised { opts = @p.parse %w(-abc 4 6 9) }
+    assert_equal true, opts[:arg1]
+    assert_equal true, opts[:arg2]
+    assert_equal [4, 6, 9], opts[:arg3]
+
+    assert_nothing_raised { opts = @p.parse %w(-ac 4 6 9 -bd 3.14 2.41) }
+    assert_equal true, opts[:arg1]
+    assert_equal true, opts[:arg2]
+    assert_equal [4, 6, 9], opts[:arg3]
+    assert_equal [3.14, 2.41], opts[:arg4]
+
+    assert_raises(CommandlineError) { opts = @p.parse %w(-abcd 3.14 2.41) }
+  end
+
+  def test_long_options_with_multiple_options
+    @p.opt :xarg, "desc", :type => String, :multi => true
+    opts = nil
+    assert_nothing_raised { opts = @p.parse %w(--xarg=a --xarg=b) }
+    assert_equal %w(a b), opts[:xarg]
+    assert_equal [], @p.leftovers
+    assert_nothing_raised { opts = @p.parse %w(--xarg a --xarg b) }
+    assert_equal %w(a b), opts[:xarg]
+    assert_equal [], @p.leftovers
+  end
+
+  def test_long_options_with_multiple_arguments
+    opts = nil
+
+    @p.opt :xarg, "desc", :type => :ints
+    assert_nothing_raised { opts = @p.parse %w(--xarg 3 2 5) }
+    assert_equal [3, 2, 5], opts[:xarg]
+    assert_equal [], @p.leftovers
+    assert_nothing_raised { opts = @p.parse %w(--xarg=3) }
+    assert_equal [3], opts[:xarg]
+    assert_equal [], @p.leftovers
+
+    @p.opt :yarg, "desc", :type => :floats
+    assert_nothing_raised { opts = @p.parse %w(--yarg 3.14 2.41 5.66) }
+    assert_equal [3.14, 2.41, 5.66], opts[:yarg]
+    assert_equal [], @p.leftovers
+    assert_nothing_raised { opts = @p.parse %w(--yarg=3.14) }
+    assert_equal [3.14], opts[:yarg]
+    assert_equal [], @p.leftovers
+
+    @p.opt :zarg, "desc", :type => :strings
+    assert_nothing_raised { opts = @p.parse %w(--zarg a b c) }
+    assert_equal %w(a b c), opts[:zarg]
+    assert_equal [], @p.leftovers
+    assert_nothing_raised { opts = @p.parse %w(--zarg=a) }
+    assert_equal %w(a), opts[:zarg]
+    assert_equal [], @p.leftovers
+  end
+
+  def test_long_options_with_multiple_options_and_arguments
+    opts = nil
+
+    @p.opt :xarg, "desc", :type => :ints, :multi => true
+    assert_nothing_raised { opts = @p.parse %w(--xarg 3 2 5 --xarg 2 1) }
+    assert_equal [[3, 2, 5], [2, 1]], opts[:xarg]
+    assert_equal [], @p.leftovers
+    assert_nothing_raised { opts = @p.parse %w(--xarg=3 --xarg=2) }
+    assert_equal [[3], [2]], opts[:xarg]
+    assert_equal [], @p.leftovers
+
+    @p.opt :yarg, "desc", :type => :floats, :multi => true
+    assert_nothing_raised { opts = @p.parse %w(--yarg 3.14 2.72 5 --yarg 2.41 1.41) }
+    assert_equal [[3.14, 2.72, 5], [2.41, 1.41]], opts[:yarg]
+    assert_equal [], @p.leftovers
+    assert_nothing_raised { opts = @p.parse %w(--yarg=3.14 --yarg=2.41) }
+    assert_equal [[3.14], [2.41]], opts[:yarg]
+    assert_equal [], @p.leftovers
+
+    @p.opt :zarg, "desc", :type => :strings, :multi => true
+    assert_nothing_raised { opts = @p.parse %w(--zarg a b c --zarg d e) }
+    assert_equal [%w(a b c), %w(d e)], opts[:zarg]
+    assert_equal [], @p.leftovers
+    assert_nothing_raised { opts = @p.parse %w(--zarg=a --zarg=d) }
+    assert_equal [%w(a), %w(d)], opts[:zarg]
+    assert_equal [], @p.leftovers
+  end
+
   def test_long_options_also_take_equals
     @p.opt :arg, "desc", :long => "arg", :type => String, :default => "hello"
     opts = nil
@@ -389,7 +616,7 @@ EOM
     assert_raises(HelpNeeded) { @p.parse(%w(--help)) }
   end
 
-  def test_version_and_help_long_args_cann_be_overridden
+  def test_version_and_help_long_args_can_be_overridden
     @p.opt :asdf, "desc", :long => "help"
     @p.opt :asdf2, "desc2", :long => "version"
     assert_nothing_raised { @p.parse %w() }
@@ -599,6 +826,50 @@ EOM
     assert_equal cmd, "sub-command-1"
     assert_equal @q.leftovers, []
   end
+
+  def assert_parses_correctly(parser, commandline, expected_opts,
+                              expected_leftovers)
+    opts = parser.parse commandline
+    assert_equal expected_opts, opts
+    assert_equal expected_leftovers, parser.leftovers
+  end
+
+  def test_unknown_subcommand
+    @p.opt :global_flag, "Global flag", :short => "-g", :type => :flag
+    @p.opt :global_param, "Global parameter", :short => "-p", :default => 5
+    @p.stop_on_unknown
+
+    expected_opts = { :global_flag =>true, :help =>false, :global_param =>5 }
+    expected_leftovers = [ "my_subcommand", "-c" ]
+
+    assert_parses_correctly @p, %w(--global-flag my_subcommand -c), \
+      expected_opts, expected_leftovers
+    assert_parses_correctly @p, %w(-g my_subcommand -c), \
+      expected_opts, expected_leftovers
+
+    expected_opts = { :global_flag =>false, :help =>false, :global_param =>5 }
+    expected_leftovers = [ "my_subcommand", "-c" ]
+
+    assert_parses_correctly @p, %w(-p 5 my_subcommand -c), \
+      expected_opts, expected_leftovers
+    assert_parses_correctly @p, %w(--global-param 5 my_subcommand -c), \
+      expected_opts, expected_leftovers
+  end
+
+  def test_alternate_args
+    args = %w(-a -b -c)
+
+    opts = ::Trollop.options(args) do
+      opt :alpher, "Ralph Alpher", :short => "-a"
+      opt :bethe, "Hans Bethe", :short => "-b"
+      opt :gamow, "George Gamow", :short => "-c"
+    end
+
+    physicists_with_humor = [:alpher, :bethe, :gamow]
+    physicists_with_humor.each do |physicist|
+      assert_equal true, opts[physicist]
+    end
+  end
 end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: trollop
 version: !ruby/object:Gem::Version 
-  version: 1.8.2
+  version: "1.9"
 platform: ruby
 authors: 
 - William Morgan
@@ -9,10 +9,19 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-06-25 00:00:00 -07:00
+date: 2008-08-20 00:00:00 -07:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.7.0
+    version: 
 description: "== DESCRIPTION  Trollop is a commandline option parser for Ruby that just gets out of your way. One line of code per option is all you need to write. For that, you get a nice automatically-generated help page, robust option parsing, command subcompletion, and sensible defaults for everything you don't specify.  #################### ###### simple ###### ####################  require 'trollop' opts = Trollop::options do opt :monkey, \"Use monkey mode\" opt :goat, \"Use goat mode\", :default => true opt :num_limbs, \"Set number of limbs\", :default => 4 end  p opts # { :monkey => false, :goat => true, :num_limbs => 4 }  #################### ###### medium ###### ####################  require 'trollop' opts = Trollop::options do version \"test 1.2.3 (c) 2007 William Morgan\" banner <<-EOS Test is an awesome program that does something very, very important.  Usage: test [options] <filenames>+ where [options] are: EOS  opt :ignore, \"Ignore incorrect values\" opt :file, \"Extra data filename to read in, with a very long option description like this one\", :type => String opt :volume, \"Volume level\", :default => 3.0 opt :iters, \"Number of iterations\", :default => 5 end Trollop::die :volume, \"must be non-negative\" if opts[:volume] < 0 Trollop::die :file, \"must exist\" unless File.exist?(opts[:file]) if opts[:file] ################################ ##### sub-command support ###### ################################  require 'trollop' global_opts = Trollop::options do opt :global_option, \"This is a global option\" stop_on %w(sub-command-1 sub-command-2) end  cmd = ARGV.shift cmd_opts = Trollop::options do opt :cmd_option, \"This is an option only for the subcommand\" end  p global_opts p cmd p cmd_opts"
 email: wmorgan-trollop@masanjin.net
 executables: []
@@ -55,9 +64,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: trollop
-rubygems_version: 1.1.1
+rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
-summary: Trollop is YAFCLAP --- yet another fine commandline argument processing library for Ruby. Trollop is designed to provide the maximal amount of GNU-style argument processing in the minimum number of lines of code (for you, the programmer).
+summary: Trollop is a commandline option parser for Ruby that just gets out of your way. One line of code per option is all you need to write. For that, you get a nice automatically-generated help page, robust option parsing, command subcompletion, and sensible defaults for everything you don't specify.
 test_files: 
 - test/test_trollop.rb