nokogiri 1.13.8 → 1.14.5

data/ext/nokogiri/nokogiri.c

@@ -49,34 +49,11 @@ void noko_init_html_sax_push_parser(void);
 void noko_init_gumbo(void);
 void noko_init_test_global_handlers(void);
 
-static ID id_read, id_write;
-
-
-#ifndef HAVE_VASPRINTF
-/*
- * Thank you Geoffroy Couprie for this implementation of vasprintf!
- */
-int
-vasprintf(char **strp, const char *fmt, va_list ap)
-{
-  /* Mingw32/64 have a broken vsnprintf implementation that fails when
-   * using a zero-byte limit in order to retrieve the required size for malloc.
-   * So we use a one byte buffer instead.
-   */
-  char tmp[1];
-  int len = vsnprintf(tmp, 1, fmt, ap) + 1;
-  char *res = (char *)malloc((unsigned int)len);
-  if (res == NULL) {
-    return -1;
-  }
-  *strp = res;
-  return vsnprintf(res, (unsigned int)len, fmt, ap);
-}
-#endif
+static ID id_read, id_write, id_external_encoding;
 
 
 static VALUE
-read_check(VALUE val)
+noko_io_read_check(VALUE val)
 {
   VALUE *args = (VALUE *)val;
   return rb_funcall(args[0], id_read, 1, args[1]);
@@ -84,75 +61,84 @@ read_check(VALUE val)
 
 
 static VALUE
-read_failed(VALUE arg, VALUE exc)
+noko_io_read_failed(VALUE arg, VALUE exc)
 {
   return Qundef;
 }
 
 
 int
-noko_io_read(void *ctx, char *buffer, int len)
+noko_io_read(void *io, char *c_buffer, int c_buffer_len)
 {
-  VALUE string, args[2];
-  size_t str_len, safe_len;
+  VALUE rb_io = (VALUE)io;
+  VALUE rb_read_string, rb_args[2];
+  size_t n_bytes_read, safe_len;
 
-  args[0] = (VALUE)ctx;
-  args[1] = INT2NUM(len);
+  rb_args[0] = rb_io;
+  rb_args[1] = INT2NUM(c_buffer_len);
 
-  string = rb_rescue(read_check, (VALUE)args, read_failed, 0);
+  rb_read_string = rb_rescue(noko_io_read_check, (VALUE)rb_args, noko_io_read_failed, 0);
 
-  if (NIL_P(string)) { return 0; }
-  if (string == Qundef) { return -1; }
-  if (TYPE(string) != T_STRING) { return -1; }
+  if (NIL_P(rb_read_string)) { return 0; }
+  if (rb_read_string == Qundef) { return -1; }
+  if (TYPE(rb_read_string) != T_STRING) { return -1; }
 
-  str_len = (size_t)RSTRING_LEN(string);
-  safe_len = str_len > (size_t)len ? (size_t)len : str_len;
-  memcpy(buffer, StringValuePtr(string), safe_len);
+  n_bytes_read = (size_t)RSTRING_LEN(rb_read_string);
+  safe_len = (n_bytes_read > (size_t)c_buffer_len) ? (size_t)c_buffer_len : n_bytes_read;
+  memcpy(c_buffer, StringValuePtr(rb_read_string), safe_len);
 
   return (int)safe_len;
 }
 
 
 static VALUE
-write_check(VALUE val)
+noko_io_write_check(VALUE rb_args)
 {
-  VALUE *args = (VALUE *)val;
-  return rb_funcall(args[0], id_write, 1, args[1]);
+  VALUE rb_io = ((VALUE *)rb_args)[0];
+  VALUE rb_output = ((VALUE *)rb_args)[1];
+  return rb_funcall(rb_io, id_write, 1, rb_output);
 }
 
 
 static VALUE
-write_failed(VALUE arg, VALUE exc)
+noko_io_write_failed(VALUE arg, VALUE exc)
 {
   return Qundef;
 }
 
 
 int
-noko_io_write(void *ctx, char *buffer, int len)
+noko_io_write(void *io, char *c_buffer, int c_buffer_len)
 {
-  VALUE args[2], size;
+  VALUE rb_args[2], rb_n_bytes_written;
+  VALUE rb_io = (VALUE)io;
+  VALUE rb_enc = Qnil;
+  rb_encoding *io_encoding;
 
-  args[0] = (VALUE)ctx;
-  args[1] = rb_str_new(buffer, (long)len);
+  if (rb_respond_to(rb_io, id_external_encoding)) {
+    rb_enc = rb_funcall(rb_io, id_external_encoding, 0);
+  }
+  io_encoding = RB_NIL_P(rb_enc) ? rb_ascii8bit_encoding() : rb_to_encoding(rb_enc);
 
-  size = rb_rescue(write_check, (VALUE)args, write_failed, 0);
+  rb_args[0] = rb_io;
+  rb_args[1] = rb_enc_str_new(c_buffer, (long)c_buffer_len, io_encoding);
 
-  if (size == Qundef) { return -1; }
+  rb_n_bytes_written = rb_rescue(noko_io_write_check, (VALUE)rb_args, noko_io_write_failed, 0);
+  if (rb_n_bytes_written == Qundef) { return -1; }
 
-  return NUM2INT(size);
+  return NUM2INT(rb_n_bytes_written);
 }
 
 
 int
-noko_io_close(void *ctx)
+noko_io_close(void *io)
 {
   return 0;
 }
 
 
 void
-Init_nokogiri()
+Init_nokogiri(void)
 {
   mNokogiri         = rb_define_module("Nokogiri");
   mNokogiriGumbo    = rb_define_module_under(mNokogiri, "Gumbo");
@@ -275,4 +261,5 @@ Init_nokogiri()
 
   id_read = rb_intern("read");
   id_write = rb_intern("write");
+  id_external_encoding = rb_intern("external_encoding");
 }

data/ext/nokogiri/nokogiri.h

@@ -1,6 +1,8 @@
 #ifndef NOKOGIRI_NATIVE
 #define NOKOGIRI_NATIVE
 
+#include <ruby/defines.h> // https://github.com/sparklemotion/nokogiri/issues/2696
+
 #ifdef _MSC_VER
 #  ifndef WIN32_LEAN_AND_MEAN
 #    define WIN32_LEAN_AND_MEAN
@@ -23,7 +25,6 @@
 #  define NOKOPUBVAR extern
 #endif
 
-
 #include <stdlib.h>
 #include <string.h>
 #include <assert.h>
@@ -75,22 +76,25 @@ xmlNodePtr xmlLastElementChild(xmlNodePtr parent);
 #define NOKOGIRI_STR_NEW(str, len) rb_external_str_new_with_enc((const char *)(str), (long)(len), rb_utf8_encoding())
 #define RBSTR_OR_QNIL(_str) (_str ? NOKOGIRI_STR_NEW2(_str) : Qnil)
 
-#ifdef DEBUG
-#  define NOKOGIRI_DEBUG_START(p) if (getenv("NOKOGIRI_NO_FREE")) return ; if (getenv("NOKOGIRI_DEBUG")) fprintf(stderr,"nokogiri: %s:%d %p start\n", __FILE__, __LINE__, p);
-#  define NOKOGIRI_DEBUG_END(p) if (getenv("NOKOGIRI_DEBUG")) fprintf(stderr,"nokogiri: %s:%d %p end\n", __FILE__, __LINE__, p);
-#else
-#  define NOKOGIRI_DEBUG_START(p)
-#  define NOKOGIRI_DEBUG_END(p)
+#ifndef NORETURN_DECL
+#  if defined(__GNUC__)
+#    define NORETURN_DECL __attribute__ ((noreturn))
+#  else
+#    define NORETURN_DECL
+#  endif
 #endif
 
-#ifndef NORETURN
+#ifndef PRINTFLIKE_DECL
 #  if defined(__GNUC__)
-#    define NORETURN(name) __attribute__((noreturn)) name
+#    define PRINTFLIKE_DECL(stringidx, argidx) __attribute__ ((format(printf,stringidx,argidx)))
 #  else
-#    define NORETURN(name) name
+#    define PRINTFLIKE_DECL(stringidx, argidx)
 #  endif
 #endif
 
+#if defined(TRUFFLERUBY) && !defined(NOKOGIRI_PACKAGED_LIBRARIES)
+#  define TRUFFLERUBY_NOKOGIRI_SYSTEM_LIBRARIES
+#endif
 
 NOKOPUBVAR VALUE mNokogiri ;
 NOKOPUBVAR VALUE mNokogiriGumbo ;
@@ -162,7 +166,6 @@ typedef struct _nokogiriXsltStylesheetTuple {
   VALUE func_instances;
 } nokogiriXsltStylesheetTuple;
 
-int vasprintf(char **strp, const char *fmt, va_list ap);
 void noko_xml_document_pin_node(xmlNodePtr);
 void noko_xml_document_pin_namespace(xmlNsPtr, xmlDocPtr);
 
@@ -171,6 +174,7 @@ int noko_io_write(void *ctx, char *buffer, int len);
 int noko_io_close(void *ctx);
 
 #define Noko_Node_Get_Struct(obj,type,sval) ((sval) = (type*)DATA_PTR(obj))
+#define Noko_Namespace_Get_Struct(obj,type,sval) ((sval) = (type*)DATA_PTR(obj))
 
 VALUE noko_xml_node_wrap(VALUE klass, xmlNodePtr node) ;
 VALUE noko_xml_node_wrap_node_set_result(xmlNodePtr node, VALUE node_set) ;
@@ -197,7 +201,7 @@ NOKOPUBFUN VALUE Nokogiri_wrap_xml_document(VALUE klass,
 #define NOKOGIRI_SAX_SELF(_ctxt) ((nokogiriSAXTuplePtr)(_ctxt))->self
 #define NOKOGIRI_SAX_CTXT(_ctxt) ((nokogiriSAXTuplePtr)(_ctxt))->ctxt
 #define NOKOGIRI_SAX_TUPLE_NEW(_ctxt, _self) nokogiri_sax_tuple_new(_ctxt, _self)
-#define NOKOGIRI_SAX_TUPLE_DESTROY(_tuple) free(_tuple)
+#define NOKOGIRI_SAX_TUPLE_DESTROY(_tuple) ruby_xfree(_tuple)
 
 #define DISCARD_CONST_QUAL(t, v) ((t)(uintptr_t)(v))
 #define DISCARD_CONST_QUAL_XMLCHAR(v) DISCARD_CONST_QUAL(xmlChar *, v)
@@ -214,7 +218,7 @@ void Nokogiri_structured_error_func_save_and_set(libxmlStructuredErrorHandlerSta
 void Nokogiri_structured_error_func_restore(libxmlStructuredErrorHandlerState *handler_state);
 VALUE Nokogiri_wrap_xml_syntax_error(xmlErrorPtr error);
 void Nokogiri_error_array_pusher(void *ctx, xmlErrorPtr error);
-NORETURN(void Nokogiri_error_raise(void *ctx, xmlErrorPtr error));
+NORETURN_DECL void Nokogiri_error_raise(void *ctx, xmlErrorPtr error);
 void Nokogiri_marshal_xpath_funcall_and_return_values(xmlXPathParserContextPtr ctx, int nargs, VALUE handler,
     const char *function_name) ;
 
@@ -222,7 +226,7 @@ static inline
 nokogiriSAXTuplePtr
 nokogiri_sax_tuple_new(xmlParserCtxtPtr ctxt, VALUE self)
 {
-  nokogiriSAXTuplePtr tuple = malloc(sizeof(nokogiriSAXTuple));
+  nokogiriSAXTuplePtr tuple = ruby_xmalloc(sizeof(nokogiriSAXTuple));
   tuple->self = self;
   tuple->ctxt = ctxt;
   return tuple;

data/ext/nokogiri/test_global_handlers.c

@@ -32,7 +32,7 @@ rb_foreign_error_handler(VALUE klass)
  *  Do NOT use this outside of the Nokogiri test suite.
  */
 void
-noko_init_test_global_handlers()
+noko_init_test_global_handlers(void)
 {
   VALUE mNokogiriTest = rb_define_module_under(mNokogiri, "Test");
 

data/ext/nokogiri/xml_attr.c

@@ -89,7 +89,7 @@ new (int argc, VALUE *argv, VALUE klass)
 }
 
 void
-noko_init_xml_attr()
+noko_init_xml_attr(void)
 {
   assert(cNokogiriXmlNode);
   /*

data/ext/nokogiri/xml_attribute_decl.c

@@ -13,7 +13,7 @@ attribute_type(VALUE self)
 {
   xmlAttributePtr node;
   Noko_Node_Get_Struct(self, xmlAttribute, node);
-  return INT2NUM((long)node->atype);
+  return INT2NUM(node->atype);
 }
 
 /*
@@ -59,7 +59,7 @@ enumeration(VALUE self)
 }
 
 void
-noko_init_xml_attribute_decl()
+noko_init_xml_attribute_decl(void)
 {
   assert(cNokogiriXmlNode);
   cNokogiriXmlAttributeDecl = rb_define_class_under(mNokogiriXml, "AttributeDecl", cNokogiriXmlNode);

data/ext/nokogiri/xml_cdata.c

@@ -29,7 +29,7 @@ new (int argc, VALUE *argv, VALUE klass)
 
   if (!NIL_P(content)) {
     content_str = (xmlChar *)StringValuePtr(content);
-    content_str_len = RSTRING_LEN(content);
+    content_str_len = RSTRING_LENINT(content);
   }
 
   node = xmlNewCDataBlock(xml_doc->doc, content_str, content_str_len);
@@ -45,7 +45,7 @@ new (int argc, VALUE *argv, VALUE klass)
 }
 
 void
-noko_init_xml_cdata()
+noko_init_xml_cdata(void)
 {
   assert(cNokogiriXmlText);
   /*

data/ext/nokogiri/xml_comment.c

@@ -48,7 +48,7 @@ new (int argc, VALUE *argv, VALUE klass)
 }
 
 void
-noko_init_xml_comment()
+noko_init_xml_comment(void)
 {
   assert(cNokogiriXmlCharacterData);
   /*

data/ext/nokogiri/xml_document.c

@@ -65,14 +65,12 @@ dealloc(xmlDocPtr doc)
 {
   st_table *node_hash;
 
-  NOKOGIRI_DEBUG_START(doc);
-
   node_hash  = DOC_UNLINKED_NODE_HASH(doc);
 
   st_foreach(node_hash, dealloc_node_i, (st_data_t)doc);
   st_free_table(node_hash);
 
-  free(doc->_private);
+  ruby_xfree(doc->_private);
 
   /* When both Nokogiri and libxml-ruby are loaded, make sure that all nodes
    * have their _private pointers cleared. This is to avoid libxml-ruby's
@@ -84,8 +82,6 @@ dealloc(xmlDocPtr doc)
   }
 
   xmlFreeDoc(doc);
-
-  NOKOGIRI_DEBUG_END(doc);
 }
 
 static void
@@ -104,7 +100,11 @@ recursively_remove_namespaces_from_node(xmlNodePtr node)
        (node->type == XML_XINCLUDE_START) ||
        (node->type == XML_XINCLUDE_END)) &&
       node->nsDef) {
-    xmlFreeNsList(node->nsDef);
+    xmlNsPtr curr = node->nsDef;
+    while (curr) {
+      noko_xml_document_pin_namespace(curr, node->doc);
+      curr = curr->next;
+    }
     node->nsDef = NULL;
   }
 
@@ -536,6 +536,7 @@ rb_xml_document_canonicalize(int argc, VALUE *argv, VALUE self)
   VALUE rb_mode;
   VALUE rb_namespaces;
   VALUE rb_comments_p;
+  int c_mode = 0;
   xmlChar **c_namespaces;
 
   xmlDocPtr c_doc;
@@ -547,8 +548,16 @@ rb_xml_document_canonicalize(int argc, VALUE *argv, VALUE self)
   VALUE rb_io;
 
   rb_scan_args(argc, argv, "03", &rb_mode, &rb_namespaces, &rb_comments_p);
-  if (!NIL_P(rb_mode)) { Check_Type(rb_mode, T_FIXNUM); }
-  if (!NIL_P(rb_namespaces)) { Check_Type(rb_namespaces, T_ARRAY); }
+  if (!NIL_P(rb_mode)) {
+    Check_Type(rb_mode, T_FIXNUM);
+    c_mode = NUM2INT(rb_mode);
+  }
+  if (!NIL_P(rb_namespaces)) {
+    Check_Type(rb_namespaces, T_ARRAY);
+    if (c_mode == XML_C14N_1_0 || c_mode == XML_C14N_1_1) {
+      rb_raise(rb_eRuntimeError, "This canonicalizer does not support this operation");
+    }
+  }
 
   Data_Get_Struct(self, xmlDoc, c_doc);
 
@@ -569,7 +578,7 @@ rb_xml_document_canonicalize(int argc, VALUE *argv, VALUE self)
     c_namespaces = NULL;
   } else {
     long ns_len = RARRAY_LEN(rb_namespaces);
-    c_namespaces = calloc((size_t)ns_len + 1, sizeof(xmlChar *));
+    c_namespaces = ruby_xcalloc((size_t)ns_len + 1, sizeof(xmlChar *));
     for (int j = 0 ; j < ns_len ; j++) {
       VALUE entry = rb_ary_entry(rb_namespaces, j);
       c_namespaces[j] = (xmlChar *)StringValueCStr(entry);
@@ -577,12 +586,12 @@ rb_xml_document_canonicalize(int argc, VALUE *argv, VALUE self)
   }
 
   xmlC14NExecute(c_doc, c_callback_wrapper, rb_callback,
-                 (int)(NIL_P(rb_mode) ? 0 : NUM2INT(rb_mode)),
+                 c_mode,
                  c_namespaces,
                  (int)RTEST(rb_comments_p),
                  c_obuf);
 
-  free(c_namespaces);
+  ruby_xfree(c_namespaces);
   xmlOutputBufferClose(c_obuf);
 
   return rb_funcall(rb_io, rb_intern("string"), 0);
@@ -600,7 +609,7 @@ noko_xml_document_wrap_with_init_args(VALUE klass, xmlDocPtr c_document, int arg
 
   rb_document = Data_Wrap_Struct(klass, mark, dealloc, c_document);
 
-  tuple = (nokogiriTuplePtr)malloc(sizeof(nokogiriTuple));
+  tuple = (nokogiriTuplePtr)ruby_xmalloc(sizeof(nokogiriTuple));
   tuple->doc = rb_document;
   tuple->unlinkedNodes = st_init_numtable_with_size(128);
   tuple->node_cache = rb_ary_new();
@@ -655,7 +664,7 @@ noko_xml_document_pin_namespace(xmlNsPtr ns, xmlDocPtr doc)
 
 
 void
-noko_init_xml_document()
+noko_init_xml_document(void)
 {
   assert(cNokogiriXmlNode);
   /*

data/ext/nokogiri/xml_document_fragment.c

@@ -32,7 +32,7 @@ new (int argc, VALUE *argv, VALUE klass)
 }
 
 void
-noko_init_xml_document_fragment()
+noko_init_xml_document_fragment(void)
 {
   assert(cNokogiriXmlNode);
   /*

data/ext/nokogiri/xml_dtd.c

@@ -190,7 +190,7 @@ external_id(VALUE self)
 }
 
 void
-noko_init_xml_dtd()
+noko_init_xml_dtd(void)
 {
   assert(cNokogiriXmlNode);
   /*

data/ext/nokogiri/xml_element_content.c

@@ -31,7 +31,7 @@ get_type(VALUE self)
   xmlElementContentPtr elem;
   Data_Get_Struct(self, xmlElementContent, elem);
 
-  return INT2NUM((long)elem->type);
+  return INT2NUM(elem->type);
 }
 
 /*
@@ -79,7 +79,7 @@ get_occur(VALUE self)
   xmlElementContentPtr elem;
   Data_Get_Struct(self, xmlElementContent, elem);
 
-  return INT2NUM((long)elem->ocur);
+  return INT2NUM(elem->ocur);
 }
 
 /*
@@ -112,7 +112,7 @@ noko_xml_element_content_wrap(VALUE doc, xmlElementContentPtr element)
 }
 
 void
-noko_init_xml_element_content()
+noko_init_xml_element_content(void)
 {
   cNokogiriXmlElementContent = rb_define_class_under(mNokogiriXml, "ElementContent", rb_cObject);
 

data/ext/nokogiri/xml_element_decl.c

@@ -15,7 +15,7 @@ element_type(VALUE self)
 {
   xmlElementPtr node;
   Noko_Node_Get_Struct(self, xmlElement, node);
-  return INT2NUM((long)node->etype);
+  return INT2NUM(node->etype);
 }
 
 /*
@@ -56,7 +56,7 @@ prefix(VALUE self)
 }
 
 void
-noko_init_xml_element_decl()
+noko_init_xml_element_decl(void)
 {
   assert(cNokogiriXmlNode);
   cNokogiriXmlElementDecl = rb_define_class_under(mNokogiriXml, "ElementDecl", cNokogiriXmlNode);

data/ext/nokogiri/xml_encoding_handler.c

@@ -45,9 +45,9 @@ rb_xml_encoding_handler_s_delete(VALUE klass, VALUE name)
 
 
 /*
- * call-seq: Nokogiri::EncodingHandler.alias(from, to)
+ * call-seq: Nokogiri::EncodingHandler.alias(real_name, alias_name)
  *
- * Alias encoding handler with name +from+ to name +to+
+ * Alias encoding handler with name +real_name+ to name +alias_name+
  */
 static VALUE
 rb_xml_encoding_handler_s_alias(VALUE klass, VALUE from, VALUE to)
@@ -89,7 +89,7 @@ rb_xml_encoding_handler_name(VALUE self)
 
 
 void
-noko_init_xml_encoding_handler()
+noko_init_xml_encoding_handler(void)
 {
   cNokogiriEncodingHandler = rb_define_class_under(mNokogiri, "EncodingHandler", rb_cObject);
 

data/ext/nokogiri/xml_entity_decl.c

@@ -86,7 +86,7 @@ system_id(VALUE self)
 }
 
 void
-noko_init_xml_entity_decl()
+noko_init_xml_entity_decl(void)
 {
   assert(cNokogiriXmlNode);
   cNokogiriXmlEntityDecl = rb_define_class_under(mNokogiriXml, "EntityDecl", cNokogiriXmlNode);

data/ext/nokogiri/xml_entity_reference.c

@@ -38,7 +38,7 @@ new (int argc, VALUE *argv, VALUE klass)
 }
 
 void
-noko_init_xml_entity_reference()
+noko_init_xml_entity_reference(void)
 {
   assert(cNokogiriXmlNode);
   /*

data/ext/nokogiri/xml_namespace.c

@@ -25,13 +25,14 @@
 VALUE cNokogiriXmlNamespace ;
 
 static void
-dealloc_namespace(xmlNsPtr ns)
+_xml_namespace_dealloc(void *ptr)
 {
   /*
    * this deallocator is only used for namespace nodes that are part of an xpath
    * node set. see noko_xml_namespace_wrap().
    */
-  NOKOGIRI_DEBUG_START(ns) ;
+  xmlNsPtr ns = ptr;
+
   if (ns->href) {
     xmlFree(DISCARD_CONST_QUAL_XMLCHAR(ns->href));
   }
@@ -39,39 +40,100 @@ dealloc_namespace(xmlNsPtr ns)
     xmlFree(DISCARD_CONST_QUAL_XMLCHAR(ns->prefix));
   }
   xmlFree(ns);
-  NOKOGIRI_DEBUG_END(ns) ;
 }
 
+#ifdef HAVE_RB_GC_LOCATION
+static void
+_xml_namespace_update_references(void *ptr)
+{
+  xmlNsPtr ns = ptr;
+  if (ns->_private) {
+    ns->_private = (void *)rb_gc_location((VALUE)ns->_private);
+  }
+}
+#else
+#  define _xml_namespace_update_references 0
+#endif
+
+static const rb_data_type_t nokogiri_xml_namespace_type_with_dealloc = {
+  "Nokogiri/XMLNamespace/WithDealloc",
+  {0, _xml_namespace_dealloc, 0, _xml_namespace_update_references},
+  0, 0,
+#ifdef RUBY_TYPED_FREE_IMMEDIATELY
+  RUBY_TYPED_FREE_IMMEDIATELY,
+#endif
+};
+
+static const rb_data_type_t nokogiri_xml_namespace_type_without_dealloc = {
+  "Nokogiri/XMLNamespace/WithoutDealloc",
+  {0, 0, 0, _xml_namespace_update_references},
+  0, 0,
+#ifdef RUBY_TYPED_FREE_IMMEDIATELY
+  RUBY_TYPED_FREE_IMMEDIATELY,
+#endif
+};
 
 /*
- * call-seq:
- *  prefix
+ *  :call-seq:
+ *    prefix() → String or nil
+ *
+ *  Return the prefix for this Namespace, or +nil+ if there is no prefix (e.g., default namespace).
+ *
+ *  *Example*
  *
- * Get the prefix for this namespace.  Returns +nil+ if there is no prefix.
+ *    doc = Nokogiri::XML.parse(<<~XML)
+ *      <?xml version="1.0"?>
+ *      <root xmlns="http://nokogiri.org/ns/default" xmlns:noko="http://nokogiri.org/ns/noko">
+ *        <child1 foo="abc" noko:bar="def"/>
+ *        <noko:child2 foo="qwe" noko:bar="rty"/>
+ *      </root>
+ *    XML
+ *
+ *    doc.root.elements.first.namespace.prefix
+ *    # => nil
+ *
+ *    doc.root.elements.last.namespace.prefix
+ *    # => "noko"
  */
 static VALUE
 prefix(VALUE self)
 {
   xmlNsPtr ns;
 
-  Data_Get_Struct(self, xmlNs, ns);
+  Noko_Namespace_Get_Struct(self, xmlNs, ns);
   if (!ns->prefix) { return Qnil; }
 
   return NOKOGIRI_STR_NEW2(ns->prefix);
 }
 
 /*
- * call-seq:
- *  href
+ *  :call-seq:
+ *    href() → String
+ *
+ *  Returns the URI reference for this Namespace.
+ *
+ *  *Example*
+ *
+ *    doc = Nokogiri::XML.parse(<<~XML)
+ *      <?xml version="1.0"?>
+ *      <root xmlns="http://nokogiri.org/ns/default" xmlns:noko="http://nokogiri.org/ns/noko">
+ *        <child1 foo="abc" noko:bar="def"/>
+ *        <noko:child2 foo="qwe" noko:bar="rty"/>
+ *      </root>
+ *    XML
+ *
+ *    doc.root.elements.first.namespace.href
+ *    # => "http://nokogiri.org/ns/default"
  *
- * Get the href for this namespace
+ *    doc.root.elements.last.namespace.href
+ *    # => "http://nokogiri.org/ns/noko"
  */
 static VALUE
 href(VALUE self)
 {
   xmlNsPtr ns;
 
-  Data_Get_Struct(self, xmlNs, ns);
+  Noko_Namespace_Get_Struct(self, xmlNs, ns);
   if (!ns->href) { return Qnil; }
 
   return NOKOGIRI_STR_NEW2(ns->href);
@@ -87,14 +149,18 @@ noko_xml_namespace_wrap(xmlNsPtr c_namespace, xmlDocPtr c_document)
   }
 
   if (c_document) {
-    rb_namespace = Data_Wrap_Struct(cNokogiriXmlNamespace, 0, 0, c_namespace);
+    rb_namespace = TypedData_Wrap_Struct(cNokogiriXmlNamespace,
+                                         &nokogiri_xml_namespace_type_without_dealloc,
+                                         c_namespace);
 
     if (DOC_RUBY_OBJECT_TEST(c_document)) {
       rb_iv_set(rb_namespace, "@document", DOC_RUBY_OBJECT(c_document));
       rb_ary_push(DOC_NODE_CACHE(c_document), rb_namespace);
     }
   } else {
-    rb_namespace = Data_Wrap_Struct(cNokogiriXmlNamespace, 0, dealloc_namespace, c_namespace);
+    rb_namespace = TypedData_Wrap_Struct(cNokogiriXmlNamespace,
+                                         &nokogiri_xml_namespace_type_with_dealloc,
+                                         c_namespace);
   }
 
   c_namespace->_private = (void *)rb_namespace;
@@ -109,7 +175,7 @@ noko_xml_namespace_wrap_xpath_copy(xmlNsPtr c_namespace)
 }
 
 void
-noko_init_xml_namespace()
+noko_init_xml_namespace(void)
 {
   cNokogiriXmlNamespace = rb_define_class_under(mNokogiriXml, "Namespace", rb_cObject);