torquebox-console 0.2.3 → 0.2.4

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

@@ -0,0 +1,112 @@
+#!/usr/bin/env ruby
+require 'ostruct'
+require 'optparse'
+require 'tilt'
+
+usage = <<USAGE
+Usage: tilt <options> <file>
+Process template <file> and write output to stdout. With no <file> or
+when <file> is '-', read template from stdin and use the --type option
+to determine the template's type.
+
+Options
+  -l, --list           List template engines + file patterns and exit
+  -t, --type=<pattern> Use this template engine; required if no <file>
+  -y, --layout=<file>  Use <file> as a layout template
+
+  -D<name>=<value>     Define variable <name> as <value>
+  --vars=<ruby>        Evaluate <ruby> to Hash and use for variables
+
+  -h, --help           Show this help message
+
+Convert markdown to HTML:
+  $ tilt foo.markdown > foo.html
+
+Process ERB template:
+  $ echo "Answer: <%= 2 + 2 %>" | tilt -t erb
+  Answer: 4
+
+Define variables:
+  $ echo "Answer: <%= 2 + n %>" | tilt -t erb --vars="{:n=>40}"
+  Answer: 42
+  $ echo "Answer: <%= 2 + n.to_i %>" | tilt -t erb -Dn=40
+  Answer: 42
+USAGE
+
+script_name = File.basename($0)
+pattern = nil
+layout = nil
+locals = {}
+
+ARGV.options do |o|
+  o.program_name = script_name
+
+  # list all available template engines
+  o.on("-l", "--list") do
+    groups = {}
+    Tilt.mappings.each do |pattern,engines|
+      engines.each do |engine|
+        key = engine.name.split('::').last.sub(/Template$/, '')
+        (groups[key] ||= []) << pattern
+      end
+    end
+    groups.sort { |(k1,v1),(k2,v2)| k1 <=> k2 }.each do |engine,files|
+      printf "%-15s %s\n", engine, files.sort.join(', ')
+    end
+    exit
+  end
+
+  # the template type / pattern
+  o.on("-t", "--type=PATTERN", String) do |val|
+    abort "unknown template type: #{val}" if Tilt[val].nil?
+    pattern = val
+  end
+
+  # pass template output into the specified layout template
+  o.on("-y", "--layout=FILE", String)  do |file|
+    paths = [file, "~/.tilt/#{file}", "/etc/tilt/#{file}"]
+    layout = paths.
+      map  { |p| File.expand_path(p) }.
+      find { |p| File.exist?(p) }
+    abort "no such layout: #{file}" if layout.nil?
+  end
+
+  # define a local variable
+  o.on("-D", "--define=PAIR", String) do |pair|
+    key, value = pair.split(/[=:]/, 2)
+    locals[key.to_sym] = value
+  end
+
+  # define local variables using a Ruby hash
+  o.on("--vars=RUBY") do |ruby|
+    hash = eval(ruby)
+    abort "vars must be a Hash, not #{hash.inspect}" if !hash.is_a?(Hash)
+    hash.each { |key, value| locals[key.to_sym] = value }
+  end
+
+  o.on_tail("-h", "--help") { puts usage; exit }
+
+  o.parse!
+end
+
+file = ARGV.first || '-'
+pattern = file if pattern.nil?
+abort "template type not given. see: #{$0} --help" if ['-', ''].include?(pattern)
+
+engine = Tilt[pattern]
+abort "template engine not found for: #{pattern}" if engine.nil?
+
+template =
+  engine.new(file) {
+    if file == '-'
+      $stdin.read
+    else
+      File.read(file)
+    end
+  }
+output = template.render(self, locals)
+
+# process layout
+output = Tilt.new(layout).render(self, locals) { output } if layout
+
+$stdout.write(output)

data/vendor/bundle/ruby/1.8/gems/tilt-1.3.4/lib/tilt.rb

