rdf-n3 3.0.1 → 3.2.0

data/lib/rdf/n3/algebra/math/negation.rb

@@ -0,0 +1,38 @@
+module RDF::N3::Algebra::Math
+  ##
+  # The subject or object is calculated to be the negation of the other.
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-numeric-unary-minus
+  class Negation < RDF::N3::Algebra::ResourceOperator
+    include RDF::N3::Algebra::Builtin
+
+    NAME = :mathNegation
+    URI = RDF::N3::Math.negation
+
+    ##
+    # The math:negation operator takes may have either a bound subject or object.
+    #
+    # @param [RDF::Term] resource
+    # @param [:subject, :object] position
+    # @return [RDF::Term]
+    # @see RDF::N3::ResourceOperator#evaluate
+    def resolve(resource, position:)
+      case resource
+      when RDF::Query::Variable
+        resource
+      when RDF::Literal
+        as_literal(-resource.as_number)
+      else
+        nil
+      end
+    end
+
+    ##
+    # Input is either the subject or object
+    #
+    # @return [RDF::Term]
+    def input_operand
+      RDF::N3::List.new(values: operands)
+    end
+  end
+end

data/lib/rdf/n3/algebra/math/not_equal_to.rb

@@ -0,0 +1,25 @@
+module RDF::N3::Algebra::Math
+  ##
+  # True iff the subject is a string representation of a number which  is NOT EQUAL to a number of which the object is a string representation.
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-numeric-equal
+  class NotEqualTo < EqualTo
+    NAME = :mathNotEqualTo
+    URI = RDF::N3::Math.notEqualTo
+
+    ##
+    # The math:notEqualTo operator takes a pair of strings or numbers and determines if they are not the same numeric 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 or operands are not comperable
+    #
+    # @see RDF::Term#==
+    def apply(term1, term2)
+      RDF::Literal(super != RDF::Literal::TRUE)
+    end
+  end
+end

data/lib/rdf/n3/algebra/math/not_greater_than.rb

@@ -0,0 +1,25 @@
+module RDF::N3::Algebra::Math
+  ##
+  # True iff the subject is a string representation of a number which is NOT greater than the number of which the object is a string representation.
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-numeric-greater-than
+  class NotGreaterThan < GreaterThan
+    NAME = :mathNotGreaterThan
+    URI = RDF::N3::Math.notGreaterThan
+
+    ##
+    # Returns TRUE if `term1` is less than or equal to `term2`.
+    #
+    # @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 or operands are not comperable
+    #
+    # @see RDF::Term#==
+    def apply(term1, term2)
+      RDF::Literal(super != RDF::Literal::TRUE)
+    end
+  end
+end

data/lib/rdf/n3/algebra/math/not_less_than.rb

@@ -0,0 +1,25 @@
+module RDF::N3::Algebra::Math
+  ##
+  # True iff the subject is a string representation of a number which  is NOT LESS than a number of which the object is a string representation.
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-numeric-less-than
+  class NotLessThan < LessThan
+    NAME = :mathNotLessThan
+    URI = RDF::N3::Math.notLessThan
+
+    ##
+    # Returns TRUE if `term1` is greater than or equal to `term2`.
+    #
+    # @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 or operands are not comperable
+    #
+    # @see RDF::Term#==
+    def apply(term1, term2)
+      RDF::Literal(super != RDF::Literal::TRUE)
+    end
+  end
+end

data/lib/rdf/n3/algebra/math/product.rb

@@ -0,0 +1,20 @@
+module RDF::N3::Algebra::Math
+  ##
+  # The subject is a list of numbers. The object is calculated as the arithmentic product of those numbers.
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-numeric-multiply
+  class Product < RDF::N3::Algebra::ListOperator
+    NAME = :mathProduct
+    URI = RDF::N3::Math.product
+
+    ##
+    # The math:product operator takes a list of strings or numbers and calculates their sum.
+    #
+    # @param [RDF::N3::List] list
+    # @return [RDF::Term]
+    # @see RDF::N3::ListOperator#evaluate
+    def resolve(list)
+      list.to_a.map(&:as_number).reduce(&:*) || RDF::Literal(1)  # Empty list product is 1
+    end
+  end
+end

data/lib/rdf/n3/algebra/math/quotient.rb

@@ -0,0 +1,36 @@
+module RDF::N3::Algebra::Math
+  ##
+  # The subject is a pair of numbers. The object is calculated by dividing the first number of the pair by the second.
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-numeric-divide
+  class Quotient < RDF::N3::Algebra::ListOperator
+    NAME = :mathQuotient
+    URI = RDF::N3::Math.quotient
+
+    ##
+    # The math:quotient operator takes a pair of strings or numbers and calculates their quotient.
+    #
+    #
+    # @param [RDF::N3::List] list
+    # @return [RDF::Term]
+    # @see RDF::N3::ListOperator#evaluate
+    def resolve(list)
+      list.to_a.map(&:as_number).reduce(&:/)
+    end
+
+    ##
+    # The list argument must be a pair of literals.
+    #
+    # @param [RDF::N3::List] list
+    # @return [Boolean]
+    # @see RDF::N3::ListOperator#validate
+    def validate(list)
+      if super && list.all? {|le| le.is_a?(RDF::Literal)} && list.length == 2
+        true
+      else
+        log_error(NAME) {"list is not a pair of literals: #{list.to_sxp}"}
+        false
+      end
+    end
+  end
+end

data/lib/rdf/n3/algebra/math/remainder.rb

@@ -0,0 +1,35 @@
+module RDF::N3::Algebra::Math
+  ##
+  # The subject is a pair of integers. The object is calculated by dividing the first number of the pair by the second and taking the remainder.
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-numeric-mod
+  class Remainder < RDF::N3::Algebra::ListOperator
+    NAME = :mathRemainder
+    URI = RDF::N3::Math.remainder
+
+    ##
+    # The math:remainder operator takes a pair of strings or numbers and calculates their remainder.
+    #
+    # @param [RDF::N3::List] list
+    # @return [RDF::Term]
+    # @see RDF::N3::ListOperator#evaluate
+    def resolve(list)
+      list.to_a.map(&:as_number).reduce(&:%)
+    end
+
+    ##
+    # The list argument must be a pair of literals.
+    #
+    # @param [RDF::N3::List] list
+    # @return [Boolean]
+    # @see RDF::N3::ListOperator#validate
+    def validate(list)
+      if super && list.all? {|li| li.is_a?(RDF::Literal) && li.as_number.is_a?(RDF::Literal::Integer)} && list.length == 2
+        true
+      else
+        log_error(NAME) {"list is not a pair of integers: #{list.to_sxp}"}
+        false
+      end
+    end
+  end
+end

data/lib/rdf/n3/algebra/math/rounded.rb

@@ -0,0 +1,26 @@
+module RDF::N3::Algebra::Math
+  ##
+  # The object is calulated as the subject rounded to the nearest integer.
+  class Rounded < RDF::N3::Algebra::ResourceOperator
+    NAME = :mathRounded
+    URI = RDF::N3::Math.rounded
+
+    ##
+    # The math:rounded operator takes string or number rounds it to the next  integer.
+    #
+    # @param [RDF::Term] resource
+    # @param [:subject, :object] position
+    # @return [RDF::Term]
+    # @see RDF::N3::ResourceOperator#evaluate
+    def resolve(resource, position:)
+      case position
+      when :subject
+        return nil unless resource.literal?
+        as_literal(resource.as_number.round)
+      when :object
+        return nil unless resource.literal? || resource.variable?
+        resource
+      end
+    end
+  end
+end

data/lib/rdf/n3/algebra/math/sin.rb

@@ -0,0 +1,40 @@
+module RDF::N3::Algebra::Math
+  ##
+  # The subject is an angle expressed in radians. The object is calulated as the sine value of the subject.
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-math-sin
+  class Sin < RDF::N3::Algebra::ResourceOperator
+    NAME = :mathSin
+    URI = RDF::N3::Math.sin
+
+    ##
+    # The math:sin operator takes string or number and calculates its sine. The arc sine of a concrete object can also calculate a variable subject.
+    #
+    # @param [RDF::Term] resource
+    # @param [:subject, :object] position
+    # @return [RDF::Term]
+    # @see RDF::N3::ResourceOperator#evaluate
+    def resolve(resource, position:)
+      case resource
+      when RDF::Query::Variable then resource
+      when RDF::Literal
+        case position
+        when :subject
+          as_literal(Math.sin(resource.as_number.object))
+        when :object
+          as_literal(Math.sinh(resource.as_number.object))
+        end
+      else
+        nil
+      end
+    end
+
+    ##
+    # Input is either the subject or object
+    #
+    # @return [RDF::Term]
+    def input_operand
+      RDF::N3::List.new(values: operands)
+    end
+  end
+end

data/lib/rdf/n3/algebra/math/sinh.rb

