temple 0.1.8 → 0.2.0

data/lib/temple/mixins.rb

@@ -1,15 +1,154 @@
 module Temple
   module Mixins
+    module EngineDSL
+      def append(*args, &block)
+        chain << element(args, block)
+      end
+
+      def prepend(*args, &block)
+        chain.unshift(element(args, block))
+      end
+
+      def remove(name)
+        found = false
+        chain.reject! do |i|
+          equal = i.first == name
+          found = true if equal
+          equal
+        end
+        raise "#{name} not found" unless found
+      end
+
+      alias use append
+
+      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
+        e = 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
+      end
+
+      def after(name, *args, &block)
+        name = Class === name ? name.name.to_sym : name
+        raise(ArgumentError, 'First argument must be Class or Symbol') unless Symbol === name
+        e = 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
+      end
+
+      def replace(name, *args, &block)
+        name = Class === name ? name.name.to_sym : name
+        raise(ArgumentError, 'First argument must be Class or Symbol') unless Symbol === name
+        e = 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
+      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)
+      end
+
+      private
+
+      def element(args, block)
+        name = args.shift
+        if Class === name
+          filter = name
+          name = filter.name.to_sym
+        end
+        raise(ArgumentError, 'First argument must be Class or Symbol') unless Symbol === name
+
+        if block
+          raise(ArgumentError, 'Class and block argument are not allowed at the same time') if filter
+          filter = block
+        end
+
+        filter ||= args.shift
+
+        case filter
+        when Proc
+          # Proc or block argument
+          # 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
+          method_name = "FILTER #{name}"
+          if Class === self
+            define_method(method_name, &filter)
+            [name, instance_method(method_name)]
+          else
+            (class << self; self; end).class_eval { define_method(method_name, &filter) }
+            [name, method(method_name)]
+          end
+        when Class
+          # Class argument (e.g Filter class)
+          # The options are passed to the classes constructor.
+          local_options = Hash === args.last ? args.pop : nil
+          raise(ArgumentError, 'Only symbols allowed in option filter') unless args.all? {|o| Symbol === o }
+          [name, filter, args, local_options]
+        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, 'Class or callable argument is required') unless filter.respond_to?(:call)
+          [name, filter]
+        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 compile(exp)
-        compile!(exp)
+      def call(exp)
+        compile(exp)
       end
 
-      def compile!(exp)
+      def compile(exp)
         type, *args = exp
         if respond_to?("on_#{type}")
           send("on_#{type}", *args)
@@ -18,14 +157,6 @@ module Temple
         end
       end
 
-      def on_multi(*exps)
-        [:multi, *exps.map {|exp| compile!(exp) }]
-      end
-
-      def on_capture(name, exp)
-        [:capture, name, compile!(exp)]
-      end
-
       module ClassMethods
         def temple_dispatch(*bases)
           bases.each do |base|
@@ -41,30 +172,50 @@ module Temple
       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 ClassMethods }
+        base.class_eval { extend DefaultOptions }
       end
 
       attr_reader :options
 
       def initialize(options = {})
-        @options = self.class.default_options.merge(options)
+        @options = Utils::ImmutableHash.new(options, self.class.default_options)
       end
+    end
 
-      module ClassMethods
-        def set_default_options(opts)
-          default_options.merge!(opts)
-        end
+    module Template
+      include DefaultOptions
 
-        def default_options
-          @default_options ||= if superclass.respond_to?(:default_options)
-                                 Hash.new {|hash, key| superclass.default_options[key] }
-                               else
-                                 {}
-                               end
+      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/templates/rails.rb

@@ -0,0 +1,34 @@
+if ::Rails::VERSION::MAJOR < 3
+  raise "Temple supports only Rails 3.x and greater, your Rails version is #{::Rails::VERSION::STRING}"
+end
+
+module Temple
+  module Templates
+    if ::Rails::VERSION::MAJOR == 3 && ::Rails::VERSION::MINOR < 1
+      class Rails < ActionView::TemplateHandler
+        include ActionView::TemplateHandlers::Compilable
+        extend Mixins::Template
+
+        def compile(template)
+          self.class.build_engine.call(template.source)
+        end
+
+        def self.register_as(name)
+          ActionView::Template.register_template_handler name.to_sym, self
+        end
+      end
+    else
+      class Rails
+        extend Mixins::Template
+
+        def self.call(template)
+          build_engine.call(template.source)
+        end
+
+        def self.register_as(name)
+          ActionView::Template.register_template_handler name.to_sym, self
+        end
+      end
+    end
+  end
+end

data/lib/temple/templates/tilt.rb

