rubocop-fourshark 0.8.4 → 0.8.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4cdbe5b265ec54b100ac589171adad9038c99fee37dac3008cb56bba16e1a002
-  data.tar.gz: 8dfc81f74e7af24ad5518bf67ab735e9d75557cf2db03d4401ee46ba1c471f61
+  metadata.gz: 1bdc31121f34ef40cca25af1bc804caafecc8b8f58fd2996457cd01d82b98502
+  data.tar.gz: 26bbc30201fe22eef3477a20ce1eaf7016ee020a1ed93f53134429654da4a11d
 SHA512:
-  metadata.gz: 684f7b5b0f1064064eb545240a7f2f290207c9d0e7f759363e26d2607b2fe0d48fda173e8e48827769fa625f3eefb5ed6591ffdbdc770bf29f63bebbe156c50f
-  data.tar.gz: 19a91ad805511e8a3f19d903d18eeb007c5a2c1d4e2329733336e12d6b041cad998466f0fe080556830fbf8a90be6736f568b33eaf1d803b3e2e4c94b0dd8555
+  metadata.gz: ce23cde85c85d07932802b8bc89aa7c48f047cd274f59ff7d8c32b5e5e490e4bc46f118bb0e6216796cc774f9dc7c687bc464d33ac59361885a8bab2dd865edb
+  data.tar.gz: 616ed09b7f636b5cc4931894d86063a62b9e7357cf35802dee67f6d4a2c77ab8523131519ced29806cb6e1bd862ce8771931401411b3b1e0d59ebe6fabc5b575

data/CHANGELOG.md

@@ -1,3 +1,19 @@
+## [0.8.6] - 2026-08-08
+
+### Fixed
+
+- `Style/DisallowDelegate` — a chained receiver carrying an own state argument is no longer flagged
+
+## [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

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/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
@@ -79,6 +86,10 @@ module RuboCop
       #     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
@@ -124,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
@@ -140,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?
@@ -176,11 +212,14 @@ module RuboCop
           mixes_in_enumerable?(body)
         end
 
-        # Remove Middle Man on a message chain IS the caller navigating, so an
-        # argument riding along does not earn the exemption.
+        # A body that passes the object's own state is composing, not forwarding:
+        # it collapses `owner.collaborator.message(owner.state)` into
+        # `owner.message`, so the method hides the passing of a parameter the
+        # object itself holds. How far the collaborator sits is not part of that
+        # judgement — depth changes the path to the collaborator, never who the
+        # answer is about. A body that passes nothing, or passes a parameter the
+        # caller handed in, composes nothing and stays an offense at any depth.
         def composes_own_state?(body)
-          return false if call_with_receiver?(body.receiver)
-
           body.arguments.any? { |argument| own_state?(argument, body.receiver) }
         end
 

data/lib/rubocop/fourshark/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module Fourshark
-    VERSION = '0.8.4'
+    VERSION = '0.8.6'
   end
 end

metadata

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