sparql 3.2.4 → 3.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 932897287930ea7265a07628e73c13a06b02b9e0d1572b578356166d3c8fe70a
-  data.tar.gz: 9d17310bc07080475780c8acccbe57acb4bbeb40e3f66ab7b74a09b15ccf0863
+  metadata.gz: eaf1d4f46a557ae2b96d66c5a8fc8b774eb9819a71304fa2d25ada151ba39671
+  data.tar.gz: e61f360e22fcaf413e71be501368ef36fa8860c71e7a714222a59ec021e44bbc
 SHA512:
-  metadata.gz: e701784500aece828b2cfd41eb0af78a809bda575eed047158e962ff38678d524b179c0c3faef21fc5b5724894ada3066637b608778a1809fdc7b9bda2ffe2a2
-  data.tar.gz: 77c2520a5f4923a1fe27d589ea6a09b6f5a36fa9c17b564184f206971204fec6988b0941c350e10d812ccfd9b0934e6ae629b82207abfaabf8d7bcc3a380ab33
+  metadata.gz: ee8251bc196d3851505802091dbcfbc206a26ac01d86eecaa5c90ebaa4b6d2f8ce23b5f9fd4b8e6b8cce5ca7e4a588ef90f981d7c950538986fb3fbf953cc324
+  data.tar.gz: 7392fb08ce46900aea2792bb565c880349e4c2f1f19d42d90e6ada7058d501a18bc5acce45728207800bd74356a331107a20a70ac7ba25497dec9eb3a6a9fd3c

data/VERSION

@@ -1 +1 @@
-3.2.4
+3.2.5

data/lib/sparql/algebra/aggregate.rb

@@ -29,7 +29,7 @@ module SPARQL; module Algebra
       args_enum = solutions.map do |solution|
         operands.map do |operand|
           begin
-            operand.evaluate(solution, depth: options[:depth].to_i + 1, **options)
+            operand.evaluate(solution, **options.merge(depth: options[:depth].to_i + 1))
           rescue TypeError
             # Ignore errors
             nil

data/lib/sparql/algebra/evaluatable.rb

@@ -14,7 +14,7 @@ module SPARQL; module Algebra
     # @return [RDF::Term]
     # @abstract
     def evaluate(bindings, **options)
-      args = operands.map { |operand| operand.evaluate(bindings, depth: options[:depth].to_i + 1, **options) }
+      args = operands.map { |operand| operand.evaluate(bindings, **options.merge(depth: options[:depth].to_i + 1)) }
       options[:memoize] ? memoize(*args, **options) : apply(*args, **options)
     end
 

data/lib/sparql/algebra/expression.rb

@@ -112,7 +112,7 @@ module SPARQL; module Algebra
         return case sse.first
         when Array
           debug(options) {"Map array elements #{sse}"}
-          sse.map {|s| self.new(s, parent_operator: parent_operator, depth: options[:depth].to_i + 1, **options)}
+          sse.map {|s| self.new(s, parent_operator: parent_operator, **options.merge(depth: options[:depth].to_i + 1))}
         else
           debug(options) {"No operator found for #{sse.first}"}
           sse.map do |s|
@@ -127,7 +127,7 @@ module SPARQL; module Algebra
         debug(options) {"Operator=#{operator.inspect}, Operand=#{operand.inspect}"}
         case operand
           when Array
-            self.new(operand, parent_operator: operator, depth: options[:depth].to_i + 1, **options)
+            self.new(operand, parent_operator: operator, **options.merge(depth: options[:depth].to_i + 1))
           when Operator, Variable, RDF::Term, RDF::Query, Symbol
             operand
           when TrueClass, FalseClass, Numeric, String, DateTime, Date, Time

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

@@ -70,7 +70,7 @@ module SPARQL; module Algebra
         end
 
         query = Union.new(qa, qb)
-        queryable.query(query, depth: options[:depth].to_i + 1, **options, &block)
+        queryable.query(query, **options.merge(depth: options[:depth].to_i + 1), &block)
       end
 
       ##

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

