malt 0.3.0 → 0.4.0

data/lib/malt.yml

@@ -0,0 +1,156 @@
+---
+source:
+- var
+authors:
+- name: trans
+  email: transfire@gmail.com
+copyrights:
+- holder: Rubyworks
+  year: '2010'
+  license: BSD-2-Clause
+replacements: []
+alternatives: []
+requirements:
+- name: blankslate
+- name: detroit
+  groups:
+  - build
+  development: true
+- name: qed
+  groups:
+  - test
+  development: true
+- name: test
+  groups:
+  - test
+  development: true
+- name: lemon
+  groups:
+  - test
+  development: true
+- name: ae
+  groups:
+  - test
+  development: true
+- name: rdoc
+  version: 3+
+  groups:
+  - test
+  development: true
+- name: RedCloth
+  groups:
+  - test
+  development: true
+- name: bluecloth
+  groups:
+  - test
+  development: true
+- name: kramdown
+  groups:
+  - test
+  development: true
+- name: rdiscount
+  groups:
+  - test
+  development: true
+- name: haml
+  groups:
+  - test
+  development: true
+- name: sass
+  groups:
+  - test
+  development: true
+- name: less
+  groups:
+  - test
+  development: true
+- name: tenjin
+  groups:
+  - test
+  development: true
+- name: rtals
+  groups:
+  - test
+  development: true
+- name: liquid
+  groups:
+  - test
+  development: true
+- name: erubis
+  groups:
+  - test
+  development: true
+- name: mustache
+  groups:
+  - test
+  development: true
+- name: markaby
+  groups:
+  - test
+  development: true
+- name: builder
+  groups:
+  - test
+  development: true
+- name: radius
+  groups:
+  - test
+  development: true
+- name: ragtag
+  groups:
+  - test
+  development: true
+- name: redcarpet
+  groups:
+  - test
+  development: true
+- name: wikicloth
+  groups:
+  - test
+  development: true
+- name: maruku
+  groups:
+  - test
+  development: true
+- name: creole
+  groups:
+  - test
+  development: true
+- name: erector
+  groups:
+  - test
+  development: true
+- name: active_support
+  groups:
+  - test
+  development: true
+- name: coffee-script
+  groups:
+  - test
+  development: true
+dependencies: []
+conflicts: []
+repositories:
+- uri: git@github.com:rubyworks/malt.git
+  scm: git
+  name: upstream
+resources:
+  home: http://rubyworks.github.com/malt
+  code: http://github.com/rubyworks/malt
+  wiki: http://wiki.github.com/rubyworks/malt
+  docs: http://rubyworks.github.com/malt/docs/api
+  bugs: http://github.com/rubyworks/malt/issues
+extra: {}
+load_path:
+- lib
+revision: 0
+created: '2010-06-22'
+summary: Multi-template/multi-markup rendering engine
+title: Malt
+version: 0.4.0
+name: malt
+description: Malt provides a factory framework for rendering a variety of template
+  and markup document formats.
+organization: rubyworks
+date: '2011-11-26'

data/lib/malt/conversions.rb

@@ -0,0 +1,42 @@
+module Malt
+
+  module Conversions
+
+    module Binding
+      extend self
+
+      #
+      def to_binding(binding)
+        binding
+      end
+
+      #
+      def to_hash(binding)
+        Hash.new{ |h,k| h[k] = binding.eval(k) }
+      end
+
+      #
+      def to_object(binding)
+        obj = binding.eval("self")
+
+        vars  = binding.eval("local_variables")
+        vals  = binding.eval("[#{vars.join(',')}]")
+        data  = Hash[*vars.zip(vals).flatten]
+
+        adhoc = (class << obj; self; end)
+        data.each do |name,value|
+          adhoc.__send__(:define_method, name){ value }
+        end
+
+        obj
+      end
+
+    end
+
+    module Object
+
+    end
+
+  end
+
+end

data/lib/malt/core_ext.rb

@@ -1,8 +1,10 @@
 require 'ostruct'
 require 'facets/module/basename'
