kwartz 3.1.2 → 3.2.0

data/lib/kwartz/binding/perl.rb

@@ -0,0 +1,230 @@
+###
+### $Rev$
+### $Release: 3.2.0 $
+### copyright(c) 2004-2006 kuwata-lab.com all rights reserved
+###
+
+require 'kwartz/converter'
+require 'kwartz/translator'
+
+
+module Kwartz
+
+
+  module PerlExpressionParser
+
+
+    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 Perl
+  ##
+  class PerlHandler < Handler
+    include PerlExpressionParser
+
+
+    PERL_DIRECTIVE_PATTERN = /\A(\w+)(?:\s*\(\s*(.*)\))?\z/
+
+    def directive_pattern
+      return PERL_DIRECTIVE_PATTERN
+    end
+
+
+    PERL_MAPPING_PATTERN = /\A'([-:\w]+)',\s*(.*)\z/
+
+    def mapping_pattern
+      return PERL_MAPPING_PATTERN
+    end
+
+
+    PERL_DIRECTIVE_FORMAT = '%s(%s)'
+
+    def directive_format
+      return PERL_DIRECTIVE_FORMAT
+    end
+
+
+    def handle(directive, elem_info, stmt_list)
+      ret = super
+      return ret if ret
+
+      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
+        unless d_arg =~ /\A(\w+)(?:,\s*(\w+))?\s+in\s+(.*)\z/  \
+            || d_arg =~ /\A(\w+)(?:,(\w+))?\s*[:=]\s*(.*)\z/
+          raise convert_error("'#{d_str}': invalid argument.", e.stag_info.linenum)
+        end
+        loopvar = $1 ;  loopval = $2 ;  looplist = $3
+        is_foreach = d_name == :for || d_name == :For || d_name == :FOR
+        counter = d_name == :for || d_name == :list ? nil : "#{loopvar}_ctr"
+        toggle  = d_name != :FOR && d_name != :LIST ? nil : "#{loopvar}_tgl"
+        foreach_code = loopval ? "#{looplist}.each do |#{loopvar}, #{loopval}|" \
+                               : "for #{loopvar} in #{looplist} do"
+        code = []
+        code << "#{counter} = 0" if counter
+        code << foreach_code
+        code << "  #{counter} += 1" if counter
+        code << "  #{toggle} = #{counter}%2==0 ? #{@even} : #{@odd}" if toggle
+        if is_foreach
+          wrap_element_with_native_stmt(elem_info, stmt_list, code, "end", :foreach)
+        else
+          wrap_content_with_native_stmt(elem_info, stmt_list, code, "end", :foreach)
+        end
+
+      when :while
+        wrap_element_with_native_stmt(elem_info, stmt_list, "while #{d_arg} do", "end", :while)
+        #stmt_list << NativeStatement.new("while #{d_arg} do", :while)
+        #stmt_list << stag_stmt(elem_info)
+        #stmt_list.concat(e.cont_stmts)
+        #stmt_list << etag_stmt(elem_info)
+        #stmt_list << NativeStatement.new("end", :while)
+
+      when :loop
+        error_if_empty_tag(elem_info, d_str)
+        wrap_content_with_native_stmt(elem_info, stmt_list, "while #{d_arg} do", "end", :while)
+        #stmt_list << stag_stmt(elem_info)
+        #stmt_list << NativeStatement.new("while #{d_arg} do", :while)
+        #stmt_list.concat(e.cont_stmts)
+        #stmt_list << NativeStatement.new("end", :while)
+        #stmt_list << etag_stmt(elem_info)
+
+      when :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(elem_info)
+        #stmt_list.concat(e.cont_stmts)
+        #stmt_list << etag_stmt(elem_info)
+
+      when :if
+        wrap_element_with_native_stmt(elem_info, stmt_list, "if #{d_arg} then", "end", :if)
+        #stmt_list << NativeStatement.new("if #{d_arg} then", :if)
+        #stmt_list << stag_stmt(elem_info)
+        #stmt_list.concat(e.cont_stmts)
+        #stmt_list << etag_stmt(elem_info)
+        #stmt_list << NativeStatement.new("end", :if)
+
+      when :elsif, :else
+        error_when_last_stmt_is_not_if(elem_info, d_str, stmt_list)
+        stmt_list.pop    # delete 'end'
+        kind = d_name == :else ? :else : :elseif
+        code = d_name == :else ? "else" : "elsif #{d_arg} then"
+        wrap_element_with_native_stmt(elem_info, stmt_list, code, "end", kind)
+        #stmt_list << NativeStatement.new(code, kind)
+        #stmt_list << stag_stmt(elem_info)
+        #stmt_list.concat(e.cont_stmts)
+        #stmt_list << etag_stmt(elem_info)
+        #stmt_list << NativeStatement.new("end", kind)
+
+      when :default, :Default, :DEFAULT
+        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(elem_info, stmt_list, expr_str, flag_escape,
+                                     "if (#{expr_str}) && !(#{d_arg}).to_s.empty? then",
+                                     "else", "end")
+        #stmt_list << stag_stmt(elem_info)
+        #stmt_list << NativeStatement.new_without_newline("if (#{d_arg}) && !(#{d_arg}).to_s.empty? then", :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(e.cont_stmts)
+        #stmt_list << NativeStatement.new_without_newline("end", :else)
+        #stmt_list << etag_stmt(elem_info)
+
+      else
+        return false
+
+      end #case
+      return true
+
+    end #def
+
+
+  end #class
+  Handler.register_class('perl', PerlHandler)
+
+
+
+  ##
+  ## translator for Perl
+  ##
+  class PerlTranslator < BaseTranslator
+    include PerlExpressionParser
+
+
+    def initialize(properties={})
+      escapefunc = properties[:escapefunc] || 'encode_entities'
+      marks = ['', '', 'push(@_buf, ', '); ', "push(@_buf, #{escapefunc}(", ')); ']
+      super(marks, properties)
+      @header = 'my @_buf = (); '  unless @header == false
+      @footer = "join('', @_buf);" + @nl   unless @footer == false
+    end
+
+
+    def translate_string(str)
+      return if str.nil? || str.empty?
+      #str.gsub!(/['\\]/, '\\\\\&')
+      #@sb << "_buf << '#{str}'; "
+      str.gsub!(/[`\\]/, '\\\\\&')
+      @sb << "push(@_buf, q`#{str}`); "
+      #if str[-1] == ?\n
+      #  str.chomp!
+      #  @sb << "push(@_buf, q`#{str}`, #{@nl.inspect});" << @nl
+      #else
+      #  @sb << "push(@_buf, q`#{str}`); "
+      #end
+    end
+
+
+    def translate(stmt_list)
+      stmt_list2 = optimize_print_stmts(stmt_list)
+      return super(stmt_list2)
+    end
+
+
+  end #class
+  Translator.register_class('perl', PerlTranslator)
+
+
+
+end #module

data/lib/kwartz/binding/php.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 PhpExpressionParser
+
+
+    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
+          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, 0)
+      rescue
+        return expr_str
+      end
+    end
+
+
+  end
+
+
+
   ##
   ## directive handler for PHP
   ##
   class PhpHandler < Handler
+    include PhpExpressionParser
 
 
     PHP_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.*\s+as\s+(\$\w+)(?:\s*=>\s*\$\w+)?\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
         counter = d_name == :foreach || d_name == :list ? nil : "#{loopvar}_ctr"
@@ -66,23 +105,23 @@ module Kwartz
         code << "  #{counter}++;"            if counter
         code << "  #{toggle} = #{counter}%2==0 ? #{@even} : #{@odd};" if toggle
         if is_foreach
-          wrap_element_with_native_stmt(stmt_list, arg, code, "}", :foeach)
+          wrap_element_with_native_stmt(elem_info, stmt_list, code, "}", :foeach)
         else
-          wrap_content_with_native_stmt(stmt_list, arg, code, "}", :foeach)
+          wrap_content_with_native_stmt(elem_info, stmt_list, code, "}", :foeach)
         end
-        #stmt_list << stag_stmt(arg)   if !is_foreach
+        #stmt_list << stag_stmt(elem_info)   if !is_foreach
         #stmt_list << NativeStatement.new("#{counter} = 0;") if counter
         #stmt_list << NativeStatement.new("foreach (#{d_arg}) {", :foreach)
         #stmt_list << NativeStatement.new("  #{counter}++;") if counter
         #stmt_list << NativeStatement.new("  #{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
         #stmt_list.concat(cont_stmts)
@@ -90,8 +129,8 @@ module Kwartz
         #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)
@@ -99,14 +138,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)
@@ -114,11 +153,11 @@ module Kwartz
         #stmt_list << NativeStatement.new("}", :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 '}'
         kind = d_name == :else ? :else : :elseif
         code = d_name == :else ? "} else {" : "} elseif (#{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)
