kwartz 3.0.0 → 3.1.0

data/lib/kwartz/converter.rb

@@ -1,6 +1,6 @@
 ###
-### $Rev: 117 $
-### $Release: 3.0.0 $
+### $Rev: 135 $
+### $Release: 3.1.0 $
 ### copyright(c) 2004-2006 kuwata-lab.com all rights reserved
 ###
 
@@ -10,6 +10,7 @@ require 'kwartz/assert'
 require 'kwartz/error'
 require 'kwartz/node'
 require 'kwartz/config'
+require 'kwartz/util'
 
 require 'abstract'
 
@@ -168,7 +169,7 @@ module Kwartz
 
 
     def merged?
-      @merged
+      !@merged.nil?
     end
 
 
@@ -226,7 +227,7 @@ module Kwartz
 
     ## set @despan and @dattr
     def include_properties(properties)
-      @dattr = properties[:dattr]   || Config::PROPERTY_DATTR    # default: 'title'
+      @dattr = properties[:dattr]   || Config::PROPERTY_DATTR    # default: 'kw:d'
       @delspan = properties.key?(:delspan) ? properties[:delspan] : Config::PROPERTY_DELSPAN  # delete dummy <span> tag or not
     end
 
@@ -238,17 +239,50 @@ module Kwartz
 
 
     ## raise errror if etag_info is null
-    def error_if_empty_tag(stag_info, etag_info, d_name, d_arg)
-      unless etag_info
-        raise convert_error("'#{d_name}:#{d_arg}': #{d_name} directive is not available with empty tag.", stag_info.linenum)
+    def error_if_empty_tag(handler_arg)
+      arg = handler_arg
+      unless arg.etag_info
+        d_name  = arg.directive_name
+        d_str   = arg.directive_str
+        msg = "'#{d_str}': #{d_name} directive is not available with empty tag."
+        raise convert_error(msg, arg.stag_info.linenum)
       end
     end
 
 
+    def error_when_last_stmt_is_not_if(stmt_list, handler_arg)
+      kind = _last_stmt_kind(stmt_list)
+      unless kind == :if || kind == :elseif
+        d_str = handler_arg.directive_str
+        linenum = handler_arg.stag_info.linenum
+        msg = "'#{d_str}': previous statement should be 'if' or 'elsif'."
+        raise convert_error(msg, linenum)
+      end
+    end
+
+
+    #private
+
+
+    def _last_stmt_kind(stmt_list)
+      return nil if stmt_list.nil? || stmt_list.empty?
+      stmt = stmt_list.last
+      return nil unless stmt.is_a?(NativeStatement)
+      return stmt.kind
+    end
+
+
+  end
+
+
+
+  module StatementHelper
+
+
     ## create print statement from text
     def create_text_print_stmt(text)
       return PrintStatement.new([text])
-      #return new PritnStatement.new([TextExpression.new(text)])
+      #return PritnStatement.new([TextExpression.new(text)])
     end
 
 
@@ -311,12 +345,84 @@ module Kwartz
     end
 
 
