temple 0.6.10 → 0.7.1

data/lib/temple/map.rb

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

data/lib/temple/mixins/engine_dsl.rb

@@ -79,9 +79,9 @@ module Temple
       end
 
       # Shortcuts to access namespaces
-      { :filter    => Temple::Filters,
-        :generator => Temple::Generators,
-        :html      => Temple::HTML }.each do |method, mod|
+      { filter: Temple::Filters,
+        generator: Temple::Generators,
+        html: Temple::HTML }.each do |method, mod|
         define_method(method) do |name, *options|
           use(name, mod.const_get(name), *options)
         end
@@ -95,12 +95,13 @@ module Temple
         name
       end
 
-      def chain_class_constructor(filter, option_filter)
-        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)
+      def chain_class_constructor(filter, local_options)
+        define_options(filter.options.valid_keys) if respond_to?(:define_options) && filter.respond_to?(:options)
         proc do |engine|
-          filter.new({}.update(engine.options).delete_if {|k,v| !option_filter.include?(k) }.update(local_options))
+          opts = {}.update(engine.options)
+          opts.delete_if {|k,v| !filter.options.valid_key?(k) } if filter.respond_to?(:options)
+          opts.update(local_options) if local_options
+          filter.new(opts)
         end
       end
 
@@ -157,7 +158,8 @@ module Temple
         when Class
           # Class argument (e.g Filter class)
           # The options are passed to the classes constructor.
-          [name, chain_class_constructor(filter, args)]
+          raise(ArgumentError, 'Too many arguments') if args.size > 1
+          [name, chain_class_constructor(filter, args.first)]
         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.

data/lib/temple/mixins/options.rb

@@ -1,42 +1,44 @@
 module Temple
   module Mixins
     # @api public
-    module DefaultOptions
+    module ClassOptions
       def set_default_options(opts)
-        default_options.update(opts)
+        warn 'set_default_options has been deprecated, use set_options'
+        set_options(opts)
       end
 
       def default_options
-        @default_options ||= OptionHash.new(superclass.respond_to?(:default_options) ?
-                                            superclass.default_options : nil) do |hash, key, deprecated|
-          unless @option_validator_disabled
-            if deprecated
-              warn "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}"
-              warn "Option #{key.inspect} is not supported by #{self}"
-            end
-          end
+        warn 'default_options has been deprecated, use options'
+        options
+      end
+
+      def set_options(opts)
+        options.update(opts)
+      end
+
+      def options
+        @options ||= OptionMap.new(superclass.respond_to?(:options) ?
+                                   superclass.options : nil) do |hash, key, what|
+          warn "#{self}: Option #{key.inspect} is #{what}" unless @option_validator_disabled
         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)
+          options.add_valid_keys(hash.keys)
+          options.update(hash)
         end
-        default_options.add_valid_keys(opts)
+        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)
+          options.add_deprecated_keys(hash.keys)
+          options.update(hash)
         end
-        default_options.add_deprecated_keys(opts)
+        options.add_deprecated_keys(opts)
       end
 
       def disable_option_validator!
@@ -47,7 +49,7 @@ module Temple
     module ThreadOptions
       def with_options(options)
         old_options = thread_options
-        Thread.current[thread_options_key] = ImmutableHash.new(options, thread_options)
+        Thread.current[thread_options_key] = ImmutableMap.new(options, thread_options)
         yield
       ensure
         Thread.current[thread_options_key] = old_options
@@ -68,7 +70,7 @@ module Temple
     module Options
       def self.included(base)
         base.class_eval do
-          extend DefaultOptions
+          extend ClassOptions
           extend ThreadOptions
         end
       end
@@ -76,9 +78,9 @@ module Temple
       attr_reader :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))
+        self.class.options.validate_map!(opts)
+        self.class.options.validate_map!(self.class.thread_options) if self.class.thread_options
+        @options = ImmutableMap.new({}.update(self.class.options).update(self.class.thread_options || {}).update(opts))
       end
     end
   end

data/lib/temple/mixins/template.rb

