rdf-n3 3.1.1 → 3.1.2

data/lib/rdf/n3/algebra/list/append.rb

@@ -1,13 +1,42 @@
 module RDF::N3::Algebra::List
   ##
-  # Iff the subject is a list of lists and the concatenation of all those lists is the object, then this is true.
+  # Iff the subject is a list of lists and the concatenation of all those lists  is the object, then this is true. The object can be calculated as a function of the subject.
+  #
   # @example
   #     ( (1 2) (3 4) ) list:append (1 2 3 4).
   #
   # The object can be calculated as a function of the subject.
-  class Append < SPARQL::Algebra::Operator::Binary
-    include RDF::Util::Logger
-
+  class Append < RDF::N3::Algebra::ListOperator
     NAME = :listAppend
+    URI = RDF::N3::List.append
+
+    ##
+    # Resolves this operator using the given variable `bindings`.
+    # If the last operand is a variable, it creates a solution for each element in the list.
+    #
+    # @param [RDF::N3::List] list
+    # @return [RDF::Term]
+    # @see RDF::N3::ListOperator#evaluate
+    def resolve(list)
+      flattened = list.to_a.map(&:to_a).flatten
+      # Bind a new list based on the values, whos subject use made up from original list subjects
+      subj = RDF::Node.intern(list.map(&:subject).hash)
+      RDF::N3::List.new(subject: subj, values: flattened)
+    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.to_a.all? {|li| li.list?}
+        true
+      else
+        log_error(NAME) {"operand is not a list of lists: #{list.to_sxp}"}
+        false
+      end
+    end
   end
 end

data/lib/rdf/n3/algebra/list/first.rb

@@ -0,0 +1,24 @@
+module RDF::N3::Algebra::List
+  ##
+  # Iff the subject is a list and the object is the first thing that list, then this is true. The object can be calculated as a function of the list.
+  #
+  # @example
+  #     { ( 1 2 3 4 5 6 ) list:first 1 } => { :test1 a :SUCCESS }.
+  #
+  # The object can be calculated as a function of the list.
+  class First < RDF::N3::Algebra::ListOperator
+    NAME = :listFirst
+    URI = RDF::N3::List.first
+
+    ##
+    # Resolves this operator using the given variable `bindings`.
+    # If the last operand is a variable, it creates a solution for each element in the list.
+    #
+    # @param [RDF::N3::List] list
+    # @return [RDF::Term]
+    # @see RDF::N3::ListOperator#evaluate
+    def resolve(list)
+      list.first
+    end
+  end
+end

data/lib/rdf/n3/algebra/list/in.rb

@@ -1,9 +1,48 @@
 module RDF::N3::Algebra::List
   ##
   # Iff the object is a list and the subject is in that list, then this is true.
-  class In < SPARQL::Algebra::Operator::Binary
-    include RDF::Util::Logger
-
+  #
+  # @example
+  #     { 1 list:in  (  1 2 3 4 5 ) } => { :test4a a :SUCCESS }.
+  class In < RDF::N3::Algebra::ListOperator
     NAME = :listIn
+    URI = RDF::N3::List.in
+
+    ##
+    # Evaluates this operator using the given variable `bindings`.
+    # If the first operand is a variable, it creates a solution for each element in the list.
+    #
+    # @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)
+        # Might be a variable or node evaluating to a list in queryable, or might be a list with variables
+        list = operand(1).evaluate(solution.bindings, formulae: formulae)
+        next unless list
+        # If it evaluated to a BNode, re-expand as a list
+        list = RDF::N3::List.try_list(list, queryable).evaluate(solution.bindings, formulae: formulae)
+
+        log_debug(NAME) {"subject: #{subject.to_sxp}, list: #{list.to_sxp}"}
+        unless list.list? && list.valid?
+          log_error(NAME) {"operand is not a list: #{list.to_sxp}"}
+          next
+        end
+
+        if subject.variable?
+          # Bind all list entries to this solution, creates an array of solutions
+          list.to_a.map do |term|
+            solution.merge(subject.to_sym => term)
+          end
+        elsif list.to_a.include?(subject)
+          solution
+        else
+          nil
+        end
+      end.flatten.compact.uniq)
+    end
   end
 end

data/lib/rdf/n3/algebra/list/last.rb

@@ -1,11 +1,24 @@
 module RDF::N3::Algebra::List
   ##
-  # Iff the suject is a list and the obbject is the last thing that list, then this is true.
+  # Iff the subject is a list and the object is the last thing that list, then this is true. The object can be calculated as a function of the list.
+  #
+  # @example
+  #     { ( 1 2 3 4 5 6 ) list:last 6 } => { :test1 a :SUCCESS }.
   #
   # The object can be calculated as a function of the list.
