kwartz 3.1.2 → 3.2.0

data/lib/kwartz/binding/ruby.rb

@@ -1,6 +1,6 @@
 ###
-### $Rev: 128 $
-### $Release: 3.1.2 $
+### $Rev$
+### $Release: 3.2.0 $
 ### copyright(c) 2004-2006 kuwata-lab.com all rights reserved
 ###
 
@@ -12,11 +12,45 @@ require 'kwartz/translator'
 module Kwartz
 
 
+  module RubyExpressionParser
+
+
+    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
+        expr = expr_str
+      when /\A(\w+)\[(\w+)\]\z/    # array or hash
+        expr = expr_str
+      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 Ruby
   ##
   class RubyHandler < Handler
+    include RubyExpressionParser
 
 
     RUBY_DIRECTIVE_PATTERN = /\A(\w+)(?:[:\s]\s*(.*))?\z/
@@ -40,24 +74,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
-      #stag_info = arg.stag_info
-      #etag_info = arg.etag_info
-      #cont_stmts = arg.cont_stmts
+      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.", arg.stag_info.linenum)
+          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
@@ -71,70 +102,70 @@ module Kwartz
         code << "  #{counter} += 1" if counter
         code << "  #{toggle} = #{counter}%2==0 ? #{@even} : #{@odd}" if toggle
         if is_foreach
-          wrap_element_with_native_stmt(stmt_list, arg, code, "end", :foreach)
+          wrap_element_with_native_stmt(elem_info, stmt_list, code, "end", :foreach)
         else
-          wrap_content_with_native_stmt(stmt_list, arg, code, "end", :foreach)
+          wrap_content_with_native_stmt(elem_info, stmt_list, code, "end", :foreach)
         end
 
       when :while