@@ -2,7 +2,7 @@ module Temple
   module Mixins
     # @api private
     module Template
-      include DefaultOptions
+      include ClassOptions
 
       def compile(code, options)
         engine = options.delete(:engine)
@@ -18,8 +18,8 @@ module Temple
         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.options[:engine] = engine
+        template.options.update(options)
         template.register_as(*register_as) if register_as
         template
       end

data/lib/temple/templates/rails.rb

@@ -1,47 +1,24 @@
-unless defined?(ActionView)
-  raise "Rails is not loaded - Temple::Templates::Rails cannot be used"
-end
-
-if ::ActionPack::VERSION::MAJOR < 3
-  raise "Temple supports only Rails 3.x and greater, your Rails version is #{::ActionPack::VERSION::STRING}"
-end
-
 module Temple
   module Templates
-    if ::ActionPack::VERSION::MAJOR == 3 && ::ActionPack::VERSION::MINOR < 1
-      class Rails < ActionView::TemplateHandler
-        include ActionView::TemplateHandlers::Compilable
-        extend Mixins::Template
-
-        def compile(template)
-          # 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
+    class Rails
+      extend Mixins::Template
 
-        def self.register_as(*names)
-          names.each do |name|
-            ActionView::Template.register_template_handler name.to_sym, self
-          end
-        end
+      def call(template)
+        opts = {}.update(self.class.options).update(file: template.identifier)
+        self.class.compile(template.source, opts)
       end
-    else
-      class Rails
-        extend Mixins::Template
 
-        def call(template)
-          opts = {}.update(self.class.default_options).update(:file => template.identifier)
-          self.class.compile(template.source, opts)
-        end
+      def supports_streaming?
+        self.class.options[:streaming]
+      end
 
-        def supports_streaming?
-          self.class.default_options[:streaming]
+      def self.register_as(*names)
+        raise 'Rails is not loaded - Temple::Templates::Rails cannot be used' unless defined?(::ActionView)
+        if ::ActiveSupport::VERSION::MAJOR < 3 || ::ActiveSupport::VERSION::MAJOR == 3 && ::ActiveSupport::VERSION::MINOR < 1
+          raise "Temple supports only Rails 3.1 and greater, your Rails version is #{::ActiveSupport::VERSION::STRING}"
         end
-
-        def self.register_as(*names)
-          names.each do |name|
-            ActionView::Template.register_template_handler name.to_sym, new
-          end
+        names.each do |name|
+          ::ActionView::Template.register_template_handler name.to_sym, new
         end
       end
     end

data/lib/temple/templates/tilt.rb

@@ -5,14 +5,14 @@ module Temple
     class Tilt < ::Tilt::Template
       extend Mixins::Template
 
-      define_options :mime_type => 'text/html'
+      define_options mime_type: 'text/html'
 
       def self.default_mime_type
-        default_options[:mime_type]
+        options[:mime_type]
       end
 
       def self.default_mime_type=(mime_type)
-        default_options[:mime_type] = mime_type
+        options[:mime_type] = mime_type
       end
 
       # Prepare Temple template
@@ -21,7 +21,7 @@ module Temple
       #
       # @return [void]
       def prepare
-        opts = {}.update(self.class.default_options).update(options).update(:file => eval_file)
+        opts = {}.update(self.class.options).update(options).update(file: eval_file)
         opts.delete(:mime_type)
         if opts.include?(:outvar)
           opts[:buffer] = opts.delete(:outvar)

data/lib/temple/utils.rb

@@ -13,10 +13,9 @@ module Temple
     # Strings which are declared as html_safe are not escaped.
     #
     # @param html [String] The string to escape
-    # @param safe [Boolean] If false use escape_html
     # @return [String] The escaped string
-    def escape_html_safe(html, safe = true)
-      safe && html.html_safe? ? html : escape_html(html)
+    def escape_html_safe(html)
+      html.html_safe? ? html : escape_html(html)
     end
 
     if defined?(EscapeUtils)
@@ -38,30 +37,14 @@ module Temple
         '>'  => '>'
       }.freeze
 
