amrita2 1.9.6

data/lib/amrita2/core.rb

@@ -0,0 +1,1897 @@
+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