libxml-ruby 3.2.0-x64-mingw32 → 3.2.1-x64-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 94c7fe73c157183aa88e339ad02d65873cf4fb855223963445c160bbbff0be78
-  data.tar.gz: c29cbebb5708cc8237df324149328df4574db8b1351c02039015362c983d89cc
+  metadata.gz: bfacaddafeb77f0b7ebd5badcdef2ccadad38ed0d0e0624a1d81bcd50a595b91
+  data.tar.gz: d93e00be745f3decdc5f97011485bfa386851ce838148537788cc353e0aea482
 SHA512:
-  metadata.gz: '0593491ff9729607c66966147192749392c11f4d200fe23e8a543cdaaa45daf924fde2c04dfe6ab9b8be3cf40810f4731a7864c7ee27b44a528edc36f8c26178'
-  data.tar.gz: d6d66bdbc69ddf104d70611b5254f25f08a188423c9667aaf9a925a862118d386345732876459e15eb9986a03201169bd0212f44bd1d6762de4d0b5a6cbc6c43
+  metadata.gz: 3a780f492bdeeb4a74d495ca255b1fd0d54b8fda9e15c5bc6c4de10303b6aaa24fc2a88aae09a8f228bd4c6a43b77689150545fb2a0f62b87ce7bbb018bff69d
+  data.tar.gz: 576512ee3ec3bca69b3023f13c6d62fa6801fb7d8f9d018d260f10c053a55280aa669ea613a1cdc33e4e47da04a61bd80201b2621c3a0c75c7461cc94a5d68eb

data/HISTORY

@@ -1,10 +1,15 @@
 = Release History
 
+== 3.2.1 / 2020-11-05
+
+* Fix incorrect handling of encodings when using XMLWriter.io (Charlie Savage)
+* Clean up README  (Richard Michael)
+
 == 3.2.0 / 2020-05-09 Charlie Savage
 
 * Fix crash when creating an empty DTD
 * Modernize tests to use Bundler to load gem
-* Add libxml-ruby.rb file so gem loads in expted way.
+* Add libxml-ruby.rb file so gem loads in expected way.
 * Add support for xmlSaveNoEmptyTags.
 * Clean up extconf.rb file
 

data/README.rdoc

@@ -12,7 +12,7 @@ We think libxml-ruby is the best XML library for Ruby because:
 
 == Requirements
 libxml-ruby requires Ruby 1.8.7 or higher.  It depends on libxml2 to
-function propoerly.  libxml2, in turn, depends on:
+function properly.  libxml2, in turn, depends on:
 
 * libm      (math routines: very standard)
 * libz      (zlib)
@@ -21,25 +21,41 @@ function propoerly.  libxml2, in turn, depends on:
 If you are running Linux or Unix you'll need a C compiler so the
 extension can be compiled when it is installed.  If you are running
 Windows, then install the x64-mingw32 gem or build it yourself using
