saxon 0.2.2-java → 0.4.0-java

data/lib/saxon/occurrence_indicator.rb

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

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

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

@@ -1,145 +0,0 @@
-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
-
-    # Resolve a QName string into a {Saxon::QName}.
-    #
-    # If the arg is a {Saxon::QName} already, it just gets returned. If
-    # it's an instance of the underlying Saxon Java QName, it'll be wrapped
-    # into a {Saxon::QName}
-    #
-    # If the arg is a string, it's resolved by using {resolve_variable_name}
-    #
-    # @param qname_or_string [String, Symbol, Saxon::QName] the qname to resolve
-    # @param namespaces [Hash<String => String>] the set of namespaces as a hash of <tt>"prefix" => "namespace-uri"</tt>
-    # @return [Saxon::QName]
-    def self.resolve(qname_or_string, namespaces = {})
-      case qname_or_string
-      when String, Symbol
-        resolve_qname_string(qname_or_string, namespaces)
-      when self
-        qname_or_string
-      when Saxon::S9API::QName
-        new(qname_or_string)
-      end
-    end
-
-    # Resolve a QName string of the form <tt>"prefix:local-name"</tt> into a
-    # {Saxon::QName} by looking up the namespace URI in a hash of
-    # <tt>"prefix" => "namespace-uri"</tt>
-    #
-    # @param qname_string [String, Symbol] the QName as a <tt>"prefix:local-name"</tt> string
-    # @param namespaces [Hash<String => String>] the set of namespaces as a hash of <tt>"prefix" => "namespace-uri"</tt>
-    # @return [Saxon::QName]
-    def self.resolve_qname_string(qname_string, namespaces = {})
-      local_name, prefix = qname_string.to_s.split(':').reverse
-      uri = nil
-
-      if prefix
-        uri = namespaces[prefix]
-        raise self::PrefixedStringWithoutNSURIError.new(qname_string, prefix) if uri.nil?
-      end
-
-      create(prefix: prefix, uri: uri, local_name: local_name)
-    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
-      def initialize(qname_string, prefix)
-        @qname_string, @prefix = qname_string, prefix
-      end
-
-      def to_s
-        "Namespace prefix ‘#{@prefix}’ for QName ‘#{@qname_string}’ is not bound to a URI"
-      end
-    end
-  end
-end

data/lib/saxon/s9api.rb

@@ -1,16 +0,0 @@
-require 'saxon/loader'
-
-module Saxon
-  module S9API
-    def self.const_missing(name)
-      Saxon::Loader.load!
-      begin
-        const_get(name)
-      rescue NameError
-        msg = "uninitialized constant Saxon::S9API::#{name}"
-        e = NameError.new(msg, name)
-        raise e
-      end
-    end
-  end
-end

data/lib/saxon/serializer.rb

@@ -1,143 +0,0 @@
-require 'saxon/s9api'
-require 'stringio'
-
-module Saxon
-  # Serialize XDM objects.
-  class Serializer
-    # Manage access to the serialization properties of this serializer, with
-    # hash-like access.
-    #
-    # Properties can be set explicitly through this API, or via XSLT or XQuery
-    # serialization options like `<xsl:output>`.
-    #
-    # Properties set explicitly here will override properties set through the
-    # document like `<xsl:output>`.
-    class OutputProperties
-      # @api private
-      # Provides mapping between symbols and the underlying Saxon property
-      # instances
-      def self.output_properties
-        @output_properties ||= Hash[
-          Saxon::S9API::Serializer::Property.values.map { |property|
-            qname = property.getQName
-            key = [
-              qname.getPrefix,
-              qname.getLocalName.tr('-', '_')
-            ].reject { |str| str == '' }.join('_').to_sym
-            [key, property]
-          }
-        ]
-      end
-
-      attr_reader :s9_serializer
-
-      # @api private
-      def initialize(s9_serializer)
-        @s9_serializer = s9_serializer
-      end
-
-      # @param [Symbol, Saxon::S9API::Serializer::Property] property The property to fetch
-      def [](property)
-        s9_serializer.getOutputProperty(resolved_property(property))
-      end
-
-      # @param [Symbol, Saxon::S9API::Serializer::Property] property The property to set
-      # @param [String] value The string value of the property
-      def []=(property, value)
-        s9_serializer.setOutputProperty(resolved_property(property), value)
-      end
-
-      # @overload fetch(property)
-      #   @param [Symbol, Saxon::S9API::Serializer::Property] property The property to fetch
-      # @overload fetch(property, default)
-      #   @param property [Symbol, Saxon::S9API::Serializer::Property] The property to fetch
-      #   @param default [Object] The value to return if the property is unset
-      def fetch(property, default = nil)
-        explicit_value = self[property]
-        if explicit_value.nil? && !default.nil?
-          default
-        else
-          explicit_value
-        end
-      end
-
-      private
-      def resolved_property(property_key)
-        case property_key
-        when Symbol
-          self.class.output_properties.fetch(property_key)
-        else
-          property_key
-        end
-      end
-    end
-
-    attr_reader :s9_serializer
-    private :s9_serializer
-
-    # @api private
-    def initialize(s9_serializer)
-      @s9_serializer = s9_serializer
-    end
-
-    # @return [Saxon::Serializer::OutputProperties] hash-like access to the Output Properties
-    def output_property
-      @output_property ||= OutputProperties.new(s9_serializer)
-    end
-
-    # @overload serialize(xdm_value, io)
-    #   Serialize an XdmValue to an IO
-    #   @param [Saxon::XdmValue] xdm_value The XdmValue to serialize
-    #   @param [File, IO] io The IO to serialize to
-    #   @return [nil]
-    # @overload serialize(xdm_value, path)
-    #   Serialize an XdmValue to file <tt>path</tt>
-    #   @param [Saxon::XdmValue] xdm_value The XdmValue to serialize
-    #   @param [String, Pathname] path The path of the file to serialize to
-    #   @return [nil]
-    # @overload serialize(xdm_value)
-    #   Serialize an XdmValue to a String
-    #   @param [Saxon::XdmValue] xdm_value The XdmValue to serialize
-    #   @return [String] The serialized XdmValue
-    def serialize(xdm_value, io_or_path = nil)
-      case io_or_path
-      when nil
-        serialize_to_string(xdm_value)
-      when String, Pathname
-        serialize_to_file(xdm_value, io_or_path)
-      else
-        serialize_to_io(xdm_value, io_or_path)
-      end
-    end
-
-    # @return [Saxon::S9API::Serializer] The underlying Saxon Serializer object
-    def to_java
-      s9_serializer
-    end
-
-    private
-
-    def serialize_to_io(xdm_value, io)
-      s9_serializer.setOutputStream(io.to_outputstream)
-      s9_serializer.serializeXdmValue(xdm_value.to_java)
-      nil
-    end
-
-    def serialize_to_string(xdm_value)
-      str_encoding = output_property.fetch(:encoding, Encoding.default_internal || Encoding.default_external)
-      StringIO.open { |io|
-        io.binmode
-        serialize_to_io(xdm_value, io)
-        io.string.force_encoding(str_encoding)
-      }
-    end
-
-    def serialize_to_file(xdm_value, path)
-      file = Java::JavaIO::File.new(path)
-      s9_serializer.setOutputFile(file)
-      s9_serializer.serializeXdmValue(xdm_value.to_java)
-      nil
-    end
-  end
-end
-