class RuboCop::Cop::Style::YodaCondition

“bar” != foo
99 == foo
# good
3 < a && a < 5
99 >= foo
# bad
@example EnforcedStyle: require_for_equality_operators_only
10 < bar
42 >= foo
“bar” != foo
99 == foo
# good
bar > 10
foo <= 42
foo == “bar”
foo == 99
# bad
@example EnforcedStyle: require_for_all_comparison_operators
3 < a && a < 5
99 >= foo
# good
“bar” != foo
99 == foo
# bad
@example EnforcedStyle: forbid_for_equality_operators_only
/#{interpolation}/ == foo
“#{interpolation}” == foo
bar > 10
foo <= 42
foo == “bar”
foo == 99
# good
10 < bar
42 >= foo
“bar” != foo
99 == foo
# bad
@example EnforcedStyle: forbid_for_all_comparison_operators (default)
—-
‘string’ == obj #=> false
obj == ‘string’ #=> true
obj = MyKlass.new
end
end
true
def ==(other)
class MyKlass
—-
[source,ruby]

For example:
have the same result if reversed.
differently on different classes, and are not guaranteed to
This cop is unsafe because comparison operators can be defined
@safety
eg. ‘5 == x`
i.e. comparison operations where the order of expression is reversed.
This cop can either enforce or forbid Yoda conditions,

def actual_code_range(node)

def actual_code_range(node)
  range_between(node.loc.expression.begin_pos, node.loc.expression.end_pos)
end

def corrected_code(node)

def corrected_code(node)
  lhs = node.receiver
  rhs = node.first_argument
  "#{rhs.source} #{reverse_comparison(node.method_name)} #{lhs.source}"
end

def enforce_yoda?

def enforce_yoda?
  style == :require_for_all_comparison_operators ||
    style == :require_for_equality_operators_only
end

def equality_only?

def equality_only?
  style == :forbid_for_equality_operators_only ||
    style == :require_for_equality_operators_only
end

def interpolation?(node)

def interpolation?(node)
  return true if node.dstr_type?
  node.regexp_type? && node.interpolation?
end

def message(node)

def message(node)
  format(MSG, source: node.source)
end

def non_equality_operator?(node)

def non_equality_operator?(node)
  !EQUALITY_OPERATORS.include?(node.method_name)
end

def noncommutative_operator?(node)

def noncommutative_operator?(node)
  NONCOMMUTATIVE_OPERATORS.include?(node.method_name)
end

def on_send(node)

def on_send(node)
  return unless yoda_compatible_condition?(node)
  return if (equality_only? && non_equality_operator?(node)) ||
            file_constant_equal_program_name?(node)
  valid_yoda?(node) || add_offense(node) do |corrector|
    corrector.replace(actual_code_range(node), corrected_code(node))
  end
end

def program_name?(name)

def program_name?(name)
  PROGRAM_NAMES.include?(name)
end

def reverse_comparison(operator)

def reverse_comparison(operator)
  REVERSE_COMPARISON.fetch(operator.to_s, operator)
end

def source_file_path_constant?(node)

def source_file_path_constant?(node)
  node.source == '__FILE__'
end

def valid_yoda?(node)

def valid_yoda?(node)
  lhs = node.receiver
  rhs = node.first_argument
  return true if (lhs.literal? && rhs.literal?) ||
                 (!lhs.literal? && !rhs.literal?) ||
                 interpolation?(lhs)
  enforce_yoda? ? lhs.literal? : rhs.literal?
end

def yoda_compatible_condition?(node)

def yoda_compatible_condition?(node)
  node.comparison_method? && !noncommutative_operator?(node)
end

Modules

Classes