nokogiri 1.3.2-x86-mingw32 → 1.3.3-x86-mingw32

data/lib/nokogiri/ffi/structs/common_node.rb

@@ -18,7 +18,7 @@ module Nokogiri
       def keep_reference_from_document! # equivalent to NOKOGIRI_ROOT_NODE
         doc = self.document
         raise "no document to add reference to" unless doc
-        LibXML.xmlXPathNodeSetAdd(doc.node_set, self)
+        LibXML.xmlXPathNodeSetAdd(doc.unlinked_nodes, self)
       end
     end
   end

data/lib/nokogiri/ffi/structs/xml_document.rb

@@ -46,7 +46,7 @@ module Nokogiri
         self[:_private].put_long(0, object.object_id)
       end
 
-      def node_set
+      def unlinked_nodes
         LibXML::XmlNodeSetCast.new(self[:_private].get_pointer(FFI.type_size(:pointer)))
       end
 

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

@@ -8,9 +8,19 @@ module Nokogiri
         cstruct[:URL]
       end
 
-      def root=(node) # :nodoc:
-        LibXML.xmlDocSetRootElement(cstruct, node.cstruct)
-        node
+      def root=(new_root) # :nodoc:
+        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 # :nodoc:
@@ -24,7 +34,8 @@ module Nokogiri
       end
 
       def encoding # :nodoc:
-        cstruct[:encoding].read_string
+        ptr = cstruct[:encoding]
+        ptr.null? ? nil : ptr.read_string
       end
 
       def self.read_io(io, url, encoding, options) # :nodoc:

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

@@ -1,14 +1,15 @@
 module Nokogiri
   module XML
     class Node
+      # :stopdoc:
 
-      attr_accessor :cstruct # :nodoc:
+      attr_accessor :cstruct
 
-      def pointer_id # :nodoc:
+      def pointer_id
         cstruct.pointer
       end
 
-      def encode_special_chars(string) # :nodoc:
+      def encode_special_chars(string)
         char_ptr = LibXML.xmlEncodeSpecialChars(self[:doc], string)
         encoded = char_ptr.read_string
         # TODO: encoding?
@@ -16,7 +17,7 @@ module Nokogiri
         encoded
       end
 
-      def internal_subset # :nodoc:
+      def internal_subset
         return nil if cstruct[:doc].null?
         doc = cstruct.document
         dtd = LibXML.xmlGetIntSubset(doc)
@@ -24,37 +25,37 @@ module Nokogiri
         Node.wrap(dtd)
       end
 
-      def dup(deep = 1) # :nodoc:
+      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 # :nodoc:
+      def unlink
         LibXML.xmlUnlinkNode(cstruct)
         cstruct.keep_reference_from_document!
         self
       end
 
-      def blank? # :nodoc:
+      def blank?
         LibXML.xmlIsBlankNode(cstruct) == 1
       end
 
-      def next_sibling # :nodoc:
+      def next_sibling
         cstruct_node_from :next
       end
 
-      def previous_sibling # :nodoc:
+      def previous_sibling
         cstruct_node_from :prev
       end
 
-      def replace_with_node(new_node) # :nodoc:
+      def replace_with_node(new_node)
         LibXML.xmlReplaceNode(cstruct, new_node.cstruct)
         Node.send(:relink_namespace, new_node.cstruct)
         self
       end
 
-      def children # :nodoc:
+      def children
         return NodeSet.new(nil) if cstruct[:children].null?
         child = Node.wrap(cstruct[:children])
 
@@ -74,26 +75,26 @@ module Nokogiri
         return set
       end
 
-      def child # :nodoc:
+      def child
         (val = cstruct[:children]).null? ? nil : Node.wrap(val)
       end
 
-      def key?(attribute) # :nodoc:
+      def key?(attribute)
         ! (prop = LibXML.xmlHasProp(cstruct, attribute.to_s)).null?
       end
 
-      def namespaced_key?(attribute, namespace) # :nodoc:
+      def namespaced_key?(attribute, namespace)
         prop = LibXML.xmlHasNsProp(cstruct, attribute.to_s,
           namespace.nil? ? nil : namespace.to_s)
         prop.null? ? false : true
       end
 
