tenderlove-nokogiri 0.0.0-x86-mswin32-60

data/ext/nokogiri/html_document.c

@@ -0,0 +1,83 @@
+#include <html_document.h>
+
+/*
+ * call-seq:
+ *  serialize
+ *
+ * Serialize this document
+ */
+static VALUE serialize(VALUE self)
+{
+  xmlDocPtr doc;
+  xmlChar *buf;
+  int size;
+  Data_Get_Struct(self, xmlDoc, doc);
+
+  htmlDocDumpMemory(doc, &buf, &size);
+  VALUE rb_str = rb_str_new((char *)buf, (long)size);
+  free(buf);
+  return rb_str;
+}
+
+/*
+ * call-seq:
+ *  read_memory(string, url, encoding, options)
+ *
+ * Read the HTML document contained in +string+ with given +url+, +encoding+,
+ * and +options+.  See Nokogiri::HTML.parse
+ */
+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               = NUM2INT(rb_funcall(string, rb_intern("length"), 0));
+
+  htmlDocPtr doc = htmlReadMemory(c_buffer, len, c_url, c_enc, NUM2INT(options));
+
+  if(doc == NULL)
+    doc = htmlNewDoc((const xmlChar *)c_url, NULL);
+
+  return Nokogiri_wrap_xml_document(klass, doc);
+}
+
+/*
+ * call-seq:
+ *  type
+ *
+ * The type for this document
+ */
+static VALUE type(VALUE self)
+{
+  htmlDocPtr doc;
+  Data_Get_Struct(self, xmlDoc, doc);
+  return INT2NUM((int)doc->type);
+}
+
+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"));
+
+  rb_define_singleton_method(klass, "read_memory", read_memory, 4);
+
+  rb_define_method(klass, "type", type, 0);
+  rb_define_method(klass, "serialize", serialize, 0);
+}

data/ext/nokogiri/html_document.h

@@ -0,0 +1,10 @@
+#ifndef NOKOGIRI_HTML_DOCUMENT
+#define NOKOGIRI_HTML_DOCUMENT
+
+#include <native.h>
+
+void init_html_document();
+
+extern VALUE cNokogiriHtmlDocument ;
+
+#endif

data/ext/nokogiri/html_sax_parser.c

@@ -0,0 +1,32 @@
+#include <html_sax_parser.h>
+
+static VALUE native_parse_file(VALUE self, VALUE data, VALUE encoding)
+{
+  xmlSAXHandlerPtr handler;
+  Data_Get_Struct(self, xmlSAXHandler, handler);
+  htmlSAXParseFile( StringValuePtr(data),
+                    (const char *)StringValuePtr(encoding),
+                    (htmlSAXHandlerPtr)handler,
+                    (void *)self );
+  return data;
+}
+
+static VALUE native_parse_memory(VALUE self, VALUE data, VALUE encoding)
+{
+  xmlSAXHandlerPtr handler;
+  Data_Get_Struct(self, xmlSAXHandler, handler);
+  htmlSAXParseDoc(  (xmlChar *)StringValuePtr(data),
+                    (const char *)StringValuePtr(encoding),
+                    (htmlSAXHandlerPtr)handler,
+                    (void *)self );
+  return data;
+}
+
+VALUE cNokogiriHtmlSaxParser ;
+void init_html_sax_parser()
+{
+  VALUE klass = cNokogiriHtmlSaxParser =
+    rb_const_get(mNokogiriHtmlSax, rb_intern("Parser"));
+  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/html_sax_parser.h

@@ -0,0 +1,11 @@
+#ifndef NOKOGIRI_HTML_SAX_PARSER
+#define NOKOGIRI_HTML_SAX_PARSER
+
+#include <native.h>
+
+void init_html_sax_parser();
+
+extern VALUE cNokogiriHtmlSaxParser ;
+#endif
+
+

data/ext/nokogiri/native.c

@@ -0,0 +1,40 @@
+#include <native.h>
+
+VALUE mNokogiri ;
+VALUE mNokogiriXml ;
+VALUE mNokogiriHtml ;
+VALUE mNokogiriXslt ;
+VALUE mNokogiriXmlSax ;
+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"));
+
+  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_text();
+  init_xml_cdata();
+  init_xml_node_set();
+  init_xml_xpath_context();
+  init_xml_xpath();
+  init_xml_sax_parser();
+  init_xml_reader();
+  init_xml_dtd();
+  init_html_sax_parser();
+  init_xslt_stylesheet();
+  init_xml_syntax_error();
+}

