thor 0.16.0 → 1.2.1

data/spec/fixtures/invoke.thor

@@ -1,112 +0,0 @@
-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

@@ -1,190 +0,0 @@
-class MyScript < Thor
-  check_unknown_options! :except => :with_optional
-
-  attr_accessor :some_attribute
-  attr_writer :another_attribute
-  attr_reader :another_attribute
-
-  group :script
-  default_task :example_default_task
-
-  map "-T" => :animal, ["-f", "--foo"] => :foo
-
-  map "animal_prison" => "zoo"
-
-  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
-
-  map "hid" => "hidden"
-
-  desc "hidden TYPE", "this is hidden", :hide => true
-  def hidden(type)
-    [type]
-  end
-
-  map "fu" => "zoo"
-
-  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!"
-  method_options :with => :string
-  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
-  long_desc <<-D
-    This is a really really really long description.
-    Here you go. So very long.
-
-    It even has two paragraphs.
-  D
-  def long_description
-  end
-
-  desc "name-with-dashes", "Ensure normalization of task names"
-  def name_with_dashes
-  end
-
-  method_options :all => :boolean
-  method_option :lazy, :lazy_default => "yes"
-  method_option :lazy_numeric, :type => :numeric, :lazy_default => 42
-  method_option :lazy_array,   :type => :array,   :lazy_default => %w[eat at joes]
-  method_option :lazy_hash,    :type => :hash,    :lazy_default => {'swedish' => 'meatballs'}
-  desc "with_optional NAME", "invoke with optional name"
-  def with_optional(name=nil, *args)
-    [ name, options, args ]
-  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
-
-class Barn < Thor
-  desc "open [ITEM]", "open the barn door"
-  def open(item = nil)
-    if item == "shotgun"
-      puts "That's going to leave a mark."
-    else
-      puts "Open sesame!"
-    end
-  end
-
-  desc "paint [COLOR]", "paint the barn"
-  method_option :coats, :type => :numeric, :default => 2, :desc => 'how many coats of paint'
-  def paint(color='red')
-    puts "#{options[:coats]} coats of #{color} paint"
-  end
-
-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
-    check_unknown_options!
-
-    namespace :default
-    desc "cow", "prints 'moo'"
-    def cow
-      puts "moo"
-    end
-
-    desc "task_conflict", "only gets called when prepended with a colon"
-    def task_conflict
-      puts "task"
-    end
-
-    desc "barn", "commands to manage the barn"
-    subcommand "barn", Barn
-  end
-
-  class ChildDefault < Thor
-    namespace "default:child"
-  end
-end
-

data/spec/fixtures/task.thor

@@ -1,10 +0,0 @@
-# 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

@@ -1,216 +0,0 @@
-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, /thor wrong_arity takes 1 argument, but it should not/)
-    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 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 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 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 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

@@ -1,100 +0,0 @@
-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

@@ -1,53 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-require 'thor/parser'
-
-describe Thor::Argument do
-
-  def argument(name, options={})
-    @argument ||= Thor::Argument.new(name, options)
-  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, :type => :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, :type => :string, :default => "bar", :required => true)
-      }.should raise_error(ArgumentError, "An argument cannot be required and have default value.")
-    end
-
-    it "raises an error if enum isn't an array" do
-      lambda {
-        argument(:task, :type => :string, :enum => "bar")
-      }.should raise_error(ArgumentError, "An argument cannot have an enum other than an array.")
-    end
-  end
-
-  describe "#usage" do
-    it "returns usage for string types" do
-      argument(:foo, :type => :string).usage.should == "FOO"
-    end
-
-    it "returns usage for numeric types" do
-      argument(:foo, :type => :numeric).usage.should == "N"
-    end
-
-    it "returns usage for array types" do
-      argument(:foo, :type => :array).usage.should == "one two three"
-    end
-
-    it "returns usage for hash types" do
-      argument(:foo, :type => :hash).usage.should == "key:value"
-    end
-  end
-end