torquebox-console 0.2.3 → 0.2.4

data/vendor/bundle/ruby/1.8/gems/thor-0.17.0/spec/util_spec.rb

@@ -0,0 +1,196 @@
+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
+      expect(Thor::Util.find_by_namespace('')).to eq(Scripts::MyDefaults)
+    end
+
+    it "adds 'default' if namespace starts with :" do
+      expect(Thor::Util.find_by_namespace(':child')).to eq(Scripts::ChildDefault)
+    end
+
+    it "returns nil if the namespace can't be found" do
+      expect(Thor::Util.find_by_namespace('thor:core_ext:ordered_hash')).to be_nil
+    end
+
+    it "returns a class if it matches the namespace" do
+      expect(Thor::Util.find_by_namespace('app:broken:counter')).to eq(BrokenCounter)
+    end
+
+    it "matches classes default namespace" do
+      expect(Thor::Util.find_by_namespace('scripts:my_script')).to eq(Scripts::MyScript)
+    end
+  end
+
+  describe "#namespace_from_thor_class" do
+    it "replaces constant nesting with task namespacing" do
+      expect(Thor::Util.namespace_from_thor_class("Foo::Bar::Baz")).to eq("foo:bar:baz")
+    end
+
+    it "snake-cases component strings" do
+      expect(Thor::Util.namespace_from_thor_class("FooBar::BarBaz::BazBoom")).to eq("foo_bar:bar_baz:baz_boom")
+    end
+
+    it "accepts class and module objects" do
+      expect(Thor::Util.namespace_from_thor_class(Thor::CoreExt::OrderedHash)).to eq("thor:core_ext:ordered_hash")
+      expect(Thor::Util.namespace_from_thor_class(Thor::Util)).to eq("thor:util")
+    end
+
+    it "removes Thor::Sandbox namespace" do
+      expect(Thor::Util.namespace_from_thor_class("Thor::Sandbox::Package")).to eq("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")
+      expect(list).to include("foo:bar")
+      expect(list).not_to 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")
+      expect(defined?(Blat)).not_to be
+      expect(defined?(Thor::Sandbox::Blat)).to be
+    end
+  end
+
+  describe "#snake_case" do
+    it "preserves no-cap strings" do
+      expect(Thor::Util.snake_case("foo")).to eq("foo")
+      expect(Thor::Util.snake_case("foo_bar")).to eq("foo_bar")
+    end
+
+    it "downcases all-caps strings" do
+      expect(Thor::Util.snake_case("FOO")).to eq("foo")
+      expect(Thor::Util.snake_case("FOO_BAR")).to eq("foo_bar")
+    end
+
+    it "downcases initial-cap strings" do
+      expect(Thor::Util.snake_case("Foo")).to eq("foo")
+    end
+
+    it "replaces camel-casing with underscores" do
+      expect(Thor::Util.snake_case("FooBarBaz")).to eq("foo_bar_baz")
+      expect(Thor::Util.snake_case("Foo_BarBaz")).to eq("foo_bar_baz")
+    end
+
+    it "places underscores between multiple capitals" do
+      expect(Thor::Util.snake_case("ABClass")).to eq("a_b_class")
+    end
+  end
+
+  describe "#find_class_and_task_by_namespace" do
+    it "returns a Thor::Group class if full namespace matches" do
+      expect(Thor::Util.find_class_and_task_by_namespace("my_counter")).to eq([MyCounter, nil])
+    end
+
+    it "returns a Thor class if full namespace matches" do
+      expect(Thor::Util.find_class_and_task_by_namespace("thor")).to eq([Thor, nil])
+    end
+
+    it "returns a Thor class and the task name" do
+      expect(Thor::Util.find_class_and_task_by_namespace("thor:help")).to eq([Thor, "help"])
+    end
+
+    it "falls back in the namespace:task look up even if a full namespace does not match" do
+      Thor.const_set(:Help, Module.new)
+      expect(Thor::Util.find_class_and_task_by_namespace("thor:help")).to eq([Thor, "help"])
+      Thor.send :remove_const, :Help
+    end
+
+    it "falls back on the default namespace class if nothing else matches" do
+      expect(Thor::Util.find_class_and_task_by_namespace("test")).to eq([Scripts::MyDefaults, "test"])
+    end
+  end
+
+  describe "#thor_classes_in" do
+    it "returns thor classes inside the given class" do
+      expect(Thor::Util.thor_classes_in(MyScript)).to eq([MyScript::AnotherScript])
+      expect(Thor::Util.thor_classes_in(MyScript::AnotherScript)).to be_empty
+    end
+  end
+
+  describe "#user_home" do
+    before do
+      ENV.stub!(:[])
+      Thor::Util.clear_user_home!
+    end
+
+    it "returns the user path if none variable is set on the environment" do
+      expect(Thor::Util.user_home).to eq(File.expand_path("~"))
+    end
+
+    it "returns the *unix system path if file cannot be expanded and separator does not exist" do
+      File.should_receive(:expand_path).with("~").and_raise(RuntimeError)
+      previous_value = File::ALT_SEPARATOR
+      capture(:stderr){ File.const_set(:ALT_SEPARATOR, false) }
+      expect(Thor::Util.user_home).to eq("/")
+      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
+      File.should_receive(:expand_path).with("~").and_raise(RuntimeError)
+      previous_value = File::ALT_SEPARATOR
+      capture(:stderr){ File.const_set(:ALT_SEPARATOR, true) }
+      expect(Thor::Util.user_home).to eq("C:/")
+      capture(:stderr){ File.const_set(:ALT_SEPARATOR, previous_value) }
+    end
+
+    it "returns HOME/.thor if set" do
+      ENV.stub!(:[]).with("HOME").and_return("/home/user/")
+      expect(Thor::Util.user_home).to eq("/home/user/")
+    end
+
+    it "returns path with HOMEDRIVE and HOMEPATH if set" do
+      ENV.stub!(:[]).with("HOMEDRIVE").and_return("D:/")
+      ENV.stub!(:[]).with("HOMEPATH").and_return("Documents and Settings/James")
+      expect(Thor::Util.user_home).to eq("D:/Documents and Settings/James")
+    end
+
+    it "returns APPDATA/.thor if set" do
+      ENV.stub!(:[]).with("APPDATA").and_return("/home/user/")
+      expect(Thor::Util.user_home).to eq("/home/user/")
+    end
+  end
+
+  describe "#thor_root_glob" do
+    before do
+      ENV.stub!(:[])
+      Thor::Util.clear_user_home!
+    end
+
+    it "escapes globs in path" do
+      ENV.stub!(:[]).with("HOME").and_return("/home/user{1}/")
+      Dir.should_receive(:[]).with("/home/user\\{1\\}/.thor/*").and_return([])
+      expect(Thor::Util.thor_root_glob).to eq([])
+    end
+  end
+
+  describe "#globs_for" do
+    it "escapes globs in path" do
+      expect(Thor::Util.globs_for("/home/apps{1}")).to eq([
+        "/home/apps\\{1\\}/Thorfile",
+        "/home/apps\\{1\\}/*.thor",
+        "/home/apps\\{1\\}/tasks/*.thor",
+        "/home/apps\\{1\\}/lib/tasks/*.thor"
+      ])
+    end
+  end
+
+  describe "#escape_globs" do
+    it "escapes ? * { } [ ] glob characters" do
+      expect(Thor::Util.escape_globs("apps?")).to eq("apps\\?")
+      expect(Thor::Util.escape_globs("apps*")).to eq("apps\\*")
+      expect(Thor::Util.escape_globs("apps {1}")).to eq("apps \\{1\\}")
+      expect(Thor::Util.escape_globs("apps [1]")).to eq("apps \\[1\\]")
+    end
+  end
+end

