nokogiri 1.1.1 → 1.2.0

data/ext/nokogiri/xml_node_set.c

@@ -110,7 +110,11 @@ VALUE Nokogiri_wrap_xml_node_set(xmlNodeSetPtr node_set)
 VALUE cNokogiriXmlNodeSet ;
 void init_xml_node_set(void)
 {
-  VALUE klass = cNokogiriXmlNodeSet = rb_eval_string("Nokogiri::XML::NodeSet");
+  VALUE nokogiri  = rb_define_module("Nokogiri");
+  VALUE xml       = rb_define_module_under(nokogiri, "XML");
+  VALUE klass     = rb_define_class_under(xml, "NodeSet", rb_cObject);
+  cNokogiriXmlNodeSet = klass;
+
   rb_define_alloc_func(klass, allocate);
   rb_define_method(klass, "length", length, 0);
   rb_define_method(klass, "[]", index_at, 1);

data/ext/nokogiri/xml_processing_instruction.c

@@ -0,0 +1,44 @@
+#include <xml_processing_instruction.h>
+
+/*
+ * call-seq:
+ *  new(document, name, content)
+ *
+ * Create a new ProcessingInstruction element on the +document+ with +name+
+ * and +content+
+ */
+static VALUE new(VALUE klass, VALUE doc, VALUE name, VALUE content)
+{
+  xmlDocPtr xml_doc;
+  Data_Get_Struct(doc, xmlDoc, xml_doc);
+
+  xmlNodePtr node = xmlNewDocPI(
+      xml_doc,
+      (const xmlChar *)StringValuePtr(name),
+      (const xmlChar *)StringValuePtr(content)
+  );
+
+  VALUE rb_node = Nokogiri_wrap_xml_node(node);
+
+  if(rb_block_given_p()) rb_yield(rb_node);
+
+  return rb_node;
+}
+
+VALUE cNokogiriXmlProcessingInstruction;
+void init_xml_processing_instruction()
+{
+  VALUE nokogiri = rb_define_module("Nokogiri");
+  VALUE xml = rb_define_module_under(nokogiri, "XML");
+  VALUE node = rb_define_class_under(xml, "Node", rb_cObject);
+
+  /*
+   * ProcessingInstruction represents a ProcessingInstruction node in an xml
+   * document.
+   */
+  VALUE klass = rb_define_class_under(xml, "ProcessingInstruction", node);
+
+  cNokogiriXmlProcessingInstruction = klass;
+
+  rb_define_singleton_method(klass, "new", new, 3);
+}

data/ext/nokogiri/xml_processing_instruction.h

@@ -0,0 +1,9 @@
+#ifndef NOKOGIRI_XML_PROCESSING_INSTRUCTION
+#define NOKOGIRI_XML_PROCESSING_INSTRUCTION
+
+#include <native.h>
+
+void init_xml_processing_instruction();
+
+extern VALUE cNokogiriXmlProcessingInstruction;
+#endif

data/ext/nokogiri/xml_reader.c

@@ -382,11 +382,24 @@ static VALUE read_more(VALUE self)
   xmlTextReaderPtr reader;
   Data_Get_Struct(self, xmlTextReader, reader);
 
+  VALUE error_list = rb_funcall(self, rb_intern("errors"), 0);
+
+  xmlSetStructuredErrorFunc((void *)error_list, Nokogiri_error_array_pusher);
   int ret = xmlTextReaderRead(reader);
+  xmlSetStructuredErrorFunc(NULL, NULL);
+
   if(ret == 1) return self;
   if(ret == 0) return Qnil;
 
-  rb_raise(rb_eRuntimeError, "Error pulling: %d", ret);
+  xmlErrorPtr error = xmlGetLastError();
+  if(error)
+    rb_funcall(rb_mKernel, rb_intern("raise"), 1,
+        Nokogiri_wrap_xml_syntax_error((VALUE)NULL, error)
+    );
+  else
+    rb_raise(rb_eRuntimeError, "Error pulling: %d", ret);
+
+  return Qnil;
 }
 
 /*
@@ -407,12 +420,12 @@ static VALUE from_memory(int argc, VALUE *argv, VALUE klass)
 
   rb_buffer = StringValue(rb_buffer) ;
   if (RTEST(rb_url)) c_url = StringValuePtr(rb_url);
-  if (RTEST(encoding)) c_encoding = StringValuePtr(rb_url);
+  if (RTEST(encoding)) c_encoding = StringValuePtr(encoding);
   if (RTEST(rb_options)) c_options = NUM2INT(rb_options);
 
   xmlTextReaderPtr reader = xmlReaderForMemory(
       StringValuePtr(rb_buffer),
-      NUM2INT(rb_funcall(rb_buffer, rb_intern("length"), 0)),
+      RSTRING_LEN(rb_buffer),
       c_url,
       c_encoding,
       c_options
@@ -423,7 +436,10 @@ static VALUE from_memory(int argc, VALUE *argv, VALUE klass)
     rb_raise(rb_eRuntimeError, "couldn't create a parser");
   }
 
-  return Data_Wrap_Struct(klass, NULL, dealloc, reader);
+  VALUE rb_reader = Data_Wrap_Struct(klass, NULL, dealloc, reader);
+  rb_funcall(rb_reader, rb_intern("initialize"), 0);
+
+  return rb_reader;
 }
 
 VALUE cNokogiriXmlReader;

data/ext/nokogiri/xml_sax_parser.c

@@ -1,4 +1,3 @@
-#define _GNU_SOURCE
 #include <stdio.h>
 #include <xml_sax_parser.h>
 
@@ -15,7 +14,7 @@ static VALUE parse_memory(VALUE self, VALUE data)
   xmlSAXUserParseMemory(  handler,
                           (void *)self,
                           StringValuePtr(data),
-                          NUM2INT(rb_funcall(data, rb_intern("length"), 0))
+                          RSTRING_LEN(data)
   );
   return data;
 }
@@ -46,6 +45,12 @@ static VALUE native_parse_io(VALUE self, VALUE io, VALUE encoding)
   return io;
 }
 
+/*
+ * call-seq:
+ *  native_parse_file(data)
+ *
+ * Parse the document stored in +data+
+ */
 static VALUE native_parse_file(VALUE self, VALUE data)
 {
   xmlSAXHandlerPtr handler;
@@ -116,7 +121,43 @@ static void comment_func(void * ctx, const xmlChar * value)
   rb_funcall(doc, rb_intern("comment"), 1, str);
 }
 
