Module: RuboCop::Cop::CheckLineBreakable

# File 'lib/rubocop/cop/mixin/check_line_breakable.rb', line 240

def already_on_multiple_lines?(node)
  return node.first_line != node.last_argument.last_line if node.any_def_type?

  node.multiline?
end

# File 'lib/rubocop/cop/mixin/check_line_breakable.rb', line 137

def breakable_collection?(node, elements)
  # For simplicity we only want to insert breaks in normal
  # hashes wrapped in a set of curly braces like {foo: 1}.
  # That is, not a kwargs hash. For method calls, this ensures
  # the method call is made with parens.
  starts_with_bracket = !node.hash_type? || node.loc.begin

  # If the call has a second argument, we can insert a line
  # break before the second argument and the rest of the
  # argument will get auto-formatted onto separate lines
  # by other cops.
  has_second_element = elements.length >= 2

  starts_with_bracket && has_second_element
end

# File 'lib/rubocop/cop/mixin/check_line_breakable.rb', line 246

def chained_to_heredoc?(node)
  while (node = node.receiver)
    return true if node.any_str_type? && node.heredoc?
  end

  false
end

# File 'lib/rubocop/cop/mixin/check_line_breakable.rb', line 195

def children_could_be_broken_up?(node, children)
  if @check_line_breakable_processed_source != processed_source
    @check_line_breakable_processed_source = processed_source
    @children_could_be_broken_up_cache = {}.compare_by_identity
  end

  @children_could_be_broken_up_cache.fetch(node) do
    @children_could_be_broken_up_cache[node] = compute_children_could_be_broken_up?(children)
  end
end

# File 'lib/rubocop/cop/mixin/check_line_breakable.rb', line 207

def compute_children_could_be_broken_up?(children)
  return false if all_on_same_line?(children)

  last_seen_line = -1
  children.each do |child|
    return true if last_seen_line >= child.first_line

    last_seen_line = child.last_line
  end
  false
end

# File 'lib/rubocop/cop/mixin/check_line_breakable.rb', line 154

def contained_by_breakable_collection_on_same_line?(node)
  node.each_ancestor.find do |ancestor|
    # Ignore ancestors on different lines.
    break if ancestor.first_line != node.first_line

    if ancestor.type?(:hash, :array)
      elements = ancestor.children
    elsif ancestor.call_type?
      elements = process_args(ancestor.arguments)
    else
      next
    end

    return true if breakable_collection?(ancestor, elements)
  end

  false
end

# File 'lib/rubocop/cop/mixin/check_line_breakable.rb', line 174

def contained_by_multiline_collection_that_could_be_broken_up?(node)
  node.each_ancestor.find do |ancestor|
    if ancestor.type?(:hash, :array) &&
       breakable_collection?(ancestor, ancestor.children)
      return children_could_be_broken_up?(ancestor, ancestor.children)
    end

    next unless ancestor.call_type?

    args = process_args(ancestor.arguments)
    if breakable_collection?(ancestor, args)
      return children_could_be_broken_up?(ancestor, args)
    end
  end

  false
end

# File 'lib/rubocop/cop/mixin/check_line_breakable.rb', line 45

def extract_breakable_node(node, max)
  if node.call_type?
    return if chained_to_heredoc?(node)

    args = process_args(node.arguments)
    return extract_breakable_node_from_elements(node, args, max)
  elsif node.any_def_type?
    return extract_breakable_node_from_elements(node, node.arguments, max)
  elsif node.type?(:array, :hash)
    return extract_breakable_node_from_elements(node, node.children, max)
  end
  nil
end

# File 'lib/rubocop/cop/mixin/check_line_breakable.rb', line 62

def extract_breakable_node_from_elements(node, elements, max)
  return unless breakable_collection?(node, elements)

  # Check the cheap conditions first, `safe_to_ignore?` may traverse all elements of
  # a containing collection.
  line = processed_source.lines[node.first_line - 1]
  return if max && line.length <= max
  return if processed_source.line_with_comment?(node.loc.line)
  return if safe_to_ignore?(node)

  extract_first_element_over_column_limit(node, elements, max)
end

# File 'lib/rubocop/cop/mixin/check_line_breakable.rb', line 76

def extract_first_element_over_column_limit(node, elements, max)
  line = node.first_line

  # If a `send` or `csend` node is not parenthesized, don't move the first element, because it
  # can result in changed behavior or a syntax error.
  if node.call_type? && !node.parenthesized? && !first_argument_is_heredoc?(node)
    elements = elements.drop(1)
  end

  i = 0
  i += 1 while within_column_limit?(elements[i], max, line)
  i = shift_elements_for_heredoc_arg(node, elements, i)

  return if i.nil?
  return elements.first if i.zero?

  elements[i - 1]
end

# File 'lib/rubocop/cop/mixin/check_line_breakable.rb', line 96

def first_argument_is_heredoc?(node)
  first_argument = node.first_argument

  first_argument.respond_to?(:heredoc?) && first_argument.heredoc?
end

# File 'lib/rubocop/cop/mixin/check_line_breakable.rb', line 227

def process_args(args)
  # If there is a trailing hash arg without explicit braces, like this:
  #
  #    method(1, 'key1' => value1, 'key2' => value2)
  #
  # ...then each key/value pair is treated as a method 'argument'
  # when determining where line breaks should appear.
  last_arg = args.last
  args = args[0...-1] + last_arg.children if last_arg&.hash_type? && !last_arg&.braces?
  args
end

# File 'lib/rubocop/cop/mixin/check_line_breakable.rb', line 121

def safe_to_ignore?(node)
  return true unless max
  return true if already_on_multiple_lines?(node)

  # If there's a containing breakable collection on the same
  # line, we let that one get broken first. In a separate pass,
  # this one might get broken as well, but to avoid conflicting
  # or redundant edits, we only mark one offense at a time.
  return true if contained_by_breakable_collection_on_same_line?(node)

  return true if contained_by_multiline_collection_that_could_be_broken_up?(node)

  false
end

# File 'lib/rubocop/cop/mixin/check_line_breakable.rb', line 105

def shift_elements_for_heredoc_arg(node, elements, index)
  return index unless node.type?(:call, :array)

  heredoc_index = elements.index { |arg| arg.respond_to?(:heredoc?) && arg.heredoc? }
  return index unless heredoc_index
  return nil if heredoc_index.zero?

  heredoc_index >= index ? index : heredoc_index + 1
end

# File 'lib/rubocop/cop/mixin/check_line_breakable.rb', line 116

def within_column_limit?(element, max, line)
  element && element.loc.column <= max && element.loc.line == line
end