thor 0.12.0 → 0.12.3

data/spec/fixtures/group.thor

@@ -0,0 +1,83 @@
+class MyCounter < Thor::Group
+  include Thor::Actions
+  add_runtime_options!
+
+  def self.get_from_super
+    from_superclass(:get_from_super, 13)
+  end
+
+  def self.source_root
+    File.expand_path(File.dirname(__FILE__))
+  end
+  source_paths << File.expand_path("broken", File.dirname(__FILE__))
+
+  argument :first,     :type => :numeric
+  argument :second,    :type => :numeric, :default => 2
+
+  class_option :third,  :type => :numeric, :desc => "The third argument", :default => 3,
+                        :banner => "THREE", :aliases => "-t"
+  class_option :fourth, :type => :numeric, :desc => "The fourth argument"
+
+  desc <<-FOO
+Description:
+  This generator run three tasks: one, two and three.
+FOO
+
+  def one
+    first
+  end
+
+  def two
+    second
+  end
+
+  def three
+    options[:third]
+  end
+
+  def self.inherited(base)
+    super
+    base.source_paths.unshift(File.expand_path(File.join(File.dirname(__FILE__), "doc")))
+  end
+end
+
+class ClearCounter < MyCounter
+  remove_argument :first, :second, :undefine => true
+  remove_class_option :third
+
+  def self.source_root
+    File.expand_path(File.join(File.dirname(__FILE__), "bundle"))
+  end
+end
+
+class BrokenCounter < MyCounter
+  namespace "app:broken:counter"
+  class_option :fail, :type => :boolean, :default => false
+
+  class << self
+    undef_method :source_root
+  end
+
+  def one
+    options[:first]
+  end
+
+  def four
+    respond_to?(:fail)
+  end
+
+  def five
+    options[:fail] ? this_method_does_not_exist : 5
+  end
+end
+
+class WhinyGenerator < Thor::Group
+  include Thor::Actions
+
+  def self.source_root
+    File.expand_path(File.dirname(__FILE__))
+  end
+
+  def wrong_arity(required)
+  end
+end

data/spec/fixtures/invoke.thor

@@ -0,0 +1,112 @@
+class A < Thor
+  include Thor::Actions
+
+  desc "one", "invoke one"
+  def one
+    p 1
+    invoke :two
+    invoke :three
+  end
+
+  desc "two", "invoke two"
+  def two
+    p 2
+    invoke :three
+  end
+
+  desc "three", "invoke three"
+  def three
+    p 3
+  end
+
+  desc "four", "invoke four"
+  def four
+    p 4
+    invoke "defined:five"
+  end
+
+  desc "five N", "check if number is equal 5"
+  def five(number)
+    number == 5
+  end
+
+  desc "invoker", "invoke a b task"
+  def invoker(*args)
+    invoke :b, :one, ["Jose"]
+  end
+end
+
+class B < Thor
+  class_option :last_name, :type => :string
+
+  desc "one FIRST_NAME", "invoke one"
+  def one(first_name)
+    "#{options.last_name}, #{first_name}"
+  end
+
+  desc "two", "invoke two"
+  def two
+    options
+  end
+
+  desc "three", "invoke three"
+  def three
+    self
+  end
+end
+
+class C < Thor::Group
+  include Thor::Actions
+
+  def one
+    p 1
+  end
+
+  def two
+    p 2
+  end
+
+  def three
+    p 3
+  end
+end
+
+class Defined < Thor::Group
+  class_option :unused, :type => :boolean, :desc => "This option has no use"
+
+  def one
+    p 1
+    invoke "a:two"
+    invoke "a:three"
+    invoke "a:four"
+    invoke "defined:five"
+  end
+
+  def five
+    p 5
+  end
+
+  def print_status
+    say_status :finished, :counting
+  end
+end
+
+class E < Thor::Group
+  invoke Defined
+end
+
+class F < Thor::Group
+  invoke "b:one" do |instance, klass, task|
+    instance.invoke klass, task, [ "Jose" ], :last_name => "Valim"
+  end
+end
+
+class G < Thor::Group
+  class_option :invoked, :type => :string, :default => "defined"
+  invoke_from_option :invoked
+end
+
+class H < Thor::Group
+  class_option :defined, :type => :boolean, :default => true
+  invoke_from_option :defined
+end

