malt 0.3.0 → 0.4.0

data/lib/malt/engines/bluecloth.rb

@@ -8,27 +8,37 @@ module Malt::Engine
     register :markdown, :md
 
     # Convert Markdown text to HTML text.
-    def render(params)
-      text = params[:text]
+    def render(params={})
       into = params[:to]
+
+      text = parameters(params, :text)
+
       case into
       when :html, nil
-        intermediate(params).to_html
+        prepare_engine(params).to_html
       else
         super(params)
       end
     end
 
-    # Convert Markdown text to intermediate object.
-    def intermediate(params)
-      text = params[:text]
-      ::BlueCloth.new(text)
+    # Prepare engine for rendering.
+    #def prepare_engine(params={})
+    #  create_engine(params)
+    #end
+
+    # Instantiate engine class and cache if applicable.
+    def create_engine(params={})
+      text = parameters(params, :text)
+
+      cached(text) do
+        ::BlueCloth.new(text)
+      end
     end
 
-    private
+  private
 
     # Load bluecloth library if not already loaded.
-    def initialize_engine
+    def require_engine
       return if defined? ::BlueCloth
       require_library 'bluecloth'
     end

data/lib/malt/engines/builder.rb

@@ -8,44 +8,111 @@ module Malt::Engine
   #
   class Builder < Abstract
 
-    default :builder
+    default :builder, :rbml
 
     #
-    #def intermediate(params)
-    #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 :xml, :html, :xhtml
+        prepare_engine(params, &content) #.target!
       else
-        super(params, &yld)
+        super(params, &content)
       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)
+  #private
+
+    # Prepare engine for rendering.
+    def prepare_engine(params={}, &content)
+      prefix = parameters(params, :prefix)
+
+      if prefix
+        prepare_engine_prefix(params, &content)
+      else
+        prepare_engine_scope(params, &content)
+      end
+    end
+
+    # TODO: Can Builder be cached?
+
+    #
+    def create_engine(params={})
+      opts = engine_options(params)
+
+      #cached(opts) do
+        ::Builder::XmlMarkup.new(opts)
+      #end
     end
 
-    private
+    #
+    def prepare_engine_prefix(params, &content)
+      prefix, text, file, scope, locals = parameters(params, :prefix, :text, :file, :scope, :locals)
+
+      bind = make_binding(scope, locals, &content)
+
+      #scope, locals = split_data(data)
+
+      #scope  ||= Object.new
+      #locals ||= {}
+
+      engine = create_engine(params)
+
+      code = %{
+        lambda do |#{prefix}|
+          #{text}
+        end
+      }
+
+      eval(code, bind, file || '(builder)').call(engine)
+    end
 
-    # Load Erector library if not already loaded.
-    def initialize_engine
+    # TODO: woud rather set instance variable via #instance_variable_set
+    # but it is not defined.
+
+    #
+    def prepare_engine_scope(params, &content)
+      text, file, scope, locals = parameters(params, :text, :file, :scope, :locals)
+
+      scope, locals = make_external(scope, locals, &content)
+
+      engine = create_engine
+
+      locals.each do |k,v|
+        next if k.to_sym == :target
+        engine.instance_eval("@#{k} = v")
+      end
+
+      unless scope.respond_to?(:to_struct)
+        scope.instance_variables.each do |k|
+          next if k == "@target"
+          v = scope.instance_variable_get(k)
+          engine.instance_eval("#{k} = v") 
+        end
+      end
+
+      engine.instance_eval(text, file || '(builder)')
+
+      engine.target!
+    end
+
+  private
+
+    # Load Builder library if not already loaded.
+    def require_engine
       return if defined? ::Builder
       require_library 'builder'
+
+      # Inexplicably Ruby 1.8 acts like the p method is present
+      # if undef_method is not used, but acts like it isn't if
+      # undef_method is used (raising an error).
+      ::Builder::XmlBase.class_eval do
+        undef_method :p rescue nil
+      end
     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.
@@ -55,15 +122,9 @@ module Malt::Engine
     #
     # :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
+    #
+    def engine_option_names
+      [:target, :indent, :margin]
     end
 
   end

data/lib/malt/engines/coffee.rb

@@ -0,0 +1,46 @@
+require 'malt/engines/abstract'
+
+module Malt::Engine
+
+  # Coffee Malt Engine
+  #
+  class Coffee < Abstract
+
+    default :coffee
+
+    # Render coffee script to JavaScript.
+    def render(params={}, &content)
+      into, text, file = parameters(params, :to, :text, :file)
+
+      case into
+      when :javascript, :js, nil
+        ::CoffeeScript.compile(text, engine_options(params))
+      else
+        super(params, &content)
+      end
+    end
+
+    # TODO: make a psuedo intermediate ?
+    # def prepare_engine(params)
+    #   
+    # end
+
+  private
+
+    # Load CoffeeScript library if not already loaded.
+    def require_engine
+      return if defined? ::CoffeeScript
+      require_library 'coffee_script'
+    end
+
+    #
+    def engine_options(params)
+      options = {}
+      options[:bare] = params[:bare] || params[:no_wrap] || false
+      options
+    end
+
+  end
+
+end
+

