sparql 3.0.2 → 3.1.0

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

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

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

@@ -31,9 +31,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)
         @solutions = operands.last.
-          execute(queryable, options.merge(depth: options[:depth].to_i + 1)).reduced
+          execute(queryable, depth: options[:depth].to_i + 1, **options).reduced
         @solutions.each(&block) if block_given?
         @solutions
       end

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

@@ -26,7 +26,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(text, pattern, flags = RDF::Literal(''), options = {})
+      def initialize(text, pattern, flags = RDF::Literal(''), **options)
         super
       end
 

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

@@ -27,7 +27,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(text, pattern, replacement, flags = RDF::Literal(''), options = {})
+      def initialize(text, pattern, replacement, flags = RDF::Literal(''), **options)
         super
       end
 

data/lib/sparql/algebra/operator/reverse.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)
         debug(options) {"Reverse #{operands.to_sse}"}
         subject, object = options[:subject], options[:object]
 
@@ -42,7 +42,7 @@ module SPARQL; module Algebra
         else
           operand(0)
         end
-        queryable.query(query, options.merge(
+        queryable.query(query, **options.merge(
           subject: object,
           object: subject,
           depth: options[:depth].to_i + 1

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

@@ -7,8 +7,8 @@ module SPARQL; module Algebra
     #   (prefix ((: <http://www.example.org/>))
     #     (filter (|| (|| (= ?sample 1.0) (= ?sample 2.2)) (= ?sample 3.5))
     #       (project (?sample)
-    #         (extend ((?sample ?.0))
-    #           (group () ((?.0 (sample ?o)))
+    #         (extend ((?sample ??.0))
+    #           (group () ((??.0 (sample ?o)))
     #             (bgp (triple ?s :dec ?o)))))))
     #
     # @see http://www.w3.org/TR/sparql11-query/#defn_aggSample

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

@@ -29,12 +29,11 @@ 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) {"Seq #{[subject, operands, object].to_sse}"}
 
-        v = RDF::Query::Variable.new
-        v.distinguished = false
+        v = RDF::Query::Variable.new(distinguished: false)
         q1 = if operand(0).is_a?(RDF::Term)
           RDF::Query.new do |q|
             q.pattern [subject, operand(0), v]
@@ -50,10 +49,10 @@ module SPARQL; module Algebra
           operand(1)
         end
 
-        left = queryable.query(q1, options.merge(object: v, depth: options[:depth].to_i + 1))
+        left = queryable.query(q1, **options.merge(object: v, depth: options[:depth].to_i + 1))
         debug(options) {"(seq)=>(left) #{left.map(&:to_h).to_sse}"}
 
-        right = queryable.query(q2, options.merge(subject: v, depth: options[:depth].to_i + 1))
+        right = queryable.query(q2, **options.merge(subject: v, depth: options[:depth].to_i + 1))
         debug(options) {"(seq)=>(right) #{right.map(&:to_h).to_sse}"}
 
         @solutions = RDF::Query::Solutions(left.map do |s1|

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

@@ -35,14 +35,14 @@ 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 = {})
+      def execute(queryable, **options)
         debug(options) {"Sequence #{operands.to_sse}"}
 
-        last = queryable.query(operands.shift, options.merge(depth: options[:depth].to_i + 1))
+        last = queryable.query(operands.shift, depth: options[:depth].to_i + 1, **options)
         debug(options) {"(sequence)=>(last) #{last.map(&:to_h).to_sse}"}
 
         operands.each do |op|
-          this = queryable.query(op, options.merge(depth: options[:depth].to_i + 1))
+          this = queryable.query(op, depth: options[:depth].to_i + 1, **options)
           debug(options) {"(sequence)=>(this) #{this.map(&:to_h).to_sse}"}
 
           last = last.map do |s1|

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

@@ -43,10 +43,10 @@ module SPARQL; module Algebra
       # @return [RDF::Query::Solutions]
       #   the resulting solution sequence
       # @see    http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
-      def execute(queryable, options = {}, &block)
+      def execute(queryable, **options, &block)
         offset = operands[0] == :_ ? 0 : operands[0].to_i
         limit = operands[1] == :_ ? -1 : operands[1].to_i
-        @solutions = operands.last. execute(queryable, options.merge(depth: options[:depth].to_i + 1))
+        @solutions = operands.last. execute(queryable, depth: options[:depth].to_i + 1, **options)
         @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/substr.rb

@@ -22,7 +22,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(source, startingLoc, length = RDF::Literal(""), options = {})
+      def initialize(source, startingLoc, length = RDF::Literal(""), **options)
         super
       end
 

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

@@ -6,12 +6,12 @@ module SPARQL; module Algebra
     # @example
     #    (prefix ((: <http://www.example.org/>))
     #      (project (?sum)
-    #        (extend ((?sum ?.0))
-    #          (group () ((?.0 (sum ?o)))
+    #        (extend ((?sum ??.0))
+    #          (group () ((??.0 (sum ?o)))
     #            (bgp (triple ?s :dec ?o))))))
     #
     # @see http://www.w3.org/TR/sparql11-query/#defn_aggSum
-    class Sum < Operator::Unary
+    class Sum < Operator
       include Aggregate
 
       NAME = :sum
@@ -23,6 +23,8 @@ module SPARQL; module Algebra
       #   enum of evaluated operand
       # @return [RDF::Literal::Numeric] The sum 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?
           RDF::Literal(0)
         elsif enum.flatten.all? {|n| n.is_a?(RDF::Literal::Numeric)}

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

@@ -33,7 +33,7 @@ module SPARQL; module Algebra
       # @return [RDF::Query::Solutions]
       #   the resulting solution sequence
       # @see    http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
-      def execute(queryable, options = {}, &block)
+      def execute(queryable, **options, &block)
         @solutions = RDF::Query::Solutions()
         Array(operands[1..-1]).each do |row|
           next unless row.is_a?(Array)

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

@@ -31,10 +31,10 @@ module SPARQL; module Algebra
       # @return [RDF::Query::Solutions]
       #   the resulting solution sequence
       # @see    http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
-      def execute(queryable, options = {}, &block)
+      def execute(queryable, **options, &block)
         debug(options) {"Union"}
         @solutions = RDF::Query::Solutions(operands.inject([]) do |memo, op|
-          solns = op.execute(queryable, options.merge(depth: options[:depth].to_i + 1))
+          solns = op.execute(queryable, depth: options[:depth].to_i + 1, **options)
           debug(options) {"=> (op) #{solns.inspect}"}
           memo + solns
         end)

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

@@ -31,11 +31,11 @@ module SPARQL; module Algebra
       # @raise [IOError]
       #   If `queryable` is immutable
       # @see    http://www.w3.org/TR/sparql11-update/
-      def execute(queryable, options = {})
+      def execute(queryable, **options)
         debug(options) {"Update"}
         raise IOError, "queryable is not mutable" unless queryable.mutable?
         operands.each do |op|
-          op.execute(queryable, options.merge(depth: options[:depth].to_i + 1))
+          op.execute(queryable, depth: options[:depth].to_i + 1, **options)
         end
         queryable
       end

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

@@ -31,9 +31,9 @@ module SPARQL; module Algebra
       # @raise [IOError]
       #   If `from` does not exist, unless the `silent` operator is present
       # @see    http://www.w3.org/TR/sparql11-update/
-      def execute(queryable, options = {}, &block)
+      def execute(queryable, **options, &block)
         debug(options) {"Using"}
-        Dataset.new(*operands).execute(queryable, options.merge(depth: options[:depth].to_i + 1), &block)
+        Dataset.new(*operands).execute(queryable, depth: options[:depth].to_i + 1, **options, &block)
       end
     end # Using
   end # Operator

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

@@ -33,7 +33,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) {"With: #{operand.to_sse}"}
         # Bound variable
         name = operands.shift
@@ -42,7 +42,7 @@ module SPARQL; module Algebra
           debug(options) {"=> default data source #{name}"}
           load_opts = {debug: options.fetch(:debug, nil), base_uri: name}
           debug(options) {"=> load #{name}"}
-          queryable.load(name.to_s, load_opts)
+          queryable.load(name.to_s, **load_opts)
         end
 
         # Set name for RDF::Graph descendants having no graph_name to the name variable
@@ -58,12 +58,12 @@ module SPARQL; module Algebra
         query = operands.shift
 
         # Restrict query portion to this graph
-        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
       end

data/lib/sparql/algebra/query.rb

@@ -50,7 +50,7 @@ module SPARQL; module Algebra
     # @raise [NotImplementedError]
     #   If an attempt is made to perform an unsupported operation
     # @see    http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
-    def execute(queryable, options = {}, &block)
+    def execute(queryable, **options, &block)
       raise NotImplementedError, "#{self.class}#execute(#{queryable})"
     end
 

data/lib/sparql/algebra/update.rb

@@ -39,7 +39,7 @@ module SPARQL; module Algebra
     # @raise [NotImplementedError]
     #   If an attempt is made to perform an unsupported operation
     # @see    http://www.w3.org/TR/sparql11-update/
-    def execute(queryable, options = {}, &block)
+    def execute(queryable, **options, &block)
       raise NotImplementedError, "#{self.class}#execute(#{queryable})"
     end
 

data/lib/sparql/extensions.rb

@@ -54,11 +54,11 @@ module RDF::Queryable
 
       # Find terms not in self as a subject and recurse with their subjects
       terms.reject {|term| self.first(subject: term)}.each do |term|
-        self.query(predicate: term) do |statement|
+        self.query({predicate: term}) do |statement|
           query_terms << statement.subject
         end
 
-        self.query(object: term) do |statement|
+        self.query({object: term}) do |statement|
           query_terms << statement.subject
         end
       end
@@ -69,7 +69,7 @@ module RDF::Queryable
     # Don't consider term if already in graph
     terms.reject {|term| graph.first(subject: term)}.each do |term|
       # Find statements from queryiable with term as a subject
-      self.query(subject: term) do |statement|
+      self.query({subject: term}) do |statement|
         yield(statement) if block_given?
         graph << statement
         
@@ -81,7 +81,7 @@ module RDF::Queryable
             RDF.predicate => statement.predicate,
             RDF.object => statement.object,
           }
-        }).execute(self).each do |solution|
+        }, **{}).execute(self).each do |solution|
           # Recurse to include this subject
           recurse_opts = options.merge(non_subjects: false, graph: graph)
           self.concise_bounded_description(solution[:s], recurse_opts, &block)

