temple 0.6.7 → 0.10.0

data/lib/temple/mixins/dispatcher.rb

@@ -58,12 +58,14 @@ module Temple
       def replace_dispatcher(exp)
         tree = DispatchNode.new
         dispatched_methods.each do |method|
-          method.split('_')[1..-1].inject(tree) {|node, type| node[type.to_sym] }.method = method
+          method.split('_'.freeze)[1..-1].inject(tree) {|node, type| node[type.to_sym] }.method = method
         end
-        self.class.class_eval %{def dispatcher(exp)
-  return replace_dispatcher(exp) if self.class != #{self.class}
-  #{tree.compile.gsub("\n", "\n  ")}
-end}
+        self.class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def dispatcher(exp)
+            return replace_dispatcher(exp) if self.class != #{self.class}
+            #{tree.compile.gsub("\n", "\n  ")}
+          end
+        RUBY
         dispatcher(exp)
       end
 
@@ -88,10 +90,11 @@ end}
             raise 'Invalid dispatcher node' unless method
             call_method
           else
-            code = "case(exp[#{level}])\n"
+            code = String.new
+            code << "case(exp[#{level}])\n"
             each do |key, child|
               code << "when #{key.inspect}\n  " <<
-                child.compile(level + 1, call_method).gsub("\n", "\n  ") << "\n"
+                child.compile(level + 1, call_method).gsub("\n".freeze, "\n  ".freeze) << "\n".freeze
             end
             code << "else\n  " << (call_method || 'exp') << "\nend"
           end

data/lib/temple/mixins/engine_dsl.rb

@@ -17,15 +17,7 @@ module Temple
 
       def remove(name)
         name = chain_name(name)
-        found = false
-        chain.reject! do |i|
-          if i.first == name
-            found = true
-          else
-            false
-          end
-        end
-        raise "#{name} not found" unless found
+        raise "#{name} not found" unless chain.reject! {|i| name === i.first }
         chain_modified!
       end
 
@@ -34,54 +26,31 @@ module Temple
       def before(name, *args, &block)
         name = chain_name(name)
         e = chain_element(args, block)
-        found, i = false, 0
-        while i < chain.size
-          if chain[i].first == name
-            found = true
-            chain.insert(i, e)
-            i += 2
-          else
-            i += 1
-          end
-        end
-        raise "#{name} not found" unless found
+        chain.map! {|f| name === f.first ? [e, f] : [f] }.flatten!(1)
+        raise "#{name} not found" unless chain.include?(e)
         chain_modified!
       end
 
       def after(name, *args, &block)
         name = chain_name(name)
         e = chain_element(args, block)
-        found, i = false, 0
-        while i < chain.size
-          if chain[i].first == name
-            found = true
-            i += 1
-            chain.insert(i, e)
-          end
-          i += 1
-        end
-        raise "#{name} not found" unless found
+        chain.map! {|f| name === f.first ? [f, e] : [f] }.flatten!(1)
+        raise "#{name} not found" unless chain.include?(e)
         chain_modified!
       end
 
       def replace(name, *args, &block)
         name = chain_name(name)
         e = chain_element(args, block)
-        found = false
-        chain.each_with_index do |c, i|
-          if c.first == name
-            found = true
-            chain[i] = e
-          end
-        end
-        raise "#{name} not found" unless found
+        chain.map! {|f| name === f.first ? e : f }
+        raise "#{name} not found" unless chain.include?(e)
         chain_modified!
       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
@@ -90,47 +59,51 @@ module Temple
       private
 
       def chain_name(name)
-        name = Class === name ? name.name.to_sym : name
-        raise(ArgumentError, 'Name argument must be Class or Symbol') unless Symbol === name
-        name
+        case name
+        when Class
+          name.name.to_sym
+        when Symbol, String
+          name.to_sym
+        when Regexp
+          name
+        else
+          raise(ArgumentError, 'Name argument must be Class, Symbol, String or Regexp')
+        end
       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
 
       def chain_proc_constructor(name, filter)
         raise(ArgumentError, 'Proc or blocks must have arity 0 or 1') if filter.arity > 1
         method_name = "FILTER #{name}"
