feedtools 0.2.26 → 0.2.27

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

@@ -1,48 +0,0 @@
-# :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

@@ -1,124 +0,0 @@
-# :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

@@ -1,207 +0,0 @@
-# :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

@@ -1,409 +0,0 @@
-# :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
-          # This line breaks in Rails 1.1.
-          #until matched_elem.equal? stack.last
-          until matched_elem.object_id == stack.last.object_id
-            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: