malt 0.3.0 → 0.4.0

data/lib/malt/engines/markaby.rb

@@ -4,43 +4,66 @@ module Malt::Engine
 
   # Markaby
   #
-  #   http://markaby.rubyforge.org/
+  # @see http://markaby.rubyforge.org/
   #
+  # Markaby doesn't support template caching b/c the the initializer
+  # takes the local variable settings.
+  # 
   class Markaby < Abstract
 
-    default :markaby, :mab
+    default  :markaby, :mab
+    register :rbml, :builder
 
     #
-    #def intermediate(params)
-    #  text = params[:text]
-    #  eval("lambda{ #{text} }")
-    #end
+    def render(params={}, &content)
+      into = parameters(params, :to) || :html
 
-    #
-    def render(params, &yld)
-      into = params[:to]
       case into
-      when :html, nil
-        render_html(params, &yld)
+      when :html, :xml, :xhtml
+        prepare_engine(params, &content).to_s
       else
-        super(params, &yld)
+        super(params, &content)
       end
     end
 
+    # TODO: Prefix support ?
+
     #
-    def render_html(params={}, &yld)
-      text = params[:text]
-      file = params[:file]
-      data = params[:data]
-      data = make_hash(data, &yld)
-      builder = ::Markaby::Builder.new(data)
-      builder.instance_eval(text).to_s
+    def prepare_engine(params={}, &content)
+      prefix, text, file, scope, locals, prefix = parameters(params, :prefix, :text, :file, :scope, :locals)
+
+      file = file || "(markaby)"
+
+      if prefix
+        raise NotImplmentedError, "Markaby doesn't support prefix templates."
+        #scope, locals = scope_and_locals(data, &content)
+        #scope, locals = split_data(data)
+
+        scope  ||= Object.new
+        locals ||= {}
+
+        mab = ::Markaby::Builder.new(locals) #, scope)
+
+        code = %{
+          lambda do |#{prefix}|
+            #{text}
+          end
+        }
+
+        eval(code, scope.to_binding, file).call(mab)
+      else
+        scope, locals = make_external(scope, locals, &content)
+
+        mab = ::Markaby::Builder.new(locals, scope)
+        mab.instance_eval(text, file)
+        mab
+      end
     end
 
-    private
+  private
 
     # Load Markaby library if not already loaded.
-    def initialize_engine
+    def require_engine
       return if defined? ::Markaby
       require_library 'markaby'
     end
@@ -48,4 +71,3 @@ module Malt::Engine
   end
 
 end
-

data/lib/malt/engines/maruku.rb

@@ -0,0 +1,89 @@
+require 'malt/engines/abstract'
+
+module Malt::Engine
+
+  # Redcarpet Markdown implementation.
+  #
+  #   http://maruku.rubyforge.org/
+  #
+  class Maruku < Abstract
+
+    register :markdown, :md
+
+    # Convert Markdown text to HTML text.
+    #
+    # @param [Hash] params
+    #
+    # @option params [String] :text
+    #   Template text
+    #
+    # @option params [String,Symbol] :to ('html')
+    #   Type or file extension to convert template into.
+    #
+    def render(params={})
+      into, text, part = parameters(params, :to, :text, :partial)
+
+      engine = prepare_engine(params)
+
+      case into
+      when :html, nil
+        if part
+          engine.to_html
+        else
+          engine.to_html_document
+        end
+      when :latex #, :pdf
+        if part
+          engine.to_latex
+        else
+          engine.to_latex_document
+        end
+      else
+        super(params)
+      end
+    end
+
+    # Convert Markdown text to intermediate object.
+    #
+    # @param [Hash] params
+    #   A hash containing the Markdown extensions which the parser
+    #   will identify. The following extensions are accepted.
+    #
+    # @option params [Symbol] :on_error
+    #   If :raise, then raise error.
+    #
+    def create_engine(params={})
+      text = parameters(params, :text)
+      opts = engine_options(params)
+
+      ::Maruku.new(text, opts)
+    end
+
+    private
+
+      # Supported engine options.
+      #
+      # @todo Add more options.
+      #
+      # @see http://maruku.rubyforge.org/exd.html
+      #
+      ENGINE_OPTION_NAMES = %w{
+        math_enabled 
+      }
+
+      # Load rdoc makup library if not already loaded.
+      def require_engine
+        return if defined? ::Maruku
+        require_library 'maruku'
+      end
+
+      #
+      def engine_option_names
+        ENGINE_OPTION_NAMES
+      end
+
+  end
+
+end
+
+