data/ext/nokogiri/native.h

@@ -0,0 +1,51 @@
+#ifndef NOKOGIRI_NATIVE
+#define NOKOGIRI_NATIVE
+
+#include <stdlib.h>
+#include <ruby.h>
+#include <libxml/parser.h>
+#include <libxml/xpath.h>
+#include <libxml/xpathInternals.h>
+#include <libxml/xmlreader.h>
+#include <libxml/HTMLparser.h>
+#include <libxml/HTMLtree.h>
+
+#include <xml_document.h>
+#include <html_document.h>
+#include <xml_node.h>
+#include <xml_text.h>
+#include <xml_cdata.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_reader.h>
+#include <html_sax_parser.h>
+#include <xslt_stylesheet.h>
+#include <xml_syntax_error.h>
+
+extern VALUE mNokogiri ;
+extern VALUE mNokogiriXml ;
+extern VALUE mNokogiriXmlSax ;
+extern VALUE mNokogiriHtml ;
+extern VALUE mNokogiriHtmlSax ;
+extern VALUE mNokogiriXslt ;
+
+#ifdef DEBUG
+
+#define NOKOGIRI_DEBUG_START_NODE(p) if (getenv("NOKOGIRI_DEBUG")) fprintf(stderr,"\nnokogiri: %s:%d %p start node (%p %x %p/%s)\n", __FILE__, __LINE__, p, p->_private, p->type, p->name, p->name);
+#define NOKOGIRI_DEBUG_START_TEXT(p) if (getenv("NOKOGIRI_DEBUG")) fprintf(stderr,"\nnokogiri: %s:%d %p start node (%p %x %p/%s) '%s'\n", __FILE__, __LINE__, p, p->_private, p->type, p->name, p->name, p->content);
+#define NOKOGIRI_DEBUG_START(p) 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_NODE(p)
+#define NOKOGIRI_DEBUG_START_TEXT(p)
+#define NOKOGIRI_DEBUG_START(p)
+#define NOKOGIRI_DEBUG_END(p)
+
+#endif
+
+#endif

data/ext/nokogiri/xml_cdata.c

@@ -0,0 +1,52 @@
+#include <xml_cdata.h>
+
+static void dealloc(xmlNodePtr node)
+{
+  if (node->doc == NULL) {
+    NOKOGIRI_DEBUG_START_NODE(node);
+    xmlFreeNode(node);
+    NOKOGIRI_DEBUG_END(node);
+  }
+}
+
+/*
+ * call-seq:
+ *  new(document, content)
+ *
+ * Create a new CData element on the +document+ with +content+
+ */
+static VALUE new(VALUE klass, VALUE doc, VALUE content)
+{
+  xmlDocPtr xml_doc;
+  Data_Get_Struct(doc, xmlDoc, xml_doc);
+
+  xmlNodePtr node = xmlNewCDataBlock(
+      xml_doc,
+      (const xmlChar *)StringValuePtr(content),
+      NUM2INT(rb_funcall(content, rb_intern("length"), 0))
+  );
+
+  VALUE rb_node = Data_Wrap_Struct(klass, NULL, dealloc, node);
+  node->_private = (void *)rb_node;
+
+  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");
+
+  /*
+   * CData represents a CData node in an xml document.
+   */
+  VALUE klass = rb_define_class_under(xml, "CData", cNokogiriXmlNode);
+
+
+  cNokogiriXmlCData = klass;
+
+  rb_define_singleton_method(klass, "new", new, 2);
+}

