nokogiri 1.11.0.rc2-x86-linux → 1.11.2-x86-linux

data/ext/nokogiri/html_entity_lookup.c

@@ -1,4 +1,6 @@
-#include <html_entity_lookup.h>
+#include <nokogiri.h>
+
+static VALUE cNokogiriHtmlEntityLookup;
 
 /*
  * call-seq:
@@ -6,27 +8,30 @@
  *
  * Get the HTML::EntityDescription for +key+
  */
-static VALUE get(VALUE self, VALUE key)
+static VALUE
+get(VALUE _, VALUE rb_entity_name)
 {
-  const htmlEntityDesc * desc =
-    htmlEntityLookup((const xmlChar *)StringValueCStr(key));
-  VALUE klass, args[3];
+  VALUE cNokogiriHtmlEntityDescription;
+  const htmlEntityDesc *c_entity_desc;
+  VALUE rb_constructor_args[3];
 
-  if(NULL == desc) return Qnil;
-  klass = rb_const_get(mNokogiriHtml, rb_intern("EntityDescription"));
+  c_entity_desc = htmlEntityLookup((const xmlChar *)StringValueCStr(rb_entity_name));
+  if (NULL == c_entity_desc) {
+    return Qnil;
+  }
 
-  args[0] = INT2NUM((long)desc->value);
-  args[1] = NOKOGIRI_STR_NEW2(desc->name);
-  args[2] = NOKOGIRI_STR_NEW2(desc->desc);
+  rb_constructor_args[0] = INT2NUM((long)c_entity_desc->value);
+  rb_constructor_args[1] = NOKOGIRI_STR_NEW2(c_entity_desc->name);
+  rb_constructor_args[2] = NOKOGIRI_STR_NEW2(c_entity_desc->desc);
 
-  return rb_class_new_instance(3, args, klass);
+  cNokogiriHtmlEntityDescription = rb_const_get_at(mNokogiriHtml, rb_intern("EntityDescription"));
+  return rb_class_new_instance(3, rb_constructor_args, cNokogiriHtmlEntityDescription);
 }
 
-void init_html_entity_lookup()
+void
+noko_init_html_entity_lookup()
 {
-  VALUE nokogiri = rb_define_module("Nokogiri");
-  VALUE html = rb_define_module_under(nokogiri, "HTML");
-  VALUE klass = rb_define_class_under(html, "EntityLookup", rb_cObject);
+  cNokogiriHtmlEntityLookup = rb_define_class_under(mNokogiriHtml, "EntityLookup", rb_cObject);
 
-  rb_define_method(klass, "get", get, 1);
+  rb_define_method(cNokogiriHtmlEntityLookup, "get", get, 1);
 }

data/ext/nokogiri/html_sax_parser_context.c

@@ -1,116 +1,119 @@
-#include <html_sax_parser_context.h>
+#include <nokogiri.h>
 
 VALUE cNokogiriHtmlSaxParserContext ;
 
