nokogiri 1.3.3-x86-mingw32 → 1.4.0-x86-mingw32

data/ext/nokogiri/xml_sax_parser.h

@@ -6,5 +6,38 @@
 void init_xml_sax_parser();
 
 extern VALUE cNokogiriXmlSaxParser ;
+
+typedef struct _nokogiriSAXTuple {
+  xmlParserCtxtPtr  ctxt;
+  VALUE             self;
+} nokogiriSAXTuple;
+
+typedef nokogiriSAXTuple * nokogiriSAXTuplePtr;
+
+#define NOKOGIRI_SAX_SELF(_ctxt) \
+  ({ \
+    nokogiriSAXTuplePtr _tuple = (nokogiriSAXTuplePtr)(_ctxt); \
+    _tuple->self; \
+  })
+
+#define NOKOGIRI_SAX_CTXT(_ctxt) \
+  ({ \
+    nokogiriSAXTuplePtr _tuple = (nokogiriSAXTuplePtr)(_ctxt); \
+    _tuple->ctxt; \
+  })
+
+#define NOKOGIRI_SAX_TUPLE_NEW(_ctxt, _self) \
+  ({ \
+    nokogiriSAXTuplePtr _tuple = malloc(sizeof(nokogiriSAXTuple)); \
+    _tuple->self = _self; \
+    _tuple->ctxt = _ctxt; \
+    _tuple; \
+  })
+
+#define NOKOGIRI_SAX_TUPLE_DESTROY(_tuple) \
+  ({ \
+    free(_tuple); \
+  })
+
 #endif
 

data/ext/nokogiri/xml_sax_parser_context.c

@@ -0,0 +1,155 @@
+#include <xml_sax_parser_context.h>
+
+VALUE cNokogiriXmlSaxParserContext ;
+
+static void deallocate(xmlParserCtxtPtr ctxt)
+{
+  NOKOGIRI_DEBUG_START(handler);
+
+  ctxt->sax = NULL;
+
+  xmlFreeParserCtxt(ctxt);
+
+  NOKOGIRI_DEBUG_END(handler);
+}
+
+/*
+ * call-seq:
+ *  parse_io(io, encoding)
+ *
+ * Parse +io+ object with +encoding+
+ */
+static VALUE parse_io(VALUE klass, VALUE io, VALUE encoding)
+{
+  xmlCharEncoding enc = (xmlCharEncoding)NUM2INT(encoding); 
+
+  xmlParserCtxtPtr ctxt = xmlCreateIOParserCtxt(
+      NULL,
+      NULL,
+      (xmlInputReadCallback)io_read_callback,
+      (xmlInputCloseCallback)io_close_callback,
+      (void *)io,
+      enc
+  );
+
+  return Data_Wrap_Struct(klass, NULL, deallocate, ctxt);
+}
+
+/*
+ * call-seq:
+ *  parse_file(filename)
+ *
+ * Parse file given +filename+
+ */
+static VALUE parse_file(VALUE klass, VALUE filename)
+{
+  xmlParserCtxtPtr ctxt = xmlCreateFileParserCtxt(StringValuePtr(filename));
+  return Data_Wrap_Struct(klass, NULL, deallocate, ctxt);
+}
+
+/*
+ * call-seq:
+ *  parse_memory(data)
+ *
+ * Parse the XML stored in memory in +data+
+ */
+static VALUE parse_memory(VALUE klass, VALUE data)
+{
+  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");
+
+  xmlParserCtxtPtr ctxt = xmlCreateMemoryParserCtxt(
+      StringValuePtr(data),
+      (int)RSTRING_LEN(data)
+  );
+
+  return Data_Wrap_Struct(klass, NULL, deallocate, ctxt);
+}
+
+/*
+ * call-seq:
+ *  parse_with(sax_handler)
+ *
+ * Use +sax_handler+ and parse the current document
+ */
+static VALUE parse_with(VALUE self, VALUE sax_handler)
+{
+  if(!rb_obj_is_kind_of(sax_handler, cNokogiriXmlSaxParser))
+    rb_raise(rb_eArgError, "argument must be a Nokogiri::XML::SAX::Parser");
+
+  xmlParserCtxtPtr ctxt;
+  Data_Get_Struct(self, xmlParserCtxt, ctxt);
+
+  xmlSAXHandlerPtr sax;
+  Data_Get_Struct(sax_handler, xmlSAXHandler, 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);
+
+  xmlParseDocument(ctxt);
+
+  if(NULL != ctxt->myDoc) xmlFreeDoc(ctxt->myDoc);
+
+  NOKOGIRI_SAX_TUPLE_DESTROY(ctxt->userData);
+}
+
+/*
+ * call-seq:
+ *  replace_entities=(boolean)
+ *
+ * Should this parser replace entities?  &amp; will get converted to '&' if
+ * set to true
+ */
+static VALUE set_replace_entities(VALUE self, VALUE value)
+{
+  xmlParserCtxtPtr ctxt;
+  Data_Get_Struct(self, xmlParserCtxt, ctxt);
+
+  if(Qfalse == value)
+    ctxt->replaceEntities = 0;
+  else
+    ctxt->replaceEntities = 1;
+
+  return value;
+}
+
+/*
+ * call-seq:
+ *  replace_entities
+ *
+ * Should this parser replace entities?  &amp; will get converted to '&' if
+ * set to true
+ */
+static VALUE get_replace_entities(VALUE self)
+{
+  xmlParserCtxtPtr ctxt;
+  Data_Get_Struct(self, xmlParserCtxt, ctxt);
+
+  if(0 == ctxt->replaceEntities)
+    return Qfalse;
+  else
+    return Qtrue;
+}
+
+void init_xml_sax_parser_context()
+{
+  VALUE nokogiri  = rb_define_module("Nokogiri");
+  VALUE xml       = rb_define_module_under(nokogiri, "XML");
+  VALUE sax       = rb_define_module_under(xml, "SAX");
+  VALUE klass     = rb_define_class_under(sax, "ParserContext", rb_cObject);
+
+  cNokogiriXmlSaxParserContext = klass;
+
+  rb_define_singleton_method(klass, "io", parse_io, 2);
+  rb_define_singleton_method(klass, "memory", parse_memory, 1);
+  rb_define_singleton_method(klass, "file", parse_file, 1);
+
+  rb_define_method(klass, "parse_with", parse_with, 1);
+  rb_define_method(klass, "replace_entities=", set_replace_entities, 1);
+  rb_define_method(klass, "replace_entities", get_replace_entities, 0);
+}

