temple 0.6.7 → 0.10.0

data/lib/temple/generator.rb

@@ -5,14 +5,40 @@ module Temple
   #
   # @api public
   class Generator
+    include Utils
     include Mixins::CompiledDispatcher
     include Mixins::Options
 
-    define_options :capture_generator => 'StringBuffer',
-                   :buffer => '_buf'
+    define_options :save_buffer,
+                   capture_generator: 'StringBuffer',
+                   buffer: '_buf',
+                   freeze_static: true
 
     def call(exp)
-      [preamble, compile(exp), postamble].join('; ')
+      [preamble, compile(exp), postamble].flatten.compact.join('; ')
+    end
+
+    def preamble
+      [save_buffer, create_buffer]
+    end
+
+    def postamble
+      [return_buffer, restore_buffer]
+    end
+
+    def save_buffer
+      "begin; #{@original_buffer = unique_name} = #{buffer} if defined?(#{buffer})" if options[:save_buffer]
+    end
+
+    def restore_buffer
+      "ensure; #{buffer} = #{@original_buffer}; end" if options[:save_buffer]
+    end
+
+    def create_buffer
+    end
+
+    def return_buffer
+      'nil'
     end
 
     def on(*exp)
@@ -20,7 +46,7 @@ module Temple
     end
 
     def on_multi(*exp)
-      exp.map {|e| compile(e) }.join('; ')
+      exp.map {|e| compile(e) }.join('; '.freeze)
     end
 
     def on_newline
@@ -28,11 +54,11 @@ module Temple
     end
 
     def on_capture(name, exp)
-      capture_generator.new(:buffer => name).call(exp)
+      capture_generator.new(buffer: name).call(exp)
     end
 
     def on_static(text)
-      concat(text.inspect)
+      concat(options[:freeze_static] ? "#{text.inspect}.freeze" : text.inspect)
     end
 
     def on_dynamic(code)

data/lib/temple/generators/array.rb

@@ -9,11 +9,11 @@ module Temple
     #
     # @api public
     class Array < Generator
-      def preamble
+      def create_buffer
         "#{buffer} = []"
       end
 
-      def postamble
+      def return_buffer
         buffer
       end
     end

data/lib/temple/generators/array_buffer.rb

@@ -5,23 +5,24 @@ module Temple
     #   _buf = []
     #   _buf << "static"
     #   _buf << dynamic
-    #   _buf.join
+    #   _buf.join("")
     #
     # @api public
     class ArrayBuffer < Array
       def call(exp)
         case exp.first
         when :static
-          "#{buffer} = #{exp.last.inspect}"
+          [save_buffer, "#{buffer} = #{exp.last.inspect}", restore_buffer].compact.join('; ')
         when :dynamic
-          "#{buffer} = (#{exp.last}).to_s"
+          [save_buffer, "#{buffer} = (#{exp.last}).to_s", restore_buffer].compact.join('; ')
         else
           super
         end
       end
 
-      def postamble
-        "#{buffer} = #{buffer}.join"
+      def return_buffer
+        freeze = options[:freeze_static] ? '.freeze' : ''
+        "#{buffer} = #{buffer}.join(\"\"#{freeze})"
       end
     end
   end

data/lib/temple/generators/erb.rb

@@ -9,7 +9,7 @@ module Temple
       end
 
       def on_multi(*exp)
-        exp.map {|e| compile(e) }.join
+        exp.map {|e| compile(e) }.join('')
       end
 
       def on_capture(name, exp)
@@ -20,10 +20,6 @@ module Temple
         text
       end
 
-      def on_newline
-        "<%\n%>"
-      end
-
       def on_dynamic(code)
         "<%= #{code} %>"
       end

data/lib/temple/generators/rails_output_buffer.rb

@@ -9,18 +9,17 @@ module Temple
     #
     # @api public
     class RailsOutputBuffer < StringBuffer
-      define_options :streaming,
-                     :buffer_class => 'ActiveSupport::SafeBuffer',
-                     :buffer => '@output_buffer',
-                     # output_buffer is needed for Rails 3.1 Streaming support
-                     :capture_generator => RailsOutputBuffer
+      define_options :streaming, # ignored
+                     buffer_class: 'ActionView::OutputBuffer',
+                     buffer: '@output_buffer',
+                     capture_generator: RailsOutputBuffer
 
       def call(exp)
