sparql 3.1.6 → 3.1.7

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

@@ -24,8 +24,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 # LessThanOrEqual
   end # Operator

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

@@ -31,7 +31,7 @@ module SPARQL; module Algebra
       # @param  [Enumerable<Array<RDF::Term>>] enum
       #   enum of evaluated operand
       # @return [RDF::Literal] The maximum value 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/md5.rb

@@ -26,7 +26,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, but got #{operand.inspect}" unless operand.literal?
         raise TypeError, "expected simple literal or xsd:string, but got #{operand.inspect}" unless (operand.datatype || RDF::XSD.string) == RDF::XSD.string
         RDF::Literal(Digest::MD5.new.hexdigest(operand.to_s))

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

@@ -31,7 +31,7 @@ module SPARQL; module Algebra
       # @param  [Enumerable<Array<RDF::Term>>] enum
       #   enum of evaluated operand
       # @return [RDF::Literal] The maximum value 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/minutes.rb

@@ -24,7 +24,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.minute)
       end

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

@@ -24,7 +24,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.month)
       end

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

@@ -22,7 +22,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)
             left * right

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

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

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

@@ -23,7 +23,7 @@ module SPARQL; module Algebra
       #   the operand
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if the operand could not be coerced to a boolean literal
-      def apply(operand)
+      def apply(operand, **options)
         case bool = boolean(operand)
           when RDF::Literal::Boolean
             RDF::Literal(bool.false?)

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

@@ -12,13 +12,15 @@ module SPARQL; module Algebra
       # Returns `true` if the operands are not equal; returns `false`
       # otherwise.
       #
+      # Comparing unknown datatypes might have different lexical forms but be the same value.
+      #
       # @param  [RDF::Term] term1
       #   an RDF term
       # @param  [RDF::Term] term2
       #   an RDF term
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if either operand is not an RDF term
-      def apply(term1, term2)
+      def apply(term1, term2, **options)
         RDF::Literal(super.false?)
       end
     end # NotEqual

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

@@ -23,7 +23,7 @@ module SPARQL; module Algebra
       # Returns an XSD dateTime value for the current query execution. All calls to this function in any one query execution must return the same value. The exact moment returned is not specified.
       #
       # @return [RDF::Literal::Double] random value
-      def apply
+      def apply(**options)
         RDF::Literal(DateTime.now)
       end
     end # Now

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

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

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

@@ -40,7 +40,13 @@ module SPARQL; module Algebra
             memo = begin
               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 = begin
+                Operator::Compare.evaluate(a_eval, b_eval, order_by: true).to_s.to_i
+              rescue TypeError
+                # Type sError is effectively zero
+                debug(options) {"(order) rescue(#{$!}): #{a_eval.inspect}, #{b_eval.inspect}"}
+                RDF::Literal(0)
+              end
               comp = -comp if op.is_a?(Operator::Desc)
               comp
             end if memo == 0

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

@@ -23,7 +23,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 = nil)
+      def apply(left, right = nil, **options)
         case
         when left.is_a?(RDF::Literal::Numeric) && right.is_a?(RDF::Literal::Numeric)
           left + right

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

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

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

@@ -18,7 +18,7 @@ module SPARQL; module Algebra
       # Returns a pseudo-random number between 0 (inclusive) and 1.0e0 (exclusive). Different numbers can be produced every time this function is invoked. Numbers should be produced with approximately equal probability.
       #
       # @return [RDF::Literal::Double] random value
-      def apply
+      def apply(**options)
         RDF::Literal::Double.new(Random.rand)
       end
     end # Rand

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

@@ -42,7 +42,7 @@ module SPARQL; module Algebra
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if any operand is unbound
       # @raise  [TypeError] if any operand is not a simple literal
-      def apply(text, pattern, flags = RDF::Literal(''))
+      def apply(text, pattern, flags = RDF::Literal(''), **options)
         # @see https://www.w3.org/TR/xpath-functions/#regex-syntax
         raise TypeError, "expected a plain RDF::Literal, but got #{text.inspect}" unless text.is_a?(RDF::Literal) && text.plain?
         text = text.to_s

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

@@ -42,7 +42,7 @@ module SPARQL; module Algebra
       # @return [RDF::Literal] 
       # @raise  [TypeError] if any operand is unbound
       # @raise  [TypeError] if any operand is not a plain literal
-      def apply(text, pattern, replacement, flags = RDF::Literal(''))
+      def apply(text, pattern, replacement, flags = RDF::Literal(''), **options)
         raise TypeError, "expected a plain RDF::Literal, but got #{text.inspect}" unless text.literal? && text.plain?
         # TODO: validate text syntax
 

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

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

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

@@ -26,7 +26,7 @@ module SPARQL; module Algebra
       #   an RDF term
       # @return [RDF::Literal::Boolean] `true` or `false`
       # @raise  [TypeError] if either operand is unbound
-      def apply(term1, term2)
+      def apply(term1, term2, **options)
         RDF::Literal(term1.eql?(term2))
       end
 

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

@@ -31,7 +31,7 @@ module SPARQL; module Algebra
       #   enum of evaluated operand
       # @return [RDF::Term] An arbitrary term
       # @raise  [TypeError] If enum is empty
-      def apply(enum)
+      def apply(enum, **options)
         enum.detect(lambda {raise TypeError, "Sampling an empty multiset"}) {|e| e.first}.first
       end
     end # LCase

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

