saxon 0.2.2-java → 0.4.0-java

data/lib/saxon/source.rb

@@ -1,187 +0,0 @@
-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

data/lib/saxon/version.rb

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

data/lib/saxon/xdm_atomic_value.rb

@@ -1,48 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

data/lib/saxon/xdm_value.rb

@@ -1,129 +0,0 @@
-require_relative 'xdm_node'
-require_relative 'xdm_atomic_value'
-
-module Saxon
-  # An XPath Data Model Value object, representing a Sequence.
-  class XdmValue
-    include Enumerable
-
-    def self.wrap_s9_xdm_value(s9_xdm_value)
-      return new(s9_xdm_value) if s9_xdm_value.instance_of?(Saxon::S9API::XdmValue)
-      case s9_xdm_value
-      when Saxon::S9API::XdmEmptySequence
-        new([])
-      else
-        wrap_s9_xdm_item(s9_xdm_value)
-      end
-    end
-
-    def self.wrap_s9_xdm_item(s9_xdm_item)
-      if s9_xdm_item.isAtomicValue
-        XdmAtomicValue.new(s9_xdm_item)
-      else
-        case s9_xdm_item
-        when Saxon::S9API::XdmNode
-          XdmNode.new(s9_xdm_item)
-        else
-          XdmUnhandledItem.new(s9_xdm_item)
-        end
-      end
-    end
-
-    # Create a new XdmValue sequence containing the items passed in as a Ruby enumerable.
-    #
-    # @param items [Enumerable] A list of XDM Item members
-    # @return [Saxon::XdmValue] The XDM value
-    def self.create(items)
-      new(Saxon::S9API::XdmValue.makeSequence(items.map(&:to_java)))
-    end
-
-    attr_reader :s9_xdm_value
-    private :s9_xdm_value
-
-    # @api private
-    def initialize(s9_xdm_value)
-      @s9_xdm_value = s9_xdm_value
-    end
-
-    # @return [Fixnum] The size of the sequence
-    def size
-      s9_xdm_value.size
-    end
-
-    # Calls the given block once for each Item in the sequence, passing that
-    # item as a parameter. Returns the value itself.
-    #
-    # If no block is given, an Enumerator is returned.
-    #
-    # @overload
-    #   @yield [item] The current XDM Item
-    #   @yieldparam item [Saxon::XdmAtomicValue, Saxon::XdmNode] the item.
-    def each(&block)
-      to_enum.each(&block)
-    end
-
-    # @return [Saxon::S9API::XdmValue] The underlying Saxon Java XDM valuee object.
-    def to_java
-      @s9_xdm_value
-    end
-
-    # Compare this XdmValue with another. Currently this requires iterating
-    # across the sequence, and the other sequence and comparing each member
-    # with the corresponding member in the other sequence.
-    #
-    # @param other [Saxon::XdmValue] The XdmValue to be compare against
-    # @return [Boolean] whether the two XdmValues are equal
-    def ==(other)
-      return false unless other.is_a?(XdmValue)
-      return false unless other.size == size
-      not_okay = to_enum.zip(other.to_enum).find { |mine, theirs|
-        mine != theirs
-      }
-      not_okay.nil? || !not_okay
-    end
-
-    alias_method :eql?, :==
-
-    # The hash code for the XdmValue
-    # @return [Fixnum] The hash code
-    def hash
-      @hash ||= to_a.hash
-    end
-
-    # Returns a lazy Enumerator over the sequence
-    # @return [Enumerator::Lazy] the enumerator
-    def to_enum
-      s9_xdm_value.each.lazy.map { |s9_xdm_item|
-        wrap_s9_xdm_item(s9_xdm_item)
-      }.each
-    end
-
-    alias_method :enum_for, :to_enum
-
-    private
-
-    def wrap_s9_xdm_item(s9_xdm_item)
-      if s9_xdm_item.isAtomicValue
-        XdmAtomicValue.new(s9_xdm_item)
-      else
-        case s9_xdm_item
-        when Saxon::S9API::XdmNode
-          XdmNode.new(s9_xdm_item)
-        else
-          XdmUnhandledItem.new(s9_xdm_item)
-        end
-      end
-    end
-  end
-
-  # Placeholder class for Saxon Items that we haven't gotten to yet
-  class XdmUnhandledItem
-    def initialize(s9_xdm_item)
-      @s9_xdm_item = s9_xdm_item
-    end
-
-    def to_java
-      @s9_xdm_item
-    end
-  end
-end

data/lib/saxon/xpath.rb

@@ -1,8 +0,0 @@
-require_relative './xpath/compiler'
-
-module Saxon
-  # Classes for compiling, configuring, and executing XPath queries against
-  # XDM nodes or documents
-  module XPath
-  end
-end

data/lib/saxon/xpath/compiler.rb

@@ -1,69 +0,0 @@
-require 'forwardable'
-require_relative './static_context'
-require_relative './executable'
-
-module Saxon
-  module XPath
-    # Compiles XPath expressions so they can be executed
-    class Compiler
-      # Create a new <tt>XPath::Compiler</tt> using the supplied Processor.
-      # Passing a block gives access to a DSL for setting up the compiler's
-      # static context.
-      #
-      # @param processor [Saxon::Processor] the {Saxon::Processor} to use
-      # @yield An XPath compiler DSL block
-      # @return [Saxon::XPath::Compiler] the new compiler instance
-      def self.create(processor, &block)
-        static_context = XPath::StaticContext.define(block)
-        new(processor.to_java, static_context)
-      end
-
-      extend Forwardable
-
-      attr_reader :static_context
-      private :static_context
-
-      # @api private
-      # @param s9_processor [net.sf.saxon.s9api.Processor] the Saxon
-      #   <tt>Processor</tt> to wrap
-      # @param static_context [Saxon::XPath::StaticContext] the static context
-      #   XPaths compiled using this compiler will have
-      def initialize(s9_processor, static_context)
-        @s9_processor, @static_context = s9_processor, static_context
-      end
-
-      def_delegators :static_context, :default_collation, :declared_namespaces, :declared_variables
-      # @!attribute [r] default_collation
-      #   @return [String] the URI of the default declared collation
-      # @!attribute [r] declared_namespaces
-      #   @return [Hash<String => String>] declared namespaces as prefix => URI hash
-      # @!attribute [r] declared_variables
-      #   @return [Hash<Saxon::QName => Saxon::XPath::VariableDeclaration>] declared variables as QName => Declaration hash
-
-      # @param expression [String] the XPath expression to compile
-      # @return [Saxon::XPath::Executable] the executable query
-      def compile(expression)
-        Saxon::XPath::Executable.new(new_compiler.compile(expression), static_context)
-      end
-
-      def create(&block)
-        new_static_context = static_context.define(block)
-        self.class.new(@s9_processor, new_static_context)
-      end
-
-      private
-
-      def new_compiler
-        compiler = @s9_processor.newXPathCompiler
-        declared_namespaces.each do |prefix, uri|
-          compiler.declareNamespace(prefix, uri)
-        end
-        declared_variables.each do |_, decl|
-          compiler.declareVariable(*decl.compiler_args)
-        end
-        compiler.declareDefaultCollation(default_collation) unless default_collation.nil?
-        compiler
-      end
-    end
-  end
-end