rubocop-fourshark 0.8.1 → 0.8.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 31d77a73abb724b68a4c2d187cc780899067d2ef82564e50bcce0d6b09dbffeb
-  data.tar.gz: fd2eda214bf001b848e18be1f68df32463d70272be3f7ce999ac7cb3b1be8f8f
+  metadata.gz: dbfa3d2a442ba57bc74ba0171563f0bcadb6f4460b769654963066462ca0b61f
+  data.tar.gz: '097de5b926870d292e63aa39f79aacc8342fe1909e34809bf9bb2f066c309a22'
 SHA512:
-  metadata.gz: 61aabc197c8224de85d39c9f150cb0fb1b73916a8882fd35cb3241b4b5ca330eb44f4098a12eff4fc934b918ea2ccf75a81bd150c1eac96193678ef620ae734c
-  data.tar.gz: b0b7426b78afa3a99f028eb84b4dd78479c153d219997d55611e7e1ab3544ddfe99ead0b323306c24220c9806715ddf413b1ace76bdb19df8ccad9bb43391562
+  metadata.gz: 36791e28a8f0c14fa70a4990d953207412390095deda3386d9aa4edb233447ef4576d645b4ea499414c5e3ecac44fe9e4d2845033d83d607453a303655d6e32a
+  data.tar.gz: 17bbb761062d3b28d03238fcf94df33bc29cc2f85ba839038469e7cf39d5c7bd0a6ced5402fac62d6660c7eb5d7c57e8971aa118f3ce1283412f7ddd366f223a

data/CHANGELOG.md

@@ -1,3 +1,19 @@
+## [0.8.3] - 2026-08-06
+
+### Fixed
+
+- `Style/DisallowDelegate` — own state passed through a splat, a double splat, an array or a block is no longer flagged
+- `Style/DisallowDelegate` — `each` in a class prepending `Enumerable` is no longer flagged
+- `Style/DisallowDelegate` — a chained receiver carrying an own state argument is flagged again
+- `Style/DisallowDelegate` — `each` in a singleton class is flagged again
+
+## [0.8.2] - 2026-08-06
+
+### Fixed
+
+- `Style/DisallowDelegate` — `each` in a class including `Enumerable` is no longer flagged
+- `Style/DisallowDelegate` — a method composing its own state into the call is no longer flagged
+
 ## [0.8.1] - 2026-08-06
 
 ### Fixed

data/README.md

@@ -76,7 +76,7 @@ Where a 4Shark cop supersedes or contradicts a stock cop, `config/default.yml` t
 
 | Cop | Intent |
 |---|---|
-| `Style/DisallowDelegate` | Flags automatic delegation (`delegate`, `delegate_missing_to`, `def_delegator(s)`, `DelegateClass`). A `delegate` line is a macro call, not a definition, so `grep 'def foo'` and jump-to-definition find nothing — the community name for the smell is Fowler's Middle Man. Write the method, or let the caller ask the object that knows. |
+| `Style/DisallowDelegate` | Flags automatic delegation (`delegate`, `delegate_missing_to`, `def_delegator(s)`, `DelegateClass`) and a hand-written method whose whole body forwards its own name to a collaborator. A `delegate` line is a macro call, not a definition, so `grep 'def foo'` and jump-to-definition find nothing — the community name for the smell is Fowler's Middle Man. Not flagged: a method answering through its own `self.class`, `each` in a class that includes or prepends `Enumerable`, and a body composing the object's own state into a call on a direct collaborator. Let the caller ask the object that knows. |
 | `Style/DisallowSafeNavigation` | Flags safe navigation (`&.`). 4Shark rejects it — a `&.` chain silently swallows a `nil` that usually signals a real bug. Use an explicit conditional so the `nil` case is handled on purpose. |
 | `Style/DisallowTernary` | Flags the ternary conditional (`cond ? a : b`). `?` and `:` are punctuation that already mean other things in Ruby (`valid?`, `:symbol`), and the ternary hides a branch inside an expression where skimming misses it. Use an explicit `if`/`else`. |
 | `Style/DisallowTry` | Flags `try` / `try!`. Same rationale — it hides the `nil`/missing-method case instead of handling it explicitly. |

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

