Module: Synvert::Core::NodeQuery::Compiler::Comparable

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

Overview

Compare acutal value with expected value.

Constant Summary collapse

SIMPLE_VALID_OPERATORS = 
['==', '!=', 'includes']
STRING_VALID_OPERATORS = 
['==', '!=', '^=', '$=', '*=', 'includes']
NUMBER_VALID_OPERATORS = 
['==', '!=', '>', '>=', '<', '<=', '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.

Returns:

  • if node is a Parser::AST::Node, return the node value, otherwise, return the node itself.



67
68
69
70
71
72
73
 
# File 'lib/synvert/core/node_query/compiler/comparable.rb', line 67

def actual_value(node)
  if node.is_a?(::Parser::AST::Node)
    node.to_value
  else
    node
  end
end

#expected_value ⇒ Object

Get the expected value



76
77
78
 
# File 'lib/synvert/core/node_query/compiler/comparable.rb', line 76

def expected_value
  @value
end

#match?(node, operator) ⇒ Boolean

Check if the actual value matches the expected value.

Parameters:

  • node (Parser::AST::Node) —

    node to calculate actual value

  • operator (Symbol) —

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

Returns:

  • (Boolean) —

    true if actual value matches the expected value

Raises:



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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
 
# File 'lib/synvert/core/node_query/compiler/comparable.rb', line 18

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

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

#valid_operator?(operator) ⇒ Boolean

Check if the operator is valid.

Returns:

  • (Boolean) —

    true if the operator is valid



82
83
84
 
# File 'lib/synvert/core/node_query/compiler/comparable.rb', line 82

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