class RuboCop::Cop::Layout::FirstParameterIndentation


second_param
nested_first_param),
some_method nested_call(
second_param)
nested_first_param),
nested_call(
foo = some_method(
second_param)
nested_first_param),
foo = some_method(nested_call(
second_param)
first_param,
foo = some_method(
second_param)
first_param,
some_method(
# good
# parentheses.
# only applies if the outer method call encloses its arguments in
# Same as ‘special_for_inner_method_call` except that the special rule
@example EnforcedStyle: special_for_inner_method_call_in_parentheses (default)
second_param
nested_first_param),
some_method nested_call(
second_param)
nested_first_param),
nested_call(
foo = some_method(
second_param)
nested_first_param),
foo = some_method(nested_call(
second_param)
first_param,
foo = some_method(
second_param)
first_param,
some_method(
# good
# should be indented relative to the inner method.
# is itself a parameter in a method call, then the inner parameter
# the preceding line, but if it’s a parameter for a method call that
# The first parameter should normally be indented one step more than
@example EnforcedStyle: special_for_inner_method_call
second_params
nested_first_param),
some_method nested_call(
second_param)
nested_first_param),
nested_call(
foo = some_method(
second_param)
nested_first_param),
foo = some_method(nested_call(
second_param)
first_param,
foo = some_method(
second_param)
first_param,
some_method(
# good
# the parent that is receiving the parameter
# The first parameter should always be indented one level relative to
@example EnforcedStyle: consistent_relative_to_receiver
second_param
nested_first_param),
some_method nested_call(
second_param)
nested_first_param),
nested_call(
foo = some_method(
second_param)
nested_first_param),
foo = some_method(nested_call(
second_param)
first_param,
foo = some_method(
second_param)
first_param,
some_method(
# good
# preceding line.
# The first parameter should always be indented one step more than the
@example EnforcedStyle: consistent
second_param
nested_first_param),
some_method nested_call(
second_param)
nested_first_param),
nested_call(
foo = some_method(
second_param)
nested_first_param),
foo = some_method(nested_call(
second_param)
first_param,
foo = some_method(
second_param)
first_param,
some_method(
# bad
@example
not by this cop.
Parameters after the first one are checked by Layout/AlignParameters,
This cop checks the indentation of the first parameter in a method call.

def autocorrect(node) 

def autocorrect(node)
  AlignmentCorrector.correct(processed_source, node, column_delta)
end

def base_indentation(node) 

def base_indentation(node)
  if special_inner_call_indentation?(node)
    column_of(base_range(node, node.first_argument))
  else
    previous_code_line(node.first_argument.first_line) =~ /\S/
  end
end

def base_range(send_node, arg_node) 

def base_range(send_node, arg_node)
  range_between(send_node.source_range.begin_pos,
                arg_node.source_range.begin_pos)
end

def column_of(range)

is simple. For ranges with line breaks, we look a the last code line.
Returns the column of the given range. For single line ranges, this 
def column_of(range)
  source = range.source.strip
  if source.include?("\n")
    previous_code_line(range.line + source.count("\n") + 1) =~ /\S/
  else
    display_column(range)
  end
end

def message(arg_node) 

def message(arg_node)
  return 'Bad indentation of the first parameter.' unless arg_node
  send_node = arg_node.parent
  text = base_range(send_node, arg_node).source.strip
  base = if text !~ /\n/ && special_inner_call_indentation?(send_node)
           "`#{text}`"
         elsif text.lines.reverse_each.first =~ /^\s*#/
           'the start of the previous line (not counting the comment)'
         else
           'the start of the previous line'
         end
  format(MSG, base: base)
end

def on_send(node) 

def on_send(node)
  return if !node.arguments? || node.operator_method?
  indent = base_indentation(node) + configured_indentation_width
  check_alignment([node.first_argument], indent)
end

def previous_code_line(line_number)

line.
containing the previous line that's not a comment line or a blank
Takes the line number of a given code line and returns a string 
def previous_code_line(line_number)
  @comment_lines ||=
    processed_source
    .comments
    .select { |c| begins_its_line?(c.loc.expression) }
    .map { |c| c.loc.line }
  line = ''
  while line.blank? || @comment_lines.include?(line_number)
    line_number -= 1
    line = processed_source.lines[line_number - 1]
  end
  line
end

def special_inner_call_indentation?(node) 

def special_inner_call_indentation?(node)
  return false if style == :consistent
  return true  if style == :consistent_relative_to_receiver
  parent = node.parent
  return false unless eligible_method_call?(parent)
  return false if !parent.parenthesized? &&
                  style == :special_for_inner_method_call_in_parentheses
  # The node must begin inside the parent, otherwise node is the first
  # part of a chained method call.
  node.source_range.begin_pos > parent.source_range.begin_pos
end