feedtools 0.1.0 → 0.2.0

data/lib/feed_tools/vendor/htree/modules.rb

@@ -0,0 +1,48 @@
+# :stopdoc:
+module HTree
+  class Name; include HTree end
+  class Context; include HTree end
+
+  module Tag; include HTree end
+    class STag; include Tag end
+    class ETag; include Tag end
+
+  module Node; include HTree end
+    module Container; include Node end
+      class Doc; include Container end
+      class Elem; include Container end
+    module Leaf; include Node end
+      class Text; include Leaf end
+      class XMLDecl; include Leaf end
+      class DocType; include Leaf end
+      class ProcIns; include Leaf end
+      class Comment; include Leaf end
+      class BogusETag; include Leaf end
+
+  module Traverse end
+  module Container::Trav; include Traverse end
+  module Leaf::Trav; include Traverse end
+  class Doc;       module Trav; include Container::Trav end; include Trav end
+  class Elem;      module Trav; include Container::Trav end; include Trav end
+  class Text;      module Trav; include Leaf::Trav      end; include Trav end
+  class XMLDecl;   module Trav; include Leaf::Trav      end; include Trav end
+  class DocType;   module Trav; include Leaf::Trav      end; include Trav end
+  class ProcIns;   module Trav; include Leaf::Trav      end; include Trav end
+  class Comment;   module Trav; include Leaf::Trav      end; include Trav end
+  class BogusETag; module Trav; include Leaf::Trav      end; include Trav end
+
+  class Location; include HTree end
+  module Container::Loc end
+  module Leaf::Loc end
+  class Doc;       class Loc < Location; include Trav, Container::Loc end end
+  class Elem;      class Loc < Location; include Trav, Container::Loc end end
+  class Text;      class Loc < Location; include Trav, Leaf::Loc      end end
+  class XMLDecl;   class Loc < Location; include Trav, Leaf::Loc      end end
+  class DocType;   class Loc < Location; include Trav, Leaf::Loc      end end
+  class ProcIns;   class Loc < Location; include Trav, Leaf::Loc      end end
+  class Comment;   class Loc < Location; include Trav, Leaf::Loc      end end
+  class BogusETag; class Loc < Location; include Trav, Leaf::Loc      end end
+
+  class Error < StandardError; end
+end
+# :startdoc:

data/lib/feed_tools/vendor/htree/name.rb