@@ -0,0 +1,30 @@
+require 'tilt'
+
+module Temple
+  module Templates
+    class Tilt < ::Tilt::Template
+      extend Mixins::Template
+
+      # Prepare Temple template
+      #
+      # Called immediately after template data is loaded.
+      #
+      # @return [void]
+      def prepare
+        @src = self.class.build_engine({ :file => eval_file }, options).call(data)
+      end
+
+      # A string containing the (Ruby) source code for the template.
+      #
+      # @param [Hash]   locals Local variables
+      # @return [String] Compiled template ruby code
+      def precompiled_template(locals = {})
+        @src
+      end
+
+      def self.register_as(name)
+        ::Tilt.register name.to_s, self
+      end
+    end
+  end
+end

data/lib/temple/templates.rb

@@ -0,0 +1,13 @@
+module Temple
+  module Templates
+    autoload :Tilt,  'temple/templates/tilt'
+    autoload :Rails, 'temple/templates/rails'
+
+    def self.method_missing(name, engine, options = {})
+      template = Class.new(const_get(name))
+      template.engine(engine)
+      template.register_as(options[:register_as]) if options[:register_as]
+      template
+    end
+  end
+end

data/lib/temple/utils.rb

@@ -2,8 +2,53 @@ module Temple
   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)
-      pre_tags =~ text ? text : text.gsub("\n", indent)
+      text = text.to_s
+      text.gsub!("\n", indent) if pre_tags !~ text
+      text
     end
 
     # Returns an escaped copy of `html`.
@@ -55,6 +100,14 @@ module Temple
       end
     end
 
+    # Generate unique temporary variable name
+    #
+    # @return [String] Variable name
+    def tmp_var(prefix)
+      @tmp_var ||= 0
+      "_temple_#{prefix}#{@tmp_var += 1}"
+    end
+
     def empty_exp?(exp)
       case exp[0]
       when :multi

data/lib/temple/version.rb

@@ -1,3 +1,3 @@
 module Temple
-  VERSION = '0.1.8'
+  VERSION = '0.2.0'
 end

data/lib/temple.rb

@@ -7,12 +7,11 @@ module Temple
   autoload :Utils,            'temple/utils'
   autoload :Mixins,           'temple/mixins'
   autoload :Filter,           'temple/filter'
-  autoload :Template,         'temple/template'
+  autoload :Templates,        'temple/templates'
 
   module ERB
     autoload :Engine,         'temple/erb/engine'
     autoload :Parser,         'temple/erb/parser'
-    autoload :Template,       'temple/erb/template'
     autoload :Trimming,       'temple/erb/trimming'
   end
 
@@ -25,6 +24,7 @@ module Temple
   end
 
   module HTML
+    autoload :Dispatcher,     'temple/html/dispatcher'
     autoload :Fast,           'temple/html/fast'
     autoload :Pretty,         'temple/html/pretty'
   end

data/temple.gemspec

@@ -1,18 +1,18 @@
 # -*- encoding: utf-8 -*-
-require File.dirname(__FILE__) + "/lib/temple/version"
+require File.dirname(__FILE__) + '/lib/temple/version'
+require 'date'
 
 Gem::Specification.new do |s|
-  s.name = %q{temple}
-  s.version = Temple::VERSION
+  s.name          = 'temple'
+  s.version       = Temple::VERSION
+  s.date          = Date.today.to_s
 
-  s.authors = ["Magnus Holm"]
-  s.date = %q{2011-03-10}
-  s.email = %q{judofyr@gmail.com}
-  s.homepage = %q{http://dojo.rubyforge.org/}
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.6}
-  s.summary = %q{Template compilation framework in Ruby}
+  s.authors       = ['Magnus Holm', 'Daniel Mendler']
+  s.email         = ['judofyr@gmail.com', 'mail@daniel-mendler.de']
+  s.homepage      = 'http://dojo.rubyforge.org/'
+  s.summary       = 'Template compilation framework in Ruby'
 
+  s.require_paths = %w(lib)
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }

data/test/filters/test_dynamic_inliner.rb

@@ -6,7 +6,7 @@ describe Temple::Filters::DynamicInliner do
   end
 
   it 'should compile several statics into dynamic' do