-      if //.respond_to?(:encoding)
-        ESCAPE_HTML_PATTERN = Regexp.union(*ESCAPE_HTML.keys)
-      else
-        # On 1.8, there is a kcode = 'u' bug that allows for XSS otherwise
-        # TODO doesn't apply to jruby, so a better condition above might be preferable?
-        ESCAPE_HTML_PATTERN = /#{Regexp.union(*ESCAPE_HTML.keys)}/n
-      end
+      ESCAPE_HTML_PATTERN = Regexp.union(*ESCAPE_HTML.keys)
 
-      if RUBY_VERSION > '1.9'
-        # Returns an escaped copy of `html`.
-        #
-        # @param html [String] The string to escape
-        # @return [String] The escaped string
-        def escape_html(html)
-          html.to_s.gsub(ESCAPE_HTML_PATTERN, ESCAPE_HTML)
-        end
-      else
-        # Returns an escaped copy of `html`.
-        #
-        # @param html [String] The string to escape
-        # @return [String] The escaped string
-        def escape_html(html)
-          html.to_s.gsub(ESCAPE_HTML_PATTERN) {|c| ESCAPE_HTML[c] }
-        end
+      # Returns an escaped copy of `html`.
+      #
+      # @param html [String] The string to escape
+      # @return [String] The escaped string
+      def escape_html(html)
+        html.to_s.gsub(ESCAPE_HTML_PATTERN, ESCAPE_HTML)
       end
     end
 
@@ -89,5 +72,19 @@ module Temple
         false
       end
     end
+
+    def indent_dynamic(text, indent_next, indent, pre_tags = nil)
+      text = text.to_s
+      safe = text.respond_to?(:html_safe?) && text.html_safe?
+      return text if pre_tags && text =~ pre_tags
+
+      level = text.scan(/^\s*/).map(&:size).min
+      text = text.gsub(/^\s{#{level}}/, '') if level > 0
+
+      text = text.sub(/\A\s*\n?/, "\n") if indent_next
+      text = text.gsub("\n", indent)
+
+      safe ? text.html_safe : text
+    end
   end
 end

data/lib/temple/version.rb

@@ -1,3 +1,3 @@
 module Temple
-  VERSION = '0.6.10'
+  VERSION = '0.7.1'
 end

data/temple.gemspec

@@ -18,6 +18,8 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.license       = 'MIT'
 
+  s.required_ruby_version = '>=1.9.2'
+
   # Tilt is only development dependency because most parts of Temple
   # can be used without it.
   s.add_development_dependency('tilt')

data/test/filters/test_eraser.rb

@@ -2,7 +2,7 @@ require 'helper'
 
 describe Temple::Filters::Eraser do
   it 'should respect keep' do
-    eraser = Temple::Filters::Eraser.new(:keep => [:a])
+    eraser = Temple::Filters::Eraser.new(keep: [:a])
     eraser.call([:multi,
       [:a],
       [:b],
@@ -15,7 +15,7 @@ describe Temple::Filters::Eraser do
   end
 
   it 'should respect erase' do
-    eraser = Temple::Filters::Eraser.new(:erase => [:a])
+    eraser = Temple::Filters::Eraser.new(erase: [:a])
     eraser.call([:multi,
       [:a],
       [:b],
@@ -28,7 +28,7 @@ describe Temple::Filters::Eraser do
   end
 
   it 'should choose erase over keep' do
-    eraser = Temple::Filters::Eraser.new(:keep => [:a, :b], :erase => [:a])
+    eraser = Temple::Filters::Eraser.new(keep: [:a, :b], erase: [:a])
     eraser.call([:multi,
       [:a],
       [:b],
@@ -41,7 +41,7 @@ describe Temple::Filters::Eraser do
   end
 
   it 'should erase nested types' do
-    eraser = Temple::Filters::Eraser.new(:erase => [[:a, :b]])
+    eraser = Temple::Filters::Eraser.new(erase: [[:a, :b]])
     eraser.call([:multi,
       [:a, :a],
       [:a, :b],