temple 0.1.3 → 0.1.4

data/lib/temple/filters/escape_html.rb

@@ -0,0 +1,27 @@
+module Temple
+  module Filters
+    class EscapeHTML < Filter
+      temple_dispatch :escape, :html
+
+      def on_escape_static(value)
+        [:static, options[:user_html_safe] ? escape_html_safe(value) : escape_html(value)]
+      end
+
+      def on_escape_dynamic(value)
+        [:dynamic, "Temple::Utils.escape_html#{options[:use_html_safe] ? '_safe' : ''}((#{value}))"]
+      end
+
+      def on_html_staticattrs(*attrs)
+        [:html, :staticattrs, *attrs.map {|k,v| [k, compile!(v)] }]
+      end
+
+      def on_html_comment(content)
+        [:html, :comment, compile!(content)]
+      end
+
+      def on_html_tag(name, attrs, closed, content)
+        [:html, :tag, name, compile!(attrs), closed, compile!(content)]
+      end
+    end
+  end
+end

data/lib/temple/filters/multi_flattener.rb

@@ -1,28 +1,20 @@
 module Temple
   module Filters
-    class MultiFlattener
-      def initialize(options = {})
-        @options = {}
-      end
-
-      def compile(exp)
-        exp.first == :multi ? on_multi(*exp[1..-1]) : exp
-      end
-      
+    class MultiFlattener < Filter
       def on_multi(*exps)
         # If the multi contains a single element, just return the element
-        return compile(exps.first) if exps.length == 1
+        return compile!(exps.first) if exps.length == 1
         result = [:multi]
-        
+
         exps.each do |exp|
-          exp = compile(exp)
+          exp = compile!(exp)
           if exp.first == :multi
             result.concat(exp[1..-1])
           else
             result << exp
           end
         end
-        
+
         result
       end
     end

data/lib/temple/filters/static_merger.rb

@@ -7,23 +7,15 @@ module Temple
     #     [:static, "World!"]]
     #
     # Compiles to:
-    # 
+    #
     #   [:multi,
     #     [:static, "Hello World!"]]
-    class StaticMerger
-      def initialize(options = {})
-        @options = {}
-      end
-      
-      def compile(exp)
-        exp.first == :multi ? on_multi(*exp[1..-1]) : exp
-      end
-
+    class StaticMerger < Filter
       def on_multi(*exps)
         res = [:multi]
         curr = nil
         state = :looking
-        
+
         exps.each do |exp|
           if exp.first == :static
             if state == :looking
@@ -33,13 +25,13 @@ module Temple
               curr << exp[1]
             end
           else
-            res << compile(exp)
+            res << compile!(exp)
             state = :looking unless exp.first == :newline
           end
         end
-        
+
         res
       end
     end
   end
-end
+end

data/lib/temple/{core.rb → generators.rb}

@@ -1,65 +1,65 @@
 module Temple
   # == The Core Abstraction
-  #            
+  #
   # The core abstraction is what every template evetually should be compiled
   # to. Currently it consists of four essential and two convenient types:
   # multi, static, dynamic, block, newline and capture.
-  #          
+  #
   # When compiling, there's two different strings we'll have to think about.
   # First we have the generated code. This is what your engine (from Temple's
   # point of view) spits out. If you construct this carefully enough, you can
   # make exceptions report correct line numbers, which is very convenient.
-  #        
+  #
   # Then there's the result. This is what your engine (from the user's point
   # of view) spits out. It's what happens if you evaluate the generated code.
-  #            
+  #
   # === [:multi, *sexp]
-  #            
+  #
   # Multi is what glues everything together. It's simply a sexp which combines
   # several others sexps:
-  #            
+  #
   #   [:multi,
   #     [:static, "Hello "],
   #     [:dynamic, "@world"]]
-  #            
+  #
   # === [:static, string]
-  #            
+  #
   # Static indicates that the given string should be appended to the result.
-  #       
+  #
   # Example:
-  #       
+  #
   #   [:static, "Hello World"]
   #   # is the same as:
   #   _buf << "Hello World"
-  #         
+  #
   #   [:static, "Hello \n World"]
   #   # is the same as
   #   _buf << "Hello\nWorld"
-  #       
+  #
   # === [:dynamic, ruby]
-  #      
+  #
   # Dynamic indicates that the given Ruby code should be evaluated and then
   # appended to the result.
-  #     
+  #
   # The Ruby code must be a complete expression in the sense that you can pass
   # it to eval() and it would not raise SyntaxError.
-  #      
+  #
   # === [:block, ruby]
-  #     
+  #
   # Block indicates that the given Ruby code should be evaluated, and may
   # change the control flow. Any \n causes a newline in the generated code.
-  #     
+  #
   # === [:newline]
-  #   
+  #
   # Newline causes a newline in the generated code, but not in the result.
-  #   
+  #
   # === [:capture, variable_name, sexp]
-  #  
+  #
   # Evaluates the Sexp using the rules above, but instead of appending to the
   # result, it sets the content to the variable given.
-  # 
+  #
   # Example:
-  # 
+  #
   #   [:multi,
   #     [:static, "Some content"],
   #     [:capture, "foo", [:static, "More content"]],
