libxml-ruby 0.9.3 → 0.9.4

data/ext/libxml/ruby_xml_html_parser.c

@@ -1,4 +1,4 @@
-/* $Id: ruby_xml_html_parser.c 621 2008-11-22 10:17:09Z cfis $ */
+/* $Id: ruby_xml_html_parser.c 630 2008-11-24 06:53:01Z cfis $ */
 
 /* Please see the LICENSE file for copyright and distribution information */
 
@@ -6,8 +6,6 @@
 
 VALUE cXMLHTMLParser;
 static ID INPUT_ATTR;
-static ID CONTEXT_ATTR;
-
 
 /*
 * Document-class: LibXML::XML::HTMLParser
@@ -28,34 +26,48 @@ static VALUE
 rxml_html_parser_initialize(VALUE self) {
   VALUE input = rb_class_new_instance(0, NULL, cXMLInput);
   rb_iv_set(self, "@input", input);
-  rb_iv_set(self, "@context", Qnil);
   return self;
 }
 
-static htmlParserCtxtPtr
-rxml_html_parser_file_ctxt(VALUE input) {
+static htmlDocPtr
+rxml_html_parser_read_file(VALUE input) {
   VALUE file = rb_ivar_get(input, FILE_ATTR);
   VALUE encoding = rb_ivar_get(input, ENCODING_ATTR);
-  VALUE encodingStr = rxml_input_encoding_to_s(Qnil, encoding);
+  VALUE encoding_str = rxml_input_encoding_to_s(Qnil, encoding);
+  char *xencoding_str = (encoding_str == Qnil ? NULL : StringValuePtr(encoding_str));
+  int options = 0;
 
-  return htmlCreateFileParserCtxt(StringValuePtr(file), StringValuePtr(encodingStr));
+  return htmlReadFile(StringValuePtr(file), xencoding_str, options);
 }
 
-static htmlParserCtxtPtr
-rxml_html_parser_str_ctxt(VALUE input) {
-  VALUE data = rb_ivar_get(input, STRING_ATTR);
-  return htmlCreateMemoryParserCtxt(StringValuePtr(data), RSTRING_LEN(data));
+static htmlDocPtr
+rxml_html_parser_read_string(VALUE input) {
+  VALUE string = rb_ivar_get(input, STRING_ATTR);
+  VALUE base_url = rb_ivar_get(input, BASE_URL_ATTR);
+  char *xbase_url = (base_url == Qnil ? NULL : StringValuePtr(base_url));
+  VALUE encoding = rb_ivar_get(input, ENCODING_ATTR);
+  VALUE encoding_str = rxml_input_encoding_to_s(Qnil, encoding);
+  char *xencoding_str = (encoding_str == Qnil ? NULL : StringValuePtr(encoding_str));
+  int options = 0;
+
+  return htmlReadMemory(StringValuePtr(string), RSTRING_LEN(string),
+                        xbase_url, xencoding_str, options);
 }
 
-/*static htmlDocPtr
-rxml_html_parser_io_ctxt(VALUE input) {
+static htmlDocPtr
+rxml_html_parser_read_io(VALUE input) {
   VALUE io = rb_ivar_get(input, IO_ATTR);
+  VALUE base_url = rb_ivar_get(input, BASE_URL_ATTR);
+  char *xbase_url = (base_url == Qnil ? NULL : StringValuePtr(base_url));
   VALUE encoding = rb_ivar_get(input, ENCODING_ATTR);
-  xmlCharEncoding xmlEncoding = NUM2INT(encoding);
-
+  VALUE encoding_str = rxml_input_encoding_to_s(Qnil, encoding);
+  char *xencoding_str = (encoding_str == Qnil ? NULL : StringValuePtr(encoding_str));
+  int options = 0;
+  
   return htmlReadIO((xmlInputReadCallback) rxml_read_callback, NULL,
-        				     io, NULL, xmlEncoding);
-}*/
+        				     (void *)io, 
+                     xbase_url, xencoding_str, options);
+}
 
 /*
  * call-seq:
@@ -67,35 +79,22 @@ rxml_html_parser_io_ctxt(VALUE input) {
  */
 static VALUE
 rxml_html_parser_parse(VALUE self) {
-  xmlParserCtxtPtr ctxt;
-  VALUE context;
   VALUE input = rb_ivar_get(self, INPUT_ATTR);
-
-  context = rb_ivar_get(self, CONTEXT_ATTR);
-  if (context != Qnil)
-    rb_raise(rb_eRuntimeError, "You cannot parse a data source twice");
+  htmlDocPtr xdoc;
 
   if (rb_ivar_get(input, FILE_ATTR) != Qnil)
-    ctxt = rxml_html_parser_file_ctxt(input);
+    xdoc = rxml_html_parser_read_file(input);
   else if (rb_ivar_get(input, STRING_ATTR) != Qnil)
-    ctxt = rxml_html_parser_str_ctxt(input);
-  /*else if (rb_ivar_get(input, IO_ATTR) != Qnil)
-    ctxt = rxml_html_parser_io_ctxt(input);
-  else if (rb_ivar_get(input, DOCUMENT_ATTR) != Qnil)
-    ctxt = rxml_html_parser_parse_document(input);*/
+    xdoc = rxml_html_parser_read_string(input);
+  else if (rb_ivar_get(input, IO_ATTR) != Qnil)
+    xdoc = rxml_html_parser_read_io(input);
   else
     rb_raise(rb_eArgError, "You must specify a parser data source");
   
-  if (!ctxt)
+  if (!xdoc)
     rxml_raise(&xmlLastError);
 
-  context = rxml_parser_context_wrap(ctxt);
-  rb_ivar_set(self, CONTEXT_ATTR, context);
- 
-  if (htmlParseDocument(ctxt) == -1)
-    rxml_raise(&ctxt->lastError);
-
-  return rxml_document_wrap(ctxt->myDoc);
+  return rxml_document_wrap(xdoc);
 }
 
 // Rdoc needs to know 