@@ -24,7 +24,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.second)
       end

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

@@ -26,7 +26,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, but got #{operand.inspect}" unless operand.literal?
         raise TypeError, "expected simple literal or xsd:string, but got #{operand.inspect}" unless (operand.datatype || RDF::XSD.string) == RDF::XSD.string
         RDF::Literal(Digest::SHA1.new.hexdigest(operand.to_s))

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

@@ -26,7 +26,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, but got #{operand.inspect}" unless operand.literal?
         raise TypeError, "expected simple literal or xsd:string, but got #{operand.inspect}" unless (operand.datatype || RDF::XSD.string) == RDF::XSD.string
         RDF::Literal(Digest::SHA256.new.hexdigest(operand.to_s))

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

@@ -26,7 +26,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, but got #{operand.inspect}" unless operand.literal?
         raise TypeError, "expected simple literal or xsd:string, but got #{operand.inspect}" unless (operand.datatype || RDF::XSD.string) == RDF::XSD.string
         RDF::Literal(Digest::SHA384.new.hexdigest(operand.to_s))

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

@@ -26,7 +26,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, but got #{operand.inspect}" unless operand.literal?
         raise TypeError, "expected simple literal or xsd:string, but got #{operand.inspect}" unless (operand.datatype || RDF::XSD.string) == RDF::XSD.string
         RDF::Literal(Digest::SHA512.new.hexdigest(operand.to_s))

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

@@ -23,7 +23,7 @@ module SPARQL; module Algebra
       #   a literal or IRI
       # @return [RDF::Literal] a simple literal
       # @raise  [TypeError] if the operand is not a literal or IRI
-      def apply(term)
+      def apply(term, **options)
         case term
           when RDF::Literal then RDF::Literal(term.value)
           when RDF::URI     then RDF::Literal(term.to_s)

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

@@ -37,7 +37,7 @@ module SPARQL; module Algebra
       #   a literal
       # @return [RDF::Literal]
       # @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/strbefore.rb

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

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

@@ -24,7 +24,7 @@ module SPARQL; module Algebra
       #   datatype
       # @return [RDF::Literal] a datatyped literal
       # @see https://www.w3.org/TR/sparql11-query/#func-strdt
-      def apply(value, datatypeIRI)
+      def apply(value, datatypeIRI, **options)
         raise TypeError, "Literal #{value.inspect} is not simple" unless value.simple?
         RDF::Literal.new(value.to_s, datatype: datatypeIRI)
       end

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

@@ -33,7 +33,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/strlang.rb

@@ -25,7 +25,7 @@ module SPARQL; module Algebra
       #   datatype
       # @return [RDF::Literal] a datatyped literal
       # @see https://www.w3.org/TR/sparql11-query/#func-strlang
-      def apply(value, langTag)
+      def apply(value, langTag, **options)
         raise TypeError, "Literal #{value.inspect} is not simple" unless value.simple?
         RDF::Literal.new(value.to_s, language: langTag.to_s)
       end

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

@@ -25,7 +25,7 @@ module SPARQL; module Algebra
       #   the operand
       # @return [RDF::Literal::Integer] length of string
       # @raise  [TypeError] if the operand is not a numeric value
-      def apply(operand)
+      def apply(operand, **options)
         raise TypeError, "expected a plain RDF::Literal, but got #{operand.inspect}" unless operand.literal? && operand.plain?
         RDF::Literal(operand.to_s.length)
       end

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

@@ -33,7 +33,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/struuid.rb

@@ -24,7 +24,7 @@ module SPARQL; module Algebra
       # Return a string that is the scheme specific part of UUID. That is, as a simple literal, the result of generating a UUID, converting to a simple literal and removing the initial urn:uuid:.
       #
       # @return [RDF::URI]
-      def apply
+      def apply(**options)
         RDF::Literal(SecureRandom.uuid)
       end
     end # StrUUID

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

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

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

@@ -49,7 +49,7 @@ module SPARQL; module Algebra
       #   an optional length of the substring.
       # @return [RDF::Literal]
       # @raise  [TypeError] if operands are not compatible
-      def apply(source, startingLoc, length)
+      def apply(source, startingLoc, length, **options)
         raise TypeError, "expected a plain RDF::Literal, but got #{source.inspect}" unless source.literal? && source.plain?
         text = text.to_s
 

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

@@ -20,7 +20,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)
             left - right

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

@@ -22,7 +22,7 @@ module SPARQL; module Algebra
       # @param  [Enumerable<Array<RDF::Term>>] enum
       #   enum of evaluated operand
       # @return [RDF::Literal::Numeric] The sum 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/timezone.rb

@@ -26,7 +26,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)
         raise TypeError, "literal has no timezone" unless res = operand.timezone
         res

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

@@ -17,7 +17,7 @@ module SPARQL; module Algebra
       # @param  [RDF::Term] object
       # @return [RDF::URI]
       # @raise  [TypeError] if the operand is not a simple literal
-      def apply(subject, predicate, object)
+      def apply(subject, predicate, object, **options)
         triple = RDF::Statement(subject, predicate, object)
         raise TypeError, "valid components, but got #{triple.inspect}" unless triple.valid?
         triple

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

@@ -24,7 +24,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)
         operand.tz
       end