millisami-thor 0.14.6

data/spec/group_spec.rb

@@ -0,0 +1,216 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Thor::Group do
+  describe "task" do
+    it "allows to use private methods from parent class as tasks" do
+      ChildGroup.start.should == ["bar", "foo", "baz"]
+      ChildGroup.new.baz("bar").should == "bar"
+    end
+  end
+
+  describe "#start" do
+    it "invokes all the tasks under the Thor group" do
+      MyCounter.start(["1", "2", "--third", "3"]).should == [ 1, 2, 3 ]
+    end
+
+    it "uses argument default value" do
+      MyCounter.start(["1", "--third", "3"]).should == [ 1, 2, 3 ]
+    end
+
+    it "invokes all the tasks in the Thor group and his parents" do
+      BrokenCounter.start(["1", "2", "--third", "3"]).should == [ 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)
+      }.should 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"]) }.should raise_error
+    end
+
+    it "raises an error when a Thor group task expects arguments" do
+      lambda { WhinyGenerator.start }.should 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
+      MyCounter.should_receive(:help)
+      MyCounter.start(["-h"])
+    end
+  end
+
+  describe "#desc" do
+    it "sets the description for a given class" do
+      MyCounter.desc.should == "Description:\n  This generator runs three tasks: one, two and three.\n"
+    end
+
+    it "can be inherited" do
+      BrokenCounter.desc.should == "Description:\n  This generator runs three tasks: one, two and three.\n"
+    end
+
+    it "can be nil" do
+      WhinyGenerator.desc.should 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.should =~ /my_counter N \[N\]/
+    end
+
+    it "shows description" do
+      @content.should =~ /Description:/
+      @content.should =~ /This generator runs three tasks: one, two and three./
+    end
+
+    it "shows options information" do
+      @content.should =~ /Options/
+      @content.should =~ /\[\-\-third=THREE\]/
+    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.should =~ /1\n2\n3\n4\n5\n/
+    end
+
+    it "shows invocation information to the user" do
+      @content.should =~ /invoke  Defined/
+    end
+
+    it "uses padding on status generated by the invoked class" do
+      @content.should =~ /finished    counting/
+    end
+
+    it "allows invocation to be configured with blocks" do
+      capture(:stdout) do
+        F.start.should == ["Valim, Jose"]
+      end
+    end
+
+    it "shows invoked options on help" do
+      content = capture(:stdout){ E.help(Thor::Base.shell.new) }
+      content.should =~ /Defined options:/
+      content.should =~ /\[--unused\]/
+      content.should =~ /# 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.should =~ /1\n2\n3\n4\n5\n/
+      end
+
+      it "does not invoke if the option is nil" do
+        capture(:stdout){ G.start(["--skip-invoked"]) }.should_not =~ /invoke/
+      end
+
+      it "prints a message if invocation cannot be found" do
+        content = capture(:stdout){ G.start(["--invoked", "unknown"]) }
+        content.should =~ /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.should =~ /invoke  e/
+      end
+
+      it "shows invocation information to the user" do
+        @content.should =~ /invoke  defined/
+      end
+
+      it "uses padding on status generated by the invoked class" do
+        @content.should =~ /finished    counting/
+      end
+
+      it "shows invoked options on help" do
+        content = capture(:stdout){ G.help(Thor::Base.shell.new) }
+        content.should =~ /defined options:/
+        content.should =~ /\[--unused\]/
+        content.should =~ /# 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.should =~ /1\n2\n3\n4\n5\n/
+      end
+
+      it "does not invoke if the option is false" do
+        capture(:stdout){ H.start(["--no-defined"]) }.should_not =~ /invoke/
+      end
+
+      it "shows invocation information to the user" do
+        @content.should =~ /invoke  defined/
+      end
+
+      it "uses padding on status generated by the invoked class" do
+        @content.should =~ /finished    counting/
+      end
+
+      it "shows invoked options on help" do
+        content = capture(:stdout){ H.help(Thor::Base.shell.new) }
+        content.should =~ /defined options:/
+        content.should =~ /\[--unused\]/
+        content.should =~ /# This option has no use/
+      end
+    end
+  end
+
+  describe "edge-cases" do
+    it "can handle boolean options followed by arguments" do
+      klass = Class.new(Thor::Group) do
+        desc "say hi to name"
+        argument :name, :type => :string
+        class_option :loud, :type => :boolean
+
+        def hi
+          name.upcase! if options[:loud]
+          "Hi #{name}"
+        end
+      end
+
+      klass.start(["jose"]).should == ["Hi jose"]
+      klass.start(["jose", "--loud"]).should == ["Hi JOSE"]
+      klass.start(["--loud", "jose"]).should == ["Hi JOSE"]
+    end
+
+    it "provides extra args as `args`" do
+      klass = Class.new(Thor::Group) do
+        desc "say hi to name"
+        argument :name, :type => :string
+        class_option :loud, :type => :boolean
+
+        def hi
+          name.upcase! if options[:loud]
+          out = "Hi #{name}"
+          out << ": " << args.join(", ") unless args.empty?
+          out
+        end
+      end
+
+      klass.start(["jose"]).should == ["Hi jose"]
+      klass.start(["jose", "--loud"]).should == ["Hi JOSE"]
+      klass.start(["--loud", "jose"]).should == ["Hi JOSE"]
+    end
+  end
+end

