class RuboCop::Cop::Layout::CaseIndentation

end
y / 3
else
x * 2
when 0
a = case n
# good
end
y / 3
else
x * 2
when 0
a = case n
# bad
@example EnforcedStyle: end
end
y / 3
else
x * 2
when 0
a = case n
# good
end
y / 3
else
x * 2
when 0
a = case n
# bad
# configuration does have an effect.
# start_of_line (as shown below), then when alignment
# if EndAlignment is set to other style such as
@example EnforcedStyle: case (default)
end
y / 3
else
x * 2
when 0
case n
# good for all styles
end
y / 3
else
x * 2
when 0
case n
# bad for all styles
# regardless of configuration.
# and therefore when should always be aligned to both -
# case and end should always be aligned to same depth,
# If Layout/EndAlignment is set to keyword style (default)
@example
It will register a separate offense for each misaligned when.
are indented in relation to its case or end keyword.
This cop checks how the *when*s of a case expression

def autocorrect(node) 

def autocorrect(node)
  whitespace = whitespace_range(node)
  return false unless whitespace.source.strip.empty?
  lambda do |corrector|
    corrector.replace(whitespace, replacement(node))
  end
end

def base_column(case_node, base) 

def base_column(case_node, base)
  case base
  when :case then case_node.location.keyword.column
  when :end  then case_node.location.end.column
  end
end

def check_when(when_node) 

def check_when(when_node)
  when_column = when_node.loc.keyword.column
  base_column = base_column(when_node.parent, style)
  if when_column == base_column + indentation_width
    correct_style_detected
  else
    incorrect_style(when_node)
  end
end

def incorrect_style(when_node) 

def incorrect_style(when_node)
  when_column = when_node.loc.keyword.column
  base_column = base_column(when_node.parent, alternative_style)
  add_offense(when_node, location: :keyword, message: message(style)) do
    if when_column == base_column
      opposite_style_detected
    else
      unrecognized_style_detected
    end
  end
end

def indent_one_step? 

def indent_one_step?
  cop_config['IndentOneStep']
end

def indentation_width 

def indentation_width
  indent_one_step? ? configured_indentation_width : 0
end

def message(base) 

def message(base)
  depth = indent_one_step? ? 'one step more than' : 'as deep as'
  format(MSG, depth: depth, base: base)
end

def on_case(case_node) 

def on_case(case_node)
  return if case_node.single_line?
  case_node.each_when do |when_node|
    check_when(when_node)
  end
end

def replacement(node) 

def replacement(node)
  case_node = node.each_ancestor(:case).first
  base_type = cop_config[style_parameter_name] == 'end' ? :end : :case
  column = base_column(case_node, base_type)
  column += indentation_width
  ' ' * column
end

def whitespace_range(node) 

def whitespace_range(node)
  when_column = node.location.keyword.column
  begin_pos = node.loc.keyword.begin_pos
  range_between(begin_pos - when_column, begin_pos)
end