sparql 3.0.2 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 580566c94580d213820adba65200fe89f481d405cbf27d65fe17a4c8eaf3ccd3
-  data.tar.gz: ab7b0abec9d6bd8aba6f3dd53f79fd53f78e29e0cde8871453d7186adb6c35a0
+  metadata.gz: 99a1a48cccda17e81f9d49d0a53d2cdd43b1dec5111379e64291c3877c91ee97
+  data.tar.gz: 5c96caf41975f32d829711fddd63092deee2532e4c8612520a43e93657c0545f
 SHA512:
-  metadata.gz: b66443f1a4cad8aa4691466dcfb05b42dc7c2b411b7a31dc913510d89e4e05972bee60f189ec7dc0b171734c801adc200d7f1eb13869e6636784218e6e4e1a15
-  data.tar.gz: 873f1bb69fee25a53f992a7a42e977f44da82f7ddca9b9030e05c1be485da6b9350f8feebcd2390e76116b3596cebf112da59752e4486517f2d9e602c2b7a7c4
+  metadata.gz: 9a877f93200339e3265642e69d940ea527b4a1c1280660a20c072417e71cfa95a92a12131cfb4072a3f577f14da69d49a83a9cb5f04b92fbb56fc98ec6178f82
+  data.tar.gz: 8601d4cc7ffc9d238f815c2141eedccba1e30d12f60f0251a025329aa00e0f1f3c6775ab241c03d2d5f4cb51c1a4c30941b72e7283f75b3ba83d1ec8e0935577

data/README.md

@@ -330,8 +330,8 @@ A copy of the [SPARQL 1.0 tests][] and [SPARQL 1.1 tests][] are also included in
 [SPARQL 1.0]:       http://www.w3.org/TR/sparql11-query/
 [SPARQL 1.0 tests]:http://www.w3.org/2001/sw/DataAccess/tests/
 [SPARQL 1.1 tests]: http://www.w3.org/2009/sparql/docs/tests/
-[SSE]:              http://openjena.org/wiki/SSE
-[SXP]:              http://www.rubydoc.info/github/bendiken/sxp-ruby
+[SSE]:              https://jena.apache.org/documentation/notes/sse.html
+[SXP]:              http://www.rubydoc.info/github/dryruby/sxp
 [grammar]:          http://www.w3.org/TR/sparql11-query/#grammar
 [RDF 1.1]:          http://www.w3.org/TR/rdf11-concepts
 [RDF.rb]:           http://rubydoc.info/github/ruby-rdf/rdf

data/VERSION

@@ -1 +1 @@
-3.0.2
+3.1.0

data/bin/sparql

@@ -9,7 +9,7 @@ rescue LoadError
 end
 require 'getoptlong'
 
-def display_results(res, options)
+def display_results(res, **options)
   puts res.inspect if options[:verbose]
   puts case res
   when RDF::Graph   then res.dump(:ttl, base_uri: query.base_uri, prefixes: query.prefixes, standard_prefixes: true)
@@ -18,7 +18,7 @@ def display_results(res, options)
   end
 end
 
-def run(input, options = {})
+def run(input, **options)
   if options[:debug]
     puts "input graph:\n#{options[:dataset].dump(:trig, standard_prefixes: true)}\n" if options[:dataset]
     puts "query:\n#{input}\n"
@@ -30,17 +30,17 @@ def run(input, options = {})
   end
 
   query = if options[:sse]
-    SPARQL::Algebra.parse(input, {debug: options[:debug], update: options[:update]})
+    SPARQL::Algebra.parse(input, debug: options[:debug], update: options[:update])
   else
     # Only do grammar debugging if we're generating SSE
-    SPARQL::Grammar.parse(input, options)
+    SPARQL::Grammar.parse(input, **options)
   end
 
   puts ("\nSSE:\n" + query.to_sse) if options[:debug] || options[:to_sse]
 
   unless options[:to_sse]
     res = query.execute(options[:dataset], debug: options[:debug])
-    display_results(res, options)
+    display_results(res, **options)
   end
 end
 
@@ -54,7 +54,7 @@ def server(options)
 
     get '/' do
       if params["query"]
-        query = params["query"].to_s.match(/^http:/) ? RDF::Util::File.open_file(params["query"]) : ::URI.decode(params["query"].to_s)
+        query = params["query"].to_s.match(/^http:/) ? RDF::Util::File.open_file(params["query"]) : ::CGI.unescape(params["query"].to_s)
         SPARQL.execute(query, settings.repository)
       else
         settings.sparql_options.replace(standard_prefixes: true)
