kwartz 3.1.2 → 3.2.0

data/lib/kwartz.rb

@@ -1,13 +1,13 @@
 ###
-### $Rev: 136 $
-### $Release: 3.1.2 $
+### $Rev$
+### $Release: 3.2.0 $
 ### copyright(c) 2004-2006 kuwata-lab.com all rights reserved
 ###
 
 
 module Kwartz
 
-  RELEASE = ('$Release: 3.1.2 $' =~ /\$Release: (\S+)\s*\$/) && $1
+  RELEASE = ('$Release: 3.2.0 $' =~ /\$Release: (\S+)\s*\$/) && $1
 
 end
 

data/lib/kwartz/assert.rb

@@ -1,6 +1,6 @@
 ####
-#### $Rev: 103 $
-#### $Release: 3.1.2 $
+#### $Rev$
+#### $Release: 3.2.0 $
 #### copyright(c) 2004-2006 kuwata-lab.com all rights reserved
 ####
 

data/lib/kwartz/binding/eperl.rb

@@ -1,6 +1,6 @@
 ###
-### $Rev: 123 $
-### $Release: 3.1.2 $
+### $Rev$
+### $Release: 3.2.0 $
 ### copyright(c) 2004-2006 kuwata-lab.com all rights reserved
 ###
 
@@ -14,10 +14,49 @@ module Kwartz
 
 
 
