malt 0.1.0

data/lib/malt/engines/sass.rb

@@ -0,0 +1,50 @@
+require 'malt/engines/abstract'
+
+module Malt::Engines
+
+  # Sass Malt Engine
+  #
+  class Sass < Abstract
+
+    default :sass, :scss
+
+    #
+    def render(params, &yld)
+      text   = params[:text]
+      file   = params[:file]
+      format = params[:format]
+
+      case format
+      when :css, nil
+        engine = intermediate(params)
+        engine.render
+      else
+        super(params, &yld)
+      end
+    end
+
+    #
+    def intermediate(params)
+      text = params[:text]
+      file = params[:file]
+      type = params[:type]
+      ::Sass::Engine.new(text, :filename=>file, :syntax=>type)
+    end
+
+    private
+
+    # Load Sass library if not already loaded.
+    def initialize_engine
+      return if defined? ::Sass::Engine
+      require_library 'sass'
+    end
+
+    def engine_options
+      opts = {}
+      opts
+    end
+
+  end
+
+end
+

data/lib/malt/engines/tenjin.rb

@@ -0,0 +1,61 @@
+require 'malt/engines/abstract'
+
+module Malt::Engines
+
+  # Tenjin
+  #
+  #   http://www.kuwata-lab.com/tenjin/
+  #
+  # options
+  #   :escapefunc=>'CGI.escapeHTML'
+  #
+  class Tenjin < Abstract
+
+    default :tenjin, :rbhtml
+
+    #
+    def render(params, &yld)
+      text   = params[:text]
+      file   = params[:file]
+      data   = params[:data]
+      type   = params[:type]
+      format = params[:format] || :html
+
+      return super(params, &yld) if type == :rbhtml && format != :html
+
+      data = make_hash(data, &yld)
+      template = intermediate(params)
+      template.convert(text, file)
+
+      template.render(data)
+    end
+
+    #
+    def compile(params)
+      text = params[:text]
+      file = params[:file]
+      intermediate(params).convert(text, file) 
+    end
+
+    private
+
+    def intermediate(params)
+      ::Tenjin::Template.new(nil, engine_options(params))
+    end
+
+    # Load Liquid library if not already loaded.
+    def initialize_engine
+      return if defined? ::Tenjin::Engine
+      require_library 'tenjin'
+    end
+
+    def engine_options(params)
+      opts = {}
+      opts[:escapefunc] = params[:escapefunc] || settings[:escapefunc]
+      opts
+    end
+
+  end
+
+end
+

data/lib/malt/formats.rb

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

data/lib/malt/formats/abstract.rb

@@ -0,0 +1,195 @@
+require 'malt/kernel'
+
+module Malt
+module Formats
+
+  # Abstract format class serves as the base
+  # class for all other format classes.
+  #
+  class Abstract
+    include Malt::Kernel
+
+    # Register the class to an extension type.
+    def self.register(*exts)
+      @extensions = exts
+      Malt.register(self, *exts)
+
+      #exts.each do |ext|
+      #  Abstract.module_eval %{
+      #    def to_#{ext}(*db,&yld)
+      #      convert(:#{ext},*db,&yld)
+      #    end
+      #  }
+      #end
+    end
+
+    #
+    def self.extensions
+      @extensions
+    end
+
+    #
+    def self.engine(set=nil)
+      @engine = set if set
+      @engine
+    end
+
+    private
+
+    #
+    def initialize(options={})
+      @options = options.rekey
+      @type    = @options[:type]
+      initialize_engine
+    end
+
+    # Override this method to load rendering engine library.
+    def initialize_engine
+    end
+
+
+    public
+
+    # Access to the options given to the initializer.
+    attr :options
+
+    # Document source text.
+    def text
+      @text ||= options[:text] || File.read(file)
+    end
+
+    # File name of document.
+    def file
+      @file ||= options[:file].to_s
+    end
+
+    # File extension (with prefixed dot).
+    def type
+      @type ||= File.extname(file)
+    end
+
+    # Specified engine to use for rendering.
+    #
+    # Keep in mind that the ability to specify the engine
+    # varies based on engine, format and output format.
+    def engine
+      options[:engine] || self.class.engine
+    end
+
+    #
+    def to(type, data=nil, &yld)
+      __send__("to_#{type}", data, &yld)
+    end
+
+    # Render to default or given format.
+    #
+    # If the first argument is a Symbol it is considered the format, otherwise
+    # it is taken to be the database for rendering template variables.
+    def render(*type_and_data, &yld)
+      type, data = parse_type_and_data(type_and_data)
+      __send__(type || default, data, &yld)
+    end
+
+    #
+    #def render_to(format, db=nil, &yld)
+    #  render_engine.render(format, text, file, db, &yld)
+    #end
+
+    #
+#    def method_missing(s, *a, &b)
+#      case s.to_s
+#      when /^to_/
+#        convert($', *a, &b)
+#      else
+#        convert(s, *a, &b).to_s
+#        #render_to(s, *a, &b)
+#      end
+#    #rescue
+#    #  super(s, *a, &b)
+#    #end
+#    end
+
+    # TODO: render a file until add extension are exhusted
+#    def convert(to, *db, &yld)
+#      db = db.first
+#      output = render_to(to, db, &yld)
+#      if subclass = Malt.registry[subtype]
+#        subclass.new(:text=>output, :file=>file.chomp(type)).convert(to, db, &yld)
+#      else
+#        subclass = Malt.registry[".#{to}"]
+#        subclass.new(:text=>output, :file=>refile(to), :fallback=>true)
+#      end
+#    end
+
+    # Produce a new filename replacing old extension with new
+    # extension.
+    #
+    # type - Symbol representation of extension (e.g. :html).
+    #
+    # Returns a String of the new file name.
+    def refile(type=nil)
+      if file
+        if type
+          type = type.to_s.sub(/^\./,'')
+          fext = self.class.extensions.find{|e| file.end_with?(e)}
+          new_file = file.chomp(fext) + type
+        else
+          fext = self.class.extensions.find{|e| file.end_with?(e)}
+          new_file = file.chomp('.'+fext)
+        end
+      else
+        new_file = nil
+      end
+      new_file
+    end
+
+    #
+    def extensions
+      self.class.extensions
+    end
+
+    #
+    def subtype
+      File.extname(file.chomp(type))
+    end
+
+    #
+    def to_s
+      text
+    end
+
+    # Default rendering type is +:html+. Override if it
+    # differs for the subclassing format.
+    def default
+      :html
+    end
+
+    #
+    def parse_type_and_data(type_and_data)
+      if Symbol === type_and_data.first
+        type = type_and_data.first
+        data = type_and_data.last
+      else
+        type = nil
+        data = type_and_data.first
+      end
+      return type, data
+    end
+
+  end
+
+  #
+  class UnsupportedConversion < Exception
+    def initialize(from_type, to_type)
+      @from_type = from_type
+      @to_type   = to_type
+      super()
+    end
+    def message
+      "unsupported conversion: #{@from_type} -> #{@to_type}"
+    end
+  end
+
+end
+end
+

