thor 0.18.1 → 0.19.0

data/spec/actions/inject_into_file_spec.rb

@@ -1,5 +1,5 @@
-require 'helper'
-require 'thor/actions'
+require "helper"
+require "thor/actions"
 
 describe Thor::Actions::InjectIntoFile do
   before do
@@ -7,12 +7,12 @@ describe Thor::Actions::InjectIntoFile do
     ::FileUtils.cp_r(source_root, destination_root)
   end
 
-  def invoker(options={})
-    @invoker ||= MyCounter.new([1,2], options, { :destination_root => destination_root })
+  def invoker(options = {})
+    @invoker ||= MyCounter.new([1, 2], options, :destination_root => destination_root)
   end
 
   def revoker
-    @revoker ||= MyCounter.new([1,2], {}, { :destination_root => destination_root, :behavior => :revoke })
+    @revoker ||= MyCounter.new([1, 2], {}, :destination_root => destination_root, :behavior => :revoke)
   end
 
   def invoke!(*args, &block)
@@ -56,7 +56,7 @@ describe Thor::Actions::InjectIntoFile do
       expect(File.read(file)).to eq("__start__\nREADME\n__end__\n")
     end
 
-    it "does not change the file if already include content" do
+    it "does not change the file if already includes content" do
       invoke! "doc/README", :before => "__end__" do
         "more content\n"
       end
@@ -70,7 +70,7 @@ describe Thor::Actions::InjectIntoFile do
       expect(File.read(file)).to eq("__start__\nREADME\nmore content\n__end__\n")
     end
 
-    it "does change the file if already include content and :force == true" do
+    it "does change the file if already includes content and :force is true" do
       invoke! "doc/README", :before => "__end__" do
         "more content\n"
       end
@@ -87,40 +87,40 @@ describe Thor::Actions::InjectIntoFile do
   end
 
   describe "#revoke!" do
-    it "substracts the destination file after injection" do
+    it "subtracts the destination file after injection" do
       invoke! "doc/README", "\nmore content", :after => "__start__"
       revoke! "doc/README", "\nmore content", :after => "__start__"
       expect(File.read(file)).to eq("__start__\nREADME\n__end__\n")
     end
 
-    it "substracts the destination file before injection" do
+    it "subtracts the destination file before injection" do
       invoke! "doc/README", "more content\n", :before => "__start__"
       revoke! "doc/README", "more content\n", :before => "__start__"
       expect(File.read(file)).to eq("__start__\nREADME\n__end__\n")
     end
 
-    it "substracts even with double after injection" do
+    it "subtracts even with double after injection" do
       invoke! "doc/README", "\nmore content", :after => "__start__"
       invoke! "doc/README", "\nanother stuff", :after => "__start__"
       revoke! "doc/README", "\nmore content", :after => "__start__"
       expect(File.read(file)).to eq("__start__\nanother stuff\nREADME\n__end__\n")
     end
 
-    it "substracts even with double before injection" do
+    it "subtracts even with double before injection" do
       invoke! "doc/README", "more content\n", :before => "__start__"
       invoke! "doc/README", "another stuff\n", :before => "__start__"
       revoke! "doc/README", "more content\n", :before => "__start__"
       expect(File.read(file)).to eq("another stuff\n__start__\nREADME\n__end__\n")
     end
 
-    it "substracts when prepending" do
+    it "subtracts when prepending" do
       invoke! "doc/README", "more content\n", :after => /\A/
       invoke! "doc/README", "another stuff\n", :after => /\A/
       revoke! "doc/README", "more content\n", :after => /\A/
       expect(File.read(file)).to eq("another stuff\n__start__\nREADME\n__end__\n")
     end
 
-    it "substracts when appending" do
+    it "subtracts when appending" do
       invoke! "doc/README", "more content\n", :before => /\z/
       invoke! "doc/README", "another stuff\n", :before => /\z/
       revoke! "doc/README", "more content\n", :before => /\z/

data/spec/actions_spec.rb

@@ -1,8 +1,8 @@
-require 'helper'
+require "helper"
 
 describe Thor::Actions do
-  def runner(options={})
-    @runner ||= MyCounter.new([1], options, { :destination_root => destination_root })
+  def runner(options = {})
+    @runner ||= MyCounter.new([1], options, :destination_root => destination_root)
   end
 
   def action(*args, &block)
