libxml-ruby 0.9.7-x86-mswin32-60 → 0.9.8-x86-mswin32-60

data/ext/libxml/ruby_xml_parser_context.h

@@ -1,4 +1,4 @@
-/* $Id: ruby_xml_parser_context.h 666 2008-12-07 00:16:50Z cfis $ */
+/* $Id: ruby_xml_parser_context.h 711 2009-01-20 07:17:15Z cfis $ */
 
 /* Please see the LICENSE file for copyright and distribution information */
 
@@ -8,6 +8,5 @@
 extern VALUE cXMLParserContext;
 
 void ruby_init_xml_parser_context(void);
-VALUE rxml_parser_context_wrap(xmlParserCtxtPtr ctxt);
 
 #endif

data/ext/libxml/ruby_xml_parser_options.c

@@ -0,0 +1,75 @@
+/* $Id: ruby_xml_parser.c 710 2009-01-20 05:30:51Z cfis $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#include <stdarg.h>
+#include "ruby_libxml.h"
+
+/* Document-class: LibXML::XML::ParserOptions
+ *
+ * Options that control the operation of the HTMLParser.  The easiest
+ * way to set a parser's options is to use the methods
+ * XML::Parser.file, XML::Parser.io or XML::Parser.string.
+ * For additional control, see XML::Parser::Context#options=.
+*/
+
+VALUE mXMLParserOptions;
+
+
+// Rdoc needs to know
+#ifdef RDOC_NEVER_DEFINED
+mLibXML = rb_define_module("LibXML");
+mXML = rb_define_module_under(mLibXML, "XML");
+#endif
+
+void ruby_init_parser_options(void)
+{
+  mXMLParserOptions = rb_define_module_under(cXMLParser, "Options");
+
+  /* recover on errors */  
+  rb_define_const(mXMLParserOptions, "RECOVER", INT2NUM(XML_PARSE_RECOVER));
+  /* substitute entities */
+  rb_define_const(mXMLParserOptions, "NOENT", INT2NUM(XML_PARSE_NOENT));
+  /* load the external subset */
+  rb_define_const(mXMLParserOptions, "DTDLOAD", INT2NUM(XML_PARSE_DTDLOAD));
+  /* default DTD attributes */
+  rb_define_const(mXMLParserOptions, "DTDATTR", INT2NUM(XML_PARSE_DTDATTR));
+  /* validate with the DTD */
+  rb_define_const(mXMLParserOptions, "DTDVALID", INT2NUM(XML_PARSE_DTDVALID));
+  /* suppress error reports */
+  rb_define_const(mXMLParserOptions, "NOERROR", INT2NUM(XML_PARSE_NOERROR));
+  /* suppress warning reports */
+  rb_define_const(mXMLParserOptions, "NOWARNING", INT2NUM(XML_PARSE_NOWARNING));
+  /* pedantic error reporting */
+  rb_define_const(mXMLParserOptions, "PEDANTIC", INT2NUM(XML_PARSE_PEDANTIC));
+  /* remove blank nodes */
+  rb_define_const(mXMLParserOptions, "NOBLANKS", INT2NUM(XML_PARSE_NOBLANKS));
+  /* use the SAX1 interface internally */
+  rb_define_const(mXMLParserOptions, "SAX1", INT2NUM(XML_PARSE_SAX1));
+  /* Implement XInclude substitition  */
+  rb_define_const(mXMLParserOptions, "XINCLUDE", INT2NUM(XML_PARSE_XINCLUDE));
+  /* Forbid network access */
+  rb_define_const(mXMLParserOptions, "NONET", INT2NUM(XML_PARSE_NONET));
+  /* Do not reuse the context dictionnary */
+  rb_define_const(mXMLParserOptions, "NODICT", INT2NUM(XML_PARSE_NODICT));
+  /* remove redundant namespaces declarations */
+  rb_define_const(mXMLParserOptions, "NSCLEAN", INT2NUM(XML_PARSE_NSCLEAN));
+  /* merge CDATA as text nodes */
+  rb_define_const(mXMLParserOptions, "NOCDATA", INT2NUM(XML_PARSE_NOCDATA));
+#if LIBXML_VERSION >= 20621
+  /* do not generate XINCLUDE START/END nodes */
+  rb_define_const(mXMLParserOptions, "NOXINCNODE", INT2NUM(XML_PARSE_NOXINCNODE));
+#endif
+#if LIBXML_VERSION >= 20700
+  /* compact small text nodes */
+  rb_define_const(mXMLParserOptions, "COMPACT", INT2NUM(XML_PARSE_COMPACT));
+  /* parse using XML-1.0 before update 5 */
+  rb_define_const(mXMLParserOptions, "PARSE_OLD10", INT2NUM(XML_PARSE_OLD10));
+  /* do not fixup XINCLUDE xml:base uris */
+  rb_define_const(mXMLParserOptions, "NOBASEFIX", INT2NUM(XML_PARSE_NOBASEFIX));
+#endif
+#if LIBXML_VERSION >= 20703
+  /* relax any hardcoded limit from the parser */
+  rb_define_const(mXMLParserOptions, "HUGE", INT2NUM(XML_PARSE_HUGE));
+#endif
+}