data/lib/malt/engines/mustache.rb

@@ -4,35 +4,41 @@ module Malt::Engine
 
   # Mustache engine.
   #
-  #   http://github.com/defunkt/mustache
+  # @see http://github.com/defunkt/mustache
   #
   class Mustache < Abstract
 
     register :mustache
 
-    ## Convert Markdown text to intermediate object.
-    #def intermediate(params)
-    #  text = params[:text]
-    #  ???
-    #end
-
     #
-    def render(params={}, &yld) #file, db, &yld)
-      text = params[:text]
-      data = params[:data]
+    def render(params={}, &content) #file, db, &content)
+      text, scope, locals = parameters(params, :text, :scope, :locals)
+
+      locals = make_hash(scope, locals, &content)
 
-      data = make_hash(data, &yld)
+      # convert symbol keys to strings w/o rewriting the hash
+      symbol_keys = locals.keys.select{ |k| Symbol === k }
+      symbol_keys.each do |k|
+        locals[k.to_s] = locals[k]
+        locals.delete(k)
+      end
 
       #engine = intermediate(params)
       #engine.render(data)
-      ::Mustache.render(text, data)
+
+      ::Mustache.render(text, locals)
     end
 
+    #
+    #def intermediate(params)
+    #  text = parameters(params, :text)
+    #  ???
+    #end
 
-    private
+  private
 
     # Load rdoc makup library if not already loaded.
-    def initialize_engine
+    def require_engine
       return if defined? ::Mustache
       require_library 'mustache'
     end

data/lib/malt/engines/nokogiri.rb

@@ -0,0 +1,89 @@
+require 'malt/engines/abstract'
+
+module Malt::Engine
+
+  # Nokogiri builder-like templates.
+  #
+  # @see http://nokogiri.org/
+
+  class Nokogiri < Abstract
+
+    default  :nokogiri
+    register :rbml, :builder
+
+    #
+    DOCUMENT_HEADER_XML = /^<\?xml version=\"1\.0\"\?>\n?/
+
+    #
+    DOCUMENT_HEADER_HTML = /^<\!DOCTYPE html PUBLIC \".*?\">/
+
+    #
+    def render(params={}, &content)
+      into = parameters(params, :to) || :html
+
+      case into.to_sym
+      when :html
+        prepare_engine(params, &content).to_html.sub(DOCUMENT_HEADER_HTML,'')
+      when :xml, :xhtml
+        prepare_engine(params, &content).to_xml.sub(DOCUMENT_HEADER_XML,'')
+      else
+        super(params, &content)
+      end
+    end
+
+    #
+    def prepare_engine(params={}, &content)
+      text, file, scope, locals = parameters(params, :text, :file, :scope, :locals)
+
+      scope, locals = make_external(scope, locals, &content)
+
+      engine = create_engine(params)
+
+      locals.each do |k,v|
+        engine.instance_eval("@#{k} = v")
+      end
+
+      scope.instance_variables.each do |k|
+        next if k == "@target"
+        v = scope.instance_variable_get(k)
+        engine.instance_eval("#{k} = v")    
+      end
+
+      engine.instance_eval(text, file || inspect)
+
+      engine
+    end
+
+    # Nokogiri engine cannot be cached as it keeps a copy the
+    # rendering internally. (Unless there is a way to clear it?)
+    #
+    def create_engine(params={})
+      into = parameters(params, :to) || :html
+
+      opts = engine_options(params)
+
+      #cached(into, opts) do
+        case into
+        when :html
+          ::Nokogiri::HTML::Builder.new(opts)
+        else
+          ::Nokogiri::XML::Builder.new(opts)
+        end
+      #end
+    end
+
+  private
+
+    # Load Nokogiri library if not already loaded.
+    def require_engine
+      return if defined? ::Nokogiri
+      require_library 'nokogiri'
+
+      ::Nokogiri::XML::Builder.class_eval do
+        undef_method :p
+      end
+    end
+
+  end
+
+end

