malt 0.1.0

data/lib/malt/formats/ruby.rb

@@ -0,0 +1,71 @@
+require 'malt/formats/abstract'
+require 'malt/formats/html'
+require 'malt/engines/erb'
+
+module Malt::Formats
+
+  # Yes, pure Ruby as a template format.
+  #
+  # The ruby code is run through eval and whatever is returned is given
+  # as the rendering.
+  #
+  # The Ruby format is a *polyglot* format --it accepts all conversion
+  # types and assumes the end-user knows it will be the result.
+  #
+  # The Ruby type is also used for "precompiling" other formats such
+  # as ERB.
+  #
+  class Ruby < Abstract
+
+    register 'rb'
+
+    #
+    def rb ; text ; end
+    alias_method :ruby, :rb
+
+    #
+    def to_rb ; self ; end
+    alias_method :to_ruby, :to_rb
+
+    #
+    def to(type, data=nil, &yld)
+      new_class   = Malt.registry[type.to_sym]
+      new_text    = render(data, &yld)
+      new_file    = refile(type)
+      new_options = options.merge(:text=>new_text, :file=>new_file)
+      new_class.new(new_options)
+    end
+
+    # Ruby templates can be any type.
+    def method_missing(sym, *args, &yld)
+      if Malt.registry.key?(sym)
+        return to(sym, *args, &yld).to_s
+      elsif md = /^to_/.match(sym.to_s)
+        type = md.post_match.to_sym
+        if Malt.registry.key?(type)
+          return to(type, *args, &yld)
+        end
+      end
+      super(sym, *args, &yld)
+    end
+
+    #
+    #def render_to(to, db, &yld)
+    #  malt_engine.render(text, file, db, &yld)
+    #end
+
+    def render(*type_and_data, &yld)
+      type, data = parse_type_and_data(type_and_data)
+      render_engine.render(:text=>text, :file=>file, :data=>data, &yld)
+    end
+
+    private
+
+    #
+    def render_engine
+      @render_engine ||= Malt::Engines::Ruby.new(options)
+    end
+
+  end
+
+end

data/lib/malt/formats/sass.rb

@@ -0,0 +1,56 @@
+require 'malt/formats/abstract'
+require 'malt/formats/css'
+require 'malt/engines/sass'
+
+module Malt::Formats
+
+  # Sass Format
+  #
+  class Sass < Abstract
+
+    register 'sass'
+
+    #
+    def css(data=nil, &yld)
+      render_engine.render(:format=>:css, :text=>text, :file=>file, :type=>type)
+    end
+
+    #
+    def to_css(data=nil, &yld)
+      result = css(data, &yld)
+      CSS.new(:text=>result, :file=>refile(:css), :type=>:css)
+    end
+
+    #
+    #def compile(db, &yld)
+    #  result = render_engine.render(text, db, &yld)
+    #  opts = options.merge(:text=>result, file=>refile(:css))
+    #  CSS.new(opts)
+    #end
+
+    #
+    #def render_to(to, db, &yld)
+    #  case to
+    #  when :css
+    #    malt_engine.render_css(text, file, db, &yld)
+    #  else
+    #    raise UnspportedConversion.new(type, to)
+    #  end
+    #end
+
+    private
+
+      #
+      def render_engine
+        @render_engine ||= Malt::Engines::Sass.new(options)
+      end
+
+      # Sass default output type is CSS.
+      def default
+        :css
+      end
+
+  end
+
+end
+

data/lib/malt/formats/tenjin.rb

