superfeedr-nokogiri 1.4.0.20091116183308

data/lib/nokogiri/xml/cdata.rb

@@ -0,0 +1,11 @@
+module Nokogiri
+  module XML
+    class CDATA < Nokogiri::XML::Text
+      ###
+      # Get the name of this CDATA node
+      def name
+        '#cdata-section'
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/character_data.rb

@@ -0,0 +1,7 @@
+module Nokogiri
+  module XML
+    class CharacterData < Nokogiri::XML::Node
+      include Nokogiri::XML::PP::CharacterData
+    end
+  end
+end

data/lib/nokogiri/xml/document.rb

@@ -0,0 +1,131 @@
+module Nokogiri
+  module XML
+    ####
+    # Nokogiri::XML::Document is the main entry point for dealing with
+    # XML documents.  The Document is created by parsing an XML document.
+    # See Nokogiri.XML()
+    #
+    # For searching a Document, see Nokogiri::XML::Node#css and
+    # Nokogiri::XML::Node#xpath
+    class Document < Node
+      ###
+      # Parse an XML file.  +thing+ may be a String, or any object that
+      # responds to _read_ and _close_ such as an IO, or StringIO.
+      # +url+ is resource where this document is located.  +encoding+ is the
+      # encoding that should be used when processing the document. +options+
+      # is a number that sets options in the parser, such as
+      # Nokogiri::XML::ParseOptions::RECOVER.  See the constants in
+      # Nokogiri::XML::ParseOptions.
+      def self.parse string_or_io, url = nil, encoding = nil, options = ParseOptions::DEFAULT_XML, &block
+
+        options = Nokogiri::XML::ParseOptions.new(options) if Fixnum === options
+        # Give the options to the user
+        yield options if block_given?
+
+        if string_or_io.respond_to?(:read)
+          url ||= string_or_io.respond_to?(:path) ? string_or_io.path : nil
+          return read_io(string_or_io, url, encoding, options.to_i)
+        end
+
+        # read_memory pukes on empty docs
+        return new if string_or_io.nil? or string_or_io.empty?
+
+        read_memory(string_or_io, url, encoding, options.to_i)
+      end
+
+      # A list of Nokogiri::XML::SyntaxError found when parsing a document
+      attr_accessor :errors
+
+      def initialize *args
+        @decorators = nil
+      end
+
+      # Create an element with +name+
+      def create_element name, &block
+        Nokogiri::XML::Element.new(name, self, &block)
+      end
+
+      # Create a text node with +text+
+      def create_text_node text, &block
+        Nokogiri::XML::Text.new(text.to_s, self, &block)
+      end
+
+      # The name of this document.  Always returns "document"
+      def name
+        'document'
+      end
+
+      # A reference to +self+
+      def document
+        self
+      end
+
+      # Get the list of decorators given +key+
+      def decorators key
+        @decorators ||= Hash.new
+        @decorators[key] ||= []
+      end
+
+      ###
+      # Validate this Document against it's DTD.  Returns a list of errors on
+      # the document or +nil+ when there is no DTD.
+      def validate
+        return nil unless internal_subset
+        internal_subset.validate self
+      end
+
+      ###
+      # Explore a document with shortcut methods.
+      def slop!
+        unless decorators(XML::Node).include? Nokogiri::Decorators::Slop
+          decorators(XML::Node) << Nokogiri::Decorators::Slop
+          decorate!
+        end
+
+        self
+      end
+
+      ###
+      # Apply any decorators to +node+
+      def decorate node
+        return unless @decorators
+        @decorators.each { |klass,list|
+          next unless node.is_a?(klass)
+          list.each { |moodule| node.extend(moodule) }
+        }
+      end
+
+      alias :to_xml :serialize
+      alias :clone :dup
+
+      # Get the hash of namespaces on the root Nokogiri::XML::Node
+      def namespaces
+        root ? root.namespaces : {}
+      end
+
+      ####
+      # Create a Nokogiri::XML::DocumentFragment from +tags+
+      # Returns an empty fragment if +tags+ is nil.
+      def fragment tags = nil
+        DocumentFragment.new(self, tags)
+      end
+
+      undef_method :swap, :parent, :namespace, :default_namespace=
+      undef_method :add_namespace_definition, :attributes
+      undef_method :namespace_definitions, :line
+
+      def add_child child
+        if [Node::ELEMENT_NODE, Node::DOCUMENT_FRAG_NODE].include? child.type
+          raise "Document already has a root node" if root
+        end
+        super
+      end
+      alias :<< :add_child
+
+      private
+      def inspect_attributes
+        [:name, :children]
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/document_fragment.rb