data/lib/malt/engines/radius.rb

@@ -11,69 +11,107 @@ module Malt::Engine
     default :radius
 
     #
-    def render(params, &yld)
-      text = params[:text]
-      data = params[:data]
-      into = params[:to]
+    def render(params={}, &content)
+      into, text = parameters(params, :to, :text)
+
       case into
       when :html, :xml, nil
-        data = make_context(data, &yld)
-        opts = engine_options(params)
-        parser = ::Radius::Parser.new(data, opts)
+        context = prepare_engine(params, &content)
+        options = engine_options(params)
+
+        parser = ::Radius::Parser.new(context, options)
         parser.parse(text)
       else
-        super(params, &yld)
+        super(params, &content)
       end
     end
 
-    private
+    #
+    def prepare_engine(params={}, &content)
+      scope, locals = parameters(params, :scope, :locals)
+
+      locals ||= {}
+
+      # convert string keys to symbols w/o rewriting the hash
+      string_keys = locals.keys.select{ |k| String === k }
+      string_keys.each do |k|
+        locals[k.to_sym] = locals[k]
+        locals.delete(k)
+      end
+
+      make_context(scope, locals, &content)
+    end
+
+  private
 
     # Load Radius library if not already loaded.
-    def initialize_engine
+    def require_engine
       return if defined? ::Radius
       require_library 'radius'
     end
 
     # Radius templates have a very special data source.
-    def make_context(data, &yld)
-      case data
-      when Hash
-        context = make_context_from_hash(data, &yld)
+    def make_context(scope, locals, &content)
+      case scope
+      when nil
+        context = make_context_from_hash(locals, &content)
+      when Binding
+        context = make_context_from_binding(scope, locals, &content)
       else
-        if data.respond_to(:to_hash)
-          data = data.to_hash
-          context = make_context_from_hash(data, &yld)
-        else
-          context = make_context_from_object(data, &yld)
+        context = make_context_from_object(scope, locals, &content)
+      end
+      context
+    end
+
+    #
+    def make_context_from_binding(scope, locals, &content)
+      context_class = Class.new(::Radius::Context)
+      context_class.class_eval do
+        define_method :tag_missing do |tag, attr|
+          if locals.key?(tag.to_sym)
+            locals[tag.to_sym]
+          else
+            scope.eval(tag)
+          end
         end
       end
+      context = context_class.new
+      context.define_tag("content") do
+        content ? content.call : ''
+      end
       context
     end
 
     #
-    def make_context_from_object(db, &yld)
-      context = Class.new(::Radius::Context).new
-      db = make_object(db)
-      (class << context; self; end).class_eval do
+    def make_context_from_object(scope, locals, &content)
+      context_class = Class.new(::Radius::Context)
+      context_class.class_eval do
         define_method :tag_missing do |tag, attr|
-          db.__send__(tag) # any way to support attr as args?
+          if locals.key?(tag.to_sym)
+            locals[tag.to_sym]
+          else
+            scope.__send__(tag) # any way to support attr as args?
+          end
         end
       end
-      context.define_tag("yield") do
-        yld.call
+      context = context_class.new
+      context.define_tag("content") do
+        content ? content.call : ''
       end
       context
     end
 
     #
-    def make_context_from_hash(data, &yld)
-      context = Class.new(::Radius::Context).new
-      #data = make_hash(data)
-      data.each do |tag, value|
-        context.define_tag(tag){ value }
+    def make_context_from_hash(locals, &content)
+      context_class = Class.new(::Radius::Context)
+      context_class.class_eval do
+        define_method :tag_missing do |tag, attr|
+          locals[tag.to_sym]
+        end
       end
-      context.define_tag("yield") do
-        yld.call
+      context = context_class.new
+      context.define_tag("content") do
+        content ? content.call : ''
       end
       context
     end
@@ -81,7 +119,7 @@ module Malt::Engine
     #
     def engine_options(params)
       opts = {}
-      opts[:tag_prefix] = params[:tag_prefix] || settings[:tag_prefix]
+      opts[:tag_prefix] = params[:tag_prefix] || settings[:tag_prefix] #|| 'r'
       opts
     end