sparql 3.0.2 → 3.1.0

data/lib/sparql/algebra/operator/bnode.rb

@@ -30,7 +30,7 @@ module SPARQL; module Algebra
       # @param  [Hash{Symbol => Object}] options
       #   any additional options (see {Operator#initialize})
       # @raise  [TypeError] if any operand is invalid
-      def initialize(literal = false, options = {})
+      def initialize(literal = false, **options)
         super
       end
 
@@ -42,8 +42,8 @@ module SPARQL; module Algebra
       # @param [Hash{Symbol => Object}] options ({})
       #   options passed from query
       # @return [RDF::Term]
-      def evaluate(bindings, options = {})
-        args = operands.map { |operand| operand.evaluate(bindings, options.merge(depth: options[:depth].to_i + 1)) }
+      def evaluate(bindings, **options)
+        args = operands.map { |operand| operand.evaluate(bindings, depth: options[:depth].to_i + 1, **options) }
         apply(args.first, bindings)
       end
 

data/lib/sparql/algebra/operator/bound.rb

@@ -25,7 +25,7 @@ module SPARQL; module Algebra
       # @param  [Hash{Symbol => Object}] options
       #   any additional options (see {Operator#initialize})
       # @raise  [TypeError] if any operand is invalid
-      def initialize(var, options = {})
+      def initialize(var, **options)
         super
       end
 
@@ -38,7 +38,7 @@ module SPARQL; module Algebra
       #   options passed from query
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if the operand is not a variable
-      def evaluate(bindings, options = {})
+      def evaluate(bindings, **options)
         case var = operand
           when Variable
             bindings.respond_to?(:bound?) && bindings.bound?(var) ?

data/lib/sparql/algebra/operator/clear.rb

@@ -29,7 +29,7 @@ module SPARQL; module Algebra
       # @raise [IOError]
       #   If `from` does not exist, unless the `silent` operator is present
       # @see    http://www.w3.org/TR/sparql11-update/
-      def execute(queryable, options = {})
+      def execute(queryable, **options)
         debug(options) {"Clear"}
         silent = operands.first == :silent
         operands.shift if silent

data/lib/sparql/algebra/operator/coalesce.rb

@@ -41,10 +41,10 @@ module SPARQL; module Algebra
       #   options passed from query
       # @return [RDF::Term]
       # @raise  [TypeError] if none of the operands succeeds
-      def evaluate(bindings, options = {})
+      def evaluate(bindings, **options)
         operands.each do |op|
           begin
-            return op.evaluate(bindings, options.merge(depth: options[:depth].to_i + 1))
+            return op.evaluate(bindings, depth: options[:depth].to_i + 1, **options)
           rescue
           end
         end

data/lib/sparql/algebra/operator/concat.rb

@@ -32,8 +32,8 @@ module SPARQL; module Algebra
       #   options passed from query
       # @return [RDF::Term]
       # @raise  [TypeError] if any operand is not a literal
-      def evaluate(bindings, options = {})
-        ops = operands.map {|op| op.evaluate(bindings, options.merge(depth: options[:depth].to_i + 1))}
+      def evaluate(bindings, **options)
+        ops = operands.map {|op| op.evaluate(bindings, depth: options[:depth].to_i + 1, **options)}
 
         raise TypeError, "expected all plain literal operands" unless ops.all? {|op| op.literal? && op.plain?}
 

data/lib/sparql/algebra/operator/construct.rb

@@ -35,13 +35,13 @@ module SPARQL; module Algebra
       # @return [RDF::Queryable]
       #   A Queryable with constructed triples
       # @see    http://www.w3.org/TR/sparql11-query/#construct
-      def execute(queryable, options = {}, &block)
+      def execute(queryable, **options, &block)
         debug(options) {"Construct #{operands.first}, #{options.inspect}"}
         graph = RDF::Graph.new
         patterns = operands.first
         query = operands.last
 
-        queryable.query(query, options.merge(depth: options[:depth].to_i + 1)).each do |solution|
+        queryable.query(query, depth: options[:depth].to_i + 1, **options).each do |solution|
           debug(options) {"(construct apply) #{solution.inspect} to BGP"}
           
           # Create a mapping from BNodes within the pattern list to newly constructed BNodes

data/lib/sparql/algebra/operator/copy.rb

@@ -29,7 +29,7 @@ module SPARQL; module Algebra
       # @raise [IOError]
       #   If `from` does not exist, unless the `silent` operator is present
       # @see    http://www.w3.org/TR/sparql11-update/
