nokogiri 1.1.1 → 1.2.0

data/ext/nokogiri/html_document.c

@@ -2,21 +2,71 @@
 
 /*
  * call-seq:
- *  serialize
+ *  new
  *
- * Serialize this document
+ * Create a new document
  */
-static VALUE serialize(VALUE self)
+static VALUE new(int argc, VALUE *argv, VALUE klass)
 {
-  xmlDocPtr doc;
-  xmlChar *buf;
-  int size;
-  Data_Get_Struct(self, xmlDoc, doc);
+  VALUE uri, external_id;
+
+  rb_scan_args(argc, argv, "02", &uri, &external_id);
+
+  htmlDocPtr doc = htmlNewDoc(
+      RTEST(uri) ? (const xmlChar *)StringValuePtr(uri) : NULL,
+      RTEST(external_id) ? (const xmlChar *)StringValuePtr(external_id) : NULL
+  );
+  return Nokogiri_wrap_xml_document(klass, doc);
+}
+
+/*
+ * call-seq:
+ *  read_io(io, url, encoding, options)
+ *
+ * Read the HTML document from +io+ with given +url+, +encoding+,
+ * and +options+.  See Nokogiri::HTML.parse
+ */
+static VALUE read_io( VALUE klass,
+                      VALUE io,
+                      VALUE url,
+                      VALUE encoding,
+                      VALUE options )
+{
+  const char * c_url    = (url == Qnil) ? NULL : StringValuePtr(url);
+  const char * c_enc    = (encoding == Qnil) ? NULL : StringValuePtr(encoding);
+  VALUE error_list      = rb_ary_new();
 
-  htmlDocDumpMemory(doc, &buf, &size);
-  VALUE rb_str = rb_str_new((char *)buf, (long)size);
-  xmlFree(buf);
-  return rb_str;
+  xmlInitParser();
+  xmlResetLastError();
+  xmlSetStructuredErrorFunc((void *)error_list, Nokogiri_error_array_pusher);
+
+  htmlDocPtr doc = htmlReadIO(
+      io_read_callback,
+      io_close_callback,
+      (void *)io,
+      c_url,
+      c_enc,
+      NUM2INT(options)
+  );
+  xmlSetStructuredErrorFunc(NULL, NULL);
+
+  if(doc == NULL) {
+    xmlFreeDoc(doc);
+
+    xmlErrorPtr error = xmlGetLastError();
+    if(error)
+      rb_funcall(rb_mKernel, rb_intern("raise"), 1,
+          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);
+  return document;
 }
 
 /*
@@ -35,17 +85,33 @@ static VALUE read_memory( VALUE klass,
   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               = NUM2INT(rb_funcall(string, rb_intern("length"), 0));
+  int len               = RSTRING_LEN(string);
+  VALUE error_list      = rb_ary_new();
+
+  xmlInitParser();
+  xmlResetLastError();
+  xmlSetStructuredErrorFunc((void *)error_list, Nokogiri_error_array_pusher);
 
   htmlDocPtr doc = htmlReadMemory(c_buffer, len, c_url, c_enc, NUM2INT(options));
+  xmlSetStructuredErrorFunc(NULL, NULL);
 
   if(doc == NULL) {
     xmlFreeDoc(doc);
-    rb_raise(rb_eRuntimeError, "Couldn't create a document");
+
+    xmlErrorPtr error = xmlGetLastError();
+    if(error)
+      rb_funcall(rb_mKernel, rb_intern("raise"), 1,
+          Nokogiri_wrap_xml_syntax_error((VALUE)NULL, error)
+      );
+    else
+      rb_raise(rb_eRuntimeError, "Could not parse document");
+
     return Qnil;
   }
 
-  return Nokogiri_wrap_xml_document(klass, doc);
+  VALUE document = Nokogiri_wrap_xml_document(klass, doc);
+  rb_funcall(document, rb_intern("errors="), 1, error_list);
+  return document;
 }
 
 /*
@@ -64,23 +130,18 @@ static VALUE type(VALUE self)
 VALUE cNokogiriHtmlDocument ;
 void init_html_document()
 {
-  /*
-   * HACK.  This is so that rdoc will work with this C file.
-   */
-  /*
-  VALUE nokogiri = rb_define_module("Nokogiri");
-  VALUE html = rb_define_module_under(nokogiri, "HTML");
-  VALUE xml = rb_define_module_under(nokogiri, "XML");
-  VALUE node = rb_define_class_under(xml, "Node", rb_cObject);
-  VALUE xml_doc = rb_define_class_under(xml, "Document", node);
-  VALUE klass = rb_define_class_under(html, "Document", xml_doc);
-  */
-
-  VALUE klass ;
-  klass = cNokogiriHtmlDocument = rb_const_get(mNokogiriHtml, rb_intern("Document"));
+  VALUE nokogiri  = rb_define_module("Nokogiri");
+  VALUE html      = rb_define_module_under(nokogiri, "HTML");
+  VALUE xml       = rb_define_module_under(nokogiri, "XML");
+  VALUE node      = rb_define_class_under(xml, "Node", rb_cObject);
+  VALUE xml_doc   = rb_define_class_under(xml, "Document", node);
+  VALUE klass     = rb_define_class_under(html, "Document", xml_doc);
+
+  cNokogiriHtmlDocument = klass;
 
   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_method(klass, "type", type, 0);
-  rb_define_method(klass, "serialize", serialize, 0);
 }

