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

data/ext/nokogiri/xml_reader.c

@@ -25,6 +25,46 @@ static int has_attributes(xmlTextReaderPtr reader)
   return(0);
 }
 
+#define XMLNS_PREFIX "xmlns"
+#define XMLNS_PREFIX_LEN 6 /* including either colon or \0 */
+#define XMLNS_BUFFER_LEN 128
+static 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),
+        (ns->href ? NOKOGIRI_STR_NEW2(ns->href) : Qnil)
+    );
+    if (key != buffer) {
+      free(key);
+    }
+    ns = ns->next ;
+  }
+}
+
+
 /*
  * call-seq:
  *   default?
@@ -34,8 +74,10 @@ static int has_attributes(xmlTextReaderPtr reader)
 static VALUE default_eh(VALUE self)
 {
   xmlTextReaderPtr reader;
+  int eh;
+
   Data_Get_Struct(self, xmlTextReader, reader);
-  int eh = xmlTextReaderIsDefault(reader);
+  eh = xmlTextReaderIsDefault(reader);
   if(eh == 0) return Qfalse;
   if(eh == 1) return Qtrue;
 
@@ -51,8 +93,10 @@ static VALUE default_eh(VALUE self)
 static VALUE value_eh(VALUE self)
 {
   xmlTextReaderPtr reader;
+  int eh;
+
   Data_Get_Struct(self, xmlTextReader, reader);
-  int eh = xmlTextReaderHasValue(reader);
+  eh = xmlTextReaderHasValue(reader);
   if(eh == 0) return Qfalse;
   if(eh == 1) return Qtrue;
 
@@ -68,8 +112,10 @@ static VALUE value_eh(VALUE self)
 static VALUE attributes_eh(VALUE self)
 {
   xmlTextReaderPtr reader;
+  int eh;
+
   Data_Get_Struct(self, xmlTextReader, reader);
-  int eh = has_attributes(reader);
+  eh = has_attributes(reader);
   if(eh == 0) return Qfalse;
   if(eh == 1) return Qtrue;
 
@@ -85,6 +131,7 @@ static VALUE attributes_eh(VALUE self)
 static VALUE namespaces(VALUE self)
 {
   xmlTextReaderPtr reader;
+  xmlNodePtr ptr;
   VALUE attr ;
 
   Data_Get_Struct(self, xmlTextReader, reader);
@@ -94,7 +141,7 @@ static VALUE namespaces(VALUE self)
   if (! has_attributes(reader))
     return attr ;
 
-  xmlNodePtr ptr = xmlTextReaderExpand(reader);
+  ptr = xmlTextReaderExpand(reader);
   if(ptr == NULL) return Qnil;
 
   Nokogiri_xml_node_namespaces(ptr, attr);
@@ -111,6 +158,7 @@ static VALUE namespaces(VALUE self)
 static VALUE attribute_nodes(VALUE self)
 {
   xmlTextReaderPtr reader;
+  xmlNodePtr ptr;
   VALUE attr ;
 
   Data_Get_Struct(self, xmlTextReader, reader);
@@ -120,30 +168,9 @@ static VALUE attribute_nodes(VALUE self)
   if (! has_attributes(reader))
     return attr ;
 
-  xmlNodePtr ptr = xmlTextReaderExpand(reader);
+  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 = Data_Wrap_Struct(cNokogiriXmlDocument, 0, 0, ptr->doc);
-    ptr->doc->_private = malloc(sizeof(nokogiriTuple));
-    rb_iv_set(rb_doc, "@decorators", Qnil);
-    ((nokogiriTuplePtr)(ptr->doc->_private))->doc = (void *)rb_doc;
-    ((nokogiriTuplePtr)(ptr->doc->_private))->unlinkedNodes = xmlXPathNodeSetCreate(NULL);
-  }
-  VALUE enc = rb_iv_get(self, "@encoding");
-
-  if(enc != Qnil && NULL == ptr->doc->encoding) {
-    ptr->doc->encoding = calloc((size_t)RSTRING_LEN(enc), sizeof(char));
-    strncpy(
-      (char *)ptr->doc->encoding,
-      StringValuePtr(enc),
-      (size_t)RSTRING_LEN(enc)
-    );
-  }
-
   Nokogiri_xml_node_properties(ptr, attr);
 
   return attr ;
@@ -158,20 +185,21 @@ static VALUE attribute_nodes(VALUE self)
 static VALUE attribute_at(VALUE self, VALUE index)
 {
   xmlTextReaderPtr reader;
+  xmlChar *value;
+  VALUE rb_value;
+
   Data_Get_Struct(self, xmlTextReader, reader);
 
-  if(index == Qnil) return Qnil;
-  index = rb_funcall(index, rb_intern("to_i"), 0);
+  if(NIL_P(index)) return Qnil;
+  index = rb_Integer(index);
 
-  xmlChar * value = xmlTextReaderGetAttributeNo(
+  value = xmlTextReaderGetAttributeNo(
       reader,
-      NUM2INT(index)
+      (int)NUM2INT(index)
   );
   if(value == NULL) return Qnil;
 
-  VALUE MAYBE_UNUSED(enc) = rb_iv_get(self, "@encoding");
-  VALUE rb_value = NOKOGIRI_STR_NEW2(value,
-      RTEST(enc) ? StringValuePtr(enc) : NULL);
+  rb_value = NOKOGIRI_STR_NEW2(value);
   xmlFree(value);
   return rb_value;
 }
@@ -186,9 +214,11 @@ static VALUE reader_attribute(VALUE self, VALUE name)
 {
   xmlTextReaderPtr reader;
   xmlChar *value ;
+  VALUE rb_value;
+
   Data_Get_Struct(self, xmlTextReader, reader);
 
-  if(name == Qnil) return Qnil;
+  if(NIL_P(name)) return Qnil;
   name = StringValue(name) ;
 
   value = xmlTextReaderGetAttribute(reader, (xmlChar*)StringValuePtr(name));
@@ -207,9 +237,7 @@ static VALUE reader_attribute(VALUE self, VALUE name)
   }
   if(value == NULL) return Qnil;
 
-  VALUE MAYBE_UNUSED(enc) = rb_iv_get(self, "@encoding");
-  VALUE rb_value = NOKOGIRI_STR_NEW2(value,
-      RTEST(enc) ? StringValuePtr(enc) : NULL);
+  rb_value = NOKOGIRI_STR_NEW2(value);
   xmlFree(value);
   return rb_value;
 }
@@ -223,11 +251,13 @@ static VALUE reader_attribute(VALUE self, VALUE name)
 static VALUE attribute_count(VALUE self)
 {
   xmlTextReaderPtr reader;
+  int count;
+
   Data_Get_Struct(self, xmlTextReader, reader);
-  int count = xmlTextReaderAttributeCount(reader);
+  count = xmlTextReaderAttributeCount(reader);
   if(count == -1) return Qnil;
 
-  return INT2NUM(count);
+  return INT2NUM((long)count);
 }
 
 /*
@@ -239,11 +269,13 @@ static VALUE attribute_count(VALUE self)
 static VALUE depth(VALUE self)
 {
   xmlTextReaderPtr reader;
+  int depth;
+
   Data_Get_Struct(self, xmlTextReader, reader);
-  int depth = xmlTextReaderDepth(reader);
+  depth = xmlTextReaderDepth(reader);
   if(depth == -1) return Qnil;
 
-  return INT2NUM(depth);
+  return INT2NUM((long)depth);
 }
 
 /*
@@ -255,11 +287,13 @@ static VALUE depth(VALUE self)
 static VALUE xml_version(VALUE self)
 {
   xmlTextReaderPtr reader;
+  const char *version;
+
   Data_Get_Struct(self, xmlTextReader, reader);
-  const char * version = (const char *)xmlTextReaderConstXmlVersion(reader);
+  version = (const char *)xmlTextReaderConstXmlVersion(reader);
   if(version == NULL) return Qnil;
 
-  return NOKOGIRI_STR_NEW2(version, "UTF-8");
+  return NOKOGIRI_STR_NEW2(version);
 }
 
 /*
@@ -271,31 +305,31 @@ static VALUE xml_version(VALUE self)
 static VALUE lang(VALUE self)
 {
   xmlTextReaderPtr reader;
+  const char *lang;
+
   Data_Get_Struct(self, xmlTextReader, reader);
-  const char * lang = (const char *)xmlTextReaderConstXmlLang(reader);
+  lang = (const char *)xmlTextReaderConstXmlLang(reader);
   if(lang == NULL) return Qnil;
 
-  VALUE MAYBE_UNUSED(enc) = rb_iv_get(self, "@encoding");
-  return NOKOGIRI_STR_NEW2(lang,
-      RTEST(enc) ? StringValuePtr(enc) : NULL);
+  return NOKOGIRI_STR_NEW2(lang);
 }
 
 /*
  * call-seq:
  *   value
  *
- * Get the text value of the node if present
+ * Get the text value of the node if present. Returns a utf-8 encoded string.
  */
 static VALUE value(VALUE self)
 {
   xmlTextReaderPtr reader;
+  const char *value;
+
   Data_Get_Struct(self, xmlTextReader, reader);
-  const char * value = (const char *)xmlTextReaderConstValue(reader);
+  value = (const char *)xmlTextReaderConstValue(reader);
   if(value == NULL) return Qnil;
 
-  VALUE MAYBE_UNUSED(enc) = rb_iv_get(self, "@encoding");
-  return NOKOGIRI_STR_NEW2(value,
-      RTEST(enc) ? StringValuePtr(enc) : NULL);
+  return NOKOGIRI_STR_NEW2(value);
 }
 
 /*
@@ -307,13 +341,13 @@ static VALUE value(VALUE self)
 static VALUE prefix(VALUE self)
 {
   xmlTextReaderPtr reader;
+  const char *prefix;
+
   Data_Get_Struct(self, xmlTextReader, reader);
-  const char * prefix = (const char *)xmlTextReaderConstPrefix(reader);
+  prefix = (const char *)xmlTextReaderConstPrefix(reader);
   if(prefix == NULL) return Qnil;
 
-  VALUE MAYBE_UNUSED(enc) = rb_iv_get(self, "@encoding");
-  return NOKOGIRI_STR_NEW2(prefix,
-      RTEST(enc) ? StringValuePtr(enc) : NULL);
+  return NOKOGIRI_STR_NEW2(prefix);
 }
 
 /*
@@ -325,13 +359,13 @@ static VALUE prefix(VALUE self)
 static VALUE namespace_uri(VALUE self)
 {
   xmlTextReaderPtr reader;
+  const char *uri;
+
   Data_Get_Struct(self, xmlTextReader, reader);
-  const char * uri = (const char *)xmlTextReaderConstNamespaceUri(reader);
+  uri = (const char *)xmlTextReaderConstNamespaceUri(reader);
   if(uri == NULL) return Qnil;
 
-  VALUE MAYBE_UNUSED(enc) = rb_iv_get(self, "@encoding");
-  return NOKOGIRI_STR_NEW2(uri,
-      RTEST(enc) ? StringValuePtr(enc) : NULL);
+  return NOKOGIRI_STR_NEW2(uri);
 }
 
 /*
@@ -343,31 +377,49 @@ static VALUE namespace_uri(VALUE self)
 static VALUE local_name(VALUE self)
 {
   xmlTextReaderPtr reader;
+  const char *name;
+
   Data_Get_Struct(self, xmlTextReader, reader);
-  const char * name = (const char *)xmlTextReaderConstLocalName(reader);
+  name = (const char *)xmlTextReaderConstLocalName(reader);
   if(name == NULL) return Qnil;
 
-  VALUE MAYBE_UNUSED(enc) = rb_iv_get(self, "@encoding");
-  return NOKOGIRI_STR_NEW2(name,
-      RTEST(enc) ? StringValuePtr(enc) : NULL);
+  return NOKOGIRI_STR_NEW2(name);
 }
 
 /*
  * call-seq:
  *   name
  *
- * Get the name of the node
+ * Get the name of the node. Returns a utf-8 encoded string.
  */
 static VALUE name(VALUE self)
 {
   xmlTextReaderPtr reader;
+  const char *name;
+
   Data_Get_Struct(self, xmlTextReader, reader);
-  const char * name = (const char *)xmlTextReaderConstName(reader);
+  name = (const char *)xmlTextReaderConstName(reader);
   if(name == NULL) return Qnil;
 
-  VALUE MAYBE_UNUSED(enc) = rb_iv_get(self, "@encoding");
-  return NOKOGIRI_STR_NEW2(name,
-      RTEST(enc) ? StringValuePtr(enc) : NULL);
+  return NOKOGIRI_STR_NEW2(name);
+}
+
+/*
+ * call-seq:
+ * base_uri
+ *
+ * Get the xml:base of the node
+ */
+static VALUE base_uri(VALUE self)
+{
+  xmlTextReaderPtr reader;
+  const char * base_uri;
+
+  Data_Get_Struct(self, xmlTextReader, reader);
+  base_uri = (const char *)xmlTextReaderBaseUri(reader);
+  if (base_uri == NULL) return Qnil;
+
+  return NOKOGIRI_STR_NEW2(base_uri);
 }
 
 /*
@@ -380,7 +432,20 @@ static VALUE state(VALUE self)
 {
   xmlTextReaderPtr reader;
   Data_Get_Struct(self, xmlTextReader, reader);
-  return INT2NUM(xmlTextReaderReadState(reader));
+  return INT2NUM((long)xmlTextReaderReadState(reader));
+}
+
+/*
+ * call-seq:
+ *   node_type
+ *
+ * Get the type of readers current node
+ */
+static VALUE node_type(VALUE self)
+{
+  xmlTextReaderPtr reader;
+  Data_Get_Struct(self, xmlTextReader, reader);
+  return INT2NUM((long)xmlTextReaderNodeType(reader));
 }
 
 /*
@@ -392,28 +457,80 @@ static VALUE state(VALUE self)
 static VALUE read_more(VALUE self)
 {
   xmlTextReaderPtr reader;
+  xmlErrorPtr error;
+  VALUE error_list;
+  int ret;
+
   Data_Get_Struct(self, xmlTextReader, reader);
 
-  VALUE error_list = rb_funcall(self, rb_intern("errors"), 0);
+  error_list = rb_funcall(self, rb_intern("errors"), 0);
 
   xmlSetStructuredErrorFunc((void *)error_list, Nokogiri_error_array_pusher);
-  int ret = xmlTextReaderRead(reader);
+  ret = xmlTextReaderRead(reader);
   xmlSetStructuredErrorFunc(NULL, NULL);
 
   if(ret == 1) return self;
   if(ret == 0) return Qnil;
 
-  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, "Error pulling: %d", ret);
 
   return Qnil;
 }
 
+/*
+ * call-seq:
+ *   inner_xml
+ *
+ * Read the contents of the current node, including child nodes and markup.
+ * Returns a utf-8 encoded string.
+ */
+static VALUE inner_xml(VALUE self)
+{
+  xmlTextReaderPtr reader;
+  xmlChar* value;
+  VALUE str;
+
+  Data_Get_Struct(self, xmlTextReader, reader);
+
+  value = xmlTextReaderReadInnerXml(reader);
+
+  str = Qnil;
+  if(value) {
+    str = NOKOGIRI_STR_NEW2((char*)value);
+    xmlFree(value);
+  }
+
+  return str;
+}
+
+/*
+ * call-seq:
+ *   outer_xml
+ *
+ * Read the current node and its contents, including child nodes and markup.
+ * Returns a utf-8 encoded string.
+ */
+static VALUE outer_xml(VALUE self)
+{
+  xmlTextReaderPtr reader;
+  xmlChar *value;
+  VALUE str = Qnil;
+
+  Data_Get_Struct(self, xmlTextReader, reader);
+
+  value = xmlTextReaderReadOuterXml(reader);
+
+  if(value) {
+    str = NOKOGIRI_STR_NEW2((char*)value);
+    xmlFree(value);
+  }
+  return str;
+}
+
 /*
  * call-seq:
  *   from_memory(string, url = nil, encoding = nil, options = 0)
@@ -423,21 +540,22 @@ static VALUE read_more(VALUE self)
 static VALUE from_memory(int argc, VALUE *argv, VALUE klass)
 {
   VALUE rb_buffer, rb_url, encoding, rb_options;
-
+  xmlTextReaderPtr reader;
   const char * c_url      = NULL;
   const char * c_encoding = NULL;
-  int c_options           = 0; 
+  int c_options           = 0;
+  VALUE rb_reader, args[3];
 
   rb_scan_args(argc, argv, "13", &rb_buffer, &rb_url, &encoding, &rb_options);
 
-  rb_buffer = StringValue(rb_buffer) ;
+  if (!RTEST(rb_buffer)) rb_raise(rb_eArgError, "string cannot be nil");
   if (RTEST(rb_url)) c_url = StringValuePtr(rb_url);
   if (RTEST(encoding)) c_encoding = StringValuePtr(encoding);
-  if (RTEST(rb_options)) c_options = NUM2INT(rb_options);
+  if (RTEST(rb_options)) c_options = (int)NUM2INT(rb_options);
 
-  xmlTextReaderPtr reader = xmlReaderForMemory(
+  reader = xmlReaderForMemory(
       StringValuePtr(rb_buffer),
-      RSTRING_LEN(rb_buffer),
+      (int)RSTRING_LEN(rb_buffer),
       c_url,
       c_encoding,
       c_options
@@ -448,12 +566,78 @@ static VALUE from_memory(int argc, VALUE *argv, VALUE klass)
     rb_raise(rb_eRuntimeError, "couldn't create a parser");
   }
 
-  VALUE rb_reader = Data_Wrap_Struct(klass, NULL, dealloc, reader);
-  rb_funcall(rb_reader, rb_intern("initialize"), 2, rb_url, encoding);
+  rb_reader = Data_Wrap_Struct(klass, NULL, dealloc, reader);
+  args[0] = rb_buffer;
+  args[1] = rb_url;
+  args[2] = encoding;
+  rb_obj_call_init(rb_reader, 3, args);
 
   return rb_reader;
 }
 
+/*
+ * call-seq:
+ *   from_io(io, url = nil, encoding = nil, options = 0)
+ *
+ * Create a new reader that parses +io+
+ */
+static VALUE from_io(int argc, VALUE *argv, VALUE klass)
+{
+  VALUE rb_io, rb_url, encoding, rb_options;
+  xmlTextReaderPtr reader;
+  const char * c_url      = NULL;
+  const char * c_encoding = NULL;
+  int c_options           = 0;
+  VALUE rb_reader, args[3];
+
+  rb_scan_args(argc, argv, "13", &rb_io, &rb_url, &encoding, &rb_options);
+
+  if (!RTEST(rb_io)) rb_raise(rb_eArgError, "io cannot be nil");
+  if (RTEST(rb_url)) c_url = StringValuePtr(rb_url);
+  if (RTEST(encoding)) c_encoding = StringValuePtr(encoding);
+  if (RTEST(rb_options)) c_options = (int)NUM2INT(rb_options);
+
+  reader = xmlReaderForIO(
+      (xmlInputReadCallback)io_read_callback,
+      (xmlInputCloseCallback)io_close_callback,
+      (void *)rb_io,
+      c_url,
+      c_encoding,
+      c_options
+  );
+
+  if(reader == NULL) {
+    xmlFreeTextReader(reader);
+    rb_raise(rb_eRuntimeError, "couldn't create a parser");
+  }
+
+  rb_reader = Data_Wrap_Struct(klass, NULL, dealloc, reader);
+  args[0] = rb_io;
+  args[1] = rb_url;
+  args[2] = encoding;
+  rb_obj_call_init(rb_reader, 3, args);
+
+  return rb_reader;
+}
+
+/*
+ * call-seq:
+ *   reader.empty_element? # => true or false
+ *
+ * Returns true if the current node is empty, otherwise false.
+ */
+static VALUE empty_element_p(VALUE self)
+{
+  xmlTextReaderPtr reader;
+
+  Data_Get_Struct(self, xmlTextReader, reader);
+
+  if(xmlTextReaderIsEmptyElement(reader))
+    return Qtrue;
+
+  return Qfalse;
+}
+
 VALUE cNokogiriXmlReader;
 
 void init_xml_reader()
