rdf-n3 3.0.1 → 3.2.0

data/lib/rdf/n3/algebra/log/output_string.rb

@@ -0,0 +1,40 @@
+module RDF::N3::Algebra::Log
+  ##
+  # The subject is a key and the object is a string, where the strings are to be output in the order of the keys.
+  class OutputString < RDF::N3::Algebra::ResourceOperator
+    NAME = :logOutputString
+    URI = RDF::N3::Log.outputString
+
+    ##
+    # Resolves inputs as strings.
+    #
+    # @param [RDF::Term] resource
+    # @param [:subject, :object] position
+    # @return [RDF::Term]
+    # @see RDF::N3::ResourceOperator#evaluate
+    def resolve(resource, position:)
+      SPARQL::Algebra::Expression.cast(RDF::XSD.string, resource) if resource.term?
+    end
+
+    ##
+    # Returns `term2`, but adds `term2` as an output keyed on `term1`.
+    #
+    # @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)
+      (@options[:strings][term1.to_s] ||= []) << term2.to_s
+      term2
+    end
+
+    # Both subject and object are inputs.
+    def input_operand
+      RDF::N3::List.new(values: operands)
+    end
+  end
+end

data/lib/rdf/n3/algebra/log/parsed_as_n3.rb

@@ -0,0 +1,36 @@
+module RDF::N3::Algebra::Log
+  ##
+  # The subject string, parsed as N3, gives this formula.
+  class ParsedAsN3 < RDF::N3::Algebra::ResourceOperator
+    NAME = :logParsedAsN3
+    URI = RDF::N3::Log.parsedAsN3
+
+    ##
+    # Parses the subject into a new formula.
+    #
+    # Returns nil if resource does not validate, given its position
+    #
+    # @param [RDF::N3::List] resource
+    # @return [RDF::Term]
+    def resolve(resource, position: :subject)
+      case position
+      when :subject
+        return nil unless resource.literal?
+        begin
+          repo = RDF::N3::Repository.new
+          repo << RDF::N3::Reader.new(resource.to_s, **@options.merge(list_terms: true,  logger: false))
+          log_debug("logParsedAsN3") {SXP::Generator.string repo.statements.to_sxp_bin}
+          content_hash = resource.hash # used as name of resulting formula
+          form = RDF::N3::Algebra::Formula.from_enumerable(repo, graph_name: RDF::Node.intern(content_hash))
+          log_info(NAME) {"form hash (#{resource}): #{form.hash}"}
+          form
+        rescue RDF::ReaderError
+          nil
+        end
+      when :object
+        return nil unless resource.literal? || resource.is_a?(RDF::Query::Variable)
+        resource
+      end
+    end
+  end
+end

data/lib/rdf/n3/algebra/log/semantics.rb

@@ -0,0 +1,40 @@
+module RDF::N3::Algebra::Log
+  ##
+  # The log:semantics of a document is the formula. achieved by parsing representation of the document. For a document in Notation3, log:semantics is the log:parsedAsN3 of the log:contents of the document. For a document in RDF/XML, it is parsed according to the RDF/XML specification to yield an RDF formula (a subclass of N3 log:Formula).
+  #
+  # [Aside: Philosophers will be distracted here into worrying about the meaning of meaning. At least we didn't call this function "meaning"! In as much as N3 is used as an interlingua for interoperability for different systems, this for an N3 based system is the meaning  expressed by a document.]
+  #
+  # (Cwm knows how to go get a document and parse N3 and RDF/XML it in order to evaluate this. Other languages for web documents  may be defined whose N3 semantics are therefore also calculable, and so they could be added in due course. See for example GRDDL, RDFa, etc)
+  class Semantics < RDF::N3::Algebra::ResourceOperator
+    NAME = :logSemantics
+    URI = RDF::N3::Log.semantics
+
+    ##
+    # Parses the subject into a new formula.
+    #
+    # Returns nil if resource does not validate, given its position
+    #
+    # @param [RDF::N3::List] resource
+    # @return [RDF::Term]
+    def resolve(resource, position: :subject)
+      case position
+      when :subject
+        return nil unless resource.literal? || resource.uri?
+        begin
+          repo = RDF::N3::Repository.new
+          repo << RDF::Reader.open(resource, **@options.merge(list_terms: true, base_uri: resource, logger: false))
+          content_hash = repo.statements.hash # used as name of resulting formula
+          form = RDF::N3::Algebra::Formula.from_enumerable(repo, graph_name: RDF::Node.intern(content_hash))
+          log_debug(NAME) {"form hash (#{resource}): #{form.hash}"}
+          form
+        rescue IOError, RDF::ReaderError => e
+          log_error(NAME) {"error loading #{resource}: #{e}"}
+          nil
+        end
+      when :object
+        return nil unless resource.literal? || resource.variable?
+        resource
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module RDF::N3::Algebra::Math
+  ##
+  # The object is calulated as the absolute value of the subject.
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-abs
+  class AbsoluteValue < RDF::N3::Algebra::ResourceOperator
+    NAME = :mathAbsoluteValue
+    URI = RDF::N3::Math.absoluteValue
+
+    ##
+    # The math:absoluteValue operator takes string or number and calculates its absolute value.
+    #
+    # @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.abs)
+      when :object
+        return nil unless resource.literal? || resource.variable?
+        resource
+      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/acos.rb