@@ -68,9 +68,51 @@ module Temple
   #   _buf << "Some content"
   #   foo = "More content"
   #   _buf << foo.downcase
-  module Core
+  class Generator
+    include Mixins::Options
+
+    default_options[:buffer] = '_buf'
+
+    def compile(exp)
+      [preamble, compile!(exp), postamble].join(' ; ')
+    end
+
+    def compile!(exp)
+      type, *args = exp
+      send("on_#{type}", *args)
+    end
+
+    def on_multi(*exp)
+      exp.map { |e| compile!(e) }.join(' ; ')
+    end
+
+    def on_newline
+      "\n"
+    end
+
+    def on_capture(name, block)
+      capture_generator.new(:buffer => name).compile(block)
+    end
+
+    protected
+
+    def capture_generator
+      @capture_generator ||=
+        options[:capture_generator] || Temple::Generators::StringBuffer
+    end
+
+    def buffer
+      options[:buffer]
+    end
+
+    def concat(str)
+      "#{buffer} << (#{str})"
+    end
+  end
+
+  module Generators
     # Implements an array buffer.
-    # 
+    #
     #   _buf = []
     #   _buf << "static"
     #   _buf << dynamic
@@ -79,29 +121,29 @@ module Temple
     #   end
     #   _buf.join
     class ArrayBuffer < Generator
-      def preamble;  buffer " = []" end
-      def postamble; buffer ".join"   end
-      
+      def preamble;  "#{buffer} = []" end
+      def postamble; "#{buffer} = #{buffer}.join" end
+
       def on_static(text)
-        concat(to_ruby(text))
+        concat(text.inspect)
       end
-      
+
       def on_dynamic(code)
         concat(code)
       end
-      
+
       def on_block(code)
         code
       end
     end
-    
+
     # Just like ArrayBuffer, but doesn't call #join on the array.
     class Array < ArrayBuffer
       def postamble; buffer; end
     end
-    
+
     # Implements a string buffer.
-    # 
+    #
     #   _buf = ''
     #   _buf << "static"
     #   _buf << dynamic.to_s
@@ -109,10 +151,9 @@ module Temple
     #     _buf << "more static"
     #   end
     #   _buf
-    class StringBuffer < ArrayBuffer
-      def preamble;  buffer " = ''" end
-      def postamble; buffer end
-      
+    class StringBuffer < Array
+      def preamble; "#{buffer} = ''" end
+
       def on_dynamic(code)
         concat(code) + '.to_s'
       end

data/lib/temple/html/fast.rb

@@ -1,163 +1,115 @@
 module Temple
   module HTML
-    class Fast
-      DEFAULT_OPTIONS = {
-        :format => :xhtml,
-        :attr_wrapper => "'",
-        :autoclose => %w[meta img link br hr input area param col base]
-      }
-      
+    class Fast < Filter
+      temple_dispatch :html
+
+      XHTML_DOCTYPES = {
+        '1.1'          => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">',
+        '5'            => '<!DOCTYPE html>',
+        'strict'       => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">',
+        'frameset'     => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">',
+        'mobile'       => '<!DOCTYPE html PUBLIC "-//WAPFORUM//DTD XHTML Mobile 1.2//EN" "http://www.openmobilealliance.org/tech/DTD/xhtml-mobile12.dtd">',
+        'basic'        => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML Basic 1.1//EN" "http://www.w3.org/TR/xhtml-basic/xhtml-basic11.dtd">',
+        'transitional' => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">',
+      }.freeze
+
+      HTML4_DOCTYPES = {
+        'strict'       => '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">',
+        'frameset'     => '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3.org/TR/html4/frameset.dtd">',
+        'transitional' => '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">',
+      }.freeze
+
+      set_default_options :format => :xhtml,
+                          :attr_wrapper => "'",
+                          :autoclose => %w[meta img link br hr input area param col base],
+                          :id_delimiter => '_'
+
       def initialize(options = {})
-        @options = DEFAULT_OPTIONS.merge(options)
-        
+        super
         unless [:xhtml, :html4, :html5].include?(@options[:format])
           raise "Invalid format #{@options[:format].inspect}"
         end
-        
       end
-      
+
       def xhtml?
-        @options[:format] == :xhtml
+        options[:format] == :xhtml
       end
-      
+
       def html?
         html5? or html4?
       end
-      
+
       def html5?
-        @options[:format] == :html5
+        options[:format] == :html5
       end
-      
+
       def html4?
-        @options[:format] == :html4
-      end
-      
-      def compile(exp)
-        case exp[0]
-        when :multi, :capture
-          send("on_#{exp[0]}", *exp[1..-1])
-        when :html
-          send("on_#{exp[1]}", *exp[2..-1])
-        else
-          exp
-        end
-      end
-      
-      def on_multi(*exp)
-        [:multi, *exp.map { |e| compile(e) }]
+        options[:format] == :html4
       end
 
-      def on_capture(name, exp)
-        [:capture, name, compile(exp)]
-      end
-      
-      def on_doctype(type)
+      def on_html_doctype(type)
         trailing_newlines = type[/(\A|[^\r])(\n+)\Z/, 2].to_s