@@ -32,17 +32,17 @@ describe Thor::Actions do
     end
 
     it "when behavior is set to force, overwrite options" do
-      runner = MyCounter.new([1], { :force => false, :skip => true }, :behavior => :force)
+      runner = MyCounter.new([1], {:force => false, :skip => true}, :behavior => :force)
       expect(runner.behavior).to eq(:invoke)
-      expect(runner.options.force).to be_true
-      expect(runner.options.skip).not_to be_true
+      expect(runner.options.force).to be true
+      expect(runner.options.skip).not_to be true
     end
 
     it "when behavior is set to skip, overwrite options" do
-      runner = MyCounter.new([1], ["--force"], :behavior => :skip)
+      runner = MyCounter.new([1], %w[--force], :behavior => :skip)
       expect(runner.behavior).to eq(:invoke)
-      expect(runner.options.force).not_to be_true
-      expect(runner.options.skip).to be_true
+      expect(runner.options.force).not_to be true
+      expect(runner.options.skip).to be true
     end
   end
 
@@ -83,11 +83,11 @@ describe Thor::Actions do
       end
 
       it "creates proper relative paths for absolute file location" do
-        expect(runner.relative_to_original_destination_root('/test/file')).to eq("/test/file")
+        expect(runner.relative_to_original_destination_root("/test/file")).to eq("/test/file")
       end
 
-      it "does not fail with files constaining regexp characters" do
-        runner = MyCounter.new([1], {}, { :destination_root => File.join(destination_root, "fo[o-b]ar") })
+      it "does not fail with files containing regexp characters" do
+        runner = MyCounter.new([1], {}, :destination_root => File.join(destination_root, "fo[o-b]ar"))
         expect(runner.relative_to_original_destination_root("bar")).to eq("bar")
       end
 
@@ -114,14 +114,14 @@ describe Thor::Actions do
 
     describe "#find_in_source_paths" do
       it "raises an error if source path is empty" do
-        expect {
+        expect do
           A.new.find_in_source_paths("foo")
-        }.to raise_error(Thor::Error, /Currently you have no source paths/)
+        end.to raise_error(Thor::Error, /Currently you have no source paths/)
       end
 
       it "finds a template inside the source path" do
         expect(runner.find_in_source_paths("doc")).to eq(File.expand_path("doc", source_root))
-        expect{ runner.find_in_source_paths("README") }.to raise_error
+        expect { runner.find_in_source_paths("README") }.to raise_error
 
         new_path = File.join(source_root, "doc")
         runner.instance_variable_set(:@source_paths, nil)
@@ -146,37 +146,37 @@ describe Thor::Actions do
 
     it "creates the directory if it does not exist" do
       runner.inside("foo") do
-        expect(File.exists?(file)).to be_true
+        expect(File.exist?(file)).to be true
       end
     end
 
     describe "when pretending" do
       it "no directories should be created" do
         runner.inside("bar", :pretend => true) {}
-        expect(File.exists?("bar")).to be_false
+        expect(File.exist?("bar")).to be false
       end
     end
 
     describe "when verbose" do
       it "logs status" do
-        expect(capture(:stdout) {
+        expect(capture(:stdout) do
           runner.inside("foo", :verbose => true) {}
-        }).to match(/inside  foo/)
+        end).to match(/inside  foo/)
       end
 
       it "uses padding in next status" do
-        expect(capture(:stdout) {
+        expect(capture(:stdout) do
           runner.inside("foo", :verbose => true) do
             runner.say_status :cool, :padding
           end
-        }).to match(/cool    padding/)
+        end).to match(/cool    padding/)
       end
 
       it "removes padding after block" do
-        expect(capture(:stdout) {
+        expect(capture(:stdout) do
           runner.inside("foo", :verbose => true) {}
           runner.say_status :no, :padding
-        }).to match(/no  padding/)
+        end).to match(/no  padding/)
       end
     end
   end
@@ -196,7 +196,7 @@ describe Thor::Actions do
 
     it "returns to the previous state" do
       runner.inside("foo") do
-        runner.in_root { }
+        runner.in_root {}
         expect(runner.destination_root).to eq(file)
       end
     end
