saxon-rb 0.4.0-java

data/lib/saxon/qname.rb

@@ -0,0 +1,153 @@
+require 'saxon/s9api'
+
+module Saxon
+  # Represents QNames
+  class QName
+    def self.clark(clark_string)
+      s9_qname = Saxon::S9API::QName.fromClarkName(clark_string)
+      new(s9_qname)
+    end
+
+    def self.eqname(eqname_string)
+      s9_qname = Saxon::S9API::QName.fromEQName(eqname_string)
+      new(s9_qname)
+    end
+
+    def self.create(opts = {})
+      prefix = opts[:prefix]
+      uri = opts[:uri]
+      begin
+        local_name = opts.fetch(:local_name)
+      rescue KeyError
+        raise ArgumentError, "The :local_name option must be passed"
+      end
+
+      s9_qname = Saxon::S9API::QName.new(*[prefix, uri, local_name].compact)
+      new(s9_qname)
+    end
+
+    # Resolve a QName string into a {Saxon::QName}.
+    #
+    # If the arg is a {Saxon::QName} already, it just gets returned. If
+    # it's an instance of the underlying Saxon Java QName, it'll be wrapped
+    # into a {Saxon::QName}
+    #
+    # If the arg is a string, it's resolved by using {resolve_variable_name}
+    #
+    # @param qname_or_string [String, Symbol, Saxon::QName] the qname to resolve
+    # @param namespaces [Hash<String => String>] the set of namespaces as a hash of <tt>"prefix" => "namespace-uri"</tt>
+    # @return [Saxon::QName]
+    def self.resolve(qname_or_string, namespaces = {})
+      case qname_or_string
+      when String, Symbol
+        resolve_qname_string(qname_or_string, namespaces)
+      when self
+        qname_or_string
+      when Saxon::S9API::QName
+        new(qname_or_string)
+      end
+    end
+
+    # Resolve a QName string of the form <tt>"prefix:local-name"</tt> into a
+    # {Saxon::QName} by looking up the namespace URI in a hash of
+    # <tt>"prefix" => "namespace-uri"</tt>
+    #
+    # @param qname_string [String, Symbol] the QName as a <tt>"prefix:local-name"</tt> string
+    # @param namespaces [Hash<String => String>] the set of namespaces as a hash of <tt>"prefix" => "namespace-uri"</tt>
+    # @return [Saxon::QName]
+    def self.resolve_qname_string(qname_string, namespaces = {})
+      local_name, prefix = qname_string.to_s.split(':').reverse
+      uri = nil
+
+      if prefix
+        uri = namespaces[prefix]
+        raise self::PrefixedStringWithoutNSURIError.new(qname_string, prefix) if uri.nil?
+      end
+
+      create(prefix: prefix, uri: uri, local_name: local_name)
+    end
+
+    attr_reader :s9_qname
+    private :s9_qname
+
+    # @api private
+    def initialize(s9_qname)
+      @s9_qname = s9_qname
+    end
+
+    # @return [String] The local name part of the QName
+    def local_name
+      @s9_qname.getLocalName
+    end
+
+    # @return [String] The prefix part of the QName ('' if unset)
+    def prefix
+      @s9_qname.getPrefix
+    end
+
+    # @return [String] The namespace URI part of the QName ('' if unset)
+    def uri
+      @s9_qname.getNamespaceURI
+    end
+
+    # Return a Clark notation representation of the QName:
+    #
+    #    "{http://ns.url}local-name"
+    #
+    # Note that the prefix is lost in Clark notation.
+    # @return [String] The QName represented using Clark notation.
+    def clark
+      @s9_qname.getClarkName
+    end
+
+    # Return a Extended QName notation representation of the QName:
+    #
+    #    "Q{http://ns.url}local-name"
+    #
+    # Note that the prefix is lost in EQName notation.
+    # @return [String] The QName represented using EQName notation.
+    def eqname
+      @s9_qname.getEQName
+    end
+
+    def ==(other)
+      return false unless other.is_a?(QName)
+      s9_qname.equals(other.to_java)
+    end
+    alias_method :eql?, :==
+
+    def hash
+      @hash ||= (local_name + uri).hash
+    end
+
+    # @return [Saxon::S9API::QName] the underlying Saxon QName object
+    def to_java
+      s9_qname
+    end
+
+    # convert the QName to a lexical string, using the prefix (if there is one).
+    # So, <tt>Saxon::QName.clark('{http://example.org/#ns}hello').to_s</tt>
+    # returns <tt>'hello'</tt>, and <tt>Saxon::QName.create(prefix: 'pre', uri:
+    # 'http://example.org/#ns', local_name: 'hello').to_s</tt> returns
+    # <tt>'pre:hello'</tt>
+    def to_s
+      s9_qname.to_s
+    end
+
+    def inspect
+      "<Saxon::QName @prefix=#{prefix} @uri=#{uri} @local_name=#{local_name}>"
+    end
+
+    # Raised when an attempt is made to resolve a <tt>prefix:local-name</tt>
+    # into a QName, and the prefix has not been bound to a namespace URI.
+    class PrefixedStringWithoutNSURIError < RuntimeError
+      def initialize(qname_string, prefix)
+        @qname_string, @prefix = qname_string, prefix
+      end
+
+      def to_s
+        "Namespace prefix ‘#{@prefix}’ for QName ‘#{@qname_string}’ is not bound to a URI"
+      end
+    end
+  end
+end

data/lib/saxon/s9api.rb

@@ -0,0 +1,34 @@
+require 'saxon/loader'
+
+module Saxon
+  module S9API
+    CLASS_IMPORT_SEMAPHORE = Mutex.new
+
+    class << self
+      def const_missing(name)
+        Saxon::Loader.load!
+        begin
+          const_set(name, imported_classes.const_get(name))
+        rescue NameError
+          msg = "uninitialized constant Saxon::S9API::#{name}"
+          e = NameError.new(msg, name)
+          raise e
+        end
+      end
+
+      private
+
+      def imported_classes
+        return @imported_classes if instance_variable_defined?(:@imported_classes)
+        CLASS_IMPORT_SEMAPHORE.synchronize do
+          @imported_classes = Module.new {
+            include_package 'net.sf.saxon.s9api'
+            java_import Java::net.sf.saxon.Configuration
+            java_import Java::net.sf.saxon.lib.FeatureKeys
+            java_import Java::net.sf.saxon.lib.ParseOptions
+          }
+        end
+      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, StringIO
+        from_io(io_path_uri_or_string, opts)
+      when Pathname, PathChecker
+        from_path(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