Module: NodeQuery::Compiler::Comparable

Included in:
ArrayValue, Boolean, Float, Identifier, Integer, Nil, Regexp, String, Symbol
Defined in:
lib/node_query/compiler/comparable.rb

Overview

Compare acutal value with expected value.

Constant Summary collapse

SIMPLE_VALID_OPERATORS = 
['=', '!=', 'includes', 'not_includes']
STRING_VALID_OPERATORS = 
['=', '!=', '^=', '$=', '*=', 'includes', 'not_includes']
NUMBER_VALID_OPERATORS = 
['=', '!=', '>', '>=', '<', '<=', 'includes', 'not_includes']
ARRAY_VALID_OPERATORS = 
['=', '!=', 'in', 'not_in']
REGEXP_VALID_OPERATORS = 
['=~', '!~']

Instance Method Summary collapse

Instance Method Details

#actual_value(node) ⇒ Object

Get the actual value from ast node.

Parameters:

  • node (Node) —

    ast node

Returns:

  • the node value, could be integer, float, string, boolean, nil, range, and etc.



92
93
94
95
96
97
98
 
# File 'lib/node_query/compiler/comparable.rb', line 92

def actual_value(node)
  if @adapter.is_node?(node)
    node.to_value
  else
    node
  end
end

#expected_value(_base_node) ⇒ Object

Get the expected value

Parameters:

  • base_node (Node) —

    the base node for evaluated value

Returns:

  • expected value, could be integer, float, string, boolean, nil, range, and etc.



103
104
105
 
# File 'lib/node_query/compiler/comparable.rb', line 103

def expected_value(_base_node)
  @value
end

#is_equal?(actual, expected) ⇒ Boolean

Check if the actual value equals the expected value.

Parameters:

  • acutal
  • expected

Returns:

  • (Boolean) —

    true if the actual value equals the expected value.



85
86
87
 
# File 'lib/node_query/compiler/comparable.rb', line 85

def is_equal?(actual, expected)
  actual == expected
end

#match?(node, base_node, operator) ⇒ Boolean

Check if the actual value matches the expected value.

Parameters:

  • node (Node) —

    node to calculate actual value

  • base_node (Node) —

    the base node for evaluated value

  • operator (String) —

    operator to compare with expected value, operator can be '=', '!=', '>', '>=', '<', '<=', 'includes', 'in', 'not_in', '=~', '!~'

  • adapter (NodeQuery::Adapter)

Returns:

  • (Boolean) —

    true if actual value matches the expected value

Raises:



20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
 
# File 'lib/node_query/compiler/comparable.rb', line 20

def match?(node, base_node, operator)
  raise InvalidOperatorError, "invalid operator #{operator}" unless valid_operator?(operator)

  actual = actual_value(node)
  expected = expected_value(base_node)
  case operator
  when '!='
    if expected.is_a?(::Array)
      !actual.is_a?(::Array) || actual.size != expected.size ||
        actual.zip(expected).any? { |actual_child, expected_child|
          expected_child.match?(actual_child, base_node, '!=')
        }
    else
      !is_equal?(actual, expected)
    end
  when '=~'
    actual =~ expected
  when '!~'
    actual !~ expected
  when '^='
    actual.start_with?(expected)
  when '$='
    actual.end_with?(expected)
  when '*='
    actual.include?(expected)
  when '>'
    actual > expected
  when '>='
    actual >= expected
  when '<'
    actual < expected
  when '<='
    actual <= expected
  when 'in'
    if node.is_a?(Array)
      node.all? { |child| expected.any? { |expected_child| expected_child.match?(child, base_node, '=') } }
    else
      expected.any? { |expected_child| expected_child.match?(node, base_node, '=') }
    end
  when 'not_in'
    if node.is_a?(Array)
      node.all? { |child| expected.all? { |expected_child| expected_child.match?(child, base_node, '!=') } }
    else
      expected.all? { |expected_child| expected_child.match?(node, base_node, '!=') }
    end
  when 'includes'
    actual.any? { |actual_child| expected.match?(actual_child) }
  when 'not_includes'
    actual.none? { |actual_child| expected.match?(actual_child) }
  else
    if expected.is_a?(::Array)
      actual.is_a?(::Array) && actual.size == expected.size &&
        actual.zip(expected).all? { |actual_child, expected_child|
          expected_child.match?(actual_child, base_node, '=')
        }
    else
      is_equal?(actual, expected)
    end
  end
end

#valid_operator?(operator) ⇒ Boolean

Check if the operator is valid.

Returns:

  • (Boolean) —

    true if the operator is valid



109
110
111
 
# File 'lib/node_query/compiler/comparable.rb', line 109

def valid_operator?(operator)
  valid_operators.include?(operator)
end