data/vendor/bundle/ruby/1.8/gems/thor-0.17.0/thor.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/thor/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.authors = ['Yehuda Katz', 'José Valim']
+  s.description = %q{A scripting framework that replaces rake, sake and rubigen}
+  s.email = 'ruby-thor@googlegroups.com'
+  s.executables = `git ls-files -- bin/*`.split("\n").map{|f| File.basename(f)}
+  s.extra_rdoc_files = ['CHANGELOG.rdoc', 'LICENSE.md', 'README.md', 'Thorfile']
+  s.files = `git ls-files`.split("\n")
+  s.homepage = 'http://whatisthor.com/'
+  s.licenses = ['MIT']
+  s.name = 'thor'
+  s.rdoc_options = ['--charset=UTF-8']
+  s.require_paths = ['lib']
+  s.required_rubygems_version = Gem::Requirement.new('>= 1.3.6')
+  s.summary = s.description
+  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.version = Thor::VERSION
+end

data/vendor/bundle/ruby/1.8/gems/tilt-1.3.4/COPYING

@@ -0,0 +1,18 @@
+Copyright (c) 2010 Ryan Tomayko <http://tomayko.com/about>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/vendor/bundle/ruby/1.8/gems/tilt-1.3.4/Gemfile

@@ -0,0 +1,32 @@
+source "http://rubygems.org"
+
+gem 'rake'
+gem 'asciidoctor', '>= 0.1.0'
+gem 'builder'
+gem 'coffee-script'
+gem 'contest'
+gem 'creole'
+gem 'erubis'
+gem 'haml', '>= 2.2.11', '< 4'
+gem 'kramdown'
+gem 'less'
+gem 'liquid'
+gem 'markaby'
+gem 'maruku'
+gem 'nokogiri'
+gem 'radius'
+gem 'sass'
+gem 'wikicloth'
+gem 'rdoc', (ENV['RDOC_VERSION'] || '> 0')
+
+platform :ruby do
+  gem 'yajl-ruby'
+  gem 'redcarpet'
+  gem 'rdiscount' if RUBY_VERSION != '1.9.2'
+  gem 'RedCloth'
+end
+
+platform :mri do
+  gem 'therubyracer'
+  gem 'bluecloth'
+end