-      def execute(queryable, options = {})
+      def execute(queryable, **options)
         debug(options) {"Copy"}
         silent = operands.first == :silent
         operands.shift if silent

data/lib/sparql/algebra/operator/count.rb

@@ -6,8 +6,8 @@ module SPARQL; module Algebra
     # @example
     #    (prefix ((: <http://www.example.org>))
     #      (project (?C)
-    #        (extend ((?C ?.0))
-    #          (group () ((?.0 (count ?O)))
+    #        (extend ((?C ??.0))
+    #          (group () ((??.0 (count ?O)))
     #            (bgp (triple ?S ?P ?O))))))
     #
     # @see http://www.w3.org/TR/sparql11-query/#defn_aggCount

data/lib/sparql/algebra/operator/create.rb

@@ -31,7 +31,7 @@ module SPARQL; module Algebra
       # @raise [IOError]
       #   If `from` does not exist, unless the `silent` operator is present
       # @see    http://www.w3.org/TR/sparql11-update/
-      def execute(queryable, options = {})
+      def execute(queryable, **options)
         debug(options) {"Create"}
         silent = operands.first == :silent
         operands.shift if silent

data/lib/sparql/algebra/operator/dataset.rb

@@ -126,7 +126,7 @@ module SPARQL; module Algebra
       # @return [RDF::Query::Solutions]
       #   the resulting solution sequence
       # @see    http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
-      def execute(queryable, options = {}, &base)
+      def execute(queryable, **options, &base)
         debug(options) {"Dataset"}
         default_datasets = []
         named_datasets = []
@@ -144,7 +144,7 @@ module SPARQL; module Algebra
           load_opts = {debug: options.fetch(:debug, nil), graph_name: uri, base_uri: uri}
           unless queryable.has_graph?(uri)
             debug(options) {"=> load #{uri}"}
