malt 0.3.0 → 0.4.0

data/lib/malt/engines/string.rb

@@ -0,0 +1,36 @@
+require 'malt/engines/abstract'
+
+module Malt::Engine
+
+  # Ruby strings as template engine.
+  #
+  # @see http://ruby-lang.org
+  #
+  class String < Abstract
+
+    default :str
+
+    #
+    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(params)
+      text = parameters(params, :text)
+      "%{#{text}}"
+    end
+
+  private
+
+    #
+    def require_engine
+    end
+
+  end
+
+end
+

data/lib/malt/engines/tenjin.rb

@@ -4,55 +4,98 @@ module Malt::Engine
 
   # Tenjin
   #
-  #   http://www.kuwata-lab.com/tenjin/
+  # @see http://www.kuwata-lab.com/tenjin/
   #
-  # options
-  #   :escapefunc=>'CGI.escapeHTML'
+  # Let to it's own designs, Tenjin renders data as template instance variables.
+  # But that will not work for Malt, so use regular variables instead.
   #
   class Tenjin < Abstract
 
     default :tenjin, :rbhtml
 
+    # Render Tenjin.
     #
-    def render(params, &yld)
-      text = params[:text]
-      file = params[:file]
-      data = params[:data]
-      type = params[:type]
-      into = params[:to] || :html
+    # @option params [String] :escapefunc
+    #   Defaults to 'CGI.escapeHTML'.
+    #
+    def render(params, &content)
+      into, text, file, type, scope, locals = parameters(params, :to, :text, :file, :type, :scope, :locals)
+
+      into ||= :html
 
-      return super(params, &yld) if type == :rbhtml && into != :html
+      if type == :rbhtml && into != :html
+        super(params, &content) 
+      else
+        scope, locals = make_ready(scope, locals, &content)
 
-      data = make_hash(data, &yld)
-      template = intermediate(params)
-      template.convert(text, file)
+        engine = prepare_engine(params)
 
-      template.render(data)
+        engine.call(scope, locals)
+      end
     end
 
+    # TODO: is there a way to split this out to a #compile method?
+
     #
-    def compile(params)
-      text = params[:text]
-      file = params[:file]
-      intermediate(params).convert(text, file) 
+    def prepare_engine(params={}, &content)
+      text, file = parameters(params, :text, :file)
+
+      file ||= "(tenjin)"
+
+      engine = create_engine(params)
+      script = engine.convert(text, file)
+
+      lambda do |scope, locals|
+        vars, vals = [], []
+        locals.each do |k,v|
+          vars << k
+          vals << v
+        end
+
+        code = %{
+          lambda do |#{vars.join(',')}|
+            _buf = ''
+            #{script}
+            _buf
+          end
+        }
+
+        eval(code, scope.to_binding, file, 2).call(*vals)
+      end
     end
 
-    private
+    #
+    def create_engine(params={})
+      file, text = parameters(params, :file, :text)
+
+      opts = engine_options(params)
+
+      opts[:escapefunc] ||= 'CGI.escapeHTML'
 
-    def intermediate(params)
-      ::Tenjin::Template.new(nil, engine_options(params))
+      cached(text, file, opts) do
+        ::Tenjin::Template.new(nil, opts)
+      end
     end
 
-    # Load Liquid library if not already loaded.
-    def initialize_engine
+    # Compile Tenjin document into Ruby source code.
+    #def compile(params)
+    #  text, file = parameters(params, :text, :file)
+    #  code = intermediate(params).convert(text, file)
+    #  "_buf = ''\n#{code}\n_buf"
+    #end
+
+  private
+
+    # Load Tenjin library if not already loaded.
+    def require_engine
       return if defined? ::Tenjin::Engine
       require_library 'tenjin'
+      require 'cgi'
     end
 
-    def engine_options(params)
-      opts = {}
-      opts[:escapefunc] = params[:escapefunc] || settings[:escapefunc]
-      opts
+    #
+    def engine_option_names
+      [:escapefunc]
     end
 
   end

data/lib/malt/engines/wikicloth.rb

@@ -0,0 +1,48 @@
+require 'malt/engines/abstract'
+
+module Malt::Engine
+
+  # WikiCloth is a MediaWiki format for Ruby. Unlike Creole, WikiCloth
+  # also supports variable interpolation.
+  #
+  #@see http://code.google.com/p/wikicloth/
+
+  class WikiCloth < Abstract
+
+    default :wiki, :mediawiki, :mw
+
+    #
+    def render(params={}, &content)
+      scope, locals = parameters(params, :scope, :locals)
+
+      data = make_hash(scope, locals, &content)
+
+      case params[:to]
+      when :html, nil
+        prepare_engine(params).to_html(:params => data)
+      else
+        super(params)
+      end
+    end
+
+    #
+    def create_engine(params={})
+      text = parameters(params, :text)
+
+      cached(text) do
+        ::WikiCloth::WikiCloth.new(:data => text)
+      end
+    end
+
+    private
+
+    # Load `wikicloth` library if not already loaded.
+    def require_engine
+      return if defined? ::WikiCloth
+      require_library 'wikicloth'
+    end
+
+  end
+
+end
+

data/lib/malt/formats/abstract.rb

@@ -27,8 +27,8 @@ module Format
     include Malt::Kernel
 
     # Register the class to an extension type.
-    def self.register(*exts)
-      @extensions = exts
+    def self.file_extension(*exts)
+      @file_extensions = exts
       Malt::Format.register(self, *exts)
 
       #exts.each do |ext|
@@ -40,9 +40,14 @@ module Format
       #end
     end
 
