nokogiri 1.2.3-java → 1.3.0-java

data/ext/nokogiri/xml_reader.h

@@ -1,7 +1,7 @@
 #ifndef NOKOGIRI_XML_READER
 #define NOKOGIRI_XML_READER
 
-#include <native.h>
+#include <nokogiri.h>
 
 void init_xml_reader();
 

data/ext/nokogiri/xml_relax_ng.c

@@ -0,0 +1,106 @@
+#include <xml_relax_ng.h>
+
+static void dealloc(xmlRelaxNGPtr schema)
+{
+  NOKOGIRI_DEBUG_START(schema);
+  xmlRelaxNGFree(schema);
+  NOKOGIRI_DEBUG_END(schema);
+}
+
+/*
+ * call-seq:
+ *  validate_document(document)
+ *
+ * Validate a Nokogiri::XML::Document against this RelaxNG schema.
+ */
+static VALUE validate_document(VALUE self, VALUE document)
+{
+  xmlDocPtr doc;
+  xmlRelaxNGPtr schema;
+
+  Data_Get_Struct(self, xmlRelaxNG, schema);
+  Data_Get_Struct(document, xmlDoc, doc);
+
+  VALUE errors = rb_ary_new();
+
+  xmlRelaxNGValidCtxtPtr valid_ctxt = xmlRelaxNGNewValidCtxt(schema);
+
+  if(NULL == valid_ctxt) {
+    // we have a problem
+    rb_raise(rb_eRuntimeError, "Could not create a validation context");
+  }
+
+  if (! is_2_6_16()) {
+    xmlRelaxNGSetValidStructuredErrors(
+      valid_ctxt,
+      Nokogiri_error_array_pusher,
+      (void *)errors
+    );
+  }
+
+  xmlRelaxNGValidateDoc(valid_ctxt, doc);
+
+  xmlRelaxNGFreeValidCtxt(valid_ctxt);
+
+  return errors;
+}
+
+/*
+ * call-seq:
+ *  read_memory(string)
+ *
+ * Create a new RelaxNG from the contents of +string+
+ */
+static VALUE read_memory(VALUE klass, VALUE content)
+{
+  xmlRelaxNGParserCtxtPtr ctx = xmlRelaxNGNewMemParserCtxt(
+      (const char *)StringValuePtr(content),
+      RSTRING_LEN(content)
+  );
+
+  VALUE errors = rb_ary_new();
+  xmlSetStructuredErrorFunc((void *)errors, Nokogiri_error_array_pusher);
+
+  if (! is_2_6_16()) {
+    xmlRelaxNGSetParserStructuredErrors(
+      ctx,
+      Nokogiri_error_array_pusher,
+      (void *)errors
+    );
+  }
+
+  xmlRelaxNGPtr schema = xmlRelaxNGParse(ctx);
+
+  xmlSetStructuredErrorFunc(NULL, NULL);
+  xmlRelaxNGFreeParserCtxt(ctx);
+
+  if(NULL == schema) {
+    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 rb_schema = Data_Wrap_Struct(klass, 0, dealloc, schema);
+  rb_iv_set(rb_schema, "@errors", errors);
+
+  return rb_schema;
+}
+
+VALUE cNokogiriXmlRelaxNG;
+void init_xml_relax_ng()
+{
+  VALUE nokogiri = rb_define_module("Nokogiri");
+  VALUE xml = rb_define_module_under(nokogiri, "XML");
+  VALUE klass = rb_define_class_under(xml, "RelaxNG", cNokogiriXmlSchema);
+
+  cNokogiriXmlRelaxNG = klass;
+
+  rb_define_singleton_method(klass, "read_memory", read_memory, 1);
+  rb_define_private_method(klass, "validate_document", validate_document, 1);
+}

data/ext/nokogiri/xml_relax_ng.h

@@ -0,0 +1,9 @@
+#ifndef NOKOGIRI_XML_RELAX_NG
+#define NOKOGIRI_XML_RELAX_NG
+
+#include <nokogiri.h>
+
+void init_xml_relax_ng();
+
+extern VALUE cNokogiriXmlRelaxNG;
+#endif

data/ext/nokogiri/xml_sax_parser.c

@@ -1,5 +1,4 @@
-#include <stdio.h>
-#include <xml_sax_parser.h>
+#include <nokogiri.h>
 
 /*
  * call-seq:
@@ -11,6 +10,9 @@ static VALUE parse_memory(VALUE self, VALUE data)
 {
   xmlSAXHandlerPtr handler;
   Data_Get_Struct(self, xmlSAXHandler, handler);
+
+  if(Qnil == data) rb_raise(rb_eArgError, "data cannot be nil");
+
   xmlSAXUserParseMemory(  handler,
                           (void *)self,
                           StringValuePtr(data),
@@ -111,6 +113,121 @@ static void end_element(void * ctx, const xmlChar *name)
   );
 }
 
+/**
+ * start_element_ns was borrowed heavily from libxml-ruby. 
+ */
+static void
+start_element_ns (
+  void * ctx,
+  const xmlChar * localname,
+  const xmlChar * prefix,
+  const xmlChar * URI,
+  int nb_namespaces,
+  const xmlChar ** namespaces,
+  int nb_attributes,
+  int nb_defaulted,
+  const xmlChar ** attributes)
+{
+  VALUE self = (VALUE)ctx;
+  VALUE doc = rb_funcall(self, rb_intern("document"), 0);
+  VALUE MAYBE_UNUSED(enc) = rb_iv_get(self, "@encoding");
+
+  VALUE attrHash = rb_hash_new();
+  VALUE nsHash = rb_hash_new();
+
+  if (attributes)
+  {
+    /* Each attribute is an array of [localname, prefix, URI, value, end] */
+    int i;
+    for (i = 0; i < nb_attributes * 5; i += 5)
+    {
+      rb_hash_aset( attrHash,
+                    NOKOGIRI_STR_NEW2((const char*)attributes[i+0], RTEST(enc) ? StringValuePtr(enc) : NULL),
+                    NOKOGIRI_STR_NEW((const char*)attributes[i+3], (attributes[i+4] - attributes[i+3]), RTEST(enc) ? StringValuePtr(enc) : NULL));
+    }
+  }
+
+  if (namespaces)
+  {
+    int i;
+    for (i = 0; i < nb_namespaces * 2; i += 2)
+    {
+      rb_hash_aset( nsHash,
+                    namespaces[i+0] ? NOKOGIRI_STR_NEW2((const char*)namespaces[i+0], RTEST(enc) ? StringValuePtr(enc) : NULL) : Qnil,
+                    namespaces[i+1] ? NOKOGIRI_STR_NEW2((const char*)namespaces[i+1], RTEST(enc) ? StringValuePtr(enc) : NULL) : Qnil);
+    }
+  }
+
+  rb_funcall( doc,
+              rb_intern("start_element_ns"),
+              5,
+              NOKOGIRI_STR_NEW2(localname, RTEST(enc) ? StringValuePtr(enc) : NULL),
+              attrHash,
+              prefix ? NOKOGIRI_STR_NEW2(prefix, RTEST(enc) ? StringValuePtr(enc) : NULL) : Qnil,
+              URI ? NOKOGIRI_STR_NEW2(URI, RTEST(enc) ? StringValuePtr(enc) : NULL) : Qnil,
+              nsHash
+  );
+
+  /* Call start element if it's there' */
+  if (rb_respond_to(doc, rb_intern("start_element")))
+  {
+    VALUE name;
+    if (prefix)
+    {
+      name = NOKOGIRI_STR_NEW2(prefix, RTEST(enc) ? StringValuePtr(enc) : NULL);
+      rb_funcall(name, rb_intern("<<"), 1, NOKOGIRI_STR_NEW2(":", RTEST(enc) ? StringValuePtr(enc) : NULL));
+      rb_funcall(name, rb_intern("<<"), 1, NOKOGIRI_STR_NEW2(localname, RTEST(enc) ? StringValuePtr(enc) : NULL));
+    }
+    else
+    {
+      name = NOKOGIRI_STR_NEW2(localname, RTEST(enc) ? StringValuePtr(enc) : NULL);
+    }
+    VALUE attrArray = rb_funcall(attrHash, rb_intern("to_a"), 0);
+    attrArray = rb_funcall(attrArray, rb_intern("flatten"), 0);
+    rb_funcall(doc, rb_intern("start_element"), 2, name, attrArray);
+  }
+
+}
+
+/**
+ * end_element_ns was borrowed heavily from libxml-ruby. 
+ */
+static void
+end_element_ns (
+  void * ctx,
+  const xmlChar * localname,
+  const xmlChar * prefix,
+  const xmlChar * URI)
+{
+  VALUE self = (VALUE)ctx;
+  VALUE doc = rb_funcall(self, rb_intern("document"), 0);
+  VALUE MAYBE_UNUSED(enc) = rb_iv_get(self, "@encoding");
+
+  rb_funcall(doc, rb_intern("end_element_ns"), 3, 
+             NOKOGIRI_STR_NEW2(localname, RTEST(enc) ? StringValuePtr(enc) : NULL),
+             prefix ? NOKOGIRI_STR_NEW2(prefix, RTEST(enc) ? StringValuePtr(enc) : NULL) : Qnil,
+             URI ? NOKOGIRI_STR_NEW2(URI, RTEST(enc) ? StringValuePtr(enc) : NULL) : Qnil
+  );
+
+  /* Call end element for old-times sake */
+  if (rb_respond_to(doc, rb_intern("end_element")))
+  {
+    VALUE name;
+    if (prefix)
+    {
+      name = NOKOGIRI_STR_NEW2(prefix, RTEST(enc) ? StringValuePtr(enc) : NULL);
+      rb_funcall(name, rb_intern("<<"), 1, NOKOGIRI_STR_NEW2(":", RTEST(enc) ? StringValuePtr(enc) : NULL));
+      rb_funcall(name, rb_intern("<<"), 1, NOKOGIRI_STR_NEW2(localname, RTEST(enc) ? StringValuePtr(enc) : NULL));
+    }
+    else
+    {
+      name = NOKOGIRI_STR_NEW2(localname, RTEST(enc) ? StringValuePtr(enc) : NULL);
+    }
+    rb_funcall(doc, rb_intern("end_element"), 1, name);
+  }
+
+}
+
 static void characters_func(void * ctx, const xmlChar * ch, int len)
 {
   VALUE self = (VALUE)ctx;
@@ -190,11 +307,14 @@ static VALUE allocate(VALUE klass)
   handler->endDocument = end_document;
   handler->startElement = start_element;
   handler->endElement = end_element;
+  handler->startElementNs = start_element_ns;
+  handler->endElementNs = end_element_ns;
   handler->characters = characters_func;
   handler->comment = comment_func;
   handler->warning = warning_func;
   handler->error = error_func;
   handler->cdataBlock = cdata_block;
+  handler->initialized = XML_SAX2_MAGIC;
 
   return Data_Wrap_Struct(klass, NULL, deallocate, handler);
 }

data/ext/nokogiri/xml_sax_parser.h

@@ -1,7 +1,7 @@
 #ifndef NOKOGIRI_XML_SAX_PARSER
 #define NOKOGIRI_XML_SAX_PARSER
 
-#include <native.h>
+#include <nokogiri.h>
 
 void init_xml_sax_parser();
 

data/ext/nokogiri/xml_sax_push_parser.c

@@ -65,6 +65,7 @@ static VALUE initialize_native(VALUE self, VALUE _xml_sax, VALUE _filename)
   if(ctx == NULL)
     rb_raise(rb_eRuntimeError, "Could not create a parser context");
 
+  ctx->sax2 = 1;
   DATA_PTR(self) = ctx;
   return self;
 }