@@ -0,0 +1,26 @@
+module RDF::N3::Algebra::Math
+  ##
+  # The object is calulated as the arc cosine value of the subject.
+  class ACos < RDF::N3::Algebra::ResourceOperator
+    NAME = :mathACos
+    URI = RDF::N3::Math.acos
+
+    ##
+    # The math:acos operator takes string or number and calculates its arc cosine.
+    #
+    # @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(Math.acos(resource.as_number.object))
+      when :object
+        return nil unless resource.literal? || resource.variable?
+        resource
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module RDF::N3::Algebra::Math
+  ##
+  # The object is calulated as the inverse hyperbolic cosine value of the subject.
+  class ACosH < RDF::N3::Algebra::ResourceOperator
+    NAME = :mathACosH
+    URI = RDF::N3::Math.acosh
+
+    ##
+    # The math:acosh operator takes string or number and calculates its inverse hyperbolic cosine.
+    #
+    # @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(Math.acosh(resource.as_number.object))
+      when :object
+        return nil unless resource.literal? || resource.variable?
+        resource
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module RDF::N3::Algebra::Math
+  ##
+  # The object is calulated as the arc sine value of the subject.
+  class ASin < RDF::N3::Algebra::ResourceOperator
+    NAME = :mathASin
+    URI = RDF::N3::Math.asin
+
+    ##
+    # The math:asin operator takes string or number and calculates its arc sine.
+    #
+    # @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(Math.asin(resource.as_number.object))
+      when :object
+        return nil unless resource.literal? || resource.variable?
+        resource
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module RDF::N3::Algebra::Math
+  ##
+  # The object is calulated as the inverse hyperbolic sine value of the subject.
+  class ASinH < RDF::N3::Algebra::ResourceOperator
+    NAME = :mathASinH
+    URI = RDF::N3::Math.asinh
+
+    ##
+    # The math:asinh operator takes string or number and calculates its inverse hyperbolic sine.
+    #
+    # @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(Math.asinh(resource.as_number.object))
+      when :object
+        return nil unless resource.literal? || resource.variable?
+        resource
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module RDF::N3::Algebra::Math
+  ##
+  # The object is calulated as the arc tangent value of the subject.
+  class ATan < RDF::N3::Algebra::ResourceOperator
+    NAME = :mathATan
+    URI = RDF::N3::Math.atan
+
+    ##
+    # The math:atan operator takes string or number and calculates its arc tangent.
+    #
+    # @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(Math.atan(resource.as_number.object))
+      when :object
+        return nil unless resource.literal? || resource.variable?
+        resource
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module RDF::N3::Algebra::Math
+  ##
+  # The object is calulated as the inverse hyperbolic tangent value of the subject.
+  class ATanH < RDF::N3::Algebra::ResourceOperator
+    NAME = :mathATanH
+    URI = RDF::N3::Math.atanh
+
+    ##
+    # The math:atanh operator takes string or number and calculates its inverse hyperbolic tangent.
+    #
+    # @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(Math.atanh(resource.as_number.object))
+      when :object
+        return nil unless resource.literal? || resource.variable?
+        resource
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module RDF::N3::Algebra::Math
+  ##
+  # The object is calculated as the subject upwards to a whole number.
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-ceiling
+  class Ceiling < RDF::N3::Algebra::ResourceOperator
+    NAME = :mathCeiling
+    URI = RDF::N3::Math.ceiling
+
+    ##
+    # The math:ceiling operator takes string or number and calculates its ceiling.
+    #
+    # @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.ceil)
+      when :object
+        return nil unless resource.literal? || resource.variable?
+        resource
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module RDF::N3::Algebra::Math
+  ##
+  # The subject is an angle expressed in radians. The object is calulated as the cosine value of the subject.
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-math-cos
+  class Cos < RDF::N3::Algebra::ResourceOperator
+    NAME = :mathCos
+    URI = RDF::N3::Math.cos
+
+    ##
+    # The math:cos operator takes string or number and calculates its cosine. The arc cosine 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.cos(resource.as_number.object))
+        when :object
+          as_literal(Math.acos(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/cosh.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 cosine value of the subject.
+  class CosH < RDF::N3::Algebra::ResourceOperator
+    NAME = :mathCosH
+    URI = RDF::N3::Math.cosh
+
+    ##
+    # The math:cosh operator takes string or number and calculates its hyperbolic cosine.  The inverse hyperbolic cosine 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.cosh(resource.as_number.object))
+        when :object
+          as_literal(Math.acosh(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/difference.rb

@@ -0,0 +1,40 @@
+module RDF::N3::Algebra::Math
+  ##
+  # The subject is a pair of numbers. The object is calculated by subtracting the second number of the pair from the first.
+  #
+  # @example
+  #     { ("8" "3") math:difference ?x} => { ?x :valueOf "8 - 3" } .
+  #     { ("8") math:difference ?x } => { ?x :valueOf "8 - (error?)" } .
+  #     { (8 3) math:difference ?x} => { ?x :valueOf "8 - 3" } .
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-numeric-subtract
+  class Difference < RDF::N3::Algebra::ListOperator
+    NAME = :mathDifference
+    URI = RDF::N3::Math.difference
+
+    ##
+    # The math:difference operator takes a pair of strings or numbers and calculates their difference.
+    #
+    # @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?(&: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/equal_to.rb

@@ -0,0 +1,54 @@
+module RDF::N3::Algebra::Math
+  ##
+  # **schema**:
+  # `$a1 math:equalTo $a2`
+  # 
+  # **summary**:
+  # checks equality of numbers
+  # 
+  # **definition**:
+  # `true` if and only if `$a1` is equal to `$a2`. 
+  # Requires both arguments to be either concrete numerals, or variables bound to a numeral.
+  # 
+  # **literal domains**:
+  # 
+  # * `$a1`: `xs:decimal` (or its derived types), `xs:float`, or `xs:double`  (see note on type promotion, and casting from string)
+  # * `$a2`: `xs:decimal` (or its derived types), `xs:float`, or `xs:double`  (see note on type promotion, and casting from string)
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-numeric-equal
+  class EqualTo < RDF::N3::Algebra::ResourceOperator
+    NAME = :mathEqualTo
+    URI = RDF::N3::Math.equalTo
+
+    ##
+    # Resolves inputs as numbers.
+    #
+    # @param [RDF::Term] resource
+    # @param [:subject, :object] position
+    # @return [RDF::Term]
+    # @see RDF::N3::ResourceOperator#evaluate
+    def resolve(resource, position:)
+      resource.as_number if resource.term?
+    end
+
+    # Both subject and object are inputs.
+    def input_operand
+      RDF::N3::List.new(values: operands)
+    end
+
+    ##
+    # Returns TRUE if `term1` and `term2` are 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(term1 == term2)
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module RDF::N3::Algebra::Math
+  ##
+  # The subject is a pair of numbers. The object is calculated by raising the first number of the power of the second.
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-math-exp
+  class Exponentiation < RDF::N3::Algebra::ListOperator
+    NAME = :mathExponentiation
+    URI = RDF::N3::Math.exponentiation
+
+    ##
+    # The math:difference operator takes a pair of strings or numbers and calculates the exponent.
+    #
+    # @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?(&: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/floor.rb

@@ -0,0 +1,28 @@
+module RDF::N3::Algebra::Math
+  ##
+  # The object is calculated as the subject downwards to a whole number.
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-floor
+  class Floor < RDF::N3::Algebra::ResourceOperator
+    NAME = :mathFloor
+    URI = RDF::N3::Math.floor
+
+    ##
+    # The math:floor operator takes string or number and calculates its floor.
+    #
+    # @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?
+        RDF::Literal(resource.as_number.floor)
+      when :object
+        return nil unless resource.literal? || resource.variable?
+        resource
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module RDF::N3::Algebra::Math
+  ##
+  # True iff the subject is a string representation of a number which  is 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 GreaterThan < RDF::N3::Algebra::ResourceOperator
+    NAME = :mathGreaterThan
+    URI = RDF::N3::Math.greaterThan
+
+    ##
+    # Resolves inputs as numbers.
+    #
+    # @param [RDF::Term] resource
+    # @param [:subject, :object] position
+    # @return [RDF::Term]
+    # @see RDF::N3::ResourceOperator#evaluate
+    def resolve(resource, position:)
+      resource.as_number if resource.term?
+    end
+
+    # Both subject and object are inputs.
+    def input_operand
+      RDF::N3::List.new(values: operands)
+    end
+
+    ##
+    # Returns TRUE if `term1` is greater than `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(term1 > term2)
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module RDF::N3::Algebra::Math
+  ##
+  # True iff the subject is a string representation of a number which  is less than the number of which the object is a string representation.
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-numeric-less-than
+  class LessThan < RDF::N3::Algebra::ResourceOperator
+    NAME = :mathLessThan
+    URI = RDF::N3::Math.lessThan
+
+    ##
+    # Resolves inputs as numbers.
+    #
+    # @param [RDF::Term] resource
+    # @param [:subject, :object] position
+    # @return [RDF::Term]
+    # @see RDF::N3::ResourceOperator#evaluate
+    def resolve(resource, position:)
+      resource.as_number if resource.term?
+    end
+
+    # Both subject and object are inputs.
+    def input_operand
+      RDF::N3::List.new(values: operands)
+    end
+
+    ##
+    # Returns TRUE if `term1` is less than `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(term1 < term2)
+    end
+  end
+end