@@ -132,7 +132,7 @@ case cmd
 when 'execute', 'parse'
   options[:to_sse] = true if cmd == 'parse'
   input ||= ARGV.empty? ? $stdin.read : RDF::Util::File.open_file(ARGV.first).read
-  run(input, options)
+  run(input, **options)
 when 'query'
   endpoint = ARGV.shift
   unless endpoint
@@ -142,7 +142,7 @@ when 'query'
   input ||= ARGV.empty? ? $stdin.read : RDF::Util::File.open_file(ARGV.first).read
   SPARQL::Client.new(endpoint) do |client|
     res = client.query(input)
-    display_results(res, options)
+    display_results(res, **options)
   end
 when 'server'
   if data_file = ARGV.shift

data/lib/rack/sparql.rb

@@ -18,7 +18,7 @@ module Rack
     # @param  [Hash{Symbol => Object}] options
     # @option options [Boolean]        :overwrite (false)
     # @return [void]
-    def self.register_mime_types!(options = {})
+    def self.register_mime_types!(**options)
       if defined?(Rack::Mime::MIME_TYPES)
         RDF::Format.each do |format|
           if !Rack::Mime::MIME_TYPES.has_key?(file_ext = ".#{format.to_sym}") || options[:overwrite]

data/lib/rack/sparql/conneg.rb

@@ -71,7 +71,7 @@ module Rack; module SPARQL
         serialize_options = {}
         serialize_options[:content_types] = env['ORDERED_CONTENT_TYPES'] if env['ORDERED_CONTENT_TYPES']
         serialize_options.merge!(@options)
-        results = ::SPARQL.serialize_results(body, serialize_options)
+        results = ::SPARQL.serialize_results(body, **serialize_options)
         raise RDF::WriterError, "can't serialize results" unless results
         headers = headers.merge(VARY).merge('Content-Type' => results.content_type) # FIXME: don't overwrite existing Vary headers
         [status, headers, [results]]

data/lib/sinatra/sparql.rb

@@ -27,7 +27,7 @@ module Sinatra
       #
       # @see http://www.w3.org/TR/sparql11-service-description
       # @see http://www.w3.org/TR/void/
-      def service_description(options = {})
+      def service_description(**options)
         repository = options[:repository]
 
         g = RDF::Graph.new

data/lib/sparql.rb

@@ -28,8 +28,8 @@ module SPARQL
   #   a `queryable` object such as an RDF::Graph
   #   or RDF::Repository. 
   # @raise  [Parser::Error] on invalid input
-  def self.parse(query, options = {})
-    query = Grammar::Parser.new(query, options).parse(options[:update] ? :UpdateUnit : :QueryUnit)
+  def self.parse(query, **options)
+    query = Grammar::Parser.new(query, **options).parse(options[:update] ? :UpdateUnit : :QueryUnit)
   end
 
   ##
@@ -67,8 +67,8 @@ module SPARQL
   # @return [RDF::Graph, Boolean, RDF::Query::Solutions::Enumerator]
   #   Note, results may be used with {SPARQL.serialize_results} to obtain appropriate output encoding.
   # @raise  [SPARQL::MalformedQuery] on invalid input
-  def self.execute(query, queryable, options = {}, &block)
-    query = self.parse(query, options)
+  def self.execute(query, queryable, **options, &block)
+    query = self.parse(query, **options)
     queryable = queryable || RDF::Repository.new
     
     case options.fetch(:debug, nil)

data/lib/sparql/algebra.rb

@@ -372,8 +372,8 @@ module SPARQL
     # @param  [Hash{Symbol => Object}] options
     #   any additional options (see {Operator#initialize})
     # @return [SPARQL::Algebra::Operator]
-    def parse(sse, options = {})
-      Expression.parse(sse, options)
+    def parse(sse, **options)
+      Expression.parse(sse, **options)
     end
     module_function :parse
 
@@ -390,8 +390,8 @@ module SPARQL
     # @yieldparam  [SPARQL::Algebra::Expression] expression
     # @yieldreturn [void] ignored
     # @return [Expression]
-    def open(sse, options = {})
-      Expression.open(sse, options)
+    def open(sse, **options)
+      Expression.open(sse, **options)
     end
     module_function :open
 

data/lib/sparql/algebra/aggregate.rb

@@ -24,12 +24,12 @@ module SPARQL; module Algebra
     # @return [RDF::Term]
     # @raise [TypeError]
     # @abstract
