sparql 1.0.6 → 1.0.7

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

@@ -0,0 +1,34 @@
+require 'digest'
+
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL logical `sha1` operator.
+    #
+    # @example
+    #     (prefix ((: <http://example.org/>))
+    #       (project (?hash)
+    #         (extend ((?hash (sha384 ?l)))
+    #           (bgp (triple :s1 :str ?l)))))
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#func-sha384
+    class SHA384 < Operator::Unary
+      include Evaluatable
+
+      NAME = :sha384
+
+      ##
+      # Returns the SHA384 checksum, as a hex digit string, calculated on the UTF-8 representation of the simple literal or lexical form of the xsd:string. Hex digits should be in lower case.
+      #
+      # @param  [RDF::Literal] operand
+      #   the operand
+      # @return [RDF::Literal]
+      # @raise  [TypeError] if the operand is not a simple literal
+      def apply(operand)
+        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))
+      end
+    end # SHA384
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -0,0 +1,34 @@
+require 'digest'
+
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL logical `sha512` operator.
+    #
+    # @example
+    #     (prefix ((: <http://example.org/>))
+    #       (project (?hash)
+    #         (extend ((?hash (sha512 ?l)))
+    #           (bgp (triple :s1 :str ?l)))))
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#func-sha512
+    class SHA512 < Operator::Unary
+      include Evaluatable
+
+      NAME = :sha512
+
+      ##
+      # Returns the SHA512 checksum, as a hex digit string, calculated on the UTF-8 representation of the simple literal or lexical form of the xsd:string. Hex digits should be in lower case.
+      #
+      # @param  [RDF::Literal] operand
+      #   the operand
+      # @return [RDF::Literal]
+      # @raise  [TypeError] if the operand is not a simple literal
+      def apply(operand)
+        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))
+      end
+    end # SHA512
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -0,0 +1,57 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # A SPARQL `strafter` operator.
+    #
+    # @example
+    #   (strafter ?x ?y)
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#func-strafter
+    # @see http://www.w3.org/TR/xpath-functions/#func-substring-after
+    class StrAfter < Operator::Binary
+      include Evaluatable
+
+      NAME = :strafter
+
+      ##
+      # The STRAFTER function corresponds to the XPath fn:substring-after function. The arguments must be argument compatible otherwise an error is raised.
+      #
+      # For compatible arguments, if the lexical part of the second argument occurs as a substring of the lexical part of the first argument, the function returns a literal of the same kind as the first argument arg1 (simple literal, plain literal same language tag, xsd:string). The lexical form of the result is the substring of the lexcial form of arg1 that follows the first occurrence of the lexical form of arg2. If the lexical form of arg2 is the empty string, this is considered to be a match and the lexical form of the result is the lexical form of arg1.
+      #
+      # If there is no such occurrence, an empty simple literal is returned.
+      #
+      # @example
+      #     strafter("abc","b") #=> "c"
+      #     strafter("abc"@en,"ab") #=> "c"@en
+      #     strafter("abc"@en,"b"@cy) #=> error
+      #     strafter("abc"^^xsd:string,"") #=> "abc"^^xsd:string
+      #     strafter("abc","xyz") #=> ""
+      #     strafter("abc"@en, "z"@en) #=> ""
+      #     strafter("abc"@en, "z") #=> ""
+      #     strafter("abc"@en, ""@en) #=> "abc"@en
+      #     strafter("abc"@en, "") #=> "abc"@en
+      #
+      # @param  [RDF::Literal] left
+      #   a literal
+      # @param  [RDF::Literal] right
+      #   a literal
+      # @return [RDF::Literal]
+      # @raise  [TypeError] if operands are not compatible
+      def apply(left, right)
+        case
+        when !left.compatible?(right)
+          raise TypeError, "expected two RDF::Literal operands, but got #{left.inspect} and #{right.inspect}"
+        when right.to_s.empty?
+          # If the lexical form of arg2 is the empty string, this is considered to be a match and the lexical form of the result is the lexical form of arg1. 
+          left
+        when !left.to_s.include?(right.to_s)
+          # If the lexical form of arg2 is the empty string, this is considered to be a match and the lexical form of the result is is the empty string. 
+          RDF::Literal("")
+        else
+          parts = left.to_s.split(right.to_s)
+          RDF::Literal(parts.last, :datatype => left.datatype, :language => left.language)
+        end
+      end
+    end # StrAfter
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -0,0 +1,59 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # A SPARQL `strbefore` operator.
+    #
+    # @example
+    #   (strbefore ?x ?y)
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#func-strbefore
+    # @see http://www.w3.org/TR/xpath-functions/#func-substring-before
+    class StrBefore < Operator::Binary
+      include Evaluatable
+
+      NAME = :strbefore
+
+      ##
+      # The STRBEFORE function corresponds to the XPath fn:substring-before function. The arguments must be argument compatible otherwise an error is raised.
+      #
+      # For compatible arguments, if the lexical part of the second argument occurs as a substring of the lexical part of the first argument, the function returns a literal of the same kind as the first argument arg1 (simple literal, plain literal same language tag, xsd:string). The lexical form of the result is the substring of the lexical form of arg1 that precedes the first occurrence of the lexical form of arg2. If the lexical form of arg2 is the empty string, this is considered to be a match and the lexical form of the result is the empty string.
+      #
+      # If there is no such occurrence, an empty simple literal is returned.
+      #
+      # @example
+      #     strbefore("abc","b") #=> "a"
+      #     strbefore("abc"@en,"bc") #=> "a"@en
+      #     strbefore("abc"@en,"b"@cy) #=> error
+      #     strbefore("abc"^^xsd:string,"") #=> ""^^xsd:string
+      #     strbefore("abc","xyz") #=> ""
+      #     strbefore("abc"@en, "z"@en) #=> ""
+      #     strbefore("abc"@en, "z") #=> ""
+      #     strbefore("abc"@en, ""@en) #=> ""@en
+      #     strbefore("abc"@en, "") #=> ""@en
+      #
+      # @param  [RDF::Literal] left
+      #   a literal
+      # @param  [RDF::Literal] right
+      #   a literal
+      # @return [RDF::Literal]
+      # @raise  [TypeError] if operands are not compatible
+      def apply(left, right)
+        case
+        when !left.plain? || !right.plain?
+          raise TypeError, "expected two RDF::Literal operands, but got #{left.inspect} and #{right.inspect}"
+        when !left.compatible?(right)
+          raise TypeError, "expected two RDF::Literal operands, but got #{left.inspect} and #{right.inspect}"
+        when right.to_s.empty?
+          # If the lexical form of arg2 is the empty string, this is considered to be a match and the lexical form of the result is is the empty string. 
+          RDF::Literal("", :language => left.language, :datatype => left.datatype)
+        when !left.to_s.include?(right.to_s)
+          # If the lexical form of arg2 is the empty string, this is considered to be a match and the lexical form of the result is is the empty string. 
+          RDF::Literal("")
+        else
+          parts = left.to_s.split(right.to_s)
+          RDF::Literal(parts.first, :language => left.language, :datatype => left.datatype)
+        end
+      end
+    end # StrBefore
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -0,0 +1,33 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL `strdt` operator.
+    #
+    # @example
+    #     (project (?s ?str1)
+    #       (extend ((?str1 (strdt ?str xsd:string)))
+    #         (filter (langMatches (lang ?str) "en")
+    #           (bgp (triple ?s :str ?str))))))
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#func-strdt
+    class StrDT < Operator::Binary
+      include Evaluatable
+
+      NAME = :strdt
+
+      ##
+      # Constructs a literal with lexical form and type as specified by the arguments.
+      #
+      # @param  [RDF::Literal] value
+      #   a literal
+      # @param  [RDF::URI] datatypeIRI
+      #   datatype
+      # @return [RDF::Literal] a datatyped literal
+      # @see http://www.w3.org/TR/sparql11-query/#func-strdt
+      def apply(value, datatypeIRI)
+        raise TypeError, "Literal #{value.inspect} is not simple" unless value.simple?
+        RDF::Literal.new(value.to_s, :datatype => datatypeIRI)
+      end
+    end # StrDT
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -0,0 +1,46 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # A SPARQL `contains` operator.
+    #
+    # @example
+    #   (strends ?x ?y)
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#func-strends
+    # @see http://www.w3.org/TR/xpath-functions/#func-ends-with
+    class StrEnds < Operator::Binary
+      include Evaluatable
+
+      NAME = :strends
+
+      ##
+      # The STRENDS function corresponds to the XPath fn:ends-with function. The arguments must be argument compatible otherwise an error is raised.
+      # 
+      # For such input pairs, the function returns true if the lexical form of arg1 ends with the lexical form of arg2, otherwise it returns false.
+      #
+      # @example
+      #     strEnds("foobar", "bar") #=> true
+      #     strEnds("foobar"@en, "bar"@en) #=> true
+      #     strEnds("foobar"^^xsd:string, "bar"^^xsd:string) #=> true
+      #     strEnds("foobar"^^xsd:string, "bar") #=> true
+      #     strEnds("foobar", "bar"^^xsd:string) #=> true
+      #     strEnds("foobar"@en, "bar") #=> true
+      #     strEnds("foobar"@en, "bar"^^xsd:string) #=> true
+      #
+      # @param  [RDF::Literal] left
+      #   a literal
+      # @param  [RDF::Literal] right
+      #   a literal
+      # @return [RDF::Literal::Boolean]
+      # @raise  [TypeError] if operands are not compatible
+      def apply(left, right)
+        case
+        when !left.compatible?(right)
+          raise TypeError, "expected two RDF::Literal operands, but got #{left.inspect} and #{right.inspect}"
+        when left.to_s.end_with?(right.to_s) then RDF::Literal::TRUE
+        else RDF::Literal::FALSE
+        end
+      end
+    end # StrEnds
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -0,0 +1,34 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL `strlang` operator.
+    #
+    # @example
+    #     (prefix ((: <http://example.org/>))
+    #       (project (?s ?s2)
+    #         (extend ((?s2 (strlang ?str "en-US")))
+    #           (filter (langMatches (lang ?str) "en")
+    #             (bgp (triple ?s :str ?str))))))
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#func-strlang
+    class StrLang < Operator::Binary
+      include Evaluatable
+
+      NAME = :strlang
+
+      ##
+      # Constructs a literal with lexical form and type as specified by the arguments.
+      #
+      # @param  [RDF::Literal] value
+      #   a literal
+      # @param  [RDF::Literal] datatypeIRI
+      #   datatype
+      # @return [RDF::Literal] a datatyped literal
+      # @see http://www.w3.org/TR/sparql11-query/#func-strlang
+      def apply(value, langTag)
+        raise TypeError, "Literal #{value.inspect} is not simple" unless value.simple?
+        RDF::Literal.new(value.to_s, :language => langTag.to_s)
+      end
+    end # StrLang
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -0,0 +1,34 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL `strlen` operator.
+    #
+    # @example
+    #   (strlen ?x)
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#func-strlen
+    # @see http://www.w3.org/TR/xpath-functions/#func-string-length
+    class StrLen < Operator::Unary
+      include Evaluatable
+
+      NAME = :strlen
+
+      ##
+      # The strlen function corresponds to the XPath fn:string-length function and returns an xsd:integer equal to the length in characters of the lexical form of the literal.
+      #
+      # @example
+      #     strlen("chat")	4
+      #     strlen("chat"@en)	4
+      #     strlen("chat"^^xsd:string)	4
+      #
+      # @param  [RDF::Literal] operand
+      #   the operand
+      # @return [RDF::Literal::Integer] length of string
+      # @raise  [TypeError] if the operand is not a numeric value
+      def apply(operand)
+        raise TypeError, "expected a plain RDF::Literal, but got #{operand.inspect}" unless operand.literal? && operand.plain?
+        RDF::Literal(operand.to_s.length)
+      end
+    end # StrLen
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -0,0 +1,46 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # A SPARQL `strstarts` operator.
+    #
+    # @example
+    #   (strstarts ?x ?y)
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#func-strstarts
+    # @see http://www.w3.org/TR/xpath-functions/#func-starts-with
+    class StrStarts < Operator::Binary
+      include Evaluatable
+
+      NAME = :strstarts
+
+      ##
+      # The STRSTARTS function corresponds to the XPath fn:starts-with function. The arguments must be argument compatible otherwise an error is raised.
+      #
+      # For such input pairs, the function returns true if the lexical form of arg1 starts with the lexical form of arg2, otherwise it returns false.
+      #
+      # @example
+      #     strStarts("foobar", "foo") #=> true
+      #     strStarts("foobar"@en, "foo"@en) #=> true
+      #     strStarts("foobar"^^xsd:string, "foo"^^xsd:string) #=> true
+      #     strStarts("foobar"^^xsd:string, "foo") #=> true
+      #     strStarts("foobar", "foo"^^xsd:string) #=> true
+      #     strStarts("foobar"@en, "foo") #=> true
+      #     strStarts("foobar"@en, "foo"^^xsd:string) #=> true
+      #
+      # @param  [RDF::Literal] left
+      #   a literal
+      # @param  [RDF::Literal] right
+      #   a literal
+      # @return [RDF::Literal::Boolean]
+      # @raise  [TypeError] if operands are not compatible
+      def apply(left, right)
+        case
+        when !left.compatible?(right)
+          raise TypeError, "expected two RDF::Literal operands, but got #{left.inspect} and #{right.inspect}"
+        when left.to_s.start_with?(right.to_s) then RDF::Literal::TRUE
+        else RDF::Literal::FALSE
+        end
+      end
+    end # StrStarts
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -0,0 +1,32 @@
+require 'securerandom'
+
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL `uuid` function.
+    #
+    # @example
+    #     (prefix ((: <http://example.org/>)
+    #              (xsd: <http://www.w3.org/2001/XMLSchema#>))
+    #       (project (?length)
+    #         (extend ((?length (strlen ?uuid)))
+    #           (filter (&& (isLiteral ?uuid) (regex ?uuid "^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$" "i"))
+    #             (extend ((?uuid (struuid)))
+    #               (bgp))))))
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#func-struuid
+    class StrUUID < Operator::Nullary
+      include Evaluatable
+
+      NAME = :struuid
+
+      ##
+      # 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
+        RDF::Literal(SecureRandom.uuid)
+      end
+    end # StrUUID
+  end # Operator
+end; end # SPARQL::Algebra

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