@@ -0,0 +1,204 @@
+module Tilt
+  VERSION = '1.3.4'
+
+  @preferred_mappings = Hash.new
+  @template_mappings = Hash.new { |h, k| h[k] = [] }
+
+  # Hash of template path pattern => template implementation class mappings.
+  def self.mappings
+    @template_mappings
+  end
+
+  def self.normalize(ext)
+    ext.to_s.downcase.sub(/^\./, '')
+  end
+
+  # Register a template implementation by file extension.
+  def self.register(template_class, *extensions)
+    if template_class.respond_to?(:to_str)
+      # Support register(ext, template_class) too
+      extensions, template_class = [template_class], extensions[0]
+    end
+
+    extensions.each do |ext|
+      ext = normalize(ext)
+      mappings[ext].unshift(template_class).uniq!
+    end
+  end
+
+  # Makes a template class preferred for the given file extensions. If you
+  # don't provide any extensions, it will be preferred for all its already
+  # registered extensions:
+  #
+  #   # Prefer RDiscount for its registered file extensions:
+  #   Tilt.prefer(Tilt::RDiscountTemplate)
+  #
+  #   # Prefer RDiscount only for the .md extensions:
+  #   Tilt.prefer(Tilt::RDiscountTemplate, '.md')
+  def self.prefer(template_class, *extensions)
+    if extensions.empty?
+      mappings.each do |ext, klasses|
+        @preferred_mappings[ext] = template_class if klasses.include? template_class
+      end
+    else
+      extensions.each do |ext|
+        ext = normalize(ext)
+        register(template_class, ext)
+        @preferred_mappings[ext] = template_class
+      end
+    end
+  end
+
+  # Returns true when a template exists on an exact match of the provided file extension
+  def self.registered?(ext)
+    mappings.key?(ext.downcase) && !mappings[ext.downcase].empty?
+  end
+
+  # Create a new template for the given file using the file's extension
+  # to determine the the template mapping.
+  def self.new(file, line=nil, options={}, &block)
+    if template_class = self[file]
+      template_class.new(file, line, options, &block)
+    else
+      fail "No template engine registered for #{File.basename(file)}"
+    end
+  end
+
+  # Lookup a template class for the given filename or file
+  # extension. Return nil when no implementation is found.
+  def self.[](file)
+    pattern = file.to_s.downcase
+    until pattern.empty? || registered?(pattern)
+      pattern = File.basename(pattern)
+      pattern.sub!(/^[^.]*\.?/, '')
+    end
+
+    # Try to find a preferred engine.
+    preferred_klass = @preferred_mappings[pattern]
+    return preferred_klass if preferred_klass
+
+    # Fall back to the general list of mappings.
+    klasses = @template_mappings[pattern]
+
+    # Try to find an engine which is already loaded.
+    template = klasses.detect do |klass|
+      if klass.respond_to?(:engine_initialized?)
+        klass.engine_initialized?
+      end
+    end
+
+    return template if template
+
+    # Try each of the classes until one succeeds. If all of them fails,
+    # we'll raise the error of the first class.
+    first_failure = nil
+
+    klasses.each do |klass|
+      begin
+        klass.new { '' }
+      rescue Exception => ex
+        first_failure ||= ex
+        next
+      else
+        return klass
+      end
+    end
+
+    raise first_failure if first_failure
+  end
+
+  # Deprecated module.
+  module CompileSite
+  end
+
+  # Extremely simple template cache implementation. Calling applications
+  # create a Tilt::Cache instance and use #fetch with any set of hashable
+  # arguments (such as those to Tilt.new):
+  #   cache = Tilt::Cache.new
+  #   cache.fetch(path, line, options) { Tilt.new(path, line, options) }
+  #
+  # Subsequent invocations return the already loaded template object.
+  class Cache
+    def initialize
+      @cache = {}
+    end
+
+    def fetch(*key)
+      @cache[key] ||= yield
+    end
+
+    def clear
+      @cache = {}
+    end
+  end
+
+
+  # Template Implementations ================================================
+
+  require 'tilt/string'
+  register StringTemplate, 'str'
+
+  require 'tilt/erb'
+  register ERBTemplate,    'erb', 'rhtml'
+  register ErubisTemplate, 'erb', 'rhtml', 'erubis'
+
+  require 'tilt/etanni'
+  register EtanniTemplate, 'etn', 'etanni'
+
+  require 'tilt/haml'
+  register HamlTemplate,   'haml'
+
+  require 'tilt/css'
+  register SassTemplate, 'sass'
+  register ScssTemplate, 'scss'
+  register LessTemplate, 'less'
+
+  require 'tilt/csv'
+  register CSVTemplate, 'csv'
+
+  require 'tilt/coffee'
+  register CoffeeScriptTemplate, 'coffee'
+
+  require 'tilt/nokogiri'
+  register NokogiriTemplate, 'nokogiri'
+
+  require 'tilt/builder'
+  register BuilderTemplate,  'builder'
+
+  require 'tilt/markaby'
+  register MarkabyTemplate,  'mab'
+
+  require 'tilt/liquid'
+  register LiquidTemplate, 'liquid'
+
+  require 'tilt/radius'
+  register RadiusTemplate, 'radius'
+
+  require 'tilt/markdown'
+  register MarukuTemplate,    'markdown', 'mkd', 'md'
+  register KramdownTemplate,  'markdown', 'mkd', 'md'
+  register BlueClothTemplate, 'markdown', 'mkd', 'md'
+  register RDiscountTemplate, 'markdown', 'mkd', 'md'
+  register RedcarpetTemplate::Redcarpet1, 'markdown', 'mkd', 'md'
+  register RedcarpetTemplate::Redcarpet2, 'markdown', 'mkd', 'md'
+  register RedcarpetTemplate, 'markdown', 'mkd', 'md'
+
+  require 'tilt/textile'
+  register RedClothTemplate, 'textile'
+
+  require 'tilt/rdoc'
+  register RDocTemplate, 'rdoc'
+
+  require 'tilt/wiki'
+  register CreoleTemplate,    'wiki', 'creole'
+  register WikiClothTemplate, 'wiki', 'mediawiki', 'mw'
+
+  require 'tilt/yajl'
+  register YajlTemplate, 'yajl'
+
+  require 'tilt/asciidoc'
+  register AsciidoctorTemplate, 'ad', 'adoc', 'asciidoc'
+
+  require 'tilt/plain'
+  register PlainTemplate, 'htmf'
+end