data/ext/libxml/ruby_xml_parser_options.h

@@ -0,0 +1,14 @@
+/* $Id: ruby_xml_parser.h 710 2009-01-20 05:30:51Z cfis $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RXML_PARSER_OPTIONS__
+#define __RXML_PARSER_OPTIONS__
+
+#define MAX_LIBXML_FEATURES_LEN 50
+
+extern VALUE mXMLParserOptions;
+
+void ruby_init_parser_options();
+
+#endif

data/ext/libxml/ruby_xml_reader.c

@@ -4,8 +4,6 @@
 #include "ruby_libxml.h"
 #include "ruby_xml_reader.h"
 
-VALUE cXMLReader;
-
 /*
  * Document-class: LibXML::XML::Reader
  *
@@ -22,27 +20,37 @@ VALUE cXMLReader;
  *
  * Example:
  *
- *  parser = XML::Reader.new("<foo><bar>1</bar><bar>2</bar><bar>3</bar></foo>")
- *  parser.read
- *  assert_equal('foo', parser.name)
- *  assert_equal(nil, parser.value)
+ *  parser = XML::Reader.string("<foo><bar>1</bar><bar>2</bar><bar>3</bar></foo>")
+ *  reader.read
+ *  assert_equal('foo', reader.name)
+ *  assert_equal(nil, reader.value)
  *
  *  3.times do |i|
- *    parser.read
- *    assert_equal(XML::Reader::TYPE_ELEMENT, parser.node_type)
- *    assert_equal('bar', parser.name)
- *    parser.read
- *    assert_equal(XML::Reader::TYPE_TEXT, parser.node_type)
- *    assert_equal((i + 1).to_s, parser.value)
- *    parser.read
- *    assert_equal(XML::Reader::TYPE_END_ELEMENT, parser.node_type)
+ *    reader.read
+ *    assert_equal(XML::Reader::TYPE_ELEMENT, reader.node_type)
+ *    assert_equal('bar', reader.name)
+ *    reader.read
+ *    assert_equal(XML::Reader::TYPE_TEXT, reader.node_type)
+ *    assert_equal((i + 1).to_s, reader.value)
+ *    reader.read
+ *    assert_equal(XML::Reader::TYPE_END_ELEMENT, reader.node_type)
  *  end
  *
+ * You can also parse documents (see XML::Reader.document), 
+ * strings (see XML::Parser.string) and io objects (see
+ * XML::Parser.io).
+ *
  * For a more in depth tutorial, albeit in C, see http://xmlsoft.org/xmlreader.html.*/
 
-static VALUE rxml_reader_new(VALUE class, xmlTextReaderPtr reader)
+VALUE cXMLReader;
+
+ID base_uri_SYMBOL;
+ID ENCODING_SYMBOL;
+ID OPTIONS_SYMBOL;
+
+static VALUE rxml_reader_wrap(xmlTextReaderPtr reader)
 {
-  return Data_Wrap_Struct(class, NULL, xmlFreeTextReader, reader);
+  return Data_Wrap_Struct(cXMLReader, NULL, xmlFreeTextReader, reader);
 }
 
 static xmlTextReaderPtr rxml_text_reader_get(VALUE obj)
@@ -54,120 +62,193 @@ static xmlTextReaderPtr rxml_text_reader_get(VALUE obj)
 
 /*
  * call-seq:
- *    XML::Reader.file(path, encoding=nil, options=0) -> reader
+ *    XML::Reader.document(doc) -> XML::Reader
  *
- * Parse an XML file from the filesystem or the network. The parsing flags
- * options are a combination of xmlParserOption.
+ * Create an new reader for the specified document.
  */
-static VALUE rxml_reader_new_file(int argc, VALUE *argv, VALUE self)
+VALUE rxml_reader_document(VALUE klass, VALUE doc)
 {
+  xmlDocPtr xdoc;
   xmlTextReaderPtr xreader;
-  VALUE rpath, rencoding, roptions;
-  char *xpath;
-  char *xencoding;
-  int options;
-
-  rb_scan_args(argc, argv, "12", &rpath, &rencoding, &roptions);
 
-  xpath = NIL_P(rpath) ? NULL : StringValueCStr(rpath);
-  xencoding = NIL_P(rencoding) ? NULL : StringValueCStr(rencoding);
-  options = NIL_P(roptions) ? 0 : FIX2INT(roptions);
+  Data_Get_Struct(doc, xmlDoc, xdoc);
 
-  xreader = xmlReaderForFile(xpath, xencoding, options);
+  xreader = xmlReaderWalker(xdoc);
 
   if (xreader == NULL)
     rxml_raise(&xmlLastError);
 
-  return rxml_reader_new(self, xreader);
+  return rxml_reader_wrap(xreader);
 }
 