data/ext/nokogiri/xml_sax_push_parser.h

@@ -1,7 +1,7 @@
 #ifndef NOKOGIRI_XML_SAX_PUSH_PARSER
 #define NOKOGIRI_XML_SAX_PUSH_PARSER
 
-#include <native.h>
+#include <nokogiri.h>
 
 void init_xml_sax_push_parser();
 

data/ext/nokogiri/xml_schema.c

@@ -0,0 +1,107 @@
+#include <xml_schema.h>
+
+static void dealloc(xmlSchemaPtr schema)
+{
+  NOKOGIRI_DEBUG_START(schema);
+  xmlSchemaFree(schema);
+  NOKOGIRI_DEBUG_END(schema);
+}
+
+/*
+ * call-seq:
+ *  validate_document(document)
+ *
+ * Validate a Nokogiri::XML::Document against this Schema.
+ */
+static VALUE validate_document(VALUE self, VALUE document)
+{
+  xmlDocPtr doc;
+  xmlSchemaPtr schema;
+
+  Data_Get_Struct(self, xmlSchema, schema);
+  Data_Get_Struct(document, xmlDoc, doc);
+
+  VALUE errors = rb_ary_new();
+
+  xmlSchemaValidCtxtPtr valid_ctxt = xmlSchemaNewValidCtxt(schema);
+
+  if(NULL == valid_ctxt) {
+    // we have a problem
+    rb_raise(rb_eRuntimeError, "Could not create a validation context");
+  }
+
+  if (! is_2_6_16()) {
+    xmlSchemaSetValidStructuredErrors(
+      valid_ctxt,
+      Nokogiri_error_array_pusher,
+      (void *)errors
+    );
+  }
+
+  xmlSchemaValidateDoc(valid_ctxt, doc);
+
+  xmlSchemaFreeValidCtxt(valid_ctxt);
+
+  return errors;
+}
+
+/*
+ * call-seq:
+ *  read_memory(string)
+ *
+ * Create a new Schema from the contents of +string+
+ */
+static VALUE read_memory(VALUE klass, VALUE content)
+{
+
+  xmlSchemaParserCtxtPtr ctx = xmlSchemaNewMemParserCtxt(
+      (const char *)StringValuePtr(content),
+      RSTRING_LEN(content)
+  );
+
+  VALUE errors = rb_ary_new();
+  xmlSetStructuredErrorFunc((void *)errors, Nokogiri_error_array_pusher);
+
+  if (! is_2_6_16()) {
+    xmlSchemaSetParserStructuredErrors(
+      ctx,
+      Nokogiri_error_array_pusher,
+      (void *)errors
+    );
+  }
+
+  xmlSchemaPtr schema = xmlSchemaParse(ctx);
+
+  xmlSetStructuredErrorFunc(NULL, NULL);
+  xmlSchemaFreeParserCtxt(ctx);
+
+  if(NULL == schema) {
+    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 rb_schema = Data_Wrap_Struct(klass, 0, dealloc, schema);
+  rb_iv_set(rb_schema, "@errors", errors);
+
+  return rb_schema;
+}
+
+VALUE cNokogiriXmlSchema;
+void init_xml_schema()
+{
+  VALUE nokogiri = rb_define_module("Nokogiri");
+  VALUE xml = rb_define_module_under(nokogiri, "XML");
+  VALUE klass = rb_define_class_under(xml, "Schema", rb_cObject);
+
+  cNokogiriXmlSchema = klass;
+
+  rb_define_singleton_method(klass, "read_memory", read_memory, 1);
+  rb_define_private_method(klass, "validate_document", validate_document, 1);
+}

data/ext/nokogiri/xml_schema.h

@@ -0,0 +1,9 @@
+#ifndef NOKOGIRI_XML_SCHEMA
+#define NOKOGIRI_XML_SCHEMA
+
+#include <nokogiri.h>
+
+void init_xml_schema();
+
+extern VALUE cNokogiriXmlSchema;
+#endif

data/ext/nokogiri/xml_syntax_error.h

@@ -1,7 +1,7 @@
 #ifndef NOKOGIRI_XML_SYNTAX_ERROR
 #define NOKOGIRI_XML_SYNTAX_ERROR
 
-#include <native.h>
+#include <nokogiri.h>
 
 void init_xml_syntax_error();
 VALUE Nokogiri_wrap_xml_syntax_error(VALUE klass, xmlErrorPtr error);

data/ext/nokogiri/xml_text.c

@@ -6,15 +6,22 @@
  *
  * Create a new Text element on the +document+ with +content+
  */
-static VALUE new(VALUE klass, VALUE string, VALUE document)
+static VALUE new(int argc, VALUE *argv, VALUE klass)
 {
   xmlDocPtr doc;
+  VALUE string;
+  VALUE document;
+  VALUE rest;
+
+  rb_scan_args(argc, argv, "2*", &string, &document, &rest);
+
   Data_Get_Struct(document, xmlDoc, doc);
 
   xmlNodePtr node = xmlNewText((xmlChar *)StringValuePtr(string));
   node->doc = doc;
 
-  VALUE rb_node = Nokogiri_wrap_xml_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);
 
@@ -36,5 +43,5 @@ void init_xml_text()
 
   cNokogiriXmlText = klass;
 
-  rb_define_singleton_method(klass, "new", new, 2);
+  rb_define_singleton_method(klass, "new", new, -1);
 }