thor 0.16.0 → 0.17.0

data/spec/register_spec.rb

@@ -54,6 +54,34 @@ class CompatibleWith19Plugin < ClassOptionGroupPlugin
   end
 end
 
+class PluginWithDefault < Thor
+  desc "say MSG", "print MSG"
+  def say(msg)
+    puts msg
+  end
+
+  default_task :say
+end
+
+class PluginWithDefaultMultipleArguments < Thor
+  desc "say MSG [MSG]", "print multiple messages"
+  def say(*args)
+    puts args
+  end
+
+  default_task :say
+end
+
+class PluginWithDefaultTaskAndDeclaredArgument < Thor
+  desc "say MSG [MSG]", "print multiple messages"
+  argument :msg
+  def say
+    puts msg
+  end
+
+  default_task :say
+end
+
 BoringVendorProvidedCLI.register(
   ExcitingPluginCLI,
   "exciting",
@@ -79,15 +107,49 @@ BoringVendorProvidedCLI.register(
   "zoo [-w animal]",
   "Shows a provided animal or just zebra")
 
+BoringVendorProvidedCLI.register(
+  PluginWithDefault,
+  'say',
+  'say message',
+  'subcommands ftw')
+
+BoringVendorProvidedCLI.register(
+  PluginWithDefaultMultipleArguments,
+  'say_multiple',
+  'say message',
+  'subcommands ftw')
+
+BoringVendorProvidedCLI.register(
+  PluginWithDefaultTaskAndDeclaredArgument,
+  'say_argument',
+  'say message',
+  'subcommands ftw')
+
 describe ".register-ing a Thor subclass" do
   it "registers the plugin as a subcommand" do
     fireworks_output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[exciting fireworks]) }
-    fireworks_output.should == "kaboom!\n"
+    expect(fireworks_output).to eq("kaboom!\n")
   end
 
   it "includes the plugin's usage in the help" do
     help_output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[help]) }
-    help_output.should include('do exciting things')
+    expect(help_output).to include('do exciting things')
+  end
+
+  it "invokes the default task correctly" do
+    output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[say hello]) }
+    expect(output).to include("hello")
+  end
+
+  it "invokes the default task 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 task correctly with a declared argument" do
+    output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[say_argument hello]) }
+    expect(output).to include("hello")
   end
 
   context "when $thor_runner is false" do
@@ -95,7 +157,7 @@ describe ".register-ing a Thor subclass" do
       begin
         $thor_runner = false
         help_output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[exciting]) }
-        help_output.should 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
@@ -105,12 +167,12 @@ 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]) }
-      help_output.should_not include('secret stuff')
+      expect(help_output).not_to include('secret stuff')
     end
 
     it "registers the plugin as a subcommand" do
       secret_output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[secret squirrel]) }
-      secret_output.should == "I love nuts\n"
+      expect(secret_output).to eq("I love nuts\n")
     end
   end
 end
@@ -118,18 +180,18 @@ end
 describe ".register-ing a Thor::Group subclass" do
   it "registers the group as a single command" do
     group_output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[groupwork]) }
-    group_output.should == "part one\npart two\n"
+    expect(group_output).to eq("part one\npart two\n")
   end
 end
 
 describe "1.8 and 1.9 syntax compatibility" do
   it "is compatible with both 1.8 and 1.9 syntax w/o task options" do
     group_output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[zoo]) }
-    group_output.should match /zebra/
+    expect(group_output).to match(/zebra/)
   end
 
   it "is compatible with both 1.8 and 1.9 syntax w/task options" do
     group_output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[zoo -w lion]) }
-    group_output.should match /lion/
+    expect(group_output).to match(/lion/)
   end
 end

data/spec/runner_spec.rb

@@ -14,41 +14,41 @@ describe Thor::Runner do
 
   describe "#help" do
     it "shows information about Thor::Runner itself" do
-      capture(:stdout){ Thor::Runner.start(["help"]) }.should =~ /List the available thor tasks/
+      expect(capture(:stdout) { Thor::Runner.start(["help"]) }).to match(/List the available thor tasks/)
     end
 
     it "shows information about an specific Thor::Runner task" do
-      content = capture(:stdout){ Thor::Runner.start(["help", "list"]) }
-      content.should =~ /List the available thor tasks/
-      content.should_not =~ /help \[TASK\]/
+      content = capture(:stdout) { Thor::Runner.start(["help", "list"]) }
+      expect(content).to match(/List the available thor tasks/)
+      expect(content).not_to match(/help \[TASK\]/)
     end
 
     it "shows information about a specific Thor class" do
-      content = capture(:stdout){ Thor::Runner.start(["help", "my_script"]) }
-      content.should =~ /zoo\s+# zoo around/m
+      content = capture(:stdout) { Thor::Runner.start(["help", "my_script"]) }
+      expect(content).to match(/zoo\s+# zoo around/m)
     end
 
     it "shows information about an specific task from an specific Thor class" do
-      content = capture(:stdout){ Thor::Runner.start(["help", "my_script:zoo"]) }
-      content.should =~ /zoo around/
-      content.should_not =~ /help \[TASK\]/
+      content = capture(:stdout) { Thor::Runner.start(["help", "my_script:zoo"]) }
+      expect(content).to match(/zoo around/)
+      expect(content).not_to match(/help \[TASK\]/)
     end
 
     it "shows information about a specific Thor group class" do
-      content = capture(:stdout){ Thor::Runner.start(["help", "my_counter"]) }
-      content.should =~ /my_counter N/
+      content = capture(:stdout) { Thor::Runner.start(["help", "my_counter"]) }
+      expect(content).to match(/my_counter N/)
     end
 
     it "raises error if a class/task cannot be found" do
       content = capture(:stderr){ Thor::Runner.start(["help", "unknown"]) }
-      content.strip.should == 'Could not find task "unknown" in "default" namespace.'
+      expect(content.strip).to eq('Could not find task "unknown" in "default" namespace.')
     end
 
     it "raises error if a class/task 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"]) }
-        content.strip.should == 'Could not find task "unknown".'
+        expect(content.strip).to eq('Could not find task "unknown".')
       end
     end
   end
@@ -56,38 +56,38 @@ describe Thor::Runner do
   describe "#start" do
     it "invokes a task from Thor::Runner" do
       ARGV.replace ["list"]
-      capture(:stdout){ Thor::Runner.start }.should =~ /my_counter N/
+      expect(capture(:stdout) { Thor::Runner.start }).to match(/my_counter N/)
     end
 
     it "invokes a task from a specific Thor class" do
       ARGV.replace ["my_script:zoo"]
-      Thor::Runner.start.should be_true
+      expect(Thor::Runner.start).to be_true
     end
 
     it "invokes the default task from a specific Thor class if none is specified" do
       ARGV.replace ["my_script"]
-      Thor::Runner.start.should == "default task"
+      expect(Thor::Runner.start).to eq("default task")
     end
 
     it "forwads arguments to the invoked task" do
       ARGV.replace ["my_script:animal", "horse"]
-      Thor::Runner.start.should == ["horse"]
+      expect(Thor::Runner.start).to eq(["horse"])
     end
 
     it "invokes tasks through shortcuts" do
       ARGV.replace ["my_script", "-T", "horse"]
-      Thor::Runner.start.should == ["horse"]
+      expect(Thor::Runner.start).to eq(["horse"])
     end
 
     it "invokes a Thor::Group" do
       ARGV.replace ["my_counter", "1", "2", "--third", "3"]
-      Thor::Runner.start.should == [1, 2, 3]
+      expect(Thor::Runner.start).to eq([1, 2, 3])
     end
 
     it "raises an error if class/task can't be found" do
       ARGV.replace ["unknown"]
       content = capture(:stderr){ Thor::Runner.start }
-      content.strip.should == 'Could not find task "unknown" in "default" namespace.'
+      expect(content.strip).to eq('Could not find task "unknown" in "default" namespace.')
     end
 
     it "raises an error if class/task can't be found in a setup without thorfiles" do
@@ -95,24 +95,24 @@ describe Thor::Runner do
         ARGV.replace ["unknown"]
         Thor::Runner.should_receive :exit
         content = capture(:stderr){ Thor::Runner.start }
-        content.strip.should == 'Could not find task "unknown".'
+        expect(content.strip).to eq('Could not find task "unknown".')
       end
     end
 
     it "does not swallow NoMethodErrors that occur inside the called method" do
       ARGV.replace ["my_script:call_unexistent_method"]
-      lambda { Thor::Runner.start }.should raise_error(NoMethodError)
+      expect{ Thor::Runner.start }.to raise_error(NoMethodError)
     end
 
     it "does not swallow Thor::Group InvocationError" do
       ARGV.replace ["whiny_generator"]
-      lambda { Thor::Runner.start }.should raise_error(ArgumentError, /thor wrong_arity takes 1 argument, but it should not/)
+      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"]
       content = capture(:stderr) { Thor::Runner.start }
-      content.strip.should == 'thor animal requires at least 1 argument: "thor my_script:animal TYPE".'
+      expect(content.strip).to eq('thor animal requires at least 1 argument: "thor my_script:animal TYPE".')
     end
   end
 
@@ -139,53 +139,53 @@ describe Thor::Runner do
       it "gives a list of the available tasks" do
         ARGV.replace ["list"]
         content = capture(:stdout) { Thor::Runner.start }
-        content.should =~ /amazing:describe NAME\s+# say that someone is amazing/m
+        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"]
-        capture(:stdout) { Thor::Runner.start }.should =~ /my_counter N/
+        expect(capture(:stdout) { Thor::Runner.start }).to match(/my_counter N/)
       end
 
       it "can filter a list of the available tasks by --group" do
         ARGV.replace ["list", "--group", "standard"]
-        capture(:stdout) { Thor::Runner.start }.should =~ /amazing:describe NAME/
+        expect(capture(:stdout) { Thor::Runner.start }).to match(/amazing:describe NAME/)
         ARGV.replace []
-        capture(:stdout) { Thor::Runner.start }.should_not =~ /my_script:animal TYPE/
+        expect(capture(:stdout) { Thor::Runner.start }).not_to match(/my_script:animal TYPE/)
         ARGV.replace ["list", "--group", "script"]
-        capture(:stdout) { Thor::Runner.start }.should =~ /my_script:animal TYPE/
+        expect(capture(:stdout) { Thor::Runner.start }).to match(/my_script:animal TYPE/)
       end
 
       it "can skip all filters to show all tasks using --all" do
         ARGV.replace ["list", "--all"]
         content = capture(:stdout) { Thor::Runner.start }
-        content.should =~ /amazing:describe NAME/
-        content.should =~ /my_script:animal TYPE/
+        expect(content).to match(/amazing:describe NAME/)
+        expect(content).to match(/my_script:animal TYPE/)
       end
 
       it "doesn't list superclass tasks in the subclass" do
         ARGV.replace ["list"]
-        capture(:stdout) { Thor::Runner.start }.should_not =~ /amazing:help/
+        expect(capture(:stdout) { Thor::Runner.start }).not_to match(/amazing:help/)
       end
 
       it "presents tasks in the default namespace with an empty namespace" do
         ARGV.replace ["list"]
-        capture(:stdout) { Thor::Runner.start }.should =~ /^thor :cow\s+# prints 'moo'/m
+        expect(capture(:stdout) { Thor::Runner.start }).to match(/^thor :cow\s+# prints 'moo'/m)
       end
 
       it "runs tasks with an empty namespace from the default namespace" do
         ARGV.replace [":task_conflict"]
-        capture(:stdout) { Thor::Runner.start }.should == "task\n"
+        expect(capture(:stdout) { Thor::Runner.start }).to eq("task\n")
       end
 
       it "runs groups even when there is a task with the same name" do
         ARGV.replace ["task_conflict"]
-        capture(:stdout) { Thor::Runner.start }.should == "group\n"
+        expect(capture(:stdout) { Thor::Runner.start }).to eq("group\n")
       end
 
       it "runs tasks with no colon in the default namespace" do
         ARGV.replace ["cow"]
-        capture(:stdout) { Thor::Runner.start }.should == "moo\n"
+        expect(capture(:stdout) { Thor::Runner.start }).to eq("moo\n")
       end
     end
 
@@ -207,8 +207,8 @@ describe Thor::Runner do
 
       it "displays the modules installed in a pretty way" do
         stdout = capture(:stdout) { Thor::Runner.start(["installed"]) }
-        stdout.should =~ /random\s*amazing/
-        stdout.should =~ /amazing:describe NAME\s+# say that someone is amazing/m
+        expect(stdout).to match(/random\s*amazing/)
+        expect(stdout).to match(/amazing:describe NAME\s+# say that someone is amazing/m)
       end
     end
 

data/spec/shell/basic_spec.rb

@@ -10,10 +10,10 @@ describe Thor::Shell::Basic do
   describe "#padding" do
     it "cannot be set to below zero" do
       shell.padding = 10
-      shell.padding.should == 10
+      expect(shell.padding).to eq(10)
 
       shell.padding = -1
-      shell.padding.should == 0
+      expect(shell.padding).to eq(0)
     end
   end
 
@@ -21,20 +21,27 @@ describe Thor::Shell::Basic do
     it "prints a message to the user and gets the response" do
       $stdout.should_receive(:print).with("Should I overwrite it? ")
       $stdin.should_receive(:gets).and_return('Sure')
-      shell.ask("Should I overwrite it?").should == "Sure"
+      expect(shell.ask("Should I overwrite it?")).to eq("Sure")
     end
 
+    it "prints a message and returns nil if EOF is sent to stdin" do
+      $stdout.should_receive(:print).with(" ")
+      $stdin.should_receive(:gets).and_return(nil)
+      expect(shell.ask("")).to eq(nil)
+    end
+
+
     it "prints a message to the user with the available options and determines the correctness of the answer" do
       $stdout.should_receive(:print).with('What\'s your favorite Neopolitan flavor? ["strawberry", "chocolate", "vanilla"] ')
       $stdin.should_receive(:gets).and_return('chocolate')
-      shell.ask("What's your favorite Neopolitan flavor?", :limited_to => ["strawberry", "chocolate", "vanilla"]).should == "chocolate"
+      expect(shell.ask("What's your favorite Neopolitan flavor?", :limited_to => ["strawberry", "chocolate", "vanilla"])).to eq("chocolate")
     end
 
     it "prints a message to the user with the available options and reasks the question after an incorrect repsonse" do
       $stdout.should_receive(:print).with('What\'s your favorite Neopolitan flavor? ["strawberry", "chocolate", "vanilla"] ').twice
       $stdout.should_receive(:puts).with('Your response must be one of: ["strawberry", "chocolate", "vanilla"]. Please try again.')
       $stdin.should_receive(:gets).and_return('moose tracks', 'chocolate')
-      shell.ask("What's your favorite Neopolitan flavor?", :limited_to => ["strawberry", "chocolate", "vanilla"]).should == "chocolate"
+      expect(shell.ask("What's your favorite Neopolitan flavor?", :limited_to => ["strawberry", "chocolate", "vanilla"])).to eq("chocolate")
     end
   end
 
@@ -42,11 +49,11 @@ describe Thor::Shell::Basic do
     it "asks the user and returns true if the user replies yes" do
       $stdout.should_receive(:print).with("Should I overwrite it? ")
         $stdin.should_receive(:gets).and_return('y')
-      shell.yes?("Should I overwrite it?").should === true
+      expect(shell.yes?("Should I overwrite it?")).to be_true
 
       $stdout.should_receive(:print).with("Should I overwrite it? ")
         $stdin.should_receive(:gets).and_return('n')
-      shell.yes?("Should I overwrite it?").should_not === true
+      expect(shell.yes?("Should I overwrite it?")).not_to be_true
     end
   end
 
@@ -54,11 +61,11 @@ describe Thor::Shell::Basic do
     it "asks the user and returns true if the user replies no" do
       $stdout.should_receive(:print).with("Should I overwrite it? ")
         $stdin.should_receive(:gets).and_return('n')
-      shell.no?("Should I overwrite it?").should === true
+      expect(shell.no?("Should I overwrite it?")).to be_true
 
       $stdout.should_receive(:print).with("Should I overwrite it? ")
         $stdin.should_receive(:gets).and_return('Yes')
-      shell.no?("Should I overwrite it?").should === false
+      expect(shell.no?("Should I overwrite it?")).to be_false
     end
   end
 
@@ -73,6 +80,11 @@ describe Thor::Shell::Basic do
       shell.say("Running... ")
     end
 
+    it "does not use a new line with whitespace+newline embedded" do
+      $stdout.should_receive(:puts).with("It's \nRunning...")
+      shell.say("It's \nRunning...")
+    end
+
     it "prints a message to the user without new line" do
       $stdout.should_receive(:print).with("Running...")
       shell.say("Running...", nil, false)
@@ -127,8 +139,8 @@ describe Thor::Shell::Basic do
     end
 
     it "prints in columns" do
-      content = capture(:stdout){ shell.print_in_columns(@array) }
-      content.rstrip.should == "1234567890  a           b           c           d           e"
+      content = capture(:stdout) { shell.print_in_columns(@array) }
+      expect(content.rstrip).to eq("1234567890  a           b           c           d           e")
     end
   end
 
@@ -141,8 +153,8 @@ describe Thor::Shell::Basic do
     end
 
     it "prints a table" do
-      content = capture(:stdout){ shell.print_table(@table) }
-      content.should == <<-TABLE
+      content = capture(:stdout) { shell.print_table(@table) }
+      expect(content).to eq(<<-TABLE)
 abc  #123  first three
      #0    empty
 xyz  #786  last three
@@ -150,8 +162,8 @@ TABLE
     end
 
     it "prints a table with indentation" do
-      content = capture(:stdout){ shell.print_table(@table, :indent => 2) }
-      content.should == <<-TABLE
+      content = capture(:stdout) { shell.print_table(@table, :indent => 2) }
+      expect(content).to eq(<<-TABLE)
   abc  #123  first three
        #0    empty
   xyz  #786  last three
@@ -162,8 +174,8 @@ TABLE
       @table << ["def", "#456", "Lançam foo bar"]
       @table << ["ghi", "#789", "بالله  عليكم"]
       shell.should_receive(:terminal_width).and_return(20)
-      content = capture(:stdout){ shell.print_table(@table, :indent => 2, :truncate => true) }
-      content.should == <<-TABLE
+      content = capture(:stdout) { shell.print_table(@table, :indent => 2, :truncate => true) }
+      expect(content).to eq(<<-TABLE)
   abc  #123  firs...
        #0    empty
   xyz  #786  last...
@@ -173,8 +185,8 @@ TABLE
     end
 
     it "honors the colwidth option" do
-      content = capture(:stdout){ shell.print_table(@table, :colwidth => 10)}
-      content.should == <<-TABLE
+      content = capture(:stdout) { shell.print_table(@table, :colwidth => 10)}
+      expect(content).to eq(<<-TABLE)
 abc         #123  first three
             #0    empty
 xyz         #786  last three
@@ -183,8 +195,8 @@ TABLE
 
     it "prints tables with implicit columns" do
       2.times { @table.first.pop }
-      content = capture(:stdout){ shell.print_table(@table) }
-      content.should == <<-TABLE
+      content = capture(:stdout) { shell.print_table(@table) }
+      expect(content).to eq(<<-TABLE)
 abc  
      #0    empty
 xyz  #786  last three
@@ -196,8 +208,8 @@ TABLE
         ["Name", "Number", "Color"],
         ["Erik", 1, "green"]
       ]
-      content = capture(:stdout){ shell.print_table(table) }
-      content.should == <<-TABLE
+      content = capture(:stdout) { shell.print_table(table) }
+      expect(content).to eq(<<-TABLE)
 Name  Number  Color
 Erik       1  green
 TABLE
@@ -208,8 +220,8 @@ TABLE
         ["Name", "Number"],
         ["Erik", 1]
       ]
