libxml-ruby 1.1.4 → 2.0.0

data/ext/libxml/libxml.c

@@ -6,6 +6,7 @@
 #include <util.h>
 #endif
 
+
 VALUE mLibXML;
 
 static void rxml_init_memory(void)
@@ -20,6 +21,21 @@ static void rxml_init_memory(void)
   );*/
 }
 
+VALUE rxml_str_new2(const char* xstr, const char* xencoding)
+{
+#ifdef HAVE_RUBY_ENCODING_H
+  if (xencoding)
+  {
+    xmlCharEncoding xmlEncoding = xmlParseCharEncoding(xencoding);
+    VALUE encoding = rxml_xml_encoding_to_rb_encoding(mXMLEncoding, xmlEncoding);
+    rb_encoding* xencodingPtr = (rb_encoding*) RDATA(encoding)->data;
+    return rb_external_str_new_with_enc(xstr, strlen(xstr), xencodingPtr);
+  }
+#endif
+  return rb_str_new2(xstr);
+}
+
+
 #if defined(_WIN32)
 __declspec(dllexport)
 #endif
@@ -28,7 +44,7 @@ void Init_libxml_ruby(void)
 /* The libxml gem provides Ruby language bindings for GNOME's Libxml2
  * XML toolkit.  To get started you may:
  *
- *  require 'xml'
+ *  require 'test_helper'
  *  document = XML::Document.new
  *
  * However, when creating an application or library you plan to

data/ext/libxml/ruby_libxml.h

@@ -40,12 +40,20 @@
 #define RHASH_TBL(s) (RHASH(s)->tbl)
 #endif
 
-// not in Ruby 1.9
+// Not in Ruby 1.9
 #ifndef GetWriteFile
 #define GetWriteFile(fp) rb_io_stdio_file(fp)
 #define OpenFile rb_io_t
 #endif
 
+// Encoding support added in Ruby 1.9.*
+#ifdef HAVE_RUBY_ENCODING_H
+#include <ruby/encoding.h>
+#endif
+
+// Ruby 1.8/1.9 encoding compatibility
+VALUE rxml_str_new2(const char* xstr, const char* xencoding);
+
 #ifdef LIBXML_DEBUG_ENABLED
 #include <libxml/xpathInternals.h>
 #endif

data/ext/libxml/ruby_xml_attr.c

@@ -9,7 +9,7 @@
  *
  * Basic Usage:
  *
- *  require 'xml'
+ *  require 'test_helper'
  *
  *  doc = XML::Document.new(<some_file>)
  *  attribute = doc.root.attributes.get_attribute_ns('http://www.w3.org/1999/xlink', 'href')
@@ -188,7 +188,7 @@ static VALUE rxml_attr_name_get(VALUE self)
   if (xattr->name == NULL)
     return Qnil;
   else
-    return rb_str_new2((const char*) xattr->name);
+    return rxml_str_new2((const char*) xattr->name, xattr->doc->encoding);
 }
 
 /*
@@ -304,7 +304,7 @@ VALUE rxml_attr_value_get(VALUE self)
 
   if (value != NULL)
   {
-    result = rb_str_new2((const char*) value);
+    result = rxml_str_new2((const char*) value, xattr->doc->encoding);
     xmlFree(value);
   }
   return result;

data/ext/libxml/ruby_xml_attr_decl.c

@@ -15,28 +15,28 @@
 
 VALUE cXMLAttrDecl;
 
-void rxml_attr_decl_mark(xmlAttributePtr xattribute)
+void rxml_attr_decl_mark(xmlAttributePtr xattr)
 {
-  if (xattribute->_private == NULL)
+  if (xattr->_private == NULL)
   {
     rb_warning("AttrDecl is not bound! (%s:%d)", __FILE__, __LINE__);
     return;
   }
 
-  rxml_node_mark((xmlNodePtr) xattribute);
+  rxml_node_mark((xmlNodePtr) xattr);
 }
 
-VALUE rxml_attr_decl_wrap(xmlAttributePtr xattribute)
+VALUE rxml_attr_decl_wrap(xmlAttributePtr xattr)
 {
   VALUE result;
 
   // This node is already wrapped
-  if (xattribute->_private != NULL)
-    return (VALUE) xattribute->_private;
+  if (xattr->_private != NULL)
+    return (VALUE) xattr->_private;
 
-  result = Data_Wrap_Struct(cXMLAttrDecl, rxml_attr_decl_mark, NULL, xattribute);
+  result = Data_Wrap_Struct(cXMLAttrDecl, rxml_attr_decl_mark, NULL, xattr);
 
-  xattribute->_private = (void*) result;
+  xattr->_private = (void*) result;
 
   return result;
 }
@@ -49,12 +49,12 @@ VALUE rxml_attr_decl_wrap(xmlAttributePtr xattribute)
  */
 static VALUE rxml_attr_decl_doc_get(VALUE self)
 {
-  xmlAttributePtr xattribute;
-  Data_Get_Struct(self, xmlAttribute, xattribute);
-  if (xattribute->doc == NULL)
+  xmlAttributePtr xattr;
+  Data_Get_Struct(self, xmlAttribute, xattr);
+  if (xattr->doc == NULL)
     return Qnil;
   else
-    return rxml_document_wrap(xattribute->doc);
+    return rxml_document_wrap(xattr->doc);
 }
 
 