-        
-        text = type.to_s.downcase.strip
-        if text.index("xml") == 0
-          if html?
-            return [:multi].concat([[:newline]] * trailing_newlines.size)
-          end
-          
-          wrapper = @options[:attr_wrapper]
+        text = type.downcase.strip
+
+        if text =~ /^xml/
+          raise 'Invalid xml directive in html mode' if html?
+          wrapper = options[:attr_wrapper]
           str = "<?xml version=#{wrapper}1.0#{wrapper} encoding=#{wrapper}#{text.split(' ')[1] || "utf-8"}#{wrapper} ?>"
-        end
-        
-        str = "<!DOCTYPE html>" if html5?
-        
-        str ||= if xhtml?
-          case text
-          when /^1\.1/;     '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">'
-          when /^5/;        '<!DOCTYPE html>'
-          when "strict";    '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">'
-          when "frameset";  '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">'
-          when "mobile";    '<!DOCTYPE html PUBLIC "-//WAPFORUM//DTD XHTML Mobile 1.2//EN" "http://www.openmobilealliance.org/tech/DTD/xhtml-mobile12.dtd">'
-          when "basic";     '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML Basic 1.1//EN" "http://www.w3.org/TR/xhtml-basic/xhtml-basic11.dtd">'
-          else              '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">'
-          end
-        elsif html4?
-          case text
-            when "strict";    '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">'
-            when "frameset";  '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3.org/TR/html4/frameset.dtd">'
-            else              '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">'
+        else
+          case options[:format]
+          when :html5
+            str = '<!DOCTYPE html>'
+          when :html4
+            str = HTML4_DOCTYPES[text] || HTML4_DOCTYPES['transitional']
+          when :xhtml
+            str = XHTML_DOCTYPES[text] || XHTML_DOCTYPES['transitional']
           end
         end
-        
+
         str << trailing_newlines
         [:static, str]
       end
-      
-      def on_comment(content)
+
+      def on_html_comment(content)
         [:multi,
-          [:static, "<!--"],
-          compile(content),
-          [:static, "-->"]]
+          [:static, '<!--'],
+          compile!(content),
+          [:static, '-->']]
       end
-      
-      def on_tag(name, attrs, content)
-        ac = @options[:autoclose].include?(name)
-        result = [:multi]
-        result << [:static, "<#{name}"]
-        result << compile(attrs)
-        result << [:static, " /"] if ac && xhtml?
-        result << [:static, ">"]
-        result << compile(content)
-        result << [:static, "</#{name}>"] if !ac
+
+      def on_html_tag(name, attrs, closed, content)
+        closed ||= options[:autoclose].include?(name)
+        raise "Closed tag #{name} has content" if closed && !empty_exp?(content)
+        result = [:multi, [:static, "<#{name}"], compile!(attrs)]
+        result << [:static, ' /'] if closed && xhtml?
+        result << [:static, '>'] << compile!(content)
+        result << [:static, "</#{name}>"] if !closed
         result
       end
-      
-      def on_attrs(*exp)
-        if exp.all? { |e| attr_easily_compilable?(e) }
-          [:multi, *merge_basicattrs(exp).map { |e| compile(e) }]
-        else
-          raise "[:html, :attrs] currently only support basicattrs"
-        end
-      end
-      
-      def attr_easily_compilable?(exp)
-        exp[1] == :basicattr and
-        exp[2][0] == :static
-      end
-      
-      def merge_basicattrs(attrs)
-        result = []
-        position = {}
-        
-        attrs.each do |(html, type, (name_type, name), value)|
-          if pos = position[name]
-            case name
-            when 'class', 'id'
-              value = [:multi,
-                result[pos].last,  # previous value
-                [:static, (name == 'class' ? ' ' : '_')], # delimiter
-                value]             # new value
-            end
-            
-            result[pos] = [name, value]
+
+      def on_html_staticattrs(*attrs)
+        result = {}
+        attrs.each do |name, value|
+          if result[name] && %w(class id).include?(name)
+            raise 'Multiple id attributes specified, but id concatenation disabled' if name == 'id' && !options[:id_delimiter]
+            result[name] = [:multi,
+                            result[name],
+                            [:static, (name == 'class' ? ' ' : options[:id_delimiter])],
+                            value]
           else
-            position[name] = result.size
-            result << [name, value]
+            result[name] = value
           end
         end
-        
-        final = []
-        result.each_with_index do |(name, value), index|
-          final << [:html, :basicattr, [:static, name], value]
+        result.sort.inject([:multi]) do |list, (name, value)|
+          list << [:multi,
+                   [:static, ' '],
+                   [:static, name],
+                   [:static, '='],
+                   [:static, options[:attr_wrapper]],
+                   value,
+                   [:static, options[:attr_wrapper]]]
         end
-        final
-      end
-      
-      def on_basicattr(name, value)
-        [:multi,
-          [:static, " "],
-          name,
-          [:static, "="],
-          [:static, @options[:attr_wrapper]],
-          value,
-          [:static, @options[:attr_wrapper]]]
       end
     end
   end
 end
-