-  class Last < SPARQL::Algebra::Operator::Binary
-    include RDF::Util::Logger
-
+  class Last < RDF::N3::Algebra::ListOperator
     NAME = :listLast
+    URI = RDF::N3::List.last
+
+    ##
+    # Resolves this operator using the given variable `bindings`.
+    # If the last operand is a variable, it creates a solution for each element in the list.
+    #
+    # @param [RDF::N3::List] list
+    # @return [RDF::Term]
+    # @see RDF::N3::ListOperator#evaluate
+    def resolve(list)
+      list.last
+    end
   end
 end

data/lib/rdf/n3/algebra/list/length.rb

@@ -0,0 +1,24 @@
+module RDF::N3::Algebra::List
+  ##
+  # Iff the subject is a list and the object is the last thing that list, then this is true. The object can be calculated as a function of the list.
+  #
+  # @example
+  #     { ( 1 2 3 4 5 6 ) list:length 6 } => { :test1 a :SUCCESS }.
+  #
+  # The object can be calculated as a function of the list.
+  class Length < RDF::N3::Algebra::ListOperator
+    NAME = :listLength
+    URI = RDF::N3::List.length
+
+    ##
+    # Resolves this operator using the given variable `bindings`.
+    # If the last operand is a variable, it creates a solution for each element in the list.
+    #
+    # @param [RDF::N3::List] list
+    # @return [RDF::Term]
+    # @see RDF::N3::ListOperator#evaluate
+    def resolve(list)
+      RDF::Literal(list.length)
+    end
+  end
+end

data/lib/rdf/n3/algebra/list/member.rb

@@ -1,7 +1,44 @@
 module RDF::N3::Algebra::List
   ##
-  # Iff the subject is a list and the obbject is in that list, then this is true.
-  class Member < SPARQL::Algebra::Operator::Binary
+  # Iff the subject is a list and the object is in that list, then this is true.
+  class Member < RDF::N3::Algebra::ListOperator
     NAME = :listMember
+    URI = RDF::N3::List.member
+
+    ##
+    # Evaluates this operator using the given variable `bindings`.
+    # If the last operand is a variable, it creates a solution for each element in the list.
+    #
+    # @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|
+        list = operand(0).evaluate(solution.bindings, formulae: formulae)
+        next unless list
+        list = RDF::N3::List.try_list(list, queryable).evaluate(solution.bindings, formulae: formulae)
+        object = operand(1).evaluate(solution.bindings, formulae: formulae) || operand(1)
+        object = formulae[object].deep_dup if object.node? && formulae.has_key?(object)
+
+        log_debug(NAME) {"list: #{list.to_sxp}, object: #{object.to_sxp}"}
+        unless list.list? && list.valid?
+          log_error(NAME) {"operand is not a list: #{list.to_sxp}"}
+          next
+        end
+
+        if object.variable?
+          # Bind all list entries to this solution, creates an array of solutions
+          list.to_a.map do |term|
+            solution.merge(object.to_sym => term)
+          end
+        elsif list.to_a.include?(object)
+          solution
+        else
+          nil
+        end
+      end.flatten.compact.uniq)
+    end
   end
 end

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