data/spec/fixtures/script.thor

@@ -0,0 +1,130 @@
+class MyScript < Thor
+  group :script
+  default_task :example_default_task
+
+  map "-T" => :animal, ["-f", "--foo"] => :foo
+
+  desc "zoo", "zoo around"
+  def zoo
+    true
+  end
+
+  desc "animal TYPE", "horse around"
+
+  no_tasks do
+    def this_is_not_a_task
+    end
+  end
+
+  def animal(type)
+    [type]
+  end
+
+  desc "foo BAR", <<END
+do some fooing
+  This is more info!
+  Everyone likes more info!
+END
+  method_option :force, :type => :boolean, :desc => "Force to do some fooing"
+  def foo(bar)
+    [bar, options]
+  end
+
+  desc "example_default_task", "example!"
+  def example_default_task
+    options.empty? ? "default task" : options
+  end
+
+  desc "call_myself_with_wrong_arity", "get the right error"
+  def call_myself_with_wrong_arity
+    call_myself_with_wrong_arity(4)
+  end
+
+  desc "call_unexistent_method", "Call unexistent method inside a task"
+  def call_unexistent_method
+    boom!
+  end
+
+  desc "long_description", "a" * 80
+  def long_description
+  end
+
+  method_options :all => :boolean
+  desc "with_optional NAME", "invoke with optional name"
+  def with_optional(name=nil)
+    [ name, options ]
+  end
+
+  class AnotherScript < Thor
+    desc "baz", "do some bazing"
+    def baz
+    end
+  end
+
+  private
+
+    def method_missing(meth, *args)
+      if meth == :boom!
+        super
+      else
+        [meth, args]
+      end
+    end
+
+    desc "what", "what"
+    def what
+    end
+end
+
+class MyChildScript < MyScript
+  remove_task :bar
+
+  method_options :force => :boolean, :param => :numeric
+  def initialize(*args)
+    super
+  end
+
+  desc "zoo", "zoo around"
+  method_options :param => :required
+  def zoo
+    options
+  end
+
+  desc "animal TYPE", "horse around"
+  def animal(type)
+    [type, options]
+  end
+  method_option :other, :type => :string, :default => "method default", :for => :animal
+  desc "animal KIND", "fish around", :for => :animal
+
+  desc "boom", "explodes everything"
+  def boom
+  end
+
+  remove_task :boom, :undefine => true
+end
+
+module Scripts
+  class MyScript < MyChildScript
+    argument :accessor, :type => :string
+    class_options :force => :boolean
+    method_option :new_option, :type => :string, :for => :example_default_task
+
+    def zoo
+      self.accessor
+    end
+  end
+
+  class MyDefaults < Thor
+    namespace :default
+    desc "test", "prints 'test'"
+    def test
+      puts "test"
+    end
+  end
+
+  class ChildDefault < Thor
+    namespace "default:child"
+  end
+end
+

data/spec/fixtures/task.thor

@@ -0,0 +1,10 @@
+# module: random
+
+class Amazing < Thor
+  desc "describe NAME", "say that someone is amazing"
+  method_options :forcefully => :boolean
+  def describe(name, opts)
+    ret = "#{name} is amazing"
+    puts opts["forcefully"] ? ret.upcase : ret
+  end
+end

data/spec/group_spec.rb

@@ -29,7 +29,7 @@ describe Thor::Group do
     end
 
     it "invokes help message if any of the shortcuts is given" do
-      stub(MyCounter).help
+      MyCounter.should_receive(:help)
       MyCounter.start(["-h"])
     end
   end
@@ -66,12 +66,6 @@ describe Thor::Group do
       @content.must =~ /Options/
       @content.must =~ /\[\-\-third=THREE\]/
     end
-
-    it "shows only usage if a short help is required" do
-      content = capture(:stdout){ MyCounter.help(Thor::Base.shell.new, :short => true) }
-      content.must =~ /my_counter N \[N\]/
-      content.must_not =~ /Options/
-    end
   end
 
   describe "#invoke" do

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