sparql 3.0.0 → 3.1.3

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

@@ -11,8 +11,8 @@ module SPARQL; module Algebra
     #          (filter (|| (= ?type ex:Reptile) (= ?type ex:Insect))
     #            (bgp (triple ?animal <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> ?type))))))
     #
-    # @see http://www.w3.org/TR/xpath-functions/#func-numeric-unary-minus
-    # @see http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
+    # @see https://www.w3.org/TR/xpath-functions/#func-numeric-unary-minus
+    # @see https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
     class Minus < Operator::Binary
       include Query
 
@@ -33,18 +33,18 @@ module SPARQL; module Algebra
       # @yieldreturn [void] ignored
       # @return [RDF::Query::Solutions]
       #   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)
+      # @see    https://www.w3.org/TR/2013/REC-sparql11-query-20130321/#defn_algMinus
+      # @see    https://www.w3.org/TR/2013/REC-sparql11-query-20130321/#negation
+      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?
@@ -52,16 +52,17 @@ module SPARQL; module Algebra
       end
       
       ##
-      # Returns an optimized version of this query.
+      # Optimizes this query.
       #
       # Groups of one graph pattern (not a filter) become join(Z, A) and can be replaced by A.
       # The empty graph pattern Z is the identity for join:
       #   Replace join(Z, A) by A
       #   Replace join(A, Z) by A
       #
-      # @return [Join, RDF::Query] `self`
-      def optimize
-        ops = operands.map {|o| o.optimize }.select {|o| o.respond_to?(:empty?) && !o.empty?}
+      # @return [self]
+      # @see SPARQL::Algebra::Expression#optimize!
+      def optimize!(**options)
+        ops = operands.map {|o| o.optimize(**options) }.select {|o| o.respond_to?(:empty?) && !o.empty?}
         @operands = ops
         self
       end

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

@@ -11,7 +11,7 @@ module SPARQL; module Algebra
     #         (extend ((?x (minutes ?date)))
     #           (bgp (triple ?s :date ?date)))))
     #
-    # @see http://www.w3.org/TR/sparql11-query/#func-minutes
+    # @see https://www.w3.org/TR/sparql11-query/#func-minutes
     class Minutes < Operator::Unary
       include Evaluatable
 

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

@@ -33,17 +33,17 @@ module SPARQL; module Algebra
       #   Returns queryable.
       # @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 = {})
+      # @see    https://www.w3.org/TR/sparql11-update/
+      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/month.rb

@@ -11,7 +11,7 @@ module SPARQL; module Algebra
     #         (extend ((?x (month ?date)))
     #           (bgp (triple ?s :date ?date)))))
     #
-    # @see http://www.w3.org/TR/sparql11-query/#func-month
+    # @see https://www.w3.org/TR/sparql11-query/#func-month
     class Month < Operator::Unary
       include Evaluatable
 

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

@@ -9,7 +9,7 @@ module SPARQL; module Algebra
     # @example
     #   (move silent <iri> to default)
     #
-    # @see http://www.w3.org/TR/sparql11-update/#move
+    # @see https://www.w3.org/TR/sparql11-update/#move
     class Move < Operator
       include SPARQL::Algebra::Update
 
@@ -28,8 +28,8 @@ module SPARQL; module Algebra
       #   Returns queryable.
       # @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 = {})
+      # @see    https://www.w3.org/TR/sparql11-update/
+      def execute(queryable, **options)
         debug(options) {"Move"}
         silent = operands.first == :silent
         operands.shift if silent

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

@@ -7,7 +7,7 @@ module SPARQL; module Algebra
     #   (* ?x ?y)
     #   (multiply ?x ?y)
     #
-    # @see http://www.w3.org/TR/xpath-functions/#func-numeric-multiply
+    # @see https://www.w3.org/TR/xpath-functions/#func-numeric-multiply
     class Multiply < Operator::Binary
       include Evaluatable
 

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

@@ -7,7 +7,7 @@ module SPARQL; module Algebra
     #   (- ?x)
     #   (negate ?x)
     #
-    # @see http://www.w3.org/TR/xpath-functions/#func-numeric-unary-minus
+    # @see https://www.w3.org/TR/xpath-functions/#func-numeric-unary-minus
     class Negate < Operator::Unary
       include Evaluatable
 

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

@@ -7,7 +7,7 @@ module SPARQL; module Algebra
     #   (! ?x)
     #   (not ?x)
     #
-    # @see http://www.w3.org/TR/xpath-functions/#func-not
+    # @see https://www.w3.org/TR/xpath-functions/#func-not
     class Not < Operator::Unary
       include Evaluatable
 

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

@@ -3,8 +3,8 @@ module SPARQL; module Algebra
     ##
     # The SPARQL relational `!=` (not equal) comparison operator.
     #
-    # @see http://www.w3.org/TR/sparql11-query/#OperatorMapping
-    # @see http://www.w3.org/TR/sparql11-query/#func-RDFterm-equal
+    # @see https://www.w3.org/TR/sparql11-query/#OperatorMapping
+    # @see https://www.w3.org/TR/sparql11-query/#func-RDFterm-equal
     class NotEqual < Equal
       NAME = :'!='
 

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

@@ -12,8 +12,8 @@ module SPARQL; module Algebra
     #                   (bgp (triple ?s ?p ex:o1))))
     #        (bgp (triple ?s ?p ex:o))))
     #
-    # @see http://www.w3.org/TR/sparql11-query/#func-abs
-    # @see http://www.w3.org/TR/xpath-functions/#func-abs
+    # @see https://www.w3.org/TR/sparql11-query/#func-abs
+    # @see https://www.w3.org/TR/xpath-functions/#func-abs
     class NotExists < Operator::Unary
       include Evaluatable
 
@@ -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

@@ -8,7 +8,7 @@ module SPARQL; module Algebra
     # @example
     #   (ask (filter (notin ?o 1 2) (bgp)))
     #
-    # @see http://www.w3.org/TR/sparql11-query/#func-notin
+    # @see https://www.w3.org/TR/sparql11-query/#func-notin
     class NotIn < Operator
       include Evaluatable
 
@@ -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
@@ -58,16 +58,6 @@ module SPARQL; module Algebra
         else RDF::Literal::TRUE
         end
       end
-
-      ##
-      # Returns an optimized version of this query.
-      #
-      # Return optimized query
-      #
-      # @return [Union, RDF::Query] `self`
-      def optimize
-        operands = operands.map(&:optimize)
-      end
     end # Exprlist
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -6,7 +6,7 @@ module SPARQL; module Algebra
     # @example
     #   (notoneof ex:p1 ex:p2)
     #
-    # @see http://www.w3.org/TR/sparql11-query/#eval_negatedPropertySet
+    # @see https://www.w3.org/TR/sparql11-query/#eval_negatedPropertySet
     class NotOneOf < Operator
       include Query
       
@@ -30,18 +30,17 @@ module SPARQL; module Algebra
       #   each matching solution
       # @yieldparam  [RDF::Query::Solution] solution
       # @yieldreturn [void] ignored
-      # @see    http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
-      def execute(queryable, options = {}, &block)
+      # @see    https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
+      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/now.rb

@@ -13,7 +13,7 @@ module SPARQL; module Algebra
     #         (extend ((?n (now)))
     #           (bgp)))))
     #
-    # @see http://www.w3.org/TR/sparql11-query/#func-now
+    # @see https://www.w3.org/TR/sparql11-query/#func-now
     class Now < Operator::Nullary
       include Evaluatable
 

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

@@ -7,8 +7,8 @@ module SPARQL; module Algebra
     #   (|| ?x ?y)
     #   (or ?x ?y)
     #
-    # @see http://www.w3.org/TR/sparql11-query/#func-logical-or
-    # @see http://www.w3.org/TR/sparql11-query/#evaluation
+    # @see https://www.w3.org/TR/sparql11-query/#func-logical-or
+    # @see https://www.w3.org/TR/sparql11-query/#evaluation
     class Or < Operator::Binary
       include Evaluatable
 
@@ -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,20 +40,20 @@ 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
 
-        # From http://www.w3.org/TR/sparql11-query/#evaluation
+        # From https://www.w3.org/TR/sparql11-query/#evaluation
         # A logical-or that encounters an error on only one branch will return TRUE if the other branch is TRUE
         # and an error if the other branch is FALSE.
         case

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

@@ -9,7 +9,7 @@ module SPARQL; module Algebra
     #       (order ((asc ?name))
     #         (bgp (triple ?x foaf:name ?name)))))
     #
-    # @see http://www.w3.org/TR/sparql11-query/#modOrderBy
+    # @see https://www.w3.org/TR/sparql11-query/#modOrderBy
     class Order < Operator::Binary
       include Query
       
@@ -30,16 +30,16 @@ module SPARQL; module Algebra
       # @yieldreturn [void] ignored
       # @return [RDF::Query::Solutions]
       #   the resulting solution sequence
-      # @see    http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
-      def execute(queryable, options = {}, &block)
+      # @see    https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
+      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
@@ -50,16 +50,6 @@ module SPARQL; module Algebra
         @solutions.each(&block) if block_given?
         @solutions
       end
-      
-      ##
-      # Returns an optimized version of this query.
-      #
-      # Return optimized query
-      #
-      # @return [Union, RDF::Query] `self`
-      def optimize
-        operands = operands.map(&:optimize)
-      end
     end # Order
   end # Operator
 end; end # SPARQL::Algebra

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

@@ -6,7 +6,7 @@ module SPARQL; module Algebra
     # @example
     #   (path :a (path+ :p) ?z)
     #
-    # @see http://www.w3.org/TR/sparql11-query/#sparqlTranslatePathExpressions
+    # @see https://www.w3.org/TR/sparql11-query/#sparqlTranslatePathExpressions
     class Path < Operator::Ternary
       include Query
       
@@ -25,17 +25,18 @@ module SPARQL; module Algebra
       # @yieldreturn [void] ignored
       # @return [RDF::Query::Solutions]
       #   the resulting solution sequence
-      # @see    http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
-      def execute(queryable, options = {}, &block)
+      # @see    https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
+      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

@@ -6,7 +6,7 @@ module SPARQL; module Algebra
     # @example
     #   (path? :p)
     #
-    # @see http://www.w3.org/TR/sparql11-query/#defn_evalPP_ZeroOrOnePath
+    # @see https://www.w3.org/TR/sparql11-query/#defn_evalPP_ZeroOrOnePath
     class PathOpt < Operator::Unary
       include Query
       
@@ -29,8 +29,8 @@ module SPARQL; module Algebra
       #   each matching solution
       # @yieldparam  [RDF::Query::Solution] solution
       # @yieldreturn [void] ignored
-      # @see    http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
-      def execute(queryable, options = {}, &block)
+      # @see    https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
+      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