-        [preamble, compile(exp), postamble].join('; ')
+        [preamble, compile(exp), postamble].flatten.compact.join('; '.freeze)
       end
 
-      def preamble
-        if options[:streaming] && options[:buffer] == '@output_buffer'
+      def create_buffer
+        if buffer == '@output_buffer'
           "#{buffer} = output_buffer || #{options[:buffer_class]}.new"
         else
           "#{buffer} = #{options[:buffer_class]}.new"

data/lib/temple/generators/string_buffer.rb

@@ -9,11 +9,11 @@ module Temple
     #
     # @api public
     class StringBuffer < ArrayBuffer
-      def preamble
+      def create_buffer
         "#{buffer} = ''"
       end
 
-      def postamble
+      def return_buffer
         buffer
       end
 

data/lib/temple/html/attribute_merger.rb

@@ -3,43 +3,38 @@ module Temple
     # This filter merges html attributes (e.g. used for id and class)
     # @api public
     class AttributeMerger < Filter
-      define_options :merge_attrs => {'id' => '_', 'class' => ' '}
+      define_options merge_attrs: {'id' => '_', 'class' => ' '}
 
       def on_html_attrs(*attrs)
-        names = []
         values = {}
 
-        attrs.each do |attr|
-          name, value = attr[2].to_s, attr[3]
+        attrs.each do |_, _, name, value|
+          name = name.to_s
           if values[name]
             raise(FilterError, "Multiple #{name} attributes specified") unless options[:merge_attrs][name]
             values[name] << value
           else
             values[name] = [value]
-            names << name
           end
         end
 
-        attrs = names.map do |name|
-          value = values[name]
+        attrs = values.map do |name, value|
           if (delimiter = options[:merge_attrs][name]) && value.size > 1
             exp = [:multi]
             if value.all? {|v| contains_nonempty_static?(v) }
               exp << value.first
               value[1..-1].each {|v| exp << [:static, delimiter] << v }
-              [:html, :attr, name, exp]
             else
               captures = unique_name
               exp << [:code, "#{captures} = []"]
               value.each_with_index {|v, i| exp << [:capture, "#{captures}[#{i}]", v] }
               exp << [:dynamic, "#{captures}.reject(&:empty?).join(#{delimiter.inspect})"]
             end
-            [:html, :attr, name, exp]
           else
-            [:html, :attr, name, value.first]
+            exp = value.first
           end
+          [:html, :attr, name, exp]
         end
-
         [:html, :attrs, *attrs]
       end
     end

data/lib/temple/html/attribute_remover.rb

@@ -3,7 +3,7 @@ module Temple
     # This filter removes empty attributes
     # @api public
     class AttributeRemover < Filter
-      define_options :remove_empty_attrs => %w(id class)
+      define_options remove_empty_attrs: %w(id class)
 
       def initialize(opts = {})
         super

data/lib/temple/html/attribute_sorter.rb

@@ -3,7 +3,7 @@ module Temple
     # This filter sorts html attributes.
     # @api public
     class AttributeSorter < Filter
-      define_options :sort_attrs => true
+      define_options sort_attrs: true
 
       def call(exp)
         options[:sort_attrs] ? super : exp

data/lib/temple/html/fast.rb

@@ -2,39 +2,50 @@ module Temple
   module HTML
     # @api public
     class Fast < Filter
-      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>',
-        'html'         => '<!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
+      DOCTYPES = {
+        xml: {
+          '1.1'          => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">',
+          '5'            => '<!DOCTYPE html>',
+          'html'         => '<!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">',
+          'svg'          => '<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">'
+        },
+        html: {
+          '5'            => '<!DOCTYPE html>',
+          'html'         => '<!DOCTYPE html>',
+          '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">'
+        }
+      }
+      DOCTYPES[:xhtml] = DOCTYPES[:xml]
+      DOCTYPES.freeze
 