@@ -0,0 +1,69 @@
+module Nokogiri
+  module XML
+    class DocumentFragment < Nokogiri::XML::Node
+      def initialize document, tags=nil
+        if tags
+          if self.kind_of?(Nokogiri::HTML::DocumentFragment)
+            HTML::SAX::Parser.new(FragmentHandler.new(self, tags)).parse(tags)
+          else
+            wrapped = "<div>#{tags.strip}</div>"
+            XML::SAX::Parser.new(FragmentHandler.new(self, wrapped)).parse(wrapped)
+            div = self.child
+            div.children.each { |child| child.parent = self }
+            div.unlink
+          end
+        end
+      end
+
+      ###
+      # return the name for DocumentFragment
+      def name
+        '#document-fragment'
+      end
+
+      ###
+      # Convert this DocumentFragment to a string
+      def to_s
+        children.to_s
+      end
+
+      ###
+      # Convert this DocumentFragment to html
+      # See Nokogiri::XML::NodeSet#to_html
+      def to_html *args
+        children.to_html(*args)
+      end
+
+      ###
+      # Convert this DocumentFragment to xhtml
+      # See Nokogiri::XML::NodeSet#to_xhtml
+      def to_xhtml *args
+        children.to_xhtml(*args)
+      end
+
+      ###
+      # Convert this DocumentFragment to xml
+      # See Nokogiri::XML::NodeSet#to_xml
+      def to_xml *args
+        children.to_xml(*args)
+      end
+
+      ###
+      # Search this fragment.  See Nokogiri::XML::Node#css
+      def css *args
+        children.css(*args)
+      end
+
+      alias :serialize :to_s
+
+      class << self
+        ####
+        # Create a Nokogiri::XML::DocumentFragment from +tags+
+        def parse tags
+          self.new(XML::Document.new, tags)
+        end
+      end
+
+    end
+  end
+end

data/lib/nokogiri/xml/dtd.rb

@@ -0,0 +1,11 @@
+module Nokogiri
+  module XML
+    class DTD < Nokogiri::XML::Node
+      undef_method :attribute_nodes
+      undef_method :content
+      undef_method :namespace
+      undef_method :namespace_definitions
+      undef_method :line
+    end
+  end
+end

data/lib/nokogiri/xml/element_content.rb

@@ -0,0 +1,36 @@
+module Nokogiri
+  module XML
+    ###
+    # Represents the allowed content in an Element Declaration inside a DTD:
+    #
+    #   <?xml version="1.0"?><?TEST-STYLE PIDATA?>
+    #   <!DOCTYPE staff SYSTEM "staff.dtd" [
+    #      <!ELEMENT div1 (head, (p | list | note)*, div2*)>
+    #   ]>
+    #   </root>
+    #
+    # ElementContent represents the tree inside the <!ELEMENT> tag shown above
+    # that lists the possible content for the div1 tag.
+    class ElementContent
+      # Possible definitions of type
+      PCDATA  = 1
+      ELEMENT = 2
+      SEQ     = 3
+      OR      = 4
+
+      # Possible content occurrences
+      ONCE    = 1
+      OPT     = 2
+      MULT    = 3
+      PLUS    = 4
+
+      attr_reader :document
+
+      ###
+      # Get the children of this ElementContent node
+      def children
+        [c1, c2].compact
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/element_decl.rb

