saxon-rb 0.5.0-java → 0.7.3-java

data/lib/saxon/item_type/value_to_ruby.rb

@@ -8,6 +8,7 @@ module Saxon
       # Regexp patterns to assist in converting XDM typed values into Ruby
       # native types
       module Patterns
+        # @see https://www.w3.org/TR/xmlschema-2/#dateTime-lexical-representation
         DATE_TIME = /\A(-?[0-9]{4,})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2}(?:\.[0-9]+)?)(Z|[-+][0-9]{2}:[0-9]{2})?\z/
       end
 
@@ -54,34 +55,45 @@ module Saxon
       # A collection of Lambdas (or objects responding to +#call+) for
       # converting XDM typed values to native Ruby types.
       module Convertors
+        # @see https://www.w3.org/TR/xmlschema-2/#integer
         INTEGER = INT = SHORT = LONG = UNSIGNED_INT = UNSIGNED_SHORT = UNSIGNED_LONG = \
         POSITIVE_INTEGER = NON_POSITIVE_INTEGER = NEGATIVE_INTEGER = NON_NEGATIVE_INTEGER = ->(xdm_atomic_value) {
           xdm_atomic_value.to_java.getValue
         }
+        # @see https://www.w3.org/TR/xmlschema-2/#decimal
         DECIMAL = ->(xdm_atomic_value) {
           BigDecimal(xdm_atomic_value.to_s)
         }
+        # @see https://www.w3.org/TR/xmlschema-2/#float
         FLOAT = DOUBLE = ->(xdm_atomic_value) {
           xdm_atomic_value.to_java.getValue
         }
+        # @see https://www.w3.org/TR/xmlschema-2/#dateTime
         DATE_TIME = DATE_TIME_STAMP = ValueToRuby::DateTimeConvertor
+        # @see https://www.w3.org/TR/xmlschema-2/#boolean
         BOOLEAN = ->(xdm_atomic_value) {
           xdm_atomic_value.to_java.getValue
         }
+        # @see https://www.w3.org/TR/xmlschema-2/#NOTATION
+        # @see https://www.w3.org/TR/xmlschema-2/#QName
         NOTATION = QNAME = ->(xdm_atomic_value) {
           Saxon::QName.new(xdm_atomic_value.to_java.getQNameValue)
         }
+        # @see https://www.w3.org/TR/xmlschema-2/#base64Binary
         BASE64_BINARY = ->(xdm_atomic_value) {
           Base64.decode64(xdm_atomic_value.to_s)
         }
+        # @see https://www.w3.org/TR/xmlschema-2/#hexBinary
         HEX_BINARY = ->(xdm_atomic_value) {
           bytes = []
           xdm_atomic_value.to_s.scan(/../) { |x| bytes << x.hex.chr(Encoding::ASCII_8BIT) }
           bytes.join
         }
+        # @see https://www.w3.org/TR/xmlschema-2/#byte
         BYTE = ->(xdm_atomic_value) {
           [xdm_atomic_value.to_java.getLongValue].pack('c')
         }
+        # @see https://www.w3.org/TR/xmlschema-2/#unsignedByte
         UNSIGNED_BYTE = ->(xdm_atomic_value) {
           [xdm_atomic_value.to_java.getLongValue].pack('C')
         }

data/lib/saxon/loader.rb

@@ -19,6 +19,7 @@ module Saxon
         @path = path
       end
 
+      # returns an error message including the missing path
       def to_s
         "The path ('#{@path}') you supplied for the Saxon .jar files doesn't exist, sorry"
       end
@@ -31,65 +32,76 @@ module Saxon
         @path = path
       end
 
+      # returns an error message including the path looked in and jars we were looking for
       def to_s
         "One of saxon9he.jar, saxon9pe.jar, or saxon9ee.jar must be present in the path ('#{@path}') you supplied, sorry"
       end
     end
 
-    # @param saxon_home [String, Pathname] the path to the dir containing
-    #   Saxon's .jars. Defaults to the vendored Saxon HE
-    # @return [true, false] Returns true if Saxon had not been loaded and
-    #   is now, and false if Saxon was already loaded
-    def self.load!(saxon_home = nil)
-      return false if instance_variable_defined?(:@saxon_loaded) && @saxon_loaded
-      LOAD_SEMAPHORE.synchronize do
-        if Saxon::S9API.const_defined?(:Processor)
+    class << self
+      # Are the Saxon jars missing from the Classpath?
+      # @return [Boolean] true if the Jars are not on the Classpath
+      def jars_not_on_classpath?
+        begin
+          Java::net.sf.saxon.s9api.Processor
           false
-        else
-          if jars_not_on_classpath?
-            if saxon_home.nil?
-              require 'saxon-rb_jars'
-            else
-              saxon_home = Pathname.new(saxon_home)
-              raise NoJarsError, saxon_home unless saxon_home.directory?
-              jars = [main_jar(saxon_home)].compact
-              raise MissingJarError if jars.empty?
-              jars += extra_jars(saxon_home)
+        rescue
+          true
+        end
+      end
+
+      # Are the Saxon JARs on the Classpath?
+      # @return [Boolean] whether the Jars are on the Classpath already
+      def jars_on_classpath?
+        !jars_not_on_classpath?
+      end
+
+      # @param saxon_home [String, Pathname] the path to the dir containing
+      #   Saxon's .jars. Defaults to the vendored Saxon HE
+      # @return [true, false] Returns true if Saxon had not been loaded and
+      #   is now, and false if Saxon was already loaded
+      def load!(saxon_home = nil)
+        return false if instance_variable_defined?(:@saxon_loaded) && @saxon_loaded
+        LOAD_SEMAPHORE.synchronize do
+          if Saxon::S9API.const_defined?(:Processor)
+            false
+          else
+            if jars_not_on_classpath?
+              if saxon_home.nil?
+                require 'saxon-rb_jars'
+              else
+                saxon_home = Pathname.new(saxon_home)
+                raise NoJarsError, saxon_home unless saxon_home.directory?
+                jars = [main_jar(saxon_home)].compact
+                raise MissingJarError if jars.empty?
+                jars += extra_jars(saxon_home)
 
-              add_jars_to_classpath!(saxon_home, jars)
+                add_jars_to_classpath!(saxon_home, jars)
+              end
             end
-          end
 
-          @saxon_loaded = true
-          true
+            @saxon_loaded = true
+            true
+          end
         end
       end
-    end
 
-    private
-
-    def self.main_jar(path)
-      ['saxon9he.jar', 'saxon9pe.jar', 'saxon9ee.jar'].map { |jar| path.join(jar) }.find { |jar| jar.file? }
-    end
+      private
 
-    def self.extra_jars(path)
-      optional = ['saxon9-unpack.jar', 'saxon9-sql.jar'].map { |jar| path.join(jar) }.select { |jar| jar.file? }
-      icu = path.children.find { |jar| jar.extname == '.jar' && !jar.basename.to_s.match(/^saxon-icu|^icu4j/).nil? }
-      ([icu] + optional).compact
-    end
+      def main_jar(path)
+        ['saxon9he.jar', 'saxon9pe.jar', 'saxon9ee.jar'].map { |jar| path.join(jar) }.find { |jar| jar.file? }
+      end
 
-    def self.jars_not_on_classpath?
-      begin
-        Java::net.sf.saxon.s9api.Processor
-        false
-      rescue
-        true
+      def extra_jars(path)
+        optional = ['saxon9-unpack.jar', 'saxon9-sql.jar'].map { |jar| path.join(jar) }.select { |jar| jar.file? }
+        icu = path.children.find { |jar| jar.extname == '.jar' && !jar.basename.to_s.match(/^saxon-icu|^icu4j/).nil? }
+        ([icu] + optional).compact
       end
-    end
 
-    def self.add_jars_to_classpath!(saxon_home, jars)
-      jars.each do |jar|
-        $CLASSPATH << jar.to_s
+      def add_jars_to_classpath!(saxon_home, jars)
+        jars.each do |jar|
+          $CLASSPATH << jar.to_s
+        end
       end
     end
   end

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
@@ -45,12 +46,14 @@ module Saxon
       @s9_processor = s9_processor
     end
 
-    # Generate a new DocumentBuilder that uses this Processor.
-    # Sharing DocumentBuilders across threads is not recommended/
+    # Generate a new DocumentBuilder that uses this Processor. Sharing
+    # DocumentBuilders across threads is not safe.
     #
+    # @yield A DocumentBuilder configuration DSL block, see
+    #   {Saxon::DocumentBuilder.create}
     # @return [Saxon::DocumentBuilder] A new Saxon::DocumentBuilder
-    def document_builder
-      Saxon::DocumentBuilder.new(@s9_processor.newDocumentBuilder)
+    def document_builder(&block)
+      Saxon::DocumentBuilder.create(self, &block)
     end
 
     # Declare custom collations for use by XSLT, XPath, and XQuery processors
@@ -82,6 +85,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.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