nokogiri 1.0.0 → 1.6.8.1

data/ext/nokogiri/xml_relax_ng.c

@@ -0,0 +1,161 @@
+#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;
+  VALUE errors;
+  xmlRelaxNGValidCtxtPtr valid_ctxt;
+
+  Data_Get_Struct(self, xmlRelaxNG, schema);
+  Data_Get_Struct(document, xmlDoc, doc);
+
+  errors = rb_ary_new();
+
+  valid_ctxt = xmlRelaxNGNewValidCtxt(schema);
+
+  if(NULL == valid_ctxt) {
+    /* we have a problem */
+    rb_raise(rb_eRuntimeError, "Could not create a validation context");
+  }
+
+#ifdef HAVE_XMLRELAXNGSETVALIDSTRUCTUREDERRORS
+  xmlRelaxNGSetValidStructuredErrors(
+    valid_ctxt,
+    Nokogiri_error_array_pusher,
+    (void *)errors
+  );
+#endif
+
+  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),
+      (int)RSTRING_LEN(content)
+  );
+  xmlRelaxNGPtr schema;
+  VALUE errors = rb_ary_new();
+  VALUE rb_schema;
+
+  xmlSetStructuredErrorFunc((void *)errors, Nokogiri_error_array_pusher);
+
+#ifdef HAVE_XMLRELAXNGSETPARSERSTRUCTUREDERRORS
+  xmlRelaxNGSetParserStructuredErrors(
+    ctx,
+    Nokogiri_error_array_pusher,
+    (void *)errors
+  );
+#endif
+
+  schema = xmlRelaxNGParse(ctx);
+
+  xmlSetStructuredErrorFunc(NULL, NULL);
+  xmlRelaxNGFreeParserCtxt(ctx);
+
+  if(NULL == schema) {
+    xmlErrorPtr error = xmlGetLastError();
+    if(error)
+      Nokogiri_error_raise(NULL, error);
+    else
+      rb_raise(rb_eRuntimeError, "Could not parse document");
+
+    return Qnil;
+  }
+
+  rb_schema = Data_Wrap_Struct(klass, 0, dealloc, schema);
+  rb_iv_set(rb_schema, "@errors", errors);
+
+  return rb_schema;
+}
+
+/*
+ * call-seq:
+ *  from_document(doc)
+ *
+ * Create a new RelaxNG schema from the Nokogiri::XML::Document +doc+
+ */
+static VALUE from_document(VALUE klass, VALUE document)
+{
+  xmlDocPtr doc;
+  xmlRelaxNGParserCtxtPtr ctx;
+  xmlRelaxNGPtr schema;
+  VALUE errors;
+  VALUE rb_schema;
+
+  Data_Get_Struct(document, xmlDoc, doc);
+
+  /* In case someone passes us a node. ugh. */
+  doc = doc->doc;
+
+  ctx = xmlRelaxNGNewDocParserCtxt(doc);
+
+  errors = rb_ary_new();
+  xmlSetStructuredErrorFunc((void *)errors, Nokogiri_error_array_pusher);
+
+#ifdef HAVE_XMLRELAXNGSETPARSERSTRUCTUREDERRORS
+  xmlRelaxNGSetParserStructuredErrors(
+    ctx,
+    Nokogiri_error_array_pusher,
+    (void *)errors
+  );
+#endif
+
+  schema = xmlRelaxNGParse(ctx);
+
+  xmlSetStructuredErrorFunc(NULL, NULL);
+
+  if(NULL == schema) {
+    xmlErrorPtr error = xmlGetLastError();
+    if(error)
+      Nokogiri_error_raise(NULL, error);
+    else
+      rb_raise(rb_eRuntimeError, "Could not parse document");
+
+    return Qnil;
+  }
+
+  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_singleton_method(klass, "from_document", from_document, 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,135 +1,253 @@
-#define _GNU_SOURCE
-#include <stdio.h>
 #include <xml_sax_parser.h>
 
-/*
- * call-seq:
- *  parse_memory(data)
- *
- * Parse the document stored in +data+
- */
-static VALUE parse_memory(VALUE self, VALUE data)
-{
-  xmlSAXHandlerPtr handler;
-  Data_Get_Struct(self, xmlSAXHandler, handler);
-  xmlSAXUserParseMemory(  handler,
-                          (void *)self,
-                          StringValuePtr(data),
-                          NUM2INT(rb_funcall(data, rb_intern("length"), 0))
-  );
-  return data;
-}
+int vasprintf (char **strp, const char *fmt, va_list ap);
+void vasprintf_free (void *p);
 
-static VALUE native_parse_file(VALUE self, VALUE data)
-{
-  xmlSAXHandlerPtr handler;
-  Data_Get_Struct(self, xmlSAXHandler, handler);
-  xmlSAXUserParseFile(  handler,
-                        (void *)self,
-                        StringValuePtr(data)
-  );
-  return data;
-}
+static ID id_start_document, id_end_document, id_start_element, id_end_element;
+static ID id_start_element_namespace, id_end_element_namespace;
+static ID id_comment, id_characters, id_xmldecl, id_error, id_warning;
+static ID id_cdata_block, id_cAttribute;
+static ID id_processing_instruction;
 
 static void start_document(void * ctx)
 {
-  VALUE self = (VALUE)ctx;
-  VALUE doc = rb_funcall(self, rb_intern("document"), 0);
-  rb_funcall(doc, rb_intern("start_document"), 0);
+  VALUE self = NOKOGIRI_SAX_SELF(ctx);
+  VALUE doc = rb_iv_get(self, "@document");
+
+  xmlParserCtxtPtr ctxt = NOKOGIRI_SAX_CTXT(ctx);
+
+  if(NULL != ctxt && ctxt->html != 1) {
+    if(ctxt->standalone != -1) {  /* -1 means there was no declaration */
+      VALUE encoding = Qnil ;
+      if (ctxt->encoding) {
+        encoding = NOKOGIRI_STR_NEW2(ctxt->encoding) ;
+      } else if (ctxt->input && ctxt->input->encoding) {
+        encoding = NOKOGIRI_STR_NEW2(ctxt->input->encoding) ;
+      }
+
+      VALUE version = ctxt->version ? NOKOGIRI_STR_NEW2(ctxt->version) : Qnil;
+
+      VALUE standalone = Qnil;
+      switch(ctxt->standalone)
+      {
+        case 0:
+          standalone = NOKOGIRI_STR_NEW2("no");
+          break;
+        case 1:
+          standalone = NOKOGIRI_STR_NEW2("yes");
+          break;
+      }
+
+      rb_funcall(doc, id_xmldecl, 3, version, encoding, standalone);
+    }
+  }
+
+  rb_funcall(doc, id_start_document, 0);
 }
 
 static void end_document(void * ctx)
 {
-  VALUE self = (VALUE)ctx;
-  VALUE doc = rb_funcall(self, rb_intern("document"), 0);
-  rb_funcall(doc, rb_intern("end_document"), 0);
+  VALUE self = NOKOGIRI_SAX_SELF(ctx);
+  VALUE doc = rb_iv_get(self, "@document");
+  rb_funcall(doc, id_end_document, 0);
 }
 
 static void start_element(void * ctx, const xmlChar *name, const xmlChar **atts)
 {
-  VALUE self = (VALUE)ctx;
-  VALUE doc = rb_funcall(self, rb_intern("document"), 0);
+  VALUE self = NOKOGIRI_SAX_SELF(ctx);
+  VALUE doc = rb_iv_get(self, "@document");
   VALUE attributes = rb_ary_new();
   const xmlChar * attr;
   int i = 0;
   if(atts) {
     while((attr = atts[i]) != NULL) {
-      rb_funcall(attributes, rb_intern("<<"), 1, rb_str_new2((const char *)attr));
-      i++;
+      const xmlChar * val = atts[i+1];
+      VALUE value = val != NULL ? NOKOGIRI_STR_NEW2(val) : Qnil;
+      rb_ary_push(attributes, rb_ary_new3(2, NOKOGIRI_STR_NEW2(attr), value));
+      i+=2;
     }
   }
 
   rb_funcall( doc,
-              rb_intern("start_element"),
+              id_start_element,
               2,
-              rb_str_new2((const char *)name),
+              NOKOGIRI_STR_NEW2(name),
               attributes
   );
 }
 
 static void end_element(void * ctx, const xmlChar *name)
 {
-  VALUE self = (VALUE)ctx;
-  VALUE doc = rb_funcall(self, rb_intern("document"), 0);
-  rb_funcall(doc, rb_intern("end_element"), 1, rb_str_new2((const char *)name));
+  VALUE self = NOKOGIRI_SAX_SELF(ctx);
+  VALUE doc = rb_iv_get(self, "@document");
+  rb_funcall(doc, id_end_element, 1, NOKOGIRI_STR_NEW2(name));
+}
+
+static VALUE attributes_as_list(
+  VALUE self,
+  int nb_attributes,
+  const xmlChar ** attributes)
+{
+  VALUE list = rb_ary_new2((long)nb_attributes);
+
+  VALUE attr_klass = rb_const_get(cNokogiriXmlSaxParser, id_cAttribute);
+  if (attributes) {
+    /* Each attribute is an array of [localname, prefix, URI, value, end] */
+    int i;
+    for (i = 0; i < nb_attributes * 5; i += 5) {
+      VALUE argv[4], attribute;
+
+      argv[0] = RBSTR_OR_QNIL(attributes[i + 0]); /* localname */
+      argv[1] = RBSTR_OR_QNIL(attributes[i + 1]); /* prefix */
+      argv[2] = RBSTR_OR_QNIL(attributes[i + 2]); /* URI */
+
+      /* value */
+      argv[3] = NOKOGIRI_STR_NEW((const char*)attributes[i+3],
+          (attributes[i+4] - attributes[i+3]));
+
+      attribute = rb_class_new_instance(4, argv, attr_klass);
+      rb_ary_push(list, attribute);
+    }
+  }
+
+  return list;
+}
+
+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 = NOKOGIRI_SAX_SELF(ctx);
+  VALUE doc = rb_iv_get(self, "@document");
+
+  VALUE attribute_list = attributes_as_list(self, nb_attributes, attributes);
+
+  VALUE ns_list = rb_ary_new2((long)nb_namespaces);
+
+  if (namespaces) {
+    int i;
+    for (i = 0; i < nb_namespaces * 2; i += 2)
+    {
+      rb_ary_push(ns_list,
+        rb_ary_new3((long)2,
+          RBSTR_OR_QNIL(namespaces[i + 0]),
+          RBSTR_OR_QNIL(namespaces[i + 1])
+        )
+      );
+    }
+  }
+
+  rb_funcall( doc,
+              id_start_element_namespace,
+              5,
+              NOKOGIRI_STR_NEW2(localname),
+              attribute_list,
+              RBSTR_OR_QNIL(prefix),
+              RBSTR_OR_QNIL(uri),
+              ns_list
+  );
+}
+
+/**
+ * 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 = NOKOGIRI_SAX_SELF(ctx);
+  VALUE doc = rb_iv_get(self, "@document");
+
+  rb_funcall(doc, id_end_element_namespace, 3,
+    NOKOGIRI_STR_NEW2(localname),
+    RBSTR_OR_QNIL(prefix),
+    RBSTR_OR_QNIL(uri)
+  );
 }
 
 static void characters_func(void * ctx, const xmlChar * ch, int len)
 {
-  VALUE self = (VALUE)ctx;
-  VALUE doc = rb_funcall(self, rb_intern("document"), 0);
-  VALUE str = rb_str_new((const char *)ch, (long)len);
-  rb_funcall(doc, rb_intern("characters"), 1, str);
+  VALUE self = NOKOGIRI_SAX_SELF(ctx);
+  VALUE doc = rb_iv_get(self, "@document");
+  VALUE str = NOKOGIRI_STR_NEW(ch, len);
+  rb_funcall(doc, id_characters, 1, str);
 }
 
 static void comment_func(void * ctx, const xmlChar * value)
 {
-  VALUE self = (VALUE)ctx;
-  VALUE doc = rb_funcall(self, rb_intern("document"), 0);
-  VALUE str = rb_str_new2((const char *)value);
-  rb_funcall(doc, rb_intern("comment"), 1, str);
+  VALUE self = NOKOGIRI_SAX_SELF(ctx);
+  VALUE doc = rb_iv_get(self, "@document");
+  VALUE str = NOKOGIRI_STR_NEW2(value);
+  rb_funcall(doc, id_comment, 1, str);
 }
 
-#ifndef XP_WIN
 static void warning_func(void * ctx, const char *msg, ...)
 {
-  VALUE self = (VALUE)ctx;
-  VALUE doc = rb_funcall(self, rb_intern("document"), 0);
+  VALUE self = NOKOGIRI_SAX_SELF(ctx);
+  VALUE doc = rb_iv_get(self, "@document");
   char * message;
+  VALUE ruby_message;
 
   va_list args;
   va_start(args, msg);
   vasprintf(&message, msg, args);
   va_end(args);
 
-  rb_funcall(doc, rb_intern("warning"), 1, rb_str_new2(message));
-  free(message);
+  ruby_message = NOKOGIRI_STR_NEW2(message);
+  vasprintf_free(message);
+  rb_funcall(doc, id_warning, 1, ruby_message);
 }
-#endif
 
-#ifndef XP_WIN
 static void error_func(void * ctx, const char *msg, ...)
 {
-  VALUE self = (VALUE)ctx;
-  VALUE doc = rb_funcall(self, rb_intern("document"), 0);
+  VALUE self = NOKOGIRI_SAX_SELF(ctx);
+  VALUE doc = rb_iv_get(self, "@document");
   char * message;
+  VALUE ruby_message;
 
   va_list args;
   va_start(args, msg);
   vasprintf(&message, msg, args);
   va_end(args);
 
-  rb_funcall(doc, rb_intern("error"), 1, rb_str_new2(message));
-  free(message);
+  ruby_message = NOKOGIRI_STR_NEW2(message);
+  vasprintf_free(message);
+  rb_funcall(doc, id_error, 1, ruby_message);
 }
-#endif
 
 static void cdata_block(void * ctx, const xmlChar * value, int len)
 {
-  VALUE self = (VALUE)ctx;
-  VALUE doc = rb_funcall(self, rb_intern("document"), 0);
-  VALUE string = rb_str_new((const char *)value, (long)len);
-  rb_funcall(doc, rb_intern("cdata_block"), 1, string);
+  VALUE self = NOKOGIRI_SAX_SELF(ctx);
+  VALUE doc = rb_iv_get(self, "@document");
+  VALUE string = NOKOGIRI_STR_NEW(value, len);
+  rb_funcall(doc, id_cdata_block, 1, string);
+}
+
+static void processing_instruction(void * ctx, const xmlChar * name, const xmlChar * content)
+{
+  VALUE rb_content;
+  VALUE self = NOKOGIRI_SAX_SELF(ctx);
+  VALUE doc = rb_iv_get(self, "@document");
+
+  rb_content = content ? NOKOGIRI_STR_NEW2(content) : Qnil;
+
+  rb_funcall( doc,
+              id_processing_instruction,
+              2,
+              NOKOGIRI_STR_NEW2(name),
+              rb_content
+  );
 }
 
 static void deallocate(xmlSAXHandlerPtr handler)
@@ -141,24 +259,23 @@ static void deallocate(xmlSAXHandlerPtr handler)
 
 static VALUE allocate(VALUE klass)
 {
-  xmlSAXHandlerPtr handler = calloc(1, sizeof(xmlSAXHandler));
+  xmlSAXHandlerPtr handler = calloc((size_t)1, sizeof(xmlSAXHandler));
+
+  xmlSetStructuredErrorFunc(NULL, NULL);
 
   handler->startDocument = start_document;
   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;
-#ifndef XP_WIN
-  /*
-   * The va*functions aren't in ming, and I don't want to deal with
-   * it right now.....
-   *
-   */
   handler->warning = warning_func;
   handler->error = error_func;
-#endif
   handler->cdataBlock = cdata_block;
+  handler->processingInstruction = processing_instruction;
+  handler->initialized = XML_SAX2_MAGIC;
 
   return Data_Wrap_Struct(klass, NULL, deallocate, handler);
 }
