libxml-ruby 3.2.2-x64-mingw-ucrt

data/ext/libxml/ruby_xml_xpath_expression.h

@@ -0,0 +1,10 @@
+/* Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RXML_XPATH_EXPRESSION__
+#define __RXML_XPATH_EXPRESSION__
+
+extern VALUE cXMLXPathExpression;
+
+void rxml_init_xpath_expression(void);
+
+#endif

data/ext/libxml/ruby_xml_xpath_object.c

@@ -0,0 +1,338 @@
+#include "ruby_libxml.h"
+
+/*
+ * Document-class: LibXML::XML::XPath::Object
+ *
+ * A collection of nodes returned from the evaluation of an XML::XPath
+ * or XML::XPointer expression.
+ */
+
+VALUE cXMLXPathObject;
+
+
+/* Memory management of xpath results is tricky.  If a nodeset is
+   returned, it generally consists of pointers to nodes in the 
+   original document.  However, namespace nodes are handled differently - 
+   libxml creates copies of them instead.  Thus, when an xmlXPathObjectPtr
+   is freed, libxml iterates over the results to find the copied namespace 
+   nodes to free them.
+
+   This causes problems for the bindings because the underlying document
+   may be freed before the xmlXPathObjectPtr instance.  This might seem
+   counterintuitive since the xmlXPathObjectPtr marks the document.
+   However, once both objects go out of scope, the order of their 
+   destruction is random.
+
+   To deal with this, the wrapper code searches for the namespace nodes
+   and wraps them in Ruby objects.  When the Ruby objects go out of scope
+   then the namespace nodes are freed. */
+
+static void rxml_xpath_object_free(rxml_xpath_object *rxpop)
+{
+  /* We positively, absolutely cannot let libxml iterate over
+     the nodeTab since if the underlying document has been
+     freed the majority of entries are invalid, resulting in
+     segmentation faults.*/
+  if (rxpop->xpop->nodesetval && rxpop->xpop->nodesetval->nodeTab)
+  {
+    xmlFree(rxpop->xpop->nodesetval->nodeTab);
+    rxpop->xpop->nodesetval->nodeTab = NULL;
+  }
+  xmlXPathFreeObject(rxpop->xpop);
+  xfree(rxpop);
+}
+
+/* Custom free function for copied namespace nodes */
+static void rxml_xpath_namespace_free(xmlNsPtr xns)
+{
+  xmlFreeNs(xns);
+}
+
+static void rxml_xpath_object_mark(rxml_xpath_object *rxpop)
+{
+  VALUE doc = (VALUE)rxpop->xdoc->_private;
+  rb_gc_mark(doc);
+  rb_gc_mark(rxpop->nsnodes);
+}
+
+VALUE rxml_xpath_object_wrap(xmlDocPtr xdoc, xmlXPathObjectPtr xpop)
+{
+  int i;
+  rxml_xpath_object *rxpop = ALLOC(rxml_xpath_object);
+
+  /* Make sure Ruby's GC can find the array in the stack */
+  VALUE nsnodes = rb_ary_new();
+  rxpop->xdoc =xdoc;
+  rxpop->xpop = xpop;
+
+  /* Find all the extra namespace nodes and wrap them. */
+  if (xpop->nodesetval && xpop->nodesetval->nodeNr)
+  {
+    for (i = 0; i < xpop->nodesetval->nodeNr; i++)
+    {
+      xmlNodePtr xnode = xpop->nodesetval->nodeTab[i];
+      if (xnode != NULL && xnode->type == XML_NAMESPACE_DECL)
+      {
+        VALUE ns = Qnil;
+        xmlNsPtr xns = (xmlNsPtr)xnode;
+
+        /* Get rid of libxml's -> next hack.  The issue here is
+           the rxml_namespace code assumes that ns->next refers
+           to another namespace. */
+        xns->next = NULL;
+
+        /* Specify a custom free function here since by default
+           namespace nodes will not be freed */
+        ns = rxml_namespace_wrap((xmlNsPtr)xnode);
+        RDATA(ns)->dfree = (RUBY_DATA_FUNC)rxml_xpath_namespace_free;
+        rb_ary_push(nsnodes, ns);
+      }
+    }
+  }
+
+  rxpop->nsnodes = nsnodes;
+  return Data_Wrap_Struct(cXMLXPathObject, rxml_xpath_object_mark, rxml_xpath_object_free, rxpop);
+}
+
+static VALUE rxml_xpath_object_tabref(xmlXPathObjectPtr xpop, int index)
+{
+  if (index < 0)
+    index = xpop->nodesetval->nodeNr + index;
+
+  if (index < 0 || index + 1 > xpop->nodesetval->nodeNr)
+    return Qnil;
+
+  switch (xpop->nodesetval->nodeTab[index]->type)
+  {
+  case XML_ATTRIBUTE_NODE:
+    return rxml_attr_wrap((xmlAttrPtr) xpop->nodesetval->nodeTab[index]);
+    break;
+  case XML_NAMESPACE_DECL:
+    return rxml_namespace_wrap((xmlNsPtr)xpop->nodesetval->nodeTab[index]);
+    break;
+  default:
+    return rxml_node_wrap(xpop->nodesetval->nodeTab[index]);
+  }
+}
+
+/*
+ * call-seq:
+ *    xpath_object.to_a -> [node, ..., node]
+ *
+ * Obtain an array of the nodes in this set.
+ */
+static VALUE rxml_xpath_object_to_a(VALUE self)
+{
+  VALUE set_ary, nodeobj;
+  rxml_xpath_object *rxpop;
+  xmlXPathObjectPtr xpop;
+  int i;
+
+  Data_Get_Struct(self, rxml_xpath_object, rxpop);
+  xpop = rxpop->xpop;
+
+  set_ary = rb_ary_new();
+
+  if (!((xpop->nodesetval == NULL) || (xpop->nodesetval->nodeNr == 0)))
+  {
+    for (i = 0; i < xpop->nodesetval->nodeNr; i++)
+    {
+      nodeobj = rxml_xpath_object_tabref(xpop, i);
+      rb_ary_push(set_ary, nodeobj);
+    }
+  }
+
+  return (set_ary);
+}
+
+/*
+ * call-seq:
+ *    xpath_object.empty? -> (true|false)
+ *
+ * Determine whether this nodeset is empty (contains no nodes).
+ */
+static VALUE rxml_xpath_object_empty_q(VALUE self)
+{
+  rxml_xpath_object *rxpop;
+  Data_Get_Struct(self, rxml_xpath_object, rxpop);
+
+  if (rxpop->xpop->type != XPATH_NODESET)
+    return Qnil;
+
+  return (rxpop->xpop->nodesetval == NULL || rxpop->xpop->nodesetval->nodeNr <= 0) ? Qtrue
+      : Qfalse;
+}
+
+/*
+ * call-seq:
+ *    xpath_object.each { |node| ... } -> self
+ *
+ * Call the supplied block for each node in this set.
+ */
+static VALUE rxml_xpath_object_each(VALUE self)
+{
+  rxml_xpath_object *rxpop;
+  int i;
+
+  if (rxml_xpath_object_empty_q(self) == Qtrue)
+    return Qnil;
+
+  Data_Get_Struct(self, rxml_xpath_object, rxpop);
+
+  for (i = 0; i < rxpop->xpop->nodesetval->nodeNr; i++)
+  {
+    rb_yield(rxml_xpath_object_tabref(rxpop->xpop, i));
+  }
+  return (self);
+}
+
+/*
+ * call-seq:
+ *    xpath_object.first -> node
+ *
+ * Returns the first node in this node set, or nil if none exist.
+ */
+static VALUE rxml_xpath_object_first(VALUE self)
+{
+  rxml_xpath_object *rxpop;
+
+  if (rxml_xpath_object_empty_q(self) == Qtrue)
+    return Qnil;
+
+  Data_Get_Struct(self, rxml_xpath_object, rxpop);
+  return rxml_xpath_object_tabref(rxpop->xpop, 0);
+}
+
+/*
+ * call-seq:
+ *    xpath_object.last -> node
+ *
+ * Returns the last node in this node set, or nil if none exist.
+ */
+static VALUE rxml_xpath_object_last(VALUE self)
+{
+  rxml_xpath_object *rxpop;
+
+  if (rxml_xpath_object_empty_q(self) == Qtrue)
+    return Qnil;
+
+  Data_Get_Struct(self, rxml_xpath_object, rxpop);
+  return rxml_xpath_object_tabref(rxpop->xpop, -1);
+}
+
+/*
+ * call-seq:
+ * xpath_object[i] -> node
+ *
+ * array index into set of nodes
+ */
+static VALUE rxml_xpath_object_aref(VALUE self, VALUE aref)
+{
+  rxml_xpath_object *rxpop;
+
+  if (rxml_xpath_object_empty_q(self) == Qtrue)
+    return Qnil;
+
+  Data_Get_Struct(self, rxml_xpath_object, rxpop);
+  return rxml_xpath_object_tabref(rxpop->xpop, NUM2INT(aref));
+}
+
+/*
+ * call-seq:
+ *    xpath_object.length -> num
+ *
+ * Obtain the length of the nodesetval node list.
+ */
+static VALUE rxml_xpath_object_length(VALUE self)
+{
+  rxml_xpath_object *rxpop;
+
+  if (rxml_xpath_object_empty_q(self) == Qtrue)
+    return INT2FIX(0);
+
+  Data_Get_Struct(self, rxml_xpath_object, rxpop);
+  return INT2NUM(rxpop->xpop->nodesetval->nodeNr);
+}
+
+/*
+ * call-seq:
+ *    xpath_object.xpath_type -> int
+ *
+ * Returns the XPath type of the result object.
+ * Possible values are defined as constants
+ * on the XML::XPath class and include:
+ *
+ * * XML::XPath::UNDEFINED
+ * * XML::XPath::NODESET
+ * * XML::XPath::BOOLEAN
+ * * XML::XPath::NUMBER
+ * * XML::XPath::STRING
+ * * XML::XPath::POINT
+ * * XML::XPath::RANGE
+ * * XML::XPath::LOCATIONSET
+ * * XML::XPath::USERS
+ * * XML::XPath::XSLT_TREE
+ */
+static VALUE rxml_xpath_object_get_type(VALUE self)
+{
+  rxml_xpath_object *rxpop;
+  Data_Get_Struct(self, rxml_xpath_object, rxpop);
+  return INT2FIX(rxpop->xpop->type);
+}
+
+/*
+ * call-seq:
+ *    xpath_object.string -> String
+ *
+ * Returns the original XPath expression as a string.
+ */
+static VALUE rxml_xpath_object_string(VALUE self)
+{
+  rxml_xpath_object *rxpop;
+
+  Data_Get_Struct(self, rxml_xpath_object, rxpop);
+
+  if (rxpop->xpop->stringval == NULL)
+    return Qnil;
+
+  return rxml_new_cstr( rxpop->xpop->stringval, rxpop->xdoc->encoding);
+}
+
+/*
+ * call-seq:
+ *    nodes.debug -> (true|false)
+ *
+ * Dump libxml debugging information to stdout.
+ * Requires Libxml be compiled with debugging enabled.
+ */
+static VALUE rxml_xpath_object_debug(VALUE self)
+{
+#ifdef LIBXML_DEBUG_ENABLED
+  rxml_xpath_object *rxpop;
+  Data_Get_Struct(self, rxml_xpath_object, rxpop);
+  xmlXPathDebugDumpObject(stdout, rxpop->xpop, 0);
+  return Qtrue;
+#else
+  rb_warn("libxml was compiled without debugging support.");
+  return Qfalse;
+#endif
+}
+
+void rxml_init_xpath_object(void)
+{
+  cXMLXPathObject = rb_define_class_under(mXPath, "Object", rb_cObject);
+  rb_include_module(cXMLXPathObject, rb_mEnumerable);
+  rb_define_attr(cXMLXPathObject, "context", 1, 0);
+  rb_define_method(cXMLXPathObject, "each", rxml_xpath_object_each, 0);
+  rb_define_method(cXMLXPathObject, "xpath_type", rxml_xpath_object_get_type, 0);
+  rb_define_method(cXMLXPathObject, "empty?", rxml_xpath_object_empty_q, 0);
+  rb_define_method(cXMLXPathObject, "first", rxml_xpath_object_first, 0);
+  rb_define_method(cXMLXPathObject, "last", rxml_xpath_object_last, 0);
+  rb_define_method(cXMLXPathObject, "length", rxml_xpath_object_length, 0);
+  rb_define_method(cXMLXPathObject, "to_a", rxml_xpath_object_to_a, 0);
+  rb_define_method(cXMLXPathObject, "[]", rxml_xpath_object_aref, 1);
+  rb_define_method(cXMLXPathObject, "string", rxml_xpath_object_string, 0);
+  rb_define_method(cXMLXPathObject, "debug", rxml_xpath_object_debug, 0);
+  rb_define_alias(cXMLXPathObject, "size", "length");
+
+}

