saxon 0.1.0-java

data/lib/saxon/s9api.rb

@@ -0,0 +1,16 @@
+require 'saxon/loader'
+
+module Saxon
+  module S9API
+    def self.const_missing(name)
+      Saxon::Loader.load!
+      begin
+        const_get(name)
+      rescue NameError
+        msg = "uninitialized constant Saxon::S9API::#{name}"
+        e = NameError.new(msg, name)
+        raise e
+      end
+    end
+  end
+end

data/lib/saxon/serializer.rb

@@ -0,0 +1,143 @@
+require 'saxon/s9api'
+require 'stringio'
+
+module Saxon
+  # Serialize XDM objects.
+  class Serializer
+    # Manage access to the serialization properties of this serializer, with
+    # hash-like access.
+    #
+    # Properties can be set explicitly through this API, or via XSLT or XQuery
+    # serialization options like `<xsl:output>`.
+    #
+    # Properties set explicitly here will override properties set through the
+    # document like `<xsl:output>`.
+    class OutputProperties
+      # @api private
+      # Provides mapping between symbols and the underlying Saxon property
+      # instances
+      def self.output_properties
+        @output_properties ||= Hash[
+          Saxon::S9API::Serializer::Property.values.map { |property|
+            qname = property.getQName
+            key = [
+              qname.getPrefix,
+              qname.getLocalName.tr('-', '_')
+            ].reject { |str| str == '' }.join('_').to_sym
+            [key, property]
+          }
+        ]
+      end
+
+      attr_reader :s9_serializer
+
+      # @api private
+      def initialize(s9_serializer)
+        @s9_serializer = s9_serializer
+      end
+
+      # @param [Symbol, Saxon::S9API::Serializer::Property] property The property to fetch
+      def [](property)
+        s9_serializer.getOutputProperty(resolved_property(property))
+      end
+
+      # @param [Symbol, Saxon::S9API::Serializer::Property] property The property to set
+      # @param [String] value The string value of the property
+      def []=(property, value)
+        s9_serializer.setOutputProperty(resolved_property(property), value)
+      end
+
+      # @overload fetch(property)
+      #   @param [Symbol, Saxon::S9API::Serializer::Property] property The property to fetch
+      # @overload fetch(property, default)
+      #   @param property [Symbol, Saxon::S9API::Serializer::Property] The property to fetch
+      #   @param default [Object] The value to return if the property is unset
+      def fetch(property, default = nil)
+        explicit_value = self[property]
+        if explicit_value.nil? && !default.nil?
+          default
+        else
+          explicit_value
+        end
+      end
+
+      private
+      def resolved_property(property_key)
+        case property_key
+        when Symbol
+          self.class.output_properties.fetch(property_key)
+        else
+          property_key
+        end
+      end
+    end
+
+    attr_reader :s9_serializer
+    private :s9_serializer
+
+    # @api private
+    def initialize(s9_serializer)
+      @s9_serializer = s9_serializer
+    end
+
+    # @return [Saxon::Serializer::OutputProperties] hash-like access to the Output Properties
+    def output_property
+      @output_property ||= OutputProperties.new(s9_serializer)
+    end
+
+    # @overload serialize(xdm_value, io)
+    #   Serialize an XdmValue to an IO
+    #   @param [Saxon::XdmValue] xdm_value The XdmValue to serialize
+    #   @param [File, IO] io The IO to serialize to
+    #   @return [nil]
+    # @overload serialize(xdm_value, path)
+    #   Serialize an XdmValue to file <tt>path</tt>
+    #   @param [Saxon::XdmValue] xdm_value The XdmValue to serialize
+    #   @param [String, Pathname] path The path of the file to serialize to
+    #   @return [nil]
+    # @overload serialize(xdm_value)
+    #   Serialize an XdmValue to a String
+    #   @param [Saxon::XdmValue] xdm_value The XdmValue to serialize
+    #   @return [String] The serialized XdmValue
+    def serialize(xdm_value, io_or_path = nil)
+      case io_or_path
+      when nil
+        serialize_to_string(xdm_value)
+      when String, Pathname
+        serialize_to_file(xdm_value, io_or_path)
+      else
+        serialize_to_io(xdm_value, io_or_path)
+      end
+    end
+
+    # @return [Saxon::S9API::Serializer] The underlying Saxon Serializer object
+    def to_java
+      s9_serializer
+    end
+
+    private
+
+    def serialize_to_io(xdm_value, io)
+      s9_serializer.setOutputStream(io.to_outputstream)
+      s9_serializer.serializeXdmValue(xdm_value.to_java)
+      nil
+    end
+
+    def serialize_to_string(xdm_value)
+      str_encoding = output_property.fetch(:encoding, Encoding.default_internal || Encoding.default_external)
+      StringIO.open { |io|
+        io.binmode
+        serialize_to_io(xdm_value, io)
+        io.string.force_encoding(str_encoding)
+      }
+    end
+
+    def serialize_to_file(xdm_value, path)
+      file = Java::JavaIO::File.new(path)
+      s9_serializer.setOutputFile(file)
+      s9_serializer.serializeXdmValue(xdm_value.to_java)
+      nil
+    end
+  end
+end
+