@@ -52,13 +52,13 @@ module SPARQL; module Algebra
       # @raise  [TypeError] if the operands could not be coerced to boolean literals
       def evaluate(bindings, **options)
         begin
-          left = boolean(operand(0).evaluate(bindings, depth: options[:depth].to_i + 1, **options)).true?
+          left = boolean(operand(0).evaluate(bindings, **options.merge(depth: options[:depth].to_i + 1))).true?
         rescue TypeError
           left = nil
         end
         
         begin
-          right = boolean(operand(1).evaluate(bindings, depth: options[:depth].to_i + 1, **options)).true?
+          right = boolean(operand(1).evaluate(bindings, **options.merge(depth: options[:depth].to_i + 1))).true?
         rescue TypeError
           right = nil
         end

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

@@ -33,7 +33,7 @@ module SPARQL; module Algebra
       #   options passed from query
       # @return [RDF::Term]
       def evaluate(bindings, **options)
-        operand(0).evaluate(bindings, depth: options[:depth].to_i + 1, **options)
+        operand(0).evaluate(bindings, **options.merge(depth: options[:depth].to_i + 1))
       end
 
       ##

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

@@ -37,7 +37,7 @@ module SPARQL; module Algebra
       # @see    https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
       def execute(queryable, **options)
         debug(options) {"Ask #{operands.first}"}
-        res = boolean(!queryable.query(operands.last, depth: options[:depth].to_i + 1, **options).empty?)
+        res = boolean(!queryable.query(operands.last, **options.merge(depth: options[:depth].to_i + 1)).empty?)
         yield res if block_given?
         res
       end

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

@@ -38,7 +38,7 @@ module SPARQL; module Algebra
       def execute(queryable, **options, &block)
         debug(options) {"Base #{operands.first}"}
         Operator.base_uri = operands.first
-        queryable.query(operands.last, depth: options[:depth].to_i + 1, **options, &block)
+        queryable.query(operands.last, **options.merge(depth: options[:depth].to_i + 1), &block)
       end
 
       ##

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

@@ -57,7 +57,7 @@ module SPARQL; module Algebra
       #   options passed from query
       # @return [RDF::Term]
       def evaluate(bindings, **options)
-        args = operands.map { |operand| operand.evaluate(bindings, depth: options[:depth].to_i + 1, **options) }
+        args = operands.map { |operand| operand.evaluate(bindings, **options.merge(depth: options[:depth].to_i + 1)) }
         apply(args.first, bindings)
       end
 

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

@@ -57,7 +57,7 @@ module SPARQL; module Algebra
       def evaluate(bindings, **options)
         operands.each do |op|
           begin
-            return op.evaluate(bindings, depth: options[:depth].to_i + 1, **options)
+            return op.evaluate(bindings, **options.merge(depth: options[:depth].to_i + 1))
           rescue
           end
         end

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

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

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

@@ -51,7 +51,7 @@ module SPARQL; module Algebra
         patterns = operands.first
         query = operands.last
 
-        queryable.query(query, depth: options[:depth].to_i + 1, **options).each do |solution|
+        queryable.query(query, **options.merge(depth: options[:depth].to_i + 1)).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/dataset.rb

@@ -149,7 +149,7 @@ module SPARQL; module Algebra
         debug(options) {"Dataset"}
         if %i(default-graph-uri named-graph-uri).any? {|k| options.key?(k)} 
           debug("=> Skip constructing merge repo due to options", options)
-          return queryable.query(operands.last, depth: options[:depth].to_i + 1, **options, &base)
+          return queryable.query(operands.last, **options.merge(depth: options[:depth].to_i + 1), &base)
         end
  
         default_datasets = []
@@ -180,7 +180,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, depth: options[:depth].to_i + 1, **options, &base)
+        aggregate.query(operands.last, **options.merge(depth: options[:depth].to_i + 1), &base)
       end
 
       ##

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

@@ -53,7 +53,7 @@ module SPARQL; module Algebra
         end
         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, depth: options[:depth].to_i + 1, **options) do |solution|