-      content = capture(:stdout){ shell.print_table(table) }
-      content.should == <<-TABLE
+      content = capture(:stdout) { shell.print_table(table) }
+      expect(content).to eq(<<-TABLE)
 Name  Number
 Erik       1
 TABLE
@@ -220,8 +232,8 @@ TABLE
         ["Name", "Number", "Color"],
         ["Erik", 1234567890123, "green"]
       ]
-      content = capture(:stdout){ shell.print_table(table) }
-      content.should == <<-TABLE
+      content = capture(:stdout) { shell.print_table(table) }
+      expect(content).to eq(<<-TABLE)
 Name  Number         Color
 Erik  1234567890123  green
 TABLE
@@ -238,27 +250,27 @@ TABLE
     it "returns true if the user choose default option" do
       $stdout.stub!(:print)
       $stdin.should_receive(:gets).and_return('')
-      shell.file_collision('foo').should be_true
+      expect(shell.file_collision('foo')).to be_true
     end
 
     it "returns false if the user choose no" do
       $stdout.stub!(:print)
       $stdin.should_receive(:gets).and_return('n')
-      shell.file_collision('foo').should be_false
+      expect(shell.file_collision('foo')).to be_false
     end
 
     it "returns true if the user choose yes" do
       $stdout.stub!(:print)
       $stdin.should_receive(:gets).and_return('y')