data/ext/nokogiri/xml_cdata.h

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

data/ext/nokogiri/xml_document.c

@@ -0,0 +1,159 @@
+#include <xml_document.h>
+
+/*
+ *  note that xmlDocPtr is being cast as an xmlNodePtr, which is legal for the
+ *  "common part" struct header which contains only node pointers.
+ */
+static void gc_mark(xmlNodePtr node)
+{
+  xmlNodePtr child ;
+  /* mark children nodes */
+  for (child = node->children ; child ; child = child->next) {
+    if (child->_private)
+      rb_gc_mark((VALUE)child->_private);
+  }
+}
+
+static void dealloc(xmlDocPtr doc)
+{
+  NOKOGIRI_DEBUG_START(doc);
+  xmlFreeDoc(doc);
+  NOKOGIRI_DEBUG_END(doc);
+}
+
+/*
+ * call-seq:
+ *  serialize
+ *
+ * Serialize this document
+ */
+static VALUE serialize(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);
+  free(buf);
+  return rb_str;
+}
+
+/*
+ * 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);
+  Nokogiri_xml_node_owned_set(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(root) ;
+}
+
+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               = NUM2INT(rb_funcall(string, rb_intern("length"), 0));
+
+  xmlInitParser();
+  xmlDocPtr doc = xmlReadMemory(c_buffer, len, c_url, c_enc, NUM2INT(options));
+
+  if(doc == NULL) {
+    xmlFreeDoc(doc);
+    rb_raise(rb_eRuntimeError, "Couldn't create a document");
+  }
+
+  return Nokogiri_wrap_xml_document(klass, doc);
+}
+
+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 = xmlNewDoc((xmlChar *)StringValuePtr(version));
+  return Nokogiri_wrap_xml_document(klass, doc);
+}
+
+/*
+ *  call-seq:
+ *    substitute_entities_set bool)
+ *
+ *  Set the global XML default for substitute entities.
+ */
+static VALUE substitute_entities_set(VALUE klass, VALUE value)
+{
+    xmlSubstituteEntitiesDefault(NUM2INT(value));
+    return Qnil ;
+}
+
+/*
+ *  call-seq:
+ *    substitute_entities_set bool)
+ *
+ *  Set the global XML default for load external subsets.
+ */
+static VALUE load_external_subsets_set(VALUE klass, VALUE value)
+{
+    xmlLoadExtDtdDefaultValue = NUM2INT(value);
+    return Qnil ;
+}
+
+VALUE cNokogiriXmlDocument ;
+void init_xml_document()
+{
+  VALUE klass = cNokogiriXmlDocument = rb_const_get(mNokogiriXml, rb_intern("Document"));
+
+  rb_define_singleton_method(klass, "read_memory", read_memory, 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, "serialize", serialize, 0);
+}
+
+
+/* this takes klass as a param because it's used for HtmlDocument, too. */
+VALUE Nokogiri_wrap_xml_document(VALUE klass, xmlDocPtr doc)
+{
+  if (doc->_private)
+    return (VALUE)doc->_private ;
+  VALUE rb_doc = Data_Wrap_Struct(klass ? klass : cNokogiriXmlDocument, gc_mark, dealloc, doc) ;
+  doc->_private = (void*)rb_doc ;
+  return rb_doc ;
+}

data/ext/nokogiri/xml_document.h

@@ -0,0 +1,10 @@
+#ifndef NOKOGIRI_XML_DOCUMENT
+#define NOKOGIRI_XML_DOCUMENT
+
+#include <native.h>
+
+void init_xml_document();
+VALUE Nokogiri_wrap_xml_document(VALUE klass, xmlDocPtr doc);
+
+extern VALUE cNokogiriXmlDocument ;
+#endif

data/ext/nokogiri/xml_dtd.c

