nokogiri 1.3.0-x86-mingw32

data/ext/nokogiri/nokogiri.h

@@ -0,0 +1,149 @@
+#ifndef NOKOGIRI_NATIVE
+#define NOKOGIRI_NATIVE
+
+#include <stdlib.h>
+#include <assert.h>
+#include <ruby.h>
+#include <libxml/parser.h>
+#include <libxml/xpath.h>
+#include <libxml/xpathInternals.h>
+#include <libxml/xmlreader.h>
+#include <libxml/xmlsave.h>
+#include <libxml/xmlschemas.h>
+#include <libxml/HTMLparser.h>
+#include <libxml/HTMLtree.h>
+
+#ifdef USE_INCLUDED_VASPRINTF
+int vasprintf (char **strp, const char *fmt, va_list ap);
+#else
+
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+#  include <stdio.h>
+
+#endif
+
+int is_2_6_16(void) ;
+
+#ifndef UNUSED
+# if defined(__GNUC__)
+#  define MAYBE_UNUSED(name) name __attribute__((unused))
+#  define UNUSED(name) MAYBE_UNUSED(UNUSED_ ## name)
+# else
+#  define MAYBE_UNUSED(name) name
+#  define UNUSED(name) name
+# endif
+#endif
+
+#ifdef HAVE_RUBY_ENCODING_H
+
+#include <ruby/encoding.h>
+
+#define NOKOGIRI_STR_NEW2(str, encoding) \
+  ({ \
+    VALUE _string = rb_str_new2((const char *)str); \
+    if(NULL != encoding) { \
+      int _enc = rb_enc_find_index(encoding); \
+      if(_enc == -1) \
+        rb_enc_associate_index(_string, rb_enc_find_index("ASCII")); \
+      else \
+        rb_enc_associate_index(_string, _enc); \
+    } \
+    _string; \
+  })
+
+#define NOKOGIRI_STR_NEW(str, len, encoding) \
+  ({ \
+    VALUE _string = rb_str_new((const char *)str, (long)len); \
+    if(NULL != encoding) { \
+      int _enc = rb_enc_find_index(encoding); \
+      if(_enc == -1) \
+        rb_enc_associate_index(_string, rb_enc_find_index("ASCII")); \
+      else \
+        rb_enc_associate_index(_string, _enc); \
+    } \
+    _string; \
+  })
+
+#else
+
+#define NOKOGIRI_STR_NEW2(str, doc) \
+  rb_str_new2((const char *)str)
+
+#define NOKOGIRI_STR_NEW(str, len, doc) \
+  rb_str_new((const char *)str, (long)len)
+#endif
+
+#include <xml_io.h>
+#include <xml_document.h>
+#include <html_entity_lookup.h>
+#include <html_document.h>
+#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>
+#include <xml_syntax_error.h>
+#include <xml_schema.h>
+#include <xml_relax_ng.h>
+#include <html_element_description.h>
+#include <xml_namespace.h>
+
+extern VALUE mNokogiri ;
+extern VALUE mNokogiriXml ;
+extern VALUE mNokogiriXmlSax ;
+extern VALUE mNokogiriHtml ;
+extern VALUE mNokogiriHtmlSax ;
+extern VALUE mNokogiriXslt ;
+
+#define NOKOGIRI_ROOT_NODE(_node) \
+  ({ \
+    nokogiriTuplePtr tuple = (nokogiriTuplePtr)(_node->doc->_private);       \
+    xmlNodeSetPtr node_set = (xmlNodeSetPtr)(tuple->unlinkedNodes);     \
+    xmlXPathNodeSetAdd(node_set, _node); \
+    _node; \
+  })
+
+#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 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,92 @@
+#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, name)
+ *
+ * Create a new Attr element on the +document+ with +name+
+ */
+static VALUE new(int argc, VALUE *argv, VALUE klass)
+{
+  xmlDocPtr xml_doc;
+  VALUE document;
+  VALUE name;
+  VALUE rest;
+
+  rb_scan_args(argc, argv, "2*", &document, &name, &rest);
+
+  Data_Get_Struct(document, xmlDoc, xml_doc);
+
+  xmlAttrPtr node = xmlNewDocProp(
+      xml_doc,
+      (const xmlChar *)StringValuePtr(name),
+      NULL
+  );
+
+  NOKOGIRI_ROOT_NODE((xmlNodePtr)node);
+
+  VALUE rb_node = Nokogiri_wrap_xml_node(klass, (xmlNodePtr)node);
+  rb_funcall2(rb_node, rb_intern("initialize"), argc, argv);
+
+  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, -1);
+  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 <nokogiri.h>
+
+void init_xml_attr();
+
+extern VALUE cNokogiriXmlAttr;
+#endif