-      shell.file_collision('foo').should be_true
+      expect(shell.file_collision('foo')).to be_true
     end
 
     it "shows help usage if the user choose help" do
       $stdout.stub!(:print)
       $stdin.should_receive(:gets).and_return('h')
       $stdin.should_receive(:gets).and_return('n')
-      help = capture(:stdout){ shell.file_collision('foo') }
-      help.should =~ /h \- help, show this help/
+      help = capture(:stdout) { shell.file_collision('foo') }
+      expect(help).to match(/h \- help, show this help/)
     end
 
     it "quits if the user choose quit" do
@@ -266,19 +278,19 @@ TABLE
       $stdout.should_receive(:puts).with('Aborting...')
       $stdin.should_receive(:gets).and_return('q')
 
-      lambda {
+      expect {
         shell.file_collision('foo')
-      }.should raise_error(SystemExit)
+      }.to raise_error(SystemExit)
     end
 
     it "always returns true if the user choose always" do
       $stdout.should_receive(:print).with('Overwrite foo? (enter "h" for help) [Ynaqh] ')
       $stdin.should_receive(:gets).and_return('a')
 
-      shell.file_collision('foo').should be_true
+      expect(shell.file_collision('foo')).to be_true
 
       $stdout.should_not_receive(:print)
-      shell.file_collision('foo').should be_true
+      expect(shell.file_collision('foo')).to be_true
     end
 
     describe "when a block is given" do
@@ -293,7 +305,7 @@ TABLE
         $stdin.should_receive(:gets).and_return('d')
         $stdin.should_receive(:gets).and_return('n')
         shell.should_receive(:system).with(/diff -u/)
-        capture(:stdout){ shell.file_collision('foo'){ } }
+        capture(:stdout) { shell.file_collision('foo'){ } }
       end
     end
   end