erubis 2.1.0 → 2.2.0

data/lib/erubis.rb

@@ -1,20 +1,13 @@
 ##
-## $Rev: 36 $
-## $Release: 2.1.0 $
-## copyright(c) 2006 kuwata-lab all rights reserved.
+## $Rev: 59 $
+## $Release: 2.2.0 $
+## copyright(c) 2006-2007 kuwata-lab all rights reserved.
 ##
 
 ##
 ## an implementation of eRuby
 ##
-## * class Eruby - normal eRuby class
-## * class XmlEruby - eRuby class which escape '&<>"' into '&amp;&lt;&gt;&quot;'
-## * module StdoutEnhancer - use $stdout instead of String as output
-## * module PrintEnhancer - enable to write print statement in <% ... %>
-## * class OptimizedEruby - optimized Eruby class faster than FastEruby
-## * class OptimizedXmlEruby - optimized XmlEruby class faster than FastXmlEruby
-##
-## example:
+## ex.
 ##   input = <<'END'
 ##    <ul>
 ##     <% for item in @list %>
@@ -24,25 +17,24 @@
 ##    </ul>
 ##   END
 ##   list = ['<aaa>', 'b&b', '"ccc"']
-##   eruby = Erubis::Eruby.new()
-##   code = eruby.convert(input)
+##   eruby = Erubis::Eruby.new(input)
 ##   puts "--- code ---"
-##   puts code
+##   puts eruby.src
 ##   puts "--- result ---"
-##   context = Object.new
-##   context.instance_variable_set("@list", list)
-##   puts context.instance_eval(code)
-##   # or @list = list; puts eval(code, binding())
+##   context = Erubis::Context.new()   # or new(:list=>list)
+##   context[:list] = list
+##   puts eruby.evaluate(context)
 ##
 ## result:
 ##   --- source ---
-##   _buf = ""; _buf << " <ul>\n"
-##      for item in list
-##   _buf << "   <li>"; _buf << ( item ).to_s; _buf << "\n"
-##   _buf << "       "; _buf << Erubis::XmlEruby.escape( item ); _buf << "</li>\n"
-##      end
-##   _buf << " </ul>\n"
-##   _buf
+##   _buf = ''; _buf << '<ul>
+##   ';  for item in @list 
+##    _buf << '  <li>'; _buf << ( item ).to_s; _buf << '
+##   '; _buf << '      '; _buf << Erubis::XmlHelper.escape_xml( item ); _buf << '</li>
+##   ';  end 
+##    _buf << '</ul>
+##   ';
+##   _buf.to_s
 ##   --- result ---
 ##    <ul>
 ##      <li><aaa>
@@ -55,6 +47,10 @@
 ##
 
 
+module Erubis
+  VERSION = ('$Release: 2.2.0 $' =~ /([.\d]+)/) && $1
+end
+
 require 'erubis/engine'
 #require 'erubis/generator'
 #require 'erubis/converter'

data/lib/erubis/context.rb

@@ -1,7 +1,7 @@
 ##
-## $Rev: 32 $
-## $Release: 2.1.0 $
-## copyright(c) 2006 kuwata-lab all rights reserved.
+## $Rev: 59 $
+## $Release: 2.2.0 $
+## copyright(c) 2006-2007 kuwata-lab all rights reserved.
 ##
 
 
@@ -29,6 +29,7 @@ module Erubis
   ##   print eruby.evaluate(context)
   ##
   class Context
+    include Enumerable
 
     def initialize(hash=nil)
       hash.each do |name, value|
@@ -45,7 +46,36 @@ module Erubis
     end
 
     def keys
-      return instance_variables.collect { |name| name[1,name.length-1] }
+      return instance_variables.collect { |name| name[1..-1] }
+    end
+
+    def each
+      instance_variables.each do |name|
+        key = name[1..-1]
+        value = instance_variable_get(name)
+        yield(key, value)
+      end
+    end
+
+    def to_hash
+      hash = {}
+      self.keys.each { |key| hash[key] = self[key] }
+      return hash
+    end
+
+    def update(context_or_hash)
+      arg = context_or_hash
+      if arg.is_a?(Hash)
+        arg.each do |key, val|
+          self[key] = val
+        end
+      else
+        arg.instance_variables.each do |varname|
+          key = varname[1..-1]
+          val = arg.instance_variable_get(varname)
+          self[key] = val
+        end
+      end
     end
 
   end