-/*
- * call-seq:
- *    XML::Reader.io(io, url=nil, encoding=nil, options=0) -> reader
+/* call-seq:
+ *    XML::Reader.file(path) -> XML::Reader
+ *    XML::Reader.file(path, :encoding => XML::Encoding::UTF_8,
+ *                           :options => XML::Parser::Options::NOENT) -> XML::Parser
  *
- * Parse an XML file from a file handle. The parsing flags options are
- * a combination of xmlParserOption.
+ * Creates a new reader by parsing the specified file or uri.
+ *
+ * You may provide an optional hash table to control how the
+ * parsing is performed.  Valid options are:
+ *
+ *  encoding - The document encoding, defaults to nil. Valid values
+ *             are the encoding constants defined on XML::Encoding.
+ *  options - Controls the execution of the parser, defaults to 0.
+ *            Valid values are the constants defined on
+ *            XML::Parser::Options.  Mutliple options can be combined
+ *            by using Bitwise OR (|). 
  */
-static VALUE rxml_reader_new_io(int argc, VALUE *argv, VALUE self)
+static VALUE rxml_reader_file(int argc, VALUE *argv, VALUE klass)
 {
   xmlTextReaderPtr xreader;
-  VALUE rio, rurl, rencoding, roptions;
-  char *xurl;
-  char *xencoding;
-  int options;
+  VALUE path;
+  VALUE options;
 
-  rb_scan_args(argc, argv, "13", &rio, &rurl, &rencoding, &roptions);
+  const char *xencoding = NULL;
+  int xoptions = 0;
 
-  xurl = NIL_P(rurl) ? NULL : StringValueCStr(rurl);
-  xencoding = NIL_P(rencoding) ? NULL : StringValueCStr(rencoding);
-  options = NIL_P(roptions) ? 0 : FIX2INT(roptions);
+  rb_scan_args(argc, argv, "11", &path, &options);
+  Check_Type(path, T_STRING);
 
-  xreader = xmlReaderForIO((xmlInputReadCallback) rxml_read_callback, NULL,
-      (void *) rio, xurl, xencoding, options);
+  if (!NIL_P(options))
+  {
+    VALUE encoding = Qnil;
+    VALUE parserOptions = Qnil;
+
+    Check_Type(options, T_HASH);
+
+    encoding = rb_hash_aref(options, base_uri_SYMBOL);
+    xencoding = NIL_P(encoding) ? NULL : xmlGetCharEncodingName(NUM2INT(encoding));
+
+    parserOptions = rb_hash_aref(options, OPTIONS_SYMBOL);
+    xoptions = NIL_P(parserOptions) ? 0 : NUM2INT(parserOptions);
+  }
+
+  xreader = xmlReaderForFile(StringValueCStr(path), xencoding, xoptions);
 
   if (xreader == NULL)
     rxml_raise(&xmlLastError);
 
-  return rxml_reader_new(self, xreader);
+  return rxml_reader_wrap(xreader);
 }
 
-/*
- * call-seq:
- *    XML::Reader.walker(doc) -> reader
- *    XML::Reader.document(doc) -> reader
+/* call-seq:
+ *    XML::Reader.io(io) -> XML::Reader
+ *    XML::Reader.io(io, :encoding => XML::Encoding::UTF_8,
+ *                       :options => XML::Parser::Options::NOENT) -> XML::Parser
+ *
+ * Creates a new reader by parsing the specified io object.
  *
- * Create an XML text reader for a preparsed document.
+ * You may provide an optional hash table to control how the
+ * parsing is performed.  Valid options are:
+ *
+ *  base_uri - The base url for the parsed document.
+ *  encoding - The document encoding, defaults to nil. Valid values
+ *             are the encoding constants defined on XML::Encoding.
+ *  options - Controls the execution of the parser, defaults to 0.
+ *            Valid values are the constants defined on
+ *            XML::Parser::Options.  Mutliple options can be combined
+ *            by using Bitwise OR (|). 
  */
-VALUE rxml_reader_new_walker(VALUE self, VALUE doc)
+static VALUE rxml_reader_io(int argc, VALUE *argv, VALUE klass)
 {
-  xmlDocPtr xdoc;
   xmlTextReaderPtr xreader;
+  VALUE io;
+  VALUE options;
+  char *xbaseurl = NULL;
+  const char *xencoding = NULL;
+  int xoptions = 0;
 
-  Data_Get_Struct(doc, xmlDoc, xdoc);
+  rb_scan_args(argc, argv, "11", &io, &options);
 
-  xreader = xmlReaderWalker(xdoc);
+  if (!NIL_P(options))
+  {
+    VALUE baseurl = Qnil;
+    VALUE encoding = Qnil;
+    VALUE parserOptions = Qnil;
+
+    Check_Type(options, T_HASH);
+
+    baseurl = rb_hash_aref(options, base_uri_SYMBOL);
+    xbaseurl = NIL_P(baseurl) ? NULL : StringValueCStr(baseurl);
+
+    encoding = rb_hash_aref(options, ENCODING_SYMBOL);
+    xencoding = NIL_P(encoding) ? NULL : xmlGetCharEncodingName(NUM2INT(encoding));
+
+    parserOptions = rb_hash_aref(options, OPTIONS_SYMBOL);
+    xoptions = NIL_P(parserOptions) ? 0 : NUM2INT(parserOptions);
+  }
+  
+  xreader = xmlReaderForIO((xmlInputReadCallback) rxml_read_callback, NULL,
+                           (void *) io, 
+                           xbaseurl, xencoding, xoptions);
 
   if (xreader == NULL)
     rxml_raise(&xmlLastError);
 
-  return rxml_reader_new(self, xreader);
+  return rxml_reader_wrap(xreader);
 }
 
-/*
- * call-seq:
- *    XML::Reader.new(data, url=nil, encoding=nil, options=0) -> reader
- *    XML::Reader.string(data, url=nil, encoding=nil, options=0) -> reader
+/* call-seq:
+ *    XML::Reader.string(io) -> XML::Reader
+ *    XML::Reader.string(io, :encoding => XML::Encoding::UTF_8,
+ *                           :options => XML::Parser::Options::NOENT) -> XML::Parser
  *
- * Create an XML text reader for an XML in-memory document. The parsing flags
- * options are a combination of xmlParserOption.
+ * Creates a new reader by parsing the specified string.
+ *
+ * You may provide an optional hash table to control how the
+ * parsing is performed.  Valid options are:
+ *
+ *  base_uri - The base url for the parsed document.
+ *  encoding - The document encoding, defaults to nil. Valid values
+ *             are the encoding constants defined on XML::Encoding.
+ *  options - Controls the execution of the parser, defaults to 0.
+ *            Valid values are the constants defined on
+ *            XML::Parser::Options.  Mutliple options can be combined
+ *            by using Bitwise OR (|).
  */
-static VALUE rxml_reader_new_data(int argc, VALUE *argv, VALUE self)
+static VALUE rxml_reader_string(int argc, VALUE *argv, VALUE klass)
 {
   xmlTextReaderPtr xreader;
-  VALUE rdata, rurl, rencoding, roptions;
-  char *xdata;
-  char *xurl;
-  char *xencoding;
-  int options;
+  VALUE string;
+  VALUE options;
+  char *xbaseurl = NULL;
+  const char *xencoding = NULL;
+  int xoptions = 0;
 
-  rb_scan_args(argc, argv, "13", &rdata, &rurl, &rencoding, &roptions);
+  rb_scan_args(argc, argv, "11", &string, &options);
+  Check_Type(string, T_STRING);
+
+  if (!NIL_P(options))
+  {
+    VALUE baseurl = Qnil;
+    VALUE encoding = Qnil;
+    VALUE parserOptions = Qnil;
 
-  xdata = NIL_P(rdata) ? NULL : StringValueCStr(rdata);
-  xurl = NIL_P(rurl) ? NULL : StringValueCStr(rurl);
-  xencoding = NIL_P(rencoding) ? NULL : StringValueCStr(rencoding);
-  options = NIL_P(roptions) ? 0 : FIX2INT(roptions);
+    Check_Type(options, T_HASH);
 
-  xreader = xmlReaderForMemory(xdata, strlen(xdata), xurl, xencoding, options);
+    baseurl = rb_hash_aref(options, base_uri_SYMBOL);
+    xbaseurl = NIL_P(baseurl) ? NULL : StringValueCStr(baseurl);
+
+    encoding = rb_hash_aref(options, ENCODING_SYMBOL);
+    xencoding = NIL_P(encoding) ? NULL : xmlGetCharEncodingName(NUM2INT(encoding));
+      
+    parserOptions = rb_hash_aref(options, OPTIONS_SYMBOL);
+    xoptions = NIL_P(parserOptions) ? 0 : NUM2INT(parserOptions);
+  }
+  
+  xreader = xmlReaderForMemory(StringValueCStr(string), RSTRING_LEN(string), 
+                               xbaseurl, xencoding, xoptions);
 
   if (xreader == NULL)
     rxml_raise(&xmlLastError);
 
-  return rxml_reader_new(self, xreader);
+  return rxml_reader_wrap(xreader);
 }
 
 /*
  * call-seq:
- *    parser.close -> code
+ *    reader.close -> code
  *
  * This method releases any resources allocated by the current instance
  * changes the state to Closed and close any underlying input.
@@ -179,7 +260,7 @@ static VALUE rxml_reader_close(VALUE self)
 
 /*
  * call-seq:
- *   parser.move_to_attribute(val) -> code
+ *   reader.move_to_attribute(val) -> code
  *
  * Move the position of the current instance to the attribute with the
  * specified index (if +val+ is an integer) or name (if +val+ is a string)
@@ -266,6 +347,21 @@ static VALUE rxml_reader_next_sibling(VALUE self)
   return INT2FIX(xmlTextReaderNextSibling(rxml_text_reader_get(self)));
 }
 
+/*
+ * call-seq:
+ *    reader.node -> XML::Node
+ *
+ * Returns the reader's current node.
+ * WARNING - Using this method is dangerous because the
+ * the node may be destroyed on the next #read.
+ */
+static VALUE rxml_reader_node(VALUE self)
+{
+  xmlTextReaderPtr xreader = rxml_text_reader_get(self);
+  xmlNodePtr xnode = xmlTextReaderCurrentNode(xreader);
+  return rxml_node_wrap(xnode);
+}
+
 /*
  * call-seq:
  *    reader.node_type -> type
@@ -299,15 +395,27 @@ static VALUE rxml_reader_normalization(VALUE self)
  * call-seq:
  *    reader.read -> code
  *
- * Move the position of the current instance to the next node in the stream,
- * exposing its properties.
+ * Causes the reader to move to the next node in the stream, exposing its properties.
  *
- * Return 1 if the node was read successfully, 0 if there is no more nodes to
- * read, or -1 in case of error.
- */
+ * Returns true if a node was successfully read or false if there are no more
+ * nodes to read.  On errors, an exception is raised.*/
 static VALUE rxml_reader_read(VALUE self)
 {
-  return INT2FIX(xmlTextReaderRead(rxml_text_reader_get(self)));
+  int result = xmlTextReaderRead(rxml_text_reader_get(self));
+  switch(result)
+  {
+    case -1:
+      rxml_raise(&xmlLastError);
+      return Qnil;
+      break;
+    case 0:
+      return Qfalse;
+    case 1:
+      return Qtrue;
+    default:
+      rb_raise(rb_eRuntimeError,
+               "xmlTextReaderRead did not return -1, 0 or 1.  Return value was: %d", result);
+  }
 }
 
 /*
@@ -456,14 +564,28 @@ static VALUE rxml_reader_attr_count(VALUE self)
 
 /*
  * call-seq:
- *    reader.encoding -> encoding
+ *    reader.encoding -> XML::Encoding::UTF_8
+ *
+ * Returns the encoding of the document being read.  Note you
+ * first have to read data from the reader for encoding
+ * to return a value
+ *
+ *   reader = XML::Reader.file(XML_FILE)
+ *   assert_nil(reader.encoding)
+ *   reader.read
+ *   assert_equal(XML::Encoding::UTF_8, reader.encoding)
  *
- * Determine the encoding of the document being read.
+ * In addition, libxml always appears to return nil for the encoding
+ * when parsing strings.
  */
 static VALUE rxml_reader_encoding(VALUE self)
 {
-  const xmlChar *result = xmlTextReaderConstEncoding(rxml_text_reader_get(self));
-  return (result == NULL ? Qnil : rb_str_new2((const char*)result));
+  xmlTextReaderPtr xreader = rxml_text_reader_get(self);
+  const xmlChar *xencoding = xmlTextReaderConstEncoding(xreader);
+  if (xencoding)
+    return INT2NUM(xmlParseCharEncoding(xencoding));
+  else
+    return INT2NUM(XML_CHAR_ENCODING_NONE);
 }
 
 /*
@@ -668,7 +790,7 @@ static VALUE rxml_reader_expand(VALUE self)
   doc = xmlTextReaderCurrentDoc(reader);
   rxml_document_wrap(doc);
 
-  return rxml_node_wrap(cXMLNode, node);
+  return rxml_node_wrap(node);
 }
 
 #if LIBXML_VERSION >= 20618
@@ -768,132 +890,104 @@ mXML = rb_define_module_under(mLibXML, "XML");
 
 void ruby_init_xml_reader(void)
 {
+  base_uri_SYMBOL = ID2SYM(rb_intern("base_uri"));
+  ENCODING_SYMBOL = ID2SYM(rb_intern("encoding"));
+  OPTIONS_SYMBOL = ID2SYM(rb_intern("options"));
+
   cXMLReader = rb_define_class_under(mXML, "Reader", rb_cObject);
 
-  rb_define_singleton_method(cXMLReader, "file", rxml_reader_new_file, -1);
-  rb_define_singleton_method(cXMLReader, "io", rxml_reader_new_io, -1);
-  rb_define_singleton_method(cXMLReader, "walker", rxml_reader_new_walker, 1);
-  rb_define_alias(CLASS_OF(cXMLReader), "document", "walker");
-  rb_define_singleton_method(cXMLReader, "new", rxml_reader_new_data, -1);
-  rb_define_alias(CLASS_OF(cXMLReader), "string", "new");
+  rb_define_singleton_method(cXMLReader, "document", rxml_reader_document, 1);
+  rb_define_singleton_method(cXMLReader, "file", rxml_reader_file, -1);
+  rb_define_singleton_method(cXMLReader, "io", rxml_reader_io, -1);
+  rb_define_singleton_method(cXMLReader, "string", rxml_reader_string, -1);
 
+  rb_define_method(cXMLReader, "[]", rxml_reader_attribute, 1);
+  rb_define_method(cXMLReader, "attribute_count", rxml_reader_attr_count, 0);
+  rb_define_method(cXMLReader, "base_uri", rxml_reader_base_uri, 0);
+#if LIBXML_VERSION >= 20618
+  rb_define_method(cXMLReader, "byte_consumed", rxml_reader_byte_consumed, 0);
+#endif
   rb_define_method(cXMLReader, "close", rxml_reader_close, 0);
-
+#if LIBXML_VERSION >= 20617
+  rb_define_method(cXMLReader, "column_number", rxml_reader_column_number, 0);
+#endif
+  rb_define_method(cXMLReader, "depth", rxml_reader_depth, 0);
+  rb_define_method(cXMLReader, "encoding", rxml_reader_encoding, 0);
+  rb_define_method(cXMLReader, "expand", rxml_reader_expand, 0);
+  rb_define_method(cXMLReader, "has_attributes?", rxml_reader_has_attributes, 0);
+  rb_define_method(cXMLReader, "has_value?", rxml_reader_has_value, 0);
+#if LIBXML_VERSION >= 20617
+  rb_define_method(cXMLReader, "line_number", rxml_reader_line_number, 0);
+#endif
+  rb_define_method(cXMLReader, "local_name", rxml_reader_local_name, 0);
+  rb_define_method(cXMLReader, "lookup_namespace",       rxml_reader_lookup_namespace, 1);
   rb_define_method(cXMLReader, "move_to_attribute", rxml_reader_move_to_attr, 1);
-  rb_define_method(cXMLReader, "move_to_first_attribute",
-      rxml_reader_move_to_first_attr, 0);
-  rb_define_method(cXMLReader, "move_to_next_attribute",
-      rxml_reader_move_to_next_attr, 0);
-  rb_define_method(cXMLReader, "move_to_element", rxml_reader_move_to_element,
-      0);
+  rb_define_method(cXMLReader, "move_to_first_attribute",       rxml_reader_move_to_first_attr, 0);
+  rb_define_method(cXMLReader, "move_to_next_attribute",       rxml_reader_move_to_next_attr, 0);
+  rb_define_method(cXMLReader, "move_to_element", rxml_reader_move_to_element,       0);
+  rb_define_method(cXMLReader, "name", rxml_reader_name, 0);
+  rb_define_method(cXMLReader, "namespace_uri", rxml_reader_namespace_uri, 0);
   rb_define_method(cXMLReader, "next", rxml_reader_next, 0);
   rb_define_method(cXMLReader, "next_sibling", rxml_reader_next_sibling, 0);
+  rb_define_method(cXMLReader, "node", rxml_reader_node, 0);
+  rb_define_method(cXMLReader, "node_type", rxml_reader_node_type, 0);
+  rb_define_method(cXMLReader, "normalization", rxml_reader_normalization, 0);
+  rb_define_method(cXMLReader, "prefix", rxml_reader_prefix, 0);
+  rb_define_method(cXMLReader, "quote_char", rxml_reader_quote_char, 0);
   rb_define_method(cXMLReader, "read", rxml_reader_read, 0);
-  rb_define_method(cXMLReader, "read_attribute_value",
-      rxml_reader_read_attr_value, 0);
+  rb_define_method(cXMLReader, "read_attribute_value", rxml_reader_read_attr_value, 0);
   rb_define_method(cXMLReader, "read_inner_xml", rxml_reader_read_inner_xml, 0);
   rb_define_method(cXMLReader, "read_outer_xml", rxml_reader_read_outer_xml, 0);
   rb_define_method(cXMLReader, "read_state", rxml_reader_read_state, 0);
   rb_define_method(cXMLReader, "read_string", rxml_reader_read_string, 0);
-
-  rb_define_method(cXMLReader, "relax_ng_validate",
-      rxml_reader_relax_ng_validate, 1);
+  rb_define_method(cXMLReader, "relax_ng_validate",       rxml_reader_relax_ng_validate, 1);
+  rb_define_method(cXMLReader, "standalone", rxml_reader_standalone, 0);
 #if LIBXML_VERSION >= 20620
   rb_define_method(cXMLReader, "schema_validate", rxml_reader_schema_validate, 1);
 #endif
-
-  rb_define_method(cXMLReader, "node_type", rxml_reader_node_type, 0);
-  rb_define_method(cXMLReader, "normalization", rxml_reader_normalization, 0);
-  rb_define_method(cXMLReader, "attribute_count", rxml_reader_attr_count, 0);
-  rb_define_method(cXMLReader, "name", rxml_reader_name, 0);
-  rb_define_method(cXMLReader, "local_name", rxml_reader_local_name, 0);
-  rb_define_method(cXMLReader, "encoding", rxml_reader_encoding, 0);
-  rb_define_method(cXMLReader, "base_uri", rxml_reader_base_uri, 0);
-  rb_define_method(cXMLReader, "namespace_uri", rxml_reader_namespace_uri, 0);
+  rb_define_method(cXMLReader, "value", rxml_reader_value, 0);
   rb_define_method(cXMLReader, "xml_lang", rxml_reader_xml_lang, 0);
   rb_define_method(cXMLReader, "xml_version", rxml_reader_xml_version, 0);
-  rb_define_method(cXMLReader, "prefix", rxml_reader_prefix, 0);
-  rb_define_method(cXMLReader, "depth", rxml_reader_depth, 0);
-  rb_define_method(cXMLReader, "quote_char", rxml_reader_quote_char, 0);
-  rb_define_method(cXMLReader, "standalone", rxml_reader_standalone, 0);
-
-  rb_define_method(cXMLReader, "has_attributes?", rxml_reader_has_attributes, 0);
-  rb_define_method(cXMLReader, "[]", rxml_reader_attribute, 1);
-  rb_define_method(cXMLReader, "has_value?", rxml_reader_has_value, 0);
-  rb_define_method(cXMLReader, "value", rxml_reader_value, 0);
-
-  rb_define_method(cXMLReader, "lookup_namespace",
-      rxml_reader_lookup_namespace, 1);
-  rb_define_method(cXMLReader, "expand", rxml_reader_expand, 0);
-
-#if LIBXML_VERSION >= 20618
-  rb_define_method(cXMLReader, "byte_consumed", rxml_reader_byte_consumed, 0);
-#endif
-#if LIBXML_VERSION >= 20617
-  rb_define_method(cXMLReader, "column_number", rxml_reader_column_number, 0);
-  rb_define_method(cXMLReader, "line_number", rxml_reader_line_number, 0);
-#endif
   rb_define_method(cXMLReader, "default?", rxml_reader_default, 0);
   rb_define_method(cXMLReader, "empty_element?", rxml_reader_empty_element, 0);
-  rb_define_method(cXMLReader, "namespace_declaration?",
-      rxml_reader_namespace_declaration, 0);
+  rb_define_method(cXMLReader, "namespace_declaration?", rxml_reader_namespace_declaration, 0);
   rb_define_method(cXMLReader, "valid?", rxml_reader_valid, 0);
 
+  /* Constants */
   rb_define_const(cXMLReader, "LOADDTD", INT2FIX(XML_PARSER_LOADDTD));
   rb_define_const(cXMLReader, "DEFAULTATTRS", INT2FIX(XML_PARSER_DEFAULTATTRS));
   rb_define_const(cXMLReader, "VALIDATE", INT2FIX(XML_PARSER_VALIDATE));
