acquia_toolbelt 2.3.0 → 2.3.1

data/lib/vendor/thor/spec/fixtures/script.thor

@@ -0,0 +1,220 @@
+class MyScript < Thor
+  check_unknown_options! :except => :with_optional
+
+  attr_accessor :some_attribute
+  attr_writer :another_attribute
+  attr_reader :another_attribute
+
+  private
+  attr_reader :private_attribute
+
+  public
+  group :script
+  default_command :example_default_command
+
+  map "-T" => :animal, ["-f", "--foo"] => :foo
+
+  map "animal_prison" => "zoo"
+
+  desc "zoo", "zoo around"
+  def zoo
+    true
+  end
+
+  desc "animal TYPE", "horse around"
+
+  no_commands do
+    def this_is_not_a_command
+    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_command", "example!"
+  method_options :with => :string
+  def example_default_command
+    options.empty? ? "default command" : 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 command"
+  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 command 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
+
+  desc "send", "send as a command name"
+  def send
+    true
+  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_command :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_command :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
+
+class PackageNameScript < Thor
+  package_name "Baboon"
+end
+
+module Scripts
+  class MyScript < MyChildScript
+    argument :accessor, :type => :string
+    class_options :force => :boolean
+    method_option :new_option, :type => :string, :for => :example_default_command
+
+    def zoo
+      self.accessor
+    end
+  end
+
+  class MyDefaults < Thor
+    check_unknown_options!
+
+    namespace :default
+    desc "cow", "prints 'moo'"
+    def cow
+      puts "moo"
+    end
+
+    desc "command_conflict", "only gets called when prepended with a colon"
+    def command_conflict
+      puts "command"
+    end
+
+    desc "barn", "commands to manage the barn"
+    subcommand "barn", Barn
+  end
+
+  class ChildDefault < Thor
+    namespace "default:child"
+  end
+
+  class Arities < Thor
+    desc "zero_args", "takes zero args"
+    def zero_args
+    end
+
+    desc "one_arg ARG", "takes one arg"
+    def one_arg(arg)
+    end
+
+    desc "two_args ARG1 ARG2", "takes two args"
+    def two_args(arg1, arg2)
+    end
+
+    desc "optional_arg [ARG]", "takes an optional arg"
+    def optional_arg(arg='default')
+    end
+  end
+end
+

data/lib/vendor/thor/spec/fixtures/subcommand.thor

@@ -0,0 +1,17 @@
+module TestSubcommands
+
+  class Subcommand < Thor
+    desc "print_opt", "My method"
+    def print_opt
+      print options["opt"]
+    end
+  end
+
+  class Parent < Thor
+    class_option "opt"
+
+    desc "sub", "My subcommand"
+    subcommand "sub", Subcommand
+  end
+
+end

data/lib/vendor/thor/spec/group_spec.rb

