nokogiri 1.2.3-x86-mswin32-60 → 1.4.5-x86-mswin32-60

data/ext/nokogiri/xml_attr.h

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

data/ext/nokogiri/xml_attribute_decl.c

@@ -0,0 +1,70 @@
+#include <xml_attribute_decl.h>
+
+/*
+ * call-seq:
+ *  attribute_type
+ *
+ * The attribute_type for this AttributeDecl
+ */
+static VALUE attribute_type(VALUE self)
+{
+  xmlAttributePtr node;
+  Data_Get_Struct(self, xmlAttribute, node);
+  return INT2NUM((long)node->atype);
+}
+
+/*
+ * call-seq:
+ *  default
+ *
+ * The default value
+ */
+static VALUE default_value(VALUE self)
+{
+  xmlAttributePtr node;
+  Data_Get_Struct(self, xmlAttribute, node);
+
+  if(node->defaultValue) return NOKOGIRI_STR_NEW2(node->defaultValue);
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *  enumeration
+ *
+ * An enumeration of possible values
+ */
+static VALUE enumeration(VALUE self)
+{
+  xmlAttributePtr node;
+  xmlEnumerationPtr enm;
+  VALUE list;
+
+  Data_Get_Struct(self, xmlAttribute, node);
+
+  list = rb_ary_new();
+  enm = node->tree;
+
+  while(enm) {
+    rb_ary_push(list, NOKOGIRI_STR_NEW2(enm->name));
+    enm = enm->next;
+  }
+
+  return list;
+}
+
+VALUE cNokogiriXmlAttributeDecl;
+
+void init_xml_attribute_decl()
+{
+  VALUE nokogiri = rb_define_module("Nokogiri");
+  VALUE xml = rb_define_module_under(nokogiri, "XML");
+  VALUE node = rb_define_class_under(xml, "Node", rb_cObject);
+  VALUE klass = rb_define_class_under(xml, "AttributeDecl", node);
+
+  cNokogiriXmlAttributeDecl = klass;
+
+  rb_define_method(klass, "attribute_type", attribute_type, 0);
+  rb_define_method(klass, "default", default_value, 0);
+  rb_define_method(klass, "enumeration", enumeration, 0);
+}

data/ext/nokogiri/xml_attribute_decl.h

@@ -0,0 +1,9 @@
+#ifndef NOKOGIRI_XML_ATTRIBUTE_DECL
+#define NOKOGIRI_XML_ATTRIBUTE_DECL
+
+#include <nokogiri.h>
+
+void init_xml_attribute_decl();
+
+extern VALUE cNokogiriXmlAttributeDecl;
+#endif

data/ext/nokogiri/xml_cdata.c

@@ -4,20 +4,31 @@
  * call-seq:
  *  new(document, content)
  *
- * Create a new CData element on the +document+ with +content+
+ * Create a new CDATA element on the +document+ with +content+
  */
-static VALUE new(VALUE klass, VALUE doc, VALUE content)
+static VALUE new(int argc, VALUE *argv, VALUE klass)
 {
   xmlDocPtr xml_doc;
+  xmlNodePtr node;
+  VALUE doc;
+  VALUE content;
+  VALUE rest;
+  VALUE rb_node;
+
+  rb_scan_args(argc, argv, "2*", &doc, &content, &rest);
+
   Data_Get_Struct(doc, xmlDoc, xml_doc);
 
-  xmlNodePtr node = xmlNewCDataBlock(
-      xml_doc,
-      (const xmlChar *)StringValuePtr(content),
-      RSTRING_LEN(content)
+  node = xmlNewCDataBlock(
+      xml_doc->doc,
+      NIL_P(content) ? NULL : (const xmlChar *)StringValuePtr(content),
+      NIL_P(content) ? 0 : (int)RSTRING_LEN(content)
   );
 
-  VALUE rb_node = Nokogiri_wrap_xml_node(node);
+  NOKOGIRI_ROOT_NODE(node);
+
+  rb_node = Nokogiri_wrap_xml_node(klass, node);
+  rb_obj_call_init(rb_node, argc, argv);
 
   if(rb_block_given_p()) rb_yield(rb_node);
 
@@ -30,7 +41,8 @@ void init_xml_cdata()
   VALUE nokogiri = rb_define_module("Nokogiri");
   VALUE xml = rb_define_module_under(nokogiri, "XML");
   VALUE node = rb_define_class_under(xml, "Node", rb_cObject);
-  VALUE text = rb_define_class_under(xml, "Text", node);
+  VALUE char_data = rb_define_class_under(xml, "CharacterData", node);
+  VALUE text = rb_define_class_under(xml, "Text", char_data);
 
   /*
    * CData represents a CData node in an xml document.
@@ -40,5 +52,5 @@ void init_xml_cdata()
 
   cNokogiriXmlCData = klass;
 
-  rb_define_singleton_method(klass, "new", new, 2);
+  rb_define_singleton_method(klass, "new", new, -1);
 }

data/ext/nokogiri/xml_cdata.h

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

data/ext/nokogiri/xml_comment.c

@@ -6,17 +6,28 @@
  *
  * Create a new Comment element on the +document+ with +content+
  */
-static VALUE new(VALUE klass, VALUE doc, VALUE content)
+static VALUE new(int argc, VALUE *argv, VALUE klass)
 {
   xmlDocPtr xml_doc;
-  Data_Get_Struct(doc, xmlDoc, xml_doc);
+  xmlNodePtr node;
+  VALUE document;
+  VALUE content;
+  VALUE rest;
+  VALUE rb_node;
 
-  xmlNodePtr node = xmlNewDocComment(
+  rb_scan_args(argc, argv, "2*", &document, &content, &rest);
+
+  Data_Get_Struct(document, xmlDoc, xml_doc);
+
+  node = xmlNewDocComment(
       xml_doc,
       (const xmlChar *)StringValuePtr(content)
   );
 
-  VALUE rb_node = Nokogiri_wrap_xml_node(node);
+  rb_node = Nokogiri_wrap_xml_node(klass, node);
+  rb_obj_call_init(rb_node, argc, argv);
+
+  NOKOGIRI_ROOT_NODE(node);
 
   if(rb_block_given_p()) rb_yield(rb_node);
 
@@ -29,14 +40,15 @@ void init_xml_comment()
   VALUE nokogiri = rb_define_module("Nokogiri");
   VALUE xml = rb_define_module_under(nokogiri, "XML");
   VALUE node = rb_define_class_under(xml, "Node", rb_cObject);
+  VALUE char_data = rb_define_class_under(xml, "CharacterData", node);
 
   /*
    * Comment represents a comment node in an xml document.
    */
-  VALUE klass = rb_define_class_under(xml, "Comment", node);
+  VALUE klass = rb_define_class_under(xml, "Comment", char_data);
 
 
   cNokogiriXmlComment = klass;
 
-  rb_define_singleton_method(klass, "new", new, 2);
+  rb_define_singleton_method(klass, "new", new, -1);
 }

data/ext/nokogiri/xml_comment.h

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

data/ext/nokogiri/xml_document.c

@@ -1,28 +1,67 @@
 #include <xml_document.h>
 
+static int dealloc_node_i(xmlNodePtr key, xmlNodePtr node, xmlDocPtr doc)
+{
+  switch(node->type) {
+  case XML_ATTRIBUTE_NODE:
+    xmlFreePropList((xmlAttrPtr)node);
+    break;
+  case XML_NAMESPACE_DECL:
+    xmlFree(node);
+    break;
+  default:
+    if(node->parent == NULL) {
+      xmlAddChild((xmlNodePtr)doc, node);
+    }
+  }
+  return ST_CONTINUE;
+}
+
 static void dealloc(xmlDocPtr doc)
 {
+  xmlDeregisterNodeFunc func;
+  st_table *node_hash;
+
   NOKOGIRI_DEBUG_START(doc);
+  func = xmlDeregisterNodeDefault(NULL);
 
-  nokogiriTuplePtr tuple = doc->_private;
-  xmlNodeSetPtr node_set = tuple->unlinkedNodes;
+  node_hash  = DOC_UNLINKED_NODE_HASH(doc);
 
-  int i;
-  for(i = 0; i < node_set->nodeNr; i++) {
-    xmlAddChild((xmlNodePtr)doc, node_set->nodeTab[i]);
-  }
-
-  if (node_set->nodeTab != NULL)
-    xmlFree(node_set->nodeTab);
-  xmlFree(node_set);
+  st_foreach(node_hash, dealloc_node_i, (st_data_t)doc);
+  st_free_table(node_hash);
 
   free(doc->_private);
   doc->_private = NULL;
   xmlFreeDoc(doc);
 
+  xmlDeregisterNodeDefault(func);
   NOKOGIRI_DEBUG_END(doc);
 }
 
+static void recursively_remove_namespaces_from_node(xmlNodePtr node)
+{
+  xmlNodePtr child ;
+  xmlAttrPtr property ;
+
+  xmlSetNs(node, NULL);
+
+  for (child = node->children ; child ; child = child->next)
+    recursively_remove_namespaces_from_node(child);
+
+  if (node->nsDef) {
+    xmlFreeNsList(node->nsDef);
+    node->nsDef = NULL;
+  }
+
+  if (node->properties != NULL) {
+    property = node->properties ;
+    while (property != NULL) {
+      if (property->ns) property->ns = NULL ;
+      property = property->next ;
+    }
+  }
+}
+
 /*
  * call-seq:
  *  url
@@ -34,8 +73,7 @@ static VALUE url(VALUE self)
   xmlDocPtr doc;
   Data_Get_Struct(self, xmlDoc, doc);
 
-  if(doc->URL)
-    return NOKOGIRI_STR_NEW2(doc->URL, doc->encoding);
+  if(doc->URL) return NOKOGIRI_STR_NEW2(doc->URL);
 
   return Qnil;
 }
@@ -50,11 +88,37 @@ static VALUE set_root(VALUE self, VALUE root)
 {
   xmlDocPtr doc;
   xmlNodePtr new_root;
+  xmlNodePtr old_root;
 
   Data_Get_Struct(self, xmlDoc, doc);
+
+  old_root = NULL;
+
+  if(NIL_P(root)) {
+    old_root = xmlDocGetRootElement(doc);
+
+    if(old_root) {
+      xmlUnlinkNode(old_root);
+      NOKOGIRI_ROOT_NODE(old_root);
+    }
+
+    return root;
+  }
+
   Data_Get_Struct(root, xmlNode, new_root);
 
+
+  /* If the new root's document is not the same as the current document,
+   * then we need to dup the node in to this document. */
+  if(new_root->doc != doc) {
+    old_root = xmlDocGetRootElement(doc);
+    if (!(new_root = xmlDocCopyNode(new_root, doc, 1))) {
+      rb_raise(rb_eRuntimeError, "Could not reparent node (xmlDocCopyNode)");
+    }
+  }
+
   xmlDocSetRootElement(doc, new_root);
+  if(old_root) NOKOGIRI_ROOT_NODE(old_root);
   return root;
 }
 
@@ -67,12 +131,30 @@ static VALUE set_root(VALUE self, VALUE root)
 static VALUE root(VALUE self)
 {
   xmlDocPtr doc;
+  xmlNodePtr root;
+
   Data_Get_Struct(self, xmlDoc, doc);
 
-  xmlNodePtr root = xmlDocGetRootElement(doc);
+  root = xmlDocGetRootElement(doc);
 
   if(!root) return Qnil;
-  return Nokogiri_wrap_xml_node(root) ;
+  return Nokogiri_wrap_xml_node(Qnil, root) ;
+}
+
+/*
+ * call-seq:
+ *  encoding= encoding
+ *
+ * Set the encoding string for this Document
+ */
+static VALUE set_encoding(VALUE self, VALUE encoding)
+{
+  xmlDocPtr doc;
+  Data_Get_Struct(self, xmlDoc, doc);
+
+  doc->encoding = xmlStrdup((xmlChar *)StringValuePtr(encoding));
+
+  return encoding;
 }
 
 /*
@@ -87,7 +169,22 @@ static VALUE encoding(VALUE self)
   Data_Get_Struct(self, xmlDoc, doc);
 
   if(!doc->encoding) return Qnil;
-  return NOKOGIRI_STR_NEW2(doc->encoding, doc->encoding);
+  return NOKOGIRI_STR_NEW2(doc->encoding);
+}
+
+/*
+ * call-seq:
+ *  version
+ *
+ * Get the XML version for this Document
+ */
+static VALUE version(VALUE self)
+{
+  xmlDocPtr doc;
+  Data_Get_Struct(self, xmlDoc, doc);
+
+  if(!doc->version) return Qnil;
+  return NOKOGIRI_STR_NEW2(doc->version);
 }
 
 /*
@@ -102,40 +199,41 @@ static VALUE read_io( VALUE klass,
                       VALUE encoding,
                       VALUE options )
 {
-  const char * c_url    = (url == Qnil) ? NULL : StringValuePtr(url);
-  const char * c_enc    = (encoding == Qnil) ? NULL : StringValuePtr(encoding);
+  const char * c_url    = NIL_P(url)      ? NULL : StringValuePtr(url);
+  const char * c_enc    = NIL_P(encoding) ? NULL : StringValuePtr(encoding);
   VALUE error_list      = rb_ary_new();
+  VALUE document;
+  xmlDocPtr doc;
 
-  xmlInitParser();
   xmlResetLastError();
   xmlSetStructuredErrorFunc((void *)error_list, Nokogiri_error_array_pusher);
 
-  xmlDocPtr doc = xmlReadIO(
+  doc = xmlReadIO(
       (xmlInputReadCallback)io_read_callback,
       (xmlInputCloseCallback)io_close_callback,
       (void *)io,
       c_url,
       c_enc,
-      NUM2INT(options)
+      (int)NUM2INT(options)
   );
   xmlSetStructuredErrorFunc(NULL, NULL);
 
   if(doc == NULL) {
+    xmlErrorPtr error;
+
     xmlFreeDoc(doc);
 
-    xmlErrorPtr error = xmlGetLastError();
+    error = xmlGetLastError();
     if(error)
-      rb_funcall(rb_mKernel, rb_intern("raise"), 1,
-          Nokogiri_wrap_xml_syntax_error((VALUE)NULL, error)
-      );
+      rb_exc_raise(Nokogiri_wrap_xml_syntax_error((VALUE)NULL, error));
     else
       rb_raise(rb_eRuntimeError, "Could not parse document");
 
     return Qnil;
   }
 
-  VALUE document = Nokogiri_wrap_xml_document(klass, doc);
-  rb_funcall(document, rb_intern("errors="), 1, error_list);
+  document = Nokogiri_wrap_xml_document(klass, doc);
+  rb_iv_set(document, "@errors", error_list);
   return document;
 }
 
@@ -152,33 +250,34 @@ static VALUE read_memory( VALUE klass,
                           VALUE options )
 {
   const char * c_buffer = StringValuePtr(string);
-  const char * c_url    = (url == Qnil) ? NULL : StringValuePtr(url);
-  const char * c_enc    = (encoding == Qnil) ? NULL : StringValuePtr(encoding);
-  int len               = RSTRING_LEN(string);
+  const char * c_url    = NIL_P(url)      ? NULL : StringValuePtr(url);
+  const char * c_enc    = NIL_P(encoding) ? NULL : StringValuePtr(encoding);
+  int len               = (int)RSTRING_LEN(string);
   VALUE error_list      = rb_ary_new();
+  VALUE document;
+  xmlDocPtr doc;
 
-  xmlInitParser();
   xmlResetLastError();
   xmlSetStructuredErrorFunc((void *)error_list, Nokogiri_error_array_pusher);
-  xmlDocPtr doc = xmlReadMemory(c_buffer, len, c_url, c_enc, NUM2INT(options));
+  doc = xmlReadMemory(c_buffer, len, c_url, c_enc, (int)NUM2INT(options));
   xmlSetStructuredErrorFunc(NULL, NULL);
 
   if(doc == NULL) {
+    xmlErrorPtr error;
+
     xmlFreeDoc(doc);
 
-    xmlErrorPtr error = xmlGetLastError();
+    error = xmlGetLastError();
     if(error)
-      rb_funcall(rb_mKernel, rb_intern("raise"), 1,
-          Nokogiri_wrap_xml_syntax_error((VALUE)NULL, error)
-      );
+      rb_exc_raise(Nokogiri_wrap_xml_syntax_error((VALUE)NULL, error));
     else
       rb_raise(rb_eRuntimeError, "Could not parse document");
 
     return Qnil;
   }
 
-  VALUE document = Nokogiri_wrap_xml_document(klass, doc);
-  rb_funcall(document, rb_intern("errors="), 1, error_list);
+  document = Nokogiri_wrap_xml_document(klass, doc);
+  rb_iv_set(document, "@errors", error_list);
   return document;
 }
 
@@ -191,62 +290,135 @@ static VALUE read_memory( VALUE klass,
  */
 static VALUE duplicate_node(int argc, VALUE *argv, VALUE self)
 {
+  xmlDocPtr doc, dup;
   VALUE level;
 
   if(rb_scan_args(argc, argv, "01", &level) == 0)
-    level = INT2NUM(1);
+    level = INT2NUM((long)1);
 
-  xmlDocPtr doc, dup;
   Data_Get_Struct(self, xmlDoc, doc);
 
-  dup = xmlCopyDoc(doc, NUM2INT(level));
+  dup = xmlCopyDoc(doc, (int)NUM2INT(level));
   if(dup == NULL) return Qnil;
 
   dup->type = doc->type;
-  if(dup->type == XML_DOCUMENT_NODE)
-    return Nokogiri_wrap_xml_document(cNokogiriXmlDocument, dup);
-  else
-    return Nokogiri_wrap_xml_document(cNokogiriHtmlDocument, dup);
+  return Nokogiri_wrap_xml_document(rb_obj_class(self), dup);
 }
 
 /*
  * call-seq:
- *  new
+ *  new(version = default)
  *
- * Create a new document
+ * Create a new document with +version+ (defaults to "1.0")
  */
 static VALUE new(int argc, VALUE *argv, VALUE klass)
 {
-  VALUE version;
-  if(rb_scan_args(argc, argv, "01", &version) == 0)
-    version = rb_str_new2("1.0");
+  xmlDocPtr doc;
+  VALUE version, rest, rb_doc ;
+
+  rb_scan_args(argc, argv, "0*", &rest);
+  version = rb_ary_entry(rest, (long)0);
+  if (NIL_P(version)) version = rb_str_new2("1.0");
 
-  xmlDocPtr doc = xmlNewDoc((xmlChar *)StringValuePtr(version));
-  return Nokogiri_wrap_xml_document(klass, doc);
+  doc = xmlNewDoc((xmlChar *)StringValuePtr(version));
+  rb_doc = Nokogiri_wrap_xml_document(klass, doc);
+  rb_obj_call_init(rb_doc, argc, argv);
+  return rb_doc ;
 }
 
 /*
  *  call-seq:
- *    substitute_entities=(boolean)
+ *    remove_namespaces!
+ *
+ *  Remove all namespaces from all nodes in the document.
+ *
+ *  This could be useful for developers who either don't understand namespaces
+ *  or don't care about them.
+ *
+ *  The following example shows a use case, and you can decide for yourself
+ *  whether this is a good thing or not:
+ *
+ *    doc = Nokogiri::XML <<-EOXML
+ *       <root>
+ *         <car xmlns:part="http://general-motors.com/">
+ *           <part:tire>Michelin Model XGV</part:tire>
+ *         </car>
+ *         <bicycle xmlns:part="http://schwinn.com/">
+ *           <part:tire>I'm a bicycle tire!</part:tire>
+ *         </bicycle>
+ *       </root>
+ *       EOXML
+ *    
+ *    doc.xpath("//tire").to_s # => ""
+ *    doc.xpath("//part:tire", "part" => "http://general-motors.com/").to_s # => "<part:tire>Michelin Model XGV</part:tire>"
+ *    doc.xpath("//part:tire", "part" => "http://schwinn.com/").to_s # => "<part:tire>I'm a bicycle tire!</part:tire>"
+ *    
+ *    doc.remove_namespaces!
+ *    
+ *    doc.xpath("//tire").to_s # => "<tire>Michelin Model XGV</tire><tire>I'm a bicycle tire!</tire>"
+ *    doc.xpath("//part:tire", "part" => "http://general-motors.com/").to_s # => ""
+ *    doc.xpath("//part:tire", "part" => "http://schwinn.com/").to_s # => ""
  *
- *  Set the global XML default for substitute entities.
+ *  For more information on why this probably is *not* a good thing in general,
+ *  please direct your browser to
+ *  http://tenderlovemaking.com/2009/04/23/namespaces-in-xml/
  */
-static VALUE substitute_entities_set(VALUE klass, VALUE value)
+VALUE remove_namespaces_bang(VALUE self)
 {
-    xmlSubstituteEntitiesDefault(NUM2INT(value));
-    return Qnil ;
+  xmlDocPtr doc ;
+  Data_Get_Struct(self, xmlDoc, doc);
+
+  recursively_remove_namespaces_from_node((xmlNodePtr)doc);
+  return self;
 }
 
-/*
- *  call-seq:
- *    load_external_subsets=(boolean)
+/* call-seq: doc.create_entity(name, type, external_id, system_id, content)
+ *
+ * Create a new entity named +name+.
  *
- *  Set the global XML default for load external subsets.
+ * +type+ is an integer representing the type of entity to be created, and it
+ * defaults to Nokogiri::XML::EntityDecl::INTERNAL_GENERAL.  See
+ * the constants on Nokogiri::XML::EntityDecl for more information.
+ *
+ * +external_id+, +system_id+, and +content+ set the External ID, System ID,
+ * and content respectively.  All of these parameters are optional.
  */
-static VALUE load_external_subsets_set(VALUE klass, VALUE value)
+static VALUE create_entity(int argc, VALUE *argv, VALUE self)
 {
-    xmlLoadExtDtdDefaultValue = NUM2INT(value);
-    return Qnil ;
+  VALUE name;
+  VALUE type;
+  VALUE external_id;
+  VALUE system_id;
+  VALUE content;
+  xmlEntityPtr ptr;
+  xmlDocPtr doc ;
+
+  Data_Get_Struct(self, xmlDoc, doc);
+
+  rb_scan_args(argc, argv, "14", &name, &type, &external_id, &system_id,
+      &content);
+
+  xmlResetLastError();
+  ptr = xmlAddDocEntity(
+      doc,
+      (xmlChar *)(NIL_P(name)        ? NULL                        : StringValuePtr(name)),
+      (int)      (NIL_P(type)        ? XML_INTERNAL_GENERAL_ENTITY : NUM2INT(type)),
+      (xmlChar *)(NIL_P(external_id) ? NULL                        : StringValuePtr(external_id)),
+      (xmlChar *)(NIL_P(system_id)   ? NULL                        : StringValuePtr(system_id)),
+      (xmlChar *)(NIL_P(content)     ? NULL                        : StringValuePtr(content))
+    );
+
+  if(NULL == ptr) {
+    xmlErrorPtr error = xmlGetLastError();
+    if(error)
+      rb_exc_raise(Nokogiri_wrap_xml_syntax_error((VALUE)NULL, error));
+    else
+      rb_raise(rb_eRuntimeError, "Could not create entity");
+
+    return Qnil;
+  }
+
+  return Nokogiri_wrap_xml_node(cNokogiriXmlEntityDecl, (xmlNodePtr)ptr);
 }
 
 VALUE cNokogiriXmlDocument ;
@@ -266,34 +438,41 @@ void init_xml_document()
   rb_define_singleton_method(klass, "read_memory", read_memory, 4);
   rb_define_singleton_method(klass, "read_io", read_io, 4);
   rb_define_singleton_method(klass, "new", new, -1);
-  rb_define_singleton_method(klass, "substitute_entities=", substitute_entities_set, 1);
-  rb_define_singleton_method(klass, "load_external_subsets=", load_external_subsets_set, 1);
 
   rb_define_method(klass, "root", root, 0);
   rb_define_method(klass, "root=", set_root, 1);
   rb_define_method(klass, "encoding", encoding, 0);
+  rb_define_method(klass, "encoding=", set_encoding, 1);
+  rb_define_method(klass, "version", version, 0);
   rb_define_method(klass, "dup", duplicate_node, -1);
   rb_define_method(klass, "url", url, 0);
+  rb_define_method(klass, "create_entity", create_entity, -1);
+  rb_define_method(klass, "remove_namespaces!", remove_namespaces_bang, 0);
 }
 
 
 /* this takes klass as a param because it's used for HtmlDocument, too. */
 VALUE Nokogiri_wrap_xml_document(VALUE klass, xmlDocPtr doc)
 {
-  VALUE rb_doc = Qnil;
   nokogiriTuplePtr tuple = (nokogiriTuplePtr)malloc(sizeof(nokogiriTuple));
 
-  rb_doc = Data_Wrap_Struct(
+  VALUE rb_doc = Data_Wrap_Struct(
       klass ? klass : cNokogiriXmlDocument,
       0,
       dealloc,
       doc
   );
+
+  VALUE cache = rb_ary_new();
   rb_iv_set(rb_doc, "@decorators", Qnil);
+  rb_iv_set(rb_doc, "@node_cache", cache);
 
   tuple->doc = (void *)rb_doc;
-  tuple->unlinkedNodes = xmlXPathNodeSetCreate(NULL);
+  tuple->unlinkedNodes = st_init_numtable_with_size(128);
+  tuple->node_cache = cache;
   doc->_private = tuple ;
 
+  rb_obj_call_init(rb_doc, 0, NULL);
+
   return rb_doc ;
 }