nokogiri 1.4.1 → 1.4.2

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

@@ -2,6 +2,15 @@
 module Nokogiri
   module XML
     class EntityDecl < Nokogiri::XML::Node
+
+      # from libxml/entities.h
+      INTERNAL_GENERAL          = 1
+      EXTERNAL_GENERAL_PARSED   = 2
+      EXTERNAL_GENERAL_UNPARSED = 3
+      INTERNAL_PARAMETER        = 4
+      EXTERNAL_PARAMETER        = 5
+      INTERNAL_PREDEFINED       = 6
+
       def content
         cstruct[:content]
       end

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

@@ -78,18 +78,14 @@ module Nokogiri
       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)
+        sibling_ptr = LibXML.xmlNextElementSibling cstruct
+        sibling_ptr.null? ? nil : Node.wrap(sibling_ptr)
       end
 
       def previous_element
+        #
+        #  note that we don't use xmlPreviousElementSibling here because it's buggy pre-2.7.7.
+        #
         sibling_ptr = cstruct[:prev]
 
         while ! sibling_ptr.null?
@@ -102,41 +98,71 @@ module Nokogiri
       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
+        Node.reparent_node_with(self, new_node) do |pivot_struct, reparentee_struct|
+          retval = LibXML.xmlReplaceNode(pivot_struct, reparentee_struct)
+          retval = reparentee_struct if retval == pivot_struct.pointer # for reparent_node_with semantics
+          retval = LibXML::XmlNode.new(retval) if retval.is_a?(FFI::Pointer)
+          if retval[:type] == TEXT_NODE
+            if retval[:prev] && LibXML::XmlNode.new(retval[:prev])[:type] == TEXT_NODE
+              retval = LibXML::XmlNode.new(LibXML.xmlTextMerge(retval[:prev], retval))
+            end
+            if retval[:next] && LibXML::XmlNode.new(retval[:next])[:type] == TEXT_NODE
+              retval = LibXML::XmlNode.new(LibXML.xmlTextMerge(retval, retval[:next]))
+            end
           end
+          retval
         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)
+        set = NodeSet.wrap(LibXML.xmlXPathNodeSetCreate(child.cstruct), self.document)
         return set unless child
 
         child_ptr = child.cstruct[:next]
         while ! child_ptr.null?
           child = Node.wrap(child_ptr)
-          LibXML.xmlXPathNodeSetAdd(set.cstruct, child.cstruct)
+          LibXML.xmlXPathNodeSetAddUnique(set.cstruct, child.cstruct)
           child_ptr = child.cstruct[:next]
         end
 
         return set
       end
 
+      def element_children
+        child = LibXML.xmlFirstElementChild(cstruct)
+        return NodeSet.new(nil) if child.null?
+        child = Node.wrap(child)
+
+        set = NodeSet.wrap(LibXML.xmlXPathNodeSetCreate(child.cstruct), self.document)
+        return set unless child
+
+        next_sibling = LibXML.xmlNextElementSibling(child.cstruct)
+        while ! next_sibling.null?
+          child = Node.wrap(next_sibling)
+          LibXML.xmlXPathNodeSetAddUnique(set.cstruct, child.cstruct)
+          next_sibling = LibXML.xmlNextElementSibling(child.cstruct)
+        end
+
+        return set
+      end
+
       def child
         (val = cstruct[:children]).null? ? nil : Node.wrap(val)
       end
 
+      def first_element_child
+        element_child = LibXML.xmlFirstElementChild(cstruct)
+        element_child.null? ? nil : Node.wrap(element_child)
+      end
+
+      def last_element_child
+        element_child = LibXML.xmlLastElementChild(cstruct)
+        element_child.null? ? nil : Node.wrap(element_child)
+      end
+
       def key?(attribute)
         ! (prop = LibXML.xmlHasProp(cstruct, attribute.to_s)).null?
       end
@@ -162,7 +188,7 @@ module Nokogiri
       end
 
       def set_namespace(namespace)