data/vendor/bundle/ruby/1.8/gems/tilt-1.3.4/lib/tilt/asciidoc.rb

@@ -0,0 +1,34 @@
+require 'tilt/template'
+
+# AsciiDoc see: http://asciidoc.org/
+module Tilt
+  # Asciidoctor implementation for AsciiDoc see:
+  # http://asciidoctor.github.com/
+  #
+  # Asciidoctor is an open source, pure-Ruby processor for
+  # converting AsciiDoc documents or strings into HTML 5,
+  # DocBook 4.5 and other formats.
+  class AsciidoctorTemplate < Template
+    self.default_mime_type = 'text/html'
+
+    def self.engine_initialized?
+      defined? ::Asciidoctor::Document
+    end
+
+    def initialize_engine
+      require_template_library 'asciidoctor'
+    end
+
+    def prepare
+      options[:header_footer] = false if options[:header_footer].nil?
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= Asciidoctor.render(data, options, &block)
+    end
+
+    def allows_script?
+      false
+    end
+  end
+end

data/vendor/bundle/ruby/1.8/gems/tilt-1.3.4/lib/tilt/builder.rb

@@ -0,0 +1,40 @@
+require 'tilt/template'
+
+module Tilt
+   # Builder template implementation. See:
+  # http://builder.rubyforge.org/
+  class BuilderTemplate < Template
+    self.default_mime_type = 'text/xml'
+
+    def self.engine_initialized?
+      defined? ::Builder
+    end
+
+    def initialize_engine
+      require_template_library 'builder'
+    end
+
+    def prepare; end
+
+    def evaluate(scope, locals, &block)
+      return super(scope, locals, &block) if data.respond_to?(:to_str)
+      xml = ::Builder::XmlMarkup.new(:indent => 2)
+      data.call(xml)
+      xml.target!
+    end
+
+    def precompiled_preamble(locals)
+      return super if locals.include? :xml
+      "xml = ::Builder::XmlMarkup.new(:indent => 2)\n#{super}"
+    end
+
+    def precompiled_postamble(locals)
+      "xml.target!"
+    end
+
+    def precompiled_template(locals)
+      data.to_str
+    end
+  end
+end
+

