saxon-rb 0.7.0-java → 0.8.1-java

data/.rspec-jar-loading

@@ -0,0 +1,2 @@
+--format progress
+--color

data/.ruby-version

@@ -1 +1 @@
-jruby-9.2.9.0
+jruby-9.2.13.0

data/Rakefile

@@ -25,7 +25,7 @@ task :circleci do
       end
     end
     def jruby_image_tags
-      %w{9.2.9.0 9.1.17.0 9.2.10.0-SNAPSHOT-latest}
+      %w{9.2.9.0 9.1.17.0 9.2.10.0 9.2.11.1 9.2.12.0 9.2.13.0-SNAPSHOT-latest}
     end
 
     def jdk_image_tags
@@ -51,7 +51,7 @@ task :circleci do
 
     def codeclimate_jobs
       (alt_saxon_urls.keys << nil).map { |alt_saxon_url|
-        ["9.2.9.0", "8-jdk-slim", alt_saxon_url]
+        ["9.2.12.0", "8-jdk-slim", alt_saxon_url]
       }
     end
 
@@ -190,12 +190,18 @@ task :circleci do
     def run_tests_step(opts)
       command = [
         "mkdir -p /tmp/test-results",
-        "bundle exec rspec spec --profile 10 --format RspecJunitFormatter --out /tmp/test-results/rspec.xml --format progress"
+        "VERIFY_SAXON_LAZY_LOADING=1 bundle exec rspec spec/jar_loading_spec.rb --options .rspec-jar-loading --profile 10 --format RspecJunitFormatter --out /tmp/test-results/rspec-jar-loading.xml"
       ]
       if opts.fetch(:run_codeclimate)
         command.prepend("./cc-test-reporter before-build")
-        command.append("if [ $? -eq 0 ]; then ./cc-test-reporter format-coverage -t simplecov -o \"cc-coverage#{"-alt-saxon" if opts.fetch(:alt_saxon_url)}.json\"; fi")
+        command.append("if [ $? -eq 0 ]; then ./cc-test-reporter format-coverage -t simplecov -o \"cc-coverage-jar-loading#{"-alt-saxon" if opts.fetch(:alt_saxon_url)}.json\"; fi")
       end
+      command.append("rm -rf coverage")
+      command.append("bundle exec rspec spec --profile 10 --format RspecJunitFormatter --out /tmp/test-results/rspec.xml --format progress")
+      if opts.fetch(:run_codeclimate)
+        command.append("if [ $? -eq 0 ]; then ./cc-test-reporter format-coverage -t simplecov -o \"cc-coverage-main#{"-alt-saxon" if opts.fetch(:alt_saxon_url)}.json\"; fi")
+      end
+
       {
         "run" => {
           "name" => "Run the tests" + (opts.fetch(:run_codeclimate) ? ", and upload coverage data to Code Climate" : ""),

data/lib/saxon-rb.rb

@@ -1 +1 @@
-require_relative 'saxon'
+require 'saxon'

data/lib/saxon/item_type.rb

@@ -6,8 +6,49 @@ require_relative 'item_type/value_to_ruby'
 module Saxon
   # Represent XDM types abstractly
   class ItemType
-    # Error raised when a Ruby class has no equivalent XDM type to be converted
-    # into
+    # lazy-loading Hash so we can avoid eager-loading saxon Jars, which prevents
+    # using external Saxon Jars unless the user is more careful than they should
+    # have to be.
+    class LazyReadOnlyHash
+      include Enumerable
+
+      attr_reader :loaded_hash, :load_mutex, :init_block
+      private :loaded_hash, :load_mutex, :init_block
+
+      def initialize(&init_block)
+        @init_block = init_block
+        @load_mutex = Mutex.new
+        @loaded_hash = nil
+      end
+
+      def [](key)
+        ensure_loaded!
+        loaded_hash[key]
+      end
+
+      def fetch(*args, &block)
+        ensure_loaded!
+        loaded_hash.fetch(*args, &block)
+      end
+
+      def each(&block)
+        ensure_loaded!
+        loaded_hash.each(&block)
+      end
+
+      private
+
+      def ensure_loaded!
+        return true unless loaded_hash.nil?
+        load_mutex.synchronize do
+          return true unless loaded_hash.nil?
+          @loaded_hash = init_block.call
+        end
+      end
+    end
+
+    # Error raised when a Ruby class has no equivalent XDM type to
+    # be converted into
     class UnmappedRubyTypeError < StandardError
       def initialize(class_name)
         @class_name = class_name
@@ -54,85 +95,89 @@ module Saxon
     }.freeze
 
     # A mapping of QNames to XDM type constants
-    QNAME_MAPPING = Hash[{
-      'anyAtomicType' => :ANY_ATOMIC_VALUE,
-      'anyURI' => :ANY_URI,
-      'base64Binary' => :BASE64_BINARY,
-      'boolean' => :BOOLEAN,
-      'byte' => :BYTE,
-      'date' => :DATE,
-      'dateTime' => :DATE_TIME,
-      'dateTimeStamp' => :DATE_TIME_STAMP,
-      'dayTimeDuration' => :DAY_TIME_DURATION,
-      'decimal' => :DECIMAL,
-      'double' => :DOUBLE,
-      'duration' => :DURATION,
-      'ENTITY' => :ENTITY,
-      'float' => :FLOAT,
-      'gDay' => :G_DAY,
-      'gMonth' => :G_MONTH,
-      'gMonthDay' => :G_MONTH_DAY,
-      'gYear' => :G_YEAR,
-      'gYearMonth' => :G_YEAR_MONTH,
-      'hexBinary' => :HEX_BINARY,
-      'ID' => :ID,
-      'IDREF' => :IDREF,
-      'int' => :INT,
-      'integer' => :INTEGER,
-      'language' => :LANGUAGE,
-      'long' => :LONG,
-      'Name' => :NAME,
-      'NCName' => :NCNAME,
-      'negativeInteger' => :NEGATIVE_INTEGER,
-      'NMTOKEN' => :NMTOKEN,
-      'nonNegativeInteger' => :NON_NEGATIVE_INTEGER,
-      'nonPositiveInteger' => :NON_POSITIVE_INTEGER,
-      'normalizedString' => :NORMALIZED_STRING,
-      'NOTATION' => :NOTATION,
-      'numeric' => :NUMERIC,
-      'positiveInteger' => :POSITIVE_INTEGER,
-      'QName' => :QNAME,
-      'short' => :SHORT,
-      'string' => :STRING,
-      'time' => :TIME,
-      'token' => :TOKEN,
-      'unsignedByte' => :UNSIGNED_BYTE,
-      'unsignedInt' => :UNSIGNED_INT,
-      'unsignedLong' => :UNSIGNED_LONG,
-      'unsignedShort' => :UNSIGNED_SHORT,
-      'untypedAtomic' => :UNTYPED_ATOMIC,
-      'yearMonthDuration' => :YEAR_MONTH_DURATION
-    }.map { |local_name, constant|
-      qname = Saxon::QName.create({
-        prefix: 'xs', uri: 'http://www.w3.org/2001/XMLSchema',
-        local_name: local_name
-      })
-      [qname, constant]
-    }].freeze
+    QNAME_MAPPING = LazyReadOnlyHash.new do
+      {
+        'anyAtomicType' => :ANY_ATOMIC_VALUE,
+        'anyURI' => :ANY_URI,
+        'base64Binary' => :BASE64_BINARY,
+        'boolean' => :BOOLEAN,
+        'byte' => :BYTE,
+        'date' => :DATE,
+        'dateTime' => :DATE_TIME,
+        'dateTimeStamp' => :DATE_TIME_STAMP,
+        'dayTimeDuration' => :DAY_TIME_DURATION,
+        'decimal' => :DECIMAL,
+        'double' => :DOUBLE,
+        'duration' => :DURATION,
+        'ENTITY' => :ENTITY,
+        'float' => :FLOAT,
+        'gDay' => :G_DAY,
+        'gMonth' => :G_MONTH,
+        'gMonthDay' => :G_MONTH_DAY,
+        'gYear' => :G_YEAR,
+        'gYearMonth' => :G_YEAR_MONTH,
+        'hexBinary' => :HEX_BINARY,
+        'ID' => :ID,
+        'IDREF' => :IDREF,
+        'int' => :INT,
+        'integer' => :INTEGER,
+        'language' => :LANGUAGE,
+        'long' => :LONG,
+        'Name' => :NAME,
+        'NCName' => :NCNAME,
+        'negativeInteger' => :NEGATIVE_INTEGER,
+        'NMTOKEN' => :NMTOKEN,
+        'nonNegativeInteger' => :NON_NEGATIVE_INTEGER,
+        'nonPositiveInteger' => :NON_POSITIVE_INTEGER,
+        'normalizedString' => :NORMALIZED_STRING,
+        'NOTATION' => :NOTATION,
+        'numeric' => :NUMERIC,
+        'positiveInteger' => :POSITIVE_INTEGER,
+        'QName' => :QNAME,
+        'short' => :SHORT,
+        'string' => :STRING,
+        'time' => :TIME,
+        'token' => :TOKEN,
+        'unsignedByte' => :UNSIGNED_BYTE,
+        'unsignedInt' => :UNSIGNED_INT,
+        'unsignedLong' => :UNSIGNED_LONG,
+        'unsignedShort' => :UNSIGNED_SHORT,
+        'untypedAtomic' => :UNTYPED_ATOMIC,
+        'yearMonthDuration' => :YEAR_MONTH_DURATION
+      }.map { |local_name, constant|
+        qname = Saxon::QName.create({
+          prefix: 'xs', uri: 'http://www.w3.org/2001/XMLSchema',
+          local_name: local_name
+        })
+        [qname, constant]
+      }.to_h.freeze
+    end
 
     # A mapping of type names/QNames to XDM type constants
-    STR_MAPPING = {
-      'array(*)' => :ANY_ARRAY,
-      'item()' => :ANY_ITEM,
-      'map(*)' => :ANY_MAP,
-      'node()' => :ANY_NODE
-    }.merge(
-      Hash[QNAME_MAPPING.map { |qname, v| [qname.to_s, v] }]
-    ).freeze
+    STR_MAPPING = LazyReadOnlyHash.new do
+      {
+        'array(*)' => :ANY_ARRAY,
+        'item()' => :ANY_ITEM,
+        'map(*)' => :ANY_MAP,
+        'node()' => :ANY_NODE
+      }.merge(
+        Hash[QNAME_MAPPING.map { |qname, v| [qname.to_s, v] }]
+      ).freeze
+    end
 
     # convertors to generate lexical strings for a given {ItemType}, as a hash keyed on the ItemType
-    ATOMIC_VALUE_LEXICAL_STRING_CONVERTORS = Hash[
+    ATOMIC_VALUE_LEXICAL_STRING_CONVERTORS = LazyReadOnlyHash.new do
       LexicalStringConversion::Convertors.constants.map { |const|
         [S9API::ItemType.const_get(const), LexicalStringConversion::Convertors.const_get(const)]
-      }
-    ].freeze
+      }.to_h.freeze
+    end
 
     # convertors from {XDM::AtomicValue} to a ruby primitve value, as a hash keyed on the ItemType
