libxml-ruby 2.9.0-x64-mingw32

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,26 @@
+
+Microsoft Visual Studio Solution File, Format Version 11.00
+# Visual Studio 2010
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libxml_ruby", "libxml_ruby_18\libxml_ruby.vcxproj", "{0B65CD1D-EEB9-41AE-93BB-75496E504152}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libxml_ruby_19", "libxml_ruby_19\libxml_ruby_19.vcxproj", "{0E73156F-E619-4FD9-8327-113FE3CC942E}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Win32 = Debug|Win32
+		Release|Win32 = Release|Win32
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{0B65CD1D-EEB9-41AE-93BB-75496E504152}.Debug|Win32.ActiveCfg = Debug|Win32
+		{0B65CD1D-EEB9-41AE-93BB-75496E504152}.Debug|Win32.Build.0 = Debug|Win32
+		{0B65CD1D-EEB9-41AE-93BB-75496E504152}.Release|Win32.ActiveCfg = Release|Win32
+		{0B65CD1D-EEB9-41AE-93BB-75496E504152}.Release|Win32.Build.0 = Release|Win32
+		{0E73156F-E619-4FD9-8327-113FE3CC942E}.Debug|Win32.ActiveCfg = Debug|Win32
+		{0E73156F-E619-4FD9-8327-113FE3CC942E}.Debug|Win32.Build.0 = Debug|Win32
+		{0E73156F-E619-4FD9-8327-113FE3CC942E}.Release|Win32.ActiveCfg = Release|Win32
+		{0E73156F-E619-4FD9-8327-113FE3CC942E}.Release|Win32.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

data/lib/libxml.rb

@@ -0,0 +1,35 @@
+# encoding: UTF-8
+
+# Load the C-based binding.
+begin
+  RUBY_VERSION =~ /(\d+.\d+)/
+  require "#{$1}/libxml_ruby"
+rescue LoadError
+  require "libxml_ruby"
+end
+# Load Ruby supporting code.
+require 'libxml/error'
+require 'libxml/parser'
+require 'libxml/document'
+require 'libxml/namespaces'
+require 'libxml/namespace'
+require 'libxml/node'
+require 'libxml/ns'
+require 'libxml/attributes'
+require 'libxml/attr'
+require 'libxml/attr_decl'
+require 'libxml/tree'
+require 'libxml/reader'
+require 'libxml/html_parser'
+require 'libxml/sax_parser'
+require 'libxml/sax_callbacks'
+require 'libxml/xpath_object'
+
+#Schema Interface
+require 'libxml/schema'
+require 'libxml/schema/type'
+require 'libxml/schema/element'
+require 'libxml/schema/attribute'
+
+# Deprecated
+require 'libxml/properties'

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

data/lib/libxml/attributes.rb

@@ -0,0 +1,14 @@
+# encoding: UTF-8
+
+module LibXML
+  module XML
+    class Attributes
+      def to_h
+        inject({}) do |hash, attr|
+          hash[attr.name] = attr.value
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/libxml/document.rb