@@ -0,0 +1,38 @@
+module RDF::N3::Algebra::Math
+  ##
+  # The subject is an angle expressed in radians. The object is calulated as the hyperbolic sine value of the subject.
+  class SinH < RDF::N3::Algebra::ResourceOperator
+    NAME = :mathSinH
+    URI = RDF::N3::Math.sinh
+
+    ##
+    # The math:sinh operator takes string or number and calculates its hyperbolic sine. The inverse hyperbolic sine of a concrete object can also calculate a variable subject.
+    #
+    # @param [RDF::Term] resource
+    # @param [:subject, :object] position
+    # @return [RDF::Term]
+    # @see RDF::N3::ResourceOperator#evaluate
+    def resolve(resource, position:)
+      case resource
+      when RDF::Query::Variable then resource
+      when RDF::Literal
+        case position
+        when :subject
+          as_literal(Math.sinh(resource.as_number.object))
+        when :object
+          as_literal(Math.asinh(resource.as_number.object))
+        end
+      else
+        nil
+      end
+    end
+
+    ##
+    # Input is either the subject or object
+    #
+    # @return [RDF::Term]
+    def input_operand
+      RDF::N3::List.new(values: operands)
+    end
+  end
+end

data/lib/rdf/n3/algebra/math/sum.rb

@@ -0,0 +1,40 @@
+module RDF::N3::Algebra::Math
+  ##
+  # **schema**:
+  # `($a_1 .. $a_n) math:sum $a_s`
+  # 
+  # **summary**:
+  # performs addition of numbers
+  # 
+  # **definition**:
+  # `true` if and only if the arithmetic sum of `$a_1, .. $a_n` equals `$a_s`.
+  # Requires either:
+  # 
+  # 1. all `$a_1, .., $a_n` to be bound; or
+  # 2. all but one `$a_i` (subject list) to be bound, and `$a_s` to be bound.
+  # 
+  # **literal domains**:
+  # 
+  # * `$a_1 .. $a_n` : `xs:decimal` (or its derived types), `xs:float`, or `xs:double` (see note on type promotion, and casting from string)
+  # * `$a_s`: `xs:decimal` (or its derived types), `xs:float`, or `xs:double` (see note on type promotion, and casting from string)
+  #
+  # @example
+  #     { ("3" "5") math:sum ?x } => { ?x :valueOf "3 + 5" } .
+  #     { (3 5) math:sum ?x } => { ?x :valueOf "3 + 5 = 8" } .
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-numeric-add
+  class Sum < RDF::N3::Algebra::ListOperator
+    NAME = :mathSum
+    URI = RDF::N3::Math[:sum]
+
+    ##
+    # Evaluates to the sum of the list elements
+    #
+    # @param [RDF::N3::List] list
+    # @return [RDF::Term]
+    # @see RDF::N3::ListOperator#evaluate
+    def resolve(list)
+      list.to_a.map(&:as_number).reduce(&:+) || RDF::Literal(0)  # Empty list sums to 0
+    end
+  end
+end

data/lib/rdf/n3/algebra/math/tan.rb

@@ -0,0 +1,40 @@
+module RDF::N3::Algebra::Math
+  ##
+  # The subject is an angle expressed in radians. The object is calulated as the tangent value of the subject.
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-math-tan
+  class Tan < RDF::N3::Algebra::ResourceOperator
+    NAME = :mathTan
+    URI = RDF::N3::Math.tan
+
+    ##
+    # The math:tan operator takes string or number and calculates its tangent. The arc tangent of a concrete object can also calculate a variable subject.
+    #
+    # @param [RDF::Term] resource
+    # @param [:subject, :object] position
+    # @return [RDF::Term]
+    # @see RDF::N3::ResourceOperator#evaluate
+    def resolve(resource, position:)
+      case resource
+      when RDF::Query::Variable then resource
+      when RDF::Literal
+        case position
+        when :subject
+          as_literal(Math.tan(resource.as_number.object))
+        when :object
+          as_literal(Math.atan(resource.as_number.object))
+        end
+      else
+        nil
+      end
+    end
+
+    ##
+    # Input is either the subject or object
+    #
+    # @return [RDF::Term]
+    def input_operand
+      RDF::N3::List.new(values: operands)
+    end
+  end
+end

data/lib/rdf/n3/algebra/math/tanh.rb

