saxon 0.1.0-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 19f0e9fb8c21c339568c774ffc0c3020f39d45f896c1bf009c9d1052bed65412
+  data.tar.gz: 92ec755ab385c2ab0509db7a4e5846f22979be58a12cc1fe7fefcc8f1350899f
+SHA512:
+  metadata.gz: a8154c57826865c13c48347ab517f9c9fa8c0499f0ee1693c063a381571d8401275c0c8718a25f3fcb4e37910423c1b7ca670b9cd490464d8bbd396e66a74379
+  data.tar.gz: 63a5ca988ee42631bf7f02158c8ce377015269716a54c194e8756a4c158e602a00c67965538cf59136517f0785de226155b05b7e56b8699a58009d76a0e19d1c

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+# VCR cassettes
+/spec/fixtures/cassettes

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.ruby-version

@@ -0,0 +1 @@
+jruby-9.2.6.0

data/.travis.yml

@@ -0,0 +1,20 @@
+dist: trusty
+sudo: false
+language: ruby
+rvm:
+  - jruby-9.1.17.0
+  - jruby-1.7.27
+jdk:
+  - oraclejdk8
+  - openjdk7
+before_install: gem install bundler -v 1.16.1
+cache: bundler
+env:
+  JDK_VERSION_FOR_CODECLIMATE: oraclejdk8
+  JRUBY_OPTS: "--debug"
+before_script:
+  - if [ "$TRAVIS_JDK_VERSION" = "$JDK_VERSION_FOR_CODECLIMATE" ]; then curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter; chmod +x ./cc-test-reporter; ./cc-test-reporter before-build; fi
+script:
+  - bundle exec rspec
+  - if [[ "$TRAVIS_PULL_REQUEST" = "false" && "$TRAVIS_JDK_VERSION" = "$JDK_VERSION_FOR_CODECLIMATE" ]]; then ./cc-test-reporter after-build --exit-code $TRAVIS_TEST_RESULT; fi
+

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at matt@reprocessed.org. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in saxon.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Matt Patterson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,43 @@
+# Saxon
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/saxon`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'saxon'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install saxon
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/saxon. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Saxon project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/saxon/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

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

@@ -0,0 +1,14 @@
+#!/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

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

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

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

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

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

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