+        query.execute(queryable, **options.merge(depth: options[:depth].to_i + 1)) do |solution|
           debug(options) {"DeleteWhere solution #{solution.to_sse}"}
           query.each_statement do |pattern|
             pattern = pattern.dup.bind(solution)

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

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

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

@@ -50,7 +50,7 @@ module SPARQL; module Algebra
       # @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, depth: options[:depth].to_i + 1, **options)).true? }
+        res = operands.all? {|op| boolean(op.evaluate(bindings, **options.merge(depth: options[:depth].to_i + 1))).true? }
         RDF::Literal(res) # FIXME: error handling
       end
     end # Exprlist

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

@@ -82,7 +82,7 @@ module SPARQL; module Algebra
       # @see https://www.w3.org/TR/sparql11-query/#evaluation
       def execute(queryable, **options, &block)
         debug(options) {"Extend"}
-        @solutions = operand(1).execute(queryable, depth: options[:depth].to_i + 1, **options)
+        @solutions = operand(1).execute(queryable, **options.merge(depth: options[:depth].to_i + 1))
         @solutions.each do |solution|
           # Re-bind to bindings, if defined, as they might not be found in solution
           options[:bindings].each_binding do |name, value|
@@ -93,8 +93,7 @@ module SPARQL; module Algebra
           operand(0).each do |(var, expr)|
             begin
               val = expr.evaluate(solution, queryable: queryable,
-                                            depth: options[:depth].to_i + 1,
-                                            **options)
+                                            **options.merge(depth: options[:depth].to_i + 1))
               debug(options) {"===> + #{var} => #{val.inspect}"}
               val = val.dup.bind(solution) if val.is_a?(RDF::Query::Pattern)
               solution.bindings[var.to_sym] = val

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

@@ -48,7 +48,7 @@ module SPARQL; module Algebra
         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, depth: options[:depth].to_i + 1, **options) do |solution|
+        queryable.query(operands.last, **options.merge(depth: options[:depth].to_i + 1)) do |solution|
           # Re-bind to bindings, if defined, as they might not be found in solution
           options[:bindings].each_binding do |name, value|
             solution[name] ||= value if operands.first.variables.include?(name)

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

@@ -82,7 +82,7 @@ module SPARQL; module Algebra
         exprlist = operands.first
         query = operands.last
         aggregates = operands.length == 3 ? operand(1) : []
-        solutions = queryable.query(query, depth: options[:depth].to_i + 1, **options)
+        solutions = queryable.query(query, **options.merge(depth: options[:depth].to_i + 1))
 
         groups = solutions.group_by do |solution|
           # Evaluate each exprlist operand to get groups where each key is a new solution

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

@@ -55,7 +55,7 @@ module SPARQL; module Algebra
         sep = operands.length == 2 ? operand(0).last : RDF::Literal(' ')
         args_enum = solutions.map do |solution|
           begin
-            operands.last.evaluate(solution, depth: options[:depth].to_i + 1, **options)
+            operands.last.evaluate(solution, **options.merge(depth: options[:depth].to_i + 1))
           rescue TypeError
             # Ignore errors
             nil

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

@@ -42,9 +42,9 @@ module SPARQL; module Algebra
       # @return [RDF::Term]
       # @raise [TypeError]
       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)
+        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)) :
+          operand(2).evaluate(bindings, **options.merge(depth: options[:depth].to_i + 1))
       rescue
         raise TypeError
       end

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

@@ -48,7 +48,7 @@ module SPARQL; module Algebra
         error_found = false
         found = operands[1..-1].any? do |op|
           begin
-            lhs == op.evaluate(bindings, depth: options[:depth].to_i + 1, **options)
+            lhs == op.evaluate(bindings, **options.merge(depth: options[:depth].to_i + 1))
           rescue TypeError
             error_found = true
           end

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

@@ -66,10 +66,10 @@ module SPARQL; module Algebra
         # Generate solutions independently, merge based on solution compatibility
         debug(options) {"Join #{operands.to_sse}"}
  
