clive 1.0.1 → 1.1.0

data/README.md

@@ -189,6 +189,26 @@ opt :size, args: '[<h> <w>]'
 # --size 10   #=> [10, nil]
 ```
 
+You can make an argument 'infinite' by appending the name with `...`, like
+`<arg>...`. Optional-ness is respected so `<arg>...` expects at least one argument
+whereas `[<arg>...]` takes 0 or more arguments. Infinite arguments also play well
+with standard arguments, and will return arrays of items even if only one argument
+was passed.
+
+``` ruby
+opt :items, :arg => '<thing>...'
+# --items            #=> Error
+# --items iPad       #=> ['iPad']
+# --items iPad iPod  #=> ['iPad', 'iPod']
+
+opt :items, :arg => '[<thing>...]'
+# --items            #=> []
+# and same as previously in other cases
+
+opt :items, :arg => '<amount> <thing>...', :as => [Integer, nil]
+# --items 5 iPad iMac  #=> [5, 'iPad', 'iMac']
+```  
+
 There are also various options that can be passed to constrain or change the
 arguments. If one of the below is passed to an option with `:arg` or `:args`
 a generic argument called `<arg>` will be added.

data/lib/clive/argument.rb

@@ -34,7 +34,8 @@ class Clive
       :match      => AlwaysTrue.for(:match),
       :within     => AlwaysTrue.for(:include?),
       :default    => nil,
-      :constraint => AlwaysTrue.for(:call)
+      :constraint => AlwaysTrue.for(:call),
+      :infinite   => false
     }
 
     attr_reader :name, :default, :type
@@ -91,6 +92,7 @@ class Clive
       @within     = opts[:within]
       @default    = opts[:default]
       @constraint = opts[:constraint]
+      @infinite   = opts[:infinite]
     end
 
     # @return Whether the argument is optional.
@@ -98,9 +100,14 @@ class Clive
       @optional
     end
 
+    # @return Whether the argument is infinite.
+    def infinite?
+      @infinite
+    end
+
     # @return [String] String representation for the argument.
     def to_s
-      optional? ? "[<#@name>]" : "<#@name>"
+      (optional? ? "[<#@name>]" : "<#@name>") + (infinite? ? '...' : '')
     end
 
     # @return [String]

data/lib/clive/arguments.rb

@@ -36,9 +36,8 @@ class Clive
       other = other.dup.compact
       # Find the number of 'spares'
       diff = other.size - find_all {|i| !i.optional? }.size
-      r = []
 
-      map do |arg|
+      r = map do |arg|
         if arg.possible?(other.first)
           if arg.optional?
             if diff > 0
@@ -53,6 +52,19 @@ class Clive
           [arg, nil]
         end
       end
+      
+      # If last arg is infinite may still have some left over so add now
+      if other != [] && last.respond_to?(:infinite?) && last.infinite?
+        r += other.map {|i| [last, i] }
+      end
+  
+      if last.respond_to?(:infinite?) && last.infinite?
+        infinites = []
+        r = r.reject! {|i| i.first.infinite? ? infinites << i : false }
+        r << [infinites[0].first, infinites.map {|i| i.last }]
+      end
+
+      r
     end
 
     # @return [String]
@@ -67,7 +79,23 @@ class Clive
 
     # @return [Integer] The maximum number of arguments that *can* be given.
     def max
-      size
+      if last && last.infinite?
+        1.0/0.0
+      else
+        size
+      end
+    end
+
+    # If the last item is infinite returns that item for any indexes greater
+    # than the actual length of the Arguments list.
+    #
+    # @param idx [Integer] Index of item to return
+    def [](idx)
+      if size <= idx && idx < max
+        last
+      else
+        super
+      end
     end
 
     # Whether the +list+ of found arguments could possibly be the arguments for
@@ -81,7 +109,7 @@ class Clive
       optionals = []
 
       list.each do |item|
-        break if i >= size
+        break if i >= max
 
         # Either, +item+ is self[i]
         if self[i].possible?(item)
@@ -89,7 +117,7 @@ class Clive
 
         # Or, the argument is optional and there is another argument to move to
         # meaning it can be skipped
-        elsif self[i].optional? && (i < size - 1)
+        elsif self[i].optional? && (i < max - 1)
           i += 1
           optionals << item
 
@@ -118,21 +146,22 @@ class Clive
     #
     # @param list [Array<Object>]
     def valid?(list)
-      zip(list).map do |a,i|
-        if a.optional?
-          nil
-        else
-          i
-        end
-      end.compact.size >= min && possible?(list)
+      l = zip(list).map {|a,i| a.optional? ? nil : i }
+      l.flatten.compact.size >= min && possible?(list)
     end
 
     # Will fill spaces in +list+ with default values, then coerces all arguments
-    # to the corect types.
+    # to the correct types.
     #
     # @return [Array]
     def create_valid(list)
-      zip(list).map {|a,r| r ? a.coerce(r) : a.coerce(a.default) }
+      zip(list).map do |a,r| 
+        if a.infinite?
+          r.map {|i| r ? a.coerce(i) : a.coerce(i.default) }
+        else
+          r ? a.coerce(r) : a.coerce(a.default) 
+        end
+      end
     end
 
   end

data/lib/clive/arguments/parser.rb

@@ -104,7 +104,7 @@ class Clive
       # @param name [String]
       # @return [String] Argument name without sqaure or angle brackets
       def clean(name)
-        name.tr '[<>]', ''
+        name.tr '[<>].', ''
       end
 
       # @param hash [Hash<Symbol=>Object, Symbol=>Array>]
@@ -188,6 +188,8 @@ class Clive
         cancelled_optional = false
 
         arg_str.split(' ').zip(hash).map do |arg, opts|
+          opts ||= {}
+
           if cancelled_optional
             optional = false
             cancelled_optional = false
@@ -201,7 +203,9 @@ class Clive
             raise InvalidArgumentStringError.new(opts[:arg])
           end
 
-          {:name => clean(arg), :optional => optional}.merge(opts || {})
+          opts[:infinite] = true if arg =~ /\.\.\.\]?$/
+
+          {:name => clean(arg), :optional => optional}.merge(opts)
         end
       end
 

data/lib/clive/option.rb

@@ -143,7 +143,7 @@ class Clive
       mapped_args = if @config[:boolean] == true
         [[:truth, args.first]]
       else
-        @args.zip(args).map {|k,v| [k.name, v] }
+        @args.zip(args).map {|k,v| [k.name, (k.infinite? ? v.first : v)] }
       end
 
       if block?
@@ -153,7 +153,7 @@ class Clive
           state = @config[:runner]._run(mapped_args, state, @block)
         end
       else
-        state = set_state(state, args, scope)
+        state = set_state(state, args.flatten(1), scope)
       end
 
       state
@@ -189,7 +189,7 @@ class Clive
     # @param scope [Symbol, nil]
     def set_state(state, args, scope=nil)
       args = (@args.max <= 1 ? args[0] : args)
-
+      
       if scope
         state[scope.name].store [@names.long, @names.short].compact, args
       else

data/lib/clive/parser.rb

@@ -24,13 +24,19 @@ class Clive
       @config = DEFAULTS.merge(config)
     end
 
-    # The parser should work how you expect. It allows you to put global options before and after
-    # a command section (if it exists, which it doesn't), so you have something like.
+    # The parser should work how you expect. It allows you to put global options 
+    # before and after a command section (if it exists, which it doesn't), so 
+    # you have something like.
     #
-    #    my_app.rb [global options] ([command] [options] [args]) [g. options] [g. args] [g. options] etc.
-    #            |  global section  |    command section       |      global section
+    #    app [global] [command] [global]
     #
-    # Only one command can be run, if you attempt to use two the other will be caught as an argument.
+    # Where the [global] sections are made of options and arguments and 
+    # [command] is made of
+    #
+    #    [command] [options/args]
+    #
+    # Only one command can be run, if you attempt to use two the other will be 
+    # caught as an argument.
     #
     # @param argv [Array]
     #   The input to parse from the command line, usually ARGV.

data/lib/clive/version.rb

@@ -1,3 +1,3 @@
 class Clive
-  VERSION = '1.0.1'
+  VERSION = '1.1.0'
 end

data/spec/clive/a_cli_spec.rb

@@ -24,6 +24,8 @@ describe 'A CLI' do
         update key, sym, *args
       end
 
+      opt :items, :args => '<item>...'
+
       desc 'Print <message> <n> times'
       opt :print, :arg => '<message> <n>', :as => [String, Integer] do
         n.times { puts message }
@@ -40,11 +42,6 @@ describe 'A CLI' do
 
         # implicit arg as "<choice>", also added default
         opt :T, :type, :in => %w(post page blog), :default => :page, :as => Symbol
-        opt :force, 'Force overwrite' do
-          require 'highline/import'
-          answer = ask("Are you sure, this could delete stuff? [y/n]\n")
-          set :force, true if answer == "y"
-        end
 
         action do |dir|
           puts "Creating #{get :type} in #{dir}" if dir
@@ -129,6 +126,18 @@ describe 'A CLI' do
     end
   end
 
+  describe '--items' do
+    it 'returns the list passed to it' do
+      r = subject.run s '--items a b c'
+      r[:items].must_equal ['a', 'b', 'c']
+    end
+
+    it 'returns a single item in an array if only one item passed' do
+      r = subject.run s '--items a'
+      r[:items].must_equal ['a']
+    end
+  end
+
   describe '--print' do
     it 'prints a message n times' do
       this {
@@ -202,13 +211,6 @@ describe 'A CLI' do
       end
     end
 
-    describe '--force' do
-      #it 'asks for conformation' do
-      #  r = subject.run s 'new --force'
-      #  r[:force].must_be_true
-      #end
-    end
-
     describe 'action' do
       it 'prints the type and dir' do
         this {

data/spec/clive/argument_spec.rb

@@ -2,12 +2,12 @@ $: << File.dirname(__FILE__) + '/..'
 require 'helper'
 
 describe Clive::Argument::AlwaysTrue do
-  subject { Clive::Argument::AlwaysTrue } 
-  
+  subject { Clive::Argument::AlwaysTrue }
+
   it 'is always true for the method given' do
     subject.for(:hey).hey.must_be_true
   end
-  
+
   it 'is always true for the methods given' do
     a = subject.for(:one, :two, :three)
     a.one.must_be_true
@@ -18,126 +18,140 @@ end
 
 describe Clive::Argument do
   subject { Clive::Argument }
-  
+
   describe '#initialize' do
     it 'converts name to Symbol' do
       subject.new('arg').name.must_be_kind_of Symbol
     end
-    
+
     it 'calls #to_proc on a Symbol constraint' do
       c = mock
       c.expects(:respond_to?).with(:to_proc).returns(true)
       c.expects(:to_proc)
-      
+
       subject.new :a, :constraint => c
     end
-    
+
     it 'merges given options with DEFAULTS' do
       opts = {:optional => true}
       Clive::Argument::DEFAULTS.expects(:merge).with(opts).returns({})
       subject.new('arg', opts)
     end
-    
+
     it 'finds the correct type class' do
       subject.new(:a, :type => String).type.must_equal Clive::Type::String
     end
-    
+
     it 'uses the class passed if type cannot be found' do
       type = Class.new
       subject.new(:a, :type => type).type.must_equal type
     end
   end
-  
+
   describe '#optional?' do
     it 'is true if the argument is optional' do
       subject.new(:arg, :optional => true).must_be :optional?
     end
-    
+
     it 'is false if the argument is not optional' do
       subject.new(:arg, :optional => false).wont_be :optional?
     end
-    
+
     it 'is false by default' do
       subject.new(:arg).wont_be :optional?
     end
   end
-  
+
+  describe '#infinite?' do
+    it 'is true if the argument is infinite' do
+      subject.new(:arg, :infinite => true).must_be :infinite?
+    end
+
+    it 'is false if the argument is not infinite' do
+      subject.new(:arg, :infinite => false).wont_be :infinite?
+    end
+
+    it 'is false by default' do
+      subject.new(:arg).wont_be :infinite?
+    end
+  end
+
   describe '#to_s' do
     it 'surrounds the name by < and >' do
       subject.new(:a).to_s.must_equal '<a>'
     end
-    
+
     it 'surrounds optional arguments with [ and ]' do
       subject.new(:a, :optional => true).to_s.must_equal '[<a>]'
     end
   end
-  
+
   describe '#choice_str' do
     it 'returns the array of values allowed' do
       subject.new(:a, :within => %w(a b c)).choice_str.must_equal '(a, b, c)'
     end
-    
+
     it 'returns the range of values allowed' do
       subject.new(:a, :within => 1..5).choice_str.must_equal '(1..5)'
     end
   end
-  
+
   describe '#possible?' do
     describe 'for @type' do
       subject { Clive::Argument.new :a, :type => Clive::Type::Time }
-      
+
       it 'is true for correct string values' do
         subject.must_be :possible?, '12:34'
       end
-      
+
       it 'is true for objects of type' do
         subject.must_be :possible?, Time.parse('12:34')
       end
-      
+
       unless RUBY_VERSION == '1.8.7' # No big problem so just ignore
         it 'is false for incorrect values' do
           subject.wont_be :possible?, 'not-a-time'
         end
       end
     end
-    
+
     describe 'for @match' do
       subject { Clive::Argument.new :a, :match => /^[a-e]+![f-o]+\?.$/ }
-      
+
       it 'is true for matching values' do
         subject.must_be :possible?, 'abe!off?.'
       end
-      
+
       it 'is false for non-matching values' do
         subject.wont_be :possible?, 'off?abe!.'
       end
     end
-    
+
     describe 'for @within' do
       subject { Clive::Argument.new :a, :within => %w(dog cat fish) }
-      
+
       it 'is true for elements included in the collection' do
         subject.must_be :possible?, 'dog'
       end
-      
+
       it 'is false for elements not in the collection' do
         subject.wont_be :possible?, 'mouse'
       end
     end
-    
+
     describe 'for @constraint' do
       subject { Clive::Argument.new :a, :constraint => proc {|i| i.size == 5 } }
-      
+
       it 'is true if the proc returns true' do
         subject.must_be :possible?, 'abcde'
       end
-      
+
       it 'is false if the proc returns false' do
         subject.wont_be :possible?, 'abcd'
       end
     end
   end
-  
+
   describe '#coerce' do
     it 'uses @type to return the correct object' do
       type = mock

data/spec/clive/arguments_spec.rb

@@ -4,11 +4,11 @@ require 'helper'
 describe Clive::Arguments do
 
   subject {
-    Clive::Arguments.create :args => '[<a>] <b> <c> [<d>]', 
+    Clive::Arguments.create :args => '[<a>] <b> <c> [<d>]',
                             :type => [Integer] * 4,
                             :constraint => [:even?, :odd?] * 2
   }
-  
+
   describe '.create' do
     it 'parses the options passed using Parser' do
       parser, opts = mock, stub
@@ -18,7 +18,7 @@ describe Clive::Arguments do
     end
     it 'returns a list of Argument instances' do
       a = Clive::Arguments.create :args => '[<a>] <b>', :as => [Integer, nil], :in => [1..5, nil]
-      a[0].must_be_argument :name => :a, :optional => true, :within => 1..5, 
+      a[0].must_be_argument :name => :a, :optional => true, :within => 1..5,
                             :type => Clive::Type::Integer
       a[1].must_be_argument :name => :b, :optional => false
     end
@@ -26,48 +26,86 @@ describe Clive::Arguments do
 
   describe '#zip' do
     it 'zips arguments properly' do
-      def subject.simple_zip(other); zip(other).map(&:last); end
-    
+      def subject.z(other); zip(other).map(&:last); end
+
       # These behaviours are definitely what should happen
-      subject.simple_zip(%w(1 4)).must_equal     [nil, '1', '4', nil]
-      subject.simple_zip(%w(1 4 3)).must_equal   [nil, '1', '4', '3']
-      subject.simple_zip(%w(2 1 4 3)).must_equal ['2', '1', '4', '3']
-      subject.simple_zip(%w(2 1 4)).must_equal   ['2', '1', '4', nil]
-      
+      subject.z(%w(1 4)).must_equal     [nil, '1', '4', nil]
+      subject.z(%w(1 4 3)).must_equal   [nil, '1', '4', '3']
+      subject.z(%w(2 1 4 3)).must_equal ['2', '1', '4', '3']
+      subject.z(%w(2 1 4)).must_equal   ['2', '1', '4', nil]
+
       # These behaviours may change
-      subject.simple_zip(%w(2)).must_equal   [nil, nil, '2', nil]
-      subject.simple_zip(%w(1)).must_equal   [nil, '1', nil, nil]
-      subject.simple_zip(%w(2 1)).must_equal [nil, nil, '2', nil]
-    end  
+      subject.z(%w(2)).must_equal   [nil, nil, '2', nil]
+      subject.z(%w(1)).must_equal   [nil, '1', nil, nil]
+      subject.z(%w(2 1)).must_equal [nil, nil, '2', nil]
+    end
+    
+    it 'zips infinite arguments properly' do
+      a = Clive::Argument.new(:a)
+      b = Clive::Argument.new(:b, :optional => true)
+      c = Clive::Argument.new(:c, :infinite => true)
+      s = Clive::Arguments.new([a, b, c])
+      
+      s.zip(%w(a)).must_equal       [[a, 'a'], [b, nil], [c, [nil]]]
+      s.zip(%w(a b)).must_equal     [[a, 'a'], [b, nil], [c, ['b']]]
+      s.zip(%w(a b c)).must_equal   [[a, 'a'], [b, 'b'], [c, ['c']]]
+      s.zip(%w(a b c d)).must_equal [[a, 'a'], [b, 'b'], [c, ['c', 'd']]]
+    end
   end
-  
+
   describe '#to_s' do
     subject {
      Clive::Arguments.new( [
-       Clive::Argument.new(:a), 
+       Clive::Argument.new(:a),
        Clive::Argument.new(:b, :optional => true),
        Clive::Argument.new(:c, :optional => true),
        Clive::Argument.new(:d)
      ])
     }
-  
+
     it 'removes extra square brackets' do
       subject.to_s.must_equal "<a> [<b> <c>] <d>"
     end
   end
-  
+
   describe '#min' do
     it 'returns the number of non-optional arguments' do
       subject.min.must_equal 2
     end
   end
-  
+
   describe '#max' do
     it 'returns the total number of arguments' do
       subject.max.must_equal 4
     end
+
+    it 'returns Infinity if last arg is infinite' do
+      as = Clive::Arguments.new([Clive::Argument.new(:a, :infinite => true)])
+      as.max.must_equal 1.0/0.0
+    end
+  end
+
+  describe '#[]' do
+    let(:a) { Clive::Argument.new(:a) }
+    let(:b) { Clive::Argument.new(:b) }
+    let(:c) { Clive::Argument.new(:c, :infinite => true) }
+
+    it 'returns the indexed item normally' do
+      subject = Clive::Arguments.new([a, b])
+      subject[0].must_equal a
+      subject[1].must_equal b
+      subject[2].must_equal nil
+    end
+
+    it 'returns the last item if infinite' do
+      subject = Clive::Arguments.new([a, c])
+      subject[0].must_equal a
+      subject[1].must_equal c
+      subject[2].must_equal c
+      subject[99].must_equal c
+    end
   end
-  
+
   describe '#possible?' do
     it 'is true if each argument is possible and list is not too long' do
       subject.must_be :possible?, [2]
@@ -75,29 +113,29 @@ describe Clive::Arguments do
       subject.must_be :possible?, [2, 3, 4]
       subject.must_be :possible?, [2, 3, 4, 5]
     end
-    
+
     it 'is false if the list is too long' do
       subject.wont_be :possible?, [2, 3, 4, 5, 6]
     end
-    
+
     it 'is true even if an argument is not possible' do
       subject.must_be :possible?, ['hello']
     end
-    
+
     it 'single' do
       subject = Clive::Arguments.create :arg => '<name>'
       subject.must_be :possible?, []
       subject.must_be :possible?, %w(John)
       subject.wont_be :possible?, %w(John Doe)
     end
-    
+
     it 'single optional' do
       subject = Clive::Arguments.create :arg => '[<name>]'
       subject.must_be :possible?, []
       subject.must_be :possible?, %w(John)
       subject.wont_be :possible?, %w(John Doe)
     end
-    
+
     it 'single with constraint' do
       subject = Clive::Arguments.create :arg => '<name>', :constraint => proc {|i| i.size == 4 }
       subject.must_be :possible?, []
@@ -105,7 +143,7 @@ describe Clive::Arguments do
       subject.wont_be :possible?, %w(James)
       subject.wont_be :possible?, %w(John Doe)
     end
-    
+
     it 'single optional with constraint' do
       subject = Clive::Arguments.create :arg => '[<name>]', :constraint => proc {|i| i.size == 4 }
       subject.must_be :possible?, []
@@ -113,7 +151,7 @@ describe Clive::Arguments do
       subject.wont_be :possible?, %w(James)
       subject.wont_be :possible?, %w(John Doe)
     end
-  
+
     it 'multiple surrounding' do
       subject = Clive::Arguments.create :args => '<first> [<middle>] <last>'
       subject.must_be :possible?, []
@@ -122,7 +160,7 @@ describe Clive::Arguments do
       subject.must_be :possible?, %w(John David Doe)
       subject.wont_be :possible?, %w(John David James Doe)
     end
-    
+
     it 'multiple middle' do
       subject = Clive::Arguments.create :args => '[<first>] <middle> [<last>]'
       subject.must_be :possible?, []
@@ -131,36 +169,75 @@ describe Clive::Arguments do
       subject.must_be :possible?, %w(John David Doe)
       subject.wont_be :possible?, %w(John David James Doe)
     end
-    
+
     it 'multiple surrounding with constraints' do
       subject = Clive::Arguments.create :args => '<first> [<middle>] <last>',
         :constraint => [proc {|i| i.size == 3 }, proc {|i| i.size == 4 }, proc {|i| i.size == 5 }]
       subject.must_be :possible?, []
-      
+
       subject.must_be :possible?, %w(Joe)   # [Joe, ..., ...]
       subject.wont_be :possible?, %w(Gary)  # [!!!, Gary, ...]
       subject.wont_be :possible?, %w(David) # [!!!, nil, David]
-      
+
       subject.must_be :possible?, %w(Joe Gary)   # [Joe, Gary, ...]
       subject.must_be :possible?, %w(Joe David)  # [Joe, ..., David]
       subject.wont_be :possible?, %w(Gary David) # [!!!, Gary, David]
-      
+
       subject.must_be :possible?, %w(Joe Gary David)     # [Joe, Gary, David]
       subject.wont_be :possible?, %w(Joe Gary David Doe) # [Joe, Gary, David] Doe
     end
+
+    it 'infinite' do
+      subject = Clive::Arguments.create :args => '<arg>...'
+
+      subject.must_be :possible?, []
+      subject.must_be :possible?, %w(a)
+      subject.must_be :possible?, %w(a b)
+      subject.must_be :possible?, %w(a b c)
+      subject.must_be :possible?, %w(a b c d)
+    end
+
+    it 'infinite with constraints' do
+      subject = Clive::Arguments.create :args => '<arg>...', :in => 'a'..'f'
+
+      subject.must_be :possible?, []
+      subject.must_be :possible?, %w(a)
+      subject.must_be :possible?, %w(a b)
+
+      subject.wont_be :possible?, %w(a z)
+    end
+
+    it 'optional infinite' do
+      subject = Clive::Arguments.create :args => '[<arg>...]'
+
+      subject.must_be :possible?, []
+      subject.must_be :possible?, %w(a)
+      subject.must_be :possible?, %w(a b)
+      subject.must_be :possible?, %w(a b c)
+      subject.must_be :possible?, %w(a b c d)
+    end
+
+    it 'normal and infinite' do
+      subject = Clive::Arguments.create :args => '<a> <arg>...'
+
+      subject.must_be :possible?, []
+      subject.must_be :possible?, %w(a)
+      subject.must_be :possible?, %w(a b)
+      subject.must_be :possible?, %w(a b c)
+    end
   end
-  
+
   describe '#valid?' do
     it 'is false if the list is not #possible' do
       subject.stubs(:possible?).returns(false)
       subject.wont_be :valid?, [1, 2]
     end
-    
+
     it 'is false if the list is too short' do
       subject.stubs(:possible?).returns(true)
       subject.wont_be :valid?, [1]
     end
-    
+
     it 'is true if the list is #possible? and not too short' do
       subject.stubs(:possible?).returns(true)
       subject.must_be :valid?, [1, 2]
@@ -168,7 +245,7 @@ describe Clive::Arguments do
       subject.must_be :valid?, [0, 1, 2, 3]
     end
   end
-  
+
   describe '#create_valid' do
     it 'returns the correct arguments' do
       a = Clive::Arguments.create :args => '[<a>] <b> [<c>]'
@@ -176,12 +253,12 @@ describe Clive::Arguments do
       a.create_valid(%w(a b)).must_equal ['a', 'b', nil]
       a.create_valid(%w(a)).must_equal [nil, 'a', nil]
     end
-    
+
     it 'coerces the arguments' do
       a = Clive::Arguments.create :args => '<a> <b>', :as => [Integer, Float]
       a.create_valid(%w(50.55 50.55)).must_equal [50, 50.55]
     end
-    
+
     it 'uses defaults where needed' do
       a = Clive::Arguments.create :args => '[<a>] <b> [<c>]', :defaults => ['y', nil, 'y']
       a.create_valid(%w(n)).must_equal %w(y n y)

data/spec/clive/parser_spec.rb

@@ -143,6 +143,38 @@ EOS
       r.must_have :auto
     end
   end
+  
+  describe 'Infinite arguments' do
+    subject {
+      Clive.new { opt :items, :arg => '<item>...' }
+    }
+    
+    it 'requires at least one argument' do
+      this {
+        subject.run s '--items'
+      }.must_raise Clive::Parser::MissingArgumentError
+    end
+    
+    it 'takes infinite arguments' do
+      r = subject.run s '--items a b c d e f g h'
+      r.items.must_equal %w(a b c d e f g h)
+    end
+  end
+  
+  describe 'Optional infinite arguments' do
+    subject {
+      Clive.new { opt :items, :arg => '[<item>...]' }
+    }
+    
+    it 'does not require an argument' do
+      subject.run s '--items'
+    end
+    
+    it 'takes infinite arguments' do
+      r = subject.run s '--items a b c d e f g h'
+      r.items.must_equal %w(a b c d e f g h)
+    end
+  end
 
   describe 'Commands' do
     describe 'with options and arguments' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: clive
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-01 00:00:00.000000000 Z
+date: 2012-02-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
-  requirement: &2156107440 !ruby/object:Gem::Requirement
+  requirement: &2152595180 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: '2.6'
   type: :development
   prerelease: false
-  version_requirements: *2156107440
+  version_requirements: *2152595180
 - !ruby/object:Gem::Dependency
   name: mocha
-  requirement: &2156106140 !ruby/object:Gem::Requirement
+  requirement: &2152592780 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,7 +32,7 @@ dependencies:
         version: '0.10'
   type: :development
   prerelease: false
-  version_requirements: *2156106140
+  version_requirements: *2152592780
 description: ! "    Clive provides a DSL for building command line interfaces. It
   allows \n    you to define commands and options, which can also take arguments,
   \n    and then runs the correct stuff!\n"