thor 0.18.1 → 0.19.0

data/spec/quality_spec.rb

@@ -0,0 +1,75 @@
+if defined?(Encoding) && Encoding.default_external != "UTF-8"
+  Encoding.default_external = "UTF-8"
+end
+
+describe "The library itself" do
+  def check_for_spec_defs_with_single_quotes(filename)
+    failing_lines = []
+
+    File.readlines(filename).each_with_index do |line,number|
+      failing_lines << number + 1 if line =~ /^ *(describe|it|context) {1}'{1}/
+    end
+
+    unless failing_lines.empty?
+      "#{filename} uses inconsistent single quotes on lines #{failing_lines.join(', ')}"
+    end
+  end
+
+  def check_for_tab_characters(filename)
+    failing_lines = []
+    File.readlines(filename).each_with_index do |line,number|
+      failing_lines << number + 1 if line =~ /\t/
+    end
+
+    unless failing_lines.empty?
+      "#{filename} has tab characters on lines #{failing_lines.join(', ')}"
+    end
+  end
+
+  def check_for_extra_spaces(filename)
+    failing_lines = []
+    File.readlines(filename).each_with_index do |line,number|
+      next if line =~ /^\s+#.*\s+\n$/
+      failing_lines << number + 1 if line =~ /\s+\n$/
+    end
+
+    unless failing_lines.empty?
+      "#{filename} has spaces on the EOL on lines #{failing_lines.join(', ')}"
+    end
+  end
+
+  RSpec::Matchers.define :be_well_formed do
+    failure_message_for_should do |actual|
+      actual.join("\n")
+    end
+
+    match do |actual|
+      actual.empty?
+    end
+  end
+
+  it "has no malformed whitespace" do
+    exempt = /\.gitmodules|\.marshal|fixtures|vendor|spec|ssl_certs|LICENSE/
+    error_messages = []
+    Dir.chdir(File.expand_path("../..", __FILE__)) do
+      `git ls-files`.split("\n").each do |filename|
+        next if filename =~ exempt
+        error_messages << check_for_tab_characters(filename)
+        error_messages << check_for_extra_spaces(filename)
+      end
+    end
+    expect(error_messages.compact).to be_well_formed
+  end
+
+  it "uses double-quotes consistently in specs" do
+    included = /spec/
+    error_messages = []
+    Dir.chdir(File.expand_path("../", __FILE__)) do
+      `git ls-files`.split("\n").each do |filename|
+        next unless filename =~ included
+        error_messages << check_for_spec_defs_with_single_quotes(filename)
+      end
+    end
+    expect(error_messages.compact).to be_well_formed
+  end
+end

data/spec/rake_compat_spec.rb

@@ -1,6 +1,6 @@
-require 'helper'
-require 'thor/rake_compat'
-require 'rake/tasklib'
+require "helper"
+require "thor/rake_compat"
+require "rake/tasklib"
 
 $main = self
 
@@ -32,7 +32,7 @@ end
 
 describe Thor::RakeCompat do
   it "sets the rakefile application" do
-    expect(["rake_compat_spec.rb", "Thorfile"]).to include(Rake.application.rakefile)
+    expect(%w[rake_compat_spec.rb Thorfile]).to include(Rake.application.rakefile)
   end
 
   it "adds rake tasks to thor classes too" do
@@ -61,12 +61,12 @@ describe Thor::RakeCompat do
   end
 
   it "invoking the thor task invokes the rake task" do
-    expect(capture(:stdout) {
-      ThorTask.start ["cool"]
-    }).to eq("COOL\n")
+    expect(capture(:stdout) do
+      ThorTask.start %w[cool]
+    end).to eq("COOL\n")
 
-    expect(capture(:stdout) {
-      ThorTask::HiperMega.start ["super"]
-    }).to eq("HIPER MEGA SUPER\n")
+    expect(capture(:stdout) do
+      ThorTask::HiperMega.start %w[super]
+    end).to eq("HIPER MEGA SUPER\n")
   end
 end

data/spec/register_spec.rb

@@ -1,4 +1,4 @@
-require 'helper'
+require "helper"
 
 class BoringVendorProvidedCLI < Thor
   desc "boring", "do boring stuff"
@@ -42,9 +42,9 @@ end
 
 class ClassOptionGroupPlugin < Thor::Group
   class_option :who,
