amrita2 1.9.6 → 2.0.0

data/lib/amrita2/core.rb

@@ -1,1897 +0,0 @@
-require 'rexml/document'
-require 'enumerator'
-require 'erb'
-
-# Amrita2 adds methods for sanitize support to Object and String.
-# Every added method name has prefix like amrita_xxxxx
-class Object
-  # sanitize any object before insertion to HTML document text
-  def amrita_sanitize
-    Amrita2::Sanitizer::sanitize_text(to_s)
-  end
-
-  # sanitize any object before insertion to HTML tag attribute
-  def amrita_sanitize_as_attribute
-    Amrita2::Sanitizer::sanitize_attribute_value(to_s)
-  end
-
-  # sanitize any object before insertion to HTML tag attribute for URL
-  def amrita_sanitize_as_url
-    Amrita2::Sanitizer::sanitize_url(to_s)
-  end
-end
-
-class Symbol
-  # treat Symbol and String equally
-  def intern
-    self
-  end
-end
-
-# Amrita2 adds methods for sanitize support to Object and String.
-# Every added method name has prefix like amrita_xxxxx
-class String
-  # sanitize self before insertion to HTML document text
-  def amrita_sanitize
-    Amrita2::Sanitizer::sanitize_text(self)
-  end
-
-  # sanitize self before insertion to HTML tag attribute
-  def amrita_sanitize_as_attribute
-    Amrita2::Sanitizer::sanitize_attribute_value(self)
-  end
-
-  # sanitize self before insertion to HTML tag attribute for URL
-  def amrita_sanitize_as_url
-    Amrita2::Sanitizer::sanitize_url(self)
-  end
-end
-
-
-# Amrita2 adds methods for support of internal compilation XML to Ruby conde
-# Every added method name has prefix like amrita_xxxxx.
-# Don't call them.
-module REXML
-  class Child  
-    attr_accessor :amrita_no_spec
-    def amrita_compile_main_code(cg)
-      #cg.put_constant(to_s)
-      cg.put_rexml_node(self)
-    end
-
-    def amrita_has_cdata?
-      false
-    end
-  end
-
-
-  class Parent < Child
-    def amrita_compile_main_code(cg)
-      if amrita_no_spec  and not amrita_has_cdata?
-        super
-      else
-        each_child do |c|
-          c.amrita_compile_main_code(cg)
-        end
-      end
-    end
-
-    def amrita_has_cdata?
-      each_child do |c|
-        case c
-        when CData
-          return true
-        when Parent
-          return true if c.amrita_has_cdata?
-        else
-        end
-      end
-      false
-    end
-  end
-
-  class XMLDecl < Child # :nodoc:
-    def amrita_compile_main_code(cg)
-      # don't output XMLDecl
-    end
-  end
-
-  class DocType < Parent  # :nodoc:
-    def amrita_compile_main_code(cg)
-      cg.put_constant(to_s)
-      cg.put_constant("\n")
-    end
-  end
-
-  class Comment < Child
-    def amrita_compile_main_code(cg)
-      cg.put_constant("<!--#{ to_s}-->")
-    end
-  end
-
-  class Element < Parent
-    attr_accessor :amrita_spec
-    def amrita_compile_main_code(cg)
-      if amrita_no_spec and not amrita_has_cdata?
-        super
-      else
-        cg.compile_element_main_code(self) do
-          super
-        end
-      end
-    end
-
-    def amrita_compile_sub_code(cg)
-      cg.compile_element_sub_code(self) do
-        elements.each do |e|
-          e.amrita_compile_sub_code(cg)
-        end
-      end
-    end
-
-    alias to_s_org to_s
-    def to_s
-      Amrita2::SanitizedString[to_s_org]
-    end
-  end
-
-  class CData < Text
-   def amrita_compile_main_code(cg)
-     cg.put_cdata(self)
-   end
-  end
-end
-
-module Amrita2   # :nodoc:
-  module SanitizeSupport # :nodoc:
-
-    # Amrita2 sanitize anything except for SanitizedString
-    # If you want to sanitize yourself and don't want to Amrita2 sanitize your object,
-    # pass SanitizedString[x] as model data.
-    class SanitizedString < String
-      def SanitizedString::[](s)
-        new(s).freeze
-      end
-
-      def amrita_sanitize
-        self
-      end
-
-      def amrita_sanitize_as_attribute
-        self
-      end
-
-      def amrita_sanitize_as_url
-        self
-      end
-
-      def to_s
-        self
-      end
-
-      def inspect
-        %[Amrita2::SanitizedString[#{super}]]
-      end
-    end
-
-    # This module provide methods for avoid XSS vulnerability
-    # taken from IPA home page(Japanese)
-    # http://www.ipa.go.jp/security/awareness/vendor/programming/a01_02.html
-    module Sanitizer # :nodoc:
-      NAMECHAR = '[-\w\d\.:]'
-      NAME = "([\\w:]#{NAMECHAR}*)"
-      NOT_REFERENCE = "(?!#{NAME};|&#\\d+;|&#x[0-9a-fA-F]+;)" # borrowed from rexml
-      AMP_WITHOUT_REFRENCE = /&#{NOT_REFERENCE}/
-      # escape &<>
-      def sanitize_text(text)
-        s = text.dup
-        s.gsub!(AMP_WITHOUT_REFRENCE, '&amp;')
-        s.gsub!("<", '&lt;')
-        s.gsub!(">", '&gt;')
-        s
-      end
-
-      # escape &<>"'
-      def sanitize_attribute_value(text)
-        s = text.dup
-        s.gsub!(AMP_WITHOUT_REFRENCE, '&amp;')
-        s.gsub!("<", '&lt;')
-        s.gsub!(">", '&gt;')
-        s.gsub!('"', '&quot;')
-        s.gsub!("'", '&#39;')
-        s
-      end
-
-      DefaultAllowedScheme = {
-        'http' => true,
-        'https' => true,
-        'ftp' => true,
-        'mailto' => true,
-      }
-
-      #UrlInvalidChar = Regexp.new(%q|[^;/?:@&=+$,A-Za-z0-9\-_.!~*'()%]|)
-      UrlInvalidChar = Regexp.new(%q|[^;/?:@&=+$,A-Za-z0-9\-_.!~*'()%#]|) #'
-
-      # +sanitize_url+ accepts only these characters 
-      #     --- http://www.ietf.org/rfc/rfc2396.txt ---
-      #     uric = reserved | unreserved | escaped
-      #     reserved = ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" | "$" | ","
-      #     unreserved = alphanum | mark
-      #     mark = "-" | "_" | "." | "!" | "~" | "*" | "'" | "(" | ")"
-      #     escaped = "%" hex hex
-      # 
-      # +sanitize_url+ accepts only schems specified by +allowd_scheme+
-      #
-      # The default is http: https: ftp: mailt:
-
-      def  sanitize_url(text, allowd_scheme = DefaultAllowedScheme)
-        # return nil if text has characters not allowd for URL
-
-        return nil if text =~ UrlInvalidChar
-
-        # return '' if text has an unknown scheme
-        # --- http://www.ietf.org/rfc/rfc2396.txt ---
-        # scheme = alpha *( alpha | digit | "+" | "-" | "." )
-
-        if text =~ %r|^([A-Za-z][A-Za-z0-9+\-.]*):| 
-            return nil unless allowd_scheme[$1]
-        end
-        
-        # escape HTML
-        # special = "&" | "<" | ">" | '"' | "'"
-        # But I checked  "<" | ">" | '"' before.
-        s = text.dup
-        #s.gsub!("&", '&amp;')
-        s.gsub!("'", '&#39;')
-
-        s
-      end
-
-      module_function :sanitize_text, :sanitize_attribute_value, :sanitize_url
-    end
-  end
-  include SanitizeSupport
-
-  module Runtime # :nodoc:
-    include SanitizeSupport
-    def new_element(tag, attrs={})
-      ret = REXML::Element.new(tag.to_s)
-      attrs.each do |k,v|
-        ret.attributes[k.to_s] = v.to_s
-      end
-      ret
-    end
-    
-    def start_tag(e, out="")
-      out << "<#{e.expanded_name}"
-      e.attributes.each_attribute do |attr|
-        next if attr.value == ""
-        out << " "
-        attr.write(out)  
-      end unless e.attributes.empty?
-      out << ">"
-      out
-    end
-
-    def end_tag(e, out="")
-      out << "</#{e.expanded_name}>"
-      out
-    end
-
-    class Context  # :nodoc:
-      attr_reader :main_stream, :sub_streams, :mv_index
-      attr_accessor :current_data, :current_binding
-      
-      def initialize(stream="", old_context=nil, opt={})
-        @sub_streams = {}
-        if old_context
-          @sub_streams = old_context.sub_streams if opt[:inherit_sub_streams]
-          @main_stream = (stream or old_context.main_stream)
-          @current_binding = (opt[:binding] or old_context.current_binding)
-          @current_data = (opt[:data] or old_context.current_data)
-          @mv_index = old_context.mv_index
-        else
-          @main_stream = (stream or "")
-          @current_binding = TOPLEVEL_BINDING
-          @current_data = nil
-          @mv_index = {}
-        end
-      end
-
-      def sub_stream(key)
-        @sub_streams[key] ||= ""
-      end
-
-      def clear_substream(key)
-        @sub_streams[key] = ""
-      end
-    end
-    
-    def context_stack
-      Thread::current[:amrita_context_stack] ||= [ Context.new ]
-    end
-
-    def current_context
-      context_stack.first
-    end
-
-    def new_context(stream = "", opt = {}, &block)
-      context_stack.unshift Context.new(stream, context_stack[0], opt)
-      yield
-      if stream.kind_of?(String)
-        SanitizedString[stream]
-      else
-        stream
-      end
-    ensure
-      context_stack.shift
-    end
-
-    def new_binding(b, &block)
-      new_context(nil, :binding => b, :inherit_sub_streams => true, &block)
-    end
-
-    def new_context_data(d, &block)
-      new_context(nil, :data => d, :inherit_sub_streams => true, &block)
-    end
-
-    def get_mainstream
-      current_context.main_stream
-    end
-
-    def get_substream(key)
-      current_context.sub_stream(key)
-    end
-
-    def output_substream(key)
-      c = current_context
-      s = c.sub_stream(key)
-      c.main_stream << SanitizedString[s]
-      c.clear_substream(key)
-    end
-
-    def set_binding(b)
-      current_context.current_binding = b
-    end
-
-    def get_binding
-      current_context.current_binding 
-    end
-
-    def set_context_data(d)
-      current_context.current_data = d
-    end
-
-    def get_context_data
-      current_context.current_data
-    end
-  end
-  include Runtime
-
-  module Core # :nodoc:
-    class CodeGenerator # :nodoc:
-      attr_accessor :current_stream, :ie_hack, :eval_cdata_as_erb
-
-      def initialize(stream = "get_mainstream")
-        @current_stream = stream
-        init_results
-        init_strbuf
-        @current_indent = 0
-        @varcnt=0
-        @const_cnt=0
-        @ie_hack = false
-        @eval_cdata_as_erb = false
-        @module_stack = [CGModule.new('X')]
-      end
-
-      def put_rexml_node(node)
-        s = ""
-        node.write(s, -1, false, @ie_hack)
-        put_constant(s)
-      end
-
-      def put_constant(msg)
-        @strbuf.concat msg
-      end
-
-      def flush
-        if @strbuf.size > 0
-          @results << [@current_indent, "#{current_stream} << " + @strbuf.inspect]
-          init_strbuf
-        end
-      end
-
-      def put_expression(exp)
-        code("#{current_stream} << #{exp}")
-      end
-
-      def code(l)
-        flush
-        @results << [@current_indent, l]
-      end
-
-      def new_var
-        @varcnt += 1
-        "v#{@varcnt}"
-      end
-
-      def results
-        flush
-        m = @module_stack.shift
-        if m
-          m.constants.each do |name, defs|
-            code("#{name} = #{defs}")
-          end
-        end
-        @results.collect do |level, line|
-          "  " * level + line
-        end
-      end
-
-      def if_(cond)
-        code("if #{cond}")
-        level_up do
-          yield
-        end
-        code("end")
-      end
-
-      def else_
-        level_down do
-          code("else")
-        end
-        yield
-      end
-
-      def level_up
-        flush
-        @current_indent += 1
-        yield
-      ensure
-        flush
-        @current_indent -= 1
-      end
-
-      def level_down
-        flush
-        @current_indent -= 1
-        yield
-      ensure
-        flush
-        @current_indent += 1
-      end
-
-      def define_method(name, *params)
-        if params.size == 0
-          code("def self.#{name}")
-        else
-          code("def self.#{name}(#{params.join(',')})")
-        end
-        level_up do
-          yield
-        end
-        code("end")
-      end
-
-      def define_element_method(name, new_stream, &block)
-        define_method(name, "val=nil", "attrs={}", "&block") do
-          unless @eval_cdata_as_erb
-            code("attrs = val if val.kind_of?(Hash)")
-          end
-          new_context("get_substream(:#{new_stream})") do
-            yield
-          end
-        end
-      end
-
-      def define_element_method_old(name, new_stream, &block)
-        define_method(name, "val=nil", "attrs={}", "&block") do
-          if_("val.kind_of?(AttrArray)") do
-            code("attrs = val ; val = val.body ")
-            unless @eval_cdata_as_erb
-              else_ do
-                code("attrs = val if val.kind_of?(Hash)")
-              end
-            end
-          end
-          new_context("get_substream(:#{new_stream})") do
-            yield
-          end
-        end
-      end
-
-      def define_module(name)
-        @module_stack.unshift CGModule.new(name)
-        code("module #{name}")
-        level_up do
-          yield
-          m = @module_stack.shift
-          m.end_of_module(self)
-        end
-        code("end")
-      end
-
-      def define_method_and_call(*vars, &block)
-        m = @module_stack[0]
-        meth_name = m.define_method(vars, &block)
-        meth_call_code = "#{meth_name}(#{(vars).join(',')})"
-        code(meth_call_code)
-        meth_call_code
-      end
-
-      def convert(encto, encfrom, *args)
-        a = args.join(",")
-        code("#{a} = *Iconv::iconv(#{encto.inspect}, #{encfrom.inspect}, #{a})")
-      end
-
-      def convert_hash(encto, encfrom, hash)
-        code("#{hash}.each do |k, v|")
-        level_up do
-          code("v = *Iconv::iconv(#{encto.inspect}, #{encfrom.inspect}, v)")
-          code("#{hash}[k] = v")
-        end
-        code("end")
-      end
-
-      def compile_element_main_code(element, &block)
-        spec = element.amrita_spec
-        if spec
-          spec.compile_element_main_code(element, self, &block)
-        else
-          generate_static_element_code(element, &block)
-        end
-      end
-
-      def compile_element_sub_code(element, &block)
-        spec = element.amrita_spec
-        if spec
-          spec.compile_element_sub_code(element, self, &block) 
-        else
-          yield
-        end
-      end
-
-      def init_results
-        @results = []
-      end
-
-      def init_strbuf
-        @strbuf = ""
-      end
-
-      def generate_static_element_code(e, option={}, &block)
-        if e.amrita_no_spec and not e.amrita_has_cdata?
-          put_rexml_node(e)
-        elsif option[:mv_attr]
-          put_constant("<#{e.name} ")
-          attr_to_output = e.attributes.to_a
-          key_attr_nm = option[:key_attr_name].to_s
-          if option[:delete_id]
-            attr_to_output.reject! do |attr|
-              attr.name == key_attr_nm 
-            end
-          end
-          a = [e.name] + attr_to_output.collect do |attr| 
-            put_constant(attr.to_string+" ")
-          end
-          option[:mv_attr].each do |k, v|
-            put_constant "#{k}='"
-            c = define_constant("Amrita2::MultiValue.new(*#{v.inspect})")
-            put_expression("#{c}.value")
-          end
-          put_constant("'>")
-          yield
-          put_constant("</#{e.name}>")
-        elsif e.name and e.name.size > 0
-          no_tag = option[:delete_tag] 
-          attr_to_output = e.attributes.to_a
-          unless no_tag
-            key_attr_nm = option[:key_attr_name].to_s
-            if option[:delete_id]
-              attr_to_output.reject! do |attr|
-                attr.name == key_attr_nm 
-              end
-            end
-          end
-          no_tag ||= (e.name == 'span' and attr_to_output.size == 0)
-          unless no_tag
-            a = [e.name] + attr_to_output.collect do |attr| 
-              attr.to_string 
-            end
-            put_constant("<#{a.join(' ')}>")
-          end
-          yield
-          put_constant("</#{e.name}>") unless no_tag
-        else
-          yield
-        end
-      end
-
-      def new_context(new_stream="nil", opt={}, &block)
-        code("new_context(#{new_stream}, #{opt.inspect}) do")
-        level_up do
-          yield
-        end
-        code("end")
-      end
-
-      def put_cdata(cdata)
-        if @eval_cdata_as_erb
-          src = "<% $_ = get_context_data;  %>" + cdata.to_s
-          erb = define_constant %[ERB.new(#{src.inspect})]
-          put_expression %[#{erb}.result(get_binding, &block)]
-        else
-          put_rexml_node(cdata)
-        end
-      end
-
-      def define_constant(const_def)
-        m = @module_stack[0]
-        ret = m.define_constant(const_def, @const_cnt)
-        @const_cnt += 1
-        ret
-      end
-
-      class CGModule # :nodoc:
-        attr_reader :name
-        attr_reader :constants
-        attr_reader :methods
-
-        def initialize(name)
-          @name = name 
-          @constants = []
-          @methods = []
-        end
-
-        def define_constant(const_def, cnt)
-          name = "C#{sprintf("%03d", cnt)}"
-          @constants << [name, const_def]
-          name
-        end
-
-        def define_method(vars, &block)
-          name = "m#{sprintf("%03d", @methods.size)}"
-          @methods << [name, vars, block]
-          name
-        end
-
-        def end_of_module(cg)
-          @constants.each do |name, defs|
-            cg.code("#{name} = #{defs}")
-          end
-          @methods.each do |name, vars, body|
-            cg.define_method(name, vars) do
-              body.call
-            end
-          end
-        end
-      end
-    end
-
-    class Matcher # :nodoc:
-      def find(e)
-        return e if match(e)
-        e.elements.each do |c|
-          x = find(c)
-          return x if x
-        end
-        nil
-      end
-    end
-
-    class AttrMatcher < Matcher # :nodoc:
-      attr_reader :sym
-      def initialize(sym, val)
-        @sym = sym
-        @sym_s = sym.to_s
-        @val = val
-      end
-
-      def match(e)
-        if @val != '*'
-          @val == e.attributes[@sym_s]
-        else
-          e.attributes[@sym_s]
-        end
-      end
-    end
-
-    class TagMatcher < Matcher # :nodoc:
-      def initialize(tag)
-        @tag = tag.to_s
-      end
-
-      def match(e)
-        e.name == @tag
-      end
-    end
-
-    class AnyMatcher < Matcher # :nodoc:
-      def match(e)
-        true
-      end
-    end
-
-
-    class SpecOptionMeta # :nodoc:
-      module MetaData # :nodoc:
-        def check_option(spec, k, v)
-        end
-      end
-
-      @@options = {}
-      def self.get_option_meta(name)
-        @@options[name]
-      end
-
-      def self.define_option(name, meta=nil, *args)
-        case meta
-        when nil
-          meta = Object.new
-          meta.extend MetaData
-        when MetaData
-          # do nothing
-        when Module
-          m = Object.new
-          m.extend meta
-          meta = m
-        end
-        args.each do |mod|
-          meta.extend mod
-        end
-        @@options[name] = meta
-      end
-
-      def self.check_options(spec)
-        spec.option.each do |k, v|
-          meta = @@options[k]
-          case meta
-          when nil
-            raise NameError, "option #{k} was not defined"
-          else
-            meta.check_option(spec, k, v)
-          end
-        end
-      end
-
-      def self.setup_compiler(spec, compiler)
-        spec.option.each do |k, v|
-          next unless v
-          meta = @@options[k]
-          case meta
-          when CompilerOption
-            compiler.extend meta 
-          end
-        end
-      end
-      
-      def self.inherit_option(spec, child_opt)
-        spec.option.each do |k, v|
-          meta = @@options[k]
-          case meta
-          when InheritableOption
-            meta.inherite_option(k, v, child_opt)
-          end
-        end
-      end
-
-      def self.define_element_ext(spec, name, sym, params, &block)
-        meta = @@options[name]
-        if meta 
-          meta.define_element_ext(spec, name, sym, params || {}, &block)
-        end
-      end
-
-      module SymbolOption # :nodoc:
-        def check_option(spec, k, v)
-          case v
-          when Symbol, String
-          else
-            raise "option #{k} must be a Symbol" 
-          end
-        end
-      end
-
-      module InheritableOption # :nodoc:
-        include MetaData
-        def inherite_option(k, v, child_opt)
-          return if child_opt.has_key?(k)
-          child_opt[k] = v if v
-        end
-      end
-
-      module CompilerOption # :nodoc:
-        include MetaData
-      end
-
-      module ElementExt # :nodoc:
-        include MetaData
-        def define_element_ext(spec, name, sym, params, &block)
-          pp = params.clone 
-          pp[name] = true
-          spec.dynamic_element(sym, pp, &block)
-        end
-      end
-
-      define_option(:key_attr_name, SymbolOption, InheritableOption)
-      define_option(:delete_tag)
-      define_option(:matcher)
-      define_option(:output_stream, SymbolOption)
-      define_option(:delete_id, InheritableOption)
-      define_option(:place_holder)
-      define_option(:match_many)
-      define_option(:generate_template, InheritableOption)
-      define_option(:encoding, InheritableOption)
-      define_option(:dummy_element, ElementExt)
-      define_option(:ie_hack)
-      define_option(:mv_attr)
-      define_option(:debug_source)
-    end
-
-    class DynamicElementSpec # :nodoc:
-      attr_accessor :cloned, :parent
-      attr_reader :sym, :matcher, :children, :option, :assigned_elements
-
-      def initialize(sym, parent, option={}, &block)
-        case sym
-        when Symbol
-          @sym = sym
-        when nil
-          @sym = nil
-        else
-          @sym = sym.to_s.intern
-        end
-        @parent = parent
-        @option, @children = option, []
-
-        SpecOptionMeta::check_options(self)
-        @direct_define = @option[:direct_define]
-        setup_matcher
-        setup_compiler
-        if block_given?
-          @in_setup = true
-          self.instance_eval(&block) 
-          @in_setup = false
-        end
-
-        check_double_id 
-      end
-
-      def inspect(lvl=0)
-        spc = "  " * lvl
-        if children.size > 0
-          "#{spc}dynamic_element(#{sym.inspect}, #{@option.inspect}, #{self.class.name}) do\n" +
-            children.collect {|c| c.inspect(lvl+1)} .join +
-            "#{spc}end\n" 
-        else
-          "#{spc}dynamic_element(#{sym.inspect}, #{@option.inspect}, #{self.class.name})\n"
-        end
-      end
-
-      def name_for(element)
-        @sym
-      end
-
-      def dynamic_element(name, opt={}, cls=DynamicElementSpec, &block)
-        SpecOptionMeta::inherit_option(self, opt)
-        new_spec = cls.new(name, self, opt, &block)
-        @children <<  new_spec
-        new_spec
-      end
-
-      
-      def compile_element_main_code(element, cg, &block)
-        return if @option[:dummy_element]
-        @compiler.compile_main(element, self, cg, &block)
-      end
-
-      def compile_element_sub_code(element, cg, &block)
-        return if @option[:dummy_element]
-        @compiler.compile_sub(element, self, cg, &block)
-      end
-
-      def method_missing(*args, &block)
-        name = nil
-        name = args.shift if args.first.kind_of?(Symbol)
-        return super unless @in_setup
-        if @direct_define 
-          params = args[-1] || {}
-          dynamic_element(name, params, &block)
-        else
-          sym = nil
-          sym = args.shift if args.first.kind_of?(Symbol)
-          SpecOptionMeta::define_element_ext(self, name , sym, args.first, &block) or 
-            super
-        end
-      end
-
-      def module_name
-        sym.to_s.capitalize  
-      end
-
-      def output_stream
-        @option[:output_stream] or sym
-      end
-
-      def get_methods
-        h = {}
-        ret = children.find_all do |c|
-          ret = h[c.sym]
-          h[c.sym] = true
-          ret != true and c.sym
-        end.collect {|c| c.sym }
-        if ret.size == 0
-          children.each do |c|
-            ret.concat c.get_methods
-          end
-        end
-        ret
-      end
-
-      def make_default_template
-        tag = @option[:html_tag] 
-        tag = 'div' if @option[:div] 
-        unless sym or tag
-          ret = children.collect do |c|
-            c.make_default_template
-          end.join('')
-          return ret
-        end
-
-        attr = @option[:html_attr]
-        a = nil
-        if attr
-          a =  attr.collect do |k,v| 
-            "#{k}='#{v}'"
-          end.join(' ')
-        end
-        if @option[:static_data]
-          tag_and_attr = tag.to_s
-          tag_and_attr += ' ' + a if attr and attr.size > 0
-          "<#{tag_and_attr}>#{@option[:static_data]}</#{tag}>"
-        else
-          tag ||= 'span' 
-          tag_and_attr = tag.to_s
-          tag_and_attr += ' ' + a if attr and attr.size > 0
-          if sym or tag
-            idparam = ""
-            idparam = " #{@option[:key_attr_name] }='#{sym}'" if sym
-            tag = 'span' unless tag
-            if children.size > 0
-              "<#{tag_and_attr}#{idparam}>" +
-                children.collect do |c|
-                c.make_default_template
-              end.join('') + "</#{tag}>"
-            else
-              "<#{tag_and_attr} #{idparam} />" 
-            end
-          else
-          end
-        end
-      end
-
-      def generate_expander(mod, parent=nil)
-        @compiler.generate_expander(self, mod, parent)
-      end
-
-      def get_dynamic_specs
-        if sym
-          [self]
-        else
-          children.collect do |c|
-            c.get_dynamic_specs
-          end.flatten
-        end
-      end
-
-      def check_double_id
-        h = {}
-        children.each do |c|
-          next unless c.sym
-          raise "dobule ID #{c.sym} in #{sym || 'ROOT'}" if h[c.sym] and not c.option[:dummy_element]
-          h[c.sym] = true
-        end
-      end
-
-      private
-      def setup_matcher
-        if sym
-          @matcher = @option[:matcher] || AttrMatcher.new(@option[:key_attr_name], sym.to_s)
-        else
-          @matcher = AnyMatcher.new
-        end
-      end
-
-      def setup_compiler
-        if @option[:compiler] 
-          @compiler = @option[:compiler]
-        else
-          @compiler = DefaultCompiler.new
-          SpecOptionMeta::setup_compiler(self, @compiler)
-        end
-      end
-
-    end
-
-    class RootSpec < DynamicElementSpec # :nodoc:
-      def initialize(option={}, &block)
-        option[:key_attr_name] = :id unless option[:key_attr_name]
-        super(nil, nil, option, &block)
-      end
-
-      def module_name
-        "MainContext"
-      end
-
-      def create_template_module(e, doc=nil)
-        m = Module.new
-        result = create_template_module_text(e)
-        @option[:debug_source].puts result  if @option[:debug_source]
-        m.module_eval result
-        if doc
-          m.const_set(:XmlDecl, doc.xml_decl.to_s)
-          m.const_set(:DocType, doc.doctype.to_s)
-        end
-        m
-      end
-
-      def create_template_module_text(e)
-        specs = [self]
-
-        traverse_and_search_match(specs, e)
-        # not match check
-        raise "SPEC #{specs.first.sym} was not matched" if specs.size > 0 
-
-        cg = CodeGenerator.new
-        cg.ie_hack = option[:ie_hack] 
-        cg.eval_cdata_as_erb = option[:eval_cdata_as_erb] 
-        cg.code("include Amrita2")
-        cg.code("extend Amrita2")
-
-         cg.define_method(:expand_template, :out, "&block") do
-           define_expand_template(cg, e)
-         end
-
-        cg.define_module(module_name) do
-          cg.code("Methods = #{get_methods.inspect}")
-          cg.code("include Amrita2")
-          cg.code("extend Amrita2")
-          define_sub_modules(cg, e)
-        end
-
-        cg.define_method(:xml_decl) do
-          cg.code("XmlDecl.dup")
-        end
-
-        cg.define_method(:doctype) do
-          cg.code("DocType.dup")
-        end
-
-        cg.results.join("\n")
-      end
-
-      def define_expand_template(cg, e)
-        cg.code("new_context(out) do")
-        cg.level_up do
-          cg.code("block.call(#{module_name or 'nil'}) if block_given? ")
-          e.amrita_compile_main_code(cg)
-        end
-        cg.code("current_context.mv_index.clear")
-        cg.code("end")
-      end
-
-      def define_sub_modules(cg, e)
-        e.amrita_compile_sub_code(cg)
-      end
-
-      def traverse_and_search_match(child_specs, element)
-        spec = child_specs.first
-        unless spec
-          element.amrita_no_spec = true unless element.amrita_spec
-          return false
-        end
-        if spec.matcher.match(element)
-          element.amrita_no_spec = false
-          element.amrita_spec = spec if spec.sym
-          child_specs.shift unless spec.option[:match_many]
-          specs = spec.children.collect do |s|
-            s.get_dynamic_specs
-          end.flatten
-          if spec.option[:generate_template] and specs.size > 0 and element.elements.size == 0
-            generate_template(spec, element)
-          end
-          traverse_and_search_match(specs, element)
-
-          # not match check
-          specs.each do |s|
-            next if s.option[:match_many]
-            next if s.option[:static_data]
-            raise "SPEC #{s.sym} was not matched" 
-          end
-        else
-          # check children has spec and set it to amrita_no_spec and return the result
-          f = false                   
-          element.elements.each do |ce|
-            f |= traverse_and_search_match(child_specs, ce)
-          end
-          element.amrita_no_spec = (not f) 
-          f
-        end
-      end
-
-      def generate_template(spec, element)
-        src = spec.make_default_template
-        doc = REXML::Document.new src
-        doc.root.elements.each do |c|
-          element.add(c)
-        end
-      end
-
-      def generate_expander(mod, parent=nil)
-        Expander::Root.new(self, mod)
-      end
-    end
-
-    class DefaultCompiler # :nodoc:
-      def compile_main(element, dyn_spec, cg, &block)
-        if dyn_spec.option[:place_holder]
-          cg.generate_static_element_code(element) do
-          end
-        elsif dyn_spec.option[:static_element]
-          cg.generate_static_element_code(element) do 
-            element.each_child do |c|
-              c.amrita_compile_main_code(cg)
-            end
-          end
-        else
-          sym = element.amrita_spec.sym
-          compile_main_code(element, dyn_spec, cg, sym.to_s, &block)
-        end
-      end
-
-      def compile_sub(element, dyn_spec, cg, &block)
-        if dyn_spec.option[:static_element]
-          element.elements.each do |c|
-            c.compile_sub_code(cg)
-          end
-        else
-          compile_dynamic_element_code(element, dyn_spec, cg, &block)
-        end
-      end
-
-      def generate_expander(spec, mod, parent=nil)
-        if spec.children.size > 0
-          Expander::Node.new(parent, spec, mod)
-        else
-          Expander::Leaf.new(parent, spec, mod)
-        end
-      end
-
-      private
-      def compile_main_code(element, dyn_spec, cg, sym)
-        cg.code("output_substream(:#{sym})")
-      end
-
-      def compile_dynamic_element_code(element, dyn_spec, cg, &block)
-        sym = dyn_spec.sym
-        if dyn_spec.children.size == 0 
-          if dyn_spec.option[:eval_cdata_as_erb] and element.amrita_has_cdata?
-            code_for_not_leaf_element(element, dyn_spec, cg, &block)
-          else
-            code_for_leaf_element(element, dyn_spec, cg, &block)
-          end
-        else
-          code_for_not_leaf_element(element, dyn_spec, cg, &block)
-        end
-      end
-
-      def code_for_leaf_element(element, dyn_spec, cg, &block)
-        sym = dyn_spec.sym
-        cg.define_element_method(sym, dyn_spec.output_stream) do
-          enc = dyn_spec.option[:encoding]
-          if enc
-            cg.convert("utf-8", enc, "sym", "val") 
-            cg.convert_hash("utf-8", enc, "attrs")
-          end
-          code_for_element_and_scalar(element, dyn_spec, cg)
-        end
-      end
-
-      def code_for_not_leaf_element(element, dyn_spec, cg, &block)
-        sym = dyn_spec.name_for(element)
-        cg.define_element_method(sym, dyn_spec.output_stream) do
-          code_for_element_with_child(element, dyn_spec, cg, &block)
-        end
-        cg.define_module(dyn_spec.module_name) do
-          cg.code("Methods = #{dyn_spec.get_methods.inspect}")
-          cg.code("include Amrita2")
-          cg.code("extend Amrita2")
-          yield
-        end
-      end
-
-      def code_for_element_and_scalar(element, dyn_spec, cg)
-        cg.if_("val == true") do
-          t = element.enum_for(:each_child).collect do |c|
-            c.to_s
-          end.join
-          cc = cg.define_constant("SanitizedString[#{t.inspect}]")
-          cg.code("val = #{cc}")
-        end
-        cg.if_("attrs.size == 0") do
-          cg.generate_static_element_code(element, dyn_spec.option) do 
-            cg.put_expression("val.amrita_sanitize")
-          end
-          cg.else_ do
-            gen_element_with_attr(element, dyn_spec, cg)
-            cg.code("e.delete_attribute(#{dyn_spec.option[:key_attr_name].to_s.inspect})") if dyn_spec.option[:delete_id]
-            cg.put_expression("start_tag(e)")
-            cg.put_expression("val.amrita_sanitize")
-            cg.put_expression("end_tag(e)")
-          end
-        end
-      end
-
-      def code_for_element_with_child(element, dyn_spec, cg)
-        cg.if_("val == true") do
-          cg.if_("attrs.size == 0") do
-            cg.put_constant(element.to_s)
-            cg.else_ do
-              gen_element_with_attr(element, dyn_spec, cg)
-              cg.put_expression("start_tag(e)")
-              element.each_child do |c|
-                cg.put_constant(c.to_s)
-              end
-              cg.put_expression("end_tag(e)")
-            end
-          end
-          cg.else_ do 
-            cg.if_("attrs.size == 0") do
-              sub_method = nil
-              cg.generate_static_element_code(element, dyn_spec.option) do 
-                sub_method = cg.define_method_and_call(:val, :attrs, "&block") do
-                  yield_block(cg, dyn_spec)
-                  element.each_child do |e|
-                    e.amrita_compile_main_code(cg)
-                  end
-                end
-              end
-              cg.else_ do
-                gen_element_with_attr(element, dyn_spec, cg)
-                cg.put_expression("start_tag(e)")
-                cg.code(sub_method)
-                cg.put_expression("end_tag(e)")
-              end
-            end
-          end
-        end
-      end
-
-      def gen_element_with_attr(element,dyn_spec, cg, varname='e')
-        a = element.attributes.collect do |k, v|
-          next if dyn_spec.option[:delete_id] and k == dyn_spec.option[:key_attr_name].to_s
-          "#{k.intern.inspect} => #{v.inspect}, "
-        end
-        default_value = "{ #{a.join(' ')}}"
-        cg.code("#{varname} = new_element(#{element.name.inspect}, #{default_value}.merge(attrs))")
-      end
-      
-      def yield_block(cg, dyn_spec)
-        cg.code("yield(#{dyn_spec.module_name}) if block_given?")
-      end
-    end
-  end
-
-  def self.define_template_spec(option={}, &block)
-    Core::RootSpec.new(option, &block)
-  end
-
-
-  module ModelData # :nodoc:
-    class AttrArray < Hash 
-      attr_reader :body
-      def initialize(h, &block)
-        h.each do |k, v|
-          self[k] = v
-        end
-        if block_given?
-          @body = yield
-        else
-          @body = true
-        end
-      end
-    end
-
-    class Tuple < Array # :nodoc:
-      def self.[](*args)
-        self.new(args)
-      end
-    end
-
-    class MultiValue # :nodoc:
-      include Runtime
-      def initialize(*v)
-        @values = v
-      end
-
-      def value
-        current_context.mv_index[object_id] ||= 0
-        cnt = current_context.mv_index[object_id]
-        v = @values[cnt]
-        current_context.mv_index[object_id] = ((cnt+1) % @values.size)
-        v
-      end
-    end
-
-    def e(tag, hash={})
-      ret = REXML::Element.new(tag.to_s)
-      hash.each do |k, v|
-        ret.attributes[k.to_s] = v
-      end
-      if block_given?
-        case child = yield 
-        when REXML::Element
-          ret.add child
-        else
-          ret.text = child
-        end
-      end
-      ret
-    end
-
-    def a(hash={}, &block)
-      AttrArray.new(hash, &block)
-    end
-
-    def t(*args)
-      Tuple[*args]
-    end
-  end
-  include ModelData
-
-  module Expander # :nodoc:
-    include ModelData
-    class Base # :nodoc:
-      include Runtime
-      attr_reader :children, :name, :mod, :spec, :parent
-      def initialize(parent, spec, pmod)
-        @parent = parent
-        @spec = spec
-        @children = []
-        @name = @spec.sym
-        @method = pmod.method(@spec.sym || :expand_template) unless spec.option[:dummy_element]
-      end
-
-      def call_template_method(data=nil, context_data=data, attrs=nil, &block)
-        args = [data]
-        args << attrs if attrs
-        if @spec.option[:eval_cdata_as_erb] and context_data
-          new_context_data(context_data) do
-            @method.call(*args, &block)
-          end
-        else
-          @method.call(*args, &block)
-        end
-      end
-    end
-
-    class Leaf < Base # :nodoc:
-      include Amrita2
-      def expand(data, i=nil)
-        case data
-        when nil
-        when String, Integer, true, false, Struct
-          call_template_method(data)
-        when REXML::Element
-          if data.name
-            call_template_method(SanitizedString[data.to_s])
-          else
-            call_template_method(data.text, data, data.attributes)
-          end
-        when AttrArray
-          call_template_method(data.body, data, data)
-        when Hash
-          call_template_method(data)
-        when Tuple
-          @method.call(*data)
-        when Enumerable
-          data.each_with_index do |d, i|
-            expand(d, i)
-          end
-        when Proc
-          data.call(@parent.mod)
-        else
-          call_template_method(data)
-        end
-      end
-    end
-
-    class Node < Base # :nodoc:
-      include Amrita2
-      def initialize(parent, spec, pmod)
-        super
-        @mod = pmod::const_get(spec.module_name)
-        traverse_children(spec)
-      end
-
-      def traverse_children(spec)
-        spec.children.each do |c|
-          if c.sym and not c.option[:dummy_element]
-            @children << c.generate_expander(@mod, self) 
-          else
-            traverse_children(c)
-          end
-        end
-      end
-
-      def each(&block)
-        @children.each do |c|
-          next unless c.spec.sym 
-          next if c.spec.option[:dummy_element]
-          yield(c)
-        end
-      end
-
-      def expand(data)
-        case data
-        when nil
-        when Proc
-          data.call(@mod)
-        when AttrArray
-          call_template_method(data) do 
-            data = data.body
-            case data
-            when Hash
-              each do |c|
-                k = c.name
-                d = data[k] || data[k.to_s]
-                c.expand(d)
-              end
-            when Struct, Enumerable
-              raise 'not implemented'
-            else
-              expand_po(data)
-            end
-          end
-        when Hash
-          call_template_method(nil, data) do 
-            each do |c|
-              k = c.name
-              d = data[k] || data[k.to_s]
-              c.expand(d)
-            end
-          end
-        when Struct
-          call_template_method(nil, data) do 
-            expand_po(data)
-          end
-        when String
-          raise "can not expand s String(#{data})"
-        when Tuple, true
-          call_template_method do 
-            each do |c|
-              c.expand(data)
-            end
-          end
-        when Enumerable
-          data.each do |d|
-            expand(d)
-          end
-        else
-          call_template_method do 
-            expand_po(data)
-          end
-        end
-      end
-
-      def expand_po(data)
-        if data.kind_of?(Binding)
-          new_binding(data) do
-            each do |c|
-              c.expand(eval(c.name.to_s, data))
-            end
-          end
-        else
-          each do |c|
-            mid = c.name
-            begin
-              meth = data.method(mid)
-              case meth.arity 
-              when 0
-                c.expand(meth.call)
-              else
-                meth.call(@mod) 
-              end
-            rescue NameError
-              c.expand(data.send(mid))
-            end
-          end
-        end
-      end
-    end
-
-    class Root < Node # :nodoc:
-      def initialize(spec, pmod)
-        super(nil, spec, pmod)
-      end
-      
-      def expand_template(out,data)
-        new_context_data(data) do
-          case data
-          when Proc
-            data.call(@mod)
-          when Hash
-            @method.call(out) do
-              @children.each do |c|
-                k = c.name
-                d = (data[k] || data[k.to_s])
-                c.expand(d)
-              end
-            end
-          else
-            @method.call(out) do
-              expand_po(data)
-            end
-          end
-        end
-      end
-    end
-  end
-
-  module Extention # :nodoc:
-
-    module UseOriginalElement # :nodoc:
-      extend Core::SpecOptionMeta::CompilerOption
-      include Amrita2::Runtime
-
-      def self.check_option(spec, k, v)
-      end
-
-      def code_for_leaf_element(element, dyn_spec, cg, &block)
-        sym = dyn_spec.sym
-        cg.define_element_method(sym, dyn_spec.output_stream) do
-          cg.if_("block_given?") do
-            gen_element_with_attr(element, dyn_spec, cg)
-            cg.code("e.text = #{element.text.inspect}")
-            cg.code("get_mainstream << yield(e).to_s")
-            cg.else_ do
-              code_for_element_and_scalar(element, dyn_spec, cg)
-            end
-          end
-        end
-      end
-
-      def code_for_element_with_child(element, dyn_spec, cg)
-        cg.code("yield(#{dyn_spec.module_name})")
-        cg.if_("get_substream(:#{dyn_spec.output_stream}).size == 0") do
-          cg.generate_static_element_code(element, dyn_spec.option) do 
-            element.each_child do |e|
-              e.amrita_compile_main_code(cg)
-            end
-          end
-          cg.else_ do
-            cg.code("output_substream(:#{dyn_spec.name_for(element)})")
-            element.each_child do |e|
-              e.amrita_compile_main_code(cg)
-            end
-            cg.put_constant(end_tag(element))
-          end
-        end
-      end
-
-      def code_for_not_leaf_element(element, dyn_spec, cg, &block)
-        sym = dyn_spec.name_for(element)
-        cg.define_element_method(sym, dyn_spec.output_stream) do
-          code_for_element_with_child(element, dyn_spec, cg, &block)
-        end
-        
-        cg.define_module(dyn_spec.module_name) do
-          cg.code("Methods = #{dyn_spec.get_methods.inspect}")
-          cg.code("include Amrita2")
-          cg.code("extend Amrita2")
-          cg.define_method(sym, "val=nil", "attrs={}") do
-            cg.new_context("get_substream(:#{sym})") do
-              cg.code("e = yield(new_element(#{element.name.inspect}))") 
-              cg.code("get_mainstream << start_tag(e)")
-            end
-            yield
-          end
-          #cg.code("module_function :#{sym}")
-        end
-      end
-
-      Core::SpecOptionMeta::define_option(:use_original_element, self)
-      public
-      class Expander < Expander::Leaf # :nodoc:
-        def expand(data, i=nil)
-          case data
-          when Proc
-            @method.call do |e|
-              data.call(e)
-            end
-          else
-            super
-          end
-        end
-      end
-      public
-      def generate_expander(spec, mod, parent=nil)
-        Expander.new(parent, spec, mod)
-      end
-    end
-
-    module ExpandByMember # :nodoc:
-      extend Core::SpecOptionMeta::CompilerOption
-      def self.check_option(spec, k, v)
-      end
-
-      def code_for_not_leaf_element(element, dyn_spec, cg, &block)
-        sym = dyn_spec.name_for(element)
-        cg.define_element_method(sym, dyn_spec.output_stream) do
-          code_for_element_with_child(element, dyn_spec, cg, &block)
-        end
-        cg.define_module(dyn_spec.module_name) do
-          cg.code("Methods = #{dyn_spec.get_methods.inspect}")
-          cg.code("include Amrita2")
-          cg.code("extend Amrita2")
-          yield
-        end
-      end
-
-      def code_for_element_with_child(element, dyn_spec, cg)
-        cg.generate_static_element_code(element, dyn_spec.option) do 
-          cg.if_("block_given?") do
-            cg.code("yield(#{dyn_spec.module_name})")
-            cg.else_ do
-              dyn_spec.children.each do |c|
-                cg.code("#{dyn_spec.module_name}::#{c.sym}(val.#{c.sym})")
-              end
-            end
-          end
-          element.each_child do |e|
-            e.amrita_compile_main_code(cg)
-          end
-        end
-      end
-      Core::SpecOptionMeta::define_option(:expand_by_member, self)
-
-      class Expander < Expander::Node # :nodoc:
-        def expand(data, i=0)
-          if data.kind_of?(Enumerable)
-            data.each_with_index do |d, i|
-              expand(d, i)
-            end
-          else
-            @method.call(i) do 
-              each do |c|
-                dd = data.send(c.name)
-                c.expand(dd)
-              end
-            end
-          end
-        end
-      end
-
-      public
-      def generate_expander(spec, mod, parent=nil)
-        Expander.new(parent, spec, mod)
-      end
-    end
-
-    module EvalCDataAsErb # :nodoc:
-      include Core::SpecOptionMeta::InheritableOption
-      extend Core::SpecOptionMeta::CompilerOption
-      def self.check_option(spec, k, v)
-      end
-      def code_for_not_leaf_element(element, dyn_spec, cg, &block)
-        sym = dyn_spec.name_for(element)
-        cg.define_element_method(sym, dyn_spec.output_stream) do
-          cg.code('new_context_data(val) do')
-          cg.level_up do
-            cg.eval_cdata_as_erb = dyn_spec.option[:eval_cdata_as_erb]
-            code_for_element_with_child(element, dyn_spec, cg, &block)
-          end
-          cg.code('end')
-        end
-        cg.define_module(dyn_spec.module_name) do
-          cg.code("Methods = #{dyn_spec.get_methods.inspect}")
-          cg.code("include Amrita2")
-          cg.code("extend Amrita2")
-          yield
-        end
-      end
-      Core::SpecOptionMeta::define_option(:eval_cdata_as_erb, self)
-    end
-
-    module UseArgs # :nodoc:
-      extend Core::SpecOptionMeta::CompilerOption
-      def self.check_option(spec, k, v)
-      end
-
-      def code_for_leaf_element(element, dyn_spec, cg, &block)
-        cg.code('include Amrita2::Runtime')
-        sym = dyn_spec.sym
-        cg.define_method(sym, "*args", "&block") do
-          cg.new_context("get_substream(:#{dyn_spec.output_stream})") do
-            complie_for_args(element, cg, dyn_spec.option[:delete_id])
-          end
-        end
-        #cg.code("module_function :#{sym}")
-      end
-
-      private
-
-      def complie_for_args(element, cg, delete_id)
-        replace_args(element)
-        #cg.code("get_mainstream << \"#{element.to_s}\"")
-        s = ""
-        element.write(s, -1, false, cg.ie_hack)
-        cg.code("get_mainstream << \"#{s}\"")
-      end
-
-      def replace_args(element)
-        element.delete_attribute('id')
-        element.attributes.each do|k,v|
-          replace_attr_args(v)
-        end
-        element.each_child do |c|
-          case c
-          when REXML::Text
-            c.value = replace_text_args(c.value) if c.value
-          when REXML::Element
-            replace_args(c)
-          end
-        end
-      end
-
-      def replace_attr_args(s)
-        s.gsub!(/\$(\d)/) do |ss|
-          case $1
-          when "0"
-            '#{block.call.amrita_sanitize_as_attribute if block}'
-          else
-            '#{args[' + ($1.to_i-1).to_s + '].amrita_sanitize_as_attribute}'
-          end
-        end
-      end
-
-      def replace_text_args(s)
-        s.gsub(/\$(\d)/) do |ss|
-          case $1
-          when "0"
-            '#{block.call.amrita_sanitize if block}'
-          else
-            '#{args[' + ($1.to_i-1).to_s + '].amrita_sanitize}'
-          end
-        end
-      end
-
-      Core::SpecOptionMeta::define_option(:use_args, self)
-      public
-    end
-
-    module EnumerateChildren # :nodoc:
-      extend Core::SpecOptionMeta::CompilerOption
-      def self.check_option(spec, k, v)
-      end
-
-      def compile_main(element, dyn_spec, cg, &block)
-        cg.code('#compile_main')
-        sym = element.amrita_spec.sym
-        cg.generate_static_element_code(element, dyn_spec.option) do 
-          compile_main_code(element, dyn_spec, cg, sym.to_s, &block)
-        end
-      end
-
-      def code_for_element_and_scalar(element, dyn_spec, cg)
-        cg.put_expression("val.amrita_sanitize")
-      end
-
-      def code_for_element_with_child(element, dyn_spec, cg)
-        yield_block(cg, dyn_spec)
-        element.each_child do |e|
-          e.amrita_compile_main_code(cg)
-        end
-      end
-
-      Core::SpecOptionMeta::define_option(:enumerate_chidren, self)
-    end
-
-
-    module ValueAttr # :nodoc:
-      extend Core::SpecOptionMeta::CompilerOption
-      def self.check_option(spec, k, v)
-      end
-
-      def code_for_leaf_element(element, dyn_spec, cg, &block)
-        cg.code('include Amrita2::Runtime')
-        sym = dyn_spec.sym
-        cg.define_element_method(sym, dyn_spec.output_stream) do
-          complie_for_single(element, dyn_spec, cg, dyn_spec.option[:value_attr])
-        end
-      end
-
-      def generate_expander(spec, mod, parent=nil)
-        ret = super
-        def ret.expand(data)
-          case data
-          when false, nil, "false"
-            @method.call(nil)
-          else
-            super
-          end
-        end
-        ret
-      end
-
-      private
-
-      def complie_for_single(element, dyn_spec, cg, value_attr)
-        gen_element_with_attr(element, dyn_spec, cg)
-        cg.code("e.attributes['#{value_attr}'] = val")
-        cg.code("e.text = #{element.text.inspect}") if element.text
-        cg.code("get_mainstream << e.to_s")
-      end
-
-      Core::SpecOptionMeta::define_option(:value_attr, self)
-    end
-
-    module LinkAttr # :nodoc:
-      extend Core::SpecOptionMeta::CompilerOption
-      def self.check_option(spec, k, v)
-      end
-
-      def code_for_leaf_element(element, dyn_spec, cg, &block)
-        cg.code('include Amrita2::Runtime')
-        sym = dyn_spec.sym
-        cg.define_method(sym, "href", "val=nil", "attrs={}") do 
-          cg.if_("val.kind_of?(Hash)") do
-            cg.code("attrs = val")
-            cg.code("val = nil")
-          end
-          cg.new_context("get_substream(:#{dyn_spec.output_stream})") do
-            complie_for_link(element, dyn_spec, cg, dyn_spec.option[:link_attr])
-          end
-        end
-      end
-
-      private
-
-      def complie_for_link(element, dyn_spec, cg, link_attr)
-        href, checks = *link_attr
-        gen_element_with_attr(element, dyn_spec, cg)
-        checks.each do |r|
-          cg.code("href = '' if #{r.inspect} =~ href")
-        end
-        cg.code("e.attributes['#{href}'] = href if href")
-        cg.code("e.delete_attribute('#{dyn_spec.option[:key_attr_name]}')") if dyn_spec.option[:delete_id]
-        cg.code("e.text = (val || #{element.text.inspect}) ")
-        cg.code("get_mainstream << e.to_s")
-      end
-
-      Core::SpecOptionMeta::define_option(:link_attr, self)
-      class LinkExpander < Expander::Leaf
-        def expand(data, i=nil)
-          case data
-          when Array
-            case data.first
-            when Array, AttrArray, Hash
-              data.each do |d|
-                expand(d)
-              end
-            else
-              @method.call(*data)
-            end
-          else 
-            super
-          end
-        end
-      end
-
-      public
-      def generate_expander(spec, mod, parent=nil)
-        LinkExpander.new(parent, spec, mod)
-      end
-    end
-  end
-end