tilt 1.2.2 → 1.3.2

data/lib/tilt/creole.rb

@@ -0,0 +1,28 @@
+require 'tilt/template'
+
+module Tilt
+  # Creole implementation. See:
+  # http://www.wikicreole.org/
+  class CreoleTemplate < Template
+    def self.engine_initialized?
+      defined? ::Creole
+    end
+
+    def initialize_engine
+      require_template_library 'creole'
+    end
+
+    def prepare
+      opts = {}
+      [:allowed_schemes, :extensions, :no_escape].each do |k|
+        opts[k] = options[k] if options[k]
+      end
+      @engine = Creole::Parser.new(data, opts)
+      @output = nil
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= @engine.to_html
+    end
+  end
+end

data/lib/tilt/css.rb

@@ -0,0 +1,67 @@
+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
+
+  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::Engine
+    end
+
+    def initialize_engine
+      require_template_library 'less'
+    end
+
+    def prepare
+      @engine = ::Less::Engine.new(data)
+    end
+
+    def evaluate(scope, locals, &block)
+      @engine.to_css
+    end
+  end
+end
+

data/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].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/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/lib/tilt/liquid.rb

@@ -0,0 +1,41 @@
+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
+  end
+end

data/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/lib/tilt/markdown.rb

@@ -0,0 +1,131 @@
+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
+  end
+
+  # Upskirt Markdown implementation. See:
+  # https://github.com/tanoku/redcarpet
+  #
+  # Compatible to RDiscount
+  class RedcarpetTemplate < RDiscountTemplate
+    self.default_mime_type = 'text/html'
+
+    def self.engine_initialized?
+      defined? ::RedcarpetCompat
+    end
+
+    def initialize_engine
+      require_template_library 'redcarpet'
+    end
+
+    def prepare
+      @engine = RedcarpetCompat.new(data, *flags)
+      @output = nil
+    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
+  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
+  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
+  end
+end
+

data/lib/tilt/nokogiri.rb

@@ -0,0 +1,43 @@
+require 'tilt/template'
+
+module Tilt
+  # Nokogiri template implementation. See:
+  # http://nokogiri.org/
+  class NokogiriTemplate < Template
+    self.default_mime_type = 'text/xml'
+
+    def self.engine_initialized?
+      defined? ::Nokogiri
+    end
+
+    def initialize_engine
+      require_template_library 'nokogiri'
+    end
+
+    def prepare; end
+
+    def evaluate(scope, locals, &block)
+      block &&= proc { yield.gsub(/^<\?xml version=\"1\.0\"\?>\n?/, "") }
+
+      if data.respond_to?(:to_str)
+        super(scope, locals, &block)
+      else
+        ::Nokogiri::XML::Builder.new.tap(&data).to_xml
+      end
+    end
+
+    def precompiled_preamble(locals)
+      return super if locals.include? :xml
+      "xml = ::Nokogiri::XML::Builder.new { |xml| }\n#{super}"
+    end
+
+    def precompiled_postamble(locals)
+      "xml.to_xml"
+    end
+
+    def precompiled_template(locals)
+      data.to_str
+    end
+  end
+end
+

data/lib/tilt/radius.rb

@@ -0,0 +1,51 @@
+require 'tilt/template'
+
+module Tilt
+  # Radius Template
+  # http://github.com/jlong/radius/
+  class RadiusTemplate < Template
+    def self.engine_initialized?
+      defined? ::Radius
+    end
+
+    def self.context_class
+      @context_class ||= Class.new(Radius::Context) do
+        attr_accessor :tilt_scope
+
+        def tag_missing(name, attributes)
+          tilt_scope.__send__(name)
+        end
+
+        def dup
+          i = super
+          i.tilt_scope = tilt_scope
+          i
+        end
+      end
+    end
+
+    def initialize_engine
+      require_template_library 'radius'
+    end
+
+    def prepare
+    end
+
+    def evaluate(scope, locals, &block)
+      context = self.class.context_class.new
+      context.tilt_scope = scope
+      context.define_tag("yield") do
+        block.call
+      end
+      locals.each do |tag, value|
+        context.define_tag(tag) do
+          value
+        end
+      end
+
+      options = {:tag_prefix => 'r'}.merge(@options)
+      parser = Radius::Parser.new(context, options)
+      parser.parse(data)
+    end
+  end
+end

data/lib/tilt/rdoc.rb

@@ -0,0 +1,32 @@
+require 'tilt/template'
+
+module Tilt
+  # RDoc template. See:
+  # http://rdoc.rubyforge.org/
+  #
+  # It's suggested that your program require 'rdoc/markup' and
+  # 'rdoc/markup/to_html' at load time when using this template
+  # engine.
+  class RDocTemplate < Template
+    self.default_mime_type = 'text/html'
+
+    def self.engine_initialized?
+      defined? ::RDoc::Markup
+    end
+
+    def initialize_engine
+      require_template_library 'rdoc/markup'
+      require_template_library 'rdoc/markup/to_html'
+    end
+
+    def prepare
+      markup = RDoc::Markup::ToHtml.new
+      @engine = markup.convert(data)
+      @output = nil
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= @engine.to_s
+    end
+  end
+end

data/lib/tilt/string.rb

@@ -0,0 +1,21 @@
+require 'tilt/template'
+
+module Tilt
+  # The template source is evaluated as a Ruby string. The #{} interpolation
+  # syntax can be used to generated dynamic output.
+  class StringTemplate < Template
+    def prepare
+      hash = "TILT#{data.hash.abs}"
+      @code = "<<#{hash}.chomp\n#{data}\n#{hash}"
+    end
+
+    def precompiled_template(locals)
+      @code
+    end
+
+    def precompiled(locals)
+      source, offset = super
+      [source, offset + 1]
+    end
+  end
+end