-    :type => :string,
-    :aliases => "-w",
-    :default => "zebra"
+               :type => :string,
+               :aliases => "-w",
+               :default => "zebra"
 end
 
 class CompatibleWith19Plugin < ClassOptionGroupPlugin
@@ -82,6 +82,20 @@ class PluginWithDefaultcommandAndDeclaredArgument < Thor
   default_command :say
 end
 
+class SubcommandWithDefault < Thor
+  default_command :default
+
+  desc "default", "default subcommand"
+  def default
+    puts "default"
+  end
+
+  desc "with_args", "subcommand with arguments"
+  def with_args(*args)
+    puts "received arguments: " + args.join(",")
+  end
+end
+
 BoringVendorProvidedCLI.register(
   ExcitingPluginCLI,
   "exciting",
@@ -97,33 +111,36 @@ BoringVendorProvidedCLI.register(
 
 BoringVendorProvidedCLI.register(
   GroupPlugin,
-  'groupwork',
+  "groupwork",
   "Do a bunch of things in a row",
   "purple monkey dishwasher")
 
 BoringVendorProvidedCLI.register(
   CompatibleWith19Plugin,
-  'zoo',
+  "zoo",
   "zoo [-w animal]",
   "Shows a provided animal or just zebra")
 
 BoringVendorProvidedCLI.register(
   PluginWithDefault,
-  'say',
-  'say message',
-  'subcommands ftw')
+  "say",
+  "say message",
+  "subcommands ftw")
 
 BoringVendorProvidedCLI.register(
   PluginWithDefaultMultipleArguments,
-  'say_multiple',
-  'say message',
-  'subcommands ftw')
+  "say_multiple",
+  "say message",
+  "subcommands ftw")
 
 BoringVendorProvidedCLI.register(
   PluginWithDefaultcommandAndDeclaredArgument,
-  'say_argument',
-  'say message',
-  'subcommands ftw')
+  "say_argument",
+  "say message",
+  "subcommands ftw")
+
+BoringVendorProvidedCLI.register(SubcommandWithDefault,
+  "subcommand", "subcommand", "Run subcommands")
 
 describe ".register-ing a Thor subclass" do
   it "registers the plugin as a subcommand" do
@@ -133,23 +150,36 @@ describe ".register-ing a Thor subclass" do
 
   it "includes the plugin's usage in the help" do
     help_output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[help]) }
-    expect(help_output).to include('do exciting things')
+    expect(help_output).to include("do exciting things")
   end
 
-  it "invokes the default command correctly" do
-    output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[say hello]) }
-    expect(output).to include("hello")
-  end
+  context "with a default command," do
+    it "invokes the default command correctly" do
+      output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[say hello]) }
+      expect(output).to include("hello")
+    end
 
-  it "invokes the default command correctly with multiple args" do
-    output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[say_multiple hello adam]) }
-    expect(output).to include("hello")
-    expect(output).to include("adam")
-  end
+    it "invokes the default command correctly with multiple args" do
+      output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[say_multiple hello adam]) }
+      expect(output).to include("hello")
+      expect(output).to include("adam")
+    end
+
+    it "invokes the default command correctly with a declared argument" do
+      output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[say_argument hello]) }
+      expect(output).to include("hello")
+    end
+
+    it "displays the subcommand's help message" do
+      output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[subcommand help]) }
+      expect(output).to include("default subcommand")
+      expect(output).to include("subcommand with argument")
+    end
 
-  it "invokes the default command correctly with a declared argument" do
-    output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[say_argument hello]) }
-    expect(output).to include("hello")
+    it "invokes commands with their actual args" do
+      output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[subcommand with_args actual_argument]) }
+      expect(output.strip).to eql("received arguments: actual_argument")
+    end
   end
 
   context "when $thor_runner is false" do
@@ -157,7 +187,7 @@ describe ".register-ing a Thor subclass" do
       begin
         $thor_runner = false
         help_output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[exciting]) }
-        expect(help_output).to include('thor exciting_plugin_c_l_i fireworks')
+        expect(help_output).to include("thor exciting_plugin_c_l_i fireworks")
       ensure
         $thor_runner = true
       end
@@ -167,7 +197,7 @@ describe ".register-ing a Thor subclass" do
   context "when hidden" do
     it "omits the hidden plugin's usage from the help" do
       help_output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[help]) }
-      expect(help_output).not_to include('secret stuff')
+      expect(help_output).not_to include("secret stuff")
     end
 
     it "registers the plugin as a subcommand" do

data/spec/runner_spec.rb

@@ -1,12 +1,12 @@
-require 'helper'
-require 'thor/runner'
+require "helper"
+require "thor/runner"
 
 describe Thor::Runner do
   def when_no_thorfiles_exist
     old_dir = Dir.pwd
-    Dir.chdir '..'
-    delete = Thor::Base.subclasses.select {|e| e.namespace == 'default' }
-    delete.each {|e| Thor::Base.subclasses.delete e }
+    Dir.chdir ".."
+    delete = Thor::Base.subclasses.select { |e| e.namespace == "default" }
+    delete.each { |e| Thor::Base.subclasses.delete e }
     yield
     Thor::Base.subclasses.concat delete
     Dir.chdir old_dir
@@ -14,40 +14,40 @@ describe Thor::Runner do
 
   describe "#help" do
     it "shows information about Thor::Runner itself" do
-      expect(capture(:stdout) { Thor::Runner.start(["help"]) }).to match(/List the available thor commands/)
+      expect(capture(:stdout) { Thor::Runner.start(%w[help]) }).to match(/List the available thor commands/)
     end
 
     it "shows information about a specific Thor::Runner command" do
-      content = capture(:stdout) { Thor::Runner.start(["help", "list"]) }
+      content = capture(:stdout) { Thor::Runner.start(%w[help list]) }
       expect(content).to match(/List the available thor commands/)
       expect(content).not_to match(/help \[COMMAND\]/)
     end
 
     it "shows information about a specific Thor class" do
