temple 0.0.1 → 0.1.0

data/lib/temple/engine.rb

@@ -1,13 +1,26 @@
 module Temple
-  # An engine is simply a chain of compilers (that includes both parsers,
-  # filters and generators).
+  # An engine is simply a chain of compilers (that often includes a parser,
+  # some filters and a generator).
   #
-  #   class ERB < Temple::Engine
-  #     parser :ERB            # shortcut for use Temple::Parsers::ERB
-  #     filter :Escapable      #              use Temple::Filters::Escapable
-  #     filter :DynamicInliner #              use Temple::Filters::DynamicInliner
-  #     generator :ArrayBuffer  #              use Temple::Core::ArrayBuffer
-  #  end
+  #   class MyEngine < Temple::Engine
+  #     # First run MyParser, passing the :strict option
+  #     use MyParser, :strict
+  # 
+  #     # Then a custom filter
+  #     use MyFilter
+  #      
+  #     # Then some general optimizations filters
+  #     filter :MultiFlattener
+  #     filter :StaticMerger
+  #     filter :DynamicInliner
+  #       
+  #     # Finally the generator
+  #     generator :ArrayBuffer, :buffer
+  #   end
+  #   
+  #   engine = MyEngine.new(:strict => "For MyParser")
+  #   engine.compile(something)
+  # 
   class Engine
     def self.filters
       @filters ||= []
@@ -17,21 +30,30 @@ module Temple
       filters << [filter, args, blk]
     end
     
+    # Shortcut for <tt>use Temple::Parsers::parser</tt>
     def self.parser(parser, *args, &blk)
       use(Temple::Parsers.const_get(parser), *args, &blk)
     end
     
+    # Shortcut for <tt>use Temple::Filters::parser</tt>
     def self.filter(filter, *args, &blk)
       use(Temple::Filters.const_get(filter), *args, &blk)
     end
     
+    # Shortcut for <tt>use Temple::Generator::parser</tt>
     def self.generator(compiler, *args, &blk)
       use(Temple::Core.const_get(compiler), *args, &blk)
     end
     
     def initialize(options = {})
       @chain = self.class.filters.map do |filter, args, blk|
-        filter.new(*args, &blk)
+        opt = args.last.is_a?(Hash) ? args.pop : {}
+        opt = args.inject(opt) do |memo, ele|
+          memo[ele] = options[ele] if options.has_key?(ele)
+          memo
+        end
+        
+        filter.new(opt, &blk)
       end
     end
     

data/lib/temple/engines/erb.rb

@@ -0,0 +1,93 @@
+require 'erb'
+
+module Temple
+  module Engines
+    # An engine which works in-place for ERB:
+    # 
+    #   require 'temple'
+    #   
+    #   template = Temple::Engine::ERB.new("<%= 1 + 1 %>")
+    #   template.result # => "2"
+    class ERB < ::ERB
+      OriginalERB = ::ERB
+      Optimizers = [Filters::StaticMerger.new, Filters::DynamicInliner.new]
+      
+      # The optional _filename_ argument passed to Kernel#eval when the ERB
+      # code is run
+      attr_accessor :filename
+      
+      # The Ruby code generated by ERB
+      attr_reader :src
+      
+      # The sexp generated by Temple
+      attr_reader :sexp
+      
+      # The optimized sexp generated by Temple
+      attr_reader :optimized_sexp
+      
+      # Sets the ERB constant to Temple::Engine::ERB
+      # 
+      # Example:
+      # 
+      #   require 'temple'
+      #   Temple::Engine::ERB.rock!
+      #   ERB == Temple::Engine::ERB
+      def self.rock!
+        Object.send(:remove_const, :ERB)
+        Object.send(:const_set, :ERB, self)
+      end
+      
+      # Sets the ERB constant back to regular ERB
+      # 
+      # Example:
+      # 
+      #   require 'temple'
+      #   original_erb = ERB
+      #   Temple::Engine::ERB.rock!
+      #   ERB.suck!
+      #   ERB == original_erb
+      
+      def self.suck!
+        Object.send(:remove_const, :ERB)
+        Object.send(:const_set, :ERB, OriginalERB)
+      end
+      
+      def initialize(str, safe_level = nil, trim_mode = nil, eoutvar = '_erbout', options = {})
+        @safe_level = safe_level
+        @trim_mode = trim_mode
+        @parser = Parsers::ERB.new(:trim_mode => @trim_mode)
+        
+        @generator = options[:generator] || Core::ArrayBuffer
+        
+        if @generator.is_a?(Class)
+          @generator = @generator.new(:buffer => eoutvar)
+        end
+        
+        @sexp = @parser.compile(str)
+        @optimized_sexp = Optimizers.inject(@sexp) { |m, e| e.compile(m) }
+        @src = @generator.compile(@optimized_sexp)
+        
+        if str.respond_to?(:encoding)
+          @enc = detect_magic_comment(str) || str.encoding
+          @src.insert(0, "#coding:#{@enc}\n")
+          @src << ".force_encoding(__ENCODING__)"
+        end
+      end
+      
+      def percent?
+        @trim_mode.is_a?(String) and @trim_mode.include?("%")
+      end
+      
+      def detect_magic_comment(s)
+        if /\A<%#(.*)%>/ =~ s or (percent? and /\A%#(.*)/ =~ s)
+  	      comment = $1
+  	      comment = $1 if comment[/-\*-\s*(.*?)\s*-*-$/]
+  	      if %r"coding\s*[=:]\s*([[:alnum:]\-_]+)" =~ comment
+  	        enc = $1.sub(/-(?:mac|dos|unix)/i, '')
+  	        enc = Encoding.find(enc)
+  	      end
+        end
+      end
+    end
+  end
+end

data/lib/temple/filters/dynamic_inliner.rb

@@ -2,6 +2,10 @@ module Temple
   module Filters
     # Inlines several static/dynamic into a single dynamic.
     class DynamicInliner
+      def initialize(options = {})
+        @options = {}
+      end
+      
       def compile(exp)
         exp.first == :multi ? on_multi(*exp[1..-1]) : exp
       end
@@ -9,21 +13,37 @@ module Temple
       def on_multi(*exps)
         res = [:multi]
         curr = nil
-        prev = nil
+        prev = []
         state = :looking
         
         # We add a noop because we need to do some cleanup at the end too.
         (exps + [:noop]).each do |exp| 
           head, arg = exp
-
-          if head == :dynamic || head == :static
+          
+          case head
+          when :newline
+            case state
+            when :looking
+              # We haven't found any static/dynamic, so let's just add it
+              res << exp
+            when :single, :several
+              # We've found something, so let's make sure the generated
+              # dynamic contains a newline by escaping a newline and
+              # starting a new string:
+              # 
+              # "Hello "\
+              # "#{@world}"
+              prev << exp
+              curr[1] << "\"\\\n\""
+            end
+          when :dynamic, :static
             case state
             when :looking
               # Found a single static/dynamic.  We don't want to turn this
               # into a dynamic yet.  Instead we store it, and if we find
               # another one, we add both then.
               state = :single
-              prev = exp
+              prev = [exp]
               curr = [:dynamic, '"' + send(head, arg)]
             when :single
               # Yes! We found another one.  Append the content to the current
@@ -39,7 +59,7 @@ module Temple
             # We need to add the closing quote.
             curr[1] << '"' unless state == :looking
             # If we found a single exp last time, let's add it.
-            res << prev if state == :single
+            res.concat(prev) if state == :single
             # Compile the current exp (unless it's the noop)
             res << compile(exp) unless head == :noop
             # Now we're looking for more!
@@ -51,7 +71,7 @@ module Temple
       end
     
       def static(str)
-        str.inspect[1..-2]
+        Generator.to_ruby(str)[1..-2]
       end
       
       def dynamic(str)

data/lib/temple/filters/escapable.rb

@@ -1,17 +1,24 @@
+require 'cgi'
+
 module Temple
   module Filters
     class Escapable
       def initialize(options = {})
-        @escaper = options[:escaper] || 'CGI.escapeHTML(%s.to_s)'
+        @escaper = options[:escaper] || 'CGI.escapeHTML((%s).to_s)'
       end
       
       def compile(exp)
         return exp if !exp.is_a?(Enumerable) || exp.is_a?(String)
         
-        if exp[0] == :static && is_escape?(exp[1])
-          [:static, eval(@escaper % exp[1][1].inspect)]
-        elsif is_escape?(exp)
-          @escaper % exp[1]
+        if is_escape?(exp)
+          case exp[1][0]
+          when :static
+            [:static, eval(@escaper % exp[1][1].inspect)]
+          when :dynamic, :block
+            [exp[1][0], @escaper % exp[1][1]]
+          else
+            raise "Escapable can only handle :static, :dynamic and :block for the moment."
+          end
         else
           exp.map { |e| compile(e) }
         end

data/lib/temple/filters/multi_flattener.rb

@@ -0,0 +1,27 @@
+module Temple
+  module Filters
+    class MultiFlattener
+      def initialize(options = {})
+        @options = {}
+      end
+      
+      def compile(exp)
+        return exp unless exp.first == :multi
+        # If the multi contains a single element, just return the element
+        return compile(exp[1]) if exp.length == 2
+        result = [:multi]
+        
+        exp[1..-1].each do |e|
+          e = compile(e)
+          if e.first == :multi
+            result.concat(e[1..-1])
+          else
+            result << e
+          end
+        end
+        
+        result
+      end
+    end
+  end
+end

data/lib/temple/filters/static_merger.rb

@@ -11,6 +11,10 @@ module Temple
     #   [:multi,
     #     [:static, "Hello World!"]]
     class StaticMerger