-      def []=(property, value) # :nodoc:
+      def []=(property, value)
         LibXML.xmlSetProp(cstruct, property, value)
         value
       end
 
-      def get(attribute) # :nodoc:
+      def get(attribute)
         return nil unless attribute
         propstr = LibXML.xmlGetProp(cstruct, attribute.to_s)
         return nil if propstr.null?
@@ -107,33 +108,26 @@ module Nokogiri
         self
       end
 
-      def attribute(name) # :nodoc:
+      def attribute(name)
         raise "Node#attribute not implemented yet"
       end
 
-      def attribute_with_ns(name, namespace) # :nodoc:
+      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 # :nodoc:
-        attr = []
-        prop_cstruct = cstruct[:properties]
-        while ! prop_cstruct.null?
-          prop = Node.wrap(prop_cstruct)
-          attr << prop
-          prop_cstruct = prop.cstruct[:next]
-        end
-        attr
+      def attribute_nodes
+        Node.node_properties cstruct
       end
 
-      def namespace # :nodoc:
+      def namespace
         cstruct[:ns].null? ? nil : Namespace.wrap(cstruct.document, cstruct[:ns])
       end
 
-      def namespace_definitions # :nodoc:
+      def namespace_definitions
         list = []
         ns_ptr = cstruct[:nsDef]
         return list if ns_ptr.null?
@@ -145,16 +139,16 @@ module Nokogiri
         list
       end
 
-      def node_type # :nodoc:
+      def node_type
         cstruct[:type]
       end
 
-      def native_content=(content) # :nodoc:
+      def native_content=(content)
         LibXML.xmlNodeSetContent(cstruct, content)
         content
       end
 
-      def content # :nodoc:
+      def content
         content_ptr = LibXML.xmlNodeGetContent(cstruct)
         return nil if content_ptr.null?
         content = content_ptr.read_string # TODO: encoding?
@@ -162,45 +156,45 @@ module Nokogiri
         content
       end
 
-      def add_child(child) # :nodoc:
+      def add_child(child)
         Node.reparent_node_with(child, self) do |child_cstruct, my_cstruct|
           LibXML.xmlAddChild(my_cstruct, child_cstruct)
         end
       end
 
-      def parent # :nodoc:
+      def parent
         cstruct_node_from :parent
       end
-      
-      def node_name=(string) # :nodoc:
+
+      def node_name=(string)
         LibXML.xmlNodeSetName(cstruct, string)
         string
       end
 
-      def node_name # :nodoc:
+      def node_name
         cstruct[:name] # TODO: encoding?
       end
 
-      def path # :nodoc:
+      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(next_sibling) # :nodoc:
+      def add_next_sibling(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(prev_sibling) # :nodoc:
+      def add_previous_sibling(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) # :nodoc:
+      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)
@@ -209,11 +203,11 @@ module Nokogiri
         io
       end
 
-      def line # :nodoc:
+      def line
         cstruct[:line]
       end
 
-      def add_namespace_definition(prefix, href) # :nodoc:
+      def add_namespace_definition(prefix, href)
         ns = LibXML.xmlNewNs(cstruct, href, prefix)
         if ns.null?
           ns = LibXML.xmlSearchNs(cstruct.document, cstruct,
@@ -223,43 +217,46 @@ module Nokogiri
         Namespace.wrap(cstruct.document, ns)
       end
 
-      def self.new(name, document, *rest) # :nodoc:
+      def self.new(name, doc, *rest)
         ptr = LibXML.xmlNewNode(nil, name.to_s)
 
         node_cstruct = LibXML::XmlNode.new(ptr)
-        node_cstruct[:doc] = document.cstruct[:doc]
+        node_cstruct[:doc] = doc.cstruct[:doc]
         node_cstruct.keep_reference_from_document!
 
-        node = Node.wrap(node_cstruct, self)
-        node.send :initialize, name, document, *rest
+        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 # :nodoc:
+      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) # :nodoc:
+      def compare(other)
         LibXML.xmlXPathCmpNodes(other.cstruct, self.cstruct)
       end
 