-#ifndef XP_WIN
+#ifdef XP_WIN
+/*
+ * I srsly hate windows.  it doesn't have vasprintf.
+ * This is stolen from here:
+ *   http://eleves.ec-lille.fr/~couprieg/index.php?2008/06/17/39-first-issues-when-porting-an-application-on-windows-ce
+ * and slightly modified
+ */
+static inline int vasprintf(char **strp, const char *fmt, va_list ap) {
+  int n;
+  size_t size = 4096;
+  char *res, *np;
+
+  if ( (res = (char *) malloc(size)) == NULL )
+    return -1;
+
+  while (1) {
+    n = vsnprintf (res, size, fmt, ap);
+    /* If that worked, return the string. */
+    if (n > -1 && n < size) {
+      *strp = res;
+      return n;
+    }
+
+    /* Else try again with more space. */
+    if (n == -1)
+      size *= 2; /* twice the old size */
+
+    if ( (np = (char *) realloc(res, size)) == NULL ) {
+      free(res);
+      return -1;
+    } else {
+      res = np;
+    }
+  }
+}
+#endif
+
 static void warning_func(void * ctx, const char *msg, ...)
 {
   VALUE self = (VALUE)ctx;
@@ -131,9 +172,7 @@ static void warning_func(void * ctx, const char *msg, ...)
   rb_funcall(doc, rb_intern("warning"), 1, rb_str_new2(message));
   free(message);
 }
-#endif
 
-#ifndef XP_WIN
 static void error_func(void * ctx, const char *msg, ...)
 {
   VALUE self = (VALUE)ctx;
@@ -148,7 +187,6 @@ static void error_func(void * ctx, const char *msg, ...)
   rb_funcall(doc, rb_intern("error"), 1, rb_str_new2(message));
   free(message);
 }