data/ext/libxml/ruby_xml_xpath_object.h

@@ -0,0 +1,17 @@
+#ifndef __RXML_XPATH_OBJECT__
+#define __RXML_XPATH_OBJECT__
+
+extern VALUE cXMLXPathObject;
+
+typedef struct rxml_xpath_object
+{
+  xmlDocPtr xdoc;
+  xmlXPathObjectPtr xpop;
+  VALUE nsnodes;
+} rxml_xpath_object;
+
+
+void rxml_init_xpath_object(void);
+VALUE rxml_xpath_object_wrap(xmlDocPtr xdoc, xmlXPathObjectPtr xpop);
+
+#endif

data/ext/libxml/ruby_xml_xpointer.c

@@ -0,0 +1,99 @@
+/* Please see the LICENSE file for copyright and distribution information */
+
+#include "ruby_libxml.h"
+#include "ruby_xml_xpointer.h"
+
+VALUE cXMLXPointer;
+
+/*
+ * Document-class: LibXML::XML::XPointer
+ *
+ * The XML::Pointer class provides a standards based API for searching an xml document.
+ * XPointer is based on the XML Path Language (XML::XPath) and is documented
+ * at http://www.w3.org/TR/WD-xptr.
+ */
+
+static VALUE rxml_xpointer_point(VALUE class, VALUE rnode, VALUE xptr_str)
+{
+#ifdef LIBXML_XPTR_ENABLED
+  xmlNodePtr xnode;
+  xmlXPathContextPtr xctxt;
+  xmlXPathObjectPtr xpop;
+
+  VALUE context;
+  VALUE result;
+  VALUE argv[1];
+
+  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, xmlNode, xnode);
+
+  argv[0] = rb_funcall(rnode, rb_intern("doc"), 0);
+  context = rb_class_new_instance(1, argv, cXMLXPathContext);
+  Data_Get_Struct(context, xmlXPathContext, xctxt);
+
+  xpop = xmlXPtrEval((xmlChar*)StringValuePtr(xptr_str), xctxt);
+  if (!xpop)
+  rxml_raise(&xmlLastError);
+
+  result = rxml_xpath_object_wrap(xnode->doc, xpop);
+  rb_iv_set(result, "@context", context);
+
+  return(result);
+#else
+  rb_warn("libxml was compiled without XPointer support");
+  return (Qfalse);
+#endif
+}
+
+VALUE rxml_xpointer_point2(VALUE node, VALUE xptr_str)
+{
+  return (rxml_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.
+ */
+static VALUE rxml_xpointer_range(VALUE class, VALUE rstart, VALUE rend)
+{
+#ifdef LIBXML_XPTR_ENABLED
+  xmlNodePtr 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, xmlNode, start);
+  if (start == NULL)
+  return(Qnil);
+
+  Data_Get_Struct(rend, xmlNode, end);
+  if (end == NULL)
+  return(Qnil);
+
+  xpath = xmlXPtrNewRangeNodes(start, end);
+  if (xpath == NULL)
+  rb_fatal("You shouldn't be able to have this happen");
+
+  rxxp = rxml_xpath_object_wrap(start->doc, xpath);
+  return(rxxp);
+#else
+  rb_warn("libxml was compiled without XPointer support");
+  return (Qfalse);
+#endif
+}
+
+void rxml_init_xpointer(void)
+{
+  cXMLXPointer = rb_define_class_under(mXML, "XPointer", rb_cObject);
+  rb_define_singleton_method(cXMLXPointer, "range", rxml_xpointer_range, 2);
+}

data/ext/libxml/ruby_xml_xpointer.h

@@ -0,0 +1,11 @@
+/* Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RXML_XPOINTER__
+#define __RXML_XPOINTER__
+
+extern VALUE cXMLXPointer;
+
+void rxml_init_xpointer(void);
+VALUE rxml_xpointer_point2(VALUE node, VALUE xptr_str);
+
+#endif

data/ext/vc/libxml_ruby.sln

@@ -0,0 +1,28 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 14
+VisualStudioVersion = 14.0.25420.1
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libxml_ruby", "libxml_ruby\libxml_ruby.vcxproj", "{0B65CD1D-EEB9-41AE-93BB-75496E504152}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Debug|x86 = Debug|x86
+		Release|x64 = Release|x64
+		Release|x86 = Release|x86
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{0B65CD1D-EEB9-41AE-93BB-75496E504152}.Debug|x64.ActiveCfg = Debug|x64
+		{0B65CD1D-EEB9-41AE-93BB-75496E504152}.Debug|x64.Build.0 = Debug|x64
+		{0B65CD1D-EEB9-41AE-93BB-75496E504152}.Debug|x86.ActiveCfg = Debug|x64
+		{0B65CD1D-EEB9-41AE-93BB-75496E504152}.Debug|x86.Build.0 = Debug|x64
+		{0B65CD1D-EEB9-41AE-93BB-75496E504152}.Release|x64.ActiveCfg = Release|x64
+		{0B65CD1D-EEB9-41AE-93BB-75496E504152}.Release|x64.Build.0 = Release|x64
+		{0B65CD1D-EEB9-41AE-93BB-75496E504152}.Release|x86.ActiveCfg = Release|Win32
+		{0B65CD1D-EEB9-41AE-93BB-75496E504152}.Release|x86.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

data/lib/libxml/attr.rb

@@ -0,0 +1,123 @@
+# encoding: UTF-8
+
+module LibXML
+  module XML
+    class Attr 
+      include Enumerable
+
+      # call-seq:
+      #    attr.child? -> (true|false)
+      #
+      # Returns whether this attribute has child attributes.
+      #
+      def child?
+        not self.children.nil?
+      end
+
+      # call-seq:
+      #    attr.doc? -> (true|false)
+      #
+      # Determine whether this attribute is associated with an
+      # XML::Document.
+      def doc?
+        not self.doc.nil?
+      end
+
+      # call-seq:
+      #    attr.last? -> (true|false)
+      #
+      # Determine whether this is the last attribute.
+      def last?
+        self.last.nil?
+      end
+
+      # call-seq:
+      #    attr.next? -> (true|false)
+      #
+      # Determine whether there is a next attribute.
+      def next?
+        not self.next.nil?
+      end
+
+      # call-seq:
+      #    attr.ns? -> (true|false)
+      #
+      # Determine whether this attribute has an associated
+      # namespace.
+      def ns?
+        not self.ns.nil?
+      end
+
+      # call-seq:
+      #   attr.namespacess -> XML::Namespaces
+      #
+      # Returns this node's XML::Namespaces object,
+      # which is used to access the namespaces
+      # associated with this node.
+      def namespaces
+        @namespaces ||= XML::Namespaces.new(self)
+      end
+      
+      #
+      # call-seq:
+      #    attr.parent? -> (true|false)
+      #
+      # Determine whether this attribute has a parent.
+      def parent?
+        not self.parent.nil?
+      end
+
+      # call-seq:
+      #    attr.prev? -> (true|false)
+      #
+      # Determine whether there is a previous attribute.
+      def prev?
+        not self.prev.nil?
+      end
+
+      # Returns this node's type name
+      def node_type_name
+        if node_type == Node::ATTRIBUTE_NODE
+          'attribute'
+        else
+          raise(UnknownType, "Unknown node type: %n", node.node_type);
+        end
+      end
+
+      # Iterates nodes and attributes
+      def siblings(node, &blk)
+        if n = node
+          loop do
+            blk.call(n)
+            break unless n = n.next
+          end
+        end
+      end
+
+      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]
+          ary
+        end
+      end
+  
+      def to_s
+        "#{name} = #{value}"
+      end
+    end
+  end
+end

data/lib/libxml/attr_decl.rb

@@ -0,0 +1,80 @@
+# encoding: UTF-8
+
+module LibXML
+  module XML
+    class AttrDecl
+      include Enumerable
+
+      # call-seq:
+      #   attr_decl.child -> nil
+      #
+      # Obtain this attribute declaration's child attribute(s).
+      # It will always be nil.
+      def child
+        nil
+      end
+
+      # call-seq:
+      #    attr_decl.child? -> (true|false)
+      #
+      # Returns whether this attribute declaration has child attributes.
+      #
+      def child?
+        not self.children.nil?
+      end
+
+      # call-seq:
+      #    attr_decl.doc? -> (true|false)
+      #
+      # Determine whether this attribute declaration is associated with an
+      # XML::Document.
+      def doc?
+        not self.doc.nil?
+      end
+
+      # call-seq:
+      #    attr_decl.next? -> (true|false)
+      #
+      # Determine whether there is a next attribute declaration.
+      def next?
+        not self.next.nil?
+      end
+
+      # call-seq:
+      #    attr_decl.parent? -> (true|false)
+      #
+      # Determine whether this attribute declaration has a parent .
+      def parent?
+        not self.parent.nil?
+      end
+
+      # call-seq:
+      #    attr_decl.prev? -> (true|false)
+      #
+      # Determine whether there is a previous attribute declaration.
+      def prev?
+        not self.prev.nil?
+      end
+
+      # call-seq:
+      #    attr_decl.node_type_name -> 'attribute declaration'
+      #
+      # Returns this attribute declaration's node type name.
+      def node_type_name
+        if node_type == Node::ATTRIBUTE_DECL
+          'attribute declaration'
+        else
+          raise(UnknownType, "Unknown node type: %n", node.node_type);
+        end
+      end
+
+      # call-seq:
+      #    attr_decl.to_s -> string
+      #
+      # Returns a string representation of this attribute declaration.
+      def to_s
+        "#{name} = #{value}"
+      end
+    end
+  end
+end