torquebox-console 0.2.3 → 0.2.4

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

@@ -0,0 +1,71 @@
+require 'tilt/template'
+
+module Tilt
+
+  # CSV Template implementation. See:
+  # http://ruby-doc.org/stdlib/libdoc/csv/rdoc/CSV.html
+  #
+  # == Example
+  #
+  #    # Example of csv template
+  #    tpl = <<-EOS
+  #      # header
+  #      csv << ['NAME', 'ID']
+  #
+  #      # data rows
+  #      @people.each do |person|
+  #        csv << [person[:name], person[:id]]
+  #      end
+  #    EOS
+  #
+  #    @people = [
+  #      {:name => "Joshua Peek", :id => 1},
+  #      {:name => "Ryan Tomayko", :id => 2},
+  #      {:name => "Simone Carletti", :id => 3}
+  #    ]
+  #
+  #    template = Tilt::CSVTemplate.new { tpl }
+  #    template.render(self)
+  #
+  class CSVTemplate < Template
+    self.default_mime_type = 'text/csv'
+
+    def self.engine_initialized?
+      engine
+    end
+
+    def self.engine
+      if RUBY_VERSION >= '1.9.0' && defined? ::CSV
+        ::CSV
+      elsif defined? ::FasterCSV
+        ::FasterCSV 
+      end
+    end
+
+    def initialize_engine
+      if RUBY_VERSION >= '1.9.0'
+        require_template_library 'csv'
+      else
+        require_template_library 'fastercsv'
+      end
+    end
+
+    def prepare
+      @code =<<-RUBY
+        #{self.class.engine}.generate do |csv|
+          #{data}
+        end
+      RUBY
+    end
+
+    def precompiled_template(locals)
+      @code
+    end
+
+    def precompiled(locals)
+      source, offset = super
+      [source, offset + 1]
+    end
+
+  end
+end

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