-    def aggregate(solutions = [], options = {})
+    def aggregate(solutions = [], **options)
       operands.shift if distinct = (operands.first == :distinct)
       args_enum = solutions.map do |solution|
         operands.map do |operand|
           begin
-            operand.evaluate(solution, options.merge(depth: options[:depth].to_i + 1))
+            operand.evaluate(solution, depth: options[:depth].to_i + 1, **options)
           rescue TypeError
             # Ignore errors
             nil

data/lib/sparql/algebra/evaluatable.rb

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

data/lib/sparql/algebra/expression.rb

@@ -19,7 +19,7 @@ module SPARQL; module Algebra
     # @yieldparam  [SPARQL::Algebra::Expression] expression
     # @yieldreturn [void] ignored
     # @return [Expression]
-    def self.parse(sse, options = {}, &block)
+    def self.parse(sse, **options, &block)
       begin
         require 'sxp' # @see http://rubygems.org/gems/sxp
       rescue LoadError
@@ -38,7 +38,7 @@ module SPARQL; module Algebra
       Operator.base_uri = options.delete(:base_uri) if options.has_key?(:base_uri)
       Operator.prefixes = sxp.prefixes || {}
 
-      expression = self.new(sxp_result, options)
+      expression = self.new(sxp_result, **options)
 
       yield(expression) if block_given?
       expression
@@ -57,8 +57,8 @@ module SPARQL; module Algebra
     # @yieldparam  [SPARQL::Algebra::Expression] expression
     # @yieldreturn [void] ignored
     # @return [Expression]
-    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|
         options[:base_uri] ||= filename
         Expression.parse(file, options, &block)
       end
@@ -87,7 +87,7 @@ module SPARQL; module Algebra
     #   any additional options (see {Operator#initialize})
     # @return [Expression]
     # @raise  [TypeError] if any of the operands is invalid
-    def self.new(sse, options = {})
+    def self.new(sse, **options)
       raise ArgumentError, "invalid SPARQL::Algebra::Expression form: #{sse.inspect}" unless sse.is_a?(Array)
 
       operator = Operator.for(sse.first, sse.length - 1)
@@ -95,7 +95,7 @@ module SPARQL; module Algebra
         return case sse.first
         when Array
           debug(options) {"Map array elements #{sse}"}
-          sse.map {|s| self.new(s, options.merge(depth: options[:depth].to_i + 1))}
+          sse.map {|s| self.new(s, depth: options[:depth].to_i + 1, **options)}
         else
           debug(options) {"No operator found for #{sse.first}"}
           sse.map do |s|
@@ -110,7 +110,7 @@ module SPARQL; module Algebra
         debug(options) {"Operator=#{operator.inspect}, Operand=#{operand.inspect}"}
         case operand
           when Array
-            self.new(operand, options.merge(depth: options[:depth].to_i + 1))
+            self.new(operand, depth: options[:depth].to_i + 1, **options)
           when Operator, Variable, RDF::Term, RDF::Query, Symbol
             operand
           when TrueClass, FalseClass, Numeric, String, DateTime, Date, Time

data/lib/sparql/algebra/extensions.rb

@@ -4,7 +4,7 @@ require 'json'
 # Extensions for Ruby's `NilClass` class.
 class NilClass
 
-  def evaluate(bindings, options = {})
+  def evaluate(bindings, **options)
     self
   end
 
@@ -53,8 +53,8 @@ class Array
   #   options passed from query
   # @return [RDF::Term]
   # @see SPARQL::Algebra::Expression.evaluate
-  def evaluate(bindings, options = {})
-    SPARQL::Algebra::Expression.extension(*self.map {|o| o.evaluate(bindings, options)})
+  def evaluate(bindings, **options)
+    SPARQL::Algebra::Expression.extension(*self.map {|o| o.evaluate(bindings, **options)})
   end
 
   ##
@@ -67,7 +67,7 @@ class Array
   # @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 = {})
+  def execute(queryable, **options)
     raise NotImplementedError, "SPARQL::Algebra '#{first}' operator not implemented"
   end
 
@@ -191,7 +191,7 @@ module RDF::Term
   # @param [Hash{Symbol => Object}] options ({})
   #   options passed from query
   # @return [RDF::Term]
-  def evaluate(bindings, options = {})
+  def evaluate(bindings, **options)
     self
   end
 
@@ -243,7 +243,7 @@ module RDF::Queryable
       solutions = if method(:query_execute).arity == 1
         query_execute(pattern, &block)
       else
