nokogiri 1.11.0.rc4-arm64-darwin

data/ext/nokogiri/xml_sax_push_parser.h

@@ -0,0 +1,9 @@
+#ifndef NOKOGIRI_XML_SAX_PUSH_PARSER
+#define NOKOGIRI_XML_SAX_PUSH_PARSER
+
+#include <nokogiri.h>
+
+void init_xml_sax_push_parser();
+
+extern VALUE cNokogiriXmlSaxPushParser ;
+#endif

data/ext/nokogiri/xml_schema.c

@@ -0,0 +1,276 @@
+#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;
+  xmlSchemaValidCtxtPtr valid_ctxt;
+  VALUE errors;
+
+  Data_Get_Struct(self, xmlSchema, schema);
+  Data_Get_Struct(document, xmlDoc, doc);
+
+  errors = rb_ary_new();
+
+  valid_ctxt = xmlSchemaNewValidCtxt(schema);
+
+  if(NULL == valid_ctxt) {
+    /* we have a problem */
+    rb_raise(rb_eRuntimeError, "Could not create a validation context");
+  }
+
+#ifdef HAVE_XMLSCHEMASETVALIDSTRUCTUREDERRORS
+  xmlSchemaSetValidStructuredErrors(
+    valid_ctxt,
+    Nokogiri_error_array_pusher,
+    (void *)errors
+  );
+#endif
+
+  xmlSchemaValidateDoc(valid_ctxt, doc);
+
+  xmlSchemaFreeValidCtxt(valid_ctxt);
+
+  return errors;
+}
+
+/*
+ * call-seq:
+ *  validate_file(filename)
+ *
+ * Validate a file against this Schema.
+ */
+static VALUE validate_file(VALUE self, VALUE rb_filename)
+{
+  xmlSchemaPtr schema;
+  xmlSchemaValidCtxtPtr valid_ctxt;
+  const char *filename ;
+  VALUE errors;
+
+  Data_Get_Struct(self, xmlSchema, schema);
+  filename = (const char*)StringValueCStr(rb_filename) ;
+
+  errors = rb_ary_new();
+
+  valid_ctxt = xmlSchemaNewValidCtxt(schema);
+
+  if(NULL == valid_ctxt) {
+    /* we have a problem */
+    rb_raise(rb_eRuntimeError, "Could not create a validation context");
+  }
+
+#ifdef HAVE_XMLSCHEMASETVALIDSTRUCTUREDERRORS
+  xmlSchemaSetValidStructuredErrors(
+    valid_ctxt,
+    Nokogiri_error_array_pusher,
+    (void *)errors
+  );
+#endif
+
+  xmlSchemaValidateFile(valid_ctxt, filename, 0);
+
+  xmlSchemaFreeValidCtxt(valid_ctxt);
+
+  return errors;
+}
+
+/*
+ * call-seq:
+ *  read_memory(string)
+ *
+ * Create a new Schema from the contents of +string+
+ */
+static VALUE read_memory(int argc, VALUE *argv, VALUE klass)
+{
+  VALUE content;
+  VALUE parse_options;
+  int parse_options_int;
+  xmlSchemaParserCtxtPtr ctx;
+  xmlSchemaPtr schema;
+  VALUE errors;
+  VALUE rb_schema;
+  int scanned_args = 0;
+  xmlExternalEntityLoader old_loader = 0;
+
+  scanned_args = rb_scan_args(argc, argv, "11", &content, &parse_options);
+  if (scanned_args == 1) {
+    parse_options = rb_const_get(rb_const_get(mNokogiriXml, rb_intern("ParseOptions")), rb_intern("DEFAULT_SCHEMA"));
+  }
+  parse_options_int = (int)NUM2INT(rb_funcall(parse_options, rb_intern("to_i"), 0));
+
+  ctx = xmlSchemaNewMemParserCtxt((const char *)StringValuePtr(content), (int)RSTRING_LEN(content));
+
+  errors = rb_ary_new();
+  xmlSetStructuredErrorFunc((void *)errors, Nokogiri_error_array_pusher);
+
+#ifdef HAVE_XMLSCHEMASETPARSERSTRUCTUREDERRORS
+  xmlSchemaSetParserStructuredErrors(
+    ctx,
+    Nokogiri_error_array_pusher,
+    (void *)errors
+    );
+#endif
+
+  if (parse_options_int & XML_PARSE_NONET) {
+    old_loader = xmlGetExternalEntityLoader();
+    xmlSetExternalEntityLoader(xmlNoNetExternalEntityLoader);
+  }
+
+  schema = xmlSchemaParse(ctx);
+
+  if (old_loader) {
+    xmlSetExternalEntityLoader(old_loader);
+  }
+
+  xmlSetStructuredErrorFunc(NULL, NULL);
+  xmlSchemaFreeParserCtxt(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);
+  rb_iv_set(rb_schema, "@parse_options", parse_options);
+
+  return rb_schema;
+}
+
+/* Schema creation will remove and deallocate "blank" nodes.
+ * If those blank nodes have been exposed to Ruby, they could get freed
+ * out from under the VALUE pointer.  This function checks to see if any of
+ * those nodes have been exposed to Ruby, and if so we should raise an exception.
+ */
+static int has_blank_nodes_p(VALUE cache)
+{
+    long i;
+
+    if (NIL_P(cache)) {
+        return 0;
+    }
+
+    for (i = 0; i < RARRAY_LEN(cache); i++) {
+        xmlNodePtr node;
+        VALUE element = rb_ary_entry(cache, i);
+        Data_Get_Struct(element, xmlNode, node);
+        if (xmlIsBlankNode(node)) {
+            return 1;
+        }
+    }
+
+    return 0;
+}
+
+/*
+ * call-seq:
+ *  from_document(doc)
+ *
+ * Create a new Schema from the Nokogiri::XML::Document +doc+
+ */
+static VALUE from_document(int argc, VALUE *argv, VALUE klass)
+{
+  VALUE document;
+  VALUE parse_options;
+  int parse_options_int;
+  xmlDocPtr doc;
+  xmlSchemaParserCtxtPtr ctx;
+  xmlSchemaPtr schema;
+  VALUE errors;
+  VALUE rb_schema;
+  int scanned_args = 0;
+  xmlExternalEntityLoader old_loader = 0;
+
+  scanned_args = rb_scan_args(argc, argv, "11", &document, &parse_options);
+
+  Data_Get_Struct(document, xmlDoc, doc);
+  doc = doc->doc; /* In case someone passes us a node. ugh. */
+
+  if (scanned_args == 1) {
+    parse_options = rb_const_get(rb_const_get(mNokogiriXml, rb_intern("ParseOptions")), rb_intern("DEFAULT_SCHEMA"));
+  }
+  parse_options_int = (int)NUM2INT(rb_funcall(parse_options, rb_intern("to_i"), 0));
+
+  if (has_blank_nodes_p(DOC_NODE_CACHE(doc))) {
+    rb_raise(rb_eArgError, "Creating a schema from a document that has blank nodes exposed to Ruby is dangerous");
+  }
+
+  ctx = xmlSchemaNewDocParserCtxt(doc);
+
+  errors = rb_ary_new();
+  xmlSetStructuredErrorFunc((void *)errors, Nokogiri_error_array_pusher);
+
+#ifdef HAVE_XMLSCHEMASETPARSERSTRUCTUREDERRORS
+  xmlSchemaSetParserStructuredErrors(
+    ctx,
+    Nokogiri_error_array_pusher,
+    (void *)errors
+  );
+#endif
+
+  if (parse_options_int & XML_PARSE_NONET) {
+    old_loader = xmlGetExternalEntityLoader();
+    xmlSetExternalEntityLoader(xmlNoNetExternalEntityLoader);
+  }
+
+  schema = xmlSchemaParse(ctx);
+
+  if (old_loader) {
+    xmlSetExternalEntityLoader(old_loader);
+  }
+
+  xmlSetStructuredErrorFunc(NULL, NULL);
+  xmlSchemaFreeParserCtxt(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);
+  rb_iv_set(rb_schema, "@parse_options", parse_options);
+
+  return rb_schema;
+
+  return Qnil;
+}
+
+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_singleton_method(klass, "from_document", from_document, -1);
+
+  rb_define_private_method(klass, "validate_document", validate_document, 1);
+  rb_define_private_method(klass, "validate_file",     validate_file, 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.c

@@ -0,0 +1,64 @@
+#include <xml_syntax_error.h>
+
+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)
+{
+  rb_exc_raise(Nokogiri_wrap_xml_syntax_error(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"));
+  }
+
+  msg = (error && error->message) ? NOKOGIRI_STR_NEW2(error->message) : Qnil;
+
+  e = rb_class_new_instance(
+      1,
+      &msg,
+      klass
+  );
+
+  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));
+    rb_iv_set(e, "@file", RBSTR_OR_QNIL(error->file));
+    rb_iv_set(e, "@line", INT2NUM(error->line));
+    rb_iv_set(e, "@str1", RBSTR_OR_QNIL(error->str1));
+    rb_iv_set(e, "@str2", RBSTR_OR_QNIL(error->str2));
+    rb_iv_set(e, "@str3", RBSTR_OR_QNIL(error->str3));
+    rb_iv_set(e, "@int1", INT2NUM(error->int1));
+    rb_iv_set(e, "@column", INT2NUM(error->int2));
+  }
+
+  return e;
+}
+
+VALUE cNokogiriXmlSyntaxError;
+void init_xml_syntax_error()
+{
+  VALUE nokogiri = rb_define_module("Nokogiri");
+  VALUE xml = rb_define_module_under(nokogiri, "XML");
+
+  /*
+   * 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;
+
+}

data/ext/nokogiri/xml_syntax_error.h

@@ -0,0 +1,13 @@
+#ifndef NOKOGIRI_XML_SYNTAX_ERROR
+#define NOKOGIRI_XML_SYNTAX_ERROR
+
+#include <nokogiri.h>
+
+void init_xml_syntax_error();
+VALUE Nokogiri_wrap_xml_syntax_error(xmlErrorPtr error);
+void Nokogiri_error_array_pusher(void * ctx, xmlErrorPtr error);
+NORETURN(void Nokogiri_error_raise(void * ctx, xmlErrorPtr error));
+
+extern VALUE cNokogiriXmlSyntaxError;
+#endif
+

data/ext/nokogiri/xml_text.c

@@ -0,0 +1,52 @@
+#include <xml_text.h>
+
+/*
+ * call-seq:
+ *  new(content, document)
+ *
+ * Create a new Text element on the +document+ with +content+
+ */
+static VALUE new(int argc, VALUE *argv, VALUE klass)
+{
+  xmlDocPtr doc;
+  xmlNodePtr node;
+  VALUE string;
+  VALUE document;
+  VALUE rest;
+  VALUE rb_node;
+
+  rb_scan_args(argc, argv, "2*", &string, &document, &rest);
+
+  Data_Get_Struct(document, xmlDoc, doc);
+
+  node = xmlNewText((xmlChar *)StringValueCStr(string));
+  node->doc = doc->doc;
+
+  nokogiri_root_node(node);
+
+  rb_node = Nokogiri_wrap_xml_node(klass, node) ;
+  rb_obj_call_init(rb_node, argc, argv);
+
+  if(rb_block_given_p()) rb_yield(rb_node);
+
+  return rb_node;
+}
+
+VALUE cNokogiriXmlText ;
+void 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);
+
+  /*
+   * Wraps Text nodes.
+   */
+  VALUE klass = rb_define_class_under(xml, "Text", char_data);
+
+  cNokogiriXmlText = klass;
+
+  rb_define_singleton_method(klass, "new", new, -1);
+}