-  rb_define_const(cXMLReader, "SUBST_ENTITIES", INT2FIX(
-      XML_PARSER_SUBST_ENTITIES));
-
-  rb_define_const(cXMLReader, "SEVERITY_VALIDITY_WARNING", INT2FIX(
-      XML_PARSER_SEVERITY_VALIDITY_WARNING));
-  rb_define_const(cXMLReader, "SEVERITY_VALIDITY_ERROR", INT2FIX(
-      XML_PARSER_SEVERITY_VALIDITY_ERROR));
-  rb_define_const(cXMLReader, "SEVERITY_WARNING", INT2FIX(
-      XML_PARSER_SEVERITY_WARNING));
-  rb_define_const(cXMLReader, "SEVERITY_ERROR", INT2FIX(
-      XML_PARSER_SEVERITY_ERROR));
+  rb_define_const(cXMLReader, "SUBST_ENTITIES", INT2FIX(XML_PARSER_SUBST_ENTITIES));
+
+  rb_define_const(cXMLReader, "SEVERITY_VALIDITY_WARNING", INT2FIX(XML_PARSER_SEVERITY_VALIDITY_WARNING));
+  rb_define_const(cXMLReader, "SEVERITY_VALIDITY_ERROR", INT2FIX(XML_PARSER_SEVERITY_VALIDITY_ERROR));
+  rb_define_const(cXMLReader, "SEVERITY_WARNING", INT2FIX(XML_PARSER_SEVERITY_WARNING));
+  rb_define_const(cXMLReader, "SEVERITY_ERROR", INT2FIX(XML_PARSER_SEVERITY_ERROR));
 
   rb_define_const(cXMLReader, "TYPE_NONE", INT2FIX(XML_READER_TYPE_NONE));
   rb_define_const(cXMLReader, "TYPE_ELEMENT", INT2FIX(XML_READER_TYPE_ELEMENT));