@@ -0,0 +1,38 @@
+module RDF::N3::Algebra::Math
+  ##
+  # The subject is an angle expressed in radians. The object is calulated as the tangent value of the subject.
+  class TanH < RDF::N3::Algebra::ResourceOperator
+    NAME = :mathTanH
+    URI = RDF::N3::Math.tanh
+
+    ##
+    # The math:tanh operator takes string or number and calculates its hyperbolic tangent. The inverse hyperbolic tangent of a concrete object can also calculate a variable subject.
+    #
+    # @param [RDF::Term] resource
+    # @param [:subject, :object] position
+    # @return [RDF::Term]
+    # @see RDF::N3::ResourceOperator#evaluate
+    def resolve(resource, position:)
+      case resource
+      when RDF::Query::Variable then resource
+      when RDF::Literal
+        case position
+        when :subject
+          as_literal(Math.tanh(resource.as_number.object))
+        when :object
+          as_literal(Math.atanh(resource.as_number.object))
+        end
+      else
+        nil
+      end
+    end
+
+    ##
+    # Input is either the subject or object
+    #
+    # @return [RDF::Term]
+    def input_operand
+      RDF::N3::List.new(values: operands)
+    end
+  end
+end

data/lib/rdf/n3/algebra/not_implemented.rb

@@ -0,0 +1,13 @@
+require 'rdf'
+
+module RDF::N3::Algebra
+  #
+  # A Notation3 Formula combines a graph with a BGP query.
+  class NotImplemented < SPARQL::Algebra::Operator
+    include RDF::N3::Algebra::Builtin
+
+    def initialize(*args, predicate:, **options)
+      raise NotImplementedError, "The #{predicate} operator is not implemented"
+    end
+  end
+end

data/lib/rdf/n3/algebra/resource_operator.rb

@@ -0,0 +1,122 @@
+module RDF::N3::Algebra
+  ##
+  # This is a generic operator where the subject is a literal or binds to a literal and the object is either a constant that equals the evaluation of the subject, or a variable to which the result is bound in a solution
+  class ResourceOperator < SPARQL::Algebra::Operator::Binary
+    include SPARQL::Algebra::Query
+    include SPARQL::Algebra::Update
+    include RDF::N3::Algebra::Builtin
+
+    NAME = :resourceOperator
+
+    ##
+    # The operator takes a literal and provides a mechanism for subclasses to operate over (and validate) that argument.
+    #
+    # @param  [RDF::Queryable] queryable
+    #   the graph or repository to query
+    # @param [RDF::Query::Solutions] solutions
+    #   solutions for chained queries
+    # @return [RDF::Query::Solutions]
+    def execute(queryable, solutions:, **options)
+      RDF::Query::Solutions(solutions.map do |solution|
+        subject = operand(0).evaluate(solution.bindings, formulae: formulae) || operand(0)
+        object = operand(1).evaluate(solution.bindings, formulae: formulae) || operand(1)
+        subject = formulae.fetch(subject, subject) if subject.node?
+        object = formulae.fetch(object, object) if object.node?
+
+        log_info(self.class.const_get(:NAME), "subject") {SXP::Generator.string(subject.to_sxp_bin).strip}
+        log_info(self.class.const_get(:NAME), "object") {SXP::Generator.string(object.to_sxp_bin).strip}
+        next unless valid?(subject, object)
+
+        lhs = resolve(subject, position: :subject)
+        if lhs.nil?
+          log_error(self.class.const_get(:NAME), "subject evaluates to null") {subject.inspect}
+          next
+        end
+
+        rhs = resolve(object, position: :object)
+        if rhs.nil?
+          log_error(self.class.const_get(:NAME), "object evaluates to null") {object.inspect}
+          next
+        end
+
+        if object.variable?
+          log_debug(self.class.const_get(:NAME), "result") {SXP::Generator.string(lhs.to_sxp_bin).strip}
+          solution.merge(object.to_sym => lhs)
+        elsif subject.variable?
+          log_debug(self.class.const_get(:NAME), "result") {SXP::Generator.string(rhs.to_sxp_bin).strip}
+          solution.merge(subject.to_sym => rhs)
+        elsif respond_to?(:apply)
+          res = apply(lhs, rhs)
+          log_debug(self.class.const_get(:NAME), "result") {SXP::Generator.string(res.to_sxp_bin).strip}
+          # Return the result applying subject and object
+          case res
+          when RDF::Literal::TRUE
+            solution
+          when RDF::Literal::FALSE
+            nil
+          when RDF::Query::Solution
+            solution.merge(res)
+          else
+            log_error(self.class.const_get(:NAME), "unexpected result type")
+            nil
+          end
+        elsif rhs != lhs
+          log_debug(self.class.const_get(:NAME), "result: false")
+          nil
+        else
+          log_debug(self.class.const_get(:NAME), "result: true")
+          solution
+        end
+      end.compact.uniq)
+    end
+
+    ##
+    # Input is generically the subject
+    #
+    # @return [RDF::Term]
+    def input_operand
+      operand(0)
+    end
+
+    ##
+    # Subclasses implement `resolve`.
+    #
+    # Returns nil if resource does not validate, given its position
+    #
+    # @param [RDF::Term] resource
+    # @return [RDF::Term]
+    def resolve(resource, position: :subject)
+      raise NotImplemented
+    end
+
+    ##
+    # Subclasses may override or supplement validate to perform validation on the list subject
+    #
+    # @param [RDF::Term] subject
+    # @param [RDF::Term] object
+    # @return [Boolean]
+    def valid?(subject, object)
+      case subject
+      when RDF::Query::Variable
+        object.term?
+      when RDF::Term
+        object.term? || object.variable?
+      else
+        false
+      end
+    end
+
+    ##
+    # Returns a literal for the numeric argument.
+    def as_literal(object)
+      case object
+      when Float
+        literal = RDF::Literal(object, canonicalize: true)
+        literal.instance_variable_set(:@string, literal.to_s.downcase)
+        literal
+      else
+        RDF::Literal(object, canonicalize: true)
+      end
+    end
+  end
+end

