temple 0.1.8 → 0.2.0

data/README.md

@@ -115,7 +115,7 @@ mind working across processes, it's not a problem at all.
 Compilers
 ---------
 
-A *compiler* is simply an object which responds a method called #compile which
+A *compiler* is simply an object which responds a method called #call which
 takes one argument and returns a value. It's illegal for a compiler to mutate
 the argument, and it should be possible to use the same instance several times
 (although not by several threads at the same time).
@@ -128,7 +128,7 @@ class. Temple then assumes the initializer takes an optional option hash:
         @options = options
       end
 
-      def compile(exp)
+      def call(exp)
         # do stuff
       end
     end
@@ -195,7 +195,7 @@ When you have a chain of a parsers, some filters and a generator you can finally
     end
 
     engine = MyEngine.new(:strict => "For MyParser")
-    engine.compile(something)
+    engine.call(something)
 
 And then?
 ---------
@@ -203,25 +203,13 @@ And then?
 You've ran the template through the parser, some filters and in the end a
 generator. What happens next?
 
-Temple's mission ends here, so it's all up to you, but we recommend using
-[Tilt](http://github.com/rtomayko/tilt), the generic interface to Ruby
-template engines. This gives you a wide range of features and your engine can
-be used right away in many projects.
+Temple provides helpers to create template classes for [Tilt](http://github.com/rtomayko/tilt) and
+Rails.
 
     require 'tilt'
 
-    class MyTemplate < Tilt::Template
-      def prepare
-        @src = MyEngine.new(options).compile(data)
-      end
-
-      def template_source
-        @src
-      end
-    end
-
-    # Register your file extension:
-    Tilt.register 'ext', MyTemplate
+    # Create template class MyTemplate and register your file extension
+    MyTemplate = Temple::Templates::Tilt(MyEngine, :register_as => 'ext')
 
     Tilt.new('example.ext').render     # => Render a file
     MyTemplate.new { "String" }.render # => Render a string

data/lib/temple/engine.rb

@@ -18,41 +18,52 @@ module Temple
   #     generator :ArrayBuffer, :buffer
   #   end
   #
+  #   class SpecialEngine < MyEngine
+  #     append MyCodeOptimizer
+  #     replace Temple::Generators::ArrayBuffer, Temple::Generators::RailsOutputBuffer
+  #   end
+  #
   #   engine = MyEngine.new(:strict => "For MyParser")
-  #   engine.compile(something)
+  #   engine.call(something)
   #
   class Engine
     include Mixins::Options
+    include Mixins::EngineDSL
+    extend  Mixins::EngineDSL
 
-    def self.chain
-      @chain ||= []
-    end
+    attr_reader :chain
 
-    def self.use(filter, *options, &block)
-      default_options = Hash === options.last ? options.pop : {}
-      chain << proc do |opts|
-        filter.new(default_options.merge(Hash[*opts.select {|k,v| options.include?(k) }.flatten]), &block)
-      end
-    end
-
-    # Shortcut for <tt>use Temple::Filters::parser</tt>
-    def self.filter(filter, *options, &block)
-      use(Temple::Filters.const_get(filter), *options, &block)
+    def self.chain
+      @chain ||= superclass.respond_to?(:chain) ? superclass.chain.dup : []
     end
 
-    # Shortcut for <tt>use Temple::Generators::parser</tt>
-    def self.generator(compiler, *options, &block)
-      use(Temple::Generators.const_get(compiler), *options, &block)
+    def initialize(o = {})
+      super
+      @chain = self.class.chain.dup
+      yield(self) if block_given?
+      [*options[:chain]].compact.each {|block| block.call(self) }
+      @chain = build_chain
     end
 
-    def compile(input)
-      chain.inject(input) {|m, e| e.compile(m) }
+    def call(input)
+      chain.inject(input) {|m, e| e.call(m) }
     end
 
     protected
 
-    def chain
-      @chain ||= self.class.chain.map { |f| f.call(options) }
+    def build_chain
+      chain.map do |e|
+        name, filter, option_filter, local_options = e
+        case filter
+        when Class
+          filtered_options = Hash[*option_filter.select {|k| options.include?(k) }.map {|k| [k, options[k]] }.flatten]
+          filter.new(Utils::ImmutableHash.new(local_options, filtered_options))
+        when UnboundMethod
+          filter.bind(self)
+        else
+          filter
+        end
+      end
     end
   end
 end

data/lib/temple/erb/engine.rb

@@ -2,8 +2,8 @@ module Temple
   module ERB
     class Engine < Temple::Engine
       use Temple::ERB::Parser, :auto_escape
-      use Temple::ERB::Trimming, :trim_mode
       filter :EscapeHTML, :use_html_safe
+      use Temple::ERB::Trimming, :trim_mode
       filter :MultiFlattener
       filter :StaticMerger
       filter :DynamicInliner

data/lib/temple/erb/parser.rb

@@ -10,7 +10,7 @@ module Temple
         '%%>' => '%>',
       }.freeze
 
-      def compile(input)
+      def call(input)
         result = [:multi]
         pos = 0
         input.scan(ERB_PATTERN) do |escaped, indicator, code|
@@ -25,7 +25,7 @@ module Temple
             when '#'
               code.count("\n").times { result << [:newline] }
             when /=/
-              result << (indicator.length > 1 || !options[:auto_escape] ? [:dynamic, code] : [:escape, :dynamic, code])
+              result << [:escape, indicator.length <= 1 && options[:auto_escape], [:dynamic, code]]
             else
               result << [:block, code]
             end

data/lib/temple/filters/debugger.rb

@@ -9,7 +9,7 @@ module Temple
         require 'pp' if options[:debug_pretty]
       end
 
-      def compile(exp)
+      def call(exp)
         if options[:debug]
           puts options[:debug_prefix] if options[:debug_prefix]
           if options[:debug_pretty]

data/lib/temple/filters/dynamic_inliner.rb

@@ -53,7 +53,7 @@ module Temple
             # If we found a single exp last time, let's add it.
             res.concat(prev) if state == :single
             # Compile the current exp (unless it's the noop)
-            res << compile!(exp) unless head == :noop
+            res << compile(exp) unless head == :noop
             # Now we're looking for more!
             state = :looking
           end

data/lib/temple/filters/escape_html.rb

@@ -1,29 +1,32 @@
 module Temple
   module Filters
     class EscapeHTML < Filter
-      temple_dispatch :escape, :html
+      include Temple::HTML::Dispatcher
+
+      temple_dispatch :html
 
       # Activate the usage of html_safe? if it is available (for Rails 3 for example)
       default_options[:use_html_safe] = ''.respond_to?(:html_safe?)
 
-      def on_escape_static(value)
-        [:static, options[:use_html_safe] ? escape_html_safe(value) : escape_html(value)]
-      end
-
-      def on_escape_dynamic(value)
-        [:dynamic, "Temple::Utils.escape_html#{options[:use_html_safe] ? '_safe' : ''}((#{value}))"]
+      def initialize(opts = {})
+        super
+        @escape = false
       end
 
-      def on_html_staticattrs(*attrs)
-        [:html, :staticattrs, *attrs.map {|k,v| [k, compile!(v)] }]
+      def on_escape(flag, exp)
+        old = @escape
+        @escape = flag
+        compile(exp)
+      ensure
+        @escape = old
       end
 
-      def on_html_comment(content)
-        [:html, :comment, compile!(content)]
+      def on_static(value)
+        [:static, @escape ? (options[:use_html_safe] ? escape_html_safe(value) : escape_html(value)) : value]
       end
 
-      def on_html_tag(name, attrs, closed, content)
-        [:html, :tag, name, compile!(attrs), closed, compile!(content)]
+      def on_dynamic(value)
+        [:dynamic, @escape ? "Temple::Utils.escape_html#{options[:use_html_safe] ? '_safe' : ''}((#{value}))" : value]
       end
     end
   end

data/lib/temple/filters/multi_flattener.rb

@@ -3,11 +3,11 @@ module Temple
     class MultiFlattener < Filter
       def on_multi(*exps)
         # If the multi contains a single element, just return the element
-        return compile!(exps.first) if exps.length == 1
+        return compile(exps.first) if exps.length == 1
         result = [:multi]
 
         exps.each do |exp|
-          exp = compile!(exp)
+          exp = compile(exp)
           if exp.first == :multi
             result.concat(exp[1..-1])
           else

data/lib/temple/filters/static_merger.rb

@@ -25,7 +25,7 @@ module Temple
               curr << exp[1]
             end
           else
-            res << compile!(exp)
+            res << compile(exp)
             state = :looking unless exp.first == :newline
           end
         end

data/lib/temple/generators.rb

@@ -73,17 +73,21 @@ module Temple
 
     default_options[:buffer] = '_buf'
 
-    def compile(exp)
-      [preamble, compile!(exp), postamble].join(' ; ')
+    def call(exp)
+      [preamble, compile(exp), postamble].join(' ; ')
     end
 
-    def compile!(exp)
+    def compile(exp)
       type, *args = exp
-      send("on_#{type}", *args)
+      if respond_to?("on_#{type}")
+        send("on_#{type}", *args)
+      else
+        raise "Generator supports only core expressions - found #{exp.inspect}"
+      end
     end
 
     def on_multi(*exp)
-      exp.map { |e| compile!(e) }.join(' ; ')
+      exp.map { |e| compile(e) }.join(' ; ')
     end
 
     def on_newline
@@ -91,7 +95,7 @@ module Temple
     end
 
     def on_capture(name, block)
-      options[:capture_generator].new(:buffer => name).compile(block)
+      options[:capture_generator].new(:buffer => name).call(block)
     end
 
     protected

data/lib/temple/html/dispatcher.rb

@@ -0,0 +1,17 @@
+module Temple
+  module HTML
+    module Dispatcher
+      def on_html_staticattrs(*attrs)
+        [:html, :staticattrs, *attrs.map {|k,v| [k, compile(v)] }]
+      end
+
+      def on_html_comment(content)
+        [:html, :comment, compile(content)]
+      end
+
+      def on_html_tag(name, attrs, closed, content)
+        [:html, :tag, name, compile(attrs), closed, compile(content)]
+      end
+    end
+  end
+end

data/lib/temple/html/fast.rb

@@ -39,18 +39,11 @@ module Temple
       end
 
       def html?
-        html5? or html4?
-      end
-
-      def html5?
-        options[:format] == :html5
-      end
-
-      def html4?
-        options[:format] == :html4
+        options[:format] == :html5 || options[:format] == :html4
       end
 
       def on_html_doctype(type)
+        type = type.to_s
         trailing_newlines = type[/(\A|[^\r])(\n+)\Z/, 2].to_s
         text = type.downcase.strip
 
@@ -76,16 +69,16 @@ module Temple
       def on_html_comment(content)
         [:multi,
           [:static, '<!--'],
-          compile!(content),
+          compile(content),
           [:static, '-->']]
       end
 
       def on_html_tag(name, attrs, closed, content)
         closed ||= options[:autoclose].include?(name)
         raise "Closed tag #{name} has content" if closed && !empty_exp?(content)
-        result = [:multi, [:static, "<#{name}"], compile!(attrs)]
+        result = [:multi, [:static, "<#{name}"], compile(attrs)]
         result << [:static, ' /'] if closed && xhtml?
-        result << [:static, '>'] << compile!(content)
+        result << [:static, '>'] << compile(content)
         result << [:static, "</#{name}>"] if !closed
         result
       end
@@ -104,13 +97,45 @@ module Temple
           end
         end
         result.sort.inject([:multi]) do |list, (name, value)|
-          list << [:multi,
-                   [:static, ' '],
-                   [:static, name],
-                   [:static, '='],
-                   [:static, options[:attr_wrapper]],
-                   value,
-                   [:static, options[:attr_wrapper]]]
+          list << compile_attribute(name, value)
+        end
+      end
+
+      protected
+
+      def compile_attribute(name, value)
+        if empty_exp?(value)
+          [:multi]
+        elsif contains_static?(value)
+          attribute(name, value)
+        else
+          tmp = tmp_var(:htmlattr)
+          [:multi,
+           [:capture, tmp, value],
+           [:block, "unless #{tmp}.empty?"],
+             attribute(name, [:dynamic, tmp]),
+           [:block, 'end']]
+        end
+      end
+
+      def attribute(name, value)
+        [:multi,
+         [:static, ' '],
+         [:static, name],
+         [:static, '='],
+         [:static, options[:attr_wrapper]],
+         value,
+         [:static, options[:attr_wrapper]]]
+      end
+
+      def contains_static?(exp)
+        case exp[0]
+        when :multi
+          exp[1..-1].any? {|e| contains_static?(e) }
+        when :static
+          true
+        else
+          false
         end
       end
     end

data/lib/temple/html/pretty.rb

@@ -3,39 +3,44 @@ module Temple
     class Pretty < Fast
       set_default_options :indent => '  ',
                           :pretty => true,
-                          :indent_tags => %w(base body dd div dl doctype dt fieldset form head h1 h2 h3
+                          :indent_tags => %w(base body dd div dl dt fieldset form head h1 h2 h3
                                              h4 h5 h6 hr html img input li link meta ol p script
                                              style table tbody td tfoot th thead title tr ul).freeze,
                           :pre_tags => %w(pre textarea).freeze
 
       def initialize(opts = {})
         super
-        @last = nil
+        @last = :noindent
         @indent = 0
         @pretty = options[:pretty]
+        @pre_tags = Regexp.new(options[:pre_tags].map {|t| "<#{t}" }.join('|'))
       end
 
-      def compile(exp)
-        [:multi, preamble, compile!(exp)]
+      def call(exp)
+        @pretty ? [:multi, preamble, compile(exp)] : super
       end
 
       def on_static(content)
-        @last = nil
-        [:static, @pretty ? content.gsub("\n", indent) : content]
+        if @pretty
+          content = Utils.indent(content, indent, @pre_tags)
+          @last = content.sub!(/\r?\n\s*$/, ' ') ? nil : :noindent
+        end
+        [:static, content]
       end
 
       def on_dynamic(content)
-        @last = nil
+        @last = :noindent
         [:dynamic, @pretty ? "Temple::Utils.indent((#{content}), #{indent.inspect}, _temple_pre_tags)" : content]
       end
 
       def on_html_doctype(type)
-        @last = 'doctype'
+        @last = nil
         super
       end
 
       def on_html_comment(content)
         return super unless @pretty
+        @last = nil
         [:multi, [:static, indent], super]
       end
 
@@ -46,18 +51,16 @@ module Temple
         raise "Closed tag #{name} has content" if closed && !empty_exp?(content)
 
         @pretty = false
-        result = [:multi, [:static, "#{tag_indent(name)}<#{name}"], compile!(attrs)]
+        result = [:multi, [:static, "#{tag_indent(name)}<#{name}"], compile(attrs)]
         result << [:static, ' /'] if closed && xhtml?
         result << [:static, '>']
 
-        @last = name
         @pretty = !options[:pre_tags].include?(name)
         @indent += 1
-        result << compile!(content)
+        result << compile(content)
         @indent -= 1
 
         result << [:static, "#{tag_indent(name)}</#{name}>"] if !closed
-        @last = name
         @pretty = true
         result
       end
@@ -65,8 +68,7 @@ module Temple
       protected
 
       def preamble
-        regexp = options[:pre_tags].map {|t| "<#{t}" }.join('|')
-        [:block, "_temple_pre_tags = /#{regexp}/"]
+        [:block, "_temple_pre_tags = /#{@pre_tags.source}/"]
       end
 
       # Return indentation if not in pre tag
@@ -76,7 +78,9 @@ module Temple
 
       # Return indentation before tag
       def tag_indent(name)
-        @last && (options[:indent_tags].include?(@last) || options[:indent_tags].include?(name)) ? indent : ''
+        result = @last != :noindent && (options[:indent_tags].include?(@last) || options[:indent_tags].include?(name)) ? indent : ''
+        @last = name
+        result
       end
     end
   end