superfeedr-nokogiri 1.4.0.20091116183308

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,261 @@
+#include <xml_syntax_error.h>
+
+static void dealloc(xmlErrorPtr ptr)
+{
+  NOKOGIRI_DEBUG_START(ptr);
+  xmlResetError(ptr);
+  xmlFree(ptr);
+  NOKOGIRI_DEBUG_END(ptr);
+}
+
+static VALUE allocate(VALUE klass)
+{
+  xmlErrorPtr error = xmlMalloc(sizeof(xmlError));
+  memset(error, 0, sizeof(xmlError));
+  return Data_Wrap_Struct(klass, NULL, dealloc, error);
+}
+
+/*
+ * call-seq:
+ *  column
+ *
+ * Column number or 0 if not available
+ */
+static VALUE column(VALUE self)
+{
+  xmlErrorPtr error;
+  Data_Get_Struct(self, xmlError, error);
+  return INT2NUM(error->int2);
+}
+
+/*
+ * call-seq:
+ *  int1
+ *
+ * Extra number information
+ */
+static VALUE int1(VALUE self)
+{
+  xmlErrorPtr error;
+  Data_Get_Struct(self, xmlError, error);
+  return INT2NUM(error->int1);
+}
+
+/*
+ * call-seq:
+ *  str3
+ *
+ * Extra string information
+ */
+static VALUE str3(VALUE self)
+{
+  xmlErrorPtr error;
+  Data_Get_Struct(self, xmlError, error);
+  if(error->str3) return NOKOGIRI_STR_NEW2(error->str3);
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *  str2
+ *
+ * Extra string information
+ */
+static VALUE str2(VALUE self)
+{
+  xmlErrorPtr error;
+  Data_Get_Struct(self, xmlError, error);
+  if(error->str2) return NOKOGIRI_STR_NEW2(error->str2);
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *  str1
+ *
+ * Extra string information
+ */
+static VALUE str1(VALUE self)
+{
+  xmlErrorPtr error;
+  Data_Get_Struct(self, xmlError, error);
+  if(error->str1) return NOKOGIRI_STR_NEW2(error->str1);
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *  line
+ *
+ * Get the line number of the error
+ */
+static VALUE line(VALUE self)
+{
+  xmlErrorPtr error;
+  Data_Get_Struct(self, xmlError, error);
+  return INT2NUM(error->line);
+}
+
+/*
+ * call-seq:
+ *  file
+ *
+ * Get the filename for the error
+ */
+static VALUE file(VALUE self)
+{
+  xmlErrorPtr error;
+  Data_Get_Struct(self, xmlError, error);
+  if(error->file) return NOKOGIRI_STR_NEW2(error->file);
+
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *  level
+ *
+ * Get the error level
+ */
+static VALUE level(VALUE self)
+{
+  xmlErrorPtr error;
+  Data_Get_Struct(self, xmlError, error);
+  return INT2NUM((short)error->level);
+}
+
+/*
+ * call-seq:
+ *  code
+ *
+ * Get the error code
+ */
+static VALUE code(VALUE self)
+{
+  xmlErrorPtr error;
+  Data_Get_Struct(self, xmlError, error);
+  return INT2NUM(error->code);
+}
+
+/*
+ * call-seq:
+ *  domain
+ *
+ * Get the part of the library that raised this exception
+ */
+static VALUE domain(VALUE self)
+{
+  xmlErrorPtr error;
+  Data_Get_Struct(self, xmlError, error);
+  return INT2NUM(error->domain);
+}
+
+/*
+ * call-seq:
+ *  message
+ *
+ * Get the human readable message.
+ */
+static VALUE message(VALUE self)
+{
+  xmlErrorPtr error;
+  Data_Get_Struct(self, xmlError, error);
+  if(error->message) return NOKOGIRI_STR_NEW2(error->message);
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *  message=
+ *
+ * Set the human readable message.
+ */
+static VALUE set_message(VALUE self, VALUE _message)
+{
+  xmlErrorPtr error;
+  Data_Get_Struct(self, xmlError, error);
+
+  if(error->message) {
+    xmlFree(error->message);
+    error->message = 0;
+  }
+
+  if(RTEST(_message)) {
+    error->message = xmlMalloc(RSTRING_LEN(_message) + 1);
+    memset(error->message, 0, RSTRING_LEN(_message) + 1);
+    memcpy(error->message, StringValuePtr(_message), RSTRING_LEN(_message));
+  }
+
+  return message;
+}
+
+/*
+ * call-seq:
+ *  initialize_copy(old_copy)
+ *
+ * Initialize a copy of the +old_copy+
+ */
+static VALUE initialize_copy(VALUE self, VALUE _old_copy)
+{
+  if(!rb_obj_is_kind_of(_old_copy, cNokogiriXmlSyntaxError))
+    rb_raise(rb_eArgError, "node must be a Nokogiri::XML::SyntaxError");
+
+  xmlErrorPtr error, old_error;
+  Data_Get_Struct(self, xmlError, error);
+  Data_Get_Struct(_old_copy, xmlError, old_error);
+
+  xmlCopyError(old_error, error);
+
+  return message;
+}
+
+void Nokogiri_error_array_pusher(void * ctx, xmlErrorPtr error)
+{
+  VALUE list = (VALUE)ctx;
+  rb_ary_push(list,  Nokogiri_wrap_xml_syntax_error((VALUE)NULL, error));
+}
+
+void Nokogiri_error_raise(void * ctx, xmlErrorPtr error)
+{
+  rb_exc_raise(Nokogiri_wrap_xml_syntax_error((VALUE)NULL, error));
+}
+
+VALUE Nokogiri_wrap_xml_syntax_error(VALUE klass, xmlErrorPtr error)
+{
+  if(!klass) klass = cNokogiriXmlSyntaxError;
+
+  xmlErrorPtr ptr = calloc(1, sizeof(xmlError));
+  xmlCopyError(error, ptr);
+
+  return Data_Wrap_Struct(klass, NULL, dealloc, ptr);
+}
+
+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;
+
+  rb_define_alloc_func(klass, allocate);
+
+  rb_define_method(klass, "message", message, 0);
+  rb_define_method(klass, "message=", set_message, 1);
+  rb_define_method(klass, "initialize_copy", initialize_copy, 1);
+  rb_define_method(klass, "domain", domain, 0);
+  rb_define_method(klass, "code", code, 0);
+  rb_define_method(klass, "level", level, 0);
+  rb_define_method(klass, "file", file, 0);
+  rb_define_method(klass, "line", line, 0);
+  rb_define_method(klass, "str1", str1, 0);
+  rb_define_method(klass, "str2", str2, 0);
+  rb_define_method(klass, "str3", str3, 0);
+  rb_define_method(klass, "int1", int1, 0);
+  rb_define_method(klass, "column", column, 0);
+}

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(VALUE klass, xmlErrorPtr error);
+void Nokogiri_error_array_pusher(void * ctx, xmlErrorPtr error);
+void Nokogiri_error_raise(void * ctx, xmlErrorPtr error);
+
+extern VALUE cNokogiriXmlSyntaxError;
+#endif
+

data/ext/nokogiri/xml_text.c

@@ -0,0 +1,48 @@
+#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;
+  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->doc;
+
+  VALUE 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.c

@@ -0,0 +1,53 @@
+#include <xml_xpath.h>
+
+static void deallocate(xmlXPathObjectPtr xpath)
+{
+  NOKOGIRI_DEBUG_START(xpath);
+  xmlXPathFreeNodeSetList(xpath); // despite the name, this frees the xpath but not the contained node set
+  NOKOGIRI_DEBUG_END(xpath);
+}
+
+VALUE Nokogiri_wrap_xml_xpath(xmlXPathObjectPtr xpath)
+{
+  return Data_Wrap_Struct(cNokogiriXmlXpath, 0, deallocate, xpath);
+}
+
+/*
+ * call-seq:
+ *  node_set
+ *
+ * Fetch the node set associated with this xpath context.
+ */
+static VALUE node_set(VALUE self)
+{
+  xmlXPathObjectPtr xpath;
+  Data_Get_Struct(self, xmlXPathObject, xpath);
+
+  VALUE node_set = Qnil;
+
+  if (xpath->nodesetval)
+    node_set = Nokogiri_wrap_xml_node_set(xpath->nodesetval);
+
+  if(NIL_P(node_set))
+    node_set = Nokogiri_wrap_xml_node_set(xmlXPathNodeSetCreate(NULL));
+
+  rb_funcall(node_set, rb_intern("document="), 1, rb_iv_get(self, "@document"));
+
+  return node_set;
+}
+
+VALUE cNokogiriXmlXpath;
+void init_xml_xpath(void)
+{
+  VALUE module = rb_define_module("Nokogiri");
+  VALUE xml = rb_define_module_under(module, "XML");
+
+  /*
+   * This class wraps an XPath object and should only be instantiated from
+   * XPathContext.
+   */
+  VALUE klass = rb_define_class_under(xml, "XPath", rb_cObject);
+
+  cNokogiriXmlXpath = klass;
+  rb_define_method(klass, "node_set", node_set, 0);
+}

data/ext/nokogiri/xml_xpath.h

@@ -0,0 +1,11 @@
+#ifndef NOKOGIRI_XML_XPATH
+#define NOKOGIRI_XML_XPATH
+
+#include <nokogiri.h>
+
+void init_xml_xpath();
+VALUE Nokogiri_wrap_xml_xpath(xmlXPathObjectPtr xpath);
+
+extern VALUE cNokogiriXmlXpath;
+#endif
+

data/ext/nokogiri/xml_xpath_context.c

@@ -0,0 +1,239 @@
+#include <xml_xpath_context.h>
+
+static void deallocate(xmlXPathContextPtr ctx)
+{
+  NOKOGIRI_DEBUG_START(ctx);
+  xmlXPathFreeContext(ctx);
+  NOKOGIRI_DEBUG_END(ctx);
+}
+
+/*
+ * 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 *)StringValuePtr(prefix),
+                      (const xmlChar *)StringValuePtr(uri)
+  );
+  return self;
+}
+
+static void ruby_funcall(xmlXPathParserContextPtr ctx, int nargs)
+{
+  VALUE xpath_handler = Qnil;
+  xmlXPathObjectPtr obj;
+
+  assert(ctx);
+  assert(ctx->context);
+  assert(ctx->context->userData);
+  assert(ctx->context->doc);
+  assert(DOC_RUBY_OBJECT_TEST(ctx->context->doc));
+
+  xpath_handler = (VALUE)(ctx->context->userData);
+
+  VALUE * argv = (VALUE *)calloc((unsigned int)nargs, sizeof(VALUE));
+  VALUE doc = DOC_RUBY_OBJECT(ctx->context->doc);
+
+  int 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);
+        break;
+      default:
+        argv[i] = NOKOGIRI_STR_NEW2(xmlXPathCastToString(obj));
+    }
+    xmlXPathFreeNodeSetList(obj);
+  } while(i-- > 0);
+
+  VALUE result = rb_funcall2(
+      xpath_handler,
+      rb_intern((const char *)ctx->context->function),
+      nargs,
+      argv
+  );
+  free(argv);
+
+  VALUE node_set = Qnil;
+  xmlNodeSetPtr xml_node_set = NULL;
+
+  switch(TYPE(result)) {
+    case T_FLOAT:
+    case T_BIGNUM:
+    case T_FIXNUM:
+      xmlXPathReturnNumber(ctx, NUM2DBL(result));
+      break;
+    case T_STRING:
+      xmlXPathReturnString(
+          ctx,
+          (xmlChar *)xmlXPathWrapCString(StringValuePtr(result))
+      );
+      break;
+    case T_TRUE:
+      xmlXPathReturnTrue(ctx);
+      break;
+    case T_FALSE:
+      xmlXPathReturnFalse(ctx);
+      break;
+    case T_NIL:
+      break;
+    case T_ARRAY:
+      {
+        VALUE args[2] = {doc, 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 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;
+}
+
+static void xpath_exception_handler(void * ctx, xmlErrorPtr error)
+{
+  VALUE xpath = rb_const_get(mNokogiriXml, rb_intern("XPath"));
+  VALUE klass = rb_const_get(xpath, rb_intern("SyntaxError"));
+
+  rb_exc_raise(Nokogiri_wrap_xml_syntax_error(klass, error));
+}
+
+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, message);
+}
+
+/*
+ * call-seq:
+ *  evaluate(search_path)
+ *
+ * Evaluate the +search_path+ returning an XML::XPath object.
+ */
+static VALUE evaluate(int argc, VALUE *argv, VALUE self)
+{
+  VALUE search_path, xpath_handler;
+  xmlXPathContextPtr ctx;
+  Data_Get_Struct(self, xmlXPathContext, ctx);
+
+  if(rb_scan_args(argc, argv, "11", &search_path, &xpath_handler) == 1)
+    xpath_handler = Qnil;
+
+  xmlChar* query = (xmlChar *)StringValuePtr(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, xpath_exception_handler);
+
+  // For some reason, xmlXPathEvalExpression will blow up with a generic error
+  // when there is a non existent function.
+  xmlSetGenericErrorFunc(NULL, xpath_generic_exception_handler);
+
+  xmlXPathObjectPtr xpath = xmlXPathEvalExpression(query, ctx);
+  xmlSetStructuredErrorFunc(NULL, NULL);
+  xmlSetGenericErrorFunc(NULL, NULL);
+
+  if(xpath == NULL) {
+    VALUE xpath = rb_const_get(mNokogiriXml, rb_intern("XPath"));
+    VALUE klass = rb_const_get(xpath, rb_intern("SyntaxError"));
+
+    xmlErrorPtr error = xmlGetLastError();
+    rb_exc_raise(Nokogiri_wrap_xml_syntax_error(klass, error));
+  }
+
+  VALUE xpath_object = Nokogiri_wrap_xml_xpath(xpath);
+
+  assert(ctx->doc);
+  assert(DOC_RUBY_OBJECT_TEST(ctx->doc));
+
+  rb_iv_set(xpath_object, "@document", DOC_RUBY_OBJECT(ctx->doc));
+  return xpath_object;
+}
+
+/*
+ * call-seq:
+ *  new(node)
+ *
+ * Create a new XPathContext with +node+ as the reference point.
+ */
+static VALUE new(VALUE klass, VALUE nodeobj)
+{
+  xmlXPathInit();
+
+  xmlNodePtr node ;
+  Data_Get_Struct(nodeobj, xmlNode, node);
+
+  xmlXPathContextPtr ctx = xmlXPathNewContext(node->doc);
+  ctx->node = node;
+  VALUE self = Data_Wrap_Struct(klass, 0, deallocate, ctx);
+  //rb_iv_set(self, "@xpath_handler", Qnil);
+  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_ns", register_ns, 2);
+}