libxml-ruby 0.9.8 → 0.9.9

data/ext/libxml/ruby_xml_document.h

@@ -1,4 +1,4 @@
-/* $Id: ruby_xml_document.h 666 2008-12-07 00:16:50Z cfis $ */
+/* $Id: ruby_xml_document.h 758 2009-01-25 20:36:03Z cfis $ */
 
 /* Please see the LICENSE file for copyright and distribution information */
 
@@ -7,7 +7,7 @@
 
 extern VALUE cXMLDocument;
 
-void ruby_init_xml_document();
+void rxml_init_document();
 
 
 #if defined(_WIN32)

data/ext/libxml/ruby_xml_dtd.c

@@ -1,136 +1,257 @@
-#include "ruby_libxml.h"
-#include "ruby_xml_dtd.h"
-
-/*
- * Document-class: LibXML::XML::Dtd
- *
- * The XML::Dtd class is used to prepare DTD's for validation of xml
- * documents.
- *
- * DTDs can be created from a string or a pair of public and system identifiers.
- * Once a Dtd object is instantiated, an XML document can be validated by the
- * XML::Document#validate method providing the XML::Dtd object as parameeter.
- * The method will raise an exception if the document is
- * not valid.
- *
- * Basic usage:
- *
- *  # parse DTD
- *  dtd = XML::Dtd.new(<<EOF)
- *  <!ELEMENT root (item*) >
- *  <!ELEMENT item (#PCDATA) >
- *  EOF
- *
- *  # parse xml document to be validated
- *  instance = XML::Document.file('instance.xml')
- *
- *  # validate
- *  instance.validate(dtd)
- */
-
-VALUE cXMLDtd;
-
-void rxml_dtd_free(xmlDtdPtr xdtd)
-{
-  xmlFreeDtd(xdtd);
-}
-
-static VALUE rxml_dtd_alloc(VALUE klass)
-{
-  return Data_Wrap_Struct(klass, NULL, rxml_dtd_free, NULL);
-}
-
-VALUE rxml_dtd_wrap(xmlDtdPtr xdtd)
-{
-  VALUE result;
-
-  // This node is already wrapped
-  if (xdtd->_private != NULL)
-    return (VALUE) xdtd->_private;
-
-  result = Data_Wrap_Struct(cXMLDtd, NULL, NULL, xdtd);
-
-  xdtd->_private = (void*) result;
-
-  return result;
-}
-
-
-
-/*
- * call-seq:
- *    XML::Dtd.new("public system") -> dtd
- *    XML::Dtd.new("public", "system") -> dtd
- *
- * Create a new Dtd from the specified public and system
- * identifiers.
- */
-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;
-
-  // 1 argument -- string               --> parsujeme jako dtd
-  // 2 argumenty -- public, system      --> bude se hledat
-  switch (argc)
-  {
-  case 2:
-    rb_scan_args(argc, argv, "20", &external, &system);
-
-    Check_Type(external, T_STRING);
-    Check_Type(system, T_STRING);
-
-    xdtd = xmlParseDTD((xmlChar*) StringValuePtr(external),
-        (xmlChar*) StringValuePtr(system));
-
-    if (xdtd == NULL)
-      rxml_raise(&xmlLastError);
-
-    DATA_PTR(self) = xdtd;
-
-    xmlSetTreeDoc((xmlNodePtr) xdtd, NULL);
-    break;
-
-  case 1:
-    rb_scan_args(argc, argv, "10", &dtd_string);
-    Check_Type(dtd_string, T_STRING);
-
-    /* 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);
-
-    xdtd = xmlIOParseDTD(NULL, buffer, enc);
-
-    if (xdtd == NULL)
-      rxml_raise(&xmlLastError);
-
-    xmlFree(new_string);
-
-    DATA_PTR( self) = xdtd;
-    break;
-
-  default:
-    rb_raise(rb_eArgError, "wrong number of arguments (need 1 or 2)");
-  }
-
-  return self;
-}
-
-// Rdoc needs to know
-#ifdef RDOC_NEVER_DEFINED
-mLibXML = rb_define_module("LibXML");
-mXML = rb_define_module_under(mLibXML, "XML");
-#endif
-
-void ruby_init_xml_dtd()
-{
-  cXMLDtd = rb_define_class_under(mXML, "Dtd", rb_cObject);
-  rb_define_alloc_func(cXMLDtd, rxml_dtd_alloc);
-  rb_define_method(cXMLDtd, "initialize", rxml_dtd_initialize, -1);
-}
-
+#include "ruby_libxml.h"
+#include "ruby_xml_dtd.h"
+
+/*
+ * Document-class: LibXML::XML::Dtd
+ *
+ * The XML::Dtd class is used to prepare DTD's for validation of xml
+ * documents.
+ *
+ * DTDs can be created from a string or a pair of public and system identifiers.
+ * Once a Dtd object is instantiated, an XML document can be validated by the
+ * XML::Document#validate method providing the XML::Dtd object as parameeter.
+ * The method will raise an exception if the document is
+ * not valid.
+ *
+ * Basic usage:
+ *
+ *  # parse DTD
+ *  dtd = XML::Dtd.new(<<EOF)
+ *  <!ELEMENT root (item*) >
+ *  <!ELEMENT item (#PCDATA) >
+ *  EOF
+ *
+ *  # parse xml document to be validated
+ *  instance = XML::Document.file('instance.xml')
+ *
+ *  # validate
+ *  instance.validate(dtd)
+ */
+
+VALUE cXMLDtd;
+
+void rxml_dtd_free(xmlDtdPtr xdtd)
+{
+  /* Set _private to NULL so that we won't reuse the
+   same, freed, Ruby wrapper object later.*/
+  xdtd->_private = NULL;
+
+  if (xdtd->doc == NULL && xdtd->parent == NULL)
+    xmlFreeDtd(xdtd);
+}
+
+void rxml_dtd_mark(xmlDtdPtr xdtd)
+{
+  if (xdtd == NULL)
+    return;
+
+  if (xdtd->_private == NULL)
+  {
+    rb_warning("XmlNode is not bound! (%s:%d)", __FILE__, __LINE__);
+    return;
+  }
+
+  rxml_node_mark_common((xmlNodePtr) xdtd);
+}
+
+
+static VALUE rxml_dtd_alloc(VALUE klass)
+{
+  return Data_Wrap_Struct(klass, rxml_dtd_mark, rxml_dtd_free, NULL);
+}
+
+VALUE rxml_dtd_wrap(xmlDtdPtr xdtd)
+{
+  VALUE result;
+
+  // This node is already wrapped
+  if (xdtd->_private != NULL)
+    return (VALUE) xdtd->_private;
+
+  result = Data_Wrap_Struct(cXMLDtd, NULL, NULL, xdtd);
+
+  xdtd->_private = (void*) result;
+
+  return result;
+}
+
+/*
+ * call-seq:
+ *    dtd.external_id -> "string"
+ *
+ * Obtain this dtd's external identifer (for a PUBLIC DTD).
+ */
+static VALUE rxml_dtd_external_id_get(VALUE self)
+{
+  xmlDtdPtr xdtd;
+  Data_Get_Struct(self, xmlDtd, xdtd);
+
+
+  if (xdtd->ExternalID == NULL)
+    return (Qnil);
+  else
+    return (rb_str_new2((const char*) xdtd->ExternalID));
+}
+
+/*
+ * call-seq:
+ *    dtd.name -> "string"
+ *
+ * Obtain this dtd's name.
+ */
+static VALUE rxml_dtd_name_get(VALUE self)
+{
+  xmlDtdPtr xdtd;
+  Data_Get_Struct(self, xmlDtd, xdtd);
+
+
+  if (xdtd->name == NULL)
+    return (Qnil);
+  else
+    return (rb_str_new2((const char*) xdtd->name));
+}
+
+
+/*
+ * call-seq:
+ *    dtd.uri -> "string"
+ *
+ * Obtain this dtd's URI (for a SYSTEM or PUBLIC DTD).
+ */
+static VALUE rxml_dtd_uri_get(VALUE self)
+{
+  xmlDtdPtr xdtd;
+  Data_Get_Struct(self, xmlDtd, xdtd);
+
+
+  if (xdtd->SystemID == NULL)
+    return (Qnil);
+  else
+    return (rb_str_new2((const char*) xdtd->SystemID));
+}
+
+/*
+ * 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
+ *
+ * Create a new Dtd from the specified public and system
+ * identifiers.
+ */
+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;
+
+  // 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;
+
+      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 XML::Document object");
+        Data_Get_Struct(doc, xmlDoc, xdoc);
+      }
+
+      if (internal == Qnil || internal == Qfalse)
+        xdtd = xmlNewDtd(xdoc, xname, xpublic, xsystem);
+      else
+        xdtd = xmlCreateIntSubset(xdoc, xname, xpublic, xsystem);
+
+      if (xdtd == NULL)
+        rxml_raise(&xmlLastError);
+
+      /* Document will free this dtd now. */
+      RDATA(self)->dfree = NULL;
+      DATA_PTR(self) = xdtd;
+
+      xmlSetTreeDoc((xmlNodePtr) xdtd, xdoc);
+    }
+    break;
+
+  case 2:
+    rb_scan_args(argc, argv, "20", &external, &system);
+
+    Check_Type(external, T_STRING);
+    Check_Type(system, T_STRING);
+
+    xdtd = xmlParseDTD((xmlChar*) StringValuePtr(external),
+        (xmlChar*) StringValuePtr(system));
+
+    if (xdtd == NULL)
+      rxml_raise(&xmlLastError);
+
+    DATA_PTR(self) = xdtd;
+
+    xmlSetTreeDoc((xmlNodePtr) xdtd, NULL);
+    break;
+
+  case 1:
+    rb_scan_args(argc, argv, "10", &dtd_string);
+    Check_Type(dtd_string, T_STRING);
+
+    /* 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);
+
+    xdtd = xmlIOParseDTD(NULL, buffer, enc);
+
+    if (xdtd == NULL)
+      rxml_raise(&xmlLastError);
+
+    xmlFree(new_string);
+
+    DATA_PTR(self) = xdtd;
+    break;
+
+  default:
+    rb_raise(rb_eArgError, "wrong number of arguments");
+  }
+
+  return self;
+}
+
+void rxml_init_dtd()
+{
+  cXMLDtd = rb_define_class_under(mXML, "Dtd", rb_cObject);
+  rb_define_alloc_func(cXMLDtd, rxml_dtd_alloc);
+  rb_define_method(cXMLDtd, "initialize", rxml_dtd_initialize, -1);
+  rb_define_method(cXMLDtd, "external_id", rxml_dtd_external_id_get, 0);
+  rb_define_method(cXMLDtd, "name", rxml_dtd_name_get, 0);
+  rb_define_method(cXMLDtd, "uri", rxml_dtd_uri_get, 0);
+
+  rb_define_alias(cXMLDtd, "system_id", "uri");
+}
+

data/ext/libxml/ruby_xml_dtd.h

@@ -3,7 +3,7 @@
 
 extern VALUE cXMLDtd;
 
-void  ruby_init_xml_dtd(void);
+void  rxml_init_dtd(void);
 VALUE rxml_dtd_wrap(xmlDtdPtr xdtd);
 
 #endif

data/ext/libxml/ruby_xml_encoding.c

@@ -8,13 +8,14 @@
 /*
  * Document-class: LibXML::XML::Encoding
  *
- * The encoding class defines the encodings that libxml
- * supports. LibXML converts all data sources to UTF8
- * internally before processing them.
+ * The encoding class exposes the encodings that libxml
+ * supports via constants.  
  *
- * By default, LibXML determines a data source's encoding 
+ * LibXML converts all data sources to UTF8
+ * internally before processing them.  By default, 
+ * LibXML determines a data source's encoding 
  * using the algorithm described on its
- * website[* http://xmlsoft.org/encoding.html].  
+ * website[http://xmlsoft.org/encoding.html].  
  *
  * However, you may override a data source's encoding 
  * by using the encoding constants defined in this
@@ -76,41 +77,58 @@ static VALUE rxml_encoding_to_s(VALUE klass, VALUE encoding)
     return rb_str_new2(xecoding);
 }
 
-// Rdoc needs to know
-#ifdef RDOC_NEVER_DEFINED
-mLibXML = rb_define_module("LibXML");
-mXML = rb_define_module_under(mLibXML, "XML");
-#endif
-
-void ruby_init_xml_encoding(void)
+void rxml_init_encoding(void)
 {
   mXMLEncoding = rb_define_module_under(mXML, "Encoding");
   rb_define_module_function(mXMLEncoding, "from_s", rxml_encoding_from_s, 1);
   rb_define_module_function(mXMLEncoding, "to_s", rxml_encoding_to_s, 1);
 
-  rb_define_const(mXMLEncoding, "UNDEFINED", INT2NUM(XPATH_UNDEFINED));
-  rb_define_const(mXMLEncoding, "ERROR", INT2NUM(XML_CHAR_ENCODING_ERROR)); /* No char encoding detected */
-  rb_define_const(mXMLEncoding, "NONE", INT2NUM(XML_CHAR_ENCODING_NONE)); /* No char encoding detected */
-  rb_define_const(mXMLEncoding, "UTF_8", INT2NUM(XML_CHAR_ENCODING_UTF8)); /* UTF-8 */
-  rb_define_const(mXMLEncoding, "UTF_16LE", INT2NUM(XML_CHAR_ENCODING_UTF16LE)); /* UTF-16 little endian */
-  rb_define_const(mXMLEncoding, "UTF_16BE", INT2NUM(XML_CHAR_ENCODING_UTF16BE)); /* UTF-16 big endian */
-  rb_define_const(mXMLEncoding, "UCS_4LE", INT2NUM(XML_CHAR_ENCODING_UCS4LE)); /* UCS-4 little endian */
-  rb_define_const(mXMLEncoding, "UCS_4BE", INT2NUM(XML_CHAR_ENCODING_UCS4BE)); /* UCS-4 big endian */
-  rb_define_const(mXMLEncoding, "EBCDIC", INT2NUM(XML_CHAR_ENCODING_EBCDIC)); /* EBCDIC uh! */
-  rb_define_const(mXMLEncoding, "UCS_4_2143", INT2NUM(XML_CHAR_ENCODING_UCS4_2143)); /* UCS-4 unusual ordering */
-  rb_define_const(mXMLEncoding, "UCS_4_3412", INT2NUM(XML_CHAR_ENCODING_UCS4_3412)); /* UCS-4 unusual ordering */
-  rb_define_const(mXMLEncoding, "UCS_2", INT2NUM(XML_CHAR_ENCODING_UCS2)); /* UCS-2 */
-  rb_define_const(mXMLEncoding, "ISO_8859_1", INT2NUM(XML_CHAR_ENCODING_8859_1)); /* ISO-8859-1 ISO Latin 1 */
-  rb_define_const(mXMLEncoding, "ISO_8859_2", INT2NUM(XML_CHAR_ENCODING_8859_2)); /* ISO-8859-2 ISO Latin 2 */
-  rb_define_const(mXMLEncoding, "ISO_8859_3", INT2NUM(XML_CHAR_ENCODING_8859_3)); /* ISO-8859-3 */
-  rb_define_const(mXMLEncoding, "ISO_8859_4", INT2NUM(XML_CHAR_ENCODING_8859_4)); /* ISO-8859-4 */
-  rb_define_const(mXMLEncoding, "ISO_8859_5", INT2NUM(XML_CHAR_ENCODING_8859_5)); /* ISO-8859-5 */
-  rb_define_const(mXMLEncoding, "ISO_8859_6", INT2NUM(XML_CHAR_ENCODING_8859_6)); /* ISO-8859-6 */
-  rb_define_const(mXMLEncoding, "ISO_8859_7", INT2NUM(XML_CHAR_ENCODING_8859_7)); /* ISO-8859-7 */
-  rb_define_const(mXMLEncoding, "ISO_8859_8", INT2NUM(XML_CHAR_ENCODING_8859_8)); /* ISO-8859-8 */
-  rb_define_const(mXMLEncoding, "ISO_8859_9", INT2NUM(XML_CHAR_ENCODING_8859_9)); /* ISO-8859-9 */
-  rb_define_const(mXMLEncoding, "ISO_2022_JP", INT2NUM(XML_CHAR_ENCODING_2022_JP)); /* ISO-2022-JP */
-  rb_define_const(mXMLEncoding, "SHIFT_JIS", INT2NUM(XML_CHAR_ENCODING_SHIFT_JIS)); /* Shift_JIS */
-  rb_define_const(mXMLEncoding, "EUC_JP", INT2NUM(XML_CHAR_ENCODING_EUC_JP)); /* EUC-JP */
-  rb_define_const(mXMLEncoding, "ASCII", INT2NUM(XML_CHAR_ENCODING_ASCII)); /* pure ASCII */
+  /* -1: No char encoding detected. */
+  rb_define_const(mXMLEncoding, "ERROR", INT2NUM(XML_CHAR_ENCODING_ERROR));
+  /* 0: No char encoding detected. */
+  rb_define_const(mXMLEncoding, "NONE", INT2NUM(XML_CHAR_ENCODING_NONE));
+  /* 1: UTF-8 */
+  rb_define_const(mXMLEncoding, "UTF_8", INT2NUM(XML_CHAR_ENCODING_UTF8));
+  /* 2: UTF-16 little endian. */
+  rb_define_const(mXMLEncoding, "UTF_16LE", INT2NUM(XML_CHAR_ENCODING_UTF16LE));
+  /* 3: UTF-16 big endian. */
+  rb_define_const(mXMLEncoding, "UTF_16BE", INT2NUM(XML_CHAR_ENCODING_UTF16BE)); 
+  /* 4: UCS-4 little endian. */
+  rb_define_const(mXMLEncoding, "UCS_4LE", INT2NUM(XML_CHAR_ENCODING_UCS4LE));
+  /* 5: UCS-4 big endian. */
+  rb_define_const(mXMLEncoding, "UCS_4BE", INT2NUM(XML_CHAR_ENCODING_UCS4BE));
+  /* 6: EBCDIC uh! */
+  rb_define_const(mXMLEncoding, "EBCDIC", INT2NUM(XML_CHAR_ENCODING_EBCDIC)); 
+  /* 7: UCS-4 unusual ordering. */
+  rb_define_const(mXMLEncoding, "UCS_4_2143", INT2NUM(XML_CHAR_ENCODING_UCS4_2143));
+  /* 8: UCS-4 unusual ordering. */
+  rb_define_const(mXMLEncoding, "UCS_4_3412", INT2NUM(XML_CHAR_ENCODING_UCS4_3412));
+  /* 9: UCS-2. */
+  rb_define_const(mXMLEncoding, "UCS_2", INT2NUM(XML_CHAR_ENCODING_UCS2));
+  /* 10: ISO-8859-1 ISO Latin 1. */
+  rb_define_const(mXMLEncoding, "ISO_8859_1", INT2NUM(XML_CHAR_ENCODING_8859_1));
+  /* 11: ISO-8859-2 ISO Latin 2. */
+  rb_define_const(mXMLEncoding, "ISO_8859_2", INT2NUM(XML_CHAR_ENCODING_8859_2));
+  /* 12: ISO-8859-3. */
+  rb_define_const(mXMLEncoding, "ISO_8859_3", INT2NUM(XML_CHAR_ENCODING_8859_3));
+  /* 13: ISO-8859-4. */
+  rb_define_const(mXMLEncoding, "ISO_8859_4", INT2NUM(XML_CHAR_ENCODING_8859_4));
+  /* 14: ISO-8859-5. */
+  rb_define_const(mXMLEncoding, "ISO_8859_5", INT2NUM(XML_CHAR_ENCODING_8859_5));
+  /* 15: ISO-8859-6. */
+  rb_define_const(mXMLEncoding, "ISO_8859_6", INT2NUM(XML_CHAR_ENCODING_8859_6));
+  /* 16: ISO-8859-7. */
+  rb_define_const(mXMLEncoding, "ISO_8859_7", INT2NUM(XML_CHAR_ENCODING_8859_7));
+  /* 17: ISO-8859-8. */
+  rb_define_const(mXMLEncoding, "ISO_8859_8", INT2NUM(XML_CHAR_ENCODING_8859_8));
+  /* 18: ISO-8859-9. */
+  rb_define_const(mXMLEncoding, "ISO_8859_9", INT2NUM(XML_CHAR_ENCODING_8859_9));
+  /* 19: ISO-2022-JP. */
+  rb_define_const(mXMLEncoding, "ISO_2022_JP", INT2NUM(XML_CHAR_ENCODING_2022_JP));
+  /* 20: Shift_JIS. */
+  rb_define_const(mXMLEncoding, "SHIFT_JIS", INT2NUM(XML_CHAR_ENCODING_SHIFT_JIS));
+  /* 21: EUC-JP. */
+  rb_define_const(mXMLEncoding, "EUC_JP", INT2NUM(XML_CHAR_ENCODING_EUC_JP));
+  /* 22: pure ASCII. */
+  rb_define_const(mXMLEncoding, "ASCII", INT2NUM(XML_CHAR_ENCODING_ASCII));
 }