torquebox-console 0.2.5 → 0.3.0

data/vendor/bundle/ruby/1.8/gems/thor-0.17.0/spec/fixtures/preserve/script.sh

@@ -1,3 +0,0 @@
-#!/bin/sh
-
-exit 0

data/vendor/bundle/ruby/1.8/gems/thor-0.17.0/spec/fixtures/script.thor

@@ -1,195 +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
-
-  desc "send", "send as a task 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_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/vendor/bundle/ruby/1.8/gems/thor-0.17.0/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/vendor/bundle/ruby/1.8/gems/thor-0.17.0/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
-      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 tasks under the Thor group" do
-      expect(MyCounter.start(["1", "2", "--third", "3"])).to eq([ 1, 2, 3 ])
-    end
-
-    it "uses argument default value" do
-      expect(MyCounter.start(["1", "--third", "3"])).to eq([ 1, 2, 3 ])
-    end
-
-    it "invokes all the tasks in the Thor group and his parents" do
-      expect(BrokenCounter.start(["1", "2", "--third", "3"])).to eq([ nil, 2, 3, false, 5 ])
-    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 task call" do
-      expect{ BrokenCounter.start(["1", "2", "--fail"]) }.to raise_error
-    end
-
-    it "raises an error when a Thor group task 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 is given" do
-      MyCounter.should_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 tasks: one, two and three.\n")
-    end
-
-    it "can be inherited" do
-      expect(BrokenCounter.desc).to eq("Description:\n  This generator runs three tasks: 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 tasks: 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
-        content = capture(:stdout) { G.start(["--invoked", "e"]) }
-        expect(content).to match(/invoke  e/)
-      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/vendor/bundle/ruby/1.8/gems/thor-0.17.0/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
-      expect(capture(:stdout) { A.new.invoke(:two) }).to eq("2\n3\n")
-    end
-
-    it "invokes a task just once" do
-      expect(capture(:stdout) { A.new.invoke(:one) }).to eq("1\n2\n3\n")
-    end
-
-    it "invokes a task 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 task 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 task if none is given to a Thor class" do
-      content = capture(:stdout) { A.new.invoke("b") }
-      expect(content).to match(/Tasks/)
-      expect(content).to match(/LAST_NAME/)
-    end
-
-    it "accepts a class as argument without a task to invoke" do
-      content = capture(:stdout) { A.new.invoke(B) }
-      expect(content).to match(/Tasks/)
-      expect(content).to match(/LAST_NAME/)
-    end
-
-    it "accepts a class as argument with a task 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 "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 tasks" 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 tasks twice" do
-      base = A.new
-      silence(:stdout){ base.invoke(:c) }
-      expect(capture(:stdout) { base.invoke("c:one") }).to be_empty
-    end
-
-    it "raises Thor::UndefinedTaskError if the task can't be found" do
-      expect {
-        A.new.invoke("foo:bar")
-      }.to 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 }
-
-      expect {
-        base.invoke("foo:bar")
-      }.to raise_error(Thor::UndefinedTaskError)
-    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