nokogiri 1.11.0.rc4-java → 1.11.5-java

data/ext/nokogiri/xml_syntax_error.c

@@ -1,38 +1,64 @@
-#include <xml_syntax_error.h>
+#include <nokogiri.h>
 
-void Nokogiri_error_array_pusher(void * ctx, xmlErrorPtr error)
+VALUE cNokogiriXmlSyntaxError;
+
+void
+Nokogiri_structured_error_func_save(libxmlStructuredErrorHandlerState *handler_state)
+{
+  /* this method is tightly coupled to the implementation of xmlSetStructuredErrorFunc */
+  handler_state->user_data = xmlStructuredErrorContext;
+  handler_state->handler = xmlStructuredError;
+}
+
+void
+Nokogiri_structured_error_func_save_and_set(libxmlStructuredErrorHandlerState *handler_state,
+    void *user_data,
+    xmlStructuredErrorFunc handler)
+{
+  Nokogiri_structured_error_func_save(handler_state);
+  xmlSetStructuredErrorFunc(user_data, handler);
+}
+
+void
+Nokogiri_structured_error_func_restore(libxmlStructuredErrorHandlerState *handler_state)
+{
+  xmlSetStructuredErrorFunc(handler_state->user_data, handler_state->handler);
+}
+
+void
+Nokogiri_error_array_pusher(void *ctx, xmlErrorPtr error)
 {
   VALUE list = (VALUE)ctx;
   Check_Type(list, T_ARRAY);
   rb_ary_push(list,  Nokogiri_wrap_xml_syntax_error(error));
 }
 
-void Nokogiri_error_raise(void * ctx, xmlErrorPtr error)
+void
+Nokogiri_error_raise(void *ctx, xmlErrorPtr error)
 {
   rb_exc_raise(Nokogiri_wrap_xml_syntax_error(error));
 }
 
-VALUE Nokogiri_wrap_xml_syntax_error(xmlErrorPtr error)
+VALUE
+Nokogiri_wrap_xml_syntax_error(xmlErrorPtr error)
 {
   VALUE msg, e, klass;
 
   klass = cNokogiriXmlSyntaxError;
 
   if (error && error->domain == XML_FROM_XPATH) {
-    VALUE xpath = rb_const_get(mNokogiriXml, rb_intern("XPath"));
-    klass = rb_const_get(xpath, rb_intern("SyntaxError"));
+    klass = cNokogiriXmlXpathSyntaxError;
   }
 
   msg = (error && error->message) ? NOKOGIRI_STR_NEW2(error->message) : Qnil;
 
   e = rb_class_new_instance(
-      1,
-      &msg,
-      klass
-  );
+        1,
+        &msg,
+        klass
+      );
 
