thor 0.16.0 → 1.2.1

data/spec/base_spec.rb

@@ -1,279 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-require 'thor/base'
-
-class Amazing
-  desc "hello", "say hello"
-  def hello
-    puts "Hello"
-  end
-end
-
-describe Thor::Base do
-  describe "#initialize" do
-    it "sets arguments array" do
-      base = MyCounter.new [1, 2]
-      base.first.should == 1
-      base.second.should == 2
-    end
-
-    it "sets arguments default values" do
-      base = MyCounter.new [1]
-      base.second.should == 2
-    end
-
-    it "sets options default values" do
-      base = MyCounter.new [1, 2]
-      base.options[:third].should == 3
-    end
-
-    it "allows options to be given as symbols or strings" do
-      base = MyCounter.new [1, 2], :third => 4
-      base.options[:third].should == 4
-
-      base = MyCounter.new [1, 2], "third" => 4
-      base.options[:third].should == 4
-    end
-
-    it "creates options with indifferent access" do
-      base = MyCounter.new [1, 2], :third => 3
-      base.options['third'].should == 3
-    end
-
-    it "creates options with magic predicates" do
-      base = MyCounter.new [1, 2], :third => 3
-      base.options.third.should == 3
-    end
-  end
-
-  describe "#no_tasks" do
-    it "avoids methods being added as tasks" do
-      MyScript.tasks.keys.should include("animal")
-      MyScript.tasks.keys.should_not include("this_is_not_a_task")
-    end
-  end
-
-  describe "#argument" do
-    it "sets a value as required and creates an accessor for it" do
-      MyCounter.start(["1", "2", "--third", "3"])[0].should == 1
-      Scripts::MyScript.start(["zoo", "my_special_param", "--param=normal_param"]).should == "my_special_param"
-    end
-
-    it "does not set a value in the options hash" do
-      BrokenCounter.start(["1", "2", "--third", "3"])[0].should be_nil
-    end
-  end
-
-  describe "#arguments" do
-    it "returns the arguments for the class" do
-      MyCounter.arguments.should have(2).items
-    end
-  end
-
-  describe "#class_option" do
-    it "sets options class wise" do
-      MyCounter.start(["1", "2", "--third", "3"])[2].should == 3
-    end
-
-    it "does not create an accessor for it" do
-      BrokenCounter.start(["1", "2", "--third", "3"])[3].should be_false
-    end
-  end
-
-  describe "#class_options" do
-    it "sets default options overwriting superclass definitions" do
-      options = Scripts::MyScript.class_options
-      options[:force].should_not be_required
-    end
-  end
-
-  describe "#remove_argument" do
-    it "removes previous defined arguments from class" do
-      ClearCounter.arguments.should be_empty
-    end
-
-    it "undefine accessors if required" do
-      ClearCounter.new.should_not respond_to(:first)
-      ClearCounter.new.should_not respond_to(:second)
-    end
-  end
-
-  describe "#remove_class_option" do
-    it "removes previous defined class option" do
-      ClearCounter.class_options[:third].should be_nil
-    end
-  end
-
-  describe "#class_options_help" do
-    before do
-      @content = capture(:stdout) { MyCounter.help(Thor::Base.shell.new) }
-    end
-
-    it "shows options description" do
-      @content.should =~ /# The third argument/
-    end
-
-    it "shows usage with banner content" do
-      @content.should =~ /\[\-\-third=THREE\]/
-    end
-
-    it "shows default values below description" do
-      @content.should =~ /# Default: 3/
-    end
-
-    it "shows options in different groups" do
-      @content.should =~ /Options\:/
-      @content.should =~ /Runtime options\:/
-      @content.should =~ /\-p, \[\-\-pretend\]/
-    end
-
-    it "use padding in options that does not have aliases" do
-      @content.should =~ /^  -t, \[--third/
-      @content.should =~ /^      \[--fourth/
-    end
-
-    it "allows extra options to be given" do
-      hash = { "Foo" => B.class_options.values }
-
-      content = capture(:stdout) { MyCounter.send(:class_options_help, Thor::Base.shell.new, hash) }
-      content.should =~ /Foo options\:/
-      content.should =~ /--last-name=LAST_NAME/
-    end
-
-    it "displays choices for enums" do
-      content = capture(:stdout) { Enum.help(Thor::Base.shell.new) }
-      content.should =~ /Possible values\: apple, banana/
-    end
-  end
-
-  describe "#namespace" do
-    it "returns the default class namespace" do
-      Scripts::MyScript.namespace.should == "scripts:my_script"
-    end
-
-    it "sets a namespace to the class" do
-      Scripts::MyDefaults.namespace.should == "default"
-    end
-  end
-
-  describe "#group" do
-    it "sets a group" do
-      MyScript.group.should == "script"
-    end
-
-    it "inherits the group from parent" do
-      MyChildScript.group.should == "script"
-    end
-
-    it "defaults to standard if no group is given" do
-      Amazing.group.should == "standard"
-    end
-  end
-
-  describe "#subclasses" do
-    it "tracks its subclasses in an Array" do
-      Thor::Base.subclasses.should include(MyScript)
-      Thor::Base.subclasses.should include(MyChildScript)
-      Thor::Base.subclasses.should include(Scripts::MyScript)
-    end
-  end
-
-  describe "#subclass_files" do
-    it "returns tracked subclasses, grouped by the files they come from" do
-      thorfile = File.join(File.dirname(__FILE__), "fixtures", "script.thor")
-      Thor::Base.subclass_files[File.expand_path(thorfile)].should == [
-        MyScript, MyScript::AnotherScript, MyChildScript, Barn,
-        Scripts::MyScript, Scripts::MyDefaults, Scripts::ChildDefault
-      ]
-    end
-
-    it "tracks a single subclass across multiple files" do
-      thorfile = File.join(File.dirname(__FILE__), "fixtures", "task.thor")
-      Thor::Base.subclass_files[File.expand_path(thorfile)].should include(Amazing)
-      Thor::Base.subclass_files[File.expand_path(__FILE__)].should include(Amazing)
-    end
-  end
-
-  describe "#tasks" do
-    it "returns a list with all tasks defined in this class" do
-      MyChildScript.new.should respond_to("animal")
-      MyChildScript.tasks.keys.should include("animal")
-    end
-
-    it "raises an error if a task with reserved word is defined" do
-      lambda {
-        klass = Class.new(Thor::Group)
-        klass.class_eval "def shell; end"
-      }.should raise_error(RuntimeError, /"shell" is a Thor reserved word and cannot be defined as task/)
-    end
-  end
-
-  describe "#all_tasks" do
-    it "returns a list with all tasks defined in this class plus superclasses" do
-      MyChildScript.new.should respond_to("foo")
-      MyChildScript.all_tasks.keys.should include("foo")
-    end
-  end
-
-  describe "#remove_task" do
-    it "removes the task from its tasks hash" do
-      MyChildScript.tasks.keys.should_not include("bar")
-      MyChildScript.tasks.keys.should_not include("boom")
-    end
-
-    it "undefines the method if desired" do
-      MyChildScript.new.should_not respond_to("boom")
-    end
-  end
-
-  describe "#from_superclass" do
-    it "does not send a method to the superclass if the superclass does not respond to it" do
-      MyCounter.get_from_super.should == 13
-    end
-  end
-
-  describe "#start" do
-    it "raises an error instead of rescueing if THOR_DEBUG=1 is given" do
-      begin
-        ENV["THOR_DEBUG"] = 1
-        lambda {
-          MyScript.start ["what", "--debug"]
-        }.should raise_error(Thor::UndefinedTaskError, 'Could not find task "what" in "my_script" namespace.')
-      rescue
-        ENV["THOR_DEBUG"] = nil
-      end
-    end
-
-    it "does not steal args" do
-      args = ["foo", "bar", "--force", "true"]
-      MyScript.start(args)
-      args.should == ["foo", "bar", "--force", "true"]
-    end
-
-    it "checks unknown options" do
-      capture(:stderr) {
-        MyScript.start(["foo", "bar", "--force", "true", "--unknown", "baz"])
-      }.strip.should == "Unknown switches '--unknown'"
-    end
-
-    it "checks unknown options except specified" do
-      capture(:stderr) {
-        MyScript.start(["with_optional", "NAME", "--omg", "--invalid"]).should == ["NAME", {}, ["--omg", "--invalid"]]
-      }.strip.should be_empty
-    end
-  end
-
-  describe "attr_*" do
-    it "should not add attr_reader as a task" do
-      capture(:stderr){ MyScript.start(["another_attribute"]) }.should =~ /Could not find/
-    end
-
-    it "should not add attr_writer as a task" do
-      capture(:stderr){ MyScript.start(["another_attribute=", "foo"]) }.should =~ /Could not find/
-    end
-
-    it "should not add attr_accessor as a task" do
-      capture(:stderr){ MyScript.start(["some_attribute"]) }.should =~ /Could not find/
-      capture(:stderr){ MyScript.start(["some_attribute=", "foo"]) }.should =~ /Could not find/
-    end
-  end
-end

data/spec/core_ext/hash_with_indifferent_access_spec.rb

@@ -1,43 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-require 'thor/core_ext/hash_with_indifferent_access'
-
-describe Thor::CoreExt::HashWithIndifferentAccess do
-  before 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'].should == 'bar'
-    @hash[:foo].should  == 'bar'
-
-    @hash.values_at(:foo, :baz).should == ['bar', 'bee']
-    @hash.delete(:foo).should == 'bar'
-  end
-
-  it "handles magic boolean predicates" do
-    @hash.force?.should be_true
-    @hash.foo?.should be_true
-    @hash.nothing?.should be_false
-  end
-
-  it "handles magic comparisions" do
-    @hash.foo?('bar').should be_true
-    @hash.foo?('bee').should be_false
-  end
-
-  it "maps methods to keys" do
-    @hash.foo.should == @hash['foo']
-  end
-
-  it "merges keys independent if they are symbols or strings" do
-    @hash.merge!('force' => false, :baz => "boom")
-    @hash[:force].should == false
-    @hash[:baz].should == "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].should == false
-    other[:baz].should == "boom"
-  end
-end

data/spec/core_ext/ordered_hash_spec.rb

@@ -1,115 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-require 'thor/core_ext/ordered_hash'
-
-describe Thor::CoreExt::OrderedHash do
-  before do
-    @hash = Thor::CoreExt::OrderedHash.new
-  end
-
-  describe "without any items" do
-    it "returns nil for an undefined key" do
-      @hash["foo"].should 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.should be_empty
-      @hash.values.should be_empty
-    end
-
-    it "must be empty" do
-      @hash.should be_empty
-    end
-  end
-
-  describe "with several items" do
-    before 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].should be_nil
-    end
-
-    it "returns the value for each key" do
-      @hash[:foo].should == "Foo!"
-      @hash[:bar].should == "Bar!"
-      @hash[:baz].should == "Baz!"
-      @hash[:bop].should == "Bop!"
-      @hash[:bat].should == "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.should == [[:foo, "Foo!"], [:bar, "Bar!"], [:baz, "Baz!"],
-                     [:bop, "Bop!"], [:bat, "Bat!"]]
-    end
-
-    it "returns the keys in order of insertion" do
-      @hash.keys.should == [:foo, :bar, :baz, :bop, :bat]
-    end
-
-    it "returns the values in order of insertion" do
-      @hash.values.should == ["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.should == ["Foo!", "Bar!", "Bip!", "Bop!", "Bat!"]
-
-      @hash[:foo] = "Bip!"
-      @hash.values.should == ["Bip!", "Bar!", "Bip!", "Bop!", "Bat!"]
-
-      @hash[:bat] = "Bip!"
-      @hash.values.should == ["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.should == ["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].should == "bar"
-      @hash[:bar].should == "Bar!"
-    end
-
-    it "converts to an array" do
-      @hash.to_a.should == [[:foo, "Foo!"], [:bar, "Bar!"], [:baz, "Baz!"], [:bop, "Bop!"], [:bat, "Bat!"]]
-    end
-
-    it "must not be empty" do
-      @hash.should_not be_empty
-    end
-
-    it "deletes values from hash" do
-      @hash.delete(:baz).should == "Baz!"
-      @hash.values.should == ["Foo!", "Bar!", "Bop!", "Bat!"]
-
-      @hash.delete(:foo).should == "Foo!"
-      @hash.values.should == ["Bar!", "Bop!", "Bat!"]
-
-      @hash.delete(:bat).should == "Bat!"
-      @hash.values.should == ["Bar!", "Bop!"]
-    end
-
-    it "returns nil if the value to be deleted can't be found" do
-      @hash.delete(:nothing).should be_nil
-    end
-  end
-end

data/spec/exit_condition_spec.rb

@@ -1,19 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-require 'thor/base'
-
-describe "Exit conditions" do
-  it "should exit 0, not bubble up EPIPE, if EPIPE is raised" do
-    epiped = false
-
-    task = Class.new(Thor) do
-      desc "my_action", "testing EPIPE"
-      define_method :my_action do
-        epiped = true
-        raise Errno::EPIPE
-      end
-    end
-
-    lambda { task.start(["my_action"]) }.should raise_error(SystemExit)
-    epiped.should == true
-  end
-end

data/spec/fixtures/application.rb

@@ -1,2 +0,0 @@
-class Application < Base
-end

data/spec/fixtures/app{1}/README

@@ -1,3 +0,0 @@
-__start__
-README
-__end__

data/spec/fixtures/bundle/execute.rb

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

data/spec/fixtures/bundle/main.thor

@@ -1 +0,0 @@
-require File.join(File.dirname(__FILE__), 'execute')

data/spec/fixtures/doc/%file_name%.rb.tt

@@ -1 +0,0 @@
-FOO = <%= "FOO" %>

data/spec/fixtures/doc/COMMENTER

@@ -1,10 +0,0 @@
-__start__
- # greenblue
-# yellowblue
-#yellowred
- #greenred
-orange
-    purple
-  ind#igo
-  # ind#igo
-__end__

data/spec/fixtures/doc/README

@@ -1,3 +0,0 @@
-__start__
-README
-__end__

data/spec/fixtures/doc/block_helper.rb

@@ -1,3 +0,0 @@
-<% world do -%>
-Hello
-<% end -%>

data/spec/fixtures/doc/config.rb

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

data/spec/fixtures/doc/config.yaml.tt

@@ -1 +0,0 @@
---- Hi from yaml

data/spec/fixtures/enum.thor

@@ -1,10 +0,0 @@
-class Enum < Thor::Group
-  include Thor::Actions
-
-  desc "snack"
-  class_option "fruit", :aliases => "-f", :type => :string, :enum => %w(apple banana)
-  def snack
-    puts options['fruit']
-  end
-
-end

data/spec/fixtures/group.thor

@@ -1,114 +0,0 @@
-class MyCounter < Thor::Group
-  include Thor::Actions
-  add_runtime_options!
-
-  def self.get_from_super
-    from_superclass(:get_from_super, 13)
-  end
-
-  source_root File.expand_path(File.dirname(__FILE__))
-  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 runs 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
-
-  no_tasks do
-    def world(&block)
-      result = capture(&block)
-      concat(result.strip + " world!")
-    end
-  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
-
-class TaskConflict < Thor::Group
-  desc "A group with the same name as a default task"
-  def group
-    puts "group"
-  end
-end
-
-class ParentGroup < Thor::Group
-private
-  def foo
-    "foo"
-  end
-
-  def baz(name = 'baz')
-    name
-  end
-end
-
-class ChildGroup < ParentGroup
-  def bar
-    "bar"
-  end
-
-  public_task :foo, :baz
-end