saxon-rb 0.4.0-java

data/lib/saxon/item_type/value_to_ruby.rb

@@ -0,0 +1,78 @@
+require 'bigdecimal'
+
+module Saxon
+  class ItemType
+    # A collection of lamba-like objects for converting XDM::AtomicValues into
+    # appropriate Ruby values
+    module ValueToRuby
+      module Patterns
+        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
+
+      class DateTimeConvertor
+        def self.call(xdm_atomic_value)
+          new(xdm_atomic_value).convert
+        end
+
+        attr_reader :timestring, :match
+
+        def initialize(xdm_atomic_value)
+          @timestring = xdm_atomic_value.to_s
+          @match = ValueToRuby::Patterns::DATE_TIME.match(@timestring)
+        end
+
+        def convert
+          return timestring if match.nil?
+          Time.new(*integer_parts, decimal_part, tz_part)
+        end
+
+        def integer_parts
+          match[1..5].map { |n| Integer(n, 10) }
+        end
+
+        def decimal_part
+          Float(match[6])
+        end
+
+        def tz_part
+          tz_string = match[7]
+          tz_string == 'Z' ? '+00:00' : tz_string
+        end
+      end
+
+      module Convertors
+        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
+        }
+        DECIMAL = ->(xdm_atomic_value) {
+          BigDecimal(xdm_atomic_value.to_s)
+        }
+        FLOAT = DOUBLE = ->(xdm_atomic_value) {
+          xdm_atomic_value.to_java.getValue
+        }
+        DATE_TIME = DATE_TIME_STAMP = ValueToRuby::DateTimeConvertor
+        BOOLEAN = ->(xdm_atomic_value) {
+          xdm_atomic_value.to_java.getValue
+        }
+        NOTATION = QNAME = ->(xdm_atomic_value) {
+          Saxon::QName.new(xdm_atomic_value.to_java.getQNameValue)
+        }
+        BASE64_BINARY = ->(xdm_atomic_value) {
+          Base64.decode64(xdm_atomic_value.to_s)
+        }
+        HEX_BINARY = ->(xdm_atomic_value) {
+          bytes = []
+          xdm_atomic_value.to_s.scan(/../) { |x| bytes << x.hex.chr(Encoding::ASCII_8BIT) }
+          bytes.join
+        }
+        BYTE = ->(xdm_atomic_value) {
+          [xdm_atomic_value.to_java.getLongValue].pack('c')
+        }
+        UNSIGNED_BYTE = ->(xdm_atomic_value) {
+          [xdm_atomic_value.to_java.getLongValue].pack('C')
+        }
+      end
+    end
+  end
+end

data/lib/saxon/jaxp.rb

@@ -0,0 +1,8 @@
+require 'java'
+
+module Saxon
+  # an easy-to-access place to keep JAXP-related Java classes
+  module JAXP
+    include_package 'javax.xml.transform.stream'
+  end
+end

data/lib/saxon/loader.rb

@@ -0,0 +1,93 @@
+require 'pathname'
+require 'java'
+
+module Saxon
+  # A sensible namespace to put Saxon Java classes into
+  module S9API
+  end
+
+  module Loader
+    LOAD_SEMAPHORE = Mutex.new
+
+    # Error raised if Saxon::Loader.load! is called but the path handed
+    # in does not exist or is not a directory
+    class NoJarsError < StandardError
+      def initialize(path)
+        @path = path
+      end
+
+      def to_s
+        "The path ('#{@path}') you supplied for the Saxon .jar files doesn't exist, sorry"
+      end
+    end
+
+    # Error raised if Saxon::Loader.load! is called but the path handed
+    # in does not contain the Saxon .jars
+    class MissingJarError < StandardError
+      def initialize(path)
+        @path = path
+      end
+
+      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)
+          false
+        else
+          if jars_not_on_classpath?
+            if saxon_home.nil?
+              require 'saxon_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)
+            end
+          end
+
+          @saxon_loaded = true
+          true
+        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
+
+    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 self.jars_not_on_classpath?
+      begin
+        Java::net.sf.saxon.s9api.Processor
+        false
+      rescue
+        true
+      end
+    end
+
+    def self.add_jars_to_classpath!(saxon_home, jars)
+      jars.each do |jar|
+        $CLASSPATH << jar.to_s
+      end
+    end
+  end
+end

data/lib/saxon/occurrence_indicator.rb

