temple 0.4.1 → 0.5.4

data/.travis.yml

@@ -4,3 +4,4 @@ rvm:
   - ruby-head
   - jruby
   - rbx-18mode
+  - rbx-19mode

data/CHANGES

@@ -1,3 +1,37 @@
+0.5.4
+
+  * HTML::AttributeMerger fixed, it didn't remove first empty attribute values
+  * Add HTML::AttributeRemover back, :remove_empty_attrs must be an Array of Strings now
+    of the attributes to be removed if empty
+  * Simplify [:case] expression grammar
+  * Ignore parameter :outvar by sinatra since sinatra assumes also that the buffer is a String,
+    they should set :buffer and :generator explicitly if they need the access
+
+0.5.3
+
+  * Only print an message if invalid options are passed to Temple filters or engines
+    since many libraries seem to use Slim and Temple in an incorrect way
+
+0.5.2
+
+  * Fix the :outvar problem really
+
+0.5.1
+
+  * Support Sinatra :outvar option in Tilt template
+
+0.5.0
+
+  * Added exception Temple::FilterError which should be thrown by filters
+  * Added Temple::Parser as default base class for parsers
+  * escape_html doesn't escape / anymore
+  * HTML::AttributeSorter uses stable sorting now
+  * HTML::AttributeRemover removed (Was too Slim specific)
+  * Engine option :chain removed
+  * Option validation implemented (Use define_options in your filters)
+  * Deprecated options implemented (Use deprecated_options in your filters)
+  * ThreadOptions added, Method #with_options
+
 0.4.1
 
   * Generators: produce optimized code

data/lib/temple.rb

@@ -1,9 +1,11 @@
 require 'temple/version'
 
 module Temple
-  autoload :InvalidExpression,    'temple/generators'
+  autoload :InvalidExpression,    'temple/exceptions'
+  autoload :FilterError,          'temple/exceptions'
   autoload :Generator,            'temple/generators'
   autoload :Generators,           'temple/generators'
+  autoload :Parser,               'temple/parser'
   autoload :Engine,               'temple/engine'
   autoload :Utils,                'temple/utils'
   autoload :Filter,               'temple/filter'
@@ -11,6 +13,7 @@ module Temple
   autoload :Grammar,              'temple/grammar'
   autoload :ImmutableHash,        'temple/hash'
   autoload :MutableHash,          'temple/hash'
+  autoload :OptionHash,           'temple/hash'
 
   module Mixins
     autoload :Dispatcher,         'temple/mixins/dispatcher'
@@ -45,7 +48,7 @@ module Temple
     autoload :Fast,               'temple/html/fast'
     autoload :Pretty,             'temple/html/pretty'
     autoload :AttributeMerger,    'temple/html/attribute_merger'
-    autoload :AttributeSorter,    'temple/html/attribute_sorter'
     autoload :AttributeRemover,   'temple/html/attribute_remover'
+    autoload :AttributeSorter,    'temple/html/attribute_sorter'
   end
 end

data/lib/temple/engine.rb

@@ -33,16 +33,17 @@ module Temple
     include Mixins::EngineDSL
     extend  Mixins::EngineDSL
 
+    define_options :file, :streaming, :buffer
+
     attr_reader :chain
 
     def self.chain
       @chain ||= superclass.respond_to?(:chain) ? superclass.chain.dup : []
     end
 
-    def initialize(o = {})
+    def initialize(opts = {})
       super
       @chain = self.class.chain.dup
-      [*options[:chain]].compact.each {|block| block.call(self) }
     end
 
     def call(input)

data/lib/temple/erb/parser.rb

@@ -3,9 +3,7 @@ module Temple
     # Example ERB parser
     #
     # @api public