-        LibXML.xmlSetNs(cstruct, namespace.cstruct)
+        LibXML.xmlSetNs(cstruct, namespace ? namespace.cstruct : nil)
         self
       end
 
@@ -197,11 +223,32 @@ module Nokogiri
         list
       end
 
+      def namespace_scopes
+        ns_list = LibXML.xmlGetNsList(self.cstruct[:doc], self.cstruct)
+        return [] if ns_list.null?
+
+        list = []
+        until (ns_ptr = ns_list.get_pointer(LibXML.pointer_offset(list.length))).null?
+          list << Namespace.wrap(cstruct.document, ns_ptr)
+        end
+
+        LibXML.xmlFree(ns_list)
+        list
+      end
+
       def node_type
         cstruct[:type]
       end
 
       def native_content=(content)
+        child_ptr = cstruct[:children]
+        while ! child_ptr.null?
+          child    = Node.wrap(child_ptr)
+          next_ptr = child.cstruct[:next]
+          LibXML.xmlUnlinkNode(child.cstruct)
+          cstruct.keep_reference_from_document!
+          child_ptr = next_ptr
+        end
         LibXML.xmlNodeSetContent(cstruct, content)
         content
       end
@@ -215,8 +262,8 @@ module Nokogiri
       end
 
       def add_child_node child
-        Node.reparent_node_with(child, self) do |child_cstruct, my_cstruct|
-          LibXML.xmlAddChild(my_cstruct, child_cstruct)
+        Node.reparent_node_with(self, child) do |pivot_struct, reparentee_struct|
+          LibXML.xmlAddChild(pivot_struct, reparentee_struct)
         end
       end
 
@@ -241,14 +288,14 @@ module Nokogiri
       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)
+        Node.reparent_node_with(self, next_sibling) do |pivot_struct, reparentee_struct|
+          LibXML.xmlAddNextSibling(pivot_struct, reparentee_struct)
         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)
+        Node.reparent_node_with(self, prev_sibling) do |pivot_struct, reparentee_struct|
+          LibXML.xmlAddPrevSibling(pivot_struct, reparentee_struct)
         end
       end
 
@@ -359,6 +406,29 @@ module Nokogiri
         cstruct.document.ruby_doc
       end
 
+      def in_context(string, options)
+        raise RuntimeError, "no contextual parsing on unlinked nodes" if parent.nil?
+
+        @errors = []
+        LibXML.xmlSetStructuredErrorFunc(nil, SyntaxError.error_array_pusher(@errors))
+        LibXML.htmlHandleOmittedElem(0)
+
+        list_memory = FFI::MemoryPointer.new :pointer
+        LibXML.xmlParseInNodeContext(cstruct, string, string.length, options, list_memory)
+
+        LibXML.htmlHandleOmittedElem(1)
+        LibXML.xmlSetStructuredErrorFunc(nil, nil)
+
+        set = NodeSet.wrap(LibXML.xmlXPathNodeSetCreate(nil), document)
+        list_ptr = list_memory.get_pointer(0)
+        while ! list_ptr.null?
+          list = Node.wrap(list_ptr)
+          LibXML.xmlXPathNodeSetAddUnique(set.cstruct, list.cstruct)
+          list_ptr = list.cstruct[:next]
+        end
+        set
+      end
+
       class << self
         def node_properties(cstruct)
           attr = []
@@ -374,38 +444,31 @@ module Nokogiri
 
       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
+      def self.reparent_node_with(pivot, reparentee, &block)
+        raise(ArgumentError, "node must be a Nokogiri::XML::Node") unless reparentee.is_a?(Nokogiri::XML::Node)
+        raise(ArgumentError, "cannot reparent a document node") if reparentee.node_type == DOCUMENT_NODE || reparentee.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))
+        pivot_struct = pivot.cstruct
+        reparentee_struct = reparentee.cstruct
+
+        LibXML.xmlUnlinkNode(reparentee_struct)
+
+        if reparentee_struct[:doc] != pivot_struct[:doc] || reparentee_struct[:type] == TEXT_NODE
+          reparentee_struct.keep_reference_from_document!
+          reparentee_struct = LibXML.xmlDocCopyNode(reparentee_struct, pivot_struct.document, 1)
+          raise(RuntimeError, "Could not reparent node (xmlDocCopyNode)") unless reparentee_struct
+          reparentee_struct = LibXML::XmlNode.new(reparentee_struct)
         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!
