temple 0.2.0 → 0.3.0

data/lib/temple/{mixins.rb → mixins/engine_dsl.rb}

@@ -1,12 +1,18 @@
 module Temple
   module Mixins
+    # @api private
     module EngineDSL
+      def chain_modified!
+      end
+
       def append(*args, &block)
         chain << element(args, block)
+        chain_modified!
       end
 
       def prepend(*args, &block)
         chain.unshift(element(args, block))
+        chain_modified!
       end
 
       def remove(name)
@@ -17,6 +23,7 @@ module Temple
           equal
         end
         raise "#{name} not found" unless found
+        chain_modified!
       end
 
       alias use append
@@ -36,6 +43,7 @@ module Temple
           end
         end
         raise "#{name} not found" unless found
+        chain_modified!
       end
 
       def after(name, *args, &block)
@@ -52,6 +60,7 @@ module Temple
           i += 1
         end
         raise "#{name} not found" unless found
+        chain_modified!
       end
 
       def replace(name, *args, &block)
@@ -66,6 +75,7 @@ module Temple
           end
         end
         raise "#{name} not found" unless found
+        chain_modified!
       end
 
       def filter(name, *options, &block)
@@ -122,100 +132,5 @@ module Temple
         end
       end
     end
-
-    module CoreDispatcher
-      def on_multi(*exps)
-        [:multi, *exps.map {|exp| compile(exp) }]
-      end
-
-      def on_capture(name, exp)
-        [:capture, name, compile(exp)]
-      end
-
-      def on_escape(flag, exp)
-        [:escape, flag, compile(exp)]
-      end
-    end
-
-    module Dispatcher
-      include CoreDispatcher
-
-      def self.included(base)
-        base.class_eval { extend ClassMethods }
-      end
-
-      def call(exp)
-        compile(exp)
-      end
-
-      def compile(exp)
-        type, *args = exp
-        if respond_to?("on_#{type}")
-          send("on_#{type}", *args)
-        else
-          exp
-        end
-      end
-
-      module ClassMethods
-        def temple_dispatch(*bases)
-          bases.each do |base|
-            class_eval %{def on_#{base}(type, *args)
-              if respond_to?("on_" #{base.to_s.inspect} "_\#{type}")
-                send("on_" #{base.to_s.inspect} "_\#{type}", *args)
-              else
-                [:#{base}, type, *args]
-              end
-            end}
-          end
-        end
-      end
-    end
-
-    module DefaultOptions
-      def set_default_options(options)
-        default_options.update(options)
-      end
-
-      def default_options
-        @default_options ||= Utils::MutableHash.new(superclass.respond_to?(:default_options) ?
-                                                    superclass.default_options : nil)
-      end
-    end
-
-    module Options
-      def self.included(base)
-        base.class_eval { extend DefaultOptions }
-      end
-
-      attr_reader :options
-
-      def initialize(options = {})
-        @options = Utils::ImmutableHash.new(options, self.class.default_options)
-      end
-    end
-
-    module Template
-      include DefaultOptions
-
-      def engine(engine = nil)
-        default_options[:engine] = engine if engine
-        default_options[:engine]
-      end
-
-      def build_engine(*options)
-        raise 'No engine configured' unless engine
-        options << default_options
-        engine.new(Utils::ImmutableHash.new(*options)) do |e|
-          chain.each {|block| e.instance_eval(&block) }
-        end
-      end
-
-      def chain(&block)
-        chain = (default_options[:chain] ||= [])
-        chain << block if block
-        chain
-      end
-    end
   end
 end

data/lib/temple/mixins/grammar_dsl.rb

@@ -0,0 +1,166 @@
+module Temple
+  module Mixins
+    # @api private
+    module GrammarDSL
+      class Rule
+        def initialize(grammar)
+          @grammar = grammar
+        end
+
+        def |(rule)
+          Or.new(@grammar, self, rule)
+        end
+
+        def copy_to(grammar)
+          copy = dup.instance_eval { @grammar = grammar; self }
+          copy.after_copy(self) if copy.respond_to?(:after_copy)
+          copy
+        end
+      end
+
+      class Or < Rule
+        def initialize(grammar, *children)
+          super(grammar)
+          @children = children.map {|rule| @grammar.Rule(rule) }
+        end
+
+        def <<(rule)
+          @children << @grammar.Rule(rule)
+          self
+        end
+
+        alias | <<
+
+        def match(exp, unmatched)
+          tmp = []
+          @children.any? {|rule| rule.match(exp, tmp) } || (unmatched.push(*tmp) && false)
+        end
+
+        def after_copy(source)
+          @children = @children.map {|child| child.copy_to(@grammar) }
+        end
+      end
+
+      class Root < Or
+        def initialize(grammar, name)
+          super(grammar)
+          @name = name.to_sym
+        end
+
+        def match(exp, unmatched)
+          success = super
+          unmatched << [@name, exp] unless success
+          success
+        end
+
+        def match?(exp)
+          match(exp, [])
+        end
+
+        def validate!(exp)
+          unmatched = []
+          unless match(exp, unmatched)
+            require 'pp'
+            rule, exp = unmatched.sort_by {|r,e| [*e].flatten.size }.first
+            raise(InvalidExpression, PP.pp(exp, "#{@grammar}::#{rule} did not match\n"))
+          end
+        end
+
+        def copy_to(grammar)
+          grammar.const_defined?(@name) ? grammar.const_get(@name) : super
+        end
+
+        def after_copy(source)
+          @grammar.const_set(@name, self)
+          super
+        end
+      end
+
+      class Element < Or
+        def initialize(grammar, rule)
+          super(grammar)
+          @rule = grammar.Rule(rule)
+        end
+
+        def match(exp, unmatched)
+          return false unless Array === exp && !exp.empty?
+          head, *tail = exp
+          @rule.match(head, unmatched) && super(tail, unmatched)
+        end
+
+        def after_copy(source)
+          @children = @children.map do |child|
+            child == source ? self : child.copy_to(@grammar)
+          end
+          @rule = @rule.copy_to(@grammar)
+        end
+      end
+
+      class Value < Rule
+        def initialize(grammar, value)
+          super(grammar)
+          @value = value
+        end
+
+        def match(exp, unmatched)
+          @value === exp
+        end
+      end
+
+      def extended(mod)
+        mod.extend GrammarDSL
+        constants.each do |name|
+          const_get(name).copy_to(mod) if Rule === const_get(name)
+        end
+      end
+
+      def match?(exp)
+        const_get(:Expression).match?(exp)
+      end
+
+      def validate!(exp)
+        const_get(:Expression).validate!(exp)
+      end
+
+      alias === match?
+      alias =~ match?
+
+      def Value(value)
+        Value.new(self, value)
+      end
+
+      def Rule(rule)
+        case rule
+        when Rule
+          rule
+        when Symbol, Class, true, false, nil
+          Value(rule)
+        when Array
+          start = Or.new(self)
+          curr = [start]
+          rule.each do |elem|
+            if elem =~ /^(.*)(\*|\?|\+)$/
+              elem = Element.new(self, const_get($1))
+              curr.each {|c| c << elem }
+              elem << elem if $2 != '?'
+              curr = $2 == '+' ? [elem] : (curr << elem)
+            else
+              elem = Element.new(self, elem)
+              curr.each {|c| c << elem }
+              curr = [elem]
+            end
+          end
+          elem = Value([])
+          curr.each {|c| c << elem }
+          start
+        else
+          raise "Invalid grammar rule '#{rule.inspect}'"
+        end
+      end
+
+      def const_missing(name)
+        const_set(name, Root.new(self, name))
+      end
+    end
+  end
+end

data/lib/temple/mixins/options.rb

@@ -0,0 +1,28 @@
+module Temple
+  module Mixins
+    # @api public
+    module DefaultOptions
+      def set_default_options(options)
+        default_options.update(options)
+      end
+
+      def default_options
+        @default_options ||= MutableHash.new(superclass.respond_to?(:default_options) ?
+                                             superclass.default_options : nil)
+      end
+    end
+
+    # @api public
+    module Options
+      def self.included(base)
+        base.class_eval { extend DefaultOptions }
+      end
+
+      attr_reader :options
+
+      def initialize(options = {})
+        @options = ImmutableHash.new(options, self.class.default_options)
+      end
+    end
+  end
+end

data/lib/temple/mixins/template.rb

@@ -0,0 +1,25 @@
+module Temple
+  module Mixins
+    # @api private
+    module Template
+      include DefaultOptions
+
+      def engine(engine = nil)
+        default_options[:engine] = engine if engine
+        default_options[:engine]
+      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/templates.rb

@@ -1,4 +1,5 @@
 module Temple
+  # @api public
   module Templates
     autoload :Tilt,  'temple/templates/tilt'
     autoload :Rails, 'temple/templates/rails'
@@ -7,6 +8,7 @@ module Temple
       template = Class.new(const_get(name))
       template.engine(engine)
       template.register_as(options[:register_as]) if options[:register_as]
+      template.default_options.update(options)
       template
     end
   end

data/lib/temple/utils.rb

@@ -1,62 +1,13 @@
 module Temple
+  # @api public
   module Utils
     extend self
 
-    class ImmutableHash
-      include Enumerable
-
-      def initialize(*hash)
-        @hash = hash.compact
-      end
-
-      def include?(key)
-        @hash.any? {|h| h.include?(key) }
-      end
-
-      def [](key)
-        @hash.each {|h| return h[key] if h.include?(key) }
-        nil
-      end
-
-      def each
-        keys.each {|k| yield(k, self[k]) }
-      end
-
-      def keys
-        @hash.inject([]) {|keys, h| keys += h.keys }.uniq
-      end
-
-      def values
-        keys.map {|k| self[k] }
-      end
-    end
-
-    class MutableHash < ImmutableHash
-      def initialize(*hash)
-        super({}, *hash)
-      end
-
-      def []=(key, value)
-        @hash.first[key] = value
-      end
-
-      def update(hash)
-        @hash.first.update(hash)
-      end
-    end
-
-    def indent(text, indent, pre_tags)
-      text = text.to_s
-      text.gsub!("\n", indent) if pre_tags !~ text
-      text
-    end
-
     # Returns an escaped copy of `html`.
     # Strings which are declared as html_safe are not escaped.
     #
     # @param html [String] The string to escape
     # @return [String] The escaped string
-    # @api public
     def escape_html_safe(html)
       html.html_safe? ? html : escape_html(html)
     end
@@ -66,7 +17,6 @@ module Temple
       #
       # @param html [String] The string to escape
       # @return [String] The escaped string
-      # @api public
       def escape_html(html)
         EscapeUtils.escape_html(html.to_s)
       end
@@ -85,7 +35,6 @@ module Temple
       #
       # @param html [String] The string to escape
       # @return [String] The escaped string
-      # @api public
       def escape_html(html)
         html.to_s.gsub(/[&\"<>\/]/, ESCAPE_HTML)
       end
@@ -94,20 +43,25 @@ module Temple
       #
       # @param html [String] The string to escape
       # @return [String] The escaped string
-      # @api public
       def escape_html(html)
         html.to_s.gsub(/&/n, '&amp;').gsub(/\"/n, '&quot;').gsub(/>/n, '&gt;').gsub(/</n, '&lt;').gsub(/\//, '&#47;')
       end
     end
 
-    # Generate unique temporary variable name
+    # Generate unique variable name
     #
+    # @param prefix [String] Variable name prefix
     # @return [String] Variable name
-    def tmp_var(prefix)
-      @tmp_var ||= 0
-      "_temple_#{prefix}#{@tmp_var += 1}"
+    def unique_name(prefix = nil)
+      @unique_name ||= 0
+      prefix ||= (@unique_prefix ||= self.class.name.gsub('::', '_').downcase)
+      "_#{prefix}#{@unique_name += 1}"
     end
 
+    # Check if expression is empty
+    #
+    # @param exp [Array] Temple expression
+    # @return true if expression is empty
     def empty_exp?(exp)
       case exp[0]
       when :multi