-      content = capture(:stdout) { Thor::Runner.start(["help", "my_script"]) }
+      content = capture(:stdout) { Thor::Runner.start(%w[help my_script]) }
       expect(content).to match(/zoo\s+# zoo around/m)
     end
 
-    it "shows information about an specific command from an specific Thor class" do
-      content = capture(:stdout) { Thor::Runner.start(["help", "my_script:zoo"]) }
+    it "shows information about a specific command from a specific Thor class" do
+      content = capture(:stdout) { Thor::Runner.start(%w[help my_script:zoo]) }
       expect(content).to match(/zoo around/)
       expect(content).not_to match(/help \[COMMAND\]/)
     end
 
     it "shows information about a specific Thor group class" do
-      content = capture(:stdout) { Thor::Runner.start(["help", "my_counter"]) }
+      content = capture(:stdout) { Thor::Runner.start(%w[help my_counter]) }
       expect(content).to match(/my_counter N/)
     end
 
     it "raises error if a class/command cannot be found" do
-      content = capture(:stderr){ Thor::Runner.start(["help", "unknown"]) }
+      content = capture(:stderr) { Thor::Runner.start(%w[help unknown]) }
       expect(content.strip).to eq('Could not find command "unknown" in "default" namespace.')
     end
 
     it "raises error if a class/command cannot be found for a setup without thorfiles" do
       when_no_thorfiles_exist do
-        Thor::Runner.should_receive :exit
-        content = capture(:stderr){ Thor::Runner.start(["help", "unknown"]) }
+        expect(Thor::Runner).to receive :exit
+        content = capture(:stderr) { Thor::Runner.start(%w[help unknown]) }
         expect(content.strip).to eq('Could not find command "unknown".')
       end
     end
@@ -55,64 +55,65 @@ describe Thor::Runner do
 
   describe "#start" do
     it "invokes a command from Thor::Runner" do
-      ARGV.replace ["list"]
+      ARGV.replace %w[list]
       expect(capture(:stdout) { Thor::Runner.start }).to match(/my_counter N/)
     end
 
     it "invokes a command from a specific Thor class" do
-      ARGV.replace ["my_script:zoo"]
-      expect(Thor::Runner.start).to be_true
+      ARGV.replace %w[my_script:zoo]
+      expect(Thor::Runner.start).to be true
     end
 
     it "invokes the default command from a specific Thor class if none is specified" do
-      ARGV.replace ["my_script"]
+      ARGV.replace %w[my_script]
       expect(Thor::Runner.start).to eq("default command")
     end
 
-    it "forwads arguments to the invoked command" do
-      ARGV.replace ["my_script:animal", "horse"]
-      expect(Thor::Runner.start).to eq(["horse"])
+    it "forwards arguments to the invoked command" do
+      ARGV.replace %w[my_script:animal horse]
+      expect(Thor::Runner.start).to eq(%w[horse])
     end
 
     it "invokes commands through shortcuts" do
-      ARGV.replace ["my_script", "-T", "horse"]
-      expect(Thor::Runner.start).to eq(["horse"])
+      ARGV.replace %w[my_script -T horse]
+      expect(Thor::Runner.start).to eq(%w[horse])
     end
 
     it "invokes a Thor::Group" do
-      ARGV.replace ["my_counter", "1", "2", "--third", "3"]
+      ARGV.replace %w[my_counter 1 2 --third 3]
       expect(Thor::Runner.start).to eq([1, 2, 3, nil, nil, nil])
     end
 
     it "raises an error if class/command can't be found" do
-      ARGV.replace ["unknown"]
-      content = capture(:stderr){ Thor::Runner.start }
+      ARGV.replace %w[unknown]
+      content = capture(:stderr) { Thor::Runner.start }
       expect(content.strip).to eq('Could not find command "unknown" in "default" namespace.')
     end
 
     it "raises an error if class/command can't be found in a setup without thorfiles" do
       when_no_thorfiles_exist do
-        ARGV.replace ["unknown"]
-        Thor::Runner.should_receive :exit
-        content = capture(:stderr){ Thor::Runner.start }
+        ARGV.replace %w[unknown]
+        expect(Thor::Runner).to receive :exit
+        content = capture(:stderr) { Thor::Runner.start }
         expect(content.strip).to eq('Could not find command "unknown".')
       end
     end
 
     it "does not swallow NoMethodErrors that occur inside the called method" do
-      ARGV.replace ["my_script:call_unexistent_method"]
-      expect{ Thor::Runner.start }.to raise_error(NoMethodError)
+      ARGV.replace %w[my_script:call_unexistent_method]
+      expect { Thor::Runner.start }.to raise_error(NoMethodError)
     end
 
     it "does not swallow Thor::Group InvocationError" do
-      ARGV.replace ["whiny_generator"]
-      expect{ Thor::Runner.start }.to raise_error(ArgumentError, /thor wrong_arity takes 1 argument, but it should not/)
+      ARGV.replace %w[whiny_generator]
+      expect { Thor::Runner.start }.to raise_error(ArgumentError, /thor wrong_arity takes 1 argument, but it should not/)
     end
 
     it "does not swallow Thor InvocationError" do
-      ARGV.replace ["my_script:animal"]
+      ARGV.replace %w[my_script:animal]
       content = capture(:stderr) { Thor::Runner.start }
-      expect(content.strip).to eq(%Q'ERROR: thor animal was called with no arguments\nUsage: "thor my_script:animal TYPE".')
+      expect(content.strip).to eq(%Q(ERROR: "thor animal" was called with no arguments
+Usage: "thor my_script:animal TYPE"))
     end
   end
 
@@ -123,68 +124,68 @@ describe Thor::Runner do
         "random" => {
           :location  => @location,
           :filename  => "4a33b894ffce85d7b412fc1b36f88fe0",
-          :namespaces => ["amazing"]
+          :namespaces => %w[amazing]
         }
       }
 
       root_file = File.join(Thor::Util.thor_root, "thor.yml")
 
       # Stub load and save to avoid thor.yaml from being overwritten
-      YAML.stub!(:load_file).and_return(@original_yaml)
-      File.stub!(:exists?).with(root_file).and_return(true)
-      File.stub!(:open).with(root_file, "w")
+      allow(YAML).to receive(:load_file).and_return(@original_yaml)
+      allow(File).to receive(:exist?).with(root_file).and_return(true)
+      allow(File).to receive(:open).with(root_file, "w")
     end
 
     describe "list" do
       it "gives a list of the available commands" do
