thor 0.18.1 → 0.19.0

data/spec/command_spec.rb

@@ -1,7 +1,7 @@
-require 'helper'
+require "helper"
 
 describe Thor::Command do
-  def command(options={})
+  def command(options = {})
     options.each do |key, value|
       options[key] = Thor::Option.parse(key, value)
     end
@@ -34,16 +34,16 @@ describe Thor::Command do
 
   describe "#dynamic" do
     it "creates a dynamic command with the given name" do
-      expect(Thor::DynamicCommand.new('command').name).to eq('command')
-      expect(Thor::DynamicCommand.new('command').description).to eq('A dynamically-generated command')
-      expect(Thor::DynamicCommand.new('command').usage).to eq('command')
-      expect(Thor::DynamicCommand.new('command').options).to eq({})
+      expect(Thor::DynamicCommand.new("command").name).to eq("command")
+      expect(Thor::DynamicCommand.new("command").description).to eq("A dynamically-generated command")
+      expect(Thor::DynamicCommand.new("command").usage).to eq("command")
+      expect(Thor::DynamicCommand.new("command").options).to eq({})
     end
 
     it "does not invoke an existing method" do
-      mock = mock()
-      mock.class.should_receive(:handle_no_command_error).with("to_s")
-      Thor::DynamicCommand.new('to_s').run(mock)
+      dub = double
+      expect(dub.class).to receive(:handle_no_command_error).with("to_s")
+      Thor::DynamicCommand.new("to_s").run(dub)
     end
   end
 
@@ -57,9 +57,9 @@ describe Thor::Command do
 
   describe "#run" do
     it "runs a command by calling a method in the given instance" do
-      mock = mock()
-      mock.should_receive(:can_has).and_return {|*args| args }
-      expect(command.run(mock, [1, 2, 3])).to eq([1, 2, 3])
+      dub = double
+      expect(dub).to receive(:can_has).and_return { |*args| args }
+      expect(command.run(dub, [1, 2, 3])).to eq([1, 2, 3])
     end
 
     it "raises an error if the method to be invoked is private" do
@@ -67,11 +67,10 @@ describe Thor::Command do
         def self.handle_no_command_error(name)
           name
         end
-
-      private
         def can_has
           "fail"
         end
+        private :can_has
       end
 
       expect(command.run(klass.new)).to eq("can_has")

data/spec/core_ext/hash_with_indifferent_access_spec.rb

@@ -1,48 +1,48 @@
-require 'helper'
-require 'thor/core_ext/hash_with_indifferent_access'
+require "helper"
+require "thor/core_ext/hash_with_indifferent_access"
 
 describe Thor::CoreExt::HashWithIndifferentAccess do
   before do
-    @hash = Thor::CoreExt::HashWithIndifferentAccess.new :foo => 'bar', 'baz' => 'bee', :force => true
+    @hash = Thor::CoreExt::HashWithIndifferentAccess.new :foo => "bar", "baz" => "bee", :force => true
   end
 
   it "has values accessible by either strings or symbols" do
-    expect(@hash['foo']).to eq('bar')
-    expect(@hash[:foo]).to eq('bar')
+    expect(@hash["foo"]).to eq("bar")
+    expect(@hash[:foo]).to eq("bar")
 
-    expect(@hash.values_at(:foo, :baz)).to eq(['bar', 'bee'])
-    expect(@hash.delete(:foo)).to eq('bar')
+    expect(@hash.values_at(:foo, :baz)).to eq(%w[bar bee])
+    expect(@hash.delete(:foo)).to eq("bar")
   end
 
   it "handles magic boolean predicates" do
-    expect(@hash.force?).to be_true
-    expect(@hash.foo?).to be_true
-    expect(@hash.nothing?).to be_false
+    expect(@hash.force?).to be true
+    expect(@hash.foo?).to be true
+    expect(@hash.nothing?).to be false
   end
 
-  it "handles magic comparisions" do
-    expect(@hash.foo?('bar')).to be_true
-    expect(@hash.foo?('bee')).to be_false
+  it "handles magic comparisons" do
+    expect(@hash.foo?("bar")).to be true
+    expect(@hash.foo?("bee")).to be false
   end
 
   it "maps methods to keys" do
