sparql 3.1.4 → 3.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ddc77cee587255c81cfcb3cd9d05759a3c98398821e23a25c3111f71e9b44c9
-  data.tar.gz: 48290eb8ba7ab1539c73c2fc3477b4004b8a15c5f09624ef24de5e3fe692ab03
+  metadata.gz: 0fc6d6745c325bd23d83fe640eb238a22406b567cf06223703afd90ea5733be1
+  data.tar.gz: 056cde1c14633aa791f492be673eb023bab95d7af4e5b19fb94c99540fc22908
 SHA512:
-  metadata.gz: 71b0e62c9d8d418e508befea92ca5723a24a0ccce9fcebf43f40ce7ee4a8299c81fdad5ae4302465defd04708abd04ef10c863ef1538f25c71c5a24ea45e826a
-  data.tar.gz: 6c1b568ed72dcdda4f68f613bcbf3de38512b8cde4b1c6b2a20d51370fb5bd4efce7dee766e3cfde64222853c52937890d5fcbeb48d4448a2694f0dce0729d0c
+  metadata.gz: 32187664d7d06bd49cffa8354987ce3f11ba44b35960a92ac80353a538a15489b342f1d3e66a0ad792971489e83cc57ab05b936e93f8e04fe2f5df4a527d3d39
+  data.tar.gz: 9d8a75fd40c9ccbac6a9753d9b7a04b9e26a4504a55636d61d3d34c1d4dde77c6838d5ac45828a40d06b7c4658971c1f435da0c6812e7b2eda4aa5dfcfaa9cda

data/README.md

