saxon 0.2.2-java → 0.4.0-java

data/Rakefile

@@ -1,12 +0,0 @@
-require 'bundler/gem_tasks'
-require 'rspec/core/rake_task'
-require 'jars/installer'
-
-RSpec::Core::RakeTask.new(:spec)
-
-task :default => :spec
-
-desc "Install JAR dependencies"
-task :install_jars do
-  Jars::Installer.vendor_jars!
-end

data/bin/console

@@ -1,14 +0,0 @@
-#!/usr/bin/env ruby
-
-require "bundler/setup"
-require "saxon"
-
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
-
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
-
-require "irb"
-IRB.start(__FILE__)

data/bin/setup

@@ -1,8 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-IFS=$'\n\t'
-set -vx
-
-bundle install
-
-# Do any other automated setup that you need to do here

data/lib/saxon.rb

@@ -1,6 +0,0 @@
-require_relative 'saxon/version'
-require_relative 'saxon/processor'
-
-# An idiomatic Ruby wrapper around the Saxon XML processing library.
-module Saxon
-end

data/lib/saxon/axis_iterator.rb

@@ -1,32 +0,0 @@
-require 'saxon/s9api'
-require 'saxon/xdm_node'
-
-module Saxon
-  # An XPath Data Model Node object, representing an XML document, or an element or one of the other node chunks in the XDM.
-  class AxisIterator
-    include Enumerable
-
-    attr_reader :s9_xdm_node, :s9_axis
-    private :s9_xdm_node, :s9_axis
-
-    def initialize(xdm_node, axis)
-      @s9_xdm_node = xdm_node.to_java
-      @s9_axis = Saxon::S9API::Axis.const_get(axis.to_s.upcase.to_sym)
-    end
-
-    # @return [Saxon::S9API::XdmSequenceIterator] A new Saxon Java XDM sequence iterator.
-    def to_java
-      s9_sequence_iterator
-    end
-
-    def each(&block)
-      s9_sequence_iterator.lazy.map { |s9_xdm_node| Saxon::XdmNode.new(s9_xdm_node) }.each(&block)
-    end
-
-    private
-
-    def s9_sequence_iterator
-      s9_xdm_node.axisIterator(s9_axis)
-    end
-  end
-end

data/lib/saxon/configuration.rb

@@ -1,116 +0,0 @@
-require 'saxon/s9api'
-require 'saxon/parse_options'
-
-module Saxon
-  # Wraps the <tt>net.saxon.Configuration</tt> class. See
-  # http://saxonica.com/documentation9.5/javadoc/net/sf/saxon/Configuration.html
-  # for details of what configuration options are available and what values
-  # they accept. See
-  # http://saxonica.com/documentation9.5/javadoc/net/sf/saxon/lib/FeatureKeys.html
-  # for details of the constant names used to access the values
-  class Configuration
-    DEFAULT_SEMAPHORE = Mutex.new
-
-    # Provides a processor with default configuration. Essentially a singleton
-    # instance
-    # @return [Saxon::Configuration]
-    def self.default
-      DEFAULT_SEMAPHORE.synchronize do
-        @config ||= create
-      end
-    end
-
-    # @param processor [Saxon::Processor] a Saxon::Processor instance
-    # @return [Saxon::Configuration]
-    def self.create(processor = nil)
-      Saxon::Loader.load!
-      if processor
-        config = processor.to_java.underlying_configuration
-      else
-        config = Saxon::S9API::Configuration.new
-      end
-      new(config)
-    end
-
-    # @param license_path [String] the absolute path to a Saxon PE or EE
-    #   license file
-    # @return [Saxon::Configuration]
-    def self.create_licensed(license_path)
-      Saxon::Loader.load!
-      java_config = Saxon::S9API::Configuration.makeLicensedConfiguration(nil, nil)
-      config = new(java_config)
-      config[:LICENSE_FILE_LOCATION] = license_path
-      config
-    end
-
-    # Set a already-created Licensed Configuration object as the default
-    # configuration
-    def self.set_licensed_default!(licensed_configuration)
-      DEFAULT_SEMAPHORE.synchronize do
-        @config = licensed_configuration
-      end
-    end
-
-    # @api private
-    # @param config [net.sf.saxon.Configuration] The Saxon Configuration
-    #   instance to wrap
-    def initialize(config)
-      @config = config
-    end
-
-    # Get a configuration option value
-    # See https://www.saxonica.com/html/documentation/javadoc/net/sf/saxon/lib/FeatureKeys.html
-    # for details of the available options. Use the constant name as a string
-    # or symbol as the option
-    #
-    # @param option [String, Symbol]
-    # @return [Object] the value of the configuration option
-    # @raise [NameError] if the option name does not exist
-    def [](option)
-      @config.getConfigurationProperty(option_url(option))
-    end
-
-    # Get a configuration option value
-    # See http://saxonica.com/documentation9.5/javadoc/net/sf/saxon/lib/FeatureKeys.html
-    # for details of the available options. Use the constant name as a string
-    # or symbol as the option
-    #
-    # @param option [String, Symbol]
-    # @param value [Object] the value of the configuration option
-    # @return [Object] the value you passed in
-    # @raise [NameError] if the option name does not exist
-    def []=(option, value)
-      url = option_url(option)
-      @config.setConfigurationProperty(url, value)
-    end
-
-    # Return the current ParseOptions object
-    # See https://www.saxonica.com/documentation/index.html#!javadoc/net.sf.saxon.lib/ParseOptions
-    # for details. This allows you to set JAXP features and properties to be
-    # passed to the parser
-    #
-    # @return [Saxon::ParseOptions] the ParseOptions object
-    def parse_options
-      ParseOptions.new(@config.getParseOptions)
-    end
-
-    # @return [net.sf.saxon.Configuration] The underlying Saxon Configuration
-    def to_java
-      @config
-    end
-
-    private
-
-    def feature_keys
-      @feature_keys ||= Saxon::S9API::FeatureKeys.java_class
-    end
-
-    def option_url(option)
-      feature_keys.field(normalize_option_name(option)).static_value
-    end
-
-    def normalize_option_name(option)
-      option.to_s.upcase
-    end
-  end
-end

