temple 0.3.2 → 0.3.4

data/.gitignore

@@ -1,3 +1,4 @@
 coverage
 .yardoc
 doc
+Gemfile.lock

data/.travis.yml

@@ -0,0 +1,7 @@
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - ruby-head
+  - rbx-2.0
+  - jruby

data/CHANGES

@@ -1,5 +1,14 @@
 master
 
+0.3.3
+
+  * Support for rails 3.1 streaming
+  * Add EngineDSL#wildcard
+  * HTML::Fast/Pretty supports only :xhtml and :html formats from now on
+  * HTML::AttributeMerger extracted from HTML::Fast
+
+0.3.1, 0.3.2
+
   * Don't modify strings destructively with gsub! in HTML::Pretty.
     This doesn't work with Rails safe buffers in version >= 3.0.8.
 

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+gemspec
+

data/lib/temple.rb

@@ -43,5 +43,6 @@ module Temple
     autoload :Filter,          'temple/html/filter'
     autoload :Fast,            'temple/html/fast'
     autoload :Pretty,          'temple/html/pretty'
+    autoload :AttributeMerger, 'temple/html/attribute_merger'
   end
 end

data/lib/temple/engine.rb

@@ -63,11 +63,12 @@ module Temple
           filtered_options = Hash[*option_filter.select {|k| options.include?(k) }.map {|k| [k, options[k]] }.flatten]
           filter.new(ImmutableHash.new(local_options, filtered_options))
         when UnboundMethod
-          filter.bind(self)
+          filter = filter.bind(self)
+          filter.arity == 1 ? filter : filter.call
         else
           filter
         end
-      end
+      end.compact
     end
   end
 end

data/lib/temple/filters/escapable.rb

@@ -14,7 +14,7 @@ module Temple
       def initialize(opts = {})
         super
         @escape_code = options[:escape_code] ||
-          "Temple::Utils.escape_html#{options[:use_html_safe] ? '_safe' : ''}((%s))"
+          "::Temple::Utils.escape_html#{options[:use_html_safe] ? '_safe' : ''}((%s))"
         @escaper = eval("proc {|v| #{@escape_code % 'v'} }")
         @escape = false
       end

data/lib/temple/generators.rb

@@ -120,10 +120,15 @@ module Temple
     class RailsOutputBuffer < StringBuffer
       set_default_options :buffer_class => 'ActiveSupport::SafeBuffer',
                           :buffer => '@output_buffer',
+                           # output_buffer is needed for Rails 3.1 Streaming support
                           :capture_generator => RailsOutputBuffer
 
       def preamble
-        "#{buffer} = #{options[:buffer_class]}.new"
+        if options[:streaming] && options[:buffer] == '@output_buffer'
+          "#{buffer} = output_buffer || #{options[:buffer_class]}.new"
+        else
+          "#{buffer} = #{options[:buffer_class]}.new"
+        end
       end
 
       def concat(str)

data/lib/temple/grammar.rb

@@ -29,14 +29,13 @@ module Temple
       # HTML abstraction
       [:html, :doctype, String]                |
       [:html, :comment, Expression]            |
-      [:html, :tag, HTMLIdentifier, HTMLAttrs, 'Expression?']
+      [:html, :tag, HTMLIdentifier, Expression, 'Expression?'] |
+      [:html, :attrs, 'HTMLAttr*']             |
+      HTMLAttr
 
     EmptyExp <<
       [:newline] | [:multi, 'EmptyExp*']
 
-    HTMLAttrs <<
-      Expression | [:html, :attrs, 'HTMLAttr*']
-
     HTMLAttr <<
       [:html, :attr, HTMLIdentifier, Expression]
 

data/lib/temple/html/attribute_merger.rb

