malt 0.1.1 → 0.2.0

data/History.rdoc

@@ -1,5 +1,23 @@
 = Release History
 
+== 0.2.0 | 2010-10-22
+
+Malt now support Erector, Markaby, Builder and Mustache templates.
+Erector, Markaby and Builder are Ruby-based formats --templates
+are simply Ruby code. This requires them to use instance variables
+in templates rather than local variables/methods. Somethinfg to keep
+in mind.
+
+Changes:
+
+* Add support for Erector templates.
+* Add support for Markaby templates.
+* Add support for Builder templates.
+* Add support for Mustache templates.
+* Add `:pass` option to render method.
+* Rename `:format` option to `:to` for render method.
+
+
 == 0.1.1 | 2010-09-21
 
 This release simple fixes two bugs. One to handle variant arity

data/README.rdoc

@@ -6,8 +6,12 @@
 
 == DESCRIPTION
 
-Malt provides a factory framework for rendering
-a variety of template and markup document formats.
+Malt provides a factory framework for rendering a variety of template and
+markup document formats. Malt has a very object-oriented design
+utilizing separate engine adapter classes and format classes. This makes
+Malt easy to maintain, debug and extend, and thus more robust. In fact,
+Malt supports template caching and ERB compilation by default, which was
+very easy to implement thanks to it's clean design.
 
 
 == SYNOPSIS

data/lib/malt.rb

@@ -20,6 +20,15 @@ module Malt
     @registry ||= {}
   end
 
+  #
+  def self.support?(ext)
+    ext  = ext.to_s
+    type = ext.sub(/^\./, '').strip
+    return false if type.empty?
+    #@registry.key?(ext.to_sym)
+    #Engine.registry[type.to_sym]
+    Engine.registry.key?(type.to_sym)
+  end
 
   #
   def self.file(file, options={})

data/lib/malt/engines/abstract.rb

@@ -42,7 +42,7 @@ module Engine
       end
     end
 
-    # Override this method to load rendering engine library.
+    #
     def initialize(settings={})
       @settings = settings.rekey
 
@@ -53,7 +53,6 @@ module Engine
     end
 
     # Access to the options given to the initializer.
-    # Returns an OpenStruct object.
     attr :settings
 
     #
@@ -90,27 +89,28 @@ module Engine
     # Convert a data source into a Binding.
     # TODO: handle yld.
     def make_binding(db, &yld)
-      return db if Binding === db
+      return db if Binding === db  # FIXME: no yld
 
       if db.respond_to?(:to_binding)
-        return db.to_binding
+        return db.to_binding(&yld)
       end
 
-      db = make_object(db)
+      db = make_object(db, &yld)
 
       return db.instance_eval{ binding }        
     end
 
     # Convert a data source into an Object (aka a "scope").
-    def make_object(db)
+    def make_object(db, &yld)
       if db.respond_to?(:to_hash)
         hash  = db.to_hash
+        hash[:yield] = yld.call if yld
         attrs = hash.keys.map{ |k| k.to_sym }
         return Struct.new(*attrs).new(*hash.values)
       end
 
       if Binding === db
-        eval('self', binding)
+        eval('self', binding) # FIXME: no yld
       end
 
       return db

data/lib/malt/engines/bluecloth.rb

@@ -9,9 +9,9 @@ module Malt::Engine
 
     # Convert Markdown text to HTML text.
     def render(params)
-      text   = params[:text]
-      format = params[:format]
-      case format
+      text = params[:text]
+      into = params[:to]
+      case into
       when :html, nil
         intermediate(params).to_html
       else

data/lib/malt/engines/builder.rb

@@ -0,0 +1,72 @@
+require 'malt/engines/abstract'
+
+module Malt::Engine
+
+  # Builder
+  #
+  #   http://builder.rubyforge.org/
+  #
+  class Builder < Abstract
+
+    default :builder
+
+    #
+    #def intermediate(params)
+    #end
+
+    #
+    def render(params, &yld)
+      into = params[:to]
+      case into
+      when :html, nil
+        render_html(params, &yld)
+      else
+        super(params, &yld)
+      end
+    end
+
+    # TODO: Do we need a #make_ivar(data, &yld) method to make data into
+    # instance variables for some templates like this one?
+    def render_html(params={}, &yld)
+      text = params[:text]
+      file = params[:file]
+      data = params[:data]
+
+      data = make_hash(data, &yld)
+      builder = ::Builder::XmlMarkup.new(engine_options(params))
+      data.each{ |k,v| builder.instance_eval("@#{k} = v") }
+      builder.instance_eval(text, file)
+    end
+
+    private
+
+    # Load Erector library if not already loaded.
+    def initialize_engine
+      return if defined? ::Builder
+      require_library 'builder'
+    end
+
+    # :target=>target_object: Object receiving the markup. target_object must
+    # respond to the <<(a_string) operator and return itself.
+    # The default target is a plain string target.
+    #
+    # :indent=>indentation: Number of spaces used for indentation. The default
+    # is no indentation and no line breaks.
+    #
+    # :margin=>initial_indentation_level: Amount of initial indentation
+    # (specified in levels, not spaces). 
+    def engine_options(params)
+      target = params[:target] || settings[:target]
+      indent = params[:indent] || settings[:indent]
+      margin = params[:margin] || settings[:margin]
+      opts = {}
+      opts[:target] = target if target
+      opts[:indent] = indent if indent
+      opts[:margin] = margin if margin
+      opts
+    end
+
+  end
+
+end
+

data/lib/malt/engines/erb.rb

@@ -28,7 +28,9 @@ module Malt::Engine
       text = params[:text]
       file = params[:file]
       data = params[:data]
+
       data = make_binding(data, &yld)
