rubyjedi-nokogiri_java 1.4.0.20100513161003-java

data/lib/nokogiri/ffi/xml/cdata.rb

@@ -0,0 +1,19 @@
+module Nokogiri
+  module XML
+    class CDATA < Text
+      
+      def self.new(document, content, *rest) # :nodoc:
+        length = content.nil? ? 0 : content.length
+        node_ptr = LibXML.xmlNewCDataBlock(document.cstruct[:doc], content, length)
+        node_cstruct = LibXML::XmlNode.new(node_ptr)
+        node_cstruct.keep_reference_from_document!
+
+        node = Node.wrap(node_cstruct, self)
+        node.send :initialize, document, content, *rest
+        yield node if block_given?
+        node
+      end
+
+    end
+  end
+end

data/lib/nokogiri/ffi/xml/comment.rb

@@ -0,0 +1,18 @@
+module Nokogiri
+  module XML
+    class Comment < CharacterData
+
+      def self.new(document, content, *rest) # :nodoc:
+        node_ptr = LibXML.xmlNewDocComment(document.cstruct, content)
+        node_cstruct = LibXML::XmlNode.new(node_ptr)
+        node_cstruct.keep_reference_from_document!
+
+        node = Node.wrap(node_ptr, self)
+        node.send :initialize, document, content, *rest
+        yield node if block_given?
+        node
+      end
+
+    end
+  end
+end

data/lib/nokogiri/ffi/xml/document.rb

@@ -0,0 +1,135 @@
+# :stopdoc:
+module Nokogiri
+  module XML
+    class Document < Node
+
+      attr_accessor :cstruct
+
+      def url
+        cstruct[:URL]
+      end
+
+      def root= new_root
+        old_root = nil
+        if new_root.cstruct[:doc] != cstruct[:doc]
+          old_root_ptr = LibXML.xmlDocGetRootElement(cstruct)
+          new_root_ptr = LibXML.xmlDocCopyNode(new_root.cstruct, cstruct, 1)
+          raise RuntimeError "Could not reparent node (xmlDocCopyNode)" if new_root_ptr.null?
+          new_root = Node.wrap(new_root_ptr)
+        end
+        LibXML.xmlDocSetRootElement(cstruct, new_root.cstruct)
+        if old_root_ptr && ! old_root_ptr.null?
+          LibXML::XmlNode.new(old_root_ptr).keep_reference_from_document!
+        end
+        new_root
+      end
+
+      def root
+        ptr = LibXML.xmlDocGetRootElement(cstruct)
+        ptr.null? ? nil : Node.wrap(LibXML::XmlNode.new(ptr))
+      end
+
+      def encoding= encoding
+        # TODO: if :encoding is already set, then it's probably getting leaked.
+        cstruct[:encoding] = LibXML.xmlStrdup(encoding)
+      end
+
+      def encoding
+        ptr = cstruct[:encoding]
+        ptr.null? ? nil : ptr.read_string
+      end
+
+      def version
+        cstruct[:version]
+      end
+
+      def self.read_io io, url, encoding, options
+        wrap_with_error_handling do
+          LibXML.xmlReadIO(IoCallbacks.reader(io), nil, nil, url, encoding, options)
+        end
+      end
+
+      def self.read_memory(string, url, encoding, options)
+        wrap_with_error_handling do
+          LibXML.xmlReadMemory(string, string.length, url, encoding, options)
+        end
+      end
+
+      def dup deep = 1
+        dup_ptr = LibXML.xmlCopyDoc(cstruct, deep)
+        return nil if dup_ptr.null?
+
+        # xmlCopyDoc does not preserve document type. wtf?
+        cstruct = LibXML::XmlDocumentCast.new(dup_ptr)
+        cstruct[:type] = self.type
+
+        self.class.wrap(dup_ptr)
+      end
+
+      def remove_namespaces!
+        self.class.recursively_remove_namespaces_from_node(root)
+      end
+
+      class << self
+        def new(*args)
+          version = args.first || "1.0"
+          doc = wrap(LibXML.xmlNewDoc(version))
+          doc.send :initialize, *args
+          doc
+        end
+
+        def wrap doc_struct
+          if doc_struct.is_a?(FFI::Pointer)
+            # cast native pointers up into a doc cstruct
+            return nil if doc_struct.null?
+            doc_struct = LibXML::XmlDocument.new(doc_struct)
+          end
+
+          doc                  = self.allocate
+          doc.cstruct          = doc_struct
+          doc.cstruct.ruby_doc = doc
+          doc.instance_eval { @decorators = nil; @node_cache = [] }
+          doc.send :initialize
+          doc
+        end
+      end
+
+      private
+
+      class << self
+        def wrap_with_error_handling(&block)
+          error_list = []
+          LibXML.xmlInitParser()
+          LibXML.xmlResetLastError()
+          LibXML.xmlSetStructuredErrorFunc(nil, SyntaxError.error_array_pusher(error_list))
+
+          ptr = yield
+
+          LibXML.xmlSetStructuredErrorFunc(nil, nil)
+
+          if ptr.null?
+            error = LibXML.xmlGetLastError()
+            if error
+              raise SyntaxError.wrap(error)
+            else
+              raise RuntimeError, "Could not parse document"
+            end
+          end
+
+          document = wrap(ptr)
+          document.errors = error_list
+          return document
+        end
+
+        def recursively_remove_namespaces_from_node(node)
+          node.cstruct[:ns] = nil
+          node.children.each do |child|
+            recursively_remove_namespaces_from_node(child)
+          end
+        end
+      end
+
+    end
+  end
+end
+# :startdoc:

data/lib/nokogiri/ffi/xml/document_fragment.rb

@@ -0,0 +1,21 @@
+module Nokogiri
+  module XML
+    class DocumentFragment < Node
+
+      def self.new(document, *rest) # :nodoc:
+        node_ptr = LibXML.xmlNewDocFragment(document.cstruct)
+        node_cstruct = LibXML::XmlNode.new(node_ptr)
+        node_cstruct.keep_reference_from_document!
+
+        node = Node.wrap(node_cstruct, self)
+
+        node.send :initialize, document, *rest
+        yield node if block_given?
+
+        node
+      end
+
+    end
+  end
+end
+

data/lib/nokogiri/ffi/xml/dtd.rb

@@ -0,0 +1,67 @@
+# :stopdoc:
+module Nokogiri
+  module XML
+    class DTD < Node
+      def validate document
+        error_list = []
+        ctxt = LibXML.xmlNewValidCtxt
+
+        LibXML.xmlSetStructuredErrorFunc(nil, SyntaxError.error_array_pusher(error_list))
+        LibXML.xmlValidateDtd ctxt, document.cstruct, cstruct
+
+        LibXML.xmlSetStructuredErrorFunc nil, nil
+
+        LibXML.xmlFreeValidCtxt ctxt
+
+        error_list
+      end
+
+      def system_id
+        cstruct[:system_id]
+      end
+
+      def external_id
+        cstruct[:external_id]
+      end
+
+      def elements
+        internal_attributes :elements
+      end
+
+      def entities
+        internal_attributes :entities
+      end
+
+      def attributes
+        internal_attributes :attributes
+      end
+
+      def notations
+        attr_ptr = cstruct[:notations]
+        return nil if attr_ptr.null?
+
+        ahash = {}
+        LibXML.xmlHashScan(attr_ptr, nil) do |payload, data, name|
+          notation_cstruct = LibXML::XmlNotation.new(payload)
+          ahash[name] = Notation.new(notation_cstruct[:name], notation_cstruct[:PublicID],
+                                     notation_cstruct[:SystemID])
+        end
+        ahash
+      end
+
+      private
+
+      def internal_attributes attr_name
+        attr_ptr = cstruct[attr_name.to_sym]
+        return nil if attr_ptr.null?
+
+        ahash = {}
+        LibXML.xmlHashScan(attr_ptr, nil) do |payload, data, name|
+          ahash[name] = Node.wrap(payload)
+        end
+        ahash
+      end
+    end
+  end
+end
+# :startdoc:

data/lib/nokogiri/ffi/xml/element_content.rb

@@ -0,0 +1,43 @@
+# :stopdoc:
+module Nokogiri
+  module XML
+    class ElementContent
+      attr_accessor :cstruct
+
+      def self.wrap pointer, document
+        return nil if pointer.null?
+
+        c = ElementContent.allocate
+        c.cstruct = LibXML::XmlElementContent.new pointer
+        c.instance_variable_set :@document, document
+        c
+      end
+
+      def type
+        cstruct[:type]
+      end
+
+      def prefix
+        cstruct[:prefix]
+      end
+
+      def occur
+        cstruct[:ocur]
+      end
+
+      def name
+        cstruct[:name]
+      end
+
+      private
+      def c1
+        self.class.wrap cstruct[:c1], document
+      end
+
+      def c2
+        self.class.wrap cstruct[:c2], document
+      end
+    end
+  end
+end
+# :startdoc:

data/lib/nokogiri/ffi/xml/element_decl.rb

@@ -0,0 +1,19 @@
+# :stopdoc:
+module Nokogiri
+  module XML
+    class ElementDecl < Nokogiri::XML::Node
+      def element_type
+        cstruct[:etype]
+      end
+
+      def prefix
+        cstruct[:prefix]
+      end
+
+      def content
+        ElementContent.wrap cstruct[:content], document
+      end
+    end
+  end
+end
+# :startdoc:

data/lib/nokogiri/ffi/xml/entity_decl.rb

@@ -0,0 +1,27 @@
+# :stopdoc:
+module Nokogiri
+  module XML
+    class EntityDecl < Nokogiri::XML::Node
+      def content
+        cstruct[:content]
+      end
+
+      def entity_type
+        cstruct[:etype]
+      end
+
+      def external_id
+        cstruct[:external_id]
+      end
+
+      def system_id
+        cstruct[:system_id]
+      end
+
+      def original_content
+        cstruct[:orig]
+      end
+    end
+  end
+end
+# :startdoc:

data/lib/nokogiri/ffi/xml/entity_reference.rb

@@ -0,0 +1,19 @@
+module Nokogiri
+  module XML
+    class EntityReference < Node
+
+      def self.new(document, name, *rest) # :nodoc:
+        node_ptr = LibXML.xmlNewReference(document.cstruct, name)
+        node_cstruct = LibXML::XmlNode.new(node_ptr)
+        node_cstruct.keep_reference_from_document!
+
+        node = Node.wrap(node_cstruct, self)
+        node.send :initialize, document, name, *rest
+        yield node if block_given?
+        node
+      end
+
+    end
+  end
+end
+

data/lib/nokogiri/ffi/xml/namespace.rb

@@ -0,0 +1,44 @@
+module Nokogiri
+  module XML
+    class Namespace
+      # :stopdoc:
+
+      attr_accessor :cstruct
+      attr_accessor :document
+
+      def prefix
+        cstruct[:prefix].nil? ? nil : cstruct[:prefix] # TODO: encoding?
+      end
+
+      def href
+        cstruct[:href].nil? ? nil : cstruct[:href] # TODO: encoding?
+      end
+
+      class << self
+        def wrap(document, node_struct)
+          if node_struct.is_a?(FFI::Pointer)
+            # cast native pointers up into a node cstruct
+            return nil if node_struct.null?
+            node_struct = LibXML::XmlNs.new(node_struct) 
+          end
+
+          ruby_node = node_struct.ruby_node
+          return ruby_node unless ruby_node.nil?
+
+          ns = Nokogiri::XML::Namespace.allocate
+          ns.document = document.ruby_doc
+          ns.cstruct = node_struct
+
+          ns.cstruct.ruby_node = ns
+
+          cache = ns.document.instance_variable_get(:@node_cache)
+          cache << ns
+
+          ns
+        end
+      end
+
+      # :startdoc:
+    end
+  end
+end

data/lib/nokogiri/ffi/xml/node.rb

