nokogiri 1.2.3-java → 1.3.0-java

data/ext/nokogiri/xml_document_fragment.h

@@ -1,7 +1,7 @@
 #ifndef NOKOGIRI_XML_DOCUMENT_FRAGMENT
 #define NOKOGIRI_XML_DOCUMENT_FRAGMENT
 
-#include <native.h>
+#include <nokogiri.h>
 
 void init_xml_document_fragment();
 

data/ext/nokogiri/xml_dtd.c

@@ -20,7 +20,7 @@ static void element_copier(void *_payload, void *data, xmlChar *name)
   VALUE hash = (VALUE)data;
   xmlNodePtr payload = (xmlNodePtr)_payload;
 
-  VALUE element = Nokogiri_wrap_xml_node(payload);
+  VALUE element = Nokogiri_wrap_xml_node(Qnil, payload);
 
   rb_hash_aset(hash, NOKOGIRI_STR_NEW2(name, payload->doc->encoding), element);
 }

data/ext/nokogiri/xml_dtd.h

@@ -1,7 +1,7 @@
 #ifndef NOKOGIRI_XML_DTD
 #define NOKOGIRI_XML_DTD
 
-#include <native.h>
+#include <nokogiri.h>
 
 void init_xml_dtd();
 

data/ext/nokogiri/xml_entity_reference.c

@@ -6,17 +6,26 @@
  *
  * Create a new EntityReference element on the +document+ with +name+
  */
-static VALUE new(VALUE klass, VALUE doc, VALUE name)
+static VALUE new(int argc, VALUE *argv, VALUE klass)
 {
   xmlDocPtr xml_doc;
-  Data_Get_Struct(doc, xmlDoc, xml_doc);
+  VALUE document;
+  VALUE name;
+  VALUE rest;
+
+  rb_scan_args(argc, argv, "2*", &document, &name, &rest);
+
+  Data_Get_Struct(document, xmlDoc, xml_doc);
 
   xmlNodePtr node = xmlNewReference(
       xml_doc,
       (const xmlChar *)StringValuePtr(name)
   );
 
-  VALUE rb_node = Nokogiri_wrap_xml_node(node);
+  NOKOGIRI_ROOT_NODE(node);
+
+  VALUE rb_node = Nokogiri_wrap_xml_node(klass, node);
+  rb_funcall2(rb_node, rb_intern("initialize"), argc, argv);
 
   if(rb_block_given_p()) rb_yield(rb_node);
 
@@ -37,5 +46,5 @@ void init_xml_entity_reference()
 
   cNokogiriXmlEntityReference = klass;
 
-  rb_define_singleton_method(klass, "new", new, 2);
+  rb_define_singleton_method(klass, "new", new, -1);
 }

data/ext/nokogiri/xml_entity_reference.h

@@ -1,7 +1,7 @@
 #ifndef NOKOGIRI_XML_ENTITY_REFERENCE
 #define NOKOGIRI_XML_ENTITY_REFERENCE
 
-#include <native.h>
+#include <nokogiri.h>
 
 void init_xml_entity_reference();
 

data/ext/nokogiri/xml_io.h

@@ -1,7 +1,7 @@
 #ifndef NOKOGIRI_XML_IO
 #define NOKOGIRI_XML_IO
 
-#include <native.h>
+#include <nokogiri.h>
 
 int io_read_callback(void * ctx, char * buffer, int len);
 int io_write_callback(void * ctx, char * buffer, int len);

data/ext/nokogiri/xml_namespace.c

@@ -0,0 +1,69 @@
+#include <xml_namespace.h>
+
+VALUE cNokogiriXmlNamespace ;
+
+/*
+ * call-seq:
+ *  prefix
+ *
+ * Get the prefix for this namespace.  Returns +nil+ if there is no prefix.
+ */
+static VALUE prefix(VALUE self)
+{
+  xmlNsPtr ns;
+  xmlDocPtr doc;
+
+  Data_Get_Struct(self, xmlNs, ns);
+  if(!ns->prefix) return Qnil;
+
+  Data_Get_Struct(rb_iv_get(self, "@document"), xmlDoc, doc);
+
+  return NOKOGIRI_STR_NEW2(ns->prefix, doc->encoding);
+}
+
+/*
+ * call-seq:
+ *  href
+ *
+ * Get the href for this namespace
+ */
+static VALUE href(VALUE self)
+{
+  xmlNsPtr ns;
+  xmlDocPtr doc;
+
+  Data_Get_Struct(self, xmlNs, ns);
+  if(!ns->href) return Qnil;
+
+  Data_Get_Struct(rb_iv_get(self, "@document"), xmlDoc, doc);
+
+  return NOKOGIRI_STR_NEW2(ns->href, doc->encoding);
+}
+
+VALUE Nokogiri_wrap_xml_namespace(xmlDocPtr doc, xmlNsPtr node)
+{
+  assert(doc->_private);
+
+  if(node->_private)
+    return (VALUE)node->_private;
+
+  VALUE ns = Data_Wrap_Struct(cNokogiriXmlNamespace, 0, 0, node);
+
+  rb_iv_set(ns, "@document", DOC_RUBY_OBJECT(doc));
+
+  node->_private = (void *)ns;
+
+  return ns;
+}
+
+void init_xml_namespace()
+{
+  VALUE nokogiri  = rb_define_module("Nokogiri");
+  VALUE xml       = rb_define_module_under(nokogiri, "XML");
+  VALUE klass     = rb_define_class_under(xml, "Namespace", rb_cObject);
+
+  cNokogiriXmlNamespace = klass;
+
+  rb_define_method(klass, "prefix", prefix, 0);
+  rb_define_method(klass, "href", href, 0);
+}

data/ext/nokogiri/xml_namespace.h

@@ -0,0 +1,12 @@
+#ifndef NOKOGIRI_XML_NAMESPACE
+#define NOKOGIRI_XML_NAMESPACE
+
+#include <nokogiri.h>
+
+void init_xml_namespace();
+
+extern VALUE cNokogiriXmlNamespace ;
+
+VALUE Nokogiri_wrap_xml_namespace(xmlDocPtr doc, xmlNsPtr node) ;
+
+#endif

data/ext/nokogiri/xml_node.c

@@ -10,20 +10,64 @@ static void debug_node_dealloc(xmlNodePtr x)
 #  define debug_node_dealloc 0
 #endif
 
+static void mark(xmlNodePtr node)
+{
+  rb_gc_mark(DOC_RUBY_OBJECT(node->doc));
+}
+
 /* :nodoc: */
 typedef xmlNodePtr (*node_other_func)(xmlNodePtr, xmlNodePtr);
 
+/* :nodoc: */
+static void relink_namespace(xmlNodePtr reparented)
+{
+  // Make sure that our reparented node has the correct namespaces
+  if(reparented->doc != (xmlDocPtr)reparented->parent)
+    xmlSetNs(reparented, reparented->parent->ns);
+
+  // Search our parents for an existing definition
+  if(reparented->nsDef) {
+    xmlNsPtr ns = xmlSearchNsByHref(
+        reparented->doc,
+        reparented->parent,
+        reparented->nsDef->href
+    );
+    if(ns && ns != reparented->nsDef) reparented->nsDef = NULL;
+  }
+
+  // Only walk all children if there actually is a namespace we need to
+  // reparent.
+  if(NULL == reparented->ns) return;
+
+  // When a node gets reparented, walk it's children to make sure that
+  // their namespaces are reparented as well.
+  xmlNodePtr child = reparented->children;
+  while(NULL != child) {
+    relink_namespace(child);
+    child = child->next;
+  }
+}
+
 /* :nodoc: */
 static VALUE reparent_node_with(VALUE node_obj, VALUE other_obj, node_other_func func)
 {
   VALUE reparented_obj ;
   xmlNodePtr node, other, reparented ;
 
+  if(! rb_funcall(node_obj, rb_intern("is_a?"), 1, cNokogiriXmlNode))
+    rb_raise(rb_eArgError, "node must be a Nokogiri::XML::Node");
+
   Data_Get_Struct(node_obj, xmlNode, node);
   Data_Get_Struct(other_obj, xmlNode, other);
 
   if (node->doc == other->doc) {
     xmlUnlinkNode(node) ;
+    if ( node->type == XML_TEXT_NODE
+         && other->type == XML_TEXT_NODE
+         && is_2_6_16() ) {
+      other->content = xmlStrdup(other->content); // we'd rather leak than segfault.
+    }
+
     if(!(reparented = (*func)(other, node))) {
       rb_raise(rb_eRuntimeError, "Could not reparent node (1)");
     }
@@ -47,21 +91,10 @@ static VALUE reparent_node_with(VALUE node_obj, VALUE other_obj, node_other_func
     DATA_PTR(node_obj) = reparented ;
   }
 
-  // Make sure that our reparented node has the correct namespaces
-  if(reparented->doc != (xmlDocPtr)reparented->parent)
-    reparented->ns = reparented->parent->ns;
-
-  // Search our parents for an existing definition
-  if(reparented->nsDef) {
-    xmlNsPtr ns = xmlSearchNsByHref(
-        reparented->doc,
-        reparented,
-        reparented->nsDef->href
-    );
-    if(ns) reparented->nsDef = NULL;
-  }
+  // Appropriately link in namespaces
+  relink_namespace(reparented);
 
-  reparented_obj = Nokogiri_wrap_xml_node(reparented);
+  reparented_obj = Nokogiri_wrap_xml_node(Qnil, reparented);
 
   rb_funcall(reparented_obj, rb_intern("decorate!"), 0);
 
@@ -69,6 +102,19 @@ static VALUE reparent_node_with(VALUE node_obj, VALUE other_obj, node_other_func
 }
 
 
+/*
+ * call-seq:
+ *  document
+ *
+ * Get the document for this Node
+ */
+static VALUE document(VALUE self)
+{
+  xmlNodePtr node;
+  Data_Get_Struct(self, xmlNode, node);
+  return DOC_RUBY_OBJECT(node->doc);
+}
+
 /*
  * call-seq:
  *  pointer_id
@@ -123,7 +169,7 @@ static VALUE internal_subset(VALUE self)
 
   if(!dtd) return Qnil;
 
-  return Nokogiri_wrap_xml_node((xmlNodePtr)dtd);
+  return Nokogiri_wrap_xml_node(Qnil, (xmlNodePtr)dtd);
 }
 
 /*
@@ -146,7 +192,7 @@ static VALUE duplicate_node(int argc, VALUE *argv, VALUE self)
   dup = xmlDocCopyNode(node, node->doc, NUM2INT(level));
   if(dup == NULL) return Qnil;
 
-  return Nokogiri_wrap_xml_node(dup);
+  return Nokogiri_wrap_xml_node(rb_obj_class(self), dup);
 }
 
 /*
@@ -193,7 +239,7 @@ static VALUE next_sibling(VALUE self)
   sibling = node->next;
   if(!sibling) return Qnil;
 
-  return Nokogiri_wrap_xml_node(sibling) ;
+  return Nokogiri_wrap_xml_node(Qnil, sibling) ;
 }
 
 /*
@@ -210,7 +256,7 @@ static VALUE previous_sibling(VALUE self)
   sibling = node->prev;
   if(!sibling) return Qnil;
 
-  return Nokogiri_wrap_xml_node(sibling);
+  return Nokogiri_wrap_xml_node(Qnil, sibling);
 }
 
 /* :nodoc: */
@@ -221,6 +267,9 @@ static VALUE replace(VALUE self, VALUE _new_node)
   Data_Get_Struct(_new_node, xmlNode, new_node);
 
   xmlReplaceNode(node, new_node);
+
+  // Appropriately link in namespaces
+  relink_namespace(new_node);
   return self ;
 }
 
@@ -246,7 +295,10 @@ static VALUE children(VALUE self)
     child = child->next;
   }
 
-  return Nokogiri_wrap_xml_node_set(set);
+  VALUE node_set = Nokogiri_wrap_xml_node_set(set);
+  rb_iv_set(node_set, "@document", DOC_RUBY_OBJECT(node->doc));
+
+  return node_set;
 }
 
 /*
@@ -263,7 +315,7 @@ static VALUE child(VALUE self)
   child = node->children;
   if(!child) return Qnil;
 
-  return Nokogiri_wrap_xml_node(child);
+  return Nokogiri_wrap_xml_node(Qnil, child);
 }
 
 /*
@@ -281,6 +333,22 @@ static VALUE key_eh(VALUE self, VALUE attribute)
   return Qfalse;
 }
 
+/*
+ * call-seq:
+ *  namespaced_key?(attribute, namespace)
+ *
+ * Returns true if +attribute+ is set with +namespace+
+ */
+static VALUE namespaced_key_eh(VALUE self, VALUE attribute, VALUE namespace)
+{
+  xmlNodePtr node;
+  Data_Get_Struct(self, xmlNode, node);
+  if(xmlHasNsProp(node, (xmlChar *)StringValuePtr(attribute),
+        Qnil == namespace ? NULL : (xmlChar *)StringValuePtr(namespace)))
+    return Qtrue;
+  return Qfalse;
+}
+
 /*
  * call-seq:
  *  []=(property, value)
@@ -323,6 +391,25 @@ static VALUE get(VALUE self, VALUE attribute)
   return rval ;
 }
 
+/*
+ * call-seq:
+ *   set_namespace(namespace)
+ *
+ * Set the namespace to +namespace+
+ */
+static VALUE set_namespace(VALUE self, VALUE namespace)
+{
+  xmlNodePtr node;
+  xmlNsPtr ns;
+
+  Data_Get_Struct(self, xmlNode, node);
+  Data_Get_Struct(namespace, xmlNs, ns);
+
+  xmlSetNs(node, ns);
+
+  return self;
+}
+
 /*
  * call-seq:
  *   attribute(name)
@@ -337,7 +424,25 @@ static VALUE attr(VALUE self, VALUE name)
   prop = xmlHasProp(node, (xmlChar *)StringValuePtr(name));
 
   if(! prop) return Qnil;
-  return Nokogiri_wrap_xml_node((xmlNodePtr)prop);
+  return Nokogiri_wrap_xml_node(Qnil, (xmlNodePtr)prop);
+}
+
+/*
+ * call-seq:
+ *   attribute_with_ns(name, namespace)
+ *
+ * Get the attribute node with +name+ and +namespace+
+ */
+static VALUE attribute_with_ns(VALUE self, VALUE name, VALUE namespace)
+{
+  xmlNodePtr node;
+  xmlAttrPtr prop;
+  Data_Get_Struct(self, xmlNode, node);
+  prop = xmlHasNsProp(node, (xmlChar *)StringValuePtr(name),
+      Qnil == namespace ? NULL : (xmlChar *)StringValuePtr(namespace));
+
+  if(! prop) return Qnil;
+  return Nokogiri_wrap_xml_node(Qnil, (xmlNodePtr)prop);
 }
 
 /*
@@ -365,36 +470,44 @@ static VALUE attribute_nodes(VALUE self)
  *  call-seq:
  *    namespace()
  *
- *  returns the namespace prefix for the node, if one exists.
+ *  returns the Nokogiri::XML::Namespace for the node, if one exists.
  */
 static VALUE namespace(VALUE self)
 {
   xmlNodePtr node ;
   Data_Get_Struct(self, xmlNode, node);
-  if (node->ns && node->ns->prefix) {
-    return NOKOGIRI_STR_NEW2(node->ns->prefix, node->doc->encoding);
-  }
+
+  if (node->ns)
+    return Nokogiri_wrap_xml_namespace(node->doc, node->ns);
+
   return Qnil ;
 }
 
 /*
  *  call-seq:
- *    namespaces()
+ *    namespace_definitions()
  *
- *  returns a hash containing the node's namespaces.
+ *  returns a list of Namespace nodes defined on _self_
  */
-static VALUE namespaces(VALUE self)
+static VALUE namespace_definitions(VALUE self)
 {
-    /* this code in the mode of xmlHasProp() */
-    xmlNodePtr node ;
-    VALUE attr ;
+  /* this code in the mode of xmlHasProp() */
+  xmlNodePtr node ;
 
-    attr = rb_hash_new() ;
-    Data_Get_Struct(self, xmlNode, node);
+  Data_Get_Struct(self, xmlNode, node);
 
-    Nokogiri_xml_node_namespaces(node, attr);
+  VALUE list = rb_ary_new();
 
-    return attr ;
+  xmlNsPtr ns = node->nsDef;
+
+  if(!ns) return list;
+
+  while(NULL != ns) {
+    rb_ary_push(list, Nokogiri_wrap_xml_namespace(node->doc, ns));
+    ns = ns->next;
+  }
+
+  return list;
 }
 
 /*
@@ -469,7 +582,7 @@ static VALUE get_parent(VALUE self)
   parent = node->parent;
   if(!parent) return Qnil;
 
-  return Nokogiri_wrap_xml_node(parent) ;
+  return Nokogiri_wrap_xml_node(Qnil, parent) ;
 }
 
 /*
@@ -547,12 +660,21 @@ static VALUE add_previous_sibling(VALUE self, VALUE rb_node)
  *
  * Write this Node to +io+ with +encoding+ and +options+
  */
-static VALUE native_write_to(VALUE self, VALUE io, VALUE encoding, VALUE options)
-{
+static VALUE native_write_to(
+    VALUE self,
+    VALUE io,
+    VALUE encoding,
+    VALUE indent_string,
+    VALUE options
+) {
   xmlNodePtr node;
 
   Data_Get_Struct(self, xmlNode, node);
 
+  xmlIndentTreeOutput = 1;
+
+  xmlTreeIndentString = StringValuePtr(indent_string);
+
   xmlSaveCtxtPtr savectx = xmlSaveToIO(
       (xmlOutputWriteCallback)io_write_callback,
       (xmlOutputCloseCallback)io_close_callback,
@@ -582,51 +704,50 @@ static VALUE line(VALUE self)
 
 /*
  * call-seq:
- *  add_namespace(prefix, href)
+ *  add_namespace_definition(prefix, href)
  *
- * Add a namespace with +prefix+ using +href+
+ * Adds a namespace definition with +prefix+ using +href+
  */
-static VALUE add_namespace(VALUE self, VALUE prefix, VALUE href)
+static VALUE add_namespace_definition(VALUE self, VALUE prefix, VALUE href)
 {
   xmlNodePtr node;
   Data_Get_Struct(self, xmlNode, node);
 
+
   xmlNsPtr ns = xmlNewNs(
       node,
       (const xmlChar *)StringValuePtr(href),
-      (const xmlChar *)StringValuePtr(prefix)
+      (const xmlChar *)(prefix == Qnil ? NULL : StringValuePtr(prefix))
   );
 
-  if(NULL == ns) return self;
+  if(Qnil == prefix) xmlSetNs(node, ns);
 
-  /*
-  xmlNewNsProp(
-      node,
-      ns,
-      (const xmlChar *)StringValuePtr(href),
-      (const xmlChar *)StringValuePtr(prefix)
-  );
-  */
-
-  return self;
+  return Nokogiri_wrap_xml_namespace(node->doc, ns);
 }
 
 /*
  * call-seq:
- *   new(name)
+ *   new(name, document)
  *
- * Create a new node with +name+
+ * Create a new node with +name+ sharing GC lifecycle with +document+
  */
-static VALUE new(VALUE klass, VALUE name, VALUE document)
+static VALUE new(int argc, VALUE *argv, VALUE klass)
 {
   xmlDocPtr doc;
+  VALUE name;
+  VALUE document;
+  VALUE rest;
+
+  rb_scan_args(argc, argv, "2*", &name, &document, &rest);
 
   Data_Get_Struct(document, xmlDoc, doc);
 
   xmlNodePtr node = xmlNewNode(NULL, (xmlChar *)StringValuePtr(name));
   node->doc = doc->doc;
+  NOKOGIRI_ROOT_NODE(node);
 
-  VALUE rb_node = Nokogiri_wrap_xml_node(node);
+  VALUE rb_node = Nokogiri_wrap_xml_node(klass, node);
+  rb_funcall2(rb_node, rb_intern("initialize"), argc, argv);
 
   if(rb_block_given_p()) rb_yield(rb_node);
 
@@ -655,11 +776,25 @@ static VALUE dump_html(VALUE self)
   return html ;
 }
 
-VALUE Nokogiri_wrap_xml_node(xmlNodePtr node)
+/*
+ * call-seq:
+ *  compare(other)
+ *
+ * Compare this Node to +other+ with respect to their Document
+ */
+static VALUE compare(VALUE self, VALUE _other)
+{
+  xmlNodePtr node, other;
+  Data_Get_Struct(self, xmlNode, node);
+  Data_Get_Struct(_other, xmlNode, other);
+
+  return INT2NUM(xmlXPathCmpNodes(other, node));
+}
+
+VALUE Nokogiri_wrap_xml_node(VALUE klass, xmlNodePtr node)
 {
   assert(node);
 
-  VALUE index = INT2NUM((int)node);
   VALUE document = Qnil ;
   VALUE node_cache = Qnil ;
   VALUE rb_node = Qnil ;
@@ -669,64 +804,70 @@ VALUE Nokogiri_wrap_xml_node(xmlNodePtr node)
 
   if(NULL != node->_private) return (VALUE)node->_private;
 
-  switch(node->type)
-  {
-    VALUE klass;
+  if(RTEST(klass))
+    rb_node = Data_Wrap_Struct(klass, mark, debug_node_dealloc, node) ;
 
+  if(!RTEST(klass)) switch(node->type)
+  {
     case XML_ELEMENT_NODE:
       klass = cNokogiriXmlElement;
-      rb_node = Data_Wrap_Struct(klass, 0, debug_node_dealloc, node) ;
+      rb_node = Data_Wrap_Struct(klass, mark, debug_node_dealloc, node) ;
       break;
     case XML_TEXT_NODE:
       klass = cNokogiriXmlText;
-      rb_node = Data_Wrap_Struct(klass, 0, debug_node_dealloc, node) ;
+      rb_node = Data_Wrap_Struct(klass, mark, debug_node_dealloc, node) ;
       break;
     case XML_ENTITY_REF_NODE:
       klass = cNokogiriXmlEntityReference;
-      rb_node = Data_Wrap_Struct(klass, 0, debug_node_dealloc, node) ;
+      rb_node = Data_Wrap_Struct(klass, mark, debug_node_dealloc, node) ;
       break;
     case XML_COMMENT_NODE:
       klass = cNokogiriXmlComment;
-      rb_node = Data_Wrap_Struct(klass, 0, debug_node_dealloc, node) ;
+      rb_node = Data_Wrap_Struct(klass, mark, debug_node_dealloc, node) ;
       break;
     case XML_DOCUMENT_FRAG_NODE:
       klass = cNokogiriXmlDocumentFragment;
-      rb_node = Data_Wrap_Struct(klass, 0, debug_node_dealloc, node) ;
+      rb_node = Data_Wrap_Struct(klass, mark, debug_node_dealloc, node) ;
       break;
     case XML_PI_NODE:
       klass = cNokogiriXmlProcessingInstruction;
-      rb_node = Data_Wrap_Struct(klass, 0, debug_node_dealloc, node) ;
+      rb_node = Data_Wrap_Struct(klass, mark, debug_node_dealloc, node) ;
       break;
     case XML_ATTRIBUTE_NODE:
       klass = cNokogiriXmlAttr;
-      rb_node = Data_Wrap_Struct(klass, 0, debug_node_dealloc, node) ;
+      rb_node = Data_Wrap_Struct(klass, mark, debug_node_dealloc, node) ;
       break;
     case XML_ENTITY_DECL:
-      klass = rb_const_get(mNokogiriXml, rb_intern("EntityDeclaration"));
-      rb_node = Data_Wrap_Struct(klass, 0, debug_node_dealloc, node) ;
+      klass = cNokogiriXmlEntityDeclaration;
+      rb_node = Data_Wrap_Struct(klass, mark, debug_node_dealloc, node) ;
       break;
     case XML_CDATA_SECTION_NODE:
       klass = cNokogiriXmlCData;
-      rb_node = Data_Wrap_Struct(klass, 0, debug_node_dealloc, node) ;
+      rb_node = Data_Wrap_Struct(klass, mark, debug_node_dealloc, node) ;
       break;
     case XML_DTD_NODE:
       klass = rb_const_get(mNokogiriXml, rb_intern("DTD"));
-      rb_node = Data_Wrap_Struct(klass, 0, debug_node_dealloc, node) ;
+      rb_node = Data_Wrap_Struct(klass, mark, debug_node_dealloc, node) ;
       break;
     default:
-      rb_node = Data_Wrap_Struct(cNokogiriXmlNode, 0, debug_node_dealloc, node) ;
+      rb_node = Data_Wrap_Struct(
+          cNokogiriXmlNode,
+          mark,
+          debug_node_dealloc,
+          node
+      );
   }
 
   node->_private = (void *)rb_node;
 
   if (DOC_RUBY_OBJECT_TEST(node->doc) && DOC_RUBY_OBJECT(node->doc)) {
     document = DOC_RUBY_OBJECT(node->doc);
-    node_cache = rb_funcall(document, rb_intern("node_cache"), 0);
+    node_cache = rb_iv_get(document, "@node_cache");
   }
 
-  if (node_cache != Qnil) rb_hash_aset(node_cache, index, rb_node);
-  rb_iv_set(rb_node, "@document", document);
-  rb_funcall(rb_node, rb_intern("decorate!"), 0);
+  rb_ary_push(node_cache, rb_node);
+  //rb_iv_set(rb_node, "@document", document);
+  rb_funcall(document, rb_intern("decorate"), 1, rb_node);
 
   return rb_node ;
 }
@@ -737,54 +878,14 @@ void Nokogiri_xml_node_properties(xmlNodePtr node, VALUE attr_list)
   xmlAttrPtr prop;
   prop = node->properties ;
   while (prop != NULL) {
-    rb_ary_push(attr_list, Nokogiri_wrap_xml_node((xmlNodePtr)prop));
+    rb_ary_push(attr_list, Nokogiri_wrap_xml_node(Qnil, (xmlNodePtr)prop));
     prop = prop->next ;
   }
 }
 
-
-#define XMLNS_PREFIX "xmlns"
-#define XMLNS_PREFIX_LEN 6 /* including either colon or \0 */
-#define XMLNS_BUFFER_LEN 128
-void Nokogiri_xml_node_namespaces(xmlNodePtr node, VALUE attr_hash)
-{
-  xmlNsPtr ns;
-  static char buffer[XMLNS_BUFFER_LEN] ;
-  char *key ;
-  size_t keylen ;
-
-  if (node->type != XML_ELEMENT_NODE) return ;
-
-  ns = node->nsDef;
-  while (ns != NULL) {
-
-    keylen = XMLNS_PREFIX_LEN + (ns->prefix ? (strlen((const char*)ns->prefix) + 1) : 0) ;
-    if (keylen > XMLNS_BUFFER_LEN) {
-      key = (char*)malloc(keylen) ;
-    } else {
-      key = buffer ;
-    }
-
-    if (ns->prefix) {
-      sprintf(key, "%s:%s", XMLNS_PREFIX, ns->prefix);
-    } else {
-      sprintf(key, "%s", XMLNS_PREFIX);
-    }
-
-    rb_hash_aset(attr_hash,
-        NOKOGIRI_STR_NEW2(key, node->doc->encoding),
-        NOKOGIRI_STR_NEW2(ns->href, node->doc->encoding)
-    );
-    if (key != buffer) {
-      free(key);
-    }
-    ns = ns->next ;
-  }
-}
-
-
 VALUE cNokogiriXmlNode ;
 VALUE cNokogiriXmlElement ;
+VALUE cNokogiriXmlEntityDeclaration ;
 
 void init_xml_node()
 {
@@ -795,11 +896,14 @@ void init_xml_node()
   cNokogiriXmlNode = klass;
 
   cNokogiriXmlElement = rb_define_class_under(xml, "Element", klass);
+  cNokogiriXmlEntityDeclaration =
+    rb_define_class_under(xml, "EntityDeclaration", klass);
 
-  rb_define_singleton_method(klass, "new", new, 2);
+  rb_define_singleton_method(klass, "new", new, -1);
 
-  rb_define_method(klass, "add_namespace", add_namespace, 2);
+  rb_define_method(klass, "add_namespace_definition", add_namespace_definition, 2);
   rb_define_method(klass, "node_name", get_name, 0);
+  rb_define_method(klass, "document", document, 0);
   rb_define_method(klass, "node_name=", set_name, 1);
   rb_define_method(klass, "add_child", add_child, 1);
   rb_define_method(klass, "parent", get_parent, 0);
@@ -811,12 +915,14 @@ void init_xml_node()
   rb_define_method(klass, "content", get_content, 0);
   rb_define_method(klass, "path", path, 0);
   rb_define_method(klass, "key?", key_eh, 1);
+  rb_define_method(klass, "namespaced_key?", namespaced_key_eh, 2);
   rb_define_method(klass, "blank?", blank_eh, 0);
   rb_define_method(klass, "[]=", set, 2);
   rb_define_method(klass, "attribute_nodes", attribute_nodes, 0);
   rb_define_method(klass, "attribute", attr, 1);
+  rb_define_method(klass, "attribute_with_ns", attribute_with_ns, 2);
   rb_define_method(klass, "namespace", namespace, 0);
-  rb_define_method(klass, "namespaces", namespaces, 0);
+  rb_define_method(klass, "namespace_definitions", namespace_definitions, 0);
   rb_define_method(klass, "add_previous_sibling", add_previous_sibling, 1);
   rb_define_method(klass, "add_next_sibling", add_next_sibling, 1);
   rb_define_method(klass, "encode_special_chars", encode_special_chars, 1);
@@ -827,8 +933,10 @@ void init_xml_node()
   rb_define_method(klass, "line", line, 0);
 
   rb_define_private_method(klass, "dump_html", dump_html, 0);
-  rb_define_private_method(klass, "native_write_to", native_write_to, 3);
+  rb_define_private_method(klass, "native_write_to", native_write_to, 4);
   rb_define_private_method(klass, "replace_with_node", replace, 1);
   rb_define_private_method(klass, "native_content=", set_content, 1);
   rb_define_private_method(klass, "get", get, 1);
+  rb_define_private_method(klass, "set_namespace", set_namespace, 1);
+  rb_define_private_method(klass, "compare", compare, 1);
 }