-  rb_define_const(cXMLReader, "TYPE_ATTRIBUTE", INT2FIX(
-      XML_READER_TYPE_ATTRIBUTE));
+  rb_define_const(cXMLReader, "TYPE_ATTRIBUTE", INT2FIX(XML_READER_TYPE_ATTRIBUTE));
   rb_define_const(cXMLReader, "TYPE_TEXT", INT2FIX(XML_READER_TYPE_TEXT));
   rb_define_const(cXMLReader, "TYPE_CDATA", INT2FIX(XML_READER_TYPE_CDATA));
-  rb_define_const(cXMLReader, "TYPE_ENTITY_REFERENCE", INT2FIX(
-      XML_READER_TYPE_ENTITY_REFERENCE));
+  rb_define_const(cXMLReader, "TYPE_ENTITY_REFERENCE", INT2FIX(XML_READER_TYPE_ENTITY_REFERENCE));
   rb_define_const(cXMLReader, "TYPE_ENTITY", INT2FIX(XML_READER_TYPE_ENTITY));
-  rb_define_const(cXMLReader, "TYPE_PROCESSING_INSTRUCTION", INT2FIX(
-      XML_READER_TYPE_PROCESSING_INSTRUCTION));
+  rb_define_const(cXMLReader, "TYPE_PROCESSING_INSTRUCTION", INT2FIX(XML_READER_TYPE_PROCESSING_INSTRUCTION));
   rb_define_const(cXMLReader, "TYPE_COMMENT", INT2FIX(XML_READER_TYPE_COMMENT));