data/spec/invocation_spec.rb

@@ -0,0 +1,100 @@
+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) }.should == "2\n3\n"
+    end
+
+    it "invokes a task just once" do
+      capture(:stdout){ A.new.invoke(:one) }.should == "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) }.should == "1\n2\n3\n4\n5\n"
+    end
+
+    it "invokes a task with arguments" do
+      A.new.invoke(:five, [5]).should be_true
+      A.new.invoke(:five, [7]).should 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.should =~ /Tasks/
+      content.should =~ /LAST_NAME/
+    end
+
+    it "accepts a class as argument without a task to invoke" do
+      content = capture(:stdout){ A.new.invoke(B) }
+      content.should =~ /Tasks/
+      content.should =~ /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"]).should == "Valim, Jose"
+    end
+
+    it "allows customized options to be given" do
+      base = A.new([], :last_name => "Wrong")
+      base.invoke(B, :one, ["Jose"], :last_name => "Valim").should == "Valim, Jose"
+    end
+
+    it "reparses options in the new class" do
+      A.start(["invoker", "--last-name", "Valim"]).should == "Valim, Jose"
+    end
+
+    it "shares initialize options with invoked class" do
+      A.new([], :foo => :bar).invoke("b:two").should == { "foo" => :bar }
+    end
+
+    it "dump configuration values to be used in the invoked class" do
+      base = A.new
+      base.invoke("b:three").shell.should == 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.should == shell
+    end
+
+    it "invokes a Thor::Group and all of its tasks" do
+      capture(:stdout){ A.new.invoke(:c) }.should == "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) }.should 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") }.should be_empty
+    end
+
+    it "raises Thor::UndefinedTaskError if the task can't be found" do
+      lambda do
+        A.new.invoke("foo:bar")
+      end.should 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_all }
+
+      lambda do
+        base.invoke("foo:bar")
+      end.should raise_error(Thor::UndefinedTaskError)
+    end
+
+    it "raises an error if a non Thor class is given" do
+      lambda do
+        A.new.invoke(Object)
+      end.should raise_error(RuntimeError, "Expected Thor class, got Object")
+    end
+  end
+end

data/spec/parser/argument_spec.rb

@@ -0,0 +1,47 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'thor/parser'
+
+describe Thor::Argument do
+
+  def argument(name, type=:string, default=nil, required=nil)
+    @argument ||= Thor::Argument.new(name, nil, required || default.nil?, type, default)
+  end
+
+  describe "errors" do
+    it "raises an error if name is not supplied" do
+      lambda {
+        argument(nil)
+      }.should raise_error(ArgumentError, "Argument name can't be nil.")
+    end
+
+    it "raises an error if type is unknown" do
+      lambda {
+        argument(:task, :unknown)
+      }.should raise_error(ArgumentError, "Type :unknown is not valid for arguments.")
+    end
+
+    it "raises an error if argument is required and have default values" do
+      lambda {
+        argument(:task, :string, "bar", true)
+      }.should raise_error(ArgumentError, "An argument cannot be required and have default value.")
+    end
+  end
+
+  describe "#usage" do
+    it "returns usage for string types" do
+      argument(:foo, :string).usage.should == "FOO"
+    end
+
+    it "returns usage for numeric types" do
+      argument(:foo, :numeric).usage.should == "N"
+    end
+
+    it "returns usage for array types" do
+      argument(:foo, :array).usage.should == "one two three"
+    end
+
+    it "returns usage for hash types" do
+      argument(:foo, :hash).usage.should == "key:value"
+    end
+  end
+end

