nokogiri 1.3.2-java → 1.3.3-java

data/ext/nokogiri/xml_reader.c

@@ -163,13 +163,6 @@ static VALUE attribute_nodes(VALUE self)
   xmlNodePtr ptr = xmlTextReaderExpand(reader);
   if(ptr == NULL) return Qnil;
 
-  // 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.
-  if(! DOC_RUBY_OBJECT_TEST(ptr->doc)) {
-    VALUE rb_doc = Nokogiri_wrap_xml_document(cNokogiriXmlDocument, ptr->doc);
-    RDATA(rb_doc)->dfree = NULL;
-  }
   VALUE enc = rb_iv_get(self, "@encoding");
 
   if(enc != Qnil && NULL == ptr->doc->encoding) {

data/ext/nokogiri/xml_relax_ng.c

@@ -120,7 +120,9 @@ static VALUE from_document(VALUE klass, VALUE document)
   xmlRelaxNGPtr schema = xmlRelaxNGParse(ctx);
 
   xmlSetStructuredErrorFunc(NULL, NULL);
-  xmlRelaxNGFreeParserCtxt(ctx);
+  if (! is_2_6_16()) {
+    xmlRelaxNGFreeParserCtxt(ctx);
+  }
 
   if(NULL == schema) {
     xmlErrorPtr error = xmlGetLastError();
@@ -132,6 +134,10 @@ static VALUE from_document(VALUE klass, VALUE document)
     return Qnil;
   }
 
+  if (is_2_6_16()) {
+    xmlRelaxNGFreeParserCtxt(ctx);
+  }
+
   VALUE rb_schema = Data_Wrap_Struct(klass, 0, dealloc, schema);
   rb_iv_set(rb_schema, "@errors", errors);
 

data/ext/nokogiri/xml_sax_parser.c

@@ -310,6 +310,8 @@ static VALUE allocate(VALUE klass)
 {
   xmlSAXHandlerPtr handler = calloc(1, sizeof(xmlSAXHandler));
 
+  xmlSetStructuredErrorFunc(NULL, NULL);
+
   handler->startDocument = start_document;
   handler->endDocument = end_document;
   handler->startElement = start_element;

data/lib/action-nokogiri.rb

@@ -18,6 +18,7 @@ module ActionController
     # Get your response as a Nokogiri::XML::Document using the
     # Nokogiri.HTML parser
     def html(flavor=nil)
+      warn "@response.html is deprecated and will be removed in nokogiri 1.4.0"
       if flavor == :hpricot
         @_nokogiri_html_hpricot ||= Nokogiri::Hpricot(body)
       else
@@ -29,6 +30,7 @@ module ActionController
     # Get your response as a Nokogiri::XML::Document using the
     # Nokogiri.XML parser
     def xml
+      warn "@response.html is deprecated and will be removed in nokogiri 1.4.0"
       @_nokogiri_xml ||= Nokogiri::XML(body)
     end
 

data/lib/nokogiri.rb

@@ -54,10 +54,16 @@ module Nokogiri
     # Parse an HTML or XML document.  +string+ contains the document.
     def parse string, url = nil, encoding = nil, options = nil
       doc =
-        if string =~ /^\s*<[^Hh>]*html/i # Probably html
-          Nokogiri::HTML::Document.parse(string, url, encoding, options || XML::ParseOptions::DEFAULT_HTML)
+        if string.respond_to?(:read) ||
+          string =~ /^\s*<[^Hh>]*html/i # Probably html
+          Nokogiri::HTML(
+            string,
+            url,
+            encoding, options || XML::ParseOptions::DEFAULT_HTML
+          )
         else
-          Nokogiri::XML::Document.parse(string, url, encoding, options || XML::ParseOptions::DEFAULT_XML)
+          Nokogiri::XML(string, url, encoding,
+                        options || XML::ParseOptions::DEFAULT_XML)
         end
       yield doc if block_given?
       doc

data/lib/nokogiri/css/generated_tokenizer.rb

@@ -1,6 +1,6 @@
 #--
 # DO NOT MODIFY!!!!
-# This file is automatically generated by rex 1.0.3
+# This file is automatically generated by rex 1.0.4
 # from lexical definition file "lib/nokogiri/css/tokenizer.rex".
 #++
 
@@ -11,133 +11,131 @@ class GeneratedTokenizer < GeneratedParser
 
   class ScanError < StandardError ; end
 
-  attr_reader :lineno
-  attr_reader :filename
+  attr_reader   :lineno
+  attr_reader   :filename
+  attr_accessor :state
 
-  def scan_setup ; end
+  def scan_setup(str)
+    @ss = StringScanner.new(str)
+    @lineno =  1
+    @state  = nil
+  end
 
-  def action &block
+  def action(&block)
     yield
   end
 
-  def scan_str( str )
-    scan_evaluate  str
+  def scan_str(str)
+    scan_setup(str)
     do_parse
   end
 
   def load_file( filename )
     @filename = filename
     open(filename, "r") do |f|
-      scan_evaluate  f.read
+      scan_setup(f.read)
     end
   end
 
   def scan_file( filename )
-    load_file  filename
+    load_file(filename)
     do_parse
   end
 
-  def next_token
-    @rex_tokens.shift
-  end
 
-  def scan_evaluate( str )
-    scan_setup
-    @rex_tokens = []
-    @lineno  =  1
-    ss = StringScanner.new(str)
-    state = nil
-    until ss.eos?
-      text = ss.peek(1)
-      @lineno  +=  1  if text == "\n"
-      case state
-      when nil
-        case
-        when (text = ss.scan(/[-@]?([_A-Za-z]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s\n\r\t\f])?|\\[^\n\r\f0-9A-Fa-f])([_A-Za-z0-9-]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s\n\r\t\f])?|\\[^\n\r\f0-9A-Fa-f])*\(\s*/))
-           @rex_tokens.push action { [:FUNCTION, text] }
+  def next_token
+    return if @ss.eos?
 
-        when (text = ss.scan(/[-@]?([_A-Za-z]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s\n\r\t\f])?|\\[^\n\r\f0-9A-Fa-f])([_A-Za-z0-9-]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s\n\r\t\f])?|\\[^\n\r\f0-9A-Fa-f])*/))
-           @rex_tokens.push action { [:IDENT, text] }
+    text = @ss.peek(1)
+    @lineno  +=  1  if text == "\n"
+    token = case @state
+    when nil
+      case
+      when (text = @ss.scan(/[-@]?([_A-Za-z]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s\n\r\t\f])?|\\[^\n\r\f0-9A-Fa-f])([_A-Za-z0-9-]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s\n\r\t\f])?|\\[^\n\r\f0-9A-Fa-f])*\(\s*/))
+         action { [:FUNCTION, text] }
 
-        when (text = ss.scan(/\#([_A-Za-z0-9-]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s\n\r\t\f])?|\\[^\n\r\f0-9A-Fa-f])+/))
-           @rex_tokens.push action { [:HASH, text] }
+      when (text = @ss.scan(/[-@]?([_A-Za-z]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s\n\r\t\f])?|\\[^\n\r\f0-9A-Fa-f])([_A-Za-z0-9-]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s\n\r\t\f])?|\\[^\n\r\f0-9A-Fa-f])*/))
+         action { [:IDENT, text] }
 
-        when (text = ss.scan(/[\s\r\n\f]*~=[\s\r\n\f]*/))
-           @rex_tokens.push action { [:INCLUDES, text] }
+      when (text = @ss.scan(/\#([_A-Za-z0-9-]|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s\n\r\t\f])?|\\[^\n\r\f0-9A-Fa-f])+/))
+         action { [:HASH, text] }
 
-        when (text = ss.scan(/[\s\r\n\f]*\|=[\s\r\n\f]*/))
-           @rex_tokens.push action { [:DASHMATCH, text] }
+      when (text = @ss.scan(/[\s\r\n\f]*~=[\s\r\n\f]*/))
+         action { [:INCLUDES, text] }
 
-        when (text = ss.scan(/[\s\r\n\f]*\^=[\s\r\n\f]*/))
-           @rex_tokens.push action { [:PREFIXMATCH, text] }
+      when (text = @ss.scan(/[\s\r\n\f]*\|=[\s\r\n\f]*/))
+         action { [:DASHMATCH, text] }
 
-        when (text = ss.scan(/[\s\r\n\f]*\$=[\s\r\n\f]*/))
-           @rex_tokens.push action { [:SUFFIXMATCH, text] }
+      when (text = @ss.scan(/[\s\r\n\f]*\^=[\s\r\n\f]*/))
+         action { [:PREFIXMATCH, text] }
 
-        when (text = ss.scan(/[\s\r\n\f]*\*=[\s\r\n\f]*/))
-           @rex_tokens.push action { [:SUBSTRINGMATCH, text] }
+      when (text = @ss.scan(/[\s\r\n\f]*\$=[\s\r\n\f]*/))
+         action { [:SUFFIXMATCH, text] }
 
-        when (text = ss.scan(/[\s\r\n\f]*!=[\s\r\n\f]*/))
-           @rex_tokens.push action { [:NOT_EQUAL, text] }
+      when (text = @ss.scan(/[\s\r\n\f]*\*=[\s\r\n\f]*/))
+         action { [:SUBSTRINGMATCH, text] }
 
-        when (text = ss.scan(/[\s\r\n\f]*=[\s\r\n\f]*/))
-           @rex_tokens.push action { [:EQUAL, text] }
+      when (text = @ss.scan(/[\s\r\n\f]*!=[\s\r\n\f]*/))
+         action { [:NOT_EQUAL, text] }
 
-        when (text = ss.scan(/[\s\r\n\f]*\)/))
-           @rex_tokens.push action { [:RPAREN, text] }
+      when (text = @ss.scan(/[\s\r\n\f]*=[\s\r\n\f]*/))
+         action { [:EQUAL, text] }
 
-        when (text = ss.scan(/[\s\r\n\f]*\[[\s\r\n\f]*/))
-           @rex_tokens.push action { [:LSQUARE, text] }
+      when (text = @ss.scan(/[\s\r\n\f]*\)/))
+         action { [:RPAREN, text] }
 
-        when (text = ss.scan(/[\s\r\n\f]*\]/))
-           @rex_tokens.push action { [:RSQUARE, text] }
+      when (text = @ss.scan(/[\s\r\n\f]*\[[\s\r\n\f]*/))
+         action { [:LSQUARE, text] }
 
-        when (text = ss.scan(/[\s\r\n\f]*\+[\s\r\n\f]*/))
-           @rex_tokens.push action { [:PLUS, text] }
+      when (text = @ss.scan(/[\s\r\n\f]*\]/))
+         action { [:RSQUARE, text] }
 
-        when (text = ss.scan(/[\s\r\n\f]*>[\s\r\n\f]*/))
-           @rex_tokens.push action { [:GREATER, text] }
+      when (text = @ss.scan(/[\s\r\n\f]*\+[\s\r\n\f]*/))
+         action { [:PLUS, text] }
 
-        when (text = ss.scan(/[\s\r\n\f]*,[\s\r\n\f]*/))
-           @rex_tokens.push action { [:COMMA, text] }
+      when (text = @ss.scan(/[\s\r\n\f]*>[\s\r\n\f]*/))
+         action { [:GREATER, text] }
 
-        when (text = ss.scan(/[\s\r\n\f]*~[\s\r\n\f]*/))
-           @rex_tokens.push action { [:TILDE, text] }
+      when (text = @ss.scan(/[\s\r\n\f]*,[\s\r\n\f]*/))
+         action { [:COMMA, text] }
 
-        when (text = ss.scan(/\:not\([\s\r\n\f]*/))
-           @rex_tokens.push action { [:NOT, text] }
+      when (text = @ss.scan(/[\s\r\n\f]*~[\s\r\n\f]*/))
+         action { [:TILDE, text] }
 
-        when (text = ss.scan(/-?([0-9]+|[0-9]*\.[0-9]+)/))
-           @rex_tokens.push action { [:NUMBER, text] }
+      when (text = @ss.scan(/\:not\([\s\r\n\f]*/))
+         action { [:NOT, text] }
 
-        when (text = ss.scan(/[\s\r\n\f]*\/\/[\s\r\n\f]*/))
-           @rex_tokens.push action { [:DOUBLESLASH, text] }
+      when (text = @ss.scan(/-?([0-9]+|[0-9]*\.[0-9]+)/))
+         action { [:NUMBER, text] }
 
-        when (text = ss.scan(/[\s\r\n\f]*\/[\s\r\n\f]*/))
-           @rex_tokens.push action { [:SLASH, text] }
+      when (text = @ss.scan(/[\s\r\n\f]*\/\/[\s\r\n\f]*/))
+         action { [:DOUBLESLASH, text] }
 
-        when (text = ss.scan(/U\+[0-9a-f?]{1,6}(-[0-9a-f]{1,6})?/))
-           @rex_tokens.push action {[:UNICODE_RANGE, text] }
+      when (text = @ss.scan(/[\s\r\n\f]*\/[\s\r\n\f]*/))
+         action { [:SLASH, text] }
 
-        when (text = ss.scan(/[\s\t\r\n\f]+/))
-           @rex_tokens.push action { [:S, text] }
+      when (text = @ss.scan(/U\+[0-9a-f?]{1,6}(-[0-9a-f]{1,6})?/))
+         action {[:UNICODE_RANGE, text] }
 
-        when (text = ss.scan(/"([^\n\r\f"]|\n|\r\n|\r|\f|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s\n\r\t\f])?|\\[^\n\r\f0-9A-Fa-f])*"|'([^\n\r\f']|\n|\r\n|\r|\f|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s\n\r\t\f])?|\\[^\n\r\f0-9A-Fa-f])*'/))
-           @rex_tokens.push action { [:STRING, text] }
+      when (text = @ss.scan(/[\s\t\r\n\f]+/))
+         action { [:S, text] }
 
-        when (text = ss.scan(/./))
-           @rex_tokens.push action { [text, text] }
+      when (text = @ss.scan(/"([^\n\r\f"]|\n|\r\n|\r|\f|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s\n\r\t\f])?|\\[^\n\r\f0-9A-Fa-f])*"|'([^\n\r\f']|\n|\r\n|\r|\f|[^\0-\177]|\\[0-9A-Fa-f]{1,6}(\r\n|[\s\n\r\t\f])?|\\[^\n\r\f0-9A-Fa-f])*'/))
+         action { [:STRING, text] }
 
-        else
-          text = ss.string[ss.pos .. -1]
-          raise  ScanError, "can not match: '" + text + "'"
-        end  # if
+      when (text = @ss.scan(/./))
+         action { [text, text] }
 
       else
-        raise  ScanError, "undefined state: '" + state.to_s + "'"
-      end  # case state
-    end  # until ss
-  end  # def scan_evaluate
+        text = @ss.string[@ss.pos .. -1]
+        raise  ScanError, "can not match: '" + text + "'"
+      end  # if
+
+    else
+      raise  ScanError, "undefined state: '" + state.to_s + "'"
+    end  # case state
+    token
+  end  # def next_token
 
 end # class
 end

data/lib/nokogiri/css/tokenizer.rb

@@ -1,11 +1,7 @@
 module Nokogiri
   module CSS
     class Tokenizer < GeneratedTokenizer
-      ###
-      # Scan and tokenize +str+
-      def scan(str)
-        scan_evaluate(str)
-      end
+      alias :scan :scan_setup
     end
   end
 end

data/lib/nokogiri/decorators/hpricot/node_set.rb

@@ -47,7 +47,7 @@ module Nokogiri
             end
           end
           sub_set
-        end          
+        end
       end
     end
   end

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