data/ext/nokogiri/xml_sax_parser_context.h

@@ -0,0 +1,10 @@
+#ifndef NOKOGIRI_XML_SAX_PARSER_CONTEXT
+#define NOKOGIRI_XML_SAX_PARSER_CONTEXT
+
+#include <nokogiri.h>
+
+extern VALUE cNokogiriXmlSaxParserContext;
+
+void init_xml_sax_parser_context();
+
+#endif

data/ext/nokogiri/xml_sax_push_parser.c

@@ -3,7 +3,10 @@
 static void deallocate(xmlParserCtxtPtr ctx)
 {
   NOKOGIRI_DEBUG_START(ctx);
-  if(ctx != NULL) xmlFreeParserCtxt(ctx);
+  if(ctx != NULL) {
+    NOKOGIRI_SAX_TUPLE_DESTROY(ctx->userData);
+    xmlFreeParserCtxt(ctx);
+  }
   NOKOGIRI_DEBUG_END(ctx);
 }
 
@@ -24,17 +27,17 @@ static VALUE native_write(VALUE self, VALUE _chunk, VALUE _last_chunk)
   Data_Get_Struct(self, xmlParserCtxt, ctx);
 
   const char * chunk  = NULL;
-  int last_chunk      = 0;
   int size            = 0;
 
   if(Qnil != _chunk) {
     chunk = StringValuePtr(_chunk);
     size = RSTRING_LEN(_chunk);
   }
-  if(Qtrue == _last_chunk) last_chunk = 1;
 
-  if(xmlParseChunk(ctx, chunk, size, last_chunk))
-    rb_raise(rb_eRuntimeError, "Couldn't parse chunk");
+  if(xmlParseChunk(ctx, chunk, size, Qtrue == _last_chunk ? 1 : 0)) {
+    xmlErrorPtr e = xmlCtxtGetLastError(ctx);
+    Nokogiri_error_raise(NULL, e);
+  }
 
   return self;
 }