-        left = queryable.query(operand(0), depth: options[:depth].to_i + 1, **options)
+        left = queryable.query(operand(0), **options.merge(depth: options[:depth].to_i + 1))
         debug(options) {"(join)=>(left) #{left.map(&:to_h).to_sse}"}
 
-        right = queryable.query(operand(1), depth: options[:depth].to_i + 1, **options)
+        right = queryable.query(operand(1), **options.merge(depth: options[:depth].to_i + 1))
         debug(options) {"(join)=>(right) #{right.map(&:to_h).to_sse}"}
 
         @solutions = RDF::Query::Solutions(left.map do |s1|

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

@@ -54,10 +54,10 @@ module SPARQL; module Algebra
           operands.length < 2 || operands.length > 3
 
         debug(options) {"LeftJoin"}
-        left = queryable.query(operand(0), depth: options[:depth].to_i + 1, **options)
+        left = queryable.query(operand(0), **options.merge(depth: options[:depth].to_i + 1))
         debug(options) {"=>(leftjoin left) #{left.inspect}"}
 
-        right = queryable.query(operand(1), depth: options[:depth].to_i + 1, **options)
+        right = queryable.query(operand(1), **options.merge(depth: options[:depth].to_i + 1))
         debug(options) {"=>(leftjoin right) #{right.inspect}"}
 
         # LeftJoin(Ω1, Ω2, expr) =
@@ -71,6 +71,30 @@ module SPARQL; module Algebra
               s[name] = value if filter.variables.include?(name)
             end if options[:bindings] && filter.respond_to?(:variables)
 
+            # See https://github.com/w3c/rdf-tests/pull/83#issuecomment-1324220844 for @afs's discussion of the simplified/not-simplified issue.
+            #
+            # The difference is when simplification is applied. It matters for OPTIONAL because OPTIONAL { ... FILTER(...) } puts the filter into the LeftJoin expressions. In LeftJoin, the FILTER can see the left-hand-side variables. (SQL: LEFT JOIN ... ON ...)
+            # 
+            # For OPTIONAL { { ... FILTER(...) } }, the inner part is Join({}, {.... FILTER }).
+            # 
+            # if simplify happens while coming back up the tree generating algebra operations, it removes the join i.e. the inner of {{ }}, and passes "... FILTER()" to the OPTIONAL. The effect of the extra nesting in {{ }} is lost and it exposes the filter to the OPTIONAL rule.
+            # 
+            # if simplification happens as a step after the whole algebra is converted, this does not happen. Compiling the OPTIONAL see a join and the filter is not at the top level of the OPTIONAl block and so not handled in the LeftJoin.
+            # 
+            # Use case:
+            # 
+            # # Include name if person over 18
+            # SELECT *
+            # { ?person :age ?age 
+            #    OPTIONAL { ?person :name ?name. FILTER(?age > 18) }
+            # }
+            # Hindsight: a better syntax would be call out if the filter needed access to the LHS.
+            # 
+            # OPTIONAL FILTER(....) { }
+            # 
+            # But we are where we are.
+            # 
+            # (a "no conditions on LeftJoin" approach would mean users having to duplicate parts of their query - possibly quite large parts.)
             expr = filter ? boolean(filter.evaluate(s)).true? : true rescue false
             debug(options) {"===>(evaluate) #{s.inspect}"} if filter
 

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

@@ -71,9 +71,9 @@ module SPARQL; module Algebra
         # 
         # card[Minus(Ω1, Ω2)](μ) = card[Ω1](μ)
         debug(options) {"Minus"}
-        left = queryable.query(operand(0), depth: options[:depth].to_i + 1, **options)
+        left = queryable.query(operand(0), **options.merge(depth: options[:depth].to_i + 1))
         debug(options) {"(minus left) #{left.inspect}"}
-        right = queryable.query(operand(1), depth: options[:depth].to_i + 1, **options)
+        right = queryable.query(operand(1), **options.merge(depth: options[:depth].to_i + 1))
         debug(options) {"(minus right) #{right.inspect}"}
         @solutions = left.minus(right)
         @solutions.each(&block) if block_given?

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

@@ -71,12 +71,12 @@ module SPARQL; module Algebra
           query = Operator::Using.new((defaults + named), query, **options)
         end
 
-        queryable.query(query, depth: options[:depth].to_i + 1, **options) do |solution|
+        queryable.query(query, **options.merge(depth: options[:depth].to_i + 1)) do |solution|
           debug(options) {"(solution)=>#{solution.inspect}"}
 
           # Execute each operand with queryable and solution
           operands.each do |op|
-            op.execute(queryable, solutions: solution, depth: options[:depth].to_i + 1, **options)
+            op.execute(queryable, solutions: solution, **options.merge(depth: options[:depth].to_i + 1))
           end
         end
         queryable

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

@@ -48,11 +48,11 @@ module SPARQL; module Algebra
       # @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, depth: options[:depth].to_i + 1, **options)
+        lhs = operands.first.evaluate(bindings, **options.merge(depth: options[:depth].to_i + 1))
         error_found = false
         found = operands[1..-1].any? do |op|
           begin
-            lhs == op.evaluate(bindings, depth: options[:depth].to_i + 1, **options)
+            lhs == op.evaluate(bindings, **options.merge(depth: options[:depth].to_i + 1))
           rescue TypeError
             error_found = true
           end

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

@@ -50,7 +50,7 @@ module SPARQL; module Algebra
           q.pattern [subject, v, object]
         end
         query = Filter.new(NotIn.new(v, *operands), bgp)
-        queryable.query(query, depth: options[:depth].to_i + 1, **options) do |solution|
+        queryable.query(query, **options.merge(depth: options[:depth].to_i + 1)) do |solution|
           solution.bindings.delete(v.to_sym)
           debug(options) {"(solution)-> #{solution.to_h.to_sse}"}
           block.call(solution)

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

@@ -56,13 +56,13 @@ module SPARQL; module Algebra
       # @raise  [TypeError] if the operands could not be coerced to a boolean literal
       def evaluate(bindings, **options)
         begin
-          left = boolean(operand(0).evaluate(bindings, depth: options[:depth].to_i + 1, **options)).true?
+          left = boolean(operand(0).evaluate(bindings, **options.merge(depth: options[:depth].to_i + 1))).true?
         rescue TypeError
           left = nil
         end
         
         begin
-          right = boolean(operand(1).evaluate(bindings, depth: options[:depth].to_i + 1, **options)).true?
+          right = boolean(operand(1).evaluate(bindings, **options.merge(depth: options[:depth].to_i + 1))).true?
         rescue TypeError
           right = nil
         end

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

@@ -86,12 +86,12 @@ module SPARQL; module Algebra
       def execute(queryable, **options, &block)
 
         debug(options) {"Order"}
-        @solutions = queryable.query(operands.last, depth: options[:depth].to_i + 1, **options).order do |a, b|
+        @solutions = queryable.query(operands.last, **options.merge(depth: options[:depth].to_i + 1)).order do |a, b|
           operand(0).inject(0) do |memo, op|
             debug(options) {"(order) #{op.inspect}"}
             memo = begin
-              a_eval = op.evaluate(a, queryable: queryable, depth: options[:depth].to_i + 1, **options) rescue nil
-              b_eval = op.evaluate(b, queryable: queryable, depth: options[:depth].to_i + 1, **options) rescue nil
+              a_eval = op.evaluate(a, queryable: queryable, **options.merge(depth: options[:depth].to_i + 1)) rescue nil
+              b_eval = op.evaluate(b, queryable: queryable, **options.merge(depth: options[:depth].to_i + 1)) rescue nil
               comp = begin
                 Operator::Compare.evaluate(a_eval, b_eval, order_by: true).to_s.to_i
               rescue TypeError

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

@@ -50,8 +50,7 @@ module SPARQL; module Algebra
           subject: subject,
           object: object,
           graph_name: options.fetch(:graph_name, false),
-          depth: options[:depth].to_i + 1,
-          **options
+          **options.merge(depth: options[:depth].to_i + 1)
         ) do |solution|
           @solutions << solution
         end

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