@@ -0,0 +1,75 @@
+module Temple
+  module HTML
+    # @api public
+    class AttributeMerger < Filter
+      default_options[:attr_delimiter] = {'id' => '_', 'class' => ' '}
+
+      def on_html_attrs(*attrs)
+        result = {}
+        attrs.each do |attr|
+          raise(InvalidExpression, 'Attribute is not a html attr') if attr[0] != :html || attr[1] != :attr
+          name, value = attr[2].to_s, attr[3]
+          next if empty_exp?(value)
+          if result[name]
+            delimiter = options[:attr_delimiter][name]
+            raise "Multiple #{name} attributes specified" unless delimiter
+            if empty_exp?(value)
+              result[name] = [:html, :attr, name,
+                              [:multi,
+                               result[name][3],
+                               value]]
+            elsif contains_static?(value)
+              result[name] = [:html, :attr, name,
+                              [:multi,
+                               result[name][3],
+                               [:static, delimiter],
+                               value]]
+            else
+              tmp = unique_name
+              result[name] = [:html, :attr, name,
+                              [:multi,
+                               result[name][3],
+                               [:capture, tmp, value],
+                               [:if, "!#{tmp}.empty?",
+                                [:multi,
+                                 [:static, delimiter],
+                                 [:dynamic, tmp]]]]]
+            end
+          else
+            result[name] = attr
+          end
+        end
+        [:multi, *result.sort.map {|name,attr| compile(attr) }]
+      end
+
+      def on_html_attr(name, value)
+        if empty_exp?(value)
+          value
+        elsif contains_static?(value)
+          [:html, :attr, name, value]
+        else
+          tmp = unique_name
+          [:multi,
+           [:capture, tmp, compile(value)],
+           [:if, "!#{tmp}.empty?",
+            [:html, :attr, name, [:dynamic, tmp]]]]
+        end
+      end
+
+      protected
+
+      def contains_static?(exp)
+        case exp[0]
+        when :multi
+          exp[1..-1].any? {|e| contains_static?(e) }
+        when :escape
+          contains_static?(exp[2])
+        when :static
+          true
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/temple/html/fast.rb

@@ -13,7 +13,9 @@ module Temple
         'transitional' => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">',
       }.freeze
 
-      HTML4_DOCTYPES = {
+      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">',
@@ -21,14 +23,13 @@ module Temple
 
       set_default_options :format => :xhtml,
                           :attr_wrapper => "'",
-                          :autoclose => %w[meta img link br hr input area param col base],
-                          :attr_delimiter => {'id' => '_', 'class' => ' '}
+                          :autoclose => %w[meta img link br hr input area param col base]
+
+      HTML = [:html, :html4, :html5]
 
       def initialize(opts = {})
         super
-        # html5 is now called html only
-        options[:format] = :html5 if options[:format] == :html
-        unless [:xhtml, :html4, :html5].include?(options[:format])
+        unless [:xhtml, *HTML].include?(options[:format])
           raise "Invalid format #{options[:format].inspect}"
         end
       end
@@ -38,7 +39,7 @@ module Temple
       end
 
       def html?
-        options[:format] == :html5 || options[:format] == :html4
+        HTML.include?(options[:format])
       end
 
       def on_html_doctype(type)
@@ -50,19 +51,13 @@ module Temple
           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} ?>"
+        elsif html?
+          str = HTML_DOCTYPES[text] || raise("Invalid html doctype #{text}")
         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
+          str = XHTML_DOCTYPES[text] || raise("Invalid xhtml doctype #{text}")
         end
 
-        str << trailing_newlines
-        [:static, str]
+        [:static, str << trailing_newlines]
       end
 
       def on_html_comment(content)
@@ -83,73 +78,15 @@ module Temple
       end
 
       def on_html_attrs(*attrs)
-        result = {}
-        attrs.each do |attr|
-          raise(InvalidExpression, 'Attribute is not a html attr') if attr[0] != :html || attr[1] != :attr
-          name, value = attr[2].to_s, attr[3]
-          next if empty_exp?(value)
-          if result[name]
-            delimiter = options[:attr_delimiter][name]
-            raise "Multiple #{name} attributes specified" unless delimiter
-            if contains_static?(value)
-              result[name] = [:html, :attr, name,
-                              [:multi,
-                               result[name][3],
-                               [:static, delimiter],
-                               value]]
-            else
-              tmp = unique_name
-              result[name] = [:html, :attr, name,
-                              [:multi,
-                               result[name][3],
-                               [:capture, tmp, value],
-                               [:if, "!#{tmp}.empty?",
-                                [:multi,
-                                 [:static, delimiter],
-                                 [:dynamic, tmp]]]]]
-            end
-          else
-            result[name] = attr
-          end
-        end
-        [:multi, *result.sort.map {|name,attr| compile(attr) }]
+        [:multi, *attrs.map {|attr| compile(attr) }]
       end
 
       def on_html_attr(name, value)
