saxon-rb 0.4.0-java

data/lib/saxon/version.rb

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

data/lib/saxon/xdm.rb

@@ -0,0 +1,35 @@
+require_relative 'xdm/node'
+require_relative 'xdm/atomic_value'
+require_relative 'xdm/array'
+require_relative 'xdm/map'
+require_relative 'xdm/function_item'
+require_relative 'xdm/external_object'
+require_relative 'xdm/value'
+require_relative 'xdm/empty_sequence'
+require_relative 'xdm/item'
+
+module Saxon
+  module XDM
+    class << self
+      def AtomicValue(*args)
+        XDM::AtomicValue.create(*args)
+      end
+
+      def Value(*args)
+        XDM::Value.create(*args)
+      end
+
+      def EmptySequence()
+        XDM::EmptySequence.create
+      end
+
+      def Array(*args)
+        XDM::Array.create(*args)
+      end
+
+      def Map(*args)
+        XDM::Map.create(*args)
+      end
+    end
+  end
+end

data/lib/saxon/xdm/array.rb

@@ -0,0 +1,77 @@
+require_relative '../s9api'
+require_relative 'sequence_like'
+
+module Saxon
+  module XDM
+    # Represents an XDM Array
+    class Array
+      def self.create(array)
+        case array
+        when S9API::XdmArray
+          new(array)
+        else
+          new(S9API::XdmArray.new(array.map { |item|
+            XDM.Value(item).to_java
+          }))
+        end
+      end
+
+      include SequenceLike
+      include ItemSequenceLike
+      include Enumerable
+
+      attr_reader :s9_xdm_array
+      private :s9_xdm_array
+
+      # @api private
+      def initialize(s9_xdm_array)
+        @s9_xdm_array = s9_xdm_array
+      end
+
+      def each(&block)
+        cached_array.each(&block)
+      end
+
+      def [](i)
+        cached_array[i]
+      end
+
+      def length
+        s9_xdm_array.arrayLength
+      end
+
+      alias_method :size, :length
+
+      # compares two {XDM::AtomicValue}s using the underlying Saxon and XDM
+      # comparision rules
+      #
+      # @param other [Saxon::XDM::AtomicValue]
+      # @return [Boolean]
+      def ==(other)
+        return false unless other.is_a?(XDM::Array)
+        return false if length != other.length
+        cached_array == other.to_a
+      end
+
+      def to_a
+        cached_array
+      end
+
+      alias_method :eql?, :==
+
+      def hash
+        @hash ||= cached_array.hash
+      end
+
+      def to_java
+        s9_xdm_array
+      end
+
+      private
+
+      def cached_array
+        @cached_array ||= s9_xdm_array.asList.map { |s9_xdm_value| XDM.Value(s9_xdm_value) }.freeze
+      end
+    end
+  end
+end

data/lib/saxon/xdm/atomic_value.rb

