nokogiri 1.4.0 → 1.4.1

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

@@ -78,18 +78,25 @@ module Nokogiri
       end
 
       def to_a # :nodoc:
-        cstruct.nodeTab.collect { |node| Node.wrap(node) }
+        cstruct.nodeTab.collect do |node|
+          node_cstruct = LibXML::XmlNode.new(node)
+          if node_cstruct[:type] == XML::Node::NAMESPACE_DECL
+            Namespace.wrap(document.cstruct, node)
+          else
+            Node.wrap(node_cstruct)
+          end
+        end
       end
 
       def unlink # :nodoc:
-        # TODO: is this simpler implementation viable:
-        #  cstruct.nodeTab.collect {|node| Node.wrap(node)}.each(&:unlink)
-        # ?
         nodetab = cstruct.nodeTab
         cstruct[:nodeNr].times do |j|
-          node = Node.wrap(nodetab[j])
-          node.unlink
-          nodetab[j] = node.cstruct.pointer
+          node_cstruct = LibXML::XmlNode.new(nodetab[j])
+          if node_cstruct[:type] != XML::Node::NAMESPACE_DECL
+            node = Node.wrap(node_cstruct)
+            node.unlink
+            nodetab[j] = node.cstruct.pointer
+          end
         end
         cstruct.nodeTab = nodetab
         self
@@ -114,7 +121,13 @@ module Nokogiri
       def index_at(number) # :nodoc:
         return nil if (number >= cstruct[:nodeNr] || number.abs > cstruct[:nodeNr])
         number = number + cstruct[:nodeNr] if number < 0
-        Node.wrap(cstruct.nodeAt(number))
+        node_ptr = cstruct.nodeAt(number)
+        node_cstruct = LibXML::XmlNode.new(node_ptr)
+        if node_cstruct[:type] == XML::Node::NAMESPACE_DECL
+          Namespace.wrap(document.cstruct, node_ptr)
+        else
+          Node.wrap(node_cstruct)
+        end
       end
 
       def subseq(beg, len) # :nodoc:

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

@@ -60,7 +60,7 @@ module Nokogiri
         if attr_ptr.null?
           # this section is an attempt to workaround older versions of libxml that
           # don't handle namespaces properly in all attribute-and-friends functions
-          prefix_ptr = FFI::MemoryPointer.new :pointer
+          prefix_ptr = FFI::Buffer.new :pointer
           localname = LibXML.xmlSplitQName2(name, prefix_ptr)
           prefix = prefix_ptr.get_pointer(0)
           if ! localname.null?

data/lib/nokogiri/ffi/xml/sax/parser.rb

@@ -48,14 +48,7 @@ module Nokogiri
         end
 
         def __internal__startElement(_, name, attributes)
-          attrs = []
-          unless attributes.null?
-            j = 0
-            while ! (value = attributes.get_pointer(LibXML.pointer_offset(j))).null?
-              attrs << value.read_string
-              j += 1
-            end
-          end
+          attrs = attributes.null? ? [] : attributes.get_array_of_string(0)
           @document.start_element name, attrs
         end
 

data/lib/nokogiri/ffi/xml/sax/push_parser.rb

@@ -5,6 +5,17 @@ module Nokogiri
 
         attr_accessor :cstruct # :nodoc:
 
+        def options
+          cstruct[:options]
+        end
+
+        def options=(user_options)
+          if LibXML.xmlCtxtUseOptions(cstruct, user_options) != 0
+            raise RuntimeError, "Cannot set XML parser context options"
+          end
+          nil
+        end
+
         private
 
         def native_write(chunk, last_chunk) # :nodoc:
@@ -14,10 +25,11 @@ module Nokogiri
             size = chunk.length
           end
 
-          rcode = LibXML.xmlParseChunk(cstruct, chunk, size, last_chunk ? 1 : 0)
-          if rcode != 0
-            error = LibXML.xmlCtxtGetLastError(cstruct)
-            raise Nokogiri::XML::SyntaxError.wrap(error)
+          if LibXML.xmlParseChunk(cstruct, chunk, size, last_chunk ? 1 : 0) != 0
+            if (cstruct[:options] & XML::ParseOptions::RECOVER) == 0
+              error = LibXML.xmlCtxtGetLastError(cstruct)
+              raise Nokogiri::XML::SyntaxError.wrap(error)
+            end
           end
 
           self

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

@@ -7,7 +7,7 @@ module Nokogiri
 
       def initialize(message)
         self.cstruct = LibXML::XmlSyntaxError.new(LibXML::XmlSyntaxError.allocate())
-        self.cstruct[:message] = FFI::MemoryPointer.from_string(message)
+        self.cstruct[:message] = LibXML.xmlStrdup(message)
       end
 
       def domain
@@ -31,7 +31,14 @@ module Nokogiri
         unless cstruct[:message].null?
           LibXML.xmlFree(cstruct[:message])
         end
