libxml-ruby 0.9.4 → 0.9.5

data/ext/libxml/ruby_xml_attributes.c

@@ -3,160 +3,158 @@
 /* Please see the LICENSE file for copyright and distribution information */
 
 /*
-* Document-class: LibXML::XML::Attributes
-*
-* Provides access to an element's attributes (XML::Attr).
-*
-* Basic Usage:
-*  require 'xml'
-*
-*  doc = XML::Document.new(<some_file>)
-*  attributes = doc.root.attributes
-*
-*  attributes.each do |attribute|
-*    ..
-*  end
-* 
-*  attributes['foo'] = 'bar'
-*  attribute = attributes.get_attribute['foo']
-*  attribute.value == 'foo'
-*
-* To access a namespaced attribute:
-*
-*  XLINK_URI = 'http://www.w3.org/1999/xlink'
-*
-*  attribute = attributes.get_attribute_ns(XLINK_URI, 'title')
-*  attribute.value = 'My title'
-*/
+ * Document-class: LibXML::XML::Attributes
+ *
+ * Provides access to an element's attributes (XML::Attr).
+ *
+ * Basic Usage:
+ *  require 'xml'
+ *
+ *  doc = XML::Document.new(<some_file>)
+ *  attributes = doc.root.attributes
+ *
+ *  attributes.each do |attribute|
+ *    ..
+ *  end
+ *
+ *  attributes['foo'] = 'bar'
+ *  attribute = attributes.get_attribute['foo']
+ *  attribute.value == 'foo'
+ *
+ * To access a namespaced attribute:
+ *
+ *  XLINK_URI = 'http://www.w3.org/1999/xlink'
+ *
+ *  attribute = attributes.get_attribute_ns(XLINK_URI, 'title')
+ *  attribute.value = 'My title'
+ */
 
 #include "ruby_libxml.h"
 #include "ruby_xml_attributes.h"
 
 VALUE cXMLAttributes;
 
