sparql 3.0.2 → 3.1.0

data/lib/sparql/algebra/operator/insert_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) {"InsertData #{op.to_sxp}"}
           queryable.insert(op)

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

@@ -34,17 +34,17 @@ module SPARQL; module Algebra
       # @see    http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
       # @see    http://www.rubydoc.info/github/ruby-rdf/rdf/RDF/Query/Solution#merge-instance_method
       # @see    http://www.rubydoc.info/github/ruby-rdf/rdf/RDF/Query/Solution#compatible%3F-instance_method
-      def execute(queryable, options = {}, &block)
+      def execute(queryable, **options, &block)
         # Join(Ω1, Ω2) = { merge(μ1, μ2) | μ1 in Ω1 and μ2 in Ω2, and μ1 and μ2 are compatible }
         # eval(D(G), Join(P1, P2)) = Join(eval(D(G), P1), eval(D(G), P2))
         #
         # Generate solutions independently, merge based on solution compatibility
         debug(options) {"Join #{operands.to_sse}"}
  
-        left = queryable.query(operand(0), options.merge(depth: options[:depth].to_i + 1))
+        left = queryable.query(operand(0), depth: options[:depth].to_i + 1, **options)
         debug(options) {"(join)=>(left) #{left.map(&:to_h).to_sse}"}
 
-        right = queryable.query(operand(1), options.merge(depth: options[:depth].to_i + 1))
+        right = queryable.query(operand(1), depth: options[:depth].to_i + 1, **options)
         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

@@ -34,14 +34,14 @@ module SPARQL; module Algebra
       # @see    http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
       # @see    http://www.rubydoc.info/github/ruby-rdf/rdf/RDF/Query/Solution#merge-instance_method
       # @see    http://www.rubydoc.info/github/ruby-rdf/rdf/RDF/Query/Solution#compatible%3F-instance_method
-      def execute(queryable, options = {}, &block)
+      def execute(queryable, **options, &block)
         filter = operand(2)
 
         debug(options) {"LeftJoin"}
-        left = queryable.query(operand(0), options.merge(depth: options[:depth].to_i + 1))
+        left = queryable.query(operand(0), depth: options[:depth].to_i + 1, **options)
         debug(options) {"=>(leftjoin left) #{left.inspect}"}
 
-        right = queryable.query(operand(1), options.merge(depth: options[:depth].to_i + 1))
+        right = queryable.query(operand(1), depth: options[:depth].to_i + 1, **options)
         debug(options) {"=>(leftjoin right) #{right.inspect}"}
 
         # LeftJoin(Ω1, Ω2, expr) =

data/lib/sparql/algebra/operator/load.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) {"Load"}
         silent = operands.first == :silent
         operands.shift if silent

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

@@ -6,12 +6,12 @@ module SPARQL; module Algebra
     # @example
     #    (prefix ((: <http://www.example.org/>))
     #      (project (?max)
-    #        (extend ((?max ?.0))
-    #          (group () ((?.0 (max ?o)))
+    #        (extend ((?max ??.0))
+    #          (group () ((??.0 (max ?o)))
     #            (bgp (triple ?s ?p ?o))))))
     #
     # @see http://www.w3.org/TR/sparql11-query/#defn_aggMax
-    class Max < Operator::Unary
+    class Max < Operator
       include Aggregate
 
       NAME = :max
@@ -25,6 +25,8 @@ module SPARQL; module Algebra
       #   enum of evaluated operand
       # @return [RDF::Literal] The maximum value of the terms
       def apply(enum)
+        # FIXME: we don't actually do anything with distinct
+        operands.shift if distinct = (operands.first == :distinct)
         if enum.empty?
           raise TypeError, "Maximum of an empty multiset"
         elsif enum.flatten.all? {|n| n.literal?}

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

@@ -6,12 +6,12 @@ module SPARQL; module Algebra
     # @example
     #    (prefix ((: <http://www.example.org/>))
     #      (project (?max)
-    #        (extend ((?min ?.0))
-    #          (group () ((?.0 (min ?o)))
+    #        (extend ((?min ??.0))
+    #          (group () ((??.0 (min ?o)))
     #            (bgp (triple ?s ?p ?o))))))
     #
     # @see http://www.w3.org/TR/sparql11-query/#defn_aggMin
-    class Min < Operator::Unary
+    class Min < Operator
       include Aggregate
 
       NAME = :min
@@ -25,6 +25,8 @@ module SPARQL; module Algebra
       #   enum of evaluated operand
       # @return [RDF::Literal] The maximum value of the terms
       def apply(enum)