@@ -57,7 +60,7 @@ static VALUE initialize_native(VALUE self, VALUE _xml_sax, VALUE _filename)
 
   xmlParserCtxtPtr ctx = xmlCreatePushParserCtxt(
       sax,
-      (void *)self,
+      NULL,
       NULL,
       0,
       filename
@@ -65,6 +68,8 @@ static VALUE initialize_native(VALUE self, VALUE _xml_sax, VALUE _filename)
   if(ctx == NULL)
     rb_raise(rb_eRuntimeError, "Could not create a parser context");
 
+  ctx->userData = NOKOGIRI_SAX_TUPLE_NEW(ctx, self);
+
   ctx->sax2 = 1;
   DATA_PTR(self) = ctx;
   return self;

data/ext/nokogiri/xml_syntax_error.c

@@ -8,6 +8,13 @@ static void dealloc(xmlErrorPtr 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
@@ -44,8 +51,7 @@ static VALUE str3(VALUE self)
 {
   xmlErrorPtr error;
   Data_Get_Struct(self, xmlError, error);
-  if(error->str3)
-    return NOKOGIRI_STR_NEW2(error->str3, "UTF-8");
+  if(error->str3) return NOKOGIRI_STR_NEW2(error->str3);
   return Qnil;
 }
 
@@ -59,8 +65,7 @@ static VALUE str2(VALUE self)
 {
   xmlErrorPtr error;
   Data_Get_Struct(self, xmlError, error);
-  if(error->str2)
-    return NOKOGIRI_STR_NEW2(error->str2, "UTF-8");
+  if(error->str2) return NOKOGIRI_STR_NEW2(error->str2);
   return Qnil;
 }
 
@@ -74,8 +79,7 @@ static VALUE str1(VALUE self)
 {
   xmlErrorPtr error;
   Data_Get_Struct(self, xmlError, error);
-  if(error->str1)
-    return NOKOGIRI_STR_NEW2(error->str1, "UTF-8");
+  if(error->str1) return NOKOGIRI_STR_NEW2(error->str1);
   return Qnil;
 }
 
@@ -102,8 +106,7 @@ static VALUE file(VALUE self)
 {
   xmlErrorPtr error;
   Data_Get_Struct(self, xmlError, error);
-  if(error->file)
-    return NOKOGIRI_STR_NEW2(error->file, "UTF-8");
+  if(error->file) return NOKOGIRI_STR_NEW2(error->file);
 
   return Qnil;
 }
@@ -157,7 +160,53 @@ static VALUE message(VALUE self)
 {
   xmlErrorPtr error;
   Data_Get_Struct(self, xmlError, error);
-  return NOKOGIRI_STR_NEW2(error->message, "UTF-8");
+  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)
@@ -168,9 +217,7 @@ void Nokogiri_error_array_pusher(void * ctx, xmlErrorPtr error)
 
 void Nokogiri_error_raise(void * ctx, xmlErrorPtr error)
 {
-  rb_funcall(rb_mKernel, rb_intern("raise"), 1,
-      Nokogiri_wrap_xml_syntax_error((VALUE)NULL, error)
-  );
+  rb_exc_raise(Nokogiri_wrap_xml_syntax_error((VALUE)NULL, error));
 }
 
 VALUE Nokogiri_wrap_xml_syntax_error(VALUE klass, xmlErrorPtr error)
@@ -196,7 +243,11 @@ void init_xml_syntax_error()
   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);

data/ext/nokogiri/xml_text.c

@@ -18,10 +18,10 @@ static VALUE new(int argc, VALUE *argv, VALUE klass)
   Data_Get_Struct(document, xmlDoc, doc);
 
   xmlNodePtr node = xmlNewText((xmlChar *)StringValuePtr(string));
-  node->doc = doc;
+  node->doc = doc->doc;
 
   VALUE rb_node = Nokogiri_wrap_xml_node(klass, node) ;
-  rb_funcall2(rb_node, rb_intern("initialize"), argc, argv);
+  rb_obj_call_init(rb_node, argc, argv);
 
   if(rb_block_given_p()) rb_yield(rb_node);
 
@@ -35,11 +35,12 @@ 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;
 

data/ext/nokogiri/xml_xpath.c

@@ -28,7 +28,7 @@ static VALUE node_set(VALUE self)
   if (xpath->nodesetval)
     node_set = Nokogiri_wrap_xml_node_set(xpath->nodesetval);
 
-  if(Qnil == node_set)
+  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"));

data/ext/nokogiri/xml_xpath_context.c

@@ -46,7 +46,7 @@ static void ruby_funcall(xmlXPathParserContextPtr ctx, int nargs)
     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;
@@ -58,9 +58,7 @@ static void ruby_funcall(xmlXPathParserContextPtr ctx, int nargs)
         argv[i] = Nokogiri_wrap_xml_node_set(obj->nodesetval);
         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);
@@ -97,18 +95,15 @@ 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] = {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_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.
         xmlXPathReturnNodeSet(ctx, xmlXPathNodeSetMerge(NULL, xml_node_set));
@@ -135,9 +130,7 @@ 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));
 }
 
 static void xpath_generic_exception_handler(void * ctx, const char *msg, ...)
@@ -191,9 +184,7 @@ 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);
@@ -201,11 +192,7 @@ static VALUE evaluate(int argc, VALUE *argv, VALUE self)
   assert(ctx->doc);
   assert(DOC_RUBY_OBJECT_TEST(ctx->doc));
 
-  rb_funcall( xpath_object,
-              rb_intern("document="),
-              1,
-              DOC_RUBY_OBJECT(ctx->doc)
-   );
+  rb_iv_set(xpath_object, "@document", DOC_RUBY_OBJECT(ctx->doc));
   return xpath_object;
 }