-    ATOMIC_VALUE_TO_RUBY_CONVERTORS = Hash[
+    ATOMIC_VALUE_TO_RUBY_CONVERTORS = LazyReadOnlyHash.new do
       ValueToRuby::Convertors.constants.map { |const|
         [S9API::ItemType.const_get(const), ValueToRuby::Convertors.const_get(const)]
-      }
-    ].freeze
+      }.to_h.freeze
+    end
 
     class << self
       # Get an appropriate {ItemType} for a Ruby type or given a type name as a

data/lib/saxon/jruby_bug_6197_workaround.rb

@@ -0,0 +1,5 @@
+unless Java::net::sf::saxon::s9api::Xslt30Transformer.instance_methods.include?(:setInitialMode)
+  class Java::net::sf::saxon::s9api::Xslt30Transformer
+    java_alias :setInitialMode, :setInitialMode, [Java::net::sf::saxon::s9api::QName]
+  end
+end

data/lib/saxon/loader.rb

@@ -38,60 +38,71 @@ module Saxon
       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
+            require_relative 'jruby_bug_6197_workaround'
+            @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/s9api.rb

@@ -11,28 +11,28 @@ module Saxon
       # alternate location for them, if they don't want to use the bundled Saxon
       # HE
       def const_missing(name)
-        Saxon::Loader.load!
-        begin
-          const_set(name, imported_classes.const_get(name))
-        rescue NameError
-          msg = "uninitialized constant Saxon::S9API::#{name}"
-          e = NameError.new(msg, name)
-          raise e
-        end
+        CLASS_IMPORT_SEMAPHORE.synchronize {
+          return const_get(name) if const_defined?(name)
+          Saxon::Loader.load!
+          begin
+            const_set(name, imported_classes.const_get(name))
+          rescue NameError
+            msg = "uninitialized constant Saxon::S9API::#{name}"
+            e = NameError.new(msg, name)
+            raise e
+          end
+        }
       end
 
       private
 
       def imported_classes
-        return @imported_classes if instance_variable_defined?(:@imported_classes)
-        CLASS_IMPORT_SEMAPHORE.synchronize do
-          @imported_classes = Module.new {
-            include_package 'net.sf.saxon.s9api'
-            java_import Java::net.sf.saxon.Configuration
-            java_import Java::net.sf.saxon.lib.FeatureKeys
-            java_import Java::net.sf.saxon.lib.ParseOptions
-          }
-        end
+        @imported_classes ||= Module.new {
+          include_package 'net.sf.saxon.s9api'
+          java_import Java::net.sf.saxon.Configuration
+          java_import Java::net.sf.saxon.lib.FeatureKeys
+          java_import Java::net.sf.saxon.lib.ParseOptions
+        }
       end
     end
   end

data/lib/saxon/version.rb

@@ -1,9 +1,9 @@
-require 'saxon/s9api'
+require 'saxon/version/library'
 
 module Saxon
   # Provides the saxon-rb and underlying Saxon library versions
   module Version
     # The version of the saxon-rb gem (not of Saxon itself)
-    WRAPPER = "0.7.0"
+    WRAPPER = "0.8.1"
   end
 end

data/lib/saxon/xdm/atomic_value.rb

@@ -36,12 +36,17 @@ module Saxon
         end
       end
 
-      # ItemType representing QNames
-      XS_QNAME = ItemType.get_type('xs:QName')
-      # ItemType representing NOTATION
-      XS_NOTATION = ItemType.get_type('xs:NOTATION')
-
       class << self
+        # ItemType representing QNames
+        def xs_qname
+          @xs_qname ||= ItemType.get_type('xs:QName')
+        end
+
+        # ItemType representing NOTATION
+        def xs_notation
+          @xs_notation ||= ItemType.get_type('xs:NOTATION')
+        end
+
         # Convert a single Ruby value into an XDM::AtomicValue
         #
         # If no explicit {ItemType} is passed, the correct type is guessed based
@@ -71,8 +76,8 @@ module Saxon
 
             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
+            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))
@@ -91,7 +96,7 @@ module Saxon
         # @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
+          raise CannotCreateQNameFromString if item_type == xs_qname
           new(new_s9_xdm_atomic_value(value.to_s, item_type))
         end