-  rb_define_const(cXMLReader, "TYPE_DOCUMENT",
-      INT2FIX(XML_READER_TYPE_DOCUMENT));
-  rb_define_const(cXMLReader, "TYPE_DOCUMENT_TYPE", INT2FIX(
-      XML_READER_TYPE_DOCUMENT_TYPE));
-  rb_define_const(cXMLReader, "TYPE_DOCUMENT_FRAGMENT", INT2FIX(
-      XML_READER_TYPE_DOCUMENT_FRAGMENT));
-  rb_define_const(cXMLReader, "TYPE_NOTATION",
-      INT2FIX(XML_READER_TYPE_NOTATION));
-  rb_define_const(cXMLReader, "TYPE_WHITESPACE", INT2FIX(
-      XML_READER_TYPE_WHITESPACE));
-  rb_define_const(cXMLReader, "TYPE_SIGNIFICANT_WHITESPACE", INT2FIX(
-      XML_READER_TYPE_SIGNIFICANT_WHITESPACE));
-  rb_define_const(cXMLReader, "TYPE_END_ELEMENT", INT2FIX(
-      XML_READER_TYPE_END_ELEMENT));
-  rb_define_const(cXMLReader, "TYPE_END_ENTITY", INT2FIX(
-      XML_READER_TYPE_END_ENTITY));
-  rb_define_const(cXMLReader, "TYPE_XML_DECLARATION", INT2FIX(
-      XML_READER_TYPE_XML_DECLARATION));
+  rb_define_const(cXMLReader, "TYPE_DOCUMENT",       INT2FIX(XML_READER_TYPE_DOCUMENT));
+  rb_define_const(cXMLReader, "TYPE_DOCUMENT_TYPE", INT2FIX(XML_READER_TYPE_DOCUMENT_TYPE));
+  rb_define_const(cXMLReader, "TYPE_DOCUMENT_FRAGMENT", INT2FIX(XML_READER_TYPE_DOCUMENT_FRAGMENT));
+  rb_define_const(cXMLReader, "TYPE_NOTATION",       INT2FIX(XML_READER_TYPE_NOTATION));
+  rb_define_const(cXMLReader, "TYPE_WHITESPACE", INT2FIX(XML_READER_TYPE_WHITESPACE));
+  rb_define_const(cXMLReader, "TYPE_SIGNIFICANT_WHITESPACE", INT2FIX(XML_READER_TYPE_SIGNIFICANT_WHITESPACE));
+  rb_define_const(cXMLReader, "TYPE_END_ELEMENT", INT2FIX(XML_READER_TYPE_END_ELEMENT));
+  rb_define_const(cXMLReader, "TYPE_END_ENTITY", INT2FIX(XML_READER_TYPE_END_ENTITY));
+  rb_define_const(cXMLReader, "TYPE_XML_DECLARATION", INT2FIX(XML_READER_TYPE_XML_DECLARATION));
 
   /* Read states */
-  rb_define_const(cXMLReader, "MODE_INITIAL", INT2FIX(
-      XML_TEXTREADER_MODE_INITIAL));
-  rb_define_const(cXMLReader, "MODE_INTERACTIVE", INT2FIX(
-      XML_TEXTREADER_MODE_INTERACTIVE));
+  rb_define_const(cXMLReader, "MODE_INITIAL", INT2FIX(XML_TEXTREADER_MODE_INITIAL));
+  rb_define_const(cXMLReader, "MODE_INTERACTIVE", INT2FIX(XML_TEXTREADER_MODE_INTERACTIVE));
   rb_define_const(cXMLReader, "MODE_ERROR", INT2FIX(XML_TEXTREADER_MODE_ERROR));
   rb_define_const(cXMLReader, "MODE_EOF", INT2FIX(XML_TEXTREADER_MODE_EOF));
-  rb_define_const(cXMLReader, "MODE_CLOSED",
-      INT2FIX(XML_TEXTREADER_MODE_CLOSED));
-  rb_define_const(cXMLReader, "MODE_READING", INT2FIX(
-      XML_TEXTREADER_MODE_READING));
+  rb_define_const(cXMLReader, "MODE_CLOSED",       INT2FIX(XML_TEXTREADER_MODE_CLOSED));
+  rb_define_const(cXMLReader, "MODE_READING", INT2FIX(XML_TEXTREADER_MODE_READING));
 }