+require 'facets/to_hash'
+require 'facets/hash/rekey'
 
+=begin
 class Hash
-
   #
   def to_hash
     dup
@@ -18,14 +20,90 @@ class Hash
     end
     h
   end unless method_defined?(:rekey)
+end
+=end
+
+
+class Binding
+  # Conversion for bindings.
+  #
+  # @todo Is there any way to integrate the optional data and block?
+  def to_binding
+    self
+  end
+
+  #
+  def itself
+    eval('self')
+  end
+
+  # Create a new binding incorporating the current binding and
+  # the given local settings hash and yield block.
+  #
+  # The yield code was neccessary b/c Ruby does not respect the use
+  # of yield in a lambda (boo hiss). 
+  def with(_hash, &_yield)
+    _hash = (_hash || {}).to_hash
+
+    if _yield
+      vars = eval('local_variables')
+      vals = eval("[#{vars.join(',')}]")
+
+      vars += _hash.keys
+      vals += _hash.values
+
+      code = <<-END
+        def self.___with(#{vars.join(',')})
+          binding
+        end
+        method(:___with)
+      END
+      eval(code).call(*vals, &_yield)
 
+      #_args = _hash.empty? ? '' : '|' + _hash.keys.join(',') + ',&y|'
+      #lamb = eval("lambda{#{_args} binding}")
+      #(class << self; self; end).send(:define_method, :__temp__, &lamb)
+      #method(:__temp__).call(*_hash.values, &_yield)
+    else
+      _args = _hash.empty? ? '' : '|' + _hash.keys.join(',') + '|'
+      eval("lambda{#{_args} binding}").call(*_hash.values)
+    end
+  end
+end
+
+class Object
+  def to_binding
+    binding
+  end
+end
+
+class Struct
+  def to_struct
+    self
+  end
+
+  def to_h
+    Hash[members.zip(values)]
+  end unless method_defined?(:to_h)
+
+  #def to_hash
+  #  Hash[members.zip(values)]
+  #end
 end
 
 class OpenStruct
+  def to_struct
+    self
+  end
 
   #
-  def to_hash
+  def to_h #ash
     @table.dup
-  end unless method_defined?(:to_hash)
+  end unless method_defined?(:to_h)
+end
 
+unless defined?(::BasicObject)
+  require 'blankslate'
+  ::BasicObject = ::BlankSlate
 end
+

data/lib/malt/engines/abstract.rb

@@ -58,36 +58,62 @@ module Engine
       @cache  = {}
       @source = {}
 
-      initialize_engine
+      require_engine
     end
 
     # Access to the options given to the initializer.
     attr :settings
 
     #
-    def render(text, options={}) #format, text, file, db, &yld)
-      if format = options[:format]
-        raise "unsupported rendering -- #{format}"
+    def cache?
+      !settings[:nocache]
+    end
+
+    #
+    def render(params, &block)
+      if into = params[:to]
+        raise NotImplementedError, "unsupported rendering -- #{into}"
       else
-        raise "unsupported rendering"
+        raise NotImplementedError, "unsupported rendering"
       end
     end
 
-    #
-    def compile(db, &yld)
-      raise "not implemented"
+    # Prepare engine for rendering.
+    def prepare_engine(params={}, &content)
+      create_engine(params, &content)
     end
 
+    # Instantiate engine class with engine options and template text,
+    # if possible.
     #
-    def cache?
-      !settings[:nocache]
+    # The initialization MUST never include template data and should
+    # support caching, if feasible.
+    #
+    def create_engine(params={})
+      raise NotImplementedError, "not implemented"
     end
 
-    private
+    # Convert a rendition to Ruby source code. Not all engines support compiling.
+    #
+    #def compile(*data, &content)
+    #  raise NotImplementedError, "not implemented"
+    #end
+
+  private
+
+    # Cached yield reuslt with given key if cache mode is active.
+    #
+    def cached(*key)
+      if cache?
+        @cache[key] ||= yield
+      else
+        yield
+      end
+    end
 
     # Override this to load template engine library and
     # prepare is for geeral usage.
-    def initialize_engine
+    def require_engine
     end
 
     # Require template library.
@@ -95,63 +121,246 @@ module Engine
       require(path)
     end
 
-    # Convert a data source into a Binding.
-    # TODO: handle yld.
-    def make_binding(db, &yld)
-      return db if Binding === db  # FIXME: no yld
+    # - - -  D A T A  H A N D L I N G  - - -
+
+    # Take `scope` and `locals` data sources are return them as object and
+    # locals hash.
+    #
+    # @param [Object,Binding] scope
+    #
+    # @param [Hash] locals
+    #
+    # @return [Array<Object,Hash>] Two element array of scope object and data hash.
+    def make_ready(scope, locals=nil, &content)
+      locals ||= {}
+
+      case scope
+      when Binding
+        vars   = scope.eval("local_variables")
+        vals   = scope.eval("[#{vars.join(',')}]")
+        locals = locals.merge(Hash[*vars.zip(vals).flatten])
+        scope  = scope.eval("self")
+      end
+
+      if scope.respond_to?(:to_struct)
+        locals = locals.merge(scope.to_struct.to_h)
+        scope  = Object.new
+      end
 
-      if db.respond_to?(:to_binding)
-        return db.to_binding(&yld)
+      if scope.respond_to?(:to_hash)
+        locals = locals.merge(scope.to_hash)
+        scope  = Object.new
       end
 
-      db = make_object(db, &yld)
+      scope ||= Object.new
 
-      return db.instance_eval{ binding }        
+      locals[:content] = content.call if content
+
+      return scope, locals
     end
 
-    # Convert a data source into an Object (aka a "scope").
-    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)
+    # Take scope and locals are return the same reworked for use as externalized
+    # template variables.
+    #
+    # @return [Array<Object,Hash>]
+    #   Two element array of scope object and data hash.
+    def make_external(scope, locals=nil, &content)
+      locals ||= {}
+
+      case scope
+      when Binding
+        vars   = scope.eval("local_variables")
+        vals   = scope.eval("[#{vars.join(',')}]")
+        locals = locals.merge(Hash[*vars.zip(vals).flatten])
+        scope  = scope.eval("self")
+      end
+
+      if scope.respond_to?(:to_struct)
+        locals = locals.merge(scope.to_struct.to_h)
+        #scope  = Object.new
       end
 