data/lib/malt/engines/creole.rb

@@ -0,0 +1,60 @@
+require 'malt/engines/abstract'
+
+module Malt::Engine
+
+  # Creole is a MediaWiki format for Ruby.
+  #
+  # @see http://github.com/larsch/creole
+
+  class Creole < Abstract
+
+    default :wiki, :creole
+
+    # Convert WikiMedia format to HTML.
+    # 
+    def render(params={}, &content)
+      into = parameters(params, :to)
+
+      case into
+      when :html, nil
+        prepare_engine(params, &content).to_html
+      else
+        super(params)
+      end
+    end
+
+    #
+    #def prepare_engine(params={}, &content)
+    #  create_engine(params)
+    #end
+
+    #
+    def create_engine(params={})
+      text = parameters(params, :text)
+      opts = engine_options(params)
+
+      cached(opts, text) do
+        ::Creole::Parser.new(text, opts)
+      end
+    end
+
+  private
+
+    # Load `creole` library if not already loaded.
+    def require_engine
+      return if defined? ::Creole
+      require_library 'creole'
+    end
+
+    #
+    ENGINE_OPTION_NAMES = [:allowed_schemes, :extensions, :no_escape]
+
+    #
+    def engine_option_names
+      ENGINE_OPTION_NAMES
+    end
+
+  end
+
+end
+

data/lib/malt/engines/erb.rb

@@ -15,72 +15,97 @@ module Malt::Engine
 
     # Render ERB template.
     #
-    # The +params+ can be:
+    # @param [Hash] params
     #
-    # * :text - text of erb document
-    # * :file - file name where text was read (or nil)
-    # * :data - data source for template interpolation
-    # * :safe -
-    # * :trim -
+    # @option params [String] :text
+    #   Text of document.
     #
-    # 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
+    # @option params [String] :file
+    #   The file name where text was read (or nil).
+    #
+    # @option params [Object,Binding] :scope
+    #   Scope from within which to render, serves as data source for
+    #   template interpolation.
+    #
+    # @option params [Object,Binding] :locals
+    #   Direct key/value data for template interpolation.
+    #
+    # @option params [Boolean] :safe
+    #   Run in separate thread.
+    #
+    # @option params [String] :trim
+    #   Trim mode, can be either of the following:
+    #     a) `%`  enables Ruby code processing for lines beginning with `%`.
+    #     b) `<>` omit newline for lines starting with `<%` and ending in `%>`.
+    #     c) `>`  omit newline for lines ending in `%>`.
+    # 
+    # @option params [Boolean] :precompile (true)
+    #   Precompile the ERB template. Default is `true`.
+    #   Note that `yield` currently does work with non-compiled tempaltes.
+    #
+    # @return [String] Rendered output.
+    #
+    def render(params={}, &content)
+      text, file, scope, locals = parameters(params, :text, :file, :scope, :locals)
+
+      #if settings[:compile] == true
+      #else
+        bind = make_binding(scope, locals, &content)
+        prepare_engine(params).result(bind)
+      #end
     end
 
     # Returns instance of underlying ::ERB class.
-    def intermediate(params={})
-      text = params[:text]
-      file = params[:file]
+    #def prepare_engine(params={})
+    #  create_engine(params)
+    #end
+
+    #
+    def create_engine(params={})
+      text = parameters(params, :text)
 
       opts = engine_options(params)
       safe = opts[:safe]
       trim = opts[:trim]
 
-      if cache?
-        @cache[file] ||= ::ERB.new(text, safe, trim)
-      else
+      cached(text,safe,trim) do
         ::ERB.new(text, safe, trim)
       end
     end
 
-    private
+  private
 
     # Load ERB library if not already loaded.
-    def initialize_engine
+    def require_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
+    #
+    def engine_option_names
+      [:safe, :trim]
     end
 
+    #def engine_options(params)
+    #  opts = {}
+    #  opts[:safe] = params[:safe] || settings[:safe]
+    #  opts[:trim] = params[:trim] || settings[:trim]
+    #  opts
+    #end
+
+    # Compile ERB template into Ruby source code.
+    #
+    # @return [String] Ruby source code.
+    #def compile(params={})
+    #  if cache?
+    #    @source[params] ||= (
+    #      intermediate(params).src
+    #    )
+    #  else
+    #    intermediate(params).src
+    #  end
+    #end
+
   end
 
 end
-