+      def initialize(options = {})
+        @options = {}
+      end
+      
       def compile(exp)
         exp.first == :multi ? on_multi(*exp[1..-1]) : exp
       end
@@ -30,7 +34,7 @@ module Temple
             end
           else
             res << compile(exp)
-            state = :looking
+            state = :looking unless exp.first == :newline
           end
         end
         

data/lib/temple/generator.rb

@@ -4,29 +4,83 @@ module Temple
       :buffer => "_buf"
     }
     
+    CONCATABLE = [:static, :dynamic]
+    
     def initialize(options = {})
       @options = DEFAULT_OPTIONS.merge(options)
+      @in_multi = false
     end
     
     def compile(exp)
-      preamble + compile_part(exp) + postamble
-    end
-    
-    def compile_part(exp)
-      send("on_#{exp.first}", *exp[1..-1])
+      res = send("on_#{exp.first}", *exp[1..-1])
+      
+      if @in_multi && CONCATABLE.include?(exp.first)
+        concat(res)
+      else
+        res
+      end
     end
     
     def buffer(str = '')
       @options[:buffer] + str
     end
     
+    def self.to_ruby(str)
+      str.inspect.gsub(/(\\r)?\\n/m) do |str|
+        if $`[-1] == ?\\
+          str
+        elsif $1
+          "\\n"
+        else
+          "\n"
+        end
+      end
+    end
+    
+    def to_ruby(str)
+      Generator.to_ruby(str)
+    end
+    
     # Sensible defaults
     
     def preamble;  '' end
     def postamble; '' end
+    def concat(s)  buffer " << (#{s})" end
     
     def on_multi(*exp)
-      exp.map { |e| compile_part(e) }.join
+      if @in_multi
+        exp.map { |e| compile(e) }
+      else
+        @in_multi = true
+        content = exp.map { |e| compile(e) }
+        content = [preamble, content, postamble].flatten
+        @in_multi = false
+        content
+      end.join(" ; ")
+    end
+    
+    def on_newline
+      "\n"
+    end
+    
+    def on_capture(name, block)
+      unless @in_multi
+        # We always need the preamble/postamble in capture.
+        return compile([:multi, [:capture, name, block]])
+      end
+      
+      @in_multi = false
+      prev_buffer, @options[:buffer] = @options[:buffer], name.to_s
+      content = compile(block)
+      @in_multi = true
+      
+      if CONCATABLE.include?(block.first)
+        "#{name} = #{content}"
+      else
+        content
+      end
+    ensure
+      @options[:buffer] = prev_buffer
     end
   end
 end

data/lib/temple/parsers/erb.rb

@@ -1,26 +1,74 @@
+require 'erb'
+
 module Temple
   module Parsers
-    # A dead simple ERB parser which compiles directly to Core.
-    # It's crappy, but it works for now.
+    # Parses ERB exactly the same way as erb.rb.
     class ERB
+      Compiler = ::ERB::Compiler
+      
+      def initialize(options = {})
+        @compiler = Compiler.new(options[:trim_mode])
+      end
+      
       def compile(src)
+        if src.respond_to?(:encoding) && src.encoding.dummy?
+          raise ArgumentError, "#{src.encoding} is not ASCII compatible"
+        end
+        
         result = [:multi]
-        while src =~ /<%(.*?)%>/
-          result << [:static, $`]
-          text = $1[1..-1].strip
-          case $1[0]
-          when ?#
-            next
-          when ?=
-            text = [:escape, text] if $1[1] == ?=
-            head = :dynamic
+        
+        content = ''
+        scanner = @compiler.make_scanner(src)
+        scanner.scan do |token|
+          next if token.nil? 
+          next if token == ''
+          if scanner.stag.nil?
+            case token
+            when Compiler::PercentLine
+              result << [:static, content] if content.size > 0
+              content = ''
+              result << [:block, token.to_s.strip]
+              result << [:newline]
+            when :cr
+              result << [:newline]
+            when '<%', '<%=', '<%#'
+              scanner.stag = token
+            when "\n"
+              content << "\n"
+              result << [:static, content]
+              content = ''
+            when '<%%'
+              result << [:static, '<%']
+            else
+              result << [:static, token]
+            end
           else
-            head = :block
+            case token
+            when '%>'
+              case scanner.stag
+              when '<%'
+                if content[-1] == ?\n
+                  content.chop!
+                  result << [:block, content]
+                  result << [:newline]
+                else
+                  result << [:block, content]
+                end
+              when '<%='
+                result << [:dynamic, content]
+              when '<%#'
+                # nothing
+              end
+              scanner.stag = nil
+              content = ''
+            when '%%>'
+              content << '%>'
+            else
+              content << token
+            end
           end
-          result << [head, text]
-          src = $'
         end
-        result << [:static, src]
+        
         result
       end
     end