-#endif
 
 static void cdata_block(void * ctx, const xmlChar * value, int len)
 {
@@ -175,15 +213,8 @@ static VALUE allocate(VALUE klass)
   handler->endElement = end_element;
   handler->characters = characters_func;
   handler->comment = comment_func;
-#ifndef XP_WIN
-  /*
-   * The va*functions aren't in ming, and I don't want to deal with
-   * it right now.....
-   *
-   */
   handler->warning = warning_func;
   handler->error = error_func;
-#endif
   handler->cdataBlock = cdata_block;
 
   return Data_Wrap_Struct(klass, NULL, deallocate, handler);
@@ -192,8 +223,13 @@ static VALUE allocate(VALUE klass)
 VALUE cNokogiriXmlSaxParser ;
 void init_xml_sax_parser()
 {
-  VALUE klass = cNokogiriXmlSaxParser =
-    rb_const_get(mNokogiriXmlSax, rb_intern("Parser"));
+  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, "Parser", rb_cObject);
+
+  cNokogiriXmlSaxParser = klass;
+
   rb_define_alloc_func(klass, allocate);
   rb_define_method(klass, "parse_memory", parse_memory, 1);
   rb_define_private_method(klass, "native_parse_file", native_parse_file, 1);

data/ext/nokogiri/xml_sax_push_parser.c

@@ -0,0 +1,85 @@
+#include <xml_sax_push_parser.h>
+
+static void deallocate(xmlParserCtxtPtr ctx)
+{
+  NOKOGIRI_DEBUG_START(handler);
+  if(ctx != NULL) xmlFreeParserCtxt(ctx);
+  NOKOGIRI_DEBUG_END(handler);
+}
+
+static VALUE allocate(VALUE klass)
+{
+  return Data_Wrap_Struct(klass, NULL, deallocate, NULL);
+}
+
+/*
+ * call-seq:
+ *  native_write(chunk, last_chunk)
+ *
+ * Write +chunk+ to PushParser. +last_chunk+ triggers the end_document handle
+ */
+static VALUE native_write(VALUE self, VALUE _chunk, VALUE _last_chunk)
+{
+  xmlParserCtxtPtr ctx;
+  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");
+
+  return self;
+}
+
+/*
+ * call-seq:
+ *  initialize_native(xml_sax, filename)
+ *
+ * Initialize the push parser with +xml_sax+ using +filename+
+ */
+static VALUE initialize_native(VALUE self, VALUE _xml_sax, VALUE _filename)
+{
+  xmlSAXHandlerPtr sax;
+
+  Data_Get_Struct(_xml_sax, xmlSAXHandler, sax);
+  
+  const char * filename = NULL;
+
+  if(_filename != Qnil) filename = StringValuePtr(_filename);
+
+  xmlParserCtxtPtr ctx = xmlCreatePushParserCtxt(
+      sax,
+      (void *)self,
+      NULL,
+      0,
+      filename
+  );
+  if(ctx == NULL)
+    rb_raise(rb_eRuntimeError, "Could not create a parser context");
+
+  DATA_PTR(self) = ctx;
+  return self;
+}
+
+VALUE cNokogiriXmlSaxPushParser ;
+void init_xml_sax_push_parser()
+{
+  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, "PushParser", rb_cObject);
+
+  cNokogiriXmlSaxPushParser = klass;
+
+  rb_define_alloc_func(klass, allocate);
+  rb_define_private_method(klass, "initialize_native", initialize_native, 2);
+  rb_define_private_method(klass, "native_write", native_write, 2);
+}

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 <native.h>
+
+void init_xml_sax_push_parser();
+
+extern VALUE cNokogiriXmlSaxPushParser ;
+#endif

data/ext/nokogiri/xml_syntax_error.c

@@ -160,17 +160,20 @@ static VALUE message(VALUE self)
   return rb_str_new2(error->message);
 }
 
-void Nokogiri_error_handler(void * ctx, xmlErrorPtr error)
+void Nokogiri_error_array_pusher(void * ctx, xmlErrorPtr error)
 {
-  // FIXME: I'm interneting this.  I *think* the pointer passed in here gets
-  // freed on its own, thats why I copy it.
-  // The files are *in* the computer.
+  VALUE list = (VALUE)ctx;
+  rb_ary_push(list,  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);
 
-  VALUE err = Data_Wrap_Struct(cNokogiriXmlSyntaxError, NULL, dealloc, ptr);
-  VALUE block = rb_funcall(mNokogiri, rb_intern("error_handler"), 0);
-  rb_funcall(block, rb_intern("call"), 1, err);
+  return Data_Wrap_Struct(klass, NULL, dealloc, ptr);
 }
 
 VALUE cNokogiriXmlSyntaxError;
@@ -182,7 +185,8 @@ void init_xml_syntax_error()
   /*
    * The XML::SyntaxError is raised on parse errors
    */
-  VALUE klass = rb_define_class_under(xml, "SyntaxError", rb_eSyntaxError);
+  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_method(klass, "message", message, 0);

data/ext/nokogiri/xml_syntax_error.h

@@ -4,7 +4,8 @@
 #include <native.h>
 
 void init_xml_syntax_error();
-void Nokogiri_error_handler(void * ctx, xmlErrorPtr error);
+VALUE Nokogiri_wrap_xml_syntax_error(VALUE klass, xmlErrorPtr error);
+void Nokogiri_error_array_pusher(void * ctx, xmlErrorPtr error);
 
 extern VALUE cNokogiriXmlSyntaxError;
 #endif