+    ## build print statement of start-tag
+    def stag_stmt(handler_arg)
+      arg = handler_arg
+      return build_print_stmt(arg.stag_info, arg.attr_info, arg.append_exprs)
+    end
+
+
+    ## build print statemetn of end-tag
+    def etag_stmt(handler_arg)
+      arg = handler_arg
+      return build_print_stmt(arg.etag_info, nil, nil)
+    end
+
+
+    def add_native_code(stmt_list, code, kind)
+      if code.is_a?(String)
+        stmt_list << NativeStatement.new(code, kind)
+      elsif code.is_a?(Array)
+        stmt_list.concat(code.collect {|line| NativeStatement.new(line, kind)})
+      end
+    end
+
+
+    def wrap_element_with_native_stmt(stmt_list, handler_arg, start_code, end_code, kind=nil)
+      add_native_code(stmt_list, start_code, kind)
+      stmt_list << stag_stmt(handler_arg)
+      stmt_list.concat(handler_arg.cont_stmts)
+      stmt_list << etag_stmt(handler_arg)
+      add_native_code(stmt_list, end_code, kind)
+    end
+
+
+    def wrap_content_with_native_stmt(stmt_list, handler_arg, start_code, end_code, kind=nil)
+      stmt_list << stag_stmt(handler_arg)
+      add_native_code(stmt_list, start_code, kind)
+      stmt_list.concat(handler_arg.cont_stmts)
+      add_native_code(stmt_list, end_code, kind)
+      stmt_list << etag_stmt(handler_arg)
+    end
+
+
+    def add_foreach_stmts(stmt_list, handler_arg, foreach_code, endforeach_code,
+                          content_only, counter, toggle, init_code, incr_code, toggle_code)
+      arg = handler_arg
+      stmt_list << stag_stmt(arg)                   if content_only
+      start_code.split(/\n/).each do |code|
+        stmt_list << NativeStatement.new(code, kind)
+      end if start_code
+      stmt_list << stag_stmt(arg)                   if !content_only
+      stmt_list.concat(arg.cont_stmts)
+      stmt_list << etag_stmt(arg)                   if !content_only
+      end_code.split(/\n/).each do |code|
+        stmt_list << NativeStatement.new(code, kind)
+      end
+      stmt_list << etag_stmt(arg)                   if content_only
+    end
+
+
+    def add_native_expr_with_default(stmt_list, handler_arg,
+                                     expr_code, flag_escape,
+                                     if_code, else_code, endif_code)
+      arg = handler_arg
+      stmt_list << stag_stmt(arg)
+      stmt_list << NativeStatement.new_without_newline(if_code, :if)
+      stmt_list << PrintStatement.new([ NativeExpression.new(expr_code, flag_escape) ])
+      stmt_list << NativeStatement.new_without_newline(else_code, :else)
+      stmt_list.concat(arg.cont_stmts)
+      stmt_list << NativeStatement.new_without_newline(endif_code, :else)
+      stmt_list << etag_stmt(arg)
+    end
+
+
   end
 
 
 
   ##
-  ## .[abstract] expand ExpandStatement and ElementInfo
+  ## (abstract) expand ExpandStatement and ElementInfo
   ##
   ## Handler class includes this module.
   ##
@@ -324,13 +430,13 @@ module Kwartz
     include Assertion
 
 
-    ## .[abstract] get ElementRuleset
+    ## (abstract) get ElementRuleset
     def get_element_ruleset(name)
       not_implemented
     end
 
 
-    ## .[abstract] get ElementInfo
+    ## (abstract) get ElementInfo
     def get_element_info(name)
       not_implemented
     end
@@ -437,11 +543,40 @@ module Kwartz
 
 
   ##
-  ## .[abstract] handle directives
+  ## argument data for handler
+  ##
+  class HandlerArgument
+    include StatementHelper
+
+
+    def initialize(directive_name, directive_arg, directive_str,
+                   stag_info, etag_info, cont_stmts, attr_info, append_exprs)
+      @directive_name = directive_name
+      @directive_arg  = directive_arg
+      @directive_str  = directive_str
+      @stag_info      = stag_info
+      @etag_info      = etag_info
+      @cont_stmts     = cont_stmts
+      @attr_info      = attr_info
+      @append_exprs   = append_exprs
+    end
+
+
+    attr_reader :directive_name, :directive_arg, :directive_str
+    attr_reader :stag_info, :etag_info, :cont_stmts, :attr_info, :append_exprs
+
+
+  end
+
+
+
+  ##
+  ## (abstract) handle directives
   ##
   class Handler
     include Assertion
     include ConverterHelper
+    include StatementHelper
     include ElementExpander
 
 
@@ -460,33 +595,52 @@ module Kwartz
 
 
     def get_element_ruleset(name)  # for ElementExpander module and Converter class
-      @elem_ruleset_table[name]
+      return @elem_ruleset_table[name]
     end
 
 
     def get_element_info(name)  # for ElementExpander module
-      @elem_info_table[name]
+      return @elem_info_table[name]
+    end
+
+
+    def _elem_info_table    # :nodoc:
+      return @elem_info_table
+    end
+
+
+    def _import_element_info_from_handler(handler, names=nil) # :nodoc:
+      if names
+        regexp_list = names.collect { |name| Kwartz::Util.pattern_to_regexp(name) }
+        handler._elem_info_table.each do |name, elem_info|
+          if regexp_list.any? { |regexp| regexp =~ name }
+            @elem_info_table[name] = elem_info
+          end
+        end
+      else
+        @elem_info_table.update(handler._elem_info_table)
+      end
     end
 
 
     protected
 
 
