Allow Option to be repeatable

Author: dturn

lib/thor/parser/option.rb

@@ -1,17 +1,18 @@
 class Thor
   class Option < Argument #:nodoc:
-    attr_reader :aliases, :group, :lazy_default, :hide
+    attr_reader :aliases, :group, :lazy_default, :hide, :repeatable
 
     VALID_TYPES = [:boolean, :numeric, :hash, :array, :string]
 
     def initialize(name, options = {})
       @check_default_type = options[:check_default_type]
       options[:required] = false unless options.key?(:required)
+      @repeatable     = options.fetch(:repeatable, false)
       super
-      @lazy_default = options[:lazy_default]
-      @group        = options[:group].to_s.capitalize if options[:group]
-      @aliases      = Array(options[:aliases])
-      @hide         = options[:hide]
+      @lazy_default   = options[:lazy_default]
+      @group          = options[:group].to_s.capitalize if options[:group]
+      @aliases        = Array(options[:aliases])
+      @hide           = options[:hide]
     end
 
     # This parse quick options given as method_options. It makes several
@@ -128,7 +129,8 @@ def validate_default_type!
         @default.class.name.downcase.to_sym
       end
 
-      raise ArgumentError, "Expected #{@type} default value for '#{switch_name}'; got #{@default.inspect} (#{default_type})" unless default_type == @type
+      expected_type = (@repeatable && @type != :hash) ? :array : @type
+      raise ArgumentError, "Expected #{expected_type} default value for '#{switch_name}'; got #{@default.inspect} (#{default_type})" unless default_type == expected_type
     end
 
     def dasherized?

lib/thor/parser/options.rb

@@ -97,7 +97,8 @@ def parse(args) # rubocop:disable MethodLength
 
             switch = normalize_switch(switch)
             option = switch_option(switch)
-            @assigns[option.human_name] = parse_peek(switch, option)
+            result = parse_peek(switch, option)
+            assign_result!(option, result)
           elsif @stop_on_unknown
             @parsing_options = false
             @extra << shifted
@@ -132,6 +133,15 @@ def check_unknown!
 
   protected
 
+  def assign_result!(option, result)
+    if option.repeatable && option.type == :hash
+      (@assigns[option.human_name] ||= {}).merge!(result)
+    elsif option.repeatable
+      (@assigns[option.human_name] ||= []) << result
+    else
+      @assigns[option.human_name] = result
+    end
+  end
     # Check if the current value in peek is a registered switch.
     #
     # Two booleans are returned.  The first is true if the current value

spec/parser/option_spec.rb

@@ -140,6 +140,30 @@ def option(name, options = {})
     end.to raise_error(ArgumentError, 'Expected numeric default value for \'--foo-bar\'; got "baz" (string)')
   end
 
+  it "raises an error if repeatable and default is inconsistent with type and check_default_type is true" do
+    expect do
+      option("foo_bar", :type => :numeric, :repeatable => true, :default => "baz", :check_default_type => true)
+    end.to raise_error(ArgumentError, 'Expected array default value for \'--foo-bar\'; got "baz" (string)')
+  end
+
+  it "raises an error type hash is repeatable and default is inconsistent with type and check_default_type is true" do
+    expect do
+      option("foo_bar", :type => :hash, :repeatable => true, :default => "baz", :check_default_type => true)
+    end.to raise_error(ArgumentError, 'Expected hash default value for \'--foo-bar\'; got "baz" (string)')
+  end
+
+  it "does not raises an error if type hash is repeatable and default is consistent with type and check_default_type is true" do
+    expect do
+      option("foo_bar", :type => :hash, :repeatable => true, :default => {}, :check_default_type => true)
+    end.not_to raise_error
+  end
+
+  it "does not raises an error if repeatable and default is consistent with type and check_default_type is true" do
+    expect do
+      option("foo_bar", :type => :numeric, :repeatable => true, :default => [1], :check_default_type => true)
+    end.not_to raise_error
+  end
+
   it "does not raises an error if default is an symbol and type string and check_default_type is true" do
     expect do
       option("foo", :type => :string, :default => :bar, :check_default_type => true)

spec/parser/options_spec.rb

@@ -6,7 +6,6 @@ def create(opts, defaults = {}, stop_on_unknown = false)
     opts.each do |key, value|
       opts[key] = Thor::Option.parse(key, value) unless value.is_a?(Thor::Option)
     end
-
     @opt = Thor::Options.new(opts, defaults, stop_on_unknown)
   end
 
@@ -302,6 +301,13 @@ def remaining
         expect { parse("--fruit", "orange") }.to raise_error(Thor::MalformattedArgumentError,
             "Expected '--fruit' to be one of #{enum.join(', ')}; got orange")
       end
+
+      it "allows multiple values if repeatable is specified" do
+        create :foo => Thor::Option.new("foo", :type => :string, :repeatable => true)
+
+        expect(parse("--foo=bar", "--foo", "12")["foo"]).to eq(["bar", "12"])
+        expect(parse("--foo", "13", "--foo", "14")["foo"]).to eq(["bar", "12", "13", "14"])
+      end
     end
 
     describe "with :boolean type" do
@@ -362,6 +368,11 @@ def remaining
         expect(parse("--skip-foo", "bar")).to eq("foo" => false)
         expect(@opt.remaining).to eq(%w(bar))
       end
+
+      it "allows multiple values if repeatable is specified" do
+        create :verbose => Thor::Option.new("verbose", :type => :boolean, :aliases => '-v', :repeatable => true)
+        expect(parse("-v", "-v", "-v")["verbose"].count).to eq(3)
+      end
     end
 
     describe "with :hash type" do
@@ -384,6 +395,11 @@ def remaining
       it "must not allow the same hash key to be specified multiple times" do
         expect { parse("--attributes", "name:string", "name:integer") }.to raise_error(Thor::MalformattedArgumentError, "You can't specify 'name' more than once in option '--attributes'; got name:string and name:integer")
       end
+
+      it "allows multiple values if repeatable is specified" do
+        create :attributes => Thor::Option.new("attributes", :type => :hash, :repeatable => true)
+        expect(parse("--attributes", "name:one", "foo:1", "--attributes", "name:two", "bar:2")["attributes"]).to eq({"name"=>"two", "foo"=>"1", "bar" => "2"})
+      end
     end
 
     describe "with :array type" do
@@ -402,6 +418,11 @@ def remaining
       it "must not mix values with other switches" do
         expect(parse("--attributes", "a", "b", "c", "--baz", "cool")["attributes"]).to eq(%w(a b c))
       end
+
+      it "allows multiple values if repeatable is specified" do
+        create :attributes => Thor::Option.new("attributes", :type => :array, :repeatable => true)
+        expect(parse("--attributes", "1", "2", "--attributes", "3", "4")["attributes"]).to eq([["1", "2"], ["3", "4"]])
+      end
     end
 
     describe "with :numeric type" do
@@ -428,6 +449,11 @@ def remaining
         expect { parse("--limit", "3") }.to raise_error(Thor::MalformattedArgumentError,
                                                         "Expected '--limit' to be one of #{enum.join(', ')}; got 3")
       end
+
+      it "allows multiple values if repeatable is specified" do
+        create :run => Thor::Option.new("run", :type => :numeric, :repeatable => true)
+        expect(parse("--run", "1", "--run", "2")["run"]).to eq([1, 2])
+      end
     end
   end
 end