Class: RuboCop::Cop::DevDoc::Style::PreferPublicSend

Inherits:
Base
  • Object
show all
Defined in:
lib/rubocop/cop/dev_doc/style/prefer_public_send.rb

Overview

Prefer ‘public_send` over `send` when dispatching dynamically.

## Rationale ‘public_send` respects Ruby’s method visibility. When the dispatched name should resolve to a public API method (the common case for generic validators, form helpers, attribute readers, etc.), using ‘public_send`:

  • **Surfaces typos / misconfig immediately.** A name that drifts to a private internal raises ‘NoMethodError` instead of silently invoking it.

  • **Future-proofs the call site.** If the target method later moves to private (refactor, contract narrowing), ‘public_send` raises on the next run; `send` keeps silently working — potentially masking a real bug.

  • **Documents intent.** A reader of ‘public_send` knows the author meant a public-API call. `send` leaves it ambiguous whether private access was wanted.

## Relationship to AvoidSend ‘DevDoc/Style/AvoidSend` flags dynamic dispatch (both `send` and `public_send`) as risky. This cop is orthogonal: it flags `send` specifically, including the cases AvoidSend exempts (literal-symbol args, prefix-string args). The friction asymmetry is intentional —`send` is the deeper exception, so it costs an extra disable:

obj.public_send(method_name)        # AvoidSend: 1 disable
obj.public_send(:foo)               # clean
obj.send(method_name)               # AvoidSend + this cop: 2 disables
obj.send(:foo)                      # this cop only: 1 disable

## When ‘send` IS the right choice Reach for `send` only when you have an articulable reason to bypass visibility — and leave a comment so the next reader knows it’s deliberate:

  • Tests calling a private helper:

    # rubocop:disable DevDoc/Style/PreferPublicSend -- unit-testing private method
assert_equal 5, calculator.send(:internal_carry)
# rubocop:enable DevDoc/Style/PreferPublicSend

  • **Framework / introspection** code that intentionally calls private callbacks (e.g. ‘record.send(:_run_save_callbacks)`).

## Receiver-less ‘send` is exempt `send(:foo)` (no explicit receiver) calls a method on `self` and is commonly used inside a class to dispatch to its own private methods. Rewriting to `public_send` would either change semantics (the method must become public) or fail. Same exemption as `AvoidSend`.

Examples:

# bad — prefer public_send
record.send(attribute)
instance.send(:public_method)
obj.send("export_#{x}")

# good — visibility-respecting dispatch
record.public_send(attribute)
instance.public_send(:public_method)
obj.public_send("export_#{x}")

# good — receiver-less send (calling self's own method)
send(:internal_helper)

Constant Summary collapse

MSG = 
'Prefer `public_send` over `send` — it respects method ' \
'visibility, surfacing typos/misconfig that would otherwise ' \
'silently invoke a private method. Disable with a reason ' \
'when bypassing visibility is intentional.'.freeze
RESTRICT_ON_SEND = 
%i[send].freeze

Instance Method Summary collapse

Instance Method Details

#on_send(node) ⇒ Object 



77
78
79
80
81
 
# File 'lib/rubocop/cop/dev_doc/style/prefer_public_send.rb', line 77

def on_send(node)
  return if node.receiver.nil?

  add_offense(node.loc.selector)
end