@@ -66,13 +66,13 @@ static VALUE rxml_attr_decl_doc_get(VALUE self)
  */
 static VALUE rxml_attr_decl_name_get(VALUE self)
 {
-  xmlAttributePtr xattribute;
-  Data_Get_Struct(self, xmlAttribute, xattribute);
+  xmlAttributePtr xattr;
+  Data_Get_Struct(self, xmlAttribute, xattr);
 
-  if (xattribute->name == NULL)
+  if (xattr->name == NULL)
     return Qnil;
   else
-    return rb_str_new2((const char*) xattribute->name);
+    return rxml_str_new2((const char*) xattr->name, xattr->doc->encoding);
 }
 
 /*
@@ -83,12 +83,12 @@ static VALUE rxml_attr_decl_name_get(VALUE self)
  */
 static VALUE rxml_attr_decl_next_get(VALUE self)
 {
-  xmlAttributePtr xattribute;
-  Data_Get_Struct(self, xmlAttribute, xattribute);
-  if (xattribute->next == NULL)
+  xmlAttributePtr xattr;
+  Data_Get_Struct(self, xmlAttribute, xattr);
+  if (xattr->next == NULL)
     return Qnil;
   else
-    return rxml_attr_decl_wrap((xmlAttributePtr)xattribute->next);
+    return rxml_attr_decl_wrap((xmlAttributePtr)xattr->next);
 }
 
 /*
@@ -113,13 +113,13 @@ static VALUE rxml_attr_decl_node_type(VALUE self)
  */
 static VALUE rxml_attr_decl_parent_get(VALUE self)
 {
-  xmlAttributePtr xattribute;
-  Data_Get_Struct(self, xmlAttribute, xattribute);
+  xmlAttributePtr xattr;
+  Data_Get_Struct(self, xmlAttribute, xattr);
 
-  if (xattribute->parent == NULL)
+  if (xattr->parent == NULL)
     return Qnil;
   else
-    return rxml_dtd_wrap(xattribute->parent);
+    return rxml_dtd_wrap(xattr->parent);
 }
 
 /*
@@ -131,13 +131,13 @@ static VALUE rxml_attr_decl_parent_get(VALUE self)
  */
 static VALUE rxml_attr_decl_prev_get(VALUE self)
 {
-  xmlAttributePtr xattribute;
-  Data_Get_Struct(self, xmlAttribute, xattribute);
+  xmlAttributePtr xattr;
+  Data_Get_Struct(self, xmlAttribute, xattr);
 
-  if (xattribute->prev == NULL)
+  if (xattr->prev == NULL)
     return Qnil;
   else
-    return rxml_attr_decl_wrap((xmlAttributePtr)xattribute->prev);
+    return rxml_attr_decl_wrap((xmlAttributePtr)xattr->prev);
 }
 
 /*
@@ -148,12 +148,12 @@ static VALUE rxml_attr_decl_prev_get(VALUE self)
  */
 VALUE rxml_attr_decl_value_get(VALUE self)
 {
-  xmlAttributePtr xattribute;
+  xmlAttributePtr xattr;
 
-  Data_Get_Struct(self, xmlAttribute, xattribute);
+  Data_Get_Struct(self, xmlAttribute, xattr);
 
-  if (xattribute->defaultValue)
-    return rb_str_new2((const char *)xattribute->defaultValue);
+  if (xattr->defaultValue)
+    return rxml_str_new2((const char *)xattr->defaultValue, xattr->doc->encoding);
   else
     return Qnil;
 }

data/ext/libxml/ruby_xml_attributes.c

@@ -8,7 +8,7 @@
  * Provides access to an element's attributes (XML::Attr).
  *
  * Basic Usage:
- *  require 'xml'
+ *  require 'test_helper'
  *
  *  doc = XML::Document.new(<some_file>)
  *  attributes = doc.root.attributes

data/ext/libxml/ruby_xml_cbg.c

@@ -42,8 +42,7 @@ void* deb_Open(char const *filename)
   deb_doc = (deb_doc_context*) malloc(sizeof(deb_doc_context));
 
   res = rb_funcall(rb_funcall(rb_mKernel, rb_intern("const_get"), 1,
-      rb_str_new2("DEBSystem")), rb_intern("document_query"), 1, rb_str_new2(
-      filename));
+      rb_str_new2("DEBSystem")), rb_intern("document_query"), 1, rb_str_new2(filename));
   deb_doc->buffer = strdup(StringValuePtr(res));
   //deb_doc->buffer = strdup("<serepes>serepes</serepes>");
 

data/ext/libxml/ruby_xml_document.c

@@ -282,7 +282,7 @@ static VALUE rxml_document_debug(VALUE self)
  * call-seq:
  *    document.encoding -> XML::Encoding::UTF_8
  *
- * Obtain the encoding specified by this document.
+ * Returns the LibXML encoding constant specified by this document.
  */
 static VALUE rxml_document_encoding_get(VALUE self)
 {
@@ -294,6 +294,25 @@ static VALUE rxml_document_encoding_get(VALUE self)
   return INT2NUM(xmlParseCharEncoding(xencoding));
 }
 
