sparql 3.1.6 → 3.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 383f162fe715a1ff7eebb78e095a77f1e1823d29045c673b57c5bf68acbcb70f
-  data.tar.gz: fc7f7ea801e556ee25a77dd340ea7268a7a5d0c39ee9bf2686cb71e887a58446
+  metadata.gz: dcc81f10a741a9060299f9b3f54e1a7a35442fb7b68b7a79b2d1b67e16c0108a
+  data.tar.gz: aa6dd52a91d86b9a981edb5f4d56bdd0da288932ece265578ba773bb289a5fe0
 SHA512:
-  metadata.gz: 662583eb75d9cca1a34d8d8299cee4eb7e97dc6d3251982300a077c888523bd63f8350be3ce1fed753692e2f26d056afd7381f26ac8115f6b72a7e8f2e89296e
-  data.tar.gz: 8cb4ee544f52b9599fb1d5dc6ac3b8a68a7755caded5b3baef706222565c9b59511e69f0921c2b00ece9f3fd22aebff543caa37c93a6d45b02a9e8211660931d
+  metadata.gz: 64669164cff7cdd9b1580bba3576247dafff7feef77ab63ba355afb51bded23a8f996ca952332abea8a4d06f8aca4ae5db25702a69748f8577aeedb720c5f788
+  data.tar.gz: d269e6c8edf25e5929876d292290257527f4bfe69def6fbe3e4500283a0ed2418ac4df5420a24fd35f826970ae63c3d679ba998d27184851cc8fe58648521df7

data/VERSION

@@ -1 +1 @@
-3.1.6
+3.1.7

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/operator.rb

@@ -314,8 +314,8 @@ module SPARQL; module Algebra
     # @param  [Array<RDF::Term>] operands
     # @return [RDF::Term]
     # @see    Operator#evaluate
-    def self.evaluate(*operands)
-      self.new(*operands).evaluate(RDF::Query::Solution.new)
+    def self.evaluate(*operands, **options)
+      self.new(*operands, **options).evaluate(RDF::Query::Solution.new, **options)
     end
 
     ##

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

@@ -29,7 +29,7 @@ module SPARQL; module Algebra
       # @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/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,69 +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)
-        when left.is_a?(RDF::Statement) && right.is_a?(RDF::Statement)
-          RDF::Literal(RDF::Literal(left.to_s).send(self.class.const_get(:NAME), RDF::Literal(right.to_s)))
+          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::Statement) && right.is_a?(RDF::Term)
-          RDF::Literal(-1)
-        when right.is_a?(RDF::Statement) && 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/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)

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

@@ -24,7 +24,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.floor
           else raise TypeError, "expected an RDF::Literal::Numeric, but got #{operand.inspect}"

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

@@ -24,8 +24,9 @@ module SPARQL; module Algebra
       #   a literal
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if either operand is not a literal
-      def apply(left, right)
-        super
+      def apply(left, right, **options)
+        #require 'byebug'; byebug if super == RDF::Literal(1)
+        RDF::Literal(super == RDF::Literal(1))
       end
     end # GreaterThan
   end # Operator

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

@@ -25,8 +25,8 @@ module SPARQL; module Algebra
       #   a literal
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if either operand is not a literal
-      def apply(left, right)
-        super
+      def apply(left, right, **options)
+        RDF::Literal(super >= RDF::Literal(0))
       end
     end # GreaterThanOrEqual
   end # Operator

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

@@ -50,7 +50,7 @@ module SPARQL; module Algebra
       #   enum of evaluated operand
       # @return [RDF::Term] An arbitrary term
       # @raise  [TypeError] If enum is empty
-      def apply(enum, separator)
+      def apply(enum, separator, **options)
         RDF::Literal(enum.flatten.map(&:to_s).join(separator.to_s))
       end
     end # GroupConcat

data/lib/sparql/algebra/operator/hours.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.hour)
       end

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

@@ -29,7 +29,7 @@ module SPARQL; module Algebra
       #   a simple literal
       # @return [RDF::URI]
       # @raise  [TypeError] if the operand is not a simple literal
-      def apply(literal)
+      def apply(literal, **options)
         raise TypeError, "expected an simple literal, but got #{literal.inspect}" unless literal.literal? && literal.simple?
         base = Operator.base_uri || RDF::URI("")
         base.join(literal.to_s)

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

@@ -23,7 +23,7 @@ module SPARQL; module Algebra
       #   an RDF term
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if the operand is not an RDF term
-      def apply(term)
+      def apply(term, **options)
         case term
           when RDF::Node then RDF::Literal::TRUE
           when RDF::Term then RDF::Literal::FALSE

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

@@ -23,7 +23,7 @@ module SPARQL; module Algebra
       #   an RDF term
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if the operand is not an RDF term
-      def apply(term)
+      def apply(term, **options)
         case term
           when RDF::URI  then RDF::Literal::TRUE
           when RDF::Term then RDF::Literal::FALSE

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

@@ -24,7 +24,7 @@ module SPARQL; module Algebra
       #   an RDF term
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if the operand is not an RDF term
-      def apply(term)
+      def apply(term, **options)
         case term
           when RDF::Literal then RDF::Literal::TRUE
           when RDF::Term    then RDF::Literal::FALSE

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

@@ -26,7 +26,7 @@ module SPARQL; module Algebra
       #   an RDF term
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if the operand is not an RDF term
-      def apply(term)
+      def apply(term, **options)
         case term
           when RDF::Literal::NonPositiveInteger then RDF::Literal::FALSE
           when RDF::Literal::NonNegativeInteger then RDF::Literal::FALSE

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

@@ -18,7 +18,7 @@ module SPARQL; module Algebra
       #   an RDF term
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if the operand is not an RDF term
-      def apply(term)
+      def apply(term, **options)
         case term
           when RDF::Statement  then RDF::Literal::TRUE
           when RDF::Term then RDF::Literal::FALSE

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

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

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

@@ -27,7 +27,7 @@ module SPARQL; module Algebra
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if either operand is unbound
       # @raise  [TypeError] if either operand is not a simple literal
-      def apply(language_tag, language_range)
+      def apply(language_tag, language_range, **options)
         raise TypeError, "expected a plain RDF::Literal for language_tag, but got #{language_tag.inspect}" unless language_tag.is_a?(RDF::Literal) && language_tag.simple?
         language_tag = language_tag.to_s.downcase
 

data/lib/sparql/algebra/operator/lcase.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 literal value
-      def apply(operand)
+      def apply(operand, **options)
         case operand
           when RDF::Literal then RDF::Literal(operand.to_s.downcase, datatype: operand.datatype, language: operand.language)
           else raise TypeError, "expected an RDF::Literal::Numeric, but got #{operand.inspect}"

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

@@ -24,8 +24,9 @@ module SPARQL; module Algebra
       #   a literal
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if either operand is not a literal
-      def apply(left, right)
-        super
+      def apply(left, right, **options)
+        #require 'byebug'; byebug if super == RDF::Literal(-1)
+        RDF::Literal(super == RDF::Literal(-1))
       end
     end # LessThan
   end # Operator