tilt 1.2.2 → 1.3

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

@@ -0,0 +1,50 @@
+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 = true
+
+    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
+  end
+end
+

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
+