@@ -0,0 +1,117 @@
+#include <xml_dtd.h>
+
+static void notation_copier(void *payload, void *data, xmlChar *name)
+{
+  VALUE hash = (VALUE)data;
+  VALUE klass = rb_const_get(mNokogiriXml, rb_intern("Notation"));
+
+  xmlNotationPtr c_notation = (xmlNotationPtr)payload;
+
+  VALUE notation = rb_funcall(klass, rb_intern("new"), 3,
+      c_notation->name ? rb_str_new2((const char *)c_notation->name) : Qnil,
+      c_notation->PublicID ? rb_str_new2((const char *)c_notation->PublicID) : Qnil,
+      c_notation->SystemID ? rb_str_new2((const char *)c_notation->SystemID) : Qnil);
+
+  rb_hash_aset(hash, rb_str_new2((const char *)name), notation);
+}
+
+static void element_copier(void *payload, void *data, xmlChar *name)
+{
+  VALUE hash = (VALUE)data;
+
+  VALUE element = Nokogiri_wrap_xml_node((xmlNodePtr)payload);
+
+  rb_hash_aset(hash, rb_str_new2((const char *)name), element);
+}
+
+/*
+ * call-seq:
+ *   entities
+ *
+ * Get a hash of the elements for this DTD.
+ */
+static VALUE entities(VALUE self)
+{
+  xmlDtdPtr dtd;
+  Data_Get_Struct(self, xmlDtd, dtd);
+
+  if(!dtd->entities) return Qnil;
+
+  VALUE hash = rb_hash_new();
+
+  xmlHashScan((xmlHashTablePtr)dtd->entities, element_copier, (void *)hash);
+
+  return hash;
+}
+
+/*
+ * call-seq:
+ *   attributes
+ *
+ * Get a hash of the attributes for this DTD.
+ */
+static VALUE attributes(VALUE self)
+{
+  xmlDtdPtr dtd;
+  Data_Get_Struct(self, xmlDtd, dtd);
+
+  if(!dtd->attributes) return Qnil;
+
+  VALUE hash = rb_hash_new();
+
+  xmlHashScan((xmlHashTablePtr)dtd->attributes, element_copier, (void *)hash);
+
+  return hash;
+}
+
+/*
+ * call-seq:
+ *   notations
+ *
+ * Get a hash of the notations for this DTD.
+ */
+static VALUE notations(VALUE self)
+{
+  xmlDtdPtr dtd;
+  Data_Get_Struct(self, xmlDtd, dtd);
+
+  if(!dtd->notations) return Qnil;
+
+  VALUE hash = rb_hash_new();
+
+  xmlHashScan((xmlHashTablePtr)dtd->notations, notation_copier, (void *)hash);
+
+  return hash;
+}
+
+/*
+ * call-seq:
+ *   elements
+ *
+ * Get a hash of the elements for this DTD.
+ */
+static VALUE elements(VALUE self)
+{
+  xmlDtdPtr dtd;
+  Data_Get_Struct(self, xmlDtd, dtd);
+
+  if(!dtd->elements) return Qnil;
+
+  VALUE hash = rb_hash_new();
+
+  xmlHashScan((xmlHashTablePtr)dtd->elements, element_copier, (void *)hash);
+
+  return hash;
+}
+
+void init_xml_dtd()
+{
+  VALUE nokogiri = rb_define_module("Nokogiri");
+  VALUE xml = rb_define_module_under(nokogiri, "XML");
+  VALUE klass = rb_define_class_under(xml, "DTD", cNokogiriXmlNode);
+
+  rb_define_method(klass, "notations", notations, 0);
+  rb_define_method(klass, "elements", elements, 0);
+  rb_define_method(klass, "attributes", attributes, 0);
+  rb_define_method(klass, "entities", entities, 0);
+}

data/ext/nokogiri/xml_dtd.h

@@ -0,0 +1,8 @@
+#ifndef NOKOGIRI_XML_DTD
+#define NOKOGIRI_XML_DTD
+
+#include <native.h>
+
+void init_xml_dtd();
+
+#endif