-static void deallocate(xmlParserCtxtPtr ctxt)
+static void
+deallocate(xmlParserCtxtPtr ctxt)
 {
-  NOKOGIRI_DEBUG_START(handler);
+  NOKOGIRI_DEBUG_START(ctxt);
 
   ctxt->sax = NULL;
 
   htmlFreeParserCtxt(ctxt);
 
-  NOKOGIRI_DEBUG_END(handler);
+  NOKOGIRI_DEBUG_END(ctxt);
 }
 
 static VALUE
 parse_memory(VALUE klass, VALUE data, VALUE encoding)
 {
-    htmlParserCtxtPtr ctxt;
-
-    if (NIL_P(data))
-	rb_raise(rb_eArgError, "data cannot be nil");
-    if (!(int)RSTRING_LEN(data))
-	rb_raise(rb_eRuntimeError, "data cannot be empty");
-
-    ctxt = htmlCreateMemoryParserCtxt(StringValuePtr(data),
-				      (int)RSTRING_LEN(data));
-    if (ctxt->sax) {
-	xmlFree(ctxt->sax);
-	ctxt->sax = NULL;
+  htmlParserCtxtPtr ctxt;
+
+  if (NIL_P(data)) {
+    rb_raise(rb_eArgError, "data cannot be nil");
+  }
+  if (!(int)RSTRING_LEN(data)) {
+    rb_raise(rb_eRuntimeError, "data cannot be empty");
+  }
+
+  ctxt = htmlCreateMemoryParserCtxt(StringValuePtr(data),
+                                    (int)RSTRING_LEN(data));
+  if (ctxt->sax) {
+    xmlFree(ctxt->sax);
+    ctxt->sax = NULL;
+  }
+
+  if (RTEST(encoding)) {
+    xmlCharEncodingHandlerPtr enc = xmlFindCharEncodingHandler(StringValueCStr(encoding));
+    if (enc != NULL) {
+      xmlSwitchToEncoding(ctxt, enc);
+      if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
+        rb_raise(rb_eRuntimeError, "Unsupported encoding %s",
+                 StringValueCStr(encoding));
+      }
     }
+  }
 
-    if (RTEST(encoding)) {
-	xmlCharEncodingHandlerPtr enc = xmlFindCharEncodingHandler(StringValueCStr(encoding));
-	if (enc != NULL) {
-	    xmlSwitchToEncoding(ctxt, enc);
-	    if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
-		rb_raise(rb_eRuntimeError, "Unsupported encoding %s",
-			 StringValueCStr(encoding));
-	    }
-	}
-    }
-
-    return Data_Wrap_Struct(klass, NULL, deallocate, ctxt);
+  return Data_Wrap_Struct(klass, NULL, deallocate, ctxt);
 }
 
-static VALUE parse_file(VALUE klass, VALUE filename, VALUE encoding)
+static VALUE
+parse_file(VALUE klass, VALUE filename, VALUE encoding)
 {
   htmlParserCtxtPtr ctxt = htmlCreateFileParserCtxt(
-      StringValueCStr(filename),
-      StringValueCStr(encoding)
-  );
+                             StringValueCStr(filename),
+                             StringValueCStr(encoding)
+                           );
   return Data_Wrap_Struct(klass, NULL, deallocate, ctxt);
 }
 
 static VALUE
 parse_doc(VALUE ctxt_val)
 {
-    htmlParserCtxtPtr ctxt = (htmlParserCtxtPtr)ctxt_val;
-    htmlParseDocument(ctxt);
-    return Qnil;
+  htmlParserCtxtPtr ctxt = (htmlParserCtxtPtr)ctxt_val;
+  htmlParseDocument(ctxt);
+  return Qnil;
 }
 
 static VALUE
 parse_doc_finalize(VALUE ctxt_val)
 {
-    htmlParserCtxtPtr ctxt = (htmlParserCtxtPtr)ctxt_val;
+  htmlParserCtxtPtr ctxt = (htmlParserCtxtPtr)ctxt_val;
 
-    if (ctxt->myDoc)
-	xmlFreeDoc(ctxt->myDoc);
+  if (ctxt->myDoc) {
+    xmlFreeDoc(ctxt->myDoc);
+  }
 
-    NOKOGIRI_SAX_TUPLE_DESTROY(ctxt->userData);
-    return Qnil;
+  NOKOGIRI_SAX_TUPLE_DESTROY(ctxt->userData);
+  return Qnil;
 }
 
 static VALUE
 parse_with(VALUE self, VALUE sax_handler)
 {
-    htmlParserCtxtPtr ctxt;
-    htmlSAXHandlerPtr sax;
+  htmlParserCtxtPtr ctxt;
+  htmlSAXHandlerPtr sax;
+
+  if (!rb_obj_is_kind_of(sax_handler, cNokogiriXmlSaxParser)) {
+    rb_raise(rb_eArgError, "argument must be a Nokogiri::XML::SAX::Parser");
+  }
 
-    if (!rb_obj_is_kind_of(sax_handler, cNokogiriXmlSaxParser))
-	rb_raise(rb_eArgError, "argument must be a Nokogiri::XML::SAX::Parser");
+  Data_Get_Struct(self, htmlParserCtxt, ctxt);
+  Data_Get_Struct(sax_handler, htmlSAXHandler, sax);
 
-    Data_Get_Struct(self, htmlParserCtxt, ctxt);
-    Data_Get_Struct(sax_handler, htmlSAXHandler, sax);
+  /* Free the sax handler since we'll assign our own */
+  if (ctxt->sax && ctxt->sax != (xmlSAXHandlerPtr)&xmlDefaultSAXHandler) {
+    xmlFree(ctxt->sax);
+  }
 
-    /* Free the sax handler since we'll assign our own */
-    if (ctxt->sax && ctxt->sax != (xmlSAXHandlerPtr)&xmlDefaultSAXHandler)
-	xmlFree(ctxt->sax);
+  ctxt->sax = sax;
+  ctxt->userData = (void *)NOKOGIRI_SAX_TUPLE_NEW(ctxt, sax_handler);
 
-    ctxt->sax = sax;
-    ctxt->userData = (void *)NOKOGIRI_SAX_TUPLE_NEW(ctxt, sax_handler);
+  xmlSetStructuredErrorFunc(NULL, NULL);
 
-    rb_ensure(parse_doc, (VALUE)ctxt, parse_doc_finalize, (VALUE)ctxt);
+  rb_ensure(parse_doc, (VALUE)ctxt, parse_doc_finalize, (VALUE)ctxt);
 
-    return self;
+  return self;
 }
 