data/ext/nokogiri/html_sax_parser.c

@@ -1,5 +1,11 @@
 #include <html_sax_parser.h>
 
+/*
+ * call-seq:
+ *  native_parse_file(data, encoding)
+ *
+ * Parse +data+ with +encoding+
+ */
 static VALUE native_parse_file(VALUE self, VALUE data, VALUE encoding)
 {
   xmlSAXHandlerPtr handler;
@@ -13,6 +19,12 @@ static VALUE native_parse_file(VALUE self, VALUE data, VALUE encoding)
   return data;
 }
 
+/*
+ * call-seq:
+ *  native_parse_memory(data, encoding)
+ *
+ * Parse +data+ with +encoding+
+ */
 static VALUE native_parse_memory(VALUE self, VALUE data, VALUE encoding)
 {
   xmlSAXHandlerPtr handler;
@@ -29,8 +41,17 @@ static VALUE native_parse_memory(VALUE self, VALUE data, VALUE encoding)
 VALUE cNokogiriHtmlSaxParser ;
 void init_html_sax_parser()
 {
-  VALUE klass = cNokogiriHtmlSaxParser =
-    rb_const_get(mNokogiriHtmlSax, rb_intern("Parser"));
+  VALUE nokogiri  = rb_define_module("Nokogiri");
+  VALUE html      = rb_define_module_under(nokogiri, "HTML");
+  VALUE sax       = rb_define_module_under(html, "SAX");
+  /*
+   * Nokogiri::HTML::SAX::Parser is used for parsing HTML with SAX
+   * callbacks.
+   */
+  VALUE klass     = rb_define_class_under(sax, "Parser", cNokogiriXmlSaxParser);
+
+  cNokogiriHtmlSaxParser = klass;
+
   rb_define_private_method(klass, "native_parse_memory", native_parse_memory, 2);
   rb_define_private_method(klass, "native_parse_file", native_parse_file, 2);
 }

data/ext/nokogiri/native.c

@@ -9,30 +9,40 @@ VALUE mNokogiriHtmlSax ;
 
 void Init_native()
 {
-  mNokogiri = rb_const_get(rb_cObject, rb_intern("Nokogiri"));
-  mNokogiriXml = rb_const_get(mNokogiri, rb_intern("XML"));
-  mNokogiriHtml = rb_const_get(mNokogiri, rb_intern("HTML"));
-  mNokogiriXslt = rb_const_get(mNokogiri, rb_intern("XSLT"));
-  mNokogiriXmlSax = rb_const_get(mNokogiriXml, rb_intern("SAX"));
-  mNokogiriHtmlSax = rb_const_get(mNokogiriHtml, rb_intern("SAX"));
+  xmlMemSetup(
+      (xmlFreeFunc)ruby_xfree,
+      (xmlMallocFunc)ruby_xmalloc,
+      (xmlReallocFunc)ruby_xrealloc,
+      strdup
+  );
+
+  mNokogiri         = rb_define_module("Nokogiri");
+  mNokogiriXml      = rb_define_module_under(mNokogiri, "XML");
+  mNokogiriHtml     = rb_define_module_under(mNokogiri, "HTML");
+  mNokogiriXslt     = rb_define_module_under(mNokogiri, "XSLT");
+  mNokogiriXmlSax   = rb_define_module_under(mNokogiriXml, "SAX");
+  mNokogiriHtmlSax  = rb_define_module_under(mNokogiriHtml, "SAX");
 
   rb_const_set( mNokogiri,
                 rb_intern("LIBXML_VERSION"),
                 rb_str_new2(LIBXML_DOTTED_VERSION)
               );
 
-  xmlSetStructuredErrorFunc(NULL, Nokogiri_error_handler);
-
   init_xml_document();
   init_html_document();
   init_xml_node();
+  init_xml_document_fragment();
   init_xml_text();
   init_xml_cdata();
+  init_xml_processing_instruction();
+  init_xml_attr();
+  init_xml_entity_reference();
   init_xml_comment();
   init_xml_node_set();
   init_xml_xpath_context();
   init_xml_xpath();
   init_xml_sax_parser();
+  init_xml_sax_push_parser();
   init_xml_reader();
   init_xml_dtd();
   init_html_sax_parser();

data/ext/nokogiri/native.h

@@ -8,6 +8,7 @@
 #include <libxml/xpath.h>
 #include <libxml/xpathInternals.h>
 #include <libxml/xmlreader.h>
+#include <libxml/xmlsave.h>
 #include <libxml/HTMLparser.h>
 #include <libxml/HTMLtree.h>
 
@@ -17,12 +18,17 @@
 #include <xml_node.h>
 #include <xml_text.h>
 #include <xml_cdata.h>
+#include <xml_attr.h>
+#include <xml_processing_instruction.h>
+#include <xml_entity_reference.h>
+#include <xml_document_fragment.h>
 #include <xml_comment.h>
 #include <xml_node_set.h>
 #include <xml_xpath.h>
 #include <xml_dtd.h>
 #include <xml_xpath_context.h>
 #include <xml_sax_parser.h>
+#include <xml_sax_push_parser.h>
 #include <xml_reader.h>
 #include <html_sax_parser.h>
 #include <xslt_stylesheet.h>
@@ -45,6 +51,22 @@ extern VALUE mNokogiriXslt ;
 #define NOKOGIRI_DEBUG_START(p)
 #define NOKOGIRI_DEBUG_END(p)
 
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(s) (RSTRING(s)->ptr)
+#endif
+
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(s) (RSTRING(s)->len)
+#endif
+
+#ifndef RARRAY_PTR
+#define RARRAY_PTR(a) RARRAY(a)->ptr
+#endif
+
+#ifndef RARRAY_LEN
+#define RARRAY_LEN(a) RARRAY(a)->len
+#endif
+
 #endif
 
 #endif

data/ext/nokogiri/xml_attr.c

@@ -0,0 +1,83 @@
+#include <xml_attr.h>
+
+/*
+ * call-seq:
+ *  value=(content)
+ *
+ * Set the value for this Attr to +content+
+ */
+static VALUE set_value(VALUE self, VALUE content)
+{
+  xmlAttrPtr attr;
+  Data_Get_Struct(self, xmlAttr, attr);
+
+  if(attr->children) xmlFreeNodeList(attr->children);
+
+  attr->children = attr->last = NULL;
+
+  if(content) {
+    xmlChar *buffer;
+    xmlNode *tmp;
+
+    // Encode our content
+    buffer = xmlEncodeEntitiesReentrant(attr->doc, (unsigned char *)StringValuePtr(content));
+
+    attr->children = xmlStringGetNodeList(attr->doc, buffer);
+    attr->last = NULL;
+    tmp = attr->children;
+
+    // Loop through the children
+    for(tmp = attr->children; tmp; tmp = tmp->next) {
+      tmp->parent = (xmlNode *)attr;
+      tmp->doc = attr->doc;
+      if(tmp->next == NULL) attr->last = tmp;
+    }
+
+    // Free up memory
+    xmlFree(buffer);
+  }
+
+  return content;
+}
+
+/*
+ * call-seq:
+ *  new(document, content)
+ *
+ * Create a new Attr element on the +document+ with +name+
+ */
+static VALUE new(VALUE klass, VALUE doc, VALUE name)
+{
+  xmlDocPtr xml_doc;
+  Data_Get_Struct(doc, xmlDoc, xml_doc);
+
+  xmlAttrPtr node = xmlNewDocProp(
+      xml_doc,
+      (const xmlChar *)StringValuePtr(name),
+      NULL
+  );
+
+  VALUE rb_node = Nokogiri_wrap_xml_node((xmlNodePtr)node);
+
+  if(rb_block_given_p()) rb_yield(rb_node);
+
+  return rb_node;
+}
+
+VALUE cNokogiriXmlAttr;
+void init_xml_attr()
+{
+  VALUE nokogiri = rb_define_module("Nokogiri");
+  VALUE xml = rb_define_module_under(nokogiri, "XML");
+  VALUE node = rb_define_class_under(xml, "Node", rb_cObject);
+
+  /*
+   * Attr represents a Attr node in an xml document.
+   */
+  VALUE klass = rb_define_class_under(xml, "Attr", node);
+
+  cNokogiriXmlAttr = klass;
+
+  rb_define_singleton_method(klass, "new", new, 2);
+  rb_define_method(klass, "value=", set_value, 1);
+}

data/ext/nokogiri/xml_attr.h

@@ -0,0 +1,9 @@
+#ifndef NOKOGIRI_XML_ATTR
+#define NOKOGIRI_XML_ATTR
+
+#include <native.h>
+
+void init_xml_attr();
+
+extern VALUE cNokogiriXmlAttr;
+#endif

data/ext/nokogiri/xml_cdata.c

@@ -14,7 +14,7 @@ static VALUE new(VALUE klass, VALUE doc, VALUE content)
   xmlNodePtr node = xmlNewCDataBlock(
       xml_doc,
       (const xmlChar *)StringValuePtr(content),
-      NUM2INT(rb_funcall(content, rb_intern("length"), 0))
+      RSTRING_LEN(content)
   );
 
   VALUE rb_node = Nokogiri_wrap_xml_node(node);

data/ext/nokogiri/xml_document.c

@@ -10,21 +10,19 @@ static void dealloc(xmlDocPtr doc)
 
 /*
  * call-seq:
- *  serialize
+ *  url
  *
- * Serialize this document
+ * Get the url name for this document.
  */
-static VALUE serialize(VALUE self)
+static VALUE url(VALUE self)
 {
   xmlDocPtr doc;
-  xmlChar *buf;
-  int size;
   Data_Get_Struct(self, xmlDoc, doc);
 
-  xmlDocDumpMemory(doc, &buf, &size);
-  VALUE rb_str = rb_str_new((char *)buf, (long)size);
-  xmlFree(buf);
-  return rb_str;
+  if(doc->URL)
+    return rb_str_new2((const char *)doc->URL);
+
+  return Qnil;
 }
 
 /*
@@ -62,6 +60,21 @@ static VALUE root(VALUE self)
   return Nokogiri_wrap_xml_node(root) ;
 }
 
+/*
+ * call-seq:
+ *  encoding
+ *
+ * Get the encoding for this Document
+ */
+static VALUE encoding(VALUE self)
+{
+  xmlDocPtr doc;
+  Data_Get_Struct(self, xmlDoc, doc);
+
+  if(!doc->encoding) return Qnil;
+  return rb_str_new2((const char *)doc->encoding);
+}
+
 /*
  * call-seq:
  *  read_io(io, url, encoding, options)
@@ -76,8 +89,11 @@ static VALUE read_io( VALUE klass,
 {
   const char * c_url    = (url == Qnil) ? NULL : StringValuePtr(url);
   const char * c_enc    = (encoding == Qnil) ? NULL : StringValuePtr(encoding);
+  VALUE error_list      = rb_ary_new();
 
   xmlInitParser();
+  xmlResetLastError();
+  xmlSetStructuredErrorFunc((void *)error_list, Nokogiri_error_array_pusher);
 
   xmlDocPtr doc = xmlReadIO(
       (xmlInputReadCallback)io_read_callback,
@@ -87,14 +103,25 @@ static VALUE read_io( VALUE klass,
       c_enc,
       NUM2INT(options)
   );
+  xmlSetStructuredErrorFunc(NULL, NULL);
 
   if(doc == NULL) {
     xmlFreeDoc(doc);
-    rb_raise(rb_eRuntimeError, "Couldn't create a document");
+
+    xmlErrorPtr error = xmlGetLastError();
+    if(error)
+      rb_funcall(rb_mKernel, rb_intern("raise"), 1,
+          Nokogiri_wrap_xml_syntax_error((VALUE)NULL, error)
+      );
+    else
+      rb_raise(rb_eRuntimeError, "Could not parse document");
+
     return Qnil;
   }
 
-  return Nokogiri_wrap_xml_document(klass, doc);
+  VALUE document = Nokogiri_wrap_xml_document(klass, doc);
+  rb_funcall(document, rb_intern("errors="), 1, error_list);
+  return document;
 }
 
 /*
@@ -112,18 +139,55 @@ static VALUE read_memory( VALUE klass,
   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               = NUM2INT(rb_funcall(string, rb_intern("length"), 0));
+  int len               = RSTRING_LEN(string);
+  VALUE error_list      = rb_ary_new();
 
   xmlInitParser();
+  xmlResetLastError();
+  xmlSetStructuredErrorFunc((void *)error_list, Nokogiri_error_array_pusher);
   xmlDocPtr doc = xmlReadMemory(c_buffer, len, c_url, c_enc, NUM2INT(options));
+  xmlSetStructuredErrorFunc(NULL, NULL);
 
   if(doc == NULL) {
     xmlFreeDoc(doc);
-    rb_raise(rb_eRuntimeError, "Couldn't create a document");
+
+    xmlErrorPtr error = xmlGetLastError();
+    if(error)
+      rb_funcall(rb_mKernel, rb_intern("raise"), 1,
+          Nokogiri_wrap_xml_syntax_error((VALUE)NULL, error)
+      );
+    else
+      rb_raise(rb_eRuntimeError, "Could not parse document");
+
     return Qnil;
   }
 
-  return Nokogiri_wrap_xml_document(klass, doc);
+  VALUE document = Nokogiri_wrap_xml_document(klass, doc);
+  rb_funcall(document, rb_intern("errors="), 1, error_list);
+  return document;
+}
+
+/*
+ * call-seq:
+ *  dup
+ *
+ * Copy this Document.  An optional depth may be passed in, but it defaults
+ * to a deep copy.  0 is a shallow copy, 1 is a deep copy.
+ */
+static VALUE duplicate_node(int argc, VALUE *argv, VALUE self)
+{
+  VALUE level;
+
+  if(rb_scan_args(argc, argv, "01", &level) == 0)
+    level = INT2NUM(1);
+
+  xmlDocPtr doc, dup;
+  Data_Get_Struct(self, xmlDoc, doc);
+
+  dup = xmlCopyDoc(doc, NUM2INT(level));
+  if(dup == NULL) return Qnil;
+
+  return Nokogiri_wrap_xml_document(cNokogiriXmlDocument, dup);
 }
 
 /*
@@ -169,9 +233,9 @@ static VALUE load_external_subsets_set(VALUE klass, VALUE value)
 VALUE cNokogiriXmlDocument ;
 void init_xml_document()
 {
-  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 nokogiri  = rb_define_module("Nokogiri");
+  VALUE xml       = rb_define_module_under(nokogiri, "XML");
+  VALUE node      = rb_define_class_under(xml, "Node", rb_cObject);
 
   /*
    * Nokogiri::XML::Document wraps an xml document.
@@ -188,7 +252,9 @@ void init_xml_document()
 
   rb_define_method(klass, "root", root, 0);
   rb_define_method(klass, "root=", set_root, 1);
-  rb_define_method(klass, "serialize", serialize, 0);
+  rb_define_method(klass, "encoding", encoding, 0);
+  rb_define_method(klass, "dup", duplicate_node, -1);
+  rb_define_method(klass, "url", url, 0);
   rb_undef_method(klass, "parent");
 }