malt 0.3.0 → 0.4.0

data/lib/malt/formats/ruby.rb

@@ -1,70 +1,36 @@
 require 'malt/formats/abstract'
-require 'malt/formats/html'
 require 'malt/engines/erb'
 
 module Malt::Format
 
   # Yes, pure Ruby as a template format.
   #
-  # The ruby code is run through eval and whatever is returned is given
+  # The ruby code is run through eval and whatever it returns 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.
+  # In the future, the Ruby type might also used for "precompiling" other
+  # formats such as ERB.
   #
-  class Ruby < Abstract
+  class Ruby < AbstractTemplate
 
-    register 'rb'
+    file_extension '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::Format.registry[type.to_sym]  # TODO: Malt.machine.format?
-      new_text    = render(data, &yld)
-      new_file    = refile(type)
-      new_options = options.merge(:text=>new_text, :file=>new_file)
-      new_class.new(new_options)
+    def rb(*)
+      text
     end
 
-    # Ruby templates can be any type.
-    def method_missing(sym, *args, &yld)
-      if Malt::Format.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::Format.registry.key?(type)  # TODO: Malt.machine.format?
-          return to(type, *args, &yld)
-        end
-      end
-      super(sym, *args, &yld)
-    end
+    alias_method :ruby, :rb
 
     #
-    #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)
+    def to_rb(*)
+      self
     end
 
-    private
-
-    #
-    def render_engine
-      @render_engine ||= Malt::Engine::Ruby.new(options)
-    end
+    alias_method :to_ruby, :to_rb
 
   end
 

data/lib/malt/formats/sass.rb

@@ -6,9 +6,10 @@ module Malt::Format
 
   # Sass Format
   #
+  #
   class Sass < Abstract
 
-    register 'sass'
+    file_extension 'sass'
 
     #
     def sass(*)
@@ -21,13 +22,14 @@ module Malt::Format
     end
 
     #
-    def css(data=nil, &yld)
-      render_engine.render(:format=>:css, :text=>text, :file=>file, :type=>type)
+    def css(*data, &content)
+      render_into(:css, *data, &content)
+      #render_engine.render(:format=>:css, :text=>text, :file=>file, :data=>data, :type=>type, &yld)
     end
 
     #
-    def to_css(data=nil, &yld)
-      result = css(data, &yld)
+    def to_css(*data, &content)
+      result = css(*data, &content)
       CSS.new(:text=>result, :file=>refile(:css), :type=>:css)
     end
 
@@ -38,27 +40,17 @@ module Malt::Format
     #  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
+   private
 
-      #
-      def render_engine
-        @render_engine ||= Malt::Engine::Sass.new(options)
-      end
+    ##
+    #def render_engine
+    #  @render_engine ||= Malt::Engine::Sass.new(options)
+    #end
 
-      # Sass default output type is CSS.
-      def default
-        :css
-      end
+    # Sass default output type is CSS.
+    def default
+      :css
+    end
 
   end
 

data/lib/malt/formats/scss.rb

@@ -9,7 +9,7 @@ module Malt::Format
   # This uses the same engine as Sass.
   class SCSS < Abstract
 
-    register 'scss'
+    file_extension 'scss'
 
     #
     def scss(*)
@@ -22,44 +22,27 @@ module Malt::Format
     end
 
     #
-    def css(data=nil, &yld)
-      render_engine.render(:format=>:css, :text=>text, :file=>file, :type=>type)
+    def css(*data, &content)
+      render_into(:css, *data, &content)
     end
 
     #
-    def to_css(data=nil, &yld)
-      result = css(data, &yld)
+    def to_css(*data, &content)
+      result = css(*data, &content)
       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
+   private
 
-    #
-    #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
+    ##
+    #def render_engine
+    #  @render_engine ||= Malt::Engine::Sass.new(options)
     #end
 
-    private
-
-      #
-      def render_engine
-        @render_engine ||= Malt::Engine::Sass.new(options)
-      end
-
-      # Sass default output type is CSS.
-      def default
-        :css
-      end
+    # Sass default output type is CSS.
+    def default
+      :css
+    end
 
   end
 

