thor 0.18.1 → 0.19.0

data/spec/line_editor/basic_spec.rb

@@ -0,0 +1,28 @@
+require "helper"
+
+describe Thor::LineEditor::Basic do
+  describe ".available?" do
+    it "returns true" do
+      expect(Thor::LineEditor::Basic).to be_available
+    end
+  end
+
+  describe "#readline" do
+    it "uses $stdin and $stdout to get input from the user" do
+      expect($stdout).to receive(:print).with("Enter your name ")
+      expect($stdin).to receive(:gets).and_return("George")
+      expect($stdin).not_to receive(:noecho)
+      editor = Thor::LineEditor::Basic.new("Enter your name ", {})
+      expect(editor.readline).to eq("George")
+    end
+
+    it "disables echo when asked to" do
+      expect($stdout).to receive(:print).with("Password: ")
+      noecho_stdin = double("noecho_stdin")
+      expect(noecho_stdin).to receive(:gets).and_return("secret")
+      expect($stdin).to receive(:noecho).and_yield(noecho_stdin)
+      editor = Thor::LineEditor::Basic.new("Password: ", :echo => false)
+      expect(editor.readline).to eq("secret")
+    end
+  end
+end

data/spec/line_editor/readline_spec.rb

@@ -0,0 +1,69 @@
+require "helper"
+
+describe Thor::LineEditor::Readline do
+  before do
+    unless defined? ::Readline
+      ::Readline = double("Readline")
+      allow(::Readline).to receive(:completion_append_character=).with(nil)
+    end
+  end
+
+  describe ".available?" do
+    it "returns true when ::Readline exists" do
+      allow(Object).to receive(:const_defined?).with(:Readline).and_return(true)
+      expect(described_class).to be_available
+    end
+
+    it "returns false when ::Readline does not exist" do
+      allow(Object).to receive(:const_defined?).with(:Readline).and_return(false)
+      expect(described_class).not_to be_available
+    end
+  end
+
+  describe "#readline" do
+    it "invokes the readline library" do
+      expect(::Readline).to receive(:readline).with("> ", true).and_return("foo")
+      expect(::Readline).not_to receive(:completion_proc=)
+      editor = Thor::LineEditor::Readline.new("> ", {})
+      expect(editor.readline).to eq("foo")
+    end
+
+    it "supports the add_to_history option" do
+      expect(::Readline).to receive(:readline).with("> ", false).and_return("foo")
+      expect(::Readline).not_to receive(:completion_proc=)
+      editor = Thor::LineEditor::Readline.new("> ", :add_to_history => false)
+      expect(editor.readline).to eq("foo")
+    end
+
+    it "provides tab completion when given a limited_to option" do
+      expect(::Readline).to receive(:readline)
+      expect(::Readline).to receive(:completion_proc=) do |proc|
+        expect(proc.call("")).to eq %w[Apples Chicken Chocolate]
+        expect(proc.call("Ch")).to eq %w[Chicken Chocolate]
+        expect(proc.call("Chi")).to eq ["Chicken"]
+      end
+
+      editor = Thor::LineEditor::Readline.new("Best food: ", :limited_to => %w[Apples Chicken Chocolate])
+      editor.readline
+    end
+
+    it "provides path tab completion when given the path option" do
+      expect(::Readline).to receive(:readline)
+      expect(::Readline).to receive(:completion_proc=) do |proc|
+        expect(proc.call("../line_ed").sort).to eq ["../line_editor/", "../line_editor_spec.rb"].sort
+      end
+
+      editor = Thor::LineEditor::Readline.new("Path to file: ", :path => true)
+      Dir.chdir(File.dirname(__FILE__)) { editor.readline }
+    end
+
+    it "uses STDIN when asked not to echo input" do
+      expect($stdout).to receive(:print).with("Password: ")
+      noecho_stdin = double("noecho_stdin")
+      expect(noecho_stdin).to receive(:gets).and_return("secret")
+      expect($stdin).to receive(:noecho).and_yield(noecho_stdin)
+      editor = Thor::LineEditor::Readline.new("Password: ", :echo => false)
+      expect(editor.readline).to eq("secret")
+    end
+  end
+end

data/spec/line_editor_spec.rb