data/lib/sparql/grammar.rb

@@ -175,8 +175,8 @@ module SPARQL
     # @param  [Hash{Symbol => Object}] options
     # @return [Parser]
     # @raise  [Parser::Error] on invalid input
-    def self.parse(query, options = {}, &block)
-      Parser.new(query, options).parse(options[:update] ? :UpdateUnit : :QueryUnit)
+    def self.parse(query, **options, &block)
+      Parser.new(query, **options).parse(options[:update] ? :UpdateUnit : :QueryUnit)
     end
 
     ##
@@ -190,8 +190,8 @@ module SPARQL
     # @yieldparam  [RDF::Reader] reader
     # @yieldreturn [void] ignored
     # @raise  [RDF::FormatError] if no reader found for the specified format
-    def self.open(filename, options = {}, &block)
-      RDF::Util::File.open_file(filename, options) do |file|
+    def self.open(filename, **options, &block)
+      RDF::Util::File.open_file(filename, **options) do |file|
         self.parse(file, options, &block)
       end
     end
@@ -206,8 +206,8 @@ module SPARQL
     # @param  [String, #to_s]          query
     # @param  [Hash{Symbol => Object}] options
     # @return [Boolean]
-    def self.valid?(query, options = {})
-      Parser.new(query, options).valid?
+    def self.valid?(query, **options)
+      Parser.new(query, **options).valid?
     end
 
     ##