-  if (error)
-  {
+  if (error) {
     rb_iv_set(e, "@domain", INT2NUM(error->domain));
     rb_iv_set(e, "@code", INT2NUM(error->code));
     rb_iv_set(e, "@level", INT2NUM((short)error->level));
@@ -48,17 +74,12 @@ VALUE Nokogiri_wrap_xml_syntax_error(xmlErrorPtr error)
   return e;
 }
 
-VALUE cNokogiriXmlSyntaxError;
-void init_xml_syntax_error()
+void
+noko_init_xml_syntax_error()
 {
-  VALUE nokogiri = rb_define_module("Nokogiri");
-  VALUE xml = rb_define_module_under(nokogiri, "XML");
-
+  assert(cNokogiriSyntaxError);
   /*
    * The XML::SyntaxError is raised on parse errors
    */
-  VALUE syntax_error_mommy = rb_define_class_under(nokogiri, "SyntaxError", rb_eStandardError);
-  VALUE klass = rb_define_class_under(xml, "SyntaxError", syntax_error_mommy);
-  cNokogiriXmlSyntaxError = klass;
-
+  cNokogiriXmlSyntaxError = rb_define_class_under(mNokogiriXml, "SyntaxError", cNokogiriSyntaxError);
 }

data/ext/nokogiri/xml_text.c

@@ -1,4 +1,6 @@
-#include <xml_text.h>
+#include <nokogiri.h>
+
+VALUE cNokogiriXmlText ;
 
 /*
  * call-seq:
@@ -6,7 +8,8 @@
  *
  * Create a new Text element on the +document+ with +content+
  */
-static VALUE new(int argc, VALUE *argv, VALUE klass)
+static VALUE
+new (int argc, VALUE *argv, VALUE klass)
 {
   xmlDocPtr doc;
   xmlNodePtr node;
@@ -22,31 +25,24 @@ static VALUE new(int argc, VALUE *argv, VALUE klass)
   node = xmlNewText((xmlChar *)StringValueCStr(string));
   node->doc = doc->doc;
 
-  nokogiri_root_node(node);
+  noko_xml_document_pin_node(node);
 
-  rb_node = Nokogiri_wrap_xml_node(klass, node) ;
+  rb_node = noko_xml_node_wrap(klass, node) ;
   rb_obj_call_init(rb_node, argc, argv);
 
-  if(rb_block_given_p()) rb_yield(rb_node);
+  if (rb_block_given_p()) { rb_yield(rb_node); }
 
   return rb_node;
 }
 
-VALUE cNokogiriXmlText ;
-void init_xml_text()
+void
+noko_init_xml_text()
 {
-  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 char_data = rb_define_class_under(xml, "CharacterData", node);
-
+  assert(cNokogiriXmlCharacterData);
   /*
    * Wraps Text nodes.
    */
-  VALUE klass = rb_define_class_under(xml, "Text", char_data);
-
-  cNokogiriXmlText = klass;
+  cNokogiriXmlText = rb_define_class_under(mNokogiriXml, "Text", cNokogiriXmlCharacterData);
 
-  rb_define_singleton_method(klass, "new", new, -1);
+  rb_define_singleton_method(cNokogiriXmlText, "new", new, -1);
 }

data/ext/nokogiri/xml_xpath_context.c

@@ -1,4 +1,6 @@
-#include <xml_xpath_context.h>
+#include <nokogiri.h>
+
+VALUE cNokogiriXmlXpathContext;
 
 /*
  * these constants have matching declarations in
@@ -7,7 +9,8 @@
 static const xmlChar *NOKOGIRI_BUILTIN_PREFIX = (const xmlChar *)"nokogiri-builtin";
 static const xmlChar *NOKOGIRI_BUILTIN_URI = (const xmlChar *)"https://www.nokogiri.org/default_ns/ruby/builtins";
 
-static void deallocate(xmlXPathContextPtr ctx)
+static void
+deallocate(xmlXPathContextPtr ctx)
 {
   NOKOGIRI_DEBUG_START(ctx);
   xmlXPathFreeContext(ctx);
@@ -15,23 +18,24 @@ static void deallocate(xmlXPathContextPtr ctx)
 }
 
 /* find a CSS class in an HTML element's `class` attribute */
-const xmlChar* builtin_css_class(const xmlChar* str, const xmlChar *val)
+static const xmlChar *
+builtin_css_class(const xmlChar *str, const xmlChar *val)
 {
   int val_len;
 
-  if (str == NULL) { return(NULL); }
-  if (val == NULL) { return(NULL); }
+  if (str == NULL) { return (NULL); }
+  if (val == NULL) { return (NULL); }
 
   val_len = xmlStrlen(val);
-  if (val_len == 0) { return(str); }
+  if (val_len == 0) { return (str); }
 
   while (*str != 0) {
     if ((*str == *val) && !xmlStrncmp(str, val, val_len)) {
-      const xmlChar* next_byte = str + val_len;
+      const xmlChar *next_byte = str + val_len;
 
       /* only match if the next byte is whitespace or end of string */
       if ((*next_byte == 0) || (IS_BLANK_CH(*next_byte))) {
-        return((const xmlChar*)str);
+        return ((const xmlChar *)str);
       }
     }
 
@@ -46,11 +50,12 @@ const xmlChar* builtin_css_class(const xmlChar* str, const xmlChar *val)
     }
   }
 
-  return(NULL);
+  return (NULL);
 }
 
 /* xmlXPathFunction to wrap builtin_css_class() */