-        if empty_exp?(value)
-          compile(value)
-        elsif contains_static?(value)
-          attribute(name, value)
-        else
-          tmp = unique_name
-          [:multi,
-           [:capture, tmp, compile(value)],
-           [:if, "!#{tmp}.empty?",
-            attribute(name, [:dynamic, tmp])]]
-        end
-      end
-
-      protected
-
-      def attribute(name, value)
         [:multi,
          [:static, " #{name}=#{options[:attr_wrapper]}"],
          compile(value),
          [:static, options[:attr_wrapper]]]
       end
-
-      def contains_static?(exp)
-        case exp[0]
-        when :multi
-          exp[1..-1].any? {|e| contains_static?(e) }
-        when :escape
-          contains_static?(exp[2])
-        when :static
-          true
-        else
-          false
-        end
-      end
     end
   end
 end

data/lib/temple/html/pretty.rb

@@ -4,9 +4,11 @@ module Temple
     class Pretty < Fast
       set_default_options :indent => '  ',
                           :pretty => true,
-                          :indent_tags => %w(base body dd div dl dt fieldset form head h1 h2 h3
-                                             h4 h5 h6 hr html img input li link meta ol p script
-                                             style table tbody td tfoot th thead title tr ul).freeze,
+                          :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 img input li link meta nav ol p
+                                             rp rt ruby section script style table tbody td tfoot
+                                             th thead title tr ul video).freeze,
                           :pre_tags => %w(code pre textarea).freeze
 
       def initialize(opts = {})

data/lib/temple/mixins/engine_dsl.rb

@@ -86,8 +86,24 @@ module Temple
         use(name, Temple::Generators.const_get(name), *options, &block)
       end
 
+      def wildcard(name, &block)
+        raise(ArgumentError, 'Block must have arity 0') unless block.arity <= 0
+        chain << [name, define_chain_method("WILDCARD #{name}", block)]
+        chain_modified!
+      end
+
       private
 
+      def define_chain_method(name, proc)
+        if Class === self
+          define_method(name, &proc)
+          instance_method(name)
+        else
+          (class << self; self; end).class_eval { define_method(name, &proc) }
+          method(name)
+        end
+      end
+
       def element(args, block)
         name = args.shift
         if Class === name
@@ -110,14 +126,7 @@ module Temple
           # The proc can then access the option hash of the engine.
           raise(ArgumentError, 'Too many arguments') unless args.empty?
           raise(ArgumentError, 'Proc or blocks must have arity 1') unless filter.arity == 1
-          method_name = "FILTER #{name}"
-          if Class === self
-            define_method(method_name, &filter)
-            [name, instance_method(method_name)]
-          else
-            (class << self; self; end).class_eval { define_method(method_name, &filter) }
-            [name, method(method_name)]
-          end
+          [name, define_chain_method("FILTER #{name}", filter)]
         when Class
           # Class argument (e.g Filter class)
           # The options are passed to the classes constructor.
@@ -127,6 +136,7 @@ module Temple
         else
           # Other callable argument (e.g. Object of class which implements #call or Method)
           # The callable has no access to the option hash of the engine.
+          raise(ArgumentError, 'Too many arguments') unless args.empty?
           raise(ArgumentError, 'Class or callable argument is required') unless filter.respond_to?(:call)
           [name, filter]
         end

data/lib/temple/mixins/grammar_dsl.rb

@@ -61,8 +61,11 @@ module Temple
           unmatched = []
           unless match(exp, unmatched)
             require 'pp'
-            rule, exp = unmatched.sort_by {|r,e| [*e].flatten.size }.first
-            raise(InvalidExpression, PP.pp(exp, "#{@grammar}::#{rule} did not match\n"))
+            entry = unmatched.first
+            unmatched.reverse_each do |u|
+              entry = u if u.flatten.size < entry.flatten.size
+            end
+            raise(InvalidExpression, PP.pp(entry.last, "#{@grammar}::#{entry.first} did not match\n"))
           end
         end
 

data/lib/temple/templates.rb

@@ -6,9 +6,9 @@ module Temple
 
     def self.method_missing(name, engine, options = {})
       template = Class.new(const_get(name))
-      template.engine(engine)
-      template.register_as(options[:register_as]) if options[:register_as]
+      template.default_options[:engine] = engine
       template.default_options.update(options)
+      template.register_as(options[:register_as]) if options[:register_as]
       template
     end
   end

data/lib/temple/templates/rails.rb

