thor-exclude_pattern 0.18.0

data/spec/command_spec.rb

@@ -0,0 +1,80 @@
+require 'helper'
+
+describe Thor::Command do
+  def command(options={})
+    options.each do |key, value|
+      options[key] = Thor::Option.parse(key, value)
+    end
+
+    @command ||= Thor::Command.new(:can_has, "I can has cheezburger", "I can has cheezburger\nLots and lots of it", "can_has", options)
+  end
+
+  describe "#formatted_usage" do
+    it "includes namespace within usage" do
+      object = Struct.new(:namespace, :arguments).new("foo", [])
+      expect(command(:bar => :required).formatted_usage(object)).to eq("foo:can_has --bar=BAR")
+    end
+
+    it "includes subcommand name within subcommand usage" do
+      object = Struct.new(:namespace, :arguments).new("main:foo", [])
+      expect(command(:bar => :required).formatted_usage(object, false, true)).to eq("foo can_has --bar=BAR")
+    end
+
+    it "removes default from namespace" do
+      object = Struct.new(:namespace, :arguments).new("default:foo", [])
+      expect(command(:bar => :required).formatted_usage(object)).to eq(":foo:can_has --bar=BAR")
+    end
+
+    it "injects arguments into usage" do
+      options = {:required => true, :type => :string}
+      object = Struct.new(:namespace, :arguments).new("foo", [Thor::Argument.new(:bar, options)])
+      expect(command(:foo => :required).formatted_usage(object)).to eq("foo:can_has BAR --foo=FOO")
+    end
+  end
+
+  describe "#dynamic" do
+    it "creates a dynamic command with the given name" do
+      expect(Thor::DynamicCommand.new('command').name).to eq('command')
+      expect(Thor::DynamicCommand.new('command').description).to eq('A dynamically-generated command')
+      expect(Thor::DynamicCommand.new('command').usage).to eq('command')
+      expect(Thor::DynamicCommand.new('command').options).to eq({})
+    end
+
+    it "does not invoke an existing method" do
+      mock = mock()
+      mock.class.should_receive(:handle_no_command_error).with("to_s")
+      Thor::DynamicCommand.new('to_s').run(mock)
+    end
+  end
+
+  describe "#dup" do
+    it "dup options hash" do
+      command = Thor::Command.new("can_has", nil, nil, nil, :foo => true, :bar => :required)
+      command.dup.options.delete(:foo)
+      expect(command.options[:foo]).to be
+    end
+  end
+
+  describe "#run" do
+    it "runs a command by calling a method in the given instance" do
+      mock = mock()
+      mock.should_receive(:can_has).and_return {|*args| args }
+      expect(command.run(mock, [1, 2, 3])).to eq([1, 2, 3])
+    end
+
+    it "raises an error if the method to be invoked is private" do
+      klass = Class.new do
+        def self.handle_no_command_error(name)
+          name
+        end
+
+      private
+        def can_has
+          "fail"
+        end
+      end
+
+      expect(command.run(klass.new)).to eq("can_has")
+    end
+  end
+end

data/spec/core_ext/hash_with_indifferent_access_spec.rb

@@ -0,0 +1,48 @@
+require '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
+    expect(@hash['foo']).to eq('bar')
+    expect(@hash[:foo]).to eq('bar')
+
+    expect(@hash.values_at(:foo, :baz)).to eq(['bar', 'bee'])
+    expect(@hash.delete(:foo)).to eq('bar')
+  end
+
+  it "handles magic boolean predicates" do
+    expect(@hash.force?).to be_true
+    expect(@hash.foo?).to be_true
+    expect(@hash.nothing?).to be_false
+  end
+
+  it "handles magic comparisions" do
+    expect(@hash.foo?('bar')).to be_true
+    expect(@hash.foo?('bee')).to be_false
+  end
+
+  it "maps methods to keys" do
+    expect(@hash.foo).to eq(@hash['foo'])
+  end
+
+  it "merges keys independent if they are symbols or strings" do
+    @hash.merge!('force' => false, :baz => "boom")
+    expect(@hash[:force]).to eq(false)
+    expect(@hash[:baz]).to eq("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")
+    expect(other[:force]).to eq(false)
+    expect(other[:baz]).to eq("boom")
+  end
+
+  it "converts to a traditional hash" do
+    expect(@hash.to_hash.class).to eq(Hash)
+    expect(@hash).to eq({ 'foo' => 'bar', 'baz' => 'bee', 'force' => true })
+  end
+end

data/spec/core_ext/ordered_hash_spec.rb

