Class: ExprEvaluator

Inherits:
Evaluator show all
Defined in:
lib/json_expr/expr_evaluator.rb

Constant Summary collapse

NUMERIC_REGEX = 
/\A[-+]?[0-9]*\.?[0-9]+\Z/

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(operators, vars) ⇒ ExprEvaluator

Returns a new instance of ExprEvaluator.



13
14
15
16
 
# File 'lib/json_expr/expr_evaluator.rb', line 13

def initialize(operators, vars)
  @operators = operators
  @vars = vars
end

Instance Attribute Details

#operators ⇒ Object

Returns the value of attribute operators.



9
10
11
 
# File 'lib/json_expr/expr_evaluator.rb', line 9

def operators
  @operators
end

#vars ⇒ Object

Returns the value of attribute vars.



10
11
12
 
# File 'lib/json_expr/expr_evaluator.rb', line 10

def vars
  @vars
end

Instance Method Details

#boolean_convert(x) ⇒ Object 



31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/json_expr/expr_evaluator.rb', line 31

def boolean_convert(x)
  if x.is_a?(TrueClass) || x.is_a?(FalseClass)
    return x
  elsif x.is_a?(Numeric) || !(x.to_s =~ NUMERIC_REGEX).nil?
    return !x.to_f.zero?
  elsif x.is_a?(String)
    return x != "false" && x != "0" && x != ""
  end

  !x.nil?
end

#compare(lhs, rhs) ⇒ Object 



88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
 
# File 'lib/json_expr/expr_evaluator.rb', line 88

def compare(lhs, rhs)
  if lhs.nil?
    return rhs.nil? ? 0 : nil
  elsif rhs.nil?
    return nil
  end

  if lhs.is_a?(Numeric)
    rvalue = number_convert(rhs)
    return lhs.to_f.to_s.casecmp(rvalue.to_s) unless rvalue.nil?
  elsif lhs.is_a?(String)
    rvalue = string_convert(rhs)
    return lhs.compare_to(rvalue) unless rvalue.nil?
  elsif lhs.is_a?(TrueClass) || lhs.is_a?(FalseClass)
    rvalue = boolean_convert(rhs)
    return lhs.to_s.casecmp(rvalue.to_s) unless rvalue.nil?
  elsif lhs.class == rhs.class && lhs === rhs
    return 0
  end
  nil
end

#evaluate(expr) ⇒ Object 



18
19
20
21
22
23
24
25
26
27
28
29
 
# File 'lib/json_expr/expr_evaluator.rb', line 18

def evaluate(expr)
  if expr.is_a? Array
    return @operators[:and].evaluate(self, expr)
  elsif expr.is_a? Hash
    expr.transform_keys(&:to_sym).each do |key, value|
      if @operators[key]
        return @operators[key].evaluate(self, value)
      end
    end
  end
  nil
end

#extract_var(path) ⇒ Object 



65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
 
# File 'lib/json_expr/expr_evaluator.rb', line 65

def extract_var(path)
  frags = path.split("/")
  target = !vars.nil? ? vars : {}

  frags.each do |frag|
    list = target
    value = nil
    if target.is_a?(Array)
      value = list[frag.to_i]
    elsif target.is_a?(Hash)
      value = list[frag].nil? ? list[frag.to_sym] : list[frag]
    end

    unless value.nil?
      target = value
      next
    end

    return nil
  end
  target
end

#number_convert(x) ⇒ Object 



43
44
45
46
47
48
49
50
51
52
 
# File 'lib/json_expr/expr_evaluator.rb', line 43

def number_convert(x)
  return if x.nil? || x.to_s.empty?

  if x.is_a?(Numeric) || !(x.to_s =~ NUMERIC_REGEX).nil?
    return x.to_f
  elsif x.is_a?(TrueClass) || x.is_a?(FalseClass)
    return x ? 1.0 : 0.0
  end
  nil
end

#string_convert(x) ⇒ Object 



54
55
56
57
58
59
60
61
62
63
 
# File 'lib/json_expr/expr_evaluator.rb', line 54

def string_convert(x)
  if x.is_a?(String)
    return x
  elsif x.is_a?(TrueClass) || x.is_a?(FalseClass)
    return x.to_s
  elsif x.is_a?(Numeric) || !(x.to_s =~ NUMERIC_REGEX).nil?
    return x == x.to_i ? x.to_i.to_s : x.to_s
  end
  nil
end