+
+/*
+ * call-seq:
+ *    document.rb_encoding -> Encoding
+ *
+ * Returns the Ruby encoding specified by this document
+ * (available on Ruby 1.9.x and higher).
+ */
+static VALUE rxml_document_rb_encoding_get(VALUE self)
+{
+  xmlDocPtr xdoc;
+  const char *xencoding;
+  VALUE encoding;
+  Data_Get_Struct(self, xmlDoc, xdoc);
+
+  xencoding = (const char*)xdoc->encoding;
+  return rxml_xml_encoding_to_rb_encoding(mXMLEncoding, xmlParseCharEncoding(xencoding));
+}
+
 /*
  * call-seq:
  *    document.encoding = XML::Encoding::UTF_8
@@ -664,7 +683,7 @@ static VALUE rxml_document_to_s(int argc, VALUE *argv, VALUE self)
   Data_Get_Struct(self, xmlDoc, xdoc);
   xmlDocDumpFormatMemoryEnc(xdoc, &buffer, &length, xencoding, indent);
 
-  result = rb_str_new((const char*) buffer, length);
+  result = rxml_str_new2((const char*) buffer, xencoding);
   xmlFree(buffer);
   return result;
 }
@@ -683,7 +702,7 @@ static VALUE rxml_document_url_get(VALUE self)
   if (xdoc->URL == NULL)
     return (Qnil);
   else
-    return (rb_str_new2((const char*) xdoc->URL));
+    return (rxml_str_new2((const char*) xdoc->URL, xdoc->encoding));
 }
 
 /*
@@ -700,7 +719,7 @@ static VALUE rxml_document_version_get(VALUE self)
   if (xdoc->version == NULL)
     return (Qnil);
   else
-    return (rb_str_new2((const char*) xdoc->version));
+    return (rxml_str_new2((const char*) xdoc->version, xdoc->encoding));
 }
 
 /*
@@ -909,6 +928,9 @@ void rxml_init_document(void)
   rb_define_method(cXMLDocument, "compression?", rxml_document_compression_q, 0);
   rb_define_method(cXMLDocument, "debug", rxml_document_debug, 0);
   rb_define_method(cXMLDocument, "encoding", rxml_document_encoding_get, 0);
+#ifdef HAVE_RUBY_ENCODING_H
+  rb_define_method(cXMLDocument, "rb_encoding", rxml_document_rb_encoding_get, 0);
+#endif
   rb_define_method(cXMLDocument, "encoding=", rxml_document_encoding_set, 1);
   rb_define_method(cXMLDocument, "import", rxml_document_import, 1);
   rb_define_method(cXMLDocument, "last", rxml_document_last_get, 0);

data/ext/libxml/ruby_xml_dtd.c

@@ -90,7 +90,7 @@ static VALUE rxml_dtd_external_id_get(VALUE self)
   if (xdtd->ExternalID == NULL)
     return (Qnil);
   else
-    return (rb_str_new2((const char*) xdtd->ExternalID));
+    return (rxml_str_new2((const char*) xdtd->ExternalID, xdtd->doc ? xdtd->doc->encoding : NULL));
 }
 
 /*
@@ -108,7 +108,7 @@ static VALUE rxml_dtd_name_get(VALUE self)
   if (xdtd->name == NULL)
     return (Qnil);
   else
-    return (rb_str_new2((const char*) xdtd->name));
+    return (rxml_str_new2((const char*) xdtd->name, xdtd->doc ? xdtd->doc->encoding : NULL));
 }
 
 
@@ -127,7 +127,7 @@ static VALUE rxml_dtd_uri_get(VALUE self)
   if (xdtd->SystemID == NULL)
     return (Qnil);
   else
-    return (rb_str_new2((const char*) xdtd->SystemID));
+    return (rxml_str_new2((const char*) xdtd->SystemID, xdtd->doc ? xdtd->doc->encoding : NULL));
 }
 
 /*

data/ext/libxml/ruby_xml_encoding.c

@@ -41,7 +41,6 @@
 
 VALUE mXMLEncoding;
 
-
 /*
  * call-seq:
  *    Input.s_to_encoding("UTF_8") -> XML::Encoding::UTF_8
@@ -64,25 +63,113 @@ static VALUE rxml_encoding_from_s(VALUE klass, VALUE encoding)
  * call-seq:
  *    Input.encoding_to_s(Input::ENCODING) -> "encoding"
  *
- * Converts an encoding contstant defined on the XML::Encoding
+ * Converts an encoding constant defined on the XML::Encoding
  * class to its text representation.
  */
 static VALUE rxml_encoding_to_s(VALUE klass, VALUE encoding)
 {
-  const char* xecoding = xmlGetCharEncodingName(NUM2INT(encoding));
+  const char* xencoding = xmlGetCharEncodingName(NUM2INT(encoding));
 
-  if (!xecoding)
+  if (!xencoding)
     return Qnil;
   else
-    return rb_str_new2(xecoding);
+    return rxml_str_new2(xencoding, xencoding);
 }
 