@@ -73,7 +73,7 @@ module SPARQL; module Algebra
         # Keep track of solutions
         # Recurse into query
         immediate_solutions = 
-          query.execute(queryable, depth: options[:depth].to_i + 1, **options)
+          query.execute(queryable, **options.merge(depth: options[:depth].to_i + 1))
 
         # For all solutions, if they are not in the accumulator, add them and recurse, otherwise skip
         recursive_solutions = RDF::Query::Solutions.new

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

@@ -48,7 +48,7 @@ module SPARQL; module Algebra
 
         # (:x :p* :y) => (:x (:p+)? :y)
         query = PathOpt.new(PathPlus.new(*operands))
-        query.execute(queryable, depth: options[:depth].to_i + 1, **options, &block)
+        query.execute(queryable, **options.merge(depth: options[:depth].to_i + 1), &block)
       end
       ##
       #

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

@@ -37,7 +37,7 @@ module SPARQL; module Algebra
       # @see    https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
       def execute(queryable, **options, &block)
         debug(options) {"Prefix"}
-        @solutions = queryable.query(operands.last, depth: options[:depth].to_i + 1, **options, &block)
+        @solutions = queryable.query(operands.last, **options.merge(depth: options[:depth].to_i + 1), &block)
       end
 
       ##

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

