thor 0.12.0 → 0.13.0

data/spec/runner_spec.rb

@@ -26,11 +26,11 @@ describe Thor::Runner do
 
     it "shows information about a specific Thor group class" do
       content = capture(:stdout){ Thor::Runner.start(["help", "my_counter"]) }
-      content.must =~ /my_counter N \[N\]/
+      content.must =~ /my_counter N/
     end
 
     it "raises error if a class/task cannot be found" do
-      mock(Thor::Runner).exit(1)
+      Thor::Runner.should_receive(:exit).with(1)
       content = capture(:stderr){ Thor::Runner.start(["help", "unknown"]) }
       content.must =~ /could not find Thor class or task 'unknown'/
     end
@@ -39,7 +39,7 @@ describe Thor::Runner do
   describe "#start" do
     it "invokes a task from Thor::Runner" do
       ARGV.replace ["list"]
-      capture(:stdout){ Thor::Runner.start }.must =~ /my_counter N \[N\]/
+      capture(:stdout){ Thor::Runner.start }.must =~ /my_counter N/
     end
 
     it "invokes a task from a specific Thor class" do
@@ -68,7 +68,7 @@ describe Thor::Runner do
     end
 
     it "raises an error if class/task can't be found" do
-      mock(Thor::Runner).exit(1)
+      Thor::Runner.should_receive(:exit).with(1)
       ARGV.replace ["unknown"]
       capture(:stderr){ Thor::Runner.start }.must =~ /could not find Thor class or task 'unknown'/
     end
@@ -78,12 +78,12 @@ describe Thor::Runner do
       lambda { Thor::Runner.start }.must raise_error(NoMethodError)
     end
 
-    it "does not swallow Thor::Group ArgumentError" do
+    it "does not swallow Thor::Group InvocationError" do
       ARGV.replace ["whiny_generator"]
       lambda { Thor::Runner.start }.must raise_error(ArgumentError, /Are you sure it has arity equals to 0\?/)
     end
 
-    it "does not swallow Thor ArgumentError" do
+    it "does not swallow Thor InvocationError" do
       ARGV.replace ["my_script:animal"]
       capture(:stderr) { Thor::Runner.start }.must =~ /'animal' was called incorrectly\. Call as 'my_script:animal TYPE'/
     end
@@ -96,26 +96,28 @@ describe Thor::Runner do
         "random" => {
           :location  => @location,
           :filename  => "4a33b894ffce85d7b412fc1b36f88fe0",
-          :constants => ["Amazing"]
+          :namespaces => ["amazing"]
         }
       }
 
+      root_file = File.join(Thor::Util.thor_root, "thor.yml")
+
       # Stub load and save to avoid thor.yaml from being overwritten
-      stub(YAML).load_file { @original_yaml }
-      stub(File).exists?(File.join(Thor::Util.thor_root, "thor.yml")){ true }
-      stub(File).open(File.join(Thor::Util.thor_root, "thor.yml"), "w")
+      YAML.stub!(:load_file).and_return(@original_yaml)
+      File.stub!(:exists?).with(root_file).and_return(true)
+      File.stub!(:open).with(root_file, "w")
     end
 
     describe "list" do
       it "gives a list of the available tasks" do
         ARGV.replace ["list"]
         content = capture(:stdout) { Thor::Runner.start }
-        content.must =~ /amazing:describe NAME \[\-\-forcefully\]\s+# say that someone is amazing/m
+        content.must =~ /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 }.must =~ /my_counter N \[N\]/
+        capture(:stdout) { Thor::Runner.start }.must =~ /my_counter N/
       end
 
       it "can filter a list of the available tasks by --group" do
@@ -141,33 +143,19 @@ describe Thor::Runner do
 
       it "presents tasks in the default namespace with an empty namespace" do
         ARGV.replace ["list"]
-        capture(:stdout) { Thor::Runner.start }.must =~ /^:test\s+# prints 'test'/m
+        capture(:stdout) { Thor::Runner.start }.must =~ /^thor :test\s+# prints 'test'/m
       end
 
       it "runs tasks with an empty namespace from the default namespace" do
         ARGV.replace [":test"]
         capture(:stdout) { Thor::Runner.start }.must == "test\n"
       end