-Devkit (http://rubyinstaller.org/add-ons/devkit/) or
-msys2 (https://msys2.github.io/).
+Devkit[http://rubyinstaller.org/add-ons/devkit/] or
+msys2[https://msys2.github.io/].
 
-== INSTALLATION
-The easiest way to install libxml-ruby is via Ruby Gems.  To install:
+== Installation
+The easiest way to install libxml-ruby is via RubyGems.  To install:
 
 <tt>gem install libxml-ruby</tt>
 
+If the extension compile process cannot find libxml2, you may need to indicate
+the location of the libxml2 configuration utility as it is used to find the
+required header and include files.  (If you need to indicate a location for the
+libxml2 library or header files different than reported by <tt>xml2-config</tt>,
+see the additional configuration options.)
+
+This may be done with RubyGems:
+
+<tt>gem install libxml-ruby -- --with-xml2-dir=/path/to/xml2-config</tt>
+
+Or bundler:
+
+<tt>bundle config build.libxml-ruby --with-xml2-config=/path/to/xml2-config</tt>
+
+<tt>bundle install libxml-ruby</tt>
+
 If you are running Windows, then install the libxml-ruby-x64-mingw32 gem.
-THe gem inncludes prebuilt extensions for Ruby 2.3.  These
+The gem includes prebuilt extensions for Ruby 2.3.  These
 extensions are built using MinGW64 and libxml2 version 2.9.3,
 iconv version 1.14 and zlib version 1.2.8. Note these binaries
-are available in the lib\libs directory.  To use them, put them
-someplace on your path.
+are available in the <tt>lib\\libs</tt> directory.  To use them, put them
+on your <tt>PATH</tt>.
 
 The gem also includes a Microsoft VC++ 2012 solution and XCode 5 project - these
 are very useful for debugging.
 
-libxml-ruby's source codes lives on Github at https://github.com/xml4r/libxml-ruby.
+libxml-ruby's source codes lives on GitHub[https://github.com/xml4r/libxml-ruby].
 
 == Getting Started
 Using libxml is easy. First decide what parser you want to use:
@@ -60,7 +76,7 @@ Beyond the basics of parsing and processing XML and HTML documents,
 libxml provides a wealth of additional functionality.
 
 Most commonly, you'll want to use its LibXML::XML::XPath support, which makes
-it easy to find data inside a XML document.  Although not as popular,
+it easy to find data inside an XML document.  Although not as popular,
 LibXML::XML::XPointer provides another API for finding data inside an XML document.
 
 Often times you'll need to validate data before processing it. For example,
@@ -72,17 +88,16 @@ This can be done using libxml's powerful set of validators:
 * Relax Schemas (LibXML::XML::RelaxNG)
 * XML Schema (LibXML::XML::Schema)
 
-Finally, if you'd like to use XSL Transformations to process data,
-then install the libxslt gem which is available at
-https://github.com/xml4r/libxslt-ruby.
+Finally, if you'd like to use XSL Transformations to process data, then install
+the {libxslt gem}[https://github.com/xml4r/libxslt-rubygem].
 
 == Usage
-For information about using libxml-ruby please refer to its documentation at
-http://xml4r.github.com/libxml-ruby/rdoc/index.html. Some tutorials are also
-available at https://github.com/xml4r/libxml-ruby/wiki.
+For information about using libxml-ruby please refer to its
+documentation[http://xml4r.github.io/libxml-ruby]. Some tutorials are also
+available[https://github.com/xml4r/libxml-ruby/wiki].
 
 All libxml classes are in the LibXML::XML module. The easiest
-way to use libxml is to require 'xml'.  This will mixin
+way to use libxml is to <tt>require 'xml'</tt>.  This will mixin
 the LibXML module into the global namespace, allowing you to
 write code like this:
 
@@ -131,10 +146,11 @@ Once you have build the shared libary, you can then run tests using rake:
 +Travis build status: {<img src="https://travis-ci.org/xml4r/libxml-ruby.svg?branch=master" alt="Build Status" />}[https://travis-ci.org/xml4r/libxml-ruby]
 
 == Performance
+
 In addition to being feature rich and conformation, the main reason
-people use libxml-ruby is for performance.  Here are the results 
+people use libxml-ruby is for performance.  Here are the results
 of a couple simple benchmarks recently blogged about on the
-Web (you can find them in the benchmark directory of the 
+Web (you can find them in the benchmark directory of the
 libxml distribution).
 
 From http://depixelate.com/2008/4/23/ruby-xml-parsing-benchmarks
@@ -156,46 +172,46 @@ From https://svn.concord.org/svn/projects/trunk/common/ruby/xml_benchmarks/
 Documentation is available via rdoc, and is installed automatically with the
 gem.
 
-libxml-ruby's online documentation is generated using Hanna, which is a
-development gem dependency.
+libxml-ruby's {online
+documentation}[https://xml4r.github.io/libxml-ruby/rdoc/index.html] is generated
+using Hanna, which is a development gem dependency.
 
 Note that older versions of Rdoc, which ship with Ruby 1.8.x, will report
 a number of errors.  To avoid them, install Rdoc 2.1 or higher.  Once you have
 installed the gem, you'll have to disable the version of Rdoc that Ruby 1.8.x
-includes.  An easy way to do that is rename the directory ruby/lib/ruby/1.8/rdoc to
-ruby/lib/ruby/1.8/rdoc_old.
+includes.  An easy way to do that is rename the directory
+<tt>ruby/lib/ruby/1.8/rdoc</tt> to
+<tt>ruby/lib/ruby/1.8/rdoc_old</tt>.
 
 == Support
-
-If you have any questions about using libxml-ruby, please report them to
-Git Hub at https://github.com/xml4r/libxml-ruby/issues
+If you have any questions about using libxml-ruby, please report an issue
+on GitHub[https://github.com/xml4r/libxml-ruby/issues].
 
 == Memory Management
 libxml-ruby automatically manages memory associated with the
 underlying libxml2 library.  The bindings create a one-to-one mapping between
-ruby objects and libxml documents and libxml parent nodes (ie, nodes that do not
-have a parent and do not belong to a document). In these cases,
+Ruby objects and libxml documents and libxml parent nodes (ie, nodes that do not
+have a parent and do not belong to a document).  In these cases,
 the bindings manage the memory.  They do this by installing a free
 function and storing a back pointer to the Ruby object from the xmlnode
 using the _private member on libxml structures.  When the Ruby object
 goes out of scope, the underlying libxml structure is freed.  Libxml
-itself then frees all child node (recursively).
+itself then frees all child nodes (recursively).
 
 For all other nodes (the vast majority), the bindings create temporary
 Ruby objects that get freed once they go out of scope. Thus there can be
-more than one ruby object pointing to the same xml node. To mostly hide
-this from programmers on the ruby side, the #eql? and #== methods are
-overriden to check if two ruby objects wrap the same xmlnode.  If they do,
+more than one Ruby object pointing to the same xml node. To mostly hide
+this from a programmer on the Ruby side, the <tt>#eql?</tt> and <tt>#==</tt> methods are
+overriden to check if two Ruby objects wrap the same xmlnode.  If they do,
 then the methods return true.  During the mark phase, each of these temporary
 objects marks its owning document, thereby keeping the Ruby document object
 alive and thus the xmldoc tree.
 
 In the sweep phase of the garbage collector, or when a program ends,
-there is no order to how Ruby objects are freed. In fact, the ruby document
-object is almost always freed before any ruby objects that wrap child nodes.
-However, this is ok because those ruby objects do not have a free function
+there is no order to how Ruby objects are freed.  In fact, the Ruby document
+object is almost always freed before any Ruby objects that wrap child nodes.
+However, this is ok because those Ruby objects do not have a free function
 and are no longer in scope (since if they were the document would not be freed).
 
 == License
 See LICENSE for license information.
-

data/ext/libxml/ruby_xml_document.c

@@ -483,7 +483,6 @@ static VALUE rxml_document_encoding_get(VALUE self)
  * Returns the Ruby encoding specified by this document
  * (available on Ruby 1.9.x and higher).
  */
-#ifdef HAVE_RUBY_ENCODING_H
 static VALUE rxml_document_rb_encoding_get(VALUE self)
 {
   xmlDocPtr xdoc;
@@ -493,7 +492,6 @@ static VALUE rxml_document_rb_encoding_get(VALUE self)
   rbencoding = rxml_xml_encoding_to_rb_encoding(mXMLEncoding, xmlParseCharEncoding((const char*)xdoc->encoding));
   return rb_enc_from_encoding(rbencoding);
 }
-#endif
 
 /*
  * call-seq:
@@ -1097,9 +1095,7 @@ 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_encoding.c

@@ -74,7 +74,6 @@ static VALUE rxml_encoding_to_s(VALUE klass, VALUE encoding)
     return rxml_new_cstr(xencoding, xencoding);
 }
 
-#ifdef HAVE_RUBY_ENCODING_H
 /*
  * Converts an xmlCharEncoding enum value into a Ruby Encoding object (available
  * on Ruby 1.9.* and higher).
@@ -179,26 +178,17 @@ rb_encoding* rxml_figure_encoding(const xmlChar* xencoding)
   }
   return result;
 }
-#endif
 
 VALUE rxml_new_cstr(const xmlChar* xstr, const xmlChar* xencoding)
 {
-#ifdef HAVE_RUBY_ENCODING_H
   rb_encoding *rbencoding = rxml_figure_encoding(xencoding);
   return rb_external_str_new_with_enc((const char*)xstr, strlen((const char*)xstr), rbencoding);
-#else
-  return rb_str_new2((const char*)xstr);
-#endif
 }
 
 VALUE rxml_new_cstr_len(const xmlChar* xstr, const long length, const xmlChar* xencoding)
 {
-#ifdef HAVE_RUBY_ENCODING_H
   rb_encoding *rbencoding = rxml_figure_encoding(xencoding);
   return rb_external_str_new_with_enc((const char*)xstr, length, rbencoding);
-#else
-  return rb_str_new((const char*)xstr, length);
-#endif
 }
 
 void rxml_init_encoding(void)
@@ -207,9 +197,7 @@ void rxml_init_encoding(void)
   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
+  rb_define_module_function(mXMLEncoding, "to_rb_encoding", rxml_encoding_to_rb_encoding, 2);
 
   /* -1: No char encoding detected. */
   rb_define_const(mXMLEncoding, "ERROR", INT2NUM(XML_CHAR_ENCODING_ERROR));

data/ext/libxml/ruby_xml_encoding.h

@@ -7,13 +7,10 @@ extern VALUE mXMLEncoding;
 
 void rxml_init_encoding();
 
-// Ruby 1.8/1.9 encoding compatibility
 VALUE rxml_new_cstr(const xmlChar* xstr, const xmlChar* xencoding);
 VALUE rxml_new_cstr_len(const xmlChar* xstr, const long length, const xmlChar* xencoding);
 
-#ifdef HAVE_RUBY_ENCODING_H
 rb_encoding* rxml_xml_encoding_to_rb_encoding(VALUE klass, xmlCharEncoding xmlEncoding);
 rb_encoding* rxml_figure_encoding(const xmlChar* xencoding);
-#endif
 
 #endif

data/ext/libxml/ruby_xml_io.c

@@ -1,13 +1,10 @@
 /* Please see the LICENSE file for copyright and distribution information */
 
 #include "ruby_libxml.h"
+#include <ruby/io.h>
 
 static ID READ_METHOD;
-#ifdef HAVE_RB_IO_BUFWRITE
-#include <ruby/io.h>
-#else
 static ID WRITE_METHOD;
-#endif /* !HAVE_RB_IO_BUFWRITE */
 
 /* This method is called by libxml when it wants to read
  more data from a stream. We go with the duck typing
@@ -27,25 +24,24 @@ int rxml_read_callback(void *context, char *buffer, int len)
   return (int)size;
 }
 
-int rxml_write_callback(void *context, const char *buffer, int len)
+int rxml_write_callback(VALUE io, const char *buffer, int len)
 {
-#ifndef HAVE_RB_IO_BUFWRITE
-  VALUE io, written, string;
-
-  io = (VALUE) context;
-  string = rb_str_new(buffer, len);
-  written = rb_funcall(io, WRITE_METHOD, 1, string);
-
-  return NUM2INT(written);
-#else
-  return (int)rb_io_bufwrite((VALUE) context, buffer, (size_t)len);
-#endif /* !HAVE_RB_IO_BUFWRITE */
+    if (rb_io_check_io(io) == Qnil)
+    {
+        // Could be StringIO
+        VALUE written, string;
+        string = rb_external_str_new_with_enc(buffer, strlen(buffer), rb_enc_get(io));
+        written = rb_funcall(io, WRITE_METHOD, 1, string);
+        return NUM2INT(written);
+    }
+    else
+    {
+        return (int)rb_io_bufwrite(io, buffer, (size_t)len);
+    }
 }
 
 void rxml_init_io(void)
 {
   READ_METHOD = rb_intern("read");
-#ifndef HAVE_RB_IO_BUFWRITE
   WRITE_METHOD = rb_intern("write");
-#endif /* !HAVE_RB_IO_BUFWRITE */
 }

data/ext/libxml/ruby_xml_io.h

@@ -4,7 +4,7 @@
 #define __RXML_IO__
 
 int rxml_read_callback(void *context, char *buffer, int len);
-int rxml_write_callback(void *context, const char *buffer, int len);
+int rxml_write_callback(VALUE io, const char *buffer, int len);
 void rxml_init_io(void);
 
 #endif

data/ext/libxml/ruby_xml_version.h

@@ -1,9 +1,9 @@
 /* Don't nuke this block!  It is used for automatically updating the
  * versions below. VERSION = string formatting, VERNUM = numbered
  * version for inline testing: increment both or none at all.*/
-#define RUBY_LIBXML_VERSION  "3.2.0"
-#define RUBY_LIBXML_VERNUM   320
+#define RUBY_LIBXML_VERSION  "3.2.1"
+#define RUBY_LIBXML_VERNUM   321
 #define RUBY_LIBXML_VER_MAJ   3
 #define RUBY_LIBXML_VER_MIN   2
-#define RUBY_LIBXML_VER_MIC   0
+#define RUBY_LIBXML_VER_MIC   1
 #define RUBY_LIBXML_VER_PATCH 0

data/ext/libxml/ruby_xml_writer.c

@@ -19,57 +19,29 @@ static VALUE sEncoding, sStandalone;
 #include <libxml/xmlwriter.h>
 
 
-typedef enum {
+typedef enum
+{
     RXMLW_OUTPUT_NONE,
     RXMLW_OUTPUT_IO,
     RXMLW_OUTPUT_DOC,
     RXMLW_OUTPUT_STRING
 } rxmlw_output_type;
 
-typedef struct {
+typedef struct
+{
     VALUE output;
-#ifdef HAVE_RUBY_ENCODING_H
-    rb_encoding *encoding;
-#endif /* HAVE_RUBY_ENCODING_H */
+    rb_encoding* encoding;
     xmlBufferPtr buffer;
     xmlTextWriterPtr writer;
     rxmlw_output_type output_type;
     int closed;
 } rxml_writer_object;
 
-#ifdef HAVE_RUBY_ENCODING_H
-
-#define /*VALUE*/ rxml_writer_c_to_ruby_string(/*const xmlChar **/ string, /*long*/ string_len) \
-    rb_external_str_new_with_enc(string, string_len, rb_utf8_encoding())
-
-#define /*VALUE*/ rxml_writer_ruby_string_to_utf8(/*VALUE*/ string) \
-    rb_str_conv_enc(string, rb_enc_get(string), rb_utf8_encoding())
-// rb_str_export_to_enc(string, rb_utf8_encoding())
-
-#define /*void*/ rxml_writer_free_utf8_string(/*VALUE*/ orig, /*VALUE*/ utf8) \
-    do {                       \
-        if (orig != utf8) {    \
-            rb_str_free(utf8); \
-        }                      \
-    } while (0);
-
-#else
-
-#define /*VALUE*/ rxml_writer_c_to_ruby_string(/*const xmlChar **/ string, /*long*/ string_len) \
-    rb_str_new(string, string_len)
-
-#define /*VALUE*/ rxml_writer_ruby_string_to_utf8(/*VALUE*/ string) \
-    string
-
-#define /*void*/ rxml_writer_free_utf8_string(/*VALUE*/ orig, /*VALUE*/ utf8) \
-    /* NOP */
-
-#endif /* HAVE_RUBY_ENCODING_H */
-
-static void rxml_writer_free(rxml_writer_object *rwo)
+static void rxml_writer_free(rxml_writer_object* rwo)
 {
 #if 0 /* seems to be done by xmlFreeTextWriter */
-    if (NULL != rwo->buffer) {
+    if (NULL != rwo->buffer)
+    {
         xmlBufferFree(rwo->buffer);
     }
 #endif
@@ -79,36 +51,40 @@ static void rxml_writer_free(rxml_writer_object *rwo)
     xfree(rwo);
 }
 
-static void rxml_writer_mark(rxml_writer_object *rwo)
+static void rxml_writer_mark(rxml_writer_object* rwo)
 {
-    if (!NIL_P(rwo->output)) {
+    if (!NIL_P(rwo->output))
+    {
         rb_gc_mark(rwo->output);
     }
 }
 
-static VALUE rxml_writer_wrap(rxml_writer_object *rwo)
+static VALUE rxml_writer_wrap(rxml_writer_object* rwo)
 {
     return Data_Wrap_Struct(cXMLWriter, rxml_writer_mark, rxml_writer_free, rwo);
 }
 
-static rxml_writer_object *rxml_textwriter_get(VALUE obj)
+static rxml_writer_object* rxml_textwriter_get(VALUE obj)
 {
-    rxml_writer_object *rwo;
+    rxml_writer_object* rwo;
 
     Data_Get_Struct(obj, rxml_writer_object, rwo);
 
     return rwo;
 }
 
-int rxml_writer_write_callback(void *context, const char *buffer, int len)
+int rxml_writer_write_callback(void* context, const char* buffer, int len)
 {
-  rxml_writer_object *rwo = context;
+    rxml_writer_object* rwo = context;
 
-  if(rwo->closed){
-    return 0;
-  }else{
-    return rxml_write_callback((void *)rwo->output, buffer, len);
-  }
+    if (rwo->closed)
+    {
+        return 0;
+    }
+    else
+    {
+        return rxml_write_callback(rwo->output, buffer, len);
+    }
 }
 
 /* ===== public class methods ===== */
@@ -120,31 +96,26 @@ int rxml_writer_write_callback(void *context, const char *buffer, int len)
  */
 static VALUE rxml_writer_io(VALUE klass, VALUE io)
 {
-#if 0
-typedef int (*xmlOutputCloseCallback)(void * context);
-typedef int (*xmlOutputWriteCallback)(void * context, const char * buffer, int len);
-
-ssize_t rb_io_bufwrite(VALUE io, const void *buf, size_t size);
-
-xmlOutputBufferPtr xmlOutputBufferCreateIO(xmlOutputWriteCallback iowrite, xmlOutputCloseCallback ioclose, void * ioctx, xmlCharEncodingHandlerPtr encoder)
-
-xmlCharEncodingHandlerPtr xmlFindCharEncodingHandler(const char * name);
-#endif
     xmlOutputBufferPtr out;
-    rxml_writer_object *rwo;
+    rxml_writer_object* rwo;
 
     rwo = ALLOC(rxml_writer_object);
     rwo->output = io;
     rwo->buffer = NULL;
     rwo->closed = 0;
-#ifdef HAVE_RUBY_ENCODING_H
-    rwo->encoding = NULL;
-#endif /* HAVE_RUBY_ENCODING_H */
+    rwo->encoding = rb_enc_get(io);
+    if (!rwo->encoding)
+        rwo->encoding = rb_utf8_encoding();
+
     rwo->output_type = RXMLW_OUTPUT_IO;
-    if (NULL == (out = xmlOutputBufferCreateIO(rxml_writer_write_callback, NULL, (void *) rwo, NULL))) {
+
+    xmlCharEncodingHandlerPtr encodingHdlr = xmlFindCharEncodingHandler(rwo->encoding->name);
+    if (NULL == (out = xmlOutputBufferCreateIO(rxml_writer_write_callback, NULL, (void*)rwo, encodingHdlr)))
+    {
         rxml_raise(&xmlLastError);
     }
-    if (NULL == (rwo->writer = xmlNewTextWriter(out))) {
+    if (NULL == (rwo->writer = xmlNewTextWriter(out)))
+    {
         rxml_raise(&xmlLastError);
     }
 
@@ -160,17 +131,16 @@ xmlCharEncodingHandlerPtr xmlFindCharEncodingHandler(const char * name);
  */
 static VALUE rxml_writer_file(VALUE klass, VALUE filename)
 {
-    rxml_writer_object *rwo;
+    rxml_writer_object* rwo;
 
     rwo = ALLOC(rxml_writer_object);
     rwo->output = Qnil;
     rwo->buffer = NULL;
     rwo->closed = 0;
-#ifdef HAVE_RUBY_ENCODING_H
-    rwo->encoding = NULL;
-#endif /* HAVE_RUBY_ENCODING_H */
+    rwo->encoding = rb_utf8_encoding();
     rwo->output_type = RXMLW_OUTPUT_NONE;
-    if (NULL == (rwo->writer = xmlNewTextWriterFilename(StringValueCStr(filename), 0))) {
+    if (NULL == (rwo->writer = xmlNewTextWriterFilename(StringValueCStr(filename), 0)))
+    {
         rxml_raise(&xmlLastError);
     }
 
@@ -184,19 +154,19 @@ static VALUE rxml_writer_file(VALUE klass, VALUE filename)
  */
 static VALUE rxml_writer_string(VALUE klass)
 {
-    rxml_writer_object *rwo;
+    rxml_writer_object* rwo;
 
     rwo = ALLOC(rxml_writer_object);
     rwo->output = Qnil;
     rwo->closed = 0;
-#ifdef HAVE_RUBY_ENCODING_H
-    rwo->encoding = NULL;
-#endif /* HAVE_RUBY_ENCODING_H */
+    rwo->encoding = rb_utf8_encoding();
     rwo->output_type = RXMLW_OUTPUT_STRING;
-    if (NULL == (rwo->buffer = xmlBufferCreate())) {
+    if (NULL == (rwo->buffer = xmlBufferCreate()))
+    {
         rxml_raise(&xmlLastError);
     }
-    if (NULL == (rwo->writer = xmlNewTextWriterMemory(rwo->buffer, 0))) {
+    if (NULL == (rwo->writer = xmlNewTextWriterMemory(rwo->buffer, 0)))
+    {
         xmlBufferFree(rwo->buffer);
         rxml_raise(&xmlLastError);
     }
@@ -212,17 +182,16 @@ static VALUE rxml_writer_string(VALUE klass)
 static VALUE rxml_writer_doc(VALUE klass)
 {
     xmlDocPtr doc;
-    rxml_writer_object *rwo;
+    rxml_writer_object* rwo;
 
     rwo = ALLOC(rxml_writer_object);
     rwo->buffer = NULL;
     rwo->output = Qnil;
     rwo->closed = 0;
-#ifdef HAVE_RUBY_ENCODING_H
-    rwo->encoding = NULL;
-#endif /* HAVE_RUBY_ENCODING_H */
+    rwo->encoding = rb_utf8_encoding();
     rwo->output_type = RXMLW_OUTPUT_DOC;
-    if (NULL == (rwo->writer = xmlNewTextWriterDoc(&doc, 0))) {
+    if (NULL == (rwo->writer = xmlNewTextWriterDoc(&doc, 0)))
+    {
         rxml_raise(&xmlLastError);
     }
     rwo->output = rxml_document_wrap(doc);
@@ -240,33 +209,34 @@ static VALUE rxml_writer_doc(VALUE klass)
  * If +empty?+ is +true+, and for a in memory XML::Writer, this internel
  * buffer is empty.
  */
-static VALUE rxml_writer_flush(int argc, VALUE *argv, VALUE self)
+static VALUE rxml_writer_flush(int argc, VALUE* argv, VALUE self)
 {
     int ret;
     VALUE empty;
-    rxml_writer_object *rwo;
+    rxml_writer_object* rwo;
 
     rb_scan_args(argc, argv, "01", &empty);
 
     rwo = rxml_textwriter_get(self);
-    if (-1 == (ret = xmlTextWriterFlush(rwo->writer))) {
+    if (-1 == (ret = xmlTextWriterFlush(rwo->writer)))
+    {
         rxml_raise(&xmlLastError);
     }
 
-    if (NULL != rwo->buffer) {
+    if (NULL != rwo->buffer)
+    {
         VALUE content;
 
-#ifdef HAVE_RUBY_ENCODING_H
         content = rb_external_str_new_with_enc((const char*)rwo->buffer->content, rwo->buffer->use, rwo->encoding);
-#else
-        content = rb_str_new(rwo->buffer->content, rwo->buffer->use);
-#endif /* HAVE_RUBY_ENCODING_H */
-        if (NIL_P(empty) || RTEST(empty)) { /* nil = default value = true */
+        if (NIL_P(empty) || RTEST(empty))
+        { /* nil = default value = true */
             xmlBufferEmpty(rwo->buffer);
         }
 
         return content;
-    } else {
+    }
+    else
+    {
         return INT2NUM(ret);
     }
 }
@@ -281,26 +251,28 @@ static VALUE rxml_writer_flush(int argc, VALUE *argv, VALUE self)
 static VALUE rxml_writer_result(VALUE self)
 {
     VALUE ret = Qnil;
-    rxml_writer_object *rwo = rxml_textwriter_get(self);
+    rxml_writer_object* rwo = rxml_textwriter_get(self);
     int bytesWritten = xmlTextWriterFlush(rwo->writer);
 
-    if (bytesWritten == -1) {
+    if (bytesWritten == -1)
+    {
         rxml_raise(&xmlLastError);
     }
 
-    switch (rwo->output_type) {
-        case RXMLW_OUTPUT_DOC:
-            ret = rwo->output;
-            break;
-        case RXMLW_OUTPUT_STRING:
-            ret = rxml_writer_c_to_ruby_string((const char*)rwo->buffer->content, rwo->buffer->use);
-            break;
-        case RXMLW_OUTPUT_IO:
-        case RXMLW_OUTPUT_NONE:
-            break;
-        default:
-            rb_bug("unexpected output");
-            break;
+    switch (rwo->output_type)
+    {
+    case RXMLW_OUTPUT_DOC:
+        ret = rwo->output;
+        break;
+    case RXMLW_OUTPUT_STRING:
+        ret = rb_external_str_new_with_enc((const char*)rwo->buffer->content, rwo->buffer->use, rwo->encoding);
+        break;
+    case RXMLW_OUTPUT_IO:
+    case RXMLW_OUTPUT_NONE:
+        break;
+    default:
+        rb_bug("unexpected output");
+        break;
     }
 
     return ret;
@@ -311,7 +283,7 @@ static VALUE rxml_writer_result(VALUE self)
 static VALUE numeric_rxml_writer_void(VALUE obj, int (*fn)(xmlTextWriterPtr))
 {
     int ret;
-    rxml_writer_object *rwo;
+    rxml_writer_object* rwo;
 
     rwo = rxml_textwriter_get(obj);
     ret = fn(rwo->writer);
@@ -335,88 +307,102 @@ static VALUE numeric_rxml_writer_va_strings(VALUE obj, VALUE pe, size_t strings_
 {
     va_list ap;
     size_t argc;
-	int ret = -1;
-    rxml_writer_object *rwo;
-    const xmlChar *argv[XMLWRITER_MAX_STRING_ARGS];
+    int ret = -1;
+    rxml_writer_object* rwo;
+    const xmlChar* argv[XMLWRITER_MAX_STRING_ARGS];
     VALUE utf8[XMLWRITER_MAX_STRING_ARGS], orig[XMLWRITER_MAX_STRING_ARGS];
 
-    if (strings_count > XMLWRITER_MAX_STRING_ARGS) {
+    if (strings_count > XMLWRITER_MAX_STRING_ARGS)
+    {
         rb_bug("more arguments than expected");
     }
     va_start(ap, fn);
     rwo = rxml_textwriter_get(obj);
-    for (argc = 0; argc < strings_count; argc++) {
+    for (argc = 0; argc < strings_count; argc++)
+    {
         VALUE arg;
 
         arg = va_arg(ap, VALUE);
         orig[argc] = arg;
-        if (NIL_P(arg)) {
+        if (NIL_P(arg))
+        {
             utf8[argc] = Qnil;
             argv[argc] = NULL;
-        } else {
-            utf8[argc] = rxml_writer_ruby_string_to_utf8(orig[argc]);
+        }
+        else
+        {
+            utf8[argc] = rb_str_conv_enc(orig[argc], rb_enc_get(orig[argc]), rwo->encoding);
             argv[argc] = BAD_CAST StringValueCStr(utf8[argc]);
         }
     }
     va_end(ap);
 
-    if (Qundef == pe) {
-        switch (strings_count) {
-            case 0:
-                ret = fn(rwo->writer);
-                break;
-            case 1:
-                ret = fn(rwo->writer, argv[0]);
-                break;
-            case 2:
-                ret = fn(rwo->writer, argv[0], argv[1]);
-                break;
-            case 3:
-                ret = fn(rwo->writer, argv[0], argv[1], argv[2]);
-                break;
-            case 4:
-                ret = fn(rwo->writer, argv[0], argv[1], argv[2], argv[3]);
-                break;
-            case 5:
-                ret = fn(rwo->writer, argv[0], argv[1], argv[2], argv[3], argv[4]);
-                break;
-            default:
-                break;
+    if (Qundef == pe)
+    {
+        switch (strings_count)
+        {
+        case 0:
+            ret = fn(rwo->writer);
+            break;
+        case 1:
+            ret = fn(rwo->writer, argv[0]);
+            break;
+        case 2:
+            ret = fn(rwo->writer, argv[0], argv[1]);
+            break;
+        case 3:
+            ret = fn(rwo->writer, argv[0], argv[1], argv[2]);
+            break;
+        case 4:
+            ret = fn(rwo->writer, argv[0], argv[1], argv[2], argv[3]);
+            break;
+        case 5:
+            ret = fn(rwo->writer, argv[0], argv[1], argv[2], argv[3], argv[4]);
+            break;
+        default:
+            break;
         }
-    } else {
+    }
+    else
+    {
         int xpe;
 
         xpe = RTEST(pe);
-        switch (strings_count) { /* strings_count doesn't include pe */
-            case 0:
-                ret = fn(rwo->writer, xpe);
-                break;
-            case 1:
-                ret = fn(rwo->writer, xpe, argv[0]);
-                break;
-            case 2:
-                ret = fn(rwo->writer, xpe, argv[0], argv[1]);
-                break;
-            case 3:
-                ret = fn(rwo->writer, xpe, argv[0], argv[1], argv[2]);
-                break;
-            case 4:
-                ret = fn(rwo->writer, xpe, argv[0], argv[1], argv[2], argv[3]);
-                break;
-            case 5:
-                ret = fn(rwo->writer, xpe, argv[0], argv[1], argv[2], argv[3], argv[4]);
-                break;
-            default:
-                break;
+        switch (strings_count)
+        { /* strings_count doesn't include pe */
+        case 0:
+            ret = fn(rwo->writer, xpe);
+            break;
+        case 1:
+            ret = fn(rwo->writer, xpe, argv[0]);
+            break;
+        case 2:
+            ret = fn(rwo->writer, xpe, argv[0], argv[1]);
+            break;
+        case 3:
+            ret = fn(rwo->writer, xpe, argv[0], argv[1], argv[2]);
+            break;
+        case 4:
+            ret = fn(rwo->writer, xpe, argv[0], argv[1], argv[2], argv[3]);
+            break;
+        case 5:
+            ret = fn(rwo->writer, xpe, argv[0], argv[1], argv[2], argv[3], argv[4]);
+            break;
+        default:
+            break;
         }
     }
-#ifdef HAVE_RUBY_ENCODING_H
-    while (--strings_count > 0) {
-        if (!NIL_P(orig[strings_count])) {
-            rxml_writer_free_utf8_string(orig[strings_count], utf8[strings_count]);
+
+    while (--strings_count > 0)
+    {
+        if (!NIL_P(orig[strings_count]))
+        {
+            if (orig[strings_count] != utf8[strings_count])
+            {
+                rb_str_free(utf8[strings_count]);
+            }
         }
     }
-#endif /* HAVE_RUBY_ENCODING_H */
 
     return (-1 == ret ? Qfalse : Qtrue);
 }
@@ -434,7 +420,7 @@ static VALUE numeric_rxml_writer_va_strings(VALUE obj, VALUE pe, size_t strings_
 static VALUE rxml_writer_set_indent(VALUE self, VALUE indentation)
 {
     int ret;
-    rxml_writer_object *rwo;
+    rxml_writer_object* rwo;
 
     rwo = rxml_textwriter_get(self);
     ret = xmlTextWriterSetIndent(rwo->writer, RTEST(indentation));
@@ -484,7 +470,7 @@ static VALUE rxml_writer_write_cdata(VALUE self, VALUE content)
 }
 
 static VALUE rxml_writer_start_element(VALUE, VALUE);
-static VALUE rxml_writer_start_element_ns(int, VALUE *, VALUE);
+static VALUE rxml_writer_start_element_ns(int, VALUE*, VALUE);
 static VALUE rxml_writer_end_element(VALUE);
 
 /* call-seq:
@@ -494,17 +480,21 @@ static VALUE rxml_writer_end_element(VALUE);
  * This is equivalent to start_element(name) + write_string(content) +
  * end_element.
  */
-static VALUE rxml_writer_write_element(int argc, VALUE *argv, VALUE self)
+static VALUE rxml_writer_write_element(int argc, VALUE* argv, VALUE self)
 {
     VALUE name, content;
 
     rb_scan_args(argc, argv, "11", &name, &content);
-    if (Qnil == content) {
-        if (Qfalse == rxml_writer_start_element(self, name)) {
+    if (Qnil == content)
+    {
+        if (Qfalse == rxml_writer_start_element(self, name))
+        {
             return Qfalse;
         }
         return rxml_writer_end_element(self);
-    } else {
+    }
+    else
+    {
         return numeric_rxml_writer_va_strings(self, Qundef, 2, xmlTextWriterWriteElement, name, content);
     }
 }
@@ -526,19 +516,23 @@ static VALUE rxml_writer_write_element(int argc, VALUE *argv, VALUE self)
  * earlier.
  * - +content+ can be omitted for an empty tag
  */
-static VALUE rxml_writer_write_element_ns(int argc, VALUE *argv, VALUE self)
+static VALUE rxml_writer_write_element_ns(int argc, VALUE* argv, VALUE self)
 {
     VALUE prefix, name, namespaceURI, content;
 
     rb_scan_args(argc, argv, "22", &prefix, &name, &namespaceURI, &content);
-    if (Qnil == content) {
+    if (Qnil == content)
+    {
         VALUE argv[3] = { prefix, name, namespaceURI };
 
-        if (Qfalse == rxml_writer_start_element_ns(ARRAY_SIZE(argv), argv, self)) {
+        if (Qfalse == rxml_writer_start_element_ns(ARRAY_SIZE(argv), argv, self))
+        {
             return Qfalse;
         }
         return rxml_writer_end_element(self);
-    } else {
+    }
+    else
+    {
         return numeric_rxml_writer_va_strings(self, Qundef, 4, xmlTextWriterWriteElementNS, prefix, name, namespaceURI, content);
     }
 }
@@ -568,7 +562,7 @@ static VALUE rxml_writer_write_attribute(VALUE self, VALUE name, VALUE content)
  * earlier.
  * - +content+ can be omitted too for an empty attribute
  */
-static VALUE rxml_writer_write_attribute_ns(int argc, VALUE *argv, VALUE self)
+static VALUE rxml_writer_write_attribute_ns(int argc, VALUE* argv, VALUE self)
 {
     VALUE prefix, name, namespaceURI, content;
 
@@ -634,7 +628,7 @@ static VALUE rxml_writer_start_attribute(VALUE self, VALUE name)
  * +namespaceURI+ to nil or omit it. Don't forget to declare the namespace
  * prefix somewhere earlier.
  */
-static VALUE rxml_writer_start_attribute_ns(int argc, VALUE *argv, VALUE self)
+static VALUE rxml_writer_start_attribute_ns(int argc, VALUE* argv, VALUE self)
 {
     VALUE prefix, name, namespaceURI;
 
@@ -697,7 +691,7 @@ static VALUE rxml_writer_start_element(VALUE self, VALUE name)
  * +namespaceURI+ to nil or omit it. Don't forget to declare the namespace
  * prefix somewhere earlier.
  */
-static VALUE rxml_writer_start_element_ns(int argc, VALUE *argv, VALUE self)
+static VALUE rxml_writer_start_element_ns(int argc, VALUE* argv, VALUE self)
 {
     VALUE prefix, name, namespaceURI;
 
@@ -762,16 +756,17 @@ static VALUE rxml_writer_end_cdata(VALUE self)
  * - standalone: nil (default) or a boolean to indicate if the document is
  * standalone or not
  */
-static VALUE rxml_writer_start_document(int argc, VALUE *argv, VALUE self)
+static VALUE rxml_writer_start_document(int argc, VALUE* argv, VALUE self)
 {
     int ret;
     VALUE options = Qnil;
-    rxml_writer_object *rwo;
-    const xmlChar *xencoding = NULL;
-    const char *xstandalone = NULL;
+    rxml_writer_object* rwo;
+    const xmlChar* xencoding = NULL;
+    const char* xstandalone = NULL;
 
     rb_scan_args(argc, argv, "01", &options);
-    if (!NIL_P(options)) {
+    if (!NIL_P(options))
+    {
         VALUE encoding, standalone;
 
         encoding = standalone = Qnil;
@@ -779,16 +774,17 @@ static VALUE rxml_writer_start_document(int argc, VALUE *argv, VALUE self)
         encoding = rb_hash_aref(options, sEncoding);
         xencoding = NIL_P(encoding) ? NULL : (const xmlChar*)xmlGetCharEncodingName(NUM2INT(encoding));
         standalone = rb_hash_aref(options, sStandalone);
-        if (NIL_P(standalone)) {
+        if (NIL_P(standalone))
+        {
             xstandalone = NULL;
-        } else {
+        }
+        else
+        {
             xstandalone = RTEST(standalone) ? "yes" : "no";
         }
     }
     rwo = rxml_textwriter_get(self);
-#ifdef HAVE_RUBY_ENCODING_H
     rwo->encoding = rxml_figure_encoding(xencoding);
-#endif /* !HAVE_RUBY_ENCODING_H */
     ret = xmlTextWriterStartDocument(rwo->writer, NULL, (const char*)xencoding, xstandalone);
 
     return (-1 == ret ? Qfalse : Qtrue);
@@ -829,7 +825,7 @@ static VALUE rxml_writer_end_pi(VALUE self)
  *
  * Starts a DTD. Returns +false+ on failure.
  */
-static VALUE rxml_writer_start_dtd(int argc, VALUE *argv, VALUE self)
+static VALUE rxml_writer_start_dtd(int argc, VALUE* argv, VALUE self)
 {
     VALUE name, pubid, sysid;
 
@@ -853,12 +849,13 @@ static VALUE rxml_writer_start_dtd_element(VALUE self, VALUE name)
  *
  * Starts a DTD entity (<!ENTITY ... >). Returns +false+ on failure.
  */
-static VALUE rxml_writer_start_dtd_entity(int argc, VALUE *argv, VALUE self)
+static VALUE rxml_writer_start_dtd_entity(int argc, VALUE* argv, VALUE self)
 {
     VALUE name, pe;
 
     rb_scan_args(argc, argv, "11", &name, &pe);
-    if (NIL_P(pe)) {
+    if (NIL_P(pe))
+    {
         pe = Qfalse;
     }
 
@@ -934,7 +931,7 @@ static VALUE rxml_writer_end_dtd_element(VALUE self)
  *   writer.write_dtd 'person', nil, nil, '<!ELEMENT person (firstname,lastname)><!ELEMENT firstname (#PCDATA)><!ELEMENT lastname (#PCDATA)>'
  *     #=> <!DOCTYPE person [<!ELEMENT person (firstname,lastname)><!ELEMENT firstname (#PCDATA)><!ELEMENT lastname (#PCDATA)>]>
  */
-static VALUE rxml_writer_write_dtd(int argc, VALUE *argv, VALUE self)
+static VALUE rxml_writer_write_dtd(int argc, VALUE* argv, VALUE self)
 {
     VALUE name, pubid, sysid, subset;
 
@@ -1043,12 +1040,12 @@ static VALUE rxml_writer_write_dtd_notation(VALUE self, VALUE name, VALUE pubid,
 static VALUE rxml_writer_set_quote_char(VALUE self, VALUE quotechar)
 {
     int ret;
-    const char *xquotechar;
-    rxml_writer_object *rwo;
+    const char* xquotechar;
+    rxml_writer_object* rwo;
 
     rwo = rxml_textwriter_get(self);
     xquotechar = StringValueCStr(quotechar);
-    ret = xmlTextWriterSetQuoteChar(rwo->writer, (xmlChar) xquotechar[0]);
+    ret = xmlTextWriterSetQuoteChar(rwo->writer, (xmlChar)xquotechar[0]);
 
     return (-1 == ret ? Qfalse : Qtrue);
 }