saxon 0.1.0-java

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,103 @@
+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

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

data/lib/saxon/qname.rb

@@ -0,0 +1,97 @@
+require 'saxon/s9api'
+
+module Saxon
+  # Represents QNames
+  class QName
+    def self.clark(clark_string)
+      s9_qname = Saxon::S9API::QName.fromClarkName(clark_string)
+      new(s9_qname)
+    end
+
+    def self.eqname(eqname_string)
+      s9_qname = Saxon::S9API::QName.fromEQName(eqname_string)
+      new(s9_qname)
+    end
+
+    def self.create(opts = {})
+      prefix = opts[:prefix]
+      uri = opts[:uri]
+      begin
+        local_name = opts.fetch(:local_name)
+      rescue KeyError
+        raise ArgumentError, "The :local_name option must be passed"
+      end
+
+      s9_qname = Saxon::S9API::QName.new(*[prefix, uri, local_name].compact)
+      new(s9_qname)
+    end
+
+    attr_reader :s9_qname
+    private :s9_qname
+
+    # @api private
+    def initialize(s9_qname)
+      @s9_qname = s9_qname
+    end
+
+    # @return [String] The local name part of the QName
+    def local_name
+      @s9_qname.getLocalName
+    end
+
+    # @return [String] The prefix part of the QName ('' if unset)
+    def prefix
+      @s9_qname.getPrefix
+    end
+
+    # @return [String] The namespace URI part of the QName ('' if unset)
+    def uri
+      @s9_qname.getNamespaceURI
+    end
+
+    # Return a Clark notation representation of the QName:
+    #
+    #    "{http://ns.url}local-name"
+    #
+    # Note that the prefix is lost in Clark notation.
+    # @return [String] The QName represented using Clark notation.
+    def clark
+      @s9_qname.getClarkName
+    end
+
+    # Return a Extended QName notation representation of the QName:
+    #
+    #    "Q{http://ns.url}local-name"
+    #
+    # Note that the prefix is lost in EQName notation.
+    # @return [String] The QName represented using EQName notation.
+    def eqname
+      @s9_qname.getEQName
+    end
+
+    def ==(other)
+      return false unless other.is_a?(QName)
+      s9_qname.equals(other.to_java)
+    end
+    alias_method :eql?, :==
+
+    def hash
+      @hash ||= (local_name + uri).hash
+    end
+
+    def to_java
+      s9_qname
+    end
+
+    def to_s
+      s9_qname.to_s
+    end
+
+    def inspect
+      "<Saxon::QName @prefix=#{prefix} @uri=#{uri} @local_name=#{local_name}>"
+    end
+
+    class PrefixedStringWithoutNSURIError < RuntimeError
+    end
+  end
+end