-        wrap_element_with_native_stmt(stmt_list, arg, "while #{d_arg} do", "end", :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(arg)
-        #stmt_list.concat(arg.cont_stmts)
-        #stmt_list << etag_stmt(arg)
+        #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(arg)
-        wrap_content_with_native_stmt(stmt_list, arg, "while #{d_arg} do", "end", :while)
-        #stmt_list << stag_stmt(arg)
+        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(arg.cont_stmts)
+        #stmt_list.concat(e.cont_stmts)
         #stmt_list << NativeStatement.new("end", :while)
-        #stmt_list << etag_stmt(arg)
+        #stmt_list << etag_stmt(elem_info)
 
       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(arg)
-        #stmt_list.concat(arg.cont_stmts)
-        #stmt_list << etag_stmt(arg)
+        #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(stmt_list, arg, "if #{d_arg} then", "end", :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(arg)
-        #stmt_list.concat(arg.cont_stmts)
-        #stmt_list << etag_stmt(arg)
+        #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(stmt_list, arg)
+        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(stmt_list, arg, code, "end", kind)
+        wrap_element_with_native_stmt(elem_info, stmt_list, code, "end", kind)
         #stmt_list << NativeStatement.new(code, kind)
-        #stmt_list << stag_stmt(arg)
-        #stmt_list.concat(arg.cont_stmts)
-        #stmt_list << etag_stmt(arg)
+        #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(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}) && !(#{d_arg}).to_s.empty? then",
+        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(arg)
+        #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(arg.cont_stmts)
+        #stmt_list.concat(e.cont_stmts)
         #stmt_list << NativeStatement.new_without_newline("end", :else)
-        #stmt_list << etag_stmt(arg)
+        #stmt_list << etag_stmt(elem_info)
 
       else
         return false
@@ -154,6 +185,7 @@ module Kwartz
   ## translator for eRuby
   ##
   class RubyTranslator < BaseTranslator
+    include RubyExpressionParser
 
 
     def initialize(properties={})

data/lib/kwartz/binding/struts.rb

@@ -1,6 +1,6 @@
 ###
-### $Rev: 111 $
-### $Release: 3.1.2 $
+### $Rev$
+### $Release: 3.2.0 $
 ### copyright(c) 2004-2006 kuwata-lab.com all rights reserved
 ###
 
@@ -22,25 +22,26 @@ module Kwartz
 
 
 
-    def handle(directive_name, directive_arg, directive_str, stag_info, etag_info, cont_stmts, attr_info, append_exprs, stmt_list)
+    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
+      d_name = directive.name
+      d_arg  = directive.arg
+      d_str  = directive.str
+      e = elem_info
 
-      case directive_name
+      case d_name
 
       when :struts
-        case tag = stag_info.tagname
-        when 'input'  ;  tag = attr_info['type'] || 'text'  ; attr_info.delete('type')
+        case tag = e.stag_info.tagname
+        when 'input'  ;  tag = e.attr_info['type'] || 'text'  ; e.attr_info.delete('type')
         when 'a'      ;  tag = 'link'
         when 'script' ;  tag = 'javascript'
         end
-        tag == :struts   and raise convert_error("#{d_str}: unknown directive.", stag_info.linenum)
-        return self.handle(tag.intern, d_arg, directive_str, stag_info, etag_info,
-                           cont_stmts, attr_info, append_exprs, stmt_list)
+        tag == :struts   and raise convert_error("#{d_str}: unknown directive.", e.stag_info.linenum)
+        directive.name = tag.intern
+        return self.handle(directive, elem_info, stmt_list)
 
       else
         convert_mapping = {
@@ -48,21 +49,21 @@ module Kwartz
           'class'=>'cssClass'
         }
         convert_mapping.each do |html_aname, struts_aname|
-          next unless attr_info[html_aname]
-          attr_info[struts_aname] = attr_info[html_aname]
-          attr_info.delete(html_aname)
+          next unless e.attr_info[html_aname]
+          e.attr_info[struts_aname] = e.attr_info[html_aname]
+          e.attr_info.delete(html_aname)
         end
         opts = eval "_evaluate_options(#{d_arg})"
         opts.each do |name, value|
-          attr_info[name.to_s] = value.is_a?(Symbol) ? "${#{value}}" : value
+          e.attr_info[name.to_s] = value.is_a?(Symbol) ? "${#{value}}" : value
         end
         tagname = "html:#{d_name}"
-        stag_info.tagname = tagname
-        etag_info.tagname = tagname if etag_info
-        stag_info.is_empty = true   if !etag_info
-        stmt_list << build_print_stmt(stag_info, attr_info, append_exprs)
+        e.stag_info.tagname = tagname
+        e.etag_info.tagname = tagname if e.etag_info
+        e.stag_info.is_empty = true   if !e.etag_info
+        stmt_list << build_print_stmt(e.stag_info, e.attr_info, e.append_exprs)
         stmt_list.concat(cont_stmts)
-        stmt_list << build_print_stmt(etag_info, nil, nil) if etag_info
+        stmt_list << build_print_stmt(e.etag_info, nil, nil) if e.etag_info
 
       end #case
       return true

data/lib/kwartz/config.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
 ###
 
@@ -20,10 +20,10 @@ module Kwartz
     PROPERTY_JSTL       = 1.2       # jstl version (1.2 or 1.1)
     #
     NO_ETAGS            = [ 'input', 'img' ,'br', 'hr', 'meta', 'link' ]
-    #ALLOW_DUPLICATE_ID  = false
+    ALLOW_DUPLICATE_ID  = false     # if true then enables to use duplicated id name.
 
 
   end
 
-  
+
 end

data/lib/kwartz/converter.rb

@@ -1,6 +1,6 @@
 ###
-### $Rev: 148 $
-### $Release: 3.1.2 $
+### $Rev$
+### $Release: 3.2.0 $
 ### copyright(c) 2004-2006 kuwata-lab.com all rights reserved
 ###
 
@@ -83,6 +83,12 @@ module Kwartz
     end
 
 
+    def clear_as_dummy_tag    # delete <span> tag
+      @tagname = nil
+      @head_space = @tail_space = nil if @head_space && @tail_space
+    end
+
+
     def _inspect
       return [ @prev_text, @head_space, @is_etag, @tagname, @attr_str, @extra_space, @is_empty, @tail_space ]
     end
@@ -104,20 +110,22 @@ module Kwartz
         @values[name] = value
         @spaces[name] = space
       end
-      @directive = nil
-      @linenum = nil
     end
     attr_reader :names, :values, :spaces
-    attr_accessor :directive, :linenum
+
+
+    def has?(name)
+      return @values.key?(name)
+    end
 
 
     def [](name)
-      @values[name]
+      return @values[name]
     end
 
 
     def []=(name, value)
-      @names << name unless @values.key?(name)
+      @names << name unless has?(name)
       @values[name] = value
       @spaces[name] = ' ' unless @spaces.key?(name)
     end
@@ -125,15 +133,13 @@ module Kwartz
 
     def each
       @names.each do |name|
-        space = @spaces[name]
-        value = @values[name]
-        yield(space, name, value)
+        yield(@spaces[name], name, @values[name])
       end
     end
 
 
     def delete(name)
-      if @values.key?(name)
+      if has?(name)
         @names.delete(name)
         @values.delete(name)
         @spaces.delete(name)
@@ -153,55 +159,58 @@ module Kwartz
   class ElementInfo
 
 
-    def initialize(name, stag_info, etag_info, cont_stmts, attr_info, append_exprs)
-      @name         = name           # String
+    def initialize(stag_info, etag_info, cont_stmts, attr_info, append_exprs)
       @stag_info    = stag_info      # TagInfo
       @etag_info    = etag_info      # TagInfo
       @cont_stmts   = cont_stmts     # list of Statement
       @attr_info    = attr_info      # AttrInfo
       @append_exprs = append_exprs   # list of NativeExpression
       @logic = [ ExpandStatement.new(:elem, @name) ]
-      @merged = nil
     end
 
-    attr_accessor :name, :stag_info, :etag_info, :cont_stmts, :attr_info, :append_exprs, :logic
+    attr_accessor :stag_info, :etag_info, :cont_stmts, :attr_info, :append_exprs
     attr_reader :stag_expr, :cont_expr, :etag_expr, :elem_expr
-
-
-    def merged?
-      !@merged.nil?
-    end
+    attr_reader :logic, :before, :after
+    attr_accessor :name
+    attr_accessor :applied
 
 
     def self.create(values={})
-      self.new(values[:name], values[:stag], values[:etag], values[:cont], values[:attr], values[:append])
+      v = values
+      return self.new(v[:name], v[:stag], v[:etag], v[:cont], v[:attr], v[:append])
     end
 
 
-    def merge(elem_ruleset)
-      return unless elem_ruleset.name == @name
-      @merged = elem_ruleset
-      @stag_expr = _to_native_expr(elem_ruleset.stag)
-      @cont_expr = _to_native_expr(elem_ruleset.cont || elem_ruleset.value)
-      @etag_expr = _to_native_expr(elem_ruleset.etag)
-      @elem_expr = _to_native_expr(elem_ruleset.elem)
+    def apply(ruleset)
+      r = ruleset
+      @stag_expr = _to_native_expr(r.stag) if r.stag
+      @cont_expr = _to_native_expr(r.cont) if r.cont
+      @etag_expr = _to_native_expr(r.etag) if r.etag
+      @elem_expr = _to_native_expr(r.elem) if r.elem
       if @cont_expr
         @cont_stmts = [ PrintStatement.new([@cont_expr]) ]
         @stag_info.tail_space = ''
         @etag_info.head_space = ''
         @etag_info.rebuild_tag_text()
       end
-      elem_ruleset.remove.each do |aname|
+      r.remove.each do |aname|
         @attr_info.delete(aname)
-      end if elem_ruleset.remove
-      elem_ruleset.attrs.each do |aname, avalue|
+      end if r.remove
+      r.attrs.each do |aname, avalue|
         @attr_info[aname] = _to_native_expr(avalue)
-      end if elem_ruleset.attrs
-      elem_ruleset.append.each do |expr|
+      end if r.attrs
+      r.append.each do |expr|
         (@append_exprs ||= []) << _to_native_expr(expr)
-      end if elem_ruleset.append
-      @tagname = elem_ruleset.tagname
-      @logic = elem_ruleset.logic if elem_ruleset.logic
+      end if r.append
+      @tagname = r.tagname if r.tagname
+      @logic  = r.logic  if r.logic
+      (@before ||= []).concat(r.before) if r.before
+      (@after  ||= []).concat(r.after)  if r.after
+    end
+
+
+    def dummy_span_tag?(tagname='span')
+      return @stag_info.tagname == tagname && @attr_info.empty?  && @append_exprs.nil?
     end
 
 
@@ -218,18 +227,9 @@ module Kwartz
 
 
   ##
-  ## helper module for Converter and Handler
   ##
-  ## Handler and Converter class include this module.
   ##
-  module ConverterHelper       # :nodoc:
-
-
-    ## set @despan and @dattr
-    def include_properties(properties)
-      @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
+  module ConvertErrorHelper       # :nodoc:
 
 
     ## return ConvertError
@@ -238,25 +238,31 @@ module Kwartz
     end
 
 
-    ## raise errror if etag_info is null
-    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
+
+
+
+  ##
+  ##
+  ##
+  module HandlerHelper
+    #include ConvertErrorHelper
+
+
+    ## raise error if etag_info is null
+    def error_if_empty_tag(elem_info, directive_str)
+      unless elem_info.etag_info
+        msg = "'#{directive_str}': directive is not available with empty tag."
+        raise convert_error(msg, elem_info.stag_info.linenum)
       end
     end
 
 
-    def error_when_last_stmt_is_not_if(stmt_list, handler_arg)
+    def error_when_last_stmt_is_not_if(elem_info, directive_str, stmt_list)
       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)