-      def self.wrap(node_struct, klass=nil) # :nodoc:
+      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) 
+          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 = document_struct.nil? ? nil : document_struct.ruby_doc
+        document_obj = document_struct.nil? ? nil : document_struct.ruby_doc
         if node_struct[:type] == DOCUMENT_NODE || node_struct[:type] == HTML_DOCUMENT_NODE
-          return document
+          return document_obj
         end
 
         ruby_node = node_struct.ruby_node
@@ -288,11 +285,13 @@ module Nokogiri
 
         node.cstruct.ruby_node = node
 
-        cache = document.instance_variable_get(:@node_cache)
-        cache << 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.instance_variable_set(:@document, document)
-        document.decorate(node)
         node
       end
 
@@ -300,11 +299,33 @@ module Nokogiri
         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) # :nodoc:
+      def self.reparent_node_with(node, other, &block)
         raise(ArgumentError, "node must be a Nokogiri::XML::Node") unless node.is_a?(Nokogiri::XML::Node)
 
+        # If a document fragment is added, we need to reparent all of it's
+        # children
+        if node.type == DOCUMENT_FRAG_NODE
+          node.children.each do |child|
+            reparent_node_with(child, other, &block)
+          end
+          return node
+        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?
@@ -320,7 +341,7 @@ module Nokogiri
           LibXML.xmlUnlinkNode(node.cstruct)
           node.cstruct.keep_reference_from_document!
         end
-        
+
         reparented_struct = LibXML::XmlNode.new(reparented_struct)
 
         # the child was a text node that was coalesced. we need to have the object
@@ -336,7 +357,7 @@ module Nokogiri
         reparented
       end
 
-      def self.relink_namespace(reparented_struct) # :nodoc:
+      def self.relink_namespace(reparented_struct)
         # Make sure that our reparented node has the correct namespaces
         if reparented_struct[:doc] != reparented_struct[:parent]
           LibXML.xmlSetNs(reparented_struct, LibXML::XmlNode.new(reparented_struct[:parent])[:ns])
@@ -365,18 +386,19 @@ module Nokogiri
         end
       end
 
-      def cstruct_node_from(sym) # :nodoc:
+      def cstruct_node_from(sym)
         (val = cstruct[sym]).null? ? nil : Node.wrap(val)
       end
 
-      def set_xml_indent_tree_output(value) # :nodoc:
+      def set_xml_indent_tree_output(value)
         LibXML.__xmlIndentTreeOutput.write_int(value)
       end
 
-      def set_xml_tree_indent_string(value) # :nodoc:
+      def set_xml_tree_indent_string(value)
         LibXML.__xmlTreeIndentString.write_pointer(LibXML.xmlStrdup(value.to_s))
       end
 
+      # :startdoc:
     end
   end
 end

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

@@ -29,8 +29,7 @@ module Nokogiri
         ptr = LibXML.xmlTextReaderExpand(cstruct)
         return nil if ptr.null?
 
-        node = Node.wrap(ptr)
-        Reader.node_namespaces(node)
+        Reader.node_namespaces(ptr)
       end
 
       def attribute_nodes # :nodoc:
@@ -40,17 +39,7 @@ module Nokogiri
         return nil if ptr.null?
         node_struct = LibXML::XmlNode.new(ptr)
 
-        # FIXME I'm not sure if this is correct.....  I don't really like pointing
-        # at this document, but I have to because of the assertions in
-        # the node wrapping code.
-        unless node_struct.document.ruby_doc
-          doc_struct = LibXML::XmlDocumentCast.new(node_struct[:doc])
-          doc_struct.alloc_tuple
-          doc = Document.wrap(doc_struct)
-        end
-
-        node = Node.wrap(node_struct)
-        node.attribute_nodes
+        Node.node_properties node_struct
       end
 
       def attribute_at(index) # :nodoc:
@@ -192,8 +181,8 @@ module Nokogiri
       private
 
       class << self
-        def node_namespaces(node) # :nodoc:
-          cstruct = node.cstruct
+        def node_namespaces(ptr) # :nodoc:
+          cstruct = LibXML::XmlNode.new(ptr)
           ahash = {}
           return ahash unless cstruct[:type] == Node::ELEMENT_NODE
           ns = cstruct[:nsDef]