thor 0.9.9 → 0.11.5

data/spec/core_ext/hash_with_indifferent_access_spec.rb

@@ -0,0 +1,43 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'thor/core_ext/hash_with_indifferent_access'
+
+describe Thor::CoreExt::HashWithIndifferentAccess do
+  before(:each) do
+    @hash = Thor::CoreExt::HashWithIndifferentAccess.new :foo => 'bar', 'baz' => 'bee', :force => true
+  end
+
+  it "has values accessible by either strings or symbols" do
+    @hash['foo'].must == 'bar'
+    @hash[:foo].must  == 'bar'
+
+    @hash.values_at(:foo, :baz).must == ['bar', 'bee']
+    @hash.delete(:foo).must == 'bar'
+  end
+
+  it "handles magic boolean predicates" do
+    @hash.force?.must be_true
+    @hash.foo?.must be_true
+    @hash.nothing?.must be_false
+  end
+
+  it "handles magic comparisions" do
+    @hash.foo?('bar').must be_true
+    @hash.foo?('bee').must be_false
+  end
+
+  it "maps methods to keys" do
+    @hash.foo.must == @hash['foo']
+  end
+
+  it "merges keys independent if they are symbols or strings" do
+    @hash.merge!('force' => false, :baz => "boom")
+    @hash[:force].must == false
+    @hash[:baz].must == "boom"
+  end
+
+  it "creates a new hash by merging keys independent if they are symbols or strings" do
+    other = @hash.merge('force' => false, :baz => "boom")
+    other[:force].must == false
+    other[:baz].must == "boom"
+  end
+end

data/spec/core_ext/ordered_hash_spec.rb

@@ -0,0 +1,115 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'thor/core_ext/ordered_hash'
+
+describe Thor::CoreExt::OrderedHash do
+  before :each do
+    @hash = Thor::CoreExt::OrderedHash.new
+  end
+
+  describe "without any items" do
+    it "returns nil for an undefined key" do
+      @hash["foo"].must be_nil
+    end
+
+    it "doesn't iterate through any items" do
+      @hash.each { fail }
+    end
+
+    it "has an empty key and values list" do
+      @hash.keys.must be_empty
+      @hash.values.must be_empty
+    end
+
+    it "must be empty" do
+      @hash.must be_empty
+    end
+  end
+
+  describe "with several items" do
+    before :each do
+      @hash[:foo] = "Foo!"
+      @hash[:bar] = "Bar!"
+      @hash[:baz] = "Baz!"
+      @hash[:bop] = "Bop!"
+      @hash[:bat] = "Bat!"
+    end
+
+    it "returns nil for an undefined key" do
+      @hash[:boom].must be_nil
+    end
+
+    it "returns the value for each key" do
+      @hash[:foo].must == "Foo!"
+      @hash[:bar].must == "Bar!"
+      @hash[:baz].must == "Baz!"
+      @hash[:bop].must == "Bop!"
+      @hash[:bat].must == "Bat!"
+    end
+
+    it "iterates through the keys and values in order of assignment" do
+      arr = []
+      @hash.each do |key, value|
+        arr << [key, value]
+      end
+      arr.must == [[:foo, "Foo!"], [:bar, "Bar!"], [:baz, "Baz!"],
+                     [:bop, "Bop!"], [:bat, "Bat!"]]
+    end
+
+    it "returns the keys in order of insertion" do
+      @hash.keys.must == [:foo, :bar, :baz, :bop, :bat]
+    end
+
+    it "returns the values in order of insertion" do
+      @hash.values.must == ["Foo!", "Bar!", "Baz!", "Bop!", "Bat!"]
+    end
+
+    it "does not move an overwritten node to the end of the ordering" do
+      @hash[:baz] = "Bip!"
+      @hash.values.must == ["Foo!", "Bar!", "Bip!", "Bop!", "Bat!"]
+
+      @hash[:foo] = "Bip!"
+      @hash.values.must == ["Bip!", "Bar!", "Bip!", "Bop!", "Bat!"]
+
+      @hash[:bat] = "Bip!"
+      @hash.values.must == ["Bip!", "Bar!", "Bip!", "Bop!", "Bip!"]
+    end
+
+    it "appends another ordered hash while preserving ordering" do
+      other_hash = Thor::CoreExt::OrderedHash.new
+      other_hash[1] = "one"
+      other_hash[2] = "two"
+      other_hash[3] = "three"
+      @hash.merge(other_hash).values.must == ["Foo!", "Bar!", "Baz!", "Bop!", "Bat!", "one", "two", "three"]
+    end
+
+    it "overwrites hash keys with matching appended keys" do
+      other_hash = Thor::CoreExt::OrderedHash.new
+      other_hash[:bar] = "bar"
+      @hash.merge(other_hash)[:bar].must == "bar"
+      @hash[:bar].must == "Bar!"
+    end
+
+    it "converts to an array" do
+      @hash.to_a.must == [[:foo, "Foo!"], [:bar, "Bar!"], [:baz, "Baz!"], [:bop, "Bop!"], [:bat, "Bat!"]]
+    end
+
+    it "must not be empty" do
+      @hash.must_not be_empty
+    end
+
+    it "deletes values from hash" do
+      @hash.delete(:baz).must == "Baz!"
+      @hash.values.must == ["Foo!", "Bar!", "Bop!", "Bat!"]
+
+      @hash.delete(:foo).must == "Foo!"
+      @hash.values.must == ["Bar!", "Bop!", "Bat!"]
+
+      @hash.delete(:bat).must == "Bat!"
+      @hash.values.must == ["Bar!", "Bop!"]
+    end
+
+    it "returns nil if the value to be deleted can't be found" do
+      @hash.delete(:nothing).must be_nil
+    end
+  end
+end

data/spec/fixtures/bundle/execute.rb

@@ -0,0 +1,6 @@
+class Execute < Thor
+  desc "ls", "Execute ls"
+  def ls
+    system "ls"
+  end
+end

data/spec/fixtures/doc/config.rb

@@ -0,0 +1 @@
+class <%= @klass %>; end

data/spec/group_spec.rb

@@ -0,0 +1,177 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Thor::Group do
+  describe "#start" do
+    it "invokes all the tasks under the Thor group" do
+      MyCounter.start(["1", "2", "--third", "3"]).must == [ 1, 2, 3 ]
+    end
+
+    it "uses argument default value" do
+      MyCounter.start(["1", "--third", "3"]).must == [ 1, 2, 3 ]
+    end
+
+    it "invokes all the tasks in the Thor group and his parents" do
+      BrokenCounter.start(["1", "2", "--third", "3"]).must == [ nil, 2, 3, false, 5 ]
+    end
+
+    it "raises an error if a required argument is added after a non-required" do
+      lambda {
+        MyCounter.argument(:foo, :type => :string)
+      }.must raise_error(ArgumentError, 'You cannot have "foo" as required argument after the non-required argument "second".')
+    end
+
+    it "raises when an exception happens within the task call" do
+      lambda { BrokenCounter.start(["1", "2", "--fail"]) }.must raise_error
+    end
+
+    it "raises an error when a Thor group task expects arguments" do
+      lambda { WhinyGenerator.start }.must raise_error(ArgumentError, /Are you sure it has arity equals to 0\?/)
+    end
+
+    it "invokes help message if any of the shortcuts is given" do
+      stub(MyCounter).help
+      MyCounter.start(["-h"])
+    end
+  end
+
+  describe "#desc" do
+    it "sets the description for a given class" do
+      MyCounter.desc.must == "Description:\n  This generator run three tasks: one, two and three.\n"
+    end
+
+    it "can be inherited" do
+      BrokenCounter.desc.must == "Description:\n  This generator run three tasks: one, two and three.\n"
+    end
+
+    it "can be nil" do
+      WhinyGenerator.desc.must be_nil
+    end
+  end
+
+  describe "#help" do
+    before(:each) do
+      @content = capture(:stdout){ MyCounter.help(Thor::Base.shell.new) }
+    end
+
+    it "provides usage information" do
+      @content.must =~ /my_counter N \[N\]/
+    end
+
+    it "shows description" do
+      @content.must =~ /Description:/
+      @content.must =~ /This generator run three tasks: one, two and three./
+    end
+
+    it "shows options information" 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
+    before(:each) do
+      @content = capture(:stdout){ E.start }
+    end
+
+    it "allows to invoke a class from the class binding" do
+      @content.must =~ /1\n2\n3\n4\n5\n/
+    end
+
+    it "shows invocation information to the user" do
+      @content.must =~ /invoke  Defined/
+    end
+
+    it "uses padding on status generated by the invoked class" do
+      @content.must =~ /finished    counting/
+    end
+
+    it "allows invocation to be configured with blocks" do
+      capture(:stdout) do
+        F.start.must == ["Valim, Jose"]
+      end
+    end
+
+    it "shows invoked options on help" do
+      content = capture(:stdout){ E.help(Thor::Base.shell.new) }
+      content.must =~ /Defined options:/
+      content.must =~ /\[--unused\]/
+      content.must =~ /# This option has no use/
+    end
+  end
+
+  describe "#invoke_from_option" do
+    describe "with default type" do
+      before(:each) do
+        @content = capture(:stdout){ G.start }
+      end
+
+      it "allows to invoke a class from the class binding by a default option" do
+        @content.must =~ /1\n2\n3\n4\n5\n/
+      end
+
+      it "does not invoke if the option is nil" do
+        capture(:stdout){ G.start(["--skip-invoked"]) }.must_not =~ /invoke/
+      end
+
+      it "prints a message if invocation cannot be found" do
+        content = capture(:stdout){ G.start(["--invoked", "unknown"]) }
+        content.must =~ /error  unknown \[not found\]/
+      end
+
+      it "allows to invoke a class from the class binding by the given option" do
+        content = capture(:stdout){ G.start(["--invoked", "e"]) }
+        content.must =~ /invoke  e/
+      end
+
+      it "shows invocation information to the user" do
+        @content.must =~ /invoke  defined/
+      end
+
+      it "uses padding on status generated by the invoked class" do
+        @content.must =~ /finished    counting/
+      end
+
+      it "shows invoked options on help" do
+        content = capture(:stdout){ G.help(Thor::Base.shell.new) }
+        content.must =~ /defined options:/
+        content.must =~ /\[--unused\]/
+        content.must =~ /# This option has no use/
+      end
+    end
+
+    describe "with boolean type" do
+      before(:each) do
+        @content = capture(:stdout){ H.start }
+      end
+
+      it "allows to invoke a class from the class binding by a default option" do
+        @content.must =~ /1\n2\n3\n4\n5\n/
+      end
+
+      it "does not invoke if the option is false" do
+        capture(:stdout){ H.start(["--no-defined"]) }.must_not =~ /invoke/
+      end
+
+      it "shows invocation information to the user" do
+        @content.must =~ /invoke  defined/
+      end
+
+      it "uses padding on status generated by the invoked class" do
+        @content.must =~ /finished    counting/
+      end
+
+      it "shows invoked options on help" do
+        content = capture(:stdout){ H.help(Thor::Base.shell.new) }
+        content.must =~ /defined options:/
+        content.must =~ /\[--unused\]/
+        content.must =~ /# This option has no use/
+      end
+    end
+  end
+end