-
-      it "updates the yaml file when invoked" do
-        capture(:stdout) { Thor::Runner.start(["list"]) }
-        @original_yaml["random"][:namespaces].must == ["amazing"]
-      end
-    end
-
-    describe "update" do
-      it "updates existing thor files" do
-        mock.instance_of(Thor::Runner).install(@original_yaml["random"][:location]) { true }
-        stub(File).delete(File.join(Thor::Util.thor_root, @original_yaml["random"][:filename]))
-        silence(:stdout) { Thor::Runner.start(["update", "random"]) }
-      end
     end
 
     describe "uninstall" do
       before(:each) do
-        stub.instance_of(Thor::Runner).save_yaml(anything)
-        stub(File).delete(anything)
-        stub(@original_yaml).delete(anything)
+        path = File.join(Thor::Util.thor_root, @original_yaml["random"][:filename])
+        FileUtils.should_receive(:rm_rf).with(path)
       end
 
       it "uninstalls existing thor modules" do
@@ -177,26 +165,34 @@ describe Thor::Runner do
 
     describe "installed" do
       before(:each) do
-        stub(Dir).[](anything) { [] }
+        Dir.should_receive(:[]).and_return([])
       end
 
       it "displays the modules installed in a pretty way" do
         stdout = capture(:stdout) { Thor::Runner.start(["installed"]) }
         stdout.must =~ /random\s*amazing/
-        stdout.must =~ /amazing:describe NAME \[\-\-forcefully\]\s+# say that someone is amazing/m
+        stdout.must =~ /amazing:describe NAME\s+# say that someone is amazing/m
       end
     end
 
-    describe "install" do
-      it "installs thor files" do
-        ARGV.replace ["install", @location]
+    describe "install/update" do
+      before(:each) do
+        FileUtils.stub!(:mkdir_p)
+        FileUtils.stub!(:touch)
+        $stdin.stub!(:gets).and_return("Y")
 
-        # Stubs for the file system interactions
-        stub.instance_of(Thor::Base.shell).no? { false }
-        stub(FileUtils).mkdir_p
-        stub(FileUtils).touch
+        path = File.join(Thor::Util.thor_root, Digest::MD5.hexdigest(@location + "random"))
+        File.should_receive(:open).with(path, "w")
+      end
 
-        mock(File).open(File.join(Thor::Util.thor_root, Digest::MD5.hexdigest(@location + "random")), "w")
+      it "updates existing thor files" do
+        path = File.join(Thor::Util.thor_root, @original_yaml["random"][:filename])
+        File.should_receive(:delete).with(path)
+        silence(:stdout) { Thor::Runner.start(["update", "random"]) }
+      end
+
+      it "installs thor files" do
+        ARGV.replace ["install", @location]
         silence(:stdout) { Thor::Runner.start }
       end
     end

data/spec/shell/basic_spec.rb

@@ -17,107 +17,85 @@ describe Thor::Shell::Basic do
 
   describe "#ask" do
     it "prints a message to the user and gets the response" do
-      mock($stdout).print("Should I overwrite it? ")
-      mock($stdin).gets{ "Sure" }
+      $stdout.should_receive(:print).with("Should I overwrite it? ")
+      $stdin.should_receive(:gets).and_return('Sure')
       shell.ask("Should I overwrite it?").must == "Sure"
     end
   end
 
   describe "#yes?" do
     it "asks the user and returns true if the user replies yes" do
-      mock($stdout).print("Should I overwrite it? ")
-      mock($stdin).gets{ "y" }
+      $stdout.should_receive(:print).with("Should I overwrite it? ")
+        $stdin.should_receive(:gets).and_return('y')
       shell.yes?("Should I overwrite it?").must be_true
 
-      mock($stdout).print("Should I overwrite it? ")
-      mock($stdin).gets{ "n" }
+      $stdout.should_receive(:print).with("Should I overwrite it? ")
+        $stdin.should_receive(:gets).and_return('n')
       shell.yes?("Should I overwrite it?").must_not be_true
     end
   end
 
   describe "#no?" do
     it "asks the user and returns true if the user replies no" do
-      mock($stdout).print("Should I overwrite it? ")
-      mock($stdin).gets{ "n" }
+      $stdout.should_receive(:print).with("Should I overwrite it? ")
+        $stdin.should_receive(:gets).and_return('n')
       shell.no?("Should I overwrite it?").must be_true
 
-      mock($stdout).print("Should I overwrite it? ")
-      mock($stdin).gets{ "Yes" }
+      $stdout.should_receive(:print).with("Should I overwrite it? ")
+        $stdin.should_receive(:gets).and_return('Yes')
       shell.no?("Should I overwrite it?").must be_false
     end
   end
 
   describe "#say" do
     it "prints a message to the user" do
-      mock($stdout).puts("Running...")
+      $stdout.should_receive(:puts).with("Running...")
       shell.say("Running...")
     end
 
     it "prints a message to the user without new line if it ends with a whitespace" do
-      mock($stdout).print("Running... ")
+      $stdout.should_receive(:print).with("Running... ")
       shell.say("Running... ")
     end
 
     it "prints a message to the user without new line" do
-      mock($stdout).print("Running...")
+      $stdout.should_receive(:print).with("Running...")
       shell.say("Running...", nil, false)
     end
   end
 
   describe "#say_status" do
     it "prints a message to the user with status" do
-      mock($stdout).puts("      create  ~/.thor/task.thor")
+      $stdout.should_receive(:puts).with("      create  ~/.thor/task.thor")
       shell.say_status(:create, "~/.thor/task.thor")
     end
 
     it "always use new line" do
-      mock($stdout).puts("      create  ")
+      $stdout.should_receive(:puts).with("      create  ")
       shell.say_status(:create, "")
     end
 
     it "does not print a message if base is set to quiet" do
       base = MyCounter.new [1,2]
-      mock(base).options { Hash.new(:quiet => true) }
+      base.should_receive(:options).and_return(:quiet => true)
 
-      dont_allow($stdout).puts
+      $stdout.should_not_receive(:puts)
       shell.base = base
       shell.say_status(:created, "~/.thor/task.thor")
     end
 
     it "does not print a message if log status is set to false" do
-      dont_allow($stdout).puts
+      $stdout.should_not_receive(:puts)
       shell.say_status(:created, "~/.thor/task.thor", false)
     end
 
     it "uses padding to set messages left margin" do
       shell.padding = 2
-      mock($stdout).puts("      create      ~/.thor/task.thor")
+      $stdout.should_receive(:puts).with("      create      ~/.thor/task.thor")
       shell.say_status(:create, "~/.thor/task.thor")
     end
   end
 
-  describe "#print_list" do
-    before(:each) do
-      @list = ["abc", "#123", "first three"]
-    end
-
-    it "prints a list" do
-      content = capture(:stdout){ shell.print_list(@list) }
-      content.must == <<-LIST
-abc
-#123
-first three
-LIST
-    end
-
-    it "prints a list inline" do
-      content = capture(:stdout){ shell.print_list(@list, :mode => :inline) }
-      content.must == <<-LIST
-abc, #123, and first three
-LIST
-    end
-  end
-
   describe "#print_table" do
     before(:each) do
       @table = []
@@ -141,41 +119,57 @@ TABLE
   abc  #123  first three
        #0    empty
   xyz  #786  last three
+TABLE
+    end
+
+    it "uses maximum terminal width" do
+      shell.should_receive(:terminal_width).and_return(20)
+      content = capture(:stdout){ shell.print_table(@table, :ident => 2, :truncate => true) }
+      content.must == <<-TABLE
+  abc  #123  firs...
+       #0    empty
+  xyz  #786  last...
 TABLE
     end
   end
 
   describe "#file_collision" do
     it "shows a menu with options" do
-      mock($stdout).print('Overwrite foo? (enter "h" for help) [Ynaqh] ')
-      mock($stdin).gets{ 'n' }
+      $stdout.should_receive(:print).with('Overwrite foo? (enter "h" for help) [Ynaqh] ')
+      $stdin.should_receive(:gets).and_return('n')
       shell.file_collision('foo')
     end
 