@@ -22,6 +22,34 @@ module RuboCop
       # method answers for a domain it owns, so it is not delegation and is not
       # flagged.
       #
+      # `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
+      # implementing its own interface rather than answering for a collaborator.
+      # It is not flagged. Any other method in such a class still is, and so is
+      # `each` in a singleton class: an instance-side mixin obliges the instance,
+      # never the singleton.
+      #
+      # A body that passes the object's own state as an argument to a DIRECT
+      # collaborator is not a pass-through. Middle Man is a method that
+      # republishes a collaborator's answer verbatim, which the caller could
+      # reach by navigating; a method that supplies its own attributes
+      # 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.
+      #
+      # 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.
+      #
       # @example
       #   # bad
       #   delegate :name, to: :commission
@@ -39,12 +67,41 @@ module RuboCop
       #     self.class.lock_key(company_id: company_id)
       #   end
       #
+      #   # good — `each` is the Enumerable contract this class implements
+      #   class SearchResult
+      #     include Enumerable
+      #
+      #     def each(&)
+      #       results.each(&)
+      #     end
+      #   end
+      #
+      #   # good — composes its own attribute, so the caller cannot just navigate
+      #   def output
+      #     variable.output(value)
+      #   end
+      #
+      #   # bad — a chain does not stop being a chain because an argument rode along
+      #   def starts_at
+      #     commission.plan.period.starts_at(calendar)
+      #   end
+      #
       class DisallowDelegate < ::RuboCop::Cop::Base
         MACRO_MSG = 'Do not use automatic delegation. Delete the forwarder and let the caller navigate.'
         FORWARDER_MSG = 'Do not forward a collaborator\'s message. Delete the forwarder and let the caller navigate.'
 
         RESTRICT_ON_SEND = %i[delegate delegate_missing_to def_delegator def_delegators DelegateClass].freeze
 
+        # An argument reaches the body wrapped in one of these when the call site
+        # spreads or blocks it, and the wrapper says nothing about whose state it
+        # carries.
+        ARGUMENT_WRAPPERS = %i[hash pair array splat kwsplat block_pass].freeze
+
+        # @!method mixes_in_enumerable?(node)
+        def_node_matcher :mixes_in_enumerable?, <<~PATTERN
+          (send nil? {:include :prepend} (const {nil? cbase} :Enumerable))
+        PATTERN
+
         def on_send(node)
           return unless node.receiver.nil?
 
@@ -53,6 +110,8 @@ module RuboCop
 
         def on_def(node)
           return unless forwards_own_message?(node.body, node.method_name)
+          return if enumerable_contract?(node)
+          return if composes_own_state?(node.body)
 
           add_offense(node.loc.name, message: FORWARDER_MSG)
         end
@@ -75,6 +134,55 @@ module RuboCop
 
           receiver.receiver.self_type?
         end
+
+        # The nearest enclosing scope decides, and a singleton class never
+        # inherits the instance side's mixin.
+        def enumerable_contract?(node)
+          return false unless node.method?(:each)
+
+          enclosing = node.each_ancestor(:class, :module, :sclass).first
+          return false if enclosing.nil?
+          return false if enclosing.sclass_type?
+
+          enumerable_body?(enclosing.body)
+        end
+
+        def enumerable_body?(body)
+          return false if body.nil?
+          return body.children.any? { |child| mixes_in_enumerable?(child) } if body.begin_type?
+
+          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?
+
+          !receiver.receiver.nil?
+        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?
+          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)
+
+          false
+        end
+
+        def wrapper?(argument)
+          ARGUMENT_WRAPPERS.include?(argument.type)
+        end
       end
     end
   end

data/lib/rubocop/fourshark/version.rb

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

metadata

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