rubocop-fourshark 0.8.2 → 0.8.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9358c7dd0bcd6717781203b1f4ccdd6e282851da1e52838db50acf058ce39414
-  data.tar.gz: f219f75c7fdaea1dff73f43ed9a1c16478e97b44f45f5242d9f21044e57cd19c
+  metadata.gz: 4cdbe5b265ec54b100ac589171adad9038c99fee37dac3008cb56bba16e1a002
+  data.tar.gz: 8dfc81f74e7af24ad5518bf67ab735e9d75557cf2db03d4401ee46ba1c471f61
 SHA512:
-  metadata.gz: edd536903d83b3516f576bdcf318847c5914a9b747d52203f2153a2dc2eaf5af783a7fc9d16d1f730674d51a8bde815b576a29f64619655824a227551a2979b1
-  data.tar.gz: c063cd068bace0cdccf5e0948e94c40088b0160fc023f14ee315f4177374134bea62eedc49d42655a505579afc0d43a9248d1f2d4a6231344d624154e5b95afe
+  metadata.gz: 684f7b5b0f1064064eb545240a7f2f290207c9d0e7f759363e26d2607b2fe0d48fda173e8e48827769fa625f3eefb5ed6591ffdbdc770bf29f63bebbe156c50f
+  data.tar.gz: 19a91ad805511e8a3f19d903d18eeb007c5a2c1d4e2329733336e12d6b041cad998466f0fe080556830fbf8a90be6736f568b33eaf1d803b3e2e4c94b0dd8555

data/CHANGELOG.md

@@ -1,3 +1,21 @@
+## [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
+
+- `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

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/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,36 +22,61 @@ module RuboCop
       # method answers for a domain it owns, so it is not delegation and is not
       # flagged.
       #
-      # `each` in a class that includes `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
+      # `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.
+      # 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 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. Own state is an instance variable or a
-      # receiverless call — a method parameter forwarded through is not, so a
-      # setter passing its argument along stays flagged.
+      # 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.
+      #
+      # 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.
+      #
+      # 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 — `each` is the Enumerable contract this class implements
@@ -65,7 +90,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
+      #     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
@@ -74,17 +114,22 @@ module RuboCop
 
         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?
 
           add_offense(node, message: MACRO_MSG)
         end
 
-        # @!method includes_enumerable?(node)
-        def_node_matcher :includes_enumerable?, <<~PATTERN
-          (send nil? :include (const {nil? cbase} :Enumerable))
-        PATTERN
-
         def on_def(node)
           return unless forwards_own_message?(node.body, node.method_name)
           return if enumerable_contract?(node)
@@ -112,35 +157,65 @@ 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).first
+          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| includes_enumerable?(child) } if body.begin_type?
+          return body.children.any? { |child| mixes_in_enumerable?(child) } if body.begin_type?
 
-          includes_enumerable?(body)
+          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.
         def composes_own_state?(body)
-          body.arguments.any? { |argument| own_state?(argument) }
+          return false if call_with_receiver?(body.receiver)
+
+          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.
-        def own_state?(argument)
+        # 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.values.any? { |value| own_state?(value) } if argument.hash_type?
+          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
       end
     end
   end

data/lib/rubocop/fourshark/version.rb

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

metadata

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