malt 0.1.0

data/lib/malt/core_ext.rb

@@ -0,0 +1,31 @@
+require 'ostruct'
+require 'facets/module/basename'
+
+class Hash
+
+  #
+  def to_hash
+    dup
+  end unless method_defined?(:to_hash)
+
+  #
+  def rekey(&block)
+    h = {}
+    if block
+      each{|k,v| h[block[k]] = v }
+    else
+      each{|k,v| h[k.to_sym] = v }
+    end
+    h
+  end unless method_defined?(:rekey)
+
+end
+
+class OpenStruct
+
+  #
+  def to_hash
+    @table.dup
+  end unless method_defined?(:to_hash)
+
+end

data/lib/malt/engines.rb

@@ -0,0 +1,10 @@
+module Malt
+  #
+  module Engines
+  end
+end
+
+Dir[File.dirname(__FILE__) + '/engines/*.rb'].each do |file|
+  require file
+end
+

data/lib/malt/engines/abstract.rb

@@ -0,0 +1,151 @@
+require 'malt/kernel'
+
+module Malt
+module Engines
+
+  class << self
+    include Malt::Kernel
+  end
+
+  #
+  def self.register(malt_class, *exts)
+    exts.each do |ext|
+      type = ext_to_type(ext)
+      registry[type] ||= []
+      registry[type] << malt_class
+      registry[type].uniq!
+    end
+  end
+
+  #
+  def self.registry
+    @registry ||= {}
+  end
+
+
+  # Abstract Template class serves as the base
+  # class for all other Template classes.
+  #
+  class Abstract
+    include Malt::Kernel
+
+    # Register the class to an extension type.
+    def self.register(*exts)
+      Engines.register(self, *exts)
+    end
+
+    # Register and set as the default for given extensions.
+    def self.default(*exts)
+      register(*exts)
+      exts.each do |ext|
+        Malt.config.engine[ext.to_sym] = self
+      end
+    end
+
+    # Override this method to load rendering engine library.
+    def initialize(settings={})
+      @settings = settings.rekey
+
+      @cache  = {}
+      @source = {}
+
+      initialize_engine
+    end
+
+    # Access to the options given to the initializer.
+    # Returns an OpenStruct object.
+    attr :settings
+
+    #
+    def render(text, options={}) #format, text, file, db, &yld)
+      if format = options[:format]
+        raise "unsupported rendering -- #{format}"
+      else
+        raise "unsupported rendering"
+      end
+    end
+
+    #
+    def compile(db, &yld)
+      raise "not implemented"
+    end
+
+    #
+    def cache?
+      !settings[:nocache]
+    end
+
+    private
+
+    # Override this to load template engine library and
+    # prepare is for geeral usage.
+    def initialize_engine
+    end
+
+    # Require template library.
+    def require_library(path)
+      require(path)
+    end
+
+    # Convert a data source into a Binding.
+    # TODO: handle yld.
+    def make_binding(db, &yld)
+      return db if Binding === db
+
+      if db.respond_to?(:to_binding)
+        return db.to_binding
+      end
+
+      db = make_object(db)
+
+      return db.instance_eval{ binding }        
+    end
+
+    # Convert a data source into an Object (aka a "scope").
+    def make_object(db)
+      if db.respond_to?(:to_hash)
+        hash  = db.to_hash
+        attrs = hash.keys.map{ |k| k.to_sym }
+        return Struct.new(*attrs).new(*hash.values)
+      end
+
+      if Binding === db
+        eval('self', binding)
+      end
+
+      return db
+    end
+
+    # Convert a data source into a Hash.
+    def make_hash(db, &yld)
+      if Binding === db
+        db = make_object(db)
+      end
+
+      if db.respond_to?(:to_hash)
+        db = db.to_hash
+        db[:yield] = yld.call if yld
+        return db
+      end
+
+      if db.respond_to?(:to_h)
+        db = db.to_h
+        db[:yield] = yld.call if yld
+        return db
+      end
+
+      # last resort
+      db = db.instance_variables.inject({}) do |h, i|
+        k = i.sub('@','').to_sym
+        v = instance_variable_get(i)
+        h[k] = v
+        h
+      end
+      db[:yield] = yld.call if yld
+      return db
+    end
+
+  end
+
+end
+end

data/lib/malt/engines/bluecloth.rb

