malt 0.1.0

data/lib/malt/engines/kramdown.rb

@@ -0,0 +1,48 @@
+require 'malt/engines/abstract'
+
+module Malt::Engines
+
+  # Discount Markdown implementation.
+  #
+  #   http://github.com/rtomayko/rdiscount
+  #
+  # The +:smart+ and +:filter_html+ options can be set true
+  # to enable those flags on the underlying RDiscount object.
+  class Kramdown < 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
+      when :latex
+        intermediate(params).to_latex
+      else
+        super(params)
+      end
+    end
+
+    # Convert Markdown text to intermediate object.
+    def intermediate(params)
+      text = params[:text]
+      ::Kramdown::Document.new(text)
+    end
+
+
+    private
+
+      # Load rdoc makup library if not already loaded.
+      def initialize_engine
+        return if defined? ::Kramdown
+        require_library 'kramdown'
+      end
+
+  end
+
+end
+
+

data/lib/malt/engines/less.rb

@@ -0,0 +1,49 @@
+require 'malt/engines/abstract'
+
+module Malt::Engines
+
+  # LESS
+  #
+  #   http://lesscss.org/
+  #
+  # LESS is an extension of CSS. You can write LESS code just like you would write CSS,
+  # except you need to compile it to CSS. That's what this class is for.
+  class Less < Abstract
+
+    default :less
+
+    #
+    def render(params)
+      text   = params[:text]
+      format = params[:format]
+      case format
+      when :css, nil
+        intermediate(params).to_css
+      else
+        super(params)
+      end
+    end
+
+    #
+    def intermediate(params)
+      text = params[:text]
+      ::Less::Engine.new(text)
+    end
+
+    #
+    #def compile(text, file)
+    #  intermediate # ??
+    #end
+
+    private
+
+      # Load Less library if not already loaded.
+      def initialize_engine
+        return if defined? ::Less::Engine
+        require_library 'less'
+      end
+
+  end
+
+end
+

data/lib/malt/engines/liquid.rb

@@ -0,0 +1,40 @@
+require 'malt/engines/abstract'
+
+module Malt::Engines
+
+  # Liquid
+  #
+  #   http://liquid.rubyforge.org/
+  #
+  class Liquid < Abstract
+
+    default :liquid
+
+    #
+    def intermediate(params)
+      text = params[:text]
+      ::Liquid::Template.parse(text)
+    end
+
+    #
+    def render(params={}, &yld) #file, db, &yld)
+      text = params[:text]
+      data = params[:data]
+      data = make_hash(data, &yld)
+      data = data.rekey{ |k| k.to_s }
+      engine = intermediate(params)
+      engine.render(data)
+    end
+
+    private
+
+    # Load Liquid library if not already loaded.
+    def initialize_engine
+      return if defined? ::Liquid::Template
+      require_library 'liquid'
+    end
+
+  end
+
+end
+

data/lib/malt/engines/radius.rb

@@ -0,0 +1,90 @@
+require 'malt/engines/abstract'
+
+module Malt::Engines
+
+  # Radius Template
+  #
+  #   http://github.com/jlong/radius/
+  #
+  class Radius < Abstract
+
+    default :radius
+
+    #
+    def render(params, &yld)
+      text   = params[:text]
+      data   = params[:data]
+      format = params[:format]
+      case format
+      when :html, :xml, nil
+        data = make_context(data, &yld)
+        opts = engine_options(params)
+        parser = ::Radius::Parser.new(data, opts)
+        parser.parse(text)
+      else
+        super(params, &yld)
+      end
+    end
+
+    private
+
+    # Load Radius library if not already loaded.
+    def initialize_engine
+      return if defined? ::Radius
+      require_library 'radius'
+    end
+
+    # Radius templates have a very special data source.
+    def make_context(data, &yld)
+      case data
+      when Hash
+        context = make_context_from_hash(data, &yld)
+      else
+        if data.respond_to(:to_hash)
+          data = data.to_hash
+          context = make_context_from_hash(data, &yld)
+        else
+          context = make_context_from_object(data, &yld)
+        end
+      end
+      context
+    end
+
+    #
+    def make_context_from_object(db, &yld)
+      context = Class.new(::Radius::Context).new
+      db = make_object(db)
+      (class << context; self; end).class_eval do
+        define_method :tag_missing do |tag, attr|
+          db.__send__(tag) # any way to support attr as args?
+        end
+      end
+      context.define_tag("yield") do
+        yld.call
+      end
+      context
+    end
+
+    #
+    def make_context_from_hash(data, &yld)
+      context = Class.new(::Radius::Context).new
+      #data = make_hash(data)
+      data.each do |tag, value|
+        context.define_tag(tag){ value }
+      end
+      context.define_tag("yield") do
+        yld.call
+      end
+      context
+    end
+
+    #
+    def engine_options(params)
+      opts = {}
+      opts[:tag_prefix] = params[:tag_prefix] || settings[:tag_prefix]
+      opts
+    end
+
+  end
+
+end