-    class Parser
-      include Mixins::Options
-
+    class Parser < Temple::Parser
       ERB_PATTERN = /(\n|<%%|%%>)|<%(==?|\#)?(.*?)?-?%>/m
 
       def call(input)

data/lib/temple/erb/trimming.rb

@@ -7,6 +7,8 @@ module Temple
     #
     # @api public
     class Trimming < Filter
+      define_options :trim_mode
+
       def on_multi(*exps)
         case options[:trim_mode]
         when '>'

data/lib/temple/exceptions.rb

@@ -0,0 +1,13 @@
+module Temple
+  # Exception raised if invalid temple expression is found
+  #
+  # @api public
+  class InvalidExpression < RuntimeError
+  end
+
+  # Exception raised if something bad happens in a Temple filter
+  #
+  # @api public
+  class FilterError < RuntimeError
+  end
+end

data/lib/temple/filters/control_flow.rb

@@ -20,9 +20,8 @@ module Temple
       def on_case(arg, *cases)
         result = [:multi, [:code, arg ? "case (#{arg})" : 'case']]
         cases.map do |c|
-          condition, *exps = c
-          result << [:code, condition == :else ? 'else' : "when #{condition}"]
-          exps.each {|e| result << compile(e) }
+          condition, exp = c
+          result << [:code, condition == :else ? 'else' : "when #{condition}"] << compile(exp)
         end
         result << [:code, 'end']
         result

data/lib/temple/filters/eraser.rb

@@ -5,7 +5,7 @@ module Temple
     # @api public
     class Eraser < Filter
       # [] is the empty type => keep all
-      default_options[:keep] = [[]]
+      define_options :keep => [[]], :erase => nil
 
       def compile(exp)
         exp.first == :multi || (do?(:keep, exp) && !do?(:erase, exp)) ?

data/lib/temple/filters/escapable.rb

@@ -8,8 +8,9 @@ module Temple
     # @api public
     class Escapable < Filter
       # Activate the usage of html_safe? if it is available (for Rails 3 for example)
-      set_default_options :use_html_safe => ''.respond_to?(:html_safe?),
-                          :disable_escape => false
+      define_options :escape_code,
+                     :use_html_safe => ''.respond_to?(:html_safe?),
+                     :disable_escape => false
 
       def initialize(opts = {})
         super

data/lib/temple/filters/validator.rb

@@ -4,7 +4,7 @@ module Temple
     #
     # @api public
     class Validator < Filter
-      default_options[:grammar] = Temple::Grammar
+      define_options :grammar => Temple::Grammar
 
       def compile(exp)
         options[:grammar].validate!(exp)

data/lib/temple/generators.rb

@@ -14,7 +14,8 @@ module Temple
     include Mixins::CompiledDispatcher
     include Mixins::Options
 
-    default_options[:buffer] = '_buf'
+    define_options :capture_generator,
+                   :buffer => '_buf'
 
     def call(exp)
       [preamble, compile(exp), postamble].join('; ')
@@ -134,10 +135,11 @@ module Temple
     #
     # @api public
     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
+      define_options :streaming,
+                     :buffer_class => 'ActiveSupport::SafeBuffer',
+                     :buffer => '@output_buffer',
+                     # output_buffer is needed for Rails 3.1 Streaming support
+                     :capture_generator => RailsOutputBuffer
 
       def call(exp)
         [preamble, compile(exp), postamble].join('; ')
@@ -157,5 +159,5 @@ module Temple
     end
   end
 
-  Generator.default_options[:capture_generator] = Temple::Generators::StringBuffer
+  Generator.default_options[:capture_generator] = Generators::StringBuffer
 end

data/lib/temple/grammar.rb

@@ -44,7 +44,7 @@ module Temple
       Symbol | String
 
     Case <<
-      [Condition, 'Expression*']
+      [Condition, Expression]
 
     Condition <<
       String | :else

data/lib/temple/hash.rb

@@ -28,6 +28,12 @@ module Temple
     def values
       keys.map {|k| self[k] }
     end
+
+    def to_hash
+      result = {}
+      each {|k, v| result[k] = v }
+      result
+    end
   end
 
   # Mutable hash class which supports hash merging
@@ -45,4 +51,54 @@ module Temple
       @hash.first.update(hash)
     end
   end
+
+  class OptionHash < MutableHash
+    def initialize(*hash, &block)
+      super(*hash)
+      @handler = block
+      @valid = {}
+      @deprecated = {}
+    end
+
+    def []=(key, value)
+      validate_key!(key)
+      super
+    end
+
+    def update(hash)
+      validate_hash!(hash)
+      super
+    end
+
+    def valid_keys
+      keys.concat(@valid.keys).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_hash!(hash)
+      hash.to_hash.keys.each {|key| validate_key!(key) }
+    end
+
+    def validate_key!(key)
+      @handler.call(self, key, true) if deprecated_key?(key)
+      @handler.call(self, key, false) unless valid_key?(key)
+    end
+
+    def deprecated_key?(key)
+      @deprecated.include?(key) ||
+        @hash.any? {|h| h.deprecated_key?(key) if h.respond_to?(:deprecated_key?) }
+    end
+
+    def valid_key?(key)
+      include?(key) || @valid.include?(key) ||
+        @hash.any? {|h| h.valid_key?(key) if h.respond_to?(:valid_key?) }
+    end
+  end
 end

data/lib/temple/html/attribute_merger.rb

@@ -3,45 +3,44 @@ module Temple
     # This filter merges html attributes (e.g. used for id and class)
     # @api public
     class AttributeMerger < Filter
-      default_options[:attr_delimiter] = {'id' => '_', 'class' => ' '}
+      define_options :attr_delimiter => {'id' => '_', 'class' => ' '}
 
       def on_html_attrs(*attrs)
         names = []
-        result = {}
+        values = {}
+
         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]
-          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]]
+          if values[name]
+            raise(FilterError, "Multiple #{name} attributes specified") unless options[:attr_delimiter][name]
+            values[name] << value
+          else
+            values[name] = [value]
+            names << name
+          end
+        end
+
+        attrs = names.map do |name|
+          value = values[name]
+          if (delimiter = options[:attr_delimiter][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
-              tmp = unique_name
-              result[name] = [:html, :attr, name,
-                              [:multi,
-                               result[name][3],
-                               [:capture, tmp, value],
-                               [:if, "!#{tmp}.empty?",
-                                [:multi,
-                                 [:static, delimiter],
-                                 [:dynamic, tmp]]]]]
+              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
-            result[name] = attr
-            names << name
+            [:html, :attr, name, value.first]
           end
         end
-        [:html, :attrs, *names.map {|name| result[name] }]
+
+        [:html, :attrs, *attrs]
       end
     end
   end

data/lib/temple/html/attribute_remover.rb

@@ -3,17 +3,24 @@ module Temple
     # This filter removes empty attributes
     # @api public
     class AttributeRemover < Filter
-      default_options[:remove_empty_attrs] = true
+      define_options :remove_empty_attrs => %w(id class)
+
+      def initialize(opts = {})
+        super
+        raise ArgumentError, "Option :remove_empty_attrs must be an Array of Strings" unless Array === options[:remove_empty_attrs] &&
+          options[:remove_empty_attrs].all? {|a| String === a }
+      end
 
       def on_html_attrs(*attrs)
-        [:multi, *(options[:remove_empty_attrs] ?
-                   attrs.map {|attr| compile(attr) } : attrs)]
+        [:multi, *attrs.map {|attr| compile(attr) }]
       end
 
       def on_html_attr(name, value)
+        return super unless options[:remove_empty_attrs].include?(name.to_s)
+
         if empty_exp?(value)
           value
-        elsif contains_static?(value)
+        elsif contains_nonempty_static?(value)
           [:html, :attr, name, value]
         else
           tmp = unique_name

data/lib/temple/html/attribute_sorter.rb

@@ -3,14 +3,18 @@ module Temple
     # This filter sorts html attributes.
     # @api public
     class AttributeSorter < Filter
-      default_options[:sort_attrs] = true
+      define_options :sort_attrs => true
+
+      def call(exp)
+        options[:sort_attrs] ? super : exp
+      end
 
       def on_html_attrs(*attrs)
-        attrs = attrs.sort_by do |attr|
+        n = 0 # Use n to make sort stable. This is important because the merger could be executed afterwards.
+        [:html, :attrs, *attrs.sort_by do |attr|
           raise(InvalidExpression, 'Attribute is not a html attr') if attr[0] != :html || attr[1] != :attr
-          attr[2].to_s
-        end if options[:sort_attrs]
-        [:html, :attrs, *attrs]
+          [attr[2].to_s, n += 1]
+        end]
       end
     end
   end

data/lib/temple/html/fast.rb

@@ -21,16 +21,16 @@ module Temple
         '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]
+      define_options :format => :xhtml,
+                     :attr_wrapper => "'",
+                     :autoclose => %w[meta img link br hr input area param col base]
 
       HTML = [:html, :html4, :html5]
 
       def initialize(opts = {})
         super
         unless [:xhtml, *HTML].include?(options[:format])
-          raise "Invalid format #{options[:format].inspect}"
+          raise ArgumentError, "Invalid format #{options[:format].inspect}"
         end
       end
 
@@ -46,13 +46,13 @@ module Temple
         type = type.to_s.downcase
 
         if type =~ /^xml(\s+(.+))?$/
-          raise 'Invalid xml directive in html mode' if html?
+          raise(FilterError, 'Invalid xml directive in html mode') if html?
           w = options[:attr_wrapper]
           str = "<?xml version=#{w}1.0#{w} encoding=#{w}#{$2 || 'utf-8'}#{w} ?>"
         elsif html?
-          str = HTML_DOCTYPES[type] || raise("Invalid html doctype #{type}")
+          str = HTML_DOCTYPES[type] || raise(FilterError, "Invalid html doctype #{type}")
         else
-          str = XHTML_DOCTYPES[type] || raise("Invalid xhtml doctype #{type}")
+          str = XHTML_DOCTYPES[type] || raise(FilterError, "Invalid xhtml doctype #{type}")
         end
 
         [:static, str]

data/lib/temple/html/filter.rb

@@ -3,6 +3,19 @@ module Temple
     # @api public
     class Filter < Temple::Filter
       include Dispatcher
+
+      def contains_nonempty_static?(exp)
+        case exp.first
+        when :multi
+          exp[1..-1].any? {|e| contains_nonempty_static?(e) }
+        when :escape
+          contains_nonempty_static?(exp.last)
+        when :static
+          !exp.last.empty?
+        else
+          false
+        end
+      end
     end
   end
 end

data/lib/temple/html/pretty.rb

@@ -2,14 +2,14 @@ module Temple
   module HTML
     # @api public
     class Pretty < Fast
-      set_default_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 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
+      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 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 = {})
         super

data/lib/temple/mixins/engine_dsl.rb

@@ -96,11 +96,11 @@ module Temple
       end
 
       def chain_class_constructor(filter, option_filter)
-        local_options = Hash === option_filter.last ? option_filter.pop : nil
+        local_options = option_filter.last.respond_to?(:to_hash) ? option_filter.pop.to_hash : {}
         raise(ArgumentError, 'Only symbols allowed in option filter') unless option_filter.all? {|o| Symbol === o }
+        define_options(*option_filter) if respond_to?(:define_options)
         proc do |engine|
-          filtered_options = Hash[*option_filter.select {|k| engine.options.include?(k) }.map {|k| [k, engine.options[k]] }.flatten]
-          filter.new(ImmutableHash.new(local_options, filtered_options))
+          filter.new({}.update(engine.options).delete_if {|k,v| !option_filter.include?(k) }.update(local_options))
         end
       end
 

data/lib/temple/mixins/grammar_dsl.rb

@@ -157,7 +157,7 @@ module Temple
           curr.each {|c| c << elem }
           start
         else
-          raise "Invalid grammar rule '#{rule.inspect}'"
+          raise ArgumentError, "Invalid grammar rule '#{rule.inspect}'"
         end
       end
 

data/lib/temple/mixins/options.rb

@@ -2,26 +2,83 @@ module Temple
   module Mixins
     # @api public
     module DefaultOptions
-      def set_default_options(options)
-        default_options.update(options)
+      def set_default_options(opts)
+        default_options.update(opts)
       end
 
       def default_options
-        @default_options ||= MutableHash.new(superclass.respond_to?(:default_options) ?
-                                             superclass.default_options : nil)
+        @default_options ||= OptionHash.new(superclass.respond_to?(:default_options) ?
+                                            superclass.default_options : nil) do |hash, key, deprecated|
+          unless @option_validator_disabled
+            if deprecated
+              puts "Option #{key.inspect} is deprecated by #{self}"
+            else
+              # TODO: This will raise an exception in the future!
+              # raise ArgumentError, "Option #{key.inspect} is not supported by #{self}"
+              puts "Option #{key.inspect} is not supported by #{self}"
+            end
+          end
+        end
+      end
+
+      def define_options(*opts)
+        if opts.last.respond_to?(:to_hash)
+          hash = opts.pop.to_hash
+          default_options.add_valid_keys(hash.keys)
+          default_options.update(hash)
+        end
+        default_options.add_valid_keys(opts)
+      end
+
+      def define_deprecated_options(*opts)
+        if opts.last.respond_to?(:to_hash)
+          hash = opts.pop.to_hash
+          default_options.add_deprecated_keys(hash.keys)
+          default_options.update(hash)
+        end
+        default_options.add_deprecated_keys(opts)
+      end
+
+      def disable_option_validator!
+        @option_validator_disabled = true
+      end
+    end
+
+    module ThreadOptions
+      def with_options(options)
+        old_options = thread_options
+        Thread.current[thread_options_key] = ImmutableHash.new(options, thread_options)
+        yield
+      ensure
+        Thread.current[thread_options_key] = old_options
+      end
+
+      def thread_options
+        Thread.current[thread_options_key]
+      end
+
+      protected
+
+      def thread_options_key
+        @thread_options_key ||= "#{self.name}-thread-options".to_sym
       end
     end
 
     # @api public
     module Options
       def self.included(base)
-        base.class_eval { extend DefaultOptions }
+        base.class_eval do
+          extend DefaultOptions
+          extend ThreadOptions
+        end
       end
 
       attr_reader :options
 
-      def initialize(options = {})
-        @options = ImmutableHash.new(options, self.class.default_options)
+      def initialize(opts = {})
+        self.class.default_options.validate_hash!(opts)
+        self.class.default_options.validate_hash!(self.class.thread_options) if self.class.thread_options
+        @options = ImmutableHash.new({}.update(self.class.default_options).update(self.class.thread_options || {}).update(opts))
       end
     end
   end

data/lib/temple/mixins/template.rb

@@ -4,39 +4,25 @@ module Temple
     module Template
       include DefaultOptions
 
-      def engine(engine = nil)
-        default_options[:engine] = engine if engine
-        default_options[:engine]
-      end
-
-      def init
-        # Overwrite this for class initialization
+      def compile(code, options)
+        engine = options.delete(:engine)
+        raise 'No engine configured' unless engine
+        engine.new(options).call(code)
       end
 
-      def register_as(name)
+      def register_as(*names)
         raise NotImplementedError
       end
 
       def create(engine, options)
+        register_as = options.delete(:register_as)
         template = Class.new(self)
+        template.disable_option_validator!
         template.default_options[:engine] = engine
         template.default_options.update(options)
-        template.init
-        template.register_as(options[:register_as]) if options[:register_as]
+        template.register_as(*register_as) if register_as
         template
       end
-
-      def build_engine(*options)
-        raise 'No engine configured' unless engine
-        options << default_options
-        engine.new(ImmutableHash.new(*options))
-      end
-
-      def chain(&block)
-        chain = (default_options[:chain] ||= [])
-        chain << block if block
-        chain
-      end
     end
   end
 end

data/lib/temple/parser.rb

@@ -0,0 +1,8 @@
+module Temple
+  # Temple base parser
+  # @api public
+  class Parser
+    include Utils
+    include Mixins::Options
+  end
+end

data/lib/temple/templates/rails.rb

@@ -14,12 +14,15 @@ module Temple
         extend Mixins::Template
 
         def compile(template)
-          self.class.build_engine(:streaming => false, # Overwrite option: No streaming support in Rails < 3.1
-                                  :file => template.identifier).call(template.source)
+          # Overwrite option: No streaming support in Rails < 3.1
+          opts = {}.update(self.class.default_options).update(:file => template.identifier, :streaming => false)
+          self.class.compile(template.source, opts)
         end
 
-        def self.register_as(name)
-          ActionView::Template.register_template_handler name.to_sym, self
+        def self.register_as(*names)
+          names.each do |name|
+            ActionView::Template.register_template_handler name.to_sym, self
+          end
         end
       end
     else
@@ -27,15 +30,18 @@ module Temple
         extend Mixins::Template
 
         def call(template)
-          self.class.build_engine(:file => template.identifier).call(template.source)
+          opts = {}.update(self.class.default_options).update(:file => template.identifier)
+          self.class.compile(template.source, opts)
         end
 
         def supports_streaming?
           self.class.default_options[:streaming]
         end
 
-        def self.register_as(name)
-          ActionView::Template.register_template_handler name.to_sym, new
+        def self.register_as(*names)
+          names.each do |name|
+            ActionView::Template.register_template_handler name.to_sym, new
+          end
         end
       end
     end

data/lib/temple/templates/tilt.rb

@@ -5,14 +5,27 @@ module Temple
     class Tilt < ::Tilt::Template
       extend Mixins::Template
 
+      define_options :mime_type => 'text/html'
+
+      def self.default_mime_type
+        default_options[:mime_type]
+      end
+
+      def self.default_mime_type=(mime_type)
+        default_options[:mime_type] = mime_type
+      end
+
       # Prepare Temple template
       #
       # Called immediately after template data is loaded.
       #
       # @return [void]
       def prepare
-        @src = self.class.build_engine({ :streaming => false, # Overwrite option: No streaming support in Tilt
-                                         :file => eval_file }, options).call(data)
+        # Overwrite option: No streaming support in Tilt
+        opts = {}.update(self.class.default_options).update(options).update(:file => eval_file, :streaming => false)
+        opts.delete(:mime_type)
+        opts.delete(:outvar) # Sinatra gives us this invalid variable
+        @src = self.class.compile(data, opts)
       end
 
       # A string containing the (Ruby) source code for the template.
@@ -23,12 +36,8 @@ module Temple
         @src
       end
 
-      def self.init
-        self.default_mime_type = default_options[:mime_type] || 'text/html'
-      end
-
-      def self.register_as(name)
-        ::Tilt.register name.to_s, self
+      def self.register_as(*names)
+        ::Tilt.register(self, *names.map(&:to_s))
       end
     end
   end

data/lib/temple/utils.rb

@@ -18,7 +18,7 @@ module Temple
       # @param html [String] The string to escape
       # @return [String] The escaped string
       def escape_html(html)
-        EscapeUtils.escape_html(html.to_s)
+        EscapeUtils.escape_html(html.to_s, false)
       end
     elsif RUBY_VERSION > '1.9'
       # Used by escape_html
@@ -28,7 +28,6 @@ module Temple
         '"' => '"',
         '<' => '&lt;',
         '>' => '&gt;',
-        '/' => '&#47;',
       }.freeze
 
       # Returns an escaped copy of `html`.