@@ -0,0 +1,83 @@
+module RDF::N3::Algebra
+  ##
+  # This is a generic operator where the subject is a list or binds to a list 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 ListOperator < SPARQL::Algebra::Operator::Binary
+    include SPARQL::Algebra::Query
+    include SPARQL::Algebra::Update
+    include RDF::N3::Algebra::Builtin
+
+    NAME = :listOperator
+
+    ##
+    # The operator takes a list and provides a mechanism for subclasses to operate over (and validate) that list 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|
+        # Might be a variable or node evaluating to a list in queryable, or might be a list with variables
+        subject = operand(0).evaluate(solution.bindings, formulae: formulae)
+        next unless subject
+        # If it evaluated to a BNode, re-expand as a list
+        subject = RDF::N3::List.try_list(subject, queryable).evaluate(solution.bindings, formulae: formulae)
+        object = operand(1).evaluate(solution.bindings, formulae: formulae) || operand(1)
+        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 validate(subject)
+
+        lhs = resolve(subject)
+        if lhs.nil?
+          log_error(self.class.const_get(:NAME), "subject evaluates to null") {subject.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 object != 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`.
+    #
+    # @param [RDF::N3::List] list
+    # @return [RDF::Term]
+    def resolve(list)
+      raise NotImplemented
+    end
+
+    ##
+    # Subclasses may override or supplement validate to perform validation on the list subject
+    #
+    # @param [RDF::N3::List] list
+    # @return [Boolean]
+    def validate(list)
+      if list.list? && list.valid?
+        true
+      else
+        log_error(NAME) {"operand is not a list: #{list.to_sxp}"}
+        false
+      end
+    end
+  end
+end

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

@@ -3,7 +3,63 @@ module RDF::N3::Algebra::Log
   # All possible conclusions which can be drawn from a formula.
   #
   # The object of this function, a formula, is the set of conclusions which can be drawn from the subject formula, by successively applying any rules it contains to the data it contains. This is equivalent to cwm's "--think" command line function.  It does use built-ins, so it may for example indirectly invoke other documents, validate signatures, etc.
-  class Conclusion < SPARQL::Algebra::Operator::Binary
+  class Conclusion < RDF::N3::Algebra::ResourceOperator
     NAME = :logConclusion
+    URI = RDF::N3::Log.conclusion
+
+    ##
+    # Evaluates this operator by creating a new formula containing the triples generated by reasoning over the input formula using think.
+    #
+    # The subject is evaluated into an isolated repository so that conclusions evaluated when evaluating the subject are not necessarily conclusions resulting from evaluating this operator.
+    #
+    # @param [RDF::N3::Algebra:Formula] resource
+    # @return [RDF::N3::Algebra::Formula]
+    # @see RDF::N3::ListOperator#evaluate
+    def resolve(resource, position:)
+      return resource unless position == :subject
+
+      log_depth do
+        reasoner = RDF::N3::Reasoner.new(resource, **@options)
+        conclusions = RDF::N3::Repository.new
+        reasoner.execute(think: true) {|stmt| conclusions << stmt}
+
+        # The result is a formula containing the conclusions
+        form = RDF::N3::Algebra::Formula.from_enumerable(conclusions, **@options).deep_dup
+
+        log_info("#{NAME} resolved") {SXP::Generator.string form.to_sxp_bin} 
+        form
+      end
+    end
+
+    ##
+    # To be valid, subject must be a formula, and object a formula or variable.
+    #
+    # @param [RDF::Term] subject
+    # @param [RDF::Term] object
+    # @return [Boolean]
+    def valid?(subject, object)
+      subject.formula? && (object.formula? || object.is_a?(RDF::Query::Variable))
+    end
+
+    ##
+    # Return subject operand.
+    #
+    # @return [RDF::Term]
+    def input_operand
+      operands.first
+    end
+
+    ##
+    # Yields statements, and de-asserts `inferred` from the subject.
+    #
+    # @yield  [statement]
+    #   each matching statement
+    # @yieldparam  [RDF::Statement] solution
+    # @yieldreturn [void] ignored
+    def each(solutions:, &block)
+      super do |stmt|
+        block.call(RDF::Statement.from(stmt.to_quad))
+      end
+    end
   end
 end

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

@@ -3,7 +3,34 @@ module RDF::N3::Algebra::Log
   # A function to merge formulae: logical AND.
   #
   # The subject is a list of formulae. The object, which can be generated, is a formula containing a copy of each of the formulae in the list on the left. A cwm built-in function.
-  class Conjunction < SPARQL::Algebra::Operator::Binary
+  class Conjunction < RDF::N3::Algebra::ListOperator
     NAME = :logConjunction
+    URI = RDF::N3::Log.conjunction
+
+    ##
+    # Evaluates this operator by creating a new formula containing the triples from each of the formulae in the list.
+    #
+    # @param [RDF::N3::List] list
+    # @return [RDF::N3::Algebra::Formula]
+    # @see RDF::N3::ListOperator#evaluate
+    def resolve(list)
+      form = RDF::N3::Algebra::Formula.new(graph_name: RDF::Node.intern(list.hash)) 
+      log_debug(NAME, "list hash") {form.graph_name}
+
+      list.each do |f|
+        form.operands.push(*f.operands)
+      end
+      form = form.dup
+      log_info(NAME, "result") {SXP::Generator.string form.to_sxp_bin}
+      form
+    end
+
+    ##
+    # Return subject operand.
+    #
+    # @return [RDF::Term]
+    def input_operand
+      operands.first
+    end
   end
 end

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

@@ -0,0 +1,34 @@
+module RDF::N3::Algebra::Log
+  ##
+  # This connects a document and a string that represents it.
+  #
+  # (Cwm knows how to go get a document in order to evaluate this.)
+  #
+  # Note that the content-type of the information is not given and so must be known or guessed.
+  class Content < RDF::N3::Algebra::ResourceOperator
+    NAME = :logContent
+    URI = RDF::N3::Log.content
+
+    ##
+    # Reads the subject into the object.
+    #
+    # 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?
+        content = begin
+          as_literal(RDF::Util::File.open_file(resource) {|f| f.read})
+        rescue IOError
+          nil
+        end
+      when :object
+        return nil unless resource.literal? || resource.variable?
+        resource
+      end
+    end
+  end
+end