@@ -101,7 +101,7 @@ module SPARQL; module Algebra
       #   the resulting solution sequence
       # @see    https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
       def execute(queryable, **options, &block)
-        @solutions = queryable.query(operands.last, depth: options[:depth].to_i + 1, **options)
+        @solutions = queryable.query(operands.last, **options.merge(depth: options[:depth].to_i + 1))
         @solutions.variable_names = self.variables.keys
         @solutions = @solutions.project(*(operands.first)) unless operands.first.empty?
         @solutions.each(&block) if block_given?

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

@@ -41,7 +41,7 @@ module SPARQL; module Algebra
       # @see    https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
       def execute(queryable, **options, &block)
         @solutions = operands.last.
-          execute(queryable, depth: options[:depth].to_i + 1, **options).reduced
+          execute(queryable, **options.merge(depth: options[:depth].to_i + 1)).reduced
         @solutions.each(&block) if block_given?
         @solutions
       end

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

@@ -31,11 +31,11 @@ module SPARQL; module Algebra
       def execute(queryable, **options)
         debug(options) {"Sequence #{operands.to_sse}"}
 
-        last = queryable.query(operands.shift, depth: options[:depth].to_i + 1, **options)
+        last = queryable.query(operands.shift, **options.merge(depth: options[:depth].to_i + 1))
         debug(options) {"(sequence)=>(last) #{last.map(&:to_h).to_sse}"}
 
         operands.each do |op|
-          this = queryable.query(op, depth: options[:depth].to_i + 1, **options)
+          this = queryable.query(op, **options.merge(depth: options[:depth].to_i + 1))
           debug(options) {"(sequence)=>(this) #{this.map(&:to_h).to_sse}"}
 
           last = last.map do |s1|

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

@@ -57,7 +57,7 @@ module SPARQL; module Algebra
       def execute(queryable, **options, &block)
         offset = operands[0] == :_ ? 0 : operands[0].to_i
         limit = operands[1] == :_ ? -1 : operands[1].to_i
-        @solutions = operands.last. execute(queryable, depth: options[:depth].to_i + 1, **options)
+        @solutions = operands.last. execute(queryable, **options.merge(depth: options[:depth].to_i + 1))
         @solutions.offset(operands[0]) unless operands[0] == :_
         @solutions.limit(operands[1]) unless operands[1] == :_
         @solutions.each(&block) if block_given?

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