-static void xpath_builtin_css_class(xmlXPathParserContextPtr ctxt, int nargs)
+static void
+xpath_builtin_css_class(xmlXPathParserContextPtr ctxt, int nargs)
 {
   xmlXPathObjectPtr hay, needle;
 
@@ -87,15 +92,16 @@ static void xpath_builtin_css_class(xmlXPathParserContextPtr ctxt, int nargs)
  *
  * Register the namespace with +prefix+ and +uri+.
  */
-static VALUE register_ns(VALUE self, VALUE prefix, VALUE uri)
+static VALUE
+register_ns(VALUE self, VALUE prefix, VALUE uri)
 {
   xmlXPathContextPtr ctx;
   Data_Get_Struct(self, xmlXPathContext, ctx);
 
-  xmlXPathRegisterNs( ctx,
-                      (const xmlChar *)StringValueCStr(prefix),
-                      (const xmlChar *)StringValueCStr(uri)
-  );
+  xmlXPathRegisterNs(ctx,
+                     (const xmlChar *)StringValueCStr(prefix),
+                     (const xmlChar *)StringValueCStr(uri)
+                    );
   return self;
 }
 
@@ -105,23 +111,26 @@ static VALUE register_ns(VALUE self, VALUE prefix, VALUE uri)
  *
  * Register the variable +name+ with +value+.
  */
-static VALUE register_variable(VALUE self, VALUE name, VALUE value)
+static VALUE
+register_variable(VALUE self, VALUE name, VALUE value)
 {
-   xmlXPathContextPtr ctx;
-   xmlXPathObjectPtr xmlValue;
-   Data_Get_Struct(self, xmlXPathContext, ctx);
+  xmlXPathContextPtr ctx;
+  xmlXPathObjectPtr xmlValue;
+  Data_Get_Struct(self, xmlXPathContext, ctx);
 
-   xmlValue = xmlXPathNewCString(StringValueCStr(value));
+  xmlValue = xmlXPathNewCString(StringValueCStr(value));
 
-   xmlXPathRegisterVariable( ctx,
-      (const xmlChar *)StringValueCStr(name),
-      xmlValue
-   );
+  xmlXPathRegisterVariable(ctx,
+                           (const xmlChar *)StringValueCStr(name),
+                           xmlValue
+                          );
 
-   return self;
+  return self;
 }
 
-void Nokogiri_marshal_xpath_funcall_and_return_values(xmlXPathParserContextPtr ctx, int nargs, VALUE handler, const char* function_name)
+void
+Nokogiri_marshal_xpath_funcall_and_return_values(xmlXPathParserContextPtr ctx, int nargs, VALUE handler,
+    const char *function_name)
 {
   int i;
   VALUE result, doc;
@@ -144,76 +153,76 @@ void Nokogiri_marshal_xpath_funcall_and_return_values(xmlXPathParserContextPtr c
     i = nargs - 1;
     do {
       obj = valuePop(ctx);
-      switch(obj->type) {
-        case XPATH_STRING:
-          argv[i] = NOKOGIRI_STR_NEW2(obj->stringval);
-          break;
-        case XPATH_BOOLEAN:
-          argv[i] = obj->boolval == 1 ? Qtrue : Qfalse;
-          break;
-        case XPATH_NUMBER:
-          argv[i] = rb_float_new(obj->floatval);
-          break;
-        case XPATH_NODESET:
-          argv[i] = Nokogiri_wrap_xml_node_set(obj->nodesetval, doc);
-          break;
-        default:
-          argv[i] = NOKOGIRI_STR_NEW2(xmlXPathCastToString(obj));
+      switch (obj->type) {
+      case XPATH_STRING:
+        argv[i] = NOKOGIRI_STR_NEW2(obj->stringval);
+        break;
+      case XPATH_BOOLEAN:
+        argv[i] = obj->boolval == 1 ? Qtrue : Qfalse;
+        break;
+      case XPATH_NUMBER:
+        argv[i] = rb_float_new(obj->floatval);
+        break;
+      case XPATH_NODESET:
+        argv[i] = noko_xml_node_set_wrap(obj->nodesetval, doc);
+        break;
+      default:
+        argv[i] = NOKOGIRI_STR_NEW2(xmlXPathCastToString(obj));
       }
       xmlXPathFreeNodeSetList(obj);
-    } while(i-- > 0);
+    } while (i-- > 0);
   }
 
-  result = rb_funcall2(handler, rb_intern((const char*)function_name), nargs, argv);
+  result = rb_funcall2(handler, rb_intern((const char *)function_name), nargs, argv);
 
   for (i = 0 ; i < nargs ; ++i) {
     rb_gc_unregister_address(&argv[i]);
   }
   free(argv);
 
-  switch(TYPE(result)) {
-    case T_FLOAT:
-    case T_BIGNUM:
-    case T_FIXNUM:
-      xmlXPathReturnNumber(ctx, NUM2DBL(result));
-      break;
-    case T_STRING:
-      xmlXPathReturnString(
-          ctx,
-          xmlCharStrdup(StringValueCStr(result))
-      );
-      break;
-    case T_TRUE:
-      xmlXPathReturnTrue(ctx);
-      break;
-    case T_FALSE:
-      xmlXPathReturnFalse(ctx);
-      break;
-    case T_NIL:
-      break;
-    case T_ARRAY:
-      {
-        VALUE args[2];
-        args[0] = doc;
-        args[1] = result;
-        node_set = rb_class_new_instance(2, args, cNokogiriXmlNodeSet);
-        Data_Get_Struct(node_set, xmlNodeSet, xml_node_set);
-        xmlXPathReturnNodeSet(ctx, xmlXPathNodeSetMerge(NULL, xml_node_set));
-      }
+  switch (TYPE(result)) {
+  case T_FLOAT:
+  case T_BIGNUM:
+  case T_FIXNUM:
+    xmlXPathReturnNumber(ctx, NUM2DBL(result));
     break;
-    case T_DATA:
-      if(rb_obj_is_kind_of(result, cNokogiriXmlNodeSet)) {
-        Data_Get_Struct(result, xmlNodeSet, xml_node_set);
-        /* Copy the node set, otherwise it will get GC'd. */
-        xmlXPathReturnNodeSet(ctx, xmlXPathNodeSetMerge(NULL, xml_node_set));
-        break;
-      }
-    default:
-      rb_raise(rb_eRuntimeError, "Invalid return type");
+  case T_STRING:
+    xmlXPathReturnString(
+      ctx,
+      xmlCharStrdup(StringValueCStr(result))
+    );
+    break;
+  case T_TRUE:
+    xmlXPathReturnTrue(ctx);
+    break;
+  case T_FALSE:
+    xmlXPathReturnFalse(ctx);
+    break;
+  case T_NIL:
+    break;
+  case T_ARRAY: {
+    VALUE args[2];
+    args[0] = doc;
+    args[1] = result;
+    node_set = rb_class_new_instance(2, args, cNokogiriXmlNodeSet);
+    Data_Get_Struct(node_set, xmlNodeSet, xml_node_set);
+    xmlXPathReturnNodeSet(ctx, xmlXPathNodeSetMerge(NULL, xml_node_set));
+  }
+  break;
+  case T_DATA:
+    if (rb_obj_is_kind_of(result, cNokogiriXmlNodeSet)) {
+      Data_Get_Struct(result, xmlNodeSet, xml_node_set);
+      /* Copy the node set, otherwise it will get GC'd. */
+      xmlXPathReturnNodeSet(ctx, xmlXPathNodeSetMerge(NULL, xml_node_set));
+      break;
     }
+  default:
+    rb_raise(rb_eRuntimeError, "Invalid return type");
+  }
 }
 
-static void ruby_funcall(xmlXPathParserContextPtr ctx, int nargs)
+static void
+ruby_funcall(xmlXPathParserContextPtr ctx, int nargs)
 {
   VALUE handler = Qnil;
   const char *function = NULL ;
@@ -224,26 +233,29 @@ static void ruby_funcall(xmlXPathParserContextPtr ctx, int nargs)
   assert(ctx->context->function);
 
   handler = (VALUE)(ctx->context->userData);
-  function = (const char*)(ctx->context->function);
+  function = (const char *)(ctx->context->function);
 
   Nokogiri_marshal_xpath_funcall_and_return_values(ctx, nargs, handler, function);
 }
 
-static xmlXPathFunction lookup( void *ctx,
-                                const xmlChar * name,
-                                const xmlChar* ns_uri )
+static xmlXPathFunction
+lookup(void *ctx,
+       const xmlChar *name,
+       const xmlChar *ns_uri)
 {
   VALUE xpath_handler = (VALUE)ctx;
-  if(rb_respond_to(xpath_handler, rb_intern((const char *)name)))
+  if (rb_respond_to(xpath_handler, rb_intern((const char *)name))) {
     return ruby_funcall;
+  }
 
   return NULL;
 }
 
-NORETURN(static void xpath_generic_exception_handler(void * ctx, const char *msg, ...));
-static void xpath_generic_exception_handler(void * ctx, const char *msg, ...)
+NORETURN(static void xpath_generic_exception_handler(void *ctx, const char *msg, ...));
+static void
+xpath_generic_exception_handler(void *ctx, const char *msg, ...)
 {
-  char * message;
+  char *message;
 
   va_list args;
   va_start(args, msg);
@@ -259,7 +271,8 @@ static void xpath_generic_exception_handler(void * ctx, const char *msg, ...)
  *
  * Evaluate the +search_path+ returning an XML::XPath object.
  */
-static VALUE evaluate(int argc, VALUE *argv, VALUE self)
+static VALUE
+evaluate(int argc, VALUE *argv, VALUE self)
 {
   VALUE search_path, xpath_handler;
   VALUE thing = Qnil;
@@ -269,12 +282,13 @@ static VALUE evaluate(int argc, VALUE *argv, VALUE self)
 
   Data_Get_Struct(self, xmlXPathContext, ctx);
 
-  if(rb_scan_args(argc, argv, "11", &search_path, &xpath_handler) == 1)
+  if (rb_scan_args(argc, argv, "11", &search_path, &xpath_handler) == 1) {
     xpath_handler = Qnil;
+  }
 
   query = (xmlChar *)StringValueCStr(search_path);
 
-  if(Qnil != xpath_handler) {
+  if (Qnil != xpath_handler) {
     /* FIXME: not sure if this is the correct place to shove private data. */
     ctx->userData = (void *)xpath_handler;
     xmlXPathRegisterFuncLookup(ctx, lookup, (void *)xpath_handler);
@@ -291,7 +305,7 @@ static VALUE evaluate(int argc, VALUE *argv, VALUE self)
   xmlSetStructuredErrorFunc(NULL, NULL);
   xmlSetGenericErrorFunc(NULL, NULL);
 
-  if(xpath == NULL) {
+  if (xpath == NULL) {
     xmlErrorPtr error = xmlGetLastError();
     rb_exc_raise(Nokogiri_wrap_xml_syntax_error(error));
   }
@@ -299,23 +313,23 @@ static VALUE evaluate(int argc, VALUE *argv, VALUE self)
   assert(ctx->doc);
   assert(DOC_RUBY_OBJECT_TEST(ctx->doc));
 
-  switch(xpath->type) {
-    case XPATH_STRING:
-      thing = NOKOGIRI_STR_NEW2(xpath->stringval);
-      xmlFree(xpath->stringval);
-      break;
-    case XPATH_NODESET:
-      thing = Nokogiri_wrap_xml_node_set(xpath->nodesetval,
-                                         DOC_RUBY_OBJECT(ctx->doc));
-      break;
-    case XPATH_NUMBER:
-      thing = rb_float_new(xpath->floatval);
-      break;
-    case XPATH_BOOLEAN:
-      thing = xpath->boolval == 1 ? Qtrue : Qfalse;
-      break;
-    default:
-      thing = Nokogiri_wrap_xml_node_set(NULL, DOC_RUBY_OBJECT(ctx->doc));
+  switch (xpath->type) {
+  case XPATH_STRING:
+    thing = NOKOGIRI_STR_NEW2(xpath->stringval);
+    xmlFree(xpath->stringval);
+    break;
+  case XPATH_NODESET:
+    thing = noko_xml_node_set_wrap(xpath->nodesetval,
+                                   DOC_RUBY_OBJECT(ctx->doc));
+    break;
+  case XPATH_NUMBER:
+    thing = rb_float_new(xpath->floatval);
+    break;
+  case XPATH_BOOLEAN:
+    thing = xpath->boolval == 1 ? Qtrue : Qfalse;
+    break;
+  default:
+    thing = noko_xml_node_set_wrap(NULL, DOC_RUBY_OBJECT(ctx->doc));
   }
 
   xmlXPathFreeNodeSetList(xpath);
@@ -329,7 +343,8 @@ static VALUE evaluate(int argc, VALUE *argv, VALUE self)
  *
  * Create a new XPathContext with +node+ as the reference point.
  */
-static VALUE new(VALUE klass, VALUE nodeobj)
+static VALUE
+new (VALUE klass, VALUE nodeobj)
 {
   xmlNodePtr node;
   xmlXPathContextPtr ctx;
@@ -350,25 +365,17 @@ static VALUE new(VALUE klass, VALUE nodeobj)
   return self;
 }
 
-VALUE cNokogiriXmlXpathContext;
-void init_xml_xpath_context(void)
+void
+noko_init_xml_xpath_context(void)
 {
-  VALUE module = rb_define_module("Nokogiri");
-
-  /*
-   * Nokogiri::XML
-   */
-  VALUE xml = rb_define_module_under(module, "XML");
-
   /*
    * XPathContext is the entry point for searching a Document by using XPath.
    */
-  VALUE klass = rb_define_class_under(xml, "XPathContext", rb_cObject);
+  cNokogiriXmlXpathContext = rb_define_class_under(mNokogiriXml, "XPathContext", rb_cObject);
 
-  cNokogiriXmlXpathContext = klass;
+  rb_define_singleton_method(cNokogiriXmlXpathContext, "new", new, 1);
 
-  rb_define_singleton_method(klass, "new", new, 1);
-  rb_define_method(klass, "evaluate", evaluate, -1);
-  rb_define_method(klass, "register_variable", register_variable, 2);
-  rb_define_method(klass, "register_ns", register_ns, 2);
+  rb_define_method(cNokogiriXmlXpathContext, "evaluate", evaluate, -1);
+  rb_define_method(cNokogiriXmlXpathContext, "register_variable", register_variable, 2);
+  rb_define_method(cNokogiriXmlXpathContext, "register_ns", register_ns, 2);
 }