@@ -0,0 +1,124 @@
+# :stopdoc:
+require 'htree/scan' # for Pat::Nmtoken
+require 'htree/context'
+
+module HTree # :nodoc:
+  # Name represents a element name and attribute name.
+  # It consists of a namespace prefix, a namespace URI and a local name.
+  class Name # :nodoc:
+=begin
+element name                    prefix  uri     localname
+{u}n, n with xmlns=u            nil     'u'     'n'
+p{u}n, p:n with xmlns:p=u       'p'     'u'     'n'
+n with xmlns=''                 nil     ''      'n'
+
+attribute name
+xmlns=                          'xmlns' nil     nil
+xmlns:n=                        'xmlns' nil     'n'
+p{u}n=, p:n= with xmlns:p=u     'p'     'u'     'n'
+n=                              nil     ''      'n'
+=end
+    def Name.parse_element_name(name, context)
+      if /\{(.*)\}/ =~ name
+        # "{u}n" means "use default namespace",
+        # "p{u}n" means "use the specified prefix p"
+        $` == '' ? Name.new(nil, $1, $') : Name.new($`, $1, $')
+      elsif /:/ =~ name && !context.namespace_uri($`).empty?
+        Name.new($`, context.namespace_uri($`), $')
+      elsif !context.namespace_uri(nil).empty?
+        Name.new(nil, context.namespace_uri(nil), name)
+      else
+        Name.new(nil, '', name)
+      end
+    end
+
+    def Name.parse_attribute_name(name, context)
+      if name == 'xmlns'
+        Name.new('xmlns', nil, nil)
+      elsif /\Axmlns:/ =~ name
+        Name.new('xmlns', nil, $')
+      elsif /\{(.*)\}/ =~ name
+        case $`
+        when ''; Name.new(nil, $1, $')
+        else Name.new($`, $1, $')
+        end
+      elsif /:/ =~ name && !context.namespace_uri($`).empty?
+        Name.new($`, context.namespace_uri($`), $')
+      else
+        Name.new(nil, '', name)
+      end
+    end
+
+    NameCache = {}
+    def Name.new(namespace_prefix, namespace_uri, local_name)
+      key = [namespace_prefix, namespace_uri, local_name, self]
+      NameCache.fetch(key) {
+        0.upto(2) {|i| key[i] = key[i].dup.freeze if key[i] }
+        NameCache[key] = super(key[0], key[1], key[2])
+      }
+    end
+
+    def initialize(namespace_prefix, namespace_uri, local_name)
+      @namespace_prefix = namespace_prefix
+      @namespace_uri = namespace_uri
+      @local_name = local_name
+      if @namespace_prefix && /\A#{Pat::Nmtoken}\z/o !~ @namespace_prefix
+        raise HTree::Error, "invalid namespace prefix: #{@namespace_prefix.inspect}"
+      end
+      if @local_name && /\A#{Pat::Nmtoken}\z/o !~ @local_name
+        raise HTree::Error, "invalid local name: #{@local_name.inspect}"
+      end
+      if @namespace_prefix == 'xmlns'
+        unless @namespace_uri == nil
+          raise HTree::Error, "Name object for xmlns:* must not have namespace URI: #{@namespace_uri.inspect}"
+        end
+      else
+        unless String === @namespace_uri 
+          raise HTree::Error, "invalid namespace URI: #{@namespace_uri.inspect}"
+        end
+      end
+    end
+    attr_reader :namespace_prefix, :namespace_uri, :local_name
+
+    def xmlns?
+      @namespace_prefix == 'xmlns' && @namespace_uri == nil
+    end
+
+    def universal_name
+      if @namespace_uri && !@namespace_uri.empty?
+        "{#{@namespace_uri}}#{@local_name}"
+      else
+        @local_name.dup
+      end
+    end
+
+    def qualified_name
+      if @namespace_uri && !@namespace_uri.empty?
+        if @namespace_prefix
+          "#{@namespace_prefix}:#{@local_name}"
+        else
+          @local_name.dup
+        end
+      elsif @local_name
+        @local_name.dup
+      else
+        "xmlns"
+      end
+    end
+
+    def to_s
+      if @namespace_uri && !@namespace_uri.empty?
+        if @namespace_prefix
+          "#{@namespace_prefix}{#{@namespace_uri}}#{@local_name}"
+        else
+          "{#{@namespace_uri}}#{@local_name}"
+        end
+      elsif @local_name
+        @local_name.dup
+      else
+        "xmlns"
+      end
+    end
+  end
+end
+# :startdoc:

data/lib/feed_tools/vendor/htree/output.rb

@@ -0,0 +1,207 @@
+# :stopdoc:
+require 'htree/encoder'
+require 'htree/doc'
+require 'htree/elem'
+require 'htree/leaf'
+require 'htree/text'
+
+module HTree # :nodoc:
+
+  class Text # :nodoc:
+    ChRef = {
+      '>' => '>',
+      '<' => '&lt;',
+      '"' => '&quot;',
+    }
+
+    def output(out, context)
+      out.output_text @rcdata.gsub(/[<>]/) {|s| ChRef[s] }
+    end
+
+    def to_attvalue_content
+      @rcdata.gsub(/[<>"]/) {|s| ChRef[s] }
+    end
+
+    def output_attvalue(out, context)
+      out.output_string '"'
+      out.output_text to_attvalue_content
+      out.output_string '"'
+    end
+  end
+
+  class Name # :nodoc:
+    def output(out, context)
+      # xxx: validate namespace prefix
+      if xmlns?
+        if @local_name
+          out.output_string "xmlns:#{@local_name}"
+        else
+          out.output_string "xmlns"
+        end
+      else
+        out.output_string qualified_name
+      end
+    end
+
+    def output_attribute(text, out, context)
+      output(out, context)
+      out.output_string '='
+      text.output_attvalue(out, context)
+    end
+  end
+
+  class Doc # :nodoc:
+    def output(out, context)
+      context = DefaultContext # discard outer context
+      xmldecl = false
+      doctypedecl = false
+      @children.each {|n|
+        if n.respond_to? :output_prolog_xmldecl
+          n.output_prolog_xmldecl(out, context) unless xmldecl # xxx: encoding?
+          xmldecl = true
+        elsif n.respond_to? :output_prolog_doctypedecl
+          n.output_prolog_doctypedecl(out, context) unless doctypedecl
+          doctypedecl = true
+        else
+          n.output(out, context)
+        end
+      }
+    end
+  end
+
+  class Elem # :nodoc:
+    def output(out, context)
+      if @empty
+        @stag.output_emptytag(out, context)
+      else
+        children_context = @stag.output_stag(out, context)
+        @children.each {|n| n.output(out, children_context) }
+        @stag.output_etag(out, context)
+      end
+    end
+  end
+
+  class STag # :nodoc:
+    def output_attributes(out, context)
+      @attributes.each {|aname, text|
+        next if aname.xmlns?
+        out.output_string ' '
+        aname.output_attribute(text, out, context)
+      }
+      @context.output_namespaces(out, context)
+    end
+
+    def output_emptytag(out, context)
+      out.output_string '<'
+      @name.output(out, context)
+      children_context = output_attributes(out, context)
+      out.output_string "\n/>"
+      children_context
+    end
+
+    def output_stag(out, context)
+      out.output_string '<'
+      @name.output(out, context)
+      children_context = output_attributes(out, context)
+      out.output_string "\n>"
+      children_context
+    end
+
+    def output_etag(out, context)
+      out.output_string '</'
+      @name.output(out, context)
+      out.output_string "\n>"
+    end
+  end
+
+  class Context # :nodoc:
+    def output_namespaces(out, outer_context)
+      unknown_namespaces = {}
+      @namespaces.each {|prefix, uri|
+        outer_uri = outer_context.namespace_uri(prefix)
+        if outer_uri == nil
+          unknown_namespaces[prefix] = uri
+        elsif outer_uri != uri
+          if prefix
+            out.output_string " xmlns:#{prefix}="
+          else
+            out.output_string " xmlns="
+          end
+          Text.new(uri).output_attvalue(out, outer_context)
+        end
+      }
+      unless unknown_namespaces.empty?
+        out.output_xmlns(unknown_namespaces)
+      end
+      outer_context.subst_namespaces(@namespaces)
+    end
+  end
+
+  class BogusETag # :nodoc:
+    # don't output anything.
+    def output(out, context)
+    end
+  end
+
+  class XMLDecl # :nodoc:
+    # don't output anything.
+    def output(out, context)
+    end
+
+    def output_prolog_xmldecl(out, context)
+      out.output_string "<?xml version=\"#{@version}\""
+      if @encoding
+        out.output_string " encoding=\"#{@encoding}\""
+      end
+      if @standalone != nil
+        out.output_string " standalone=\"#{@standalone ? 'yes' : 'no'}\""
+      end
+      out.output_string "?>"
+    end
+  end
+
+  class DocType # :nodoc:
+    # don't output anything.
+    def output(out, context)
+    end
+
+    def generate_content # :nodoc:
+      result = ''
+      if @public_identifier
+        result << "PUBLIC \"#{@public_identifier}\""
+      else
+        result << "SYSTEM"
+      end
+      # Although a system identifier is not omissible in XML,
+      # we cannot output it if it is not given.
+      if @system_identifier
+        if /"/ !~ @system_identifier
+          result << " \"#{@system_identifier}\""
+        else
+          result << " '#{@system_identifier}'"
+        end
+      end
+      result
+    end
+
+    def output_prolog_doctypedecl(out, context)
+      out.output_string "<!DOCTYPE #{@root_element_name} #{generate_content}>"
+    end
+  end
+
+  class ProcIns # :nodoc:
+    def output(out, context)
+      out.output_string "<?#{@target}"
+      out.output_string " #{@content}" if @content
+      out.output_string "?>"
+    end
+  end
+
+  class Comment # :nodoc:
+    def output(out, context)
+      out.output_string "<!--#{@content}-->"
+    end
+  end
+
+end
+# :startdoc:

data/lib/feed_tools/vendor/htree/parse.rb

@@ -0,0 +1,407 @@
+# :stopdoc:
+require 'htree/scan'
+require 'htree/htmlinfo'
+require 'htree/text'
+require 'htree/tag'
+require 'htree/leaf'
+require 'htree/doc'
+require 'htree/elem'
+require 'htree/raw_string'
+require 'htree/context'
+require 'htree/encoder'
+require 'htree/fstr'
+
+module HTree # :nodoc:
+  # HTree.parse parses <i>input</i> and return a document tree.
+  # represented by HTree::Doc.
+  #
+  # <i>input</i> should be a String or
+  # an object which respond to read or open method.
+  # For example, IO, StringIO, Pathname, URI::HTTP and URI::FTP are acceptable.
+  # Note that the URIs need open-uri.
+  #
+  # HTree.parse guesses <i>input</i> is HTML or not and XML or not.
+  #
+  # If it is guessed as HTML, the default namespace in the result is set to http://www.w3.org/1999/xhtml
+  # regardless of <i>input</i> has XML namespace declaration or not nor even it is pre-XML HTML.
+  #
+  # If it is guessed as HTML and not XML, all element and attribute names are downcaseed. 
+  #
+  # If opened file or read content has charset method,
+  # HTree.parse decode it according to $KCODE before parsing.
+  # Otherwise HTree.parse assumes the character encoding of the content is
+  # compatible to $KCODE.
+  # Note that the charset method is provided by URI::HTTP with open-uri.
+  def HTree.parse(input)
+    HTree.with_frozen_string_hash {
+      parse_as(input, false)
+    }
+  end
+
+  # HTree.parse_xml parses <i>input</i> as XML and
+  # return a document tree represented by HTree::Doc.
+  #
+  # It behaves almost same as HTree.parse but it assumes <i>input</> is XML
+  # even if no XML declaration.
+  # The assumption causes following differences.
+  # * doesn't downcase element name.
+  # * The content of <script> and <style> element is PCDATA, not CDATA.
+  def HTree.parse_xml(input)
+    HTree.with_frozen_string_hash {
+      parse_as(input, true)
+    }
+  end
+
+  def HTree.parse_as(input, is_xml)
+    input_charset = nil
+    if input.tainted? && 1 <= $SAFE
+      raise SecurityError, "input tainted"
+    end
+    if input.respond_to? :read # IO, StringIO
+      input = input.read.untaint
+      input_charset = input.charset if input.respond_to? :charset
+    elsif input.respond_to? :open # Pathname, URI with open-uri
+      input.open {|f|
+        input = f.read.untaint
+        input_charset = f.charset if f.respond_to? :charset
+      }
+    end
+    if input_charset && input_charset != Encoder.internal_charset
+      input = Iconv.conv(Encoder.internal_charset, input_charset, input)
+    end
+
+    tokens = []
+    is_xml, is_html = HTree.scan(input, is_xml) {|token|
+      tokens << token
+    }
+    context = is_html ? HTMLContext: DefaultContext
+    structure_list = parse_pairs(tokens, is_xml, is_html)
+    structure_list = fix_structure_list(structure_list, is_xml, is_html)
+    nodes = structure_list.map {|s| build_node(s, is_xml, is_html, context) }
+    Doc.new(nodes)
+  end
+
+  def HTree.parse_pairs(tokens, is_xml, is_html)
+    stack = [[nil, nil, []]]
+    tokens.each {|token|
+      case token[0]
+      when :stag
+        stag_raw_string = token[1]
+        stagname = stag_raw_string[Pat::Name]
+        stagname = stagname.downcase if !is_xml && is_html
+        stagname = HTree.frozen_string(stagname)
+        stack << [stagname, stag_raw_string, []]
+      when :etag
+        etag_raw_string = token[1]
+        etagname = etag_raw_string[Pat::Name]
+        etagname = etagname.downcase if !is_xml && is_html
+        etagname = HTree.frozen_string(etagname)
+        matched_elem = nil
+        stack.reverse_each {|elem|
+          stagname, _, _ = elem
+          if stagname == etagname
+            matched_elem = elem
+            break
+          end
+        }
+        if matched_elem
+          until matched_elem.equal? stack.last
+            stagname, stag_raw_string, children = stack.pop
+            stack.last[2] << [:elem, stag_raw_string, children]
+          end
+          stagname, stag_raw_string, children = stack.pop
+          stack.last[2] << [:elem, stag_raw_string, children, etag_raw_string]
+        else
+          stack.last[2] << [:bogus_etag, etag_raw_string]
+        end
+      else
+        stack.last[2] << token
+      end
+    }
+    elem = nil
+    while 1 < stack.length
+      stagname, stag_raw_string, children = stack.pop
+      stack.last[2] << [:elem, stag_raw_string, children]
+    end
+    stack[0][2]
+  end
+
+  def HTree.fix_structure_list(structure_list, is_xml, is_html)
+    result = []
+    rest = structure_list.dup
+    until rest.empty?
+      structure = rest.shift
+      if structure[0] == :elem
+        elem, rest2 = fix_element(structure, [], [], is_xml, is_html)
+        result << elem
+        rest = rest2 + rest
+      else
+        result << structure
+      end
+    end
+    result
+  end
+
+  def HTree.fix_element(elem, excluded_tags, included_tags, is_xml, is_html)
+    stag_raw_string = elem[1]
+    children = elem[2]
+    if etag_raw_string = elem[3]
+      return [:elem, stag_raw_string, fix_structure_list(children, is_xml, is_html), etag_raw_string], []
+    else
+      tagname = stag_raw_string[Pat::Name]
+      tagname = tagname.downcase if !is_xml && is_html
+      if ElementContent[tagname] == :EMPTY
+        return [:elem, stag_raw_string, []], children
+      else
+        if ElementContent[tagname] == :CDATA
+          possible_tags = []
+        else
+          possible_tags = ElementContent[tagname]
+        end
+        if possible_tags
+          excluded_tags2 = ElementExclusions[tagname]
+          included_tags2 = ElementInclusions[tagname]
+          excluded_tags |= excluded_tags2 if excluded_tags2
+          included_tags |= included_tags2 if included_tags2
+          containable_tags = (possible_tags | included_tags) - excluded_tags
+          uncontainable_tags = ElementContent.keys - containable_tags
+        else
+          # If the tagname is unknown, it is assumed that any element
+          # except excluded can be contained.
+          uncontainable_tags = excluded_tags
+        end
+        fixed_children = []
+        rest = children
+        until rest.empty?
+          if rest[0][0] == :elem
+            elem = rest.shift
+            elem_tagname = elem[1][Pat::Name]
+            elem_tagname = elem_tagname.downcase if !is_xml && is_html
+            if uncontainable_tags.include? elem_tagname
+              rest.unshift elem
+              break
+            else
+              fixed_elem, rest2 = fix_element(elem, excluded_tags, included_tags, is_xml, is_html)
+              fixed_children << fixed_elem
+              rest = rest2 + rest
+            end
+          else
+            fixed_children << rest.shift
+          end
+        end
+        return [:elem, stag_raw_string, fixed_children], rest
+      end
+    end
+  end
+
+  def HTree.build_node(structure, is_xml, is_html, inherited_context=DefaultContext)
+    case structure[0]
+    when :text_pcdata
+      Text.parse_pcdata(structure[1])
+    when :elem
+      _, stag_rawstring, children, etag_rawstring = structure
+      etag = etag_rawstring && ETag.parse(etag_rawstring, is_xml, is_html)
+      stag = STag.parse(stag_rawstring, true, is_xml, is_html, inherited_context)
+      if !children.empty? || etag
+        Elem.new!(stag,
+                  children.map {|c| build_node(c, is_xml, is_html, stag.context) },
+                  etag)
+      else
+        Elem.new!(stag)
+      end
+    when :emptytag
+      Elem.new!(STag.parse(structure[1], false, is_xml, is_html, inherited_context))
+    when :bogus_etag
+      BogusETag.parse(structure[1], is_xml, is_html)
+    when :xmldecl
+      XMLDecl.parse(structure[1])
+    when :doctype
+      DocType.parse(structure[1], is_xml, is_html)
+    when :procins
+      ProcIns.parse(structure[1])
+    when :comment
+      Comment.parse(structure[1])
+    when :text_cdata_content
+      Text.parse_cdata_content(structure[1])
+    when :text_cdata_section
+      Text.parse_cdata_section(structure[1])
+    else
+      raise Exception, "[bug] unknown structure: #{structure.inspect}"
+    end
+  end
+
+  def STag.parse(raw_string, is_stag, is_xml, is_html, inherited_context=DefaultContext)
+    attrs = []
+    if (is_stag ? /\A#{Pat::ValidStartTag_C}\z/o : /\A#{Pat::ValidEmptyTag_C}\z/o) =~ raw_string
+      qname = $1
+      $2.scan(Pat::ValidAttr_C) {
+        attrs << ($5 ? [nil, $5] : [$1, $2 || $3 || $4])
+      }
+    elsif (is_stag ? /\A#{Pat::InvalidStartTag_C}\z/o : /\A#{Pat::InvalidEmptyTag_C}\z/o) =~ raw_string
+      qname = $1
+      last_attr = $3
+      $2.scan(Pat::InvalidAttr1_C) {
+        attrs << ($5 ? [nil, $5] : [$1, $2 || $3 || $4])
+      }
+      if last_attr
+        /#{Pat::InvalidAttr1End_C}/o =~ last_attr
+        attrs << [$1, $2 || $3]
+      end
+    else
+      raise HTree::Error, "cannot recognize as start tag or empty tag: #{raw_string.inspect}"
+    end
+
+    qname = qname.downcase if !is_xml && is_html
+
+    attrs.map! {|aname, aval|
+      if aname
+        aname = (!is_xml && is_html) ? aname.downcase : aname
+        [aname, Text.parse_pcdata(aval)]
+      else
+        if val2name = OmittedAttrName[qname]
+          aval_downcase = aval.downcase
+          aname = val2name.fetch(aval_downcase, aval_downcase)
+        else
+          aname = aval
+        end
+        [aname, Text.new(aval)]
+      end
+    }
+
+    result = STag.new(qname, attrs, inherited_context)
+    result.raw_string = raw_string
+    result
+  end
+
+  def ETag.parse(raw_string, is_xml, is_html)
+    unless /\A#{Pat::EndTag_C}\z/o =~ raw_string
+      raise HTree::Error, "cannot recognize as end tag: #{raw_string.inspect}"
+    end
+
+    qname = $1
+    qname = qname.downcase if !is_xml && is_html
+
+    result = self.new(qname)
+    result.raw_string = raw_string
+    result
+  end
+
+  def BogusETag.parse(raw_string, is_xml, is_html)
+    unless /\A#{Pat::EndTag_C}\z/o =~ raw_string
+      raise HTree::Error, "cannot recognize as end tag: #{raw_string.inspect}"
+    end
+
+    qname = $1
+    qname = qname.downcase if !is_xml && is_html
+
+    result = self.new(qname)
+    result.raw_string = raw_string
+    result
+  end
+
+  def Text.parse_pcdata(raw_string)
+    fixed = raw_string.gsub(/&(?:(?:#[0-9]+|#x[0-9a-fA-F]+|([A-Za-z][A-Za-z0-9]*));?)?/o) {|s|
+      name = $1
+      case s
+      when /;\z/
+        s
+      when /\A&#/
+        "#{s};"
+      when '&'
+        '&amp;'
+      else 
+        if NamedCharactersPattern =~ name
+          "&#{name};"
+        else
+          "&amp;#{name}"
+        end
+      end
+    }
+    fixed = raw_string if fixed == raw_string
+    result = Text.new_internal(fixed)
+    result.raw_string = raw_string
+    result
+  end
+
+  def Text.parse_cdata_content(raw_string)
+    result = Text.new(raw_string)
+    result.raw_string = raw_string
+    result
+  end
+
+  def Text.parse_cdata_section(raw_string)
+    unless /\A#{Pat::CDATA_C}\z/o =~ raw_string
+      raise HTree::Error, "cannot recognize as CDATA section: #{raw_string.inspect}"
+    end
+
+    content = $1
+
+    result = Text.new(content)
+    result.raw_string = raw_string
+    result
+  end
+
+  def XMLDecl.parse(raw_string)
+    unless /\A#{Pat::XmlDecl_C}\z/o =~ raw_string
+      raise HTree::Error, "cannot recognize as XML declaration: #{raw_string.inspect}"
+    end
+
+    version = $1 || $2
+    encoding = $3 || $4
+    case $5 || $6
+    when 'yes'
+      standalone = true
+    when 'no'
+      standalone = false
+    else
+      standalone = nil
+    end
+
+    result = XMLDecl.new(version, encoding, standalone)
+    result.raw_string = raw_string
+    result
+  end
+
+  def DocType.parse(raw_string, is_xml, is_html)
+    unless /\A#{Pat::DocType_C}\z/o =~ raw_string
+      raise HTree::Error, "cannot recognize as XML declaration: #{raw_string.inspect}"
+    end
+
+    root_element_name = $1
+    public_identifier = $2 || $3
+    system_identifier = $4 || $5
+
+    root_element_name = root_element_name.downcase if !is_xml && is_html
+
+    result = DocType.new(root_element_name, public_identifier, system_identifier)
+    result.raw_string = raw_string
+    result
+  end
+
+  def ProcIns.parse(raw_string)
+    unless /\A#{Pat::XmlProcIns_C}\z/o =~ raw_string
+      raise HTree::Error, "cannot recognize as processing instruction: #{raw_string.inspect}"
+    end
+
+    target = $1
+    content = $2
+
+    result = ProcIns.new(target, content)
+    result.raw_string = raw_string
+    result
+  end
+
+  def Comment.parse(raw_string)
+    unless /\A#{Pat::Comment_C}\z/o =~ raw_string
+      raise HTree::Error, "cannot recognize as comment: #{raw_string.inspect}"
+    end
+
+    content = $1
+
+    result = Comment.new(content)
+    result.raw_string = raw_string
+    result
+  end
+
+end
+# :startdoc: