malt 0.3.0 → 0.4.0

data/lib/malt/engines/erector.rb

@@ -2,58 +2,89 @@ require 'malt/engines/abstract'
 
 module Malt::Engine
 
-  # Erector
+  # The Erector template engine handles a builder-style template format.
   #
-  #   http://erector.rubyforge.org/userguide.html
+  # @see http://erector.rubyforge.org/userguide.html
+  #
+  # For Erector templates the data is passed in as attribute variables.
+  #
+  # A simple example template:
+  #
+  #    div do
+  #      h1 @name
+  #      div @state, :id=>'state'
+  #      div @content, :id=>'yield'
+  #    end
+  #
+  # IMPORTANT! Erecotor templates do not currently support scope.
   #
   class Erector < Abstract
 
-    default :erector
+    default  :erector
+    register :rbml, :builder
 
     #
-    def intermediate(params)
-      text = params[:text]
-      Class.new(::Erector::Widget) do
-        module_eval %{ def content; #{text}; end }
-      end
-    end
+    def render(params={}, &content)
+      into = params[:to] || :html
 
-    #
-    def render(params, &yld)
-      into = params[:to]
       case into
-      when :html, nil
-        render_html(params, &yld)
+      when :html, :xhtml
+        prepare_engine(params, &content).to_html
       else
-        super(params, &yld)
+        super(params, &content)
+      end
+    end
+
+    # Return Erector parser, ready to render results.
+    def prepare_engine(params={}, &content)
+      file, scope, locals = parameters(params, :file, :scope, :locals)
+
+      scope, locals = make_external(scope, locals, &content)
+
+      unless scope.respond_to?(:to_struct)
+        scope_locals = {}
+        scope.instance_variables.each do |k|
+          next if k == "@target"
+          name = k.to_s.sub('@','').to_sym
+          v = scope.instance_variable_get(k)
+          scope_locals[name] = v
+        end
+        locals = scope_locals.merge(locals)
       end
+
+      create_engine(params).new(locals)
     end
 
+    # TODO: how to support scope ?
+
+    # Erector constructor support caching.
     #
-    def render_html(params={}, &yld)
-      #text = params[:text]
-      file = params[:file]
-      data = params[:data]
-      data = make_hash(data, &yld)
+    def create_engine(params={})
+      text, prefix = parameters(params, :text, :prefix)
+
+      cached(prefix, text) do
+        Class.new(::Erector::Widget) do
+          module_eval %{
+            def #{prefix}; self; end
+          } if prefix
 
-      intermediate(params).new(data).to_html      
+          module_eval %{
+            def content
+              #{text}
+            end
+          }
+        end
+      end
     end
 
-    private
+  private
 
     # Load Erector library if not already loaded.
-    def initialize_engine
+    def require_engine
       return if defined? ::Erector
       require_library 'erector'
     end
 
-    #
-    def engine_options(params)
-      opts = {}
-      opts
-    end
-
   end
 
 end
-

data/lib/malt/engines/erubis.rb

@@ -10,54 +10,64 @@ module Malt::Engine
   #
   class Erubis < Abstract
 
-    register :erb, :rhtml
+    register :erb, :rhtml, :eruby
 
     # Render template.
-    def render(params, &yld)
-      text = params[:text]
-      data = params[:data]
-      data = make_binding(data, &yld)
-      intermediate(params).result(data)
-    end
-
-    # Compile template into Ruby source code.
-    def compile(params)
-      text = params[:text]
-      file = params[:file]
-      intermediate(text, file).src
-    end
+    def render(params, &content)
+      text, file, scope, locals = parameters(params, :text, :file, :scope, :locals)
 
-    #
-    def intermediate(params)
-      text = params[:text]
-      file = params[:file]
+      # NOTE: Erubis can handle hash data via result(:list=>data).
+      # Would it be better to use that?
 
-      opts = {}
+      bind = make_binding(scope, locals, &content)
 
-      if params[:escape_html] || settings[:escape_html]
-        ::Erubis::EscapedEruby.new(text, settings)
-      else
-        ::Erubis::Eruby.new(text, settings)
-      end
+      prepare_engine(params).result(bind)
     end
 
     #
-    def safe
-      options[:safe]
-    end
+    #def prepare_eninge(params={})
+    #  create_engine(params)
+    #end
 
     #
-    def trim
-      options[:trim]
+    def create_engine(params={})
+      text, file, esc = parameters(params, :text, :file, :escape_html)
+
+      opts = engine_options(params)
+
+      cached(text, file, esc, opts) do
+        if esc
+          ::Erubis::EscapedEruby.new(text, opts)
+        else
+          ::Erubis::Eruby.new(text, opts)
+        end
+      end
     end
 
-    ;;;; private ;;;;
+    # Compile template into Ruby source code.
+    #def compile(params)
+    #  if cache?
+    #    @source[params] ||= intermediate(params).src
+    #  else
+    #    intermediate(params).src
+    #  end
+    #end
+
+   private
 
     # Load ERB library if not already loaded.
-    def initialize_engine
+    def require_engine
       return if defined? ::Erubius
       require_library('erubis')
     end
+  
+    #  
+    ENGINE_OPTION_NAMES = %w{safe trim pattern preamble postable}
+
+    #
+    def engine_option_names
+      ENGINE_OPTION_NAMES
+    end
 
   end
 

data/lib/malt/engines/haml.rb

@@ -9,55 +9,31 @@ module Malt::Engine
     default :haml
 
     #
-    def render(params, &yld)
-      into = params[:to]
+    def render(params={}, &content)
+      into, scope, locals = parameters(params, :to, :scope, :locals)
+
+      scope, locals = make_ready(scope, locals, &content)
+
       case into
       when :html, nil
-        render_html(params, &yld)
+        prepare_engine(params, &content).render(scope, locals, &content)
       else
-        super(params, &yld)
+        super(params, &content)
       end
     end
 
     #
-    def render_html(params, &yld)
-      text = params[:text]
-      file = params[:file]
-      data = params[:data]
-
-      engine = intermediate(params)
-      case data
-      when Binding
-        html = engine.render(make_object(data), &yld)
-      when Hash
-        html = engine.render(Object.new, data, &yld)
-      else
-        if data.respond_to?(:to_hash)
-          data = data.to_hash
-          html = engine.render(Object.new, data, &yld)
-        else
-          html = engine.render(data || Object.new, &yld)
-        end
+    def create_engine(params={})
+      text, file = parameters(params, :text, :file)
+      cached(text, file) do
+        ::Haml::Engine.new(text, :filename=>file)
       end
-      html
-    end
-
-    #
-    #def compile(text, file)
-    #  intermediate # ??
-    #end
-
-    #
-    def intermediate(params)
-      text = params[:text]
-      file = params[:file]
-      ::Haml::Engine.new(text, :filename=>file)
     end
 
-    private
+  private
 
     # Load Haml library if not already loaded.
-    def initialize_engine
+    def require_engine
       return if defined? ::Haml::Engine
       require_library 'haml'
     end

data/lib/malt/engines/kramdown.rb

@@ -2,47 +2,72 @@ require 'malt/engines/abstract'
 
 module Malt::Engine
 
-  # Discount Markdown implementation.
+  # Kramdown Markdown implementation.
   #
-  #   http://github.com/rtomayko/rdiscount
+  #   http://kramdown.rubyforge.org/
   #
-  # The +:smart+ and +:filter_html+ options can be set true
-  # to enable those flags on the underlying RDiscount object.
   class Kramdown < Abstract
 
     register :markdown, :md
 
     # Convert Markdown text to HTML text.
     #
-    # @option params [String] :text Template text
-    # @option params [String,Symbol] :to ('html') Type or file extension to convert template into.
-    def render(params)
-      text = params[:text]
-      into = params[:to]
+    # @param [Hash] params
+    #   A hash containing the Markdown extensions which the parser
+    #   will identify. The following extensions are accepted.
+    #
+    # @option params [String] :text
+    #   Template text.
+    #
+    # @option params [String,Symbol] :to ('html')
+    #   Type or file extension to convert template into.
+    #
+    # @see http://kramdown.rubyforge.org/rdoc/Kramdown/Options.html
+    #
+    def render(params={})
+      into, text = parameters(params, :to, :text)
+
       case into
       when :html, nil
-        intermediate(params).to_html
+        prepare_engine(params).to_html
       when :latex
-        intermediate(params).to_latex
+        prepare_engine(params).to_latex
       else
         super(params)
       end
     end
 
     # Convert Markdown text to intermediate object.
-    def intermediate(params)
-      text = params[:text]
-      ::Kramdown::Document.new(text)
+    def create_engine(params={})
+      text = parameters(params, :text)
+      cached(text) do
+        ::Kramdown::Document.new(text)
+      end
     end
 
     private
 
       # Load rdoc makup library if not already loaded.
-      def initialize_engine
+      def require_engine
         return if defined? ::Kramdown
         require_library 'kramdown'
       end
 
+      # Kramdown has lots of options!
+      ENGINE_OPTION_NAMES = %w{
+        auto_id_prefix auto_ids
+        coderay_bold_every coderay_css coderay_line_number_start
+        coderay_line_numbers coderay_tab_width coderay_wrap
+        entity_output footnote_nr html_to_native latex_headers
+        line_width parse_block_html parse_span_html smart_quotes
+        template toc_levels
+      }
+
+      #
+      def engine_option_names
+        ENGINE_OPTION_NAMES
+      end
+
   end
 
 end

data/lib/malt/engines/less.rb

@@ -2,32 +2,33 @@ require 'malt/engines/abstract'
 
 module Malt::Engine
 
-  # LESS
+  # LESS is an extension of CSS. You can write LESS code just like you
+  # would write CSS, except you need to compile it to CSS.
   #
-  #   http://lesscss.org/
+  # @see http://lesscss.org/
   #
-  # LESS is an extension of CSS. You can write LESS code just like you would write CSS,
-  # except you need to compile it to CSS. That's what this class is for.
   class Less < Abstract
 
     default :less
 
     #
-    def render(params)
-      text = params[:text]
-      into = params[:to]
+    def render(params={})
+      into, text, compress = parameters(params, :to, :text, :compress)
+
       case into
       when :css, nil
-        intermediate(params).to_css
+        prepare_engine(params).to_css(:compress=>compress)
       else
         super(params)
       end
     end
 
     #
-    def intermediate(params)
-      text = params[:text]
-      ::Less::Engine.new(text)
+    def create_engine(params={})
+      text, file = parameters(params, :text, :file)
+      cached(text, file) do
+        ::Less::Parser.new(:filename=>file).parse(text)
+      end
     end
 
     #
@@ -35,11 +36,11 @@ module Malt::Engine
     #  intermediate # ??
     #end
 
-    private
+  private
 
     # Load Less library if not already loaded.
-    def initialize_engine
-      return if defined? ::Less::Engine
+    def require_engine
+      return if defined? ::Less::Parser
       require_library 'less'
     end
 

data/lib/malt/engines/liquid.rb

@@ -2,34 +2,44 @@ require 'malt/engines/abstract'
 
 module Malt::Engine
 
-  # Liquid
+  # Liquid templates.
   #
-  #   http://liquid.rubyforge.org/
+  # @see http://liquid.rubyforge.org/
   #
   class Liquid < Abstract
 
     default :liquid
 
     #
-    def intermediate(params)
-      text = params[:text]
-      ::Liquid::Template.parse(text)
+    def render(params={}, &content) #file, db, &content)
+      text, scope, locals = parameters(params, :text, :scope, :locals)
+
+      data = make_hash(scope, locals, &content)
+
+      # convert symbol keys to strings w/o rewriting the hash
+      symbol_keys = data.keys.select{ |k| Symbol === k }
+      symbol_keys.each do |k|
+        data[k.to_s] = data[k]
+        data.delete(k)
+      end
+
+      engine = prepare_engine(params)
+
+      engine.render(data)
     end
 
     #
-    def render(params={}, &yld) #file, db, &yld)
-      text = params[:text]
-      data = params[:data]
-      data = make_hash(data, &yld)
-      data = data.rekey{ |k| k.to_s }
-      engine = intermediate(params)
-      engine.render(data)
+    def create_engine(params={})
+      text = parameters(params, :text)
+      cached(text) do
+        ::Liquid::Template.parse(text)
+      end
     end
 
-    private
+  private
 
     # Load Liquid library if not already loaded.
-    def initialize_engine
+    def require_engine
       return if defined? ::Liquid::Template
       require_library 'liquid'
     end