@@ -0,0 +1,50 @@
+require 'malt/formats/abstract_template'
+require 'malt/formats/html'
+require 'malt/engines/tenjin'
+
+module Malt::Formats
+
+  # Tenjin
+  #
+  #   http://www.kuwata-lab.com/tenjin/
+  #
+  class Tenjin < AbstractTemplate
+
+    register 'tenjin'
+
+    def rb
+      render_engine.compile(text, file)
+    end
+
+    # Erb templates can be "precompiled" into Ruby templates.
+    def to_rb
+      text = rb
+      Ruby.new(:text=>text, :file=>refile(:rb), :type=>:rb)
+    end
+
+    alias_method(:to_ruby, :to_rb)
+
+    #
+    def html
+      render(:html, data, &yld)
+    end
+
+    #
+    def to_html(data, &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
+
+    private
+
+    #
+    def render_engine
+      @render_engine ||= Malt::Engines::Tenjin.new(options)
+    end
+
+  end
+
+end
+

data/lib/malt/formats/text.rb

@@ -0,0 +1,54 @@
+require 'malt/formats/abstract'
+require 'malt/formats/html'
+require 'malt/formats/pdf'
+
+module Malt::Formats
+
+  # Plain text format. Plain text documents are uniqu in that they can
+  # be transformed into any other type of document. For example, applying
+  # to_html in text doesn't actually transform the source text in any way.
+  # Rather it simply "informs" Malt to treat the text as HTML.
+  #
+  class Text < Abstract
+
+    register('txt')
+
+    #
+    def txt(*)
+      text
+    end
+
+    #
+    def to_txt(*)
+      self
+    end
+
+    #
+    def method_missing(sym, *args, &block)
+      if md = /^to_/.match(sym.to_s)
+        type = md.post_match.to_sym
+        opts = options.merge(:type=>type, :file=>refile(type))
+        return Malt.text(text, opts)
+      end
+      super(sym, *args, &block)
+    end
+
+    # Returns an HTML object.
+    #def to_html
+    #  HTML.new(:text=>text,:file=>refile(:html))
+    #end
+
+    # Returns a PDF object.
+    #def to_pdf
+    #  PDF.new(:text=>text,:file=>refile(:pdf))
+    #end
+
+    private
+
+      def render_engine
+      end
+
+  end
+
+end
+

data/lib/malt/formats/textile.rb

@@ -0,0 +1,59 @@
+require 'malt/formats/abstract'
+require 'malt/engines/redcloth'
+
+module Malt::Formats
+ 
+  #
+  class Textile < Abstract
+
+    register('textile', 'tt')
+
+    #
+    def html
+      render_engine.render(:format=>:html, :text=>text, :file=>file)
+    end
+
+    #
+    def textile
+      text
+    end
+
+    #
+    alias_method :tt, :textile
+
+    #
+    def to_html
+      opts = options.merge(:text=>html, :file=>refile(:html), :type=>:html)
+      HTML.new(opts)
+    end
+
+    #
+    def to_textile
+      self
+    end
+
+    alias_method :to_tt, :to_textile
+
+    #
+    #def render_to(to, *)
+    #  case to
+    #  when :textile, :tt
+    #    self
+    #  when :html
+    #    malt_engine.render_html(text, file)
+    #  else
+    #    raise "can't render textile to #{to} type" #?
+    #  end
+    #end
+
+    private
+
+      #
+      def render_engine
+        @render_engine ||= Malt::Engines::RedCloth.new(options)
+      end
+
+  end
+
+end
+

data/lib/malt/formats/yaml.rb

@@ -0,0 +1,50 @@
+require 'malt/formats/abstract'
+require 'malt/formats/html'
+
+module Malt::Formats
+
+  # = YAML format
+  #
+  # TODO: hmm... maybe use data to update yaml?
+  class YAML < Abstract
+
+    register 'yaml', 'yml'
+
+    #
+    def yaml(*)
+      text
+    end
+
+    alias_method :yml, :yaml
+
+    #
+    def to_yaml(*)
+      self
+    end
+
+    alias_method :to_yml, :to_yaml
+
+    # Converting a plan YAML file to HTML makes no sense so we
+    # just wrap it in +pre+ tags.
+    def html
+      "<pre>\n#{h text}\n</pre>"
+    end
+
+    #
+    def to_html
+      text = html
+      opts = options.merge(:text=>text, :file=>refile(:html), :type=>:html)
+      HTML.new(opts)
+    end
+
+    private
+
+      # TODO: HTML escaping
+      def h(text)
+        text
+      end
+
+  end
+
+end
+

data/lib/malt/kernel.rb

@@ -0,0 +1,31 @@
+require 'malt/core_ext'
+
+module Malt
+
+  module Kernel
+    private
+
+    #
+    def make_ostruct(hash)
+      case hash
+      when OpenStruct
+        hash
+      else
+        OpenStruct.new(hash)
+      end
+    end
+
+    #
+    def ext_to_type(ext)
+      ext = ext.to_s.downcase
+      return nil if ext.empty?
+      if ext[0,1] == '.'
+        ext[1..-1].to_sym
+      else
+        ext.to_sym
+      end
+    end
+
+  end
+
+end

data/lib/malt/meta/data.rb

@@ -0,0 +1,26 @@
+Object.__send__(:remove_const, :VERSION) if Object.const_defined?(:VERSION)      # becuase Ruby 1.8~ gets in the way
+
+module Malt
+
+  DIRECTORY = File.dirname(__FILE__)
+
+  def self.gemfile
+    @gemfile ||= (
+      require 'yaml'
+      YAML.load(File.new(DIRECTORY + '/gemfile'))
+    )
+  end
+
+  def self.profile
+    @profile ||= (
+      require 'yaml'
+      YAML.load(File.new(DIRECTORY + '/profile'))
+    )
+  end
+
+  def self.const_missing(name)
+    key = name.to_s.downcase
+    gemfile[key] || profile[key] || super(name)
+  end
+
+end

data/lib/malt/meta/gemfile

@@ -0,0 +1,17 @@
+name    : malt
+date    : 2010-09-07
+version : 0.1.0
+
+requires:
+  - syckle   (build)
+  - qed       (test)
+  - rdoc      (test)
+  - redcloth  (test)
+  - bluecloth (test)
+  - kramdown  (test)
+  - haml      (test)
+  - tenjin    (test)
+  - rtals     (test)
+  - liquid    (test)
+  - erubis    (test)
+

data/lib/malt/meta/profile

@@ -0,0 +1,21 @@
+title  : Malt
+summary: Multi-template/multi-markup rendering engine
+contact: trans <transfire@gmail.com>
+created: 2010-06-22
+
+authors:
+  - Thomas Sawyer
+
+description:
+  Malt provides a factory framework for rendering
+  a variety of template and markup document formats.
+
+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
+
+copyright:
+  Copyright (c) 2010 Thomas Sawyer