data/ext/nokogiri/xml_cdata.c

@@ -0,0 +1,53 @@
+#include <xml_cdata.h>
+
+/*
+ * call-seq:
+ *  new(document, content)
+ *
+ * Create a new CData element on the +document+ with +content+
+ */
+static VALUE new(int argc, VALUE *argv, VALUE klass)
+{
+  xmlDocPtr xml_doc;
+  VALUE doc;
+  VALUE content;
+  VALUE rest;
+
+  rb_scan_args(argc, argv, "2*", &doc, &content, &rest);
+
+  Data_Get_Struct(doc, xmlDoc, xml_doc);
+
+  xmlNodePtr node = xmlNewCDataBlock(
+      xml_doc->doc,
+      Qnil == content ? NULL : (const xmlChar *)StringValuePtr(content),
+      Qnil == content ? 0 : RSTRING_LEN(content)
+  );
+
+  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);
+
+  return rb_node;
+}
+
+VALUE cNokogiriXmlCData;
+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);
+
+  /*
+   * CData represents a CData node in an xml document.
+   */
+  VALUE klass = rb_define_class_under(xml, "CDATA", text);
+
+
+  cNokogiriXmlCData = klass;
+
+  rb_define_singleton_method(klass, "new", new, -1);
+}

data/ext/nokogiri/xml_cdata.h

@@ -0,0 +1,9 @@
+#ifndef NOKOGIRI_XML_CDATA
+#define NOKOGIRI_XML_CDATA
+
+#include <nokogiri.h>
+
+void init_xml_cdata();
+
+extern VALUE cNokogiriXmlCData;
+#endif

data/ext/nokogiri/xml_comment.c

@@ -0,0 +1,51 @@
+#include <xml_comment.h>
+
+/*
+ * call-seq:
+ *  new(document, content)
+ *
+ * Create a new Comment element on the +document+ with +content+
+ */
+static VALUE new(int argc, VALUE *argv, VALUE klass)
+{
+  xmlDocPtr xml_doc;
+  VALUE document;
+  VALUE content;
+  VALUE rest;
+
+  rb_scan_args(argc, argv, "2*", &document, &content, &rest);
+
+  Data_Get_Struct(document, xmlDoc, xml_doc);
+
+  xmlNodePtr node = xmlNewDocComment(
+      xml_doc,
+      (const xmlChar *)StringValuePtr(content)
+  );
+
+  VALUE rb_node = Nokogiri_wrap_xml_node(klass, node);
+  rb_funcall2(rb_node, rb_intern("initialize"), argc, argv);
+
+  NOKOGIRI_ROOT_NODE(node);
+
+  if(rb_block_given_p()) rb_yield(rb_node);
+
+  return rb_node;
+}
+
+VALUE cNokogiriXmlComment;
+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);
+
+  /*
+   * Comment represents a comment node in an xml document.
+   */
+  VALUE klass = rb_define_class_under(xml, "Comment", node);
+
+
+  cNokogiriXmlComment = klass;
+
+  rb_define_singleton_method(klass, "new", new, -1);
+}

data/ext/nokogiri/xml_comment.h

@@ -0,0 +1,9 @@
+#ifndef NOKOGIRI_XML_COMMENT
+#define NOKOGIRI_XML_COMMENT
+
+#include <nokogiri.h>
+
+void init_xml_comment();
+
+extern VALUE cNokogiriXmlComment;
+#endif

data/ext/nokogiri/xml_document.c

