class RuboCop::Cop::Lint::AssignmentInCondition

end
do_something
if some_var == true
# good
@example
end
do_something
if some_var = true
# bad
@example
if/while/until.
This cop 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 check(node) 

def check(node)
  return if node.condition.block_type?
  traverse_node(node.condition, ASGN_TYPES) do |asgn_node|
    next :skip_children if skip_children?(asgn_node)
    next if allowed_construct?(asgn_node)
    add_offense(asgn_node, location: :operator)
  end
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)
  check(node)
end

def on_until(node) 

def on_until(node)
  check(node)
end

def on_while(node) 

def on_while(node)
  check(node)
end

def skip_children?(asgn_node) 

def skip_children?(asgn_node)
  (asgn_node.send_type? && asgn_node.method_name !~ /=\z/) ||
    empty_condition?(asgn_node) ||
    (safe_assignment_allowed? && safe_assignment?(asgn_node))
end

def traverse_node(node, types, &block)

each_node/visit_descendants_with_types with :skip_children 
def traverse_node(node, types, &block)
  result = yield node if types.include?(node.type)
  return if result == :skip_children
  node.each_child_node { |child| traverse_node(child, types, &block) }
end