@@ -208,27 +208,27 @@ describe Thor::Actions do
         @foo = "FOO"
         say_status :cool, :padding
       TEMPLATE
-      @template.stub(:read).and_return(@template)
+      allow(@template).to receive(:read).and_return(@template)
 
-      @file = '/'
-      runner.stub(:open).and_return(@template)
+      @file = "/"
+      allow(runner).to receive(:open).and_return(@template)
     end
 
     it "accepts a URL as the path" do
       @file = "http://gist.github.com/103208.txt"
-      runner.should_receive(:open).with(@file, "Accept" => "application/x-thor-template").and_return(@template)
+      expect(runner).to receive(:open).with(@file, "Accept" => "application/x-thor-template").and_return(@template)
       action(:apply, @file)
     end
 
     it "accepts a secure URL as the path" do
       @file = "https://gist.github.com/103208.txt"
-      runner.should_receive(:open).with(@file, "Accept" => "application/x-thor-template").and_return(@template)
+      expect(runner).to receive(:open).with(@file, "Accept" => "application/x-thor-template").and_return(@template)
       action(:apply, @file)
     end
 
     it "accepts a local file path with spaces" do
       @file = File.expand_path("fixtures/path with spaces", File.dirname(__FILE__))
-      runner.should_receive(:open).with(@file).and_return(@template)
+      expect(runner).to receive(:open).with(@file).and_return(@template)
       action(:apply, @file)
     end
 
@@ -254,7 +254,7 @@ describe Thor::Actions do
 
   describe "#run" do
     before do
-      runner.should_receive(:system).with("ls")
+      expect(runner).to receive(:system).with("ls")
     end
 
     it "executes the command given" do
@@ -270,15 +270,15 @@ describe Thor::Actions do
     end
 
     it "accepts a color as status" do
-      runner.shell.should_receive(:say_status).with(:run, 'ls from "."', :yellow)
+      expect(runner.shell).to receive(:say_status).with(:run, 'ls from "."', :yellow)
       action :run, "ls", :verbose => :yellow
     end
   end
 
   describe "#run_ruby_script" do
     before do
-      Thor::Util.stub!(:ruby_command).and_return("/opt/jruby")
-      runner.should_receive(:system).with("/opt/jruby script.rb")
+      allow(Thor::Util).to receive(:ruby_command).and_return("/opt/jruby")
+      expect(runner).to receive(:system).with("/opt/jruby script.rb")
     end
 
     it "executes the ruby script" do
@@ -296,35 +296,35 @@ describe Thor::Actions do
 
   describe "#thor" do
     it "executes the thor command" do
-      runner.should_receive(:system).with("thor list")
+      expect(runner).to receive(:system).with("thor list")
       action :thor, :list, :verbose => true
     end
 
     it "converts extra arguments to command arguments" do
-      runner.should_receive(:system).with("thor list foo bar")
+      expect(runner).to receive(:system).with("thor list foo bar")
       action :thor, :list, "foo", "bar"
     end
 
     it "converts options hash to switches" do
-      runner.should_receive(:system).with("thor list foo bar --foo")
+      expect(runner).to receive(:system).with("thor list foo bar --foo")
       action :thor, :list, "foo", "bar", :foo => true
 
-      runner.should_receive(:system).with("thor list --foo 1 2 3")
-      action :thor, :list, :foo => [1,2,3]
+      expect(runner).to receive(:system).with("thor list --foo 1 2 3")
+      action :thor, :list, :foo => [1, 2, 3]
     end
 
     it "logs status" do
-      runner.should_receive(:system).with("thor list")
+      expect(runner).to receive(:system).with("thor list")
       expect(action(:thor, :list)).to eq("         run  thor list from \".\"\n")
     end
 
     it "does not log status if required" do
-      runner.should_receive(:system).with("thor list --foo 1 2 3")
-      expect(action(:thor, :list, :foo => [1,2,3], :verbose => false)).to be_empty
+      expect(runner).to receive(:system).with("thor list --foo 1 2 3")
+      expect(action(:thor, :list, :foo => [1, 2, 3], :verbose => false)).to be_empty
     end
 
     it "captures the output when :capture is given" do
-      runner.should_receive(:`).with("thor foo bar")
+      expect(runner).to receive(:`).with("thor foo bar")
       action(:thor, "foo", "bar", :capture => true)
     end
   end

