libxml-ruby 0.9.7 → 0.9.8

data/ext/libxml/ruby_xml_node.h

@@ -1,4 +1,4 @@
-/* $Id: ruby_xml_node.h 666 2008-12-07 00:16:50Z cfis $ */
+/* $Id: ruby_xml_node.h 693 2008-12-13 22:53:32Z cfis $ */
 
 /* Please see the LICENSE file for copyright and distribution information */
 
@@ -9,6 +9,6 @@ extern VALUE cXMLNode;
 
 void ruby_init_xml_node(void);
 void rxml_node_mark_common(xmlNodePtr xnode);
-VALUE rxml_node_wrap(VALUE klass, xmlNodePtr xnode);
+VALUE rxml_node_wrap(xmlNodePtr xnode);
 VALUE check_string_or_symbol(VALUE val);
 #endif

data/ext/libxml/ruby_xml_parser.c

@@ -1,14 +1,10 @@
-/* $Id: ruby_xml_parser.c 650 2008-11-30 03:40:22Z cfis $ */
+/* $Id: ruby_xml_parser.c 737 2009-01-23 01:23:08Z walltndr $ */
 
 /* 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
  *
@@ -24,71 +20,43 @@ static ID CONTEXT_ATTR;
  *
  * Using the parser is simple:
  *
- *   parser = XML::Parser.new
- *   parser.file = 'my_file'
+ *   parser = XML::Parser.file('my_file')
  *   doc = parser.parse
  *
- * You can also parse strings (see XML::Parser.string) and io objects (see
+ * You can also parse documents (see XML::Parser.document), 
+ * strings (see XML::Parser.string) and io objects (see
  * XML::Parser.io).
  */
 
+VALUE cXMLParser;
+static ID CONTEXT_ATTR;
+
 /*
  * call-seq:
- *    parser.initialize -> parser
+ *    parser.initialize(context) -> XML::Parser
  *
- * Initiliazes instance of parser.
+ * Creates a new XML::Parser from the specified 
+ * XML::Parser::Context.
  */
-static VALUE rxml_parser_initialize(VALUE self)
+static VALUE rxml_parser_initialize(int argc, VALUE *argv, 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;
-}
+  VALUE context = Qnil;
 
-static xmlParserCtxtPtr rxml_parser_filename_ctxt(VALUE input)
-{
-  xmlParserCtxtPtr ctxt;
-  int retry_count = 0;
-  VALUE filename = rb_ivar_get(input, FILE_ATTR);
+  rb_scan_args(argc, argv, "01", &context);
 
-  retry: ctxt = xmlCreateFileParserCtxt(StringValuePtr(filename));
-  if (ctxt == NULL)
+  if (context == Qnil)
   {
-    if ((errno == EMFILE || errno == ENFILE) && retry_count == 0)
-    {
-      retry_count++;
-      rb_gc();
-      goto retry;
-    }
-    else
-    {
-      rb_raise(rb_eIOError, StringValuePtr(filename));
-    }
+    rb_warn("Passing no parameters to XML::Parser.new is deprecated.  Pass an instance of XML::Parser::Context instead.");
+    context = rb_class_new_instance(0, NULL, cXMLParserContext);
   }
 
-  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);
+  rb_ivar_set(self, CONTEXT_ATTR, context);
+  return self;
 }
 
 /*
  * call-seq:
- *    parser.parse -> document
+ *    parser.parse -> XML::Document
  *
  * Parse the input XML and create an XML::Document with
  * it's content. If an error occurs, XML::Parser::ParseError
@@ -97,33 +65,14 @@ static xmlParserCtxtPtr rxml_parser_io_ctxt(VALUE input)
 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);
+  VALUE context = rb_ivar_get(self, CONTEXT_ATTR);
+  
+  Data_Get_Struct(context, xmlParserCtxt, ctxt);
 
-  if (xmlParseDocument(ctxt) == -1 || !ctxt->wellFormed)
+  if ((xmlParseDocument(ctxt) == -1 || !ctxt->wellFormed) && ! ctxt->recovery)
   {
-    xmlFreeDoc(ctxt->myDoc);
+    if (ctxt->myDoc)
+      xmlFreeDoc(ctxt->myDoc);
     rxml_raise(&ctxt->lastError);
   }
 
@@ -141,12 +90,11 @@ 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, "initialize", rxml_parser_initialize, -1);
   rb_define_method(cXMLParser, "parse", rxml_parser_parse, 0);
 }

data/ext/libxml/ruby_xml_parser.h

@@ -1,4 +1,4 @@
-/* $Id: ruby_xml_parser.h 666 2008-12-07 00:16:50Z cfis $ */
+/* $Id: ruby_xml_parser.h 711 2009-01-20 07:17:15Z cfis $ */
 
 /* Please see the LICENSE file for copyright and distribution information */
 