data/lib/saxon/source.rb

@@ -0,0 +1,187 @@
+require 'java'
+require 'saxon/jaxp'
+require 'uri'
+require 'pathname'
+
+module Saxon
+  # Provides a wrapper around the JAXP StreamSource class Saxon uses to bring
+  # the XML bytestream in. Provides some extra methods to make handling closing
+  # the source and its inputstream after consumption more idiomatic
+  class Source
+    module Helpers
+      # Given a File, or IO object which will return either #path or
+      # #base_uri, return the #base_uri, if present, or the #path, if present, or
+      # nil
+      # @param [File, IO] io A File or IO
+      #   object representing the input XML file or data, or a String containing
+      #   the XML
+      # @return [String, nil] the path or URI from the IO (or nil if there is none)
+      def self.base_uri(io)
+        if io.respond_to?(:base_uri)
+          return io.base_uri.to_s
+        end
+        io.path if io.respond_to?(:path)
+      end
+
+      # Given a File or IO return a Java InputStream
+      # @param [File, IO, org.jruby.util.IOInputStream, java.io.InputStream]
+      #   io input to be converted to an input stream
+      # @return [java.io.InputStream] the wrapped input
+      def self.inputstream(io)
+        case io
+        when org.jruby.util.IOInputStream, java.io.InputStream
+          io
+        else
+          io.to_inputstream if io.respond_to?(:read)
+        end
+      end
+
+      # Given a path return a Java File object
+      # @param [String, Pathname] path the path to the file
+      # @return [java.io.File] the Java File object
+      def self.file(path)
+        java.io.File.new(path.to_s)
+      end
+    end
+
+    PathChecker = ->(path) {
+      File.file?(path)
+    }
+    URIChecker = ->(uri) {
+      begin
+        URI.parse(uri)
+        true
+      rescue URI::InvalidURIError
+        false
+      end
+    }
+
+    # Generate a Saxon::Source given an IO-like
+    #
+    # @param [IO, File] io The IO-like containing XML to be parsed
+    # @param [Hash] opts
+    # @option opts [String] :base_uri The Base URI for the Source - an
+    #   absolute URI or relative path that will be used to resolve relative
+    #   URLs in the XML. Setting this will override any path or URI derived
+    #   from the IO-like.
+    # @return [Saxon::Source] the Saxon::Source wrapping the input
+    def self.from_io(io, opts = {})
+      base_uri = opts.fetch(:base_uri) { Helpers.base_uri(io) }
+      inputstream = Helpers.inputstream(io)
+      stream_source = Saxon::JAXP::StreamSource.new(inputstream, base_uri)
+      new(stream_source, inputstream)
+    end
+
+    # Generate a Saxon::Source given a path to a file
+    #
+    # @param [String, Pathname] path The path to the XML file to be parsed
+    # @param [Hash] opts
+    # @option opts [String] :base_uri The Base URI for the Source - an
+    #   absolute URI or relative path that will be used to resolve relative
+    #   URLs in the XML. Setting this will override the file path.
+    # @return [Saxon::Source] the Saxon::Source wrapping the input
+    def self.from_path(path, opts = {})
+      stream_source = Saxon::JAXP::StreamSource.new(Helpers.file(path))
+      stream_source.setSystemId(opts[:base_uri]) if opts[:base_uri]
+      new(stream_source)
+    end
+
+    # Generate a Saxon::Source given a URI
+    #
+    # @param [String, URI] uri The URI to the XML file to be parsed
+    # @param [Hash] opts
+    # @option opts [String] :base_uri The Base URI for the Source - an
+    #   absolute URI or relative path that will be used to resolve relative
+    #   URLs in the XML. Setting this will override the given URI.
+    # @return [Saxon::Source] the Saxon::Source wrapping the input
+    def self.from_uri(uri, opts = {})
+      stream_source = Saxon::JAXP::StreamSource.new(uri.to_s)
+      stream_source.setSystemId(opts[:base_uri]) if opts[:base_uri]
+      new(stream_source)
+    end
+
+    # Generate a Saxon::Source given a string containing XML
+    #
+    # @param [String] string The string containing XML to be parsed
+    # @param [Hash] opts
+    # @option opts [String] :base_uri The Base URI for the Source - an
+    #   absolute URI or relative path that will be used to resolve relative
+    #   URLs in the XML. This will be nil unless set.
+    # @return [Saxon::Source] the Saxon::Source wrapping the input
+    def self.from_string(string, opts = {})
+      reader = java.io.StringReader.new(string)
+      stream_source = Saxon::JAXP::StreamSource.new(reader)
+      stream_source.setSystemId(opts[:base_uri]) if opts[:base_uri]
+      new(stream_source, reader)
+    end
+
+    def self.create(io_path_uri_or_string, opts = {})
+      case io_path_uri_or_string
+      when IO, File, java.io.InputStream
+        from_io(io_path_uri_or_string, opts)
+      when Pathname, PathChecker
+        from_file(io_path_uri_or_string, opts)
+      when URIChecker
+        from_uri(io_path_uri_or_string, opts)
+      else
+        from_string(io_path_uri_or_string, opts)
+      end
+    end
+
+    attr_reader :stream_source, :inputstream
+    private :stream_source, :inputstream
+
+    # @api private
+    # @param [java.xml.transform.stream.StreamSource] stream_source The Java JAXP StreamSource
+    # @param [java.io.InputStream, java.io.StringReader] inputstream The Java InputStream or StringReader
+    def initialize(stream_source, inputstream = nil)
+      @stream_source = stream_source
+      @inputstream = inputstream
+      @closed = false
+    end
+
+    # @return [String] The base URI of the Source
+    def base_uri
+      stream_source.getSystemId
+    end
+
+    # @param [String, URI] uri The URI to use as the Source's Base URI
+    # @return [String] The new base URI of the Source
+    def base_uri=(uri)
+      stream_source.setSystemId(uri.to_s)
+      base_uri
+    end
+
+    # Close the Source and its associated InputStream or Reader, allowing those
+    # resources to be freed.
+    # @return [TrueClass] Returns true
+    def close
+      inputstream.close
+      @closed = true
+    end
+
+    # @return [Boolean] Returns true if the source is closed, false otherwise
+    def closed?
+      @closed
+    end
+
+    # Yields itself and then closes itself. To be used by DocumentBuilders or
+    # other consumers, making it easy to ensure the source is closed after it
+    # has been consumed.
+    #
+    # @raise [Saxon::SourceClosedError] if the Source has already been closed
+    # @yield [source] Yields self to the block
+    def consume(&block)
+      raise SourceClosedError if closed?
+      block.call(self)
+      close
+    end
+
+    # @return [java.xml.transform.stream.StreamSource] The underlying JAXP StreamSource
+    def to_java
+      @stream_source
+    end
+  end
+
+  class SourceClosedError < Exception; end
+end