-        cstruct[:message] = string
+        cstruct[:message] = LibXML.xmlStrdup(string)
+        string
+      end
+
+      def initialize_copy(other)
+        raise ArgumentError, "node must be a Nokogiri::XML::SyntaxError" unless other.is_a?(Nokogiri::XML::SyntaxError)
+        LibXML.xmlCopyError(other.cstruct, cstruct)
+        self
       end
 
       def level

data/lib/nokogiri/ffi/xslt/stylesheet.rb

@@ -22,19 +22,22 @@ module Nokogiri
       end
 
       def serialize(document) # :nodoc:
-        buf_ptr = FFI::MemoryPointer.new :pointer
-        buf_len = FFI::MemoryPointer.new :int
+        buf_ptr = FFI::Buffer.new :pointer
+        buf_len = FFI::Buffer.new :int
         LibXML.xsltSaveResultToString(buf_ptr, buf_len, document.cstruct, cstruct)
-        buf = Nokogiri::LibXML::XmlAlloc.new(buf_ptr.read_pointer)
-        buf.pointer.read_string(buf_len.read_int)
+        buf = Nokogiri::LibXML::XmlAlloc.new(buf_ptr.get_pointer(0))
+        buf.pointer.read_string(buf_len.get_int(0))
       end
 
       def transform(document, params=[]) # :nodoc:
-        param_arr = FFI::MemoryPointer.new(:pointer, params.length + 1)
-        params.each_with_index do |param, j|
-          param_arr[j].put_pointer(0, FFI::MemoryPointer.from_string(param.to_s))
-        end
-        param_arr[params.length].put_pointer(0,nil)
+        param_arr = FFI::MemoryPointer.new(:pointer, params.length + 1, false)
+
+        # Keep the MemoryPointer instances alive until after the call
+        ptrs = params.map { |param | FFI::MemoryPointer.from_string(param.to_s) }
+        param_arr.put_array_of_pointer(0, ptrs)
+        
+        # Terminate the list with a NULL pointer
+        param_arr.put_pointer(LibXML.pointer_offset(params.length), nil)
 
         ptr = LibXML.xsltApplyStylesheet(cstruct, document.cstruct, param_arr)
         raise(RuntimeError, "could not perform xslt transform on document") if ptr.null?

data/lib/nokogiri/version.rb

@@ -1,6 +1,6 @@
 module Nokogiri
   # The version of Nokogiri you are using
-  VERSION = '1.4.0'
+  VERSION = '1.4.1'
 
   # More complete version information about libxml
   VERSION_INFO = {}

data/lib/nokogiri/xml/builder.rb

@@ -269,7 +269,7 @@ module Nokogiri
       ###
       # Create a Text Node with content of +string+
       def text string
-        insert @doc.create_text_node string
+        insert @doc.create_text_node(string)
       end
 
       ###

data/lib/nokogiri/xml/document.rb

@@ -60,6 +60,34 @@ module Nokogiri
         self
       end
 
+      ###
+      # Recursively get all namespaces from this node and its subtree and
+      # return them as a hash.
+      #
+      # For example, given this document:
+      #
+      #   <root xmlns:foo="bar">
+      #     <bar xmlns:hello="world" />
+      #   </root>
+      #
+      # This method will return:
+      #
+      #   { 'xmlns:foo' => 'bar', 'xmlns:hello' => 'world' }
+      #
+      # WARNING: this method will clobber duplicate names in the keys.
+      # For example, given this document:
+      #
+      #   <root xmlns:foo="bar">
+      #     <bar xmlns:foo="baz" />
+      #   </root>
+      #
+      # The hash returned will look like this: { 'xmlns:foo' => 'bar' }
+      def collect_namespaces
+        ns = {}
+        traverse { |j| ns.merge!(j.namespaces) }
+        ns
+      end
+
       # Get the list of decorators given +key+
       def decorators key
         @decorators ||= Hash.new
@@ -112,13 +140,16 @@ module Nokogiri
 
       undef_method :swap, :parent, :namespace, :default_namespace=
       undef_method :add_namespace_definition, :attributes
-      undef_method :namespace_definitions, :line
+      undef_method :namespace_definitions, :line, :add_namespace
 
       def add_child child
-        if [Node::ELEMENT_NODE, Node::DOCUMENT_FRAG_NODE].include? child.type
-          raise "Document already has a root node" if root
+        raise "Document already has a root node" if root
+        if child.type == Node::DOCUMENT_FRAG_NODE
+          raise "Document cannot have multiple root nodes" if child.children.size > 1
+          super(child.children.first)
+        else
+          super
         end
-        super
       end
       alias :<< :add_child
 

data/lib/nokogiri/xml/document_fragment.rb

@@ -51,7 +51,11 @@ module Nokogiri
       ###
       # Search this fragment.  See Nokogiri::XML::Node#css
       def css *args
-        children.css(*args)
+        if children.any?
+          children.css(*args)
+        else
+          NodeSet.new(document)
+        end
       end
 
       alias :serialize :to_s

data/lib/nokogiri/xml/fragment_handler.rb

@@ -8,33 +8,27 @@ module Nokogiri
         @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
+        @original_html  = prepare_for_regex(original_html.strip)
       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
+        if ! @doc_started && @original_html =~ regex
+          @doc_started = true
+        end
         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
+        ns = nil
+        if @document.root
+          match = name.match(QNAME_REGEX)
+          if match
+            prefix, name = match[1], match[2]
+            ns = @document.root.namespace_definitions.detect { |x|
+              x.prefix == prefix
+            }
+          end
         end
 
         node = Element.new(name, @document)
@@ -50,7 +44,7 @@ module Nokogiri
       end
 
       def characters string
-        @doc_started = true if @original_html.strip =~ %r{^\s*#{Regexp.escape(string.strip)}}
+        @doc_started = true
         @stack.last << Text.new(string, @document)
       end
 
@@ -66,6 +60,20 @@ module Nokogiri
         return unless @stack.last.name == name
         @stack.pop
       end
+
+      private
+
+      #
+      # 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
+      #
+      def prepare_for_regex(string)
+        (newline_index = string.index("\n")) ? string.slice(0,newline_index) : string
+      end
     end
   end
 end

data/lib/nokogiri/xml/node.rb

@@ -192,6 +192,13 @@ module Nokogiri
         xpath(*rules)
       end
 
+      ###
+      # Search this node's immidiate children using CSS selector +selector+
+      def > selector
+        ns = document.root.namespaces
+        xpath CSS.xpath_for(selector, :prefix => "./", :ns => ns).first
+      end
+
       ###
       # Search for the first occurrence of +path+.
       # Returns nil if nothing is found, otherwise a Node.
@@ -225,10 +232,59 @@ module Nokogiri
         get(name.to_s)
       end
 
+      ###
+      # Add +node+ as a child of this Node.
+      # The new node must be a Nokogiri::XML::Node or a non-empty String.
+      # Returns the new child node.
+      def add_child(node)
+        Node.verify_nodeishness(node)
+        if node.type == DOCUMENT_FRAG_NODE
+          node.children.each do |child|
+            add_child_node child
+          end
+        else
+          add_child_node node
+        end
+      end
+
+      ###
+      # Insert +node+ before this Node (as a sibling).
+      def add_previous_sibling(node)
+        Node.verify_nodeishness(node)
+        if node.type == DOCUMENT_FRAG_NODE
+          node.children.each do |child|
+            add_previous_sibling_node child
+          end
+        else
+          add_previous_sibling_node node
+        end
+      end
+
+      ###
+      # Insert +node+ after this Node (as a sibling).
+      def add_next_sibling(node)
+        Node.verify_nodeishness(node)
+        if node.type == DOCUMENT_FRAG_NODE
+          node.children.reverse.each do |child|
+            add_next_sibling_node child
+          end
+        else
+          add_next_sibling_node node
+        end
+      end
+
       alias :next           :next_sibling
       alias :previous       :previous_sibling
+
+      # :stopdoc:
+      # HACK: This is to work around an RDoc bug
+      alias :next=          :add_next_sibling
+      # :startdoc:
+
+      alias :previous=      :add_previous_sibling
       alias :remove         :unlink
       alias :get_attribute  :[]
+      alias :attr           :[]
       alias :set_attribute  :[]=
       alias :text           :content
       alias :inner_text     :content
@@ -241,8 +297,9 @@ module Nokogiri
       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.
+      # Returns a hash containing the node's attributes.  The key is
+      # the attribute name, the value is a Nokogiri::XML::Attr
+      # representing the attribute.
       def attributes
         Hash[*(attribute_nodes.map { |node|
           [node.node_name, node]
@@ -279,7 +336,7 @@ module Nokogiri
       ###
       # Returns true if this Node matches +selector+
       def matches? selector
-        document.search(selector).include?(self)
+        ancestors.last.search(selector).include?(self)
       end
 
       ####
@@ -435,8 +492,10 @@ module Nokogiri
 
         return NodeSet.new(document, parents) unless selector
 
+        root = parents.last
+
         NodeSet.new(document, parents.find_all { |parent|
-          parent.matches?(selector)
+          root.search(selector).include?(parent)
         })
       end
 
@@ -473,16 +532,19 @@ module Nokogiri
       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
+      # +replace+ this Node with the +node+ in the Document.
+      # The new node must be a Nokogiri::XML::Node or a non-empty String.
+      # Returns the new child node.
+      def replace node
+        Node.verify_nodeishness(node)
+        if node.type == DOCUMENT_FRAG_NODE
+          node.children.each do |child|
+            add_previous_sibling child
+          end
+          unlink
+        else
+          replace_node node
         end
-        replace_with_node new_node
       end
 
       ###
@@ -657,6 +719,15 @@ Node.replace requires a Node argument, and cannot accept a Document.
       end
 
       private
+      def self.verify_nodeishness(node)
+        if node.is_a?(Document) || !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
+      end
+
       def inspect_attributes
         [:name, :namespace, :attribute_nodes, :children]
       end