saxon-rb 0.5.0-java → 0.6.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cc90ab039f1169f43563e5036774ae66149c78c7b0027ea2b0cb72cafcd0b5e3
-  data.tar.gz: 18490756712240e5d3869d73dd788ae980178ef3b79ffb41330a8e7db80c1b47
+  metadata.gz: 2e9afbc5a2644034bc285b3c3cd4e78f852b715d7a096ff8f7a6386730501598
+  data.tar.gz: fe9c135af6356690fcca7b4f1dc2d9656cce44018806c3b5f6c9f4b6407c576d
 SHA512:
-  metadata.gz: d20fdd7e7b7fb7842d3d6059bb176903195fc911e46f4ffaecfa22d5dcc4e8919dadce8fe85feb5ab84045484d97f97ed3217330d77a4454a31c0b5efe1fc220
-  data.tar.gz: c39dd5d7fa31cf2e58cddc002f51d218543f38eb270c10e618105eb559c1467cd338ca68abe317d4574427ef2461c1f3112c7f0acf0e2dd9f9463c67992b8660
+  metadata.gz: c59e0f986b8bbf4de77b18feba99a61c8e724df537679b0e674bc142a0d2b476026bb01579dcd2ec6e9b4f246493db3b892fbe7e997848eb06bf5c7bd8e2f5ea
+  data.tar.gz: 182d383aced898a376d37eaedb60ff80461910d3451e119f2bf6e97ebe37d8c64e600563ba968efec22f49ae02f025ec3725f00a2cb9af10813af8e20fc13100

data/README.md