data/lib/saxon/version.rb

@@ -0,0 +1,3 @@
+module Saxon
+  VERSION = "0.1.0"
+end

data/lib/saxon/xdm_atomic_value.rb

@@ -0,0 +1,48 @@
+require_relative 'qname'
+
+module Saxon
+  # An XPath Data Model Node object, representing an XML document, or an element or one of the other node chunks in the XDM.
+  class XdmAtomicValue
+    # convert a single Ruby value into an XdmAtomicValue
+    #
+    # @param value the value to convert
+    # @return [Saxon::XdmAtomicValue]
+    def self.create(value)
+      new(Saxon::S9API::XdmAtomicValue.new(value))
+    end
+
+    attr_reader :s9_xdm_atomic_value
+    private :s9_xdm_atomic_value
+
+    # @api private
+    def initialize(s9_xdm_atomic_value)
+      @s9_xdm_atomic_value = s9_xdm_atomic_value
+    end
+
+    # Return a {QName} representing the type of the value
+    #
+    # @return [Saxon::QName] the {QName} of the value's type
+    def type_name
+      @type_name ||= Saxon::QName.new(s9_xdm_atomic_value.getTypeName)
+    end
+
+    # @return [Saxon::S9API::XdmAtomicValue] The underlying Saxon Java XDM atomic value object.
+    def to_java
+      s9_xdm_atomic_value
+    end
+
+    # compares two {XdmAtomicValue}s using the underlying Saxon and XDM comparision rules
+    # @param other [Saxon::XdmAtomicValue]
+    # @return [Boolean]
+    def ==(other)
+      return false unless other.is_a?(XdmAtomicValue)
+      s9_xdm_atomic_value.equals(other.to_java)
+    end
+
+    alias_method :eql?, :==
+
+    def hash
+      @hash ||= s9_xdm_atomic_value.hashCode
+    end
+  end
+end

