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]
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.



60
61
62
63
64
65
66
 
# File 'lib/synvert/core/node_query/compiler/comparable.rb', line 60

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



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

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:



17
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
 
# File 'lib/synvert/core/node_query/compiler/comparable.rb', line 17

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) > 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



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

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