-        ARGV.replace ["list"]
+        ARGV.replace %w[list]
         content = capture(:stdout) { Thor::Runner.start }
         expect(content).to match(/amazing:describe NAME\s+# say that someone is amazing/m)
       end
 
       it "gives a list of the available Thor::Group classes" do
-        ARGV.replace ["list"]
+        ARGV.replace %w[list]
         expect(capture(:stdout) { Thor::Runner.start }).to match(/my_counter N/)
       end
 
       it "can filter a list of the available commands by --group" do
-        ARGV.replace ["list", "--group", "standard"]
+        ARGV.replace %w[list --group standard]
         expect(capture(:stdout) { Thor::Runner.start }).to match(/amazing:describe NAME/)
         ARGV.replace []
         expect(capture(:stdout) { Thor::Runner.start }).not_to match(/my_script:animal TYPE/)
-        ARGV.replace ["list", "--group", "script"]
+        ARGV.replace %w[list --group script]
         expect(capture(:stdout) { Thor::Runner.start }).to match(/my_script:animal TYPE/)
       end
 
       it "can skip all filters to show all commands using --all" do
-        ARGV.replace ["list", "--all"]
+        ARGV.replace %w[list --all]
         content = capture(:stdout) { Thor::Runner.start }
         expect(content).to match(/amazing:describe NAME/)
         expect(content).to match(/my_script:animal TYPE/)
       end
 
       it "doesn't list superclass commands in the subclass" do
-        ARGV.replace ["list"]
+        ARGV.replace %w[list]
         expect(capture(:stdout) { Thor::Runner.start }).not_to match(/amazing:help/)
       end
 
       it "presents commands in the default namespace with an empty namespace" do
-        ARGV.replace ["list"]
+        ARGV.replace %w[list]
         expect(capture(:stdout) { Thor::Runner.start }).to match(/^thor :cow\s+# prints 'moo'/m)
       end
 
       it "runs commands with an empty namespace from the default namespace" do
-        ARGV.replace [":command_conflict"]
+        ARGV.replace %w[:command_conflict]
         expect(capture(:stdout) { Thor::Runner.start }).to eq("command\n")
       end
 
       it "runs groups even when there is a command with the same name" do
-        ARGV.replace ["command_conflict"]
+        ARGV.replace %w[command_conflict]
         expect(capture(:stdout) { Thor::Runner.start }).to eq("group\n")
       end
 
       it "runs commands with no colon in the default namespace" do
-        ARGV.replace ["cow"]
+        ARGV.replace %w[cow]
         expect(capture(:stdout) { Thor::Runner.start }).to eq("moo\n")
       end
     end
@@ -192,21 +193,21 @@ describe Thor::Runner do
     describe "uninstall" do
       before do
         path = File.join(Thor::Util.thor_root, @original_yaml["random"][:filename])
-        FileUtils.should_receive(:rm_rf).with(path)
+        expect(FileUtils).to receive(:rm_rf).with(path)
       end
 
       it "uninstalls existing thor modules" do
-        silence(:stdout) { Thor::Runner.start(["uninstall", "random"]) }
+        silence(:stdout) { Thor::Runner.start(%w[uninstall random]) }
       end
     end
 
     describe "installed" do
       before do
-        Dir.should_receive(:[]).and_return([])
+        expect(Dir).to receive(:[]).and_return([])
       end
 
       it "displays the modules installed in a pretty way" do
-        stdout = capture(:stdout) { Thor::Runner.start(["installed"]) }
+        stdout = capture(:stdout) { Thor::Runner.start(%w[installed]) }
         expect(stdout).to match(/random\s*amazing/)
         expect(stdout).to match(/amazing:describe NAME\s+# say that someone is amazing/m)
       end
@@ -214,27 +215,31 @@ describe Thor::Runner do
 
     describe "install/update" do
       before do
-        FileUtils.stub!(:mkdir_p)
-        FileUtils.stub!(:touch)
-        $stdin.stub!(:gets).and_return("Y")
+        allow(FileUtils).to receive(:mkdir_p)
+        allow(FileUtils).to receive(:touch)
+        allow(Thor::LineEditor).to receive(:readline).and_return("Y")
 
         path = File.join(Thor::Util.thor_root, Digest::MD5.hexdigest(@location + "random"))
-        File.should_receive(:open).with(path, "w")
+        expect(File).to receive(:open).with(path, "w")
       end
 
       it "updates existing thor files" do
         path = File.join(Thor::Util.thor_root, @original_yaml["random"][:filename])
         if File.directory? path
-          FileUtils.should_receive(:rm_rf).with(path)
+          expect(FileUtils).to receive(:rm_rf).with(path)
         else
-          File.should_receive(:delete).with(path)
+          expect(File).to receive(:delete).with(path)
+        end
+        silence_warnings do
+          silence(:stdout) { Thor::Runner.start(%w[update random]) }
         end
-        silence(:stdout) { Thor::Runner.start(["update", "random"]) }
       end
 
       it "installs thor files" do
-        ARGV.replace ["install", @location]
-        silence(:stdout) { Thor::Runner.start }
+        ARGV.replace %W[install #{@location}]
+        silence_warnings do
+          silence(:stdout) { Thor::Runner.start }
+        end
       end
     end
   end