-      HTML_DOCTYPES = {
-        '5'            => '<!DOCTYPE html>',
-        'html'         => '<!DOCTYPE html>',
-        '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
+      # See http://www.w3.org/html/wg/drafts/html/master/single-page.html#void-elements
+      HTML_VOID_ELEMENTS = %w[area base br col embed hr img input keygen link menuitem meta param source track wbr]
 
-      define_options :format => :xhtml,
-                     :attr_quote => '"',
-                     :autoclose => %w[meta img link br hr input area param col base],
-                     :js_wrapper => nil
-
-      HTML = [:html, :html4, :html5]
+      define_options format: :xhtml,
+                     attr_quote: '"',
+                     autoclose: HTML_VOID_ELEMENTS,
+                     js_wrapper: nil
 
       def initialize(opts = {})
         super
-        unless [:xhtml, *HTML].include?(options[:format])
-          raise ArgumentError, "Invalid format #{options[:format].inspect}"
+        @format = options[:format]
+        unless [:xhtml, :html, :xml].include?(@format)
+          if @format == :html4 || @format == :html5
+            warn "Format #{@format.inspect} is deprecated, use :html"
+            @format = :html
+          else
+            raise ArgumentError, "Invalid format #{@format.inspect}"
+          end
         end
         wrapper = options[:js_wrapper]
-        wrapper = xhtml? ? :cdata : :comment if wrapper == :guess
+        wrapper = @format == :xml || @format == :xhtml ? :cdata : :comment if wrapper == :guess
         @js_wrapper =
           case wrapper
           when :comment
@@ -51,25 +62,15 @@ module Temple
           end
       end
 
-      def xhtml?
-        options[:format] == :xhtml
-      end
-
-      def html?
-        HTML.include?(options[:format])
-      end
-
       def on_html_doctype(type)
         type = type.to_s.downcase
 
         if type =~ /^xml(\s+(.+))?$/
-          raise(FilterError, 'Invalid xml directive in html mode') if html?
+          raise(FilterError, 'Invalid xml directive in html mode') if @format == :html
           w = options[:attr_quote]
           str = "<?xml version=#{w}1.0#{w} encoding=#{w}#{$2 || 'utf-8'}#{w} ?>"
-        elsif html?
-          str = HTML_DOCTYPES[type] || raise(FilterError, "Invalid html doctype #{type}")
         else
-          str = XHTML_DOCTYPES[type] || raise(FilterError, "Invalid xhtml doctype #{type}")
+          str = DOCTYPES[@format][type] || raise(FilterError, "Invalid doctype #{type}")
         end
 
         [:static, str]
@@ -91,9 +92,9 @@ module Temple
 
       def on_html_tag(name, attrs, content = nil)
         name = name.to_s
-        closed = !content || (empty_exp?(content) && options[:autoclose].include?(name))
+        closed = !content || (empty_exp?(content) && (@format == :xml || options[:autoclose].include?(name)))
         result = [:multi, [:static, "<#{name}"], compile(attrs)]
-        result << [:static, (closed && xhtml? ? ' /' : '') + '>']
+        result << [:static, (closed && @format != :html ? ' /' : '') + '>']
         result << compile(content) if content
         result << [:static, "</#{name}>"] if !closed
         result
@@ -104,10 +105,14 @@ module Temple
       end
 
       def on_html_attr(name, value)
-        [:multi,
-         [:static, " #{name}=#{options[:attr_quote]}"],
-         compile(value),
-         [:static, options[:attr_quote]]]
+        if @format == :html && empty_exp?(value)
+          [:static, " #{name}"]
+        else
+          [:multi,
+           [:static, " #{name}=#{options[:attr_quote]}"],
+           compile(value),
+           [:static, options[:attr_quote]]]
+        end
       end
 
       def on_html_js(content)

data/lib/temple/html/pretty.rb

@@ -2,21 +2,21 @@ module Temple
   module HTML
     # @api public
     class Pretty < Fast
-      define_options :indent => '  ',
-                     :pretty => true,
-                     :indent_tags => %w(article aside audio base body datalist dd div dl dt
-                                        fieldset figure footer form head h1 h2 h3 h4 h5 h6
-                                        header hgroup hr html li link meta nav ol option p
-                                        rp rt ruby section script style table tbody td tfoot
-                                        th thead tr ul video doctype).freeze,
-                     :pre_tags => %w(code pre textarea).freeze
+      define_options indent: '  ',
+                     pretty: true,
+                     indent_tags: %w(article aside audio base body datalist dd div dl dt
+                                     fieldset figure footer form head h1 h2 h3 h4 h5 h6
+                                     header hgroup hr html li link meta nav ol option p
+                                     rp rt ruby section script style table tbody td tfoot
+                                     th thead tr ul video doctype).freeze,
+                     pre_tags: %w(code pre textarea).freeze
 
       def initialize(opts = {})
         super
-        @last = nil
+        @indent_next = nil
         @indent = 0
         @pretty = options[:pretty]
-        @pre_tags = Regexp.new(options[:pre_tags].map {|t| "<#{t}" }.join('|'))
+        @pre_tags = @format != :xml && Regexp.union(options[:pre_tags].map {|t| "<#{t}" })
       end
 
       def call(exp)
@@ -24,36 +24,19 @@ module Temple
       end
 
       def on_static(content)
-        if @pretty
-          if @pre_tags !~ content
-            content = content.sub(/\A\s*\n?/, "\n") if options[:indent_tags].include?(@last)
-            content = content.gsub("\n", indent)
-          end
-          @last = :static
+        return [:static, content] unless @pretty
+        unless @pre_tags && @pre_tags =~ content
+          content = content.sub(/\A\s*\n?/, "\n".freeze) if @indent_next
+          content = content.gsub("\n".freeze, indent)
         end
+        @indent_next = false
         [:static, content]
       end
 
       def on_dynamic(code)
-        if @pretty
-          tmp = unique_name
-          indent_code = ''
-          indent_code << "#{tmp} = #{tmp}.sub(/\\A\\s*\\n?/, \"\\n\"); " if options[:indent_tags].include?(@last)
-          indent_code << "#{tmp} = #{tmp}.gsub(\"\n\", #{indent.inspect}); "
-          if ''.respond_to?(:html_safe)
-            safe = unique_name
-            # we have to first save if the string was html_safe
-            # otherwise the gsub operation will lose that knowledge
-            indent_code = "#{safe} = #{tmp}.html_safe?; #{indent_code}#{tmp} = #{tmp}.html_safe if #{safe}; "
-          end
-          @last = :dynamic
-          [:multi,
-           [:code, "#{tmp} = (#{code}).to_s"],
-           [:code, "if #{@pre_tags_name} !~ #{tmp}; #{indent_code}end"],
-           [:dynamic, tmp]]
-        else
-          [:dynamic, code]
-        end
+        return [:dynamic, code] unless @pretty
+        indent_next, @indent_next = @indent_next, false
+        [:dynamic, "::Temple::Utils.indent_dynamic((#{code}), #{indent_next.inspect}, #{indent.inspect}#{@pre_tags ? ', ' + @pre_tags_name : ''})"]
       end
 
       def on_html_doctype(type)
@@ -64,7 +47,7 @@ module Temple
       def on_html_comment(content)
         return super unless @pretty
         result = [:multi, [:static, tag_indent('comment')], super]
-        @last = :comment
+        @indent_next = false
         result
       end
 
@@ -76,16 +59,18 @@ module Temple
 
         @pretty = false
         result = [:multi, [:static, "#{tag_indent(name)}<#{name}"], compile(attrs)]
-        result << [:static, (closed && xhtml? ? ' /' : '') + '>']
+        result << [:static, (closed && @format != :html ? ' /' : '') + '>']
 
-        @pretty = !options[:pre_tags].include?(name)
+        @pretty = !@pre_tags || !options[:pre_tags].include?(name)
         if content
           @indent += 1
           result << compile(content)
           @indent -= 1
         end
-        result << [:static, "#{content && !empty_exp?(content) ? tag_indent(name) : ''}</#{name}>"] unless closed
-
+        unless closed
+          indent = tag_indent(name)
+          result << [:static, "#{content && !empty_exp?(content) ? indent : ''}</#{name}>"]
+        end
         @pretty = true
         result
       end
@@ -93,6 +78,7 @@ module Temple
       protected
 
       def preamble
+        return [:multi] unless @pre_tags
         @pre_tags_name = unique_name
         [:code, "#{@pre_tags_name} = /#{@pre_tags.source}/"]
       end
@@ -103,9 +89,14 @@ module Temple
 
       # Return indentation before tag
       def tag_indent(name)
-        result = @last && (options[:indent_tags].include?(@last) || options[:indent_tags].include?(name)) ? indent : ''
-        @last = name
-        result
+        if @format == :xml
+          flag = @indent_next != nil
+          @indent_next = true
+        else
+          flag = @indent_next != nil && (@indent_next || options[:indent_tags].include?(name))
+          @indent_next = options[:indent_tags].include?(name)
+        end
+        flag ? indent : ''
       end
     end
   end

data/lib/temple/html/safe.rb

@@ -0,0 +1,23 @@
+module Temple
+  module HTML
+    class SafeString < String
+      def html_safe?; true end
+      def html_safe;  self end
+      def to_s;       self end
+    end
+  end
+end
+
+class Object
+  def html_safe?; false end
+end
+
+class Numeric
+  def html_safe?; true end
+end
+
+class String
+  def html_safe
+    Temple::HTML::SafeString.new(self)
+  end
+end

data/lib/temple/map.rb

@@ -0,0 +1,105 @@
+module Temple
+  # Immutable map class which supports map merging
+  # @api public
+  class ImmutableMap
+    include Enumerable
+
+    def initialize(*map)
+      @map = map.compact
+    end
+
+    def include?(key)
+      @map.any? {|h| h.include?(key) }
+    end
+
+    def [](key)
+      @map.each {|h| return h[key] if h.include?(key) }
+      nil
+    end
+
+    def each
+      keys.each {|k| yield(k, self[k]) }
+    end
+
+    def keys
+      @map.inject([]) {|keys, h| keys.concat(h.keys) }.uniq
+    end
+
+    def values
+      keys.map {|k| self[k] }
+    end
+
+    def to_hash
+      result = {}
+      each {|k, v| result[k] = v }
+      result
+    end
+  end
+
+  # Mutable map class which supports map merging
+  # @api public
+  class MutableMap < ImmutableMap
+    def initialize(*map)
+      super({}, *map)
+    end
+
+    def []=(key, value)
+      @map.first[key] = value
+    end
+
+    def update(map)
+      @map.first.update(map)
+    end
+  end
+
+  class OptionMap < MutableMap
+    def initialize(*map, &block)
+      super(*map)
+      @handler = block
+      @valid = {}
+      @deprecated = {}
+    end
+
+    def []=(key, value)
+      validate_key!(key)
+      super
+    end
+
+    def update(map)
+      validate_map!(map)
+      super
+    end
+
+    def valid_keys
+      (keys + @valid.keys +
+       @map.map {|h| h.valid_keys if h.respond_to?(:valid_keys) }.compact.flatten).uniq
+    end
+
+    def add_valid_keys(*keys)
+      keys.flatten.each { |key| @valid[key] = true }
+    end
+
+    def add_deprecated_keys(*keys)
+      keys.flatten.each { |key| @valid[key] = @deprecated[key] = true }
+    end
+
+    def validate_map!(map)
+      map.to_hash.keys.each {|key| validate_key!(key) }
+    end
+
+    def validate_key!(key)
+      @handler.call(self, key, :deprecated) if deprecated_key?(key)
+      @handler.call(self, key, :invalid) unless valid_key?(key)
+    end
+
+    def deprecated_key?(key)
+      @deprecated.include?(key) ||
+        @map.any? {|h| h.deprecated_key?(key) if h.respond_to?(:deprecated_key?) }
+    end
+
+    def valid_key?(key)
+      include?(key) || @valid.include?(key) ||
+        @map.any? {|h| h.valid_key?(key) if h.respond_to?(:valid_key?) }
+    end
+  end
+end