@@ -0,0 +1,33 @@
+require_relative 's9api'
+
+module Saxon
+  # Provides simple access to Saxon's OccurrenceIndicator constants,
+  # for use in declaring variable types
+  module OccurrenceIndicator
+    class << self
+      def one
+        @one ||= Saxon::S9API::OccurrenceIndicator::ONE
+      end
+
+      def one_or_more
+        @one_or_more ||= Saxon::S9API::OccurrenceIndicator::ONE_OR_MORE
+      end
+
+      def zero
+        @zero ||= Saxon::S9API::OccurrenceIndicator::ZERO
+      end
+
+      def zero_or_more
+        @zero_or_more ||= Saxon::S9API::OccurrenceIndicator::ZERO_OR_MORE
+      end
+
+      def zero_or_one
+        @zero_or_one ||= Saxon::S9API::OccurrenceIndicator::ZERO_OR_ONE
+      end
+
+      def indicator_names
+        @indicator_names ||= (public_methods(false) - Object.public_methods - [:indicator_names])
+      end
+    end
+  end
+end

data/lib/saxon/parse_options.rb

@@ -0,0 +1,127 @@
+require 'saxon/s9api'
+
+module Saxon
+  # Wraps the <tt>net.sf.saxon.lib.ParseOptions</tt> class, which holds default
+  # options to be passed to the parser
+  class ParseOptions
+    attr_reader :parse_options
+    private :parse_options
+
+    # @api private
+    # @param parse_options [net.sf.saxon.lib.ParseOptions, nil] The Saxon
+    #   ParseOptions instance to wrap
+    def initialize(parse_options = nil)
+      @parse_options = parse_options || Saxon::S9API::ParseOptions.new
+    end
+
+    # Provide hash-like access to SAX parser properties
+    # @return [Saxon::ParseOptions::ParserProperties] the properties object
+    def properties
+      @properties ||= ParserProperties.new(parse_options)
+    end
+
+    # Provide hash-like access to SAX parser features
+    # @return [Saxon::ParseOptions::ParserFeatures] the features object
+    def features
+      @features ||= ParserFeatures.new(parse_options)
+    end
+  end
+
+  # Provides idiomatic access to parser properties
+  class ParserProperties
+    include Enumerable
+
+    attr_reader :parse_options
+    private :parse_options
+
+    # @api private
+    # @param [Saxon::ParseOptions] parse_options The ParseOptions object this
+    #   belongs to
+    def initialize(parse_options)
+      @parse_options ||= parse_options
+    end
+
+    # @return [Hash] the currently-set properties as a (frozen) hash
+    def to_h
+      (parse_options.getParserProperties || {}).freeze
+    end
+
+    # Fetch the current value of a Parser Property
+    #
+    # @param [String, URI] uri The Parser Property URI to fetch
+    # @return [Object] The current value of the property
+    def [](uri)
+      return nil if parse_options.getParserProperties.nil?
+      parse_options.getParserProperty(uri)
+    end
+
+    # Set the value of a Parser Property
+    #
+    # @param [String, URI] uri The Parser Property URI to set
+    # @param [Object] value The value to set the property to
+    # @return [Object] The new value of the property
+    def []=(uri, value)
+      parse_options.addParserProperties(uri, value)
+      self[uri]
+    end
+
+    # Iterate across each currently-set property, in the same way as a hash
+    #
+    # @yield [uri, value]
+    # @yieldparam uri [String] The URI of the property as a String
+    # @yieldparam value [Object] The value of the property
+    def each(&block)
+      to_h.each(&block)
+    end
+  end
+
+  # Provides idiomatic access to parser properties
+  class ParserFeatures
+    include Enumerable
+
+    attr_reader :parse_options
+    private :parse_options
+
+    # @api private
+    # @param [Saxon::ParseOptions] parse_options The ParseOptions object this
+    #   belongs to
+    def initialize(parse_options)
+      @parse_options ||= parse_options
+    end
+
+    # @return [Hash] the currently-set features as a (frozen) hash
+    def to_h
+      (parse_options.getParserFeatures || {}).freeze
+    end
+
+    # Fetch the current value of a Parser Feature
+    #
+    # @param [String, URI] uri The Parser Feature URI to fetch
+    # @return [Boolean, nil] The current value of the feature, or nil if it's
+    #   unset
+    def [](uri)
+      pf = parse_options.getParserFeatures
+      return nil if pf.nil? || !pf.include?(uri)
+      parse_options.getParserFeature(uri)
+    end
+
+    # Set the value of a Parser Feature
+    #
+    # @param [String, URI] uri The Parser Property URI to set
+    # @param [Boolean] value The value to set the property to
+    # @return [Boolean] The new value of the property
+    def []=(uri, value)
+      parse_options.addParserFeature(uri, value)
+      self[uri]
+    end
+
+    # Iterate across each currently-set feature, in the same way as a hash
+    #
+    # @yield [uri, value]
+    # @yieldparam uri [String] The URI of the feature as a String
+    # @yieldparam value [Boolean] Whether the feature is on or off
+    def each(&block)
+      to_h.each(&block)
+    end
+  end
+end