@@ -0,0 +1,39 @@
+require 'malt/engines/abstract'
+
+module Malt::Engines
+
+  #
+  class BlueCloth < Abstract
+
+    register :markdown, :md
+
+    # Convert Markdown text to HTML text.
+    def render(params)
+      text   = params[:text]
+      format = params[:format]
+      case format
+      when :html, nil
+        intermediate(params).to_html
+      else
+        super(params)
+      end
+    end
+
+    # Convert Markdown text to intermediate object.
+    def intermediate(params)
+      text = params[:text]
+      ::BlueCloth.new(text)
+    end
+
+    private
+
+    # Load bluecloth library if not already loaded.
+    def initialize_engine
+      return if defined? ::BlueCloth
+      require_library 'bluecloth'
+    end
+
+  end
+
+end
+

data/lib/malt/engines/erb.rb

@@ -0,0 +1,84 @@
+require 'malt/engines/abstract'
+
+module Malt::Engines
+
+  # ERB template implementation.
+  #
+  #   http://www.ruby-doc.org/stdlib/libdoc/erb/rdoc/classes/ERB.html
+  #
+  # ERB templates accept two options. +safe+ sets the safe mode for
+  # rendering the template and +trim+ is a weird string that controls
+  # a few rendering options --it can be '%' and/or '>' or '<>'.
+  class Erb < Abstract
+
+    default :erb, :rhtml
+
+    # Render ERB template.
+    #
+    # The +params+ can be:
+    #
+    # * :text - text of erb document
+    # * :file - file name where text was read (or nil)
+    # * :data - data source for template interpolation
+    # * :safe -
+    # * :trim -
+    #
+    # Returns a String.
+    def render(params={}, &yld)
+      text = params[:text]
+      file = params[:file]
+      data = params[:data]
+      data = make_binding(data, &yld)
+      if settings[:precompile] == false
+        intermediate(params).result(data)
+      else
+        ruby = compile(params)
+        eval(ruby, data, file)
+      end
+    end
+
+    # Compile ERB template into Ruby source code.
+    def compile(params={})
+      file = params[:file]
+      if cache?
+        @source[file] ||= intermediate(params).src
+      else
+        intermediate(params).src
+      end
+    end
+
+    # Returns instance of underlying ::ERB class.
+    def intermediate(params={})
+      text = params[:text]
+      file = params[:file]
+
+      opts = engine_options(params)
+      safe = opts[:safe]
+      trim = opts[:trim]
+
+      if cache?
+        @cache[file] ||= ::ERB.new(text, safe, trim)
+      else
+        ::ERB.new(text, safe, trim)
+      end
+    end
+
+    private
+
+    # Load ERB library if not already loaded.
+    def initialize_engine
+      return if defined? ::ERB
+      require_library('erb')
+    end
+
+    def engine_options(params)
+      opts = {}
+      opts[:safe] = params[:safe] || settings[:safe]
+      opts[:trim] = params[:trim] || settings[:trim]
+      opts
+    end
+
+  end
+
+end
+

data/lib/malt/engines/erubis.rb

@@ -0,0 +1,65 @@
+require 'malt/engines/abstract'
+
+module Malt::Engines
+
+  # Erubis template implementation.
+  #
+  #   http://www.kuwata-lab.com/erubis/
+  #
+  # Erubis is essentially compatibel with ERB, but it is faster.
+  #
+  class Erubis < Abstract
+
+    register :erb, :rhtml
+
+    # 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 intermediate(params)
+      text = params[:text]
+      file = params[:file]
+
+      opts = {}
+
+      if params[:escape_html] || settings[:escape_html]
+        ::Erubis::EscapedEruby.new(text, settings)
+      else
+        ::Erubis::Eruby.new(text, settings)
+      end
+    end
+
+    #
+    def safe
+      options[:safe]
+    end
+
+    #
+    def trim
+      options[:trim]
+    end
+
+    ;;;; private ;;;;
+
+    # Load ERB library if not already loaded.
+    def initialize_engine
+      return if defined? ::Erubius
+      require_library('erubis')
+    end
+
+  end
+
+end
+

data/lib/malt/engines/haml.rb

@@ -0,0 +1,68 @@
+require 'malt/engines/abstract'
+
+module Malt::Engines
+
+  # Haml
+  #
+  class Haml < Abstract
+
+    default :haml
+
+    #
+    def render(params, &yld)
+      format = params[:format]
+      case format
+      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]
+
+      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
+      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
+
+    # Load Haml library if not already loaded.
+    def initialize_engine
+      return if defined? ::Haml::Engine
+      require_library 'haml'
+    end
+
+  end
+
+end
+