Class: Keisan::Evaluator

Inherits:
Object
  • Object
show all
Defined in:
lib/keisan/evaluator.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(calculator, cache: nil) ⇒ Evaluator

Returns a new instance of Evaluator.



5
6
7
8
 
# File 'lib/keisan/evaluator.rb', line 5

def initialize(calculator, cache: nil)
  @calculator = calculator
  @cache = cache
end

Instance Attribute Details

#calculator ⇒ Object (readonly)

Returns the value of attribute calculator.



3
4
5
 
# File 'lib/keisan/evaluator.rb', line 3

def calculator
  @calculator
end

Instance Method Details

#evaluate(expression, definitions = {}) ⇒ Object 



10
11
12
13
 
# File 'lib/keisan/evaluator.rb', line 10

def evaluate(expression, definitions = {})
  context = calculator.context.spawn_child(definitions: definitions, transient: true)
  evaluate_ast(parse_ast(expression), context: context)
end

#evaluate_ast(ast, definitions: {}, context: nil) ⇒ Object 



15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
# File 'lib/keisan/evaluator.rb', line 15

def evaluate_ast(ast, definitions: {}, context: nil)
  context ||= calculator.context.spawn_child(definitions: definitions, transient: true)
  last_line = last_line(ast)

  evaluation = ast.evaluated(context)

  if last_line.is_a?(AST::Assignment)
    if last_line.children.first.is_a?(AST::Variable)
      context.variable(last_line.children.first.name).value(context)
    end
  else
    evaluation.value(context)
  end
end

#parse_ast(expression) ⇒ Object 



40
41
42
43
44
45
46
47
 
# File 'lib/keisan/evaluator.rb', line 40

def parse_ast(expression)
  ast = @cache.nil? ? AST.parse(expression) : @cache.fetch_or_build(expression)
  disallowed = disallowed_nodes
  if !disallowed.empty? && ast.contains_a?(disallowed)
    raise Keisan::Exceptions::InvalidExpression.new("Context does not permit expressions with #{disallowed}")
  end
  ast
end

#simplify(expression, definitions = {}) ⇒ Object 



30
31
32
33
 
# File 'lib/keisan/evaluator.rb', line 30

def simplify(expression, definitions = {})
  context = calculator.context.spawn_child(definitions: definitions, transient: true)
  simplify_ast(parse_ast(expression), context: context)
end

#simplify_ast(ast, definitions: {}, context: nil) ⇒ Object 



35
36
37
38
 
# File 'lib/keisan/evaluator.rb', line 35

def simplify_ast(ast, definitions: {}, context: nil)
  context ||= calculator.context.spawn_child(definitions: definitions, transient: true)
  ast.simplified(context)
end