-    ## .[abstract] directive pattern, which is used to detect directives.
+    ## (abstract) directive pattern, which is used to detect directives.
     def directive_pattern
       not_implemented
       #return /\A(\w+):\s*(.*)/
     end
 
 
-    ## .[abstract] mapping pattern, which is used to parse 'attr' directive.
+    ## (abstract) mapping pattern, which is used to parse 'attr' directive.
     def mapping_pattern
       not_implemented
       #return /\A'([-:\w]+)'\s+(.*)/
     end
 
 
-    ## .[abstract] directive format, which is used at has_directive?() method
+    ## (abstract) directive format, which is used at has_directive?() method
     def directive_format
       not_implemented
       #return '%s: %s'
@@ -500,32 +654,35 @@ module Kwartz
     ##
     ## return true if directive name is one of 'stag', 'etag', 'elem', 'cont', and 'value',
     ## else return false.
-    def handle(directive_name, directive_arg, directive_str, stag_info, etag_info, cont_stmts, attr_info, append_exprs, stmt_list)
-      d_name = directive_name
-      d_arg  = directive_arg
-      d_str  = directive_str
+    def handle(stmt_list, handler_arg)
+      arg = handler_arg
+      d_name = arg.directive_name
+      d_arg  = arg.directive_arg
+      d_str  = arg.directive_str
 
-      case directive_name
+      case d_name
 
       when nil
-        assert unless !attr_info.empty? || !append_exprs.empty?
-        stmt_list << build_print_stmt(stag_info, attr_info, append_exprs)
-        stmt_list.concat(cont_stmts)
-        stmt_list << build_print_stmt(etag_info, nil, nil) if etag_info   # when empty-tag
+        assert unless !arg.attr_info.empty? || !arg.append_exprs.empty?
+        stmt_list << stag_stmt(arg)
+        stmt_list.concat(arg.cont_stmts)
+        stmt_list << etag_stmt(arg) if arg.etag_info   # when empty-tag
 
       when :dummy
         # nothing
 
       when :id, :mark
-        unless directive_arg =~ /\A(\w+)\z/ || directive_arg =~ /\A'(\w+)'\z/
-          raise convert_error("'#{d_str}': invalid marking name.", stag_info.linenum)
+        unless d_arg =~ /\A(\w+)\z/ || d_arg =~ /\A'(\w+)'\z/
+          raise convert_error("'#{d_str}': invalid marking name.", arg.stag_info.linenum)
         end
         name = $1
-        elem_info = ElementInfo.new(name, stag_info, etag_info, cont_stmts, attr_info, append_exprs)
+        elem_info = ElementInfo.new(name, arg.stag_info, arg.etag_info, arg.cont_stmts,
+                                    arg.attr_info, arg.append_exprs)
         if @elem_info_table[name]
           #unless Config::ALLOW_DUPLICATE_ID
             previous_linenum = @elem_info_table[name].stag_info.linenum
-            raise convert_error("'#{d_str}': id '#{name}' is already used at line #{previous_linenum}.", stag_info.linenum)
+            msg = "'#{d_str}': id '#{name}' is already used at line #{previous_linenum}."
+            raise convert_error(msg, arg.stag_info.linenum)
           #end
         else
           @elem_info_table[name] = elem_info
@@ -534,47 +691,46 @@ module Kwartz
         expand_element_info(elem_info, stmt_list)
 
       when :stag, :Stag, :STAG
-        error_if_empty_tag(stag_info, etag_info, d_name, d_arg)
+        error_if_empty_tag(arg)
         flag_escape = d_name == :stag ? nil : (d_name == :Stag)
         expr = NativeExpression.new(d_arg, flag_escape)
-        stmt_list << build_print_expr_stmt(expr, stag_info, nil)
-        stmt_list.concat(cont_stmts)
-        stmt_list << build_print_stmt(etag_info, nil, nil)
+        stmt_list << build_print_expr_stmt(expr, arg.stag_info, nil)
+        stmt_list.concat(arg.cont_stmts)
+        stmt_list << etag_stmt(arg)
 
       when :etag, :Etag, :ETAG
-        error_if_empty_tag(stag_info, etag_info, d_name, d_arg)
+        error_if_empty_tag(arg)
         flag_escape = d_name == :etag ? nil : (d_name == :Etag)
         expr = NativeExpression.new(d_arg, flag_escape)
-        stmt_list << build_print_stmt(stag_info, attr_info, append_exprs)
-        stmt_list.concat(cont_stmts)
-        stmt_list << build_print_expr_stmt(expr, nil, etag_info)
+        stmt_list << stag_stmt(arg)
+        stmt_list.concat(arg.cont_stmts)
+        stmt_list << build_print_expr_stmt(expr, nil, arg.etag_info)
 
       when :elem, :Elem, :ELEM
         flag_escape = d_name == :elem ? nil : (d_name == :Elem)
         expr = NativeExpression.new(d_arg, flag_escape)
-        stmt_list << build_print_expr_stmt(expr, stag_info, etag_info)
+        stmt_list << build_print_expr_stmt(expr, arg.stag_info, arg.etag_info)
 
       when :cont, :Cont, :CONT, :value, :Value, :VALUE
-        error_if_empty_tag(stag_info, etag_info, d_name, d_arg)
-        stag_info.tail_space = etag_info.head_space = nil    # delete spaces
-        args = build_print_args(stag_info, attr_info, append_exprs)
+        error_if_empty_tag(arg)
+        arg.stag_info.tail_space = arg.etag_info.head_space = nil    # delete spaces
+        pargs = build_print_args(arg.stag_info, arg.attr_info, arg.append_exprs)
         flag_escape = (d_name == :cont || d_name == :value) ? nil : (d_name == :Cont || d_name == :Value)
-        args << NativeExpression.new(d_arg, flag_escape)
-        #args << etag_info.tag_text
-        args << etag_info.tag_text if etag_info.tagname
-        stmt_list << PrintStatement.new(args)
+        pargs << NativeExpression.new(d_arg, flag_escape)
+        pargs << arg.etag_info.tag_text if arg.etag_info.tagname
+        stmt_list << PrintStatement.new(pargs)
 
       when :attr, :Attr, :ATTR
         unless d_arg =~ self.mapping_pattern()     # ex. /\A'([-:\w]+)'\s+(.*)\z/
-          raise convert_error("'#{d_str}': invalid attr pattern.", stag_info.linenum)
+          raise convert_error("'#{d_str}': invalid attr pattern.", arg.stag_info.linenum)
         end
         aname = $1;  avalue = $2
         flag_escape = d_name == :attr ? nil : (d_name == :Attr)
-        attr_info[aname] = NativeExpression.new(avalue, flag_escape)
+        arg.attr_info[aname] = NativeExpression.new(avalue, flag_escape)
 
       when :append, :Append, :APPEND
         flag_escape = d_name == :append ? nil : (d_name == :Append)
-        append_exprs << NativeExpression.new(d_arg, flag_escape)
+        arg.append_exprs << NativeExpression.new(d_arg, flag_escape)
 
       when :replace_element_with_element, :replace_element_with_content,
            :replace_content_with_element, :replace_content_with_content
@@ -583,15 +739,15 @@ module Kwartz
         with_content = arr[3] == 'content'
         name = d_arg
         #
-        error_if_empty_tag(stag_info, etag_info, d_name, d_arg)           if replace_cont
-        stmt_list << build_print_stmt(stag_info, attr_info, append_exprs) if replace_cont
+        error_if_empty_tag(arg)   if replace_cont
+        stmt_list << stag_stmt(arg) if replace_cont
         #stmt_list << ExpandStatement.new(:element, name)
         elem_info = @elem_info_table[name]
         unless elem_info
-          raise convert_error("'#{d_str}': element '#{name}' not found.", stag_info.linenum)
+          raise convert_error("'#{d_str}': element '#{name}' not found.", arg.stag_info.linenum)
         end
         expand_element_info(elem_info, stmt_list, with_content)
-        stmt_list << build_print_stmt(etag_info, nil, nil)                if replace_cont
+        stmt_list << etag_stmt(arg) if replace_cont
 
       when :replace_element_with, :replace_content_with, :replace, :placeholder
         unless d_arg =~ /\A_?(element|content)\(["']?(\w+)["']?\)\z/
@@ -602,15 +758,17 @@ module Kwartz
         replace_cont = d_name == :replace_content_with || d_name == :placeholder
         with_content = kind == 'content'
         #
-        error_if_empty_tag(stag_info, etag_info, d_name, d_arg)           if replace_cont
-        stmt_list << build_print_stmt(stag_info, attr_info, append_exprs) if replace_cont
+        error_if_empty_tag(arg) if replace_cont
+        stmt_list << stag_stmt(arg) if replace_cont
         #stmt_list << ExpandStatement.new(:element, name)
         elem_info = @elem_info_table[name]
         unless elem_info
-          raise convert_error("'#{d_str}': element '#{name}' not found.", stag_info.linenum)
+          msg = "'#{d_str}': element '#{name}' not found."
+          raise convert_error(msg, arg.stag_info.linenum)
         end
         expand_element_info(elem_info, stmt_list, with_content)
-        stmt_list << build_print_stmt(etag_info, nil, nil)                if replace_cont
+        stmt_list << etag_stmt(arg) if replace_cont
+
       else
         return false
       end #case
@@ -648,10 +806,11 @@ module Kwartz
 
 
   ##
-  ## .[abstract] covnert presentation data into list of Statement.
+  ## (abstract) covnert presentation data into list of Statement.
   ##
   class Converter
     include ConverterHelper
+    include StatementHelper
 
 
     def initialize(handler, properties={})
@@ -662,7 +821,7 @@ module Kwartz
     attr_reader :handler   #, :dattr, :input
 
 
-    ## .[abstract] convert string into list of Statement.
+    ## (abstract) convert string into list of Statement.
     def convert(input, filename='')
       not_implemented
     end
@@ -749,7 +908,7 @@ module Kwartz
       taginfo = TagInfo.new(@scanner)
       @linenum += (@linenum_delta + taginfo.prev_text.count("\n"))
       @linenum_delta = taginfo.tag_text.count("\n")
-      taginfo.linenum = linenum
+      taginfo.linenum = @linenum
       return taginfo
     end
 
@@ -832,12 +991,14 @@ module Kwartz
         d_arg  = $2 || ''    # directive arg
         case d_name
         when :attr, :Attr, :ATTR
-          @handler.handle(d_name, d_arg, d_str, stag_info, etag_info,
-                          cont_stmts, attr_info, append_exprs, stmt_list)
+          handler_args = HandlerArgument.new(d_name, d_arg, d_str, stag_info, etag_info,
+                                             cont_stmts, attr_info, append_exprs)
+          @handler.handle(stmt_list, handler_args)
         when :append, :Append, :APPEND
           append_exprs ||= []
-          @handler.handle(d_name, d_arg, d_str, stag_info, etag_info,
-                          cont_stmts, attr_info, append_exprs, stmt_list)
+          handler_args = HandlerArgument.new(d_name, d_arg, d_str, stag_info, etag_info,
+                                             cont_stmts, attr_info, append_exprs)
+          @handler.handle(stmt_list, handler_args)
         else
           if directive_name
             raise convert_error("'#{d_str}': not available with '#{directive_name}' directive.", stag_info.linenum)
@@ -854,8 +1015,10 @@ module Kwartz
       end
 
       ## handle other directives
-      ret = @handler.handle(directive_name, directive_arg, directive_str, stag_info, etag_info,
-                            cont_stmts, attr_info, append_exprs, stmt_list)
+      handler_args = HandlerArgument.new(directive_name, directive_arg, directive_str,
+                                         stag_info, etag_info, cont_stmts,
+                                         attr_info, append_exprs)
+      ret = @handler.handle(stmt_list, handler_args)
       if directive_name && !ret
         raise convert_error("'#{directive_str}': unknown directive.", stag_info.linenum)
       end
@@ -865,8 +1028,8 @@ module Kwartz
 
     ## detect whether directive is exist or not
     def has_directive?(attr_info, taginfo)
-      ## title attribute
-      val = attr_info[@dattr]     # ex. @dattr == 'title'
+      ## kw:d attribute
+      val = attr_info[@dattr]     # ex. @dattr == 'kw:d'
       if val && val.is_a?(String) && !val.empty?
         if val[0] == ?\  ;
           val[0,1] = ''     # delete a space