+        # FIXME: we don't actually do anything with distinct
+        operands.shift if distinct = (operands.first == :distinct)
         if enum.empty?
           raise TypeError, "Minumuim of an empty multiset"
         elsif enum.flatten.all? {|n| n.literal?}

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

@@ -35,16 +35,16 @@ module SPARQL; module Algebra
       #   the resulting solution sequence
       # @see    http://www.w3.org/TR/2013/REC-sparql11-query-20130321/#defn_algMinus
       # @see    http://www.w3.org/TR/2013/REC-sparql11-query-20130321/#negation
-      def execute(queryable, options = {}, &block)
+      def execute(queryable, **options, &block)
         # Let Ω1 and Ω2 be multisets of solution mappings. We define:
         # 
         # Minus(Ω1, Ω2) = { μ | μ in Ω1 . ∀ μ' in Ω2, either μ and μ' are not compatible or dom(μ) and dom(μ') are disjoint }
         # 
         # card[Minus(Ω1, Ω2)](μ) = card[Ω1](μ)
         debug(options) {"Minus"}
-        left = queryable.query(operand(0), options.merge(depth: options[:depth].to_i + 1))
+        left = queryable.query(operand(0), depth: options[:depth].to_i + 1, **options)
         debug(options) {"(minus left) #{left.inspect}"}
-        right = queryable.query(operand(1), options.merge(depth: options[:depth].to_i + 1))
+        right = queryable.query(operand(1), depth: options[:depth].to_i + 1, **options)
         debug(options) {"(minus right) #{right.inspect}"}
         @solutions = left.minus(right)
         @solutions.each(&block) if block_given?

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

@@ -34,16 +34,16 @@ 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) {"Modify"}
         query = operands.shift
 
-        queryable.query(query, options.merge(depth: options[:depth].to_i + 1)) do |solution|
+        queryable.query(query, depth: options[:depth].to_i + 1, **options) do |solution|
           debug(options) {"(solution)=>#{solution.inspect}"}
 
           # Execute each operand with queryable and solution
           operands.each do |op|
-            op.execute(queryable, solution, options.merge(depth: options[:depth].to_i + 1))
+            op.execute(queryable, solutions: solution, depth: options[:depth].to_i + 1, **options)
           end
         end
         queryable

data/lib/sparql/algebra/operator/move.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) {"Move"}
         silent = operands.first == :silent
         operands.shift if silent

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

@@ -29,10 +29,10 @@ 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)
         solutions = RDF::Query::Solutions(bindings)
         queryable = options[:queryable]
-        operand(0).execute(queryable, options.merge(solutions: solutions)).empty?
+        operand(0).execute(queryable, solutions: solutions, **options).empty?
       end
     end # NotExists
   end # Operator

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

@@ -42,12 +42,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.merge(depth: options[:depth].to_i + 1))
+      def evaluate(bindings, **options)
+        lhs = operands.first.evaluate(bindings, depth: options[:depth].to_i + 1, **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/notoneof.rb

@@ -31,17 +31,16 @@ module SPARQL; module Algebra
       # @yieldparam  [RDF::Query::Solution] solution
       # @yieldreturn [void] ignored
       # @see    http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
-      def execute(queryable, options = {}, &block)
+      def execute(queryable, **options, &block)
         debug(options) {"NotOneOf #{operands.to_sse}"}
         subject, object = options[:subject], options[:object]
 
-        v = RDF::Query::Variable.new
-        v.distinguished = false
+        v = RDF::Query::Variable.new(distinguished: false)
         bgp = RDF::Query.new do |q|
           q.pattern [subject, v, object]
         end
         query = Filter.new(NotIn.new(v, *operands), bgp)
-        queryable.query(query, options.merge(depth: options[:depth].to_i + 1)) do |solution|
+        queryable.query(query, depth: options[:depth].to_i + 1, **options) 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

@@ -24,7 +24,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(left, right, options = {})
+      def initialize(left, right, **options)
         super
       end
 
@@ -40,15 +40,15 @@ 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 = {})
+      def evaluate(bindings, **options)
         begin
-          left = boolean(operand(0).evaluate(bindings, options.merge(depth: options[:depth].to_i + 1))).true?
+          left = boolean(operand(0).evaluate(bindings, depth: options[:depth].to_i + 1, **options)).true?
         rescue TypeError
           left = nil
         end
         
         begin
