saxon 0.1.0-java → 0.2.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19f0e9fb8c21c339568c774ffc0c3020f39d45f896c1bf009c9d1052bed65412
-  data.tar.gz: 92ec755ab385c2ab0509db7a4e5846f22979be58a12cc1fe7fefcc8f1350899f
+  metadata.gz: 9a66efc7aa5610d1826b3f6762061353e44bdd97f13aad85e2339195883a64bc
+  data.tar.gz: bd0b05fb1814f2863efba80651cb2cbce75f7d2f7ae3202ffcdc9a74685e985c
 SHA512:
-  metadata.gz: a8154c57826865c13c48347ab517f9c9fa8c0499f0ee1693c063a381571d8401275c0c8718a25f3fcb4e37910423c1b7ca670b9cd490464d8bbd396e66a74379
-  data.tar.gz: 63a5ca988ee42631bf7f02158c8ce377015269716a54c194e8756a4c158e602a00c67965538cf59136517f0785de226155b05b7e56b8699a58009d76a0e19d1c
+  metadata.gz: d9cbe86dad9cf8db64909057cbcc116642305b7d1287b2762872e1d23dae3f2d59f4476563486f650e7a2f0fd6053448724da4ed2e50907517709bb4cddb8f21
+  data.tar.gz: ff553975c4ace0ce9bc763510bcffc8ccb044b7fc642ba3aba9a46c02e2542103d22eb3da8178fbde4ce4e13cfcf09ddc4fc51cacd856ca7ddf7d81f7bc80451

data/lib/saxon/qname.rb

@@ -26,6 +26,47 @@ module Saxon
       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
 
@@ -92,6 +133,13 @@ module Saxon
     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/version.rb

@@ -1,3 +1,3 @@
 module Saxon
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/saxon/xpath/static_context.rb

@@ -41,49 +41,6 @@ module Saxon
         end
       end
 
-      # methods for resolving a QName represented as a <tt>prefix:local-name</tt> string into a {Saxon::QName} by looking the prefix up in declared namespaces
-      module Resolver
-        # 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, Saxon::QName] the qname to resolve
-        # @return [Saxon::QName]
-        def self.resolve_variable_qname(qname_or_string, namespaces)
-          case qname_or_string
-          when String
-            resolve_variable_name(qname_or_string, namespaces)
-          when Saxon::QName
-            qname_or_string
-          when Saxon::S9API::QName
-            Saxon::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] 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_variable_name(qname_string, namespaces)
-          local_name, prefix = qname_string.split(':').reverse
-          uri = nil
-
-          if prefix
-            uri = namespaces[prefix]
-            raise MissingVariableNamespaceError.new(qname_string, prefix) if uri.nil?
-          end
-
-          Saxon::QName.create(prefix: prefix, uri: uri, local_name: local_name)
-        end
-      end
-
       # Provides the hooks for constructing a {StaticContext} with a DSL.
       # @api private
       class DSL
@@ -141,7 +98,7 @@ module Saxon
         private
 
         def resolve_variable_qname(qname_or_string)
-          Resolver.resolve_variable_qname(qname_or_string, @declared_namespaces)
+          Saxon::QName.resolve(qname_or_string, @declared_namespaces)
         end
 
         def resolve_variable_type_decl(type_decl)

data/lib/saxon/xslt/compiler.rb

@@ -1,6 +1,6 @@
 require 'forwardable'
-require_relative './static_context'
-# require_relative './executable'
+require_relative './evaluation_context'
+require_relative './executable'
 
 module Saxon
   module XSLT
@@ -14,39 +14,45 @@ module Saxon
       # @yield An XSLT compiler DSL block
       # @return [Saxon::XSLT::Compiler] the new compiler instance
       def self.create(processor, &block)
-        static_context = XSLT::StaticContext.define(block)
-        new(processor.to_java, static_context)
+        evaluation_context = XSLT::EvaluationContext.define(block)
+        new(processor.to_java, evaluation_context)
       end
 
       extend Forwardable
 
-      attr_reader :static_context
-      private :static_context
+      attr_reader :evaluation_context
+      private :evaluation_context
 
       # @api private
       # @param s9_processor [net.sf.saxon.s9api.Processor] the Saxon
       #   <tt>Processor</tt> to wrap
-      # @param static_context [Saxon::XPath::StaticContext] the static context
+      # @param evaluation_context [Saxon::XSLT::EvaluationContext] the static context
       #   XPaths compiled using this compiler will have
-      def initialize(s9_processor, static_context)
-        @s9_processor, @static_context = s9_processor, static_context
+      def initialize(s9_processor, evaluation_context)
+        @s9_processor, @evaluation_context = s9_processor, evaluation_context
       end
 
-      def_delegators :static_context, :default_collation
+      def_delegators :evaluation_context, :default_collation, :static_parameters, :global_parameters, :initial_template_parameters, :initial_template_tunnel_parameters
       # @!attribute [r] declared_collations
       #   @return [Hash<String => java.text.Collator>] declared collations as URI => Collator hash
       # @!attribute [r] default_collation
       #   @return [String] the URI of the default declared collation
+      # @!attribute [r] static_parameters
+      #   @return [Hash<Saxon::QName => Saxon::XdmValue, Saxon::XdmNode,
+      #   Saxon::XdmAtomicValue>] parameters required at compile time as QName => value hash
 
-      # @param expression [String] the  expression to compile
-      # @return [Saxon::XSLT::Executable] the executable query
-      def compile(expression)
-        Saxon::XSLT::Executable.new(new_compiler.compile(expression), static_context)
+      # @param expression [Saxon::Source] the Source to compile
+      # @return [Saxon::XSLT::Executable] the executable stylesheet
+      def compile(source, &block)
+        Saxon::XSLT::Executable.new(
+          new_compiler.compile(source.to_java),
+          evaluation_context.define(block)
+        )
       end
 
       def create(&block)
-        new_static_context = static_context.define(block)
-        self.class.new(@s9_processor, new_static_context)
+        new_evaluation_context = evaluation_context.define(block)
+        self.class.new(@s9_processor, new_evaluation_context)
       end
 
       private
@@ -54,6 +60,9 @@ module Saxon
       def new_compiler
         compiler = @s9_processor.newXsltCompiler
         compiler.declareDefaultCollation(default_collation) unless default_collation.nil?
+        static_parameters.each do |qname, value|
+          compiler.setParameter(qname.to_java, value.to_java)
+        end
         compiler
       end
     end

data/lib/saxon/xslt/evaluation_context.rb