data/vendor/bundle/ruby/1.8/gems/tilt-1.3.4/lib/tilt/coffee.rb

@@ -0,0 +1,54 @@
+require 'tilt/template'
+
+module Tilt
+  # CoffeeScript template implementation. See:
+  # http://coffeescript.org/
+  #
+  # CoffeeScript templates do not support object scopes, locals, or yield.
+  class CoffeeScriptTemplate < Template
+    self.default_mime_type = 'application/javascript'
+
+    @@default_bare = false
+
+    def self.default_bare
+      @@default_bare
+    end
+
+    def self.default_bare=(value)
+      @@default_bare = value
+    end
+
+    # DEPRECATED
+    def self.default_no_wrap
+      @@default_bare
+    end
+
+    # DEPRECATED
+    def self.default_no_wrap=(value)
+      @@default_bare = value
+    end
+
+    def self.engine_initialized?
+      defined? ::CoffeeScript
+    end
+
+    def initialize_engine
+      require_template_library 'coffee_script'
+    end
+
+    def prepare
+      if !options.key?(:bare) and !options.key?(:no_wrap)
+        options[:bare] = self.class.default_bare
+      end
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= CoffeeScript.compile(data, options)
+    end
+
+    def allows_script?
+      false
+    end
+  end
+end
+

data/vendor/bundle/ruby/1.8/gems/tilt-1.3.4/lib/tilt/css.rb

@@ -0,0 +1,80 @@
+require 'tilt/template'
+
+module Tilt
+  # Sass template implementation. See:
+  # http://haml.hamptoncatlin.com/
+  #
+  # Sass templates do not support object scopes, locals, or yield.
+  class SassTemplate < Template
+    self.default_mime_type = 'text/css'
+
+    def self.engine_initialized?
+      defined? ::Sass::Engine
+    end
+
+    def initialize_engine
+      require_template_library 'sass'
+    end
+
+    def prepare
+      @engine = ::Sass::Engine.new(data, sass_options)
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= @engine.render
+    end
+
+    def allows_script?
+      false
+    end
+
+  private
+    def sass_options
+      options.merge(:filename => eval_file, :line => line, :syntax => :sass)
+    end
+  end
+
+  # Sass's new .scss type template implementation.
+  class ScssTemplate < SassTemplate
+    self.default_mime_type = 'text/css'
+
+  private
+    def sass_options
+      options.merge(:filename => eval_file, :line => line, :syntax => :scss)
+    end
+  end
+
+   # Lessscss template implementation. See:
+  # http://lesscss.org/
+  #
+  # Less templates do not support object scopes, locals, or yield.
+  class LessTemplate < Template
+    self.default_mime_type = 'text/css'
+
+    def self.engine_initialized?
+      defined? ::Less
+    end
+
+    def initialize_engine
+      require_template_library 'less'
+    end
+
+    def prepare
+      if ::Less.const_defined? :Engine
+        @engine = ::Less::Engine.new(data)
+      else
+        parser  = ::Less::Parser.new(options.merge :filename => eval_file, :line => line)
+        @engine = parser.parse(data)
+      end
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= @engine.to_css(options)
+    end
+
+    def allows_script?
+      false
+    end
+  end
+end
+