+        if reparentee_struct[:type] == TEXT_NODE && pivot_struct[:type] == TEXT_NODE && Nokogiri.is_2_6_16?
+          pivot_struct.pointer.put_pointer(pivot_struct.offset_of(:content), LibXML.xmlStrdup(pivot_struct[:content]))
         end
 
-        reparented_struct = LibXML::XmlNode.new(reparented_struct) if reparented_struct.is_a?(FFI::Pointer)
+        reparented_struct = block.call(pivot_struct, reparentee_struct)
+        raise(RuntimeError, "Could not reparent node") unless reparented_struct
 
-        # 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
+        reparented_struct = LibXML::XmlNode.new(reparented_struct) if reparented_struct.is_a?(FFI::Pointer)
+        reparentee.cstruct = reparented_struct
 
         relink_namespace reparented_struct
 
@@ -424,12 +487,30 @@ module Nokogiri
 
         # 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?
+          curr = reparented_struct[:nsDef]
+          prev = nil
+
+          while (! curr.null?)
+            curr_ns = LibXML::XmlNs.new(curr)
+            ns = LibXML.xmlSearchNsByHref(
+              reparented_struct[:doc],
+              reparented_struct[:parent],
+              curr_ns[:href]
+              )
+            # If we find the namespace is already declared, remove it from this
+            # definition list.
+            if (! ns.null? && ns != curr)
+              if prev
+                prev[:next] = curr_ns[:next]
+              else
+                reparented_struct[:nsDef] = curr_ns[:next]
+              end
+              curr_ns.keep_reference_from!(reparented_struct.document)
+            else
+              prev = curr_ns
+            end
+            curr = curr_ns[:next]
+          end
         end
 
         # Only walk all children if there actually is a namespace we need to reparent.
@@ -439,7 +520,7 @@ module Nokogiri
         # their namespaces are reparented as well.
         child_ptr = reparented_struct[:children]
         while ! child_ptr.null?
-          child_struct = LibXML::XmlNode.new(child_ptr) 
+          child_struct = LibXML::XmlNode.new(child_ptr)
           relink_namespace child_struct
           child_ptr = child_struct[:next]
         end

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

@@ -6,7 +6,7 @@ module Nokogiri
 
       def dup # :nodoc:
         dup = LibXML.xmlXPathNodeSetMerge(nil, self.cstruct)
-        NodeSet.wrap(dup)
+        NodeSet.wrap(dup, self.document)
       end
 
       def length # :nodoc:
@@ -24,9 +24,7 @@ module Nokogiri
         new_set_ptr = LibXML::xmlXPathNodeSetMerge(nil, self.cstruct)
         new_set_ptr = LibXML::xmlXPathNodeSetMerge(new_set_ptr, node_set.cstruct)
 
-        new_set = NodeSet.wrap(new_set_ptr)
-        new_set.document = document
-        new_set
+        NodeSet.wrap(new_set_ptr, self.document)
       end
 
       def -(node_set) # :nodoc:
@@ -37,7 +35,7 @@ module Nokogiri
         node_set.cstruct[:nodeNr].times do |j|
           LibXML.xmlXPathNodeSetDel(new_set_ptr, other_nodetab[j])
         end        
-        NodeSet.wrap(new_set_ptr)
+        NodeSet.wrap(new_set_ptr, self.document)
       end
 
       def delete(node) # :nodoc:
@@ -69,7 +67,7 @@ module Nokogiri
       def &(node_set) # :nodoc:
         raise(ArgumentError, "node_set must be a Nokogiri::XML::NodeSet") unless node_set.is_a?(XML::NodeSet)
         new_set_ptr = LibXML.xmlXPathIntersection(cstruct, node_set.cstruct)