@@ -36,7 +35,7 @@ module Temple
       # @param html [String] The string to escape
       # @return [String] The escaped string
       def escape_html(html)
-        html.to_s.gsub(/[&\"<>\/]/, ESCAPE_HTML)
+        html.to_s.gsub(/[&\"<>]/, ESCAPE_HTML)
       end
     else
       # Returns an escaped copy of `html`.
@@ -44,7 +43,7 @@ module Temple
       # @param html [String] The string to escape
       # @return [String] The escaped string
       def escape_html(html)
-        html.to_s.gsub(/&/n, '&amp;').gsub(/\"/n, '&quot;').gsub(/>/n, '&gt;').gsub(/</n, '&lt;').gsub(/\//, '&#47;')
+        html.to_s.gsub(/&/n, '&amp;').gsub(/\"/n, '&quot;').gsub(/>/n, '&gt;').gsub(/</n, '&lt;')
       end
     end
 
@@ -58,19 +57,6 @@ module Temple
       "_#{prefix}#{@unique_name += 1}"
     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
-
     # Check if expression is empty
     #
     # @param exp [Array] Temple expression

data/lib/temple/version.rb

@@ -1,3 +1,3 @@
 module Temple
-  VERSION = '0.4.1'
+  VERSION = '0.5.4'
 end

data/temple.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |s|
 
   s.authors       = ['Magnus Holm', 'Daniel Mendler']
   s.email         = ['judofyr@gmail.com', 'mail@daniel-mendler.de']
-  s.homepage      = 'http://dojo.rubyforge.org/'
+  s.homepage      = 'https://github.com/judofyr/temple'
   s.summary       = 'Template compilation framework in Ruby'
 
   s.require_paths = %w(lib)

data/test/filters/test_control_flow.rb

@@ -56,14 +56,13 @@ describe Temple::Filters::ControlFlow do
 
   it 'should process cond' do
     @filter.call([:cond,
-      ['cond1', [:exp11], [:exp12]],
+      ['cond1', [:exp1]],
       ['cond2', [:exp2]],
       [:else,   [:exp3]],
     ]).should.equal [:multi,
       [:code, 'case'],
       [:code, 'when cond1'],
-      [:exp11],
-      [:exp12],
+      [:exp1],
       [:code, 'when cond2'],
       [:exp2],
       [:code, 'else'],
@@ -74,14 +73,13 @@ describe Temple::Filters::ControlFlow do
 
   it 'should process case' do
     @filter.call([:case, 'var',
-      ['Array',  [:exp11], [:exp12]],
+      ['Array',  [:exp1]],
       ['String', [:exp2]],
       [:else,    [:exp3]],
     ]).should.equal [:multi,
       [:code, 'case (var)'],
       [:code, 'when Array'],
-      [:exp11],
-      [:exp12],
+      [:exp1],
       [:code, 'when String'],
       [:exp2],
       [:code, 'else'],

data/test/html/test_attribute_merger.rb

@@ -50,13 +50,10 @@ describe Temple::HTML::AttributeMerger do
                      [:html, :attrs,
                       [:html, :attr, "id",
                        [:multi,
-                        [:dynamic, "a"],
-                        [:capture, "_temple_html_attributemerger1",
-                         [:dynamic, "b"]],
-                        [:if, "!_temple_html_attributemerger1.empty?",
-                         [:multi,
-                          [:static, "_"],
-                          [:dynamic, "_temple_html_attributemerger1"]]]]]],
+                        [:code, "_temple_html_attributemerger1 = []"],
+                        [:capture, "_temple_html_attributemerger1[0]", [:dynamic, "a"]],
+                        [:capture, "_temple_html_attributemerger1[1]", [:dynamic, "b"]],
+                        [:dynamic, "_temple_html_attributemerger1.reject(&:empty?).join(\"_\")"]]]],
                      [:content]]
   end
 
@@ -69,13 +66,10 @@ describe Temple::HTML::AttributeMerger do
                      [:html, :attrs,
                       [:html, :attr, "class",
                        [:multi,
-                        [:static, "a"],
-                        [:capture, "_temple_html_attributemerger1",
-                         [:dynamic, "b"]],
-                        [:if, "!_temple_html_attributemerger1.empty?",
-                         [:multi,
-                          [:static, " "],
-                          [:dynamic, "_temple_html_attributemerger1"]]]]]],
+                        [:code, "_temple_html_attributemerger1 = []"],
+                        [:capture, "_temple_html_attributemerger1[0]", [:static, "a"]],
+                        [:capture, "_temple_html_attributemerger1[1]", [:dynamic, "b"]],
+                        [:dynamic, "_temple_html_attributemerger1.reject(&:empty?).join(\" \")"]]]],
                      [:content]]
   end
 end

