rango 0.1.pre → 0.1.0

data/vendor/thor/spec/shell/color_spec.rb

@@ -1,41 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Thor::Shell::Color do
-  def shell
-    @shell ||= Thor::Shell::Color.new
-  end
-
-  describe "#say" do
-    it "set the color if specified" do
-      mock($stdout).puts("\e[32mWow! Now we have colors!\e[0m")
-      shell.say "Wow! Now we have colors!", :green
-    end
-
-    it "does not use a new line even with colors" do
-      mock($stdout).print("\e[32mWow! Now we have colors! \e[0m")
-      shell.say "Wow! Now we have colors! ", :green
-    end
-  end
-
-  describe "#say_status" do
-    it "uses color to say status" do
-      mock($stdout).puts("\e[1m\e[31m    conflict\e[0m  README")
-      shell.say_status :conflict, "README", :red
-    end
-  end
-
-  describe "#file_collision" do
-    describe "when a block is given" do
-      it "invokes the diff command" do
-        stub($stdout).print
-        mock($stdin).gets{ 'd' }
-        mock($stdin).gets{ 'n' }
-
-        output = capture(:stdout){ shell.file_collision('spec/fixtures/doc/README'){ "README\nEND\n" } }
-        output.must =~ /\e\[31m\- __start__\e\[0m/
-        output.must =~ /^  README/
-        output.must =~ /\e\[32m\+ END\e\[0m/
-      end
-    end
-  end
-end

data/vendor/thor/spec/shell_spec.rb

@@ -1,25 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe Thor::Shell do
-  def shell
-    @shell ||= Thor::Base.shell.new
-  end
-
-  describe "#initialize" do
-    it "sets shell value" do
-      base = MyCounter.new [1, 2], { }, :shell => shell
-      base.shell.must == shell
-    end
-
-    it "sets the base value on the shell if an accessor is available" do
-      base = MyCounter.new [1, 2], { }, :shell => shell
-      shell.base.must == base
-    end
-  end
-
-  describe "#shell" do
-    it "returns the shell in use" do
-      MyCounter.new([1,2]).shell.must be_kind_of(Thor::Base.shell)
-    end
-  end
-end

data/vendor/thor/spec/spec.opts

@@ -1 +0,0 @@
---color

data/vendor/thor/spec/spec_helper.rb

@@ -1,52 +0,0 @@
-$TESTING=true
-
-$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
-require 'thor'
-require 'stringio'
-
-require 'rubygems'
-require 'rr'
-require 'diff/lcs' # You need diff/lcs installed to run specs (but not to run Thor).
-
-# Load fixtures
-load File.join(File.dirname(__FILE__), "fixtures", "task.thor")
-load File.join(File.dirname(__FILE__), "fixtures", "group.thor")
-load File.join(File.dirname(__FILE__), "fixtures", "script.thor")
-load File.join(File.dirname(__FILE__), "fixtures", "invoke.thor")
-
-# Set shell to basic
-Thor::Base.shell = Thor::Shell::Basic
-
-Kernel.module_eval do
-  alias_method :must, :should
-  alias_method :must_not, :should_not
-  undef_method :should
-  undef_method :should_not
-end
-
-Spec::Runner.configure do |config|
-  config.mock_with :rr
-
-  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/vendor/thor/spec/task_spec.rb

@@ -1,88 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe Thor::Task do
-  def task(options={})
-    options.each do |key, value|
-      options[key] = Thor::Option.parse(key, value)
-    end
-
-    @task ||= Thor::Task.new(:can_has, "I can has cheezburger", "can_has", options)
-  end
-
-  describe "#formatted_usage" do
-    it "shows usage with options" do
-      task('foo' => true, :bar => :required).formatted_usage.must == "can_has --bar=BAR [--foo]"
-    end
-
-    it "includes namespace within usage" do
-      stub(Object).namespace{ "foo" }
-      stub(Object).arguments{ [] }
-      task(:bar => :required).formatted_usage(Object, true).must == "foo:can_has --bar=BAR"
-    end
-
-    it "does not show options if required" do
-      stub(Object).namespace{ "foo" }
-      stub(Object).arguments{ [] }
-      task(:bar => :required).formatted_usage(Object, true, false).must == "foo:can_has"
-    end
-
-    it "removes default from namespace" do
-      stub(Object).namespace{ "default:foo" }
-      stub(Object).arguments{ [] }
-      task(:bar => :required).formatted_usage(Object, true).must == ":foo:can_has --bar=BAR"
-    end
-
-    it "injects arguments into usage" do
-      stub(Object).namespace{ "foo" }
-      stub(Object).arguments{ [ Thor::Argument.new(:bar, nil, true, :string) ] }
-      task(:foo => true).formatted_usage(Object).must == "can_has BAR [--foo]"
-    end
-  end
-
-  describe "#dynamic" do
-    it "creates a dynamic task with the given name" do
-      Thor::Task::Dynamic.new('task').name.must == 'task'
-      Thor::Task::Dynamic.new('task').description.must == 'A dynamically-generated task'
-      Thor::Task::Dynamic.new('task').usage.must == 'task'
-      Thor::Task::Dynamic.new('task').options.must == {}
-    end
-
-    it "does not invoke an existing method" do
-      lambda {
-        Thor::Task::Dynamic.new('to_s').run([])
-      }.must raise_error(Thor::Error, "could not find Thor class or task 'to_s'")
-    end
-  end
-
-  describe "#dup" do
-    it "dup options hash" do
-      task = Thor::Task.new("can_has", nil, nil, :foo => true, :bar => :required)
-      task.dup.options.delete(:foo)
-      task.options[:foo].must_not be_nil
-    end
-  end
-
-  describe "#run" do
-    it "runs a task by calling a method in the given instance" do
-      mock = mock!.send("can_has", 1, 2, 3).subject
-      task.run(mock, [1, 2, 3])
-    end
-
-    it "raises an error if the method to be invoked is private" do
-      mock = mock!.private_methods{ [ 'can_has' ] }.subject
-      lambda {
-        task.run(mock)
-      }.must raise_error(Thor::UndefinedTaskError, "the 'can_has' task of Object is private")
-    end
-  end
-
-  describe "#short_description" do
-    it "returns the first line of the description" do
-      Thor::Task.new(:task, "I can has\ncheezburger", "can_has").short_description == "I can has"
-    end
-
-    it "returns the whole description if it's one line" do
-      Thor::Task.new(:task, "I can has cheezburger", "can_has").short_description == "I can has cheezburger"
-    end
-  end
-end

data/vendor/thor/spec/thor_spec.rb

@@ -1,234 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe Thor do
-  describe "#method_option" do
-    it "sets options to the next method to be invoked" do
-      args = ["foo", "bar", "--force"]
-      arg, options = MyScript.start(args)
-      options.must == { "force" => true }
-    end
-
-    describe "when :for is supplied" do
-      it "updates an already defined task" do
-        args, options = MyChildScript.start(["animal", "horse", "--other=fish"])
-        options[:other].must == "fish"
-      end
-
-      describe "and the target is on the parent class" do
-        it "updates an already defined task" do
-          args = ["example_default_task", "my_param", "--new-option=verified"]
-          options = Scripts::MyScript.start(args)
-          options[:new_option].must == "verified"
-        end
-
-        it "adds a task to the tasks list if the updated task is on the parent class" do
-          Scripts::MyScript.tasks["example_default_task"].must_not be_nil
-        end
-
-        it "clones the parent task" do
-          Scripts::MyScript.tasks["example_default_task"].must_not == MyChildScript.tasks["example_default_task"]
-        end
-      end
-    end
-  end
-
-  describe "#default_task" do
-    it "sets a default task" do
-      MyScript.default_task.must == "example_default_task"
-    end
-
-    it "invokes the default task if no command is specified" do
-      MyScript.start([]).must == "default task"
-    end
-
-    it "inherits the default task from parent" do
-      MyChildScript.default_task.must == "example_default_task"
-    end
-  end
-
-  describe "#map" do
-    it "calls the alias of a method if one is provided" do
-      MyScript.start(["-T", "fish"]).must == ["fish"]
-    end
-
-    it "calls the alias of a method if several are provided via .map" do
-      MyScript.start(["-f", "fish"]).must == ["fish", {}]
-      MyScript.start(["--foo", "fish"]).must == ["fish", {}]
-    end
-
-    it "inherits all mappings from parent" do
-      MyChildScript.default_task.must == "example_default_task"
-    end
-  end
-
-  describe "#desc" do
-    before(:all) do
-      @content = capture(:stdout) { MyScript.start(["help"]) }
-    end
-
-    it "provides description for a task" do
-      @content.must =~ /zoo\s+# zoo around/m
-    end
-
-    describe "when :for is supplied" do
-      it "overwrites a previous defined task" do
-        capture(:stdout) { MyChildScript.start(["help"]) }.must =~ /animal KIND \[\-\-other=OTHER\]\s+# fish around/m
-      end
-    end
-  end
-
-  describe "#method_options" do
-    it "sets default options if called before an initializer" do
-      options = MyChildScript.class_options
-      options[:force].type.must == :boolean
-      options[:param].type.must == :numeric
-    end
-
-    it "overwrites default options if called on the method scope" do
-      args = ["zoo", "--force", "--param", "feathers"]
-      options = MyChildScript.start(args)
-      options.must == { "force" => true, "param" => "feathers" }
-    end
-
-    it "allows default options to be merged with method options" do
-      args = ["animal", "bird", "--force", "--param", "1.0", "--other", "tweets"]
-      arg, options = MyChildScript.start(args)
-      arg.must == 'bird'
-      options.must == { "force"=>true, "param"=>1.0, "other"=>"tweets" }
-    end
-  end
-
-  describe "#start" do
-    it "calls a no-param method when no params are passed" do
-      MyScript.start(["zoo"]).must == true
-    end
-
-    it "calls a single-param method when a single param is passed" do
-      MyScript.start(["animal", "fish"]).must == ["fish"]
-    end
-
-    it "does not set options in attributes" do
-      MyScript.start(["with_optional", "--all"]).must == [nil, { "all" => true }]
-    end
-
-    it "raises an error if a required param is not provided" do
-      capture(:stderr) { MyScript.start(["animal"]) }.must =~ /'animal' was called incorrectly\. Call as 'my_script:animal TYPE'/
-    end
-
-    it "raises an error if the invoked task does not exist" do
-      capture(:stderr) { Amazing.start(["animal"]) }.must =~ /The amazing namespace doesn't have a 'animal' task/
-    end
-
-    it "calls method_missing if an unknown method is passed in" do
-      MyScript.start(["unk", "hello"]).must == [:unk, ["hello"]]
-    end
-
-    it "does not call a private method no matter what" do
-      capture(:stderr) { MyScript.start(["what"]) }.must =~ /the 'what' task of MyScript is private/
-    end
-
-    it "uses task default options" do
-      options = MyChildScript.start(["animal", "fish"]).last
-      options.must == { "other" => "method default" }
-    end
-
-    it "raises when an exception happens within the task call" do
-      lambda { MyScript.start(["call_myself_with_wrong_arity"]) }.must raise_error
-    end
-  end
-
-  describe "#help" do
-    def shell
-      @shell ||= Thor::Base.shell.new
-    end
-
-    describe "on general" do
-      before(:each) do
-        @content = capture(:stdout){ MyScript.help(shell) }
-      end
-
-      it "provides useful help info for the help method itself" do
-        @content.must =~ /help \[TASK\]\s+# Describe available tasks/m
-      end
-
-      it "provides useful help info for a method with params" do
-        @content.must =~ /animal TYPE\s+# horse around/m
-      end
-
-      it "provides description for tasks from classes in the same namespace" do
-        @content.must =~ /baz\s+# do some bazing/m
-      end
-
-      it "shows superclass tasks" do
-        content = capture(:stdout){ MyChildScript.help(shell) }
-        content.must =~ /foo BAR \[\-\-force\]\s+# do some fooing/m
-      end
-
-      it "shows class options information" do
-        content = capture(:stdout){ MyChildScript.help(shell) }
-        content.must =~ /Class options\:/
-        content.must =~ /\[\-\-param=N\]/
-      end
-
-      it "injects class arguments into default usage" do
-        content = capture(:stdout){ Scripts::MyScript.help(shell) }
-        content.must =~ /zoo ACCESSOR \-\-param\=PARAM/
-      end
-    end
-
-    describe "for a specific task" do
-      it "provides full help info when talking about a specific task" do
-        capture(:stdout) { MyScript.help(shell, "foo") }.must == <<END
-Usage:
-  foo BAR
-
-Method options:
-  [--force]  # Force to do some fooing
-
-do some fooing
-  This is more info!
-  Everyone likes more info!
-END
-      end
-
-      it "raises an error if the task can't be found" do
-        lambda {
-          MyScript.help(shell, "unknown")
-        }.must raise_error(Thor::Error, "task 'unknown' could not be found in namespace 'my_script'")
-      end
-    end
-
-    describe "options" do
-      it "shows the namespace if required" do
-        capture(:stdout){ MyScript.help(shell, nil, :namespace => true) }.must =~ /my_script:foo BAR/
-      end
-
-      it "does not show superclass tasks if required" do
-        capture(:stdout){ MyScript.help(shell, nil, :short => true) }.must_not =~ /help/
-      end
-    end
-
-    describe "instance method" do
-      it "calls the class method" do
-        stub(MyScript).help(mock.instance_of(Thor::Base.shell), nil, :namespace => nil)
-        MyScript.start(["help"])
-      end
-    end
-  end
-
-  describe "when creating tasks" do
-    it "prints a warning if a public method is created without description or usage" do
-      capture(:stdout) {
-        klass = Class.new(Thor)
-        klass.class_eval "def hello_from_thor; end"
-      }.must =~ /\[WARNING\] Attempted to create task "hello_from_thor" without usage or description/
-    end
-
-    it "does not print if overwriting a previous task" do
-      capture(:stdout) {
-        klass = Class.new(Thor)
-        klass.class_eval "def help; end"
-      }.must be_empty
-    end
-  end
-end

data/vendor/thor/spec/util_spec.rb

@@ -1,196 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-module Thor::Util
-  def self.clear_user_home!
-    @@user_home = nil
-  end
-end
-
-describe Thor::Util do
-  describe "#find_by_namespace" do
-    it "returns 'default' if no namespace is given" do
-      Thor::Util.find_by_namespace('').must == Scripts::MyDefaults
-    end
-
-    it "adds 'default' if namespace starts with :" do
-      Thor::Util.find_by_namespace(':child').must == Scripts::ChildDefault
-    end
-
-    it "returns nil if the namespace can't be found" do
-      Thor::Util.find_by_namespace('thor:core_ext:ordered_hash').must be_nil
-    end
-
-    it "returns a class if it matches the namespace" do
-      Thor::Util.find_by_namespace('app:broken:counter').must == BrokenCounter
-    end
-
-    it "matches classes default namespace" do
-      Thor::Util.find_by_namespace('scripts:my_script').must == Scripts::MyScript
-    end
-  end
-
-  describe "#namespace_from_thor_class" do
-    it "replaces constant nesting with task namespacing" do
-      Thor::Util.namespace_from_thor_class("Foo::Bar::Baz").must == "foo:bar:baz"
-    end
-
-    it "snake-cases component strings" do
-      Thor::Util.namespace_from_thor_class("FooBar::BarBaz::BazBoom").must == "foo_bar:bar_baz:baz_boom"
-    end
-
-    it "gets rid of an initial Default module" do
-      Thor::Util.namespace_from_thor_class("Default::Foo::Bar").must == ":foo:bar"
-      Thor::Util.namespace_from_thor_class("Default").must == ""
-    end
-
-    it "accepts class and module objects" do
-      Thor::Util.namespace_from_thor_class(Thor::CoreExt::OrderedHash).must == "thor:core_ext:ordered_hash"
-      Thor::Util.namespace_from_thor_class(Thor::Util).must == "thor:util"
-    end
-
-    it "removes Thor::Sandbox namespace" do
-      Thor::Util.namespace_from_thor_class("Thor::Sandbox::Package").must == "package"
-    end
-  end
-
-  describe "#namespaces_in_content" do
-    it "returns an array of names of constants defined in the string" do
-      list = Thor::Util.namespaces_in_content("class Foo; class Bar < Thor; end; end; class Baz; class Bat; end; end")
-      list.must include("foo:bar")
-      list.must_not include("bar:bat")
-    end
-
-    it "doesn't put the newly-defined constants in the enclosing namespace" do
-      Thor::Util.namespaces_in_content("class Blat; end")
-      defined?(Blat).must_not be
-      defined?(Thor::Sandbox::Blat).must be
-    end
-  end
-
-  describe "#snake_case" do
-    it "preserves no-cap strings" do
-      Thor::Util.snake_case("foo").must == "foo"
-      Thor::Util.snake_case("foo_bar").must == "foo_bar"
-    end
-
-    it "downcases all-caps strings" do
-      Thor::Util.snake_case("FOO").must == "foo"
-      Thor::Util.snake_case("FOO_BAR").must == "foo_bar"
-    end
-
-    it "downcases initial-cap strings" do
-      Thor::Util.snake_case("Foo").must == "foo"
-    end
-
-    it "replaces camel-casing with underscores" do
-      Thor::Util.snake_case("FooBarBaz").must == "foo_bar_baz"
-      Thor::Util.snake_case("Foo_BarBaz").must == "foo_bar_baz"
-    end
-
-    it "places underscores between multiple capitals" do
-      Thor::Util.snake_case("ABClass").must == "a_b_class"
-    end
-  end
-
-  describe "#namespace_to_thor_class_and_task" do
-    it "returns a Thor::Group class if full namespace matches" do
-      Thor::Util.namespace_to_thor_class_and_task("my_counter").must == [MyCounter, nil]
-    end
-
-    it "returns a Thor class if full namespace matches" do
-      Thor::Util.namespace_to_thor_class_and_task("thor").must == [Thor, nil]
-    end
-
-    it "returns a Thor class and the task name" do
-      Thor::Util.namespace_to_thor_class_and_task("thor:help").must == [Thor, "help"]
-    end
-
-    it "fallbacks in the namespace:task look up even if a full namespace does not match" do
-      Thor.const_set(:Help, Module.new)
-      Thor::Util.namespace_to_thor_class_and_task("thor:help").must == [Thor, "help"]
-      Thor.send :remove_const, :Help
-    end
-
-    describe 'errors' do
-      it "raises an error if the Thor class or task can't be found" do
-        lambda {
-          Thor::Util.namespace_to_thor_class_and_task("foobar")
-        }.must raise_error(Thor::Error, "could not find Thor class or task 'foobar'")
-      end
-    end
-  end
-
-  describe "#thor_classes_in" do
-    it "returns thor classes inside the given class" do
-      Thor::Util.thor_classes_in(MyScript).must == [MyScript::AnotherScript]
-      Thor::Util.thor_classes_in(MyScript::AnotherScript).must be_empty
-    end
-  end
-
-  describe "#user_home" do
-    before(:each) do
-      stub(ENV)[]
-      Thor::Util.clear_user_home!
-    end
-
-    it "returns the user path if none variable is set on the environment" do
-      Thor::Util.user_home.must == File.expand_path("~")
-    end
-
-    it "returns the *unix system path if file cannot be expanded and separator does not exist" do
-      stub(File).expand_path("~"){ raise }
-      previous_value = File::ALT_SEPARATOR
-      capture(:stderr){ File.const_set(:ALT_SEPARATOR, false) }
-      Thor::Util.user_home.must == "/"
-      capture(:stderr){ File.const_set(:ALT_SEPARATOR, previous_value) }
-    end
-
-    it "returns the windows system path if file cannot be expanded and a separator exists" do
-      stub(File).expand_path("~"){ raise }
-      previous_value = File::ALT_SEPARATOR
-      capture(:stderr){ File.const_set(:ALT_SEPARATOR, true) }
-      Thor::Util.user_home.must == "C:/"
-      capture(:stderr){ File.const_set(:ALT_SEPARATOR, previous_value) }
-    end
-
-    it "returns HOME/.thor if set" do
-      stub(ENV)["HOME"].returns{ "/home/user/" }
-      Thor::Util.user_home.must == "/home/user/"
-    end
-
-    it "returns path with HOMEDRIVE and HOMEPATH if set" do
-      stub(ENV)["HOMEDRIVE"].returns{ "D:/" }
-      stub(ENV)["HOMEPATH"].returns{ "Documents and Settings/James" }
-      Thor::Util.user_home.must == "D:/Documents and Settings/James"
-    end
-
-    it "returns APPDATA/.thor if set" do
-      stub(ENV)["APPDATA"].returns{ "/home/user/" }
-      Thor::Util.user_home.must == "/home/user/"
-    end
-  end
-
-  describe "#convert_constants_to_namespaces" do
-    before(:each) do
-      @hash = {
-        :git => {
-          :constants => [Object, "Thor::Sandbox::Package", Thor::CoreExt::OrderedHash]
-        }
-      }
-    end
-
-    it "converts constants in the hash to namespaces" do
-      Thor::Util.convert_constants_to_namespaces(@hash)
-      @hash[:git][:namespaces].must == [ "object", "package", "thor:core_ext:ordered_hash" ]
-    end
-
-    it "returns true if the hash changed" do
-      Thor::Util.convert_constants_to_namespaces(@hash).must be_true
-    end
-
-    it "does not add namespaces to the hash if namespaces were already added" do
-      Thor::Util.convert_constants_to_namespaces(@hash)
-      Thor::Util.convert_constants_to_namespaces(@hash).must be_false
-    end
-  end
-end