@@ -1,3 +1,7 @@
+unless Object.const_defined?(:Rails)
+  raise "Rails is not loaded - Temple::Templates::Rails cannot be used"
+end
+
 if ::Rails::VERSION::MAJOR < 3
   raise "Temple supports only Rails 3.x and greater, your Rails version is #{::Rails::VERSION::STRING}"
 end
@@ -10,7 +14,8 @@ module Temple
         extend Mixins::Template
 
         def compile(template)
-          self.class.build_engine.call(template.source)
+          self.class.build_engine(:streaming => false, # Overwrite option: No streaming support in Rails < 3.1
+                                  :file => template.identifier).call(template.source)
         end
 
         def self.register_as(name)
@@ -21,12 +26,16 @@ module Temple
       class Rails
         extend Mixins::Template
 
-        def self.call(template)
-          build_engine.call(template.source)
+        def call(template)
+          self.class.build_engine(:file => template.identifier).call(template.source)
+        end
+
+        def supports_streaming?
+          self.class.default_options[:streaming]
         end
 
         def self.register_as(name)
-          ActionView::Template.register_template_handler name.to_sym, self
+          ActionView::Template.register_template_handler name.to_sym, new
         end
       end
     end

data/lib/temple/templates/tilt.rb

@@ -11,7 +11,8 @@ module Temple
       #
       # @return [void]
       def prepare
-        @src = self.class.build_engine({ :file => eval_file }, options).call(data)
+        @src = self.class.build_engine({ :streaming => false, # Overwrite option: No streaming support in Tilt
+                                         :file => eval_file }, options).call(data)
       end
 
       # A string containing the (Ruby) source code for the template.

data/lib/temple/version.rb

@@ -1,3 +1,3 @@
 module Temple
-  VERSION = '0.3.2'
+  VERSION = '0.3.4'
 end

data/temple.gemspec

@@ -21,4 +21,5 @@ Gem::Specification.new do |s|
   # can be used without it.
   s.add_development_dependency('tilt')
   s.add_development_dependency('bacon')
+  s.add_development_dependency('rake')
 end

data/test/filters/test_escapable.rb

@@ -18,7 +18,7 @@ describe Temple::Filters::Escapable do
                    [:dynamic, "ruby_method"]]
     ]).should.equal [:multi,
       [:static, "a < b"],
-      [:dynamic, "Temple::Utils.escape_html((ruby_method))"],
+      [:dynamic, "::Temple::Utils.escape_html((ruby_method))"],
     ]
   end
 

data/test/html/test_attribute_merger.rb

@@ -0,0 +1,69 @@
+require 'helper'
+
+describe Temple::HTML::AttributeMerger do
+  before do
+    @merger = Temple::HTML::AttributeMerger.new
+  end
+
+  it 'should pass static attributes through' do
+    @merger.call([:html, :tag,
+      'div',
+      [:html, :attrs, [:html, :attr, 'class', [:static, 'b']]],
+      [:content]
+    ]).should.equal [:html, :tag, "div",
+                     [:multi,
+                      [:html, :attr, "class", [:static, "b"]]],
+                     [:content]]
+  end
+
+  it 'should check for empty dynamic attribute' do
+    @merger.call([:html, :tag,
+      'div',
+      [:html, :attrs, [:html, :attr, 'class', [:dynamic, 'b']]],
+      [:content]
+    ]).should.equal [:html, :tag, "div",
+                     [:multi,
+                      [:multi,
+                       [:capture, "_temple_html_attributemerger1", [:dynamic, "b"]],
+                       [:if, "!_temple_html_attributemerger1.empty?",
+                        [:html, :attr, "class", [:dynamic, "_temple_html_attributemerger1"]]]]],
+                     [:content]]
+  end
+
+  it 'should merge ids' do
+    @merger.call([:html, :tag,
+      'div',
+      [:html, :attrs, [:html, :attr, 'id', [:dynamic, 'a']], [:html, :attr, 'id', [:dynamic, 'b']]],
+      [:content]
+    ]).should.equal [:html, :tag, "div",
+                     [:multi,
+                      [:multi,
+                       [:capture, "_temple_html_attributemerger2",
+                        [:multi, [:dynamic, "a"],
+                         [:capture, "_temple_html_attributemerger1",
+                          [:dynamic, "b"]],
+                         [:if, "!_temple_html_attributemerger1.empty?",
+                          [:multi, [:static, "_"],
+                           [:dynamic, "_temple_html_attributemerger1"]]]]],
+                       [:if, "!_temple_html_attributemerger2.empty?",
+                        [:html, :attr, "id", [:dynamic, "_temple_html_attributemerger2"]]]]],
+                     [:content]]
+  end
+
+  it 'should merge classes' do
+    @merger.call([:html, :tag,
+      'div',
+      [:html, :attrs, [:html, :attr, 'class', [:static, 'a']], [:html, :attr, 'class', [:dynamic, 'b']]],
+      [:content]
+    ]).should.equal [:html, :tag, "div",
+                     [:multi,
+                      [:html, :attr, "class",
+                       [:multi, [:static, "a"],
+                        [:capture, "_temple_html_attributemerger1", [:dynamic, "b"]],
+                        [:if, "!_temple_html_attributemerger1.empty?",
+                         [:multi, [:static, " "],
+                          [:dynamic, "_temple_html_attributemerger1"]]]]]],
+                     [:content]]
+  end
+end
+