-    @filter.compile([:multi,
+    @filter.call([:multi,
       [:static, "Hello "],
       [:static, "World\n "],
       [:static, "Have a nice day"]
@@ -14,7 +14,7 @@ describe Temple::Filters::DynamicInliner do
   end
 
   it 'should compile several dynamics into dynamic' do
-    @filter.compile([:multi,
+    @filter.call([:multi,
       [:dynamic, "@hello"],
       [:dynamic, "@world"],
       [:dynamic, "@yeah"]
@@ -22,7 +22,7 @@ describe Temple::Filters::DynamicInliner do
   end
 
   it 'should compile static and dynamic into dynamic' do
-    @filter.compile([:multi,
+    @filter.call([:multi,
       [:static, "Hello"],
       [:dynamic, "@world"],
       [:dynamic, "@yeah"],
@@ -31,7 +31,7 @@ describe Temple::Filters::DynamicInliner do
   end
 
   it 'should merge statics and dynamics around a block' do
-    exp = @filter.compile([:multi,
+    exp = @filter.call([:multi,
       [:static, "Hello "],
       [:dynamic, "@world"],
       [:block, "Oh yeah"],
@@ -46,21 +46,21 @@ describe Temple::Filters::DynamicInliner do
 
   it 'should keep blocks intact' do
     exp = [:multi, [:block, 'foo']]
-    @filter.compile(exp).should.equal exp
+    @filter.call(exp).should.equal exp
   end
 
   it 'should keep single statics intact' do
     exp = [:multi, [:static, 'foo']]
-    @filter.compile(exp).should.equal exp
+    @filter.call(exp).should.equal exp
   end
 
   it 'should keep single dynamic intact' do
     exp = [:multi, [:dynamic, 'foo']]
-    @filter.compile(exp).should.equal exp
+    @filter.call(exp).should.equal exp
   end
 
   it 'should inline inside multi' do
-    @filter.compile([:multi,
+    @filter.call([:multi,
       [:static, "Hello "],
       [:dynamic, "@world"],
       [:multi,
@@ -76,7 +76,7 @@ describe Temple::Filters::DynamicInliner do
   end
 
   it 'should merge across newlines' do
-    exp = @filter.compile([:multi,
+    exp = @filter.call([:multi,
       [:static, "Hello \n"],
       [:newline],
       [:dynamic, "@world"],
@@ -87,7 +87,7 @@ describe Temple::Filters::DynamicInliner do
   end
 
   it 'should compile static followed by newline' do
-    @filter.compile([:multi,
+    @filter.call([:multi,
       [:static, "Hello \n"],
       [:newline],
       [:block, "world"]

data/test/filters/test_escape_html.rb

@@ -12,9 +12,10 @@ describe Temple::Filters::EscapeHTML do
   end
 
   it 'should handle escape expressions' do
-    @filter.compile([:multi,
-      [:escape, :static, "a < b"],
-      [:escape, :dynamic, "ruby_method"]
+    @filter.call([:escape, true,
+                  [:multi,
+                   [:static, "a < b"],
+                   [:dynamic, "ruby_method"]]
     ]).should.equal [:multi,
       [:static, "a &lt; b"],
       [:dynamic, "Temple::Utils.escape_html((ruby_method))"],
@@ -23,25 +24,23 @@ describe Temple::Filters::EscapeHTML do
 
   it 'should keep blocks intact' do
     exp = [:multi, [:block, 'foo']]
-    @filter.compile(exp).should.equal exp
+    @filter.call(exp).should.equal exp
   end
 
   it 'should keep statics intact' do
     exp = [:multi, [:static, '<']]
-    @filter.compile(exp).should.equal exp
+    @filter.call(exp).should.equal exp
   end
 
   it 'should keep dynamic intact' do
     exp = [:multi, [:dynamic, 'foo']]
-    @filter.compile(exp).should.equal exp
+    @filter.call(exp).should.equal exp
   end
 
   it 'should have use_html_safe option' do
     filter = Temple::Filters::EscapeHTML.new(:use_html_safe => true)
-    filter.compile([:multi,
-      [:escape, :static, HtmlSafeString.new("a < b")],
-    ]).should.equal [:multi,
-      [:static, "a < b"],
-    ]
+    filter.call([:escape, true,
+      [:static, HtmlSafeString.new("a < b")],
+    ]).should.equal [:static, "a < b"]
   end
 end

data/test/filters/test_multi_flattener.rb

@@ -6,7 +6,7 @@ describe Temple::Filters::MultiFlattener do
   end
 
   it 'should flatten nested multi expressions' do
-    @filter.compile([:multi,
+    @filter.call([:multi,
       [:static, "a"],
       [:multi,
        [:dynamic, "aa"],
@@ -28,6 +28,6 @@ describe Temple::Filters::MultiFlattener do
   end
 
   it 'should return first element' do
-    @filter.compile([:multi, [:block, 'foo']]).should.equal [:block, 'foo']
+    @filter.call([:multi, [:block, 'foo']]).should.equal [:block, 'foo']
   end
 end

data/test/filters/test_static_merger.rb

@@ -6,7 +6,7 @@ describe Temple::Filters::StaticMerger do
   end
 
   it 'should merge serveral statics' do
-    @filter.compile([:multi,
+    @filter.call([:multi,
       [:static, "Hello "],
       [:static, "World, "],
       [:static, "Good night"]
@@ -16,7 +16,7 @@ describe Temple::Filters::StaticMerger do
   end
 
   it 'should merge serveral statics around block' do
-    @filter.compile([:multi,
+    @filter.call([:multi,
       [:static, "Hello "],
       [:static, "World!"],
       [:block, "123"],
@@ -30,7 +30,7 @@ describe Temple::Filters::StaticMerger do
   end
 
   it 'should merge serveral statics across newlines' do
-    @filter.compile([:multi,
+    @filter.call([:multi,
       [:static, "Hello "],
       [:static, "World, "],
       [:newline],