@@ -0,0 +1,43 @@
+require "helper"
+
+describe Thor::LineEditor, "on a system with Readline support" do
+  before do
+    @original_readline = ::Readline if defined? ::Readline
+    silence_warnings { ::Readline = double("Readline") }
+  end
+
+  after do
+    silence_warnings { ::Readline = @original_readline }
+  end
+
+  describe ".readline" do
+    it "uses the Readline line editor" do
+      editor = double("Readline")
+      expect(Thor::LineEditor::Readline).to receive(:new).with("Enter your name ", :default => "Brian").and_return(editor)
+      expect(editor).to receive(:readline).and_return("George")
+      expect(Thor::LineEditor.readline("Enter your name ", :default => "Brian")).to eq("George")
+    end
+  end
+end
+
+describe Thor::LineEditor, "on a system without Readline support" do
+  before do
+    if defined? ::Readline
+      @original_readline = ::Readline
+      Object.send(:remove_const, :Readline)
+    end
+  end
+
+  after do
+    silence_warnings { ::Readline = @original_readline }
+  end
+
+  describe ".readline" do
+    it "uses the Basic line editor" do
+      editor = double("Basic")
+      expect(Thor::LineEditor::Basic).to receive(:new).with("Enter your name ", :default => "Brian").and_return(editor)
+      expect(editor).to receive(:readline).and_return("George")
+      expect(Thor::LineEditor.readline("Enter your name ", :default => "Brian")).to eq("George")
+    end
+  end
+end

data/spec/parser/argument_spec.rb

@@ -1,35 +1,35 @@
-require 'helper'
-require 'thor/parser'
+require "helper"
+require "thor/parser"
 
 describe Thor::Argument do
 
-  def argument(name, options={})
+  def argument(name, options = {})
     @argument ||= Thor::Argument.new(name, options)
   end
 
   describe "errors" do
     it "raises an error if name is not supplied" do
-      expect {
+      expect do
         argument(nil)
-      }.to raise_error(ArgumentError, "Argument name can't be nil.")
+      end.to raise_error(ArgumentError, "Argument name can't be nil.")
     end
 
     it "raises an error if type is unknown" do
-      expect {
+      expect do
         argument(:command, :type => :unknown)
-      }.to raise_error(ArgumentError, "Type :unknown is not valid for arguments.")
+      end.to raise_error(ArgumentError, "Type :unknown is not valid for arguments.")
     end
 
-    it "raises an error if argument is required and have default values" do
-      expect {
+    it "raises an error if argument is required and has default values" do
+      expect do
         argument(:command, :type => :string, :default => "bar", :required => true)
-      }.to raise_error(ArgumentError, "An argument cannot be required and have default value.")
+      end.to raise_error(ArgumentError, "An argument cannot be required and have default value.")
     end
 
     it "raises an error if enum isn't an array" do
-      expect {
+      expect do
         argument(:command, :type => :string, :enum => "bar")
-      }.to raise_error(ArgumentError, "An argument cannot have an enum other than an array.")
+      end.to raise_error(ArgumentError, "An argument cannot have an enum other than an array.")
     end
   end
 

data/spec/parser/arguments_spec.rb

@@ -1,14 +1,14 @@
-require 'helper'
-require 'thor/parser'
+require "helper"
+require "thor/parser"
 
 describe Thor::Arguments do
-  def create(opts={})
+  def create(opts = {})
     arguments = opts.map do |type, default|
       options = {:required => default.nil?, :type => type, :default => default}
       Thor::Argument.new(type.to_s, options)
     end
 
-    arguments.sort!{ |a,b| b.name <=> a.name }
+    arguments.sort! { |a, b| b.name <=> a.name }
     @opt = Thor::Arguments.new(arguments)
   end
 
@@ -26,14 +26,14 @@ describe Thor::Arguments do
     it "accepts hashes" do
       create :string => nil, :hash => nil
       expect(parse("product", "title:string", "age:integer")["string"]).to eq("product")
-      expect(parse("product", "title:string", "age:integer")["hash"]).to eq({ "title" => "string", "age" => "integer"})
-      expect(parse("product", "url:http://www.amazon.com/gp/product/123")["hash"]).to eq({ "url" => "http://www.amazon.com/gp/product/123" })
+      expect(parse("product", "title:string", "age:integer")["hash"]).to eq("title" => "string", "age" => "integer")
+      expect(parse("product", "url:http://www.amazon.com/gp/product/123")["hash"]).to eq("url" => "http://www.amazon.com/gp/product/123")
     end
 
     it "accepts arrays" do
       create :string => nil, :array => nil
       expect(parse("product", "title", "age")["string"]).to eq("product")
