libxml-ruby 4.1.2 → 5.0.1

data/ext/libxml/ruby_xml_dtd.c

@@ -124,112 +124,118 @@ static VALUE rxml_dtd_type(VALUE self)
 
 /*
  * call-seq:
- *    XML::Dtd.new("DTD string") -> dtd
- *    XML::Dtd.new("public", "system") -> dtd
- *    XML::Dtd.new("name", "public", "system", document) -> external subset dtd
- *    XML::Dtd.new("name", "public", "system", document, false) -> internal subset dtd
- *    XML::Dtd.new("name", "public", "system", document, true) -> internal subset dtd
+ *    XML::Dtd.new(dtd_string) -> dtd
+ *    XML::Dtd.new(external_id, system_id) -> dtd
+ *    XML::Dtd.new(external_id, system_id, name, document, internal) -> dtd
  *
- * Create a new Dtd from the specified public and system
- * identifiers.
+ * Create a new Dtd from the specified public and system identifiers:
+ *   
+ *   * The first usage creates a DTD from a string and requires 1 parameter.
+ *   * The second usage loads and parses an external DTD and requires 2 parameters.
+ *   * The third usage creates a new internal or external DTD and requires 3 parameters and 2 optional parameters.
+ *     It then attaches the DTD to the specified document if it is not nil
+ * 
+ * Parameters:
+ * 
+ *   dtd_string - A string that contains a complete DTD
+ *   external_id - A string that specifies the DTD's external name. For example, "-//W3C//DTD XHTML 1.0 Transitional//EN"
+ *   system_id - A string that specififies the DTD's system name. For example, "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"
+ *   name - A string that specifies the DTD's name. For example "xhtml1".
+ *   document - A xml document.
+ *   internal - Boolean value indicating whether this is an internal or external DTD. Optional. If not specified
+ *              then external is assumed.
  */
 static VALUE rxml_dtd_initialize(int argc, VALUE *argv, VALUE self)
 {
-  VALUE external, system, dtd_string;
-  xmlParserInputBufferPtr buffer;
-  xmlCharEncoding enc = XML_CHAR_ENCODING_NONE;
-  xmlChar *new_string;
   xmlDtdPtr xdtd;
+  VALUE external, system;
 
-  // 1 argument -- string                            --> parsujeme jako dtd
-  // 2 arguments -- public, system                   --> bude se hledat
-  // 3 arguments -- public, system, name             --> creates an external subset (any parameter may be nil)
-  // 4 arguments -- public, system, name, doc        --> creates an external subset (any parameter may be nil)
-  // 5 arguments -- public, system, name, doc, true  --> creates an internal subset (all but last parameter may be nil)
   switch (argc)
   {
-  case 3:
-  case 4:
-  case 5: {
-      VALUE name, doc, internal;
-      const xmlChar *xname = NULL, *xpublic = NULL, *xsystem = NULL;
-      xmlDocPtr xdoc = NULL;
+      case 3:
+      case 4:
+      case 5:
+      {
+          const xmlChar *xname = NULL, *xpublic = NULL, *xsystem = NULL;
+          xmlDocPtr xdoc = NULL;
 
-      rb_scan_args(argc, argv, "32", &external, &system, &name, &doc, &internal);
+          VALUE name, doc, internal;
+          rb_scan_args(argc, argv, "32", &external, &system, &name, &doc, &internal);
 
-      if (external != Qnil) {
-        Check_Type(external, T_STRING);
-        xpublic = (const xmlChar*) StringValuePtr(external);
-      }
-      if (system != Qnil) {
-        Check_Type(system, T_STRING);
-        xsystem = (const xmlChar*) StringValuePtr(system);
-      }
-      if (name != Qnil) {
-        Check_Type(name, T_STRING);
-        xname = (const xmlChar*) StringValuePtr(name);
-      }
-      if (doc != Qnil) {
-        if (rb_obj_is_kind_of(doc, cXMLDocument) == Qfalse)
-          rb_raise(rb_eTypeError, "Must pass an LibXML::XML::Document object");
-        Data_Get_Struct(doc, xmlDoc, xdoc);
-      }
+          Check_Type(external, T_STRING);
+          xpublic = (const xmlChar*) StringValuePtr(external);
 
-      if (internal == Qnil || internal == Qfalse)
-        xdtd = xmlNewDtd(xdoc, xname, xpublic, xsystem);
-      else
-        xdtd = xmlCreateIntSubset(xdoc, xname, xpublic, xsystem);
+          Check_Type(system, T_STRING);
+          xsystem = (const xmlChar*) StringValuePtr(system);
 
-      if (xdtd == NULL)
-        rxml_raise(&xmlLastError);
+          Check_Type(name, T_STRING);
+          xname = (const xmlChar*) StringValuePtr(name);
 
-      /* Document will free this dtd now. */
-      RDATA(self)->dfree = NULL;
-      DATA_PTR(self) = xdtd;
+          if (doc != Qnil)
+          {
+            if (rb_obj_is_kind_of(doc, cXMLDocument) == Qfalse)
+              rb_raise(rb_eTypeError, "Must pass an LibXML::XML::Document object");
+            Data_Get_Struct(doc, xmlDoc, xdoc);
+          }
 
-      xmlSetTreeDoc((xmlNodePtr) xdtd, xdoc);
-    }
-    break;
+          if (internal == Qnil || internal == Qfalse)
+            xdtd = xmlNewDtd(xdoc, xname, xpublic, xsystem);
+          else
+            xdtd = xmlCreateIntSubset(xdoc, xname, xpublic, xsystem);
 
-  case 2:
-    rb_scan_args(argc, argv, "20", &external, &system);
+          if (xdtd == NULL)
+            rxml_raise(xmlGetLastError());
 
-    Check_Type(external, T_STRING);
-    Check_Type(system, T_STRING);
+          /* The document will free the dtd so Ruby should not */
+          RDATA(self)->dfree = NULL;
+          DATA_PTR(self) = xdtd;
 
-    xdtd = xmlParseDTD((xmlChar*) StringValuePtr(external),
-        (xmlChar*) StringValuePtr(system));
+          xmlSetTreeDoc((xmlNodePtr) xdtd, xdoc);
+        }
+        break;
 
-    if (xdtd == NULL)
-      rxml_raise(&xmlLastError);
+      case 2:
+      {
+        rb_scan_args(argc, argv, "20", &external, &system);
 
-    DATA_PTR(self) = xdtd;
+        Check_Type(external, T_STRING);
+        Check_Type(system, T_STRING);
 
-    xmlSetTreeDoc((xmlNodePtr) xdtd, NULL);
-    break;
+        xdtd = xmlParseDTD((xmlChar*) StringValuePtr(external), (xmlChar*) StringValuePtr(system));
 
-  case 1:
-    rb_scan_args(argc, argv, "10", &dtd_string);
-    Check_Type(dtd_string, T_STRING);
+        if (xdtd == NULL)
+          rxml_raise(xmlGetLastError());
 
-    /* Note that buffer is freed by xmlParserInputBufferPush*/
-    buffer = xmlAllocParserInputBuffer(enc);
-    new_string = xmlStrdup((xmlChar*) StringValuePtr(dtd_string));
-    xmlParserInputBufferPush(buffer, xmlStrlen(new_string),
-        (const char*) new_string);
+        DATA_PTR(self) = xdtd;
 
-    xdtd = xmlIOParseDTD(NULL, buffer, enc);
+        xmlSetTreeDoc((xmlNodePtr) xdtd, NULL);
+        break;
+      }
+      case 1:
+      {
+        VALUE dtd_string;
+        rb_scan_args(argc, argv, "10", &dtd_string);
+        Check_Type(dtd_string, T_STRING);
 
-    if (xdtd == NULL)
-      rxml_raise(&xmlLastError);
+        /* Note that buffer is freed by xmlParserInputBufferPush*/
+        xmlCharEncoding enc = XML_CHAR_ENCODING_NONE;
+        xmlParserInputBufferPtr buffer = xmlAllocParserInputBuffer(enc);
+        xmlChar *new_string = xmlStrdup((xmlChar*) StringValuePtr(dtd_string));
+        xmlParserInputBufferPush(buffer, xmlStrlen(new_string),
+            (const char*) new_string);
 
-    xmlFree(new_string);
+        xdtd = xmlIOParseDTD(NULL, buffer, enc);
 
-    DATA_PTR(self) = xdtd;
-    break;
+        if (xdtd == NULL)
+          rxml_raise(xmlGetLastError());
 
-  default:
-    rb_raise(rb_eArgError, "wrong number of arguments");
+        xmlFree(new_string);
+
+        DATA_PTR(self) = xdtd;
+        break;
+      }
+      default:
+        rb_raise(rb_eArgError, "wrong number of arguments");
   }
 
   return self;

data/ext/libxml/ruby_xml_encoding.h

@@ -1,18 +1,20 @@
-/* Please see the LICENSE file for copyright and distribution information */
-
-#ifndef __RXML_ENCODING__
-#define __RXML_ENCODING__
-
-#include <ruby/encoding.h>
-
-extern VALUE mXMLEncoding;
-
-void rxml_init_encoding();
-
-VALUE rxml_new_cstr(const xmlChar* xstr, const xmlChar* xencoding);
-VALUE rxml_new_cstr_len(const xmlChar* xstr, const long length, const xmlChar* xencoding);
-
-rb_encoding* rxml_xml_encoding_to_rb_encoding(VALUE klass, xmlCharEncoding xmlEncoding);
-rb_encoding* rxml_figure_encoding(const xmlChar* xencoding);
-
-#endif
+/* Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RXML_ENCODING__
+#define __RXML_ENCODING__
+
+#include <ruby/encoding.h>
+#include <libxml/encoding.h>
+#include <libxml/xmlstring.h>
+
+extern VALUE mXMLEncoding;
+
+void rxml_init_encoding(void);
+
+VALUE rxml_new_cstr(const xmlChar* xstr, const xmlChar* xencoding);
+VALUE rxml_new_cstr_len(const xmlChar* xstr, const long length, const xmlChar* xencoding);
+
+rb_encoding* rxml_xml_encoding_to_rb_encoding(VALUE klass, xmlCharEncoding xmlEncoding);
+rb_encoding* rxml_figure_encoding(const xmlChar* xencoding);
+
+#endif

data/ext/libxml/ruby_xml_error.c

@@ -50,7 +50,7 @@ static VALUE rxml_error_get_handler(VALUE self)
   return block;
 }
 
-VALUE rxml_error_wrap(xmlErrorPtr xerror)
+VALUE rxml_error_wrap(const xmlError *xerror)
 {
   VALUE result = Qnil;
 
@@ -97,7 +97,7 @@ VALUE rxml_error_wrap(xmlErrorPtr xerror)
 }
 
 /* Hook that receives xml error message */
-static void structuredErrorFunc(void *userData, xmlErrorPtr xerror)
+static void structuredErrorFunc(void *userData, const xmlError *xerror)
 {
   VALUE error = rxml_error_wrap(xerror);
 
@@ -158,11 +158,14 @@ static VALUE rxml_error_reset_handler(VALUE self)
   return self;
 }
 
-NORETURN(void rxml_raise(xmlErrorPtr xerror))
+void rxml_raise(const xmlError *xerror)
 {
-  /* Wrap error up as Ruby object and send it off to ruby */
-  VALUE error = rxml_error_wrap(xerror);
-  rb_exc_raise(error);
+  if (xerror)
+  {
+    /* Wrap error up as Ruby object and send it off to ruby */
+    VALUE error = rxml_error_wrap(xerror);
+    rb_exc_raise(error);
+  }
 }
 
 void rxml_init_error(void)

data/ext/libxml/ruby_xml_error.h

@@ -8,7 +8,7 @@
 extern VALUE eXMLError;
 
 void rxml_init_error(void);
-VALUE rxml_error_wrap(xmlErrorPtr xerror);
-NORETURN(void rxml_raise(xmlErrorPtr xerror));
+VALUE rxml_error_wrap(const xmlError *xerror);
+void rxml_raise(const xmlError *xerror);
 
 #endif

data/ext/libxml/ruby_xml_html_parser_context.c

@@ -146,19 +146,23 @@ static VALUE rxml_html_parser_context_wrap(htmlParserCtxtPtr ctxt)
  *
  * Parameters:
  *
- *  file - A filename or uri.
+ *  file - A filename or uri
+ *  options - A or'ed together list of LibXML::XML::HTMLParser::Options values
 */
-static VALUE rxml_html_parser_context_file(VALUE klass, VALUE file)
+static VALUE rxml_html_parser_context_file(int argc, VALUE* argv, VALUE klass)
 {
+  VALUE file, options;
+  rb_scan_args(argc, argv, "11", &file, &options);
+
   htmlParserCtxtPtr ctxt = htmlCreateFileParserCtxt(StringValuePtr(file), NULL);
   if (!ctxt)
-    rxml_raise(&xmlLastError);
+    rxml_raise(xmlGetLastError());
 
   /* This is annoying, but xmlInitParserCtxt (called indirectly above) and 
      xmlCtxtUseOptionsInternal (called below) initialize slightly different
      context options, in particular XML_PARSE_NODICT which xmlInitParserCtxt
      sets to 0 and xmlCtxtUseOptionsInternal sets to 1.  So we have to call both. */
-  htmlCtxtUseOptions(ctxt, rxml_libxml_default_options());
+  htmlCtxtUseOptions(ctxt, options == Qnil ? 0 : NUM2INT(options));
 
   return rxml_html_parser_context_wrap(ctxt);
 }
@@ -170,10 +174,14 @@ static VALUE rxml_html_parser_context_file(VALUE klass, VALUE file)
  *
  * Parameters:
  *
- *  io - A ruby IO object.
+ *  io - A ruby IO object
+ *  options - A or'ed together list of LibXML::XML::HTMLParser::Options values
 */
-static VALUE rxml_html_parser_context_io(VALUE klass, VALUE io)
+static VALUE rxml_html_parser_context_io(int argc, VALUE* argv, VALUE klass)
 {
+  VALUE io, options;
+  rb_scan_args(argc, argv, "11", &io, &options);
+
   VALUE result;
   htmlParserCtxtPtr ctxt;
   xmlParserInputBufferPtr input;
@@ -189,14 +197,14 @@ static VALUE rxml_html_parser_context_io(VALUE klass, VALUE io)
   if (!ctxt)
   {
     xmlFreeParserInputBuffer(input);
-    rxml_raise(&xmlLastError);
+    rxml_raise(xmlGetLastError());
   }
 
   /* This is annoying, but xmlInitParserCtxt (called indirectly above) and 
      xmlCtxtUseOptionsInternal (called below) initialize slightly different
      context options, in particular XML_PARSE_NODICT which xmlInitParserCtxt
      sets to 0 and xmlCtxtUseOptionsInternal sets to 1.  So we have to call both. */
-  htmlCtxtUseOptions(ctxt, rxml_libxml_default_options());
+  htmlCtxtUseOptions(ctxt, options == Qnil ? 0 : NUM2INT(options));
 
   stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
 
@@ -204,7 +212,7 @@ static VALUE rxml_html_parser_context_io(VALUE klass, VALUE io)
   {
     xmlFreeParserInputBuffer(input);
     xmlFreeParserCtxt(ctxt);
-    rxml_raise(&xmlLastError);
+    rxml_raise(xmlGetLastError());
   }
   inputPush(ctxt, stream);
   result = rxml_html_parser_context_wrap(ctxt);
@@ -222,29 +230,35 @@ static VALUE rxml_html_parser_context_io(VALUE klass, VALUE io)
  *
  * Parameters:
  *
- *  string - A string that contains the data to parse.
+ *  string - A string that contains the data to parse
+ *  options - A or'ed together list of LibXML::XML::HTMLParser::Options values
 */
-static VALUE rxml_html_parser_context_string(VALUE klass, VALUE string)
+static VALUE rxml_html_parser_context_string(int argc, VALUE* argv, VALUE klass)
 {
-  htmlParserCtxtPtr ctxt;
+  VALUE string, options;
+  rb_scan_args(argc, argv, "11", &string, &options);
+
   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),
+  htmlParserCtxtPtr ctxt = xmlCreateMemoryParserCtxt(StringValuePtr(string),
                                    (int)RSTRING_LEN(string));
   if (!ctxt)
-    rxml_raise(&xmlLastError);
+    rxml_raise(xmlGetLastError());
 
   /* This is annoying, but xmlInitParserCtxt (called indirectly above) and 
      xmlCtxtUseOptionsInternal (called below) initialize slightly different
      context options, in particular XML_PARSE_NODICT which xmlInitParserCtxt
      sets to 0 and xmlCtxtUseOptionsInternal sets to 1.  So we have to call both. */
-  htmlCtxtUseOptions(ctxt, rxml_libxml_default_options());
+  htmlCtxtUseOptions(ctxt, options == Qnil ? 0 : NUM2INT(options));
 
-  if (ctxt->sax != NULL)
-    memcpy(ctxt->sax, &htmlDefaultSAXHandler, sizeof(xmlSAXHandlerV1));
+  // Setup sax handler
+  // TODO - there must be a better way? The sax handler is initialized for XML, but we want
+  // to use HTML
+  memset(ctxt->sax, 0, sizeof(xmlSAXHandler));
+  xmlSAX2InitHtmlDefaultSAXHandler(ctxt->sax);
   
   return rxml_html_parser_context_wrap(ctxt);
 }
@@ -288,7 +302,7 @@ static VALUE rxml_html_parser_context_disable_cdata_set(VALUE self, VALUE value)
   if (value)
     ctxt->sax->cdataBlock = NULL;
   else
-    ctxt->sax->cdataBlock = htmlDefaultSAXHandler.cdataBlock;
+    ctxt->sax->cdataBlock = xmlSAX2CDataBlock;
 
   return value;
 }