data/lib/erubis/converter.rb

@@ -1,7 +1,7 @@
 ##
-## $Rev: 37 $
-## $Release: 2.1.0 $
-## copyright(c) 2006 kuwata-lab all rights reserved.
+## $Rev: 60 $
+## $Release: 2.2.0 $
+## copyright(c) 2006-2007 kuwata-lab all rights reserved.
 ##
 
 require 'abstract'
@@ -41,6 +41,36 @@ module Erubis
 
     protected
 
+    ##
+    ## detect spaces at beginning of line
+    ##
+    def detect_spaces_at_bol(text, is_bol)
+      lspace = nil
+      if text.empty?
+        lspace = "" if is_bol
+      elsif text[-1] == ?\n
+        lspace = ""
+      else
+        rindex = text.rindex(?\n)
+        if rindex
+          s = text[rindex+1..-1]
+          if s =~ /\A[ \t]*\z/
+            lspace = s
+            #text = text[0..rindex]
+            text[rindex+1..-1] = ''
+          end
+        else
+          if is_bol && text =~ /\A[ \t]*\z/
+            #lspace = text
+            #text = nil
+            lspace = text.dup
+            text[0..-1] = ''
+          end
+        end
+      end
+      return lspace
+    end
+
     ##
     ## (abstract) convert input to code
     ##
@@ -72,57 +102,65 @@ module Erubis
 
     def init_converter(properties={})
       super(properties)
-      @pattern   = properties[:pattern]
-      @trim      = properties[:trim] != false
+      @pattern = properties[:pattern]
+      @trim    = properties[:trim] != false
     end
 