@@ -107,13 +106,11 @@ rxml_html_parser_parse(VALUE self) {
 void
 ruby_init_html_parser(void) {	
   INPUT_ATTR = rb_intern("@input");
-  CONTEXT_ATTR = rb_intern("@context");
 
   cXMLHTMLParser = rb_define_class_under(mXML, "HTMLParser", rb_cObject);
  
   /* Atributes */
   rb_define_attr(cXMLHTMLParser, "input", 1, 0);
-  rb_define_attr(cXMLHTMLParser, "context", 1, 0);
 
   /* Instance methods */
   rb_define_method(cXMLHTMLParser, "initialize", rxml_html_parser_initialize, 0);

data/ext/libxml/ruby_xml_input.c

@@ -20,7 +20,12 @@ VALUE cXMLInput;
 * but instead will use the various Document and Parser apis.
 * For example:
 *
-*   document = Document.file('my_file') 
+*   parser = XML::Parser.file('my_file') 
+*   parser = XML::Parser.string('<myxml/>') 
+*   parser = XML::Parser.io(File.open('my_file')) 
+*
+*  XML::HTMLParser, XML::Reader, XML::SaxParser and
+*  XML::Document work in the same way.
 *
 * LibXML converts all data sources to UTF8 internally before 
 * processing them.  By default, LibXML will determine a data
@@ -52,11 +57,10 @@ VALUE cXMLInput;
 *   document.encoding = document
 *   doc << XML::Node.new */
 
-
+ID BASE_URL_ATTR;
 ID ENCODING_ATTR;
 ID FILE_ATTR;
 ID STRING_ATTR;
-ID DOCUMENT_ATTR;
 ID IO_ATTR;
 
 static ID READ_METHOD;
@@ -204,9 +208,8 @@ static VALUE
 rxml_input_file_set(VALUE self, VALUE FILE) {
   Check_Type(FILE, T_STRING);
   rb_ivar_set(self, FILE_ATTR, FILE);
-  rb_ivar_set(self, STRING_ATTR, Qnil);
-  rb_ivar_set(self, DOCUMENT_ATTR, Qnil);
   rb_ivar_set(self, IO_ATTR, Qnil);
+  rb_ivar_set(self, STRING_ATTR, Qnil);
   return self;
 }
 
@@ -233,35 +236,8 @@ static VALUE
 rxml_input_string_set(VALUE self, VALUE string) {
   Check_Type(string, T_STRING);
   rb_ivar_set(self, FILE_ATTR, Qnil);
-  rb_ivar_set(self, STRING_ATTR, string);
-  rb_ivar_set(self, DOCUMENT_ATTR, Qnil);
-  rb_ivar_set(self, IO_ATTR, Qnil);
-  return self;
-}
-
-/*
- * call-seq:
- *    input.document -> "document"
- * 
- * Obtain the document this parser will read from.
- */
-static VALUE
-rxml_input_document_get(VALUE self) {
-  return rb_ivar_get(self, DOCUMENT_ATTR);
-}
-
-/*
- * call-seq:
- *    input.document = LibXML::XML::Document.new
- * 
- * Set the document this parser will read from.
- */
-static VALUE
-rxml_input_document_set(VALUE self, VALUE document) {
-  rb_ivar_set(self, FILE_ATTR, Qnil);
-  rb_ivar_set(self, STRING_ATTR, Qnil);
-  rb_ivar_set(self, DOCUMENT_ATTR, document);
   rb_ivar_set(self, IO_ATTR, Qnil);
+  rb_ivar_set(self, STRING_ATTR, string);
   return self;
 }
 
@@ -285,9 +261,8 @@ rxml_input_io_get(VALUE self) {
 static VALUE
 rxml_input_io_set(VALUE self, VALUE io) {
   rb_ivar_set(self, FILE_ATTR, Qnil);
-  rb_ivar_set(self, STRING_ATTR, Qnil);
-  rb_ivar_set(self, DOCUMENT_ATTR, Qnil);
   rb_ivar_set(self, IO_ATTR, io);
+  rb_ivar_set(self, STRING_ATTR, Qnil);
   return self;
 }
 
@@ -307,10 +282,12 @@ rxml_input_io_set(VALUE self, VALUE io) {
 
 void
 ruby_init_xml_input(void) {	
-  FILE_ATTR = rb_intern("@FILE");
-  STRING_ATTR = rb_intern("@string");
-  DOCUMENT_ATTR = rb_intern("@document");
+  BASE_URL_ATTR = rb_intern("@base_url");
+  ENCODING_ATTR = rb_intern("@encoding");
+  FILE_ATTR = rb_intern("@file");
   IO_ATTR = rb_intern("@io");
+  STRING_ATTR = rb_intern("@string");
+
   READ_METHOD = rb_intern("read");
 
   cXMLInput = rb_define_class_under(mXML, "Input", rb_cObject);
@@ -342,14 +319,14 @@ ruby_init_xml_input(void) {
   rb_define_const(cXMLInput, "EUC_JP", INT2NUM(XML_CHAR_ENCODING_EUC_JP));       /* EUC-JP */
   rb_define_const(cXMLInput, "ASCII", INT2NUM(XML_CHAR_ENCODING_ASCII));         /* pure ASCII */
 
+  rb_define_attr(cXMLInput, "base_url", 1, 1);
   rb_define_attr(cXMLInput, "encoding", 1, 1);
+
   rb_define_method(cXMLInput, "initialize", rxml_input_initialize, 0);
   rb_define_method(cXMLInput, "file", rxml_input_file_get, 0);
   rb_define_method(cXMLInput, "file=", rxml_input_file_set, 1);
   rb_define_method(cXMLInput, "string", rxml_input_string_get, 0);
   rb_define_method(cXMLInput, "string=", rxml_input_string_set, 1);
-  rb_define_method(cXMLInput, "document", rxml_input_document_get, 0);
-  rb_define_method(cXMLInput, "document=", rxml_input_document_set, 1);
   rb_define_method(cXMLInput, "io", rxml_input_io_get, 0);
   rb_define_method(cXMLInput, "io=", rxml_input_io_set, 1);
 }

data/ext/libxml/ruby_xml_input.h

@@ -7,11 +7,11 @@
 
 extern VALUE cXMLInput;
 
+extern ID BASE_URL_ATTR;
 extern ID ENCODING_ATTR;
 extern ID FILE_ATTR;
-extern ID STRING_ATTR;
-extern ID DOCUMENT_ATTR;
 extern ID IO_ATTR;
+extern ID STRING_ATTR;
 
 void ruby_init_xml_input();
 int rxml_read_callback(void *context, char *buffer, int len);

data/ext/libxml/ruby_xml_parser.c

@@ -1,151 +1,151 @@
-/* $Id: ruby_xml_parser.c 613 2008-11-21 08:39:51Z cfis $ */
-
-/* Please see the LICENSE file for copyright and distribution information */
-
-#include <stdarg.h>
-#include "ruby_libxml.h"
-
-VALUE cXMLParser;
-static ID INPUT_ATTR;
-static ID CONTEXT_ATTR;
-
-/*
- * Document-class: LibXML::XML::Parser
- *
- * The XML::Parser provides a tree based API for processing
- * xml documents, in contract to XML::Reader's stream
- * based api and XML::SaxParser callback based API.
- *
- * As a result, parsing a document creates an in-memory document object
- * that consist of any number of XML::Node instances.  This is simple
- * and powerful model, but has the major limitation that the size of 
- * the document that can be processed is limited by the amount of
- * memory available.  In such cases, it is better to use the XML::Reader.
- *
- * Using the parser is simple:
- *
- *   parser = XML::Parser.new
- *   parser.file = 'my_file'
- *   doc = parser.parse
- * 
- * You can also parse strings (see XML::Parser.string) and io objects (see 
- * XML::Parser.io).
- */
-
-/*
- * call-seq:
- *    parser.initialize -> parser
- * 
- * Initiliazes instance of parser.
- */
-static VALUE
-rxml_parser_initialize(VALUE self) {
-  VALUE input = rb_class_new_instance(0, NULL, cXMLInput);
-  rb_iv_set(self, "@input", input);
-  rb_iv_set(self, "@context", Qnil);
-  return self;
-}
-
-static xmlParserCtxtPtr
-rxml_parser_filename_ctxt(VALUE input) {
-  xmlParserCtxtPtr ctxt;
-  int retry_count = 0;
-  VALUE filename = rb_ivar_get(input, FILE_ATTR);
-  
-  retry:
-  ctxt = xmlCreateFileParserCtxt(StringValuePtr(filename));
-  if (ctxt == NULL) {
-    if ((errno == EMFILE || errno == ENFILE) && retry_count == 0) {
-      retry_count++;
-      rb_gc();
-      goto retry;
-    } else {
-      rb_raise(rb_eIOError, StringValuePtr(filename));
-    }
-  }
-
-  return ctxt;
-}
-
-static xmlParserCtxtPtr
-rxml_parser_str_ctxt(VALUE input) {
-  VALUE str = rb_ivar_get(input, STRING_ATTR);
-  return xmlCreateMemoryParserCtxt(StringValuePtr(str), RSTRING_LEN(str));
-}
-
-static xmlParserCtxtPtr
-rxml_parser_io_ctxt(VALUE input) {
-  VALUE io = rb_ivar_get(input, IO_ATTR);
-  VALUE encoding = rb_ivar_get(input, ENCODING_ATTR);
-  xmlCharEncoding xmlEncoding = NUM2INT(encoding);
-
-  return xmlCreateIOParserCtxt(NULL, NULL,
-	 			                      (xmlInputReadCallback) rxml_read_callback,
-				                      NULL, io, xmlEncoding);
-}
-
-
-/*
- * call-seq:
- *    parser.parse -> document
- * 
- * Parse the input XML and create an XML::Document with
- * it's content. If an error occurs, XML::Parser::ParseError
- * is thrown.
- */
-static VALUE
-rxml_parser_parse(VALUE self) {
-  xmlParserCtxtPtr ctxt;
-  VALUE context;
-  VALUE input = rb_ivar_get(self, INPUT_ATTR);
-
-  context = rb_ivar_get(self, CONTEXT_ATTR);
-  if (context != Qnil)
-    rb_raise(rb_eRuntimeError, "You cannot parse a data source twice");
-
-  if (rb_ivar_get(input, FILE_ATTR) != Qnil)
-    ctxt = rxml_parser_filename_ctxt(input);
-  else if (rb_ivar_get(input, STRING_ATTR) != Qnil)
-    ctxt = rxml_parser_str_ctxt(input);
-  /*else if (rb_ivar_get(input, DOCUMENT_ATTR) != Qnil)
-    ctxt = rxml_parser_parse_document(input);*/
-  else if (rb_ivar_get(input, IO_ATTR) != Qnil)
-    ctxt = rxml_parser_io_ctxt(input);
-  else
-    rb_raise(rb_eArgError, "You must specify a parser data source");
-  
-  if (!ctxt)
-    rxml_raise(&xmlLastError);
-
-  context = rxml_parser_context_wrap(ctxt);
-  rb_ivar_set(self, CONTEXT_ATTR, context);
- 
-  if (xmlParseDocument(ctxt) == -1 || !ctxt->wellFormed) {
-    xmlFreeDoc(ctxt->myDoc);
-    rxml_raise(&ctxt->lastError);
-  }
-
-  return rxml_document_wrap(ctxt->myDoc);
-}
-
-
-// Rdoc needs to know 
-#ifdef RDOC_NEVER_DEFINED
-  mLibXML = rb_define_module("LibXML");
-  mXML = rb_define_module_under(mLibXML, "XML");
-#endif
-
-void
-ruby_init_parser(void) {	
-  cXMLParser = rb_define_class_under(mXML, "Parser", rb_cObject);
-                 
-  /* Atributes */
-  INPUT_ATTR = rb_intern("@input");
-  CONTEXT_ATTR = rb_intern("@context");
-  rb_define_attr(cXMLParser, "input", 1, 0);
-  rb_define_attr(cXMLParser, "context", 1, 0);
-
-  /* Instance Methods */
-  rb_define_method(cXMLParser, "initialize", rxml_parser_initialize, 0);
-  rb_define_method(cXMLParser, "parse", rxml_parser_parse, 0);
-}
+/* $Id: ruby_xml_parser.c 630 2008-11-24 06:53:01Z cfis $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#include <stdarg.h>
+#include "ruby_libxml.h"
+
+VALUE cXMLParser;
+static ID INPUT_ATTR;
+static ID CONTEXT_ATTR;
+
+/*
+ * Document-class: LibXML::XML::Parser
+ *
+ * The XML::Parser provides a tree based API for processing
+ * xml documents, in contract to XML::Reader's stream
+ * based api and XML::SaxParser callback based API.
+ *
+ * As a result, parsing a document creates an in-memory document object
+ * that consist of any number of XML::Node instances.  This is simple
+ * and powerful model, but has the major limitation that the size of 
+ * the document that can be processed is limited by the amount of
+ * memory available.  In such cases, it is better to use the XML::Reader.
+ *
+ * Using the parser is simple:
+ *
+ *   parser = XML::Parser.new
+ *   parser.file = 'my_file'
+ *   doc = parser.parse
+ * 
+ * You can also parse strings (see XML::Parser.string) and io objects (see 
+ * XML::Parser.io).
+ */
+
+/*
+ * call-seq:
+ *    parser.initialize -> parser
+ * 
+ * Initiliazes instance of parser.
+ */
+static VALUE
+rxml_parser_initialize(VALUE self) {
+  VALUE input = rb_class_new_instance(0, NULL, cXMLInput);
+  rb_iv_set(self, "@input", input);
+  rb_iv_set(self, "@context", Qnil);
+  return self;
+}
+
+static xmlParserCtxtPtr
+rxml_parser_filename_ctxt(VALUE input) {
+  xmlParserCtxtPtr ctxt;
+  int retry_count = 0;
+  VALUE filename = rb_ivar_get(input, FILE_ATTR);
+  
+  retry:
+  ctxt = xmlCreateFileParserCtxt(StringValuePtr(filename));
+  if (ctxt == NULL) {
+    if ((errno == EMFILE || errno == ENFILE) && retry_count == 0) {
+      retry_count++;
+      rb_gc();
+      goto retry;
+    } else {
+      rb_raise(rb_eIOError, StringValuePtr(filename));
+    }
+  }
+
+  return ctxt;
+}
+
+static xmlParserCtxtPtr
+rxml_parser_str_ctxt(VALUE input) {
+  VALUE str = rb_ivar_get(input, STRING_ATTR);
+  return xmlCreateMemoryParserCtxt(StringValuePtr(str), RSTRING_LEN(str));
+}
+
+static xmlParserCtxtPtr
+rxml_parser_io_ctxt(VALUE input) {
+  VALUE io = rb_ivar_get(input, IO_ATTR);
+  VALUE encoding = rb_ivar_get(input, ENCODING_ATTR);
+  xmlCharEncoding xmlEncoding = NUM2INT(encoding);
+
+  return xmlCreateIOParserCtxt(NULL, NULL,
+	 			                      (xmlInputReadCallback) rxml_read_callback,
+				                      NULL, (void *)io, xmlEncoding);
+}
+
+
+/*
+ * call-seq:
+ *    parser.parse -> document
+ * 
+ * Parse the input XML and create an XML::Document with
+ * it's content. If an error occurs, XML::Parser::ParseError
+ * is thrown.
+ */
+static VALUE
+rxml_parser_parse(VALUE self) {
+  xmlParserCtxtPtr ctxt;
+  VALUE context;
+  VALUE input = rb_ivar_get(self, INPUT_ATTR);
+
+  context = rb_ivar_get(self, CONTEXT_ATTR);
+  if (context != Qnil)
+    rb_raise(rb_eRuntimeError, "You cannot parse a data source twice");
+
+  if (rb_ivar_get(input, FILE_ATTR) != Qnil)
+    ctxt = rxml_parser_filename_ctxt(input);
+  else if (rb_ivar_get(input, STRING_ATTR) != Qnil)
+    ctxt = rxml_parser_str_ctxt(input);
+  /*else if (rb_ivar_get(input, DOCUMENT_ATTR) != Qnil)
+    ctxt = rxml_parser_parse_document(input);*/
+  else if (rb_ivar_get(input, IO_ATTR) != Qnil)
+    ctxt = rxml_parser_io_ctxt(input);
+  else
+    rb_raise(rb_eArgError, "You must specify a parser data source");
+  
+  if (!ctxt)
+    rxml_raise(&xmlLastError);
+
+  context = rxml_parser_context_wrap(ctxt);
+  rb_ivar_set(self, CONTEXT_ATTR, context);
+ 
+  if (xmlParseDocument(ctxt) == -1 || !ctxt->wellFormed) {
+    xmlFreeDoc(ctxt->myDoc);
+    rxml_raise(&ctxt->lastError);
+  }
+
+  return rxml_document_wrap(ctxt->myDoc);
+}
+
+
+// Rdoc needs to know 
+#ifdef RDOC_NEVER_DEFINED
+  mLibXML = rb_define_module("LibXML");
+  mXML = rb_define_module_under(mLibXML, "XML");
+#endif
+
+void
+ruby_init_parser(void) {	
+  cXMLParser = rb_define_class_under(mXML, "Parser", rb_cObject);
+                 
+  /* Atributes */
+  INPUT_ATTR = rb_intern("@input");
+  CONTEXT_ATTR = rb_intern("@context");
+  rb_define_attr(cXMLParser, "input", 1, 0);
+  rb_define_attr(cXMLParser, "context", 1, 0);
+
+  /* Instance Methods */
+  rb_define_method(cXMLParser, "initialize", rxml_parser_initialize, 0);
+  rb_define_method(cXMLParser, "parse", rxml_parser_parse, 0);
+}