@@ -0,0 +1,173 @@
+require_relative 'sequence_like'
+require_relative '../s9api'
+require_relative '../qname'
+require_relative '../item_type'
+
+module Saxon
+  module XDM
+    # An XPath Data Model Node object, representing an XML document, or an element
+    # or one of the other node chunks in the XDM.
+    class AtomicValue
+      include XDM::SequenceLike
+      include XDM::ItemSequenceLike
+
+      # Error thrown when an attempt to create QName-holding XDM::AtomicValue is
+      # made using anything other than a {Saxon::QName} or s9api.QName instance.
+      #
+      # QNames are dependent on the namespace URI, which isn't present in the
+      # lexical string you normally see (e.g. <tt>prefix:name</tt>). Prefixes are
+      # only bound to a URI in the context of a particular document, so creating
+      # them imlpicitly through the XDM::AtomicValue creation process doesn't really
+      # work. They need to be created explicitly and then handed in to be wrapped.
+      class CannotCreateQNameFromString < StandardError
+        def to_s
+          "QName XDM::AtomicValues must be created using an instance of Saxon::QName, not a string like 'prefix:name': Prefix URI binding is undefined at this point"
+        end
+      end
+
+      # xs:NOTATION is another QName-holding XDM type. Unlike xs:QName, there
+      # isn't a way to create these outside of parsing an XML document within
+      # Saxon, so attempting to do so raises this error.
+      class NotationCannotBeDirectlyCreated < StandardError
+        def to_s
+          "xs:NOTATION XDM::AtomicValues cannot be directly created outside of XML parsing."
+        end
+      end
+
+      XS_QNAME = ItemType.get_type('xs:QName')
+      XS_NOTATION = ItemType.get_type('xs:NOTATION')
+
+      class << self
+        # Convert a single Ruby value into an XDM::AtomicValue
+        #
+        # If no explicit {ItemType} is passed, the correct type is guessed based
+        # on the class of the value. (e.g. <tt>xs:date</tt> for {Date}.)
+        #
+        # Values are converted based on Ruby idioms and operations, so an explicit
+        # {ItemType} of <tt>xs:boolean</tt> will use truthyness to evaluate the
+        # value. This means that the Ruby string <tt>'false'</tt> will produce an
+        # <tt>xs:boolean</tt> whose value is <tt>true</tt>, because all strings
+        # are truthy. If you need to pass lexical strings unchanged, use
+        # {XDM::AtomicValue.from_lexical_string}.
+        #
+        # @param value [Object] the value to convert
+        #
+        # @param item_type [Saxon::ItemType, String] the value's type, as either
+        #   an {ItemType} or a name (<tt>xs:date</tt>)
+        #
+        # @return [Saxon::XDM::AtomicValue]
+        def create(value, item_type = nil)
+          case value
+          when Saxon::S9API::XdmAtomicValue
+            new(value)
+          when XDM::AtomicValue
+            value
+          else
+            return create_implying_item_type(value) if item_type.nil?
+
+            item_type = ItemType.get_type(item_type)
+
+            return new(Saxon::S9API::XdmAtomicValue.new(value.to_java)) if item_type == XS_QNAME && value_is_qname?(value)
+            raise NotationCannotBeDirectlyCreated if item_type == XS_NOTATION
+
+            value_lexical_string = item_type.lexical_string(value)
+            new(new_s9_xdm_atomic_value(value_lexical_string, item_type))
+          end
+        end
+
+        # convert a lexical string representation of an XDM Atomic Value into an
+        # XDM::AtomicValue.
+        #
+        # Note that this skips all conversion and checking of the string before
+        # handing it off to Saxon.
+        #
+        # @param value [String] the lexical string representation of the value
+        # @param item_type [Saxon::ItemType, String] the value's type, as either
+        #   an {ItemType} or a name (<tt>xs:date</tt>)
+        # @return [Saxon::XDM::AtomicValue]
+        def from_lexical_string(value, item_type)
+          item_type = ItemType.get_type(item_type)
+          raise CannotCreateQNameFromString if item_type == XS_QNAME
+          new(new_s9_xdm_atomic_value(value.to_s, item_type))
+        end
+
+        private
+
+        def new_s9_xdm_atomic_value(value, item_type)
+          Saxon::S9API::XdmAtomicValue.new(value.to_java, item_type.to_java)
+        end
+
+        def create_implying_item_type(value)
+          return new(Saxon::S9API::XdmAtomicValue.new(value.to_java)) if value_is_qname?(value)
+
+          item_type = ItemType.get_type(value.class)
+
+          new(new_s9_xdm_atomic_value(item_type.lexical_string(value), item_type))
+        end
+
+        def value_is_qname?(value)
+          QName === value || S9API::QName === value
+        end
+      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
+
+      # Return the value as a String. Like calling XPath's <tt>string()</tt>
+      # function.
+      #
+      # @return [String] The string representation of the value
+      def to_s
+        s9_xdm_atomic_value.toString
+      end
+
+      # @return [Saxon::ItemType] The ItemType of the value
+      def item_type
+        @item_type ||= Saxon::ItemType.get_type(Saxon::QName.resolve(s9_xdm_atomic_value.getTypeName))
+      end
+
+      # Return the value as an instance of the Ruby class that best represents the
+      # type of the value. Types with no sensible equivalent are returned as their
+      # lexical string form
+      #
+      # @return [Object] A Ruby object representation of the value
+      def to_ruby
+        @ruby_value ||= item_type.ruby_value(self).freeze
+      end
+
+      # compares two {XDM::AtomicValue}s using the underlying Saxon and XDM
+      # comparision rules
+      #
+      # @param other [Saxon::XDM::AtomicValue]
+      # @return [Boolean]
+      def ==(other)
+        return false unless other.is_a?(XDM::AtomicValue)
+        s9_xdm_atomic_value.equals(other.to_java)
+      end
+
+      alias_method :eql?, :==
+
+      def hash
+        @hash ||= s9_xdm_atomic_value.hashCode
+      end
+    end
+  end
+end

data/lib/saxon/xdm/empty_sequence.rb