@@ -126,19 +165,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
@@ -158,6 +197,7 @@ module Kwartz
   ## translator for php
   ##
   class PhpTranslator < BaseTranslator
+    include PhpExpressionParser
 
 
     PHP_EMBED_PATTERNS = [

data/lib/kwartz/binding/pierubis.rb

@@ -1,6 +1,6 @@
 ###
-### $Rev: 137 $
-### $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 PIErubisTranslator < BaseTranslator
+    include RubyExpressionParser
 
 
     PIERUBIS_EMBED_PATTERNS = [

data/lib/kwartz/binding/rails.rb

@@ -1,6 +1,6 @@
 ###
-### $Rev: 135 $
-### $Release: 3.1.2 $
+### $Rev$
+### $Release: 3.2.0 $
 ### copyright(c) 2004-2006 kuwata-lab.com all rights reserved
 ###
 
@@ -93,15 +93,15 @@ module Kwartz
     ##
     ## everytime return true whenever directive name is unknown.
     ##
-    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
-      attr_info = arg.attr_info
+      d_name = directive.name
+      d_arg  = directive.arg
+      d_str  = directive.str
+      e = elem_info
+      attr_info = e.attr_info
 
       ## parse 'name="user[name]"' or 'id="user_name"'
       case d_name.to_s
@@ -126,13 +126,13 @@ module Kwartz
         add_directive_integer_option(d_arg, 'size', attr_info['size'])
 
       when :link_to, :link_to_remote, :link_to_unless_current
-        add_directive_content_as_arg(d_arg, arg.cont_stmts)
+        add_directive_content_as_arg(d_arg, elem_info.cont_stmts)
 
       when :anchor, :anchor_remote
         replace_elem = false
 
       when :mail_to
-        add_directive_content_as_arg(d_arg, arg.cont_stmts)
+        add_directive_content_as_arg(d_arg, elem_info.cont_stmts)
         add_directive_attr_as_arg(d_arg, attr_info, 'href')
         d_arg.sub!(/\A\'mailto:/, "'")
 
@@ -170,7 +170,7 @@ module Kwartz
       end #case
 
       ##
-      print_directive(stmt_list, arg, replace_elem)
+      print_directive(elem_info, stmt_list, d_name, d_arg, replace_elem)
 
       return true      # everytime return true
 
@@ -251,18 +251,17 @@ module Kwartz
     end
 
 
-    def print_directive(stmt_list, handler_arg, replace_elem=true)
-      arg = handler_arg
-      head_space = arg.stag_info.head_space
-      tail_space = (arg.etag_info || arg.stag_info).tail_space
+    def print_directive(elem_info, stmt_list, directive_name, directive_arg, replace_elem=true)
+      head_space = elem_info.stag_info.head_space
+      tail_space = (elem_info.etag_info || elem_info.stag_info).tail_space
       pargs = []
       pargs << head_space if head_space
-      pargs << NativeExpression.new("#{arg.directive_name} #{arg.directive_arg}")
+      pargs << NativeExpression.new("#{directive_name} #{directive_arg}")
       pargs << tail_space if tail_space
       stmt_list << PrintStatement.new(pargs)
       unless replace_elem
-        stmt_list.concat(arg.cont_stmts)
-        stmt_list << PrintStatement.new([arg.etag_info.tag_text])
+        stmt_list.concat(elem_info.cont_stmts)
+        stmt_list << PrintStatement.new([elem_info.etag_info.tag_text])
       end
     end
 
@@ -276,6 +275,7 @@ module Kwartz
   ## translator for rails
   ##
   class RailsTranslator < BaseTranslator
+    include RubyExpressionParser
 
 
     RAILS_EMBED_PATTERNS = [