@@ -0,0 +1,308 @@
+#include <xml_document.h>
+
+static void dealloc(xmlDocPtr doc)
+{
+  NOKOGIRI_DEBUG_START(doc);
+
+  nokogiriTuplePtr tuple = doc->_private;
+  xmlNodeSetPtr node_set = tuple->unlinkedNodes;
+
+  xmlDeregisterNodeFunc func = xmlDeregisterNodeDefault(NULL);
+
+  int j ;
+  for(j = 0 ; j < node_set->nodeNr ; j++) {
+    xmlNodePtr node = node_set->nodeTab[j];
+    switch(node->type)
+    {
+      case XML_ATTRIBUTE_NODE:
+        xmlFreePropList((xmlAttrPtr)node);
+        break;
+      default:
+        if(node->parent == NULL) {
+          xmlAddChild((xmlNodePtr)doc, node);
+        }
+    }
+  }
+
+  if (node_set->nodeTab != NULL)
+    xmlFree(node_set->nodeTab);
+  xmlFree(node_set);
+
+  free(doc->_private);
+  doc->_private = NULL;
+  xmlFreeDoc(doc);
+
+  xmlDeregisterNodeDefault(func);
+
+  NOKOGIRI_DEBUG_END(doc);
+}
+
+/*
+ * call-seq:
+ *  url
+ *
+ * Get the url name for this document.
+ */
+static VALUE url(VALUE self)
+{
+  xmlDocPtr doc;
+  Data_Get_Struct(self, xmlDoc, doc);
+
+  if(doc->URL)
+    return NOKOGIRI_STR_NEW2(doc->URL, doc->encoding);
+
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *  root=
+ *
+ * Set the root element on this document
+ */
+static VALUE set_root(VALUE self, VALUE root)
+{
+  xmlDocPtr doc;
+  xmlNodePtr new_root;
+
+  Data_Get_Struct(self, xmlDoc, doc);
+  Data_Get_Struct(root, xmlNode, new_root);
+
+  xmlDocSetRootElement(doc, new_root);
+  return root;
+}
+
+/*
+ * call-seq:
+ *  root
+ *
+ * Get the root node for this document.
+ */
+static VALUE root(VALUE self)
+{
+  xmlDocPtr doc;
+  Data_Get_Struct(self, xmlDoc, doc);
+
+  xmlNodePtr root = xmlDocGetRootElement(doc);
+
+  if(!root) return Qnil;
+  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;
+}
+
+/*
+ * 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 NOKOGIRI_STR_NEW2(doc->encoding, doc->encoding);
+}
+
+/*
+ * call-seq:
+ *  read_io(io, url, encoding, options)
+ *
+ * Create a new document from an IO object
+ */
+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();
+
+  xmlInitParser();
+  xmlResetLastError();
+  xmlSetStructuredErrorFunc((void *)error_list, Nokogiri_error_array_pusher);
+
+  xmlDocPtr doc = xmlReadIO(
+      (xmlInputReadCallback)io_read_callback,
+      (xmlInputCloseCallback)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;
+}
+
+/*
+ * call-seq:
+ *  read_memory(string, url, encoding, options)
+ *
+ * Create a new document from a String
+ */
+static VALUE read_memory( VALUE klass,
+                          VALUE string,
+                          VALUE url,
+                          VALUE encoding,
+                          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);
+  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);
+
+    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;
+}
+
+/*
+ * 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;
+
+  dup->type = doc->type;
+  return Nokogiri_wrap_xml_document(RBASIC(self)->klass, dup);
+}
+
+/*
+ * call-seq:
+ *  new(version = default)
+ *
+ * Create a new document with +version+ (defaults to "1.0")
+ */
+static VALUE new(int argc, VALUE *argv, VALUE klass)
+{
+  VALUE version, rest, rb_doc ;
+
+  rb_scan_args(argc, argv, "0*", &rest);
+  version = rb_ary_entry(rest, 0);
+  if (version == Qnil) {
+    version = rb_str_new2("1.0");
+  }
+
+  xmlDocPtr doc = xmlNewDoc((xmlChar *)StringValuePtr(version));
+  rb_doc = Nokogiri_wrap_xml_document(klass, doc);
+  rb_funcall2(rb_doc, rb_intern("initialize"), argc, argv);
+  return rb_doc ;
+}
+
+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);
+
+  /*
+   * Nokogiri::XML::Document wraps an xml document.
+   */
+  VALUE klass = rb_define_class_under(xml, "Document", node);
+
+  cNokogiriXmlDocument = 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, "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, "dup", duplicate_node, -1);
+  rb_define_method(klass, "url", url, 0);
+}
+
+
+/* this takes klass as a param because it's used for HtmlDocument, too. */
+VALUE Nokogiri_wrap_xml_document(VALUE klass, xmlDocPtr doc)
+{
+  nokogiriTuplePtr tuple = (nokogiriTuplePtr)malloc(sizeof(nokogiriTuple));
+
+  VALUE rb_doc = Data_Wrap_Struct(
+      klass ? klass : cNokogiriXmlDocument,
+      0,
+      dealloc,
+      doc
+  );
+  rb_iv_set(rb_doc, "@decorators", Qnil);
+  rb_iv_set(rb_doc, "@node_cache", rb_ary_new());
+  rb_funcall(rb_doc, rb_intern("initialize"), 0);
+
+  tuple->doc = (void *)rb_doc;
+  tuple->unlinkedNodes = xmlXPathNodeSetCreate(NULL);
+  doc->_private = tuple ;
+
+  return rb_doc ;
+}