@@ -0,0 +1,37 @@
+require_relative '../s9api'
+require_relative 'sequence_like'
+
+module Saxon
+  module XDM
+    # Represents the empty sequence in XDM
+    class EmptySequence
+      def self.create
+        @instance ||= new
+      end
+
+      include SequenceLike
+
+      def sequence_enum
+        [].to_enum
+      end
+
+      def sequence_size
+        0
+      end
+
+      def ==(other)
+        other.class == self.class
+      end
+
+      alias_method :eql?, :==
+
+      def hash
+        [].hash
+      end
+
+      def to_java
+        @s9_xdm_empty_sequence ||= Saxon::S9API::XdmEmptySequence.getInstance
+      end
+    end
+  end
+end

data/lib/saxon/xdm/external_object.rb

@@ -0,0 +1,21 @@
+require_relative '../s9api'
+require_relative 'sequence_like'
+
+module Saxon
+  module XDM
+    # Represents a Saxon XDM ExternalObject
+    class ExternalObject
+      include SequenceLike
+      include ItemSequenceLike
+
+      # @api private
+      def initialize(s9_xdm_external_object)
+        @s9_xdm_external_object = s9_xdm_external_object
+      end
+
+      def to_java
+        @s9_xdm_external_object
+      end
+    end
+  end
+end

data/lib/saxon/xdm/function_item.rb

@@ -0,0 +1,21 @@
+require_relative '../s9api'
+require_relative 'sequence_like'
+
+module Saxon
+  module XDM
+    # Represents an XDM Function Item
+    class FunctionItem
+      include SequenceLike
+      include ItemSequenceLike
+
+      # @api private
+      def initialize(s9_xdm_function_item)
+        @s9_xdm_function_item = s9_xdm_function_item
+      end
+
+      def to_java
+        @s9_xdm_function_item
+      end
+    end
+  end
+end

data/lib/saxon/xdm/item.rb

@@ -0,0 +1,32 @@
+module Saxon
+  module XDM
+    def self.Item(item)
+      case item
+      when Value, AtomicValue, Node, Array, Map, ExternalObject
+        item
+      when Saxon::S9API::XdmNode
+        Node.new(item)
+      when Saxon::S9API::XdmAtomicValue
+        AtomicValue.new(item)
+      when Saxon::S9API::XdmExternalObject
+        ExternalObject.new(item)
+      when Saxon::S9API::XdmArray
+        Array.new(item)
+      when Saxon::S9API::XdmMap
+        Map.new(item)
+      when Saxon::S9API::XdmValue
+        Value.new(item)
+      when ::Array
+        Array.create(item)
+      when ::Hash
+        Map.create(item)
+      else
+        if item.respond_to?(:each)
+          Array.create(item)
+        else
+          AtomicValue.create(item)
+        end
+      end
+    end
+  end
+end

data/lib/saxon/xdm/map.rb

@@ -0,0 +1,77 @@
+require_relative '../s9api'
+require_relative 'sequence_like'
+
+module Saxon
+  module XDM
+    # Represents an XDM Map
+    class Map
+      def self.create(hash)
+        case hash
+        when Saxon::S9API::XdmMap
+          new(hash)
+        else
+          new(S9API::XdmMap.new(Hash[
+            hash.map { |key, value|
+              [XDM.AtomicValue(key).to_java, XDM.Value(value).to_java]
+            }
+          ]))
+        end
+      end
+
+      include SequenceLike
+      include ItemSequenceLike
+      include Enumerable
+
+      attr_reader :s9_xdm_map
+      private :s9_xdm_map
+
+      # @api private
+      def initialize(s9_xdm_map)
+        @s9_xdm_map = s9_xdm_map
+      end
+
+      def ==(other)
+        return false unless other.is_a?(self.class)
+        to_h == other.to_h
+      end
+
+      def [](key)
+        cached_hash[XDM.AtomicValue(key)]
+      end
+
+      def fetch(key, *args, &block)
+        cached_hash.fetch(XDM.AtomicValue(key), *args, &block)
+      end
+
+      def each(&block)
+        cached_hash.each(&block)
+      end
+
+      def select(&block)
+        self.class.create(each.select(&block).to_h)
+      end
+
+      def reject(&block)
+        self.class.create(each.reject(&block).to_h)
+      end
+
+      def merge(other)
+        self.class.create(to_h.merge(other.to_h))
+      end
+
+      def to_java
+        @s9_xdm_map
+      end
+
+      def to_h
+        cached_hash
+      end
+
+      private
+
+      def cached_hash
+        @cached_hash ||= s9_xdm_map.entrySet.map { |entry| [XDM.AtomicValue(entry.getKey), XDM.Value(entry.getValue)] }.to_h.freeze
+      end
+    end
+  end
+end