-    expect(@hash.foo).to eq(@hash['foo'])
+    expect(@hash.foo).to eq(@hash["foo"])
   end
 
   it "merges keys independent if they are symbols or strings" do
-    @hash.merge!('force' => false, :baz => "boom")
+    @hash.merge!("force" => false, :baz => "boom")
     expect(@hash[:force]).to eq(false)
-    expect(@hash[:baz]).to eq("boom")
+    expect(@hash["baz"]).to eq("boom")
   end
 
   it "creates a new hash by merging keys independent if they are symbols or strings" do
-    other = @hash.merge('force' => false, :baz => "boom")
+    other = @hash.merge("force" => false, :baz => "boom")
     expect(other[:force]).to eq(false)
-    expect(other[:baz]).to eq("boom")
+    expect(other["baz"]).to eq("boom")
   end
 
   it "converts to a traditional hash" do
     expect(@hash.to_hash.class).to eq(Hash)
-    expect(@hash).to eq({ 'foo' => 'bar', 'baz' => 'bee', 'force' => true })
+    expect(@hash).to eq("foo" => "bar", "baz" => "bee", "force" => true)
   end
 end

data/spec/core_ext/ordered_hash_spec.rb

@@ -1,5 +1,5 @@
-require 'helper'
-require 'thor/core_ext/ordered_hash'
+require "helper"
+require "thor/core_ext/ordered_hash"
 
 describe Thor::CoreExt::OrderedHash do
   before do
@@ -8,7 +8,7 @@ describe Thor::CoreExt::OrderedHash do
 
   describe "without any items" do
     it "returns nil for an undefined key" do
-      expect(@hash["foo"]).to be_nil
+      expect(@hash["foo"]).to be nil
     end
 
     it "doesn't iterate through any items" do
@@ -35,7 +35,7 @@ describe Thor::CoreExt::OrderedHash do
     end
 
     it "returns nil for an undefined key" do
-      expect(@hash[:boom]).to be_nil
+      expect(@hash[:boom]).to be nil
     end
 
     it "returns the value for each key" do
@@ -52,7 +52,7 @@ describe Thor::CoreExt::OrderedHash do
         arr << [key, value]
       end
       expect(arr).to eq([[:foo, "Foo!"], [:bar, "Bar!"], [:baz, "Baz!"],
-                     [:bop, "Bop!"], [:bat, "Bat!"]])
+                         [:bop, "Bop!"], [:bat, "Bat!"]])
     end
 
     it "returns the keys in order of insertion" do
@@ -109,7 +109,7 @@ describe Thor::CoreExt::OrderedHash do
     end
 
     it "returns nil if the value to be deleted can't be found" do
-      expect(@hash.delete(:nothing)).to be_nil
+      expect(@hash.delete(:nothing)).to be nil
     end
   end
 end

data/spec/exit_condition_spec.rb

@@ -1,5 +1,5 @@
-require 'helper'
-require 'thor/base'
+require "helper"
+require "thor/base"
 
 describe "Exit conditions" do
   it "exits 0, not bubble up EPIPE, if EPIPE is raised" do
@@ -9,11 +9,11 @@ describe "Exit conditions" do
       desc "my_action", "testing EPIPE"
       define_method :my_action do
         epiped = true
-        raise Errno::EPIPE
+        fail Errno::EPIPE
       end
     end
 
-    expect{ command.start(["my_action"]) }.to raise_error(SystemExit)
+    expect { command.start(["my_action"]) }.to raise_error(SystemExit)
     expect(epiped).to eq(true)
   end
 end

data/spec/fixtures/invoke.thor

@@ -53,6 +53,12 @@ class B < Thor
   def three
     self
   end
+
+  desc "four", "invoke four"
+  option :defaulted_value, :type => :string, :default => 'default'
+  def four
+    options.defaulted_value
+  end
 end
 
 class C < Thor::Group
@@ -110,3 +116,16 @@ class H < Thor::Group
   class_option :defined, :type => :boolean, :default => true
   invoke_from_option :defined
 end