@@ -166,9 +283,27 @@ static VALUE allocate(VALUE klass)
 VALUE cNokogiriXmlSaxParser ;
 void init_xml_sax_parser()
 {
-  VALUE klass = cNokogiriXmlSaxParser =
-    rb_const_get(mNokogiriXmlSax, rb_intern("Parser"));
+  VALUE nokogiri  = rb_define_module("Nokogiri");
+  VALUE xml       = rb_define_module_under(nokogiri, "XML");
+  VALUE sax       = rb_define_module_under(xml, "SAX");
+  VALUE klass     = rb_define_class_under(sax, "Parser", rb_cObject);
+
+  cNokogiriXmlSaxParser = klass;
+
   rb_define_alloc_func(klass, allocate);
-  rb_define_method(klass, "parse_memory", parse_memory, 1);
-  rb_define_private_method(klass, "native_parse_file", native_parse_file, 1);
+
+  id_start_document = rb_intern("start_document");
+  id_end_document   = rb_intern("end_document");
+  id_start_element  = rb_intern("start_element");
+  id_end_element    = rb_intern("end_element");
+  id_comment        = rb_intern("comment");
+  id_characters     = rb_intern("characters");
+  id_xmldecl        = rb_intern("xmldecl");
+  id_error          = rb_intern("error");
+  id_warning        = rb_intern("warning");
+  id_cdata_block    = rb_intern("cdata_block");
+  id_cAttribute     = rb_intern("Attribute");
+  id_start_element_namespace = rb_intern("start_element_namespace");
+  id_end_element_namespace = rb_intern("end_element_namespace");
+  id_processing_instruction = rb_intern("processing_instruction");
 }