-void init_html_sax_parser_context()
+void
+noko_init_html_sax_parser_context()
 {
-  VALUE nokogiri  = rb_define_module("Nokogiri");
-  VALUE xml       = rb_define_module_under(nokogiri, "XML");
-  VALUE html      = rb_define_module_under(nokogiri, "HTML");
-  VALUE sax       = rb_define_module_under(xml, "SAX");
-  VALUE hsax      = rb_define_module_under(html, "SAX");
-  VALUE pc        = rb_define_class_under(sax, "ParserContext", rb_cObject);
-  VALUE klass     = rb_define_class_under(hsax, "ParserContext", pc);
-
-  cNokogiriHtmlSaxParserContext = klass;
+  assert(cNokogiriXmlSaxParserContext);
+  cNokogiriHtmlSaxParserContext = rb_define_class_under(mNokogiriHtmlSax, "ParserContext", cNokogiriXmlSaxParserContext);
 
-  rb_define_singleton_method(klass, "memory", parse_memory, 2);
-  rb_define_singleton_method(klass, "file", parse_file, 2);
+  rb_define_singleton_method(cNokogiriHtmlSaxParserContext, "memory", parse_memory, 2);
+  rb_define_singleton_method(cNokogiriHtmlSaxParserContext, "file", parse_file, 2);
 
-  rb_define_method(klass, "parse_with", parse_with, 1);
+  rb_define_method(cNokogiriHtmlSaxParserContext, "parse_with", parse_with, 1);
 }

data/ext/nokogiri/html_sax_push_parser.c

@@ -1,4 +1,6 @@
-#include <html_sax_push_parser.h>
+#include <nokogiri.h>
+
+VALUE cNokogiriHtmlSaxPushParser;
 
 /*
  * call-seq:
@@ -6,25 +8,32 @@
  *
  * Write +chunk+ to PushParser. +last_chunk+ triggers the end_document handle
  */