-        if Class === self
-          define_method(method_name, &filter)
-          filter = instance_method(method_name)
+        c = Class === self ? self : singleton_class
+        filter = c.class_eval { define_method(method_name, &filter); instance_method(method_name) }
+        proc do |engine|
           if filter.arity == 1
-            proc {|engine| filter.bind(engine) }
+            # the proc takes one argument, e.g. use(:Filter) {|exp| exp }
+            filter.bind(engine)
           else
-            proc do |engine|
-              f = filter.bind(engine).call
-              raise 'Constructor must return callable object' unless f.respond_to?(:call)
+            f = filter.bind(engine).call
+            if f.respond_to? :call
+              # the proc returns a callable object, e.g. use(:Filter) { Filter.new }
               f
+            else
+              raise(ArgumentError, 'Proc or blocks must return a Callable or a Class') unless f.respond_to? :new
+              # the proc returns a class, e.g. use(:Filter) { Filter }
+              f.new(f.respond_to?(:options) ? engine.options.to_hash.select {|k,v| f.options.valid_key?(k) } : engine.options)
             end
           end
-        else
-          (class << self; self; end).class_eval { define_method(method_name, &filter) }
-          filter = method(method_name)
-          proc {|engine| filter }
         end
       end
 
-      def chain_callable_constructor(filter)
-        raise(ArgumentError, 'Class or callable argument is required') unless filter.respond_to?(:call)
-        proc {|engine| filter }
-      end
-
       def chain_element(args, block)
         name = args.shift
         if Class === name
@@ -157,12 +130,14 @@ 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.
           raise(ArgumentError, 'Too many arguments') unless args.empty?
-          [name, chain_callable_constructor(filter)]
+          raise(ArgumentError, 'Class or callable argument is required') unless filter.respond_to?(:call)
+          [name, proc { filter }]
         end
       end
     end

data/lib/temple/mixins/grammar_dsl.rb

@@ -7,6 +7,12 @@ module Temple
           @grammar = grammar
         end
 
+        def match?(exp)
+          match(exp, [])
+        end
+        alias === match?
+        alias =~ match?
+
         def |(rule)
           Or.new(@grammar, self, rule)
         end
@@ -53,10 +59,6 @@ module Temple
           success
         end
 
-        def match?(exp)
-          match(exp, [])
-        end
-
         def validate!(exp)
           unmatched = []
           unless match(exp, unmatched)
@@ -120,14 +122,13 @@ module Temple
       def match?(exp)
         const_get(:Expression).match?(exp)
       end
+      alias === match?
+      alias =~ match?
 
       def validate!(exp)
         const_get(:Expression).validate!(exp)
       end
 
-      alias === match?
-      alias =~ match?
-
       def Value(value)
         Value.new(self, value)
       end
@@ -142,7 +143,8 @@ module Temple
           start = Or.new(self)
           curr = [start]
           rule.each do |elem|
-            if elem =~ /^(.*)(\*|\?|\+)$/
+            case elem
+            when /^(.*)(\*|\?|\+)$/
               elem = Element.new(self, const_get($1))
               curr.each {|c| c << elem }
               elem << elem if $2 != '?'

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/static_analyzer.rb

@@ -0,0 +1,77 @@
+begin
+  require 'ripper'
+rescue LoadError
+end
+
+module Temple
+  module StaticAnalyzer
+    STATIC_TOKENS = [
+      :on_tstring_beg, :on_tstring_end, :on_tstring_content,
+      :on_embexpr_beg, :on_embexpr_end,
+      :on_lbracket, :on_rbracket,
+      :on_qwords_beg, :on_words_sep, :on_qwords_sep,
+      :on_lparen, :on_rparen,
+      :on_lbrace, :on_rbrace, :on_label,
+      :on_int, :on_float, :on_imaginary,
+      :on_comma, :on_sp, :on_ignored_nl,
+    ].freeze
+
+    DYNAMIC_TOKENS = [
+      :on_ident, :on_period,
+    ].freeze
+
+    STATIC_KEYWORDS = [
+      'true', 'false', 'nil',
+    ].freeze
+
+    STATIC_OPERATORS = [
+      '=>',
+    ].freeze
+
+    class << self
+      def available?
+        defined?(Ripper) && Ripper.respond_to?(:lex)
+      end
+
+      def static?(code)
+        return false if code.nil? || code.strip.empty?
+        return false if syntax_error?(code)
+
+        Ripper.lex(code).each do |_, token, str|
+          case token
+          when *STATIC_TOKENS
+            # noop
+          when :on_kw
+            return false unless STATIC_KEYWORDS.include?(str)
+          when :on_op
+            return false unless STATIC_OPERATORS.include?(str)
+          when *DYNAMIC_TOKENS
+            return false
+          else
+            return false
+          end
+        end
+        true
+      end
+
+      def syntax_error?(code)
+        SyntaxChecker.new(code).parse
+        false
+      rescue SyntaxChecker::ParseError
+        true
+      end
+    end
+
+    if defined?(Ripper)
+      class SyntaxChecker < Ripper
+        class ParseError < StandardError; end
+
+        private
+
+        def on_parse_error(*)
+          raise ParseError
+        end
+      end
+    end
+  end
+end