data/ext/nokogiri/xml_sax_parser.h

@@ -1,10 +1,39 @@
 #ifndef NOKOGIRI_XML_SAX_PARSER
 #define NOKOGIRI_XML_SAX_PARSER
 
-#include <native.h>
+#include <nokogiri.h>
 
 void init_xml_sax_parser();
 
 extern VALUE cNokogiriXmlSaxParser ;
+
+typedef struct _nokogiriSAXTuple {
+  xmlParserCtxtPtr  ctxt;
+  VALUE             self;
+} nokogiriSAXTuple;
+
+typedef nokogiriSAXTuple * nokogiriSAXTuplePtr;
+
+#define NOKOGIRI_SAX_SELF(_ctxt) \
+  ((nokogiriSAXTuplePtr)(_ctxt))->self
+
+#define NOKOGIRI_SAX_CTXT(_ctxt) \
+  ((nokogiriSAXTuplePtr)(_ctxt))->ctxt
+
+#define NOKOGIRI_SAX_TUPLE_NEW(_ctxt, _self) \
+  nokogiri_sax_tuple_new(_ctxt, _self)
+
+static inline nokogiriSAXTuplePtr
+nokogiri_sax_tuple_new(xmlParserCtxtPtr ctxt, VALUE self)
+{
+  nokogiriSAXTuplePtr tuple = malloc(sizeof(nokogiriSAXTuple));
+  tuple->self = self;
+  tuple->ctxt = ctxt;
+  return tuple;
+}
+
+#define NOKOGIRI_SAX_TUPLE_DESTROY(_tuple) \
+  free(_tuple) \
+
 #endif