@@ -0,0 +1,80 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # A SPARQL `substr` operator.
+    #
+    # @example
+    #   (substr ?x ?y)
+    #
+    # @see http://www.w3.org/TR/sparql11-query/#func-substr
+    # @see http://www.w3.org/TR/xpath-functions/#func-substring
+    class SubStr < Operator::Ternary
+      include Evaluatable
+
+      NAME = :substr
+
+      ##
+      # Initializes a new operator instance.
+      #
+      # @param  [RDF::Literal] source
+      # @param  [RDF::Litereal::Integer] startingLoc
+      # @param  [RDF::Litereal::Integer] length (-1)
+      # @param  [Hash{Symbol => Object}] options
+      #   any additional options (see {Operator#initialize})
+      # @raise  [TypeError] if any operand is invalid
+      def initialize(source, startingLoc, length = RDF::Literal(""), options = {})
+        super
+      end
+
+      ##
+      # The substr function corresponds to the XPath fn:substring function and returns a literal of the same kind (simple literal, literal with language tag, xsd:string typed literal) as the source input parameter but with a lexical form formed from the substring of the lexcial form of the source.
+      #
+      # The arguments startingLoc and length may be derived types of xsd:integer.
+      #
+      # The index of the first character in a strings is 1.
+      #
+      # @example
+      #     substr("foobar", 4) #=> "bar"
+      #     substr("foobar"@en, 4) #=> "bar"@en
+      #     substr("foobar"^^xsd:string, 4) #=> "bar"^^xsd:string
+      #     substr("foobar", 4, 1) #=> "b"
+      #     substr("foobar"@en, 4, 1) #=> "b"@en
+      #     substr("foobar"^^xsd:string, 4, 1) #=> "b"^^xsd:string
+      #
+      # @param  [RDF::Literal] source
+      #   a literal
+      # @param  [RDF::Literal] startingLoc
+      #   an 1-based integer offset into source
+      # @param [RDF::Literal::Integer] length (-1)
+      #   an optional length of the substring.
+      # @return [RDF::Literal]
+      # @raise  [TypeError] if operands are not compatible
+      def apply(source, startingLoc, length)
+        raise TypeError, "expected a plain RDF::Literal, but got #{source.inspect}" unless source.literal? && source.plain?
+        text = text.to_s
+
+        raise TypeError, "expected an integer, but got #{startingLoc.inspect}" unless startingLoc.is_a?(RDF::Literal::Integer)
+        startingLoc = startingLoc.to_i
+
+        if length == RDF::Literal("")
+          RDF::Literal(source.to_s[(startingLoc-1)..-1], :datatype => source.datatype, :language => source.language)
+        else
+          raise TypeError, "expected an integer, but got #{length.inspect}" unless length.is_a?(RDF::Literal::Integer)
+          length = length.to_i
+          RDF::Literal(source.to_s[(startingLoc-1), length], :datatype => source.datatype, :language => source.language)
+        end
+      end
+
+      ##
+      # Returns the SPARQL S-Expression (SSE) representation of this expression.
+      #
+      # Remove the optional argument.
+      #
+      # @return [Array] `self`
+      # @see    http://openjena.org/wiki/SSE
+      def to_sxp_bin
+        [NAME] + operands.reject {|o| o.to_s == ""}
+      end
+    end # SubStr
+  end # Operator
+end; end # SPARQL::Algebra