nokogiri 1.2.3-x86-mswin32-60 → 1.4.5-x86-mswin32-60

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

@@ -1,179 +1,45 @@
 #include <xml_syntax_error.h>
 
-static void dealloc(xmlErrorPtr ptr)
-{
-  NOKOGIRI_DEBUG_START(ptr);
-  xmlResetError(ptr);
-  xmlFree(ptr);
-  NOKOGIRI_DEBUG_END(ptr);
-}
-
-/*
- * 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, "UTF-8");
-  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, "UTF-8");
-  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, "UTF-8");
-  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, "UTF-8");
-
-  return Qnil;
-}
-
-/*
- * call-seq:
- *  level
- *
- * Get the error level
- */
-static VALUE level(VALUE self)
+void Nokogiri_error_array_pusher(void * ctx, xmlErrorPtr error)
 {
-  xmlErrorPtr error;
-  Data_Get_Struct(self, xmlError, error);
-  return INT2NUM((short)error->level);
+  VALUE list = (VALUE)ctx;
+  rb_ary_push(list,  Nokogiri_wrap_xml_syntax_error((VALUE)NULL, error));
 }
 
-/*
- * call-seq:
- *  code
- *
- * Get the error code
- */
-static VALUE code(VALUE self)
+void Nokogiri_error_raise(void * ctx, xmlErrorPtr error)
 {
-  xmlErrorPtr error;
-  Data_Get_Struct(self, xmlError, error);
-  return INT2NUM(error->code);
+  rb_exc_raise(Nokogiri_wrap_xml_syntax_error((VALUE)NULL, error));
 }
 
-/*
- * call-seq:
- *  domain
- *
- * Get the part of the library that raised this exception
- */
-static VALUE domain(VALUE self)
+VALUE Nokogiri_wrap_xml_syntax_error(VALUE klass, xmlErrorPtr error)
 {
-  xmlErrorPtr error;
-  Data_Get_Struct(self, xmlError, error);
-  return INT2NUM(error->domain);
-}
+  VALUE msg, e;
 
-/*
- * call-seq:
- *  message
- *
- * Get the human readable message.
- */
-static VALUE message(VALUE self)
-{
-  xmlErrorPtr error;
-  Data_Get_Struct(self, xmlError, error);
-  return NOKOGIRI_STR_NEW2(error->message, "UTF-8");
-}
+  if(!klass) klass = cNokogiriXmlSyntaxError;
 
-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));
-}
+  msg = (error && error->message) ? NOKOGIRI_STR_NEW2(error->message) : Qnil;
 
-VALUE Nokogiri_wrap_xml_syntax_error(VALUE klass, xmlErrorPtr error)
-{
-  if(!klass) klass = cNokogiriXmlSyntaxError;
+  e = rb_class_new_instance(
+      1,
+      &msg,
+      klass
+  );
 
-  xmlErrorPtr ptr = calloc(1, sizeof(xmlError));
-  xmlCopyError(error, ptr);
+  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 Data_Wrap_Struct(klass, NULL, dealloc, ptr);
+  return e;
 }
 
 VALUE cNokogiriXmlSyntaxError;
@@ -189,15 +55,4 @@ void init_xml_syntax_error()
   VALUE klass = rb_define_class_under(xml, "SyntaxError", syntax_error_mommy);
   cNokogiriXmlSyntaxError = klass;
 
-  rb_define_method(klass, "message", message, 0);
-  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

@@ -1,11 +1,12 @@
 #ifndef NOKOGIRI_XML_SYNTAX_ERROR
 #define NOKOGIRI_XML_SYNTAX_ERROR
 
-#include <native.h>
+#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);
+NORETURN(void Nokogiri_error_raise(void * ctx, xmlErrorPtr error));
 
 extern VALUE cNokogiriXmlSyntaxError;
 #endif

data/ext/nokogiri/xml_text.c

@@ -6,15 +6,24 @@
  *
  * Create a new Text element on the +document+ with +content+
  */
-static VALUE new(VALUE klass, VALUE string, VALUE document)
+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);
 
-  xmlNodePtr node = xmlNewText((xmlChar *)StringValuePtr(string));
-  node->doc = doc;
+  node = xmlNewText((xmlChar *)StringValuePtr(string));
+  node->doc = doc->doc;
 
-  VALUE rb_node = Nokogiri_wrap_xml_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);
 
@@ -28,13 +37,14 @@ void init_xml_text()
   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", node);
+  VALUE klass = rb_define_class_under(xml, "Text", char_data);
 
   cNokogiriXmlText = klass;
 
-  rb_define_singleton_method(klass, "new", new, 2);
+  rb_define_singleton_method(klass, "new", new, -1);
 }

data/ext/nokogiri/xml_text.h

@@ -1,7 +1,7 @@
 #ifndef NOKOGIRI_XML_TEXT
 #define NOKOGIRI_XML_TEXT
 
-#include <native.h>
+#include <nokogiri.h>
 
 void init_xml_text();
 

data/ext/nokogiri/xml_xpath_context.c

@@ -1,5 +1,7 @@
 #include <xml_xpath_context.h>
 
+int vasprintf (char **strp, const char *fmt, va_list ap);
+
 static void deallocate(xmlXPathContextPtr ctx)
 {
   NOKOGIRI_DEBUG_START(ctx);
@@ -25,10 +27,38 @@ static VALUE register_ns(VALUE self, VALUE prefix, VALUE 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(StringValuePtr(value));
+
+   xmlXPathRegisterVariable( ctx,
+      (const xmlChar *)StringValuePtr(name),
+      xmlValue
+   );
+
+   return self;
+}
+
 static void ruby_funcall(xmlXPathParserContextPtr ctx, int nargs)
 {
   VALUE xpath_handler = Qnil;
+  VALUE result;
+  VALUE *argv;
+  VALUE doc;
+  VALUE node_set = Qnil;
+  xmlNodeSetPtr xml_node_set = NULL;
   xmlXPathObjectPtr obj;
+  int i;
 
   assert(ctx);
   assert(ctx->context);
@@ -38,15 +68,19 @@ static void ruby_funcall(xmlXPathParserContextPtr ctx, int nargs)
 
   xpath_handler = (VALUE)(ctx->context->userData);
 
-  VALUE * argv = (VALUE *)calloc((unsigned int)nargs, sizeof(VALUE));
-  VALUE doc = DOC_RUBY_OBJECT(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);
 
-  int i = nargs - 1;
+  i = nargs - 1;
   do {
     obj = valuePop(ctx);
     switch(obj->type) {
       case XPATH_STRING:
-        argv[i] = NOKOGIRI_STR_NEW2(obj->stringval, ctx->context->doc->encoding);
+        argv[i] = NOKOGIRI_STR_NEW2(obj->stringval);
         break;
       case XPATH_BOOLEAN:
         argv[i] = obj->boolval == 1 ? Qtrue : Qfalse;
@@ -55,26 +89,25 @@ static void ruby_funcall(xmlXPathParserContextPtr ctx, int nargs)
         argv[i] = rb_float_new(obj->floatval);
         break;
       case XPATH_NODESET:
-        argv[i] = Nokogiri_wrap_xml_node_set(obj->nodesetval);
+        argv[i] = Nokogiri_wrap_xml_node_set(obj->nodesetval, doc);
         break;
       default:
-        argv[i] = NOKOGIRI_STR_NEW2(
-            xmlXPathCastToString(obj), ctx->context->doc->encoding
-        );
+        argv[i] = NOKOGIRI_STR_NEW2(xmlXPathCastToString(obj));
     }
     xmlXPathFreeNodeSetList(obj);
   } while(i-- > 0);
 
-  VALUE result = rb_funcall2(
+  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;
+  for (i = 0 ; i < nargs ; ++i) {
+    rb_gc_unregister_address(&argv[i]);
+  }
+  free(argv);
 
   switch(TYPE(result)) {
     case T_FLOAT:
@@ -97,20 +130,19 @@ static void ruby_funcall(xmlXPathParserContextPtr ctx, int nargs)
     case T_NIL:
       break;
     case T_ARRAY:
-      node_set = rb_funcall(
-          cNokogiriXmlNodeSet,
-          rb_intern("new"),
-          2,
-          doc,
-          result
-      );
-      Data_Get_Struct(node_set, xmlNodeSet, xml_node_set);
-      xmlXPathReturnNodeSet(ctx, xmlXPathNodeSetMerge(NULL, xml_node_set));
+      {
+        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_funcall(result, rb_intern("is_a?"), 1, cNokogiriXmlNodeSet)) {
+      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.
+        /* Copy the node set, otherwise it will get GC'd. */
         xmlXPathReturnNodeSet(ctx, xmlXPathNodeSetMerge(NULL, xml_node_set));
         break;
       }
@@ -130,16 +162,16 @@ static xmlXPathFunction lookup( void *ctx,
   return NULL;
 }
 
+NORETURN(static void xpath_exception_handler(void * ctx, xmlErrorPtr error));
 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_funcall(rb_mKernel, rb_intern("raise"), 1,
-    Nokogiri_wrap_xml_syntax_error(klass, error)
-  );
+  rb_exc_raise(Nokogiri_wrap_xml_syntax_error(klass, error));
 }
 
+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;
@@ -154,23 +186,27 @@ static void xpath_generic_exception_handler(void * ctx, const char *msg, ...)
 
 /*
  * call-seq:
- *  evaluate(search_path)
+ *  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;
 
-  xmlChar* query = (xmlChar *)StringValuePtr(search_path);
+  query = (xmlChar *)StringValuePtr(search_path);
 
   if(Qnil != xpath_handler) {
-    // FIXME: not sure if this is the correct place to shove private data.
+    /* FIXME: not sure if this is the correct place to shove private data. */
     ctx->userData = (void *)xpath_handler;
     xmlXPathRegisterFuncLookup(ctx, lookup, (void *)xpath_handler);
   }
@@ -178,11 +214,11 @@ static VALUE evaluate(int argc, VALUE *argv, VALUE self)
   xmlResetLastError();
   xmlSetStructuredErrorFunc(NULL, xpath_exception_handler);
 
-  // For some reason, xmlXPathEvalExpression will blow up with a generic error
-  // when there is a non existent function.
+  /* 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);
+  xpath = xmlXPathEvalExpression(query, ctx);
   xmlSetStructuredErrorFunc(NULL, NULL);
   xmlSetGenericErrorFunc(NULL, NULL);
 
@@ -191,22 +227,39 @@ static VALUE evaluate(int argc, VALUE *argv, VALUE self)
     VALUE klass = rb_const_get(xpath, rb_intern("SyntaxError"));
 
     xmlErrorPtr error = xmlGetLastError();
-    rb_funcall(rb_mKernel, rb_intern("raise"), 1,
-        Nokogiri_wrap_xml_syntax_error(klass, error)
-    );
+    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_funcall( xpath_object,
-              rb_intern("document="),
-              1,
-              DOC_RUBY_OBJECT(ctx->doc)
-   );
-  return xpath_object;
+  switch(xpath->type) {
+    case XPATH_STRING:
+      thing = NOKOGIRI_STR_NEW2(xpath->stringval);
+      break;
+    case XPATH_NODESET:
+      if(NULL == xpath->nodesetval) {
+        thing = Nokogiri_wrap_xml_node_set(xmlXPathNodeSetCreate(NULL),
+          DOC_RUBY_OBJECT(ctx->doc));
+      } else {
+        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(xmlXPathNodeSetCreate(NULL),
+        DOC_RUBY_OBJECT(ctx->doc));
+  }
+
+  xmlXPathFreeNodeSetList(xpath);
+
+  return thing;
 }
 
 /*
@@ -217,15 +270,18 @@ static VALUE evaluate(int argc, VALUE *argv, VALUE self)
  */
 static VALUE new(VALUE klass, VALUE nodeobj)
 {
+  xmlNodePtr node;
+  xmlXPathContextPtr ctx;
+  VALUE self;
+
   xmlXPathInit();
 
-  xmlNodePtr node ;
   Data_Get_Struct(nodeobj, xmlNode, node);
 
-  xmlXPathContextPtr ctx = xmlXPathNewContext(node->doc);
+  ctx = xmlXPathNewContext(node->doc);
   ctx->node = node;
-  VALUE self = Data_Wrap_Struct(klass, 0, deallocate, ctx);
-  //rb_iv_set(self, "@xpath_handler", Qnil);
+  self = Data_Wrap_Struct(klass, 0, deallocate, ctx);
+  /*rb_iv_set(self, "@xpath_handler", Qnil); */
   return self;
 }
 
@@ -248,5 +304,6 @@ void init_xml_xpath_context(void)
 
   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);
 }