data/test/html/test_fast.rb

@@ -51,77 +51,18 @@ describe Temple::HTML::Fast do
                      [:static, "</div>"]]
   end
 
-  it 'should compile html with static attrs' do
+  it 'should compile html with attrs' do
     @html.call([:html, :tag,
       'div',
       [:html, :attrs,
        [:html, :attr, 'id', [:static, 'test']],
        [:html, :attr, 'class', [:dynamic, 'block']]],
        [:content]
-    ]).should.equal [:multi,
-                     [:static,
-                      "<div"],
-                     [:multi,
-                      [:multi,
-                       [:capture, "_temple_html_fast1",
-                        [:dynamic, "block"]],
-                       [:if, "!_temple_html_fast1.empty?",
-                        [:multi,
-                         [:static, " class='"],
-                         [:dynamic, "_temple_html_fast1"],
-                         [:static, "'"]]]],
-                      [:multi,
-                       [:static, " id='"],
-                       [:static, "test"],
-                       [:static, "'"]]],
-                     [:static, ">"],
-                     [:content],
-                     [:static, "</div>"]]
-  end
-
-  it 'should compile html with merged ids' do
-    @html.call([:html, :tag,
-      'div',
-      [:html, :attrs, [:html, :attr, 'id', [:static, 'a']], [:html, :attr, 'id', [:dynamic, 'b']]],
-      [:content]
-    ]).should.equal [:multi,
-                     [:static, "<div"],
-                     [:multi,
-                      [:multi,
-                       [:static, " id='"],
-                       [:multi,
-                        [:static, "a"],
-                        [:capture, "_temple_html_fast1",
-                         [:dynamic, "b"]],
-                        [:if, "!_temple_html_fast1.empty?",
-                         [:multi,
-                          [:static, "_"],
-                          [:dynamic, "_temple_html_fast1"]]]],
-                       [:static, "'"]]],
-                     [:static, ">"],
-                     [:content],
-                     [:static, "</div>"]]
-  end
-
-  it 'should compile html with merged classes' do
-    @html.call([:html, :tag,
-      'div',
-      [:html, :attrs, [:html, :attr, 'class', [:static, 'a']], [:html, :attr, 'class', [:dynamic, 'b']]],
-      [:content]
     ]).should.equal [:multi,
                      [:static, "<div"],
                      [:multi,
-                      [:multi,
-                       [:static, " class='"],
-                       [:multi,
-                        [:static, "a"],
-                        [:capture, "_temple_html_fast1",
-                         [:dynamic, "b"]],
-                        [:if, "!_temple_html_fast1.empty?",
-                         [:multi,
-                          [:static, " "],
-                          [:dynamic, "_temple_html_fast1"]]]],
-                       [:static, "'"]]],
+                      [:multi, [:static, " id='"], [:static, "test"], [:static, "'"]],
+                      [:multi, [:static, " class='"], [:dynamic, "block"], [:static, "'"]]],
                      [:static, ">"],
                      [:content],
                      [:static, "</div>"]]

data/test/test_engine.rb

@@ -1,7 +1,13 @@
 # -*- coding: utf-8 -*-
 require 'helper'
 
-class OtherCallable
+class Callable1
+  def call(exp)
+    exp
+  end
+end
+
+class Callable2
   def call(exp)
     exp
   end
@@ -16,12 +22,13 @@ class TestEngine < Temple::Engine
   use Temple::HTML::Pretty, :format, :pretty => true
   filter :MultiFlattener
   generator :ArrayBuffer
