sparql 3.1.2 → 3.1.7

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

@@ -12,11 +12,18 @@ module SPARQL; module Algebra
     #             (bgp (triple ?s :dec ?o)))))))
     #
     # @see https://www.w3.org/TR/sparql11-query/#defn_aggSample
-    class Sample < Operator::Unary
+    class Sample < Operator
       include Aggregate
 
       NAME = :sample
 
+      def initialize(*operands, **options)
+        raise ArgumentError,
+          "sample operator accepts at most one argument with an optional :distinct" if
+          (operands - %i{distinct}).length != 1
+        super
+      end
+
       ##
       # Sample is a set function which returns an arbitrary value from the multiset passed to it.
       #
@@ -24,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

@@ -0,0 +1,29 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL `SUBJECT` operator.
+    #
+    # Returns the subject part of `arg` as a term.
+    #
+    # If triple is an RDF-star triple, the function returns the subject of this triple. Passing anything other than an RDF-star triple is an error.
+    #
+    # @see https://w3c.github.io/rdf-star/rdf-star-cg-spec.html#subject
+    class Subject < Operator::Unary
+      include Evaluatable
+
+      NAME = :subject
+
+      ##
+      # Returns the subject part of arg.
+      #
+      # @param  [RDF::Statement] operand
+      #   the operand
+      # @return [RDF::Literal]
+      # @raise  [TypeError] if the operand is not a statement
+      def apply(operand, **options)
+        raise TypeError, "expected an RDF::Statement, but got #{operand.inspect}" unless operand.is_a?(RDF::Statement)
+        operand.subject
+      end
+    end # Subject
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -0,0 +1,27 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL `triple` operator.
+    #
+    # If the 3-tuple (term1, term2, term3) is an RDF-star triple, the function returns this triple. If the 3-tuple is not an RDF-star triple, then the function raises an error.
+    #
+    # @see https://w3c.github.io/rdf-star/rdf-star-cg-spec.html#triple
+    class Triple < Operator::Ternary
+      include Evaluatable
+
+      NAME = :triple
+
+      ##
+      # @param  [RDF::Term] subject
+      # @param  [RDF::Term] predicate
+      # @param  [RDF::Term] object
+      # @return [RDF::URI]
+      # @raise  [TypeError] if the operand is not a simple literal
+      def apply(subject, predicate, object, **options)
+        triple = RDF::Statement(subject, predicate, object)
+        raise TypeError, "valid components, but got #{triple.inspect}" unless triple.valid?
+        triple
+      end
+    end # Triple
+  end # Operator
+end; end # SPARQL::Algebra

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

data/lib/sparql/algebra/operator/ucase.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.upcase, datatype: operand.datatype, language: operand.language)
           else raise TypeError, "expected an RDF::Literal::Numeric, but got #{operand.inspect}"

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

@@ -24,7 +24,7 @@ module SPARQL; module Algebra
       # Return a fresh IRI from the UUID URN scheme. Each call of UUID() returns a different UUID. It must not be the "nil" UUID (all zeroes). The variant and version of the UUID is implementation dependent.
       #
       # @return [RDF::URI]
-      def apply
+      def apply(**options)
         RDF::URI("urn:uuid:#{SecureRandom.uuid}")
       end
     end # UUID

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

@@ -40,7 +40,7 @@ module SPARQL; module Algebra
 
         unless queryable.has_graph?(name)
           debug(options) {"=> default data source #{name}"}
-          load_opts = {debug: options.fetch(:debug, nil), base_uri: name}
+          load_opts = {logger: options.fetch(:logger, false), base_uri: name}
           debug(options) {"=> load #{name}"}
           queryable.load(name.to_s, **load_opts)
         end

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

data/lib/sparql/extensions.rb

@@ -25,11 +25,7 @@ module RDF::Queryable
   #
   # Used to implement the SPARQL `DESCRIBE` operator.
   #