-      expect(parse("product", "title", "age")["array"]).to eq(%w(title age))
+      expect(parse("product", "title", "age")["array"]).to eq(%w[title age])
     end
 
     describe "with no inputs" do
@@ -44,23 +44,23 @@ describe Thor::Arguments do
 
       it "and required arguments raises an error" do
         create :string => nil, :numeric => nil
-        expect{ parse }.to raise_error(Thor::RequiredArgumentMissingError, "No value provided for required arguments 'string', 'numeric'")
+        expect { parse }.to raise_error(Thor::RequiredArgumentMissingError, "No value provided for required arguments 'string', 'numeric'")
       end
 
       it "and default arguments returns default values" do
         create :string => "name", :numeric => 13
-        expect(parse).to eq({ "string" => "name", "numeric" => 13 })
+        expect(parse).to eq("string" => "name", "numeric" => 13)
       end
     end
 
     it "returns the input if it's already parsed" do
       create :string => nil, :hash => nil, :array => nil, :numeric => nil
-      expect(parse("", 0, {}, [])).to eq({ "string" => "", "numeric" => 0, "hash" => {}, "array" => [] })
+      expect(parse("", 0, {}, [])).to eq("string" => "", "numeric" => 0, "hash" => {}, "array" => [])
     end
 
     it "returns the default value if none is provided" do
       create :string => "foo", :numeric => 3.0
-      expect(parse("bar")).to eq({ "string" => "bar", "numeric" => 3.0 })
+      expect(parse("bar")).to eq("string" => "bar", "numeric" => 3.0)
     end
   end
 end

data/spec/parser/option_spec.rb

@@ -1,12 +1,12 @@
-require 'helper'
-require 'thor/parser'
+require "helper"
+require "thor/parser"
 
 describe Thor::Option do
   def parse(key, value)
     Thor::Option.parse(key, value)
   end
 
-  def option(name, options={})
+  def option(name, options = {})
     @option ||= Thor::Option.new(name, options)
   end
 
@@ -19,9 +19,9 @@ describe Thor::Option do
           expect(parse(:foo, :numeric).type).to eq(:numeric)
         end
 
-        it "has not default value" do
-          expect(parse(:foo, :string).default).to be_nil
-          expect(parse(:foo, :numeric).default).to be_nil
+        it "has no default value" do
+          expect(parse(:foo, :string).default).to be nil
+          expect(parse(:foo, :numeric).default).to be nil
         end
       end
 
@@ -31,17 +31,17 @@ describe Thor::Option do
         end
 
         it "has no default value" do
-          expect(parse(:foo, :required).default).to be_nil
+          expect(parse(:foo, :required).default).to be nil
         end
       end
 
       describe "and symbol is not a reserved key" do
-        it "has type equals to :string" do
+        it "has type equal to :string" do
           expect(parse(:foo, :bar).type).to eq(:string)
         end
 
         it "has no default value" do
-          expect(parse(:foo, :bar).default).to be_nil
+          expect(parse(:foo, :bar).default).to be nil
         end
       end
     end
@@ -51,8 +51,8 @@ describe Thor::Option do
         expect(parse(:foo, :a => :b).type).to eq(:hash)
       end
 
-      it "has default value equals to the hash" do
-        expect(parse(:foo, :a => :b).default).to eq({ :a => :b })
+      it "has default value equal to the hash" do
+        expect(parse(:foo, :a => :b).default).to eq(:a => :b)
       end
     end
 
@@ -61,7 +61,7 @@ describe Thor::Option do
         expect(parse(:foo, [:a, :b]).type).to eq(:array)
       end
 
-      it "has default value equals to the array" do
+      it "has default value equal to the array" do
         expect(parse(:foo, [:a, :b]).default).to eq([:a, :b])
       end
     end
@@ -71,7 +71,7 @@ describe Thor::Option do
         expect(parse(:foo, "bar").type).to eq(:string)
       end
 
-      it "has default value equals to the string" do
+      it "has default value equal to the string" do
         expect(parse(:foo, "bar").default).to eq("bar")
       end
     end
@@ -81,7 +81,7 @@ describe Thor::Option do
         expect(parse(:foo, 2.0).type).to eq(:numeric)
       end
 