@@ -328,9 +342,9 @@ void rxml_init_html_parser_context(void)
   IO_ATTR = ID2SYM(rb_intern("@io"));
   cXMLHtmlParserContext = rb_define_class_under(cXMLHtmlParser, "Context", cXMLParserContext);
 
-  rb_define_singleton_method(cXMLHtmlParserContext, "file", rxml_html_parser_context_file, 1);
-  rb_define_singleton_method(cXMLHtmlParserContext, "io", rxml_html_parser_context_io, 1);
-  rb_define_singleton_method(cXMLHtmlParserContext, "string", rxml_html_parser_context_string, 1);
+  rb_define_singleton_method(cXMLHtmlParserContext, "file", rxml_html_parser_context_file, -1);
+  rb_define_singleton_method(cXMLHtmlParserContext, "io", rxml_html_parser_context_io, -1);
+  rb_define_singleton_method(cXMLHtmlParserContext, "string", rxml_html_parser_context_string, -1);
   rb_define_method(cXMLHtmlParserContext, "close", rxml_html_parser_context_close, 0);
   rb_define_method(cXMLHtmlParserContext, "disable_cdata=", rxml_html_parser_context_disable_cdata_set, 1);
   rb_define_method(cXMLHtmlParserContext, "options=", rxml_html_parser_context_options_set, 1);

data/ext/libxml/ruby_xml_namespace.c

@@ -58,9 +58,6 @@ static VALUE rxml_namespace_initialize(VALUE self, VALUE node, VALUE prefix,
   xmlPrefix = NIL_P(prefix) ? NULL : (xmlChar *)StringValuePtr(prefix);
   xns = xmlNewNs(xnode, (xmlChar*) StringValuePtr(href), xmlPrefix);
 
-  if (!xns)
-    rxml_raise(&xmlLastError);
-
   DATA_PTR(self) = xns;
   return self;
 }