@@ -225,7 +225,7 @@ module SPARQL
     # @yieldparam [Lexer] lexer
     # @return [Lexer]
     # @raise  [Lexer::Error] on invalid input
-    def self.tokenize(query, options = {}, &block)
+    def self.tokenize(query, **options, &block)
       Lexer.tokenize(query, options, &block)
     end
   end # Grammar

data/lib/sparql/grammar/parser11.rb

@@ -1415,7 +1415,7 @@ module SPARQL::Grammar
         str = lit.delete(:string)
         lit[:datatype] = lit.delete(:iri) if lit[:iri]
         lit[:language] = lit.delete(:language).last.downcase if lit[:language]
-        input[:literal] = RDF::Literal.new(str, lit) if str
+        input[:literal] = RDF::Literal.new(str, **lit) if str
       end
     end
 
@@ -1466,7 +1466,7 @@ module SPARQL::Grammar
     # @yieldparam  [SPARQL::Grammar::Parser] parser
     # @yieldreturn [void] ignored
     # @return [SPARQL::Grammar::Parser]
-    def initialize(input = nil, options = {}, &block)
+    def initialize(input = nil, **options, &block)
       @input = case input
       when IO, StringIO then input.read
       else input.to_s.dup
@@ -1530,10 +1530,13 @@ module SPARQL::Grammar
     # @see http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
     # @see http://axel.deri.ie/sparqltutorial/ESWC2007_SPARQL_Tutorial_unit2b.pdf
     def parse(prod = START)