+  module EperlExpressionParser
+
+
+    def parse_expr_str(expr_str, linenum)
+      case expr_str
+      when /\A(\w+)\z/             # variable
+        expr = '$'+$1
+      when /\A(\w+)\.(\w+)\z/      # object.property
+        expr = "$#{$1}->{#{$2}}"
+      when /\A(\w+)\[(.*?'|".*?"|:\w+)\]\z/   # hash
+        key = $2[0] == ?: ? "'#{$2[1..-1]}'" : $2
+        expr = "$#{$1}{#{key}}"
+      when /\A(\w+)\[(\w+)\]\z/    # array or hash
+        begin
+          expr = "$#{$1}[#{Integer($2)}]"
+        rescue ArgumentError
+          expr = "$#{$1}[$#{$2}]"
+        end
+      else
+        raise convert_error("'#{expr_str}': invalid expression.", linenum)
+      end
+      return expr
+    end
+
+
+    def parse_expr_str!(expr_str)
+      begin
+        return parse_expr_str(expr_str, -1)
+      rescue
+        return expr_str
+      end
+    end
+
+
+  end
+
+
+
   ##
   ## directive handler for ePerl
   ##
   class EperlHandler < Handler
+    include EperlExpressionParser
 
 
     PERL_DIRECTIVE_PATTERN = /\A(\w+)(?:\s*\(\s*(.*)\))?\z/
@@ -41,21 +80,21 @@ module Kwartz
     end
 
 
-    def handle(stmt_list, handler_arg)
+    def handle(directive, elem_info, stmt_list)
       ret = super
       return ret if ret
 
-      arg = handler_arg
-      d_name = arg.directive_name
-      d_arg  = arg.directive_arg
-      d_str  = arg.directive_str
+      d_name = directive.name
+      d_arg  = directive.arg
+      d_str  = directive.str
+      e = elem_info
 
       case d_name
 
       when :foreach, :Foreach, :FOREACH, :list, :List, :LIST
         is_foreach = d_name == :foreach || d_name == :Foreach || d_name == :FOREACH
         unless d_arg =~ /\A(\$\w+)(?:,\s*(\$\w+))?\s+in\s+(.*)\z/
-          raise convert_error("'#{d_str}': invalid argument.", stag_info.linenum)
+          raise convert_error("'#{d_str}': invalid argument.", e.stag_info.linenum)
         end
         loopvar = $1 ;  loopval = $2 ;  looplist = $3
         counter = d_name == :foreach || d_name == :list ? nil : "#{loopvar}_ctr"
@@ -71,11 +110,11 @@ module Kwartz
         code   << "  #{counter}++;" if counter
         code   << "  my #{toggle} = #{counter}%2==0 ? #{self.even} : #{self.odd};" if toggle
         if is_foreach
-          wrap_element_with_native_stmt(stmt_list, arg, code, "}", :foreach)
+          wrap_element_with_native_stmt(elem_info, stmt_list, code, "}", :foreach)
         else
-          wrap_content_with_native_stmt(stmt_list, arg, code, "}", :foreach)
+          wrap_content_with_native_stmt(elem_info, stmt_list, code, "}", :foreach)
         end
-        #stmt_list  <<  stag_stmt(arg)   if !is_foreach
+        #stmt_list  <<  stag_stmt(elem_info)   if !is_foreach
         #stmt_list  <<  NativeStatement.new("my #{counter} = 0;") if counter
         #if loopval
         #  stmt_list << NativeStatement.new("foreach my #{loopvar} (keys #{looplist}) {", :foreach)
@@ -85,23 +124,23 @@ module Kwartz
         #end
         #stmt_list  <<  NativeStatement.new("  #{counter}++;") if counter
         #stmt_list  <<  NativeStatement.new("  my #{toggle} = #{counter}%2==0 ? #{self.even} : #{self.odd};") if toggle
-        #stmt_list  <<  stag_stmt(arg)   if is_foreach
-        #stmt_list.concat(arg.cont_stmts)
-        #stmt_list  <<  etag_stmt(arg)   if is_foreach
+        #stmt_list  <<  stag_stmt(elem_info)   if is_foreach
+        #stmt_list.concat(elem_info.cont_stmts)
+        #stmt_list  <<  etag_stmt(elem_info)   if is_foreach
         #stmt_list  <<  NativeStatement.new("}", :foreach)
-        #stmt_list  <<  etag_stmt(arg)   if !is_foreach
+        #stmt_list  <<  etag_stmt(elem_info)   if !is_foreach
 
       when :while
-        wrap_element_with_native_stmt(stmt_list, arg, "while (#{d_arg}) {", "}", :while)
+        wrap_element_with_native_stmt(elem_info, stmt_list, "while (#{d_arg}) {", "}", :while)
         #stmt_list << NativeStatement.new("while (#{d_arg}) {", :while)
-        #stmt_list << stag_stmt(arg)
+        #stmt_list << stag_stmt(elem_info)
         #stmt_list.concat(cont_stmts)
-        #stmt_list << etag_stmt(arg)
+        #stmt_list << etag_stmt(elem_info)
         #stmt_list << NativeStatement.new("}", :while)
 
       when :loop
-        error_if_empty_tag(arg)
-        wrap_content_with_native_stmt(stmt_list, arg, "while (#{d_arg}) {", "}", :while)
+        error_if_empty_tag(elem_info, d_str)
+        wrap_content_with_native_stmt(elem_info, stmt_list, "while (#{d_arg}) {", "}", :while)
         #stmt_list << stag_stmt
         #stmt_list << NativeStatement.new("while (#{d_arg}) {", :while)
         #stmt_list.concat(cont_stmts)
@@ -109,14 +148,14 @@ module Kwartz
         #stmt_list << etag_stmt
 
       when :set
-        wrap_element_with_native_stmt(stmt_list, arg, "#{d_arg};", nil, :set)
+        wrap_element_with_native_stmt(elem_info, stmt_list, "#{d_arg};", nil, :set)
         #stmt_list << NativeStatement.new("#{d_arg};", :set)
         #stmt_list << stag_stmt
         #stmt_list.concat(cont_stmts)
         #stmt_list << etag_stmt
 
       when :if
-        wrap_element_with_native_stmt(stmt_list, arg, "if (#{d_arg}) {", "}", :if)
+        wrap_element_with_native_stmt(elem_info, stmt_list, "if (#{d_arg}) {", "}", :if)
         #stmt_list << NativeStatement.new("if (#{d_arg}) {", :if)
         #stmt_list << stag_stmt
         #stmt_list.concat(cont_stmts)
@@ -124,11 +163,11 @@ module Kwartz
         #stmt_list << NativeStatement.new("}", :if)
 
       when :elsif, :else
-        error_when_last_stmt_is_not_if(stmt_list, arg)
+        error_when_last_stmt_is_not_if(elem_info, d_str, stmt_list)
         stmt_list.pop    # delete '}'
         kind = d_name == :else ? :else : :elseif
         code = d_name == :else ? "} else {" : "} elsif (#{d_arg}) {"
-        wrap_element_with_native_stmt(stmt_list, arg, code, "}", kind)
+        wrap_element_with_native_stmt(elem_info, stmt_list, code, "}", kind)
         #stmt_list << NativeStatement.new(code, kind)
         #stmt_list << stag_stmt
         #stmt_list.concat(cont_stmts)
@@ -136,19 +175,19 @@ module Kwartz
         #stmt_list << NativeStatement.new("}", kind)
 
       when :default, :Default, :DEFAULT
-        error_if_empty_tag(arg)
-        expr_code = d_arg
+        error_if_empty_tag(elem_info, d_str)
+        expr_str = directive.dattr == 'id' ? parse_expr_str(d_arg, e.stag_info.linenum) : d_arg
         flag_escape = d_name == :default ? nil : (d_name == :Default)
-        add_native_expr_with_default(stmt_list, arg, expr_code, flag_escape,
-                                     "if (#{d_arg}) {", "} else {", "}")
-        #stmt_list << stag_stmt(arg)
+        add_native_expr_with_default(elem_info, stmt_list, expr_str, flag_escape,
+                                     "if (#{expr_str}) {", "} else {", "}")
+        #stmt_list << stag_stmt(elem_info)
         #stmt_list << NativeStatement.new_without_newline("if (#{d_arg}) {", :if)
         #flag_escape = d_name == :default ? nil : (d_name == :Default)
         #stmt_list << PrintStatement.new([ NativeExpression.new(d_arg, flag_escape) ])
         #stmt_list << NativeStatement.new_without_newline("} else {", :else)
-        #stmt_list.concat(arg.cont_stmts)
+        #stmt_list.concat(elem_info.cont_stmts)
         #stmt_list << NativeStatement.new_without_newline("}", :else)
-        #stmt_list << etag_stmt(arg)
+        #stmt_list << etag_stmt(elem_info)
 
       else
         return false
@@ -168,6 +207,7 @@ module Kwartz
   ## translator for ePerl
   ##
   class EperlTranslator < BaseTranslator
+    include EperlExpressionParser
 
 
     EPERL_EMBED_PATTERNS = [

data/lib/kwartz/binding/erubis.rb

@@ -1,6 +1,6 @@
 ###
-### $Rev: 124 $
-### $Release: 3.1.2 $
+### $Rev$
+### $Release: 3.2.0 $
 ### copyright(c) 2004-2006 kuwata-lab.com all rights reserved
 ###
 
@@ -24,6 +24,7 @@ module Kwartz
   ## translator for Erubis
   ##
   class ErubisTranslator < BaseTranslator
+    include RubyExpressionParser
 
 
     ERUBIS_EMBED_PATTERNS = [

data/lib/kwartz/binding/eruby.rb

@@ -1,6 +1,6 @@
 ###
-### $Rev: 124 $
-### $Release: 3.1.2 $
+### $Rev$
+### $Release: 3.2.0 $
 ### copyright(c) 2004-2006 kuwata-lab.com all rights reserved
 ###
 
@@ -27,6 +27,7 @@ module Kwartz
   ## translator for eRuby
   ##
   class ErubyTranslator < BaseTranslator
+    include RubyExpressionParser
 
 
     ERUBY_EMBED_PATTERNS = [

data/lib/kwartz/binding/jstl.rb

@@ -1,6 +1,6 @@
 ###
-### $Rev: 123 $
-### $Release: 3.1.2 $
+### $Rev$
+### $Release: 3.2.0 $
 ### copyright(c) 2004-2006 kuwata-lab.com all rights reserved
 ###
 
@@ -14,10 +14,45 @@ module Kwartz
 
 
 
+  module JstlExpressionParser
+
+
+    def parse_expr_str(expr_str, linenum)
+      case expr_str
+      when /\A(\w+)\z/             # variable
+        expr = expr_str
+      when /\A(\w+)\.(\w+)\z/      # object.property
+        expr = expr_str
+      when /\A(\w+)\[('.*?'|".*?"|:\w+)\]\z/   # hash
+        key = $2[0] == ?: ? "'#{$2[1..-1]}'" : $2
+        expr = "#{$1}[#{key}]"
+      when /\A(\w+)\[(\w+)\]\z/    # array or hash
+        expr = "#{$1}[#{$2}]"
+      else
+        raise convert_error("'#{expr_str}': invalid expression.", linenum)
+      end
+      return expr
+    end
+
+
+    def parse_expr_str!(expr_str)
+      begin
+        return parse_expr_str(expr_str, 0)
+      rescue
+        return expr_str
+      end
+    end
+
+
+  end
+
+
+
   ##
   ## directive handler for JSTL
   ##
   class JstlHandler < Handler
+    include JstlExpressionParser
 
 
     def initialize(elem_rulesets=[], properties={})
@@ -47,22 +82,22 @@ module Kwartz
     end
 
 
-    def handle(stmt_list, handler_arg)
+    def handle(directive, elem_info, stmt_list)
       ret = super
       return ret if ret
 
-      arg = handler_arg
-      d_name = arg.directive_name
-      d_arg  = arg.directive_arg
-      d_str  = arg.directive_str
+      d_name = directive.name
+      d_arg  = directive.arg
+      d_str  = directive.str
+      e = elem_info
 
       case d_name
 
       when :for, :For, :FOR, :list, :List, :LIST
         is_foreach = d_name == :for || d_name == :For || d_name == :FOR
-        error_if_empty_tag(arg) unless is_foreach
+        error_if_empty_tag(elem_info, d_str) unless is_foreach
         unless d_arg =~ /\A(\w+)\s*:\s*(.*)\z/
-          raise convert_error("'#{d_str}': invalid argument.", arg.stag_info.linenum)
+          raise convert_error("'#{d_str}': invalid argument.", elem_info.stag_info.linenum)
         end
         loopvar = $1 ; looplist = $2
         counter = d_name == :for || d_name == :list ? nil : "#{loopvar}_ctr"
@@ -87,40 +122,40 @@ module Kwartz
         end
         end_code = "</c:forEach>"
         if is_foreach
-          wrap_element_with_native_stmt(stmt_list, arg, code, end_code, :set)
+          wrap_element_with_native_stmt(elem_info, stmt_list, code, end_code, :set)
         else
-          wrap_content_with_native_stmt(stmt_list, arg, code, end_code, :set)
+          wrap_content_with_native_stmt(elem_info, stmt_list, code, end_code, :set)
         end
 
       when :while, :loop
         msg = "'#{d_str}': jstl doesn't support '#{d_arg}' directive."
-        raise convert_error(msg, arg.stag_info.linenum)
+        raise convert_error(msg, elem_info.stag_info.linenum)
 
       when :set
         unless d_arg =~ /\A(\S+)\s*=\s*(.*)\z/
-          raise convert_error("'#{d_str}': invalid argument.", arg.stag_info.linenum)
+          raise convert_error("'#{d_str}': invalid argument.", elem_info.stag_info.linenum)
         end
         lhs = $1;  rhs = $2
         code = "<c:set var=\"#{lhs}\" value=\"${#{rhs}}\"/>"
-        wrap_element_with_native_stmt(stmt_list, arg, code, nil, :set)
+        wrap_element_with_native_stmt(elem_info, stmt_list, code, nil, :set)
         #code = "<c:set var=\"#{lhs}\" value=\"${#{rhs}}\"/>"
         #stmt_list << NativeStatement.new(code, :set)
-        #stmt_list << stag_stmt(arg)
+        #stmt_list << stag_stmt(elem_info)
         #stmt_list.concat(cont_stmts)
-        #stmt_list << etag_stmt(arg)
+        #stmt_list << etag_stmt(elem_info)
 
       when :if
         start_code = "<c:choose><c:when test=\"${#{d_arg}}\">"
         end_code   = "</c:when></c:choose>"
-        wrap_element_with_native_stmt(stmt_list, arg, start_code, end_code, :if)
+        wrap_element_with_native_stmt(elem_info, stmt_list, start_code, end_code, :if)
         #stmt_list << NativeStatement.new(start_code, :if)
-        #stmt_list << stag_stmt(arg)
+        #stmt_list << stag_stmt(elem_info)
         #stmt_list.concat(cont_stmts)
-        #stmt_list << etag_stmt(arg)
+        #stmt_list << etag_stmt(elem_info)
         #stmt_list << NativeStatement.new(end, :if)
 
       when :elseif, :else
-        error_when_last_stmt_is_not_if(stmt_list, arg)
+        error_when_last_stmt_is_not_if(elem_info, d_str, stmt_list)
         stmt_list.pop    # delete '</c:when></c:choose>'
         if d_name == :else
           kind = :else
@@ -131,7 +166,7 @@ module Kwartz
           start_code = "</c:when><c:when test=\"${#{d_arg}}\">"
           end_code   = "</c:when></c:choose>"
         end
-        wrap_element_with_native_stmt(stmt_list, arg, start_code, end_code, kind)
+        wrap_element_with_native_stmt(elem_info, stmt_list, start_code, end_code, kind)
         #stmt_list << NativeStatement.new(start_code, kind)
         #stmt_list << stag_stmt
         #stmt_list.concat(cont_stmts)
@@ -139,31 +174,32 @@ module Kwartz
         #stmt_list << NativeStatement.new(end_code, kind)
 
       when :default, :Default, :DEFAULT
-        error_if_empty_tag(arg)
-        stmt_list << stag_stmt(arg)
+        error_if_empty_tag(elem_info, d_str)
+        stmt_list << stag_stmt(elem_info)
         flag_escape = d_name == :default ? nil : (d_name == :Default)
-        argstr = arg.cont_stmts[0].args[0]
-        code =  "<c:out value=\"${#{d_arg}}\""
+        argstr = elem_info.cont_stmts[0].args[0]
+        expr_str = directive.dattr == 'id' ? parse_expr_str(d_arg, e.stag_info.linenum) : d_arg
+        code =  "<c:out value=\"${#{expr_str}}\""
         code << " escapeXml=\"#{flag_escape}\"" unless flag_escape == nil
         code << " default=\"#{argstr}\"/>"
         stmt_list << NativeStatement.new_without_newline(code)
-        stmt_list << etag_stmt(arg)
+        stmt_list << etag_stmt(elem_info)
 
       when :catch
         if d_arg && !d_arg.empty? && d_arg !~ /\A\w+\z/
-          raise convert_error("'#{d_str}': invalid varname.", arg.stag_info.linenum)
+          raise convert_error("'#{d_str}': invalid varname.", elem_info.stag_info.linenum)
         end
         code = "<c:catch"
         code << " var=\"#{d_arg}\"" if d_arg && !d_arg.empty?
         code << ">"
         stmt_list << NativeStatement.new(code)
-        stmt_list.concat(arg.cont_stmts)
+        stmt_list.concat(elem_info.cont_stmts)
         stmt_list << NativeStatement.new("</c:catch>")
 
       when :forEach, :forTokens
         options = eval "{ #{d_arg} }"
         stag, etag = self.__send__ "handle_jstl_#{d_name}", options
-        wrap_element_with_native_stmt(stmt_list, arg, stag, etag, nil)
+        wrap_element_with_native_stmt(elem_info, stmt_list, stag, etag, nil)
         #stmt_list << NativeStatement.new(stag)
         #stmt_list << stag_stmt
         #stmt_list.concat(cont_stmts)
@@ -287,6 +323,7 @@ module Kwartz
   ## translator for php
   ##
   class JstlTranslator < BaseTranslator
+    include JstlExpressionParser
 
 
     JSTL11_EMBED_PATTERNS = [