-    #DEFAULT_REGEXP = /(.*?)(^[ \t]*)?<%(=+|\#)?(.*?)-?%>([ \t]*\r?\n)?/m
-    DEFAULT_REGEXP = /(^[ \t]*)?<%(=+|\#)?(.*?)-?%>([ \t]*\r?\n)?/m
+    protected
 
     ## return regexp of pattern to parse eRuby script
-    def pattern_regexp(pattern=@pattern)
-      if pattern.nil? || pattern == '<% %>'
-        return DEFAULT_REGEXP
-      else
-        prefix, postfix = pattern.split()
-        #return /(.*?)(^[ \t]*)?#{prefix}(=+|\#)?(.*?)-?#{postfix}([ \t]*\r?\n)?/m
-        return /(^[ \t]*)?#{prefix}(=+|\#)?(.*?)-?#{postfix}([ \t]*\r?\n)?/m
-      end
+    def pattern_regexp(pattern)
+      prefix, postfix = pattern.split()   # '<% %>' => '<%', '%>'
+      #return /(.*?)(^[ \t]*)?#{prefix}(=+|\#)?(.*?)-?#{postfix}([ \t]*\r?\n)?/m
+      #return /(^[ \t]*)?#{prefix}(=+|\#)?(.*?)-?#{postfix}([ \t]*\r?\n)?/m
+      return /#{prefix}(=+|-|\#)?(.*?)-?#{postfix}([ \t]*\r?\n)?/m
     end
-    protected :pattern_regexp
+    module_function :pattern_regexp
+
+    #DEFAULT_REGEXP = /(.*?)(^[ \t]*)?<%(=+|\#)?(.*?)-?%>([ \t]*\r?\n)?/m
+    #DEFAULT_REGEXP = /(^[ \t]*)?<%(=+|\#)?(.*?)-?%>([ \t]*\r?\n)?/m
+    #DEFAULT_REGEXP = /<%(=+|\#)?(.*?)-?%>([ \t]*\r?\n)?/m
+    DEFAULT_REGEXP = pattern_regexp('<% %>')
+
+    public
 
     def convert_input(src, input)
-      regexp = pattern_regexp(@pattern)
+      pat = @pattern
+      regexp = pat.nil? || pat == '<% %>' ? DEFAULT_REGEXP : pattern_regexp(pat)
       pos = 0
-      input.scan(regexp) do |lspace, indicator, code, rspace|
+      is_bol = true     # is beginning of line
+      input.scan(regexp) do |indicator, code, rspace|
         match = Regexp.last_match()
-        index = match.begin(0)
-        text  = input[pos, index - pos]
-        pos   = match.end(0)
-        add_text(src, text)
+        len  = match.begin(0) - pos
+        text = input[pos, len]
+        pos  = match.end(0)
+        ch   = indicator ? indicator[0] : nil
+        lspace = ch == ?= ? nil : detect_spaces_at_bol(text, is_bol)
+        is_bol = rspace ? true : false
+        add_text(src, text) if text && !text.empty?
         ## * when '<%= %>', do nothing
         ## * when '<% %>' or '<%# %>', delete spaces iff only spaces are around '<% %>'
-        if !indicator               # <% %>
+        if ch == ?=              # <%= %>
+          add_text(src, lspace) if lspace
+          add_expr(src, code, indicator)
+          add_text(src, rspace) if rspace
+        elsif ch == ?\#          # <%# %>
+          n = code.count("\n") + (rspace ? 1 : 0)
           if @trim && lspace && rspace
-            add_stmt(src, "#{lspace}#{code}#{rspace}")
+            add_stmt(src, "\n" * n)
           else
             add_text(src, lspace) if lspace
-            add_stmt(src, code)
+            add_stmt(src, "\n" * n)
             add_text(src, rspace) if rspace
           end
-        elsif indicator[0] == ?\#   # <%# %>
-          n = code.count("\n") + (rspace ? 1 : 0)
+        else                     # <% %>
           if @trim && lspace && rspace
-            add_stmt(src, "\n" * n)
+            add_stmt(src, "#{lspace}#{code}#{rspace}")
           else
             add_text(src, lspace) if lspace
-            add_stmt(src, "\n" * n)
+            add_stmt(src, code)
             add_text(src, rspace) if rspace
           end
-        else                        # <%= %>
-          add_text(src, lspace) if lspace
-          add_expr(src, code, indicator)
-          add_text(src, rspace) if rspace
         end
       end
       rest = $' || input     # add input when no matched
@@ -171,9 +209,9 @@ module Erubis
 
     def init_converter(properties={})
       super(properties)
-      @trim    = !(properties[:trim] == false)
+      @trim    = properties.fetch(:trim, true)
       @pi      = properties[:pi] if properties[:pi]
-      @embchar = properties[:embchar]  || '@'
+      @embchar = properties[:embchar] || '@'
       @pattern = properties[:pattern]
       @pattern = '<% %>' if @pattern.nil?  #|| @pattern == true
     end
@@ -186,60 +224,106 @@ module Erubis
     protected
 
     def convert_input(codebuf, input)
-      parse_stmts(codebuf, input)
-      #parse_stmts2(codebuf, input)
-    end
-
-    def parse_stmts(codebuf, input)
-      #regexp = pattern_regexp(@pattern)
-      @pi ||= 'e'
-      @stmt_pattern ||= /(^[ \t]*)?<\?#{@pi}(?:-(\w+))?(\s.*?)\?>([ \t]*\r?\n)?/m
-      pos = 0
-      input.scan(@stmt_pattern) do |lspace, pi_arg, code, rspace|
-        match = Regexp.last_match
-        index = match.begin(0)
-        text = input[pos, index - pos]
-        pos = match.end(0)
-        parse_exprs(codebuf, text) # unless text.empty?
-        if @trim && lspace && rspace
-          add_pi_stmt(codebuf, "#{lspace}#{code}#{rspace}", pi_arg)
-        else
-          add_text(codebuf, lspace)
-          add_pi_stmt(codebuf, code, pi_arg)
-          add_text(codebuf, rspace)
-        end
-      end
-      rest = $' || input
-      parse_exprs(codebuf, rest)
-    end
-
-    def parse_exprs(codebuf, input)
-      unless @expr_pattern
+      unless @regexp
+        @pi ||= 'e'
         ch = Regexp.escape(@embchar)
         if @pattern
           left, right = @pattern.split(' ')
-          @expr_pattern = /#{ch}(!*)?\{(.*?)\}#{ch}|#{left}(=+)(.*?)#{right}/
+          @regexp = /<\?#{@pi}(?:-(\w+))?(\s.*?)\?>([ \t]*\r?\n)?|#{ch}(!*)?\{(.*?)\}#{ch}|#{left}(=+)(.*?)#{right}/m
         else
-          @expr_pattern = /#{ch}(!*)?\{(.*?)\}#{ch}/
+          @regexp = /<\?#{@pi}(?:-(\w+))?(\s.*?)\?>([ \t]*\r?\n)?|#{ch}(!*)?\{(.*?)\}#{ch}/m
         end
       end
+      #
+      is_bol = true
       pos = 0
-      input.scan(@expr_pattern) do |indicator1, code1, indicator2, code2|
-        indicator = indicator1 || indicator2
-        code = code1 || code2
+      input.scan(@regexp) do |pi_arg, stmt, rspace,
+                              indicator1, expr1, indicator2, expr2|
         match = Regexp.last_match
-        index = match.begin(0)
-        text = input[pos, index - pos]
+        len = match.begin(0) - pos
+        text = input[pos, len]
         pos = match.end(0)
+        lspace = stmt ? detect_spaces_at_bol(text, is_bol) : nil
+        is_bol = stmt && rspace ? true : false
         add_text(codebuf, text) # unless text.empty?
-        add_pi_expr(codebuf, code, indicator)
+        #
+        if stmt
+          if @trim && lspace && rspace
+            add_pi_stmt(codebuf, "#{lspace}#{stmt}#{rspace}", pi_arg)
+          else
+            add_text(codebuf, lspace) if lspace
+            add_pi_stmt(codebuf, stmt, pi_arg)
+            add_text(codebuf, rspace) if rspace
+          end
+        else
+          add_pi_expr(codebuf, expr1 || expr2, indicator1 || indicator2)
+        end
       end
       rest = $' || input
       add_text(codebuf, rest)
     end
 
+    #--
+    #def convert_input(codebuf, input)
+    #  parse_stmts(codebuf, input)
+    #  #parse_stmts2(codebuf, input)
+    #end
+    #
+    #def parse_stmts(codebuf, input)
+    #  #regexp = pattern_regexp(@pattern)
+    #  @pi ||= 'e'
+    #  @stmt_pattern ||= /<\?#{@pi}(?:-(\w+))?(\s.*?)\?>([ \t]*\r?\n)?/m
+    #  is_bol = true
+    #  pos = 0
+    #  input.scan(@stmt_pattern) do |pi_arg, code, rspace|
+    #    match = Regexp.last_match
+    #    len  = match.begin(0) - pos
+    #    text = input[pos, len]
+    #    pos  = match.end(0)
+    #    lspace = detect_spaces_at_bol(text, is_bol)
+    #    is_bol = rspace ? true : false
+    #    parse_exprs(codebuf, text) # unless text.empty?
+    #    if @trim && lspace && rspace
+    #      add_pi_stmt(codebuf, "#{lspace}#{code}#{rspace}", pi_arg)
+    #    else
+    #      add_text(codebuf, lspace)
+    #      add_pi_stmt(codebuf, code, pi_arg)
+    #      add_text(codebuf, rspace)
+    #    end
+    #  end
+    #  rest = $' || input
+    #  parse_exprs(codebuf, rest)
+    #end
+    #
+    #def parse_exprs(codebuf, input)
+    #  unless @expr_pattern
+    #    ch = Regexp.escape(@embchar)
+    #    if @pattern
+    #      left, right = @pattern.split(' ')
+    #      @expr_pattern = /#{ch}(!*)?\{(.*?)\}#{ch}|#{left}(=+)(.*?)#{right}/
+    #    else
+    #      @expr_pattern = /#{ch}(!*)?\{(.*?)\}#{ch}/
+    #    end
+    #  end
+    #  pos = 0
+    #  input.scan(@expr_pattern) do |indicator1, code1, indicator2, code2|
+    #    indicator = indicator1 || indicator2
+    #    code = code1 || code2
+    #    match = Regexp.last_match
+    #    len  = match.begin(0) - pos
+    #    text = input[pos, len]
+    #    pos  = match.end(0)
+    #    add_text(codebuf, text) # unless text.empty?
+    #    add_pi_expr(codebuf, code, indicator)
+    #  end
+    #  rest = $' || input
+    #  add_text(codebuf, rest)
+    #end
+    #++
+
     def add_pi_stmt(codebuf, code, pi_arg)  # :nodoc:
       case pi_arg
+      when nil      ;  add_stmt(codebuf, code)
       when 'header' ;  @header = code
       when 'footer' ;  @footer = code
       when 'comment';  add_stmt(codebuf, "\n" * code.count("\n"))
@@ -250,57 +334,17 @@ module Erubis
 
     def add_pi_expr(codebuf, code, indicator)  # :nodoc:
       case indicator
-      when  nil, '', '=='    # @{...}@ or <%== ... %>
+      when nil, '', '=='    # @{...}@ or <%== ... %>
         @escape == false ? add_expr_literal(codebuf, code) : add_expr_escaped(codebuf, code)
-      when  '!', '='         # @!{...}@ or <%= ... %>
+      when '!', '='         # @!{...}@ or <%= ... %>
         @escape == false ? add_expr_escaped(codebuf, code) : add_expr_literal(codebuf, code)
-      when  '!!', '==='      # @!!{...}@ or <%=== ... %>
+      when '!!', '==='      # @!!{...}@ or <%=== ... %>
         add_expr_debug(codebuf, code)
       else
         # ignore
       end
     end
 
-    ## (obsolete) equivarent to parse_stmts(), but a little slower than it.
-    def parse_stmts2(codebuf, input)   # :nodoc:
-      #regexp = pattern_regexp(@pattern)
-      @pi ||= 'e'
-      unless @embedded_pattern
-        ch = Regexp.escape(@embchar)
-        if @pattern
-          left, right = @pattern.split(' ')
-          @embedded_pattern = /(^[ \t]*)?<\?#{@pi}(?:-(\w+))?(\s.*?)\?>([ \t]*\r?\n)?|#{ch}(!*)?\{(.*?)\}#{ch}|#{left}(=+)(.*?)#{right}/m
-        else
-          @embedded_pattern = /(^[ \t]*)?<\?#{@pi}(?:-(\w+))?(\s.*?)\?>([ \t]*\r?\n)?|#{ch}(!*)?\{(.*?)\}#{ch}/m
-        end
-      end
-      pos = 0
-      input.scan(@embedded_pattern) do |lspace, pi_arg, stmt, rspace,
-                                    indicator1, expr1, indicator2, expr2|
-        match = Regexp.last_match
-        index = match.begin(0)
-        text = input[pos, index - pos]
-        pos = match.end(0)
-        add_text(codebuf, text)  # unless text.empty?
-        if stmt
-          code = stmt
-          if @trim && lspace && rspace
-            add_pi_stmt(codebuf, "#{lspace}#{code}#{rspace}", pi_arg)
-          else
-            add_text(codebuf, lspace)
-            add_pi_stmt(codebuf, code, pi_arg)
-            add_text(codebuf, rspace)
-          end
-        else
-          code = expr1 || expr2
-          indicator = indicator1 || indicator2
-          add_pi_expr(codebuf, code, indicator)
-        end
-      end
-      rest = $' || input
-      add_text(codebuf, rest)
-    end
-
   end