-            queryable.load(uri.to_s, load_opts)
+            queryable.load(uri.to_s, **load_opts)
           end
         end
         debug(options) {
@@ -156,7 +156,7 @@ module SPARQL; module Algebra
         aggregate = RDF::AggregateRepo.new(queryable)
         named_datasets.each {|name| aggregate.named(name) if queryable.has_graph?(name)}
         aggregate.default(*default_datasets.select {|name| queryable.has_graph?(name)})
-        aggregate.query(operands.last, options.merge(depth: options[:depth].to_i + 1), &base)
+        aggregate.query(operands.last, depth: options[:depth].to_i + 1, **options, &base)
       end
       
       ##

data/lib/sparql/algebra/operator/delete.rb

@@ -20,7 +20,7 @@ module SPARQL; module Algebra
       #
       # @param  [RDF::Queryable] queryable
       #   the graph or repository to write
-      # @param  [RDF::Query::Solution] solution
+      # @param  [RDF::Query::Solution] :solution
       #   Solution to map to patterns for this operation
       # @param  [Hash{Symbol => Object}] options
       #   any additional keyword options
@@ -31,8 +31,10 @@ module SPARQL; module Algebra
       # @raise [IOError]
       #   If `from` does not exist, unless the `silent` operator is present
       # @see    http://www.w3.org/TR/sparql11-update/
-      def execute(queryable, solution, options = {})
+      def execute(queryable, solutions: nil, **options)
         debug(options) {"Delete: #{solution} against #{operands.to_sse}"}
+        # Only binds the first solution
+        solution = solutions.is_a?(RDF::Query::Solutions) ? solutions.first : solutions
         # Operands are an array of patterns and Queries (when named).
         # Create a new query made up all patterns
         patterns = operand.inject([]) do |memo, op|

data/lib/sparql/algebra/operator/delete_data.rb

@@ -29,7 +29,7 @@ module SPARQL; module Algebra
       # @raise [IOError]
       #   If `from` does not exist, unless the `silent` operator is present
       # @see    http://www.w3.org/TR/sparql11-update/
-      def execute(queryable, options = {})
+      def execute(queryable, **options)
         operand.each do |op|
           debug(options) {"DeleteData #{op.to_sxp}"}
           queryable.delete(op)

data/lib/sparql/algebra/operator/delete_where.rb

@@ -29,7 +29,7 @@ module SPARQL; module Algebra
       # @raise [IOError]
       #   If `from` does not exist, unless the `silent` operator is present
       # @see    http://www.w3.org/TR/sparql11-update/
-      def execute(queryable, options = {})
+      def execute(queryable, **options)
         # Operands are an array of patterns and Queries (when named).
         # Create a new query made up all patterns
         patterns = operand.inject([]) do |memo, op|
@@ -40,9 +40,9 @@ module SPARQL; module Algebra
           end
           memo
         end
-        query = RDF::Query.new(*patterns, {}) # FIXME: added hash argument needed until Statement#to_hash removed.
+        query = RDF::Query.new(*patterns, **{}) # FIXME: added hash argument needed until Statement#to_hash removed.
         debug(options) {"DeleteWhere query #{query.to_sse}"}
-        query.execute(queryable, options.merge(depth: options[:depth].to_i + 1)) do |solution|
+        query.execute(queryable, depth: options[:depth].to_i + 1, **options) do |solution|
           debug(options) {"DeleteWhere solution #{solution.to_sse}"}
           query.each_statement do |pattern|
             pattern = pattern.dup.bind(solution)

data/lib/sparql/algebra/operator/describe.rb

@@ -40,7 +40,7 @@ module SPARQL; module Algebra
       # @return [RDF::Graph]
       #   containing the constructed triples
       # @see    http://www.w3.org/TR/sparql11-query/#describe
-      def execute(queryable, options = {}, &block)
+      def execute(queryable, **options, &block)
         debug(options) {"Describe #{operands.first}, #{options.inspect}"}
 
         # Describe any constand URIs

data/lib/sparql/algebra/operator/distinct.rb

@@ -31,8 +31,8 @@ module SPARQL; module Algebra
       # @return [RDF::Query::Solutions]
       #   the resulting solution sequence
       # @see    http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
-      def execute(queryable, options = {}, &block)
-        @solutions = queryable.query(operands.last, options.merge(depth: options[:depth].to_i + 1)).distinct
+      def execute(queryable, **options, &block)
+        @solutions = queryable.query(operands.last, depth: options[:depth].to_i + 1, **options).distinct
         @solutions.each(&block) if block_given?
         @solutions
       end

data/lib/sparql/algebra/operator/drop.rb

@@ -31,7 +31,7 @@ module SPARQL; module Algebra
       # @raise [IOError]
       #   If `from` does not exist, unless the `silent` operator is present
       # @see    http://www.w3.org/TR/sparql11-update/
-      def execute(queryable, options = {})
+      def execute(queryable, **options)
         debug(options) {"Drop"}
         silent = operands.first == :silent
         silent = operands.first == :silent

data/lib/sparql/algebra/operator/encode_for_uri.rb

@@ -29,7 +29,7 @@ module SPARQL; module Algebra
       # @raise  [TypeError] if the operand is not a literal value
       def apply(operand)
         case operand
-          when RDF::Literal then RDF::Literal(::URI.encode(operand.to_s))
+          when RDF::Literal then RDF::Literal(CGI.escape(operand.to_s))
           else raise TypeError, "expected an RDF::Literal, but got #{operand.inspect}"
         end
       end

data/lib/sparql/algebra/operator/exists.rb

@@ -26,11 +26,11 @@ module SPARQL; module Algebra
       # @option options[RDF::Queryable] queryable
       #   queryable to execute, using bindings as an initial solution.
       # @return [RDF::Literal::Boolean] `true` or `false`
-      def evaluate(bindings, options = {})
+      def evaluate(bindings, **options)
         queryable = options[:queryable]
-        !operand(0).execute(queryable, options.merge(
-                                        solutions: RDF::Query::Solutions(bindings),
-                                        depth: options[:depth].to_i + 1)).empty?
+        !operand(0).execute(queryable, solutions: RDF::Query::Solutions(bindings),
+                                       depth: options[:depth].to_i + 1,
+                                       **options).empty?
       end
     end # Exists
   end # Operator

data/lib/sparql/algebra/operator/exprlist.rb

@@ -36,8 +36,8 @@ module SPARQL; module Algebra
       #   options passed from query
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if the operands could not be coerced to a boolean literal
-      def evaluate(bindings, options = {})
-        res = operands.all? {|op| boolean(op.evaluate(bindings, options.merge(depth: options[:depth].to_i + 1))).true? }
+      def evaluate(bindings, **options)
+        res = operands.all? {|op| boolean(op.evaluate(bindings, depth: options[:depth].to_i + 1, **options)).true? }
         RDF::Literal(res) # FIXME: error handling
       end
 

data/lib/sparql/algebra/operator/extend.rb

@@ -39,16 +39,16 @@ module SPARQL; module Algebra
       # @return [RDF::Query::Solutions]
       #   the resulting solution sequence
       # @see http://www.w3.org/TR/sparql11-query/#evaluation
-      def execute(queryable, options = {}, &block)
+      def execute(queryable, **options, &block)
         debug(options) {"Extend"}
-        @solutions = operand(1).execute(queryable, options.merge(depth: options[:depth].to_i + 1))
+        @solutions = operand(1).execute(queryable, depth: options[:depth].to_i + 1, **options)
         @solutions.each do |solution|
           debug(options) {"===> soln #{solution.to_h.inspect}"}
           operand(0).each do |(var, expr)|
             begin
-              val = expr.evaluate(solution, options.merge(
-                                              queryable: queryable,
-                                              depth: options[:depth].to_i + 1))
+              val = expr.evaluate(solution, queryable: queryable,
+                                            depth: options[:depth].to_i + 1,
+                                            **options)
               debug(options) {"===> + #{var} => #{val.inspect}"}
               solution.bindings[var.to_sym] = val
             rescue TypeError => e

data/lib/sparql/algebra/operator/filter.rb

@@ -36,13 +36,13 @@ module SPARQL; module Algebra
       #   the resulting solution sequence
       # @see    http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
       # @see    http://www.w3.org/TR/sparql11-query/#ebv
-      def execute(queryable, options = {}, &block)
+      def execute(queryable, **options, &block)
         debug(options) {"Filter #{operands.first.to_sxp}"}
         opts = options.merge(queryable: queryable, depth: options[:depth].to_i + 1)
         @solutions = RDF::Query::Solutions()
-        queryable.query(operands.last, options.merge(depth: options[:depth].to_i + 1)) do |solution|
+        queryable.query(operands.last, depth: options[:depth].to_i + 1, **options) do |solution|
           begin
-            pass = boolean(operands.first.evaluate(solution, opts)).true?
+            pass = boolean(operands.first.evaluate(solution, **opts)).true?
             debug(options) {"(filter) #{pass.inspect} #{solution.to_h.inspect}"}
             @solutions << solution if pass
           rescue

data/lib/sparql/algebra/operator/graph.rb

@@ -64,10 +64,10 @@ module SPARQL; module Algebra
       # @return [RDF::Query::Solutions]
       #   the resulting solution sequence
       # @see    http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
-      def execute(queryable, options = {}, &block)
+      def execute(queryable, **options, &block)
         debug(options) {"Graph #{operands.first}"}
         graph_name, query = operands.first, operands.last
-        @solutions = queryable.query(query, options.merge(graph_name: graph_name), &block)
+        @solutions = queryable.query(query, graph_name: graph_name, **options, &block)
       end
       
       ##

data/lib/sparql/algebra/operator/group.rb

@@ -11,8 +11,8 @@ module SPARQL; module Algebra
     # @example
     #     (prefix ((: <http://example/>))
     #       (project (?w ?S)
-    #         (extend ((?S ?.0))
-    #           (group (?w) ((?.0 (sample ?v)))
+    #         (extend ((?S ??.0))
+    #           (group (?w) ((??.0 (sample ?v)))
     #             (leftjoin
     #               (bgp (triple ?s :p ?v))
     #               (bgp (triple ?s :q ?w)))))))
@@ -38,12 +38,12 @@ module SPARQL; module Algebra
       # @return [RDF::Query::Solutions]
       #   the resulting solution sequence
       # @see    http://www.w3.org/TR/sparql11-query/#sparqlGroupAggregate
-      def execute(queryable, options = {}, &block)
+      def execute(queryable, **options, &block)
         debug(options) {"Group"}
         exprlist = operands.first
         query = operands.last
         aggregates = operands.length == 3 ? operand(1) : []
-        solutions = queryable.query(query, options.merge(depth: options[:depth].to_i + 1))
+        solutions = queryable.query(query, depth: options[:depth].to_i + 1, **options)
 
         groups = solutions.group_by do |solution|
           # Evaluate each exprlist operand to get groups where each key is a new solution
@@ -54,14 +54,14 @@ module SPARQL; module Algebra
               if operand.is_a?(Array)
                 # Form is [variable, expression]
                 soln[operand.first] = operand.last.evaluate(solution,
-                                                            options.merge(
-                                                             queryable: queryable,
-                                                             depth: options[:depth].to_i + 1))
+                                                            queryable: queryable,
+                                                            depth: options[:depth].to_i + 1,
+                                                            **options)
               else
                 # Form is variable
-                soln[operand] = operand.evaluate(solution, options.merge(
-                                                            queryable: queryable,
-                                                            depth: options[:depth].to_i + 1))
+                soln[operand] = operand.evaluate(solution, queryable: queryable,
+                                                           depth: options[:depth].to_i + 1,
+                                                           **options)
               end
             rescue TypeError
               # Ignore expression
@@ -76,7 +76,7 @@ module SPARQL; module Algebra
         @solutions = RDF::Query::Solutions(groups.map do |group_soln, solns|
           aggregates.each do |(var, aggregate)|
             begin
-              group_soln[var] = aggregate.aggregate(solns, options)
+              group_soln[var] = aggregate.aggregate(solns, **options)
             rescue TypeError
               # Ignored in output
             end

data/lib/sparql/algebra/operator/group_concat.rb

@@ -9,9 +9,9 @@ module SPARQL; module Algebra
     #    (prefix ((: <http://www.example.org/>))
     #      (filter (|| (= ?g "1 22") (= ?g "22 1"))
     #        (project (?g)
-    #          (extend ((?g ?.0))
-    #            (group () ((?.0 (group_concat ?o)))
-    #              (bgp (triple ??0 :p1 ?o)))))))
+    #          (extend ((?g ??.0))
+    #            (group () ((??.0 (group_concat ?o)))
+    #              (bgp (triple ??.0 :p1 ?o)))))))
     #
     # @see http://www.w3.org/TR/sparql11-query/#defn_aggGroupConcat
     class GroupConcat < Operator
@@ -29,12 +29,12 @@ module SPARQL; module Algebra
       # @return [RDF::Term]
       # @raise [TypeError]
       # @abstract
-      def aggregate(solutions = [], options = {})
+      def aggregate(solutions = [], **options)
         operands.shift if distinct = (operands.first == :distinct)
         sep = operands.length == 2 ? operand(0).last : RDF::Literal(' ')
         args_enum = solutions.map do |solution|
           begin
-            operands.last.evaluate(solution, options.merge(depth: options[:depth].to_i + 1))
+            operands.last.evaluate(solution, depth: options[:depth].to_i + 1, **options)
           rescue TypeError
             # Ignore errors
             nil

data/lib/sparql/algebra/operator/if.rb

@@ -33,10 +33,10 @@ module SPARQL; module Algebra
       #   a query solution containing zero or more variable bindings
       # @return [RDF::Term]
       # @raise [TypeError]
-      def evaluate(bindings, options = {})
-        operand(0).evaluate(bindings, options.merge(depth: options[:depth].to_i + 1)) == RDF::Literal::TRUE ?
-          operand(1).evaluate(bindings, options.merge(depth: options[:depth].to_i + 1).merge(depth: options[:depth].to_i + 1)) :
-          operand(2).evaluate(bindings, options.merge(depth: options[:depth].to_i + 1))
+      def evaluate(bindings, **options)
+        operand(0).evaluate(bindings, depth: options[:depth].to_i + 1, **options) == RDF::Literal::TRUE ?
+          operand(1).evaluate(bindings, depth: options[:depth].to_i + 1, **options) :
+          operand(2).evaluate(bindings, depth: options[:depth].to_i + 1, **options)
         rescue
           raise TypeError
       end

data/lib/sparql/algebra/operator/in.rb

@@ -38,12 +38,12 @@ module SPARQL; module Algebra
       #   options passed from query
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if term is not found and any operand raises an error
-      def evaluate(bindings, options = {})
-        lhs = operands.first.evaluate(bindings, options)
+      def evaluate(bindings, **options)
+        lhs = operands.first.evaluate(bindings, **options)
         error_found = false
         found = operands[1..-1].any? do |op|
           begin
-            lhs == op.evaluate(bindings, options.merge(depth: options[:depth].to_i + 1))
+            lhs == op.evaluate(bindings, depth: options[:depth].to_i + 1, **options)
           rescue TypeError
             error_found = true
           end

data/lib/sparql/algebra/operator/insert.rb

@@ -20,7 +20,7 @@ module SPARQL; module Algebra
       #
       # @param  [RDF::Queryable] queryable
       #   the graph or repository to write
-      # @param  [RDF::Query::Solution] solution
+      # @param  [RDF::Query::Solution] :solutions
       #   Solution to map to patterns for this operation
       # @param  [Hash{Symbol => Object}] options
       #   any additional keyword options
@@ -31,7 +31,9 @@ module SPARQL; module Algebra
       # @raise [IOError]
       #   If `from` does not exist, unless the `silent` operator is present
       # @see    http://www.w3.org/TR/sparql11-update/
-      def execute(queryable, solution, options = {})
+      def execute(queryable, solutions: nil, **options)
+        # Only binds the first solution
+        solution = solutions.is_a?(RDF::Query::Solutions) ? solutions.first : solutions
         debug(options) {"Insert"}
         patterns = operand.inject([]) do |memo, op|
           if op.respond_to?(:statements)