data/lib/saxon/processor.rb

@@ -0,0 +1,102 @@
+require 'saxon/s9api'
+require 'saxon/source'
+require 'saxon/configuration'
+require 'saxon/document_builder'
+require 'saxon/xpath'
+require 'saxon/xslt'
+
+module Saxon
+  # Saxon::Processor wraps the S9API::Processor object. This is the object
+  # responsible for creating an XSLT compiler or an XML Document object.
+  #
+  # The Processor is threadsafe, and can be shared between threads. But, most
+  # importantly XSLT or XML objects created by a Processor can only be used
+  # with other XSLT or XML objects created by the same Processor instance.
+  class Processor
+    # Provides a processor with default configuration. Essentially a singleton
+    # instance
+    # @return [Saxon::Processor]
+    def self.default
+      @processor ||= create(Saxon::Configuration.default)
+    end
+
+    # @param config [File, String, IO, Saxon::Configuration] an open File, or string,
+    #   containing a Saxon configuration file; an existing Saxon::Configuration
+    #   object
+    # @return [Saxon::Processor]
+    def self.create(config = nil)
+      Saxon::Loader.load!
+      case config
+      when nil
+        licensed_or_config_source = false
+      when Saxon::Configuration
+        licensed_or_config_source = config.to_java
+      else
+        licensed_or_config_source = Saxon::Source.create(config).to_java
+      end
+      s9_processor = S9API::Processor.new(licensed_or_config_source)
+      new(s9_processor)
+    end
+
+    # @api private
+    # @param [net.sf.saxon.s9api.Processor] s9_processor The Saxon Processor
+    #   instance to wrap
+    def initialize(s9_processor)
+      @s9_processor = s9_processor
+    end
+
+    # Generate a new DocumentBuilder that uses this Processor.
+    # Sharing DocumentBuilders across threads is not recommended/
+    #
+    # @return [Saxon::DocumentBuilder] A new Saxon::DocumentBuilder
+    def document_builder
+      Saxon::DocumentBuilder.new(@s9_processor.newDocumentBuilder)
+    end
+
+    # Declare custom collations for use by XSLT, XPath, and XQuery processors
+    #
+    # @param collations [Hash<String => java.text.Collator>] collations to
+    #   declare, as a hash of URI => Collator
+    def declare_collations(collations)
+      collations.each do |uri, collation|
+        @s9_processor.declareCollation(uri, collation)
+      end
+    end
+    # Generate a new <tt>XPath::Compiler</tt> that uses this
+    # <tt>Processor</tt>. Sharing <tt>XPath::Compiler</tt>s across threads is
+    # fine as long as the static context is not changed.
+    #
+    # @yield An XPath compiler DSL block, see {Saxon::XPath::Compiler.create}
+    # @return [Saxon::XPath::Compiler] a new XPath compiler
+    def xpath_compiler(&block)
+      Saxon::XPath::Compiler.create(self, &block)
+    end
+
+    # Generate a new <tt>XSLT::Compiler</tt> that uses this
+    # <tt>Processor</tt>. Sharing <tt>XSLT::Compiler</tt>s across threads is
+    # fine as long as the static context is not changed.
+    #
+    # @yield An XPath compiler DSL block, see {Saxon::XSLT::Compiler.create}
+    # @return [Saxon::XSLT::Compiler] a new XSLT compiler
+    def xslt_compiler(&block)
+      Saxon::XSLT::Compiler.create(self, &block)
+    end
+
+    # @return [net.sf.saxon.s9api.Processor] The underlying Saxon processor
+    def to_java
+      @s9_processor
+    end
+
+    # compare equal if the underlying java processor is the same instance for
+    # self and other
+    # @param other object to compare against
+    def ==(other)
+      other.to_java === to_java
+    end
+
+    # @return [Saxon::Configuration] This processor's configuration instance
+    def config
+      @config ||= Saxon::Configuration.create(self)
+    end
+  end
+end