data/spec/parser/arguments_spec.rb

@@ -0,0 +1,65 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'thor/parser'
+
+describe Thor::Arguments do
+  def create(opts={})
+    arguments = opts.map do |type, default|
+      Thor::Argument.new(type.to_s, nil, default.nil?, type, default)
+    end
+
+    arguments.sort!{ |a,b| b.name <=> a.name }
+    @opt = Thor::Arguments.new(arguments)
+  end
+
+  def parse(*args)
+    @opt.parse(args)
+  end
+
+  describe "#parse" do
+    it "parses arguments in the given order" do
+      create :string => nil, :numeric => nil
+      parse("name", "13")["string"].should == "name"
+      parse("name", "13")["numeric"].should == 13
+    end
+
+    it "accepts hashes" do
+      create :string => nil, :hash => nil
+      parse("product", "title:string", "age:integer")["string"].should == "product"
+      parse("product", "title:string", "age:integer")["hash"].should == { "title" => "string", "age" => "integer"}
+      parse("product", "url:http://www.amazon.com/gp/product/123")["hash"].should == { "url" => "http://www.amazon.com/gp/product/123" }
+    end
+
+    it "accepts arrays" do
+      create :string => nil, :array => nil
+      parse("product", "title", "age")["string"].should == "product"
+      parse("product", "title", "age")["array"].should == %w(title age)
+    end
+
+    describe "with no inputs" do
+      it "and no arguments returns an empty hash" do
+        create
+        parse.should == {}
+      end
+
+      it "and required arguments raises an error" do
+        create :string => nil, :numeric => nil
+        lambda { parse }.should raise_error(Thor::RequiredArgumentMissingError, "No value provided for required arguments 'string', 'numeric'")
+      end
+
+      it "and default arguments returns default values" do
+        create :string => "name", :numeric => 13
+        parse.should == { "string" => "name", "numeric" => 13 }
+      end
+    end
+
+    it "returns the input if it's already parsed" do
+      create :string => nil, :hash => nil, :array => nil, :numeric => nil
+      parse("", 0, {}, []).should == { "string" => "", "numeric" => 0, "hash" => {}, "array" => [] }
+    end
+
+    it "returns the default value if none is provided" do
+      create :string => "foo", :numeric => 3.0
+      parse("bar").should == { "string" => "bar", "numeric" => 3.0 }
+    end
+  end
+end

data/spec/parser/option_spec.rb

