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

data/ext/libxml/ruby_xml_dtd.c

@@ -40,6 +40,23 @@ static VALUE rxml_dtd_alloc(VALUE klass)
   return Data_Wrap_Struct(klass, NULL, rxml_dtd_free, NULL);
 }
 
+VALUE rxml_dtd_wrap(xmlDtdPtr xdtd)
+{
+  VALUE result;
+
+  // This node is already wrapped
+  if (xdtd->_private != NULL)
+    return (VALUE) xdtd->_private;
+
+  result = Data_Wrap_Struct(cXMLDtd, NULL, NULL, xdtd);
+
+  xdtd->_private = (void*) result;
+
+  return result;
+}
+
+
+
 /*
  * call-seq:
  *    XML::Dtd.new("public system") -> dtd
@@ -72,7 +89,7 @@ static VALUE rxml_dtd_initialize(int argc, VALUE *argv, VALUE self)
     if (xdtd == NULL)
       rxml_raise(&xmlLastError);
 
-    DATA_PTR( self) = xdtd;
+    DATA_PTR(self) = xdtd;
 
     xmlSetTreeDoc((xmlNodePtr) xdtd, NULL);
     break;

data/ext/libxml/ruby_xml_dtd.h

@@ -4,5 +4,6 @@
 extern VALUE cXMLDtd;
 
 void  ruby_init_xml_dtd(void);
+VALUE rxml_dtd_wrap(xmlDtdPtr xdtd);
 
 #endif

data/ext/libxml/ruby_xml_encoding.c

@@ -0,0 +1,116 @@
+/* $Id: rxml_input.c 528 2008-11-15 23:43:48Z cfis $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#include <stdarg.h>
+#include "ruby_libxml.h"
+
+/*
+ * Document-class: LibXML::XML::Encoding
+ *
+ * The encoding class defines the encodings that libxml
+ * supports. LibXML converts all data sources to UTF8
+ * internally before processing them.
+ *
+ * By default, LibXML determines a data source's encoding 
+ * using the algorithm described on its
+ * website[* http://xmlsoft.org/encoding.html].  
+ *
+ * However, you may override a data source's encoding 
+ * by using the encoding constants defined in this
+ * module.
+ *
+ * Example 1:
+ *
+ *   io = File.open('some_file', 'rb')
+ *   parser = XML::Parser.io(io, :encoding => XML::Encoding::ISO_8859_1)
+ *   doc = parser.parse
+ *
+ * Example 2:
+ *
+ *   parser = XML::HTMLParser.file("some_file", :encoding => XML::Encoding::ISO_8859_1)
+ *   doc = parser.parse
+ *
+ * Example 3:
+ *
+ *   document = XML::Document.new
+ *   document.encoding = XML::Encoding::ISO_8859_1
+ *   doc << XML::Node.new
+ */
+
+VALUE mXMLEncoding;
+
+
+/*
+ * call-seq:
+ *    Input.s_to_encoding("UTF_8") -> XML::Encoding::UTF_8
+ *
+ * Converts an encoding string to an encoding constant
+ * defined on the XML::Encoding class.
+ */
+static VALUE rxml_encoding_from_s(VALUE klass, VALUE encoding)
+{
+  xmlCharEncoding xencoding;
+  
+  if (encoding == Qnil)
+    return Qnil;
+
+  xencoding = xmlParseCharEncoding(StringValuePtr(encoding));
+  return NUM2INT(xencoding);
+}
+
+/*
+ * call-seq:
+ *    Input.encoding_to_s(Input::ENCODING) -> "encoding"
+ *
+ * Converts an encoding contstant defined on the XML::Encoding
+ * class to its text representation.
+ */
+static VALUE rxml_encoding_to_s(VALUE klass, VALUE encoding)
+{
+  const char* xecoding = xmlGetCharEncodingName(NUM2INT(encoding));
+
+  if (!xecoding)
+    return Qnil;
+  else
+    return rb_str_new2(xecoding);
+}
+
+// Rdoc needs to know
+#ifdef RDOC_NEVER_DEFINED
+mLibXML = rb_define_module("LibXML");
+mXML = rb_define_module_under(mLibXML, "XML");
+#endif
+
+void ruby_init_xml_encoding(void)
+{
+  mXMLEncoding = rb_define_module_under(mXML, "Encoding");
+  rb_define_module_function(mXMLEncoding, "from_s", rxml_encoding_from_s, 1);
+  rb_define_module_function(mXMLEncoding, "to_s", rxml_encoding_to_s, 1);
+
+  rb_define_const(mXMLEncoding, "UNDEFINED", INT2NUM(XPATH_UNDEFINED));
+  rb_define_const(mXMLEncoding, "ERROR", INT2NUM(XML_CHAR_ENCODING_ERROR)); /* No char encoding detected */
+  rb_define_const(mXMLEncoding, "NONE", INT2NUM(XML_CHAR_ENCODING_NONE)); /* No char encoding detected */
+  rb_define_const(mXMLEncoding, "UTF_8", INT2NUM(XML_CHAR_ENCODING_UTF8)); /* UTF-8 */
+  rb_define_const(mXMLEncoding, "UTF_16LE", INT2NUM(XML_CHAR_ENCODING_UTF16LE)); /* UTF-16 little endian */
+  rb_define_const(mXMLEncoding, "UTF_16BE", INT2NUM(XML_CHAR_ENCODING_UTF16BE)); /* UTF-16 big endian */
+  rb_define_const(mXMLEncoding, "UCS_4LE", INT2NUM(XML_CHAR_ENCODING_UCS4LE)); /* UCS-4 little endian */
+  rb_define_const(mXMLEncoding, "UCS_4BE", INT2NUM(XML_CHAR_ENCODING_UCS4BE)); /* UCS-4 big endian */
+  rb_define_const(mXMLEncoding, "EBCDIC", INT2NUM(XML_CHAR_ENCODING_EBCDIC)); /* EBCDIC uh! */
+  rb_define_const(mXMLEncoding, "UCS_4_2143", INT2NUM(XML_CHAR_ENCODING_UCS4_2143)); /* UCS-4 unusual ordering */
+  rb_define_const(mXMLEncoding, "UCS_4_3412", INT2NUM(XML_CHAR_ENCODING_UCS4_3412)); /* UCS-4 unusual ordering */
+  rb_define_const(mXMLEncoding, "UCS_2", INT2NUM(XML_CHAR_ENCODING_UCS2)); /* UCS-2 */
+  rb_define_const(mXMLEncoding, "ISO_8859_1", INT2NUM(XML_CHAR_ENCODING_8859_1)); /* ISO-8859-1 ISO Latin 1 */
+  rb_define_const(mXMLEncoding, "ISO_8859_2", INT2NUM(XML_CHAR_ENCODING_8859_2)); /* ISO-8859-2 ISO Latin 2 */
+  rb_define_const(mXMLEncoding, "ISO_8859_3", INT2NUM(XML_CHAR_ENCODING_8859_3)); /* ISO-8859-3 */
+  rb_define_const(mXMLEncoding, "ISO_8859_4", INT2NUM(XML_CHAR_ENCODING_8859_4)); /* ISO-8859-4 */
+  rb_define_const(mXMLEncoding, "ISO_8859_5", INT2NUM(XML_CHAR_ENCODING_8859_5)); /* ISO-8859-5 */
+  rb_define_const(mXMLEncoding, "ISO_8859_6", INT2NUM(XML_CHAR_ENCODING_8859_6)); /* ISO-8859-6 */
+  rb_define_const(mXMLEncoding, "ISO_8859_7", INT2NUM(XML_CHAR_ENCODING_8859_7)); /* ISO-8859-7 */
+  rb_define_const(mXMLEncoding, "ISO_8859_8", INT2NUM(XML_CHAR_ENCODING_8859_8)); /* ISO-8859-8 */
+  rb_define_const(mXMLEncoding, "ISO_8859_9", INT2NUM(XML_CHAR_ENCODING_8859_9)); /* ISO-8859-9 */
+  rb_define_const(mXMLEncoding, "ISO_2022_JP", INT2NUM(XML_CHAR_ENCODING_2022_JP)); /* ISO-2022-JP */
+  rb_define_const(mXMLEncoding, "SHIFT_JIS", INT2NUM(XML_CHAR_ENCODING_SHIFT_JIS)); /* Shift_JIS */
+  rb_define_const(mXMLEncoding, "EUC_JP", INT2NUM(XML_CHAR_ENCODING_EUC_JP)); /* EUC-JP */
+  rb_define_const(mXMLEncoding, "ASCII", INT2NUM(XML_CHAR_ENCODING_ASCII)); /* pure ASCII */
+}

data/ext/libxml/ruby_xml_encoding.h

@@ -0,0 +1,12 @@
+/* $Id: rxml_parser.h 39 2006-02-21 20:40:16Z roscopeco $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RXML_ENCODING__
+#define __RXML_ENCODING__
+
+extern VALUE mXMLEncoding;
+
+void ruby_init_xml_encoding();
+
+#endif

data/ext/libxml/ruby_xml_error.c

@@ -108,10 +108,16 @@ VALUE rxml_error_wrap(xmlErrorPtr xerror)
   rb_iv_set(result, "@int1", INT2NUM(xerror->int1));
   rb_iv_set(result, "@int2", INT2NUM(xerror->int2));
 
-  //rb_define_attr(eXMLError, "ctxt", 1, 0);
   if (xerror->node)
   {
-    VALUE node = rxml_node_wrap(cXMLNode, xerror->node);
+    /* Returning the original node is too dangerous because its 
+       parent document is never returned to Ruby.  So return a 
+       copy of the node, which does not belong to any document,
+       and can free itself when Ruby calls its free method.  Note
+       we just copy the node, and don't bother with the overhead
+       of a recursive query. */
+    xmlNodePtr xNode = xmlCopyNode((const xmlNodePtr)xerror->node, 2);
+    VALUE node = rxml_node_wrap(xNode);
     rb_iv_set(result, "@node", node);
   }
   return result;

