class RuboCop::Cop::Style::TrailingCommaInBlockArgs

end
foo + bar
add do
# good
end
foo
add do |foo,|
# good
end
foo + bar
add do |foo, bar|
# good
end
foo + bar
add do |foo, bar,|
# bad
add { foo }
# good
add { |foo,| foo }
# good
add { |foo, bar| foo + bar }
# good
add { |foo, bar,| foo + bar }
# bad
@example
require a trailing comma.
that comma to be present. Blocks with more than one argument never
required. Blocks with only one argument and a trailing comma require
This cop checks whether trailing commas in block arguments are

def arg_count(node) 

def arg_count(node)
  node.arguments.each_descendant(:arg, :optarg, :kwoptarg).to_a.size
end

def argument_tokens(node) 

def argument_tokens(node)
  tokens = processed_source.tokens_within(node)
  pipes = tokens.select { |token| token.type == :tPIPE }
  begin_pos, end_pos = pipes.map do |pipe|
    tokens.index(pipe)
  end
  tokens[begin_pos + 1..end_pos - 1]
end

def last_comma(node) 

def last_comma(node)
  argument_tokens(node).last
end

def on_block(node) 

def on_block(node)
  # lambda literal (`->`) never has block arguments.
  return if node.send_node.lambda_literal?
  return unless useless_trailing_comma?(node)
  last_comma_pos = last_comma(node).pos
  add_offense(last_comma_pos) do |corrector|
    corrector.replace(last_comma_pos, '')
  end
end

def trailing_comma?(node) 

def trailing_comma?(node)
  argument_tokens(node).last.comma?
end

def useless_trailing_comma?(node) 

def useless_trailing_comma?(node)
  arg_count(node) > 1 && trailing_comma?(node)
end