-      it "has default value equals to the numeric" do
+      it "has default value equal to the numeric" do
         expect(parse(:foo, 2.0).default).to eq(2.0)
       end
     end
@@ -92,14 +92,14 @@ describe Thor::Option do
         expect(parse(:foo, false).type).to eq(:boolean)
       end
 
-      it "has default value equals to the boolean" do
+      it "has default value equal to the boolean" do
         expect(parse(:foo, true).default).to eq(true)
         expect(parse(:foo, false).default).to eq(false)
       end
     end
 
     describe "with key as a symbol" do
-      it "sets the name equals to the key" do
+      it "sets the name equal to the key" do
         expect(parse(:foo, true).name).to eq("foo")
       end
     end
@@ -135,10 +135,10 @@ describe Thor::Option do
     expect(option).to be_required
   end
 
-  it "cannot be required and have type boolean" do
-    expect {
+  it "boolean options cannot be required" do
+    expect do
       option("foo", :required => true, :type => :boolean)
-    }.to raise_error(ArgumentError, "An option cannot be boolean and required.")
+    end.to raise_error(ArgumentError, "An option cannot be boolean and required.")
   end
 
   it "allows type predicates" do
@@ -148,9 +148,9 @@ describe Thor::Option do
   end
 
   it "raises an error on method missing" do
-    expect {
+    expect do
       parse(:foo, :string).unknown?
-    }.to raise_error(NoMethodError)
+    end.to raise_error(NoMethodError)
   end
 
   describe "#usage" do
@@ -172,18 +172,22 @@ describe Thor::Option do
     end
 
     it "returns usage for boolean types" do
-      expect(parse(:foo, :boolean).usage).to eq("[--foo]")
+      expect(parse(:foo, :boolean).usage).to eq("[--foo], [--no-foo]")
+    end
+
+    it "does not use padding when no aliases are given" do
+      expect(parse(:foo, :boolean).usage).to eq("[--foo], [--no-foo]")
     end
 
-    it "uses padding when no aliases is given" do
-      expect(parse(:foo, :boolean).usage(4)).to eq("    [--foo]")
+    it "documents a negative option when boolean" do
+      expect(parse(:foo, :boolean).usage).to include("[--no-foo]")
     end
 
     it "uses banner when supplied" do
       expect(option(:foo, :required => false, :type => :string, :banner => "BAR").usage).to eq("[--foo=BAR]")
     end
 
-    it "checkes when banner is an empty string" do
+    it "checks when banner is an empty string" do
       expect(option(:foo, :required => false, :type => :string, :banner => "").usage).to eq("[--foo]")
     end
 
@@ -197,6 +201,10 @@ describe Thor::Option do
       it "does not show the usage between brackets" do
         expect(parse([:foo, "-f", "-b"], :required).usage).to eq("-f, -b, --foo=FOO")
       end
+
+      it "does not negate the aliases" do
+        expect(parse([:foo, "-f", "-b"], :boolean).usage).to eq("-f, -b, [--foo], [--no-foo]")
+      end
     end
   end
 end

data/spec/parser/options_spec.rb

@@ -1,8 +1,8 @@
-require 'helper'
-require 'thor/parser'
+require "helper"
+require "thor/parser"
 
 describe Thor::Options do
-  def create(opts, defaults={}, stop_on_unknown=false)
+  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
@@ -40,12 +40,12 @@ describe Thor::Options do
     end
 
     it "joins several values" do
-      switches = Thor::Options.to_switches(:color => true, :foo => "bar").split(' ').sort
-      expect(switches).to eq(['"bar"', "--color", "--foo"])
+      switches = Thor::Options.to_switches(:color => true, :foo => "bar").split(" ").sort
+      expect(switches).to eq(%w["bar" --color --foo])
     end
 
     it "accepts arrays" do
-      expect(Thor::Options.to_switches(:count => [1,2,3])).to eq("--count 1 2 3")
+      expect(Thor::Options.to_switches(:count => [1, 2, 3])).to eq("--count 1 2 3")
     end
 
     it "accepts hashes" do
@@ -60,7 +60,7 @@ describe Thor::Options do
 
   describe "#parse" do
     it "allows multiple aliases for a given switch" do
-      create ["--foo", "--bar", "--baz"] => :string
+      create %w[--foo --bar --baz] => :string
       expect(parse("--foo", "12")["foo"]).to eq("12")
       expect(parse("--bar", "12")["foo"]).to eq("12")
       expect(parse("--baz", "12")["foo"]).to eq("12")
@@ -68,27 +68,27 @@ describe Thor::Options do
 
     it "allows custom short names" do
       create "-f" => :string
-      expect(parse("-f", "12")).to eq({"f" => "12"})
+      expect(parse("-f", "12")).to eq("f" => "12")
     end
 
     it "allows custom short-name aliases" do
-      create ["--bar", "-f"] => :string
-      expect(parse("-f", "12")).to eq({"bar" => "12"})
+      create %w[--bar -f] => :string
+      expect(parse("-f", "12")).to eq("bar" => "12")
     end
 
     it "accepts conjoined short switches" do
-      create ["--foo", "-f"] => true, ["--bar", "-b"] => true, ["--app", "-a"] => true
+      create %w[--foo -f] => true, %w[--bar -b] => true, %w[--app -a] => true
       opts = parse("-fba")
-      expect(opts["foo"]).to be_true
-      expect(opts["bar"]).to be_true
-      expect(opts["app"]).to be_true
+      expect(opts["foo"]).to be true
+      expect(opts["bar"]).to be true
+      expect(opts["app"]).to be true
     end
 
     it "accepts conjoined short switches with input" do
-      create ["--foo", "-f"] => true, ["--bar", "-b"] => true, ["--app", "-a"] => :required
+      create %w[--foo -f] => true, %w[--bar -b] => true, %w[--app -a] => :required
       opts = parse "-fba", "12"
-      expect(opts["foo"]).to be_true
-      expect(opts["bar"]).to be_true
+      expect(opts["foo"]).to be true
+      expect(opts["bar"]).to be true
       expect(opts["app"]).to eq("12")
     end
 
@@ -110,18 +110,18 @@ describe Thor::Options do
     it "raises an error for unknown switches" do
       create :foo => "baz", :bar => :required
       parse("--bar", "baz", "--baz", "unknown")
-      expect{ check_unknown! }.to raise_error(Thor::UnknownArgumentError, "Unknown switches '--baz'")
+      expect { check_unknown! }.to raise_error(Thor::UnknownArgumentError, "Unknown switches '--baz'")
     end
 
     it "skips leading non-switches" do
       create(:foo => "baz")
 
-      expect(parse("asdf", "--foo", "bar")).to eq({"foo" => "bar"})
+      expect(parse("asdf", "--foo", "bar")).to eq("foo" => "bar")
     end
 
     it "correctly recognizes things that look kind of like options, but aren't, as not options" do
       create(:foo => "baz")
-      expect(parse("--asdf---asdf", "baz", "--foo", "--asdf---dsf--asdf")).to eq({"foo" => "--asdf---dsf--asdf"})
+      expect(parse("--asdf---asdf", "baz", "--foo", "--asdf---dsf--asdf")).to eq("foo" => "--asdf---dsf--asdf")
       check_unknown!
     end
 
@@ -139,31 +139,31 @@ describe Thor::Options do
 
     it "interprets everything after -- as args instead of options" do
       create(:foo => :string, :bar => :required)
-      expect(parse(%w[--bar abc moo -- --foo def -a])).to eq({"bar" => "abc"})
+      expect(parse(%w[--bar abc moo -- --foo def -a])).to eq("bar" => "abc")
       expect(remaining).to eq(%w[moo --foo def -a])
     end
 
     it "ignores -- when looking for single option values" do
       create(:foo => :string, :bar => :required)
-      expect(parse(%w[--bar -- --foo def -a])).to eq({"bar" => "--foo"})
+      expect(parse(%w[--bar -- --foo def -a])).to eq("bar" => "--foo")
       expect(remaining).to eq(%w[def -a])
     end
 
     it "ignores -- when looking for array option values" do
       create(:foo => :array)
-      expect(parse(%w[--foo a b -- c d -e])).to eq({"foo" => %w[a b c d -e]})
+      expect(parse(%w[--foo a b -- c d -e])).to eq("foo" => %w[a b c d -e])
       expect(remaining).to eq([])
     end
 
     it "ignores -- when looking for hash option values" do
       create(:foo => :hash)