-          right = boolean(operand(1).evaluate(bindings, options.merge(depth: options[:depth].to_i + 1))).true?
+          right = boolean(operand(1).evaluate(bindings, depth: options[:depth].to_i + 1, **options)).true?
         rescue TypeError
           right = nil
         end

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

@@ -31,15 +31,15 @@ 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) {"Order"}
-        @solutions = queryable.query(operands.last, options.merge(depth: options[:depth].to_i + 1)).order do |a, b|
+        @solutions = queryable.query(operands.last, depth: options[:depth].to_i + 1, **options).order do |a, b|
           operand(0).inject(0) do |memo, op|
             debug(options) {"(order) #{op.inspect}"}
             memo = begin
-              a_eval = op.evaluate(a, options.merge(queryable: queryable, depth: options[:depth].to_i + 1)) rescue nil
-              b_eval = op.evaluate(b, options.merge(queryable: queryable, depth: options[:depth].to_i + 1)) rescue nil
+              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
               comp = Operator::Compare.evaluate(a_eval, b_eval).to_i
               comp = -comp if op.is_a?(Operator::Desc)
               comp

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

@@ -26,16 +26,17 @@ 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) {"Path #{operands.to_sse}"}
         subject, path_op, object = operands
 
         @solutions = RDF::Query::Solutions.new