-void
-rxml_attributes_mark(xmlNodePtr xnode) {
+void rxml_attributes_mark(xmlNodePtr xnode)
+{
   rxml_node_mark_common(xnode);
 }
 
 /*
  * Creates a  new attributes instance.  Not exposed to ruby.
  */
-VALUE
-rxml_attributes_new(xmlNodePtr xnode)
+VALUE rxml_attributes_new(xmlNodePtr xnode)
 {
-  return Data_Wrap_Struct(cXMLAttributes,
-                          rxml_attributes_mark, NULL,
-                          xnode);
+  return Data_Wrap_Struct(cXMLAttributes, rxml_attributes_mark, NULL, xnode);
 }
 
 /*
  * call-seq:
  *   attributes.node -> XML::Node
- * 
+ *
  * Return the node that owns this attributes list.
  *
  *  doc.root.attributes.node == doc.root
  */
-VALUE
-rxml_attributes_node_get(VALUE self) {
+VALUE rxml_attributes_node_get(VALUE self)
+{
   xmlNodePtr xnode;
   Data_Get_Struct(self, xmlNode, xnode);
-  return(rxml_node2_wrap(cXMLNode, xnode));
+  return (rxml_node_wrap(cXMLNode, xnode));
 }
 
-
 /*
  * call-seq:
  *    attributes.get_attribute("name") -> XML::Attr
- * 
+ *
  * Returns the specified attribute.
- * 
+ *
  * name: The name of the attribute, not including a namespace.
  *
  *  doc.root.attributes.get_attribute("foo")
  */
-static VALUE
-rxml_attributes_get_attribute(VALUE self, VALUE name) {
+static VALUE rxml_attributes_get_attribute(VALUE self, VALUE name)
+{
   xmlNodePtr xnode;
   xmlAttrPtr xattr;
 
   name = check_string_or_symbol(name);
-  
+
   Data_Get_Struct(self, xmlNode, xnode);
-  
-  xattr = xmlHasProp(xnode, (xmlChar*)StringValuePtr(name));
-  
+
+  xattr = xmlHasProp(xnode, (xmlChar*) StringValuePtr(name));
+
   if (xattr)
-    return(rxml_attr_wrap(xattr));
+    return (rxml_attr_wrap(xattr));
   else
-    return(Qnil);
+    return (Qnil);
 }
 
 /*
  * call-seq:
  *    attributes.get_attribute_ns("namespace", "name") -> XML::Attr
- * 
+ *
  * Returns the specified attribute.
- * 
+ *
  * namespace: The URI of the attribute's namespace.
  * name: The name of the attribute, not including a namespace.
  *
  *  doc.root.attributes.get_attribute_ns('http://www.w3.org/1999/xlink', 'href')
  */
-static VALUE
-rxml_attributes_get_attribute_ns(VALUE self, VALUE namespace, VALUE name) {
+static VALUE rxml_attributes_get_attribute_ns(VALUE self, VALUE namespace,
+    VALUE name)
+{
   xmlNodePtr xnode;
   xmlAttrPtr xattr;
 
   name = check_string_or_symbol(name);
-  
+
   Data_Get_Struct(self, xmlNode, xnode);
-  
-  xattr = xmlHasNsProp(xnode, (xmlChar*)StringValuePtr(name), (xmlChar*)StringValuePtr(namespace));
-  
+
+  xattr = xmlHasNsProp(xnode, (xmlChar*) StringValuePtr(name),
+      (xmlChar*) StringValuePtr(namespace));
+
   if (xattr)
-    return(rxml_attr_wrap(xattr));
+    return (rxml_attr_wrap(xattr));
   else
-    return(Qnil);
+    return (Qnil);
 }
 
 /*
  * call-seq:
  *    attributes["name"] -> String
- * 
+ *
  * Fetches an attribute value. If you want to access the underlying
- * Attribute itself use get_attribute.  
+ * Attribute itself use get_attribute.
  *
  * name: The name of the attribute, not including any namespaces.
- *  
+ *
  *  doc.root.attributes['att'] -> 'some value'
  */
-VALUE
-rxml_attributes_attribute_get(VALUE self, VALUE name) {
+VALUE rxml_attributes_attribute_get(VALUE self, VALUE name)
+{
   VALUE xattr = rxml_attributes_get_attribute(self, name);
-  if NIL_P(xattr)
+  if (NIL_P(xattr))
     return(Qnil);
   else
     return rxml_attr_value_get(xattr);
-}  
+}
 
 /*
  * call-seq:
  *    attributes["name"] = "value"
- * 
+ *
  * Sets an attribute value. If you want to get the Attribute itself,
- * use get_attribute.  
+ * use get_attribute.
  *
  * name: The name of the attribute, not including any namespaces.
  * value: The new value of the namespace.
- *  
+ *
  *  doc.root.attributes['att'] = 'some value'
  */
-VALUE
-rxml_attributes_attribute_set(VALUE self, VALUE name, VALUE value) {
+VALUE rxml_attributes_attribute_set(VALUE self, VALUE name, VALUE value)
+{
   VALUE xattr = rxml_attributes_get_attribute(self, name);
-  if NIL_P(xattr)
+  if (NIL_P(xattr))
   {
     VALUE args[3];
 
@@ -170,19 +168,18 @@ rxml_attributes_attribute_set(VALUE self, VALUE name, VALUE value) {
   {
     return rxml_attr_value_set(xattr, value);
   }
-}  
-
+}
 
 /*
  * call-seq:
  *    attributes.each {block} -> XML::Attr
- * 
+ *
  * Iterates over each attribute.
- *  
+ *
  *  doc.root.attributes.each {|attribute| puts attribute.name}
  */
-static VALUE
-rxml_attributes_each(VALUE self) {
+static VALUE rxml_attributes_each(VALUE self)
+{
   xmlNodePtr xnode;
   xmlAttrPtr xattr;
   Data_Get_Struct(self, xmlNode, xnode);
@@ -191,24 +188,24 @@ rxml_attributes_each(VALUE self) {
 
   while (xattr)
   {
-     VALUE attr = rxml_attr_wrap(xattr);
-     rb_yield(attr);
-     xattr = xattr->next;
+    VALUE attr = rxml_attr_wrap(xattr);
+    rb_yield(attr);
+    xattr = xattr->next;
   }
-  
+
   return self;
-}  
-  
+}
+
 /*
  * call-seq:
  *    attributes.length -> Integer
- * 
+ *
  * Returns the number of attributes.
  *
  *  doc.root.attributes.length
  */
-static VALUE
-rxml_attributes_length(VALUE self) {
+static VALUE rxml_attributes_length(VALUE self)
+{
   int length = 0;
   xmlNodePtr xnode;
   xmlAttrPtr xattr;
@@ -218,49 +215,53 @@ rxml_attributes_length(VALUE self) {
 
   while (xattr)
   {
-     length++;
-     xattr = xattr->next;
+    length++;
+    xattr = xattr->next;
   }
-  
+
   return INT2NUM(length);
-}  
+}
 
 /*
  * call-seq:
  *    attributes.first -> XML::Attr
- * 
+ *
  * Returns the first attribute.
  *
  *  doc.root.attributes.first
  */
-static VALUE
-rxml_attributes_first(VALUE self) {
+static VALUE rxml_attributes_first(VALUE self)
+{
   xmlNodePtr xnode;
   Data_Get_Struct(self, xmlNode, xnode);
 
-  if (xnode->type == XML_ELEMENT_NODE) {
+  if (xnode->type == XML_ELEMENT_NODE)
+  {
     xmlAttrPtr xattr = xnode->properties;
-    
-    if (xattr) {
-      return(rxml_attr_wrap(xattr));
+
+    if (xattr)
+    {
+      return (rxml_attr_wrap(xattr));
     }
-  } 
-  return(Qnil);
+  }
+  return (Qnil);
 }
 
-// Rdoc needs to know 
+// Rdoc needs to know
 #ifdef RDOC_NEVER_DEFINED
-  mLibXML = rb_define_module("LibXML");
-  mXML = rb_define_module_under(mLibXML, "XML");
+mLibXML = rb_define_module("LibXML");
+mXML = rb_define_module_under(mLibXML, "XML");
 #endif
-    
-void
-ruby_init_xml_attributes(void) {
+
+void ruby_init_xml_attributes(void)
+{
   cXMLAttributes = rb_define_class_under(mXML, "Attributes", rb_cObject);
   rb_include_module(cXMLAttributes, rb_mEnumerable);
   rb_define_method(cXMLAttributes, "node", rxml_attributes_node_get, 0);
-  rb_define_method(cXMLAttributes, "get_attribute", rxml_attributes_get_attribute, 1);
-  rb_define_method(cXMLAttributes, "get_attribute_ns", rxml_attributes_get_attribute_ns, 2);
+  rb_define_method(cXMLAttributes, "get_attribute",
+      rxml_attributes_get_attribute, 1);
+  rb_define_method(cXMLAttributes, "get_attribute_ns",
+      rxml_attributes_get_attribute_ns, 2);
   rb_define_method(cXMLAttributes, "[]", rxml_attributes_attribute_get, 1);
   rb_define_method(cXMLAttributes, "[]=", rxml_attributes_attribute_set, 2);
   rb_define_method(cXMLAttributes, "each", rxml_attributes_each, 0);

data/ext/libxml/ruby_xml_document.c

@@ -1,148 +1,147 @@
-/* $Id: ruby_xml_document.c 626 2008-11-22 20:47:07Z cfis $ */
+/* $Id: ruby_xml_document.c 650 2008-11-30 03:40:22Z cfis $ */
 
 /*
-* Document-class: LibXML::XML::Document
-*
-* The XML::Document class provides a tree based API for working
-* with xml documents.  You may directly create a document and
-* manipulate it, or create a document from a data source by
-* using an XML::Parser object.
-*
-* To create a document from scratch:
-*
-*  doc = XML::Document.new()
-*  doc.root = XML::Node.new('root_node')
-*  doc.root << XML::Node.new('elem1')
-*  doc.save('output.xml', format)
-* 
-* To read a document from a file:
-* 
-*   doc = XML::Document.file('my_file')
-*
-* To use a parser to read a document:
-*
-*   parser = XML::Parser.new
-*   parser.file = 'my_file'
-*   doc = parser.parse
-*
-* To write a file:
-*
-*
-*  doc = XML::Document.new()
-*  doc.root = XML::Node.new('root_node')
-*  root = doc.root
-*  
-*  root << elem1 = XML::Node.new('elem1')
-*  elem1['attr1'] = 'val1'
-*  elem1['attr2'] = 'val2'
-*
-*  root << elem2 = XML::Node.new('elem2')
-*  elem2['attr1'] = 'val1'
-*  elem2['attr2'] = 'val2'
-*
-*  root << elem3 = XML::Node.new('elem3')
-*  elem3 << elem4 = XML::Node.new('elem4')
-*  elem3 << elem5 = XML::Node.new('elem5')
-*
-*  elem5 << elem6 = XML::Node.new('elem6')
-*  elem6 << 'Content for element 6'
-*
-*  elem3['attr'] = 'baz'
-*  
-*  format = true
-*  doc.save('output.xml', format)
-*/
+ * Document-class: LibXML::XML::Document
+ *
+ * The XML::Document class provides a tree based API for working
+ * with xml documents.  You may directly create a document and
+ * manipulate it, or create a document from a data source by
+ * using an XML::Parser object.
+ *
+ * To create a document from scratch:
+ *
+ *  doc = XML::Document.new()
+ *  doc.root = XML::Node.new('root_node')
+ *  doc.root << XML::Node.new('elem1')
+ *  doc.save('output.xml', format)
+ *
+ * To read a document from a file:
+ *
+ *   doc = XML::Document.file('my_file')
+ *
+ * To use a parser to read a document:
+ *
+ *   parser = XML::Parser.new
+ *   parser.file = 'my_file'
+ *   doc = parser.parse
+ *
+ * To write a file:
+ *
+ *
+ *  doc = XML::Document.new()
+ *  doc.root = XML::Node.new('root_node')
+ *  root = doc.root
+ *
+ *  root << elem1 = XML::Node.new('elem1')
+ *  elem1['attr1'] = 'val1'
+ *  elem1['attr2'] = 'val2'
+ *
+ *  root << elem2 = XML::Node.new('elem2')
+ *  elem2['attr1'] = 'val1'
+ *  elem2['attr2'] = 'val2'
+ *
+ *  root << elem3 = XML::Node.new('elem3')
+ *  elem3 << elem4 = XML::Node.new('elem4')
+ *  elem3 << elem5 = XML::Node.new('elem5')
+ *
+ *  elem5 << elem6 = XML::Node.new('elem6')
+ *  elem6 << 'Content for element 6'
+ *
+ *  elem3['attr'] = 'baz'
+ *
+ *  format = true
+ *  doc.save('output.xml', format)
+ */
 
 #include <stdarg.h>
 #include <st.h>
 #include "ruby_libxml.h"
 #include "ruby_xml_document.h"
 
-
 VALUE cXMLDocument;
 
-void
-rxml_document_free(xmlDocPtr xdoc) {
+void rxml_document_free(xmlDocPtr xdoc)
+{
   xdoc->_private = NULL;
   xmlFreeDoc(xdoc);
-}   
- 
-void
-rxml_document_mark(xmlDocPtr xdoc) {
+}
+
+void rxml_document_mark(xmlDocPtr xdoc)
+{
   rb_gc_mark(LIBXML_STATE);
 }
 
-VALUE
-rxml_document_wrap(xmlDocPtr xdoc) {
+VALUE rxml_document_wrap(xmlDocPtr xdoc)
+{
   VALUE result;
 
   // This node is already wrapped
   if (xdoc->_private != NULL)
   {
-    result = (VALUE)xdoc->_private;
+    result = (VALUE) xdoc->_private;
   }
-  else  
+  else
   {
-    result = Data_Wrap_Struct(cXMLDocument, rxml_document_mark, rxml_document_free, xdoc);
-    xdoc->_private = (void*)result;
+    result = Data_Wrap_Struct(cXMLDocument, rxml_document_mark,
+        rxml_document_free, xdoc);
+    xdoc->_private = (void*) result;
   }
-     
+
   return result;
 }
 
-
 /*
  * call-seq:
  *    XML::Document.alloc(xml_version = 1.0) -> document
- * 
+ *
  * Alocates a new XML::Document, optionally specifying the
  * XML version.
  */
-static VALUE
-rxml_document_alloc(VALUE klass) {
+static VALUE rxml_document_alloc(VALUE klass)
+{
   return Data_Wrap_Struct(klass, rxml_document_mark, rxml_document_free, NULL);
 }
 
 /*
  * call-seq:
  *    XML::Document.initialize(xml_version = 1.0) -> document
- * 
+ *
  * Initializes a new XML::Document, optionally specifying the
  * XML version.
  */
-static VALUE
-rxml_document_initialize(int argc, VALUE *argv, VALUE self) {
+static VALUE rxml_document_initialize(int argc, VALUE *argv, VALUE self)
+{
   xmlDocPtr xdoc;
   VALUE xmlver;
 
-  switch (argc) {
-    case 0:
-      xmlver = rb_str_new2("1.0");
-      break;
-    case 1:
-      rb_scan_args(argc, argv, "01", &xmlver);
-      break;
-    default:
-      rb_raise(rb_eArgError, "wrong number of arguments (need 0 or 1)");
+  switch (argc)
+  {
+  case 0:
+    xmlver = rb_str_new2("1.0");
+    break;
+  case 1:
+    rb_scan_args(argc, argv, "01", &xmlver);
+    break;
+  default:
+    rb_raise(rb_eArgError, "wrong number of arguments (need 0 or 1)");
   }
 
   Check_Type(xmlver, T_STRING);
-  xdoc = xmlNewDoc((xmlChar*)StringValuePtr(xmlver));
-  xdoc->_private = (void*)self;
-  DATA_PTR(self) = xdoc; 
-  
+  xdoc = xmlNewDoc((xmlChar*) StringValuePtr(xmlver));
+  xdoc->_private = (void*) self;
+  DATA_PTR( self) = xdoc;
+
   return self;
 }
 
-
 /*
  * call-seq:
  *    document.compression -> num
- * 
+ *
  * Obtain this document's compression mode identifier.
  */
-static VALUE
-rxml_document_compression_get(VALUE self) {
+static VALUE rxml_document_compression_get(VALUE self)
+{
 #ifdef HAVE_ZLIB_H
   xmlDocPtr xdoc;
 
@@ -151,24 +150,23 @@ rxml_document_compression_get(VALUE self) {
 
   compmode = xmlGetDocCompressMode(xdoc);
   if (compmode == -1)
-    return(Qnil);
+  return(Qnil);
   else
-    return(INT2NUM(compmode));
+  return(INT2NUM(compmode));
 #else
   rb_warn("libxml not compiled with zlib support");
-  return(Qfalse);
+  return (Qfalse);
 #endif
 }
 
-
 /*
  * call-seq:
  *    document.compression = num
- * 
+ *
  * Set this document's compression mode.
  */
-static VALUE
-rxml_document_compression_set(VALUE self, VALUE num) {
+static VALUE rxml_document_compression_set(VALUE self, VALUE num)
+{
 #ifdef HAVE_ZLIB_H
   xmlDocPtr xdoc;
 
@@ -176,93 +174,92 @@ rxml_document_compression_set(VALUE self, VALUE num) {
   Check_Type(num, T_FIXNUM);
   Data_Get_Struct(self, xmlDoc, xdoc);
 
-  if (xdoc == NULL) {
+  if (xdoc == NULL)
+  {
     return(Qnil);
-  } else {
+  }
+  else
+  {
     xmlSetDocCompressMode(xdoc, NUM2INT(num));
 
     compmode = xmlGetDocCompressMode(xdoc);
     if (compmode == -1)
-      return(Qnil);
+    return(Qnil);
     else
-      return(INT2NUM(compmode));
+    return(INT2NUM(compmode));
   }
 #else
   rb_warn("libxml compiled without zlib support");
-  return(Qfalse);
+  return (Qfalse);
 #endif
 }
 
-
 /*
  * call-seq:
  *    document.compression? -> (true|false)
- * 
+ *
  * Determine whether this document is compressed.
  */
-static VALUE
-rxml_document_compression_q(VALUE self) {
+static VALUE rxml_document_compression_q(VALUE self)
+{
 #ifdef HAVE_ZLIB_H
   xmlDocPtr xdoc;
 
   Data_Get_Struct(self, xmlDoc, xdoc);
 
   if (xdoc->compression != -1)
-    return(Qtrue);
+  return(Qtrue);
   else
-    return(Qfalse);
+  return(Qfalse);
 #else
   rb_warn("libxml compiled without zlib support");
-  return(Qfalse);
+  return (Qfalse);
 #endif
 }
 
-
 /*
  * call-seq:
  *    document.child -> node
- * 
+ *
  * Get this document's child node.
  */
-static VALUE
-rxml_document_child_get(VALUE self) {
+static VALUE rxml_document_child_get(VALUE self)
+{
   xmlDocPtr xdoc;
   Data_Get_Struct(self, xmlDoc, xdoc);
 
   if (xdoc->children == NULL)
-    return(Qnil);
+    return (Qnil);
 
-  return rxml_node2_wrap(cXMLNode, xdoc->children);
+  return rxml_node_wrap(cXMLNode, xdoc->children);
 }
 
-
 /*
  * call-seq:
  *    document.child? -> (true|false)
- * 
+ *
  * Determine whether this document has a child node.
  */
-static VALUE
-rxml_document_child_q(VALUE self) {
+static VALUE rxml_document_child_q(VALUE self)
+{
   xmlDocPtr xdoc;
   Data_Get_Struct(self, xmlDoc, xdoc);
 
   if (xdoc->children == NULL)
-    return(Qfalse);
+    return (Qfalse);
   else
-    return(Qtrue);
+    return (Qtrue);
 }
 
-
 /*
  * call-seq:
  *    document.dump([stream]) -> true
- * 
+ *
  * Dump this document's XML to the specified IO stream.
  * If no stream is specified, stdout is used.
  */
-static VALUE
-rxml_document_dump(int argc, VALUE *argv, VALUE self) {
+static VALUE rxml_document_dump(int argc, VALUE *argv, VALUE self)
+{
   OpenFile *fptr;
   VALUE io;
   FILE *out;
@@ -270,9 +267,10 @@ rxml_document_dump(int argc, VALUE *argv, VALUE self) {
 
   Data_Get_Struct(self, xmlDoc, xdoc);
   if (xdoc == NULL)
-    return(Qnil);
+    return (Qnil);
 
-  switch (argc) {
+  switch (argc)
+  {
   case 0:
     io = rb_stdout;
     break;
@@ -289,18 +287,17 @@ rxml_document_dump(int argc, VALUE *argv, VALUE self) {
   rb_io_check_writable(fptr);
   out = GetWriteFile(fptr);
   xmlDocDump(out, xdoc);
-  return(Qtrue);
+  return (Qtrue);
 }
 
-
 /*
  * call-seq:
  *    document.debug_dump([stream]) -> true
- * 
+ *
  * Debug version of dump.
  */
-static VALUE
-rxml_document_debug_dump(int argc, VALUE *argv, VALUE self) {
+static VALUE rxml_document_debug_dump(int argc, VALUE *argv, VALUE self)
+{
 #ifdef LIBXML_DEBUG_ENABLED
   OpenFile *fptr;
   VALUE io;
@@ -309,18 +306,19 @@ rxml_document_debug_dump(int argc, VALUE *argv, VALUE self) {
 
   Data_Get_Struct(self, xmlDoc, xdoc);
   if (xdoc == NULL)
-    return(Qnil);
+  return(Qnil);
 
-  switch (argc) {
-  case 0:
+  switch (argc)
+  {
+    case 0:
     io = rb_stderr;
     break;
-  case 1:
+    case 1:
     io = argv[0];
     if (!rb_obj_is_kind_of(io, rb_cIO))
-      rb_raise(rb_eTypeError, "need an IO object");
+    rb_raise(rb_eTypeError, "need an IO object");
     break;
-  default:
+    default:
     rb_raise(rb_eArgError, "wrong number of arguments (0 or 1)");
   }
 
@@ -330,42 +328,42 @@ rxml_document_debug_dump(int argc, VALUE *argv, VALUE self) {
   xmlDebugDumpDocument(out, xdoc);
   return(Qtrue);
 #else
-  rb_warn("libxml was compiled without debugging support.  Please recompile libxml and ruby-libxml");
-  return(Qfalse);
+  rb_warn(
+      "libxml was compiled without debugging support.  Please recompile libxml and ruby-libxml");
+  return (Qfalse);
 #endif
 }
 
-
 /*
  * call-seq:
  *    document.debug_dump_head([stream]) -> true
- * 
+ *
  * Debug-dump this document's header to the specified IO stream.
  * If no stream is specified, stdout is used.
  */
-static VALUE
-rxml_document_debug_dump_head(int argc, VALUE *argv, VALUE self) {
+static VALUE rxml_document_debug_dump_head(int argc, VALUE *argv, VALUE self)
+{
 #ifdef LIBXML_DEBUG_ENABLED
   OpenFile *fptr;
   VALUE io;
   FILE *out;
   xmlDocPtr xdoc;
 
-
   Data_Get_Struct(self, xmlDoc, xdoc);
   if (xdoc == NULL)
-    return(Qnil);
+  return(Qnil);
 
-  switch (argc) {
-  case 0:
+  switch (argc)
+  {
+    case 0:
     io = rb_stdout;
     break;
-  case 1:
+    case 1:
     io = argv[0];
     if (!rb_obj_is_kind_of(io, rb_cIO))
-      rb_raise(rb_eTypeError, "need an IO object");
+    rb_raise(rb_eTypeError, "need an IO object");
     break;
-  default:
+    default:
     rb_raise(rb_eArgError, "wrong number of arguments (0 or 1)");
   }
 
@@ -375,23 +373,23 @@ rxml_document_debug_dump_head(int argc, VALUE *argv, VALUE self) {
   xmlDebugDumpDocumentHead(out, xdoc);
   return(Qtrue);
 #else
-  rb_warn("libxml was compiled without debugging support.  Please recompile libxml and ruby-libxml");
-  return(Qfalse);
+  rb_warn(
+      "libxml was compiled without debugging support.  Please recompile libxml and ruby-libxml");
+  return (Qfalse);
 #endif
 }
 
-
 /*
  * call-seq:
  *    document.format_dump([stream], [spacing]) -> true
- * 
+ *
  * Dump this document's formatted XML to the specified IO stream.
- * If no stream is specified, stdout is used. If spacing is 
- * specified, it must be a boolean that determines whether 
+ * If no stream is specified, stdout is used. If spacing is
+ * specified, it must be a boolean that determines whether
  * spacing is used.
  */
-static VALUE
-rxml_document_format_dump(int argc, VALUE *argv, VALUE self) {
+static VALUE rxml_document_format_dump(int argc, VALUE *argv, VALUE self)
+{
   OpenFile *fptr;
   VALUE bool, io;
   FILE *out;
@@ -401,9 +399,10 @@ rxml_document_format_dump(int argc, VALUE *argv, VALUE self) {
 
   Data_Get_Struct(self, xmlDoc, xdoc);
   if (xdoc == NULL)
-    return(Qnil);
+    return (Qnil);
 
-  switch (argc) {
+  switch (argc)
+  {
   case 0:
     io = rb_stdout;
     spacing = 1;
@@ -424,7 +423,8 @@ rxml_document_format_dump(int argc, VALUE *argv, VALUE self) {
     else if (TYPE(bool) == T_FALSE)
       spacing = 0;
     else
-      rb_raise(rb_eTypeError, "incorect argument type, second argument must be bool");
+      rb_raise(rb_eTypeError,
+          "incorect argument type, second argument must be bool");
 
     break;
   default:
@@ -435,222 +435,206 @@ rxml_document_format_dump(int argc, VALUE *argv, VALUE self) {
   rb_io_check_writable(fptr);
   out = GetWriteFile(fptr);
   size = xmlDocFormatDump(out, xdoc, spacing);
-  return(INT2NUM(size));
+  return (INT2NUM(size));
 }
 
-
 /*
  * call-seq:
  *    document.debug_format_dump([stream]) -> true
- * 
+ *
  * *Deprecated* in favour of format_dump.
  */
-static VALUE
-rxml_document_debug_format_dump(int argc, VALUE *argv, VALUE self) {
+static VALUE rxml_document_debug_format_dump(int argc, VALUE *argv, VALUE self)
+{
   rb_warn("debug_format_dump has been deprecaited, use format_dump instead");
-  return(rxml_document_format_dump(argc, argv, self));
+  return (rxml_document_format_dump(argc, argv, self));
 }
 
-
 /*
  * call-seq:
  *    document.encoding -> "encoding"
- * 
+ *
  * Obtain the encoding specified by this document.
  */
-static VALUE
-rxml_document_encoding_get(VALUE self) {
+static VALUE rxml_document_encoding_get(VALUE self)
+{
   xmlDocPtr xdoc;
 
   Data_Get_Struct(self, xmlDoc, xdoc);
   if (xdoc->encoding == NULL)
-    return(Qnil);
+    return (Qnil);
   else
-    return(rb_str_new2((const char*)xdoc->encoding));
+    return (rb_str_new2((const char*) xdoc->encoding));
 }
 
-
 /*
  * call-seq:
  *    document.encoding = "encoding"
- * 
+ *
  * Set the encoding for this document.
  */
-static VALUE
-rxml_document_encoding_set(VALUE self, VALUE encoding) {
+static VALUE rxml_document_encoding_set(VALUE self, VALUE encoding)
+{
   xmlDocPtr xdoc;
 
-
   Check_Type(encoding, T_STRING);
   Data_Get_Struct(self, xmlDoc, xdoc);
   xdoc->encoding = xmlStrdup(StringValuePtr(encoding));
-  return(rxml_document_encoding_get(self));
+  return (rxml_document_encoding_get(self));
 }
 
 /*
  * call-seq:
  *    document.last -> node
- * 
+ *
  * Obtain the last node.
  */
-static VALUE
-rxml_document_last_get(VALUE self) {
+static VALUE rxml_document_last_get(VALUE self)
+{
   xmlDocPtr xdoc;
 
-
   Data_Get_Struct(self, xmlDoc, xdoc);
 
   if (xdoc->last == NULL)
-    return(Qnil);
+    return (Qnil);
 
-  return rxml_node2_wrap(cXMLNode, xdoc->last);
+  return rxml_node_wrap(cXMLNode, xdoc->last);
 }
 
-
 /*
  * call-seq:
  *    document.last? -> (true|false)
- * 
+ *
  * Determine whether there is a last node.
  */
-static VALUE
-rxml_document_last_q(VALUE self) {
+static VALUE rxml_document_last_q(VALUE self)
+{
   xmlDocPtr xdoc;
 
   Data_Get_Struct(self, xmlDoc, xdoc);
 
   if (xdoc->last == NULL)
-    return(Qfalse);
+    return (Qfalse);
   else
-    return(Qtrue);
+    return (Qtrue);
 }
 
-
 /*
  * call-seq:
  *    document.next -> node
- * 
+ *
  * Obtain the next node.
  */
-static VALUE
-rxml_document_next_get(VALUE self) {
+static VALUE rxml_document_next_get(VALUE self)
+{
   xmlDocPtr xdoc;
 
-
   Data_Get_Struct(self, xmlDoc, xdoc);
 
   if (xdoc->next == NULL)
-    return(Qnil);
+    return (Qnil);
 
-  return rxml_node2_wrap(cXMLNode, xdoc->next);
+  return rxml_node_wrap(cXMLNode, xdoc->next);
 }
 
-
 /*
  * call-seq:
  *    document.next? -> (true|false)
- * 
+ *
  * Determine whether there is a next node.
  */
-static VALUE
-rxml_document_next_q(VALUE self) {
+static VALUE rxml_document_next_q(VALUE self)
+{
   xmlDocPtr xdoc;
 
   Data_Get_Struct(self, xmlDoc, xdoc);
 
   if (xdoc->next == NULL)
-    return(Qfalse);
+    return (Qfalse);
   else
-    return(Qtrue);
+    return (Qtrue);
 }
 
-
 /*
  * call-seq:
  *    document.parent -> node
- * 
+ *
  * Obtain the parent node.
  */
-static VALUE
-rxml_document_parent_get(VALUE self) {
+static VALUE rxml_document_parent_get(VALUE self)
+{
   xmlDocPtr xdoc;
 
-
   Data_Get_Struct(self, xmlDoc, xdoc);
 
   if (xdoc->parent == NULL)
-    return(Qnil);
+    return (Qnil);
 
-  return rxml_node2_wrap(cXMLNode, xdoc->parent);
+  return rxml_node_wrap(cXMLNode, xdoc->parent);
 }
 
-
 /*
  * call-seq:
  *    document.parent? -> (true|false)
- * 
+ *
  * Determine whether there is a parent node.
  */
-static VALUE
-rxml_document_parent_q(VALUE self) {
+static VALUE rxml_document_parent_q(VALUE self)
+{
   xmlDocPtr xdoc;
 
   Data_Get_Struct(self, xmlDoc, xdoc);
 
   if (xdoc->parent == NULL)
-    return(Qfalse);
+    return (Qfalse);
   else
-    return(Qtrue);
+    return (Qtrue);
 }
 
-
 /*
  * call-seq:
  *    document.prev -> node
- * 
+ *
  * Obtain the previous node.
  */
-static VALUE
-rxml_document_prev_get(VALUE self) {
+static VALUE rxml_document_prev_get(VALUE self)
+{
   xmlDocPtr xdoc;
 
-
   Data_Get_Struct(self, xmlDoc, xdoc);
 
   if (xdoc->prev == NULL)
-    return(Qnil);
+    return (Qnil);
 
-  return rxml_node2_wrap(cXMLNode, xdoc->prev);
+  return rxml_node_wrap(cXMLNode, xdoc->prev);
 }
 
-
 /*
  * call-seq:
  *    document.prev? -> (true|false)
- * 
+ *
  * Determine whether there is a previous node.
  */
-static VALUE
-rxml_document_prev_q(VALUE self) {
+static VALUE rxml_document_prev_q(VALUE self)
+{
   xmlDocPtr xdoc;
 
   Data_Get_Struct(self, xmlDoc, xdoc);
 
   if (xdoc->prev == NULL)
-    return(Qfalse);
+    return (Qfalse);
   else
-    return(Qtrue);
+    return (Qtrue);
 }
 
-
 /*
  * call-seq:
  *    document.root -> node
- * 
+ *
  * Obtain the root node.
  */
-static VALUE
-rxml_document_root_get(VALUE self) {
+static VALUE rxml_document_root_get(VALUE self)
+{
   xmlDocPtr xdoc;
 
   xmlNodePtr root;
@@ -659,20 +643,19 @@ rxml_document_root_get(VALUE self) {
   root = xmlDocGetRootElement(xdoc);
 
   if (root == NULL)
-    return(Qnil);
+    return (Qnil);
 
-  return rxml_node2_wrap(cXMLNode, root);
+  return rxml_node_wrap(cXMLNode, root);
 }
 
-
 /*
  * call-seq:
  *    document.root = node
- * 
+ *
  * Set the root node.
  */
-static VALUE
-rxml_document_root_set(VALUE self, VALUE node) {
+static VALUE rxml_document_root_set(VALUE self, VALUE node)
+{
   xmlDocPtr xdoc;
   xmlNodePtr xroot, xnode;
 
@@ -683,84 +666,84 @@ rxml_document_root_set(VALUE self, VALUE node) {
   Data_Get_Struct(node, xmlNode, xnode);
   xroot = xmlDocSetRootElement(xdoc, xnode);
   if (xroot == NULL)
-    return(Qnil);
+    return (Qnil);
 
-  return rxml_node2_wrap(cXMLNode, xroot);
+  return rxml_node_wrap(cXMLNode, xroot);
 }
 
-
 /*
  * call-seq:
  *    document.save(filename, format = false) -> int
- * 
- * Save this document to the file given by filename, 
+ *
+ * Save this document to the file given by filename,
  * optionally formatting the output.
- 
+
  * Parameters:
  *  filename: The filename or URL of the new document
  *  format: Specifies whether formatting spaces should be added.
- *  returns: The number of bytes written or -1 in case of error. 
+ *  returns: The number of bytes written or -1 in case of error.
  */
-static VALUE
-rxml_document_save(int argc, VALUE *argv, VALUE self) {
+static VALUE rxml_document_save(int argc, VALUE *argv, VALUE self)
+{
   xmlDocPtr xdoc;
 
   const char *filename;
   int format = 0;
   int len;
 
-  if (argc <1 || argc > 2)
+  if (argc < 1 || argc > 2)
     rb_raise(rb_eArgError, "wrong number of arguments (need 1 or 2)");
 
   Check_Type(argv[0], T_STRING);
   filename = StringValuePtr(argv[0]);
-  
+
   if (argc == 2)
   {
-    switch (TYPE(argv[1])) {
-      case T_TRUE:
-        format = 1;
-        break;
-      case T_FALSE:
-        format = 0;
-        break;
-      default:
-        rb_raise(rb_eArgError, "The second parameter (format) must be true or false");
+    switch (TYPE(argv[1]))
+    {
+    case T_TRUE:
+      format = 1;
+      break;
+    case T_FALSE:
+      format = 0;
+      break;
+    default:
+      rb_raise(rb_eArgError,
+          "The second parameter (format) must be true or false");
     }
   }
 
   Data_Get_Struct(self, xmlDoc, xdoc);
-  len = xmlSaveFormatFileEnc(filename, xdoc, (const char*)xdoc->encoding, format);
-  
+  len = xmlSaveFormatFileEnc(filename, xdoc, (const char*) xdoc->encoding,
+      format);
+
   if (len == -1)
     rb_raise(rb_eIOError, "Could not write document");
   else
-    return(INT2NUM(len));
+    return (INT2NUM(len));
 }
 
-
 /*
  * call-seq:
  *    document.standalone? -> (true|false)
- * 
+ *
  * Determine whether this is a standalone document.
  */
-static VALUE
-rxml_document_standalone_q(VALUE self) {
+static VALUE rxml_document_standalone_q(VALUE self)
+{
   xmlDocPtr xdoc;
 
   Data_Get_Struct(self, xmlDoc, xdoc);
   if (xdoc->standalone)
-    return(Qtrue);
+    return (Qtrue);
   else
-    return(Qfalse);
+    return (Qfalse);
 }
 
-
 /*
  * call-seq:
  *    document.to_s({format=true,encoding) -> "xml"
- * 
+ *
  * Coerce this document to a string representation
  * of it's XML. The default is to pretty format, but this
  * depends Parser#indent_tree_output==true or
@@ -769,21 +752,22 @@ rxml_document_standalone_q(VALUE self) {
  * The encoding is not applied to the document, but is
  * encoding target of the resulting string.
  */
-static VALUE
-rxml_document_to_s(int argc, VALUE *argv, VALUE self) {
+static VALUE rxml_document_to_s(int argc, VALUE *argv, VALUE self)
+{
   xmlDocPtr xdoc;
 
-  xmlChar *result, *encoding=NULL;
+  xmlChar *result, *encoding = NULL;
   int format, len;
   VALUE rresult;
 
-  switch (argc) {
+  switch (argc)
+  {
   case 0:
     format = 1;
     break;
   case 2:
     if (TYPE(argv[1]) == T_STRING)
-      encoding=(xmlChar *)StringValuePtr(argv[1]);
+      encoding = (xmlChar *) StringValuePtr(argv[1]);
   case 1:
     if (TYPE(argv[0]) == T_TRUE)
       format = 1;
@@ -797,72 +781,76 @@ rxml_document_to_s(int argc, VALUE *argv, VALUE self) {
   }
 
   Data_Get_Struct(self, xmlDoc, xdoc);
-  if (xdoc == NULL) {
-    return(Qnil);
-  } else if (encoding != NULL) {
-    if (format) {
-      xmlDocDumpFormatMemoryEnc(xdoc, &result, &len,
-				(const char*)encoding, format);
-    } else {
-      xmlDocDumpMemoryEnc(xdoc, &result, &len,
-			  (const char *)encoding);
+  if (xdoc == NULL)
+  {
+    return (Qnil);
+  }
+  else if (encoding != NULL)
+  {
+    if (format)
+    {
+      xmlDocDumpFormatMemoryEnc(xdoc, &result, &len, (const char*) encoding,
+          format);
+    }
+    else
+    {
+      xmlDocDumpMemoryEnc(xdoc, &result, &len, (const char *) encoding);
     }
-  } else {
+  }
+  else
+  {
     if (format)
       xmlDocDumpFormatMemory(xdoc, &result, &len, format);
     else
       xmlDocDumpMemory(xdoc, &result, &len);
   }
-  rresult=rb_str_new((const char*)result,len);
+  rresult = rb_str_new((const char*) result, len);
   xmlFree(result);
   return rresult;
 }
 
-
 /*
  * call-seq:
  *    document.url -> "url"
- * 
+ *
  * Obtain this document's source URL, if any.
  */
-static VALUE
-rxml_document_url_get(VALUE self) {
+static VALUE rxml_document_url_get(VALUE self)
+{
   xmlDocPtr xdoc;
 
   Data_Get_Struct(self, xmlDoc, xdoc);
   if (xdoc->URL == NULL)
-    return(Qnil);
+    return (Qnil);
   else
-    return(rb_str_new2((const char*)xdoc->URL));
+    return (rb_str_new2((const char*) xdoc->URL));
 }
 
-
 /*
  * call-seq:
  *    document.version -> "version"
- * 
+ *
  * Obtain the XML version specified by this document.
  */
-static VALUE
-rxml_document_version_get(VALUE self) {
+static VALUE rxml_document_version_get(VALUE self)
+{
   xmlDocPtr xdoc;
 
   Data_Get_Struct(self, xmlDoc, xdoc);
   if (xdoc->version == NULL)
-    return(Qnil);
+    return (Qnil);
   else
-    return(rb_str_new2((const char*)xdoc->version));
+    return (rb_str_new2((const char*) xdoc->version));
 }
 
-
 /*
  * call-seq:
  *    document.xinclude -> num
- * 
- * Process xinclude directives in this document. 
+ *
+ * Process xinclude directives in this document.
  */
-static VALUE
-rxml_document_xinclude(VALUE self) {
+static VALUE rxml_document_xinclude(VALUE self)
+{
 #ifdef LIBXML_XINCLUDE_ENABLED
   xmlDocPtr xdoc;
 
@@ -880,32 +868,37 @@ rxml_document_xinclude(VALUE self) {
     return Qnil;
   }
 #else
-  rb_warn("libxml was compiled without XInclude support.  Please recompile libxml and ruby-libxml");
-  return(Qfalse);
+  rb_warn(
+      "libxml was compiled without XInclude support.  Please recompile libxml and ruby-libxml");
+  return (Qfalse);
 #endif
 }
 
-void
-LibXML_validity_error(void * ctxt, const char * msg, va_list ap)
+void LibXML_validity_error(void * ctxt, const char * msg, va_list ap)
 {
-  if (rb_block_given_p()) {
+  if (rb_block_given_p())
+  {
     char buff[1024];
     snprintf(buff, 1024, msg, ap);
     rb_yield(rb_ary_new3(2, rb_str_new2(buff), Qtrue));
-  } else {
+  }
+  else
+  {
     fprintf(stderr, "error -- found validity error: ");
     fprintf(stderr, msg, ap);
   }
 }
 
-void
-LibXML_validity_warning(void * ctxt, const char * msg, va_list ap)
+void LibXML_validity_warning(void * ctxt, const char * msg, va_list ap)
 {
-  if (rb_block_given_p()) {
+  if (rb_block_given_p())
+  {
     char buff[1024];
     snprintf(buff, 1024, msg, ap);
     rb_yield(rb_ary_new3(2, rb_str_new2(buff), Qfalse));
-  } else {
+  }
+  else
+  {
     fprintf(stderr, "warning -- found validity error: ");
     fprintf(stderr, msg, ap);
   }
@@ -914,15 +907,15 @@ LibXML_validity_warning(void * ctxt, const char * msg, va_list ap)
 /*
  * call-seq:
  *    document.validate_schema(schema) -> (true|false)
- * 
+ *
  * Validate this document against the specified XML::Schema.
- * 
+ *
  * If a block is provided it is used as an error handler for validaten errors.
  * The block is called with two argument, the message and a flag indication
  * if the message is an error (true) or a warning (false).
  */
-static VALUE
-rxml_document_validate_schema(VALUE self, VALUE schema) {
+static VALUE rxml_document_validate_schema(VALUE self, VALUE schema)
+{
   xmlSchemaValidCtxtPtr vptr;
   xmlDocPtr xdoc;
   xmlSchemaPtr xschema;
@@ -933,34 +926,35 @@ rxml_document_validate_schema(VALUE self, VALUE schema) {
 
   vptr = xmlSchemaNewValidCtxt(xschema);
 
-  xmlSchemaSetValidErrors(vptr, (xmlSchemaValidityErrorFunc)LibXML_validity_error,
-                                (xmlSchemaValidityWarningFunc)LibXML_validity_warning, NULL);
-  
+  xmlSchemaSetValidErrors(vptr,
+      (xmlSchemaValidityErrorFunc) LibXML_validity_error,
+      (xmlSchemaValidityWarningFunc) LibXML_validity_warning, NULL);
+
   is_invalid = xmlSchemaValidateDoc(vptr, xdoc);
   xmlSchemaFreeValidCtxt(vptr);
-  if (is_invalid) 
+  if (is_invalid)
   {
     rxml_raise(&xmlLastError);
     return Qfalse;
-  } 
+  }
   else
   {
-	  return Qtrue;
+    return Qtrue;
   }
 }
 
 /*
  * call-seq:
  *    document.validate_schema(relaxng) -> (true|false)
- * 
+ *
  * Validate this document against the specified XML::RelaxNG.
  *
  * If a block is provided it is used as an error handler for validaten errors.
  * The block is called with two argument, the message and a flag indication
  * if the message is an error (true) or a warning (false).
  */
-static VALUE
-rxml_document_validate_relaxng(VALUE self, VALUE relaxng) {
+static VALUE rxml_document_validate_relaxng(VALUE self, VALUE relaxng)
+{
   xmlRelaxNGValidCtxtPtr vptr;
   xmlDocPtr xdoc;
   xmlRelaxNGPtr xrelaxng;
@@ -971,30 +965,31 @@ rxml_document_validate_relaxng(VALUE self, VALUE relaxng) {
 
   vptr = xmlRelaxNGNewValidCtxt(xrelaxng);
 
-  xmlRelaxNGSetValidErrors(vptr, (xmlRelaxNGValidityErrorFunc)LibXML_validity_error,
-                                (xmlRelaxNGValidityWarningFunc)LibXML_validity_warning, NULL);
-  
+  xmlRelaxNGSetValidErrors(vptr,
+      (xmlRelaxNGValidityErrorFunc) LibXML_validity_error,
+      (xmlRelaxNGValidityWarningFunc) LibXML_validity_warning, NULL);
+
   is_invalid = xmlRelaxNGValidateDoc(vptr, xdoc);
   xmlRelaxNGFreeValidCtxt(vptr);
-  if (is_invalid) 
+  if (is_invalid)
   {
     rxml_raise(&xmlLastError);
     return Qfalse;
-  } else 
+  }
+  else
   {
-	  return Qtrue;
+    return Qtrue;
   }
 }
 
-
 /*
  * call-seq:
  *    document.validate(dtd) -> (true|false)
- * 
+ *
  * Validate this document against the specified XML::DTD.
  */
-static VALUE
-rxml_document_validate_dtd(VALUE self, VALUE dtd) {
+static VALUE rxml_document_validate_dtd(VALUE self, VALUE dtd)
+{
   VALUE error = Qnil;
   xmlValidCtxt ctxt;
   xmlDocPtr xdoc;
@@ -1004,8 +999,8 @@ rxml_document_validate_dtd(VALUE self, VALUE dtd) {
   Data_Get_Struct(dtd, xmlDtd, xdtd);
 
   ctxt.userData = &error;
-  ctxt.error = (xmlValidityErrorFunc)LibXML_validity_error;
-  ctxt.warning = (xmlValidityWarningFunc)LibXML_validity_warning;
+  ctxt.error = (xmlValidityErrorFunc) LibXML_validity_error;
+  ctxt.warning = (xmlValidityWarningFunc) LibXML_validity_warning;
 
   ctxt.nodeNr = 0;
   ctxt.nodeTab = NULL;
@@ -1014,7 +1009,7 @@ rxml_document_validate_dtd(VALUE self, VALUE dtd) {
 
   if (xmlValidateDtd(&ctxt, xdoc, xdtd))
   {
-    return(Qtrue);
+    return (Qtrue);
   }
   else
   {
@@ -1023,41 +1018,43 @@ rxml_document_validate_dtd(VALUE self, VALUE dtd) {
   }
 }
 
-
 /*
  * call-seq:
  *    document.reader -> reader
- * 
+ *
  * Create a XML::Reader from the document. This is a shortcut to
  * XML::Reader.walker().
  */
-static VALUE
-rxml_document_reader(VALUE self)
+static VALUE rxml_document_reader(VALUE self)
 {
   return rxml_reader_new_walker(cXMLReader, self);
 }
 
-// Rdoc needs to know 
+// Rdoc needs to know
 #ifdef RDOC_NEVER_DEFINED
-  mLibXML = rb_define_module("LibXML");
-  mXML = rb_define_module_under(mLibXML, "XML");
+mLibXML = rb_define_module("LibXML");
+mXML = rb_define_module_under(mLibXML, "XML");
 #endif
 
-void
-ruby_init_xml_document(void) {
+void ruby_init_xml_document(void)
+{
   cXMLDocument = rb_define_class_under(mXML, "Document", rb_cObject);
   rb_define_alloc_func(cXMLDocument, rxml_document_alloc);
 
   rb_define_method(cXMLDocument, "initialize", rxml_document_initialize, -1);
   rb_define_method(cXMLDocument, "child", rxml_document_child_get, 0);
   rb_define_method(cXMLDocument, "child?", rxml_document_child_q, 0);
-  rb_define_method(cXMLDocument, "compression", rxml_document_compression_get, 0);
-  rb_define_method(cXMLDocument, "compression=", rxml_document_compression_set, 1);
+  rb_define_method(cXMLDocument, "compression", rxml_document_compression_get,
+      0);
+  rb_define_method(cXMLDocument, "compression=", rxml_document_compression_set,
+      1);
   rb_define_method(cXMLDocument, "compression?", rxml_document_compression_q, 0);
   rb_define_method(cXMLDocument, "dump", rxml_document_dump, -1);
   rb_define_method(cXMLDocument, "debug_dump", rxml_document_debug_dump, -1);
-  rb_define_method(cXMLDocument, "debug_dump_head", rxml_document_debug_dump_head, -1);
-  rb_define_method(cXMLDocument, "debug_format_dump", rxml_document_debug_format_dump, -1);
+  rb_define_method(cXMLDocument, "debug_dump_head",
+      rxml_document_debug_dump_head, -1);
+  rb_define_method(cXMLDocument, "debug_format_dump",
+      rxml_document_debug_format_dump, -1);
   rb_define_method(cXMLDocument, "encoding", rxml_document_encoding_get, 0);
   rb_define_method(cXMLDocument, "encoding=", rxml_document_encoding_set, 1);
   rb_define_method(cXMLDocument, "format_dump", rxml_document_format_dump, -1);
@@ -1078,7 +1075,9 @@ ruby_init_xml_document(void) {
   rb_define_method(cXMLDocument, "version", rxml_document_version_get, 0);
   rb_define_method(cXMLDocument, "xinclude", rxml_document_xinclude, 0);
   rb_define_method(cXMLDocument, "validate", rxml_document_validate_dtd, 1);
-  rb_define_method(cXMLDocument, "validate_schema", rxml_document_validate_schema, 1);
-  rb_define_method(cXMLDocument, "validate_relaxng", rxml_document_validate_relaxng, 1);
+  rb_define_method(cXMLDocument, "validate_schema",
+      rxml_document_validate_schema, 1);
+  rb_define_method(cXMLDocument, "validate_relaxng",
+      rxml_document_validate_relaxng, 1);
   rb_define_method(cXMLDocument, "reader", rxml_document_reader, 0);
 }