@@ -0,0 +1,194 @@
+# encoding: UTF-8
+
+module LibXML
+  module XML
+    class Document
+      # call-seq:
+      #    XML::Document.document(document) -> XML::Document
+      #
+      # Creates a new document based on the specified document.
+      #
+      # Parameters:
+      #
+      #  document - A preparsed document.
+      def self.document(value)
+        Parser.document(value).parse
+      end
+
+      # call-seq:
+      #    XML::Document.file(path) -> 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:
+      #
+      #  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
+      end
+
+      # call-seq:
+      #    XML::Document.io(io) -> XML::Document
+      #    XML::Document.io(io, :encoding => XML::Encoding::UTF_8,
+      #                         :options => XML::Parser::Options::NOENT
+      #                         :base_uri="http://libxml.org") -> XML::Document
+      #
+      # Creates a new document from the specified io object.
+      #
+      # Parameters:
+      #
+      #  io - io object that contains the xml to parser
+      #  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.io(value, options = {})
+        Parser.io(value, 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
+      #
+      # 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:
+      #
+      #   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
+      end
+
+      # Returns a new XML::XPathContext for the document.
+      #
+      # call-seq:
+      #   document.context(namespaces=nil) -> XPath::Context
+      #
+      # Namespaces is an optional array of XML::NS objects
+      def context(nslist = nil)
+        context = XPath::Context.new(self)
+        context.node = self.root
+        context.register_namespaces_from_node(self.root)
+        context.register_namespaces(nslist) if nslist
+        context
+      end
+
+      # Return the nodes matching the specified xpath expression, 
+      # optionally using the specified namespace.  For more 
+      # information about working with namespaces, please refer
+      # to the XML::XPath documentation.
+      #
+      # call-seq:
+      #   document.find(xpath, nslist=nil) -> XML::XPath::Object
+      # 
+      # Parameters:
+      # * xpath - The xpath expression as a string
+      # * namespaces - An optional list of namespaces (see XML::XPath for information).
+      #
+      #  document.find('/foo', 'xlink:http://www.w3.org/1999/xlink')
+      #
+      # IMPORTANT - The returned XML::Node::Set must be freed before
+      # its associated document.  In a running Ruby program this will
+      # happen automatically via Ruby's mark and sweep garbage collector.
+      # However, if the program exits, Ruby does not guarantee the order
+      # in which objects are freed
+      # (see http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-core/17700).
+      # As a result, the associated document may be freed before the node
+      # list, which will cause a segmentation fault.
+      # To avoid this, use the following (non-ruby like) coding style:
+      #
+      #  nodes = doc.find('/header')
+      #  nodes.each do |node|
+      #    ... do stuff ...
+      #  end
+      # #  nodes = nil #  GC.start
+      def find(xpath, nslist = nil)
+        self.context(nslist).find(xpath)
+      end
+    
+      # Return the first node matching the specified xpath expression.
+      # For more information, please refer to the documentation
+      # for XML::Document#find.
+      def find_first(xpath, nslist = nil)
+        find(xpath, nslist).first
+      end
+      
+      # Returns this node's type name    
+      def node_type_name
+        case node_type
+        when XML::Node::DOCUMENT_NODE
+          'document_xml'
+        when XML::Node::DOCB_DOCUMENT_NODE
+          'document_docbook'
+        when XML::Node::HTML_DOCUMENT_NODE
+          'document_html'
+        else
+          raise(UnknownType, "Unknown node type: %n", node.node_type);
+        end
+      end
+      # :enddoc:
+
+      # Specifies if this is an document node
+      def document?
+        node_type == XML::Node::DOCUMENT_NODE
+      end
+
+      # Specifies if this is an docbook node
+      def docbook_doc?
+        node_type == XML::Node::DOCB_DOCUMENT_NODE
+      end
+
+      # Specifies if this is an html node
+      def html_doc?
+        node_type == XML::Node::HTML_DOCUMENT_NODE
+      end
+
+      def dump
+        warn('Document#dump is deprecated.  Use Document#to_s instead.')
+        self.to_s
+      end
+
+      def format_dump
+        warn('Document#format_dump is deprecated.  Use Document#to_s instead.')
+        self.to_s
+      end
+
+      def debug_dump
+        warn('Document#debug_dump is deprecated.  Use Document#debug instead.')
+        self.debug
+      end
+
+      def debug_dump_head
+        warn('Document#debug_dump_head is deprecated.  Use Document#debug instead.')
+        self.debug
+      end
+
+      def debug_format_dump
+        warn('Document#debug_format_dump is deprecated.  Use Document#to_s instead.')
+        self.to_s
+      end
+
+      def reader
+        warn('Document#reader is deprecated.  Use XML::Reader.document(self) instead.')
+        XML::Reader.document(self)
+      end
+    end
+  end
+end