data/spec/base_spec.rb

@@ -1,5 +1,5 @@
-require 'helper'
-require 'thor/base'
+require "helper"
+require "thor/base"
 
 class Amazing
   desc "hello", "say hello"
@@ -36,7 +36,7 @@ describe Thor::Base do
 
     it "creates options with indifferent access" do
       base = MyCounter.new [1, 2], :third => 3
-      expect(base.options['third']).to eq(3)
+      expect(base.options["third"]).to eq(3)
     end
 
     it "creates options with magic predicates" do
@@ -54,39 +54,39 @@ describe Thor::Base do
 
   describe "#argument" do
     it "sets a value as required and creates an accessor for it" do
-      expect(MyCounter.start(["1", "2", "--third", "3"])[0]).to eq(1)
-      expect(Scripts::MyScript.start(["zoo", "my_special_param", "--param=normal_param"])).to eq("my_special_param")
+      expect(MyCounter.start(%w[1 2 --third 3])[0]).to eq(1)
+      expect(Scripts::MyScript.start(%w[zoo my_special_param --param=normal_param])).to eq("my_special_param")
     end
 
     it "does not set a value in the options hash" do
-      expect(BrokenCounter.start(["1", "2", "--third", "3"])[0]).to be_nil
+      expect(BrokenCounter.start(%w[1 2 --third 3])[0]).to be nil
     end
   end
 
   describe "#arguments" do
     it "returns the arguments for the class" do
-      expect(MyCounter.arguments).to have(2).items
+      expect(MyCounter.arguments.size).to be(2)
     end
   end
 
   describe ":aliases" do
     it "supports string aliases without a dash prefix" do
-      expect(MyCounter.start(["1", "2", "-z", "3"])[4]).to eq(3)
+      expect(MyCounter.start(%w[1 2 -z 3])[4]).to eq(3)
     end
 
     it "supports symbol aliases" do
-      expect(MyCounter.start(["1", "2", "-y", "3"])[5]).to eq(3)
-      expect(MyCounter.start(["1", "2", "-r", "3"])[5]).to eq(3)
+      expect(MyCounter.start(%w[1 2 -y 3])[5]).to eq(3)
+      expect(MyCounter.start(%w[1 2 -r 3])[5]).to eq(3)
     end
   end
 
   describe "#class_option" do
     it "sets options class wise" do
-      expect(MyCounter.start(["1", "2", "--third", "3"])[2]).to eq(3)
+      expect(MyCounter.start(%w[1 2 --third 3])[2]).to eq(3)
     end
 
     it "does not create an accessor for it" do
-      expect(BrokenCounter.start(["1", "2", "--third", "3"])[3]).to be_false
+      expect(BrokenCounter.start(%w[1 2 --third 3])[3]).to be false
     end
   end
 
@@ -98,7 +98,7 @@ describe Thor::Base do
   end
 
   describe "#remove_argument" do
-    it "removes previous defined arguments from class" do
+    it "removes previously defined arguments from class" do
       expect(ClearCounter.arguments).to be_empty
     end
 
@@ -110,7 +110,7 @@ describe Thor::Base do
 
   describe "#remove_class_option" do
     it "removes previous defined class option" do
-      expect(ClearCounter.class_options[:third]).to be_nil
+      expect(ClearCounter.class_options[:third]).to be nil
     end
   end
 
@@ -119,7 +119,7 @@ describe Thor::Base do
       @content = capture(:stdout) { MyCounter.help(Thor::Base.shell.new) }
     end
 
