malt 0.3.0 → 0.4.0

data/lib/malt/engines/ragtag.rb

@@ -2,43 +2,52 @@ require 'malt/engines/abstract'
 
 module Malt::Engine
 
-  # RagTag
+  # RagTag XML/HTML templates.
   #
-  #  http://github.com/rubyworks/ragtag
+  # @see 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]
+    def render(params={}, &content)
+      into = parameters(params, :to) || :html
 
       case into
-      when :html, nil
-        data = make_binding(data, &yld)
-        intermediate(params).compile(data).to_xhtml
+      when :html
+        prepare_engine(params,&content).to_html
+      when :xhtml
+        prepare_engine(params,&content).to_xhtml
       when :xml
-        data = make_binding(data, &yld)
-        intermediate(params).compile(data).to_xml
+        prepare_engine(params,&content).to_xml
       else
-        super(params, &yld)
+        super(params, &content)
       end
     end
 
+    # 
+    def prepare_engine(params={}, &content)
+      text, file, scope, locals = parameters(params, :text, :file, :scope, :locals)
+
+      binding = make_binding(scope, locals, &content)
+
+      create_engine(params).compile(binding)
+    end
+
     #
-    def intermediate(params)
-      text = params[:text]
-      ::RagTag.new(text)
+    def create_engine(params={})
+      text = parameters(params, :text)
+
+      cached(text) do
+        ::RagTag.new(text)
+      end
     end
 
     private
 
     # Load Haml library if not already loaded.
-    def initialize_engine
+    def require_engine
       return if defined? ::RagTag
       require_library 'ragtag'
     end
@@ -46,4 +55,3 @@ module Malt::Engine
   end
 
 end
-

data/lib/malt/engines/rdiscount.rb

@@ -6,7 +6,7 @@ module Malt::Engine
 
   # Discount Markdown implementation.
   #
-  #   http://github.com/rtomayko/rdiscount
+  # @see http://github.com/rtomayko/rdiscount
   #
   # The +:smart+ and +:filter_html+ options can be set true
   # to enable those flags on the underlying RDiscount object.
@@ -15,31 +15,38 @@ module Malt::Engine
     default :markdown, :md
 
     # Convert Markdown text to HTML text.
-    def render(params)
-      case params[:to]
+    def render(params={})
+      into = parameters(params, :to)
+
+      case into
       when :html, nil
-        intermediate(params).to_html
+        prepare_engine(params).to_html
       else
         super(params)
       end
     end
 
-    # Convert Markdown text to intermediate engine object.
-    def intermediate(params)
-      text = params[:text]
-      ::RDiscount.new(text, *flags)
+    # Convert Markdown text to create_engine engine object.
+    def create_engine(params={})
+      text = parameters(params, :text)
+
+      flags = engine_options(params)
+
+      cached(text, flags) do
+        ::RDiscount.new(text, *flags)
+      end
     end
 
-    private
+  private
 
     # Load rdoc makup library if not already loaded.
-    def initialize_engine
+    def require_engine
       return if defined? ::RDiscount
       require_library 'rdiscount'
     end
 
     #
-    def flags(params={})
+    def engine_options(params={})
       [:smart, :filter_html].select{ |flag| params[flag] || settings[flag] }
     end
 

data/lib/malt/engines/rdoc.rb

@@ -14,31 +14,37 @@ module Malt::Engine
     default :rdoc
 
     # Convert rdoc text to html.
-    def render(params)
-      text = params[:text]
-      into = params[:to]
+    def render(params={})
+      into, text = parameters(params, :to, :text)
+
       case into
       when :html, nil
-        html_engine.convert(text).to_s
+        prepare_engine(params).convert(text).to_s
       else
         super(params)
       end
     end
 
-    private
+    #
+    def create_engine(params={})
+      into = parameters(params, :to)
 
-      # Load rdoc makup library if not already loaded.
-      def initialize_engine
-        return if defined?(::RDoc::Markup)
-        require 'rubygems' # hack
-        require_library 'rdoc/markup'
-        require_library 'rdoc/markup/to_html'
+      cached(into) do
+        ::RDoc::Markup::ToHtml.new
       end