data/lib/malt/formats/string.rb

@@ -0,0 +1,61 @@
+require 'malt/formats/abstract'
+require 'malt/formats/html'
+require 'malt/engines/erb'
+
+module Malt::Format
+
+  # 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 String < AbstractTemplate
+
+    file_extension 'str'
+
+    #
+    def string(*) ; text ; end
+
+    #
+    def to_string(*) ; self ; end
+
+=begin
+    #
+    def to(type, *data, &yld)
+      new_class   = Malt::Format.registry[type.to_sym]  # TODO: Malt.machine.format?
+      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
+=end
+
+#    # Ruby templates can be any type.
+#    def method_missing(sym, *args, &yld)
+#      if Malt::Format.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::Format.registry.key?(type)  # TODO: Malt.machine.format?
+#          return to(type, *args, &yld)
+#        end
+#      end
+#      super(sym, *args, &yld)
+#    end
+
+    #private
+
+    ##
+    #def render_engine
+    #  @render_engine ||= Malt::Engine::String.new(options)
+    #end
+
+  end
+
+end

data/lib/malt/formats/tenjin.rb

@@ -25,13 +25,13 @@ module Malt::Format
     alias_method(:to_ruby, :to_rb)
 
     #
-    def html(data=nil, &yld)
-      render(:html, data, &yld)
+    def html(*data, &content)
+      render_into(:html, *data, &content)
     end
 
     #
-    def to_html(data=nil, &yld)
-      new_text    = render(:html, data, &yld)
+    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)

data/lib/malt/formats/text.rb

@@ -11,7 +11,7 @@ module Malt::Format
   #
   class Text < Abstract
 
-    register('txt')
+    file_extension 'txt'
 
     #
     def txt(*)

data/lib/malt/formats/textile.rb

@@ -6,7 +6,7 @@ module Malt::Format
   #
   class Textile < Abstract
 
-    register('textile', 'tt')
+    file_extension 'textile', 'tt'
 
     #
     def textile(*)
@@ -24,8 +24,8 @@ module Malt::Format
     alias_method :to_tt, :to_textile
 
     #
-    def html(*)
-      render_engine.render(:format=>:html, :text=>text, :file=>file)
+    def html(*data, &content)
+      render_into(:html, *data, &content)
     end
 
     #
@@ -34,25 +34,13 @@ module Malt::Format
       HTML.new(opts)
     end
 
+    #private
     #
-    #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
+    ##
+    #def render_engine
+    #  @render_engine ||= Malt::Engine::RedCloth.new(options)
     #end
 
-    private
-
-      #
-      def render_engine
-        @render_engine ||= Malt::Engine::RedCloth.new(options)
-      end
-
   end
 
 end

data/lib/malt/kernel.rb

@@ -1,7 +1,6 @@
-require 'malt/core_ext'
-
 module Malt
 
+  # Common methods that can be used through-out Malt classes.
   module Kernel
     private
 

data/lib/malt/machine.rb

@@ -5,19 +5,19 @@ module Malt
   # which engines and formats are used for rendering.
   #--
   # TODO: Can we dynamically generate the MARKUP and TEMPLATE constants
-  # from the format classes? In anycase, the still need tweaking.
+  # from the format classes? In anycase, the still needs tweaking.
   #++
   class Machine
 
     # List of markup types. These are formats that just allow markup transformations
     # and do not provide for data injection.
-    MARKUP = [:rdoc, :markdown, :textile, :scss, :sass, :less, :css, :html, :xml]
+    MARKUP = [:rdoc, :markdown, :textile, :scss, :sass, :less, :css, :html, :xml, :wikicloth]
 
     # List of template types. These are template formats that provide data injection.
-    TEMPLATES = [:ruby, :erb, :liquid, :mustache, :tenjin, :ragtag, :radius, :erector, :builder, :markaby]
+    TEMPLATE = [:erb, :liquid, :mustache, :tenjin, :ragtag, :radius, :erector, :builder, :ruby, :string]
 
     # Template types that prevent arbitrary Ruby code execution.
