Class: RuboCop::Cop::Style::NegativeArrayIndex

# File 'lib/rubocop/cop/style/negative_array_index.rb', line 168

def build_current_source(receiver, range_without_parens, index_arg)
  has_parentheses = index_arg.begin_type?

  if has_parentheses
    "#{receiver}[(#{range_without_parens})]"
  else
    "#{receiver}[#{range_without_parens}]"
  end
end

# File 'lib/rubocop/cop/style/negative_array_index.rb', line 151

def build_message_for_range(receiver, start, range_op, index, current)
  format(
    MSG_RANGE,
    receiver: receiver, start: start, range_op: range_op, index: index, current: current
  )
end

# File 'lib/rubocop/cop/style/negative_array_index.rb', line 126

def build_range_offense_data(receiver, range_node, range_end, inner_end, negative_index,
                             index_arg)
  range_op = range_node.erange_type? ? '...' : '..'
  range_start = range_node.begin.source

  range_without_parens =
    build_range_without_parens(range_start, range_op, range_end, inner_end)
  current_source = build_current_source(receiver, range_without_parens, index_arg)
  start, index = format_range_message_parts(range_start, negative_index, index_arg)

  message = build_message_for_range(receiver, start, range_op, index, current_source)
  replacement = build_replacement_string(range_start, range_op, negative_index, index_arg)

  [message, replacement]
end

# File 'lib/rubocop/cop/style/negative_array_index.rb', line 178

def build_range_without_parens(range_start, range_op, range_end, inner_end)
  end_expression = range_end.begin_type? ? range_end.source : inner_end.source

  "#{range_start}#{range_op}#{end_expression}"
end

# File 'lib/rubocop/cop/style/negative_array_index.rb', line 158

def build_replacement_string(range_start, range_op, negative_index, index_arg)
  has_parentheses = index_arg.begin_type?

  if has_parentheses
    "(#{range_start}#{range_op}-#{negative_index})"
  else
    "#{range_start}#{range_op}-#{negative_index}"
  end
end

# File 'lib/rubocop/cop/style/negative_array_index.rb', line 198

def extract_base_receiver(node)
  receiver = node.receiver

  return nil unless receiver
  return receiver unless receiver.receiver

  extract_base_receiver(receiver)
end

# File 'lib/rubocop/cop/style/negative_array_index.rb', line 78

def extract_inner_end(node)
  node.children.size == 1 ? node.children.first : node
end

# File 'lib/rubocop/cop/style/negative_array_index.rb', line 74

def extract_range_from_begin(node)
  node.begin_type? ? node.children.first : node
end

# File 'lib/rubocop/cop/style/negative_array_index.rb', line 143

def format_range_message_parts(range_start, negative_index, index_arg)
  has_parentheses = index_arg.begin_type?
  start = has_parentheses ? "(#{range_start}" : range_start
  index = has_parentheses ? "#{negative_index})" : negative_index

  [start, index]
end

# File 'lib/rubocop/cop/style/negative_array_index.rb', line 111

def handle_range_pattern(receiver, range_node, index_arg)
  range_end = range_node.end
  inner_end = extract_inner_end(range_end)
  _length_receiver, negative_index = length_subtraction?(inner_end)

  message, replacement = build_range_offense_data(
    receiver, range_node, range_end, inner_end, negative_index, index_arg
  )

  add_offense(range_end, message: message) do |corrector|
    corrector.replace(index_arg, replacement)
  end
end

# File 'lib/rubocop/cop/style/negative_array_index.rb', line 65

def handle_simple_index_pattern(node, index_arg)
  length_receiver, negative_index = length_subtraction?(index_arg)

  return unless negative_index&.positive?
  return unless receivers_match?(length_receiver, node.receiver)

  add_offense_for_subtraction(node, index_arg, negative_index)
end

# File 'lib/rubocop/cop/style/negative_array_index.rb', line 42

def_node_matcher :length_subtraction?, <<~PATTERN
  (send
    (send $_ {:length :size :count}) :-
    (int $_))
PATTERN

# File 'lib/rubocop/cop/style/negative_array_index.rb', line 61

alias on_csend on_send

# File 'lib/rubocop/cop/style/negative_array_index.rb', line 48

def on_send(node)
  return if node.arguments.empty?

  index_arg = node.first_argument
  range_node = extract_range_from_begin(index_arg)
  if range_with_length_subtraction?(range_node, node.receiver)
    receiver = node.receiver.source
    return handle_range_pattern(receiver, range_node, index_arg)
  end

  handle_simple_index_pattern(node, index_arg)
end

# File 'lib/rubocop/cop/style/negative_array_index.rb', line 207

def preserving_method?(node)
  return true if node.receiver.nil?

  method_name = node.method_name
  return false unless PRESERVING_METHODS.include?(method_name)

  preserving_method?(node.receiver)
end

# File 'lib/rubocop/cop/style/negative_array_index.rb', line 94

def range_with_length_subtraction?(range_node, array_receiver)
  return false unless range_node.range_type?

  range_end = range_node.end
  range_start = range_node.begin
  return false unless range_end && range_start

  return false unless preserving_method?(range_start)

  inner_end = extract_inner_end(range_end)
  length_receiver, negative_index = length_subtraction?(inner_end)

  return false unless negative_index&.positive?

  receivers_match_strict?(length_receiver, array_receiver)
end

# File 'lib/rubocop/cop/style/negative_array_index.rb', line 184

def receivers_match?(length_receiver, array_receiver)
  unless preserving_method?(array_receiver) && preserving_method?(length_receiver)
    return false
  end
  return true if length_receiver.source == array_receiver.source

  !extract_base_receiver(array_receiver).nil?
end

# File 'lib/rubocop/cop/style/negative_array_index.rb', line 193

def receivers_match_strict?(length_receiver, array_receiver)
  preserving_method?(array_receiver) &&
    length_receiver.source == array_receiver.source
end