-    it "shows options description" do
+    it "shows option's description" do
       expect(@content).to match(/# The third argument/)
     end
 
@@ -127,7 +127,7 @@ describe Thor::Base do
       expect(@content).to match(/\[\-\-third=THREE\]/)
     end
 
-    it "shows default values below description" do
+    it "shows default values below descriptions" do
       expect(@content).to match(/# Default: 3/)
     end
 
@@ -137,13 +137,13 @@ describe Thor::Base do
       expect(@content).to match(/\-p, \[\-\-pretend\]/)
     end
 
-    it "use padding in options that does not have aliases" do
+    it "use padding in options that do not have aliases" do
       expect(@content).to match(/^  -t, \[--third/)
       expect(@content).to match(/^          \[--fourth/)
     end
 
     it "allows extra options to be given" do
-      hash = { "Foo" => B.class_options.values }
+      hash = {"Foo" => B.class_options.values}
 
       content = capture(:stdout) { MyCounter.send(:class_options_help, Thor::Base.shell.new, hash) }
       expect(content).to match(/Foo options\:/)
@@ -212,10 +212,10 @@ describe Thor::Base do
     end
 
     it "raises an error if a command with reserved word is defined" do
-      expect {
+      expect do
         klass = Class.new(Thor::Group)
         klass.class_eval "def shell; end"
-      }.to raise_error(RuntimeError, /"shell" is a Thor reserved word and cannot be defined as command/)
+      end.to raise_error(RuntimeError, /"shell" is a Thor reserved word and cannot be defined as command/)
     end
   end
 
@@ -244,48 +244,55 @@ describe Thor::Base do
   end
 
   describe "#start" do
-    it "raises an error instead of rescueing if THOR_DEBUG=1 is given" do
+    it "raises an error instead of rescuing if THOR_DEBUG=1 is given" do
       begin
-        ENV["THOR_DEBUG"] = 1
-        expect {
-          MyScript.start ["what", "--debug"]
-        }.to raise_error(Thor::UndefinedcommandError, 'Could not find command "what" in "my_script" namespace.')
-      rescue
+        ENV["THOR_DEBUG"] = "1"
+
+        expect do
+          MyScript.start %w[what --debug]
+        end.to raise_error(Thor::UndefinedCommandError, 'Could not find command "what" in "my_script" namespace.')
+      ensure
         ENV["THOR_DEBUG"] = nil
       end
     end
 
+    it "raises an error instead of rescuing if :debug option is given" do
+      expect do
+        MyScript.start %w[what], :debug => true
+      end.to raise_error(Thor::UndefinedCommandError, 'Could not find command "what" in "my_script" namespace.')
+    end
+
     it "does not steal args" do
-      args = ["foo", "bar", "--force", "true"]
+      args = %w[foo bar --force true]
       MyScript.start(args)
-      expect(args).to eq(["foo", "bar", "--force", "true"])
+      expect(args).to eq(%w[foo bar --force true])
     end
 
     it "checks unknown options" do
-      expect(capture(:stderr) {
-        MyScript.start(["foo", "bar", "--force", "true", "--unknown", "baz"])
-      }.strip).to eq("Unknown switches '--unknown'")
+      expect(capture(:stderr) do
+        MyScript.start(%w[foo bar --force true --unknown baz])
+      end.strip).to eq("Unknown switches '--unknown'")
     end
 
     it "checks unknown options except specified" do
-      expect(capture(:stderr) {
-        expect(MyScript.start(["with_optional", "NAME", "--omg", "--invalid"])).to eq(["NAME", {}, ["--omg", "--invalid"]])
-      }.strip).to be_empty
+      expect(capture(:stderr) do
+        expect(MyScript.start(%w[with_optional NAME --omg --invalid])).to eq(["NAME", {}, %w[--omg --invalid]])
+      end.strip).to be_empty
     end
   end
 
   describe "attr_*" do
     it "does not add attr_reader as a command" do
-      expect(capture(:stderr){ MyScript.start(["another_attribute"]) }).to match(/Could not find/)
+      expect(capture(:stderr) { MyScript.start(%w[another_attribute]) }).to match(/Could not find/)
     end
 
     it "does not add attr_writer as a command" do
-      expect(capture(:stderr){ MyScript.start(["another_attribute=", "foo"]) }).to match(/Could not find/)
+      expect(capture(:stderr) { MyScript.start(%w[another_attribute= foo]) }).to match(/Could not find/)
     end
 
     it "does not add attr_accessor as a command" do
-      expect(capture(:stderr){ MyScript.start(["some_attribute"]) }).to match(/Could not find/)
-      expect(capture(:stderr){ MyScript.start(["some_attribute=", "foo"]) }).to match(/Could not find/)
+      expect(capture(:stderr) { MyScript.start(["some_attribute"]) }).to match(/Could not find/)
+      expect(capture(:stderr) { MyScript.start(["some_attribute=", "foo"]) }).to match(/Could not find/)
     end
   end
 end