rubocop-fourshark 0.8.3 → 0.8.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dbfa3d2a442ba57bc74ba0171563f0bcadb6f4460b769654963066462ca0b61f
-  data.tar.gz: '097de5b926870d292e63aa39f79aacc8342fe1909e34809bf9bb2f066c309a22'
+  metadata.gz: 0b6d31dcd7f72bdcf6f8cc44ca8315d8fd4388c54352be392fcf3b13160ed690
+  data.tar.gz: d399855a3ce34a564f243a741d34fc76c368cfeb2922f0c4f41f7d8020d0b89e
 SHA512:
-  metadata.gz: 36791e28a8f0c14fa70a4990d953207412390095deda3386d9aa4edb233447ef4576d645b4ea499414c5e3ecac44fe9e4d2845033d83d607453a303655d6e32a
-  data.tar.gz: 17bbb761062d3b28d03238fcf94df33bc29cc2f85ba839038469e7cf39d5c7bd0a6ced5402fac62d6660c7eb5d7c57e8971aa118f3ce1283412f7ddd366f223a
+  metadata.gz: cb034ef690e144cbb51853a88e987059f697a4c434317e66da75cc6aee3002074aa7501ed2642382582feb1f4de3906bf05fd1b005cf02fd4df36255bfa7ce65
+  data.tar.gz: ece127b0287704f962886699502445783f2ad3eac3354aa9628bd62dd30f3a97710ea37a98db39e173d16c202088747af1a8ca0acfa1d6e992221d7639d09864

data/CHANGELOG.md

@@ -1,3 +1,22 @@
+## [0.8.5] - 2026-08-07
+
+### Changed
+
+- Convention rationale in the README
+
+### Fixed
+
+- `Style/DisallowDelegate` — a macro aimed at the object's own class is no longer flagged
+
+## [0.8.4] - 2026-08-07
+
+### Fixed
+
+- `Style/DisallowDelegate` — own state reached through a call on it is no longer flagged
+- `Style/DisallowDelegate` — an argument rooted at the collaborator being forwarded to is flagged again
+- `Style/DisallowDelegate` — own state read through an explicit `self` is no longer flagged
+- `Style/DisallowDelegate` — a call reached through safe navigation counts as the call it is, on both the receiver and the argument side
+
 ## [0.8.3] - 2026-08-06
 
 ### Fixed

data/README.md

@@ -118,20 +118,18 @@ Where a 4Shark cop supersedes or contradicts a stock cop, `config/default.yml` t
 |---|---|
 | `FactoryBot/AssociationInFactory` | No associations declared inside a factory — they trigger cascading object creation and callbacks. Set the association manually in the spec. Scoped to `spec/factories`. |
 
-The full rationale behind each convention (the "why this is good 4Shark code") lives in the team's engineering docs; this README states the intent each cop enforces. One convention deviates from a safe Rails default and is worth spelling out — see below.
+This README states the intent each cop enforces. One convention deviates from a safe Rails default and is worth spelling out — see below.
 
 ### Why `belongs_to` is `optional: true` by default
 
-4Shark never exposes internal database IDs across its API and upload boundaries. Clients send their **own** identifiers; each external identifier is mapped to its internal record (a surrogate-key cross-reference), and that lookup is scoped to the client's account — so it confirms both that the record **exists** and that it **belongs to the caller**, in a single step.
-
-By the time an association is assigned, existence and ownership have already been verified — more strictly than Rails would. Rails' default `belongs_to` (`optional: false`) then adds an existence `SELECT` per record on top of that: redundant work, and at high API throughput a measurable per-request cost.
+Rails' default `belongs_to` (`optional: false`) validates that the associated record exists, which costs an existence `SELECT` per record. That validation is redundant in an application whose own request handling already establishes, before the association is assigned, that the record exists and is reachable by the caller — and under high throughput the redundant query is a measurable per-request cost.
 
 So the convention is:
 
 - `belongs_to` is always declared `optional: true` (enforced by `Rails/OptionalBelongsTo`), turning off Rails' automatic existence validation.
 - Presence is validated manually with `validates :x_id, presence: true` **where the business rule requires it** — case by case, not globally (which is why no cop enforces the presence side).
 
-A deliberate performance trade-off backed by the external-identifier mapping — not an omission.
+A deliberate performance trade-off — not an omission.
 
 ## Development
 
@@ -147,7 +145,7 @@ Each new cop ships with a spec (`expect_offense` / `expect_no_offenses`) and a `
 
 ## Releasing
 
-This project does **not** use HubFlow. Releases are cut from `main`: feature branches merge into `main` via PR, the version is bumped, a `vX.Y.Z` tag is created from `main`, and the gem is published to RubyGems. Consuming repos depend on the published version in their `Gemfile`.
+Releases are cut from `main`: feature branches merge into `main` via PR, the version is bumped, a `vX.Y.Z` tag is created from `main`, and the gem is published to RubyGems.
 
 ## License
 

data/config/default.yml

@@ -16,8 +16,8 @@ Layout/MultilineMethodCallIndentation:
 
 # Stock cop configured (not a 4Shark cop): name the rescued exception variable
 # `exception`. The cop's default is `e`, and a single-letter variable is banned by
-# the 4Shark naming convention — so the two disagree on every rescue in the
-# codebase. `PreferredName` is the option the cop ships to settle exactly that,
+# the 4Shark naming convention — so the two disagree wherever a rescue binds its
+# exception. `PreferredName` is the option the cop ships to settle exactly that,
 # and the cop autocorrects, so the rename is mechanical.
 Naming/RescuedExceptionsVariableName:
   PreferredName: exception

data/lib/rubocop/cop/rails/bidirectional_association.rb

@@ -141,7 +141,7 @@ module RuboCop
         #
         # Example:
         #   "UserAccount" → "user_account"
-        #   "PlanStatementAudit::Row" → "plan_statement_audit/row"
+        #   "InvoiceLineItem::Row" → "invoice_line_item/row"
         def camel_to_snake(name)
           return '' if name.nil?
 

data/lib/rubocop/cop/rspec/inverse_of_matcher.rb

@@ -127,7 +127,7 @@ module RuboCop
           match && match[1]
         end
 
-        # "UserAccount" → "user_account"; "Plan::Statement" → "plan/statement"
+        # "UserAccount" → "user_account"; "Order::LineItem" → "order/line_item"
         def camel_to_snake(name)
           name.gsub('::', '/')
             .gsub(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')

data/lib/rubocop/cop/style/disallow_delegate.rb

@@ -22,6 +22,13 @@ module RuboCop
       # method answers for a domain it owns, so it is not delegation and is not
       # flagged.
       #
+      # A macro aimed at `:class` reaches the same place and is exempt for the
+      # same reason. Remove Middle Man has nothing to prescribe here: there is no
+      # third object for the caller to navigate to, so the only alternatives are
+      # the macro and a hand-written body that says exactly what the macro says.
+      # Between those two the macro is the better spelling, and flagging it while
+      # exempting the body would push every author toward the longer one.
+      #
       # `each` in a class that includes or prepends `Enumerable` is the module's
       # required contract, not delegation. The class has no interface without it
       # — every method `Enumerable` provides is built on `each` — so the class is
@@ -37,36 +44,52 @@ module RuboCop
       # contributes something the caller would otherwise have to reach in and
       # take, and the result is a simpler API on the object that owns the data.
       #
-      # Three limits keep that exemption from swallowing the rule. The receiver
-      # must not itself be a chain — Remove Middle Man on a message chain IS the
-      # caller navigating, so composing own state does not excuse it. Own state
-      # is an instance variable or a receiverless call, so a method parameter
-      # forwarded through does not qualify and a setter stays flagged. And own
-      # state is read through a splat, a double splat, an array or a block pass,
-      # because the wrapper does not change whose state the argument carries.
+      # Own state is an instance variable, `self`, or a receiverless call,
+      # reached directly, through a wrapper, or through a call on it — `record`,
+      # `record.owner_id` and `[record.owner_id]` all carry the object's own
+      # data. A method PARAMETER does not: it arrives as an `lvar`, so a setter
+      # handing its argument to a collaborator stays flagged.
+      #
+      # Two limits keep the exemption from swallowing the rule.
+      #
+      # The receiver must not itself be a chain. Remove Middle Man on a message
+      # chain IS the caller navigating, so composing own state does not excuse
+      # it.
+      #
+      # An argument rooted at the collaborator being forwarded to does not earn
+      # the exemption. `author.name(author.locale)` hands the collaborator back
+      # its own data, which is the echo this rule forbids, not composition, so
+      # with no other argument to carry it the forward stays flagged. Rooted at
+      # the object's OWN state the argument may be a chain of any depth — the
+      # object still supplied what the collaborator needed, and how far it
+      # reached inside itself to build the value is its own business.
       #
-      # An argument derived from own state through another call —
-      # `variable.label(value.to_s)` — is still flagged. Recursing into an
-      # argument's receiver would also exempt `Lock.lock_key(company_id:
-      # user.company_id)`, which is delegation, so the conservative reading wins.
+      # A forward to a collaborator that passes NO argument is the one that
+      # republishes, and it is always flagged. That is the line — supplying data
+      # the collaborator needs is composition, echoing back what the collaborator
+      # already knows is delegation.
       #
       # @example
       #   # bad
-      #   delegate :name, to: :commission
+      #   delegate :name, to: :author
       #
       #   # bad — same promise, written by hand
       #   def name
-      #     commission.name
+      #     author.name
       #   end
       #
       #   # good — the caller navigates
-      #   statement.commission.name
+      #   post.author.name
       #
       #   # good — the object answers about itself, not for a collaborator
       #   def lock_key
-      #     self.class.lock_key(company_id: company_id)
+      #     self.class.lock_key(owner_id: owner_id)
       #   end
       #
+      #   # good — aimed at the object's own class, where there is no third
+      #   # object to navigate to
+      #   delegate :model, to: :class
+      #
       #   # good — `each` is the Enumerable contract this class implements
       #   class SearchResult
       #     include Enumerable
@@ -78,12 +101,22 @@ module RuboCop
       #
       #   # good — composes its own attribute, so the caller cannot just navigate
       #   def output
-      #     variable.output(value)
+      #     formatter.output(value)
+      #   end
+      #
+      #   # good — names an expression built from its own record; not a forward
+      #   def lock_key
+      #     Registry.lock_key(owner_id: record.owner_id)
       #   end
       #
       #   # bad — a chain does not stop being a chain because an argument rode along
       #   def starts_at
-      #     commission.plan.period.starts_at(calendar)
+      #     schedule.window.period.starts_at(calendar)
+      #   end
+      #
+      #   # bad — the argument is the collaborator's own data handed back to it
+      #   def name
+      #     author.name(author.locale)
       #   end
       #
       class DisallowDelegate < ::RuboCop::Cop::Base
@@ -102,8 +135,23 @@ module RuboCop
           (send nil? {:include :prepend} (const {nil? cbase} :Enumerable))
         PATTERN
 
+        # `delegate` names its target in a `to:` option, wherever that option
+        # sits among the forwarded method names.
+        # @!method to_option(node)
+        def_node_matcher :to_option, <<~PATTERN
+          (send nil? :delegate ... (hash <(pair (sym :to) $_) ...>))
+        PATTERN
+
+        # The Forwardable macros and `delegate_missing_to` take their target as
+        # the first argument. `DelegateClass` names none and never matches.
+        # @!method leading_target(node)
+        def_node_matcher :leading_target, <<~PATTERN
+          (send nil? {:delegate_missing_to :def_delegator :def_delegators} $_ ...)
+        PATTERN
+
         def on_send(node)
           return unless node.receiver.nil?
+          return if own_class_target?(node)
 
           add_offense(node, message: MACRO_MSG)
         end
@@ -118,6 +166,16 @@ module RuboCop
 
         private
 
+        # The target is written as a bare name, so a symbol and a string say the
+        # same thing and both are read as one.
+        def own_class_target?(node)
+          target = to_option(node) || leading_target(node)
+          return false if target.nil?
+          return false unless target.type?(:sym, :str)
+
+          target.value.to_sym == :class
+        end
+
         def forwards_own_message?(body, method_name)
           return false if body.nil?
           return false unless body.send_type?
@@ -154,32 +212,43 @@ module RuboCop
           mixes_in_enumerable?(body)
         end
 
-        def composes_own_state?(body)
-          return false if chained_receiver?(body.receiver)
-
-          body.arguments.any? { |argument| own_state?(argument) }
-        end
-
         # Remove Middle Man on a message chain IS the caller navigating, so an
         # argument riding along does not earn the exemption.
-        def chained_receiver?(receiver)
-          return false unless receiver.send_type?
+        def composes_own_state?(body)
+          return false if call_with_receiver?(body.receiver)
 
-          !receiver.receiver.nil?
+          body.arguments.any? { |argument| own_state?(argument, body.receiver) }
         end
 
         # A method parameter reaches the body as an `lvar`, so only an instance
-        # variable or a receiverless call counts as the object's own state. An
-        # anonymous block pass carries a nil child, hence the first guard.
-        def own_state?(argument)
-          return false if argument.nil?
+        # variable, `self`, or a receiverless call counts as the object's own
+        # state — read directly, through a wrapper, or through a call on it.
+        # Anything rooted at the collaborator is that collaborator's own data
+        # coming back, which is the echo the rule forbids. The first guard
+        # refuses anything that is not a node, which covers both the nil child
+        # an anonymous block pass carries and a wrapper whose children are raw
+        # Ruby values rather than nodes.
+        def own_state?(argument, collaborator)
+          return false unless argument.is_a?(::RuboCop::AST::Node)
+          return false if argument == collaborator
           return true if argument.ivar_type?
-          return true if argument.send_type? && argument.receiver.nil?
-          return argument.children.any? { |child| own_state?(child) } if wrapper?(argument)
+          return true if argument.self_type?
+          return own_state?(argument.receiver, collaborator) if call_with_receiver?(argument)
+          return true if argument.send_type?
+          return argument.children.any? { |child| own_state?(child, collaborator) } if wrapper?(argument)
 
           false
         end
 
+        # `call_type?` is the `send`/`csend` union, so safe navigation counts as
+        # the call it is — a `&.` link neither escapes the chain limit nor stops
+        # own state from being recognized.
+        def call_with_receiver?(node)
+          return false unless node.call_type?
+
+          !node.receiver.nil?
+        end
+
         def wrapper?(argument)
           ARGUMENT_WRAPPERS.include?(argument.type)
         end

data/lib/rubocop/fourshark/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module Fourshark
-    VERSION = '0.8.3'
+    VERSION = '0.8.5'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-fourshark
 version: !ruby/object:Gem::Version
-  version: 0.8.3
+  version: 0.8.5
 platform: ruby
 authors:
 - Paulo Ribeiro