-  use :FinalFilter, OtherCallable.new
+  use :BeforeLast, Callable1.new
+  wildcard(:Last) { Callable2.new }
 end
 
 describe Temple::Engine do
   it 'should build chain' do
-    TestEngine.chain.size.should.equal 7
+    TestEngine.chain.size.should.equal 8
 
     TestEngine.chain[0].first.should.equal :Parser
     TestEngine.chain[0].size.should.equal 2
@@ -45,8 +52,12 @@ describe Temple::Engine do
     TestEngine.chain[5].should.equal [:ArrayBuffer, Temple::Generators::ArrayBuffer, [], nil]
 
     TestEngine.chain[6].size.should.equal 2
-    TestEngine.chain[6][0].should.equal :FinalFilter
-    TestEngine.chain[6][1].should.be.instance_of OtherCallable
+    TestEngine.chain[6][0].should.equal :BeforeLast
+    TestEngine.chain[6][1].should.be.instance_of Callable1
+
+    TestEngine.chain[7].size.should.equal 2
+    TestEngine.chain[7][0].should.equal :Last
+    TestEngine.chain[7][1].should.be.instance_of UnboundMethod
   end
 
   it 'should instantiate chain' do
@@ -57,47 +68,48 @@ describe Temple::Engine do
     call_chain[3].should.be.instance_of Temple::HTML::Pretty
     call_chain[4].should.be.instance_of Temple::Filters::MultiFlattener
     call_chain[5].should.be.instance_of Temple::Generators::ArrayBuffer
-    call_chain[6].should.be.instance_of OtherCallable
+    call_chain[6].should.be.instance_of Callable1
+    call_chain[7].should.be.instance_of Callable2
   end
 
   it 'should have #append' do
     engine = TestEngine.new
     call_chain = engine.send(:call_chain)
-    call_chain.size.should.equal 7
+    call_chain.size.should.equal 8
 
     engine.append :MyFilter3 do |exp|
       exp
     end
 
-    TestEngine.chain.size.should.equal 7
-    engine.chain.size.should.equal 8
-    engine.chain[7].first.should.equal :MyFilter3
-    engine.chain[7].size.should.equal 2
-    engine.chain[7].last.should.be.instance_of Method
+    TestEngine.chain.size.should.equal 8
+    engine.chain.size.should.equal 9
+    engine.chain[8].first.should.equal :MyFilter3
+    engine.chain[8].size.should.equal 2
+    engine.chain[8].last.should.be.instance_of Method
 
     call_chain = engine.send(:call_chain)
-    call_chain.size.should.equal 8
-    call_chain[7].should.be.instance_of Method
+    call_chain.size.should.equal 9
+    call_chain[8].should.be.instance_of Method
   end
 
   it 'should have #prepend' do
     engine = TestEngine.new
     call_chain = engine.send(:call_chain)
-    call_chain.size.should.equal 7
+    call_chain.size.should.equal 8
 
     engine.prepend :MyFilter0 do |exp|
       exp
     end
 
-    TestEngine.chain.size.should.equal 7
-    engine.chain.size.should.equal 8
+    TestEngine.chain.size.should.equal 8
+    engine.chain.size.should.equal 9
     engine.chain[0].first.should.equal :MyFilter0
     engine.chain[0].size.should.equal 2
     engine.chain[0].last.should.be.instance_of Method
     engine.chain[1].first.should.equal :Parser
 
     call_chain = engine.send(:call_chain)
-    call_chain.size.should.equal 8
+    call_chain.size.should.equal 9
     call_chain[0].should.be.instance_of Method
   end
 
@@ -106,7 +118,7 @@ describe Temple::Engine do
     engine.after :Parser, :MyFilter0 do |exp|
       exp
     end
-    engine.chain.size.should.equal 8
+    engine.chain.size.should.equal 9
     engine.chain[0].first.should.equal :Parser
     engine.chain[1].first.should.equal :MyFilter0
     engine.chain[2].first.should.equal :MyFilter1
@@ -117,7 +129,7 @@ describe Temple::Engine do
     engine.before :MyFilter1, :MyFilter0 do |exp|
       exp
     end
-    engine.chain.size.should.equal 8
+    engine.chain.size.should.equal 9
     engine.chain[0].first.should.equal :Parser
     engine.chain[1].first.should.equal :MyFilter0
     engine.chain[2].first.should.equal :MyFilter1