-static VALUE native_write(VALUE self, VALUE _chunk, VALUE _last_chunk)
+static VALUE
+native_write(VALUE self, VALUE _chunk, VALUE _last_chunk)
 {
   xmlParserCtxtPtr ctx;
-  const char * chunk  = NULL;
-  int size            = 0;
-
+  const char *chunk = NULL;
+  int size = 0;
+  int status = 0;
+  libxmlStructuredErrorHandlerState handler_state;
 
   Data_Get_Struct(self, xmlParserCtxt, ctx);
 
-  if(Qnil != _chunk) {
+  if (Qnil != _chunk) {
     chunk = StringValuePtr(_chunk);
     size = (int)RSTRING_LEN(_chunk);
   }
 
-  if(htmlParseChunk(ctx, chunk, size, Qtrue == _last_chunk ? 1 : 0)) {
-    if (!(ctx->options & XML_PARSE_RECOVER)) {
-      xmlErrorPtr e = xmlCtxtGetLastError(ctx);
-      Nokogiri_error_raise(NULL, e);
-    }
+  Nokogiri_structured_error_func_save_and_set(&handler_state, NULL, NULL);
+
+  status = htmlParseChunk(ctx, chunk, size, Qtrue == _last_chunk ? 1 : 0);
+
+  Nokogiri_structured_error_func_restore(&handler_state);
+
+  if ((status != 0) && !(ctx->options & XML_PARSE_RECOVER)) {
+    // TODO: there appear to be no tests for this block
+    xmlErrorPtr e = xmlCtxtGetLastError(ctx);
+    Nokogiri_error_raise(NULL, e);
   }
 
   return self;
@@ -36,34 +45,37 @@ static VALUE native_write(VALUE self, VALUE _chunk, VALUE _last_chunk)
  *
  * Initialize the push parser with +xml_sax+ using +filename+
  */
-static VALUE initialize_native(VALUE self, VALUE _xml_sax, VALUE _filename,
-			       VALUE encoding)
+static VALUE
+initialize_native(VALUE self, VALUE _xml_sax, VALUE _filename,
+                  VALUE encoding)
 {
   htmlSAXHandlerPtr sax;
-  const char * filename = NULL;
+  const char *filename = NULL;
   htmlParserCtxtPtr ctx;
   xmlCharEncoding enc = XML_CHAR_ENCODING_NONE;
 
   Data_Get_Struct(_xml_sax, xmlSAXHandler, sax);
 
-  if(_filename != Qnil) filename = StringValueCStr(_filename);
+  if (_filename != Qnil) { filename = StringValueCStr(_filename); }
 
   if (!NIL_P(encoding)) {
     enc = xmlParseCharEncoding(StringValueCStr(encoding));
-    if (enc == XML_CHAR_ENCODING_ERROR)
+    if (enc == XML_CHAR_ENCODING_ERROR) {
       rb_raise(rb_eArgError, "Unsupported Encoding");
+    }
   }
 
   ctx = htmlCreatePushParserCtxt(
-      sax,
-      NULL,
-      NULL,
-      0,
-      filename,
-      enc
-  );
-  if(ctx == NULL)
+          sax,
+          NULL,
+          NULL,
+          0,
+          filename,
+          enc
+        );
+  if (ctx == NULL) {
     rb_raise(rb_eRuntimeError, "Could not create a parser context");
+  }
 
   ctx->userData = NOKOGIRI_SAX_TUPLE_NEW(ctx, self);
 
@@ -72,16 +84,12 @@ static VALUE initialize_native(VALUE self, VALUE _xml_sax, VALUE _filename,
   return self;
 }
 
-VALUE cNokogiriHtmlSaxPushParser;
-void init_html_sax_push_parser()
+void
+noko_init_html_sax_push_parser()
 {
-  VALUE nokogiri = rb_define_module("Nokogiri");
-  VALUE html = rb_define_module_under(nokogiri, "HTML");
-  VALUE sax = rb_define_module_under(html, "SAX");
-  VALUE klass = rb_define_class_under(sax, "PushParser", cNokogiriXmlSaxPushParser);
-
-  cNokogiriHtmlSaxPushParser = klass;
+  assert(cNokogiriXmlSaxPushParser);
+  cNokogiriHtmlSaxPushParser = rb_define_class_under(mNokogiriHtmlSax, "PushParser", cNokogiriXmlSaxPushParser);
 
-  rb_define_private_method(klass, "initialize_native", initialize_native, 3);
-  rb_define_private_method(klass, "native_write", native_write, 2);
+  rb_define_private_method(cNokogiriHtmlSaxPushParser, "initialize_native", initialize_native, 3);
+  rb_define_private_method(cNokogiriHtmlSaxPushParser, "native_write", native_write, 2);
 }

data/ext/nokogiri/include/libexslt/exslt.h

@@ -0,0 +1,102 @@
+
+#ifndef __EXSLT_H__
+#define __EXSLT_H__
+
+#include <libxml/tree.h>
+#include <libxml/xpath.h>
+#include "exsltexports.h"
+#include <libexslt/exsltconfig.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+EXSLTPUBVAR const char *exsltLibraryVersion;
+EXSLTPUBVAR const int exsltLibexsltVersion;
+EXSLTPUBVAR const int exsltLibxsltVersion;
+EXSLTPUBVAR const int exsltLibxmlVersion;
+
+/**
+ * EXSLT_COMMON_NAMESPACE:
+ *
+ * Namespace for EXSLT common functions
+ */
+#define EXSLT_COMMON_NAMESPACE ((const xmlChar *) "http://exslt.org/common")
+/**
+ * EXSLT_CRYPTO_NAMESPACE:
+ *
+ * Namespace for EXSLT crypto functions
+ */
+#define EXSLT_CRYPTO_NAMESPACE ((const xmlChar *) "http://exslt.org/crypto")
+/**
+ * EXSLT_MATH_NAMESPACE:
+ *
+ * Namespace for EXSLT math functions
+ */
+#define EXSLT_MATH_NAMESPACE ((const xmlChar *) "http://exslt.org/math")
+/**
+ * EXSLT_SETS_NAMESPACE:
+ *
+ * Namespace for EXSLT set functions
+ */
+#define EXSLT_SETS_NAMESPACE ((const xmlChar *) "http://exslt.org/sets")
+/**
+ * EXSLT_FUNCTIONS_NAMESPACE:
+ *
+ * Namespace for EXSLT functions extension functions
+ */
+#define EXSLT_FUNCTIONS_NAMESPACE ((const xmlChar *) "http://exslt.org/functions")
+/**
+ * EXSLT_STRINGS_NAMESPACE:
+ *
+ * Namespace for EXSLT strings functions
+ */
+#define EXSLT_STRINGS_NAMESPACE ((const xmlChar *) "http://exslt.org/strings")
+/**
+ * EXSLT_DATE_NAMESPACE:
+ *
+ * Namespace for EXSLT date functions
+ */
+#define EXSLT_DATE_NAMESPACE ((const xmlChar *) "http://exslt.org/dates-and-times")
+/**
+ * EXSLT_DYNAMIC_NAMESPACE:
+ *
+ * Namespace for EXSLT dynamic functions
+ */
+#define EXSLT_DYNAMIC_NAMESPACE ((const xmlChar *) "http://exslt.org/dynamic")
+
+/**
+ * SAXON_NAMESPACE:
+ *
+ * Namespace for SAXON extensions functions
+ */
+#define SAXON_NAMESPACE ((const xmlChar *) "http://icl.com/saxon")
+
+EXSLTPUBFUN void EXSLTCALL exsltCommonRegister (void);
+#ifdef EXSLT_CRYPTO_ENABLED
+EXSLTPUBFUN void EXSLTCALL exsltCryptoRegister (void);
+#endif
+EXSLTPUBFUN void EXSLTCALL exsltMathRegister (void);
+EXSLTPUBFUN void EXSLTCALL exsltSetsRegister (void);
+EXSLTPUBFUN void EXSLTCALL exsltFuncRegister (void);
+EXSLTPUBFUN void EXSLTCALL exsltStrRegister (void);
+EXSLTPUBFUN void EXSLTCALL exsltDateRegister (void);
+EXSLTPUBFUN void EXSLTCALL exsltSaxonRegister (void);
+EXSLTPUBFUN void EXSLTCALL exsltDynRegister(void);
+
+EXSLTPUBFUN void EXSLTCALL exsltRegisterAll (void);
+
+EXSLTPUBFUN int EXSLTCALL exsltDateXpathCtxtRegister (xmlXPathContextPtr ctxt,
+                                                      const xmlChar *prefix);
+EXSLTPUBFUN int EXSLTCALL exsltMathXpathCtxtRegister (xmlXPathContextPtr ctxt,
+                                                      const xmlChar *prefix);
+EXSLTPUBFUN int EXSLTCALL exsltSetsXpathCtxtRegister (xmlXPathContextPtr ctxt,
+                                                      const xmlChar *prefix);
+EXSLTPUBFUN int EXSLTCALL exsltStrXpathCtxtRegister (xmlXPathContextPtr ctxt,
+                                                     const xmlChar *prefix);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* __EXSLT_H__ */
+