data/lib/rdf/n3/algebra/str/concatenation.rb

@@ -0,0 +1,27 @@
+module RDF::N3::Algebra::Str
+  ##
+  # The subject is a list of strings. The object is calculated as a concatenation of those strings.
+  #
+  # @example
+  #     ("a" "b") string:concatenation :s
+  class Concatenation < RDF::N3::Algebra::ListOperator
+    NAME = :strConcatenation
+    URI = RDF::N3::Str.concatenation
+
+    ##
+    # The string:concatenation operator takes a list of terms cast to strings and either binds the result of concatenating them to the output variable, removes a solution that does equal the literal object.
+    #
+    # List entries are stringified using {SPARQL::Algebra::Expression.cast}.
+    #
+    # @param [RDF::N3::List] list
+    # @return [RDF::Term]
+    # @see RDF::N3::ListOperator#evaluate
+    def resolve(list)
+      RDF::Literal(
+        list.to_a.map do |o|
+          SPARQL::Algebra::Expression.cast(RDF::XSD.string, o)
+        end.join("")
+      )
+    end
+  end
+end

data/lib/rdf/n3/algebra/str/contains.rb

@@ -0,0 +1,33 @@
+module RDF::N3::Algebra::Str
+  # True iff the subject string contains the object string.
+  class Contains < RDF::N3::Algebra::ResourceOperator
+    NAME = :strContains
+    URI = RDF::N3::Str.contains
+
+    ##
+    # Resolves inputs as strings.
+    #
+    # @param [RDF::Term] resource
+    # @param [:subject, :object] position
+    # @return [RDF::Literal]
+    # @see RDF::N3::ResourceOperator#evaluate
+    def resolve(resource, position:)
+      resource if resource.term?
+    end
+
+    # Neither subect nor object are considered inputs, and must be resolved before evaluation.
+    def input_operand
+      RDF::N3::List.new
+    end
+
+    ##
+    # @param  [String] left
+    #   a literal
+    # @param  [String] right
+    #   a literal
+    # @return [RDF::Literal::Boolean]
+    def apply(left, right)
+      RDF::Literal(left.to_s.include?(right.to_s)) 
+    end
+  end
+end

data/lib/rdf/n3/algebra/str/contains_ignoring_case.rb

@@ -0,0 +1,33 @@
+module RDF::N3::Algebra::Str
+  # True iff the subject string contains the object string, with the comparison done ignoring the difference between upper case and lower case characters.
+  class ContainsIgnoringCase < RDF::N3::Algebra::ResourceOperator
+    NAME = :strContainsIgnoringCase
+    URI = RDF::N3::Str.containsIgnoringCase
+
+    ##
+    # Resolves inputs as lower-case strings.
+    #
+    # @param [RDF::Term] resource
+    # @param [:subject, :object] position
+    # @return [RDF::Literal]
+    # @see RDF::N3::ResourceOperator#evaluate
+    def resolve(resource, position:)
+      RDF::Literal(resource.to_s.downcase) if resource.term?
+    end
+
+    # Both subject and object are inputs.
+    def input_operand
+      RDF::N3::List.new(values: operands)
+    end
+
+    ##
+    # @param  [String] left
+    #   a literal
+    # @param  [String] right
+    #   a literal
+    # @return [RDF::Literal::Boolean]
+    def apply(left, right)
+      RDF::Literal(left.to_s.include?(right.to_s)) 
+    end
+  end
+end