data/lib/saxon/document_builder.rb

@@ -1,28 +0,0 @@
-require 'saxon/xdm_node'
-
-module Saxon
-  # Builds XDM objects from XML sources, for use in XSLT or for query and
-  # access
-  class DocumentBuilder
-    # @api private
-    # @param [net.sf.saxon.s9api.DocumentBuilder] s9_document_builder The
-    # Saxon DocumentBuilder instance to wrap
-    def initialize(s9_document_builder)
-      @s9_document_builder = s9_document_builder
-    end
-
-    # @param [Saxon::Source] source The Saxon::Source containing the source
-    #   IO/string
-    # @return [Saxon::XdmNode] The Saxon::XdmNode representing the root of the
-    #   document tree
-    def build(source)
-      XdmNode.new(@s9_document_builder.build(source.to_java))
-    end
-
-    # @return [net.sf.saxon.s9api.DocumentBuilder] The underlying Java Saxon
-    #   DocumentBuilder instance
-    def to_java
-      @s9_document_builder
-    end
-  end
-end

data/lib/saxon/item_type.rb

@@ -1,200 +0,0 @@
-require_relative 's9api'
-
-module Saxon
-  # Represent XDM types abstractly
-  class ItemType
-    # A mapping of Ruby types to XDM type constants
-    TYPE_MAPPING = {
-      'String' => :STRING,
-      'Array'  => :ANY_ARRAY,
-      'Hash'   => :ANY_MAP,
-      'TrueClass'  => :BOOLEAN,
-      'FalseClass' => :BOOLEAN,
-      'Date' => :DATE,
-      'DateTime' => :DATE_TIME,
-      'Time' => :DATE_TIME,
-      'BigDecimal' => :DECIMAL,
-      'Integer' => :INTEGER,
-      'Float' => :FLOAT,
-      'Numeric' => :NUMERIC
-    }.freeze
-
-    # A mapping of type names/QNames to XDM type constants
-    STR_MAPPING = {
-      'array(*)' => :ANY_ARRAY,
-      'xs:anyAtomicType' => :ANY_ATOMIC_VALUE,
-      'item()' => :ANY_ITEM,
-      'map(*)' => :ANY_MAP,
-      'node()' => :ANY_NODE,
-      'xs:anyURI' => :ANY_URI,
-      'xs:base64Binary' => :BASE64_BINARY,
-      'xs:boolean' => :BOOLEAN,
-      'xs:byte' => :BYTE,
-      'xs:date' => :DATE,
-      'xs:dateTime' => :DATE_TIME,
-      'xs:dateTimeStamp' => :DATE_TIME_STAMP,
-      'xs:dayTimeDuration' => :DAY_TIME_DURATION,
-      'xs:decimal' => :DECIMAL,
-      'xs:double' => :DOUBLE,
-      'xs:duration' => :DURATION,
-      'xs:ENTITY' => :ENTITY,
-      'xs:float' => :FLOAT,
-      'xs:gDay' => :G_DAY,
-      'xs:gMonth' => :G_MONTH,
-      'xs:gMonthDay' => :G_MONTH_DAY,
-      'xs:gYear' => :G_YEAR,
-      'xs:gYearMonth' => :G_YEAR_MONTH,
-      'xs:hexBinary' => :HEX_BINARY,
-      'xs:ID' => :ID,
-      'xs:IDREF' => :IDREF,
-      'xs:int' => :INT,
-      'xs:integer' => :INTEGER,
-      'xs:language' => :LANGUAGE,
-      'xs:long' => :LONG,
-      'xs:Name' => :NAME,
-      'xs:NCName' => :NCNAME,
-      'xs:negativeInteger' => :NEGATIVE_INTEGER,
-      'xs:NMTOKEN' => :NMTOKEN,
-      'xs:nonNegativeInteger' => :NON_NEGATIVE_INTEGER,
-      'xs:nonPositiveInteger' => :NON_POSITIVE_INTEGER,
-      'xs:normalizedString' => :NORMALIZED_STRING,
-      'xs:NOTATION' => :NOTATION,
-      'xs:numeric' => :NUMERIC,
-      'xs:positiveInteger' => :POSITIVE_INTEGER,
-      'xs:QName' => :QNAME,
-      'xs:short' => :SHORT,
-      'xs:string' => :STRING,
-      'xs:time' => :TIME,
-      'xs:token' => :TOKEN,
-      'xs:unsignedByte' => :UNSIGNED_BYTE,
-      'xs:unsignedInt' => :UNSIGNED_INT,
-      'xs:unsignedLong' => :UNSIGNED_LONG,
-      'xs:unsignedShort' => :UNSIGNED_SHORT,
-      'xs:untypedAtomic' => :UNTYPED_ATOMIC,
-      'xs:yearMonthDuration' => :YEAR_MONTH_DURATION
-    }.freeze
-
-    class << self
-      # Get an appropriate {ItemType} for a Ruby type or given a type name as a
-      # string
-      #
-      # @return [Saxon::ItemType]
-      # @overload get_type(ruby_class)
-      #   Get an appropriate {ItemType} for object of a given Ruby class
-      #   @param ruby_class [Class] The Ruby class to get a type for
-      # @overload get_type(type_name)
-      #   Get the {ItemType} for the name
-      #   @param type_name [String] name of the built-in {ItemType} to fetch
-      def get_type(arg)
-        new(get_s9_type(arg))
-      end
-
-      private
-
-      def get_s9_type(arg)
-        case arg
-        when Class
-          get_s9_class_mapped_type(arg)
-        when String
-          get_s9_str_mapped_type(arg)
-        end
-      end
-
-      def get_s9_class_mapped_type(klass)
-        class_name = klass.name
-        if mapped_type = TYPE_MAPPING.fetch(class_name, false)
-          S9API::ItemType.const_get(mapped_type)
-        else
-          raise UnmappedRubyTypeError, class_name
-        end
-      end
-
-      def get_s9_str_mapped_type(type_str)
-        if mapped_type = STR_MAPPING.fetch(type_str, false)
-          # ANY_ITEM is a method, not a constant, for reasons not entirely
-          # clear to me
-          return S9API::ItemType.ANY_ITEM if mapped_type == :ANY_ITEM
-          S9API::ItemType.const_get(mapped_type)
-        else
-          raise UnmappedXSDTypeNameError, type_str
-        end
-      end
-    end
-
-    attr_reader :s9_item_type
-    private :s9_item_type
-
-    # @api private
-    def initialize(s9_item_type)
-      @s9_item_type = s9_item_type
-    end
-
-    # Return the {QName} which represents this type
-    #
-    # @return [Saxon::QName] the {QName} of the type
-    def type_name
-      @type_name ||= Saxon::QName.new(s9_item_type.getTypeName)
-    end
-
-    # @return [Saxon::S9API::ItemType] The underlying Saxon Java ItemType object
-    def to_java
-      s9_item_type
-    end
-
-    # compares two {ItemType}s using the underlying Saxon and XDM comparision rules
-    # @param other [Saxon::ItemType]
-    # @return [Boolean]
-    def ==(other)
-      return false unless other.is_a?(ItemType)
-      s9_item_type.equals(other.to_java)
-    end
-
-    alias_method :eql?, :==
-
-    def hash
-      @hash ||= s9_item_type.hashCode
-    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
-      end
-
-      def to_s
-        "Ruby class <#{@class_name}> has no XDM type equivalent"
-      end
-    end
-
-    # Error raise when an attempt to reify an <tt>xs:*</tt> type string is
-    # made, but the type string doesn't match any of the built-in <tt>xs:*</tt>
-    # types
-    class UnmappedXSDTypeNameError < StandardError
-      def initialize(type_str)
-        @type_str = type_str
-      end
-
-      def to_s
-        "'#{@type_str}' is not recognised as an XSD built-in type"
-      end
-    end
-
-    class Factory
-      DEFAULT_SEMAPHORE = Mutex.new
-
-      attr_reader :processor
-
-      def initialize(processor)
-        @processor = processor
-      end
-
-      def s9_factory
-        return @s9_factory if instance_variable_defined?(:@s9_factory)
-        DEFAULT_SEMAPHORE.synchronize do
-          @s9_factory = S9API::ItemTypeFactory.new(processor.to_java)
-        end
-      end
-    end
-  end
-end

data/lib/saxon/jaxp.rb

@@ -1,8 +0,0 @@
-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

@@ -1,103 +0,0 @@
-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 @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
-          import_classes_to_namespace!
-
-          @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
-
-    def self.import_classes_to_namespace!
-      Saxon::S9API.class_eval do
-        include_package 'net.sf.saxon.s9api'
-        java_import 'net.sf.saxon.Configuration'
-        java_import 'net.sf.saxon.lib.FeatureKeys'
-        java_import 'net.sf.saxon.lib.ParseOptions'
-      end
-    end
-  end
-end