-      expect(parse(%w[--foo a:b -- c:d -e])).to eq({"foo" => {'a' => 'b', 'c' => 'd'}})
+      expect(parse(%w[--foo a:b -- c:d -e])).to eq("foo" => {"a" => "b", "c" => "d"})
       expect(remaining).to eq(%w[-e])
     end
 
     it "ignores trailing --" do
       create(:foo => :string)
-      expect(parse(%w[--foo --])).to eq({"foo" => nil})
+      expect(parse(%w[--foo --])).to eq("foo" => nil)
       expect(remaining).to eq([])
     end
 
@@ -180,7 +180,7 @@ describe Thor::Options do
 
       it "and a required switch raises an error" do
         create "--foo" => :required
-        expect{ parse }.to raise_error(Thor::RequiredArgumentMissingError, "No value provided for required options '--foo'")
+        expect { parse }.to raise_error(Thor::RequiredArgumentMissingError, "No value provided for required options '--foo'")
       end
     end
 
@@ -190,21 +190,21 @@ describe Thor::Options do
       end
 
       it "raises an error if the required switch has no argument" do
-        expect{ parse("--foo") }.to raise_error(Thor::MalformattedArgumentError)
+        expect { parse("--foo") }.to raise_error(Thor::MalformattedArgumentError)
       end
 
       it "raises an error if the required switch isn't given" do
-        expect{ parse("--bar") }.to raise_error(Thor::RequiredArgumentMissingError)
+        expect { parse("--bar") }.to raise_error(Thor::RequiredArgumentMissingError)
       end
 
       it "raises an error if the required switch is set to nil" do
-        expect{ parse("--no-foo") }.to raise_error(Thor::RequiredArgumentMissingError)
+        expect { parse("--no-foo") }.to raise_error(Thor::RequiredArgumentMissingError)
       end
 
       it "does not raises an error if the required option has a default value" do
         options = {:required => true, :type => :string, :default => "baz"}
         create :foo => Thor::Option.new("foo", options), :bar => :boolean
-        expect{ parse("--bar") }.not_to raise_error
+        expect { parse("--bar") }.not_to raise_error
       end
     end
 
@@ -215,38 +215,38 @@ describe Thor::Options do
 
       it "stops parsing on first non-option" do
         expect(parse(%w[foo --verbose])).to eq({})
-        expect(remaining).to eq(["foo", "--verbose"])
+        expect(remaining).to eq(%w[foo --verbose])
       end
 
       it "stops parsing on unknown option" do
         expect(parse(%w[--bar --verbose])).to eq({})
-        expect(remaining).to eq(["--bar", "--verbose"])
+        expect(remaining).to eq(%w[--bar --verbose])
       end
 
       it "retains -- after it has stopped parsing" do
         expect(parse(%w[--bar -- whatever])).to eq({})
-        expect(remaining).to eq(["--bar", "--", "whatever"])
+        expect(remaining).to eq(%w[--bar -- whatever])
       end
 
       it "still accepts options that are given before non-options" do
-        expect(parse(%w[--verbose foo])).to eq({"verbose" => true})
-        expect(remaining).to eq(["foo"])
+        expect(parse(%w[--verbose foo])).to eq("verbose" => true)
+        expect(remaining).to eq(%w[foo])
       end
 
       it "still accepts options that require a value" do
-        expect(parse(%w[--foo bar baz])).to eq({"foo" => "bar"})
-        expect(remaining).to eq(["baz"])
+        expect(parse(%w[--foo bar baz])).to eq("foo" => "bar")
+        expect(remaining).to eq(%w[baz])
       end
 
       it "still interprets everything after -- as args instead of options" do
         expect(parse(%w[-- --verbose])).to eq({})
-        expect(remaining).to eq(["--verbose"])
+        expect(remaining).to eq(%w[--verbose])
       end
     end
 
     describe "with :string type" do
       before do
-        create ["--foo", "-f"] => :required
+        create %w[--foo -f] => :required
       end
 
       it "accepts a switch <value> assignment" do
@@ -266,12 +266,12 @@ describe Thor::Options do
 
       it "accepts a --no-switch format" do
         create "--foo" => "bar"
-        expect(parse("--no-foo")["foo"]).to be_nil
+        expect(parse("--no-foo")["foo"]).to be nil
       end
 
       it "does not consume an argument for --no-switch format" do
         create "--cheese" => :string
