temple 0.3.4 → 0.3.5

data/CHANGES

@@ -1,5 +1,19 @@
 master
 
+0.3.5
+
+  * Temple::HTML::Pretty improved
+  * :sort_attrs option (default: true) added to HTML::AttributeMerger;
+    if set to false, the attributes will appear in the insertion order
+  * Temple::Mixins::EngineDSL api changed ("wildcard" is deprecated, use "use" instead)
+  * Temple::Mixins::CompiledDispatcher supports arbitrary levels now
+  * Don't use gsub! on incoming strings (#57)
+  * Fix newlines in erb parser (#46)
+
+0.3.4
+
+  * Bugfix release (0.3.3 was yanked)
+
 0.3.3
 
   * Support for rails 3.1 streaming

data/README.md

@@ -35,23 +35,27 @@ Temple is built on a theory that every template consists of three elements:
 The goal of a template engine is to take the template and eventually compile
 it into *the core abstraction*:
 
-    [:multi,
-      [:static, "Hello "],
-      [:dynamic, "@user.name"],
-      [:static, "!\n"],
-      [:code, "if @user.birthday == Date.today"],
-      [:static, "Happy birthday!"],
-      [:code, "end"]]
+```ruby
+ [:multi,
+   [:static, "Hello "],
+   [:dynamic, "@user.name"],
+   [:static, "!\n"],
+   [:code, "if @user.birthday == Date.today"],
+   [:static, "Happy birthday!"],
+   [:code, "end"]]
+```
 
 Then you can apply some optimizations, feed it to Temple and it generates fast
 Ruby code for you:
 
-    _buf = []
-    _buf << ("Hello #{@user.name}!\n")
-    if @user.birthday == Date.today
-      _buf << "Happy birthday!"
-    end
-    _buf.join
+```ruby
+ _buf = []
+ _buf << ("Hello #{@user.name}!\n")
+ if @user.birthday == Date.today
+   _buf << "Happy birthday!"
+ end
+ _buf.join
+```
 
 S-expression
 ------------
@@ -67,13 +71,15 @@ manipulated by computers.
 
 Some examples:
 
-    [:static, "Hello World!"]
+```ruby
+ [:static, "Hello World!"]
 
-    [:multi,
-      [:static, "Hello "],
-      [:dynamic, "@world"]]
+ [:multi,
+   [:static, "Hello "],
+   [:dynamic, "@world"]]
 
-    [:html, :tag, "em", [:html, :attrs], [:static, "Hey hey"]]
+ [:html, :tag, "em", [:html, :attrs], [:static, "Hey hey"]]
+```
 
 *NOTE:* SexpProcessor, a library written by Ryan Davis, includes a `Sexp`
 class. While you can use this class (since it's a subclass of Array), it's not
@@ -89,11 +95,13 @@ do one thing at every step.
 
 So what's an abstraction? An abstraction is when you introduce a new types:
 
-    # Instead of:
-    [:static, "<strong>Use the force</strong>"]
+```ruby
+ # Instead of:
+ [:static, "<strong>Use the force</strong>"]
 
-    # You use:
-    [:html, :tag, "strong", [:html, :attrs], [:static, "Use the force"]]
+ # You use:
+ [:html, :tag, "strong", [:html, :attrs], [:static, "Use the force"]]
+```
 
 ### Why are abstractions so important?
 
@@ -126,15 +134,17 @@ the argument, and it should be possible to use the same instance several times
 While a compiler can be any object, you very often want to structure it as a
 class. Temple then assumes the initializer takes an optional option hash:
 
-    class MyCompiler
-      def initialize(options = {})
-        @options = options
-      end
+```ruby
+ class MyCompiler
+   def initialize(options = {})
+     @options = options
+   end
 
-      def call(exp)
-        # do stuff
-      end
-    end
+   def call(exp)
+     # do stuff
+   end
+ end
+```
 
 ### Parsers
 
@@ -181,24 +191,26 @@ Engines
 
 When you have a chain of a parsers, some filters and a generator you can finally create your *engine*. Temple provides {Temple::Engine} which makes this very easy:
 
-    class MyEngine < Temple::Engine
-      # First run MyParser, passing the :strict option
-      use MyParser, :strict
+```ruby
+ class MyEngine < Temple::Engine
+   # First run MyParser, passing the :strict option
+   use MyParser, :strict
 
-      # Then a custom filter
-      use MyFilter
+   # Then a custom filter
+   use MyFilter
 
-      # Then some general optimizations filters
-      filter :MultiFlattener
-      filter :StaticMerger
-      filter :DynamicInliner
+   # Then some general optimizations filters
+   filter :MultiFlattener
+   filter :StaticMerger
+   filter :DynamicInliner
 
-      # Finally the generator
-      generator :ArrayBuffer, :buffer
-    end
+   # Finally the generator
+   generator :ArrayBuffer, :buffer
+ end
 
-    engine = MyEngine.new(:strict => "For MyParser")
-    engine.call(something)
+ engine = MyEngine.new(:strict => "For MyParser")
+ engine.call(something)
+```
 
 And then?
 ---------
@@ -209,13 +221,15 @@ generator. What happens next?
 Temple provides helpers to create template classes for [Tilt](http://github.com/rtomayko/tilt) and
 Rails.
 
-    require 'tilt'
+```ruby
+ require 'tilt'
 
-    # Create template class MyTemplate and register your file extension
-    MyTemplate = Temple::Templates::Tilt(MyEngine, :register_as => 'ext')
+ # Create template class MyTemplate and register your file extension
+ MyTemplate = Temple::Templates::Tilt(MyEngine, :register_as => 'ext')
 
-    Tilt.new('example.ext').render     # => Render a file
-    MyTemplate.new { "String" }.render # => Render a string
+ Tilt.new('example.ext').render     # => Render a file
+ MyTemplate.new { "String" }.render # => Render a string
+```
 
 Installation
 ------------
@@ -223,7 +237,9 @@ Installation
 You need Ruby 1.8.7 or Ruby 1.9.2 to work with Temple. Temple is published as a Ruby Gem which can be installed
 as following:
 
-    $ gem install temple
+```bash
+ $ gem install temple
+```
 
 Engines using Temple
 --------------------

data/lib/temple/erb/parser.rb

@@ -6,27 +6,28 @@ module Temple
     class Parser
       include Mixins::Options
 
-      ERB_PATTERN = /(<%%|%%>)|<%(==?|\#)?(.*?)?-?%>/m
-
-      ESCAPED = {
-        '<%%' => '<%',
-        '%%>' => '%>',
-      }.freeze
+      ERB_PATTERN = /(\n|<%%|%%>)|<%(==?|\#)?(.*?)?-?%>/m
 
       def call(input)
         result = [:multi]
         pos = 0
-        input.scan(ERB_PATTERN) do |escaped, indicator, code|
-          m = Regexp.last_match
-          text = input[pos...m.begin(0)]
-          pos  = m.end(0)
-          result << [:static, text] if !text.empty?
-          if escaped
-            result << [:static, ESCAPED[escaped]]
+        input.scan(ERB_PATTERN) do |token, indicator, code|
+          text = input[pos...$~.begin(0)]
+          pos  = $~.end(0)
+          if token
+            case token
+            when "\n"
+              result << [:static, "#{text}\n"] << [:newline]
+            when '<%%', '%%>'
+              result << [:static, text] unless text.empty?
+              token.slice!(1)
+              result << [:static, token]
+            end
           else
+            result << [:static, text] unless text.empty?
             case indicator
             when '#'
-              code.count("\n").times { result << [:newline] }
+              result << [:code, "\n" * code.count("\n")]
             when /=/
               result << [:escape, indicator.size <= 1, [:dynamic, code]]
             else

data/lib/temple/erb/trimming.rb

@@ -10,18 +10,17 @@ module Temple
       def on_multi(*exps)
         case options[:trim_mode]
         when '>'
-          exps.each_cons(2) do |a, b|
-            if code?(a) && static?(b)
-              b[1].gsub!(/^\n/, '')
-            end
+          i = 0
+          while i < exps.size
+            exps.delete_at(i + 1) if code?(exps[i]) && exps[i+1] == [:static, "\n"]
+            i += 1
           end
         when '<>'
-          exps.each_with_index do |exp, i|
-            if code?(exp) &&
-                (!exps[i-1] || static?(exps[i-1]) && exps[i-1][1] =~ /\n$/) &&
-                (exps[i+1] && static?(exps[i+1]) && exps[i+1][1] =~ /^\n/)
-              exps[i+1][1].gsub!(/^\n/, '') if exps[i+1]
-            end
+          i = 0
+          while i < exps.size
+            exps.delete_at(i + 1) if code?(exps[i]) && exps[i+1] == [:static, "\n"] &&
+                                     (!exps[i-1] || (exps[i-1] == [:newline]))
+            i += 1
           end
         end
         [:multi, *exps]
@@ -32,10 +31,6 @@ module Temple
       def code?(exp)
         exp[0] == :escape || exp[0] == :code
       end
-
-      def static?(exp)
-        exp[0] == :static
-      end
     end
   end
 end

data/lib/temple/generators.rb

@@ -11,6 +11,7 @@ module Temple
   #
   # @api public
   class Generator
+    include Mixins::CompiledDispatcher
     include Mixins::Options
 
     default_options[:buffer] = '_buf'
@@ -19,14 +20,8 @@ module Temple
       [preamble, compile(exp), postamble].join('; ')
     end
 
-    def compile(exp)
-      type, *args = exp
-      method = "on_#{type}"
-      if respond_to?(method)
-        send(method, *args)
-      else
-        raise InvalidExpression, "Generator supports only core expressions - found #{exp.inspect}"
-      end
+    def on(*exp)
+      raise InvalidExpression, "Generator supports only core expressions - found #{exp.inspect}"
     end
 
     def on_multi(*exp)

data/lib/temple/html/attribute_merger.rb

@@ -3,13 +3,14 @@ module Temple
     # @api public
     class AttributeMerger < Filter
       default_options[:attr_delimiter] = {'id' => '_', 'class' => ' '}
+      default_options[:sort_attrs] = true
 
       def on_html_attrs(*attrs)
+        names = []
         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
@@ -37,9 +38,11 @@ module Temple
             end
           else
             result[name] = attr
+            names << name
           end
         end
-        [:multi, *result.sort.map {|name,attr| compile(attr) }]
+        result = options[:sort_attrs] ? result.sort : names.map {|k| [k, result[k]] }
+        [:multi, *result.map {|name,attr| compile(attr) }]
       end
 
       def on_html_attr(name, value)

data/lib/temple/html/fast.rb

@@ -43,21 +43,19 @@ module Temple
       end
 
       def on_html_doctype(type)
-        type = type.to_s
-        trailing_newlines = type[/(\A|[^\r])(\n+)\Z/, 2].to_s
-        text = type.downcase.strip
+        type = type.to_s.downcase
 
-        if text =~ /^xml/
+        if type =~ /^xml(\s+(.+))?$/
           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} ?>"
+          w = options[:attr_wrapper]
+          str = "<?xml version=#{w}1.0#{w} encoding=#{w}#{$2 || 'utf-8'}#{w} ?>"
         elsif html?
-          str = HTML_DOCTYPES[text] || raise("Invalid html doctype #{text}")
+          str = HTML_DOCTYPES[type] || raise("Invalid html doctype #{type}")
         else
-          str = XHTML_DOCTYPES[text] || raise("Invalid xhtml doctype #{text}")
+          str = XHTML_DOCTYPES[type] || raise("Invalid xhtml doctype #{type}")
         end
 
-        [:static, str << trailing_newlines]
+        [:static, str]
       end
 
       def on_html_comment(content)

data/lib/temple/html/pretty.rb

@@ -6,7 +6,7 @@ module Temple
                           :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 img input li link meta nav ol p
+                                             header hgroup hr html 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
@@ -25,7 +25,7 @@ module Temple
 
       def on_static(content)
         if @pretty
-          content.gsub!("\n", indent) if @pre_tags !~ content
+          content = content.gsub("\n", indent) if @pre_tags !~ content
           @last = content.sub!(/\r?\n\s*$/, ' ') ? nil : :noindent
         end
         [:static, content]
@@ -38,7 +38,7 @@ module Temple
           gsub_code = if ''.respond_to?(:html_safe?)
                         "#{tmp} = #{tmp}.html_safe? ? #{tmp}.gsub(\"\\n\", #{indent.inspect}).html_safe : #{tmp}.gsub(\"\\n\", #{indent.inspect})"
                       else
-                        "#{tmp}.gsub!(\"\\n\", #{indent.inspect})"
+                        "#{tmp} = #{tmp}.gsub(\"\\n\", #{indent.inspect})"
                       end
           [:multi,
            [:code, "#{tmp} = (#{code}).to_s"],
@@ -56,8 +56,9 @@ module Temple
 
       def on_html_comment(content)
         return super unless @pretty
+        result = [:multi, [:static, tag_indent(nil)], super]
         @last = nil
-        [:multi, [:static, indent], super]
+        result
       end
 
       def on_html_tag(name, attrs, content = nil)
@@ -76,8 +77,8 @@ module Temple
           result << compile(content)
           @indent -= 1
         end
+        result << [:static, "#{content && !empty_exp?(content) ? tag_indent(name) : ''}</#{name}>"] unless closed
 
-        result << [:static, "#{tag_indent(name)}</#{name}>"] if !closed
         @pretty = true
         result
       end

data/lib/temple/mixins/dispatcher.rb

@@ -51,38 +51,19 @@ module Temple
 
       private
 
-      def case_statement(types)
-        code = "type, *args = args\ncase type\n"
-        types.each do |name, method|
-          code << "when #{name.to_sym.inspect}\n" <<
-            (Hash === method ? case_statement(method) : "#{method}(*args)\n")
-        end
-        code << "else\nexp\nend\n"
-      end
-
       def dispatcher(exp)
         replace_dispatcher(exp)
       end
 
       def replace_dispatcher(exp)
-        types = {}
-        self.class.instance_methods.each do |method|
-          next if method.to_s !~ /^on_(.*)$/
-          method_types = $1.split('_')
-          (0...method_types.size).inject(types) do |tmp, i|
-            raise "Invalid temple dispatcher #{method}" unless Hash === tmp
-            if i == method_types.size - 1
-              tmp[method_types[i]] = method
-            else
-              tmp[method_types[i]] ||= {}
-            end
-          end
+        tree = DispatchNode.new
+        dispatched_methods.each do |method|
+          method.split('_')[1..-1].inject(tree) {|node, type| node[type.to_sym] }.method = method
         end
         self.class.class_eval %{
           def dispatcher(exp)
             if self.class == #{self.class}
-              args = exp
-              #{case_statement(types)}
+              #{tree.compile}
             else
               replace_dispatcher(exp)
             end
@@ -90,9 +71,100 @@ module Temple
         }
         dispatcher(exp)
       end
+
+      def dispatched_methods
+        re = /^on(_[a-zA-Z0-9]+)*$/
+        self.methods.map(&:to_s).select(&re.method(:=~))
+      end
+
+      # @api private
+      class DispatchNode < Hash
+        attr_accessor :method
+
+        def initialize
+          super { |hsh,key| hsh[key] = DispatchNode.new }
+          @method = nil
+        end
+
+        def compile(level = 0, parent = nil)
+          if empty?
+            if method
+              ('  ' * level) + "#{method}(*exp[#{level}..-1])"
+            elsif !parent
+              'exp'
+            else
+              raise 'Invalid dispatcher node'
+            end
+          else
+            code = [('  ' * level) + "case(exp[#{level}])"]
+            each do |key, child|
+              code << ('  ' * level) + "when #{key.inspect}"
+              code << child.compile(level + 1, parent || method)
+            end
+            if method || !parent
+              code << ('  ' * level) + "else"
+              if method
+                code << ('  ' * level) + "  #{method}(*exp[#{level}..-1])"
+              else
+                code << ('  ' * level) + "  exp"
+              end
+            end
+            code << ('  ' * level) + "end"
+            code.join("\n")
+          end
+        end
+      end
     end
 
-    # @api private
+    # @api public
+    #
+    # Implements a compatible call-method
+    # based on the including classe's methods.
+    #
+    # It uses every method starting with
+    # "on" and uses the rest of the method
+    # name as prefix of the expression it
+    # will receive. So, if a dispatcher
+    # has a method named "on_x", this method
+    # will be called with arg0,..,argN
+    # whenever an expression like [:x, arg0,..,argN ]
+    # is encountered.
+    #
+    # This works with longer prefixes, too.
+    # For example a method named "on_y_z"
+    # will be called whenever an expression
+    # like [:y, :z, .. ] is found. Furthermore,
+    # if additionally a method named "on_y"
+    # is present, it will be called when an
+    # expression starts with :y but then does
+    # not contain with :z. This way a
+    # dispatcher can implement namespaces.
+    #
+    # @note
+    #  Processing does not reach into unknown
+    #  expression types by default.
+    #
+    # @example
+    #   class MyAwesomeDispatch
+    #     include Temple::Mixins::Dispatcher
+    #     def on_awesome(thing) # keep awesome things
+    #       return [:awesome, thing]
+    #     end
+    #     def on_boring(thing) # make boring things awesome
+    #       return [:awesome, thing+" with bacon"]
+    #     end
+    #     def on(type,*args) # unknown stuff is boring too
+    #       return [:awesome, 'just bacon']
+    #     end
+    #   end
+    #   filter = MyAwesomeDispatch.new
+    #   # Boring things are converted:
+    #   filter.call([:boring, 'egg']) #=> [:awesome, 'egg with bacon']
+    #   # Unknown things too:
+    #   filter.call([:foo]) #=> [:awesome, 'just bacon']
+    #   # Known but not boring things won't be touched:
+    #   filter.call([:awesome, 'chuck norris']) #=>[:awesome, 'chuck norris']
+    #
     module Dispatcher
       include CompiledDispatcher
       include CoreDispatcher

data/lib/temple/mixins/engine_dsl.rb

@@ -28,6 +28,16 @@ module Temple
 
       alias use append
 
+      # DEPRECATED!
+      #
+      #    wildcard(:FilterName) { FilterClass.new(options) }
+      #
+      # is replaced by
+      #
+      #    use(:FilterName) { FilterClass.new(options) }
+      #
+      alias wildcard use
+
       def before(name, *args, &block)
         name = Class === name ? name.name.to_sym : name
         raise(ArgumentError, 'First argument must be Class or Symbol') unless Symbol === name
@@ -78,18 +88,12 @@ module Temple
         chain_modified!
       end
 
-      def filter(name, *options, &block)
-        use(name, Temple::Filters.const_get(name), *options, &block)
-      end
-
-      def generator(name, *options, &block)
-        use(name, Temple::Generators.const_get(name), *options, &block)
+      def filter(name, *options)
+        use(name, Temple::Filters.const_get(name), *options)
       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!
+      def generator(name, *options)
+        use(name, Temple::Generators.const_get(name), *options)
       end
 
       private
@@ -125,7 +129,7 @@ module Temple
           # The proc is converted to a method of the engine class.
           # 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
+          raise(ArgumentError, 'Proc or blocks must have arity 0 or 1') if filter.arity > 1
           [name, define_chain_method("FILTER #{name}", filter)]
         when Class
           # Class argument (e.g Filter class)

data/lib/temple/version.rb

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

data/test/html/test_attribute_merger.rb

@@ -3,6 +3,7 @@ require 'helper'
 describe Temple::HTML::AttributeMerger do
   before do
     @merger = Temple::HTML::AttributeMerger.new
+    @ordered_merger = Temple::HTML::AttributeMerger.new :sort_attrs => false
   end
 
   it 'should pass static attributes through' do
@@ -16,6 +17,46 @@ describe Temple::HTML::AttributeMerger do
                      [:content]]
   end
 
+  it 'should sort html attributes by name by default, when :sort_attrs is true' do
+    @merger.call([:html, :tag,
+      'meta',
+      [:html, :attrs, [:html, :attr, 'c', [:static, '1']],
+                      [:html, :attr, 'd', [:static, '2']],
+                      [:html, :attr, 'a', [:static, '3']],
+                      [:html, :attr, 'b', [:static, '4']]]
+    ]).should.equal [:html, :tag, 'meta',
+                     [:multi,
+                      [:html, :attr, 'a', [:static, '3']],
+                      [:html, :attr, 'b', [:static, '4']],
+                      [:html, :attr, 'c', [:static, '1']],
+                      [:html, :attr, 'd', [:static, '2']]]]
+  end
+
+  it 'should preserve the order of html attributes when :sort_attrs is false' do
+    @ordered_merger.call([:html, :tag,
+      'meta',
+      [:html, :attrs, [:html, :attr, 'c', [:static, '1']],
+                      [:html, :attr, 'd', [:static, '2']],
+                      [:html, :attr, 'a', [:static, '3']],
+                      [:html, :attr, 'b', [:static, '4']]]
+    ]).should.equal [:html, :tag, 'meta',
+                     [:multi,
+                      [:html, :attr, 'c', [:static, '1']],
+                      [:html, :attr, 'd', [:static, '2']],
+                      [:html, :attr, 'a', [:static, '3']],
+                      [:html, :attr, 'b', [:static, '4']]]]
+
+    # Use case:
+    @ordered_merger.call([:html, :tag,
+      'meta',
+      [:html, :attrs, [:html, :attr, 'http-equiv', [:static, 'Content-Type']],
+                      [:html, :attr, 'content', [:static, '']]]
+    ]).should.equal [:html, :tag, 'meta',
+                     [:multi,
+                      [:html, :attr, 'http-equiv', [:static, 'Content-Type']],
+                      [:html, :attr, 'content', [:static, '']]]]
+  end
+
   it 'should check for empty dynamic attribute' do
     @merger.call([:html, :tag,
       'div',

data/test/html/test_pretty.rb

@@ -22,7 +22,7 @@ describe Temple::HTML::Pretty do
                         [:static, "text"],
                         [:multi,
                          [:code, "_temple_html_pretty2 = (code).to_s"],
-                         [:code, 'if _temple_html_pretty1 !~ _temple_html_pretty2; _temple_html_pretty2.gsub!("\n", "\n    "); end'],
+                         [:code, 'if _temple_html_pretty1 !~ _temple_html_pretty2; _temple_html_pretty2 = _temple_html_pretty2.gsub("\n", "\n    "); end'],
                          [:dynamic, "_temple_html_pretty2"]]],
                        [:static, "</p>"]],
                       [:static, "\n</div>"]]]

data/test/mixins/test_dispatcher.rb

@@ -7,9 +7,23 @@ class FilterWithDispatcherMixin
     [:on_test, arg]
   end
 
+  def on_test_check(arg)
+    [:on_check, arg]
+  end
+
   def on_second_test(arg)
     [:on_second_test, arg]
   end
+
+  def on_seventh_level_level_level_level_level_test(arg)
+    [:on_seventh_test, arg]
+  end
+end
+
+class FilterWithDispatcherMixinAndOn < FilterWithDispatcherMixin
+  def on(*args)
+    [:on_zero, *args]
+  end
 end
 
 describe Temple::Mixins::Dispatcher do
@@ -28,4 +42,16 @@ describe Temple::Mixins::Dispatcher do
   it 'should dispatch second level' do
     @filter.call([:second, :test, 42]).should.equal [:on_second_test, 42]
   end
+
+  it 'should dispatch second level if prefixed' do
+    @filter.call([:test, :check, 42]).should.equal [:on_check, 42]
+  end
+
+  it 'should dispatch seventh level' do
+    @filter.call([:seventh, :level, :level, :level, :level, :level, :test, 42]).should == [:on_seventh_test, 42]
+  end
+
+  it 'should dispatch zero level' do
+    FilterWithDispatcherMixinAndOn.new.call([:foo,42]).should == [:on_zero, :foo, 42]
+  end
 end

data/test/test_engine.rb

@@ -23,7 +23,7 @@ class TestEngine < Temple::Engine
   filter :MultiFlattener
   generator :ArrayBuffer
   use :BeforeLast, Callable1.new
-  wildcard(:Last) { Callable2.new }
+  use(:Last) { Callable2.new }
 end
 
 describe Temple::Engine do

metadata

@@ -1,58 +1,63 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: temple
-version: !ruby/object:Gem::Version
-  version: 0.3.4
+version: !ruby/object:Gem::Version 
   prerelease: 
+  version: 0.3.5
 platform: ruby
-authors:
+authors: 
 - Magnus Holm
 - Daniel Mendler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-09-02 00:00:00.000000000Z
-dependencies:
-- !ruby/object:Gem::Dependency
+
+date: 2012-01-06 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
   name: tilt
-  requirement: &70118806201520 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
   type: :development
-  prerelease: false
-  version_requirements: *70118806201520
-- !ruby/object:Gem::Dependency
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
   name: bacon
-  requirement: &70118806201100 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
   type: :development
-  prerelease: false
-  version_requirements: *70118806201100
-- !ruby/object:Gem::Dependency
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
   name: rake
-  requirement: &70118806200640 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
   type: :development
-  prerelease: false
-  version_requirements: *70118806200640
+  version_requirements: *id003
 description: 
-email:
+email: 
 - judofyr@gmail.com
 - mail@daniel-mendler.de
 executables: []
+
 extensions: []
+
 extra_rdoc_files: []
-files:
+
+files: 
 - .gitignore
 - .travis.yml
 - .yardopts
@@ -114,31 +119,35 @@ files:
 - test/test_grammar.rb
 - test/test_hash.rb
 - test/test_utils.rb
+has_rdoc: true
 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.6
+rubygems_version: 1.6.2
 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