data/spec/invocation_spec.rb

@@ -0,0 +1,107 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'thor/base'
+
+describe Thor::Invocation do
+  describe "#invoke" do
+    it "invokes a task inside another task" do
+      capture(:stdout){ A.new.invoke(:two) }.must == "2\n3\n"
+    end
+
+    it "invokes a task just once" do
+      capture(:stdout){ A.new.invoke(:one) }.must == "1\n2\n3\n"
+    end
+
+    it "invokes a task just once even if they belongs to different classes" do
+      capture(:stdout){ Defined.new.invoke(:one) }.must == "1\n2\n3\n4\n5\n"
+    end
+
+    it "invokes a task with arguments" do
+      A.new.invoke(:five, [5]).must be_true
+      A.new.invoke(:five, [7]).must be_false
+    end
+
+    it "invokes the default task if none is given to a Thor class" do
+      content = capture(:stdout){ A.new.invoke("b") }
+      content.must =~ /Tasks/
+      content.must =~ /LAST_NAME/
+    end
+
+    it "accepts a class as argument without a task to invoke" do
+      content = capture(:stdout){ A.new.invoke(B) }
+      content.must =~ /Tasks/
+      content.must =~ /LAST_NAME/
+    end
+
+    it "accepts a class as argument with a task to invoke" do
+      base = A.new([], :last_name => "Valim")
+      base.invoke(B, :one, ["Jose"]).must == "Valim, Jose"
+    end
+
+    it "accepts a Thor instance as argument" do
+      invoked = B.new([], :last_name => "Valim")
+      base = A.new
+      base.invoke(invoked, :one, ["Jose"]).must == "Valim, Jose"
+      base.invoke(invoked, :one, ["Jose"]).must be_nil
+    end
+
+    it "allows customized options to be given" do
+      base = A.new([], :last_name => "Wrong")
+      base.invoke(B, :one, ["Jose"], :last_name => "Valim").must == "Valim, Jose"
+    end
+
+    it "reparses options in the new class" do
+      A.start(["invoker", "--last-name", "Valim"]).must == "Valim, Jose"
+    end
+
+    it "shares initialize options with invoked class" do
+      A.new([], :foo => :bar).invoke("b:two").must == { "foo" => :bar }
+    end
+
+    it "dump configuration values to be used in the invoked class" do
+      base = A.new
+      base.invoke("b:three").shell.must == base.shell
+    end
+
+    it "allow extra configuration values to be given" do
+      base, shell = A.new, Thor::Base.shell.new
+      base.invoke("b:three", [], {}, :shell => shell).shell.must == shell
+    end
+
+    it "invokes a Thor::Group and all of its tasks" do
+      capture(:stdout){ A.new.invoke(:c) }.must == "1\n2\n3\n"
+    end
+
+    it "does not invoke a Thor::Group twice" do
+      base = A.new
+      silence(:stdout){ base.invoke(:c) }
+      capture(:stdout){ base.invoke(:c) }.must be_empty
+    end
+
+    it "does not invoke any of Thor::Group tasks twice" do
+      base = A.new
+      silence(:stdout){ base.invoke(:c) }
+      capture(:stdout){ base.invoke("c:one") }.must be_empty
+    end
+
+    it "raises Thor::UndefinedTaskError if the task can't be found" do
+      lambda do
+        A.new.invoke("foo:bar")
+      end.must raise_error(Thor::UndefinedTaskError)
+    end
+
+    it "raises Thor::UndefinedTaskError if the task can't be found even if all tasks where already executed" do
+      base = C.new
+      silence(:stdout){ base.invoke }
+
+      lambda do
+        base.invoke("foo:bar")
+      end.must raise_error(Thor::UndefinedTaskError)
+    end
+
+    it "raises an error if a non Thor class is given" do
+      lambda do
+        A.new.invoke(Object)
+      end.must raise_error(RuntimeError, "Expected Thor class, got Object")
+    end
+  end
+end