class RuboCop::Cop::Style::ExplicitBlockArgument


end
9.times(&block)
def nine_times(&block)
# good
end
puts “dir is accessible as a parameter and pwd is set: #{dir}”
with_tmp_dir do |dir|
end
end
Dir.chdir(tmp_dir, &block)
Dir.mktmpdir do |tmp_dir|
def with_tmp_dir(&block)
# good
end
9.times { yield }
def nine_times
# bad
end
end
Dir.chdir(tmp_dir) { |dir| yield dir } # block just passes arguments
Dir.mktmpdir do |tmp_dir|
def with_tmp_dir
# bad
@example
block literal that just passes its arguments to another block.
This cop enforces the use of explicit block argument to avoid writing

def add_block_argument(node, corrector) 

def add_block_argument(node, corrector)
  if node.arguments?
    last_arg = node.arguments.last
    arg_range = range_with_surrounding_comma(last_arg.source_range, :right)
    replacement = ' &block'
    replacement = ",#{replacement}" unless arg_range.source.end_with?(',')
    corrector.insert_after(arg_range, replacement) unless last_arg.blockarg_type?
  elsif node.call_type?
    corrector.insert_after(node, '(&block)')
  else
    corrector.insert_after(node.loc.name, '(&block)')
  end
end

def block_body_range(block_node, send_node) 

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

def initialize(config = nil, options = nil) 

def initialize(config = nil, options = nil)
  super
  @def_nodes = Set.new
end

def on_yield(node) 

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(:def, :defs).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
    add_offense(block_node) do |corrector|
      corrector.remove(block_body_range(block_node, send_node))
      add_block_argument(send_node, corrector)
      add_block_argument(def_node, corrector) if @def_nodes.add?(def_node)
    end
  end
end

def yielding_arguments?(block_args, yield_args) 

def yielding_arguments?(block_args, yield_args)
  yield_args.zip(block_args).all? do |yield_arg, block_arg|
    block_arg && yield_arg.children.first == block_arg.children.first
  end
end