data/ext/nokogiri/xml_xpath_context.c

@@ -139,6 +139,7 @@ static VALUE evaluate(int argc, VALUE *argv, VALUE self)
   VALUE search_path, xpath_handler;
   xmlXPathContextPtr ctx;
   Data_Get_Struct(self, xmlXPathContext, ctx);
+  VALUE error_list      = rb_ary_new();
 
   if(rb_scan_args(argc, argv, "11", &search_path, &xpath_handler) == 1)
     xpath_handler = Qnil;
@@ -151,11 +152,19 @@ static VALUE evaluate(int argc, VALUE *argv, VALUE self)
     xmlXPathRegisterFuncLookup(ctx, lookup, (void *)xpath_handler);
   }
 
+  xmlResetLastError();
+  xmlSetStructuredErrorFunc((void *)error_list, Nokogiri_error_array_pusher);
   xmlXPathObjectPtr xpath = xmlXPathEvalExpression(query, ctx);
+  xmlSetStructuredErrorFunc(NULL, NULL);
+
   if(xpath == NULL) {
     VALUE xpath = rb_const_get(mNokogiriXml, rb_intern("XPath"));
-    VALUE error = rb_const_get(xpath, rb_intern("SyntaxError"));
-    rb_raise(error, "Couldn't evaluate expression '%s'", query);
+    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)
+    );
   }
 
   VALUE xpath_object = Nokogiri_wrap_xml_xpath(xpath);

data/ext/nokogiri/xslt_stylesheet.c

@@ -105,16 +105,11 @@ static VALUE apply_to(int argc, VALUE* argv, VALUE self)
 VALUE cNokogiriXsltStylesheet ;
 void init_xslt_stylesheet()
 {
-  /*
-   * HACK.  This is so that rdoc will work with this C file.
-   */
-  /*
   VALUE nokogiri = rb_define_module("Nokogiri");
   VALUE xslt = rb_define_module_under(nokogiri, "XSLT");
   VALUE klass = rb_define_class_under(xslt, "Stylesheet", rb_cObject);
-  */
 
-  VALUE klass = cNokogiriXsltStylesheet = rb_const_get(mNokogiriXslt, rb_intern("Stylesheet"));
+  cNokogiriXsltStylesheet = klass;
     
   rb_define_singleton_method(klass, "parse_stylesheet_doc", parse_stylesheet_doc, 1);
   rb_define_method(klass, "serialize", serialize, 1);

data/lib/nokogiri.rb

@@ -1,4 +1,12 @@
+# Modify the PATH on windows so that the external DLLs will get loaded.
+ENV['PATH'] = [File.expand_path(
+  File.join(File.dirname(__FILE__), "..", "ext", "nokogiri")
+), ENV['PATH']].compact.join(';') if RUBY_PLATFORM =~ /mswin/i
+
+require 'nokogiri/native' unless RUBY_PLATFORM =~ /java/
+
 require 'nokogiri/version'
+require 'nokogiri/syntax_error'
 require 'nokogiri/xml'
 require 'nokogiri/xslt'
 require 'nokogiri/html'
@@ -7,17 +15,8 @@ require 'nokogiri/css'
 require 'nokogiri/html/builder'
 require 'nokogiri/hpricot'
 
-# Modify the PATH on windows so that the external DLLs will get loaded.
-ENV['PATH'] = [File.expand_path(
-  File.join(File.dirname(__FILE__), "..", "ext", "nokogiri")
-), ENV['PATH']].compact.join(';') if RUBY_PLATFORM =~ /mswin/i
-
-require 'nokogiri/native' unless RUBY_PLATFORM =~ /java/
-
 module Nokogiri
   class << self
-    attr_accessor :error_handler
-
     ###
     # Parse an HTML or XML document.  +string+ contains the document.
     def parse string, url = nil, encoding = nil, options = nil
@@ -33,7 +32,7 @@ module Nokogiri
 
     def make input = nil, opts = {}, &blk
       if input
-        Nokogiri::XML::Node.new_from_str(input)
+        Nokogiri::HTML.fragment(input).children.first
       else
         Nokogiri(&blk)
       end
@@ -58,14 +57,12 @@ module Nokogiri
       Nokogiri(*args, &block).slop!
     end
   end
-
-  self.error_handler = lambda { |syntax_error| }  
 end
 
 def Nokogiri(*args, &block)
   if block_given?
     builder = Nokogiri::HTML::Builder.new(&block)
-    return builder.doc
+    return builder.doc.root
   else
     Nokogiri.parse(*args)
   end