rdf-n3 2.2.0 → 3.1.2

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,123 @@
+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
+          #require 'byebug'; byebug
+          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

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

@@ -0,0 +1,33 @@
+module RDF::N3::Algebra::Str
+  # True iff the subject string ends with the object string.
+  class EndsWith < RDF::N3::Algebra::ResourceOperator
+    NAME = :strEndsWith
+    URI = RDF::N3::Str.endsWith
+
+    ##
+    # 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
+
+    # Both subject and object are inputs.
+    def input_operand
+      RDF::N3::List.new(values: operands)
+    end
+
+    ##
+    # @param  [RDF::Literal] left
+    #   a literal
+    # @param  [RDF::Literal] right
+    #   a literal
+    # @return [RDF::Literal::Boolean]
+    def apply(left, right)
+      RDF::Literal(left.to_s.end_with?(right.to_s))
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module RDF::N3::Algebra::Str
+  class EqualIgnoringCase < RDF::N3::Algebra::ResourceOperator
+    NAME = :strEqualIgnoringCase
+    URI = RDF::N3::Str.equalIgnoringCase
+
+    ##
+    # 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
+
+    ##
+    # True iff the subject string is the same as object string ignoring differences between upper and lower case.
+    #
+    # @param  [RDF::Literal] left
+    #   a literal
+    # @param  [RDF::Literal] right
+    #   a literal
+    # @return [RDF::Literal::Boolean]
+    def apply(left, right)
+      RDF::Literal(left.to_s == right.to_s)
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module RDF::N3::Algebra::Str
+  # The subject is a list, whose first member is a format string, and whose remaining members are arguments to the format string. The formating string is in the style of python's % operator, very similar to C's sprintf(). The object is calculated from the subject.
+  class Format < RDF::N3::Algebra::ListOperator
+    include RDF::N3::Algebra::Builtin
+    NAME = :strFormat
+    URI = RDF::N3::Str.format
+
+    ##
+    # @param [RDF::N3::List] list
+    # @return [RDF::Term]
+    # @see RDF::N3::ListOperator#evaluate
+    def resolve(list)
+      format, *args = list.to_a.map(&:value)
+      str = RDF::Literal(format % args)
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module RDF::N3::Algebra::Str
+  # True iff the string is greater than the object when ordered according to Unicode(tm) code order.
+  class GreaterThan < RDF::N3::Algebra::ResourceOperator
+    NAME = :strGreaterThan
+    URI = RDF::N3::Str.greaterThan
+
+    ##
+    # The string:greaterThan compares subject with object as strings.
+    #
+    # @param [RDF::Term] resource
+    # @param [:subject, :object] position
+    # @return [RDF::Term]
+    # @see RDF::N3::ResourceOperator#evaluate
+    def resolve(resource, position:)
+      resource if resource.literal?
+    end
+
+    # Both subject and object are inputs.
+    def input_operand
+      RDF::N3::List.new(values: operands)
+    end
+
+    ##
+    # @param  [RDF::Literal] left
+    #   a literal
+    # @param  [RDF::Literal] right
+    #   a literal
+    # @return [RDF::Literal::Boolean]
+    def apply(left, right)
+      case
+      when !left.is_a?(RDF::Term) || !right.is_a?(RDF::Term) || !left.compatible?(right)
+        log_error(NAME) {"expected two RDF::Literal operands, but got #{left.inspect} and #{right.inspect}"}
+      when left > right then RDF::Literal::TRUE
+      else RDF::Literal::FALSE
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module RDF::N3::Algebra::Str
+  # True iff the string is less than the object when ordered according to Unicode(tm) code order.
+  class LessThan < RDF::N3::Algebra::ResourceOperator
+    NAME = :strLessThan
+    URI = RDF::N3::Str.lessThan
+
+    ##
+    # 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
+
+    # Both subject and object are inputs.
+    def input_operand
+      RDF::N3::List.new(values: operands)
+    end
+
+    ##
+    # @param  [RDF::Literal] left
+    #   a literal
+    # @param  [RDF::Literal] right
+    #   a literal
+    # @return [RDF::Literal::Boolean]
+    def apply(left, right)
+      RDF::Literal(left.to_s < right.to_s)
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module RDF::N3::Algebra::Str
+  # The subject is a string; the object is is a regular expression in the perl, python style.
+  # It is true iff the string matches the regexp.
+  class Matches < RDF::N3::Algebra::ResourceOperator
+    NAME = :strMatches
+    URI = RDF::N3::Str.matches
+
+    ##
+    # 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.literal?
+    end
+
+    # Neither subect nor object are considered inputs, and must be resolved before evaluation.
+    def input_operand
+      RDF::N3::List.new
+    end
+
+    ##
+    # Tre if right, treated as a regular expression, matches left
+    #
+    # @param  [RDF::Literal] left
+    #   a simple literal
+    # @param  [RDF::Literal] right
+    #   a simple literal
+    # @return [RDF::Literal::Boolean] `true` or `false`
+    # @see https://www.w3.org/TR/xpath-functions/#regex-syntax
+    def apply(left, right)
+      RDF::Literal(Regexp.new(right.to_s).match?(left.to_s))
+    end
+  end
+end