+    end
 
-      #
-      def html_engine
-        @html_engine ||= ::RDoc::Markup::ToHtml.new
-      end
+  private
+
+    # Load rdoc makup library if not already loaded.
+    def require_engine
+      return if defined?(::RDoc::Markup)
+      require 'rubygems' # hack
+      gem 'rdoc', '> 3'
+      require_library 'rdoc'
+      #require_library 'rdoc/markup'
+      #require_library 'rdoc/markup/to_html'
+    end
 
   end
 

data/lib/malt/engines/redcarpet.rb

@@ -0,0 +1,137 @@
+require 'malt/engines/abstract'
+
+module Malt::Engine
+
+  # Redcarpet Markdown implementation.
+  #
+  # @see https://github.com/tanoku/redcarpet
+  #
+  class Redcarpet < 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 = parameters(params, :to, :text)
+
+      case into
+      when :html, nil  # :man, :manpage
+        if ::Redcarpet::VERSION < '2'
+          prepare_engine(params).to_html
+        else
+          prepare_engine(params).render(text)
+        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 [Boolean] :no_intra_emphasis 
+    #   Do not parse emphasis inside of words. Strings such as `foo_bar_baz`
+    #   will not generate `<em>` tags.
+    #
+    # @option params [Boolean] :tables
+    #   Parse tables, PHP-Markdown style.
+    #
+    # @option params [Boolean] :fenced_code_blocks
+    #   Parse fenced code blocks, PHP-Markdown style. Blocks delimited with
+    #   three or more `~` or backticks  will be considered as code, without
+    #   the need to be indented. An optional language name may be added at
+    #   the end of the opening fence for the code block
+    #
+    # @option params [Boolean] :autolink
+    #   parse links even when they are not enclosed in
+    #   `<>` characters. Autolinks for the http, https and ftp
+    #   protocols will be automatically detected. Email addresses
+    #   are also handled, and http links without protocol, but
+    #   starting with `www.`
+    #
+    # @option params [Boolean] :strikethrough
+    #   parse strikethrough, PHP-Markdown style
+    #   Two `~` characters mark the start of a strikethrough,
+    #   e.g. `this is ~~good~~ bad`
+    #
+    # @option params [Boolean] :lax_html_blocks
+    #   HTML blocks do not require to be surrounded
+    #   by an empty line as in the Markdown standard.
+    #
+    # @option params [Boolean] :space_after_headers
+    #   A space is always required between the
+    #   hash at the beginning of a header and its name, e.g.
+    #   `#this is my header` would not be a valid header.
+    #
+    # @option params [Boolean] :superscript
+    #   parse superscripts after the `^` character;
+    #   contiguous superscripts are nested together, and complex
+    #   values can be enclosed in parenthesis, e.g. `this is the 2^(nd) time`
+    #
+    def create_engine(params={})
+      return create_engine_1x(params) if ::Redcarpet::VERSION < '2'
+
+      into, toc = parameters(params, :to, :toc)
+
+      opts = engine_options(params)
+
+      case into
+      when :man, :manpage
+        renderer = ::Redcarpet::Render::ManPage
+      else
+        if toc
+          renderer = ::Redcarpet::Render::HTML_TOC
+        else
+          renderer = ::Redcarpet::Render::HTML
+        end
+      end
+
+      cached(into, toc, opts) do
+        ::Redcarpet::Markdown.new(renderer)
+      end
+    end
+
+    # For Recarpet v1.x.
+    def create_engine_1x(params={})
+      text = parameters(params, :text)
+
+      cached(text) do
+        ::Redcarpet.new(text) #, engine_options(params))
+      end
+    end
+
+  private
+
+    ENGINE_OPTION_NAMES = %w{
+      no_intra_emphasis tables fenced_code_blocks autolink strikethrough
+      lax_html_blocks space_after_headers superscript
+    }
+
+    # Load rdoc makup library if not already loaded.
+    def require_engine
+      return if defined? ::Redcarpet
+      require_library 'redcarpet'
+    end
+
+    #
+    def engine_option_names
+      ENGINE_OPTION_NAMES
+    end
+
+  end
+
+end
+
+