@@ -0,0 +1,465 @@
+module Nokogiri
+  module XML
+    class Node
+      # :stopdoc:
+
+      attr_accessor :cstruct
+
+      def pointer_id
+        cstruct.pointer
+      end
+
+      def encode_special_chars(string)
+        char_ptr = LibXML.xmlEncodeSpecialChars(self[:doc], string)
+        encoded = char_ptr.read_string
+        # TODO: encoding?
+        LibXML.xmlFree(char_ptr)
+        encoded
+      end
+
+      def internal_subset
+        doc = cstruct.document
+        dtd = LibXML.xmlGetIntSubset(doc)
+        return nil if dtd.null?
+        Node.wrap(dtd)
+      end
+
+      def external_subset
+        doc = cstruct.document
+        return nil if doc[:extSubset].null?
+
+        Node.wrap(doc[:extSubset])
+      end
+
+      def create_internal_subset name, external_id, system_id
+        raise("Document already has an internal subset") if internal_subset
+
+        doc = cstruct.document
+        dtd_ptr = LibXML.xmlCreateIntSubset doc, name, external_id, system_id
+
+        return nil if dtd_ptr.null?
+
+        Node.wrap dtd_ptr
+      end
+
+      def create_external_subset name, external_id, system_id
+        raise("Document already has an external subset") if external_subset
+
+        doc = cstruct.document
+        dtd_ptr = LibXML.xmlNewDtd doc, name, external_id, system_id
+
+        return nil if dtd_ptr.null?
+
+        Node.wrap dtd_ptr
+      end
+
+      def dup(deep = 1)
+        dup_ptr = LibXML.xmlDocCopyNode(cstruct, cstruct.document, deep)
+        return nil if dup_ptr.null?
+        Node.wrap(dup_ptr, self.class)
+      end
+
+      def unlink
+        LibXML.xmlUnlinkNode(cstruct)
+        cstruct.keep_reference_from_document!
+        self
+      end
+
+      def blank?
+        LibXML.xmlIsBlankNode(cstruct) == 1
+      end
+
+      def next_sibling
+        cstruct_node_from :next
+      end
+
+      def previous_sibling
+        cstruct_node_from :prev
+      end
+
+      def next_element
+        sibling_ptr = cstruct[:next]
+
+        while ! sibling_ptr.null?
+          sibling_cstruct = LibXML::XmlNode.new(sibling_ptr)
+          break if sibling_cstruct[:type] == ELEMENT_NODE
+          sibling_ptr = sibling_cstruct[:next]
+        end
+
+        return sibling_ptr.null? ? nil : Node.wrap(sibling_ptr)
+      end
+
+      def previous_element
+        sibling_ptr = cstruct[:prev]
+
+        while ! sibling_ptr.null?
+          sibling_cstruct = LibXML::XmlNode.new(sibling_ptr)
+          break if sibling_cstruct[:type] == ELEMENT_NODE
+          sibling_ptr = sibling_cstruct[:prev]
+        end
+
+        return sibling_ptr.null? ? nil : Node.wrap(sibling_ptr)
+      end
+
+      def replace_node new_node
+        Node.reparent_node_with(new_node, self) do |new_node_cstruct, self_cstruct|
+          retval = LibXML.xmlReplaceNode(self_cstruct, new_node_cstruct)
+          if retval == self_cstruct.pointer
+            new_node_cstruct # for reparent_node_with semantics
+          else
+            retval
+          end
+        end
+        self
+      end
+
+      def children
+        return NodeSet.new(nil) if cstruct[:children].null?
+        child = Node.wrap(cstruct[:children])
+
+        set = NodeSet.new child.document
+        set_ptr = LibXML.xmlXPathNodeSetCreate(child.cstruct)
+
+        set.cstruct = LibXML::XmlNodeSet.new(set_ptr)
+        return set unless child
+
+        child_ptr = child.cstruct[:next]
+        while ! child_ptr.null?
+          child = Node.wrap(child_ptr)
+          LibXML.xmlXPathNodeSetAdd(set.cstruct, child.cstruct)
+          child_ptr = child.cstruct[:next]
+        end
+
+        return set
+      end
+
+      def child
+        (val = cstruct[:children]).null? ? nil : Node.wrap(val)
+      end
+
+      def key?(attribute)
+        ! (prop = LibXML.xmlHasProp(cstruct, attribute.to_s)).null?
+      end
+
+      def namespaced_key?(attribute, namespace)
+        prop = LibXML.xmlHasNsProp(cstruct, attribute.to_s,
+          namespace.nil? ? nil : namespace.to_s)
+        !prop.null?
+      end
+
+      def []=(property, value)
+        LibXML.xmlSetProp(cstruct, property, value)
+        value
+      end
+
+      def get(attribute)
+        return nil unless attribute
+        propstr = LibXML.xmlGetProp(cstruct, attribute.to_s)
+        return nil if propstr.null?
+        rval = propstr.read_string # TODO: encoding?
+        LibXML.xmlFree(propstr)
+        rval
+      end
+
+      def set_namespace(namespace)
+        LibXML.xmlSetNs(cstruct, namespace.cstruct)
+        self
+      end
+
+      def attribute(name)
+        attribute_nodes.find { |x| x.name == name }
+      end
+
+      def attribute_with_ns(name, namespace)
+        prop = LibXML.xmlHasNsProp(cstruct, name.to_s,
+          namespace.nil? ? NULL : namespace.to_s)
+        return prop if prop.null?
+        Node.wrap(prop)
+      end
+
+      def attribute_nodes
+        Node.node_properties cstruct
+      end
+
+      def namespace
+        cstruct[:ns].null? ? nil : Namespace.wrap(cstruct.document, cstruct[:ns])
+      end
+
+      def namespace_definitions
+        list = []
+        ns_ptr = cstruct[:nsDef]
+        return list if ns_ptr.null?
+        while ! ns_ptr.null?
+          ns = Namespace.wrap(cstruct.document, ns_ptr)
+          list << ns
+          ns_ptr = ns.cstruct[:next]
+        end
+        list
+      end
+
+      def node_type
+        cstruct[:type]
+      end
+
+      def native_content=(content)
+        LibXML.xmlNodeSetContent(cstruct, content)
+        content
+      end
+
+      def content
+        content_ptr = LibXML.xmlNodeGetContent(cstruct)
+        return nil if content_ptr.null?
+        content = content_ptr.read_string # TODO: encoding?
+        LibXML.xmlFree(content_ptr)
+        content
+      end
+
+      def add_child_node child
+        Node.reparent_node_with(child, self) do |child_cstruct, my_cstruct|
+          LibXML.xmlAddChild(my_cstruct, child_cstruct)
+        end
+      end
+
+      def parent
+        cstruct_node_from :parent
+      end
+
+      def node_name=(string)
+        LibXML.xmlNodeSetName(cstruct, string)
+        string
+      end
+
+      def node_name
+        cstruct[:name] # TODO: encoding?
+      end
+
+      def path
+        path_ptr = LibXML.xmlGetNodePath(cstruct)
+        val = path_ptr.null? ? nil : path_ptr.read_string # TODO: encoding?
+        LibXML.xmlFree(path_ptr)
+        val
+      end
+
+      def add_next_sibling_node next_sibling
+        Node.reparent_node_with(next_sibling, self) do |sibling_cstruct, my_cstruct|
+          LibXML.xmlAddNextSibling(my_cstruct, sibling_cstruct)
+        end
+      end
+
+      def add_previous_sibling_node prev_sibling
+        Node.reparent_node_with(prev_sibling, self) do |sibling_cstruct, my_cstruct|
+          LibXML.xmlAddPrevSibling(my_cstruct, sibling_cstruct)
+        end
+      end
+
+      def native_write_to(io, encoding, indent_string, options)
+        set_xml_indent_tree_output 1
+        set_xml_tree_indent_string indent_string
+        savectx = LibXML.xmlSaveToIO(IoCallbacks.writer(io), nil, nil, encoding, options)
+        LibXML.xmlSaveTree(savectx, cstruct)
+        LibXML.xmlSaveClose(savectx)
+        io
+      end
+
+      def line
+        cstruct[:line]
+      end
+
+      def add_namespace_definition(prefix, href)
+        ns = LibXML.xmlNewNs(cstruct, href, prefix)
+        if ns.null?
+          ns = LibXML.xmlSearchNs(cstruct.document, cstruct,
+            prefix.nil? ? nil : prefix.to_s)
+        end
+        LibXML.xmlSetNs(cstruct, ns) if prefix.nil?
+        Namespace.wrap(cstruct.document, ns)
+      end
+
+      def self.new(name, doc, *rest)
+        ptr = LibXML.xmlNewNode(nil, name.to_s)
+
+        node_cstruct = LibXML::XmlNode.new(ptr)
+        node_cstruct[:doc] = doc.cstruct[:doc]
+        node_cstruct.keep_reference_from_document!
+
+        node = Node.wrap(
+          node_cstruct,
+          Node == self ? nil : self
+        )
+        node.send :initialize, name, doc, *rest
+        yield node if block_given?
+        node
+      end
+
+      def dump_html
+        return to_xml if type == DOCUMENT_NODE
+        buffer = LibXML::XmlBuffer.new(LibXML.xmlBufferCreate())
+        LibXML.htmlNodeDump(buffer, cstruct[:doc], cstruct)
+        buffer[:content] # TODO: encoding?
+      end
+
+      def compare(other)
+        LibXML.xmlXPathCmpNodes(other.cstruct, self.cstruct)
+      end
+
+      def self.wrap(node_struct, klass=nil)
+        if node_struct.is_a?(FFI::Pointer)
+          # cast native pointers up into a node cstruct
+          return nil if node_struct.null?
+          node_struct = LibXML::XmlNode.new(node_struct)
+        end
+
+        raise "wrapping a node without a document" unless node_struct.document
+
+        document_struct = node_struct.document
+        document_obj = document_struct.nil? ? nil : document_struct.ruby_doc
+        if node_struct[:type] == DOCUMENT_NODE || node_struct[:type] == HTML_DOCUMENT_NODE
+          return document_obj
+        end
+
+        ruby_node = node_struct.ruby_node
+        return ruby_node unless ruby_node.nil?
+
+        klasses = case node_struct[:type]
+                  when ELEMENT_NODE then [XML::Element]
+                  when TEXT_NODE then [XML::Text]
+                  when ENTITY_REF_NODE then [XML::EntityReference]
+                  when ATTRIBUTE_DECL then [XML::AttributeDecl, LibXML::XmlAttribute]
+                  when ELEMENT_DECL then [XML::ElementDecl, LibXML::XmlElement]
+                  when COMMENT_NODE then [XML::Comment]
+                  when DOCUMENT_FRAG_NODE then [XML::DocumentFragment]
+                  when PI_NODE then [XML::ProcessingInstruction]
+                  when ATTRIBUTE_NODE then [XML::Attr]
+                  when ENTITY_DECL then [XML::EntityDecl, LibXML::XmlEntity]
+                  when CDATA_SECTION_NODE then [XML::CDATA]
+                  when DTD_NODE then [XML::DTD, LibXML::XmlDtd]
+                  else [XML::Node]
+                  end
+
+        if klass
+          node = klass.allocate
+        else
+          node = klasses.first.allocate
+        end
+        node.cstruct = klasses[1] ? klasses[1].new(node_struct.pointer) : node_struct
+
+        node.cstruct.ruby_node = node
+
+        if document_obj
+          node.instance_variable_set(:@document, document_obj)
+          cache = document_obj.instance_variable_get(:@node_cache)
+          cache << node
+          document_obj.decorate(node)
+        end
+
+        node
+      end
+
+      def document
+        cstruct.document.ruby_doc
+      end
+
+      class << self
+        def node_properties(cstruct)
+          attr = []
+          prop_cstruct = cstruct[:properties]
+          while ! prop_cstruct.null?
+            prop = Node.wrap(prop_cstruct)
+            attr << prop
+            prop_cstruct = prop.cstruct[:next]
+          end
+          attr
+        end
+      end
+
+      private
+
+      def self.reparent_node_with(node, other, &block)
+        raise(ArgumentError, "node must be a Nokogiri::XML::Node") unless node.is_a?(Nokogiri::XML::Node)
+        raise(ArgumentError, "cannot reparent a document node") if node.node_type == DOCUMENT_NODE || node.node_type == HTML_DOCUMENT_NODE
+
+        if node.type == TEXT_NODE
+          node.cstruct.keep_reference_from_document!
+          node.cstruct = LibXML::XmlNode.new(LibXML.xmlDocCopyNode(node.cstruct, other.cstruct.document, 1))
+        end
+
+        if node.cstruct[:doc] == other.cstruct[:doc]
+          LibXML.xmlUnlinkNode(node.cstruct)
+          if node.type == TEXT_NODE && other.type == TEXT_NODE && Nokogiri.is_2_6_16?
+            other.cstruct.pointer.put_pointer(other.cstruct.offset_of(:content), LibXML.xmlStrdup(other.cstruct[:content]))
+          end
+          reparented_struct = block.call(node.cstruct, other.cstruct)
+          raise(RuntimeError, "Could not reparent node (1)") unless reparented_struct
+        else
+          duped_node = LibXML.xmlDocCopyNode(node.cstruct, other.cstruct.document, 1)
+          raise(RuntimeError, "Could not reparent node (xmlDocCopyNode)") unless duped_node
+          reparented_struct = block.call(duped_node, other.cstruct)
+          raise(RuntimeError, "Could not reparent node (2)") unless reparented_struct
+          LibXML.xmlUnlinkNode(node.cstruct)
+          node.cstruct.keep_reference_from_document!
+        end
+
+        reparented_struct = LibXML::XmlNode.new(reparented_struct) if reparented_struct.is_a?(FFI::Pointer)
+
+        # the child was a text node that was coalesced. we need to have the object
+        # point at SOMETHING, or we'll totally bomb out.
+        if reparented_struct != node.cstruct
+          node.cstruct = reparented_struct
+        end
+
+        relink_namespace reparented_struct
+
+        reparented = Node.wrap(reparented_struct)
+        reparented.decorate!
+        reparented
+      end
+
+      def self.relink_namespace(reparented_struct)
+        return if reparented_struct[:parent].null?
+
+        # Make sure that our reparented node has the correct namespaces
+        if reparented_struct[:ns].null? && reparented_struct[:doc] != reparented_struct[:parent]
+          LibXML.xmlSetNs(reparented_struct, LibXML::XmlNode.new(reparented_struct[:parent])[:ns])
+        end
+
+        # Search our parents for an existing definition
+        if ! reparented_struct[:nsDef].null?
+          ns = LibXML.xmlSearchNsByHref(
+            reparented_struct[:doc],
+            reparented_struct[:parent],
+            LibXML::XmlNs.new(reparented_struct[:nsDef])[:href]
+            )
+          reparented_struct[:nsDef] = nil unless ns.null?
+        end
+
+        # Only walk all children if there actually is a namespace we need to reparent.
+        return if reparented_struct[:ns].null?
+
+        # When a node gets reparented, walk it's children to make sure that
+        # their namespaces are reparented as well.
+        child_ptr = reparented_struct[:children]
+        while ! child_ptr.null?
+          child_struct = LibXML::XmlNode.new(child_ptr) 
+          relink_namespace child_struct
+          child_ptr = child_struct[:next]
+        end
+      end
+
+      def cstruct_node_from(sym)
+        (val = cstruct[sym]).null? ? nil : Node.wrap(val)
+      end
+
+      def set_xml_indent_tree_output(value)
+        LibXML.__xmlIndentTreeOutput.write_int(value)
+      end
+
+      def set_xml_tree_indent_string(value)
+        LibXML.__xmlTreeIndentString.write_pointer(LibXML.xmlStrdup(value.to_s))
+      end
+
+      # :startdoc:
+    end
+  end
+end
+class Nokogiri::XML::Element < Nokogiri::XML::Node; end
+class Nokogiri::XML::CharacterData < Nokogiri::XML::Node; end