saxon-rb 0.4.0-java → 0.7.2-java

data/lib/saxon/sequence_type.rb

@@ -0,0 +1,131 @@
+require_relative './item_type'
+require_relative './occurrence_indicator'
+
+module Saxon
+  # Represents a type definition for an XDM Sequence: an {ItemType} plus an
+  # {OccurrenceIndicator} as a restriction on the cardinality (length) of the
+  # sequence. Used most often to define variables in XPath or XSLT, plus in
+  # extension function definition.
+  class SequenceType
+    class << self
+      # Generate a {SequenceType} from a type declaration string (see
+      # {.from_type_decl}), or some combination of type name/Ruby class (see
+      # {ItemType.get_type}), and an {OccurrenceIndicator} or symbol referencing
+      # an OccurenceIndicator (one of +:zero_or_more+, +:one_or_more+,
+      # +:zero_or_one+, or +:one+)
+      #
+      # @return [Saxon::SequenceType] the resulting SequenceType
+      def create(type_name, occurrence_indicator = nil)
+        case type_name
+        when SequenceType
+          return type_name
+        when S9API::SequenceType
+          return new(type_name)
+        else
+          check_for_complete_decl!(type_name, occurrence_indicator)
+          return from_type_decl(type_name) if type_name.is_a?(String) && occurrence_indicator.nil?
+          item_type = ItemType.get_type(type_name)
+          occurrence_indicator = OccurrenceIndicator.get_indicator(occurrence_indicator)
+          new(item_type, occurrence_indicator)
+        end
+      end
+
+      # Generate a {SequenceType} from a declaration string following the rules
+      # of parameter and function +as=+ declarations in XSLT, like
+      # <tt><xsl:variable ... as="xs:string+"/></tt>
+      #
+      # @param type_decl [String] the declaration string
+      # @return [Saxon::SequenceType] the resulting SequenceType
+      def from_type_decl(type_decl)
+        occurence_char = type_decl[-1]
+        occurence = case occurence_char
+        when '?'
+          new(ItemType.get_type(type_decl[0..-2]), OccurrenceIndicator.zero_or_one)
+        when '+'
+          new(ItemType.get_type(type_decl[0..-2]), OccurrenceIndicator.one_or_more)
+        when '*'
+          new(ItemType.get_type(type_decl[0..-2]), OccurrenceIndicator.zero_or_more)
+        else
+          new(ItemType.get_type(type_decl), OccurrenceIndicator.one)
+        end
+      end
+
+      private
+
+      def check_for_complete_decl!(type_name, occurrence_indicator)
+        return true if occurrence_indicator.nil?
+        if type_name_is_complete_decl?(type_name)
+          raise ArgumentError, "Cannot pass a complete type declaration (#{type_name}) and an OccurrenceIndicator"
+        end
+      end
+
+      def type_name_is_complete_decl?(type_name)
+        !!(type_name.is_a?(String) && type_name.match(/[+*?]$/))
+      end
+    end
+
+    # @overload initialize(item_type, occurrence_indicator)
+    #   creates new instance using item type and occurrence indicator
+    #   @param item_type [Saxon::ItemType] the sequence's item type
+    #   @param occurrence_indicator [net.sf.saxon.s9api.OccurrenceIndicator] the
+    #     occurrence indicator (cardinality) of the sequence
+    # @overload initialize(s9_sequence_type)
+    #   create a new instance by wrapping one of Saxon's underlying Java
+    #   +SequenceType+s
+    #   @param s9_sequence_type [net.sf.saxon.s9api.SequenceType]
+    # @return [Saxon::SequenceType] the new SequenceType
+    def initialize(item_type, occurrence_indicator = nil)
+      if occurrence_indicator.nil? && !item_type.is_a?(S9API::SequenceType)
+        raise ArgumentError, "Expected a Java s9api.SequenceType when handed a single argument, but got a #{item_type.class}"
+      end
+
+      if occurrence_indicator.nil?
+        @s9_sequence_type = item_type
+      else
+        @item_type = item_type
+        @occurrence_indicator = occurrence_indicator
+      end
+    end
+
+    # @return [Saxon::ItemType] the type's ItemType
+    def item_type
+      @item_type ||= Saxon::ItemType.get_type(s9_sequence_type.getItemType)
+    end
+
+    # @return [net.sf.saxon.s9api.OccurrenceIndicator] the type's OccurrenceIndicator
+    def occurrence_indicator
+      @occurrence_indicator ||= s9_sequence_type.getOccurrenceIndicator
+    end
+
+    # @return [net.sf.saxon.s9api.SequenceType] the underlying Saxon SequenceType
+    def to_java
+      s9_sequence_type
+    end
+
+    # Compare equal with another SequenceType
+    # @param other [Saxon::SequenceType]
+    # @return [Boolean] the result of comparing +self+ and +other+
+    def ==(other)
+      return false if other.class != self.class
+      item_type == other.item_type && occurrence_indicator == other.occurrence_indicator
+    end
+    alias_method :eql?, :==
+
+    # Generated hash code for use as keys in Hashes
+    def hash
+      @hash ||= item_type.hash ^ occurrence_indicator.hash
+    end
+
+    private
+
+    def s9_sequence_type
+      @s9_sequence_type ||= S9API::SequenceType.makeSequenceType(item_type.to_java, occurrence_indicator.to_java)
+    end
+  end
+
+  # Convenience wrapper for {SequenceType.create}
+  # @see SequenceType.create
+  def self.SequenceType(*args)
+    SequenceType.create(*args)
+  end
+end

data/lib/saxon/serializer.rb

@@ -1,143 +1,9 @@
-require 'saxon/s9api'
-require 'stringio'
+require_relative './serializer/destination.rb'
+require_relative './serializer/object.rb'
 
 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
+  module Serializer
   end
 end
 

data/lib/saxon/serializer/destination.rb

@@ -0,0 +1,80 @@
+require_relative '../s9api'
+require_relative './output_properties'
+
+module Saxon
+  module Serializer
+    # A Saxon Serializer to be used as a Destination for a transformation rather
+    # than being directly called with existing XDM objects
+    class Destination
+      include OutputProperties
+
+      attr_reader :s9_serializer, :invocation_lambda
+
+      # @api private
+      def initialize(s9_serializer, invocation_lambda, &block)
+        @s9_serializer, @invocation_lambda = s9_serializer, invocation_lambda
+        if block_given?
+          instance_exec(&block)
+        end
+      end
+
+      # @overload serialize(io)
+      #   Serialize the transformation to an IO
+      #   @param [File, IO] io The IO to serialize to
+      #   @return [nil]
+      # @overload serialize(path)
+      #   Serialize the transformation to file <tt>path</tt>
+      #   @param [String, Pathname] path The path of the file to serialize to
+      #   @return [nil]
+      # @overload serialize
+      #   Serialize the transformation to a String
+      #   @return [String] The serialized XdmValue
+      def serialize(io_or_path = nil)
+        case io_or_path
+        when nil
+          serialize_to_string
+        when String, Pathname
+          serialize_to_file(io_or_path)
+        else
+          serialize_to_io(io_or_path)
+        end
+      end
+
+      # @return [Saxon::S9API::Serializer] The underlying Saxon Serializer object
+      def to_java
+        s9_serializer
+      end
+
+      private
+
+      def run_transform!
+        invocation_lambda.call(self.to_java)
+      end
+
+      def serialize_to_string
+        str_encoding = output_property.fetch(:encoding, Encoding.default_internal || Encoding.default_external)
+        StringIO.open { |io|
+          io.binmode
+          set_output_io(io)
+          run_transform!
+          io.string.force_encoding(str_encoding)
+        }
+      end
+
+      def serialize_to_io(io)
+        set_output_io(io)
+        run_transform!
+      end
+
+      def set_output_io(io)
+        s9_serializer.setOutputStream(io.to_outputstream)
+      end
+
+      def serialize_to_file(path)
+        file = Java::JavaIO::File.new(path.to_s)
+        s9_serializer.setOutputFile(file)
+        run_transform!
+      end
+    end
+  end
+end

data/lib/saxon/serializer/object.rb

@@ -0,0 +1,93 @@
+require_relative '../s9api'
+require_relative './output_properties'
+require 'stringio'
+
+module Saxon
+  module Serializer
+    # A Saxon Serializer to be used directly with XDM Values rather than being
+    # called as a Destination for a transformation.
+    class Object
+      # Create a serializer from the passed in +Processor+. When called with a
+      # block, the block will be executed via instance-exec so that output
+      # properties can be set, e.g.
+      #
+      #     Serializer::Object.create(processor) {
+      #       output_property[:indent] = 'yes'
+      #     }
+      #
+      # @param processor [Saxon::Processor] the processor to create this
+      #   +Serializer::Object+ from
+      # @yield the passed block bound via instance-exec to the new serializer
+      def self.create(processor, &block)
+        new(processor.to_java.newSerializer, &block)
+      end
+
+      include OutputProperties
+
+      attr_reader :s9_serializer
+      private :s9_serializer
+
+      # @api private
+      def initialize(s9_serializer, &block)
+        @s9_serializer = s9_serializer
+        if block_given?
+          instance_exec(&block)
+        end
+      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.to_s)
+        s9_serializer.setOutputFile(file)
+        s9_serializer.serializeXdmValue(xdm_value.to_java)
+        nil
+      end
+    end
+  end
+end