data/ext/libxml/ruby_xml_parser_context.c

@@ -1,4 +1,4 @@
-/* $Id: ruby_xml_parser_context.c 659 2008-12-01 17:08:58Z cfis $ */
+/* $Id: ruby_xml_parser_context.c 750 2009-01-24 21:16:41Z cfis $ */
 
 /* Please see the LICENSE file for copyright and distribution information */
 
@@ -16,16 +16,164 @@ VALUE cXMLParserContext;
 
 static void rxml_parser_context_free(xmlParserCtxtPtr ctxt)
 {
-  if (ctxt != NULL)
+  xmlFreeParserCtxt(ctxt);
+}
+
+static VALUE rxml_parser_context_wrap(xmlParserCtxtPtr ctxt)
+{
+  return Data_Wrap_Struct(cXMLParserContext, NULL, rxml_parser_context_free, ctxt);
+}
+
+
+static VALUE rxml_parser_context_alloc(VALUE klass)
+{
+  xmlParserCtxtPtr ctxt = xmlNewParserCtxt();
+  return Data_Wrap_Struct(klass, NULL, rxml_parser_context_free, ctxt);
+}
+
+/* call-seq:
+ *    XML::Parser::Context.document(document) -> XML::Parser::Context
+ *
+ * Creates a new parser context based on the specified document.
+ *
+ * Parameters:
+ *
+ *  document - An XML::Document instance.
+ */
+static VALUE rxml_parser_context_document(VALUE klass, VALUE document)
+{
+  xmlParserCtxtPtr ctxt;
+  xmlDocPtr xdoc;
+  xmlChar *buffer; 
+  int length;
+
+  if (rb_obj_is_kind_of(document, cXMLDocument) == Qfalse)
+    rb_raise(rb_eTypeError, "Must pass an XML::Document object");
+
+  Data_Get_Struct(document, xmlDoc, xdoc);
+  xmlDocDumpFormatMemoryEnc(xdoc, &buffer, &length, xdoc->encoding, 0);
+
+  ctxt = xmlCreateDocParserCtxt(buffer);
+  return rxml_parser_context_wrap(ctxt);
+}
+
+/* call-seq:
+ *    XML::Parser::Context.file(file) -> XML::Parser::Context
+ *
+ * Creates a new parser context based on the specified file or uri.
+ *
+ * Parameters:
+ *
+ *  file - A filename or uri.
+*/
+static VALUE rxml_parser_context_file(VALUE klass, VALUE file)
+{
+  xmlParserCtxtPtr ctxt = xmlCreateURLParserCtxt(StringValuePtr(file), 0);
+  return rxml_parser_context_wrap(ctxt);
+}
+
+/* call-seq:
+ *    XML::Parser::Context.string(string) -> XML::Parser::Context
+ *
+ * Creates a new parser context based on the specified string.
+ *
+ * Parameters:
+ *
+ *  string - A string that contains the data to parse.
+*/
+static VALUE rxml_parser_context_string(VALUE klass, VALUE string)
+{
+  xmlParserCtxtPtr ctxt;
+  Check_Type(string, T_STRING);
+
+  if (RSTRING_LEN(string) == 0)
+    rb_raise(rb_eArgError, "Must specify a string with one or more characters");
+
+  ctxt = xmlCreateMemoryParserCtxt(StringValuePtr(string),
+                                   RSTRING_LEN(string));
+
+  if (!ctxt)
+    rxml_raise(&xmlLastError);
+
+  return rxml_parser_context_wrap(ctxt);
+}
+
+/* call-seq:
+ *    XML::Parser::Context.io(io) -> XML::Parser::Context
+ *
+ * Creates a new parser context based on the specified io object.
+ *
+ * Parameters:
+ *
+ *  io - A ruby IO object.
+*/
+static VALUE rxml_parser_context_io(VALUE klass, VALUE io)
+{
+  xmlParserCtxtPtr ctxt;
+  xmlParserInputBufferPtr input;
+  xmlParserInputPtr stream;
+
+  input = xmlParserInputBufferCreateIO((xmlInputReadCallback) rxml_read_callback, NULL,
+                                       (void*)io, XML_CHAR_ENCODING_NONE);
+    
+  ctxt = xmlNewParserCtxt();
+  if (!ctxt)
+  {
+    xmlFreeParserInputBuffer(input);
+    rxml_raise(&xmlLastError);
+  }
+
+  stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
+
+  if (!stream)
+  {
+    xmlFreeParserInputBuffer(input);
     xmlFreeParserCtxt(ctxt);
+    rxml_raise(&xmlLastError);
+  }
+  inputPush(ctxt, stream);
+  return rxml_parser_context_wrap(ctxt);
+}
+
+/*
+ * call-seq:
+ *    context.base_uri -> "http:://libxml.org"
+ *
+ * Obtain the base url for this parser context.
+ */
+static VALUE rxml_parser_context_base_uri_get(VALUE self)
+{
+  xmlParserCtxtPtr ctxt;
+  Data_Get_Struct(self, xmlParserCtxt, ctxt);
+
+  if (ctxt->input && ctxt->input->filename)
+    return rb_str_new2(ctxt->input->filename);
+  else
+    return Qnil;
 }
 
-VALUE rxml_parser_context_wrap(xmlParserCtxtPtr ctxt)
+/*
+ * call-seq:
+ *    context.base_uri = "http:://libxml.org"
+ *
+ * Sets the base url for this parser context.
+ */
+static VALUE rxml_parser_context_base_uri_set(VALUE self, VALUE url)
 {
-  return Data_Wrap_Struct(cXMLParserContext, NULL, rxml_parser_context_free,
-      ctxt);
+  xmlParserCtxtPtr ctxt;
+  Data_Get_Struct(self, xmlParserCtxt, ctxt);
+
+  Check_Type(url, T_STRING);
+
+  if (ctxt->input && !ctxt->input->filename)
+  {
+    const xmlChar * xurl = StringValuePtr(url);
+    ctxt->input->filename = (char *) xmlStrdup(xurl);
+  }
+  return self;
 }
 
+
 /*
  * call-seq:
  *    context.data_directory -> "dir"
@@ -94,7 +242,7 @@ static VALUE rxml_parser_context_docbook_q(VALUE self)
 
 /*
  * call-seq:
- *    context.encoding -> "encoding"
+ *    context.encoding -> XML::Encoding::UTF_8
  *
  * Obtain the character encoding identifier used in
  * this context.
@@ -103,11 +251,36 @@ static VALUE rxml_parser_context_encoding_get(VALUE self)
 {
   xmlParserCtxtPtr ctxt;
   Data_Get_Struct(self, xmlParserCtxt, ctxt);
+  return INT2NUM(xmlParseCharEncoding(ctxt->encoding));
+}
+
+/*
+ * call-seq:
+ *    context.encoding = XML::Encoding::UTF_8
+ *
+ * Sets the character encoding for this context.
+ */
+static VALUE rxml_parser_context_encoding_set(VALUE self, VALUE encoding)
+{
+  xmlParserCtxtPtr ctxt;
+  int result;
+  const char* xencoding = xmlGetCharEncodingName((xmlCharEncoding)NUM2INT(encoding));
+  xmlCharEncodingHandlerPtr hdlr = xmlFindCharEncodingHandler(xencoding);
+  
+  if (!hdlr)
+    rb_raise(rb_eRuntimeError, "Unknown encoding: %s", encoding);
+
+  Data_Get_Struct(self, xmlParserCtxt, ctxt);
+  result = xmlSwitchToEncoding(ctxt, hdlr);
 
-  if (ctxt->encoding == NULL)
-    return (Qnil);
-  else
-    return (rb_str_new2((const char*) ctxt->encoding));
+  if (result != 0)
+    rxml_raise(&xmlLastError);
+
+  if (ctxt->encoding != NULL)
+    xmlFree((xmlChar *) ctxt->encoding);
+
+  ctxt->encoding = xmlStrdup((const xmlChar *) xencoding);
+  return self;
 }
 
 /*
@@ -293,7 +466,7 @@ static VALUE rxml_parser_context_node_get(VALUE self)
   if (ctxt->node == NULL)
     return (Qnil);
   else
-    return (rxml_node_wrap(cXMLNode, ctxt->node));
+    return (rxml_node_wrap(ctxt->node));
 }
 
 /*
@@ -324,6 +497,85 @@ static VALUE rxml_parser_context_num_chars_get(VALUE self)
   return (LONG2NUM(ctxt->nbChars));
 }
 
+
+/*
+ * call-seq:
+ *    context.options > XML::Parser::Options::NOENT
+ *
+ * Returns the parser options for this context.  Multiple
+ * options can be combined by using Bitwise OR (|).
+ */
+static VALUE rxml_parser_context_options_get(VALUE self)
+{
+  xmlParserCtxtPtr ctxt;
+  Data_Get_Struct(self, xmlParserCtxt, ctxt);
+
+  return INT2NUM(ctxt->options);
+}
+
+/*
+ * call-seq:
+ *    context.options = XML::Parser::Options::NOENT |
+                        XML::Parser::Options::NOCDATA
+ *
+ * Provides control over the execution of a parser.  Valid values 
+ * are the constants defined on XML::Parser::Options.  Multiple
+ * options can be combined by using Bitwise OR (|).
+ */
+static VALUE rxml_parser_context_options_set(VALUE self, VALUE options)
+{
+  int result;
+  xmlParserCtxtPtr ctxt;
+  Check_Type(options, T_FIXNUM);
+
+  Data_Get_Struct(self, xmlParserCtxt, ctxt);
+  result = xmlCtxtUseOptions(ctxt, NUM2INT(options));
+
+  return self;
+}
+
+/*
+ * call-seq:
+ *    context.recovery? -> (true|false)
+ *
+ * Determine whether recovery mode is enabled in this
+ * context.
+ */
+static VALUE rxml_parser_context_recovery_q(VALUE self)
+{
+  xmlParserCtxtPtr ctxt;
+  Data_Get_Struct(self, xmlParserCtxt, ctxt);
+
+  if (ctxt->recovery)
+    return (Qtrue);
+  else
+    return (Qfalse);
+}
+
+/*
+ * call-seq:
+ *    context.recovery = true|false
+ *
+ * Control whether recovery mode is enabled in this
+ * context.
+ */
+static VALUE rxml_parser_context_recovery_set(VALUE self, VALUE bool)
+{
+  xmlParserCtxtPtr ctxt;
+  Data_Get_Struct(self, xmlParserCtxt, ctxt);
+
+  if (TYPE(bool) == T_FALSE)
+  {
+    ctxt->recovery = 0;
+    return (Qfalse);
+  }
+  else
+  {
+    ctxt->recovery = 1;
+    return (Qtrue);
+  }
+}
+
 /*
  * call-seq:
  *    context.replace_entities? -> (true|false)
@@ -362,7 +614,7 @@ static VALUE rxml_parser_context_replace_entities_set(VALUE self, VALUE bool)
   else
   {
     ctxt->replaceEntities = 1;
-    return (Qfalse);
+    return (Qtrue);
   }
 }
 
@@ -589,16 +841,31 @@ static VALUE rxml_parser_context_well_formed_q(VALUE self)
     return (Qfalse);
 }
 
+// Rdoc needs to know 
+#ifdef RDOC_NEVER_DEFINED
+  mLibXML = rb_define_module("LibXML");
+  mXML = rb_define_module_under(mLibXML, "XML");
+  cXMLParser = rb_define_class_under(mXML, "Parser", rb_cObject);
+#endif
+
 void ruby_init_xml_parser_context(void)
 {
   cXMLParserContext = rb_define_class_under(cXMLParser, "Context", rb_cObject);
-  rb_undef_alloc_func(cXMLParserContext);
+  rb_define_alloc_func(cXMLParserContext, rxml_parser_context_alloc);
+
+  rb_define_singleton_method(cXMLParserContext, "document", rxml_parser_context_document, 1);
+  rb_define_singleton_method(cXMLParserContext, "file", rxml_parser_context_file, 1);
+  rb_define_singleton_method(cXMLParserContext, "io", rxml_parser_context_io, 1);
+  rb_define_singleton_method(cXMLParserContext, "string", rxml_parser_context_string, 1);
 
+  rb_define_method(cXMLParserContext, "base_uri", rxml_parser_context_base_uri_get, 0);
+  rb_define_method(cXMLParserContext, "base_uri=", rxml_parser_context_base_uri_set, 1);
   rb_define_method(cXMLParserContext, "data_directory", rxml_parser_context_data_directory_get, 0);
   rb_define_method(cXMLParserContext, "depth", rxml_parser_context_depth_get, 0);
   rb_define_method(cXMLParserContext, "disable_sax?", rxml_parser_context_disable_sax_q, 0);
   rb_define_method(cXMLParserContext, "docbook?", rxml_parser_context_docbook_q, 0);
   rb_define_method(cXMLParserContext, "encoding", rxml_parser_context_encoding_get, 0);
+  rb_define_method(cXMLParserContext, "encoding=", rxml_parser_context_encoding_set, 1);
   rb_define_method(cXMLParserContext, "errno", rxml_parser_context_errno_get, 0);
   rb_define_method(cXMLParserContext, "html?", rxml_parser_context_html_q, 0);
   rb_define_method(cXMLParserContext, "io_max_num_streams", rxml_parser_context_io_max_num_streams_get, 0);
@@ -612,6 +879,10 @@ void ruby_init_xml_parser_context(void)
   rb_define_method(cXMLParserContext, "node_depth", rxml_parser_context_node_depth_get, 0);
   rb_define_method(cXMLParserContext, "node_depth_max", rxml_parser_context_node_depth_max_get, 0);
   rb_define_method(cXMLParserContext, "num_chars", rxml_parser_context_num_chars_get, 0);
+  rb_define_method(cXMLParserContext, "options", rxml_parser_context_options_get, 0);
+  rb_define_method(cXMLParserContext, "options=", rxml_parser_context_options_set, 1);
+  rb_define_method(cXMLParserContext, "recovery?", rxml_parser_context_recovery_q, 0);
+  rb_define_method(cXMLParserContext, "recovery=", rxml_parser_context_recovery_set, 1);
   rb_define_method(cXMLParserContext, "replace_entities?", rxml_parser_context_replace_entities_q, 0);
   rb_define_method(cXMLParserContext, "replace_entities=", rxml_parser_context_replace_entities_set, 1);
   rb_define_method(cXMLParserContext, "space_depth", rxml_parser_context_space_depth_get, 0);