-        query_execute(pattern, options, &block)
+        query_execute(pattern, **options, &block)
       end
       after_query(pattern) if respond_to?(:after_query)
 
@@ -252,10 +252,10 @@ module RDF::Queryable
         solutions
       else
         # Return an enumerator
-        enum_for(:query, pattern, options)
+        enum_for(:query, pattern, **options)
       end
     else
-      query_without_sparql(pattern, options, &block)
+      query_without_sparql(pattern, **options, &block)
     end
   end
   
@@ -386,15 +386,10 @@ class RDF::Query::Variable
   #   options passed from query
   # @return [RDF::Term] the value of this variable
   # @raise [TypeError] if the variable is not bound
-  def evaluate(bindings, options = {})
+  def evaluate(bindings, **options)
     raise TypeError if bindings.respond_to?(:bound?) && !bindings.bound?(self)
     bindings[name.to_sym]
   end
-
-  def to_s
-    prefix = distinguished? || name.to_s[0,1] == '.' ? '?' : "??"
-    unbound? ? "#{prefix}#{name}" : "#{prefix}#{name}=#{value}"
-  end
 end # RDF::Query::Variable
 
 ##

data/lib/sparql/algebra/operator.rb

@@ -331,7 +331,7 @@ module SPARQL; module Algebra
     # @overload initialize(*operands)
     #   @param  [Array<RDF::Term>] operands
     #
-    # @overload initialize(*operands, options)
+    # @overload initialize(*operands, **options)
     #   @param  [Array<RDF::Term>] operands
     #   @param  [Hash{Symbol => Object}] options
     #     any additional options

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

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

@@ -33,7 +33,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) {"Alt #{[subject, operands, object].to_sse}"}
 
@@ -55,7 +55,7 @@ module SPARQL; module Algebra
         end
 
         query = Union.new(qa, qb)
-        queryable.query(query, options.merge(depth: options[:depth].to_i + 1), &block)
+        queryable.query(query, depth: options[:depth].to_i + 1, **options, &block)
       end
     end # Alt
   end # Operator

data/lib/sparql/algebra/operator/and.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
 
@@ -37,15 +37,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 boolean literals
-      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/asc.rb

@@ -24,8 +24,8 @@ module SPARQL; module Algebra
       # @param [Hash{Symbol => Object}] options ({})
       #   options passed from query
       # @return [RDF::Term]
-      def evaluate(bindings, options = {})
-        operand(0).evaluate(bindings, options.merge(depth: options[:depth].to_i + 1))
+      def evaluate(bindings, **options)
+        operand(0).evaluate(bindings, depth: options[:depth].to_i + 1, **options)
       end
     end # Asc
   end # Operator

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

@@ -29,9 +29,9 @@ module SPARQL; module Algebra
       # @yieldreturn [void] ignored
       # @return [RDF::Literal::Boolean]\
       # @see    http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
-      def execute(queryable, options = {})
+      def execute(queryable, **options)
         debug(options) {"Ask #{operands.first}"}
-        res = boolean(!queryable.query(operands.last, options.merge(depth: options[:depth].to_i + 1)).empty?)
+        res = boolean(!queryable.query(operands.last, depth: options[:depth].to_i + 1, **options).empty?)
         yield res if block_given?
         res
       end

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

@@ -6,12 +6,12 @@ module SPARQL; module Algebra
     # @example
     #    (prefix ((: <http://www.example.org/>))
     #      (project (?avg)
-    #        (extend ((?avg ?.0))
-    #          (group () ((?.0 (avg ?o)))
+    #        (extend ((?avg ??.0))
+    #          (group () ((??.0 (avg ?o)))
     #            (bgp (triple ?s :dec ?o))))))
     #
     # @see http://www.w3.org/TR/sparql11-query/#defn_aggAvg
-    class Avg < Operator::Unary
+    class Avg < Operator
       include Aggregate
 
       NAME = :avg
@@ -23,6 +23,8 @@ module SPARQL; module Algebra
       #   enum of evaluated operand
       # @return [RDF::Literal::Numeric] The numeric average 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/base.rb

@@ -29,10 +29,10 @@ module SPARQL; module Algebra
       # @return [RDF::Queryable, 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) {"Base #{operands.first}"}
         Operator.base_uri = operands.first
-        queryable.query(operands.last, options.merge(depth: options[:depth].to_i + 1), &block)
+        queryable.query(operands.last, depth: options[:depth].to_i + 1, **options, &block)
       end
       
       ##