@@ -0,0 +1,110 @@
+require 'tilt/template'
+
+module Tilt
+  # ERB template implementation. See:
+  # http://www.ruby-doc.org/stdlib/libdoc/erb/rdoc/classes/ERB.html
+  class ERBTemplate < Template
+    @@default_output_variable = '_erbout'
+
+    def self.default_output_variable
+      @@default_output_variable
+    end
+
+    def self.default_output_variable=(name)
+      @@default_output_variable = name
+    end
+
+    def self.engine_initialized?
+      defined? ::ERB
+    end
+
+    def initialize_engine
+      require_template_library 'erb'
+    end
+
+    def prepare
+      @outvar = options[:outvar] || self.class.default_output_variable
+      options[:trim] = '<>' if !(options[:trim] == false) && (options[:trim].nil? || options[:trim] == true)
+      @engine = ::ERB.new(data, options[:safe], options[:trim], @outvar)
+    end
+
+    def precompiled_template(locals)
+      source = @engine.src
+      source
+    end
+
+    def precompiled_preamble(locals)
+      <<-RUBY
+        begin
+          __original_outvar = #{@outvar} if defined?(#{@outvar})
+          #{super}
+      RUBY
+    end
+
+    def precompiled_postamble(locals)
+      <<-RUBY
+          #{super}
+        ensure
+          #{@outvar} = __original_outvar
+        end
+      RUBY
+    end
+
+    # ERB generates a line to specify the character coding of the generated
+    # source in 1.9. Account for this in the line offset.
+    if RUBY_VERSION >= '1.9.0'
+      def precompiled(locals)
+        source, offset = super
+        [source, offset + 1]
+      end
+    end
+  end
+
+  # Erubis template implementation. See:
+  # http://www.kuwata-lab.com/erubis/
+  #
+  # ErubisTemplate supports the following additional options, which are not
+  # passed down to the Erubis engine:
+  #
+  #   :engine_class   allows you to specify a custom engine class to use
+  #                   instead of the default (which is ::Erubis::Eruby).
+  #
+  #   :escape_html    when true, ::Erubis::EscapedEruby will be used as
+  #                   the engine class instead of the default. All content
+  #                   within <%= %> blocks will be automatically html escaped.
+  class ErubisTemplate < ERBTemplate
+    def self.engine_initialized?
+      defined? ::Erubis
+    end
+
+    def initialize_engine
+      require_template_library 'erubis'
+    end
+
+    def prepare
+      @outvar = options.delete(:outvar) || self.class.default_output_variable
+      @options.merge!(:preamble => false, :postamble => false, :bufvar => @outvar)
+      engine_class = options.delete(:engine_class)
+      engine_class = ::Erubis::EscapedEruby if options.delete(:escape_html)
+      @engine = (engine_class || ::Erubis::Eruby).new(data, options)
+    end
+
+    def precompiled_preamble(locals)
+      [super, "#{@outvar} = _buf = ''"].join("\n")
+    end
+
+    def precompiled_postamble(locals)
+      [@outvar, super].join("\n")
+    end
+
+    # Erubis doesn't have ERB's line-off-by-one under 1.9 problem.
+    # Override and adjust back.
+    if RUBY_VERSION >= '1.9.0'
+      def precompiled(locals)
+        source, offset = super
+        [source, offset - 1]
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,27 @@
+require 'tilt/template'
+
+module Tilt
+  class EtanniTemplate < Template
+    def prepare
+      separator = data.hash.abs
+      chomp = "<<#{separator}.chomp!"
+      start = "\n_out_ << #{chomp}\n"
+      stop = "\n#{separator}\n"
+      replacement = "#{stop}\\1#{start}"
+
+      temp = data.strip
+      temp.gsub!(/<\?r\s+(.*?)\s+\?>/m, replacement)
+
+      @code = "_out_ = [<<#{separator}.chomp!]\n#{temp}#{stop}_out_.join"
+    end
+
+    def precompiled_template(locals)
+      @code
+    end
+
+    def precompiled(locals)
+      source, offset = super
+      [source, offset + 1]
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+require 'tilt/template'
+
+module Tilt
+  # Haml template implementation. See:
+  # http://haml.hamptoncatlin.com/
+  class HamlTemplate < Template
+    self.default_mime_type = 'text/html'
+
+    def self.engine_initialized?
+      defined? ::Haml::Engine
+    end
+
+    def initialize_engine
+      require_template_library 'haml'
+    end
+
+    def prepare
+      options = @options.merge(:filename => eval_file, :line => line)
+      @engine = ::Haml::Engine.new(data, options)
+    end
+
+    def evaluate(scope, locals, &block)
+      if @engine.respond_to?(:precompiled_method_return_value, true)
+        super
+      else
+        @engine.render(scope, locals, &block)
+      end
+    end
+
+    # Precompiled Haml source. Taken from the precompiled_with_ambles
+    # method in Haml::Precompiler:
+    # http://github.com/nex3/haml/blob/master/lib/haml/precompiler.rb#L111-126
+    def precompiled_template(locals)
+      @engine.precompiled
+    end
+
+    def precompiled_preamble(locals)
+      local_assigns = super
+      @engine.instance_eval do
+        <<-RUBY
+          begin
+            extend Haml::Helpers
+            _hamlout = @haml_buffer = Haml::Buffer.new(@haml_buffer, #{options_for_buffer.inspect})
+            _erbout = _hamlout.buffer
+            __in_erb_template = true
+            _haml_locals = locals
+            #{local_assigns}
+        RUBY
+      end
+    end
+
+    def precompiled_postamble(locals)
+      @engine.instance_eval do
+        <<-RUBY
+            #{precompiled_method_return_value}
+          ensure
+            @haml_buffer = @haml_buffer.upper
+          end
+        RUBY
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,45 @@
+require 'tilt/template'
+
+module Tilt
+  # Liquid template implementation. See:
+  # http://liquid.rubyforge.org/
+  #
+  # Liquid is designed to be a *safe* template system and threfore
+  # does not provide direct access to execuatable scopes. In order to
+  # support a +scope+, the +scope+ must be able to represent itself
+  # as a hash by responding to #to_h. If the +scope+ does not respond
+  # to #to_h it will be ignored.
+  #
+  # LiquidTemplate does not support yield blocks.
+  #
+  # It's suggested that your program require 'liquid' at load
+  # time when using this template engine.
+  class LiquidTemplate < Template
+    def self.engine_initialized?
+      defined? ::Liquid::Template
+    end
+
+    def initialize_engine
+      require_template_library 'liquid'
+    end
+
+    def prepare
+      @engine = ::Liquid::Template.parse(data)
+    end
+
+    def evaluate(scope, locals, &block)
+      locals = locals.inject({}){ |h,(k,v)| h[k.to_s] = v ; h }
+      if scope.respond_to?(:to_h)
+        scope  = scope.to_h.inject({}){ |h,(k,v)| h[k.to_s] = v ; h }
+        locals = scope.merge(locals)
+      end
+      locals['yield'] = block.nil? ? '' : yield
+      locals['content'] = locals['yield']
+      @engine.render(locals)
+    end
+
+    def allows_script?
+      false
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+require 'tilt/template'
+
+module Tilt
+  # Markaby
+  # http://github.com/markaby/markaby
+  class MarkabyTemplate < Template
+    def self.builder_class
+      @builder_class ||= Class.new(Markaby::Builder) do
+        def __capture_markaby_tilt__(&block)
+          __run_markaby_tilt__ do
+            text capture(&block)
+          end
+        end
+      end
+    end
+
+    def self.engine_initialized?
+      defined? ::Markaby
+    end
+
+    def initialize_engine
+      require_template_library 'markaby'
+    end
+
+    def prepare
+    end
+
+    def evaluate(scope, locals, &block)
+      builder = self.class.builder_class.new({}, scope)
+      builder.locals = locals
+
+      if data.kind_of? Proc
+        (class << builder; self end).send(:define_method, :__run_markaby_tilt__, &data)
+      else
+        builder.instance_eval <<-CODE, __FILE__, __LINE__
+          def __run_markaby_tilt__
+            #{data}
+          end
+        CODE
+      end
+
+      if block
+        builder.__capture_markaby_tilt__(&block)
+      else
+        builder.__run_markaby_tilt__
+      end
+
+      builder.to_s
+    end
+  end
+end
+

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

@@ -0,0 +1,214 @@
+require 'tilt/template'
+
+module Tilt
+  # Discount Markdown implementation. See:
+  # http://github.com/rtomayko/rdiscount
+  #
+  # RDiscount is a simple text filter. It does not support +scope+ or
+  # +locals+. The +:smart+ and +:filter_html+ options may be set true
+  # to enable those flags on the underlying RDiscount object.
+  class RDiscountTemplate < Template
+    self.default_mime_type = 'text/html'
+
+    ALIAS = {
+      :escape_html => :filter_html,
+      :smartypants => :smart
+    }
+
+    FLAGS = [:smart, :filter_html, :smartypants, :escape_html]
+
+    def flags
+      FLAGS.select { |flag| options[flag] }.map { |flag| ALIAS[flag] || flag }
+    end
+
+    def self.engine_initialized?
+      defined? ::RDiscount
+    end
+
+    def initialize_engine
+      require_template_library 'rdiscount'
+    end
+
+    def prepare
+      @engine = RDiscount.new(data, *flags)
+      @output = nil
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= @engine.to_html
+    end
+
+    def allows_script?
+      false
+    end
+  end
+
+  # Upskirt Markdown implementation. See:
+  # https://github.com/tanoku/redcarpet
+  #
+  # Supports both Redcarpet 1.x and 2.x
+  class RedcarpetTemplate < Template
+    def self.engine_initialized?
+      defined? ::Redcarpet
+    end
+
+    def initialize_engine
+      require_template_library 'redcarpet'
+    end
+
+    def prepare
+      klass = [Redcarpet2, Redcarpet1].detect { |e| e.engine_initialized? }
+      @engine = klass.new(file, line, options) { data }
+    end
+
+    def evaluate(scope, locals, &block)
+      @engine.evaluate(scope, locals, &block)
+    end
+
+    def allows_script?
+      false
+    end
+
+    # Compatibility mode for Redcarpet 1.x
+    class Redcarpet1 < RDiscountTemplate
+      self.default_mime_type = 'text/html'
+
+      def self.engine_initialized?
+        defined? ::RedcarpetCompat
+      end
+
+      def prepare
+        @engine = RedcarpetCompat.new(data, *flags)
+        @output = nil
+      end
+    end
+
+    # Future proof mode for Redcarpet 2.x (not yet released)
+    class Redcarpet2 < Template
+      self.default_mime_type = 'text/html'
+
+      def self.engine_initialized?
+        defined? ::Redcarpet::Render and defined? ::Redcarpet::Markdown
+      end
+
+      def generate_renderer
+        renderer = options.delete(:renderer) || ::Redcarpet::Render::HTML
+        return renderer unless options.delete(:smartypants)
+        return renderer if renderer.is_a?(Class) && renderer <= ::Redcarpet::Render::SmartyPants
+
+        if renderer == ::Redcarpet::Render::XHTML
+          ::Redcarpet::Render::SmartyHTML.new(:xhtml => true)
+        elsif renderer == ::Redcarpet::Render::HTML
+          ::Redcarpet::Render::SmartyHTML
+        elsif renderer.is_a? Class
+          Class.new(renderer) { include ::Redcarpet::Render::SmartyPants }
+        else
+          renderer.extend ::Redcarpet::Render::SmartyPants
+        end
+      end
+
+      def prepare
+        # try to support the same aliases
+        RDiscountTemplate::ALIAS.each do |opt, aka|
+          next if options.key? opt or not options.key? aka
+          options[opt] = options.delete(aka)
+        end
+
+        # only raise an exception if someone is trying to enable :escape_html
+        options.delete(:escape_html) unless options[:escape_html]
+
+        @engine = ::Redcarpet::Markdown.new(generate_renderer, options)
+        @output = nil
+      end
+
+      def evaluate(scope, locals, &block)
+        @output ||= @engine.render(data)
+      end
+
+      def allows_script?
+        false
+      end
+    end
+  end
+
+  # BlueCloth Markdown implementation. See:
+  # http://deveiate.org/projects/BlueCloth/
+  class BlueClothTemplate < Template
+    self.default_mime_type = 'text/html'
+
+    def self.engine_initialized?
+      defined? ::BlueCloth
+    end
+
+    def initialize_engine
+      require_template_library 'bluecloth'
+    end
+
+    def prepare
+      @engine = BlueCloth.new(data, options)
+      @output = nil
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= @engine.to_html
+    end
+
+    def allows_script?
+      false
+    end
+  end
+
+  # Maruku markdown implementation. See:
+  # http://maruku.rubyforge.org/
+  class MarukuTemplate < Template
+    def self.engine_initialized?
+      defined? ::Maruku
+    end
+
+    def initialize_engine
+      require_template_library 'maruku'
+    end
+
+    def prepare
+      @engine = Maruku.new(data, options)
+      @output = nil
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= @engine.to_html
+    end
+
+    def allows_script?
+      false
+    end
+  end
+
+  # Kramdown Markdown implementation. See:
+  # http://kramdown.rubyforge.org/
+  class KramdownTemplate < Template
+    DUMB_QUOTES = [39, 39, 34, 34]
+
+    def self.engine_initialized?
+      defined? ::Kramdown
+    end
+
+    def initialize_engine
+      require_template_library 'kramdown'
+    end
+
+    def prepare
+      options[:smart_quotes] = DUMB_QUOTES unless options[:smartypants]
+      @engine = Kramdown::Document.new(data, options)
+      @output = nil
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= @engine.to_html
+    end
+
+    def allows_script?
+      false
+    end
+  end
+end
+