+
       if settings[:precompile] == false
         intermediate(params).result(data)
       else

data/lib/malt/engines/erector.rb

@@ -0,0 +1,59 @@
+require 'malt/engines/abstract'
+
+module Malt::Engine
+
+  # Erector
+  #
+  #   http://erector.rubyforge.org/userguide.html
+  #
+  class Erector < Abstract
+
+    default :erector
+
+    #
+    def intermediate(params)
+      text = params[:text]
+      Class.new(::Erector::Widget) do
+        module_eval %{ def content; #{text}; end }
+      end
+    end
+
+    #
+    def render(params, &yld)
+      into = params[:to]
+      case into
+      when :html, nil
+        render_html(params, &yld)
+      else
+        super(params, &yld)
+      end
+    end
+
+    #
+    def render_html(params={}, &yld)
+      #text = params[:text]
+      file = params[:file]
+      data = params[:data]
+      data = make_hash(data, &yld)
+
+      intermediate(params).new(data).to_html      
+    end
+
+    private
+
+    # Load Erector library if not already loaded.
+    def initialize_engine
+      return if defined? ::Erector
+      require_library 'erector'
+    end
+
+    #
+    def engine_options(params)
+      opts = {}
+      opts
+    end
+
+  end
+
+end
+

data/lib/malt/engines/haml.rb

@@ -10,8 +10,8 @@ module Malt::Engine
 
     #
     def render(params, &yld)
-      format = params[:format]
-      case format
+      into = params[:to]
+      case into
       when :html, nil
         render_html(params, &yld)
       else

data/lib/malt/engines/kramdown.rb

@@ -13,10 +13,13 @@ module Malt::Engine
     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]
-      format = params[:format]
-      case format
+      text = params[:text]
+      into = params[:to]
+      case into
       when :html, nil
         intermediate(params).to_html
       when :latex
@@ -32,7 +35,6 @@ module Malt::Engine
       ::Kramdown::Document.new(text)
     end
 
-
     private
 
       # Load rdoc makup library if not already loaded.

data/lib/malt/engines/less.rb

@@ -14,9 +14,9 @@ module Malt::Engine
 
     #
     def render(params)
-      text   = params[:text]
-      format = params[:format]
-      case format
+      text = params[:text]
+      into = params[:to]
+      case into
       when :css, nil
         intermediate(params).to_css
       else
@@ -37,11 +37,11 @@ module Malt::Engine
 
     private
 
-      # Load Less library if not already loaded.
-      def initialize_engine
-        return if defined? ::Less::Engine
-        require_library 'less'
-      end
+    # Load Less library if not already loaded.
+    def initialize_engine
+      return if defined? ::Less::Engine
+      require_library 'less'
+    end
 
   end
 

data/lib/malt/engines/markaby.rb

@@ -0,0 +1,51 @@
+require 'malt/engines/abstract'
+
+module Malt::Engine
+
+  # Markaby
+  #
+  #   http://markaby.rubyforge.org/
+  #
+  class Markaby < Abstract
+
+    default :markaby, :mab
+
+    #
+    #def intermediate(params)
+    #  text = params[:text]
+    #  eval("lambda{ #{text} }")
+    #end
+
+    #
+    def render(params, &yld)
+      into = params[:to]
+      case into
+      when :html, nil
+        render_html(params, &yld)
+      else
+        super(params, &yld)
+      end
+    end
+
+    #
+    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
+    end
+
+    private
+
+    # Load Markaby library if not already loaded.
+    def initialize_engine
+      return if defined? ::Markaby
+      require_library 'markaby'
+    end
+
+  end
+
+end
+

data/lib/malt/engines/mustache.rb

@@ -0,0 +1,44 @@
+require 'malt/engines/abstract'
+
+module Malt::Engine
+
+  # Mustache engine.
+  #
+  #   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]
+
+      data = make_hash(data, &yld)
+
+      #engine = intermediate(params)
+      #engine.render(data)
+      ::Mustache.render(text, data)
+    end
+
+
+    private
+
+    # Load rdoc makup library if not already loaded.
+    def initialize_engine
+      return if defined? ::Mustache
+      require_library 'mustache'
+    end
+
+  end
+
+end
+
+

data/lib/malt/engines/radius.rb

@@ -12,10 +12,10 @@ module Malt::Engine
 
     #
     def render(params, &yld)
-      text   = params[:text]
-      data   = params[:data]
-      format = params[:format]
-      case format
+      text = params[:text]
+      data = params[:data]
+      into = params[:to]
+      case into
       when :html, :xml, nil
         data = make_context(data, &yld)
         opts = engine_options(params)

data/lib/malt/engines/ragtag.rb

@@ -0,0 +1,49 @@
+require 'malt/engines/abstract'
+
+module Malt::Engine
+
+  # RagTag
+  #
+  #  http://github.com/rubyworks/ragtag
+  #
+  class RagTag < Abstract
+
+    default :ragtag, :rt
+
+    #
+    def render(params, &yld)
+      text = params[:text]
+      file = params[:file]
+      data = params[:data]
+      into = params[:to]
+
+      case into
+      when :html, nil
+        data = make_binding(data, &yld)
+        intermediate(params).compile(data).to_xhtml
+      when :xml
+        data = make_binding(data, &yld)
+        intermediate(params).compile(data).to_xml
+      else
+        super(params, &yld)
+      end
+    end
+
+    #
+    def intermediate(params)
+      text = params[:text]
+      ::RagTag.new(text)
+    end
+
+    private
+
+    # Load Haml library if not already loaded.
+    def initialize_engine
+      return if defined? ::RagTag
+      require_library 'ragtag'
+    end
+
+  end
+
+end
+