@@ -0,0 +1,174 @@
+require 'set'
+require_relative '../qname'
+
+module Saxon
+  module XSLT
+    # Represents the evaluation context for an XSLT compiler, and stylesheets
+    # compiled using one. {EvaluationContext}s are immutable.
+    class EvaluationContext
+      # methods used by both {EvaluationContext} and {EvaluationContext::DSL}
+      module Common
+        # @param args [Hash]
+        # @option args [String] default_collation URI of the default collation
+        # @option args [Hash<String,Symbol,Saxon::QName =>
+        #   Object,Saxon::XdmValue] static_parameters Hash of QName => value
+        #   bindings for static (compile-time) parameters for this compiler
+        def initialize(args = {})
+          @default_collation = args.fetch(:default_collation, nil).freeze
+          @static_parameters = args.fetch(:static_parameters, {}).freeze
+          @global_parameters = args.fetch(:global_parameters, {}).freeze
+          @initial_template_parameters = args.fetch(:initial_template_parameters, {}).freeze
+          @initial_template_tunnel_parameters = args.fetch(:initial_template_tunnel_parameters, {}).freeze
+        end
+
+        # returns the context details in a hash suitable for initializing a new one
+        # @return [Hash<Symbol => Hash,null>] the args hash
+        def args_hash
+          check_for_clashing_parameters!
+          {
+            default_collation: @default_collation,
+            static_parameters: @static_parameters,
+            global_parameters: @global_parameters,
+            initial_template_parameters: @initial_template_parameters,
+            initial_template_tunnel_parameters: @initial_template_tunnel_parameters
+          }
+        end
+
+        private
+
+        def check_for_clashing_parameters!
+          @checked ||= begin
+            if Set.new(@static_parameters.keys).intersect?(Set.new(@global_parameters.keys))
+              raise GlobalAndStaticParameterClashError
+            else
+              true
+            end
+          end
+        end
+      end
+
+      # Provides the hooks for constructing a {EvaluationContext} with a DSL.
+      # @api private
+      class DSL
+        include Common
+
+        # Create an instance based on the args hash, and execute the passed in Proc/lambda against it using <tt>#instance_exec</tt> and return a
+        # new {EvaluationContext} with the results
+        # @param block [Proc] a Proc/lambda (or <tt>to_proc</tt>'d containing DSL calls
+        # @return [Saxon::XSLT::EvaluationContext]
+        def self.define(block, args = {})
+          dsl = new(args)
+          dsl.instance_exec(&block) unless block.nil?
+          EvaluationContext.new(dsl.args_hash)
+        end
+
+        # Set the default Collation to use. This should be one of the special
+        # collation URIs Saxon recognises, or one that has been registered
+        # using Saxon::Processor#declare_collations on the Processor that
+        # created the {XSLT::Compiler} this context is for.
+        #
+        # @param collation_uri [String] The URI of the Collation to set as the default
+        def default_collation(collation_uri)
+          @default_collation = collation_uri
+        end
+
+        # Set the value for static parameters (those that must be known at
+        # compile-time to avoid an error), as a hash of QName => Value pairs.
+        # Parameter QNames can be declared as Strings or Symbols if they are
+        # not in any namespace, otherwise an explicit {Saxon::QName} must be
+        # used. Values can be provided as explicit XdmValues:
+        # {Saxon::XdmValue}, {Saxon::XdmNode}, and {Saxon::XdmAtomicValue}, or
+        # as Ruby objects which will be converted to {Saxon::XdmAtomicValue}s
+        # in the usual way.
+        #
+        # @param parameters [Hash<String,Symbol,Saxon::QName =>
+        #   Object,Saxon::XdmValue>] Hash of QName => value
+        def static_parameters(parameters = {})
+          @static_parameters = @static_parameters.merge(process_parameters(parameters)).freeze
+        end
+
+        # Set the values for global parameters (those that are available to all templates and functions).
+        #
+        # @see EvaluationContext#static_parameters for details of the argument format
+        #
+        # @param parameters [Hash<String,Symbol,Saxon::QName =>
+        #   Object,Saxon::XdmValue>] Hash of QName => value
+        def global_parameters(parameters = {})
+          @global_parameters = @global_parameters.merge(process_parameters(parameters)).freeze
+        end
+
+        # Set the values for parameters made available only to the initial
+        # template invoked (either via apply_templates or call_template),
+        # effectively as if <tt><xsl:with-param tunnel="no"></tt> was being used.
+        #
+        # @see EvaluationContext#static_parameters for details of the argument format
+        #
+        # @param parameters [Hash<String,Symbol,Saxon::QName =>
+        #   Object,Saxon::XdmValue>] Hash of QName => value
+        def initial_template_parameters(parameters = {})
+          @initial_template_parameters = @initial_template_parameters.merge(process_parameters(parameters))
+        end
+
+        # Set the values for tunneling parameters made available only to the initial
+        # template invoked (either via apply_templates or call_template),
+        # effectively as if <tt><xsl:with-param tunnel="yes"></tt> was being used.
+        #
+        # @see EvaluationContext#static_parameters for details of the argument format
+        #
+        # @param parameters [Hash<String,Symbol,Saxon::QName =>
+        #   Object,Saxon::XdmValue>] Hash of QName => value
+        def initial_template_tunnel_parameters(parameters = {})
+          @initial_template_tunnel_parameters = @initial_template_tunnel_parameters.merge(process_parameters(parameters))
+        end
+
+        private
+
+        def process_parameters(parameters)
+          XSLT::ParameterHelper.process_parameters(parameters)
+        end
+      end
+
+      include Common
+
+      # Executes the Proc/lambda passed in with a new instance of
+      # {EvaluationContext} as <tt>self</tt>, allowing the DSL methods to be
+      # called in a DSL-ish way
+      #
+      # @param block [Proc] the block of DSL calls to be executed
+      # @return [Saxon::XSLT::EvaluationContext] the static context created by the block
+      def self.define(block)
+        DSL.define(block)
+      end
+
+      attr_reader :default_collation, :static_parameters, :global_parameters, :initial_template_parameters, :initial_template_tunnel_parameters
+
+      def define(block)
+        block.nil? ? self : DSL.define(block, args_hash)
+      end
+    end
+
+    class GlobalAndStaticParameterClashError < StandardError
+    end
+
+    module ParameterHelper
+      def self.process_parameters(parameters)
+        Hash[parameters.map { |qname, value|
+          [Saxon::QName.resolve(qname), process_xdm_value(value)]
+        }]
+      end
+
+      def self.process_xdm_value(value)
+        case value
+        when Saxon::XdmValue, Saxon::XdmNode, Saxon::XdmAtomicValue
+          value
+        else
+          Saxon::XdmAtomicValue.create(value)
+        end
+      end
+
+      def self.to_java(parameters)
+        Hash[parameters.map { |k,v| [k.to_java, v.to_java] }].to_java
+      end
+    end
+  end
+end

data/lib/saxon/xslt/executable.rb

@@ -1,24 +1,29 @@
-require_relative 'static_context'
+require 'forwardable'
+require_relative 'evaluation_context'
 require_relative '../serializer'
 require_relative '../xdm_value'
 require_relative '../qname'
 
 module Saxon
   module XSLT
-    # Represents a compiled XPaGth query ready to be executed
+    # Represents a compiled XSLT stylesheet ready to be executed
     class Executable
-      # @return [XSLT::StaticContext] the XPath's static context
-      attr_reader :static_context
+      extend Forwardable
+
+      attr_reader :evaluation_context
+      private :evaluation_context
 
       # @api private
       # @param s9_xslt_executable [net.sf.saxon.s9api.XsltExecutable] the
-      #   Saxon compiled XPath object
-      # @param static_context [XPath::StaticContext] the XPath's static
+      #   Saxon compiled XSLT object
+      # @param evaluation_context [XSLT::EvaluationContext] the XSLT's evaluation
       #   context
-      def initialize(s9_xslt_executable, static_context)
-        @s9_xslt_executable, @static_context = s9_xslt_executable, static_context
+      def initialize(s9_xslt_executable, evaluation_context)
+        @s9_xslt_executable, @evaluation_context = s9_xslt_executable, evaluation_context
       end
 
+      def_delegators :evaluation_context, :global_parameters, :initial_template_parameters, :initial_template_tunnel_parameters
+
       def apply_templates(source, opts = {})
         transformation(opts).apply_templates(source)
       end
@@ -36,10 +41,32 @@ module Saxon
       private
 
       def transformation(opts)
-        Transformation.new(opts.merge({
+        Transformation.new(params_merged_opts(opts).merge({
           s9_transformer: @s9_xslt_executable.load30,
         }))
       end
+
+      def params_merged_opts(opts)
+        merged_opts = params_hash.dup
+        opts.each do |key, value|
+          if [:global_parameters, :initial_template_parameters, :initial_template_tunnel_parameters].include?(key)
+            merged_opts[key] = merged_opts.fetch(key, {}).merge(XSLT::ParameterHelper.process_parameters(value))
+          else
+            merged_opts[key] = value
+          end
+        end
+        merged_opts
+      end
+
+      def params_hash
+        @params_hash ||= begin
+          params_hash = {}
+          params_hash[:global_parameters] = global_parameters unless global_parameters.empty?
+          params_hash[:initial_template_parameters] = initial_template_parameters unless initial_template_parameters.empty?
+          params_hash[:initial_template_tunnel_parameters] = initial_template_tunnel_parameters unless initial_template_tunnel_parameters.empty?
+          params_hash
+        end.freeze
+      end
     end
 
     class Result
@@ -72,7 +99,7 @@ module Saxon
       end
 
       def call_template(template_name)
-        transformation_result(:callTemplate, resolve_qname(template_name))
+        transformation_result(:callTemplate, Saxon::QName.resolve(template_name))
       end
 
       private
@@ -110,17 +137,19 @@ module Saxon
       end
 
       def mode(mode_name)
-        s9_transformer.setInitialMode(resolve_qname(mode_name).to_java)
+        s9_transformer.setInitialMode(Saxon::QName.resolve(mode_name).to_java)
       end
 
-      def resolve_qname(qname)
-        case qname
-        when Saxon::QName
-          qname
-        else
-          raise Saxon::QName::PrefixedStringWithoutNSURIError if qname.to_s.include?(':')
-          Saxon::QName.create(local_name: qname.to_s)
-        end
+      def global_parameters(parameters)
+        s9_transformer.setStylesheetParameters(XSLT::ParameterHelper.to_java(parameters))
+      end
+
+      def initial_template_parameters(parameters)
+        s9_transformer.setInitialTemplateParameters(XSLT::ParameterHelper.to_java(parameters) , false)
+      end
+
+      def initial_template_tunnel_parameters(parameters)
+        s9_transformer.setInitialTemplateParameters(XSLT::ParameterHelper.to_java(parameters) , true)
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: saxon
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: java
 authors:
 - Matt Patterson
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2019-04-12 00:00:00.000000000 Z
+date: 2019-04-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -183,8 +183,8 @@ files:
 - lib/saxon/xpath/variable_declaration.rb
 - lib/saxon/xslt.rb
 - lib/saxon/xslt/compiler.rb
+- lib/saxon/xslt/evaluation_context.rb
 - lib/saxon/xslt/executable.rb
-- lib/saxon/xslt/static_context.rb
 - lib/saxon_jars.rb
 - saxon.gemspec
 homepage: https://github.com/fidothe/saxon-rb

data/lib/saxon/xslt/static_context.rb

@@ -1,69 +0,0 @@
-require_relative '../qname'
-module Saxon
-  module XSLT
-    # Represents the static context for an XSLT compiler. {StaticContext}s are immutable.
-    class StaticContext
-      # methods used by both {StaticContext} and {StaticContext::DSL}
-      module Common
-        # @param args [Hash]
-        # @option args [Hash<String => java.text.Collator>] :declared_collations Hash of URI => Collator bindings
-        # @option args [String] :default_collation URI of the default collation
-        def initialize(args = {})
-          @default_collation = args.fetch(:default_collation, nil).freeze
-        end
-
-        # returns the context details in a hash suitable for initializing a new one
-        # @return [Hash<Symbol => Hash,null>] the args hash
-        def args_hash
-          {
-            default_collation: @default_collation
-          }
-        end
-      end
-
-      # Provides the hooks for constructing a {StaticContext} with a DSL.
-      # @api private
-      class DSL
-        include Common
-
-        # Create an instance based on the args hash, and execute the passed in Proc/lambda against it using <tt>#instance_exec</tt> and return a
-        # new {StaticContext} with the results
-        # @param block [Proc] a Proc/lambda (or <tt>to_proc</tt>'d containing DSL calls
-        # @return [Saxon::XPath::StaticContext]
-        def self.define(block, args = {})
-          dsl = new(args)
-          dsl.instance_exec(&block) unless block.nil?
-          StaticContext.new(dsl.args_hash)
-        end
-
-        # Set the default Collation to use. This should be one of the special
-        # collation URIs Saxon recognises, or one that has been registered
-        # using Saxon::Processor#declare_collations on the Processor that
-        # created the {XSLT::Compiler} this context is for.
-        #
-        # @param collation_uri [String] The URI of the Collation to set as the default
-        def default_collation(collation_uri)
-          @default_collation = collation_uri
-        end
-      end
-
-      include Common
-
-      # Executes the Proc/lambda passed in with a new instance of
-      # {StaticContext} as <tt>self</tt>, allowing the DSL methods to be
-      # called in a DSL-ish way
-      #
-      # @param block [Proc] the block of DSL calls to be executed
-      # @return [Saxon::XSLT::StaticContext] the static context created by the block
-      def self.define(block)
-        DSL.define(block)
-      end
-
-      attr_reader :default_collation
-
-      def define(block)
-        DSL.define(block, args_hash)
-      end
-    end
-  end
-end