malt 0.3.0 → 0.4.0

data/lib/malt/formats/builder.rb

@@ -1,36 +1,50 @@
 require 'malt/formats/abstract'
 require 'malt/formats/html'
 require 'malt/engines/builder'
+require 'malt/engines/markaby'
+require 'malt/engines/nokogiri'
+require 'malt/engines/erector'
 
 module Malt::Format
 
-  # Builder looks like a Markup format, but it is a template format
-  # as Ruby code.
+  # Builder is the format common to Builder, Markaby, Erector and Nokogiri's Builder.
+  # Although there are some variant features between them, they all support the
+  # same general format. The format looks like a Markup format, but is in fact a 
+  # templating system built out of Ruby code for creating XML/HTML documents.
   #
-  #   http://builder.rubyforge.org/
+  # @see http://builder.rubyforge.org/
+  # @see http://markaby.rubyforge.org/
+  # @see http://erector.rubyforge.org/
+  # @see http://nokogiri.org/
   #
+  # To unite these different engines I have designated them a common file 
+  # extension of `.rbml`.
+  # 
   class Builder < Abstract
 
-    register 'builder'
+    file_extension 'rbml', 'builder', 'nokogiri', 'mab', 'markaby', 'erector'
 
     #
     def builder(*)
       text
     end
+    alias_method :rbml, :builder
 
     #
     def to_builder(*)
       self
     end
+    alias_method :to_rbml, :to_builder
 
     #
-    def html(data=nil, &yld)
-      render_engine.render(:format=>:html, :text=>text, :file=>file, :data=>data, &yld)
+    def html(*data, &content)
+      #render_engine.render(:to=>:html, :text=>text, :file=>file, :data=>data, &yld)
+      render_into(:html, *data, &content)
     end
 
     #
-    def to_html(data=nil, &yld)
-      text = html(data, &yld)
+    def to_html(*data, &content)
+      text = html(*data, &content)
       opts = options.merge(:text=>text, :file=>refile(:html), :type=>:html)
       HTML.new(opts)
     end
@@ -43,12 +57,24 @@ module Malt::Format
     #  )
     #end
 
-    private
+  private
 
-      #
-      def render_engine
-        @render_engine ||= Malt::Engine::Builder.new(options)
-      end
+    # TODO: allow the type to influence the engine selection
+    #
+    #def render_engine
+    #  @render_engine ||= (
+    #    case engine
+    #    when :erector
+    #      Malt::Engine::Erector.new(options)
+    #    when :builder
+    #      Malt::Engine::Builder.new(options)
+    #    when :markaby, :mab
+    #      Malt::Engine::Markaby.new(options)
+    #    else
+    #      Malt::Engine::Nokogiri.new(options)
+    #    end
+    #  )
+    #end
 
   end
 

data/lib/malt/formats/coffee.rb

@@ -0,0 +1,54 @@
+require 'malt/formats/abstract'
+require 'malt/formats/javascript'
+require 'malt/engines/coffee'
+
+module Malt::Format
+
+  # Coffee Format
+  #
+  class Coffee < Abstract
+
+    file_extension 'coffee'
+
+    #
+    def coffee(*)
+      text
+    end
+
+    #
+    def to_coffee(*)
+      self
+    end
+
+    #
+    def javascript(*data, &content)
+      #render_engine.render(:format=>:javascript, :text=>text, :file=>file, :data=>data, :type=>type, &yielding)
+      render_into(:javascript, *data, &content)
+    end
+
+    alias :js :javascript
+
+    #
+    def to_javascript(*data, &content)
+      result = javascript(*data, &content)
+      Javascript.new(:text=>result, :file=>refile(:js), :type=>:javascript)
+    end
+
+    alias :to_js :to_javascript
+
+   private
+
+    #
+    #def render_engine
+    #  @render_engine ||= Malt::Engine::Coffee.new(options)
+    #end
+
+    # Coffee default output type is Javascript.
+    def default
+      :javascript
+    end
+
+  end
+
+end
+

data/lib/malt/formats/css.rb

@@ -5,7 +5,7 @@ module Malt::Format
   #
   class CSS < Abstract
 
-    register('css')
+    file_extension 'css'
 
     #
     def css(*)
@@ -20,8 +20,8 @@ module Malt::Format
     private
 
     #
-    def render_engine
-    end
+    #def render_engine
+    #end
 
     # CSS default output type is itself.
     def default

data/lib/malt/formats/erb.rb

@@ -8,94 +8,59 @@ module Malt::Format
   #
   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
+    file_extension 'erb'
 
     # 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)
+    #
+    def html(*data, &content)
+      render_into(:html, *data, &content)
     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)
+    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
 
-#    #
-#    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
+    # TODO: compile, if we decide to support
+=begin
+    # 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
 
     #