+    it "returns true if the user choose default option" do
+      $stdout.stub!(:print)
+      $stdin.should_receive(:gets).and_return('')
+      shell.file_collision('foo').must be_true
+    end
+
     it "returns false if the user choose no" do
-      stub($stdout).print
-      mock($stdin).gets{ 'n' }
+      $stdout.stub!(:print)
+      $stdin.should_receive(:gets).and_return('n')
       shell.file_collision('foo').must be_false
     end
 
     it "returns true if the user choose yes" do
-      stub($stdout).print
-      mock($stdin).gets{ 'y' }
+      $stdout.stub!(:print)
+      $stdin.should_receive(:gets).and_return('y')
       shell.file_collision('foo').must be_true
     end
 
     it "shows help usage if the user choose help" do
-      stub($stdout).print
-      mock($stdin).gets{ 'h' }
-      mock($stdin).gets{ 'n' }
+      $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.must =~ /h \- help, show this help/
     end
 
     it "quits if the user choose quit" do
-      stub($stdout).print
-      mock($stdout).puts('Aborting...')
-      mock($stdin).gets{ 'q' }
+      $stdout.stub!(:print)
+      $stdout.should_receive(:puts).with('Aborting...')
+      $stdin.should_receive(:gets).and_return('q')
 
       lambda {
         shell.file_collision('foo')
@@ -183,27 +177,27 @@ TABLE
     end
 
     it "always returns true if the user choose always" do
-      mock($stdout).print('Overwrite foo? (enter "h" for help) [Ynaqh] ')
-      mock($stdin).gets{ 'a' }
+      $stdout.should_receive(:print).with('Overwrite foo? (enter "h" for help) [Ynaqh] ')
+      $stdin.should_receive(:gets).and_return('a')
 
       shell.file_collision('foo').must be_true
 
-      dont_allow($stdout).print
+      $stdout.should_not_receive(:print)
       shell.file_collision('foo').must be_true
     end
 
     describe "when a block is given" do
       it "displays diff options to the user" do
-        mock($stdout).print('Overwrite foo? (enter "h" for help) [Ynaqdh] ')
-        mock($stdin).gets{ 's' }
+        $stdout.should_receive(:print).with('Overwrite foo? (enter "h" for help) [Ynaqdh] ')
+        $stdin.should_receive(:gets).and_return('s')
         shell.file_collision('foo'){ }
       end
 
       it "invokes the diff command" do
-        stub($stdout).print
-        mock($stdin).gets{ 'd' }
-        mock($stdin).gets{ 'n' }
-        mock(shell).system(/diff -u/)
+        $stdout.stub!(:print)
+        $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'){ } }
       end
     end

data/spec/shell/color_spec.rb

@@ -7,19 +7,19 @@ describe Thor::Shell::Color do
 
   describe "#say" do
     it "set the color if specified" do
-      mock($stdout).puts("\e[32mWow! Now we have colors!\e[0m")
+      $stdout.should_receive(:puts).with("\e[32mWow! Now we have colors!\e[0m")
       shell.say "Wow! Now we have colors!", :green
     end
 
     it "does not use a new line even with colors" do
-      mock($stdout).print("\e[32mWow! Now we have colors! \e[0m")
+      $stdout.should_receive(:print).with("\e[32mWow! Now we have colors! \e[0m")
       shell.say "Wow! Now we have colors! ", :green
     end
   end
 
   describe "#say_status" do
     it "uses color to say status" do
-      mock($stdout).puts("\e[1m\e[31m    conflict\e[0m  README")
+      $stdout.should_receive(:puts).with("\e[1m\e[31m    conflict\e[0m  README")
       shell.say_status :conflict, "README", :red
     end
   end
@@ -27,9 +27,9 @@ describe Thor::Shell::Color do
   describe "#file_collision" do
     describe "when a block is given" do
       it "invokes the diff command" do
-        stub($stdout).print
-        mock($stdin).gets{ 'd' }
-        mock($stdin).gets{ 'n' }
+        $stdout.stub!(:print)
+        $stdin.should_receive(:gets).and_return('d')
+        $stdin.should_receive(:gets).and_return('n')
 
         output = capture(:stdout){ shell.file_collision('spec/fixtures/doc/README'){ "README\nEND\n" } }
         output.must =~ /\e\[31m\- __start__\e\[0m/

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -2,12 +2,15 @@ $TESTING=true
 
 $:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
 require 'thor'
+require 'thor/group'
 require 'stringio'
 
 require 'rubygems'
-require 'rr'
+require 'rdoc'
 require 'diff/lcs' # You need diff/lcs installed to run specs (but not to run Thor).
 
+$thor_runner = true
+
 # Load fixtures
 load File.join(File.dirname(__FILE__), "fixtures", "task.thor")
 load File.join(File.dirname(__FILE__), "fixtures", "group.thor")
@@ -25,8 +28,6 @@ Kernel.module_eval do
 end
 
 Spec::Runner.configure do |config|
-  config.mock_with :rr
-
   def capture(stream)
     begin
       stream = stream.to_s
@@ -48,5 +49,5 @@ Spec::Runner.configure do |config|
     File.join(File.dirname(__FILE__), 'sandbox')
   end
 
-  alias silence capture
+  alias :silence :capture
 end

data/spec/task_spec.rb

@@ -10,32 +10,22 @@ describe Thor::Task do
   end
 
   describe "#formatted_usage" do
-    it "shows usage with options" do
-      task('foo' => true, :bar => :required).formatted_usage.must == "can_has --bar=BAR [--foo]"
-    end
-
     it "includes namespace within usage" do
-      stub(Object).namespace{ "foo" }
-      stub(Object).arguments{ [] }
-      task(:bar => :required).formatted_usage(Object, true).must == "foo:can_has --bar=BAR"
-    end
-
-    it "does not show options if required" do
-      stub(Object).namespace{ "foo" }
-      stub(Object).arguments{ [] }
-      task(:bar => :required).formatted_usage(Object, true, false).must == "foo:can_has"
+      Object.stub!(:namespace).and_return("foo")
+      Object.stub!(:arguments).and_return([])
+      task(:bar => :required).formatted_usage(Object).must == "foo:can_has --bar=BAR"
     end
 
     it "removes default from namespace" do
-      stub(Object).namespace{ "default:foo" }
-      stub(Object).arguments{ [] }
-      task(:bar => :required).formatted_usage(Object, true).must == ":foo:can_has --bar=BAR"
+      Object.stub!(:namespace).and_return("default:foo")
+      Object.stub!(:arguments).and_return([])
+      task(:bar => :required).formatted_usage(Object).must == ":foo:can_has --bar=BAR"
     end
 
     it "injects arguments into usage" do
-      stub(Object).namespace{ "foo" }
-      stub(Object).arguments{ [ Thor::Argument.new(:bar, nil, true, :string) ] }
-      task(:foo => true).formatted_usage(Object).must == "can_has BAR [--foo]"
+      Object.stub!(:namespace).and_return("foo")
+      Object.stub!(:arguments).and_return([ Thor::Argument.new(:bar, nil, true, :string) ])
+      task(:foo => :required).formatted_usage(Object).must == "foo:can_has BAR --foo=FOO"
     end
   end
 
@@ -64,25 +54,17 @@ describe Thor::Task do
 
   describe "#run" do
     it "runs a task by calling a method in the given instance" do
-      mock = mock!.send("can_has", 1, 2, 3).subject
+      mock = mock()
+      mock.should_receive(:send).with("can_has", 1, 2, 3)
       task.run(mock, [1, 2, 3])
     end
 
     it "raises an error if the method to be invoked is private" do
-      mock = mock!.private_methods{ [ 'can_has' ] }.subject
+      mock = mock()
+      mock.should_receive(:private_methods).and_return(['can_has'])
       lambda {
         task.run(mock)
-      }.must raise_error(Thor::UndefinedTaskError, "the 'can_has' task of Object is private")
-    end
-  end
-
-  describe "#short_description" do
-    it "returns the first line of the description" do
-      Thor::Task.new(:task, "I can has\ncheezburger", "can_has").short_description == "I can has"
-    end
-
-    it "returns the whole description if it's one line" do
-      Thor::Task.new(:task, "I can has cheezburger", "can_has").short_description == "I can has cheezburger"
+      }.must raise_error(Thor::UndefinedTaskError, "the 'can_has' task of Spec::Mocks::Mock is private")
     end
   end
 end

data/spec/thor_spec.rb

@@ -72,7 +72,7 @@ describe Thor do
 
     describe "when :for is supplied" do
       it "overwrites a previous defined task" do
-        capture(:stdout) { MyChildScript.start(["help"]) }.must =~ /animal KIND \[\-\-other=OTHER\]\s+# fish around/m
+        capture(:stdout) { MyChildScript.start(["help"]) }.must =~ /animal KIND \s+# fish around/m
       end
     end
   end
@@ -133,7 +133,7 @@ describe Thor do
     end
 
     it "raises when an exception happens within the task call" do
-      lambda { MyScript.start(["call_myself_with_wrong_arity"]) }.must raise_error
+      lambda { MyScript.start(["call_myself_with_wrong_arity"]) }.must raise_error(ArgumentError)
     end
   end
 
@@ -148,25 +148,31 @@ describe Thor do
       end
 
       it "provides useful help info for the help method itself" do
-        @content.must =~ /help \[TASK\]\s+# Describe available tasks/m
+        @content.must =~ /help \[TASK\]\s+# Describe available tasks/
       end
 
       it "provides useful help info for a method with params" do
-        @content.must =~ /animal TYPE\s+# horse around/m
+        @content.must =~ /animal TYPE\s+# horse around/
+      end
+
+      it "uses the maximum terminal size to show tasks" do
+        @shell.should_receive(:terminal_width).and_return(80)
+        content = capture(:stdout){ MyScript.help(shell) }
+        content.must =~ /aaa\.\.\.$/
       end
 
       it "provides description for tasks from classes in the same namespace" do
-        @content.must =~ /baz\s+# do some bazing/m
+        @content.must =~ /baz\s+# do some bazing/
       end
 
       it "shows superclass tasks" do
         content = capture(:stdout){ MyChildScript.help(shell) }
-        content.must =~ /foo BAR \[\-\-force\]\s+# do some fooing/m
+        content.must =~ /foo BAR \s+# do some fooing/
       end
 
       it "shows class options information" do
         content = capture(:stdout){ MyChildScript.help(shell) }
-        content.must =~ /Class options\:/
+        content.must =~ /Options\:/
         content.must =~ /\[\-\-param=N\]/
       end
 
@@ -178,11 +184,11 @@ describe Thor do
 
     describe "for a specific task" do
       it "provides full help info when talking about a specific task" do
-        capture(:stdout) { MyScript.help(shell, "foo") }.must == <<END
+        capture(:stdout) { MyScript.task_help(shell, "foo") }.must == <<END
 Usage:
-  foo BAR
+  thor my_script:foo BAR
 
-Method options:
+Options:
   [--force]  # Force to do some fooing
 
 do some fooing
@@ -193,25 +199,18 @@ END
 
       it "raises an error if the task can't be found" do
         lambda {
-          MyScript.help(shell, "unknown")
+          MyScript.task_help(shell, "unknown")
         }.must raise_error(Thor::Error, "task 'unknown' could not be found in namespace 'my_script'")
       end
     end
 
-    describe "options" do
-      it "shows the namespace if required" do
-        capture(:stdout){ MyScript.help(shell, nil, :namespace => true) }.must =~ /my_script:foo BAR/
-      end
-
-      it "does not show superclass tasks if required" do
-        capture(:stdout){ MyScript.help(shell, nil, :short => true) }.must_not =~ /help/
+    describe "instance method" do
+      it "calls the class method" do
+        capture(:stdout){ MyScript.start(["help"]) }.must =~ /Tasks:/
       end
-    end
 
-    describe "instance method" do
       it "calls the class method" do
-        stub(MyScript).help(mock.instance_of(Thor::Base.shell), nil, :namespace => nil)
-        MyScript.start(["help"])
+        capture(:stdout){ MyScript.start(["help", "foo"]) }.must =~ /Usage:/
       end
     end
   end