Class: RuboCop::Cop::Style::ExplicitBlockArgument

# File 'lib/rubocop/cop/style/explicit_block_argument.rb', line 91

def argument_forwarding?(def_node)
  def_node.arguments.any?(&:forward_arg_type?)
end

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

def block_body_range(block_node, send_node)
  range_between(send_node.source_range.end_pos, block_node.loc.end.end_pos)
end

# File 'lib/rubocop/cop/style/explicit_block_argument.rb', line 109

def block_name_taken?(def_node, block_name)
  return false if def_node.block_argument?

  def_node.each_descendant(:argument, :lvasgn).any? { |node| node.name.to_s == block_name }
end

# File 'lib/rubocop/cop/style/explicit_block_argument.rb', line 182

def build_new_arguments_for_zsuper(node)
  def_node = node.each_ancestor(:any_def).first
  def_node.arguments.filter_map do |arg|
    case arg.type
    when :arg, :optarg then arg.name.to_s
    when :kwarg, :kwoptarg then "#{arg.name}: #{arg.name}"
    when :restarg, :kwrestarg then arg.source
    end
  end
end

# File 'lib/rubocop/cop/style/explicit_block_argument.rb', line 154

def call_like?(node)
  node.type?(:call, :zsuper, :super)
end

# File 'lib/rubocop/cop/style/explicit_block_argument.rb', line 103

def can_add_block_argument?(def_node, send_node, block_name)
  return false if block_name_taken?(def_node, block_name)

  !send_node.zsuper_type? || zsuper_arguments_forwardable?(def_node)
end

# File 'lib/rubocop/cop/style/explicit_block_argument.rb', line 166

def correct_call_node(node, corrector, block_name)
  new_arguments = if node.zsuper_type?
                    args = build_new_arguments_for_zsuper(node) << "&#{block_name}"
                    args.join(', ')
                  else
                    "&#{block_name}"
                  end
  corrector.insert_after(node, "(#{new_arguments})")
  return unless node.parenthesized?

  args_begin = Util.args_begin(node)
  args_end = Util.args_end(node)
  range = range_between(args_begin.begin_pos, args_end.end_pos)
  corrector.remove(range)
end

# File 'lib/rubocop/cop/style/explicit_block_argument.rb', line 149

def empty_arguments?(node)
  # Is there an arguments node with only parentheses?
  node.arguments.is_a?(RuboCop::AST::Node) && node.arguments.loc.begin
end

# File 'lib/rubocop/cop/style/explicit_block_argument.rb', line 95

def extract_block_name(def_node)
  if def_node.block_argument?
    def_node.last_argument.name
  else
    'block'
  end
end

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

def insert_argument(node, corrector, block_name)
  last_arg = node.last_argument
  arg_range = range_with_surrounding_comma(last_arg.source_range, :right)
  replacement = " &#{block_name}"
  replacement = ",#{replacement}" unless arg_range.source.end_with?(',')
  corrector.insert_after(arg_range, replacement) unless last_arg.blockarg_type?
end

# File 'lib/rubocop/cop/style/explicit_block_argument.rb', line 62

def on_yield(node)
  block_node = node.parent

  yielding_block?(block_node) do |send_node, block_args, yield_args|
    return unless yielding_arguments?(block_args, yield_args)

    def_node = block_node.each_ancestor(:any_def).first
    # if `yield` is being called outside of a method context, ignore
    # this is not a valid ruby pattern, but can happen in haml or erb,
    # so this can cause crashes in haml_lint
    return unless def_node
    return if argument_forwarding?(def_node)

    block_name = extract_block_name(def_node)

    add_offense(block_node) do |corrector|
      next unless can_add_block_argument?(def_node, send_node, block_name)

      corrector.remove(block_body_range(block_node, send_node))

      add_block_argument(send_node, corrector, block_name)
      add_block_argument(def_node, corrector, block_name) if @def_nodes.add?(def_node)
    end
  end
end

# File 'lib/rubocop/cop/style/explicit_block_argument.rb', line 124

def yielding_arguments?(block_args, yield_args)
  yield_args = yield_args.dup.fill(
    nil,
    yield_args.length, block_args.length - yield_args.length
  )

  yield_args.zip(block_args).all? do |yield_arg, block_arg|
    next false unless yield_arg && block_arg

    block_arg && yield_arg.children.first == block_arg.children.first
  end
end

# File 'lib/rubocop/cop/style/explicit_block_argument.rb', line 49

def_node_matcher :yielding_block?, <<~PATTERN
  (block $_ (args $...) (yield $...))
PATTERN

# File 'lib/rubocop/cop/style/explicit_block_argument.rb', line 117

def zsuper_arguments_forwardable?(def_node)
  def_node.arguments.none? do |arg|
    arg.mlhs_type? ||
      (arg.type?(:restarg, :kwrestarg) && !arg.name && target_ruby_version < 3.2)
  end
end