groovenauts-thor 0.19.1 → 0.19.1.1

data/spec/base_spec.rb

@@ -0,0 +1,298 @@
+require "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]
+      expect(base.first).to eq(1)
+      expect(base.second).to eq(2)
+    end
+
+    it "sets arguments default values" do
+      base = MyCounter.new [1]
+      expect(base.second).to eq(2)
+    end
+
+    it "sets options default values" do
+      base = MyCounter.new [1, 2]
+      expect(base.options[:third]).to eq(3)
+    end
+
+    it "allows options to be given as symbols or strings" do
+      base = MyCounter.new [1, 2], :third => 4
+      expect(base.options[:third]).to eq(4)
+
+      base = MyCounter.new [1, 2], "third" => 4
+      expect(base.options[:third]).to eq(4)
+    end
+
+    it "creates options with indifferent access" do
+      base = MyCounter.new [1, 2], :third => 3
+      expect(base.options["third"]).to eq(3)
+    end
+
+    it "creates options with magic predicates" do
+      base = MyCounter.new [1, 2], :third => 3
+      expect(base.options.third).to eq(3)
+    end
+  end
+
+  describe "#no_commands" do
+    it "avoids methods being added as commands" do
+      expect(MyScript.commands.keys).to include("animal")
+      expect(MyScript.commands.keys).not_to include("this_is_not_a_command")
+    end
+  end
+
+  describe "#argument" do
+    it "sets a value as required and creates an accessor for it" do
+      expect(MyCounter.start(%w[1 2 --third 3])[0]).to eq(1)
+      expect(Scripts::MyScript.start(%w[zoo my_special_param --param=normal_param])).to eq("my_special_param")
+    end
+
+    it "does not set a value in the options hash" do
+      expect(BrokenCounter.start(%w[1 2 --third 3])[0]).to be nil
+    end
+  end
+
+  describe "#arguments" do
+    it "returns the arguments for the class" do
+      expect(MyCounter.arguments.size).to be(2)
+    end
+  end
+
+  describe ":aliases" do
+    it "supports string aliases without a dash prefix" do
+      expect(MyCounter.start(%w[1 2 -z 3])[4]).to eq(3)
+    end
+
+    it "supports symbol aliases" do
+      expect(MyCounter.start(%w[1 2 -y 3])[5]).to eq(3)
+      expect(MyCounter.start(%w[1 2 -r 3])[5]).to eq(3)
+    end
+  end
+
+  describe "#class_option" do
+    it "sets options class wise" do
+      expect(MyCounter.start(%w[1 2 --third 3])[2]).to eq(3)
+    end
+
+    it "does not create an accessor for it" do
+      expect(BrokenCounter.start(%w[1 2 --third 3])[3]).to be false
+    end
+  end
+
+  describe "#class_options" do
+    it "sets default options overwriting superclass definitions" do
+      options = Scripts::MyScript.class_options
+      expect(options[:force]).not_to be_required
+    end
+  end
+
+  describe "#remove_argument" do
+    it "removes previously defined arguments from class" do
+      expect(ClearCounter.arguments).to be_empty
+    end
+
+    it "undefine accessors if required" do
+      expect(ClearCounter.new).not_to respond_to(:first)
+      expect(ClearCounter.new).not_to respond_to(:second)
+    end
+  end
+
+  describe "#remove_class_option" do
+    it "removes previous defined class option" do
+      expect(ClearCounter.class_options[:third]).to be nil
+    end
+  end
+
+  describe "#class_options_help" do
+    before do
+      @content = capture(:stdout) { MyCounter.help(Thor::Base.shell.new) }
+    end
+
+    it "shows option's description" do
+      expect(@content).to match(/# The third argument/)
+    end
+
+    it "shows usage with banner content" do
+      expect(@content).to match(/\[\-\-third=THREE\]/)
+    end
+
+    it "shows default values below descriptions" do
+      expect(@content).to match(/# Default: 3/)
+    end
+
+    it "shows options in different groups" do
+      expect(@content).to match(/Options\:/)
+      expect(@content).to match(/Runtime options\:/)
+      expect(@content).to match(/\-p, \[\-\-pretend\]/)
+    end
+
+    it "use padding in options that do not have aliases" do
+      expect(@content).to match(/^  -t, \[--third/)
+      expect(@content).to match(/^          \[--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) }
+      expect(content).to match(/Foo options\:/)
+      expect(content).to match(/--last-name=LAST_NAME/)
+    end
+
+    it "displays choices for enums" do
+      content = capture(:stdout) { Enum.help(Thor::Base.shell.new) }
+      expect(content).to match(/Possible values\: apple, banana/)
+    end
+  end
+
+  describe "#namespace" do
+    it "returns the default class namespace" do
+      expect(Scripts::MyScript.namespace).to eq("scripts:my_script")
+    end
+
+    it "sets a namespace to the class" do
+      expect(Scripts::MyDefaults.namespace).to eq("default")
+    end
+  end
+
+  describe "#group" do
+    it "sets a group" do
+      expect(MyScript.group).to eq("script")
+    end
+
+    it "inherits the group from parent" do
+      expect(MyChildScript.group).to eq("script")
+    end
+
+    it "defaults to standard if no group is given" do
+      expect(Amazing.group).to eq("standard")
+    end
+  end
+
+  describe "#subclasses" do
+    it "tracks its subclasses in an Array" do
+      expect(Thor::Base.subclasses).to include(MyScript)
+      expect(Thor::Base.subclasses).to include(MyChildScript)
+      expect(Thor::Base.subclasses).to 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")
+      expect(Thor::Base.subclass_files[File.expand_path(thorfile)]).to eq([
+        MyScript, MyScript::AnotherScript, MyChildScript, Barn,
+        PackageNameScript, Scripts::MyScript, Scripts::MyDefaults,
+        Scripts::ChildDefault, Scripts::Arities
+      ])
+    end
+
+    it "tracks a single subclass across multiple files" do
+      thorfile = File.join(File.dirname(__FILE__), "fixtures", "command.thor")
+      expect(Thor::Base.subclass_files[File.expand_path(thorfile)]).to include(Amazing)
+      expect(Thor::Base.subclass_files[File.expand_path(__FILE__)]).to include(Amazing)
+    end
+  end
+
+  describe "#commands" do
+    it "returns a list with all commands defined in this class" do
+      expect(MyChildScript.new).to respond_to("animal")
+      expect(MyChildScript.commands.keys).to include("animal")
+    end
+
+    it "raises an error if a command with reserved word is defined" do
+      expect do
+        klass = Class.new(Thor::Group)
+        klass.class_eval "def shell; end"
+      end.to raise_error(RuntimeError, /"shell" is a Thor reserved word and cannot be defined as command/)
+    end
+  end
+
+  describe "#all_commands" do
+    it "returns a list with all commands defined in this class plus superclasses" do
+      expect(MyChildScript.new).to respond_to("foo")
+      expect(MyChildScript.all_commands.keys).to include("foo")
+    end
+  end
+
+  describe "#remove_command" do
+    it "removes the command from its commands hash" do
+      expect(MyChildScript.commands.keys).not_to include("bar")
+      expect(MyChildScript.commands.keys).not_to include("boom")
+    end
+
+    it "undefines the method if desired" do
+      expect(MyChildScript.new).not_to 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
+      expect(MyCounter.get_from_super).to eq(13)
+    end
+  end
+
+  describe "#start" do
+    it "raises an error instead of rescuing if THOR_DEBUG=1 is given" do
+      begin
+        ENV["THOR_DEBUG"] = "1"
+
+        expect do
+          MyScript.start %w[what --debug]
+        end.to raise_error(Thor::UndefinedCommandError, 'Could not find command "what" in "my_script" namespace.')
+      ensure
+        ENV["THOR_DEBUG"] = nil
+      end
+    end
+
+    it "raises an error instead of rescuing if :debug option is given" do
+      expect do
+        MyScript.start %w[what], :debug => true
+      end.to raise_error(Thor::UndefinedCommandError, 'Could not find command "what" in "my_script" namespace.')
+    end
+
+    it "does not steal args" do
+      args = %w[foo bar --force true]
+      MyScript.start(args)
+      expect(args).to eq(%w[foo bar --force true])
+    end
+
+    it "checks unknown options" do
+      expect(capture(:stderr) do
+        MyScript.start(%w[foo bar --force true --unknown baz])
+      end.strip).to eq("Unknown switches '--unknown'")
+    end
+
+    it "checks unknown options except specified" do
+      expect(capture(:stderr) do
+        expect(MyScript.start(%w[with_optional NAME --omg --invalid])).to eq(["NAME", {}, %w[--omg --invalid]])
+      end.strip).to be_empty
+    end
+  end
+
+  describe "attr_*" do
+    it "does not add attr_reader as a command" do
+      expect(capture(:stderr) { MyScript.start(%w[another_attribute]) }).to match(/Could not find/)
+    end
+
+    it "does not add attr_writer as a command" do
+      expect(capture(:stderr) { MyScript.start(%w[another_attribute= foo]) }).to match(/Could not find/)
+    end
+
+    it "does not add attr_accessor as a command" do
+      expect(capture(:stderr) { MyScript.start(["some_attribute"]) }).to match(/Could not find/)
+      expect(capture(:stderr) { MyScript.start(["some_attribute=", "foo"]) }).to match(/Could not find/)
+    end
+  end
+end

data/spec/command_spec.rb

@@ -0,0 +1,79 @@
+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
+      dub = double
+      expect(dub.class).to receive(:handle_no_command_error).with("to_s")
+      Thor::DynamicCommand.new("to_s").run(dub)
+    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
+      dub = double
+      expect(dub).to receive(:can_has).and_return { |*args| args }
+      expect(command.run(dub, [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
+        def can_has
+          "fail"
+        end
+        private :can_has
+      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(%w[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 comparisons" 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