data/lib/temple/templates/rails.rb

@@ -1,47 +1,28 @@
-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
+    class Rails
+      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
-
-        def self.register_as(*names)
-          names.each do |name|
-            ActionView::Template.register_template_handler name.to_sym, self
-          end
+      def call(template, source = nil)
+        opts = {}.update(self.class.options).update(file: template.identifier)
+        if ActionView::Base.try(:annotate_rendered_view_with_filenames) && template.format == :html
+          opts[:preamble] = "<!-- BEGIN #{template.short_identifier} -->\n"
+          opts[:postamble] = "<!-- END #{template.short_identifier} -->\n"
         end
+        self.class.compile((source || 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 < 5
+          raise "Temple supports only Rails 5 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,15 +5,7 @@ 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
+      define_options mime_type: 'text/html'
 
       # Prepare Temple template
       #
@@ -21,10 +13,12 @@ module Temple
       #
       # @return [void]
       def prepare
-        # 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
+        opts = {}.update(self.class.options).update(options).update(file: eval_file)
+        metadata[:mime_type] = opts.delete(:mime_type)
+        if opts.include?(:outvar)
+          opts[:buffer] = opts.delete(:outvar)
+          opts[:save_buffer] = true
+        end
         @src = self.class.compile(data, opts)
       end
 

data/lib/temple/utils.rb

@@ -1,7 +1,6 @@
 begin
-  require 'escape_utils'
+  require 'cgi/escape'
 rescue LoadError
-  # Loading EscapeUtils failed
 end
 
 module Temple
@@ -15,16 +14,17 @@ module Temple
     # @param html [String] The string to escape
     # @return [String] The escaped string
     def escape_html_safe(html)
-      html.html_safe? ? html : escape_html(html)
+      s = html.to_s
+      s.html_safe? || html.html_safe? ? s : escape_html(s)
     end
 
-    if defined?(EscapeUtils)
+    if defined?(CGI.escapeHTML)
       # Returns an escaped copy of `html`.
       #
       # @param html [String] The string to escape
       # @return [String] The escaped string
       def escape_html(html)
-        EscapeUtils.escape_html(html.to_s, false)
+        CGI.escapeHTML(html.to_s)
       end
     else
       # Used by escape_html
@@ -37,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
 
@@ -70,7 +54,7 @@ module Temple
     # @return [String] Variable name
     def unique_name(prefix = nil)
       @unique_name ||= 0
-      prefix ||= (@unique_prefix ||= self.class.name.gsub('::', '_').downcase)
+      prefix ||= (@unique_prefix ||= self.class.name.gsub('::'.freeze, '_'.freeze).downcase)
       "_#{prefix}#{@unique_name += 1}"
     end
 
@@ -88,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(/(?!\A)^\s{#{level}}/, '') if level > 0
+
+      text = text.sub(/\A\s*\n?/, "\n".freeze) if indent_next
+      text = text.gsub("\n".freeze, indent)
+
+      safe ? text.html_safe : text
+    end
   end
 end

data/lib/temple/version.rb

@@ -1,3 +1,3 @@
 module Temple
-  VERSION = '0.6.7'
+  VERSION = '0.10.0'
 end