-        expect(parse('burger', '--no-cheese', 'fries')["cheese"]).to be_nil
+        expect(parse("burger", "--no-cheese", "fries")["cheese"]).to be nil
       end
 
       it "accepts a --switch format on non required types" do
@@ -288,6 +288,13 @@ describe Thor::Options do
         expect(parse("--foo=bar", "--foo", "12")["foo"]).to eq("12")
         expect(parse("--foo", "12", "--foo", "13")["foo"]).to eq("13")
       end
+
+      it "raises error when value isn't in enum" do
+        enum = %w[apple banana]
+        create :fruit => Thor::Option.new("fruit", :type => :string, :enum => enum)
+        expect { parse("--fruit", "orange") }.to raise_error(Thor::MalformattedArgumentError,
+                                                             "Expected '--fruit' to be one of #{enum.join(', ')}; got orange")
+      end
     end
 
     describe "with :boolean type" do
@@ -336,8 +343,8 @@ describe Thor::Options do
 
       it "doesn't eat the next part of the param" do
         create :foo => :boolean
-        expect(parse("--foo", "bar")).to eq({"foo" => true})
-        expect(@opt.remaining).to eq(["bar"])
+        expect(parse("--foo", "bar")).to eq("foo" => true)
+        expect(@opt.remaining).to eq(%w[bar])
       end
     end
 
@@ -347,15 +354,15 @@ describe Thor::Options do
       end
 
       it "accepts a switch=<value> assignment" do
-        expect(parse("--attributes=name:string", "age:integer")["attributes"]).to eq({"name" => "string", "age" => "integer"})
+        expect(parse("--attributes=name:string", "age:integer")["attributes"]).to eq("name" => "string", "age" => "integer")
       end
 
       it "accepts a switch <value> assignment" do
-        expect(parse("--attributes", "name:string", "age:integer")["attributes"]).to eq({"name" => "string", "age" => "integer"})
+        expect(parse("--attributes", "name:string", "age:integer")["attributes"]).to eq("name" => "string", "age" => "integer")
       end
 
       it "must not mix values with other switches" do
-        expect(parse("--attributes", "name:string", "age:integer", "--baz", "cool")["attributes"]).to eq({"name" => "string", "age" => "integer"})
+        expect(parse("--attributes", "name:string", "age:integer", "--baz", "cool")["attributes"]).to eq("name" => "string", "age" => "integer")
       end
     end
 
@@ -365,15 +372,15 @@ describe Thor::Options do
       end
 
       it "accepts a switch=<value> assignment" do
-        expect(parse("--attributes=a", "b", "c")["attributes"]).to eq(["a", "b", "c"])
+        expect(parse("--attributes=a", "b", "c")["attributes"]).to eq(%w[a b c])
       end
 
       it "accepts a switch <value> assignment" do
-        expect(parse("--attributes", "a", "b", "c")["attributes"]).to eq(["a", "b", "c"])
+        expect(parse("--attributes", "a", "b", "c")["attributes"]).to eq(%w[a b c])
       end
 
       it "must not mix values with other switches" do
-        expect(parse("--attributes", "a", "b", "c", "--baz", "cool")["attributes"]).to eq(["a", "b", "c"])
+        expect(parse("--attributes", "a", "b", "c", "--baz", "cool")["attributes"]).to eq(%w[a b c])
       end
     end
 
@@ -387,12 +394,19 @@ describe Thor::Options do
       end
 
       it "converts values to numeric types" do
-        expect(parse("-n", "3", "-m", ".5")).to eq({"n" => 3, "m" => 0.5})
+        expect(parse("-n", "3", "-m", ".5")).to eq("n" => 3, "m" => 0.5)
       end
 
       it "raises error when value isn't numeric" do
-        expect{ parse("-n", "foo") }.to raise_error(Thor::MalformattedArgumentError,
-          "Expected numeric value for '-n'; got \"foo\"")
+        expect { parse("-n", "foo") }.to raise_error(Thor::MalformattedArgumentError,
+                                                     "Expected numeric value for '-n'; got \"foo\"")
+      end
+
+      it "raises error when value isn't in enum" do
+        enum = [1, 2]
+        create :limit => Thor::Option.new("limit", :type => :numeric, :enum => enum)
+        expect { parse("--limit", "3") }.to raise_error(Thor::MalformattedArgumentError,
+                                                        "Expected '--limit' to be one of #{enum.join(', ')}; got 3")
       end
     end