+        msg = "'#{directive_str}': previous statement should be 'if' or 'elsif'."
+        raise convert_error(msg, elem_info.stag_info.linenum)
       end
     end
 
@@ -272,13 +278,6 @@ module Kwartz
     end
 
 
-  end
-
-
-
-  module StatementHelper
-
-
     ## create print statement from text
     def create_text_print_stmt(text)
       return PrintStatement.new([text])
@@ -305,8 +304,9 @@ module Kwartz
       attr_info.each do |space, aname, avalue|
         sb << "#{space}#{aname}=\""
         if avalue.is_a?(NativeExpression)
+          native_expr = expand_attr_vars_in_native_expr(avalue, attr_info)
           args << sb     # TextExpression.new(sb)
-          args << avalue
+          args << native_expr
           sb = ''
         else
           sb << avalue
@@ -318,7 +318,10 @@ module Kwartz
           args << sb     # TextExpression.new(sb)
           sb = ''
         end
-        args.concat(append_exprs)
+        append_exprs.each do |append_expr|
+          native_expr = expand_attr_vars_in_native_expr(append_expr, attr_info)
+          args << native_expr
+        end
       end
       sb << "#{t.extra_space}#{t.is_empty ? '/' : ''}>#{t.tail_space}"
       args << sb         # TextExpression.new(sb)
@@ -334,28 +337,67 @@ module Kwartz
 
 
     ## create PrintStatement for NativeExpression
-    def build_print_expr_stmt(native_expr, stag_info, etag_info)
+    def build_print_expr_stmt(native_expr, stag_info, etag_info, attr_info=nil)
       head_space = (stag_info || etag_info).head_space
       tail_space = (etag_info || stag_info).tail_space
+      native_expr = expand_attr_vars_in_native_expr(native_expr, attr_info) if attr_info
       args = []
-      args << head_space if head_space    # TexExpression.new(head_space)
+      args << head_space if head_space    # TextExpression.new(head_space)
       args << native_expr
       args << tail_space if tail_space    # TextExpression.new(tail_space)
       return PrintStatement.new(args)
     end
 
 
+    ## expand attribute variables (such as '$(rows)' or '$(value)') and return new code
+    def expand_attr_vars(code, attr_info)
+      new_code = code.gsub(/\$\((\w+(?::\w+)?)\)/) do |m|
+        aname = $1
+        #unless attrs.key?(aname)
+        #  raise "#{m}: attribute '#{aname}' expected but not found."
+        #end
+        avalue = attr_info[aname]
+        if avalue.is_a?(NativeExpression)
+          raise "#{m}: attribute value of '#{aname}' is NativeExpression object."
+        end
+        avalue
+      end
+      return new_code
+    end
+
+
+    ## expand attribute variables and return new NativeExpression
+    def expand_attr_vars_in_native_expr(native_expr, attr_info)
+      code = expand_attr_vars(native_expr.code, attr_info)
+      if code != native_expr.code
+        native_expr = NativeExpression.new(code, native_expr.escape)
+      end
+      return native_expr
+    end
+
+
+    ## expand attribute variables and return new NativeExpression
+    def expand_attr_vars_in_native_stmt(native_stmt, attr_info)
+      code = expand_attr_vars(native_stmt.code, attr_info)
+      if code != native_stmt.code
+        no_newline = native_stmt.no_newline
+        native_stmt = NativeStatement.new(code, native_stmt.kind)
+        native_stmt.no_newline = no_newline unless no_newline.nil?
+      end
+      return native_stmt
+    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)
+    def stag_stmt(elem_info)
+      e = elem_info
+      return build_print_stmt(e.stag_info, e.attr_info, e.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)
+    def etag_stmt(elem_info)
+      return build_print_stmt(elem_info.etag_info, nil, nil)
     end
 
 
@@ -368,52 +410,50 @@ module Kwartz
     end
 
 
-    def wrap_element_with_native_stmt(stmt_list, handler_arg, start_code, end_code, kind=nil)
+    def wrap_element_with_native_stmt(elem_info, stmt_list, 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)
+      stmt_list << stag_stmt(elem_info)
+      stmt_list.concat(elem_info.cont_stmts)
+      stmt_list << etag_stmt(elem_info)
       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)
+    def wrap_content_with_native_stmt(elem_info, stmt_list, start_code, end_code, kind=nil)
+      stmt_list << stag_stmt(elem_info)
       add_native_code(stmt_list, start_code, kind)
-      stmt_list.concat(handler_arg.cont_stmts)
+      stmt_list.concat(elem_info.cont_stmts)
       add_native_code(stmt_list, end_code, kind)
-      stmt_list << etag_stmt(handler_arg)
+      stmt_list << etag_stmt(elem_info)
     end
 
 
-    def add_foreach_stmts(stmt_list, handler_arg, foreach_code, endforeach_code,
+    def add_foreach_stmts(elem_info, stmt_list, 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
+      stmt_list << stag_stmt(elem_info)               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
+      stmt_list << stag_stmt(elem_info)               if !content_only
+      stmt_list.concat(elem_info.cont_stmts)
+      stmt_list << etag_stmt(elem_info)               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
+      stmt_list << etag_stmt(elem_info)               if content_only
     end
 
 
-    def add_native_expr_with_default(stmt_list, handler_arg,
+    def add_native_expr_with_default(elem_info, stmt_list,
                                      expr_code, flag_escape,
                                      if_code, else_code, endif_code)
-      arg = handler_arg
-      stmt_list << stag_stmt(arg)
+      stmt_list << stag_stmt(elem_info)
       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.concat(elem_info.cont_stmts)
       stmt_list << NativeStatement.new_without_newline(endif_code, :else)
-      stmt_list << etag_stmt(arg)
+      stmt_list << etag_stmt(elem_info)
     end
 
 
@@ -426,12 +466,12 @@ module Kwartz
   ##
   ## Handler class includes this module.
   ##
-  module ElementExpander
+  module Expander
     include Assertion
 
 
-    ## (abstract) get ElementRuleset
-    def get_element_ruleset(name)
+    ## (abstract) get Ruleset
+    def get_ruleset(selector)
       not_implemented
     end
 
@@ -444,97 +484,109 @@ module Kwartz
 
     ## expand ElementInfo
     def expand_element_info(elem_info, stmt_list, content_only=false)
-      #elem_ruleset = @ruleset_table[elem_info.name]
-      elem_ruleset = get_element_ruleset(elem_info.name)
-      if elem_ruleset && !elem_info.merged?
-        elem_info.merge(elem_ruleset)
+      expand_statements(elem_info.before, stmt_list, elem_info) if elem_info.before
+      stmts = content_only ? [ ExpandStatement.new(:cont) ] : elem_info.logic
+      stmts.each do |stmt|
+        expand_statement(stmt, stmt_list, elem_info)
       end
-      logic = content_only ? [ ExpandStatement.new(:cont, elem_info.name) ] : elem_info.logic
-      logic.each do |stmt|
+      expand_statements(elem_info.after, stmt_list, elem_info) if elem_info.after
+    end
+
+
+    ## expand list of ExpandStatement
+    def expand_statements(stmts, stmt_list, elem_info)
+      stmts.each do |stmt|
         expand_statement(stmt, stmt_list, elem_info)
       end
-      #if content_only
-      #  stmt = ExpandStatement.new(:cont, elem_info.name)
-      #  expand_statement(stmt, stmt_list, elem_info)
-      #else
-      #  elem_info.logic.each do |stmt|
-      #    expand_statement(stmt, stmt_list, elem_info)
-      #  end
-      #end
     end
 
 
     ## expand ExpandStatement
     def expand_statement(stmt, stmt_list, elem_info)
 
-      if stmt.is_a?(ExpandStatement)
-        e = elem_info
-
-        ## delete dummy '<span>' tag
-        if @delspan && e.stag_info.tagname == 'span' && e.attr_info.empty? && e.append_exprs.nil?
-          e.stag_info.tagname = e.etag_info.tagname = nil
+      if stmt.is_a?(NativeStatement)
+        if elem_info
+          native_stmt = expand_attr_vars_in_native_stmt(stmt, elem_info.attr_info)
+        else
+          native_stmt = stmt
         end
+        stmt_list << native_stmt
+        return
+      end
 
-        case stmt.kind
+      if ! stmt.is_a?(ExpandStatement)
+        stmt_list << stmt
+        return
+      end
 
-        when :stag
-          assert unless elem_info
-          if e.stag_expr
-            assert unless e.stag_expr.is_a?(NativeExpression)
-            stmt_list << build_print_expr_stmt(e.stag_expr, e.stag_info, nil)
-          else
-            stmt_list << build_print_stmt(e.stag_info, e.attr_info, e.append_exprs)
-          end
+      e = elem_info
 
-        when :etag
-          assert unless elem_info
-          if e.etag_expr
-            assert unless e.etag_expr.is_a?(NativeExpression)
-            stmt_list << build_print_expr_stmt(e.etag_expr, nil, e.etag_info)
-          elsif e.etag_info    # e.etag_info is nil when <br>, <input>, <hr>, <img>, <meta>
-            stmt_list << build_print_stmt(e.etag_info, nil, nil)
-          end
+      ## remove dummy <span> tag
+      if @delspan && elem_info && elem_info.dummy_span_tag?('span')
+        #e.stag_info.tagname = e.etag_info.tagname = nil
+        e.stag_info.clear_as_dummy_tag()
+        e.etag_info.clear_as_dummy_tag()
+      end
 
-        when :cont
-          if e.cont_expr
-            assert unless e.cont_expr.is_a?(NativeExpression)
-            stmt_list << PrintStatement.new([e.cont_expr])
-          else
-            elem_info.cont_stmts.each do |cont_stmt|
-              expand_statement(cont_stmt, stmt_list, nil)
-            end
-          end
+      case stmt.kind
 
-        when :elem
-          assert unless elem_info
-          if e.elem_expr
-            assert unless e.elem_expr.is_a?(NativeExpression)
-            stmt_list << build_print_expr_stmt(e.elem_expr, e.stag_info, e.etag_info)
-          else
-            stmt.kind = :stag
-            expand_statement(stmt, stmt_list, elem_info)
-            stmt.kind = :cont
-            expand_statement(stmt, stmt_list, elem_info)
-            stmt.kind = :etag
-            expand_statement(stmt, stmt_list, elem_info)
-            stmt.kind = :elem
-          end
+      when :stag
+        assert unless elem_info
+        if e.stag_expr
+          assert unless e.stag_expr.is_a?(NativeExpression)
+          stmt_list << build_print_expr_stmt(e.stag_expr, e.stag_info, nil, e.attr_info)
+        else
+          stmt_list << build_print_stmt(e.stag_info, e.attr_info, e.append_exprs)
+        end
+
+      when :etag
+        assert unless elem_info
+        if e.etag_expr
+          assert unless e.etag_expr.is_a?(NativeExpression)
+          stmt_list << build_print_expr_stmt(e.etag_expr, nil, e.etag_info, e.attr_info)
+        elsif e.etag_info    # e.etag_info is nil when <br>, <input>, <hr>, <img>, <meta>
+          stmt_list << build_print_stmt(e.etag_info, nil, nil)
+        end
 
-        when :element, :content
-          content_only = stmt.kind == :content
-          #elem_info = @elements[stmt.name]
-          elem_info = get_element_info(stmt.name)
-          unless elem_info
-            raise convert_error("element '#{stmt.name}' is not found.", nil)
+      when :cont
+        if e.cont_expr
+          assert unless e.cont_expr.is_a?(NativeExpression)
+          #stmt_list << PrintStatement.new([e.cont_expr])
+          native_expr = expand_attr_vars_in_native_expr(e.cont_expr, e.attr_info)
+          stmt_list << PrintStatement.new([native_expr])
+        else
+          elem_info.cont_stmts.each do |cont_stmt|
+            expand_statement(cont_stmt, stmt_list, nil)
           end
-          expand_element_info(elem_info, stmt_list, content_only)
+        end
 
+      when :elem
+        assert unless elem_info
+        if e.elem_expr
+          assert unless e.elem_expr.is_a?(NativeExpression)
+          stmt_list << build_print_expr_stmt(e.elem_expr, e.stag_info, e.etag_info, e.attr_info)
         else
-          assert
-        end #case
+          stmt.kind = :stag
+          expand_statement(stmt, stmt_list, elem_info)
+          stmt.kind = :cont
+          expand_statement(stmt, stmt_list, elem_info)
+          stmt.kind = :etag
+          expand_statement(stmt, stmt_list, elem_info)
+          stmt.kind = :elem
+        end
+
+      when :element, :content
+        content_only = stmt.kind == :content
+        #elem_info = @elements[stmt.name]
+        elem_info = get_element_info(stmt.name)
+        unless elem_info
+          raise convert_error("element '#{stmt.name}' is not found.", nil)
+        end
+        expand_element_info(elem_info, stmt_list, content_only)
+
       else
-        stmt_list << stmt
-      end #if
+        assert
+      end #case
     end
 
 
@@ -543,27 +595,21 @@ module Kwartz
 
 
   ##
-  ## argument data for handler
+  ## directive
   ##
-  class HandlerArgument
-    include StatementHelper
+  class Directive
 
 
-    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
+    def initialize(args={})
+      @name   = args[:name]
+      @arg    = args[:arg]
+      @dattr  = args[:dattr]
+      @str    = args[:str]
+      @linenum = args[:linenum]
     end
 
 
-    attr_reader :directive_name, :directive_arg, :directive_str
-    attr_reader :stag_info, :etag_info, :cont_stmts, :attr_info, :append_exprs
+    attr_accessor :name, :arg, :dattr, :str, :linenum
 
 
   end
@@ -575,35 +621,47 @@ module Kwartz
   ##
   class Handler
     include Assertion
-    include ConverterHelper
-    include StatementHelper
-    include ElementExpander
+    include ConvertErrorHelper
+    include HandlerHelper
+    include Expander
 
 
-    def initialize(elem_rulesets=[], properties={})
-      @elem_rulesets = elem_rulesets
-      #@elem_ruleset_table = elem_rulesets.inject({}) { |table, ruleset| table[ruleset.name] = ruleset; table }
-      @elem_ruleset_table = {} ; elem_rulesets.each { |ruleset| @elem_ruleset_table[ruleset.name] = ruleset }
+    def initialize(rulesets=[], properties={})
+      @ruleset_table = {}
+      rulesets.each { |ruleset| _register_ruleset(ruleset) }
       @elem_info_table = {}
-      include_properties(properties)     # @delspan and @dattr
-      @odd  = properties[:odd]     || Config::PROPERTY_ODD      # "'odd'"
-      @even = properties[:even]    || Config::PROPERTY_EVEN     # "'even'"
-      @filename = nil
+      @delspan = properties.fetch(:delspan, Config::PROPERTY_DELSPAN)  # delete dummy <span> tag or not
+      @odd     = properties.fetch(:odd,     Config::PROPERTY_ODD)      # "'odd'"
+      @even    = properties.fetch(:even,    Config::PROPERTY_EVEN)     # "'even'"
     end
     attr_reader :odd, :even
-    attr_accessor :converter, :filename
+    attr_accessor :filename
 
 
-    def get_element_ruleset(name)  # for ElementExpander module and Converter class
-      return @elem_ruleset_table[name]
+    def _register_ruleset(ruleset)
+      ruleset.selectors.each do |selector|
+        r = @ruleset_table[selector]
+        @ruleset_table[selector] = r ? r.merge(ruleset) : ruleset
+      end
     end
+    private :_register_ruleset
+
 
+    def get_ruleset(selector)  # for Expander module and Converter class
+      return @ruleset_table[selector]
+    end
 
-    def get_element_info(name)  # for ElementExpander module
+
+    def get_element_info(name)  # for Expander module
       return @elem_info_table[name]
     end
 
 
+    def register_element_info(name, elem_info)
+      @elem_info_table[name] = elem_info
+    end
+
+
     def _elem_info_table    # :nodoc:
       return @elem_info_table
     end
@@ -640,97 +698,158 @@ module Kwartz
     end
 
 
-    ## (abstract) directive format, which is used at has_directive?() method
-    def directive_format
+    ## (abstract) convert universal expression string to native expression string
+    def parse_expr_str(expr_str, linenum)
       not_implemented
-      #return '%s: %s'
     end
 
 
     public
 
 
+    def handle_directives(directive, elem_info, stmt_list)
+      e = elem_info
+      linenum = elem_info.stag_info.linenum
+      append_exprs = nil
+
+      if directive.dattr == 'id'
+        ## nothing
+      else
+        ## handle 'attr:' and 'append:' directives
+        d_str = nil
+        directive.str.split(/;/).each do |d_str|
+          d_str.strip!
+          unless d_str =~ self.directive_pattern     # ex. /\A(\w+):\s*(.*)\z/
+            raise convert_error("'#{d_str}': invalid directive pattern", linenum)
+          end
+          d_name = $1.intern   # directive name
+          d_arg  = $2 || ''    # directive arg
+          case d_name
+          when :attr, :Attr, :ATTR
+            directive2 = Directive.new(:name=>d_name, :arg=>d_arg, :sr=>d_str)
+            handle(directive2, elem_info, stmt_list)
+          when :append, :Append, :APPEND
+            append_exprs ||= []
+            elem_info.append_exprs = append_exprs
+            directive2 = Directive.new(:name=>d_name, :arg=>d_arg, :sr=>d_str)
+            handle(directive2, elem_info, stmt_list)
+          else
+            if directive.name
+              raise convert_error("'#{d_str}': not available with '#{directive.name}' directive.", linenum)
+            end
+            directive.name = d_name
+            directive.arg  = d_arg
+            directive.str  = d_str
+          end #case
+        end
+      end
+
+      ## remove dummy <span> tag
+      if @delspan && elem_info.dummy_span_tag?('span')
+        #e.stag_info.tagname = e.etag_info.tagname = nil
+        e.stag_info.clear_as_dummy_tag()
+        e.etag_info.clear_as_dummy_tag()
+      end
+
+      ## handle other directives
+      if directive.name
+        handled = handle(directive, elem_info, stmt_list)
+        handled or raise convert_error("'#{directive.str}': unknown directive.", linenum)
+      else   # for 'attr' and 'append' directive
+        assert unless !elem_info.attr_info.empty? || !elem_info.append_exprs.empty?
+        stmt_list << stag_stmt(elem_info)
+        stmt_list.concat(elem_info.cont_stmts)
+        stmt_list << etag_stmt(elem_info) if elem_info.etag_info   # when empty-tag
+      end
+
+    end
+
+
     ## handle directives ('stag', 'etag', 'elem', 'cont'(='value'))
     ##
     ## return true if directive name is one of 'stag', 'etag', 'elem', 'cont', and 'value',
     ## else return false.
-    def handle(stmt_list, handler_arg)
-      arg = handler_arg
-      d_name = arg.directive_name
-      d_arg  = arg.directive_arg
-      d_str  = arg.directive_str
+    def handle(directive, elem_info, stmt_list)
+      d_name = directive.name
+      d_arg  = directive.arg
+      d_str  = directive.str
+      d_attr = directive.dattr
+      e = elem_info
+      linenum = e.stag_info.linenum
 
       case d_name
 
       when nil
-        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
+        assert false
 
       when :dummy
         # nothing
 
       when :id, :mark
-        unless d_arg =~ /\A(\w+)\z/ || d_arg =~ /\A'(\w+)'\z/
-          raise convert_error("'#{d_str}': invalid marking name.", arg.stag_info.linenum)
+        unless d_arg =~ /\A([-\w]+)\z/ || d_arg =~ /\A'([-\w]+)'\z/
+          raise convert_error("'#{d_str}': invalid marking name.", linenum)
         end
         name = $1
-        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
+        if get_element_info(name)
+          unless Config::ALLOW_DUPLICATE_ID
+            previous_linenum = get_element_info(name).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
+            raise convert_error(msg, linenum)
+          end
         end
+        ruleset = get_ruleset('#' + name)
+        elem_info.apply(ruleset) if ruleset
+        register_element_info(name, elem_info)
         #stmt_list << ExpandStatement.new(:element, name)     # lazy expantion
         expand_element_info(elem_info, stmt_list)
 
       when :stag, :Stag, :STAG
-        error_if_empty_tag(arg)
+        error_if_empty_tag(elem_info, d_str)
         flag_escape = d_name == :stag ? nil : (d_name == :Stag)
-        expr = NativeExpression.new(d_arg, flag_escape)
-        stmt_list << build_print_expr_stmt(expr, arg.stag_info, nil)
-        stmt_list.concat(arg.cont_stmts)
-        stmt_list << etag_stmt(arg)
+        expr_str = d_attr == 'id' ? parse_expr_str(d_arg, linenum) : d_arg
+        expr = NativeExpression.new(expr_str, flag_escape)
+        stmt_list << build_print_expr_stmt(expr, e.stag_info, nil)
+        stmt_list.concat(e.cont_stmts)
+        stmt_list << etag_stmt(elem_info)
 
       when :etag, :Etag, :ETAG
-        error_if_empty_tag(arg)
+        error_if_empty_tag(elem_info, d_str)
         flag_escape = d_name == :etag ? nil : (d_name == :Etag)
-        expr = NativeExpression.new(d_arg, flag_escape)
-        stmt_list << stag_stmt(arg)
-        stmt_list.concat(arg.cont_stmts)
-        stmt_list << build_print_expr_stmt(expr, nil, arg.etag_info)
+        expr_str = d_attr == 'id' ? parse_expr_str(d_arg, linenum) : d_arg
+        expr = NativeExpression.new(expr_str, flag_escape)
+        stmt_list << stag_stmt(elem_info)
+        stmt_list.concat(e.cont_stmts)
+        stmt_list << build_print_expr_stmt(expr, nil, e.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, arg.stag_info, arg.etag_info)
+        expr_str = d_attr == 'id' ? parse_expr_str(d_arg, linenum) : d_arg
+        expr = NativeExpression.new(expr_str, flag_escape)
+        stmt_list << build_print_expr_stmt(expr, e.stag_info, e.etag_info)
 
       when :cont, :Cont, :CONT, :value, :Value, :VALUE
-        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)
+        error_if_empty_tag(elem_info, directive.str)
+        e.stag_info.tail_space = e.etag_info.head_space = nil    # delete spaces
+        pargs = build_print_args(e.stag_info, e.attr_info, e.append_exprs)
         flag_escape = (d_name == :cont || d_name == :value) ? nil : (d_name == :Cont || d_name == :Value)
-        pargs << NativeExpression.new(d_arg, flag_escape)
-        pargs << arg.etag_info.tag_text if arg.etag_info.tagname
+        expr_str = d_attr == 'id' ? parse_expr_str(d_arg, linenum) : d_arg
+        pargs << NativeExpression.new(expr_str, flag_escape)
+        pargs << e.etag_info.tag_text if e.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.", arg.stag_info.linenum)
+          raise convert_error("'#{d_str}': invalid attr pattern.", linenum)
         end
         aname = $1;  avalue = $2
         flag_escape = d_name == :attr ? nil : (d_name == :Attr)
-        arg.attr_info[aname] = NativeExpression.new(avalue, flag_escape)
+        expr_str = d_attr == 'id' ? parse_expr_str(avalue, linenum) : avalue
+        e.attr_info[aname] = NativeExpression.new(expr_str, flag_escape)
 
       when :append, :Append, :APPEND
         flag_escape = d_name == :append ? nil : (d_name == :Append)
-        arg.append_exprs << NativeExpression.new(d_arg, flag_escape)
+        expr_str = d_attr == 'id' ? parse_expr_str(d_arg, linenum) : d_arg
+        e.append_exprs << NativeExpression.new(expr_str, flag_escape)
 
       when :replace_element_with_element, :replace_element_with_content,
            :replace_content_with_element, :replace_content_with_content
@@ -739,35 +858,35 @@ module Kwartz
         with_content = arr[3] == 'content'
         name = d_arg
         #
-        error_if_empty_tag(arg)   if replace_cont
-        stmt_list << stag_stmt(arg) if replace_cont
+        error_if_empty_tag(elem_info, d_str)   if replace_cont
+        stmt_list << stag_stmt(elem_info) if replace_cont
         #stmt_list << ExpandStatement.new(:element, name)
-        elem_info = @elem_info_table[name]
+        elem_info2 = @elem_info_table[name]
         unless elem_info
-          raise convert_error("'#{d_str}': element '#{name}' not found.", arg.stag_info.linenum)
+          raise convert_error("'#{d_str}': element '#{name}' not found.", linenum)
         end
-        expand_element_info(elem_info, stmt_list, with_content)
-        stmt_list << etag_stmt(arg) if replace_cont
+        expand_element_info(elem_info2, stmt_list, with_content)
+        stmt_list << etag_stmt(elem_info) if replace_cont
 
       when :replace_element_with, :replace_content_with, :replace, :placeholder
         unless d_arg =~ /\A_?(element|content)\(["']?(\w+)["']?\)\z/
-          raise convert_error("'#{d_str}': invalid #{d_name} format.", stag_info.linenum)
+          raise convert_error("'#{d_str}': invalid #{d_name} format.", linenum)
         end
         kind = $1
         name = $2
         replace_cont = d_name == :replace_content_with || d_name == :placeholder
         with_content = kind == 'content'
         #
-        error_if_empty_tag(arg) if replace_cont
-        stmt_list << stag_stmt(arg) if replace_cont
+        error_if_empty_tag(elem_info, d_str) if replace_cont
+        stmt_list << stag_stmt(elem_info) if replace_cont
         #stmt_list << ExpandStatement.new(:element, name)
-        elem_info = @elem_info_table[name]
-        unless elem_info
+        elem_info2 = @elem_info_table[name]
+        unless elem_info2
           msg = "'#{d_str}': element '#{name}' not found."
-          raise convert_error(msg, arg.stag_info.linenum)
+          raise convert_error(msg, linenum)
         end
-        expand_element_info(elem_info, stmt_list, with_content)
-        stmt_list << etag_stmt(arg) if replace_cont
+        expand_element_info(elem_info2, stmt_list, with_content)
+        stmt_list << etag_stmt(elem_info) if replace_cont
 
       else
         return false
@@ -778,6 +897,19 @@ module Kwartz
     end
 
 
+    def apply_rulesets(elem_info)
+      assert unless !elem_info.applied
+      elem_info.applied = true
+      tagname = elem_info.stag_info.tagname
+      classname = elem_info.attr_info['class']
+      #idname = elem_info.name || elem_info.attr_info['id']
+      ruleset = nil
+      elem_info.apply(ruleset) if ruleset = get_ruleset(tagname)
+      elem_info.apply(ruleset) if classname && (ruleset = get_ruleset('.'+classname))
+      #elem_info.apply(ruleset) if idname && (ruleset = get_ruleset('#'+idname))
+    end
+
+
     def extract(elem_name, content_only=false)
       elem_info = @elem_info_table[elem_name]
       elem_info or raise convert_error("element '#{elem_name}' not found.", nil)
@@ -809,13 +941,11 @@ module Kwartz
   ## (abstract) covnert presentation data into list of Statement.
   ##
   class Converter
-    include ConverterHelper
-    include StatementHelper
+    include ConvertErrorHelper
 
 
     def initialize(handler, properties={})
       @handler = handler
-      @handler.converter = self
     end
 
     attr_reader :handler   #, :dattr, :input
@@ -853,7 +983,7 @@ module Kwartz
 
     def initialize(handler, properties={})
       super
-      include_properties(properties)    # set @delspan and @dattr
+      @dattr = properties.fetch(:dattr, Config::PROPERTY_DATTR)    # default: 'kw:d'
     end
 
 
@@ -868,18 +998,28 @@ module Kwartz
     end
     protected :reset
 
+
     attr_reader :rest, :linenum
 
 
     def convert(input, filename='')
       reset(input, filename)
       stmt_list = []
-      doc_ruleset = @handler.get_element_ruleset('DOCUMENT')
-      stmt_list += doc_ruleset.begin if doc_ruleset && doc_ruleset.begin
-      #stmt_list << NativeStatement.new(doc_ruleset.head.chomp, nil) if doc_ruleset && doc_ruleset.head
       _convert(stmt_list)
-      stmt_list += doc_ruleset.end if doc_ruleset && doc_ruleset.end
-      #stmt_list << NativeStatement.new(doc_ruleset.tail.chomp, nil) if doc_ruleset && doc_ruleset.tail
+      ruleset = @handler.get_ruleset('#DOCUMENT')
+      if ruleset
+        stmt_list2 = []
+        elem_info = nil
+        r = ruleset
+        @handler.expand_statements(r.before, stmt_list2, elem_info) if r.before
+        if r.logic
+          @handler.expand_statements(r.logic, stmt_list2, elem_info)
+        else
+          stmt_list2.concat(stmt_list)
+        end
+        @handler.expand_statements(r.after,  stmt_list2, elem_info) if r.after
+        stmt_list = stmt_list2
+      end
       return stmt_list
     end
 
@@ -896,10 +1036,19 @@ module Kwartz
     end
 
 
+    def match_ruleset(taginfo, attr_info)
+      idname = attr_info['id']
+      return true if idname && @handler.get_ruleset("#"+idname)
+      classname = attr_info['class']
+      return true if classname && @handler.get_ruleset("."+classname)
+      return @handler.get_ruleset(taginfo.tagname) ? true : false
+    end
+
+
     private
 
 
-    def fetch
+    def _fetch
       str = @scanner.scan(@@fetch_pattern)
       unless str
         @rest = @scanner.scan(/.*/m)
@@ -918,11 +1067,11 @@ module Kwartz
       start_linenum = @linenum
 
       ##
-      while taginfo = fetch()
+      while taginfo = _fetch()
         #tag_text, prev_text, head_space, is_etag, tagname, attr_str, extra_space, is_empty, tail_space = taginfo.to_a
 
         prev_text = taginfo.prev_text
-        stmt_list << create_text_print_stmt(prev_text) if prev_text && !prev_text.empty?
+        stmt_list << _create_text_print_stmt(prev_text) if prev_text && !prev_text.empty?
 
         if taginfo.is_etag?              # end tag
 
@@ -930,36 +1079,49 @@ module Kwartz
             etag_info = taginfo
             return etag_info
           else
-            stmt_list << create_text_print_stmt(taginfo.tag_text)
+            stmt_list << _create_text_print_stmt(taginfo.tag_text)
           end
 
         elsif taginfo.is_empty? || skip_etag?(taginfo)    # empty tag
 
           attr_info = AttrInfo.new(taginfo.attr_str)
-          if has_directive?(attr_info, taginfo)
+          directive = _get_directive(attr_info, taginfo)
+          if directive
             stag_info  = taginfo
             etag_info  = nil
             cont_stmts = []
-            handle_directive(stag_info, etag_info, cont_stmts, attr_info, stmt_list)
+            elem_info = ElementInfo.new(stag_info, etag_info, cont_stmts, attr_info, nil)
+            @handler.apply_rulesets(elem_info)
+            @handler.handle_directives(directive, elem_info, stmt_list)
           else
-            stmt_list << create_text_print_stmt(taginfo.tag_text)
+            stmt_list << _create_text_print_stmt(taginfo.tag_text)
           end
 
         else                            # start tag
 
           attr_info = AttrInfo.new(taginfo.attr_str)
-          if has_directive?(attr_info, taginfo)
+          directive = _get_directive(attr_info, taginfo)
+          if directive
             stag_info  = taginfo
             cont_stmts = []
-            etag_info  = _convert(cont_stmts, taginfo)
-            handle_directive(stag_info, etag_info, cont_stmts, attr_info, stmt_list)
+            etag_info  = _convert(cont_stmts, stag_info)
+            elem_info = ElementInfo.new(stag_info, etag_info, cont_stmts, attr_info, nil)
+            @handler.apply_rulesets(elem_info)
+            @handler.handle_directives(directive, elem_info, stmt_list)
+          elsif match_ruleset(taginfo, attr_info)
+            stag_info = taginfo
+            cont_stmts = []
+            etag_info = _convert(cont_stmts, stag_info)
+            elem_info = ElementInfo.new(stag_info, etag_info, cont_stmts, attr_info, nil)
+            @handler.apply_rulesets(elem_info)
+            @handler.expand_element_info(elem_info, stmt_list)
           elsif taginfo.tagname == start_tagname
             stag_info = taginfo
-            stmt_list << create_text_print_stmt(stag_info.tag_text)
+            stmt_list << _create_text_print_stmt(stag_info.tag_text)
             etag_info = _convert(stmt_list, stag_info)
-            stmt_list << create_text_print_stmt(etag_info.tag_text)
+            stmt_list << _create_text_print_stmt(etag_info.tag_text)
           else
-            stmt_list << create_text_print_stmt(taginfo.tag_text)
+            stmt_list << _create_text_print_stmt(taginfo.tag_text)
           end
 
         end #if
@@ -970,64 +1132,14 @@ module Kwartz
         raise convert_error("'<#{start_tagname}>' is not closed.", start_tag_info.linenum)
       end
 
-      stmt_list << create_text_print_stmt(@rest) if @rest
+      stmt_list << _create_text_print_stmt(@rest) if @rest && ! @rest.empty?
       nil
 
     end #def
 
 
-    def handle_directive(stag_info, etag_info, cont_stmts, attr_info, stmt_list)
-      directive_name = directive_arg = directive_str = nil
-      append_exprs = nil
-
-      ## handle 'attr:' and 'append:' directives
-      d_str = nil
-      attr_info.directive.split(/;/).each do |d_str|
-        d_str.strip!
-        unless d_str =~ @handler.directive_pattern     # ex. /\A(\w+):\s*(.*)\z/
-          raise convert_error("'#{d_str}': invalid directive pattern", stag_info.linenum)
-        end
-        d_name = $1.intern   # directive name
-        d_arg  = $2 || ''    # directive arg
-        case d_name
-        when :attr, :Attr, :ATTR
-          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_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)
-          end
-          directive_name = d_name
-          directive_arg  = d_arg
-          directive_str  = d_str
-        end #case
-      end if attr_info.directive
-
-      ## remove dummy <span> tag
-      if @delspan && stag_info.tagname == 'span' && attr_info.empty?  && append_exprs.nil? && directive_name != :id
-        stag_info.tagname = etag_info.tagname = nil
-      end
-
-      ## handle other directives
-      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
-
-    end
-
-
-    ## detect whether directive is exist or not
-    def has_directive?(attr_info, taginfo)
+    ## get directive object
+    def _get_directive(attr_info, taginfo)
       ## kw:d attribute
       val = attr_info[@dattr]     # ex. @dattr == 'kw:d'
       if val && val.is_a?(String) && !val.empty?
@@ -1037,8 +1149,9 @@ module Kwartz
           #return false
         elsif val =~ @handler.directive_pattern()    # ex. /\A(\w+):\s*(.*)/
           attr_info.delete(@dattr)
-          attr_info.directive = val
-          return true
+          #directive = Directive.new(:name=>$1.intern, :arg=>$2, :dattr=>@dattr, :str=>val)
+          directive = Directive.new(:dattr=>@dattr, :str=>val)
+          return directive
         else
           raise convert_error("'#{@dattr}=\"#{val}\"': invalid directive pattern.", taginfo.linenum)
         end
@@ -1047,21 +1160,22 @@ module Kwartz
       val = attr_info['id']
       if val
         case val
-        when /\A\w+\z/
-          attr_info.directive = @handler.directive_format() % ['mark', val]
-          return true
-        #when @handler.directive_pattern()     # ex. /\A\w+:/
+        when /\A[-\w]+\z/
+          directive = Directive.new(:name=>:mark, :arg=>val, :dattr=>'id', :str=>val)
+          return directive
+        #when @handler.directive_pattern()     # ex. /\A(\w+):(.*)/
         #  attr_info.delete('id')
-        #  attr_info.directive = val
-        #  return true
-        when /\A(mark|dummy):(\w+)\z/,
-             /\A(replace_(?:element|content)_with_(?:element|content)):(\w+)\z/
-          attr_info.directive = @handler.directive_format() % [$1, $2]
+        #  directive = Directive.new(:name=>$1.intern, :arg=>$2, :dattr=>'id', :str=>val)
+        #  return directive
+        when /\A(mark|dummy):([-\w]+)\z/,
+             /\A(value|stag|cont|etag|elem|default):(.*)\z/i,
+             /\A(replace_[a-z]+_with_[a-z]+):([-\w]+)\z/
           attr_info.delete('id')
-          return true
+          directive = Directive.new(:name=>$1.intern, :arg=>$2, :dattr=>'id', :str=>val)
+          return directive
         end
       end
-      return false
+      return nil
     end
 
 
@@ -1075,6 +1189,12 @@ module Kwartz
     end
 
 
+    def _create_text_print_stmt(text)
+      return PrintStatement.new([text])
+      #return PritnStatement.new([TextExpression.new(text)])
+    end
+
+
   end #class
   Converter.register_class('text', TextConverter)