nokogiri 1.4.0-java → 1.4.1-java

data/lib/nokogiri/css/generated_tokenizer.rb

@@ -29,6 +29,7 @@ class GeneratedTokenizer < GeneratedParser
     scan_setup(str)
     do_parse
   end
+  alias :scan :scan_str
 
   def load_file( filename )
     @filename = filename
@@ -51,7 +52,10 @@ class GeneratedTokenizer < GeneratedParser
     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*/))
+      when (text = @ss.scan(/has\([\s\r\n\f]*/))
+         action { [:HAS, 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])*\([\s\r\n\f]*/))
          action { [:FUNCTION, 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])*/))

data/lib/nokogiri/css/parser.y

@@ -2,7 +2,7 @@ class Nokogiri::CSS::GeneratedParser
 
 token FUNCTION INCLUDES DASHMATCH LBRACE HASH PLUS GREATER S STRING IDENT
 token COMMA NUMBER PREFIXMATCH SUFFIXMATCH SUBSTRINGMATCH TILDE NOT_EQUAL
-token SLASH DOUBLESLASH NOT EQUAL RPAREN LSQUARE RSQUARE
+token SLASH DOUBLESLASH NOT EQUAL RPAREN LSQUARE RSQUARE HAS
 
 rule
   selector
@@ -112,6 +112,9 @@ rule
     | NOT expr RPAREN {
         result = Node.new(:FUNCTION, [val.first.strip, val[1]].flatten)
       }
+    | HAS selector RPAREN {
+        result = Node.new(:FUNCTION, [val.first.strip, val[1]].flatten)
+      }
     ;
   expr
     : NUMBER COMMA expr { result = [val.first, val.last] }

data/lib/nokogiri/css/tokenizer.rex

@@ -22,7 +22,8 @@ rule
 
 # [:state]  pattern  [actions]
 
-            {ident}\(\s*     { [:FUNCTION, text] }
+            has\({w}         { [:HAS, text] }
+            {ident}\({w}     { [:FUNCTION, text] }
             {ident}          { [:IDENT, text] }
             \#{name}         { [:HASH, text] }
             {w}~={w}         { [:INCLUDES, text] }

data/lib/nokogiri/css/xpath_visitor.rb

@@ -31,6 +31,8 @@ module Nokogiri
           "last() = 1"
         when /^comment\(/
           "comment()"
+        when /^has\(/
+          node.value[1].accept(self)
         else
           args = ['.'] + node.value[1..-1]
           "#{node.value.first}#{args.join(', ')})"

data/lib/nokogiri/ffi/encoding_handler.rb

@@ -0,0 +1,42 @@
+module Nokogiri
+  class EncodingHandler
+    # :stopdoc:
+    attr_accessor :cstruct
+
+    class << self
+      def [](key)
+        handler = LibXML.xmlFindCharEncodingHandler(key)
+        handler.null? ? nil : wrap(handler)
+      end
+
+      def delete(name)
+        (LibXML.xmlDelEncodingAlias(name) != 0) ? nil : true
+      end
+
+      def alias(from, to)
+        LibXML.xmlAddEncodingAlias(from, to)
+        to
+      end
+
+      def clear_aliases!
+        LibXML.xmlCleanupEncodingAliases
+        self
+      end
+
+      private
+
+      def wrap(ptr)
+        cstruct = LibXML::XmlCharEncodingHandler.new(ptr)
+        eh = Nokogiri::EncodingHandler.allocate
+        eh.cstruct = cstruct
+        eh
+      end
+
+    end
+
+    def name
+      cstruct[:name]
+    end
+    # :startdoc:
+  end
+end

data/lib/nokogiri/ffi/html/element_description.rb

@@ -68,16 +68,12 @@ module Nokogiri
       private
 
       def get_string_array_from(sym) # :nodoc:
-        list = []
-        return list if cstruct[sym].null?
-
-        j = 0
-        while (ptr = cstruct[sym].get_pointer(j * FFI.type_size(:pointer))) && ! ptr.null?
-          list << ptr.read_string
-          j += 1
+        ptr = cstruct[sym]
+        unless ptr.null?
+          ptr.get_array_of_string(0)
+        else
+          []
         end
-
-        list
       end
 
     end

data/lib/nokogiri/ffi/libxml.rb

@@ -3,8 +3,12 @@ module Nokogiri
   module LibXML
     extend FFI::Library
     if RUBY_PLATFORM =~ /java/ && java.lang.System.getProperty('os.name') =~ /windows/i
-      raise(RuntimeError, "Nokogiri requires JRuby 1.4.0RC1 or later on Windows") if JRUBY_VERSION < "1.4.0RC1"
-      ffi_lib 'libxml2', 'libxslt', 'libexslt', 'msvcrt'
+      raise(RuntimeError, "Nokogiri requires JRuby 1.4.0 or later on Windows") if JRUBY_VERSION < "1.4.0"
+      dll_dir = File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "..", "ext", "nokogiri"))
+      libs = ["libxml2.dll", "libxslt.dll", "libexslt.dll"].collect do |lib|
+        File.join(dll_dir, lib).tr("/","\\") # see http://jira.codehaus.org/browse/JRUBY-2763
+      end + ["msvcrt"]
+      ffi_lib(*libs)
     else
       ffi_lib 'xml2', 'xslt', 'exslt'
     end
@@ -18,6 +22,8 @@ module Nokogiri
 
   LIBXML_PARSER_VERSION = LibXML.__xmlParserVersion().read_pointer.read_string
   LIBXML_VERSION = LIBXML_PARSER_VERSION.scan(/^(.*)(..)(..)$/).first.collect{|j|j.to_i}.join(".")
+
+  LIBXML_ICONV_ENABLED = true # sigh.
 end
 
 require 'nokogiri/version'
@@ -57,6 +63,12 @@ module Nokogiri
     callback :start_element_ns_sax2_func, [:pointer, :pointer, :pointer, :pointer, :int, :pointer, :int, :int, :pointer], :void
     callback :end_element_ns_sax2_func, [:pointer, :pointer, :pointer, :pointer], :void
 
+    # encoding.c
+    attach_function :xmlFindCharEncodingHandler, [:string], :pointer
+    attach_function :xmlDelEncodingAlias, [:string], :int
+    attach_function :xmlAddEncodingAlias, [:string, :string], :int
+    attach_function :xmlCleanupEncodingAliases, [], :void
+
     # HTMLparser.c
     attach_function :htmlReadMemory, [:string, :int, :string, :string, :int], :pointer
     attach_function :htmlReadIO, [:io_read_callback, :io_close_callback, :pointer, :string, :string, :int], :pointer
@@ -88,6 +100,7 @@ module Nokogiri
     attach_function :xmlFreeParserCtxt, [:pointer], :void
     attach_function :xmlCreatePushParserCtxt, [:pointer, :pointer, :string, :int, :string], :pointer
     attach_function :xmlParseChunk, [:pointer, :string, :int, :int], :int
+    attach_function :xmlCtxtUseOptions, [:pointer, :int], :int
 
     # tree.c
     attach_function :xmlNewDoc, [:string], :pointer
@@ -131,7 +144,7 @@ module Nokogiri
     attach_function :xmlGetIntSubset, [:pointer], :pointer
     attach_function :xmlBufferCreate, [], :pointer
     attach_function :xmlBufferFree, [:pointer], :void
-    attach_function :xmlSplitQName2, [:string, :pointer], :pointer # returns char* that must be freed
+    attach_function :xmlSplitQName2, [:string, :buffer_out], :pointer # returns char* that must be freed
     attach_function :xmlNewDocProp, [:pointer, :string, :string], :pointer
     attach_function :xmlFreePropList, [:pointer], :void
     attach_function :xmlCreateIntSubset, [:pointer] * 4, :pointer
@@ -245,7 +258,7 @@ module Nokogiri
     attach_function :xsltParseStylesheetDoc, [:pointer], :pointer
     attach_function :xsltFreeStylesheet, [:pointer], :void
     attach_function :xsltApplyStylesheet, [:pointer, :pointer, :pointer], :pointer
-    attach_function :xsltSaveResultToString, [:pointer, :pointer, :pointer, :pointer], :int
+    attach_function :xsltSaveResultToString, [:buffer_out, :buffer_out, :pointer, :pointer], :int
     attach_function :xsltSetGenericErrorFunc, [:pointer, :generic_error_handler], :void
 
     # exslt.c
@@ -281,8 +294,9 @@ module Nokogiri
     attach_function :xmlSwitchEncoding, [:pointer, :int], :void
 
     # helpers
+    POINTER_SIZE = FFI.type_size(:pointer)
     def self.pointer_offset(n)
-      n * FFI.type_size(:pointer) # byte offset of nth pointer in an array of pointers
+      n * POINTER_SIZE # byte offset of nth pointer in an array of pointers
     end
   end
 end
@@ -293,8 +307,10 @@ require 'nokogiri/syntax_error'
 require 'nokogiri/xml/syntax_error'
 
 [ "io_callbacks",
+  "encoding_handler",
   "structs/common_node",
   "structs/xml_alloc",
+  "structs/xml_char_encoding_handler",
   "structs/xml_document",
   "structs/xml_node",
   "structs/xml_dtd",

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

@@ -0,0 +1,11 @@
+module Nokogiri
+  module LibXML # :nodoc:
+    class XmlCharEncodingHandler < FFI::Struct # :nodoc:
+      layout(
+        :name,          :string,
+        :input,         :pointer,
+        :output,        :pointer
+        )
+    end
+  end
+end

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

@@ -47,12 +47,12 @@ module Nokogiri
       end
 
       def unlinked_nodes
-        LibXML::XmlNodeSetCast.new(self[:_private].get_pointer(FFI.type_size(:pointer)))
+        LibXML::XmlNodeSetCast.new(self[:_private].get_pointer(LibXML.pointer_offset(1)))
       end
 
       def alloc_tuple
-        self[:_private] = LibXML.calloc(FFI.type_size(:pointer), 2)
-        self[:_private].put_pointer(FFI.type_size(:pointer), LibXML.xmlXPathNodeSetCreate(nil))
+        self[:_private] = LibXML.calloc(LibXML::POINTER_SIZE, 2)
+        self[:_private].put_pointer(LibXML.pointer_offset(1), LibXML.xmlXPathNodeSetCreate(nil))
       end
     end
 

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

@@ -3,7 +3,116 @@ module Nokogiri
   module LibXML
     class XmlSaxPushParserContext < FFI::ManagedStruct
 
-      layout :dummy, :int, 0 # to avoid @layout warnings
+      layout(
+        :sax,           :pointer,       # struct _xmlSAXHandler *sax;       /* The SAX handler */
+        :userData,      :pointer,       # void            *userData;        /* For SAX interface only, used by DOM build */
+        :myDoc,         :pointer,       # xmlDocPtr           myDoc;        /* the document being built */
+        :wellFormed,    :int,           # int            wellFormed;        /* is the document well formed */
+        :replaceEntities, :int,         # int       replaceEntities;        /* shall we replace entities ? */
+        :version,       :pointer,       # const xmlChar    *version;        /* the XML version string */
+        :encoding,      :pointer,       # const xmlChar   *encoding;        /* the declared encoding, if any */
+        :standalone,    :int,           # int            standalone;        /* standalone document */
+        :html,          :int,           # int                  html;        /* an HTML(1)/Docbook(2) document
+
+        :input,         :pointer,       # xmlParserInputPtr  input;         /* Current input stream */
+        :inputNr,       :int,           # int                inputNr;       /* Number of current input streams */
+        :inputMax,      :int,           # int                inputMax;      /* Max number of input streams */
+        :inputTab,      :pointer,       # xmlParserInputPtr *inputTab;      /* stack of inputs */
+
+        :node,          :pointer,       # xmlNodePtr         node;          /* Current parsed Node */
+        :nodeNr,        :int,           # int                nodeNr;        /* Depth of the parsing stack */
+        :nodeMax,       :int,           # int                nodeMax;       /* Max depth of the parsing stack */
+        :nodeTab,       :pointer,       # xmlNodePtr        *nodeTab;       /* array of nodes */
+
+        :record_info,   :int,           # int record_info;                  /* Whether node info should be kept */
+
+        # xmlParserNodeInfoSeq node_seq;    /* info about each node parsed */
+                :node_seq_maximum, :ulong,
+                :node_seq_length,  :ulong,
+                :node_seq_buffer,  :pointer,
+
+        :errNo,         :int,           # int errNo;                        /* error code */
+
+        :hasExternalSubset, :int,       # int     hasExternalSubset;        /* reference and external subset */
+        :hasPErefs,     :int,           # int             hasPErefs;        /* the internal subset has PE refs */
+        :external,      :int,           # int              external;        /* are we parsing an external entity */
+
+        :valid,         :int,           # int                 valid;        /* is the document valid */
+        :validate,      :int,           # int              validate;        /* shall we try to validate ? */
+
+        # xmlValidCtxt        vctxt;        /* The validity context */
+                :vctxt_userData,        :pointer,       # void *userData;			/* user specific data block */
+                :vctxt_error,           :pointer,       # xmlValidityErrorFunc error;		/* the callback in case of errors */
+                :vctxt_warning,         :pointer,       # xmlValidityWarningFunc warning;	/* the callback in case of warning */
+                :vctxt_node,            :pointer,       # xmlNodePtr         node;          /* Current parsed Node */
+                :vctxt_nodeNr,          :int,           # int                nodeNr;        /* Depth of the parsing stack */
+                :vctxt_nodeMax,         :int,           # int                nodeMax;       /* Max depth of the parsing stack */
+                :vctxt_nodeTab,         :pointer,       # xmlNodePtr        *nodeTab;       /* array of nodes */
+
+                :vctxt_finishDtd,       :int,           # unsigned int     finishDtd;       /* finished validating the Dtd ? */
+                :vctxt_doc,             :pointer,       # xmlDocPtr              doc;       /* the document */
+                :vctxt_valid,           :int,           # int                  valid;       /* temporary validity check result */
+                :vctxt_vstate,          :pointer,       # xmlValidState     *vstate;        /* current state */
+                :vctxt_vstatNr,         :int,           # int                vstateNr;      /* Depth of the validation stack */
+                :vctxt_vstateMax,       :int,           # int                vstateMax;     /* Max depth of the validation stack */
+                :vctxt_vstateTab,       :pointer,       # xmlValidState     *vstateTab;     /* array of validation states */
+                :vctxt_am,              :pointer,       # xmlAutomataPtr            am;     /* the automata */
+                :vctxt_state,           :pointer,       # xmlAutomataStatePtr    state;     /* used to build the automata */
+
+        :instate,       :int,           # xmlParserInputState instate;      /* current type of input */
+        :token,         :int,           # int                 token;        /* next char look-ahead */    
+
+        :directory,     :pointer,       # char           *directory;        /* the data directory */
+        :name,          :pointer,       # const xmlChar     *name;          /* Current parsed Node */
+        :nameNr,        :int,           # int                nameNr;        /* Depth of the parsing stack */
+        :nameMax,       :int,           # int                nameMax;       /* Max depth of the parsing stack */
+        :nameTab,       :pointer,       # const xmlChar *   *nameTab;       /* array of nodes */
+
+        :nbChars,       :long,          # long               nbChars;       /* number of xmlChar processed */
+        :checkIndex,    :long,          # long            checkIndex;       /* used by progressive parsing lookup */
+        :keepBlanks,    :int,           # int             keepBlanks;       /* ugly but ... */
+        :disableSAX,    :int,           # int             disableSAX;       /* SAX callbacks are disabled */
+        :inSubset,      :int,           # int               inSubset;       /* Parsing is in int 1/ext 2 subset */
+        :intSubName,    :pointer,       # const xmlChar *    intSubName;    /* name of subset */
+        :extSubURI,     :pointer,       # xmlChar *          extSubURI;     /* URI of external subset */
+        :extSubSystem,  :pointer,       # xmlChar *          extSubSystem;  /* SYSTEM ID of external subset */
+
+        :space,         :pointer,       # int *              space;         /* Should the parser preserve spaces */
+        :spaceNr,       :int,           # int                spaceNr;       /* Depth of the parsing stack */
+        :spaceMax,      :int,           # int                spaceMax;      /* Max depth of the parsing stack */
+        :spaceTab,      :pointer,       # int *              spaceTab;      /* array of space infos */
+        :depth,         :int,           # int                depth;         /* to prevent entity substitution loops */
+        :entity,        :pointer,       # xmlParserInputPtr  entity;        /* used to check entities boundaries */
+        :charset,       :int,           # int                charset;       /* encoding of the in-memory content
+        :nodelen,       :int,           # int                nodelen;       /* Those two fields are there to */
+        :nodemem,       :int,           # int                nodemem;       /* Speed up large node parsing */
+        :pedantic,      :int,           # int                pedantic;      /* signal pedantic warnings */
+        :_private,      :pointer,       # void              *_private;      /* For user data, libxml won't touch it */
+
+        :loadsubset,    :int,           # int                loadsubset;    /* should the external subset be loaded */
+        :linenumbers,   :int,           # int                linenumbers;   /* set line number in element content */
+        :catalogs,      :pointer,       # void              *catalogs;      /* document's own catalog */
+        :recovery,      :int,           # int                recovery;      /* run in recovery mode */
+        :progressive,   :int,           # int                progressive;   /* is this a progressive parsing */
+        :dict,          :pointer,       # xmlDictPtr         dict;          /* dictionnary for the parser */
+        :atts,          :pointer,       # const xmlChar *   *atts;          /* array for the attributes callbacks */
+        :maxatts,       :int,           # int                maxatts;       /* the size of the array */
+        :docdict,       :int,           # int                docdict;       /* use strings from dict to build tree */
+        :str_xml,       :pointer,       # const xmlChar *str_xml;
+        :str_xmlns,     :pointer,       # const xmlChar *str_xmlns;
+        :str_xml_ns,    :pointer,       # const xmlChar *str_xml_ns;
+
+        :sax2,          :int,           # int                sax2;          /* operating in the new SAX mode */
+        :nsNr,          :int,           # int                nsNr;          /* the number of inherited namespaces */
+        :nsMax,         :int,           # int                nsMax;         /* the size of the arrays */
+        :nsTab,         :pointer,       # const xmlChar *   *nsTab;         /* the array of prefix/namespace name */
+        :attallocs,     :pointer,       # int               *attallocs;     /* which attribute were allocated */
+        :pushTab,       :pointer,       # void *            *pushTab;       /* array of data for push */
+        :attsDefault,   :pointer,       # xmlHashTablePtr    attsDefault;   /* defaulted attributes if any */
+        :attsSpecial,   :pointer,       # xmlHashTablePtr    attsSpecial;   /* non-CDATA attributes if any */
+        :nsWellFormed,  :int,           # int                nsWellFormed;  /* is the document XML Nanespace okay */
+        :options,       :int            # int                options;       /* Extra options */
+        )
 
       def self.release ptr
         LibXML.xmlFreeParserCtxt(ptr)

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

@@ -41,12 +41,11 @@ module Nokogiri
         return nil if attr_ptr.null?
 
         ahash = {}
-        proc = lambda do |payload, data, name|
+        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
-        LibXML.xmlHashScan(attr_ptr, proc, nil)
         ahash
       end
 
@@ -57,10 +56,9 @@ module Nokogiri
         return nil if attr_ptr.null?
 
         ahash = {}
-        proc = lambda do |payload, data, name|
+        LibXML.xmlHashScan(attr_ptr, nil) do |payload, data, name|
           ahash[name] = Node.wrap(payload)
         end
-        LibXML.xmlHashScan(attr_ptr, proc, nil)
         ahash
       end
     end

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

@@ -77,9 +77,39 @@ module Nokogiri
         cstruct_node_from :prev
       end
 
-      def replace_with_node(new_node)
-        LibXML.xmlReplaceNode(cstruct, new_node.cstruct)
-        Node.send(:relink_namespace, new_node.cstruct)
+      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
 
@@ -114,7 +144,7 @@ module Nokogiri
       def namespaced_key?(attribute, namespace)
         prop = LibXML.xmlHasNsProp(cstruct, attribute.to_s,
           namespace.nil? ? nil : namespace.to_s)
-        prop.null? ? false : true
+        !prop.null?
       end
 
       def []=(property, value)
@@ -184,7 +214,7 @@ module Nokogiri
         content
       end
 
-      def add_child(child)
+      def add_child_node child
         Node.reparent_node_with(child, self) do |child_cstruct, my_cstruct|
           LibXML.xmlAddChild(my_cstruct, child_cstruct)
         end
@@ -210,13 +240,13 @@ module Nokogiri
         val
       end
 
-      def add_next_sibling(next_sibling)
+      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(prev_sibling)
+      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
@@ -348,15 +378,6 @@ module Nokogiri
         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 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.type == TEXT_NODE
           node.cstruct.keep_reference_from_document!
           node.cstruct = LibXML::XmlNode.new(LibXML.xmlDocCopyNode(node.cstruct, other.cstruct.document, 1))
@@ -378,7 +399,7 @@ module Nokogiri
           node.cstruct.keep_reference_from_document!
         end
 
-        reparented_struct = LibXML::XmlNode.new(reparented_struct)
+        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.