-        path_op.execute(queryable, options.merge(
+        path_op.execute(queryable,
           subject: subject,
           object: object,
           graph_name: options.fetch(:graph_name, false),
-          depth: options[:depth].to_i + 1)
+          depth: options[:depth].to_i + 1,
+          **options
         ) do |solution|
           @solutions << solution
         end

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

@@ -30,7 +30,7 @@ module SPARQL; module Algebra
       # @yieldparam  [RDF::Query::Solution] solution
       # @yieldreturn [void] ignored
       # @see    http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
-      def execute(queryable, options = {}, &block)
+      def execute(queryable, **options, &block)
         subject, object = options[:subject], options[:object]
         debug(options) {"Path? #{[subject, operands, object].to_sse}"}
 
@@ -41,48 +41,48 @@ module SPARQL; module Algebra
           # Nodes is the set of all subjects and objects in queryable
           # FIXME: should this be Queryable#enum_nodes?
           # All subjects which are `object`
-          query = RDF::Query.new {|q| q.pattern(subject: subject)}
-          queryable.query(query, options) do |solution|
+          query = RDF::Query.new {|q| q.pattern({subject: subject})}
+          queryable.query(query, **options) do |solution|
             solution.merge!(object.to_sym => solution[subject])
             debug(options) {"(solution-s0)-> #{solution.to_h.to_sse}"}
             solutions << solution
           end if query.valid?
 
           # All objects which are `object`
-          query = RDF::Query.new {|q| q.pattern(object: object)}
-          queryable.query(query, options) do |solution|
+          query = RDF::Query.new {|q| q.pattern({object: object})}
+          queryable.query(query, **options) do |solution|
             solution.merge!(subject.to_sym => solution[object])
             debug(options) {"(solution-o0)-> #{solution.to_h.to_sse}"}
             solutions << solution
           end if query.valid?
         when subject.variable?
           # All subjects which are `object`
-          query = RDF::Query.new {|q| q.pattern(subject: object)}
-          queryable.query(query, options) do |solution|
+          query = RDF::Query.new {|q| q.pattern({subject: object})}
+          queryable.query(query, **options) do |solution|
             solution.merge!(subject.to_sym => object)
             debug(options) {"(solution-s0)-> #{solution.to_h.to_sse}"}
             solutions << solution
           end if query.valid?
 
           # All objects which are `object`
-          query = RDF::Query.new {|q| q.pattern(object: object)}
-          queryable.query(query, options) do |solution|
+          query = RDF::Query.new {|q| q.pattern({object: object})}
+          queryable.query(query, **options) do |solution|
             solution.merge!(subject.to_sym => object)
             debug(options) {"(solution-o0)-> #{solution.to_h.to_sse}"}
             solutions << solution
           end if query.valid?
         when object.variable?
           # All subjects which are `subject`
-          query = RDF::Query.new {|q| q.pattern(subject: subject)}
-          queryable.query(query, options) do |solution|
+          query = RDF::Query.new {|q| q.pattern({subject: subject})}
+          queryable.query(query, **options) do |solution|
             solution.merge!(object.to_sym => subject)
             debug(options) {"(solution-s0)-> #{solution.to_h.to_sse}"}
             solutions << solution
           end if query.valid?
 
           # All objects which are `subject
-          query = RDF::Query.new {|q| q.pattern(object: subject)}
-          queryable.query(query, options) do |solution|
+          query = RDF::Query.new {|q| q.pattern({object: subject})}
+          queryable.query(query, **options) do |solution|
             solution.merge!(object.to_sym => subject)
             debug(options) {"(solution-o0)-> #{solution.to_h.to_sse}"}
             solutions << solution
@@ -103,7 +103,7 @@ module SPARQL; module Algebra
 
         # Recurse into query
         solutions += 
-        queryable.query(query, options.merge(depth: options[:depth].to_i + 1))
+        queryable.query(query, depth: options[:depth].to_i + 1, **options)
         solutions.each(&block) if block_given?
         solutions
       end

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

@@ -26,7 +26,7 @@ module SPARQL; module Algebra
       # @yieldparam  [RDF::Query::Solution] solution
       # @yieldreturn [void] ignored
       # @see    http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
-      def execute(queryable, options = {}, &block)
+      def execute(queryable, **options, &block)
         subject, object = options[:subject], options[:object]
         debug(options) {"Path+ #{[subject, operands, object].to_sse}"}
 
@@ -53,7 +53,7 @@ module SPARQL; module Algebra
         # Keep track of solutions
         # Recurse into query
         immediate_solutions = []
-        queryable.query(query, options.merge(depth: options[:depth].to_i + 1)) do |solution|
+        queryable.query(query, depth: options[:depth].to_i + 1, **options) do |solution|
           immediate_solutions << solution
         end
 
@@ -66,23 +66,23 @@ module SPARQL; module Algebra
           case
           when subject.variable? && object.variable?
             # Query starting with bound object as subject, but replace result with subject
-            rs = queryable.query(self, options.merge(
+            rs = queryable.query(self, **options.merge(
               subject: solution[object],
               accumulator: (cumulative_solutions + immediate_solutions),
               depth: options[:depth].to_i + 1)).map {|s| s.merge(subject.to_sym => solution[subject])}
             # Query starting with bound subject as object, but replace result with subject
-            ro = queryable.query(self, options.merge(
+            ro = queryable.query(self, **options.merge(
               object: solution[subject],
               accumulator: (cumulative_solutions + immediate_solutions),
               depth: options[:depth].to_i + 1)).map {|s| s.merge(object.to_sym => solution[object])}
             recursive_solutions += (rs + ro).uniq
           when subject.variable?
-            recursive_solutions += queryable.query(self, options.merge(
+            recursive_solutions += queryable.query(self, **options.merge(
               object: solution[subject],
               accumulator: (cumulative_solutions + immediate_solutions),
               depth: options[:depth].to_i + 1)).uniq
           when object.variable?
-            recursive_solutions += queryable.query(self, options.merge(
+            recursive_solutions += queryable.query(self, **options.merge(
               subject: solution[object],
               accumulator: (cumulative_solutions + immediate_solutions),
               depth: options[:depth].to_i + 1)).uniq

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

@@ -29,13 +29,13 @@ module SPARQL; module Algebra
       # @yieldparam  [RDF::Query::Solution] solution
       # @yieldreturn [void] ignored
       # @see    http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
-      def execute(queryable, options = {}, &block)
+      def execute(queryable, **options, &block)
         subject, object = options[:subject], options[:object]
         debug(options) {"Path* #{[subject, operands, object].to_sse}"}
 
         # (:x :p* :y) => (:x (:p+)? :y)
         query = PathOpt.new(PathPlus.new(*operands))
-        query.execute(queryable, options.merge(depth: options[:depth].to_i + 1), &block)
+        query.execute(queryable, depth: options[:depth].to_i + 1, **options, &block)
       end
     end # PathStar
   end # Operator

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

@@ -9,7 +9,7 @@ module SPARQL; module Algebra
     #
     # @see http://www.w3.org/TR/xpath-functions/#func-numeric-unary-plus
     # @see http://www.w3.org/TR/xpath-functions/#func-numeric-add
-    class Plus < Operator::Unary
+    class Plus < Operator
       include Evaluatable
 
       NAME = [:+, :plus]

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

@@ -30,9 +30,9 @@ 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) {"Prefix"}
-        @solutions = queryable.query(operands.last, options.merge(depth: options[:depth].to_i + 1), &block)
+        @solutions = queryable.query(operands.last, depth: options[:depth].to_i + 1, **options, &block)
       end
       
       ##