-      ll1_parse(@input, prod.to_sym, @options.merge(branch: BRANCH,
-                                                    first: FIRST,
-                                                    follow: FOLLOW,
-                                                    whitespace: WS)
+      ll1_parse(@input,
+        prod.to_sym,
+        branch: BRANCH,
+        first: FIRST,
+        follow: FOLLOW,
+        whitespace: WS,
+        **@options
       ) do |context, *data|
         case context
         when :trace
@@ -1718,9 +1721,7 @@ module SPARQL::Grammar
 
       if id
         @vars[id] ||= begin
-          v = RDF::Query::Variable.new(id)
-          v.distinguished = distinguished
-          v
+          RDF::Query::Variable.new(id, distinguished: distinguished)
         end
       else
         unless distinguished
@@ -1728,9 +1729,7 @@ module SPARQL::Grammar
           id = @nd_var_gen
           @nd_var_gen = id.succ
         end
-        v = RDF::Query::Variable.new(id)
-        v.distinguished = distinguished
-        v
+        RDF::Query::Variable.new(id, distinguished: distinguished)
       end
     end
 
@@ -1758,7 +1757,7 @@ module SPARQL::Grammar
     end
 
     # Create a literal
-    def literal(value, options = {})
+    def literal(value, **options)
       options = options.dup
       # Internal representation is to not use xsd:string, although it could arguably go the other way.
       options.delete(:datatype) if options[:datatype] == RDF::XSD.string
@@ -1767,7 +1766,7 @@ module SPARQL::Grammar
         "options: #{options.inspect}, " +
         "validate: #{validate?.inspect}, "
       end
-      RDF::Literal.new(value, options.merge(validate: validate?))
+      RDF::Literal.new(value, validate: validate?, **options)
     end
 
     # Take collection of objects and create RDF Collection using rdf:first, rdf:rest and rdf:nil
@@ -1798,7 +1797,7 @@ module SPARQL::Grammar
     #
     # @param [String] production Production generating pattern
     # @param [Hash{Symbol => Object}] options
-    def add_pattern(production, options)
+    def add_pattern(production, **options)
       progress(production, "[:pattern, #{options[:subject]}, #{options[:predicate]}, #{options[:object]}]")
       triple = {}
       options.each_pair do |r, v|
@@ -1880,8 +1879,7 @@ module SPARQL::Grammar
               avf.first
             else
               # Allocate a temporary variable for this function, and retain the mapping for outside the group
-              av = RDF::Query::Variable.new(".#{agg}")
-              av.distinguished = false
+              av = RDF::Query::Variable.new(".#{agg}", distinguished: false)
               agg += 1
               aggregates << [av, function]
               av

data/lib/sparql/results.rb

@@ -185,7 +185,7 @@ module SPARQL
   # @return [String]
   #   String with serialized results and `#content_type`
   # @raise [RDF::WriterError] when inappropriate formatting options are used
-  def serialize_results(solutions, options = {})
+  def serialize_results(solutions, **options)
     format = options[:format].to_sym if options[:format]
     content_type = options[:content_type].to_s.split(';').first
     content_types = Array(options[:content_types] || '*/*')
@@ -236,7 +236,7 @@ module SPARQL
       end
       format ||= fmt.to_sym
       content_type ||= fmt.content_type.first
-      results = solutions.dump(format, options)
+      results = solutions.dump(format, **options)
       raise RDF::WriterError, "Unknown format #{fmt.inspect} for #{solutions.class}" unless results
       results
     when RDF::Query::Solutions
@@ -306,7 +306,7 @@ module SPARQL
   #   May also be an RDF::Writer content_type to serialize DESCRIBE or CONSTRUCT results
   # @return [String]
   #   String with serialized results and #content_type
-  def serialize_exception(exception, options = {})
+  def serialize_exception(exception, **options)
     format = options[:format]
     content_type = options[:content_type]
     content_type ||= SPARQL::Results::MIME_TYPES[format]