class RuboCop::Cop::Layout::MultilineAssignmentLayout


end
’bar’ * i<br>.map do |i|
foo =
# good
end
’bar’
foo = if expression
# good
@example SupportedTypes: [‘block’]
end
i + 1<br>.map do |i|
foo =
# good
end
’bar’
if expression
foo =
# good
@example SupportedTypes: [‘block’, ‘case’, ‘class’, ‘if’, ‘kwbegin’, ‘module’] (default)
end
’bar’
foo = if expression
# good
@example EnforcedStyle: same_line
end
nil
rescue => e
compute
begin
foo =
# good
end
’bar’
if expression
foo =
# good
end
’bar’
foo = if expression
# bad
@example EnforcedStyle: new_line (default)
after the assignment operator.
Checks whether the multiline assignments have a newline

def check_assignment(node, rhs) 

def check_assignment(node, rhs)
  return if node.send_type? && node.loc.operator&.source != '='
  return unless rhs
  return unless supported_types.include?(rhs.type)
  return if rhs.single_line?
  check_by_enforced_style(node, rhs)
end

def check_by_enforced_style(node, rhs) 

def check_by_enforced_style(node, rhs)
  case style
  when :new_line
    check_new_line_offense(node, rhs)
  when :same_line
    check_same_line_offense(node, rhs)
  end
end

def check_new_line_offense(node, rhs) 

def check_new_line_offense(node, rhs)
  return unless same_line?(node.loc.operator, rhs)
  add_offense(node, message: NEW_LINE_OFFENSE) do |corrector|
    corrector.insert_after(node.loc.operator, "\n")
  end
end

def check_same_line_offense(node, rhs) 

def check_same_line_offense(node, rhs)
  return unless node.loc.operator.line != rhs.first_line
  add_offense(node, message: SAME_LINE_OFFENSE) do |corrector|
    range = range_between(
      node.loc.operator.end_pos, extract_rhs(node).source_range.begin_pos
    )
    corrector.replace(range, ' ')
  end
end

def supported_types 

def supported_types
  @supported_types ||= cop_config['SupportedTypes'].map(&:to_sym)
end