+
+class I < Thor
+  desc "two", "Two"
+  def two
+    current_command_chain
+  end
+end
+
+class J < Thor
+  desc "i", "I"
+  subcommand :one, I
+end
+

data/spec/fixtures/script.thor

@@ -88,7 +88,7 @@ END
   method_option :lazy_hash,    :type => :hash,    :lazy_default => {'swedish' => 'meatballs'}
   desc "with_optional NAME", "invoke with optional name"
   def with_optional(name=nil, *args)
-    [ name, options, args ]
+    [name, options, args]
   end
 
   class AnotherScript < Thor

data/spec/group_spec.rb

@@ -1,43 +1,43 @@
-require 'helper'
+require "helper"
 
 describe Thor::Group do
   describe "command" do
     it "allows to use private methods from parent class as commands" do
-      expect(ChildGroup.start).to eq(["bar", "foo", "baz"])
+      expect(ChildGroup.start).to eq(%w[bar foo baz])
       expect(ChildGroup.new.baz("bar")).to eq("bar")
     end
   end
 
   describe "#start" do
     it "invokes all the commands under the Thor group" do
-      expect(MyCounter.start(["1", "2", "--third", "3"])).to eq([ 1, 2, 3, nil, nil, nil ])
+      expect(MyCounter.start(%w[1 2 --third 3])).to eq([1, 2, 3, nil, nil, nil])
     end
 
-    it "uses argument default value" do
-      expect(MyCounter.start(["1", "--third", "3"])).to eq([ 1, 2, 3, nil, nil, nil ])
+    it "uses argument's default value" do
+      expect(MyCounter.start(%w[1 --third 3])).to eq([1, 2, 3, nil, nil, nil])
     end
 
     it "invokes all the commands in the Thor group and its parents" do
-      expect(BrokenCounter.start(["1", "2", "--third", "3"])).to eq([ nil, 2, 3, false, 5, nil ])
+      expect(BrokenCounter.start(%w[1 2 --third 3])).to eq([nil, 2, 3, false, 5, nil])
     end
 
     it "raises an error if a required argument is added after a non-required" do
-      expect {
+      expect do
         MyCounter.argument(:foo, :type => :string)
-      }.to raise_error(ArgumentError, 'You cannot have "foo" as required argument after the non-required argument "second".')
+      end.to raise_error(ArgumentError, 'You cannot have "foo" as required argument after the non-required argument "second".')
     end
 
     it "raises when an exception happens within the command call" do
-      expect{ BrokenCounter.start(["1", "2", "--fail"]) }.to raise_error
+      expect { BrokenCounter.start(%w[1 2 --fail]) }.to raise_error
     end
 
     it "raises an error when a Thor group command expects arguments" do
-      expect{ WhinyGenerator.start }.to raise_error(ArgumentError, /thor wrong_arity takes 1 argument, but it should not/)
+      expect { WhinyGenerator.start }.to raise_error(ArgumentError, /thor wrong_arity takes 1 argument, but it should not/)
     end
 
-    it "invokes help message if any of the shortcuts is given" do
-      MyCounter.should_receive(:help)
-      MyCounter.start(["-h"])
+    it "invokes help message if any of the shortcuts are given" do
+      expect(MyCounter).to receive(:help)
+      MyCounter.start(%w[-h])
     end
   end
 
@@ -51,7 +51,7 @@ describe Thor::Group do
     end
 
     it "can be nil" do
-      expect(WhinyGenerator.desc).to be_nil
+      expect(WhinyGenerator.desc).to be nil
     end
   end
 
@@ -117,17 +117,23 @@ describe Thor::Group do
       end
 
       it "does not invoke if the option is nil" do
-        expect(capture(:stdout) { G.start(["--skip-invoked"]) }).not_to match(/invoke/)
+        expect(capture(:stdout) { G.start(%w[--skip-invoked]) }).not_to match(/invoke/)
       end
 
       it "prints a message if invocation cannot be found" do
-        content = capture(:stdout) { G.start(["--invoked", "unknown"]) }
+        content = capture(:stdout) { G.start(%w[--invoked unknown]) }
         expect(content).to match(/error  unknown \[not found\]/)
       end
 
       it "allows to invoke a class from the class binding by the given option" do
