class RuboCop::Cop::Lint::AmbiguousBlockAssociation

expect { do_something }.to change { object.attribute }
# good
@example IgnoredMethods: [change]
foo = ->(bar) { bar.baz }
# Lambda arguments require no disambiguation
# good
foo == bar { |b| b.baz }
# Operator methods require no disambiguation
# good
some_method(a) { |val| puts val }
# or (different meaning)
some_method(a { |val| puts val })
# With parentheses, there’s no ambiguity.
# good
@example
some_method a { |val| puts val }
# bad
@example
This cop can customize ignored methods with ‘IgnoredMethods`.
when param passed without parentheses.
Checks for ambiguous block association with method

def allowed_method?(node) 

def allowed_method?(node)
  node.assignment? || node.operator_method? || node.method?(:[]) ||
    ignored_method?(node.last_argument.send_node.source)
end

def ambiguous_block_association?(send_node) 

def ambiguous_block_association?(send_node)
  send_node.last_argument.block_type? && !send_node.last_argument.send_node.arguments?
end

def message(send_node) 

def message(send_node)
  block_param = send_node.last_argument
  format(MSG, param: block_param.source, method: block_param.send_node.source)
end

def on_send(node) 

def on_send(node)
  return unless node.arguments?
  return unless ambiguous_block_association?(node)
  return if node.parenthesized? || node.last_argument.lambda? || node.last_argument.proc? ||
            allowed_method?(node)
  message = message(node)
  add_offense(node, message: message)
end