-      if Binding === db
-        eval('self', binding) # FIXME: no yld
+      if scope.respond_to?(:to_hash)
+        locals = locals.merge(scope.to_hash)
+        scope  = Object.new
       end
 
-      return db
+      scope ||= Object.new
+      scope = make_object(scope || Object.new)
+
+      locals[:scope]   = scope
+      locals[:content] = content.call if content
+
+      return scope, locals
     end
 
-    # Convert a data source into a Hash.
-    def make_hash(db, &yld)
-      if Binding === db
-        db = make_object(db)
+    # Convert scope and data into a Binding.
+    #
+    # @param [Object,Binding,Hash,Array] data
+    #   The data source used for evaluation.
+    #
+    # @see #split_data
+    #
+    # @return [Object] The data and yield block converted to a Binding.
+    def make_binding(scope, locals=nil, &content)
+      case scope
+      when Binding
+        locals ||= {}
+        locals[:content] = content.call if content
+        scope.with(locals)
+      else
+        scope, locals = make_ready(scope, locals, &content)
+        scope.to_binding.with(locals)
       end
+    end
 
-      if db.respond_to?(:to_hash)
-        db = db.to_hash
-        db[:yield] = yld.call if yld
-        return db
+    # TODO: Simplify the #make_object method.
+
+    # Convert data into an object.
+    #
+    # @param [Object,Binding,Hash,Array] data
+    #   The data source used for evaluation.
+    #
+    # @return [Object] The data and yield block converted to an Object.
+    def make_object(scope, locals=nil)
+      locals ||= {}
+
+      case scope
+      when nil
+        hash = locals.to_hash.dup
+        if hash.empty?
+          Object.new
+        else
+          vars, vals = [], []
+          hash.each_pair do |k,v|
+            vars << k; vals << v
+          end
+          Struct.new(*vars).new(*vals)
+        end
+      when Binding
+        Class.new(::BasicObject){
+          define_method(:method_missing) do |s, *a|
+            if locals.key?(s)
+              locals[s]
+            elsif locals.key?(s.to_s)
+              locals[s.to_s]
+            else
+              scope.eval(s.to_s)
+            end
+          end
+        }.new
+      when Struct
+        vars, vals = [], []
+        scope.each_pair do |k,v|
+          vars << k; vals << v
+        end
+        locals.each_pair do |k,v|
+          vars << k; vals << v
+        end
+        Struct.new(*vars).new(*vals)
+      else
+        if scope.respond_to?(:to_hash)
+          hash = scope.to_hash.merge(locals.to_hash)
+          if hash.empty?
+            Object.new
+          else
+            vars, vals = [], []
+            hash.each_pair do |k,v|
+              vars << k; vals << v
+            end
+            Struct.new(*vars).new(*vals)
+          end
+        else
+          Class.new(::BasicObject){
+            define_method(:method_missing) do |s, *a, &b|
+              if locals.key?(s)
+                locals[s]
+              elsif locals.key?(s.to_s)
+                locals[s.to_s]
+              else
+                scope.__send__(s.to_s, *a, &b)
+              end
+            end
+          }.new
+        end
       end
+    end
 
-      if db.respond_to?(:to_h)
-        db = db.to_h
-        db[:yield] = yld.call if yld
-        return db
+    # Convert data source into a hash.
+    #
+    # @param [Object,Binding,Hash,Array] data
+    #   The data source used for evaluation.
+    #
+    # @see #scope_vs_hash
+    #
+    # @return [Hash] The data and yield block converted to a Hash.
+    def make_hash(scope, locals=nil, &content)
+      case scope
+      when nil
+        hash = locals || {}
+      when Binding
+        #hash = Hash.new{ |h,k| p h,k; h[k] = data.key?(k) ? data[k] : scope.eval(k) }
+        hash = Hash.new{ |h,k| h[k] = scope.eval(k) }
+      else
+        if scope.respond_to?(:to_hash)
+          hash = scope.to_hash.merge(data)
+        else
+          #hash = Hash.new{ |h,k| data.key?(k) ? data[k] : h[k] = scope.__send__(k) }
+          hash = Hash.new{ |h,k| h[k] = scope.__send__(k) }
+        end
       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
+      hash = hash.merge(locals || {})
+
+      if content
+        hash[:content] = content.call.to_s  # rescue nil ?
+      end
+
+      hash
+    end
+
+    #
+    #def make_scope_and_data(data, &content)
+    #  scope, data = scope_vs_data(data)
+    #  case scope
+    #  when Binding
+    #    vars  = scope.eval("local_variables")
+    #    vals  = scope.eval("[#{vars.join(',')}]")
+    #    data  = data.merge(Hash[*vars.zip(vals).flatten])
+    #    scope = scope.eval("self")
+    #  else
+    #    scope ||= Object.new
+    #  end
+    #  return scope, data
+    #end
+
+    #
+    def engine_options(params)
+      opts = {}
+      engine_option_names.each do |o|
+        o = o.to_sym
+        v = params[o] || settings[o]
+        opts[o] = v if v
+      end
+      opts
+    end
+
+    # Override this.
+    def engine_option_names
+      []
+    end
+
+    # Helper method to get paramters.
+    def parameters(params, *names)
+      pvals = names.map do |name|
+        params[name.to_sym] || settings[name.to_sym]
+      end
+
+      if names.size == 1
+        return pvals.first
+      else
+        return *pvals
       end
-      db[:yield] = yld.call if yld
-      return db
     end
 
   end