data/lib/saxon/xdm_node.rb

@@ -0,0 +1,65 @@
+require_relative 'axis_iterator'
+
+module Saxon
+  # An XPath Data Model Node object, representing an XML document, or an element or one of the other node chunks in the XDM.
+  class XdmNode
+    include Enumerable
+
+    attr_reader :s9_xdm_node
+    private :s9_xdm_node
+
+    # @api private
+    def initialize(s9_xdm_node)
+      @s9_xdm_node = s9_xdm_node
+    end
+
+    # @return [Saxon::S9API::XdmNode] The underlying Saxon Java XDM node object.
+    def to_java
+      @s9_xdm_node
+    end
+
+    def node_name
+      return @node_name if instance_variable_defined?(:@node_name)
+      node_name = s9_xdm_node.getNodeName
+      @node_name = node_name.nil? ? nil : Saxon::QName.new(node_name)
+    end
+
+    def node_kind
+      @node_kind ||= case s9_xdm_node.nodeKind
+      when Saxon::S9API::XdmNodeKind::ELEMENT
+        :element
+      when Saxon::S9API::XdmNodeKind::TEXT
+        :text
+      when Saxon::S9API::XdmNodeKind::ATTRIBUTE
+        :attribute
+      when Saxon::S9API::XdmNodeKind::NAMESPACE
+        :namespace
+      when Saxon::S9API::XdmNodeKind::COMMENT
+        :comment
+      when Saxon::S9API::XdmNodeKind::PROCESSING_INSTRUCTION
+        :processing_instruction
+      when Saxon::S9API::XdmNodeKind::DOCUMENT
+        :document
+      end
+    end
+
+    def ==(other)
+      return false unless other.is_a?(XdmNode)
+      s9_xdm_node.equals(other.to_java)
+    end
+
+    alias_method :eql?, :==
+
+    def hash
+      @hash ||= s9_xdm_node.hashCode
+    end
+
+    def each(&block)
+      axis_iterator(:child).each(&block)
+    end
+
+    def axis_iterator(axis)
+      AxisIterator.new(self, axis)
+    end
+  end
+end