@@ -126,7 +138,7 @@ describe Temple::Engine do
   it 'should have #remove' do
     engine = TestEngine.new
     engine.remove :MyFilter1
-    engine.chain.size.should.equal 6
+    engine.chain.size.should.equal 7
     engine.chain[0].first.should.equal :Parser
     engine.chain[1].first.should.equal :MyFilter2
   end
@@ -136,24 +148,24 @@ describe Temple::Engine do
     engine.before :Parser, :MyParser do |exp|
       exp
     end
-    engine.chain.size.should.equal 8
+    engine.chain.size.should.equal 9
     engine.chain[0].first.should.equal :MyParser
   end
 
   it 'should work with inheritance' do
     inherited_engine = Class.new(TestEngine)
-    inherited_engine.chain.size.should.equal 7
+    inherited_engine.chain.size.should.equal 8
     inherited_engine.append :MyFilter3 do |exp|
       exp
     end
-    inherited_engine.chain.size.should.equal 8
-    TestEngine.chain.size.should.equal 7
+    inherited_engine.chain.size.should.equal 9
+    TestEngine.chain.size.should.equal 8
   end
 
   it 'should support chain option' do
     engine = TestEngine.new(:chain => proc {|e| e.remove :MyFilter1 })
-    TestEngine.chain.size.should.equal 7
-    engine.chain.size.should.equal 6
+    TestEngine.chain.size.should.equal 8
+    engine.chain.size.should.equal 7
     engine.chain[0].first.should.equal :Parser
     engine.chain[1].first.should.equal :MyFilter2
   end

data/test/test_grammar.rb

@@ -44,9 +44,4 @@ describe Temple::Grammar do
     Temple::Grammar.should.match [:html, :tag, 'Tag', [:html, :attrs, [:html, :attr, 'id',
                                   [:static, 'val']]], [:static, 'Text']]
   end
-
-  it 'should not match lone html attributes' do
-    Temple::Grammar.should.not.match [:html, :attr, 'id', [:multi]]
-    Temple::Grammar.should.not.match [:html, :attrs]
-  end
 end

metadata

@@ -1,55 +1,64 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: temple
-version: !ruby/object:Gem::Version 
+version: !ruby/object:Gem::Version
+  version: 0.3.4
   prerelease: 
-  version: 0.3.2
 platform: ruby
-authors: 
+authors:
 - Magnus Holm
 - Daniel Mendler
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-06-19 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2011-09-02 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: tilt
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &70118806201520 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
+  prerelease: false
+  version_requirements: *70118806201520
+- !ruby/object:Gem::Dependency
   name: bacon
+  requirement: &70118806201100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: *70118806201100
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70118806200640 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id002
+  prerelease: false
+  version_requirements: *70118806200640
 description: 
-email: 
+email:
 - judofyr@gmail.com
 - mail@daniel-mendler.de
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - .gitignore
+- .travis.yml
 - .yardopts
 - CHANGES
 - EXPRESSIONS.md
+- Gemfile
 - LICENSE
 - README.md
 - Rakefile
@@ -70,6 +79,7 @@ files:
 - lib/temple/generators.rb
 - lib/temple/grammar.rb
 - lib/temple/hash.rb
+- lib/temple/html/attribute_merger.rb
 - lib/temple/html/dispatcher.rb
 - lib/temple/html/fast.rb
 - lib/temple/html/filter.rb
@@ -92,6 +102,7 @@ files:
 - test/filters/test_multi_flattener.rb
 - test/filters/test_static_merger.rb
 - test/helper.rb
+- test/html/test_attribute_merger.rb
 - test/html/test_fast.rb
 - test/html/test_pretty.rb
 - test/mixins/test_dispatcher.rb
@@ -105,32 +116,29 @@ files:
 - test/test_utils.rb
 homepage: http://dojo.rubyforge.org/
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.8.2
+rubygems_version: 1.8.6
 signing_key: 
 specification_version: 3
 summary: Template compilation framework in Ruby
-test_files: 
+test_files:
 - test/filters/test_control_flow.rb
 - test/filters/test_dynamic_inliner.rb
 - test/filters/test_eraser.rb
@@ -138,6 +146,7 @@ test_files:
 - test/filters/test_multi_flattener.rb
 - test/filters/test_static_merger.rb
 - test/helper.rb
+- test/html/test_attribute_merger.rb
 - test/html/test_fast.rb
 - test/html/test_pretty.rb
 - test/mixins/test_dispatcher.rb