libxml-ruby 0.6.0-x86-mswin32-60

data/ext/libxml/ruby_xml_xpath_object.h

@@ -0,0 +1,28 @@
+/* $Id $ */
+
+#ifndef __RUBY_XML_XPATH_OBJECT__
+#define __RUBY_XML_XPATH_OBJECT__
+
+extern VALUE cXMLXPathObject;
+
+typedef struct ruby_xml_xpath_object_s {
+  xmlXPathObjectPtr xpop;
+} ruby_xml_xpath_object;
+
+VALUE ruby_xml_xpath_object_wrap(xmlXPathObjectPtr xpop);
+VALUE ruby_xml_xpath_object_to_a(VALUE self);
+VALUE ruby_xml_xpath_object_first(VALUE self);
+VALUE ruby_xml_xpath_object_set(VALUE self);
+VALUE ruby_xml_xpath_object_empty_q(VALUE self);
+VALUE ruby_xml_xpath_object_each(VALUE self);
+VALUE ruby_xml_xpath_object_first(VALUE self);
+VALUE ruby_xml_xpath_object_length(VALUE self);
+VALUE ruby_xml_xpath_object_set_type(VALUE self);
+VALUE ruby_xml_xpath_object_string(VALUE self);
+
+void ruby_xml_xpath_object_mark(xmlXPathObjectPtr xpop);
+void ruby_xml_xpath_object_free(xmlXPathObjectPtr xpop);
+
+void ruby_init_xml_xpath_object(void);
+
+#endif

data/ext/libxml/ruby_xml_xpointer.c

@@ -0,0 +1,100 @@
+/* $Id: ruby_xml_xpointer.c 300 2008-07-01 19:14:15Z cfis $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#include "ruby_libxml.h"
+#include "ruby_xml_xpointer.h"
+
+VALUE cXMLXPointer;
+VALUE eXMLXPointerInvalidExpression;
+
+VALUE
+ruby_xml_xpointer_point(VALUE class, VALUE rnode, VALUE xptr_str) {
+#ifdef LIBXML_XPTR_ENABLED
+  ruby_xml_node *node;
+  xmlXPathContextPtr ctxt;
+  VALUE rxptr_xpth_ctxt, rxxp;
+  xmlXPathObjectPtr xpath;
+
+  Check_Type(xptr_str, T_STRING);
+  if (rb_obj_is_kind_of(rnode, cXMLNode) == Qfalse)
+    rb_raise(rb_eTypeError, "require an XML::Node object");
+
+  Data_Get_Struct(rnode, ruby_xml_node, node);
+
+  rxptr_xpth_ctxt =
+    ruby_xml_xpath_context_wrap(ctxt=xmlXPtrNewContext(node->node->doc, node->node, NULL));
+
+  if (NIL_P(rxptr_xpth_ctxt))
+    return(Qnil);
+
+  xpath = xmlXPtrEval((xmlChar*)StringValuePtr(xptr_str), ctxt);
+  if (xpath == NULL)
+    rb_raise(eXMLXPointerInvalidExpression, "invalid xpointer expression");
+
+  rxxp = ruby_xml_xpath_object_wrap(xpath);
+  return(rxxp);
+#else
+  rb_warn("libxml was compiled without XPointer support");
+  return(Qfalse);
+#endif
+}
+
+
+VALUE
+ruby_xml_xpointer_point2(VALUE node, VALUE xptr_str) {
+  return(ruby_xml_xpointer_point(cXMLXPointer, node, xptr_str));
+}
+
+
+/*
+ * call-seq:
+ *    XML::XPointer.range(start_node, end_node) => xpath
+ * 
+ * Create an xpath representing the range between the supplied
+ * start and end node.
+ */
+VALUE
+ruby_xml_xpointer_range(VALUE class, VALUE rstart, VALUE rend) {
+#ifdef LIBXML_XPTR_ENABLED
+  ruby_xml_node *start, *end;
+  VALUE rxxp;
+  xmlXPathObjectPtr xpath;
+
+  if (rb_obj_is_kind_of(rstart, cXMLNode) == Qfalse)
+    rb_raise(rb_eTypeError, "require an XML::Node object as a starting point");
+  if (rb_obj_is_kind_of(rend, cXMLNode) == Qfalse)
+    rb_raise(rb_eTypeError, "require an XML::Node object as an ending point");
+
+  Data_Get_Struct(rstart, ruby_xml_node, start);
+  if (start->node == NULL)
+    return(Qnil);
+
+  Data_Get_Struct(rend, ruby_xml_node, end);
+  if (end->node == NULL)
+    return(Qnil);
+
+  xpath = xmlXPtrNewRangeNodes(start->node, end->node);
+  if (xpath == NULL)
+    rb_fatal("You shouldn't be able to have this happen");
+
+  rxxp = ruby_xml_xpath_object_wrap(xpath);
+  return(rxxp);
+#else
+  rb_warn("libxml was compiled without XPointer support");
+  return(Qfalse);
+#endif
+}
+
+// Rdoc needs to know 
+#ifdef RDOC_NEVER_DEFINED
+  mXML = rb_define_module("XML");
+#endif
+
+void
+ruby_init_xml_xpointer(void) {
+  cXMLXPointer = rb_define_class_under(mXML, "XPointer", rb_cObject);
+  eXMLXPointerInvalidExpression = rb_define_class_under(cXMLXPointer, "InvalidExpression", eXMLError);
+
+  rb_define_singleton_method(cXMLXPointer, "range", ruby_xml_xpointer_range, 2);
+}

data/ext/libxml/ruby_xml_xpointer.h

@@ -0,0 +1,27 @@
+/* $Id: ruby_xml_xpointer.h 39 2006-02-21 20:40:16Z roscopeco $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RUBY_XML_XPOINTER__
+#define __RUBY_XML_XPOINTER__
+
+extern VALUE cXMLXPointer;
+extern VALUE eXMLXPointerInvalidExpression;
+
+typedef struct ruby_xml_xpointer {
+  VALUE xd;
+  VALUE ctxt;
+  /*
+   * This needs to go into a xpointer data struct:
+   *
+   * xmlLocationSetPtr xptr;
+   *
+   * I also need an xpointer data struct type.
+  */
+} ruby_xml_xpointer;
+
+VALUE ruby_xml_xpointer_point(VALUE class, VALUE node, VALUE xptr_string);
+VALUE ruby_xml_xpointer_point2(VALUE node, VALUE xptr_string);
+void ruby_init_xml_xpointer(void);
+
+#endif

data/ext/libxml/ruby_xml_xpointer_context.c

@@ -0,0 +1,21 @@
+/* $Id: ruby_xml_xpointer_context.c 300 2008-07-01 19:14:15Z cfis $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#include "ruby_libxml.h"
+#include "ruby_xml_xpointer_context.h"
+
+VALUE cXMLXPointerContext;
+VALUE eXMLXPointerContextInvalidPath;
+
+// Rdoc needs to know 
+#ifdef RDOC_NEVER_DEFINED
+  mXML = rb_define_module("XML");
+  cXMLXPointer = rb_define_class_under(mXML, "XPointer", rb_cObject);
+#endif
+
+void
+ruby_init_xml_xpointer_context(void) {
+  cXMLXPointerContext = rb_define_class_under(cXMLXPointer, "Context", cXMLXPathContext);
+  eXMLXPointerContextInvalidPath = rb_define_class_under(cXMLXPointerContext, "InvalidPath", eXMLError);
+}

data/ext/libxml/ruby_xml_xpointer_context.h

@@ -0,0 +1,18 @@
+/* $Id: ruby_xml_xpointer_context.h 39 2006-02-21 20:40:16Z roscopeco $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RUBY_XML_XPOINTER_CONTEXT__
+#define __RUBY_XML_XPOINTER_CONTEXT__
+
+extern VALUE cXMLXPointerContext;
+extern VALUE eXMLXPointerContextInvalidPath;
+
+typedef struct ruby_xml_xpointer_context {
+  VALUE xd;
+  xmlXPathContextPtr ctxt;
+} ruby_xml_xpointer_context;
+
+void ruby_init_xml_xpointer_context(void);
+
+#endif

data/ext/libxml/sax_parser_callbacks.inc

@@ -0,0 +1,213 @@
+/* $Id: sax_parser_callbacks.inc 120 2006-11-26 12:57:56Z roscopeco $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+/*
+ * SAX CALLBACK HANDLERS
+ */ 
+static void internal_subset_func(ruby_xml_sax_parser *cbp, 
+       const char *name,
+       const char *extid,
+       const char *sysid) {
+  VALUE handler = cbp->callbackHandler;
+  
+  if (handler && handler != Qnil) {
+    rb_funcall(handler, cbidOnInternalSubset, 3, rb_str_new2(name),
+        rb_str_new2(extid), rb_str_new2(sysid));
+  }    
+}
+
+static void is_standalone_func(ruby_xml_sax_parser *cbp) {
+  VALUE handler = cbp->callbackHandler;
+  
+  if (handler && handler != Qnil) {
+    rb_funcall(handler,cbidOnIsStandalone,0);
+  }    
+}
+
+static void has_internal_subset_func(ruby_xml_sax_parser *cbp) {
+  VALUE handler = cbp->callbackHandler;
+  
+  if (handler && handler != Qnil) {
+    rb_funcall(handler,cbidOnHasInternalSubset,0);
+  }    
+}
+
+static void has_external_subset_func(ruby_xml_sax_parser *cbp) {
+  VALUE handler = cbp->callbackHandler;
+  
+  if (handler && handler != Qnil) {
+    rb_funcall(handler,cbidOnHasExternalSubset,0);
+  }    
+}
+
+static void start_document_func(ruby_xml_sax_parser *cbp) {
+  VALUE handler = cbp->callbackHandler;
+  
+  if (handler && handler != Qnil) {
+    rb_funcall(handler,cbidOnStartDocument,0);
+  }    
+}
+
+static void end_document_func(ruby_xml_sax_parser *cbp) {
+  VALUE handler = cbp->callbackHandler;
+  
+  if (handler && handler != Qnil) {
+    rb_funcall(handler,cbidOnEndDocument,0);
+  }    
+}
+
+static void start_element_func(ruby_xml_sax_parser *cbp, 
+       const char *name, const char **attrs) {  
+  VALUE handler = cbp->callbackHandler;
+  VALUE ahsh = rb_hash_new();
+  const char *attr, *value;
+  
+  if (attrs) {
+    while ((attr = *(attrs++))) {
+      value = *(attrs++);            
+      rb_hash_aset(ahsh, rb_str_new2(attr), rb_str_new2(value));
+    }
+  }    
+  
+  if (handler && handler != Qnil) {
+    rb_funcall(handler,cbidOnStartElement,2,rb_str_new2(name),ahsh);
+  }    
+}        
+
+static void end_element_func(ruby_xml_sax_parser *cbp, 
+       const char *name) {
+  VALUE handler = cbp->callbackHandler;
+  
+  if (handler && handler != Qnil) {
+    rb_funcall(handler,cbidOnEndElement,1,rb_str_new2(name));
+  }    
+}
+
+static void reference_func(ruby_xml_sax_parser *cbp, 
+       const char *name) {
+  VALUE handler = cbp->callbackHandler;
+  
+  if (handler && handler != Qnil) {
+    rb_funcall(handler,cbidOnReference,1,rb_str_new2(name));
+  }    
+}
+
+static void characters_func(ruby_xml_sax_parser *cbp, 
+       const char *chars, int len) {
+  VALUE handler = cbp->callbackHandler;
+  
+  if (handler && handler != Qnil) {
+    rb_funcall(handler,cbidOnCharacters,1,rb_str_new(chars, len));
+  }    
+}
+
+static void processing_instruction_func(ruby_xml_sax_parser *cbp, 
+       const char *target, const char *data) {
+  VALUE handler = cbp->callbackHandler;
+  
+  if (handler && handler != Qnil) {
+    rb_funcall(handler, cbidOnProcessingInstruction, 2,
+        rb_str_new2(target),rb_str_new2(data));
+  }    
+}
+
+static void comment_func(ruby_xml_sax_parser *cbp, 
+       const char *msg) {
+  VALUE handler = cbp->callbackHandler;
+  
+  if (handler && handler != Qnil) {
+    rb_funcall(handler,cbidOnComment,1,rb_str_new2(msg));
+  }    
+}
+
+#define FORMAT_AND_CALL(callsym) \
+  do { \
+    va_list args; \
+    char buf[1024]; \
+    va_start(args, msg); \
+    vsnprintf(buf, sizeof buf, msg, args); \
+    rb_funcall(handler,callsym,1,rb_str_new2(buf)); \
+    va_end(args); \
+  } \
+  while (0)
+  
+// TODO these next three should actually be formatting messages.
+static void warning_func(ruby_xml_sax_parser *cbp, 
+       const char *msg, ...) {
+  VALUE handler = cbp->callbackHandler;
+  
+  if (handler && handler != Qnil) {
+    FORMAT_AND_CALL(cbidOnXmlParserWarning);
+  }    
+}
+
+static void error_func(ruby_xml_sax_parser *cbp, 
+       const char *msg, ...) {
+  VALUE handler = cbp->callbackHandler;
+  
+  if (handler && handler != Qnil) {
+    FORMAT_AND_CALL(cbidOnXmlParserError);
+  }    
+}
+
+static void fatal_error_func(ruby_xml_sax_parser *cbp, 
+       const char *msg, ...) {
+  VALUE handler = cbp->callbackHandler;
+  
+  if (handler && handler != Qnil) {
+    FORMAT_AND_CALL(cbidOnXmlParserFatalError);
+  }    
+}
+
+static void cdata_block_func(ruby_xml_sax_parser *cbp, 
+       const char *value, int len) {
+  VALUE handler = cbp->callbackHandler;
+  
+  if (handler && handler != Qnil) {
+    rb_funcall(handler,cbidOnCdataBlock,1,rb_str_new(value, len));
+  }    
+}
+
+static void external_subset_func(ruby_xml_sax_parser *cbp, 
+       const char *name,
+       const char *extid,
+       const char *sysid) {
+  VALUE handler = cbp->callbackHandler;
+  
+  if (handler && handler != Qnil) {
+    rb_funcall(handler, cbidOnExternalSubset, 3, rb_str_new2(name),
+        rb_str_new2(extid), rb_str_new2(sysid));
+  }    
+}
+
+static xmlSAXHandler rubySAXHandlerStruct = {
+  (internalSubsetSAXFunc)internal_subset_func,
+  (isStandaloneSAXFunc)is_standalone_func,
+  (hasInternalSubsetSAXFunc)has_internal_subset_func,
+  (hasExternalSubsetSAXFunc)has_external_subset_func,
+  0, /* resolveEntity */
+  0, /* getEntity */
+  0, /* entityDecl */
+  0, /* notationDecl */
+  0, /* attributeDecl */
+  0, /* elementDecl */
+  0, /* unparsedEntityDecl */
+  0, /* setDocumentLocator */
+  (startDocumentSAXFunc)start_document_func, 
+  (endDocumentSAXFunc)end_document_func, 
+  (startElementSAXFunc)start_element_func, 
+  (endElementSAXFunc)end_element_func, 
+  (referenceSAXFunc)reference_func,
+  (charactersSAXFunc)characters_func,
+  0, /* ignorableWhitespace */
+  (processingInstructionSAXFunc)processing_instruction_func,
+  (commentSAXFunc)comment_func,
+  (warningSAXFunc)warning_func,
+  (errorSAXFunc)error_func,
+  (fatalErrorSAXFunc)fatal_error_func,
+  0, /* xmlGetParameterEntity */
+  (cdataBlockSAXFunc)cdata_block_func,
+  (externalSubsetSAXFunc)external_subset_func,
+  1
+};

data/ext/libxml/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  "0.6.0"
+#define RUBY_LIBXML_VERNUM   0
+#define RUBY_LIBXML_VER_MAJ   0
+#define RUBY_LIBXML_VER_MIN   6
+#define RUBY_LIBXML_VER_MIC   0
+#define RUBY_LIBXML_VER_PATCH 0

data/lib/libxml.rb

@@ -0,0 +1,125 @@
+# $Id: libxml.rb 291 2008-07-01 08:04:25Z cfis $ 
+# Please see the LICENSE file for copyright and distribution information 
+
+require 'libxml_ruby.so'
+
+module XML::XMLParserOptions
+  XML_PARSE_RECOVER = 1 # recover on errors
+  XML_PARSE_NOENT = 2 # substitute entities
+  XML_PARSE_DTDLOAD = 4 # load the external subset
+  XML_PARSE_DTDATTR = 8 # default DTD attributes
+  XML_PARSE_DTDVALID = 16 # validate with the DTD
+  XML_PARSE_NOERROR = 32 # suppress error reports
+  XML_PARSE_NOWARNING = 64 # suppress warning reports
+  XML_PARSE_PEDANTIC = 128 # pedantic error reporting
+  XML_PARSE_NOBLANKS = 256 # remove blank nodes
+  XML_PARSE_SAX1 = 512 # use the SAX1 interface internally
+  XML_PARSE_XINCLUDE = 1024 # Implement XInclude substitition
+  XML_PARSE_NONET = 2048 # Forbid network access
+  XML_PARSE_NODICT = 4096 # Do not reuse the context dictionnary
+  XML_PARSE_NSCLEAN = 8192 # remove redundant namespaces declarations
+  XML_PARSE_NOCDATA = 16384 # merge CDATA as text nodes
+  XML_PARSE_NOXINCNODE = 32768 # do not generate XINCLUDE START/END nodes
+  XML_PARSE_COMPACT = 65536 # compact small text nodes; no modification of the tree allowed afterwards (will possibly crash if you try to modify the tree)
+end
+
+class XML::Document
+  include Enumerable
+
+  # maybe, maybe not...
+  def each(&blk)
+    find('//*').each(&blk)
+  end
+end
+
+class XML::Node::Set 
+  include Enumerable 
+
+  # inefficient, but maybe can find a way to cache the
+  # ary and dump on change?
+  def [](i, count = nil) 
+    if count
+      to_a[i,count]
+    else
+      to_a[i]
+    end
+  end
+
+  def to_s #:nodoc:
+    to_a.to_s
+  end
+end
+
+module XML::SiblingEnum
+  private 
+  
+  # Iterates nodes and attributes
+  def siblings(node, &blk)
+    if n = node
+      loop do
+        blk.call(n)
+        break unless n = n.next
+      end
+    end 
+  end
+end
+
+class XML::Node
+  include XML::SiblingEnum
+  include Enumerable
+  include Comparable
+  
+  # maybe these don't belong on all nodes...
+  def each_child(&blk)
+    siblings(child, &blk)   
+  end
+
+  def each_attr(&blk)
+    siblings(properties, &blk)
+  end
+
+  # all siblings INCLUDING self
+  def each_sibling(&blk)
+    siblings(self, &blk)
+  end
+  
+  # I guess this is what you'd expect?
+  alias :each :each_child
+
+  def to_a
+    inject([]) { |ary,n| ary << n }
+  end
+  
+  def <=>(other)
+    to_s <=> other.to_s
+  end  
+
+  def clone
+    copy(false)
+  end
+end
+
+class XML::Attr 
+  include XML::SiblingEnum
+  include Enumerable
+
+  def each_sibling(&blk)
+    siblings(self,&blk)
+  end
+  
+  alias :each_attr :each_sibling
+  alias :each :each_sibling
+  
+  def to_h
+    inject({}) do |h,a| h[a.name] = a.value; h end
+  end
+
+  def to_a
+    inject([]) do |ary,a| ary << [a.name, a.value] end
+  end
+  
+  def to_s
+    "#{name} = #{value}"
+  end
+end
+