data/ext/nokogiri/xml_text.h

@@ -0,0 +1,9 @@
+#ifndef NOKOGIRI_XML_TEXT
+#define NOKOGIRI_XML_TEXT
+
+#include <nokogiri.h>
+
+void init_xml_text();
+
+extern VALUE cNokogiriXmlText ;
+#endif

data/ext/nokogiri/xml_xpath_context.c

@@ -0,0 +1,374 @@
+#include <xml_xpath_context.h>
+
+/*
+ * these constants have matching declarations in
+ * ext/java/nokogiri/internals/NokogiriNamespaceContext.java
+ */
+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)
+{
+  NOKOGIRI_DEBUG_START(ctx);
+  xmlXPathFreeContext(ctx);
+  NOKOGIRI_DEBUG_END(ctx);
+}
+
+/* find a CSS class in an HTML element's `class` attribute */
+const xmlChar* builtin_css_class(const xmlChar* str, const xmlChar *val)
+{
+  int val_len;
+
+  if (str == NULL) { return(NULL); }
+  if (val == NULL) { return(NULL); }
+
+  val_len = xmlStrlen(val);
+  if (val_len == 0) { return(str); }
+
+  while (*str != 0) {
+    if ((*str == *val) && !xmlStrncmp(str, val, 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);
+      }
+    }
+
+    /* advance str to whitespace */
+    while ((*str != 0) && !IS_BLANK_CH(*str)) {
+      str++;
+    }
+
+    /* advance str to start of next word or end of string */
+    while ((*str != 0) && IS_BLANK_CH(*str)) {
+      str++;
+    }
+  }
+
+  return(NULL);
+}
+
+/* xmlXPathFunction to wrap builtin_css_class() */
+static void xpath_builtin_css_class(xmlXPathParserContextPtr ctxt, int nargs)
+{
+  xmlXPathObjectPtr hay, needle;
+
+  CHECK_ARITY(2);
+
+  CAST_TO_STRING;
+  needle = valuePop(ctxt);
+  if ((needle == NULL) || (needle->type != XPATH_STRING)) {
+    xmlXPathFreeObject(needle);
+    XP_ERROR(XPATH_INVALID_TYPE);
+  }
+
+  CAST_TO_STRING;
+  hay = valuePop(ctxt);
+  if ((hay == NULL) || (hay->type != XPATH_STRING)) {
+    xmlXPathFreeObject(hay);
+    xmlXPathFreeObject(needle);
+    XP_ERROR(XPATH_INVALID_TYPE);
+  }
+
+  if (builtin_css_class(hay->stringval, needle->stringval)) {
+    valuePush(ctxt, xmlXPathNewBoolean(1));
+  } else {
+    valuePush(ctxt, xmlXPathNewBoolean(0));
+  }
+
+  xmlXPathFreeObject(hay);
+  xmlXPathFreeObject(needle);
+}
+
+/*
+ * call-seq:
+ *  register_ns(prefix, uri)
+ *
+ * Register the namespace with +prefix+ and +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)
+  );
+  return self;
+}
+
+/*
+ * call-seq:
+ *  register_variable(name, value)
+ *
+ * Register the variable +name+ with +value+.
+ */
+static VALUE register_variable(VALUE self, VALUE name, VALUE value)
+{
+   xmlXPathContextPtr ctx;
+   xmlXPathObjectPtr xmlValue;
+   Data_Get_Struct(self, xmlXPathContext, ctx);
+
+   xmlValue = xmlXPathNewCString(StringValueCStr(value));
+
+   xmlXPathRegisterVariable( ctx,
+      (const xmlChar *)StringValueCStr(name),
+      xmlValue
+   );
+
+   return self;
+}
+
+void Nokogiri_marshal_xpath_funcall_and_return_values(xmlXPathParserContextPtr ctx, int nargs, VALUE handler, const char* function_name)
+{
+  int i;
+  VALUE result, doc;
+  VALUE *argv;
+  VALUE node_set = Qnil;
+  xmlNodeSetPtr xml_node_set = NULL;
+  xmlXPathObjectPtr obj;
+
+  assert(ctx->context->doc);
+  assert(DOC_RUBY_OBJECT_TEST(ctx->context->doc));
+
+  argv = (VALUE *)calloc((size_t)nargs, sizeof(VALUE));
+  for (i = 0 ; i < nargs ; ++i) {
+    rb_gc_register_address(&argv[i]);
+  }
+
+  doc = DOC_RUBY_OBJECT(ctx->context->doc);
+
+  if (nargs > 0) {
+    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));
+      }
+      xmlXPathFreeNodeSetList(obj);
+    } while(i-- > 0);
+  }
+
+  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));
+      }
+    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)
+{
+  VALUE handler = Qnil;
+  const char *function = NULL ;
+
+  assert(ctx);
+  assert(ctx->context);
+  assert(ctx->context->userData);
+  assert(ctx->context->function);
+
+  handler = (VALUE)(ctx->context->userData);
+  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 )
+{
+  VALUE xpath_handler = (VALUE)ctx;
+  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, ...)
+{
+  char * message;
+
+  va_list args;
+  va_start(args, msg);
+  vasprintf(&message, msg, args);
+  va_end(args);
+
+  rb_raise(rb_eRuntimeError, "%s", message);
+}
+
+/*
+ * call-seq:
+ *  evaluate(search_path, handler = nil)
+ *
+ * Evaluate the +search_path+ returning an XML::XPath object.
+ */
+static VALUE evaluate(int argc, VALUE *argv, VALUE self)
+{
+  VALUE search_path, xpath_handler;
+  VALUE thing = Qnil;
+  xmlXPathContextPtr ctx;
+  xmlXPathObjectPtr xpath;
+  xmlChar *query;
+
+  Data_Get_Struct(self, xmlXPathContext, ctx);
+
+  if(rb_scan_args(argc, argv, "11", &search_path, &xpath_handler) == 1)
+    xpath_handler = Qnil;
+
+  query = (xmlChar *)StringValueCStr(search_path);
+
+  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);
+  }
+
+  xmlResetLastError();
+  xmlSetStructuredErrorFunc(NULL, Nokogiri_error_raise);
+
+  /* For some reason, xmlXPathEvalExpression will blow up with a generic error */
+  /* when there is a non existent function. */
+  xmlSetGenericErrorFunc(NULL, xpath_generic_exception_handler);
+
+  xpath = xmlXPathEvalExpression(query, ctx);
+  xmlSetStructuredErrorFunc(NULL, NULL);
+  xmlSetGenericErrorFunc(NULL, NULL);
+
+  if(xpath == NULL) {
+    xmlErrorPtr error = xmlGetLastError();
+    rb_exc_raise(Nokogiri_wrap_xml_syntax_error(error));
+  }
+
+  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));
+  }
+
+  xmlXPathFreeNodeSetList(xpath);
+
+  return thing;
+}
+
+/*
+ * call-seq:
+ *  new(node)
+ *
+ * Create a new XPathContext with +node+ as the reference point.
+ */
+static VALUE new(VALUE klass, VALUE nodeobj)
+{
+  xmlNodePtr node;
+  xmlXPathContextPtr ctx;
+  VALUE self;
+
+  Data_Get_Struct(nodeobj, xmlNode, node);
+
+  xmlXPathInit();
+
+  ctx = xmlXPathNewContext(node->doc);
+  ctx->node = node;
+
+  xmlXPathRegisterNs(ctx, NOKOGIRI_BUILTIN_PREFIX, NOKOGIRI_BUILTIN_URI);
+  xmlXPathRegisterFuncNS(ctx, (const xmlChar *)"css-class", NOKOGIRI_BUILTIN_URI,
+                         xpath_builtin_css_class);
+
+  self = Data_Wrap_Struct(klass, 0, deallocate, ctx);
+  return self;
+}
+
+VALUE cNokogiriXmlXpathContext;
+void 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 = klass;
+
+  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);
+}