-  # @overload concise_bounded_description(*terms, &block)
-  #   @param [Array<RDF::Term>] terms
-  #     List of terms to include in the results.
-  #
-  # @overload concise_bounded_description(*terms, options, &block)
+  # @overload concise_bounded_description(*terms, **options, &block)
   #   @param [Array<RDF::Term>] terms
   #     List of terms to include in the results.
   #   @param [Hash{Symbol => Object}] options
@@ -44,16 +40,14 @@ module RDF::Queryable
   # @return [RDF::Graph]
   #
   # @see https://www.w3.org/Submission/CBD/
-  def concise_bounded_description(*terms, &block)
-    options = terms.last.is_a?(Hash) ? terms.pop.dup : {}
-
+  def concise_bounded_description(*terms, **options, &block)
     graph = options[:graph] || RDF::Graph.new
 
     if options[:non_subjects]
       query_terms = terms.dup
 
       # Find terms not in self as a subject and recurse with their subjects
-      terms.reject {|term| self.first(subject: term)}.each do |term|
+      terms.reject {|term| self.first({subject: term})}.each do |term|
         self.query({predicate: term}) do |statement|
           query_terms << statement.subject
         end
@@ -67,7 +61,7 @@ module RDF::Queryable
     end
 
     # Don't consider term if already in graph
-    terms.reject {|term| graph.first(subject: term)}.each do |term|
+    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|
         yield(statement) if block_given?
@@ -84,13 +78,13 @@ module RDF::Queryable
         }, **{}).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)
+          self.concise_bounded_description(solution[:s], **recurse_opts, &block)
         end
 
         # Recurse if object is a BNode and it is not already in subjects
         if statement.object.node?
           recurse_opts = options.merge(non_subjects: false, graph: graph)
-          self.concise_bounded_description(statement.object, recurse_opts, &block)
+          self.concise_bounded_description(statement.object, **recurse_opts, &block)
         end
       end
     end

data/lib/sparql/grammar.rb

@@ -1,7 +1,6 @@
 require 'rdf' # @see https://rubygems.org/gems/rdf
 require 'sparql/algebra'
 require 'json'
-require 'sxp'
 
 module SPARQL
   ##
@@ -193,31 +192,6 @@ module SPARQL
   #     PREFIX foaf: <http://xmlns.com/foaf/0.1/>
   #     PREFIX dct:  <http://purl.org/dc/elements/1.1/>
   #     
-  #     SELECT ?age ?src WHERE {
-  #        ?bob foaf:name "Bob" .
-  #        BIND( <<?bob foaf:age ?age>> AS ?t ) .
-  #        ?t dct:source ?src .
-  #     }
-  #
-  # SXP:
-  #
-  #     (prefix
-  #      (
-  #       (: <http://bigdata.com>)
-  #       (foaf: <http://xmlns.com/foaf/0.1/>)
-  #       (dct: <http://purl.org/dc/elements/1.1/>))
-  #      (project
-  #       (?age ?src)
-  #       (join
-  #        (extend ((?t (triple ?bob foaf:age ?age))) (bgp (triple ?bob foaf:name "Bob")))
-  #        (bgp (triple ?t dct:source ?src))) ))
-  #
-  # SPARQL:
-  #
-  #     PREFIX : <http://bigdata.com>
-  #     PREFIX foaf: <http://xmlns.com/foaf/0.1/>
-  #     PREFIX dct:  <http://purl.org/dc/elements/1.1/>
-  #     
   #     CONSTRUCT {
   #       ?bob foaf:name "Bob" .
   #       <<?bob foaf:age ?age>> dct:creator <http://example.com/crawlers#c1>;
@@ -293,7 +267,7 @@ module SPARQL
     # @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|
-        self.parse(file, options, &block)
+        self.parse(file, **options, &block)
       end
     end
 
@@ -327,7 +301,7 @@ module SPARQL
     # @return [Lexer]
     # @raise  [Lexer::Error] on invalid input
     def self.tokenize(query, **options, &block)
-      Lexer.tokenize(query, options, &block)
+      Lexer.tokenize(query, **options, &block)
     end
   end # Grammar
 end # SPARQL