coupa-libxml-ruby 1.1.4

data/ext/libxml/ruby_xml_sax2_handler.h

@@ -0,0 +1,12 @@
+/* $Id: ruby_xml_sax_parser.h 666 2008-12-07 00:16:50Z cfis $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RXML_SAX2_HANDLER__
+#define __RXML_SAX2_HANDLER__
+
+extern xmlSAXHandler rxml_sax_handler;
+
+void rxml_init_sax2_handler(void);
+
+#endif

data/ext/libxml/ruby_xml_sax_parser.c

@@ -0,0 +1,137 @@
+/* $Id: ruby_xml_sax_parser.c 758 2009-01-25 20:36:03Z cfis $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#include "ruby_libxml.h"
+#include "ruby_xml_sax_parser.h"
+
+/*
+ * Document-class: LibXML::XML::SaxParser
+ *
+ * XML::SaxParser provides a callback based API for parsing documents,
+ * in contrast to XML::Parser's tree based API and XML::Reader's stream
+ * based API.
+ *
+ * The XML::SaxParser API is fairly complex, not well standardized,
+ * and does not directly support validation making entity, namespace and
+ * base processing relatively hard.
+ *
+ * To use the XML::SaxParser, register a callback class via the
+ * XML::SaxParser#callbacks=.  It is easiest to include the
+ * XML::SaxParser::Callbacks module in your class and override
+ * the methods as needed.
+ *
+ * Basic example:
+ *
+ *   class MyCallbacks
+ *     include XML::SaxParser::Callbacks
+ *     def on_start_element(element, attributes)
+ *       puts #Element started: #{element}"
+ *     end
+ *   end
+ *
+ *   parser = XML::SaxParser.string(my_string)
+ *   parser.callbacks = MyCallbacks.new
+ *   parser.parse
+ *
+ * You can also parse strings (see XML::SaxParser.string) and
+ * io objects (see XML::SaxParser.io).
+ */
+
+VALUE cXMLSaxParser;
+static ID CALLBACKS_ATTR;
+static ID CONTEXT_ATTR;
+
+
+/* ======  Parser  =========== */
+
+/*static int rxml_sax_parser_parse_io(VALUE self, VALUE input)
+{
+  VALUE handler = rb_ivar_get(self, CALLBACKS_ATTR);
+  VALUE io = rb_ivar_get(input, IO_ATTR);
+  VALUE encoding = rb_ivar_get(input, ENCODING_ATTR);
+  xmlCharEncoding xmlEncoding = NUM2INT(encoding);
+  xmlParserCtxtPtr ctxt =
+      xmlCreateIOParserCtxt((xmlSAXHandlerPtr) &rxml_sax_handler,
+          (void *) handler, (xmlInputReadCallback) rxml_read_callback, NULL,
+          (void *) io, xmlEncoding);
+  return xmlParseDocument(ctxt);
+}*/
+
+
+/*
+ * call-seq:
+ *    parser.initialize(context) -> XML::Parser
+ *
+ * Creates a new XML::Parser from the specified 
+ * XML::Parser::Context.
+ */
+static VALUE rxml_sax_parser_initialize(int argc, VALUE *argv, VALUE self)
+{
+  VALUE context = Qnil;
+
+  rb_scan_args(argc, argv, "01", &context);
+
+  if (context == Qnil)
+  {
+    rb_warn("Passing no parameters to XML::SaxParser.new is deprecated.  Pass an instance of XML::Parser::Context instead.");
+    context = rb_class_new_instance(0, NULL, cXMLParserContext);
+  }
+
+  rb_ivar_set(self, CONTEXT_ATTR, context);
+  return self;
+}
+
+/*
+ * call-seq:
+ *    parser.parse -> (true|false)
+ *
+ * Parse the input XML, generating callbacks to the object
+ * registered via the +callbacks+ attributesibute.
+ */
+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)&rxml_sax_handler;
+    
+  status = xmlParseDocument(ctxt);
+
+  /* IMPORTANT - null the handle to our sax handler
+     so libxml doesn't try to free it.*/
+  ctxt->sax = NULL;
+  
+  /* Now check the parsing result*/
+  if (status == -1 || !ctxt->wellFormed)
+  {
+    if (ctxt->myDoc)
+      xmlFreeDoc(ctxt->myDoc);
+
+    rxml_raise(&ctxt->lastError);
+  }
+  return Qtrue;
+}
+
+void rxml_init_sax_parser(void)
+{
+  /* SaxParser */
+  cXMLSaxParser = rb_define_class_under(mXML, "SaxParser", rb_cObject);
+
+  /* Atributes */
+  CALLBACKS_ATTR = rb_intern("@callbacks");
+  CONTEXT_ATTR = rb_intern("@context");
+  rb_define_attr(cXMLSaxParser, "callbacks", 1, 1);
+
+  /* Instance Methods */
+  rb_define_method(cXMLSaxParser, "initialize", rxml_sax_parser_initialize, -1);
+  rb_define_method(cXMLSaxParser, "parse", rxml_sax_parser_parse, 0);
+}

