Class: Ruby::Rego::Evaluator::ExpressionEvaluator

Inherits:
Object
  • Object
show all
Includes:
AssignmentSupport, BindingHelpers, LocalShadowing
Defined in:
lib/ruby/rego/evaluator/expression_evaluator.rb,
lib/ruby/rego/evaluator/expression_evaluator/operators.rb,
lib/ruby/rego/evaluator/expression_evaluator/quantifiers.rb,
lib/ruby/rego/evaluator/expression_evaluator/node_evaluation.rb

Overview

Variable, reference, literal, and call node evaluation.

Constant Summary collapse

PRIMITIVE_TYPES = 
[String, Numeric, TrueClass, FalseClass, Array, Hash, Set, NilClass].freeze
NODE_EVALUATORS = 
[
  [AST::Literal, ->(literal, _evaluator) { Value.from_ruby(literal.value) }],
  [AST::Variable, ->(variable, evaluator) { evaluator.send(:evaluate_variable, variable) }],
  [AST::Reference, ->(reference, evaluator) { evaluator.send(:evaluate_reference, reference) }],
  [AST::BinaryOp, ->(binary_op, evaluator) { evaluator.send(:evaluate_binary_op, binary_op) }],
  [AST::UnaryOp, ->(unary_op, evaluator) { evaluator.send(:evaluate_unary_op, unary_op) }],
  [AST::ArrayLiteral, ->(node, evaluator) { evaluator.send(:evaluate_array_literal, node) }],
  [AST::ObjectLiteral, ->(node, evaluator) { evaluator.send(:evaluate_object_literal, node) }],
  [AST::SetLiteral, ->(node, evaluator) { evaluator.send(:evaluate_set_literal, node) }],
  [AST::ArrayComprehension, ->(node, evaluator) { evaluator.send(:eval_array_comprehension, node) }],
  [AST::ObjectComprehension, ->(node, evaluator) { evaluator.send(:eval_object_comprehension, node) }],
  [AST::SetComprehension, ->(node, evaluator) { evaluator.send(:eval_set_comprehension, node) }],
  [AST::Every, ->(node, evaluator) { evaluator.send(:evaluate_every, node) }],
  [AST::Call, ->(call, evaluator) { evaluator.send(:evaluate_call, call) }],
  [AST::TemplateString, ->(node, evaluator) { evaluator.send(:evaluate_template_string, node) }]
].freeze
TRUE_VALUE = 
BooleanValue.new(true)
FALSE_VALUE = 
BooleanValue.new(false)

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(environment:, reference_resolver:) ⇒ ExpressionEvaluator

:reek:TooManyStatements

Parameters:



42
43
44
45
46
47
48
49
50
51
52
53
 
# File 'lib/ruby/rego/evaluator/expression_evaluator.rb', line 42

def initialize(environment:, reference_resolver:)
  @environment = environment
  @reference_resolver = reference_resolver
  @dispatch = build_dispatch
  @unifier = Unifier.new(variable_resolver: method(:resolve_reference_variable_key))
  @object_literal_evaluator = ObjectLiteralEvaluator.new(expression_evaluator: self)
  @comprehension_evaluator = ComprehensionEvaluator.new(
    expression_evaluator: self,
    environment: environment
  )
  @query_evaluator = nil
end

Class Method Details

.call_name(node) ⇒ Object

:reek:UtilityFunction



88
89
90
 
# File 'lib/ruby/rego/evaluator/expression_evaluator.rb', line 88

def self.call_name(node)
  CallName.call_name(node)
end

Instance Method Details

#attach_query_evaluator(query_evaluator) ⇒ void

This method returns an undefined value.

Parameters:



57
58
59
60
61
 
# File 'lib/ruby/rego/evaluator/expression_evaluator.rb', line 57

def attach_query_evaluator(query_evaluator)
  @query_evaluator = query_evaluator
  comprehension_evaluator.attach_query_evaluator(query_evaluator)
  nil
end

#eval_with_unification(node, env = environment) ⇒ Enumerator

Parameters:

  • node (Object)
  • env (Environment) (defaults to: environment)

Returns:

  • (Enumerator) 


74
75
76
77
78
79
80
81
82
83
84
85
 
# File 'lib/ruby/rego/evaluator/expression_evaluator.rb', line 74

def eval_with_unification(node, env = environment)
  Enumerator.new do |yielder|
    case node
    when AST::BinaryOp
      handle_unification_operator(node, env, yielder)
    when AST::Reference
      yield_reference_bindings(node, env, yielder)
    else
      yield_truthy_bindings(node, yielder)
    end
  end
end

#evaluate(node) ⇒ Value

Parameters:

  • node (Object)

Returns:



65
66
67
68
69
 
# File 'lib/ruby/rego/evaluator/expression_evaluator.rb', line 65

def evaluate(node)
  return node if node.is_a?(Value)

  dispatch.primitive_value(node) || dispatch.dispatch_node(node, self) || raise_unknown_node(node)
end

#evaluate_user_function(name, args) ⇒ Object 



65
66
67
68
69
 
# File 'lib/ruby/rego/evaluator/expression_evaluator/node_evaluation.rb', line 65

def evaluate_user_function(name, args)
  return UndefinedValue.new unless query_evaluator

  query_evaluator.evaluate_function_call(name, args)
end

#imported_or_rule_variable?(name) ⇒ Boolean

Returns:

  • (Boolean) 


91
92
93
94
 
# File 'lib/ruby/rego/evaluator/expression_evaluator/node_evaluation.rb', line 91

def imported_or_rule_variable?(name)
  !!(reference_resolver.resolve_import_variable(name) ||
    reference_resolver.resolve_rule_variable(name))
end

#variable_known?(name) ⇒ Boolean

Returns:

  • (Boolean) 


72
73
74
75
76
77
78
 
# File 'lib/ruby/rego/evaluator/expression_evaluator/node_evaluation.rb', line 72

def variable_known?(name)
  variable_name = name.to_s
  return false if wildcard_variable_name?(variable_name)
  return true if locally_resolved_variable?(variable_name)

  imported_or_rule_variable?(variable_name)
end