data/lib/malt/engines/redcloth.rb

@@ -2,7 +2,10 @@ require 'malt/engines/abstract'
 
 module Malt::Engine
 
+  # Redcloth handles textile markup.
   #
+  # @see http://redcloth.org/
+
   class RedCloth < Abstract
 
     default :tt, :textile
@@ -14,24 +17,29 @@ module Malt::Engine
     #   :format => Symbol of the format to render [:html]
     #
     def render(params={})
-      case params[:to]
+      into, text = parameters(params, :to, :text)
+
+      case into
       when :html, nil
-        intermediate(params).to_html
+        prepare_engine(params).to_html
       else
         super(params)
       end
     end
 
     #
-    def intermediate(params={})
-      text = params[:text]
-      ::RedCloth.new(text)
+    def create_engine(params={})
+      text = parameters(params, :text)
+
+      cached(text) do
+        ::RedCloth.new(text)
+      end
     end
 
-    private
+  private
 
     # Load redcloth library if not already loaded.
-    def initialize_engine
+    def require_engine
       return if defined? ::RedCloth
       require_library 'redcloth'
     end

data/lib/malt/engines/ruby.rb

@@ -2,32 +2,33 @@ require 'malt/engines/abstract'
 
 module Malt::Engine
 
-  # Ruby as a template engine.
+  # Ruby return reuslt as template engine.
   #
-  #   http://
+  # @todo deprecate ?
+  # 
+  # @see http://ruby-lang.org
   #
   class Ruby < Abstract
 
     default :rb
 
     #
-    def render(params={}, &yld)
-      text = params[:text]
-      file = params[:file]
-      data = params[:data]
-      data = make_binding(data, &yld)
-      eval(text, data, file)
+    def render(params={}, &content)
+      text, file, scope, locals = parameters(params, :text, :file, :scope, :locals)
+
+      bind = make_binding(scope, locals, &content)
+      eval(text, bind, file || 'eval')
     end
 
     # Ruby compiles to Ruby. How odd. ;)
-    def compile(text, file)
-      text
+    def compile(params)
+      params[:text] #file
     end
 
-    private
+  private
 
     #
-    def initialize_engine
+    def require_engine
     end
 
   end

data/lib/malt/engines/sass.rb

@@ -9,40 +9,53 @@ module Malt::Engine
     default :sass, :scss
 
     #
-    def render(params, &yld)
-      text = params[:text]
-      file = params[:file]
-      into = params[:to]
+    def render(params={}, &content)
+      into = parameters(params, :to)
 
       case into
       when :css, nil
-        engine = intermediate(params)
+        engine = prepare_engine(params)
         engine.render
       else
-        super(params, &yld)
+        super(params, &content)
       end
     end
 
     #
-    def intermediate(params)
-      text = params[:text]
-      file = params[:file]
-      type = params[:type]
-      ::Sass::Engine.new(text, :filename=>file, :syntax=>type)
+    def create_engine(params={})
+      text, file, type = parameters(params, :text, :file, :type)
+
+      opts = engine_options(params)
+
+      opts[:filename] = file
+      opts[:syntax]   = type
+
+      cached(text, file, type) do
+        ::Sass::Engine.new(text, opts)
+      end
     end
 
-    private
+  private
 
     # Load Sass library if not already loaded.
-    def initialize_engine
+    def require_engine
       return if defined? ::Sass::Engine
       require_library 'sass'
     end
 
-    #def engine_options
-    #  opts = {}
-    #  opts
-    #end
+    # List of Sass/Scss engine options. Note that not all options are supported.
+    # Also use `:type` instead of `:syntax` and `:file` instead of `:filename`.
+    #
+    # @see http://sass-lang.com/docs/yardoc/file.SASS_REFERENCE.html#options
+    ENGINE_OPTION_NAMES = %w{
+      syntax filename line style unix_newlines
+      line_numbers trace_selectors debug_info quiet 
+    }
+
+    #
+    def engine_option_names
+      ENGINE_OPTION_NAMES
+    end
 
   end