@@ -41,7 +41,7 @@ module SPARQL; module Algebra
       def execute(queryable, **options, &block)
         debug(options) {"Union"}
         @solutions = RDF::Query::Solutions(operands.inject([]) do |memo, op|
-          solns = op.execute(queryable, depth: options[:depth].to_i + 1, **options)
+          solns = op.execute(queryable, **options.merge(depth: options[:depth].to_i + 1))
           debug(options) {"=> (op) #{solns.inspect}"}
           memo + solns
         end)

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

@@ -68,7 +68,7 @@ module SPARQL; module Algebra
         debug(options) {"Update"}
         raise IOError, "queryable is not mutable" unless queryable.mutable?
         operands.each do |op|
-          op.execute(queryable, depth: options[:depth].to_i + 1, **options)
+          op.execute(queryable, **options.merge(depth: options[:depth].to_i + 1))
         end
         queryable
       end

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

@@ -67,7 +67,7 @@ module SPARQL; module Algebra
       # @see    https://www.w3.org/TR/sparql11-update/
       def execute(queryable, **options, &block)
         debug(options) {"Using"}
-        Dataset.new(*operands).execute(queryable, depth: options[:depth].to_i + 1, **options, &block)
+        Dataset.new(*operands).execute(queryable, **options.merge(depth: options[:depth].to_i + 1), &block)
       end
 
       ##

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

@@ -69,12 +69,12 @@ module SPARQL; module Algebra
         query = operands.shift
 
         # Restrict query portion to this graph
-        queryable.query(query, depth: options[:depth].to_i + 1, **options) do |solution|
+        queryable.query(query, **options.merge(depth: options[:depth].to_i + 1)) do |solution|
           debug(options) {"(solution)=>#{solution.inspect}"}
 
           # Execute each operand with queryable and solution
           operands.each do |op|
-            op.execute(queryable, solutions: solution, depth: options[:depth].to_i + 1, **options)
+            op.execute(queryable, solutions: solution, **options.merge(depth: options[:depth].to_i + 1))
           end
         end
       end

data/lib/sparql/grammar/terminals11.rb

@@ -94,10 +94,10 @@ module SPARQL::Grammar
     STR_EXPR = %r(ABS|ADD|ADJUST|ALL|ASC|ASK|AS|AVG|BASE|BINDINGS|BIND
                  |BNODE|BOUND|BY|CEIL|CLEAR|COALESCE|CONCAT
                  |CONSTRUCT|CONTAINS|COPY|COUNT|CREATE|DATATYPE|DAY
-                 |DEFAULT|DELETE#{WS}DATA|DELETE#{WS}WHERE|DELETE
+                 |DEFAULT|DELETE\s+DATA|DELETE\s+WHERE|DELETE
                  |DESCRIBE|DESC|DISTINCT|DROP|ENCODE_FOR_URI|EXISTS
                  |FILTER|FLOOR|FROM|GRAPH|GROUP_CONCAT|GROUP|HAVING
-                 |HOURS|IF|INSERT#{WS}DATA|INSERT|INTO|IN|IRI
+                 |HOURS|IF|INSERT\s+DATA|INSERT|INTO|IN|IRI
                  |LANGMATCHES|LANGTAG|LANG|LCASE|LIMIT|LOAD
                  |MAX|MD5|MINUS|MINUTES|MIN|MONTH|MOVE
                  |NAMED|NOT|NOW|OFFSET|OPTIONAL

data/lib/sparql/results.rb

@@ -280,7 +280,8 @@ module SPARQL
     end
 
     content_type ||= SPARQL::Results::MIME_TYPES[format] if format
-    
+
+    serialization = serialization.dup if serialization.frozen?
     serialization.instance_eval do
       define_singleton_method(:content_type) { content_type }
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sparql
 version: !ruby/object:Gem::Version
-  version: 3.2.4
+  version: 3.2.5
 platform: ruby
 authors:
 - Gregg Kellogg
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-06-07 00:00:00.000000000 Z
+date: 2023-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdf
@@ -455,7 +455,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: SPARQL Query and Update library for Ruby.