data/ext/libxml/ruby_xml_html_parser.c

@@ -1,78 +1,60 @@
-/* $Id: ruby_xml_html_parser.c 665 2008-12-06 07:52:49Z cfis $ */
+/* $Id: ruby_xml_html_parser.c 737 2009-01-23 01:23:08Z walltndr $ */
 
 /* Please see the LICENSE file for copyright and distribution information */
 
 #include "ruby_libxml.h"
 
-VALUE cXMLHTMLParser;
-static ID INPUT_ATTR;
-
-/*
- * Document-class: LibXML::XML::HTMLParser
+/* Document-class: LibXML::XML::HTMLParser
  *
  * The HTML parser implements an HTML 4.0 non-verifying parser with an API
  * compatible with the XML::Parser.  In contrast with the XML::Parser,
  * it can parse "real world" HTML, even if it severely broken from a
- * specification point of view. */
+ * specification point of view.
+ *
+ * The HTML parser creates an in-memory document object
+ * that consist of any number of XML::Node instances.  This is simple
+ * and powerful model, but has the major limitation that the size of
+ * the document that can be processed is limited by the amount of
+ * memory available.
+ *
+ * Using the html parser is simple:
+ *
+ *   parser = XML::HTMLParser.file('my_file')
+ *   doc = parser.parse
+ *
+ * You can also parse documents (see XML::HTMLParser.document), 
+ * strings (see XML::HTMLParser.string) and io objects (see
+ * XML::HTMLParser.io).
+ */
 
-/*
- * call-seq:
+VALUE cXMLHtmlParser;
+static ID CONTEXT_ATTR;
+
+
+/* call-seq:
  *    XML::HTMLParser.initialize -> parser
  *
  * Initializes a new parser instance with no pre-determined source.
  */
-static VALUE rxml_html_parser_initialize(VALUE self)
+static VALUE rxml_html_parser_initialize(int argc, VALUE *argv, VALUE self)
 {
-  VALUE input = rb_class_new_instance(0, NULL, cXMLInput);
-  rb_iv_set(self, "@input", input);
-  return self;
-}
+  VALUE context = Qnil;
 
-static htmlDocPtr rxml_html_parser_read_file(VALUE input)
-{
-  VALUE file = rb_ivar_get(input, FILE_ATTR);
-  VALUE encoding = rb_ivar_get(input, ENCODING_ATTR);
-  VALUE encoding_str = rxml_input_encoding_to_s(cXMLInput, encoding);
-  char *xencoding_str = (encoding_str == Qnil ? NULL : StringValuePtr(
-      encoding_str));
-  int options = 0;
-
-  return htmlReadFile(StringValuePtr(file), xencoding_str, options);
-}
+  rb_scan_args(argc, argv, "01", &context);
 
-static htmlDocPtr rxml_html_parser_read_string(VALUE input)
-{
-  VALUE string = rb_ivar_get(input, STRING_ATTR);
-  VALUE base_url = rb_ivar_get(input, BASE_URL_ATTR);
-  char *xbase_url = (base_url == Qnil ? NULL : StringValuePtr(base_url));
-  VALUE encoding = rb_ivar_get(input, ENCODING_ATTR);
-  VALUE encoding_str = rxml_input_encoding_to_s(cXMLInput, encoding);
-  char *xencoding_str = (encoding_str == Qnil ? NULL : StringValuePtr(
-      encoding_str));
-  int options = 0;
-
-  return htmlReadMemory(StringValuePtr(string), RSTRING_LEN(string),
-                        xbase_url, xencoding_str, options);
-}
+  if (context == Qnil)
+  {
+    rb_warn("Passing no parameters to XML::HTMLParser.new is deprecated.  Pass an instance of XML::Parser::Context instead.");
+    context = rb_class_new_instance(0, NULL, cXMLParserContext);
+  }
 
-static htmlDocPtr rxml_html_parser_read_io(VALUE input)
-{
-  VALUE io = rb_ivar_get(input, IO_ATTR);
-  VALUE base_url = rb_ivar_get(input, BASE_URL_ATTR);
-  char *xbase_url = (base_url == Qnil ? NULL : StringValuePtr(base_url));
-  VALUE encoding = rb_ivar_get(input, ENCODING_ATTR);
-  VALUE encoding_str = rxml_input_encoding_to_s(cXMLInput, encoding);
-  char *xencoding_str = (encoding_str == Qnil ? NULL : StringValuePtr(
-      encoding_str));
-  int options = 0;
-
-  return htmlReadIO((xmlInputReadCallback) rxml_read_callback, NULL,
-      (void *) io, xbase_url, xencoding_str, options);
+  rb_ivar_set(self, CONTEXT_ATTR, context);
+  return self;
 }
 
 /*
  * call-seq:
- *    parser.parse -> document
+ *    parser.parse -> XML::Document
  *
  * Parse the input XML and create an XML::Document with
  * it's content. If an error occurs, XML::Parser::ParseError
@@ -80,22 +62,19 @@ static htmlDocPtr rxml_html_parser_read_io(VALUE input)
  */
 static VALUE rxml_html_parser_parse(VALUE self)
 {
-  VALUE input = rb_ivar_get(self, INPUT_ATTR);
-  htmlDocPtr xdoc;
-
-  if (rb_ivar_get(input, FILE_ATTR) != Qnil)
-    xdoc = rxml_html_parser_read_file(input);
-  else if (rb_ivar_get(input, STRING_ATTR) != Qnil)
-    xdoc = rxml_html_parser_read_string(input);
-  else if (rb_ivar_get(input, IO_ATTR) != Qnil)
-    xdoc = rxml_html_parser_read_io(input);
-  else
-    rb_raise(rb_eArgError, "You must specify a parser data source");
-
-  if (!xdoc)
-    rxml_raise(&xmlLastError);
-
-  return rxml_document_wrap(xdoc);
+  xmlParserCtxtPtr ctxt;
+  VALUE context = rb_ivar_get(self, CONTEXT_ATTR);
+  
+  Data_Get_Struct(context, xmlParserCtxt, ctxt);
+
+  if (htmlParseDocument(ctxt) == -1 && ! ctxt->recovery)
+  {
+    if (ctxt->myDoc)
+      xmlFreeDoc(ctxt->myDoc);
+    rxml_raise(&ctxt->lastError);
+  }
+
+  return rxml_document_wrap(ctxt->myDoc);
 }
 
 // Rdoc needs to know
@@ -106,14 +85,14 @@ mXML = rb_define_module_under(mLibXML, "XML");
 
 void ruby_init_html_parser(void)
 {
-  INPUT_ATTR = rb_intern("@input");
+  CONTEXT_ATTR = rb_intern("@context");
 
-  cXMLHTMLParser = rb_define_class_under(mXML, "HTMLParser", rb_cObject);
+  cXMLHtmlParser = rb_define_class_under(mXML, "HTMLParser", rb_cObject);
 
   /* Atributes */
-  rb_define_attr(cXMLHTMLParser, "input", 1, 0);
+  rb_define_attr(cXMLHtmlParser, "input", 1, 0);
 
   /* Instance methods */
-  rb_define_method(cXMLHTMLParser, "initialize", rxml_html_parser_initialize, 0);
-  rb_define_method(cXMLHTMLParser, "parse", rxml_html_parser_parse, 0);
+  rb_define_method(cXMLHtmlParser, "initialize", rxml_html_parser_initialize, -1);
+  rb_define_method(cXMLHtmlParser, "parse", rxml_html_parser_parse, 0);
 }

data/ext/libxml/ruby_xml_html_parser.h

@@ -1,12 +1,11 @@
-/* $Id: ruby_xml_html_parser.h 666 2008-12-07 00:16:50Z cfis $ */
+/* $Id: ruby_xml_html_parser.h 711 2009-01-20 07:17:15Z cfis $ */
 
 /* Please see the LICENSE file for copyright and distribution information */
 
 #ifndef __RXML_HTML_PARSER__
 #define __RXML_HTML_PARSER__
 
-extern int rxml_html_parser_count;
-extern VALUE cXMLHTMLParser;
+extern VALUE cXMLHtmlParser;
 
 void ruby_init_html_parser(void);
 

data/ext/libxml/ruby_xml_html_parser_context.c

@@ -0,0 +1,145 @@
+/* $Id: ruby_xml_parser_context.c 710 2009-01-20 05:30:51Z cfis $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#include "ruby_libxml.h"
+#include "ruby_xml_html_parser_context.h"
+
+/*
+ * Document-class: LibXML::XML::HTMLParser::Context
+ *
+ * The XML::HTMLParser::Context class provides in-depth control over how
+ * a document is parsed.
+ */
+
+VALUE cXMLHtmlParserContext;
+
+static void rxml_html_parser_context_free(xmlParserCtxtPtr ctxt)
+{
+  xmlFreeParserCtxt(ctxt);
+}
+
+static VALUE rxml_html_parser_context_wrap(xmlParserCtxtPtr ctxt)
+{
+  return Data_Wrap_Struct(cXMLHtmlParserContext, NULL, rxml_html_parser_context_free, ctxt);
+}
+
+/* call-seq:
+ *    XML::HTMLParser::Context.file(file) -> XML::HTMLParser::Context
+ *
+ * Creates a new parser context based on the specified file or uri.
+ *
+ * Parameters:
+ *
+ *  file - A filename or uri.
+*/
+static VALUE rxml_html_parser_context_file(VALUE klass, VALUE file)
+{
+  xmlParserCtxtPtr ctxt = htmlCreateFileParserCtxt(StringValuePtr(file), NULL);
+  return rxml_html_parser_context_wrap(ctxt);
+}
+
+/* call-seq:
+ *    XML::HTMLParser::Context.io(io) -> XML::HTMLParser::Context
+ *
+ * Creates a new parser context based on the specified io object.
+ *
+ * Parameters:
+ *
+ *  io - A ruby IO object.
+*/
+static VALUE rxml_html_parser_context_io(VALUE klass, VALUE io)
+{
+  htmlParserCtxtPtr ctxt;
+  xmlParserInputBufferPtr input;
+  xmlParserInputPtr stream;
+
+  input = xmlParserInputBufferCreateIO((xmlInputReadCallback) rxml_read_callback, NULL,
+                                     (void*)io, XML_CHAR_ENCODING_NONE);
+
+  ctxt = htmlNewParserCtxt();
+  if (!ctxt)
+  {
+    xmlFreeParserInputBuffer(input);
+    rxml_raise(&xmlLastError);
+  }
+
+  stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
+
+  if (!stream)
+  {
+    xmlFreeParserInputBuffer(input);
+    xmlFreeParserCtxt(ctxt);
+    rxml_raise(&xmlLastError);
+  }
+  inputPush(ctxt, stream);
+
+  return rxml_html_parser_context_wrap(ctxt);
+}
+
+/* call-seq:
+ *    XML::HTMLParser::Context.string(string) -> XML::HTMLParser::Context
+ *
+ * Creates a new parser context based on the specified string.
+ *
+ * Parameters:
+ *
+ *  string - A string that contains the data to parse.
+*/
+static VALUE rxml_html_parser_context_string(VALUE klass, VALUE string)
+{
+  xmlParserCtxtPtr ctxt;
+  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),
+                                   RSTRING_LEN(string));
+  if (!ctxt)
+    rxml_raise(&xmlLastError);
+
+  htmlDefaultSAXHandlerInit();
+  if (ctxt->sax != NULL)
+    memcpy(ctxt->sax, &htmlDefaultSAXHandler, sizeof(xmlSAXHandlerV1));
+  
+  return rxml_html_parser_context_wrap(ctxt);
+}
+
+/*
+ * call-seq:
+ *    context.options = XML::Parser::Options::NOENT |
+                        XML::Parser::Options::NOCDATA
+ *
+ * Provides control over the execution of a parser.  Valid values 
+ * are the constants defined on XML::Parser::Options.  Multiple
+ * options can be combined by using Bitwise OR (|).
+ */
+static VALUE rxml_html_parser_context_options_set(VALUE self, VALUE options)
+{
+  int result;
+  xmlParserCtxtPtr ctxt;
+  Check_Type(options, T_FIXNUM);
+
+  Data_Get_Struct(self, xmlParserCtxt, ctxt);
+  result = htmlCtxtUseOptions(ctxt, NUM2INT(options));
+
+  return self;
+}
+
+// Rdoc needs to know 
+#ifdef RDOC_NEVER_DEFINED
+  mLibXML = rb_define_module("LibXML");
+  mXML = rb_define_module_under(mLibXML, "XML");
+  cXMLHtmlParser = rb_define_class_under(mXML, "HTMLParser", rb_cObject);
+#endif
+
+void ruby_init_html_parser_context(void)
+{
+  cXMLHtmlParserContext = rb_define_class_under(cXMLHtmlParser, "Context", cXMLParserContext);
+
+  rb_define_singleton_method(cXMLHtmlParserContext, "file", rxml_html_parser_context_file, 1);
+  rb_define_singleton_method(cXMLHtmlParserContext, "io", rxml_html_parser_context_io, 1);
+  rb_define_singleton_method(cXMLHtmlParserContext, "string", rxml_html_parser_context_string, 1);
+  rb_define_method(cXMLHtmlParserContext, "options=", rxml_html_parser_context_options_set, 1);
+}