data/lib/malt/formats/css.rb

@@ -0,0 +1,34 @@
+require 'malt/formats/abstract'
+
+module Malt::Formats
+
+  #
+  class CSS < Abstract
+
+    register('css')
+
+    #
+    def css(*)
+      text
+    end
+
+    # CSS is CSS ;)
+    def to_css(*)
+      self
+    end
+
+    private
+
+      #
+      def render_engine
+      end
+
+      # CSS default output type is itself.
+      def default
+        :css
+      end
+
+  end
+
+end
+

data/lib/malt/formats/erb.rb

@@ -0,0 +1,102 @@
+require 'malt/formats/abstract_template'
+require 'malt/formats/html'
+require 'malt/engines/erb'
+require 'malt/engines/erubis'
+
+module Malt::Formats
+
+  #
+  class Erb < AbstractTemplate
+
+    register 'erb'
+
+    # TODO: Lookup engine from engine registry.
+    def rb(*)
+      render_engine.compile(:text=>text, :file=>file)
+    end
+
+    # Erb templates can be "pre-compiled" into Ruby templates.
+    def to_rb(*)
+      text = rb
+      Ruby.new(:text=>text, :file=>refile(:rb))
+    end
+
+    #
+    alias_method(:to_ruby, :to_rb)
+
+    #
+    alias_method :precompile, :to_rb
+
+    # Technically #method_missing will pick this up, but since it is likely
+    # to be the most commonly used, adding the method directly will provide
+    # a small speed boost.
+    def html(data=nil, &yld)
+      render(:html, data, &yld)
+    end
+
+    # Technically #method_missing will pick this up, but since it is likely
+    # to be the most commonly used, adding the method directly will provide
+    # a small speed boost.
+    def to_html(data=nil, &yld)
+      new_text    = render(:html, data, &yld)
+      new_file    = refile(:html)
+      new_options = options.merge(:text=>new_text, :file=>new_file, :type=>:html)
+      HTML.new(new_options)
+    end
+
+#    #
+#    def to(type, data=nil, &yld)
+#      new_class   = Malt.registry[type.to_sym]
+#      new_text    = render(type, data, &yld)
+#      new_file    = refile(type)
+#      new_options = options.merge(:text=>new_text, :file=>new_file, :type=>type)
+#      new_class.new(new_options)
+#    end
+
+#    #
+#    def render(*type_and_data, &yld)
+#      type, data = parse_type_and_data(type_and_data)
+#      opts = options.merge(:format=>type, :text=>text, :file=>file, :data=>data)
+#      #opts = options.merge(:format=>type, :text=>text, :file=>file, :data=>data, :engine=>engine)
+#      #Malt.render(opts, &yld)
+#      #if options[:recompile]
+#        render_engine.render(opts, &yld)
+#      #else
+#      # precompile.render(type, data, &yld)
+#      #end
+#    end
+
+
+    #
+    #def to_html(db, &yld)
+    #  # unless pre-compilation is turned off, convert to ruby
+    #  return to_ruby.to_html(db, &yld) unless options[:recompile]
+    #  convert(:html, db, &yld)
+    #end
+
+    #
+    #def render_to(to, db, &yld)
+    #  #if options[:recompile]
+    #    render_engine.render(text, file, db, &yld)
+    #  #else
+    #  #  to_ruby.render(db, &yld)
+    #  #end
+    #end
+
+    private
+
+    #
+    def render_engine
+      @render_engine ||= (
+        case engine
+        when :erubis
+          Malt::Engines::Erubis.new(options)
+        else
+          Malt::Engines::Erb.new(options)
+        end
+      )
+    end
+
+  end
+
+end