data/test/html/test_attribute_remover.rb

@@ -3,7 +3,6 @@ require 'helper'
 describe Temple::HTML::AttributeRemover do
   before do
     @remover = Temple::HTML::AttributeRemover.new
-    @disabled_remover = Temple::HTML::AttributeRemover.new :remove_empty_attrs => false
   end
 
   it 'should pass static attributes through' do
@@ -17,7 +16,7 @@ describe Temple::HTML::AttributeRemover do
                      [:content]]
   end
 
-  it 'should check for empty dynamic attribute if :remove_empty_attrs is true' do
+  it 'should check for empty dynamic attribute if it is included in :remove_empty_attrs' do
     @remover.call([:html, :tag,
       'div',
       [:html, :attrs, [:html, :attr, 'class', [:dynamic, 'b']]],
@@ -31,14 +30,14 @@ describe Temple::HTML::AttributeRemover do
                      [:content]]
   end
 
-  it 'should not check for empty dynamic attribute if :remove_empty_attrs is false' do
-    @disabled_remover.call([:html, :tag,
+  it 'should not check for empty dynamic attribute if it is not included in :remove_empty_attrs' do
+    @remover.call([:html, :tag,
       'div',
-      [:html, :attrs, [:html, :attr, 'class', [:dynamic, 'b']]],
+      [:html, :attrs, [:html, :attr, 'name', [:dynamic, 'b']]],
       [:content]
     ]).should.equal [:html, :tag, "div",
                      [:multi,
-                      [:html, :attr, "class", [:dynamic, "b"]]],
+                      [:html, :attr, "name", [:dynamic, "b"]]],
                      [:content]]
   end
 end

data/test/test_engine.rb

@@ -167,12 +167,4 @@ describe Temple::Engine do
     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 8
-    engine.chain.size.should.equal 7
-    engine.chain[0].first.should.equal :Parser
-    engine.chain[1].first.should.equal :MyFilter2
-  end
 end

data/test/test_erb.rb

@@ -38,13 +38,13 @@ world}
   it 'should escape automatically' do
     src = '<%= "<" %>'
     ans = '&lt;'
-    erb(src, :auto_escape => true).should.equal ans
+    erb(src).should.equal ans
   end
 
   it 'should support == to disable automatic escape' do
     src = '<%== "<" %>'
     ans = '<'
-    erb(src, :auto_escape => true).should.equal ans
+    erb(src).should.equal ans
   end
 
   it 'should support trim mode' do

data/test/test_filter.rb

@@ -1,6 +1,8 @@
 require 'helper'
 
 class SimpleFilter < Temple::Filter
+  define_options :key
+
   def on_test(arg)
     [:on_test, arg]
   end
@@ -10,8 +12,9 @@ describe Temple::Filter do
   it 'should support options' do
     Temple::Filter.should.respond_to :default_options
     Temple::Filter.should.respond_to :set_default_options
+    Temple::Filter.should.respond_to :define_options
     Temple::Filter.new.options.should.be.instance_of Temple::ImmutableHash
-    Temple::Filter.new(:key => 3).options[:key].should.equal 3
+    SimpleFilter.new(:key => 3).options[:key].should.equal 3
   end
 
   it 'should implement call' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: temple
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.4
   prerelease: 
 platform: ruby
 authors:
@@ -10,11 +10,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-04 00:00:00.000000000 Z
+date: 2012-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tilt
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &6391160 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -22,15 +22,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+  version_requirements: *6391160
 - !ruby/object:Gem::Dependency
   name: bacon
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &6390120 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -38,15 +33,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+  version_requirements: *6390120
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &6389580 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,12 +44,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+  version_requirements: *6389580
 description: 
 email:
 - judofyr@gmail.com
@@ -83,6 +68,7 @@ files:
 - lib/temple/erb/parser.rb
 - lib/temple/erb/template.rb
 - lib/temple/erb/trimming.rb
+- lib/temple/exceptions.rb
 - lib/temple/filter.rb
 - lib/temple/filters/control_flow.rb
 - lib/temple/filters/dynamic_inliner.rb
@@ -106,6 +92,7 @@ files:
 - lib/temple/mixins/grammar_dsl.rb
 - lib/temple/mixins/options.rb
 - lib/temple/mixins/template.rb
+- lib/temple/parser.rb
 - lib/temple/templates.rb
 - lib/temple/templates/rails.rb
 - lib/temple/templates/tilt.rb
@@ -133,7 +120,7 @@ files:
 - test/test_grammar.rb
 - test/test_hash.rb
 - test/test_utils.rb
-homepage: http://dojo.rubyforge.org/
+homepage: https://github.com/judofyr/temple
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -153,7 +140,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.15
 signing_key: 
 specification_version: 3
 summary: Template compilation framework in Ruby