-        NodeSet.wrap(new_set_ptr)
+        NodeSet.wrap(new_set_ptr, self.document)
       end
 
       def include?(node) # :nodoc:
@@ -103,21 +101,25 @@ module Nokogiri
       end
 
       def self.new document, list = [] # :nodoc:
-        set = NodeSet.wrap(LibXML.xmlXPathNodeSetCreate(nil))
+        set = NodeSet.wrap(LibXML.xmlXPathNodeSetCreate(nil), document)
         set.document = document
         list.each { |x| set << x }
         yield set if block_given?
         set
       end
 
-      private
-
-      def self.wrap(ptr) # :nodoc:
+      def self.wrap(ptr, document) # :nodoc:
         set = allocate
         set.cstruct = LibXML::XmlNodeSet.new(ptr)
+        if document
+          set.document = document
+          document.decorate(set)
+        end
         set
       end
 
+      private
+
       def index_at(number) # :nodoc:
         return nil if (number >= cstruct[:nodeNr] || number.abs > cstruct[:nodeNr])
         number = number + cstruct[:nodeNr] if number < 0
@@ -133,10 +135,11 @@ module Nokogiri
       def subseq(beg, len) # :nodoc:
         return nil if beg > cstruct[:nodeNr]
         return nil if beg < 0 || len < 0
+        len = cstruct[:nodeNr] - beg if beg + len > cstruct[:nodeNr]
 
-        set = NodeSet.wrap(LibXML.xmlXPathNodeSetCreate(nil))
+        set = NodeSet.wrap(LibXML.xmlXPathNodeSetCreate(nil), self.document)
         beg.upto(beg+len-1) do |j|
-          LibXML.xmlXPathNodeSetAdd(set.cstruct, cstruct.nodeAt(j));
+          LibXML.xmlXPathNodeSetAddUnique(set.cstruct, cstruct.nodeAt(j));
         end
         set
       end

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

@@ -127,6 +127,11 @@ module Nokogiri
         val.null? ? nil : val.read_string
       end
 
+      def base_uri
+        val = LibXML.xmlTextReaderConstBaseUri(cstruct)
+        val.null? ? nil : val.read_string
+      end
+
       def state
         LibXML.xmlTextReaderReadState(cstruct)
       end

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

@@ -22,6 +22,23 @@ module Nokogiri
       end
       private :validate_document
 
+      def validate_file filename
+        errors = []
+
+        ctx = LibXML.xmlSchemaNewValidCtxt(cstruct)
+        raise RuntimeError.new("Could not create a validation context") if ctx.null?
+
+        LibXML.xmlSchemaSetValidStructuredErrors(ctx,
+          SyntaxError.error_array_pusher(errors), nil) unless Nokogiri.is_2_6_16?
+
+        LibXML.xmlSchemaValidateFile(ctx, filename, 0)
+
+        LibXML.xmlSchemaFreeValidCtxt(ctx)
+
+        errors
+      end
+      private :validate_document
+
       def self.read_memory content
         content_copy = FFI::MemoryPointer.from_string(content)
         ctx = LibXML.xmlSchemaNewMemParserCtxt(content_copy, content.length)

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

@@ -20,7 +20,7 @@ module Nokogiri
 
       def message
         val = cstruct[:message]
-        val.null? ? nil : val.read_string
+        val.null? ? nil : val.read_string.chomp
       end
       undef_method :inspect
       alias_method :inspect, :message
@@ -54,15 +54,15 @@ module Nokogiri
       end
 
       def str1
-        cstruct[:str1].null? ? nil : cstruct[:str1]
+        cstruct[:str1]
       end
 
       def str2
-        cstruct[:str].null? ? nil : cstruct[:str]
+        cstruct[:str]
       end
 
       def str3
-        cstruct[:str3].null? ? nil : cstruct[:str3]
+        cstruct[:str3]
       end
 
       def int1