@@ -0,0 +1,13 @@
+module Nokogiri
+  module XML
+    class ElementDecl < Nokogiri::XML::Node
+      undef_method :namespace
+      undef_method :namespace_definitions
+      undef_method :line
+
+      def inspect
+        "#<#{self.class.name}:#{sprintf("0x%x", object_id)} #{to_s.inspect}>"
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/entity_decl.rb

@@ -0,0 +1,15 @@
+module Nokogiri
+  module XML
+    class EntityDecl < Nokogiri::XML::Node
+      undef_method :attribute_nodes
+      undef_method :attributes
+      undef_method :namespace
+      undef_method :namespace_definitions
+      undef_method :line
+
+      def inspect
+        "#<#{self.class.name}:#{sprintf("0x%x", object_id)} #{to_s.inspect}>"
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/fragment_handler.rb

@@ -0,0 +1,71 @@
+module Nokogiri
+  module XML
+    class FragmentHandler < Nokogiri::XML::SAX::Document # :nodoc:
+      QNAME_REGEX = /(.*):(.*)/
+
+      def initialize node, original_html
+        @doc_started    = false
+        @document       = node.document
+        @stack          = [node]
+        @html_eh        = node.kind_of? HTML::DocumentFragment
+
+        # the regexes used in start_element() and characters() anchor at
+        # start-of-line, but we really only want them to anchor at
+        # start-of-doc. so let's only save up to the first newline.
+        #
+        # this implementation choice was the result of some benchmarks, if
+        # you're curious: http://gist.github.com/115936
+        #
+        @original_html = original_html.lstrip
+        newline_index = @original_html.index("\n")
+        @original_html = @original_html[0,newline_index] if newline_index
+      end
+
+      def start_element name, attrs = []
+        regex = @html_eh ? %r{^\s*<#{Regexp.escape(name)}}i :
+                           %r{^\s*<#{Regexp.escape(name)}}
+
+        @doc_started = true if @original_html =~ regex
+        return unless @doc_started
+
+        if match = name.match(QNAME_REGEX)
+          prefix, name = match[1], match[2]
+          ns = @document.root.namespace_definitions.detect { |x|
+            x.prefix == prefix
+          }
+        else
+          ns = nil
+        end
+
+        node = Element.new(name, @document)
+        attrs << "" unless (attrs.length % 2) == 0
+        Hash[*attrs].each do |k,v|
+          node[k] = v
+        end
+
+        node.namespace = ns if ns
+
+        @stack.last << node
+        @stack << node
+      end
+
+      def characters string
+        @doc_started = true if @original_html.strip =~ %r{^\s*#{Regexp.escape(string.strip)}}
+        @stack.last << Text.new(string, @document)
+      end
+
+      def comment string
+        @stack.last << Comment.new(@document, string)
+      end
+
+      def cdata_block string
+        @stack.last << CDATA.new(@document, string)
+      end
+
+      def end_element name
+        return unless @stack.last.name == name
+        @stack.pop
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/namespace.rb

@@ -0,0 +1,13 @@
+module Nokogiri
+  module XML
+    class Namespace
+      include Nokogiri::XML::PP::Node
+      attr_reader :document
+
+      private
+      def inspect_attributes
+        [:prefix, :href]
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/node.rb

@@ -0,0 +1,665 @@
+require 'stringio'
+require 'nokogiri/xml/node/save_options'
+
+module Nokogiri
+  module XML
+    ####
+    # Nokogiri::XML::Node is your window to the fun filled world of dealing
+    # with XML and HTML tags.  A Nokogiri::XML::Node may be treated similarly
+    # to a hash with regard to attributes.  For example (from irb):
+    #
+    #   irb(main):004:0> node
+    #   => <a href="#foo" id="link">link</a>
+    #   irb(main):005:0> node['href']
+    #   => "#foo"
+    #   irb(main):006:0> node.keys
+    #   => ["href", "id"]
+    #   irb(main):007:0> node.values
+    #   => ["#foo", "link"]
+    #   irb(main):008:0> node['class'] = 'green'
+    #   => "green"
+    #   irb(main):009:0> node
+    #   => <a href="#foo" id="link" class="green">link</a>
+    #   irb(main):010:0>
+    #
+    # See Nokogiri::XML::Node#[] and Nokogiri::XML#[]= for more information.
+    #
+    # Nokogiri::XML::Node also has methods that let you move around your
+    # tree.  For navigating your tree, see:
+    #
+    # * Nokogiri::XML::Node#parent
+    # * Nokogiri::XML::Node#children
+    # * Nokogiri::XML::Node#next
+    # * Nokogiri::XML::Node#previous
+    #
+    # You may search this node's subtree using Node#xpath and Node#css
+    class Node
+      include Nokogiri::XML::PP::Node
+
+      # Element node type, see Nokogiri::XML::Node#element?
+      ELEMENT_NODE =       1
+      # Attribute node type
+      ATTRIBUTE_NODE =     2
+      # Text node type, see Nokogiri::XML::Node#text?
+      TEXT_NODE =          3
+      # CDATA node type, see Nokogiri::XML::Node#cdata?
+      CDATA_SECTION_NODE = 4
+      # Entity reference node type
+      ENTITY_REF_NODE =    5
+      # Entity node type
+      ENTITY_NODE =        6
+      # PI node type
+      PI_NODE =            7
+      # Comment node type, see Nokogiri::XML::Node#comment?
+      COMMENT_NODE =       8
+      # Document node type, see Nokogiri::XML::Node#xml?
+      DOCUMENT_NODE =      9
+      # Document type node type
+      DOCUMENT_TYPE_NODE = 10
+      # Document fragment node type
+      DOCUMENT_FRAG_NODE = 11
+      # Notation node type
+      NOTATION_NODE =      12
+      # HTML document node type, see Nokogiri::XML::Node#html?
+      HTML_DOCUMENT_NODE = 13
+      # DTD node type
+      DTD_NODE =           14
+      # Element declaration type
+      ELEMENT_DECL =       15
+      # Attribute declaration type
+      ATTRIBUTE_DECL =     16
+      # Entity declaration type
+      ENTITY_DECL =        17
+      # Namespace declaration type
+      NAMESPACE_DECL =     18
+      # XInclude start type
+      XINCLUDE_START =     19
+      # XInclude end type
+      XINCLUDE_END =       20
+      # DOCB document node type
+      DOCB_DOCUMENT_NODE = 21
+
+      def initialize name, document
+        # ... Ya.  This is empty on purpose.
+      end
+
+      ###
+      # Decorate this node with the decorators set up in this node's Document
+      def decorate!
+        document.decorate(self)
+      end
+
+      ###
+      # Search this node for +paths+.  +paths+ can be XPath or CSS, and an
+      # optional hash of namespaces may be appended.
+      # See Node#xpath and Node#css.
+      def search *paths
+        ns = paths.last.is_a?(Hash) ? paths.pop :
+          (document.root ? document.root.namespaces : {})
+        xpath(*(paths.map { |path|
+          path = path.to_s
+          path =~ /^(\.\/|\/)/ ? path : CSS.xpath_for(
+            path,
+            :prefix => ".//",
+            :ns     => ns
+          )
+        }.flatten.uniq) + [ns])
+      end
+      alias :/ :search
+
+      ###
+      # Search this node for XPath +paths+. +paths+ must be one or more XPath
+      # queries.  A hash of namespaces may be appended.  For example:
+      #
+      #   node.xpath('.//title')
+      #   node.xpath('.//foo:name', { 'foo' => 'http://example.org/' })
+      #   node.xpath('.//xmlns:name', node.root.namespaces)
+      #
+      # Custom XPath functions may also be defined.  To define custom functions
+      # create a class and implement the # function you want to define.
+      # For example:
+      #
+      #   node.xpath('.//title[regex(., "\w+")]', Class.new {
+      #     def regex node_set, regex
+      #       node_set.find_all { |node| node['some_attribute'] =~ /#{regex}/ }
+      #     end
+      #   }.new)
+      #
+      def xpath *paths
+        # Pop off our custom function handler if it exists
+        handler = ![
+          Hash, String, Symbol
+        ].include?(paths.last.class) ? paths.pop : nil
+
+        ns = paths.last.is_a?(Hash) ? paths.pop :
+          (document.root ? document.root.namespaces : {})
+
+        return NodeSet.new(document) unless document
+
+        sets = paths.map { |path|
+          ctx = XPathContext.new(self)
+          ctx.register_namespaces(ns)
+          set = ctx.evaluate(path, handler).node_set
+          set.document = document
+          document.decorate(set)
+          set
+        }
+        return sets.first if sets.length == 1
+
+        NodeSet.new(document) do |combined|
+          document.decorate(combined)
+          sets.each do |set|
+            set.each do |node|
+              combined << node
+            end
+          end
+        end
+      end
+
+      ###
+      # Search this node for CSS +rules+. +rules+ must be one or more CSS
+      # selectors.  For example:
+      #
+      #   node.css('title')
+      #   node.css('body h1.bold')
+      #   node.css('div + p.green', 'div#one')
+      #
+      # Custom CSS pseudo classes may also be defined.  To define custom pseudo
+      # classes, create a class and implement the custom pseudo class you
+      # want defined.  The first argument to the method will be the current
+      # matching NodeSet.  Any other arguments are ones that you pass in.
+      # For example:
+      #
+      #   node.css('title:regex("\w+")', Class.new {
+      #     def regex node_set, regex
+      #       node_set.find_all { |node| node['some_attribute'] =~ /#{regex}/ }
+      #     end
+      #   }.new)
+      #
+      def css *rules
+        # Pop off our custom function handler if it exists
+        handler = ![
+          Hash, String, Symbol
+        ].include?(rules.last.class) ? rules.pop : nil
+
+        ns = rules.last.is_a?(Hash) ? rules.pop :
+          (document.root ? document.root.namespaces : {})
+
+        rules = rules.map { |rule|
+          CSS.xpath_for(rule, :prefix => ".//", :ns => ns)
+        }.flatten.uniq + [ns, handler].compact
+
+        xpath(*rules)
+      end
+
+      ###
+      # Search for the first occurrence of +path+.
+      # Returns nil if nothing is found, otherwise a Node.
+      def at path, ns = document.root ? document.root.namespaces : {}
+        search(path, ns).first
+      end
+      alias :% :at
+
+      ##
+      # Search this node for the first occurrence of XPath +paths+.
+      # Equivalent to <tt>xpath(paths).first</tt>
+      # See Node#xpath for more information.
+      #
+      def at_xpath *paths
+        xpath(*paths).first
+      end
+
+      ##
+      # Search this node for the first occurrence of CSS +rules+.
+      # Equivalent to <tt>css(rules).first</tt>
+      # See Node#css for more information.
+      #
+      def at_css *rules
+        css(*rules).first
+      end
+
+      ###
+      # Get the attribute value for the attribute +name+
+      def [] name
+        return nil unless key?(name.to_s)
+        get(name.to_s)
+      end
+
+      alias :next           :next_sibling
+      alias :previous       :previous_sibling
+      alias :remove         :unlink
+      alias :get_attribute  :[]
+      alias :set_attribute  :[]=
+      alias :text           :content
+      alias :inner_text     :content
+      alias :has_attribute? :key?
+      alias :<<             :add_child
+      alias :name           :node_name
+      alias :name=          :node_name=
+      alias :type           :node_type
+      alias :to_str         :text
+      alias :clone          :dup
+
+      ####
+      # Returns a hash containing the node's attributes.  The key is the
+      # attribute name, the value is the string value of the attribute.
+      def attributes
+        Hash[*(attribute_nodes.map { |node|
+          [node.node_name, node]
+        }.flatten)]
+      end
+
+      ###
+      # Get the attribute values for this Node.
+      def values
+        attribute_nodes.map { |node| node.value }
+      end
+
+      ###
+      # Get the attribute names for this Node.
+      def keys
+        attribute_nodes.map { |node| node.node_name }
+      end
+
+      ###
+      # Iterate over each attribute name and value pair for this Node.
+      def each &block
+        attribute_nodes.each { |node|
+          block.call(node.node_name, node.value)
+        }
+      end
+
+      ###
+      # Remove the attribute named +name+
+      def remove_attribute name
+        attributes[name].remove if key? name
+      end
+      alias :delete :remove_attribute
+
+      ###
+      # Returns true if this Node matches +selector+
+      def matches? selector
+        document.search(selector).include?(self)
+      end
+
+      ####
+      # Create nodes from +data+ and insert them before this node
+      # (as a sibling).
+      def before data
+        fragment(data).children.each do |node|
+          add_previous_sibling node
+        end
+        self
+      end
+
+      ####
+      # Create nodes from +data+ and insert them after this node
+      # (as a sibling).
+      def after data
+        fragment(data).children.to_a.reverse.each do |node|
+          add_next_sibling node
+        end
+        self
+      end
+
+      ####
+      # Swap this Node for new nodes made from +data+
+      def swap data
+        before(data)
+        remove
+        self
+      end
+
+      ####
+      # Set the inner_html for this Node to +tags+
+      def inner_html= tags
+        children.each { |x| x.remove}
+
+        fragment(tags).children.to_a.each do |node|
+          add_child node
+        end
+        self
+      end
+
+      def fragment tags # :nodoc:
+        # TODO: deprecate?
+        document.fragment(tags)
+      end
+
+      ####
+      # Set the Node content to +string+.  The content gets XML escaped.
+      def content= string
+        self.native_content = encode_special_chars(string.to_s)
+      end
+
+      ###
+      # Set the parent Node for this Node
+      def parent= parent_node
+        parent_node.add_child(self)
+        parent_node
+      end
+
+      ###
+      # Get a hash containing the Namespace definitions for this Node
+      def namespaces
+        Hash[*namespace_definitions.map { |nd|
+          key = ['xmlns', nd.prefix].compact.join(':')
+          if RUBY_VERSION >= '1.9' && document.encoding
+            begin
+              key.force_encoding document.encoding
+            rescue ArgumentError
+            end
+          end
+          [key, nd.href]
+        }.flatten]
+      end
+
+      # Returns true if this is a Comment
+      def comment?
+        type == COMMENT_NODE
+      end
+
+      # Returns true if this is a CDATA
+      def cdata?
+        type == CDATA_SECTION_NODE
+      end
+
+      # Returns true if this is an XML::Document node
+      def xml?
+        type == DOCUMENT_NODE
+      end
+
+      # Returns true if this is an HTML::Document node
+      def html?
+        type == HTML_DOCUMENT_NODE
+      end
+
+      # Returns true if this is a Text node
+      def text?
+        type == TEXT_NODE
+      end
+
+      ###
+      # Fetch the Nokogiri::HTML::ElementDescription for this node.  Returns
+      # nil on XML documents and on unknown tags.
+      def description
+        return nil if document.xml?
+        Nokogiri::HTML::ElementDescription[name]
+      end
+
+      ###
+      # Is this a read only node?
+      def read_only?
+        # According to gdome2, these are read-only node types
+        [NOTATION_NODE, ENTITY_NODE, ENTITY_DECL].include?(type)
+      end
+
+      # Returns true if this is an Element node
+      def element?
+        type == ELEMENT_NODE
+      end
+      alias :elem? :element?
+
+      ###
+      # Turn this node in to a string.  If the document is HTML, this method
+      # returns html.  If the document is XML, this method returns XML.
+      def to_s
+        document.xml? ? to_xml : to_html
+      end
+
+      # Get the inner_html for this node's Node#children
+      def inner_html *args
+        children.map { |x| x.to_html(*args) }.join
+      end
+
+      # Get the path to this node as a CSS expression
+      def css_path
+        path.split(/\//).map { |part|
+          part.length == 0 ? nil : part.gsub(/\[(\d+)\]/, ':nth-of-type(\1)')
+        }.compact.join(' > ')
+      end
+
+      ###
+      # Get a list of ancestor Node for this Node.  If +selector+ is given,
+      # the ancestors must match +selector+
+      def ancestors selector = nil
+        return NodeSet.new(document) unless respond_to?(:parent)
+        return NodeSet.new(document) unless parent
+
+        parents = [parent]
+
+        while parents.last.respond_to?(:parent)
+          break unless ctx_parent = parents.last.parent
+          parents << ctx_parent
+        end
+
+        return NodeSet.new(document, parents) unless selector
+
+        NodeSet.new(document, parents.find_all { |parent|
+          parent.matches?(selector)
+        })
+      end
+
+      ###
+      # Set the default namespace for this node to +url+
+      def default_namespace= url
+        add_namespace_definition(nil, url)
+      end
+      alias :add_namespace :add_namespace_definition
+
+      ###
+      # Set the namespace for this node to +ns+
+      def namespace= ns
+        if ns.document != document
+          raise ArgumentError, 'namespace must be declared on the same document'
+        end
+        unless ns.is_a? Nokogiri::XML::Namespace
+          raise TypeError, "#{ns.class} can't be coerced into Nokogiri::XML::Namespace"
+        end
+        set_namespace ns
+      end
+
+      ####
+      # Yields self and all children to +block+ recursively.
+      def traverse &block
+        children.each{|j| j.traverse(&block) }
+        block.call(self)
+      end
+
+      ###
+      # Accept a visitor.  This method calls "visit" on +visitor+ with self.
+      def accept visitor
+        visitor.visit(self)
+      end
+
+      ####
+      # +replace+ this Node with the +new_node+ in the Document.  The new node
+      # must be a Nokogiri::XML::Node or a non-empty String
+      def replace new_node
+        if new_node.is_a?(Document) || !new_node.is_a?(XML::Node)
+          raise ArgumentError, <<-EOERR
+Node.replace requires a Node argument, and cannot accept a Document.
+(You probably want to select a node from the Document with at() or search(), or create a new Node via Node.new().)
+          EOERR
+        end
+        replace_with_node new_node
+      end
+
+      ###
+      # Test to see if this Node is equal to +other+
+      def == other
+        return false unless other
+        return false unless other.respond_to?(:pointer_id)
+        pointer_id == other.pointer_id
+      end
+
+      ###
+      # Serialize Node using +options+.  Save options can also be set using a
+      # block. See SaveOptions.
+      #
+      # These two statements are equivalent:
+      #
+      #  node.serialize(:encoding => 'UTF-8', :save_with => FORMAT | AS_XML)
+      #
+      # or
+      #
+      #   node.serialize(:encoding => 'UTF-8') do |config|
+      #     config.format.as_xml
+      #   end
+      #
+      def serialize *args, &block
+        options = args.first.is_a?(Hash) ? args.shift : {
+          :encoding   => args[0],
+          :save_with  => args[1] || SaveOptions::FORMAT
+        }
+
+        encoding = options[:encoding] || document.encoding
+
+        outstring = ""
+        if encoding && outstring.respond_to?(:force_encoding)
+          outstring.force_encoding(Encoding.find(encoding))
+        end
+        io = StringIO.new(outstring)
+        write_to io, options, &block
+        io.string
+      end
+
+      ###
+      # Serialize this Node to HTML
+      #
+      #   doc.to_html
+      #
+      # See Node#write_to for a list of +options+.  For formatted output,
+      # use Node#to_xhtml instead.
+      def to_html options = {}
+        # FIXME: this is a hack around broken libxml versions
+        return dump_html if %w[2 6] === LIBXML_VERSION.split('.')[0..1]
+
+        options[:save_with] ||= SaveOptions::FORMAT |
+                                SaveOptions::NO_DECLARATION |
+                                SaveOptions::NO_EMPTY_TAGS |
+                                SaveOptions::AS_HTML
+
+        serialize(options)
+      end
+
+      ###
+      # Serialize this Node to XML using +options+
+      #
+      #   doc.to_xml(:indent => 5, :encoding => 'UTF-8')
+      #
+      # See Node#write_to for a list of +options+
+      def to_xml options = {}
+        encoding = nil
+
+        options[:save_with] ||= SaveOptions::FORMAT | SaveOptions::AS_XML
+
+        serialize(options)
+      end
+
+      ###
+      # Serialize this Node to XHTML using +options+
+      #
+      #   doc.to_xhtml(:indent => 5, :encoding => 'UTF-8')
+      #
+      # See Node#write_to for a list of +options+
+      def to_xhtml options = {}
+        # FIXME: this is a hack around broken libxml versions
+        return dump_html if %w[2 6] === LIBXML_VERSION.split('.')[0..1]
+
+        options[:save_with] ||= SaveOptions::FORMAT |
+                                SaveOptions::NO_DECLARATION |
+                                SaveOptions::NO_EMPTY_TAGS |
+                                SaveOptions::AS_XHTML
+
+        serialize(options)
+      end
+
+      ###
+      # Write Node to +io+ with +options+. +options+ modify the output of
+      # this method.  Valid options are:
+      #
+      # * +:encoding+ for changing the encoding
+      # * +:indent_text+ the indentation text, defaults to one space
+      # * +:indent+ the number of +:indent_text+ to use, defaults to 2
+      # * +:save_with+ a combination of SaveOptions constants.
+      #
+      # To save with UTF-8 indented twice:
+      #
+      #   node.write_to(io, :encoding => 'UTF-8', :indent => 2)
+      #
+      # To save indented with two dashes:
+      #
+      #   node.write_to(io, :indent_text => '-', :indent => 2
+      #
+      def write_to io, *options
+        options       = options.first.is_a?(Hash) ? options.shift : {}
+        encoding      = options[:encoding] || options[0]
+        save_options  = options[:save_with] || options[1] || SaveOptions::FORMAT
+        indent_text   = options[:indent_text] || ' '
+        indent_times  = options[:indent] || 2
+
+
+        config = SaveOptions.new(save_options)
+        yield config if block_given?
+
+        native_write_to(io, encoding, indent_text * indent_times, config.options)
+      end
+
+      ###
+      # Write Node as HTML to +io+ with +options+
+      #
+      # See Node#write_to for a list of +options+
+      def write_html_to io, options = {}
+        # FIXME: this is a hack around broken libxml versions
+        return (io << dump_html) if %w[2 6] === LIBXML_VERSION.split('.')[0..1]
+
+        options[:save_with] ||= SaveOptions::FORMAT |
+          SaveOptions::NO_DECLARATION |
+          SaveOptions::NO_EMPTY_TAGS |
+          SaveOptions::AS_HTML
+        write_to io, options
+      end
+
+      ###
+      # Write Node as XHTML to +io+ with +options+
+      #
+      # See Node#write_to for a list of +options+
+      def write_xhtml_to io, options = {}
+        # FIXME: this is a hack around broken libxml versions
+        return (io << dump_html) if %w[2 6] === LIBXML_VERSION.split('.')[0..1]
+
+        options[:save_with] ||= SaveOptions::FORMAT |
+          SaveOptions::NO_DECLARATION |
+          SaveOptions::NO_EMPTY_TAGS |
+          SaveOptions::AS_XHTML
+        write_to io, options
+      end
+
+      ###
+      # Write Node as XML to +io+ with +options+
+      #
+      #   doc.write_xml_to io, :encoding => 'UTF-8'
+      #
+      # See Node#write_to for a list of options
+      def write_xml_to io, options = {}
+        options[:save_with] ||= SaveOptions::FORMAT | SaveOptions::AS_XML
+        write_to io, options
+      end
+
+      ###
+      # Compare two Node objects with respect to their Document.  Nodes from
+      # different documents cannot be compared.
+      def <=> other
+        return nil unless other.is_a?(Nokogiri::XML::Node)
+        return nil unless document == other.document
+        compare other
+      end
+
+      private
+      def inspect_attributes
+        [:name, :namespace, :attribute_nodes, :children]
+      end
+    end
+  end
+end