@@ -471,8 +655,13 @@ void init_xml_reader()
   cNokogiriXmlReader = klass;
 
   rb_define_singleton_method(klass, "from_memory", from_memory, -1);
+  rb_define_singleton_method(klass, "from_io", from_io, -1);
+
   rb_define_method(klass, "read", read_more, 0);
+  rb_define_method(klass, "inner_xml", inner_xml, 0);
+  rb_define_method(klass, "outer_xml", outer_xml, 0);
   rb_define_method(klass, "state", state, 0);
+  rb_define_method(klass, "node_type", node_type, 0);
   rb_define_method(klass, "name", name, 0);
   rb_define_method(klass, "local_name", local_name, 0);
   rb_define_method(klass, "namespace_uri", namespace_uri, 0);
@@ -485,8 +674,11 @@ void init_xml_reader()
   rb_define_method(klass, "attribute", reader_attribute, 1);
   rb_define_method(klass, "namespaces", namespaces, 0);
   rb_define_method(klass, "attribute_at", attribute_at, 1);
-  rb_define_method(klass, "attribute_nodes", attribute_nodes, 0);
+  rb_define_method(klass, "empty_element?", empty_element_p, 0);
   rb_define_method(klass, "attributes?", attributes_eh, 0);
   rb_define_method(klass, "value?", value_eh, 0);
   rb_define_method(klass, "default?", default_eh, 0);
+  rb_define_method(klass, "base_uri", base_uri, 0);
+
+  rb_define_private_method(klass, "attr_nodes", attribute_nodes, 0);
 }