-        content = capture(:stdout) { G.start(["--invoked", "e"]) }
+        error = nil
+        content = capture(:stdout) do
+          error = capture(:stderr) do
+            G.start(%w[--invoked e])
+          end
+        end
         expect(content).to match(/invoke  e/)
+        expect(error).to match(/ERROR: "thor two" was called with arguments/)
       end
 
       it "shows invocation information to the user" do
@@ -156,7 +162,7 @@ describe Thor::Group do
       end
 
       it "does not invoke if the option is false" do
-        expect(capture(:stdout) { H.start(["--no-defined"]) }).not_to match(/invoke/)
+        expect(capture(:stdout) { H.start(%w[--no-defined]) }).not_to match(/invoke/)
       end
 
       it "shows invocation information to the user" do
@@ -189,9 +195,9 @@ describe Thor::Group do
         end
       end
 
-      expect(klass.start(["jose"])).to eq(["Hi jose"])
-      expect(klass.start(["jose", "--loud"])).to eq(["Hi JOSE"])
-      expect(klass.start(["--loud", "jose"])).to eq(["Hi JOSE"])
+      expect(klass.start(%w[jose])).to eq(["Hi jose"])
+      expect(klass.start(%w[jose --loud])).to eq(["Hi JOSE"])
+      expect(klass.start(%w[--loud jose])).to eq(["Hi JOSE"])
     end
 
     it "provides extra args as `args`" do
@@ -208,9 +214,9 @@ describe Thor::Group do
         end
       end
 
-      expect(klass.start(["jose"])).to eq(["Hi jose"])
-      expect(klass.start(["jose", "--loud"])).to eq(["Hi JOSE"])
-      expect(klass.start(["--loud", "jose"])).to eq(["Hi JOSE"])
+      expect(klass.start(%w[jose])).to eq(["Hi jose"])
+      expect(klass.start(%w[jose --loud])).to eq(["Hi JOSE"])
+      expect(klass.start(%w[--loud jose])).to eq(["Hi JOSE"])
     end
   end
 end

data/spec/helper.rb

@@ -1,23 +1,27 @@
-$TESTING=true
+$TESTING = true
 
-require 'simplecov'
-require 'coveralls'
+require "simplecov"
+require "coveralls"
 
 SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
   SimpleCov::Formatter::HTMLFormatter,
   Coveralls::SimpleCov::Formatter
 ]
-SimpleCov.start
 
-$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
-require 'thor'
-require 'thor/group'
-require 'stringio'
+SimpleCov.start do
+  add_filter "/spec/"
+  minimum_coverage(92.21)
+end
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+require "thor"
+require "thor/group"
+require "stringio"
 
-require 'rdoc'
-require 'rspec'
-require 'diff/lcs' # You need diff/lcs installed to run specs (but not to run Thor).
-require 'fakeweb'  # You need fakeweb installed to run specs (but not to run Thor).
+require "rdoc"
+require "rspec"
+require "diff/lcs" # You need diff/lcs installed to run specs (but not to run Thor).
+require "fakeweb"  # You need fakeweb installed to run specs (but not to run Thor).
 
 # Set shell to basic
 $0 = "thor"
@@ -56,12 +60,21 @@ RSpec.configure do |config|
   end
 
   def source_root
-    File.join(File.dirname(__FILE__), 'fixtures')
+    File.join(File.dirname(__FILE__), "fixtures")
   end
 
   def destination_root
-    File.join(File.dirname(__FILE__), 'sandbox')
+    File.join(File.dirname(__FILE__), "sandbox")
+  end
+
+  # This code was adapted from Ruby on Rails, available under MIT-LICENSE
+  # Copyright (c) 2004-2013 David Heinemeier Hansson
+  def silence_warnings
+    old_verbose, $VERBOSE = $VERBOSE, nil
+    yield
+  ensure
+    $VERBOSE = old_verbose
   end
 
-  alias :silence :capture
+  alias silence capture
 end

data/spec/invocation_spec.rb

@@ -1,5 +1,5 @@
-require 'helper'
-require 'thor/base'
+require "helper"
+require "thor/base"
 
 describe Thor::Invocation do
   describe "#invoke" do