@@ -194,6 +194,47 @@ result = xslt.call_template('template-name', {
 
 Global and initial template parameters can be set at compiler creation time, compile time, or execution time. See [Setting parameters](#label-Setting+parameters) for details.
 
+To serialize the document you can, of course, just call `#to_s` on the result:
+
+```ruby
+result = xslt.apply_templates(input)
+puts result.to_s #=> '<?xml version="1.0"...'
+```
+
+You can also serialize directly to a file path or to any IO instance.
+
+```ruby
+result = xslt.apply_templates(input)
+result.serialize('/path/to/output.xml')
+
+result_2 = xslt.apply_templates(input)
+result_2.serialize($stderr)
+```
+
+You can override serialization options that were set by `<xsl:output/>` in your XSLT:
+
+```ruby
+result = xslt.apply_templates(input)
+result.serialize('/path/to/output.xml') {
+  output_property[:indent] = 'yes'
+}
+```
+
+You can also obtain the result of the transform as an XDM Value:
+
+```ruby
+result = xslt.apply_templates(input)
+result.xdm_value #=> #<Saxon::XDM::Node...>
+```
+
+You also have easy access to provide an instance of a class implementing Saxon's `net.sf.saxon.s9api.Destination` interface:
+
+```ruby
+dom_document = javax.xml.parsers.DocumentBuilderFactory.newInstance.builder.newDocument
+destination = Saxon::S9API::DOMDestination.new(dom_document)
+result = xslt.apply_templates(input).to_destination(destination)
+```
+
 #### Setting parameters
 
 There are four kinds of parameters you can set: *Static parameters*, which are

data/lib/saxon/nokogiri.rb

@@ -44,7 +44,7 @@ module Saxon
       # @return [String] a serialization of the the input document
       def serialize(doc_node)
         s9_transformer = @s9_xslt_executable.load30
-        serializer = Saxon::Serializer.new(s9_transformer.newSerializer)
+        serializer = Saxon::Serializer::Object.new(s9_transformer.newSerializer)
         serializer.serialize(doc_node.to_java)
       end
 

data/lib/saxon/processor.rb

@@ -4,6 +4,7 @@ require 'saxon/configuration'
 require 'saxon/document_builder'
 require 'saxon/xpath'
 require 'saxon/xslt'
+require 'saxon/serializer'
 
 module Saxon
   # Saxon::Processor wraps the S9API::Processor object. This is the object
@@ -82,6 +83,17 @@ module Saxon
       Saxon::XSLT::Compiler.create(self, &block)
     end
 
+    # Generate a new +Serializer+ for directly serializing XDM Values that uses
+    # this +Processor+. +Serializer+s are effectively one-shot objects, and
+    # shouldn't be reused.
+    #
+    # @yield the block passed will be called bound to the serializer instance. See
+    #   {Saxon::Serializer::Object.create}
+    # @return [Saxon::Serializer::Object]
+    def serializer(&block)
+      Saxon::Serializer::Object.create(self, &block)
+    end
+
     # @return [net.sf.saxon.s9api.Processor] The underlying Saxon processor
     def to_java
       @s9_processor

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

data/lib/saxon/serializer/output_properties.rb

@@ -0,0 +1,83 @@
+module Saxon
+  module 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 by +<xsl:output>+.
+    module OutputProperties
+      # @return [Saxon::Serializer::OutputProperties] hash-like access to the Output Properties
+      def output_property
+        @output_property ||= OutputProperties::Accessor.new(s9_serializer)
+      end
+
+      # @api private
+      #
+      # The private wrapper class that manages getting and setting output
+      # properties on a Serializer in an idiomatic Ruby-like way.
+      class Accessor
+        # @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
+    end
+  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/version.rb

@@ -1,3 +1,3 @@
 module Saxon
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end

data/lib/saxon/xdm/node.rb

@@ -33,9 +33,10 @@ module Saxon
         @node_name = node_name.nil? ? nil : Saxon::QName.new(node_name)
       end
 
-      # What kind of node this is. Returns one of +:element+, +:text+,
-      # +:attribute+, +:namespace+, +:comment+, +:processing_instruction+, or
-      # +:comment+
+      # What kind of node this is. Returns one of +:document+, +:element+,
+      # +:text+, +:attribute+, +:namespace+, +:comment+,
+      # +:processing_instruction+, or +:comment+
+      #
       # @return [Symbol] the kind of node this is
       def node_kind
         @node_kind ||= case s9_xdm_node.nodeKind

data/lib/saxon/xslt/executable.rb

@@ -1,5 +1,6 @@
 require 'forwardable'
 require_relative 'evaluation_context'
+require_relative 'invocation'
 require_relative '../serializer'
 require_relative '../xdm'
 require_relative '../qname'
@@ -96,7 +97,7 @@ module Saxon
       #   to pass to the first template matched. Setting already-defined
       #   parameters will replace their value for this invocation of the XSLT
       #   only, it won't affect the {XSLT::Compiler}'s context.
-      # @return [Saxon::XSLT::Result] the transformation result
+      # @return [Saxon::XSLT::Invocation] the transformation result
       def apply_templates(source, opts = {})
         transformation(opts).apply_templates(source)
       end
@@ -130,7 +131,7 @@ module Saxon
       #   to pass to the first template matched. Setting already-defined
       #   parameters will replace their value for this invocation of the XSLT
       #   only, it won't affect the {XSLT::Compiler}'s context.
-      # @return [Saxon::XSLT::Result] the transformation result
+      # @return [Saxon::XSLT::Invocation] the transformation result
       def call_template(template_name = nil, opts = {})
         transformation(opts).call_template(template_name)
       end
@@ -155,14 +156,14 @@ module Saxon
       #   Additional global parameters to set. Setting already-defined
       #   parameters will replace their value for this invocation of the XSLT
       #   only, it won't affect the {XSLT::Compiler}'s context.
-      # @return [Saxon::XSLT::Result] the transformation result
+      # @return [Saxon::XSLT::Invocation] the transformation result
       def call_function(function_name, opts = {})
         args = opts.fetch(:args, [])
         transformation(opts.reject { |k, v| k == :args }).call_function(function_name, args)
       end
 
       # @return [net.sf.saxon.s9api.XsltExecutable] the underlying Saxon
-      #   <tt>XsltExecutable</tt>
+      #   +XsltExecutable+
       def to_java
         @s9_xslt_executable
       end
@@ -213,6 +214,7 @@ module Saxon
         @default_initial_template ||= Saxon::QName.clark('{http://www.w3.org/1999/XSL/Transform}initial-template')
       end
 
+      # @api private
       def initialize(args)
         @s9_transformer = args.fetch(:s9_transformer)
         @destination = args.fetch(:destination, nil)
@@ -225,57 +227,48 @@ module Saxon
       # Apply templates to Source, using all the context set up when we were
       # created.
       def apply_templates(source)
-        transformation_result(:applyTemplates, source)
+        transformation_invocation(:applyTemplates, source.to_java)
       end
 
       # Call the named template, using all the context set up when we were
       # created.
       def call_template(template_name)
-        transformation_result(:callTemplate, resolve_template_name(template_name))
+        transformation_invocation(:callTemplate, resolve_template_name(template_name))
       end
 
       # Call the named function, using all the context set up when we were
       # created.
       def call_function(function_name, args)
         function_name = Saxon::QName.resolve(function_name).to_java
-        args = function_args(args)
-        call_function_result(function_name, args)
+        transformation_invocation(:callFunction, function_name, function_args(args))
       end
 
       private
 
-      def transformation_result(invocation_method, invocation_arg)
+      def transformation_invocation(invocation_method, *invocation_args)
         set_opts!
-        transformer_args = [invocation_method, invocation_arg.to_java, destination].compact
-        Result.new(result_xdm_value(s9_transformer.send(*transformer_args)), s9_transformer)
+        XSLT::Invocation.new(s9_transformer, invocation_lambda(invocation_method, invocation_args), raw?)
       end
 
-      def call_function_result(name, args)
-        set_opts!
-        Result.new(result_xdm_value(s9_transformer.callFunction(*[name, args, destination].compact)), s9_transformer)
-      end
-
-      def result_xdm_value(transformer_return_value)
-        XDM.Value(
-          transformer_return_value.nil? ? destination.getXdmNode : transformer_return_value
-        )
+      def invocation_lambda(invocation_method, invocation_args)
+        ->(destination) {
+          if destination.nil?
+            s9_transformer.send(invocation_method, *invocation_args)
+          else
+            s9_transformer.send(invocation_method, *invocation_args, destination.to_java)
+          end
+        }
       end
 
       def resolve_template_name(template_name)
-        return self.class.default_initial_template if template_name.nil?
-        Saxon::QName.resolve(template_name)
+        return self.class.default_initial_template.to_java if template_name.nil?
+        Saxon::QName.resolve(template_name).to_java
       end
 
       def function_args(args = [])
         args.map { |val| Saxon::XDM.Value(val).to_java }.to_java(S9API::XdmValue)
       end
 
-      def destination
-        @destination ||= begin
-          Saxon::S9API::XdmDestination.new unless raw?
-        end
-      end
-
       def set_opts!
         opts.each do |opt, value|
           raise BadOptionError, opt unless VALID_OPTS.include?(opt)
@@ -312,24 +305,6 @@ module Saxon
       end
     end
 
-    # Represents the result of a transformation, providing a simple default
-    # serializer as well
-    class Result
-      attr_reader :xdm_value
-
-      # @api private
-      def initialize(xdm_value, s9_transformer)
-        @xdm_value, @s9_transformer = xdm_value, s9_transformer
-      end
-
-      # Serialize the result to a string using the options specified in
-      # +<xsl:output/>+ in the XSLT
-      def to_s
-        serializer = Serializer.new(@s9_transformer.newSerializer)
-        serializer.serialize(xdm_value.to_java)
-      end
-    end
-
     # Raised if a bad option name is passed in the options hash to
     # Executable#apply_templates et al
     class BadOptionError < StandardError

data/lib/saxon/xslt/invocation.rb

@@ -0,0 +1,96 @@
+require_relative '../serializer'
+require_relative '../xdm/value'
+
+
+module Saxon
+  module XSLT
+    # Represents the invocation of a compiled and loaded transformation,
+    # providing an idiomatic way to send the result a transformation to a
+    # particular Destination, or to serialize it directly to a file, string, or
+    # IO.
+    class Invocation
+      attr_reader :s9_transformer, :invocation_lambda
+
+      # @api private
+      def initialize(s9_transformer, invocation_lambda, raw)
+        @s9_transformer, @invocation_lambda, @raw = s9_transformer, invocation_lambda, raw
+      end
+
+      # Serialize the result to a string using the options specified in
+      # +<xsl:output/>+ in the XSLT
+      #
+      # @return [String] the serialized result of the transformation
+      def to_s
+        serializer_destination.serialize
+      end
+
+      # Serialize the result of the transformation. When called with a
+      # block, the block will be executed via instance-exec so that output
+      # properties can be set, e.g.
+      #
+      #     result.serialize {
+      #       output_property[:indent] = 'yes'
+      #     }
+      #
+      # @overload serialize(io)
+      #   Serialize the transformation to an IO
+      #   @param [File, IO] io The IO to serialize to
+      #   @return [nil]
+      #   @yield the passed block bound via instance-exec to the new serializer
+      # @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]
+      #   @yield the passed block bound via instance-exec to the new serializer
+      # @overload serialize
+      #   Serialize the transformation to a String
+      #   @return [String] The serialized XdmValue
+      def serialize(path_or_io = nil, &block)
+        serializer_destination(&block).serialize(path_or_io)
+      end
+
+      # Return the result of the transformation as an XDM Value, either as it is
+      # returned (if the XSLT::Executable was created with :raw => true), or
+      # wrapped in a Document node and sequence normalized.
+      #
+      # @return [Saxon::XDM::Value] the XDM value returned by the transformation
+      def xdm_value
+        if raw?
+          XDM.Value(invocation_lambda.call(nil))
+        else
+          invocation_lambda.call(s9_xdm_destination)
+          XDM.Value(s9_xdm_destination.getXdmNode)
+        end
+      end
+
+      # Send the result of the transformation to the supplied Destination
+      #
+      # @param destination [net.sf.saxon.s9api.Destination] the Saxon
+      #   destination to use
+      # @return [nil]
+      def to_destination(s9_destination)
+        invocation_lambda.call(s9_destination)
+        nil
+      end
+
+      # Whether the transformation was invoked as a 'raw' transformation, where
+      # an XDM Value result will be returned without being wrapped in a Document
+      # node, and without sequence normalization.
+      #
+      # @return [Boolean] whether the transformation was invoked 'raw' or not
+      def raw?
+        @raw
+      end
+
+      private
+
+      def serializer_destination(&block)
+        Saxon::Serializer::Destination.new(s9_transformer.newSerializer, invocation_lambda, &block)
+      end
+
+      def s9_xdm_destination
+        @s9_xdm_destination ||= Saxon::S9API::XdmDestination.new
+      end
+    end
+  end
+end

data/saxon-rb.gemspec

@@ -34,6 +34,6 @@ It aims to provide an idiomatic Ruby wrapper around all of Saxon's features.}
   spec.add_development_dependency 'addressable', '~> 2.4.0'
   spec.add_development_dependency 'webmock', '~> 2.3.2'
   spec.add_development_dependency 'yard', '~> 0.9.12'
-  spec.add_development_dependency 'simplecov', '~> 0.15'
+  spec.add_development_dependency 'simplecov', '~> 0.17.1'
   spec.add_development_dependency 'rspec_junit_formatter'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: saxon-rb
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: java
 authors:
 - Matt Patterson
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-01-02 00:00:00.000000000 Z
+date: 2020-02-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -127,7 +127,7 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.15'
+        version: 0.17.1
   name: simplecov
   prerelease: false
   type: :development
@@ -135,7 +135,7 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.15'
+        version: 0.17.1
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
@@ -191,6 +191,9 @@ files:
 - lib/saxon/s9api.rb
 - lib/saxon/sequence_type.rb
 - lib/saxon/serializer.rb
+- lib/saxon/serializer/destination.rb
+- lib/saxon/serializer/object.rb
+- lib/saxon/serializer/output_properties.rb
 - lib/saxon/source.rb
 - lib/saxon/version.rb
 - lib/saxon/xdm.rb
@@ -213,6 +216,7 @@ files:
 - lib/saxon/xslt/compiler.rb
 - lib/saxon/xslt/evaluation_context.rb
 - lib/saxon/xslt/executable.rb
+- lib/saxon/xslt/invocation.rb
 - saxon-rb.gemspec
 homepage: https://github.com/fidothe/saxon-rb
 licenses: