sparql 3.0.1 → 3.1.4

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

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

@@ -6,7 +6,7 @@ module SPARQL; module Algebra
     # @example
     #   (path+ :p)
     #
-    # @see http://www.w3.org/TR/sparql11-query/#defn_evalPP_OneOrMorePath
+    # @see https://www.w3.org/TR/sparql11-query/#defn_evalPP_OneOrMorePath
     class PathPlus < Operator::Unary
       include Query
       
@@ -25,8 +25,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}"}
 
@@ -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

@@ -6,7 +6,7 @@ module SPARQL; module Algebra
     # @example
     #   (path* :p)
     #
-    # @see http://www.w3.org/TR/sparql11-query/#defn_evalPP_ZeroOrMorePath
+    # @see https://www.w3.org/TR/sparql11-query/#defn_evalPP_ZeroOrMorePath
     class PathStar < Operator::Unary
       include Query
       
@@ -28,14 +28,14 @@ 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}"}
 
         # (: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

@@ -7,9 +7,9 @@ module SPARQL; module Algebra
     #   (+ ?x ?y)
     #   (plus ?x ?y)
     #
-    # @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
+    # @see https://www.w3.org/TR/xpath-functions/#func-numeric-unary-plus
+    # @see https://www.w3.org/TR/xpath-functions/#func-numeric-add
+    class Plus < Operator
       include Evaluatable
 
       NAME = [:+, :plus]

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

@@ -8,7 +8,7 @@ module SPARQL; module Algebra
     #     (graph ?g
     #       (bgp (triple ?s ?p ?o))))
     #
-    # @see http://www.w3.org/TR/sparql11-query/#QSynIRI
+    # @see https://www.w3.org/TR/sparql11-query/#QSynIRI
     class Prefix < Binary
       include Query
       
@@ -29,21 +29,21 @@ 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) {"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
-      
+
       ##
       # Returns an optimized version of this query.
       #
-      # If optimize operands, and if the first two operands are both Queries, replace
-      # with the unique sum of the query elements
+      # Replace with the query with URIs having their lexical shortcut removed
       #
-      # @return [Union, RDF::Query] `self`
-      def optimize
-        operands.last.optimize
+      # @return [Prefix] a copy of `self`
+      # @see SPARQL::Algebra::Expression#optimize
+      def optimize(**options)
+        operands.last.optimize(**options)
       end
 
       # Combine two prefix definitions, merging their definitions