@@ -0,0 +1,222 @@
+require 'helper'
+
+describe Thor::Group do
+  describe "command" do
+    it "allows to use private methods from parent class as commands" do
+      expect(ChildGroup.start).to eq(["bar", "foo", "baz"])
+      expect(ChildGroup.new.baz("bar")).to eq("bar")
+    end
+  end
+
+  describe "#start" do
+    it "invokes all the commands under the Thor group" do
+      expect(MyCounter.start(["1", "2", "--third", "3"])).to eq([ 1, 2, 3, nil, nil, nil ])
+    end
+
+    it "uses argument's default value" do
+      expect(MyCounter.start(["1", "--third", "3"])).to eq([ 1, 2, 3, nil, nil, nil ])
+    end
+
+    it "invokes all the commands in the Thor group and its parents" do
+      expect(BrokenCounter.start(["1", "2", "--third", "3"])).to eq([ nil, 2, 3, false, 5, nil ])
+    end
+
+    it "raises an error if a required argument is added after a non-required" do
+      expect {
+        MyCounter.argument(:foo, :type => :string)
+      }.to 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 command call" do
+      expect{ BrokenCounter.start(["1", "2", "--fail"]) }.to raise_error
+    end
+
+    it "raises an error when a Thor group command expects arguments" do
+      expect{ WhinyGenerator.start }.to raise_error(ArgumentError, /thor wrong_arity takes 1 argument, but it should not/)
+    end
+
+    it "invokes help message if any of the shortcuts are given" do
+      expect(MyCounter).to receive(:help)
+      MyCounter.start(["-h"])
+    end
+  end
+
+  describe "#desc" do
+    it "sets the description for a given class" do
+      expect(MyCounter.desc).to eq("Description:\n  This generator runs three commands: one, two and three.\n")
+    end
+
+    it "can be inherited" do
+      expect(BrokenCounter.desc).to eq("Description:\n  This generator runs three commands: one, two and three.\n")
+    end
+
+    it "can be nil" do
+      expect(WhinyGenerator.desc).to be_nil
+    end
+  end
+
+  describe "#help" do
+    before do
+      @content = capture(:stdout) { MyCounter.help(Thor::Base.shell.new) }
+    end
+
+    it "provides usage information" do
+      expect(@content).to match(/my_counter N \[N\]/)
+    end
+
+    it "shows description" do
+      expect(@content).to match(/Description:/)
+      expect(@content).to match(/This generator runs three commands: one, two and three./)
+    end
+
+    it "shows options information" do
+      expect(@content).to match(/Options/)
+      expect(@content).to match(/\[\-\-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
+      expect(@content).to match(/1\n2\n3\n4\n5\n/)
+    end
+
+    it "shows invocation information to the user" do
+      expect(@content).to match(/invoke  Defined/)
+    end
+
+    it "uses padding on status generated by the invoked class" do
+      expect(@content).to match(/finished    counting/)
+    end
+
+    it "allows invocation to be configured with blocks" do
+      capture(:stdout) do
+        expect(F.start).to eq(["Valim, Jose"])
+      end
+    end
+
+    it "shows invoked options on help" do
+      content = capture(:stdout) { E.help(Thor::Base.shell.new) }
+      expect(content).to match(/Defined options:/)
+      expect(content).to match(/\[--unused\]/)
+      expect(content).to match(/# 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
+        expect(@content).to match(/1\n2\n3\n4\n5\n/)
+      end
+
+      it "does not invoke if the option is nil" do
+        expect(capture(:stdout) { G.start(["--skip-invoked"]) }).not_to match(/invoke/)
+      end
+
+      it "prints a message if invocation cannot be found" do
+        content = capture(:stdout) { G.start(["--invoked", "unknown"]) }
+        expect(content).to match(/error  unknown \[not found\]/)
+      end
+
+      it "allows to invoke a class from the class binding by the given option" do
+        error = nil
+        content = capture(:stdout) {
+          error = capture(:stderr) {
+            G.start(["--invoked", "e"])
+          }
+        }
+        expect(content).to match(/invoke  e/)
+        expect(error).to match(/ERROR: "thor two" was called with arguments/)
+      end
+
+      it "shows invocation information to the user" do
+        expect(@content).to match(/invoke  defined/)
+      end
+
+      it "uses padding on status generated by the invoked class" do
+        expect(@content).to match(/finished    counting/)
+      end
+
+      it "shows invoked options on help" do
+        content = capture(:stdout) { G.help(Thor::Base.shell.new) }
+        expect(content).to match(/defined options:/)
+        expect(content).to match(/\[--unused\]/)
+        expect(content).to match(/# 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
+        expect(@content).to match(/1\n2\n3\n4\n5\n/)
+      end
+
+      it "does not invoke if the option is false" do
+        expect(capture(:stdout) { H.start(["--no-defined"]) }).not_to match(/invoke/)
+      end
+
+      it "shows invocation information to the user" do
+        expect(@content).to match(/invoke  defined/)
+      end
+
+      it "uses padding on status generated by the invoked class" do
+        expect(@content).to match(/finished    counting/)
+      end
+
+      it "shows invoked options on help" do
+        content = capture(:stdout) { H.help(Thor::Base.shell.new) }
+        expect(content).to match(/defined options:/)
+        expect(content).to match(/\[--unused\]/)
+        expect(content).to match(/# 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
+
+      expect(klass.start(["jose"])).to eq(["Hi jose"])
+      expect(klass.start(["jose", "--loud"])).to eq(["Hi JOSE"])
+      expect(klass.start(["--loud", "jose"])).to eq(["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
+
+      expect(klass.start(["jose"])).to eq(["Hi jose"])
+      expect(klass.start(["jose", "--loud"])).to eq(["Hi JOSE"])
+      expect(klass.start(["--loud", "jose"])).to eq(["Hi JOSE"])
+    end
+  end
+end

data/lib/vendor/thor/spec/helper.rb

@@ -0,0 +1,67 @@
+$TESTING=true
+
+require 'simplecov'
+require 'coveralls'
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+SimpleCov.start
+
+$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+require 'thor'
+require 'thor/group'
+require 'stringio'
+
+require 'rdoc'
+require 'rspec'
+require 'diff/lcs' # You need diff/lcs installed to run specs (but not to run Thor).
+require 'fakeweb'  # You need fakeweb installed to run specs (but not to run Thor).
+
+# Set shell to basic
+$0 = "thor"
+$thor_runner = true
+ARGV.clear
+Thor::Base.shell = Thor::Shell::Basic
+
+# Load fixtures
+load File.join(File.dirname(__FILE__), "fixtures", "enum.thor")
+load File.join(File.dirname(__FILE__), "fixtures", "group.thor")
+load File.join(File.dirname(__FILE__), "fixtures", "invoke.thor")
+load File.join(File.dirname(__FILE__), "fixtures", "script.thor")
+load File.join(File.dirname(__FILE__), "fixtures", "subcommand.thor")
+load File.join(File.dirname(__FILE__), "fixtures", "command.thor")
+
+RSpec.configure do |config|
+  config.before do
+    ARGV.replace []
+  end
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  def capture(stream)
+    begin
+      stream = stream.to_s
+      eval "$#{stream} = StringIO.new"
+      yield
+      result = eval("$#{stream}").string
+    ensure
+      eval("$#{stream} = #{stream.upcase}")
+    end
+
+    result
+  end
+
+  def source_root
+    File.join(File.dirname(__FILE__), 'fixtures')
+  end
+
+  def destination_root
+    File.join(File.dirname(__FILE__), 'sandbox')
+  end
+
+  alias :silence :capture
+end

data/lib/vendor/thor/spec/invocation_spec.rb

@@ -0,0 +1,108 @@
+require 'helper'
+require 'thor/base'
+
+describe Thor::Invocation do
+  describe "#invoke" do
+    it "invokes a command inside another command" do
+      expect(capture(:stdout) { A.new.invoke(:two) }).to eq("2\n3\n")
+    end
+
+    it "invokes a command just once" do
+      expect(capture(:stdout) { A.new.invoke(:one) }).to eq("1\n2\n3\n")
+    end
+
+    it "invokes a command just once even if they belongs to different classes" do
+      expect(capture(:stdout) { Defined.new.invoke(:one) }).to eq("1\n2\n3\n4\n5\n")
+    end
+
+    it "invokes a command with arguments" do
+      expect(A.new.invoke(:five, [5])).to be_true
+      expect(A.new.invoke(:five, [7])).to be_false
+    end
+
+    it "invokes the default command if none is given to a Thor class" do
+      content = capture(:stdout) { A.new.invoke("b") }
+      expect(content).to match(/Commands/)
+      expect(content).to match(/LAST_NAME/)
+    end
+
+    it "accepts a class as argument without a command to invoke" do
+      content = capture(:stdout) { A.new.invoke(B) }
+      expect(content).to match(/Commands/)
+      expect(content).to match(/LAST_NAME/)
+    end
+
+    it "accepts a class as argument with a command to invoke" do
+      base = A.new([], :last_name => "Valim")
+      expect(base.invoke(B, :one, ["Jose"])).to eq("Valim, Jose")
+    end
+
+    it "allows customized options to be given" do
+      base = A.new([], :last_name => "Wrong")
+      expect(base.invoke(B, :one, ["Jose"], :last_name => "Valim")).to eq("Valim, Jose")
+    end
+
+    it "reparses options in the new class" do
+      expect(A.start(["invoker", "--last-name", "Valim"])).to eq("Valim, Jose")
+    end
+
+    it "shares initialize options with invoked class" do
+      expect(A.new([], :foo => :bar).invoke("b:two")).to eq({ "foo" => :bar })
+    end
+
+    it "uses default options from invoked class if no matching arguments are given" do
+      expect(A.new([]).invoke("b:four")).to eq("default")
+    end
+
+    it "overrides default options if options are passed to the invoker" do
+      expect(A.new([], { :defaulted_value => "not default"}).invoke("b:four")).to eq("not default")
+    end
+
+    it "dump configuration values to be used in the invoked class" do
+      base = A.new
+      expect(base.invoke("b:three").shell).to eq(base.shell)
+    end
+
+    it "allow extra configuration values to be given" do
+      base, shell = A.new, Thor::Base.shell.new
+      expect(base.invoke("b:three", [], {}, :shell => shell).shell).to eq(shell)
+    end
+
+    it "invokes a Thor::Group and all of its commands" do
+      expect(capture(:stdout) { A.new.invoke(:c) }).to eq("1\n2\n3\n")
+    end
+
+    it "does not invoke a Thor::Group twice" do
+      base = A.new
+      silence(:stdout){ base.invoke(:c) }
+      expect(capture(:stdout) { base.invoke(:c) }).to be_empty
+    end
+
+    it "does not invoke any of Thor::Group commands twice" do
+      base = A.new
+      silence(:stdout){ base.invoke(:c) }
+      expect(capture(:stdout) { base.invoke("c:one") }).to be_empty
+    end
+
+    it "raises Thor::UndefinedCommandError if the command can't be found" do
+      expect {
+        A.new.invoke("foo:bar")
+      }.to raise_error(Thor::UndefinedCommandError)
+    end
+
+    it "raises Thor::UndefinedCommandError if the command can't be found even if all commands were already executed" do
+      base = C.new
+      silence(:stdout){ base.invoke_all }
+
+      expect {
+        base.invoke("foo:bar")
+      }.to raise_error(Thor::UndefinedCommandError)
+    end
+
+    it "raises an error if a non Thor class is given" do
+      expect {
+        A.new.invoke(Object)
+      }.to raise_error(RuntimeError, "Expected Thor class, got Object")
+    end
+  end
+end

data/lib/vendor/thor/spec/parser/argument_spec.rb

@@ -0,0 +1,53 @@
+require '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
+      expect {
+        argument(nil)
+      }.to raise_error(ArgumentError, "Argument name can't be nil.")
+    end
+
+    it "raises an error if type is unknown" do
+      expect {
+        argument(:command, :type => :unknown)
+      }.to raise_error(ArgumentError, "Type :unknown is not valid for arguments.")
+    end
+
+    it "raises an error if argument is required and has default values" do
+      expect {
+        argument(:command, :type => :string, :default => "bar", :required => true)
+      }.to raise_error(ArgumentError, "An argument cannot be required and have default value.")
+    end
+
+    it "raises an error if enum isn't an array" do
+      expect {
+        argument(:command, :type => :string, :enum => "bar")
+      }.to 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
+      expect(argument(:foo, :type => :string).usage).to eq("FOO")
+    end
+
+    it "returns usage for numeric types" do
+      expect(argument(:foo, :type => :numeric).usage).to eq("N")
+    end
+
+    it "returns usage for array types" do
+      expect(argument(:foo, :type => :array).usage).to eq("one two three")
+    end
+
+    it "returns usage for hash types" do
+      expect(argument(:foo, :type => :hash).usage).to eq("key:value")
+    end
+  end
+end