data/ext/libxml/ruby_xml_sax_parser.h

@@ -0,0 +1,12 @@
+/* $Id: ruby_xml_sax_parser.h 758 2009-01-25 20:36:03Z cfis $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RXML_SAX_PARSER__
+#define __RXML_SAX_PARSER__
+
+extern VALUE cXMLSaxParser;
+
+void rxml_init_sax_parser(void);
+
+#endif

data/ext/libxml/ruby_xml_schema.c

@@ -0,0 +1,159 @@
+#include "ruby_libxml.h"
+#include "ruby_xml_schema.h"
+
+/*
+ * Document-class: LibXML::XML::Schema
+ *
+ * The XML::Schema class is used to prepare XML Schemas for validation of xml
+ * documents.
+ *
+ * Schemas can be created from XML documents, strings or URIs using the
+ * corresponding methods (new for URIs).
+ *
+ * Once a schema is prepared, an XML document can be validated by the
+ * XML::Document#validate_schema method providing the XML::Schema object
+ * as parameter. The method return true if the document validates, false
+ * otherwise.
+ *
+ * Basic usage:
+ *
+ *  # parse schema as xml document
+ *  schema_document = XML::Document.file('schema.rng')
+ *
+ *  # prepare schema for validation
+ *  schema = XML::Schema.document(schema_document)
+ *
+ *  # parse xml document to be validated
+ *  instance = XML::Document.file('instance.xml')
+ *
+ *  # validate
+ *  instance.validate_schema(schema)
+ */
+
+VALUE cXMLSchema;
+
+static void rxml_schema_free(xmlSchemaPtr xschema)
+{
+  xmlSchemaFree(xschema);
+}
+
+/*
+ * call-seq:
+ *    XML::Schema.initialize(schema_uri) -> schema
+ *
+ * Create a new schema from the specified URI.
+ */
+static VALUE rxml_schema_init_from_uri(VALUE class, VALUE uri)
+{
+  xmlSchemaParserCtxtPtr xparser;
+  xmlSchemaPtr xschema;
+
+  Check_Type(uri, T_STRING);
+
+  xparser = xmlSchemaNewParserCtxt(StringValuePtr(uri));
+  xschema = xmlSchemaParse(xparser);
+  xmlSchemaFreeParserCtxt(xparser);
+
+  return Data_Wrap_Struct(cXMLSchema, NULL, rxml_schema_free, xschema);
+}
+
+/*
+ * call-seq:
+ *    XML::Schema.document(document) -> schema
+ *
+ * Create a new schema from the specified document.
+ */
+static VALUE rxml_schema_init_from_document(VALUE class, VALUE document)
+{
+  xmlDocPtr xdoc;
+  xmlSchemaPtr xschema;
+  xmlSchemaParserCtxtPtr xparser;
+
+  Data_Get_Struct(document, xmlDoc, xdoc);
+
+  xparser = xmlSchemaNewDocParserCtxt(xdoc);
+  xschema = xmlSchemaParse(xparser);
+  xmlSchemaFreeParserCtxt(xparser);
+
+  return Data_Wrap_Struct(cXMLSchema, NULL, rxml_schema_free, xschema);
+}
+
+/*
+ * call-seq:
+ *    XML::Schema.string("schema_data") -> "value"
+ *
+ * Create a new schema using the specified string.
+ */
+static VALUE rxml_schema_init_from_string(VALUE self, VALUE schema_str)
+{
+  xmlSchemaParserCtxtPtr xparser;
+  xmlSchemaPtr xschema;
+
+  Check_Type(schema_str, T_STRING);
+
+  xparser = xmlSchemaNewMemParserCtxt(StringValuePtr(schema_str), strlen(
+      StringValuePtr(schema_str)));
+  xschema = xmlSchemaParse(xparser);
+  xmlSchemaFreeParserCtxt(xparser);
+
+  return Data_Wrap_Struct(cXMLSchema, NULL, rxml_schema_free, xschema);
+}
+
+/* TODO what is this patch doing here?
+
+ xmlSchemaParserCtxtPtr  parser;
+ xmlSchemaPtr            sptr;
+ xmlSchemaValidCtxtPtr   vptr;
+ +	int                     is_invalid;
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &source) == FAILURE) {
+ return;
+ @@ -598,26 +598,24 @@
+ convert_to_string_ex(&source);
+ parser = xmlSchemaNewParserCtxt(Z_STRVAL_P(source));
+ sptr = xmlSchemaParse(parser);
+ break;
+ case SCHEMA_BLOB:
+ convert_to_string_ex(&source);
+ parser = xmlSchemaNewMemParserCtxt(Z_STRVAL_P(source), Z_STRLEN_P(source));
+ sptr = xmlSchemaParse(parser);
+ break;
+ }
+
+ vptr = xmlSchemaNewValidCtxt(sptr);
+ +	is_invalid = xmlSchemaValidateDoc(vptr, (xmlDocPtr) sxe->document->ptr);
+ xmlSchemaFree(sptr);
+ xmlSchemaFreeValidCtxt(vptr);
+ xmlSchemaFreeParserCtxt(parser);
+
+ -	if (is_valid) {
+ -		RETURN_TRUE;
+ -	} else {
+ +	if (is_invalid) {
+ RETURN_FALSE;
+ +	} else {
+ +		RETURN_TRUE;
+ }
+ }
+ }}}
+ @@ -695,7 +693,7 @@
+ {
+ if (!strcmp(method, "xsearch")) {
+ simplexml_ce_xpath_search(INTERNAL_FUNCTION_PARAM_PASSTHRU);
+ -#ifdef xmlSchemaParserCtxtPtr
+ +#ifdef LIBXML_SCHEMAS_ENABLED
+ } else if (!strcmp(method, "validate_schema_file")) {
+ simplexml_ce_schema_validate(INTERNAL_FUNCTION_PARAM_PASSTHRU, SCHEMA_FILE);
+ } else if (!strcmp(method, "validate_schema_buffer")) {
+ */
+
+void rxml_init_schema(void)
+{
+  cXMLSchema = rb_define_class_under(mXML, "Schema", rb_cObject);
+  rb_define_singleton_method(cXMLSchema, "new", rxml_schema_init_from_uri, 1);
+  rb_define_singleton_method(cXMLSchema, "from_string",
+      rxml_schema_init_from_string, 1);
+  rb_define_singleton_method(cXMLSchema, "document",
+      rxml_schema_init_from_document, 1);
+}
+

data/ext/libxml/ruby_xml_schema.h

@@ -0,0 +1,11 @@
+#ifndef __RXML_SCHEMA__
+#define __RXML_SCHEMA__
+
+#include <libxml/schemasInternals.h>
+#include <libxml/xmlschemas.h>
+
+extern VALUE cXMLSchema;
+
+void  rxml_init_schema(void);
+#endif
+

data/ext/libxml/ruby_xml_version.h

@@ -0,0 +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  "1.1.4"
+#define RUBY_LIBXML_VERNUM   114
+#define RUBY_LIBXML_VER_MAJ   1
+#define RUBY_LIBXML_VER_MIN   1
+#define RUBY_LIBXML_VER_MIC   4
+#define RUBY_LIBXML_VER_PATCH 1

data/ext/libxml/ruby_xml_xinclude.c

@@ -0,0 +1,18 @@
+/* $Id: ruby_xml_xinclude.c 758 2009-01-25 20:36:03Z cfis $ */
+
+#include "ruby_libxml.h"
+#include "ruby_xml_xinclude.h"
+
+VALUE cXMLXInclude;
+
+/*
+ * Document-class: LibXML::XML::XInclude
+ *
+ * The ruby bindings do not currently expose libxml's
+ * XInclude fuctionality.
+ */
+
+void rxml_init_xinclude(void)
+{
+  cXMLXInclude = rb_define_class_under(mXML, "XInclude", rb_cObject);
+}

data/ext/libxml/ruby_xml_xinclude.h

@@ -0,0 +1,13 @@
+/* $Id: ruby_xml_xinclude.h 758 2009-01-25 20:36:03Z cfis $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RXML_XINCLUDE__
+#define __RXML_XINCLUDE__
+
+extern VALUE cXMLXInclude;
+extern VALUE eXMLXIncludeError;
+
+void rxml_init_xinclude(void);
+
+#endif

data/ext/libxml/ruby_xml_xpath.c

@@ -0,0 +1,107 @@
+/* $Id: ruby_xml_xpath.c 759 2009-01-26 00:15:49Z cfis $ */
+
+/*
+ * Document-class: LibXML::XML::XPath
+ *
+ * The XML::XPath module is used to query XML documents. It is
+ * usually accessed via the XML::Document#find or
+ * XML::Node#find methods.  For example:
+ *
+ *  document.find('/foo', namespaces) -> XML::XPath::Object
+ *
+ * The optional namespaces parameter can be a string, array or
+ * hash table.
+ *
+ *   document.find('/foo', 'xlink:http://www.w3.org/1999/xlink')
+ *   document.find('/foo', ['xlink:http://www.w3.org/1999/xlink',
+ *                          'xi:http://www.w3.org/2001/XInclude')
+ *   document.find('/foo', 'xlink' => 'http://www.w3.org/1999/xlink',
+ *                             'xi' => 'http://www.w3.org/2001/XInclude')
+ *
+ *
+ * === Working With Default Namespaces
+ *
+ * Finding namespaced elements and attributes can be tricky.
+ * Lets work through an example of a document with a default
+ * namespace:
+ *
+ *  <?xml version="1.0" encoding="utf-8"?>
+ *  <feed xmlns="http://www.w3.org/2005/Atom">
+ *    <title type="text">Phil Bogle's Contacts</title>
+ *  </feed>
+ *
+ * To find nodes you must define the atom namespace for
+ * libxml.  One way to do this is:
+ *
+ *   node = doc.find('atom:title', 'atom:http://www.w3.org/2005/Atom')
+ *
+ * Alternatively, you can register the default namespace like this:
+ *
+ *   doc.root.namespaces.default_prefix = 'atom'
+ *   node = doc.find('atom:title')
+ *
+ * === More Complex Namespace Examples
+ *
+ * Lets work through some more complex examples using the
+ * following xml document:
+ *
+ *  <soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
+ *    <soap:Body>
+ *      <getManufacturerNamesResponse xmlns="http://services.somewhere.com">
+ *        <IDAndNameList xmlns="http://services.somewhere.com">
+ *          <ns1:IdAndName xmlns:ns1="http://domain.somewhere.com"/>
+ *        </IDAndNameList>
+ *      </getManufacturerNamesResponse>
+ *  </soap:Envelope>
+ *
+ *  # Since the soap namespace is defined on the root
+ *  # node we can directly use it.
+ *  doc.find('/soap:Envelope')
+ *
+ *  # Since the ns1 namespace is not defined on the root node
+ *  # we have to first register it with the xpath engine.
+ *  doc.find('//ns1:IdAndName',
+ *           'ns1:http://domain.somewhere.com')
+ *
+ *  # Since the getManufacturerNamesResponse element uses a default
+ *  # namespace we first have to give it a prefix and register
+ *  # it with the xpath engine.
+ *  doc.find('//ns:getManufacturerNamesResponse',
+ *            'ns:http://services.somewhere.com')
+ *
+ *  # Here is an example showing a complex namespace aware
+ *  # xpath expression.
+ *  doc.find('/soap:Envelope/soap:Body/ns0:getManufacturerNamesResponse/ns0:IDAndNameList/ns1:IdAndName',
+ *  ['ns0:http://services.somewhere.com', 'ns1:http://domain.somewhere.com'])
+*/
+
+
+#include "ruby_libxml.h"
+
+VALUE mXPath;
+
+void rxml_init_xpath(void)
+{
+  mXPath = rb_define_module_under(mXML, "XPath");
+
+  /* 0: Undefined value. */
+  rb_define_const(mXPath, "UNDEFINED", INT2NUM(XPATH_UNDEFINED));
+  /* 1: A nodeset, will be wrapped by XPath Object. */
+  rb_define_const(mXPath, "NODESET", INT2NUM(XPATH_NODESET));
+  /* 2: A boolean value. */
+  rb_define_const(mXPath, "BOOLEAN", INT2NUM(XPATH_BOOLEAN));
+  /* 3: A numeric value. */
+  rb_define_const(mXPath, "NUMBER", INT2NUM(XPATH_NUMBER));
+  /* 4: A string value. */
+  rb_define_const(mXPath, "STRING", INT2NUM(XPATH_STRING));
+  /* 5: An xpointer point */
+  rb_define_const(mXPath, "POINT", INT2NUM(XPATH_POINT));
+  /* 6: An xpointer range */
+  rb_define_const(mXPath, "RANGE", INT2NUM(XPATH_RANGE));
+  /* 7: An xpointer location set */
+  rb_define_const(mXPath, "LOCATIONSET", INT2NUM(XPATH_LOCATIONSET));
+  /* 8: XPath user type */
+  rb_define_const(mXPath, "USERS", INT2NUM(XPATH_USERS));
+  /* 9: An XSLT value tree, non modifiable */
+  rb_define_const(mXPath, "XSLT_TREE", INT2NUM(XPATH_XSLT_TREE));
+}