class RuboCop::Cop::Lint::AssignmentInCondition


end
do_something
if (some_var = true)
# bad
@example AllowSafeAssignment: false
end
do_something
if (some_var = true)
# good
@example AllowSafeAssignment: true (default)
end
do_something
if some_var == true
# good
end
do_something
if some_var = true
# bad
@example
the author meant to use an assignment result as a condition.
This cop’s autocorrection is unsafe because it assumes that
@safety
as a condition. It’s not a mistake.“
an assignment to indicate ”I know I’m using an assignment
By safe assignment we mean putting parentheses around
`AllowSafeAssignment` option for safe assignment.
if/while/until.
Checks for assignments in the conditions of

def allowed_construct?(asgn_node) 

def allowed_construct?(asgn_node)
  asgn_node.begin_type? || conditional_assignment?(asgn_node)
end

def conditional_assignment?(asgn_node) 

def conditional_assignment?(asgn_node)
  !asgn_node.loc.operator
end

def message(_node) 

def message(_node)
  if safe_assignment_allowed?
    MSG_WITH_SAFE_ASSIGNMENT_ALLOWED
  else
    MSG_WITHOUT_SAFE_ASSIGNMENT_ALLOWED
  end
end

def on_if(node) 

def on_if(node)
  return if node.condition.block_type?
  traverse_node(node.condition) do |asgn_node|
    next :skip_children if skip_children?(asgn_node)
    next if allowed_construct?(asgn_node)
    add_offense(asgn_node.loc.operator) do |corrector|
      next unless safe_assignment_allowed?
      corrector.wrap(asgn_node, '(', ')')
    end
  end
end

def skip_children?(asgn_node) 

def skip_children?(asgn_node)
  (asgn_node.send_type? && !asgn_node.assignment_method?) ||
    empty_condition?(asgn_node) ||
    (safe_assignment_allowed? && safe_assignment?(asgn_node))
end

def traverse_node(node, &block) 

def traverse_node(node, &block)
  # if the node is a block, any assignments are irrelevant
  return if node.block_type?
  result = yield node if ASGN_TYPES.include?(node.type)
  return if result == :skip_children
  node.each_child_node { |child| traverse_node(child, &block) }
end