-    #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
+    alias_method(:to_ruby, :to_rb)
 
     #
-    #def render_to(to, db, &yld)
-    #  #if options[:recompile]
-    #    render_engine.render(text, file, db, &yld)
-    #  #else
-    #  #  to_ruby.render(db, &yld)
-    #  #end
-    #end
+    alias_method :precompile, :to_rb
+=end
 
-    private
+   #private
 
     #
-    def render_engine
-      @render_engine ||= (
-        case engine
-        when :erubis
-          Malt::Engine::Erubis.new(options)
-        else
-          Malt::Engine::Erb.new(options)
-        end
-      )
-    end
+    #def render_engine
+    #  @render_engine ||= (
+    #    case engine
+    #    when :erubis
+    #      Malt::Engine::Erubis.new(options)
+    #    else
+    #      Malt::Engine::Erb.new(options)
+    #    end
+    #  )
+    #end
 
   end
 

data/lib/malt/formats/haml.rb

@@ -21,13 +21,13 @@ module Malt::Format
     end
 
     #
-    def html(data=nil, &yld)
-      render_engine.render(:format=>:html, :text=>text, :file=>file, :data=>data, &yld)
+    def html(*data, &content)
+      render_into(:html, *data, &content)
     end
 
     #
-    def to_html(data=nil, &yld)
-      text = html(data, &yld)
+    def to_html(*data, &content)
+      text = html(*data, &content)
       opts = options.merge(:text=>text, :file=>refile(:html), :type=>:html)
       HTML.new(opts)
     end
@@ -40,12 +40,12 @@ module Malt::Format
     #  )
     #end
 
-    private
+    #private
 
       #
-      def render_engine
-        @render_engine ||= Malt::Engine::Haml.new(options)
-      end
+      #def render_engine
+      #  @render_engine ||= Malt::Engine::Haml.new(options)
+      #end
 
   end
 

data/lib/malt/formats/html.rb

@@ -5,7 +5,7 @@ module Malt::Format
   #
   class HTML < Abstract
 
-    register 'html'
+    file_extension 'html'  #, 'xhtml' ?
 
     #
     def html(*)
@@ -17,12 +17,6 @@ module Malt::Format
       self
     end
 
-    private
-
-    #
-    def render_engine
-    end
-
   end
 
 end

data/lib/malt/formats/javascript.rb

@@ -0,0 +1,27 @@
+require 'malt/formats/abstract'
+
+module Malt::Format
+
+  #
+  class Javascript < Abstract
+
+    file_extension 'js'
+
+    #
+    def js(*)
+      text
+    end
+
+    alias_method :javascript, :js
+
+    #
+    def to_js(*)
+      self
+    end
+
+    alias_method :to_javascript, :to_js
+
+  end
+
+end
+

data/lib/malt/formats/latex.rb

@@ -6,7 +6,7 @@ module Malt::Format
   #
   class Latex < Abstract
 
-    register 'latex'
+    file_extension 'latex'
 
     #
     def latex(*)

data/lib/malt/formats/less.rb

@@ -9,7 +9,7 @@ module Malt::Format
   #
   class LESS < Abstract
 
-    register('less')
+    file_extension 'less'
 
     #
     def less(*)
@@ -22,23 +22,25 @@ module Malt::Format
     end
 
     #
-    def css(*)
-      render_engine.render(:text=>text, :file=>:file, :format=>:css)
+    def css(*data, &content)
+      render_into(:css, *data, &content)
+      #opts = options.merge(:text=>text, :file=>file, :format=>:css)
+      #render_engine.render(opts)
     end
 
     #
-    def to_css(*)
-      text = css
+    def to_css(*data, &content)
+      text = css(*data, &content)
       opts = options.merge(:text=>text, :file=>refile(:css), :type=>:css)
       CSS.new(opts)
     end
 
-    private
-
-    #
-    def render_engine
-      @render_engine ||= Malt::Engine::Less.new(options)
-    end
+#  private
+#
+#    #
+#    def render_engine
+#      @render_engine ||= Malt::Engine::Less.new(options)
+#    end
 
     # LESS default output type is CSS.
     def default

data/lib/malt/formats/liquid.rb

@@ -9,7 +9,7 @@ module Malt::Format
   #
   class Liquid < AbstractTemplate
 
-    register('liquid')
+    file_extension 'liquid'
 
     #
     def liquid(*)
@@ -50,12 +50,12 @@ module Malt::Format
 #      super(sym, *args, &yld)
 #    end
 
-    private
-
-      #
-      def render_engine
-        @render_engine ||= Malt::Engine::Liquid.new(options)
-      end
+#    private
+#
+#      #
+#      def render_engine
+#        @render_engine ||= Malt::Engine::Liquid.new(options)
+#      end
 
   end