@@ -0,0 +1,202 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'thor/parser'
+
+describe Thor::Option do
+  def parse(key, value)
+    Thor::Option.parse(key, value)
+  end
+
+  def option(name, *args)
+    @option ||= Thor::Option.new(name, *args)
+  end
+
+  describe "#parse" do
+
+    describe "with value as a symbol" do
+      describe "and symbol is a valid type" do
+        it "has type equals to the symbol" do
+          parse(:foo, :string).type.should == :string
+          parse(:foo, :numeric).type.should == :numeric
+        end
+
+        it "has not default value" do
+          parse(:foo, :string).default.should be_nil
+          parse(:foo, :numeric).default.should be_nil
+        end
+      end
+
+      describe "equals to :required" do
+        it "has type equals to :string" do
+          parse(:foo, :required).type.should == :string
+        end
+
+        it "has no default value" do
+          parse(:foo, :required).default.should be_nil
+        end
+      end
+
+      describe "and symbol is not a reserved key" do
+        it "has type equals to :string" do
+          parse(:foo, :bar).type.should == :string
+        end
+
+        it "has no default value" do
+          parse(:foo, :bar).default.should be_nil
+        end
+      end
+    end
+
+    describe "with value as hash" do
+      it "has default type :hash" do
+        parse(:foo, :a => :b).type.should == :hash
+      end
+
+      it "has default value equals to the hash" do
+        parse(:foo, :a => :b).default.should == { :a => :b }
+      end
+    end
+
+    describe "with value as array" do
+      it "has default type :array" do
+        parse(:foo, [:a, :b]).type.should == :array
+      end
+
+      it "has default value equals to the array" do
+        parse(:foo, [:a, :b]).default.should == [:a, :b]
+      end
+    end
+
+    describe "with value as string" do
+      it "has default type :string" do
+        parse(:foo, "bar").type.should == :string
+      end
+
+      it "has default value equals to the string" do
+        parse(:foo, "bar").default.should == "bar"
+      end
+    end
+
+    describe "with value as numeric" do
+      it "has default type :numeric" do
+        parse(:foo, 2.0).type.should == :numeric
+      end
+
+      it "has default value equals to the numeric" do
+        parse(:foo, 2.0).default.should == 2.0
+      end
+    end
+
+    describe "with value as boolean" do
+      it "has default type :boolean" do
+        parse(:foo, true).type.should == :boolean
+        parse(:foo, false).type.should == :boolean
+      end
+
+      it "has default value equals to the boolean" do
+        parse(:foo, true).default.should == true
+        parse(:foo, false).default.should == false
+      end
+    end
+
+    describe "with key as a symbol" do
+      it "sets the name equals to the key" do
+        parse(:foo, true).name.should == "foo"
+      end
+    end
+
+    describe "with key as an array" do
+      it "sets the first items in the array to the name" do
+        parse([:foo, :bar, :baz], true).name.should == "foo"
+      end
+
+      it "sets all other items as aliases" do
+        parse([:foo, :bar, :baz], true).aliases.should == [:bar, :baz]
+      end
+    end
+  end
+
+  it "returns the switch name" do
+    option("foo").switch_name.should == "--foo"
+    option("--foo").switch_name.should == "--foo"
+  end
+
+  it "returns the human name" do
+    option("foo").human_name.should == "foo"
+    option("--foo").human_name.should == "foo"
+  end
+
+  it "converts underscores to dashes" do
+    option("foo_bar").switch_name.should == "--foo-bar"
+  end
+
+  it "can be required and have default values" do
+    option = option("foo", nil, true, :string, "bar")
+    option.default.should == "bar"
+    option.should be_required
+  end
+
+  it "cannot be required and have type boolean" do
+    lambda {
+      option("foo", nil, true, :boolean)
+    }.should raise_error(ArgumentError, "An option cannot be boolean and required.")
+  end
+
+  it "allows type predicates" do
+    parse(:foo, :string).should be_string
+    parse(:foo, :boolean).should be_boolean
+    parse(:foo, :numeric).should be_numeric
+  end
+
+  it "raises an error on method missing" do
+    lambda {
+      parse(:foo, :string).unknown?
+    }.should raise_error(NoMethodError)
+  end
+
+  describe "#usage" do
+
+    it "returns usage for string types" do
+      parse(:foo, :string).usage.should == "[--foo=FOO]"
+    end
+
+    it "returns usage for numeric types" do
+      parse(:foo, :numeric).usage.should == "[--foo=N]"
+    end
+
+    it "returns usage for array types" do
+      parse(:foo, :array).usage.should == "[--foo=one two three]"
+    end
+
+    it "returns usage for hash types" do
+      parse(:foo, :hash).usage.should == "[--foo=key:value]"
+    end
+
+    it "returns usage for boolean types" do
+      parse(:foo, :boolean).usage.should == "[--foo]"
+    end
+
+    it "uses padding when no aliases is given" do
+      parse(:foo, :boolean).usage(4).should == "    [--foo]"
+    end
+
+    it "uses banner when supplied" do
+      option(:foo, nil, false, :string, nil, "BAR").usage.should == "[--foo=BAR]"
+    end
+
+    it "checkes when banner is an empty string" do
+      option(:foo, nil, false, :string, nil, "").usage.should == "[--foo]"
+    end
+
+    describe "with required values" do
+      it "does not show the usage between brackets" do
+        parse(:foo, :required).usage.should == "--foo=FOO"
+      end
+    end
+
+    describe "with aliases" do
+      it "does not show the usage between brackets" do
+        parse([:foo, "-f", "-b"], :required).usage.should == "-f, -b, --foo=FOO"
+      end
+    end
+  end
+end