@@ -16,8 +16,8 @@ describe Thor::Invocation do
     end
 
     it "invokes a command with arguments" do
-      expect(A.new.invoke(:five, [5])).to be_true
-      expect(A.new.invoke(:five, [7])).to be_false
+      expect(A.new.invoke(:five, [5])).to be true
+      expect(A.new.invoke(:five, [7])).to be false
     end
 
     it "invokes the default command if none is given to a Thor class" do
@@ -34,20 +34,40 @@ describe Thor::Invocation do
 
     it "accepts a class as argument with a command to invoke" do
       base = A.new([], :last_name => "Valim")
-      expect(base.invoke(B, :one, ["Jose"])).to eq("Valim, Jose")
+      expect(base.invoke(B, :one, %w[Jose])).to eq("Valim, Jose")
     end
 
     it "allows customized options to be given" do
       base = A.new([], :last_name => "Wrong")
-      expect(base.invoke(B, :one, ["Jose"], :last_name => "Valim")).to eq("Valim, Jose")
+      expect(base.invoke(B, :one, %w[Jose], :last_name => "Valim")).to eq("Valim, Jose")
     end
 
     it "reparses options in the new class" do
-      expect(A.start(["invoker", "--last-name", "Valim"])).to eq("Valim, Jose")
+      expect(A.start(%w[invoker --last-name Valim])).to eq("Valim, Jose")
     end
 
     it "shares initialize options with invoked class" do
-      expect(A.new([], :foo => :bar).invoke("b:two")).to eq({ "foo" => :bar })
+      expect(A.new([], :foo => :bar).invoke("b:two")).to eq("foo" => :bar)
+    end
+
+    it "uses default options from invoked class if no matching arguments are given" do
+      expect(A.new([]).invoke("b:four")).to eq("default")
+    end
+
+    it "overrides default options if options are passed to the invoker" do
+      expect(A.new([], :defaulted_value => "not default").invoke("b:four")).to eq("not default")
+    end
+
+    it "returns the command chain" do
+      expect(I.new.invoke("two")).to eq([:two])
+
+      if RUBY_VERSION < "1.9.3"
+        result = J.start(["one", "two" ])
+        expect(result).to include(:one)
+        expect(result).to include(:two)
+      else
+        expect(J.start(["one", "two" ])).to eq([:one, :two])
+      end
     end
 
     it "dump configuration values to be used in the invoked class" do
@@ -66,35 +86,35 @@ describe Thor::Invocation do
 
     it "does not invoke a Thor::Group twice" do
       base = A.new
-      silence(:stdout){ base.invoke(:c) }
+      silence(:stdout) { base.invoke(:c) }
       expect(capture(:stdout) { base.invoke(:c) }).to be_empty
     end
 
     it "does not invoke any of Thor::Group commands twice" do
       base = A.new
-      silence(:stdout){ base.invoke(:c) }
+      silence(:stdout) { base.invoke(:c) }
       expect(capture(:stdout) { base.invoke("c:one") }).to be_empty
     end
 
-    it "raises Thor::UndefinedcommandError if the command can't be found" do
-      expect {
+    it "raises Thor::UndefinedCommandError if the command can't be found" do
+      expect do
         A.new.invoke("foo:bar")
-      }.to raise_error(Thor::UndefinedCommandError)
+      end.to raise_error(Thor::UndefinedCommandError)
     end
 
-    it "raises Thor::UndefinedcommandError if the command can't be found even if all commands were already executed" do
+    it "raises Thor::UndefinedCommandError if the command can't be found even if all commands were already executed" do
       base = C.new
-      silence(:stdout){ base.invoke_all }
+      silence(:stdout) { base.invoke_all }
 
-      expect {
+      expect do
         base.invoke("foo:bar")
-      }.to raise_error(Thor::UndefinedCommandError)
+      end.to raise_error(Thor::UndefinedCommandError)
     end
 
     it "raises an error if a non Thor class is given" do
-      expect {
+      expect do
         A.new.invoke(Object)
-      }.to raise_error(RuntimeError, "Expected Thor class, got Object")
+      end.to raise_error(RuntimeError, "Expected Thor class, got Object")
     end
   end
 end