nokogiri 1.1.1-java

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,36 @@
+#include <html_sax_parser.h>
+
+static VALUE native_parse_file(VALUE self, VALUE data, VALUE encoding)
+{
+  xmlSAXHandlerPtr handler;
+  htmlDocPtr hdoc ;
+  Data_Get_Struct(self, xmlSAXHandler, handler);
+  hdoc = htmlSAXParseFile( StringValuePtr(data),
+                           (const char *)StringValuePtr(encoding),
+                           (htmlSAXHandlerPtr)handler,
+                           (void *)self );
+  xmlFreeDoc(hdoc);
+  return data;
+}
+
+static VALUE native_parse_memory(VALUE self, VALUE data, VALUE encoding)
+{
+  xmlSAXHandlerPtr handler;
+  htmlDocPtr hdoc ;
+  Data_Get_Struct(self, xmlSAXHandler, handler);
+  hdoc = htmlSAXParseDoc(  (xmlChar *)StringValuePtr(data),
+                           (const char *)StringValuePtr(encoding),
+                           (htmlSAXHandlerPtr)handler,
+                           (void *)self );
+  xmlFreeDoc(hdoc);
+  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,41 @@
+#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_comment();
+  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,50 @@
+#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/HTMLparser.h>
+#include <libxml/HTMLtree.h>
+
+#include <xml_io.h>
+#include <xml_document.h>
+#include <html_document.h>
+#include <xml_node.h>
+#include <xml_text.h>
+#include <xml_cdata.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_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(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)
+
+#endif
+
+#endif

data/ext/nokogiri/xml_cdata.c

@@ -0,0 +1,44 @@
+#include <xml_cdata.h>
+
+/*
+ * 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 = Nokogiri_wrap_xml_node(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");
+  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, 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_comment.c

@@ -0,0 +1,42 @@
+#include <xml_comment.h>
+
+/*
+ * call-seq:
+ *  new(document, content)
+ *
+ * Create a new Comment 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 = xmlNewDocComment(
+      xml_doc,
+      (const xmlChar *)StringValuePtr(content)
+  );
+
+  VALUE rb_node = Nokogiri_wrap_xml_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, 2);
+}

data/ext/nokogiri/xml_comment.h

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

data/ext/nokogiri/xml_document.c

@@ -0,0 +1,206 @@
+#include <xml_document.h>
+
+static void dealloc(xmlDocPtr doc)
+{
+  NOKOGIRI_DEBUG_START(doc);
+  doc->_private = NULL;
+  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);
+  xmlFree(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);
+  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) ;
+}
+
+/*
+ * 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);
+
+  xmlInitParser();
+
+  xmlDocPtr doc = xmlReadIO(
+      (xmlInputReadCallback)io_read_callback,
+      (xmlInputCloseCallback)io_close_callback,
+      (void *)io,
+      c_url,
+      c_enc,
+      NUM2INT(options)
+  );
+
+  if(doc == NULL) {
+    xmlFreeDoc(doc);
+    rb_raise(rb_eRuntimeError, "Couldn't create a document");
+    return Qnil;
+  }
+
+  return Nokogiri_wrap_xml_document(klass, doc);
+}
+
+/*
+ * 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               = 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 Qnil;
+  }
+
+  return Nokogiri_wrap_xml_document(klass, doc);
+}
+
+/*
+ * call-seq:
+ *  new
+ *
+ * Create a new document
+ */
+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=(boolean)
+ *
+ *  Set the global XML default for substitute entities.
+ */
+static VALUE substitute_entities_set(VALUE klass, VALUE value)
+{
+    xmlSubstituteEntitiesDefault(NUM2INT(value));
+    return Qnil ;
+}
+
+/*
+ *  call-seq:
+ *    load_external_subsets=(boolean)
+ *
+ *  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 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_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);
+  rb_undef_method(klass, "parent");
+}
+
+
+/* this takes klass as a param because it's used for HtmlDocument, too. */
+VALUE Nokogiri_wrap_xml_document(VALUE klass, xmlDocPtr doc)
+{
+  VALUE rb_doc = Qnil;
+
+  rb_doc = Data_Wrap_Struct(klass ? klass : cNokogiriXmlDocument, 0, dealloc, doc) ;
+  rb_iv_set(rb_doc, "@decorators", Qnil);
+  doc->_private = (void *)rb_doc;
+
+  return rb_doc ;
+}