-    TEMPLATES_SAFE = [:liquid, :mustache]
+    TEMPLATE_SAFE = [:liquid, :mustache]
 
     # New Malt Machine.
     #
@@ -26,7 +26,7 @@ module Malt
     #
     def initialize(config={})
       if priority = config[:priority]
-        priority.map!{ |e| e.to_sym }
+        priority = priority.map{ |e| e.to_sym }
       else
         priority = []
       end
@@ -68,6 +68,7 @@ module Malt
       end
       @priority
     end
+    alias_method :prefer, :priority
 
     #
     def engine?(ext)
@@ -92,7 +93,7 @@ module Malt
       type = options[:type] || options[:format] || File.extname(file)
       type = ext_to_type(type)
       malt_class = formats[type]
-      raise "unkown type -- #{type}" unless malt_class
+      raise "unknown type -- #{type}" unless malt_class
       malt_class.new(options.merge(:file=>file,:type=>type))
     end
 
@@ -110,11 +111,14 @@ module Malt
     end
 
     # Open a URL as a Malt Format object.
+    #
+    # @return [Malt::Format]
     def open(url, options={})
       require 'open-uri'
       text = open(url).read
       file = File.basename(url) # parse better with URI.parse
-      text(text, :file=>file)
+      options[:file] = file
+      text(text, options)
     end
 
     # Render template directly.
@@ -126,14 +130,67 @@ module Malt
     # parameters[:engine] - Force the use of a this specific engine.
     # parameters[:to]     - Format to convert to (usual default is `html`).
     #
-    def render(parameters={}, &body)
+    def render(parameters={}, &content)
+      parameters = normalize_parameters(parameters)
+
+      if parameters[:multi]
+        multi_render(parameters, &content)
+      else
+        single_render(parameters, &content)
+      end
+    end
+
+  private
+
+    # Normalize parameters.
+    def normalize_parameters(parameters)
+      params = parameters.rekey
+
+      if data = params.delete(:data)
+        scope, locals = split_data(data)
+        params[:scope]  ||= scope
+        params[:locals] ||= locals
+      end
+
+      file = params[:file]
+      text = params[:text]
+
+      unless text
+        params[:text] = file_read(file)
+      end
+
+      params
+    end
+
+    #
+    def multi_render(parameters={}, &content)
+      type = parameters[:type]
+      #file = parameters[:file]
+      text = parameters[:text]
+
+      if type = parameters[:type]
+        types = [type].flatten
+      else
+        types = file.split('.')[1..-1]
+      end
+
+      types.reverse_each do |t|
+        parameters[:type] = t
+        parameters[:text] = single_render(parameters, &content)
+      end
+
+      parameters[:text]
+    end
+
+    #
+    def single_render(parameters={}, &content)
       type   = parameters[:type]
       file   = parameters[:file]
       text   = parameters[:text]
       engine = parameters[:engine]
 
       type   = file_type(file, type)
-      text   = file_read(file) unless text
+      #text   = file_read(file) unless text
 
       engine_class = engine(type, engine)
 
@@ -142,22 +199,22 @@ module Malt
         parameters[:text] = text
 
         engine = engine_class.new
-        engine.render(parameters, &body)
+
+        engine.render(parameters, &content)
       else
         if parameters[:pass]
           text
         else
           raise NoEngineError, "no engine to handle `#{type}' format"      
         end
-      end
+      end     
     end
 
-    private
-
     #
     def engine(type, engine=nil)
       type = ext_to_type(type)
       #engine = engine || Malt.config.engine[type]  # FIXME
+
       case engine
       when Class
         #raise unless Engine.registry[type].include?(engine)
@@ -218,6 +275,19 @@ module Malt
       end
     end
 
+    # Unlike +#scope_and_locals+, this method returns +nil+ for missing
+    # scope or locals.
+    #
+    def split_data(data)
+      scope, locals = *[data].flatten
+      if scope.respond_to?(:to_hash)
+        locals ||= {}
+        locals = locals.merge(scope.to_hash)
+        scope  = nil
+      end
+      return scope, locals
+    end
+
   end
 
   #