data/vendor/bundle/ruby/1.8/gems/tilt-1.3.4/HACKING

@@ -0,0 +1,16 @@
+Clone:
+
+    git clone git://github.com/rtomayko/tilt.git
+    cd tilt
+
+Install needed packages under ./vendor and run tests (requires bundler):
+
+    rake
+
+Run tests under your current gem environment. Do not install anything:
+
+    rake test
+
+Only install needed packages under ./vendor:
+
+    rake setup

data/vendor/bundle/ruby/1.8/gems/tilt-1.3.4/README.md

@@ -0,0 +1,211 @@
+Tilt [![Build Status](https://secure.travis-ci.org/rtomayko/tilt.png)](http://travis-ci.org/rtomayko/tilt) [![Dependency Status](https://gemnasium.com/rtomayko/tilt.png)](https://gemnasium.com/rtomayko/tilt)
+====
+
+Tilt is a thin interface over a bunch of different Ruby template engines in
+an attempt to make their usage as generic possible. This is useful for web
+frameworks, static site generators, and other systems that support multiple
+template engines but don't want to code for each of them individually.
+
+The following features are supported for all template engines (assuming the
+feature is relevant to the engine):
+
+ * Custom template evaluation scopes / bindings
+ * Ability to pass locals to template evaluation
+ * Support for passing a block to template evaluation for "yield"
+ * Backtraces with correct filenames and line numbers
+ * Template file caching and reloading
+ * Fast, method-based template source compilation
+
+The primary goal is to get all of the things listed above right for all
+template engines included in the distribution.
+
+Support for these template engines is included with the package:
+
+    ENGINE                     FILE EXTENSIONS         REQUIRED LIBRARIES
+    -------------------------- ----------------------- ----------------------------
+    Asciidoctor                .ad, .adoc, .asciidoc   asciidoctor (>= 0.1.0)
+    ERB                        .erb, .rhtml            none (included ruby stdlib)
+    Interpolated String        .str                    none (included ruby core)
+    Erubis                     .erb, .rhtml, .erubis   erubis
+    Haml                       .haml                   haml
+    Sass                       .sass                   haml (< 3.1) or sass (>= 3.1)
+    Scss                       .scss                   haml (< 3.1) or sass (>= 3.1)
+    Less CSS                   .less                   less
+    Builder                    .builder                builder
+    Liquid                     .liquid                 liquid
+    RDiscount                  .markdown, .mkd, .md    rdiscount
+    Redcarpet                  .markdown, .mkd, .md    redcarpet
+    BlueCloth                  .markdown, .mkd, .md    bluecloth
+    Kramdown                   .markdown, .mkd, .md    kramdown
+    Maruku                     .markdown, .mkd, .md    maruku
+    RedCloth                   .textile                redcloth
+    RDoc                       .rdoc                   rdoc
+    Radius                     .radius                 radius
+    Markaby                    .mab                    markaby
+    Nokogiri                   .nokogiri               nokogiri
+    CoffeeScript               .coffee                 coffee-script (+ javascript)
+    Creole (Wiki markup)       .wiki, .creole          creole
+    WikiCloth (Wiki markup)    .wiki, .mediawiki, .mw  wikicloth
+    Yajl                       .yajl                   yajl-ruby
+    CSV                        .csv                    none (Ruby >= 1.9), fastercsv (Ruby < 1.9)
+
+These template engines ship with their own Tilt integration:
+
+    ENGINE                     FILE EXTENSIONS   REQUIRED LIBRARIES
+    -------------------------- ----------------- ----------------------------
+    Slim                       .slim             slim (>= 0.7)
+    Embedded JavaScript                          sprockets
+    Embedded CoffeeScript                        sprockets
+    JST                                          sprockets
+    Org-mode                   .org              org-ruby (>= 0.6.2)
+
+See [TEMPLATES.md][t] for detailed information on template engine
+options and supported features.
+
+[t]: http://github.com/rtomayko/tilt/blob/master/TEMPLATES.md
+   "Tilt Template Engine Documentation"
+
+Basic Usage
+-----------
+
+Instant gratification:
+
+    require 'erb'
+    require 'tilt'
+    template = Tilt.new('templates/foo.erb')
+    => #<Tilt::ERBTemplate @file="templates/foo.rb" ...>
+    output = template.render
+    => "Hello world!"
+
+It's recommended that calling programs explicitly require template engine
+libraries (like 'erb' above) at load time. Tilt attempts to lazy require the
+template engine library the first time a template is created but this is
+prone to error in threaded environments.
+
+The `Tilt` module contains generic implementation classes for all supported
+template engines. Each template class adheres to the same interface for
+creation and rendering. In the instant gratification example, we let Tilt
+determine the template implementation class based on the filename, but
+`Tilt::Template` implementations can also be used directly:
+
+    template = Tilt::HamlTemplate.new('templates/foo.haml')
+    output = template.render
+
+The `render` method takes an optional evaluation scope and locals hash
+arguments. Here, the template is evaluated within the context of the
+`Person` object with locals `x` and `y`:
+
+    template = Tilt::ERBTemplate.new('templates/foo.erb')
+    joe = Person.find('joe')
+    output = template.render(joe, :x => 35, :y => 42)
+
+If no scope is provided, the template is evaluated within the context of an
+object created with `Object.new`.
+
+A single `Template` instance's `render` method may be called multiple times
+with different scope and locals arguments. Continuing the previous example,
+we render the same compiled template but this time in jane's scope:
+
+    jane = Person.find('jane')
+    output = template.render(jane, :x => 22, :y => nil)
+
+Blocks can be passed to `render` for templates that support running
+arbitrary ruby code (usually with some form of `yield`). For instance,
+assuming the following in `foo.erb`:
+
+    Hey <%= yield %>!
+
+The block passed to `render` is called on `yield`:
+
+    template = Tilt::ERBTemplate.new('foo.erb')
+    template.render { 'Joe' }
+    # => "Hey Joe!"
+
+Template Mappings
+-----------------
+
+The `Tilt` module includes methods for associating template implementation
+classes with filename patterns and for locating/instantiating template
+classes based on those associations.
+
+The `Tilt::register` method associates a filename pattern with a specific
+template implementation. To use ERB for files ending in a `.bar` extension:
+
+     >> Tilt.register Tilt::ERBTemplate, 'bar'
+     >> Tilt.new('views/foo.bar')
+     => #<Tilt::ERBTemplate @file="views/foo.bar" ...>
+
+Retrieving the template class for a file or file extension:
+
+     >> Tilt['foo.bar']
+     => Tilt::ERBTemplate
+     >> Tilt['haml']
+     => Tilt::HamlTemplate
+
+It's also possible to register template file mappings that are more specific
+than a file extension. To use Erubis for `bar.erb` but ERB for all other `.erb`
+files:
+
+     >> Tilt.register Tilt::ErubisTemplate, 'bar.erb'
+     >> Tilt.new('views/foo.erb')
+     => Tilt::ERBTemplate
+     >> Tilt.new('views/bar.erb')
+     => Tilt::ErubisTemplate
+
+The template class is determined by searching for a series of decreasingly
+specific name patterns. When creating a new template with
+`Tilt.new('views/foo.html.erb')`, we check for the following template
+mappings:
+
+  1. `views/foo.html.erb`
+  2. `foo.html.erb`
+  3. `html.erb`
+  4. `erb`
+
+### Fallback mode
+
+If there are more than one template class registered for a file extension, Tilt
+will automatically try to load the version that works on your machine:
+
+  1. If any of the template engines has been loaded already: Use that one.
+  2. If not, it will try to initialize each of the classes with an empty template.
+  3. Tilt will use the first that doesn't raise an exception.
+  4. If however *all* of them failed, Tilt will raise the exception of the first
+     template engine, since that was the most preferred one.
+
+Template classes that were registered *last* would be tried first. Because the
+Markdown extensions are registered like this:
+
+    Tilt.register Tilt::BlueClothTemplate, 'md'
+    Tilt.register Tilt::RDiscountTemplate, 'md'
+
+Tilt will first try RDiscount and then BlueCloth. You could say that RDiscount
+has a *higher priority* than BlueCloth.
+
+The fallback mode works nicely when you just need to render an ERB or Markdown
+template, but if you depend on a specific implementation, you should use #prefer:
+
+    # Prefer BlueCloth for all its registered extensions (markdown, mkd, md)
+    Tilt.prefer Tilt::BlueClothTemplate
+
+    # Prefer Erubis for .erb only:
+    Tilt.prefer Tilt::ErubisTemplate, 'erb'
+
+When a file extension has a preferred template class, Tilt will *always* use
+that class, even if it raises an exception.
+
+Template Compilation
+--------------------
+
+Tilt compiles generated Ruby source code produced by template engines and reuses
+it on subsequent template invocations. Benchmarks show this yields a 5x-10x
+performance increase over evaluating the Ruby source on each invocation.
+
+Template compilation is currently supported for these template engines:
+StringTemplate, ERB, Erubis, Haml, Nokogiri, Builder and Yajl.
+
+LICENSE
+-------
+
+Tilt is Copyright (c) 2010 [Ryan Tomayko](http://tomayko.com/about) and
+distributed under the MIT license. See the `COPYING` file for more info.