data/lib/malt/engines/rdiscount.rb

@@ -0,0 +1,49 @@
+require 'malt/engines/abstract'
+require 'malt/formats/rdoc'
+require 'malt/formats/html'
+
+module Malt::Engines
+
+  # Discount Markdown implementation.
+  #
+  #   http://github.com/rtomayko/rdiscount
+  #
+  # The +:smart+ and +:filter_html+ options can be set true
+  # to enable those flags on the underlying RDiscount object.
+  class RDiscount < Abstract
+
+    default :markdown, :md
+
+    # Convert Markdown text to HTML text.
+    def render(params)
+      case params[:format]
+      when :html, nil
+        intermediate(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)
+    end
+
+    private
+
+    # Load rdoc makup library if not already loaded.
+    def initialize_engine
+      return if defined? ::RDiscount
+      require_library 'rdiscount'
+    end
+
+    #
+    def flags(params={})
+      [:smart, :filter_html].select{ |flag| params[flag] || settings[flag] }
+    end
+
+  end
+
+end
+

data/lib/malt/engines/rdoc.rb

@@ -0,0 +1,46 @@
+require 'malt/engines/abstract'
+
+module Malt::Engines
+
+  # RDoc template.
+  #
+  #   http://rdoc.rubyforge.org/
+  #
+  # It's suggested that your program require 'rdoc/markup' and
+  # 'rdoc/markup/to_html' at load time when using this template
+  # engine.
+  class RDoc < Abstract
+
+    default :rdoc
+
+    # Convert rdoc text to html.
+    def render(params)
+      text   = params[:text]
+      format = params[:format]
+      case format
+      when :html, nil
+        html_engine.convert(text).to_s
+      else
+        super(params)
+      end
+    end
+
+    private
+
+      # 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'
+      end
+
+      #
+      def html_engine
+        @html_engine ||= ::RDoc::Markup::ToHtml.new
+      end
+
+  end
+
+end
+

data/lib/malt/engines/redcloth.rb

@@ -0,0 +1,42 @@
+require 'malt/engines/abstract'
+
+module Malt::Engines
+
+  #
+  class RedCloth < Abstract
+
+    default :tt, :textile
+
+    # Convert textile text to html.
+    # 
+    # params:
+    #
+    #   :format => Symbol of the format to render [:html]
+    #
+    def render(params={})
+      case params[:format]
+      when :html, nil
+        intermediate(params).to_html
+      else
+        super(params)
+      end
+    end
+
+    #
+    def intermediate(params={})
+      text = params[:text]
+      ::RedCloth.new(text)
+    end
+
+    private
+
+    # Load redcloth library if not already loaded.
+    def initialize_engine
+      return if defined? ::RedCloth
+      require_library 'redcloth'
+    end
+
+  end
+
+end
+

data/lib/malt/engines/rtals.rb

@@ -0,0 +1,46 @@
+require 'malt/engines/abstract'
+
+module Malt::Engines
+
+  # RTALS
+  #
+  #  http://github.com/rubyworks/rtals
+  #
+  class RTALS < Abstract
+
+    default :rtal
+
+    #
+    def render(params, &yld)
+      text   = params[:text]
+      file   = params[:file]
+      data   = params[:data]
+      format = params[:format]
+
+      case format
+      when :html, :xml, nil
+        data = make_binding(data, &yld)
+        intermediate(params).compile(data).to_s
+      else
+        super(params, &yld)
+      end
+    end
+
+    #
+    def intermediate(params)
+      text = params[:text]
+      ::RTAL.new(text)
+    end
+
+    private
+
+    # Load Haml library if not already loaded.
+    def initialize_engine
+      return if defined? ::RTAL
+      require_library 'rtals'
+    end
+
+  end
+
+end
+

data/lib/malt/engines/ruby.rb

@@ -0,0 +1,36 @@
+require 'malt/engines/abstract'
+
+module Malt::Engines
+
+  # Ruby as a template engine.
+  #
+  #   http://
+  #
+  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)
+    end
+
+    # Ruby compiles to Ruby. How odd. ;)
+    def compile(text, file)
+      text
+    end
+
+    private
+
+    #
+    def initialize_engine
+    end
+
+  end
+
+end
+