Class: RDF::N3::Algebra::List::Member

Inherits:
RDF::N3::Algebra::ListOperator show all
Defined in:
lib/rdf/n3/algebra/list/member.rb

Overview

Iff the subject is a list and the object is in that list, then this is true.

Constant Summary collapse

NAME = 
:listMember
URI = 
RDF::N3::List.member

Instance Attribute Summary

Attributes included from Enumerable

#existentials, #universals

Instance Method Summary collapse

Methods inherited from RDF::N3::Algebra::ListOperator

#as_literal, #input_operand, #resolve, #validate

Methods included from Builtin

#each, #evaluate, #hash, #input_operand, #rank, #to_uri

Instance Method Details

#execute(queryable, solutions:, **options) ⇒ RDF::Query::Solutions

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.

Parameters:

  • queryable (RDF::Queryable) —

    the graph or repository to query

  • solutions (RDF::Query::Solutions) —

    solutions for chained queries

Returns:

  • (RDF::Query::Solutions) 


17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
# File 'lib/rdf/n3/algebra/list/member.rb', line 17

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