@@ -0,0 +1,115 @@
+require '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
+      expect(@hash["foo"]).to be_nil
+    end
+
+    it "doesn't iterate through any items" do
+      @hash.each { fail }
+    end
+
+    it "has an empty key and values list" do
+      expect(@hash.keys).to be_empty
+      expect(@hash.values).to be_empty
+    end
+
+    it "must be empty" do
+      expect(@hash).to 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
+      expect(@hash[:boom]).to be_nil
+    end
+
+    it "returns the value for each key" do
+      expect(@hash[:foo]).to eq("Foo!")
+      expect(@hash[:bar]).to eq("Bar!")
+      expect(@hash[:baz]).to eq("Baz!")
+      expect(@hash[:bop]).to eq("Bop!")
+      expect(@hash[:bat]).to eq("Bat!")
+    end
+
+    it "iterates through the keys and values in order of assignment" do
+      arr = []
+      @hash.each do |key, value|
+        arr << [key, value]
+      end
+      expect(arr).to eq([[:foo, "Foo!"], [:bar, "Bar!"], [:baz, "Baz!"],
+                     [:bop, "Bop!"], [:bat, "Bat!"]])
+    end
+
+    it "returns the keys in order of insertion" do
+      expect(@hash.keys).to eq([:foo, :bar, :baz, :bop, :bat])
+    end
+
+    it "returns the values in order of insertion" do
+      expect(@hash.values).to eq(["Foo!", "Bar!", "Baz!", "Bop!", "Bat!"])
+    end
+
+    it "does not move an overwritten node to the end of the ordering" do
+      @hash[:baz] = "Bip!"
+      expect(@hash.values).to eq(["Foo!", "Bar!", "Bip!", "Bop!", "Bat!"])
+
+      @hash[:foo] = "Bip!"
+      expect(@hash.values).to eq(["Bip!", "Bar!", "Bip!", "Bop!", "Bat!"])
+
+      @hash[:bat] = "Bip!"
+      expect(@hash.values).to eq(["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"
+      expect(@hash.merge(other_hash).values).to eq(["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"
+      expect(@hash.merge(other_hash)[:bar]).to eq("bar")
+      expect(@hash[:bar]).to eq("Bar!")
+    end
+
+    it "converts to an array" do
+      expect(@hash.to_a).to eq([[:foo, "Foo!"], [:bar, "Bar!"], [:baz, "Baz!"], [:bop, "Bop!"], [:bat, "Bat!"]])
+    end
+
+    it "must not be empty" do
+      expect(@hash).not_to be_empty
+    end
+
+    it "deletes values from hash" do
+      expect(@hash.delete(:baz)).to eq("Baz!")
+      expect(@hash.values).to eq(["Foo!", "Bar!", "Bop!", "Bat!"])
+
+      expect(@hash.delete(:foo)).to eq("Foo!")
+      expect(@hash.values).to eq(["Bar!", "Bop!", "Bat!"])
+
+      expect(@hash.delete(:bat)).to eq("Bat!")
+      expect(@hash.values).to eq(["Bar!", "Bop!"])
+    end
+
+    it "returns nil if the value to be deleted can't be found" do
+      expect(@hash.delete(:nothing)).to be_nil
+    end
+  end
+end

data/spec/exit_condition_spec.rb

@@ -0,0 +1,19 @@
+require 'helper'
+require 'thor/base'
+
+describe "Exit conditions" do
+  it "exits 0, not bubble up EPIPE, if EPIPE is raised" do
+    epiped = false
+
+    command = Class.new(Thor) do
+      desc "my_action", "testing EPIPE"
+      define_method :my_action do
+        epiped = true
+        raise Errno::EPIPE
+      end
+    end
+
+    expect{ command.start(["my_action"]) }.to raise_error(SystemExit)
+    expect(epiped).to eq(true)
+  end
+end

data/spec/fixtures/application.rb

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

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

@@ -0,0 +1,3 @@
+__start__
+README
+__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/bundle/main.thor

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

data/spec/fixtures/command.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/fixtures/doc/%file_name%.rb.tt

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

data/spec/fixtures/doc/COMMENTER

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

data/spec/fixtures/doc/README

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

data/spec/fixtures/doc/block_helper.rb

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

data/spec/fixtures/doc/config.rb

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

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

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

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

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

data/spec/fixtures/enum.thor

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

@@ -0,0 +1,128 @@
+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"
+  class_option :simple,   :type => :numeric, :aliases => 'z'
+  class_option :symbolic, :type => :numeric, :aliases => [:y, :r]
+
+  desc <<-FOO
+Description:
+  This generator runs three commands: one, two and three.
+FOO
+
+  def one
+    first
+  end
+
+  def two
+    second
+  end
+
+  def three
+    options[:third]
+  end
+
+  def four
+    options[:fourth]
+  end
+
+  def five
+    options[:simple]
+  end
+
+  def six
+    options[:symbolic]
+  end
+
+  def self.inherited(base)
+    super
+    base.source_paths.unshift(File.expand_path(File.join(File.dirname(__FILE__), "doc")))
+  end
+
+  no_commands 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 CommandConflict < Thor::Group
+  desc "A group with the same name as a default command"
+  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_command :foo, :baz
+end