+    # @deprecated
+    def self.register(*exts)
+      self.file_extension(*exts)
+    end
+
     #
     def self.extensions
-      @extensions
+      @file_extensions
     end
 
     #--
@@ -53,37 +58,47 @@ module Format
       @engine
     end
 
-    private
+   private
 
     #
     def initialize(options={})
       @options = options.rekey
-      @type    = @options[:type]
-      initialize_engine
-    end
 
-    # Override this method to load rendering engine library.
-    def initialize_engine
+      @file = @options[:file]
+      @text = @options[:text] || file_read(@file)
+      @type = @options[:type] || file_type(@file)
     end
 
-    public
+   public
 
     # Access to the options given to the initializer.
     attr :options
 
+    # Change options on the fly.
+    def with(options={})
+      alt = dup
+      alt.with!(options)
+    end
+
+    # Change options in-place.
+    def with!(options)
+      @options.update(options.rekey)
+      self
+    end
+
     # Document source text.
     def text
-      @text ||= options[:text] || File.read(file)
+      @text
     end
 
     # File name of document.
     def file
-      @file ||= options[:file].to_s
+      @file
     end
 
     # File extension (with prefixed dot).
     def type
-      @type ||= File.extname(file)
+      @type
     end
 
     # Specified engine to use for rendering.
@@ -95,25 +110,37 @@ module Format
     end
 
     #
-    def to(type, data=nil, &yld)
-      __send__("to_#{type}", data, &yld)
+    def to(type, *data, &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.
+    # it is taken to be the data for rendering template variables.
     def render(*type_and_data, &yld)
-      type, data = parse_type_and_data(type_and_data)
+      type, data = parse_type_from_data(*type_and_data)
       meth = method(type || default)
       #__send__(type || default, data, &yld)
-      meth.arity == 0 ?  meth.call(&yld) :  meth.call(data, &yld)
+      meth.arity == 0 ?  meth.call(&yld) :  meth.call(*data, &yld)
     end
 
     #
-    #def render_to(format, db=nil, &yld)
-    #  render_engine.render(format, text, file, db, &yld)
-    #end
+    def render_into(into, *data, &content)
+      parameters = rendering_parameters(into, data)
+      Malt.render(parameters, &content)
+    end
+
+    #
+    def rendering_parameters(into, data)
+      opts = options.merge(
+        :to     => into,
+        :data   => data,
+        :text   => text,
+        :file   => file,
+        :engine => engine
+      )
+    end
 
     #
 #    def method_missing(s, *a, &b)
@@ -152,7 +179,7 @@ module Format
         if type
           type = type.to_s.sub(/^\./,'')
           fext = self.class.extensions.find{|e| file.end_with?(e)}
-          new_file = file.chomp(fext) + type
+          new_file = file.chomp(fext) + '.' + type
         else
           fext = self.class.extensions.find{|e| file.end_with?(e)}
           new_file = file.chomp('.'+fext)
@@ -179,8 +206,8 @@ module Format
     end
 
     #
-    def to_default(data=nil, &yld)
-      to(default, data, &yld)
+    def to_default(*data, &yld)
+      to(default, *data, &yld)
     end
 
     # Default rendering type is +:html+. Override if it
@@ -190,17 +217,51 @@ module Format
     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
+    def parse_type_from_data(*data)
+      if Symbol === data.first
+        type = data.shift
       else
         type = nil
-        data = type_and_data.first
       end
       return type, data
     end
 
+    ##
+    #def parse_type_scope_data(*data)
+    #  if Symbol === data.first
+    #    type = data.shift
+    #  else
+    #    type = nil
+    #  end
+    #  scope, data = scope_vs_data(*data)
+    #  return type, scope, data
+    #end
+
+    # @deprecate
+    def scope_vs_data(scope, data=nil)
+      if scope && !data
+        if scope.respond_to?(:to_hash)
+          data  = scope
+          scope = nil
+        end
+      end
+      return scope, data
+    end
+
+    #
+    def file_read(file)
+      File.read(file)
+    end
+
+    #
+    def file_type(file)
+      if file
+        File.extname(file)
+      else
+        nil
+      end
+    end
+
   end
 
   # TODO: Is this needed anymore, if so where?

data/lib/malt/formats/abstract_template.rb

@@ -9,19 +9,21 @@ module Format
   class AbstractTemplate < Abstract
 
     #
-    def to(type, data=nil, &yld)
+    def to(type, *data, &yld)
       new_class   = Malt::Format.registry[type.to_sym]  # TODO: Malt.machine.format?
-      new_text    = render(type, data, &yld)
+      new_text    = render_into(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)
-      render_engine.render(opts, &yld)
+    def render(*type_and_data, &content)
+      type, data = parse_type_from_data(*type_and_data)
+      #opts = options.merge(:to=>type, :text=>text, :file=>file, :data=>data)
+      render_into(type, *data, &content)
+
+      #render_engine.render(opts, &yld)
       #opts = options.merge(:format=>type, :text=>text, :file=>file, :data=>data, :engine=>engine)
       #Malt.render(opts, &yld)
     end
@@ -29,7 +31,7 @@ module Format
     # ERB templates can be any type.
     def method_missing(sym, *args, &yld)
       if Malt::Format.registry.key?(sym)  # TODO: Malt.machine.format?
-        return render(sym, *args, &yld).to_s
+        return render_into(sym, *args, &yld) #.to_s
       elsif md = /^to_/.match(sym.to_s)
         type = md.post_match.to_sym
         if Malt::Format.registry.key?(type)  # TODO: Malt.machine.format?