+#ifdef HAVE_RUBY_ENCODING_H
+VALUE rxml_xml_encoding_to_rb_encoding(VALUE klass, xmlCharEncoding xmlEncoding)
+{
+  ID encoding_name;
+
+  switch (xmlEncoding)
+  {
+    case XML_CHAR_ENCODING_UTF8:
+      encoding_name = rb_intern("UTF_8");
+      break;
+    case XML_CHAR_ENCODING_UTF16LE:
+      encoding_name = rb_intern("UTF_16LE");
+      break;
+    case XML_CHAR_ENCODING_UTF16BE:
+      encoding_name = rb_intern("UTF_16BE");
+      break;
+    case XML_CHAR_ENCODING_UCS4LE:
+      encoding_name = rb_intern("UCS_4LE");
+      break;
+    case XML_CHAR_ENCODING_UCS4BE:
+      encoding_name = rb_intern("UCS_4BE");
+      break;
+    case XML_CHAR_ENCODING_UCS2:
+      encoding_name = rb_intern("UCS_2");
+      break;
+    case XML_CHAR_ENCODING_8859_1:
+      encoding_name = rb_intern("ISO8859_1");
+      break;
+    case XML_CHAR_ENCODING_8859_2:
+      encoding_name = rb_intern("ISO8859_2");
+      break;
+    case XML_CHAR_ENCODING_8859_3:
+      encoding_name = rb_intern("ISO8859_3");
+      break;
+    case XML_CHAR_ENCODING_8859_4:
+      encoding_name = rb_intern("ISO8859_4");
+      break;
+    case XML_CHAR_ENCODING_8859_5:
+      encoding_name = rb_intern("ISO8859_5");
+      break;
+    case XML_CHAR_ENCODING_8859_6:
+      encoding_name = rb_intern("ISO8859_6");
+      break;
+    case XML_CHAR_ENCODING_8859_7:
+      encoding_name = rb_intern("ISO8859_7");
+      break;
+    case XML_CHAR_ENCODING_8859_8:
+      encoding_name = rb_intern("ISO8859_8");
+      break;
+    case XML_CHAR_ENCODING_8859_9:
+      encoding_name = rb_intern("ISO8859_9");
+      break;
+    case XML_CHAR_ENCODING_2022_JP:
+      encoding_name = rb_intern("ISO_2022_JP");
+      break;
+    case XML_CHAR_ENCODING_SHIFT_JIS:
+      encoding_name = rb_intern("SHIFT_JIS");
+      break;
+    case XML_CHAR_ENCODING_EUC_JP:
+      encoding_name = rb_intern("EUC_JP");
+      break;
+    case XML_CHAR_ENCODING_ASCII:
+      encoding_name = rb_intern("US-ASCII");
+      break;
+    default:
+      /* Covers XML_CHAR_ENCODING_ERROR, XML_CHAR_ENCODING_NONE, XML_CHAR_ENCODING_EBCDIC */
+      encoding_name = rb_intern("ASCII_8BIT");
+  }
+  return rb_const_get(rb_cEncoding, encoding_name);
+}
+
+/*
+ * call-seq:
+ *    Input.encoding_to_rb_encoding(Input::ENCODING) -> Encoding
+ *
+ * Converts an encoding constant defined on the XML::Encoding
+ * class to a Ruby encoding object (available on Ruby 1.9.* and higher).
+ */
+VALUE rxml_encoding_to_rb_encoding(VALUE klass, VALUE encoding)
+{
+  return rxml_xml_encoding_to_rb_encoding(klass, NUM2INT(encoding));
+}
+#endif
+
 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);
 
+#ifdef HAVE_RUBY_ENCODING_H
+ // rb_define_module_function(mXMLEncoding, "to_rb_encoding", rxml_encoding_to_rb_encoding, 2);
+#endif
+
   /* -1: No char encoding detected. */
   rb_define_const(mXMLEncoding, "ERROR", INT2NUM(XML_CHAR_ENCODING_ERROR));
   /* 0: No char encoding detected. */