libxml-ruby 4.1.2-x64-mingw-ucrt → 5.0.1-x64-mingw-ucrt

data/ext/libxml/ruby_xml_parser.h

@@ -5,6 +5,6 @@
 
 extern VALUE cXMLParser;
 
-void rxml_init_parser();
+void rxml_init_parser(void);
 
 #endif

data/ext/libxml/ruby_xml_parser_context.c

@@ -39,31 +39,33 @@ static VALUE rxml_parser_context_alloc(VALUE klass)
  *
  * Parameters:
  *
- *  document - An XML::Document instance.
+ *  document - An XML::Document instance
+ *  options - A or'ed together list of LibXML::XML::Parser::Options values
  */
-static VALUE rxml_parser_context_document(VALUE klass, VALUE document)
+static VALUE rxml_parser_context_document(int argc, VALUE* argv, VALUE klass)
 {
-  xmlParserCtxtPtr ctxt;
-  xmlDocPtr xdoc;
-  xmlChar *buffer; 
-  int length;
+  VALUE document, options;
+  rb_scan_args(argc, argv, "11", &document, &options);
 
   if (rb_obj_is_kind_of(document, cXMLDocument) == Qfalse)
     rb_raise(rb_eTypeError, "Must pass an LibXML::XML::Document object");
 
+  xmlDocPtr xdoc;
+  xmlChar *buffer;
+  int length;
   Data_Get_Struct(document, xmlDoc, xdoc);
   xmlDocDumpFormatMemoryEnc(xdoc, &buffer, &length, (const char*)xdoc->encoding, 0);
 
-  ctxt = xmlCreateDocParserCtxt(buffer);
+  xmlParserCtxtPtr ctxt = xmlCreateDocParserCtxt(buffer);
 
   if (!ctxt)
-    rxml_raise(&xmlLastError);
+    rxml_raise(xmlGetLastError());
 
   /* This is annoying, but xmlInitParserCtxt (called indirectly above) and 
      xmlCtxtUseOptionsInternal (called below) initialize slightly different
      context options, in particular XML_PARSE_NODICT which xmlInitParserCtxt
      sets to 0 and xmlCtxtUseOptionsInternal sets to 1.  So we have to call both. */
-  xmlCtxtUseOptions(ctxt, rxml_libxml_default_options());
+  xmlCtxtUseOptions(ctxt, options == Qnil ? 0 : NUM2INT(options));
 
   return rxml_parser_context_wrap(ctxt);
 }
@@ -75,20 +77,24 @@ static VALUE rxml_parser_context_document(VALUE klass, VALUE document)
  *
  * Parameters:
  *
- *  file - A filename or uri.
+ *  file - A filename or uri
+ *  options - A or'ed together list of LibXML::XML::Parser::Options values
 */
-static VALUE rxml_parser_context_file(VALUE klass, VALUE file)
+static VALUE rxml_parser_context_file(int argc, VALUE* argv, VALUE klass)
 {
+  VALUE file, options;
+  rb_scan_args(argc, argv, "11", &file, &options);
+
   xmlParserCtxtPtr ctxt = xmlCreateURLParserCtxt(StringValuePtr(file), 0);
 
   if (!ctxt)
-    rxml_raise(&xmlLastError);
+    rxml_raise(xmlGetLastError());
 
   /* This is annoying, but xmlInitParserCtxt (called indirectly above) and 
      xmlCtxtUseOptionsInternal (called below) initialize slightly different
      context options, in particular XML_PARSE_NODICT which xmlInitParserCtxt
      sets to 0 and xmlCtxtUseOptionsInternal sets to 1.  So we have to call both. */
-  xmlCtxtUseOptions(ctxt, rxml_libxml_default_options());
+  xmlCtxtUseOptions(ctxt, options == Qnil ? 0 : NUM2INT(options));
 
   return rxml_parser_context_wrap(ctxt);
 }
@@ -100,26 +106,29 @@ static VALUE rxml_parser_context_file(VALUE klass, VALUE file)
  *
  * Parameters:
  *
- *  string - A string that contains the data to parse.
+ *  string - A string that contains the data to parse
+ *  options - A or'ed together list of LibXML::XML::Parser::Options values
 */
-static VALUE rxml_parser_context_string(VALUE klass, VALUE string)
+static VALUE rxml_parser_context_string(int argc, VALUE* argv, VALUE klass)
 {
-  xmlParserCtxtPtr ctxt;
+  VALUE string, options;
+  rb_scan_args(argc, argv, "11", &string, &options);
+
   Check_Type(string, T_STRING);
 
   if (RSTRING_LEN(string) == 0)
     rb_raise(rb_eArgError, "Must specify a string with one or more characters");
 
-  ctxt = xmlCreateMemoryParserCtxt(StringValuePtr(string), (int)RSTRING_LEN(string));
+  xmlParserCtxtPtr ctxt = xmlCreateMemoryParserCtxt(StringValuePtr(string), (int)RSTRING_LEN(string));
   
   if (!ctxt)
-    rxml_raise(&xmlLastError);
+    rxml_raise(xmlGetLastError());
 
   /* This is annoying, but xmlInitParserCtxt (called indirectly above) and 
      xmlCtxtUseOptionsInternal (called below) initialize slightly different
      context options, in particular XML_PARSE_NODICT which xmlInitParserCtxt
      sets to 0 and xmlCtxtUseOptionsInternal sets to 1.  So we have to call both. */
-  xmlCtxtUseOptions(ctxt, rxml_libxml_default_options());
+  xmlCtxtUseOptions(ctxt, options == Qnil ? 0 : NUM2INT(options));
 
   return rxml_parser_context_wrap(ctxt);
 }
@@ -131,45 +140,44 @@ static VALUE rxml_parser_context_string(VALUE klass, VALUE string)
  *
  * Parameters:
  *
- *  io - A ruby IO object.
+ *  io - A ruby IO object
+ *  options - A or'ed together list of LibXML::XML::Parser::Options values
 */
-static VALUE rxml_parser_context_io(VALUE klass, VALUE io)
+static VALUE rxml_parser_context_io(int argc, VALUE* argv, VALUE klass)
 {
-  VALUE result;
-  xmlParserCtxtPtr ctxt;
-  xmlParserInputBufferPtr input;
-  xmlParserInputPtr stream;
+  VALUE io, options;
+  rb_scan_args(argc, argv, "11", &io, &options);
 
   if (NIL_P(io))
     rb_raise(rb_eTypeError, "Must pass in an IO object");
 
-  input = xmlParserInputBufferCreateIO((xmlInputReadCallback) rxml_read_callback, NULL,
+  xmlParserInputBufferPtr input = xmlParserInputBufferCreateIO((xmlInputReadCallback) rxml_read_callback, NULL,
                                        (void*)io, XML_CHAR_ENCODING_NONE);
-    
-  ctxt = xmlNewParserCtxt();
+
+  xmlParserCtxtPtr ctxt = xmlNewParserCtxt();
 
   if (!ctxt)
   {
     xmlFreeParserInputBuffer(input);
-    rxml_raise(&xmlLastError);
+    rxml_raise(xmlGetLastError());
   }
 
   /* This is annoying, but xmlInitParserCtxt (called indirectly above) and 
      xmlCtxtUseOptionsInternal (called below) initialize slightly different
      context options, in particular XML_PARSE_NODICT which xmlInitParserCtxt
      sets to 0 and xmlCtxtUseOptionsInternal sets to 1.  So we have to call both. */
-  xmlCtxtUseOptions(ctxt, rxml_libxml_default_options());
+  xmlCtxtUseOptions(ctxt, options == Qnil ? 0 : NUM2INT(options));
 
-  stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
+  xmlParserInputPtr stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
 
   if (!stream)
   {
     xmlFreeParserInputBuffer(input);
     xmlFreeParserCtxt(ctxt);
-    rxml_raise(&xmlLastError);
+    rxml_raise(xmlGetLastError());
   }
   inputPush(ctxt, stream);
-  result = rxml_parser_context_wrap(ctxt);
+  VALUE result = rxml_parser_context_wrap(ctxt);
 
   /* Attach io object to parser so it won't get freed.*/
   rb_ivar_set(result, IO_ATTR, io);
@@ -303,7 +311,7 @@ static VALUE rxml_parser_context_disable_cdata_set(VALUE self, VALUE value)
   if (value)
     ctxt->sax->cdataBlock = NULL;
   else
-    ctxt->sax->cdataBlock = xmlDefaultSAXHandler.cdataBlock;
+    ctxt->sax->cdataBlock = xmlSAX2CDataBlock;
 
   return value;
 }
@@ -377,7 +385,7 @@ static VALUE rxml_parser_context_encoding_set(VALUE self, VALUE encoding)
   result = xmlSwitchToEncoding(ctxt, hdlr);
 
   if (result != 0)
-    rxml_raise(&xmlLastError);
+    rxml_raise(xmlGetLastError());
 
   if (ctxt->encoding != NULL)
     xmlFree((xmlChar *) ctxt->encoding);
@@ -950,10 +958,10 @@ void rxml_init_parser_context(void)
   cXMLParserContext = rb_define_class_under(cXMLParser, "Context", rb_cObject);
   rb_define_alloc_func(cXMLParserContext, rxml_parser_context_alloc);
 
-  rb_define_singleton_method(cXMLParserContext, "document", rxml_parser_context_document, 1);
-  rb_define_singleton_method(cXMLParserContext, "file", rxml_parser_context_file, 1);
-  rb_define_singleton_method(cXMLParserContext, "io", rxml_parser_context_io, 1);
-  rb_define_singleton_method(cXMLParserContext, "string", rxml_parser_context_string, 1);
+  rb_define_singleton_method(cXMLParserContext, "document", rxml_parser_context_document, -1);
+  rb_define_singleton_method(cXMLParserContext, "file", rxml_parser_context_file, -1);
+  rb_define_singleton_method(cXMLParserContext, "io", rxml_parser_context_io, -1);
+  rb_define_singleton_method(cXMLParserContext, "string", rxml_parser_context_string, -1);
 
   rb_define_method(cXMLParserContext, "base_uri", rxml_parser_context_base_uri_get, 0);
   rb_define_method(cXMLParserContext, "base_uri=", rxml_parser_context_base_uri_set, 1);

data/ext/libxml/ruby_xml_parser_options.c

@@ -55,7 +55,7 @@ void rxml_init_parser_options(void)
   /* 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));
+  rb_define_const(mXMLParserOptions, "OLD10", INT2NUM(XML_PARSE_OLD10));
   /* do not fixup XINCLUDE xml:base uris */
   rb_define_const(mXMLParserOptions, "NOBASEFIX", INT2NUM(XML_PARSE_NOBASEFIX));
 #endif
@@ -63,4 +63,12 @@ void rxml_init_parser_options(void)
   /* relax any hardcoded limit from the parser */
   rb_define_const(mXMLParserOptions, "HUGE", INT2NUM(XML_PARSE_HUGE));
 #endif
+#if LIBXML_VERSION >= 21106
+  /* parse using SAX2 interface before 2.7.0 */
+  rb_define_const(mXMLParserOptions, "OLDSAX", INT2NUM(XML_PARSE_OLDSAX));
+  /* ignore internal document encoding hint */
+  rb_define_const(mXMLParserOptions, "IGNORE_ENC", INT2NUM(XML_PARSE_IGNORE_ENC));
+  /* Store big lines numbers in text PSVI field */
+  rb_define_const(mXMLParserOptions, "BIG_LINES", INT2NUM(XML_PARSE_BIG_LINES));
+#endif
 }

data/ext/libxml/ruby_xml_parser_options.h

@@ -5,6 +5,6 @@
 
 extern VALUE mXMLParserOptions;
 
-void rxml_init_parser_options();
+void rxml_init_parser_options(void);
 
 #endif

data/ext/libxml/ruby_xml_reader.c

@@ -4,6 +4,8 @@
 #include "ruby_libxml.h"
 #include "ruby_xml_reader.h"
 
+#include <errno.h>
+
 #include <libxml/xmlreader.h>
 #include <libxml/xmlschemas.h>
 
@@ -98,7 +100,7 @@ VALUE rxml_reader_document(VALUE klass, VALUE doc)
   xreader = xmlReaderWalker(xdoc);
 
   if (xreader == NULL)
-    rxml_raise(&xmlLastError);
+    rxml_raise(xmlGetLastError());
 
   return rxml_reader_wrap(xreader);
 }
@@ -122,34 +124,31 @@ VALUE rxml_reader_document(VALUE klass, VALUE doc)
  */
 static VALUE rxml_reader_file(int argc, VALUE *argv, VALUE klass)
 {
-  xmlTextReaderPtr xreader;
   VALUE path;
   VALUE options;
 
-  const char *xencoding = NULL;
-  int xoptions = 0;
-
   rb_scan_args(argc, argv, "11", &path, &options);
   Check_Type(path, T_STRING);
 
+  const char* xencoding = NULL;
+  int xoptions = 0;
+
   if (!NIL_P(options))
   {
-    VALUE encoding = Qnil;
-    VALUE parserOptions = Qnil;
-
     Check_Type(options, T_HASH);
 
-    encoding = rb_hash_aref(options, BASE_URI_SYMBOL);
+    VALUE encoding = rb_hash_aref(options, BASE_URI_SYMBOL);
     xencoding = NIL_P(encoding) ? NULL : xmlGetCharEncodingName(NUM2INT(encoding));
 
-    parserOptions = rb_hash_aref(options, OPTIONS_SYMBOL);
+    VALUE parserOptions = rb_hash_aref(options, OPTIONS_SYMBOL);
     xoptions = NIL_P(parserOptions) ? 0 : NUM2INT(parserOptions);
   }
 
-  xreader = xmlReaderForFile(StringValueCStr(path), xencoding, xoptions);
+  xmlTextReaderPtr xreader = xmlReaderForFile(StringValueCStr(path), xencoding, xoptions);
 
+  // Unfortunately libxml2 does not set xmlLastError and just returns a null reader
   if (xreader == NULL)
-    rxml_raise(&xmlLastError);
+    rb_syserr_fail(ENOENT, StringValueCStr(path));
 
   return rxml_reader_wrap(xreader);
 }
@@ -207,7 +206,7 @@ static VALUE rxml_reader_io(int argc, VALUE *argv, VALUE klass)
                            xbaseurl, xencoding, xoptions);
 
   if (xreader == NULL)
-    rxml_raise(&xmlLastError);
+    rxml_raise(xmlGetLastError());
 
   result = rxml_reader_wrap(xreader);
 
@@ -269,7 +268,7 @@ static VALUE rxml_reader_string(int argc, VALUE *argv, VALUE klass)
                                xbaseurl, xencoding, xoptions);
 
   if (xreader == NULL)
-    rxml_raise(&xmlLastError);
+    rxml_raise(xmlGetLastError());
 
   return rxml_reader_wrap(xreader);
 }
@@ -472,7 +471,7 @@ static VALUE rxml_reader_read(VALUE self)
   switch(result)
   {
     case -1:
-      rxml_raise(&xmlLastError);
+      rxml_raise(xmlGetLastError());
       return Qnil;
       break;
     case 0:
@@ -1048,7 +1047,7 @@ static VALUE
 rxml_reader_byte_consumed(VALUE self)
 {
   xmlTextReaderPtr xreader = rxml_text_reader_get(self);
-  return INT2NUM(xmlTextReaderByteConsumed(xreader));
+  return LONG2NUM(xmlTextReaderByteConsumed(xreader));
 }
 #endif
 

data/ext/libxml/ruby_xml_sax2_handler.c

@@ -243,7 +243,7 @@ static void start_element_ns_callback(void *ctx,
              namespaces);
 }
 
-static void structured_error_callback(void *ctx, xmlErrorPtr xerror)
+static void structured_error_callback(void *ctx, const xmlError *xerror)
 {
   /* Older versions of Libxml will pass a NULL context from the sax parser.  Fixed on
      Feb 23, 2011.  See:

data/ext/libxml/ruby_xml_sax_parser.c

@@ -74,23 +74,15 @@ static VALUE rxml_sax_parser_initialize(int argc, VALUE *argv, VALUE self)
  */
 static VALUE rxml_sax_parser_parse(VALUE self)
 {
-  int status;
   VALUE context = rb_ivar_get(self, CONTEXT_ATTR);
   xmlParserCtxtPtr ctxt;
   Data_Get_Struct(context, xmlParserCtxt, ctxt);
 
   ctxt->sax2 = 1;
 	ctxt->userData = (void*)rb_ivar_get(self, CALLBACKS_ATTR);
-
-  if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
-    xmlFree(ctxt->sax);
-    
-  ctxt->sax = (xmlSAXHandlerPtr) xmlMalloc(sizeof(rxml_sax_handler));
-  if (ctxt->sax == NULL)
-    rb_fatal("Not enough memory.");
   memcpy(ctxt->sax, &rxml_sax_handler, sizeof(rxml_sax_handler));
     
-  status = xmlParseDocument(ctxt);
+  int status = xmlParseDocument(ctxt);
 
   /* Now check the parsing result*/
   if (status == -1 || !ctxt->wellFormed)

data/ext/libxml/ruby_xml_schema.c

@@ -143,7 +143,7 @@ static VALUE rxml_schema_init(VALUE class, xmlSchemaParserCtxtPtr xparser)
   xmlSchemaFreeParserCtxt(xparser);
 
   if (!xschema)
-    rxml_raise(&xmlLastError);
+    rxml_raise(xmlGetLastError());
 
   return rxml_wrap_schema(xschema);
 }
@@ -163,7 +163,7 @@ static VALUE rxml_schema_init_from_uri(VALUE class, VALUE uri)
   xmlResetLastError();
   xparser = xmlSchemaNewParserCtxt(StringValuePtr(uri));
   if (!xparser)
-    rxml_raise(&xmlLastError);
+    rxml_raise(xmlGetLastError());
 
   return rxml_schema_init(class, xparser);
 }
@@ -184,7 +184,7 @@ static VALUE rxml_schema_init_from_document(VALUE class, VALUE document)
   xmlResetLastError();
   xparser = xmlSchemaNewDocParserCtxt(xdoc);
   if (!xparser)
-    rxml_raise(&xmlLastError);
+    rxml_raise(xmlGetLastError());
 
   return rxml_schema_init(class, xparser);
 }
@@ -204,7 +204,7 @@ static VALUE rxml_schema_init_from_string(VALUE class, VALUE schema_str)
   xmlResetLastError();
   xparser = xmlSchemaNewMemParserCtxt(StringValuePtr(schema_str), (int)strlen(StringValuePtr(schema_str)));
   if (!xparser)
-    rxml_raise(&xmlLastError);
+    rxml_raise(xmlGetLastError());
 
   return rxml_schema_init(class, xparser);
 }

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  "4.1.2"
-#define RUBY_LIBXML_VERNUM   400
-#define RUBY_LIBXML_VER_MAJ   4
-#define RUBY_LIBXML_VER_MIN   1
-#define RUBY_LIBXML_VER_MIC   2
+#define RUBY_LIBXML_VERSION  "5.0.1"
+#define RUBY_LIBXML_VERNUM   501
+#define RUBY_LIBXML_VER_MAJ   5
+#define RUBY_LIBXML_VER_MIN   0
+#define RUBY_LIBXML_VER_MIC   1
 #define RUBY_LIBXML_VER_PATCH 0

data/ext/libxml/ruby_xml_writer.c

@@ -116,11 +116,11 @@ static VALUE rxml_writer_io(VALUE klass, VALUE io)
     xmlCharEncodingHandlerPtr encodingHdlr = xmlFindCharEncodingHandler(rwo->encoding->name);
     if (NULL == (out = xmlOutputBufferCreateIO(rxml_writer_write_callback, NULL, (void*)rwo, encodingHdlr)))
     {
-        rxml_raise(&xmlLastError);
+        rxml_raise(xmlGetLastError());
     }
     if (NULL == (rwo->writer = xmlNewTextWriter(out)))
     {
-        rxml_raise(&xmlLastError);
+        rxml_raise(xmlGetLastError());
     }
 
     return rxml_writer_wrap(rwo);
@@ -145,7 +145,7 @@ static VALUE rxml_writer_file(VALUE klass, VALUE filename)
     rwo->output_type = RXMLW_OUTPUT_NONE;
     if (NULL == (rwo->writer = xmlNewTextWriterFilename(StringValueCStr(filename), 0)))
     {
-        rxml_raise(&xmlLastError);
+        rxml_raise(xmlGetLastError());
     }
 
     return rxml_writer_wrap(rwo);
@@ -167,12 +167,12 @@ static VALUE rxml_writer_string(VALUE klass)
     rwo->output_type = RXMLW_OUTPUT_STRING;
     if (NULL == (rwo->buffer = xmlBufferCreate()))
     {
-        rxml_raise(&xmlLastError);
+        rxml_raise(xmlGetLastError());
     }
     if (NULL == (rwo->writer = xmlNewTextWriterMemory(rwo->buffer, 0)))
     {
         xmlBufferFree(rwo->buffer);
-        rxml_raise(&xmlLastError);
+        rxml_raise(xmlGetLastError());
     }
 
     return rxml_writer_wrap(rwo);
@@ -196,7 +196,7 @@ static VALUE rxml_writer_doc(VALUE klass)
     rwo->output_type = RXMLW_OUTPUT_DOC;
     if (NULL == (rwo->writer = xmlNewTextWriterDoc(&doc, 0)))
     {
-        rxml_raise(&xmlLastError);
+        rxml_raise(xmlGetLastError());
     }
     rwo->output = rxml_document_wrap(doc);
 
@@ -224,7 +224,7 @@ static VALUE rxml_writer_flush(int argc, VALUE* argv, VALUE self)
     rwo = rxml_textwriter_get(self);
     if (-1 == (ret = xmlTextWriterFlush(rwo->writer)))
     {
-        rxml_raise(&xmlLastError);
+        rxml_raise(xmlGetLastError());
     }
 
     if (NULL != rwo->buffer)
@@ -260,7 +260,7 @@ static VALUE rxml_writer_result(VALUE self)
 
     if (bytesWritten == -1)
     {
-        rxml_raise(&xmlLastError);
+        rxml_raise(xmlGetLastError());
     }
 
     switch (rwo->output_type)

data/ext/libxml/ruby_xml_xpath.c

@@ -89,7 +89,7 @@ VALUE rxml_xpath_to_value(xmlXPathContextPtr xctxt, xmlXPathObjectPtr xobject)
     /* xmlLastError is different than xctxt->lastError.  Use
      xmlLastError since it has the message set while xctxt->lastError
      does not. */
-    xmlErrorPtr xerror = xmlGetLastError();
+    const xmlError *xerror = xmlGetLastError();
     rxml_raise(xerror);
   }
 

data/ext/libxml/ruby_xml_xpath_context.c

@@ -320,7 +320,7 @@ rxml_xpath_context_enable_cache(int argc,  VALUE *argv, VALUE self)
   }
 
   if (xmlXPathContextSetCache(xctxt, 1, value, 0) == -1)
-    rxml_raise(&xmlLastError);
+    rxml_raise(xmlGetLastError());
 
   return self;
 }
@@ -338,7 +338,7 @@ rxml_xpath_context_disable_cache(VALUE self)
   Data_Get_Struct(self, xmlXPathContext, xctxt);
 
   if (xmlXPathContextSetCache(xctxt, 0, 0, 0) == -1)
-    rxml_raise(&xmlLastError);
+    rxml_raise(xmlGetLastError());
 
   return self;
 }

data/ext/libxml/ruby_xml_xpath_expression.c

@@ -64,7 +64,7 @@ static VALUE rxml_xpath_expression_initialize(VALUE self, VALUE expression)
 
   if (compexpr == NULL)
   {
-    xmlErrorPtr xerror = xmlGetLastError();
+    const xmlError *xerror = xmlGetLastError();
     rxml_raise(xerror);
   }
 

data/lib/libxml/document.rb

@@ -17,21 +17,21 @@ module LibXML
 
       # call-seq:
       #    XML::Document.file(path) -> XML::Document
-      #    XML::Document.file(path, :encoding => XML::Encoding::UTF_8,
-      #                             :options => XML::Parser::Options::NOENT) -> XML::Document
+      #    XML::Document.file(path, encoding: XML::Encoding::UTF_8,
+      #                             options: XML::Parser::Options::NOENT) -> XML::Document
       #
       # Creates a new document from the specified file or uri.
       #
-      # You may provide an optional hash table to control how the
-      # parsing is performed.  Valid options are:
+      # Parameters:
       #
+      #  path - Path to file
       #  encoding - The document encoding, defaults to nil. Valid values
       #             are the encoding constants defined on XML::Encoding.
       #  options - Parser options.  Valid values are the constants defined on
       #            XML::Parser::Options.  Mutliple options can be combined
       #            by using Bitwise OR (|).
-      def self.file(value, options = {})
-        Parser.file(value, options).parse
+      def self.file(path, encoding: nil, options: nil)
+        Parser.file(path, encoding: encoding, options: options).parse
       end
 
       # call-seq:
@@ -51,29 +51,29 @@ module LibXML
       #  options - Parser options.  Valid values are the constants defined on
       #            XML::Parser::Options.  Mutliple options can be combined
       #            by using Bitwise OR (|).
-      def self.io(value, options = {})
-        Parser.io(value, options).parse
+      def self.io(io, base_uri: nil, encoding: nil, options: nil)
+        Parser.io(io, base_uri: base_uri, encoding: encoding, options: options).parse
       end
 
       # call-seq:
       #    XML::Document.string(string) -> XML::Document
-      #    XML::Document.string(string, :encoding => XML::Encoding::UTF_8,
-      #                               :options => XML::Parser::Options::NOENT
-      #                               :base_uri="http://libxml.org") -> XML::Document
+      #    XML::Document.string(string, encoding: XML::Encoding::UTF_8,
+      #                                 options: XML::Parser::Options::NOENT
+      #                                 base_uri: "http://libxml.org") -> XML::Document
       #
       # Creates a new document from the specified string.
       #
-      # You may provide an optional hash table to control how the
-      # parsing is performed.  Valid options are:
+      # Parameters:
       #
+      #   string - String to parse
       #   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  - Parser options.  Valid values are the constants defined on
       #              XML::Parser::Options.  Mutliple options can be combined
       #              by using Bitwise OR (|).
-      def self.string(value, options = {})
-        Parser.string(value, options).parse
+      def self.string(value, base_uri: nil, encoding: nil, options: nil)
+        Parser.string(value, base_uri: base_uri, encoding: encoding, options: options).parse
       end
 
       # Returns a new XML::XPathContext for the document.