class RuboCop::Cop::Rails::RedundantReceiverInWithOptions

end
end
merger.invoke(another_receiver)
with_another_method do |another_receiver|
merger.invoke
with_options options: false do |merger|
# receiver.
# cannot be evaluated. Thus, it is ok to include the explicit
# When ‘with_options` includes a block, all scoping scenarios
# ok
end
client.invoke(merger.something, something)
with_options options: false do |merger|
client = Client.new
# good
end
invoke(something)
with_options options: false do
# good
end
merger.invoke(merger.something)
with_options options: false do |merger|
# bad
@example
end
end
has_many :expenses
has_many :invoices
has_many :products
has_many :customers
with_options dependent: :destroy do
class Account < ApplicationRecord
# good
end
end
assoc.has_many :expenses
assoc.has_many :invoices
assoc.has_many :products
assoc.has_many :customers
with_options dependent: :destroy do |assoc|
class Account < ApplicationRecord
# bad
@example
Receiver is implicit from Rails 4.2 or higher.
This cop checks for redundant receiver in `with_options`.

def autocorrect(node) 

def autocorrect(node)
  lambda do |corrector|
    corrector.remove(node.receiver.source_range)
    corrector.remove(node.loc.dot)
    corrector.remove(block_argument_range(node))
  end
end

def block_argument_range(node) 

def block_argument_range(node)
  block_node = node.each_ancestor(:block).first
  block_argument = block_node.children[1].source_range
  range_between(
    search_begin_pos_of_space_before_block_argument(
      block_argument.begin_pos
    ),
    block_argument.end_pos
  )
end

def on_block(node) 

def on_block(node)
  with_options?(node) do |arg, body|
    return unless all_block_nodes_in(body).count.zero?
    send_nodes = all_send_nodes_in(body)
    if send_nodes.all? { |n| same_value?(arg, n.receiver) }
      send_nodes.each do |send_node|
        receiver = send_node.receiver
        add_offense(send_node, location: receiver.source_range)
      end
    end
  end
end

def same_value?(arg_node, recv_node) 

def same_value?(arg_node, recv_node)
  recv_node && recv_node.children[0] == arg_node.children[0]
end

def search_begin_pos_of_space_before_block_argument(begin_pos) 

def search_begin_pos_of_space_before_block_argument(begin_pos)
  position = begin_pos - 1
  if processed_source.raw_source[position] == ' '
    search_begin_pos_of_space_before_block_argument(position)
  else
    begin_pos
  end
end