@@ -4,7 +4,7 @@ This is a [Ruby][] implementation of [SPARQL][] for [RDF.rb][].
 
 [![Gem Version](https://badge.fury.io/rb/sparql.png)](https://badge.fury.io/rb/sparql)
 [![Build Status](https://github.com/ruby-rdf/sparql/workflows/CI/badge.svg?branch=develop)](https://github.com/ruby-rdf/sparql/actions?query=workflow%3ACI)
-[![Coverage Status](https://coveralls.io/repos/ruby-rdf/sparql/badge.svg)](https://coveralls.io/r/ruby-rdf/sparql)
+[![Coverage Status](https://coveralls.io/repos/ruby-rdf/sparql/badge.svg?branch=develop)](https://coveralls.io/r/ruby-rdf/sparql?branch=develop)
 [![Gitter chat](https://badges.gitter.im/ruby-rdf/rdf.png)](https://gitter.im/ruby-rdf/rdf)
 
 ## Features
@@ -26,7 +26,7 @@ This is a [Ruby][] implementation of [SPARQL][] for [RDF.rb][].
 * Compatible with Ruby >= 2.2.2.
 * Compatible with older Ruby versions with the help of the [Backports][] gem.
 * Supports Unicode query strings both on all versions of Ruby.
-* Provisional support for [SPARQL*][].
+* Provisional support for [SPARQL-star][].
 
 ## Description
 
@@ -96,9 +96,9 @@ Then, use the function in a query:
 
 See {SPARQL::Algebra::Expression.register_extension} for details.
 
-### SPARQLStar (SPARQL*)
+### SPARQLStar (SPARQL-star)
 
-The gem supports [SPARQL*][] where patterns may include sub-patterns recursively, for a kind of Reification.
+The gem supports [SPARQL-star][] where patterns may include sub-patterns recursively, for a kind of Reification.
 
 For example, the following Turtle* file uses a statement as the subject of another statement:
 
@@ -159,7 +159,7 @@ As well as a `CONSTRUCT`:
       <<?bob foaf:age ?age>> ?b ?c .
     }
 
-Note that results can be serialized only when the format supports [RDF*][].
+Note that results can be serialized only when the format supports [RDF-star][].
 
 #### SPARQL results
 
@@ -448,8 +448,8 @@ A copy of the [SPARQL 1.0 tests][] and [SPARQL 1.1 tests][] are also included in
 [grammar]:          https://www.w3.org/TR/sparql11-query/#grammar
 [RDF 1.1]:          https://www.w3.org/TR/rdf11-concepts
 [RDF.rb]:           https://rubydoc.info/github/ruby-rdf/rdf
-[RDF*]:             https://w3c.github.io/rdf-star/rdf-star-cg-spec.html
-[SPARQL*]:          https://w3c.github.io/rdf-star/rdf-star-cg-spec.html#sparql-query-language
+[RDF-star]:             https://w3c.github.io/rdf-star/rdf-star-cg-spec.html
+[SPARQL-star]:          https://w3c.github.io/rdf-star/rdf-star-cg-spec.html#sparql-query-language
 [Backports]:        https://rubygems.org/gems/backports
 [Linked Data]:      https://rubygems.org/gems/linkeddata
 [SPARQL doc]:       https://rubydoc.info/github/ruby-rdf/sparql/frames

data/VERSION

@@ -1 +1 @@
-3.1.4
+3.1.8

data/bin/sparql

@@ -1,6 +1,7 @@
 #!/usr/bin/env ruby
 require 'rubygems'
 $:.unshift("../../lib", __FILE__)
+require 'logger'
 require 'sparql'
 begin
   require 'linkeddata'

data/lib/sparql/algebra/aggregate.rb

@@ -44,7 +44,7 @@ module SPARQL; module Algebra
     #   Enumerable yielding evaluated operands
     # @return [RDF::Term]
     # @abstract
-    def apply(enum)
+    def apply(enum, **options)
       raise NotImplementedError, "#{self.class}#apply(#{operands.map(&:class).join(', ')})"
     end
 

data/lib/sparql/algebra/evaluatable.rb

@@ -15,16 +15,16 @@ module SPARQL; module Algebra
     # @abstract
     def evaluate(bindings, **options)
       args = operands.map { |operand| operand.evaluate(bindings, depth: options[:depth].to_i + 1, **options) }
-      options[:memoize] ? memoize(*args) : apply(*args)
+      options[:memoize] ? memoize(*args, **options) : apply(*args, **options)
     end
 
     ##
     # @param  [Array<RDF::Term>] operands
     #   evaluated operands
     # @return [RDF::Term] the memoized result
-    def memoize(*operands)
+    def memoize(*operands, **options)
       @cache ||= RDF::Util::Cache.new(options[:memoize].is_a?(Integer) ? options[:memoize] : -1)
-      @cache[operands] ||= apply(*operands)
+      @cache[operands] ||= apply(*operands, **options)
     end
 
     ##
@@ -32,7 +32,7 @@ module SPARQL; module Algebra
     #   evaluated operands
     # @return [RDF::Term]
     # @abstract
-    def apply(*operands)
+    def apply(*operands, **options)
       raise NotImplementedError, "#{self.class}#apply(#{operands.map(&:class).join(', ')})"
     end
 

data/lib/sparql/algebra/expression.rb

@@ -4,6 +4,8 @@ module SPARQL; module Algebra
   #
   # @abstract
   module Expression
+    include RDF::Util::Logger
+
     ##
     # @example
     #   Expression.parse('(isLiteral 3.1415)')
@@ -53,7 +55,7 @@ module SPARQL; module Algebra
     def self.open(filename, **options, &block)
       RDF::Util::File.open_file(filename, **options) do |file|
         options[:base_uri] ||= filename
-        Expression.parse(file, options, &block)
+        Expression.parse(file, **options, &block)
       end
     end
 
@@ -114,8 +116,11 @@ module SPARQL; module Algebra
 
       debug(options) {"#{operator.inspect}(#{operands.map(&:inspect).join(',')})"}
       options.delete_if {|k, v| [:debug, :logger, :depth, :prefixes, :base_uri, :update, :validate].include?(k) }
-      operands << options unless options.empty?
-      operator.new(*operands)
+      begin
+        operator.new(*operands, **options)
+      rescue ArgumentError => e
+        error(options) {"Operator=#{operator.inspect}: #{e}"}
+      end
     end
 
     ##
@@ -332,7 +337,7 @@ module SPARQL; module Algebra
     # @param [Hash{Symbol => Object}] options ({})
     #   options passed from query
     # @return [Expression] `self`
-    def evaluate(bindings, options = {})
+    def evaluate(bindings, **options)
       self
     end
 
@@ -407,7 +412,8 @@ module SPARQL; module Algebra
     end
     
     def debug(*args, &block)
-      Expression.debug(*args, &block)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      log_debug(*args, **options, &block)
     end
   end # Expression
 end; end # SPARQL::Algebra

data/lib/sparql/algebra/extensions.rb

@@ -308,7 +308,7 @@ module RDF::Queryable
   #
   # @example
   #     queryable.query([nil, RDF::DOAP.developer, nil])
-  #     queryable.query(predicate: RDF::DOAP.developer)
+  #     queryable.query({predicate: RDF::DOAP.developer})
   #
   #     op = SPARQL::Algebra::Expression.parse(%q((bgp (triple ?a doap:developer ?b))))
   #     queryable.query(op)
@@ -320,7 +320,7 @@ module RDF::Queryable
   # @yieldreturn [void] ignored
   # @return [Enumerator]
   # @see    RDF::Queryable#query_pattern
-  def query(pattern, options = {}, &block)
+  def query(pattern, **options, &block)
     raise TypeError, "#{self} is not queryable" if respond_to?(:queryable?) && !queryable?
 
     if pattern.is_a?(SPARQL::Algebra::Operator) && pattern.respond_to?(:execute)
@@ -529,6 +529,13 @@ class RDF::Query::Variable
   def optimize(**options)
     self
   end
+
+  # Display variable as SXP
+  # @return [Array]
+  def to_sxp
+    prefix = distinguished? ? (existential? ? '$' : '?') : (existential? ? '$$' : '??')
+    unbound? ? "#{prefix}#{name}".to_sym.to_sxp : ["#{prefix}#{name}".to_sym, value].to_sxp
+  end
 end # RDF::Query::Variable
 
 ##

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

@@ -20,7 +20,7 @@ module SPARQL; module Algebra
       #   the operand
       # @return [RDF::Literal] literal of same type
       # @raise  [TypeError] if the operand is not a numeric value
-      def apply(operand)
+      def apply(operand, **options)
         case operand
           when RDF::Literal::Numeric then operand.abs
           else raise TypeError, "expected an RDF::Literal::Numeric, but got #{operand.inspect}"

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

@@ -16,13 +16,20 @@ module SPARQL; module Algebra
 
       NAME = :avg
 
+      def initialize(*operands, **options)
+        raise ArgumentError,
+          "avg operator accepts at most one argument with an optional :distinct" if
+          (operands - %i{distinct}).length != 1
+        super
+      end
+
       ##
       # The Avg set function calculates the average value for an expression over a group. It is defined in terms of Sum and Count.
       #
       # @param  [Enumerable<Array<RDF::Term>>] enum
       #   enum of evaluated operand
       # @return [RDF::Literal::Numeric] The numeric average of the terms
-      def apply(enum)
+      def apply(enum, **options)
         # FIXME: we don't actually do anything with distinct
         operands.shift if distinct = (operands.first == :distinct)
         if enum.empty?

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

@@ -22,7 +22,7 @@ module SPARQL; module Algebra
       # @yieldparam  [RDF::Query::Solution] solution
       # @yieldreturn [void] ignored
       # @return [RDF::Query]
-      def self.new(*patterns, &block)
+      def self.new(*patterns, **options, &block)
         RDF::Query.new(*patterns, graph_name: false, &block)
       end
     end # BGP

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

@@ -57,7 +57,7 @@ module SPARQL; module Algebra
       #   a query solution containing zero or more variable bindings
       # @return [RDF::Node] 
       # @raise  [TypeError] if the operand is not a simple literal or nil
-      def apply(literal, bindings)
+      def apply(literal, bindings, **options)
         @@bnode_base ||= "b0"
         @@bindings ||= bindings
         @@bnodes ||= {}

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

@@ -20,7 +20,7 @@ module SPARQL; module Algebra
       #   the operand
       # @return [RDF::Literal] literal of same type
       # @raise  [TypeError] if the operand is not a numeric value
-      def apply(operand)
+      def apply(operand, **options)
         case operand
           when RDF::Literal::Numeric then operand.ceil
           else raise TypeError, "expected an RDF::Literal::Numeric, but got #{operand.inspect}"

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

@@ -30,62 +30,68 @@ module SPARQL; module Algebra
       # @param  [RDF::Literal] right
       #   a literal
       # @return [RDF::Literal::Integer] `-1`, `0`, or `1`
-      # @raise  [TypeError] if either operand is not a literal
-      def apply(left, right)
+      # @raise  [TypeError] if either operand is not a term
+      def apply(left, right, **options)
+        RDF::Literal(spaceship(left, right, **options))
+      end
+
+    private
+      # Define <=> as private for recursive statements
+      def spaceship(left, right, **options)
         case
         # @see https://www.w3.org/TR/sparql11-query/#OperatorMapping
         # @see https://www.w3.org/TR/sparql11-query/#modOrderBy
         when left.is_a?(RDF::Literal) && right.is_a?(RDF::Literal)
-          case
           # @see https://www.w3.org/TR/xpath-functions/#string-compare
           # @see https://www.w3.org/TR/xpath-functions/#comp.numeric
           # @see https://www.w3.org/TR/xpath-functions/#op.boolean
           # @see https://www.w3.org/TR/xpath-functions/#comp.duration.datetime
-          when (left.simple? && right.simple?) ||
-               (left.is_a?(RDF::Literal::Numeric) && right.is_a?(RDF::Literal::Numeric)) ||
-               (left.datatype == right.datatype && left.language == right.language)
-            RDF::Literal(left.send(self.class.const_get(:NAME), right))
-
-          # A plain literal is lower than an RDF literal with type xsd:string of the same lexical form.
-          when left.simple? && right.datatype == RDF::XSD.string && left.value == right.value
-            RDF::Literal(-1)
-          when right.simple? && left.datatype == RDF::XSD.string && right.value == left.value
-            RDF::Literal(-1)
-
-          else
-            left <=> right
-          end
-          
+          left <=> right
         when left.is_a?(RDF::URI) && right.is_a?(RDF::URI)
+          raise TypeError, "Comparing IRIs not supported" unless options[:order_by] || left == right
           # Pairs of IRIs are ordered by comparing them as simple literals.
-          RDF::Literal(RDF::Literal(left.to_s).send(self.class.const_get(:NAME), RDF::Literal(right.to_s)))
+          left.to_s <=> right.to_s
         when left.is_a?(RDF::Node) && right.is_a?(RDF::Node)
+          raise TypeError, "Comparing Blank nodes not supported" unless options[:order_by] || left == right
           # BNode comparison is undefined.
-          RDF::Literal(0)
+          left == right ? 0 : 1
         when left.nil? && right.nil?
-          RDF::Literal(0)
-        
+          0
+
+        when left.is_a?(RDF::Statement) && right.is_a?(RDF::Statement)
+          v = spaceship(left.subject, right.subject, **options)
+          v = spaceship(left.predicate, right.predicate, **options) if v == 0
+          v = spaceship(left.object, right.object, **options) if v == 0
+          v
+        when left.is_a?(RDF::Statement) && right.is_a?(RDF::Term)
+          raise TypeError, "Comparing statement with #{right.inspect}" unless options[:order_by]
+          1
+        when right.is_a?(RDF::Statement) && left.is_a?(RDF::Term)
+          raise TypeError, "Comparing statement with #{left.inspect}" unless options[:order_by]
+          -1
+
         # SPARQL also fixes an order between some kinds of RDF terms that would not otherwise be ordered:
 
         when left.nil? && !right.nil?
-          RDF::Literal(-1)
+          -1
         when right.nil?
-          RDF::Literal(1)
+          1
 
         when left.is_a?(RDF::Node) && right.is_a?(RDF::Term)
-          RDF::Literal(-1)
+          raise TypeError, "Comparing Blank nodes not supported" unless options[:order_by]
+          # Nodes lower than other terms
+          -1
         when right.is_a?(RDF::Node) && left.is_a?(RDF::Term)
-          RDF::Literal(1)
-
-        when left.is_a?(RDF::Node) && right.is_a?(RDF::URI)
-          RDF::Literal(-1)
-        when right.is_a?(RDF::Node) && left.is_a?(RDF::URI)
-          RDF::Literal(1)
+          raise TypeError, "Comparing Blank nodes not supported" unless options[:order_by]
+          1
 
         when left.is_a?(RDF::URI) && right.is_a?(RDF::Term)
-          RDF::Literal(-1)
+          raise TypeError, "Comparing IRIs not supported" unless options[:order_by]
+          # IRIs lower than terms other than nodes
+          -1
         when right.is_a?(RDF::URI) && left.is_a?(RDF::Term)
-          RDF::Literal(1)
+          raise TypeError, "Comparing IRIs not supported" unless options[:order_by]
+          1
         else raise TypeError, "expected two RDF::Term operands, but got #{left.inspect} and #{right.inspect}"
         end
       end

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

@@ -52,10 +52,11 @@ module SPARQL; module Algebra
               terms[r] = case o = pattern.send(r)
               when RDF::Node            then nodes[o] ||= RDF::Node.new
               when RDF::Query::Variable then solution[o]
+              when RDF::Query::Pattern  then RDF::Statement.from(o.dup.bind(solution))
               else                           o
               end
             end
-            
+
             statement = RDF::Statement.from(terms)
 
             # Sanity checking on statement

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

@@ -31,7 +31,7 @@ module SPARQL; module Algebra
       #   a literal
       # @return [RDF::Literal::Boolean]
       # @raise  [TypeError] if operands are not compatible
-      def apply(left, right)
+      def apply(left, right, **options)
         case
         when !left.compatible?(right)
           raise TypeError, "expected two RDF::Literal operands, but got #{left.inspect} and #{right.inspect}"

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

@@ -22,7 +22,7 @@ module SPARQL; module Algebra
       # @param  [Enumerable<Array<RDF::Term>>] enum
       #   enum of evaluated operand
       # @return [RDF::Literal::Integer] The number of non-error terms in the multiset
-      def apply(enum)
+      def apply(enum, **options)
         RDF::Literal(enum.length)
       end
     end # Count

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

@@ -27,7 +27,7 @@ module SPARQL; module Algebra
       #   a typed or simple literal
       # @return [RDF::URI] the datatype IRI, or `xsd:string` for simple literals
       # @raise  [TypeError] if the operand is not a typed or simple literal
-      def apply(literal)
+      def apply(literal, **options)
         case literal
           when RDF::Literal then literal.datatype
           else raise TypeError, "expected an RDF::Literal, but got #{literal.inspect}"

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

@@ -22,7 +22,7 @@ module SPARQL; module Algebra
       #   the operand
       # @return [RDF::Literal]
       # @raise  [TypeError] if the operand is not a simple literal
-      def apply(operand)
+      def apply(operand, **options)
         raise TypeError, "expected an RDF::Literal::DateTime, but got #{operand.inspect}" unless operand.is_a?(RDF::Literal::DateTime)
         RDF::Literal(operand.object.day)
       end

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

@@ -21,7 +21,7 @@ module SPARQL; module Algebra
       #   a numeric literal
       # @return [RDF::Literal::Numeric]
       # @raise  [TypeError] if either operand is not a numeric literal
-      def apply(left, right)
+      def apply(left, right, **options)
         case
           when left.is_a?(RDF::Literal::Numeric) && right.is_a?(RDF::Literal::Numeric)
             # For xsd:decimal and xsd:integer operands, if the divisor is

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

@@ -27,7 +27,7 @@ module SPARQL; module Algebra
       #   the operand
       # @return [RDF::Literal] literal of same type
       # @raise  [TypeError] if the operand is not a literal value
-      def apply(operand)
+      def apply(operand, **options)
         case operand
           when RDF::Literal then RDF::Literal(CGI.escape(operand.to_s))
           else raise TypeError, "expected an RDF::Literal, but got #{operand.inspect}"

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

@@ -26,7 +26,7 @@ module SPARQL; module Algebra
       # @raise  [TypeError] if either operand is not an RDF term or operands are not comperable
       #
       # @see RDF::Term#==
-      def apply(term1, term2)
+      def apply(term1, term2, **options)
         term1 = term1.dup.extend(RDF::TypeCheck)
         term2 = term2.dup.extend(RDF::TypeCheck)
         RDF::Literal(term1 == term2)