rubocop-callbacksystems 0.1.0

data/lib/rubocop/cop/callbacksystems/prefer_delegate.rb

@@ -0,0 +1,242 @@
+# Detects methods that only delegate to a same-named method on a delegatable
+# receiver (`def size; node.size; end`). The `delegate` macro says it
+# declaratively, whether the receiver is a constant, a call on self or a chain
+# of them.
+#
+# Rails/Delegate covers the public single-hop case, so what is left here is the
+# private one (the macro defines public methods unless told otherwise), the
+# nested one, where a chain of calls becomes a dotted target that Rails/Delegate
+# does not recognize, and the one that forwards a block, which it does not read
+# because it matches positional arguments only. The macro forwards the block on
+# its own.
+#
+# A private method taking no parameters reads its arguments from its own state,
+# so delegating it changes arity and every call site has to start passing them,
+# which is why the offense is only reported. The same public method is left
+# alone, since its callers are not all in view and a command line is one of
+# them. So is a method that combines its own parameters with data of its own,
+# a partial application that every call site would have to repeat.
+#
+# The autocorrection folds the method into an existing same-target `delegate`
+# when one is present, keeping them on one line, and otherwise writes a fresh
+# macro where the section already declares things, below its mixins when it
+# declares nothing yet.
+#
+# @example
+#   # bad - hand-written private delegation
+#   private
+#     delegate :name, to: :node, private: true
+#
+#     def size
+#       node.size
+#     end
+#
+#   # good - folded into the existing delegate
+#   private
+#     delegate :name, :size, to: :node, private: true
+#
+#   # bad - hand-written nested delegation
+#   def database_names
+#     config.postgres.database_names
+#   end
+#
+#   # good - the chain becomes a dotted target
+#   delegate :database_names, to: "config.postgres"
+#
+#   # bad - the method exists only to hand the block over
+#   def each(&block)
+#     blocks.each(&block)
+#   end
+#
+#   # good
+#   delegate :each, to: :blocks
+#
+#   # bad - callers must pass the argument: subunit_factor(options[:currency])
+#   private
+#     def subunit_factor
+#       Currency.subunit_factor(options[:currency])
+#     end
+#
+#   # good - delegating would make every call site repeat the slot names
+#   def parse(raw)
+#     WALPressure.parse(raw, slot_names: SLOTS)
+#   end
+#
+class RuboCop::Cop::Callbacksystems::PreferDelegate < RuboCop::Cop::Callbacksystems::Base
+  extend RuboCop::Cop::AutoCorrector
+
+  def on_new_investigation
+    @source_comments = RuboCop::Callbacksystems::Source::Comments.for(processed_source)
+  end
+
+  def on_def(node)
+    report ManualDelegation.new(node, @source_comments)
+  end
+
+  private
+    class ManualDelegation
+      include RuboCop::Callbacksystems::Helpers
+
+      MESSAGE = "Use `%<macro>s` instead of a hand-written delegation%<arguments_note>s."
+
+      def initialize(node, source_comments)
+        @node = node
+        @source_comments = source_comments
+      end
+
+      def offense
+        if declarable?
+          RuboCop::Callbacksystems::Offense.new(node, message, correcting: correctable?) { correct(it) }
+        end
+      end
+
+      private
+        attr_reader :node, :source_comments
+        delegate :body, to: :node, private: true
+
+        def declarable?
+          declarable_delegation? && (forwards_own_parameters? ? beyond_rails_delegate? : binds_own_state?)
+        end
+
+        # `delegate` declares public and private methods, so a protected one has no macro to stand in its place.
+        def declarable_delegation?
+          body&.send_type? && body.method?(node.method_name) && target.delegable? &&
+            !protected_method?(node) && declared_in_class_body?
+        end
+
+        def target
+          @target ||= RuboCop::Callbacksystems::Methods::DelegationTarget.new(body.receiver)
+        end
+
+        # A macro stands where the definition stands, so one nested in a conditional or a block has no place to give it.
+        def declared_in_class_body?
+          statements_in(enclosing_definition_of(node)&.body).any? { it.equal?(statement) }
+        end
+
+        def statement
+          @statement ||= visibility_applied_to(node.parent, node) ? node.parent : node
+        end
+
+        def forwards_own_parameters?
+          body.arguments.map(&:source) == node.arguments.map(&:source)
+        end
+
+        def beyond_rails_delegate?
+          private_method?(node) || target.nested? || forwards_block?
+        end
+
+        def forwards_block?
+          node.arguments.any?(&:blockarg_type?)
+        end
+
+        def binds_own_state?
+          node.arguments.empty? && private_method?(node)
+        end
+
+        def message
+          format MESSAGE,
+            macro: conversion.macro_source,
+            arguments_note: forwards_own_parameters? ? "" : " and pass the arguments at the call sites"
+        end
+
+        def conversion
+          @conversion ||= Conversion.new(node, target, source_comments)
+        end
+
+        def correctable?
+          forwards_own_parameters? && conversion.placeable?
+        end
+
+        def correct(corrector)
+          conversion.apply(corrector)
+        end
+    end
+
+    class Conversion
+      include RuboCop::Callbacksystems::Helpers
+
+      def initialize(node, target, source_comments)
+        @node = node
+        @target = target
+        @source_comments = source_comments
+      end
+
+      def placeable?
+        (sibling_delegate.present? || anchor.present?) && !comments_attached_to_definition?
+      end
+
+      def apply(corrector)
+        write(corrector)
+        corrector.remove(statement_removal_range_for(node))
+      end
+
+      def macro_source
+        "delegate :#{node.method_name}, to: #{target.source}#{private_option}"
+      end
+
+      private
+        attr_reader :node, :target, :source_comments
+
+        def sibling_delegate
+          @sibling_delegate ||= container_macros.find { sibling?(it) }
+        end
+
+        def container_macros
+          container_statements.map { RuboCop::Callbacksystems::Methods::DelegateMacro.new(it) }
+        end
+
+        def container_statements
+          statements_in(enclosing_definition_of(node).body)
+        end
+
+        def sibling?(macro)
+          macro.macro? && macro.target == target.name && macro.plain?(private: private_delegation?)
+        end
+
+        def private_delegation?
+          private_method?(node)
+        end
+
+        def anchor
+          @anchor ||= declarations.last || private_modifier || mixins.last
+        end
+
+        def declarations
+          preceding_statements.select { declaration_macro?(it) }
+        end
+
+        def preceding_statements
+          container_statements.take_while { it != node }
+        end
+
+        def private_modifier
+          preceding_statements.find { visibility_modifier_of(it) == :private }
+        end
+
+        def mixins
+          preceding_statements.select { mixin_macro?(it) }
+        end
+
+        def comments_attached_to_definition?
+          source_comments.any_on_lines?(node.first_line..node.last_line) ||
+            source_comments.own_line_comment_on(node.first_line - 1).present?
+        end
+
+        def write(corrector)
+          if sibling_delegate
+            corrector.insert_before(sibling_delegate.first_option, ":#{node.method_name}, ")
+          else
+            corrector.insert_after(anchor, "#{separator}#{indentation_of(node)}#{macro_source}")
+          end
+        end
+
+        # After a mixin the macro keeps the blank line that belongs there, and elsewhere it joins the line above.
+        def separator
+          mixins.any? { it.equal?(anchor) } ? "\n\n" : "\n"
+        end
+
+        def private_option
+          ", private: true" if private_delegation?
+        end
+    end
+end

data/lib/rubocop/cop/callbacksystems/prefer_delegate_over_instance_variable_assignment.rb

@@ -0,0 +1,175 @@
+# Detects `@x = receiver.x` style assignments inside `initialize` that mirror
+# a method call. These eager assignments are better expressed as `delegate`
+# declarations: they read declaratively, avoid duplicating the name, and stop
+# inviting bigger refactors (the very anti-pattern flagged by
+# `NoRedundantWrapperMethod` and `NoAnemicDelegation`).
+#
+# Only assignments where the variable name matches the called method name are
+# flagged, and only when the receiver itself is also assigned to a variable of
+# the same name in the same `initialize` (so the receiver is reachable via
+# `attr_reader` from the surrounding class).
+#
+# @example
+#   # bad - eager assignment that mirrors `node.body`
+#   def initialize(node)
+#     @node = node
+#     @body = node.body
+#   end
+#
+#   private
+#     attr_reader :node, :body
+#
+#   # good - declare the delegation
+#   def initialize(node)
+#     @node = node
+#   end
+#
+#   private
+#     attr_reader :node
+#     delegate :body, to: :node, private: true
+#
+#   # ok - the assignment transforms the value (different name from the call)
+#   def initialize(name)
+#     @name = name
+#     @name_parts = name.split("_")
+#   end
+#
+class RuboCop::Cop::Callbacksystems::PreferDelegateOverInstanceVariableAssignment < RuboCop::Cop::Callbacksystems::Base
+  def on_ivasgn(node)
+    report Assignment.new(node)
+  end
+
+  private
+    class Assignment
+      extend RuboCop::AST::NodePattern::Macros
+      include RuboCop::Callbacksystems::Helpers
+
+      MESSAGE = "Replace `@%<name>s = %<receiver>s.%<name>s` with `delegate :%<name>s, to: :%<receiver>s`."
+
+      # @!method mirroring_assignment?(node)
+      def_node_matcher :mirroring_assignment?, <<~PATTERN
+        (ivasgn $_ (send (lvar $_) $_))
+      PATTERN
+
+      # @!method receiver_assignment?(node, variable_name, lvar_name)
+      def_node_matcher :receiver_assignment?, <<~PATTERN
+        (ivasgn %1 (lvar %2))
+      PATTERN
+
+      def initialize(node)
+        @node = node
+      end
+
+      def offense
+        RuboCop::Callbacksystems::Offense.new(node, message) if mirroring_delegation?
+      end
+
+      private
+        attr_reader :node
+
+        def mirroring_delegation?
+          variable_name && variable_matches_method? && stable_initialization?
+        end
+
+        def variable_name
+          captures&.first
+        end
+
+        def captures
+          @captures ||= mirroring_assignment?(node)
+        end
+
+        def variable_matches_method?
+          name_without_sigil(variable_name).to_sym == method_name
+        end
+
+        def method_name
+          captures.third
+        end
+
+        def stable_initialization?
+          direct_receiver_pair? && stable_state?
+        end
+
+        def direct_receiver_pair?
+          direct_initialize_assignment? && receiver_assignment_precedes?
+        end
+
+        def direct_initialize_assignment?
+          initialize_method && direct_statements.any? { it.equal?(node) }
+        end
+
+        def initialize_method
+          @initialize_method ||= node.each_ancestor(:any_def).find { it.method?(:initialize) }
+        end
+
+        def direct_statements
+          @direct_statements ||= statements_in(initialize_method.body)
+        end
+
+        def receiver_assignment_precedes?
+          receiver_assignment && receiver_assignment.source_range.begin_pos < node.source_range.begin_pos
+        end
+
+        def receiver_assignment
+          @receiver_assignment ||= direct_statements.find do |statement|
+            receiver_assignment?(statement, :"@#{receiver_name}", receiver_name)
+          end
+        end
+
+        def receiver_name
+          captures.second
+        end
+
+        def stable_state?
+          receiver_local_stable? && instance_state_stable?
+        end
+
+        def receiver_local_stable?
+          receiver_rebindings.none? { between_receiver_and_mirror?(it) }
+        end
+
+        def receiver_rebindings
+          nodes_in(initialize_method.body, :lvasgn, :match_var).select { variable_name_of(it) == receiver_name }
+        end
+
+        def between_receiver_and_mirror?(write)
+          write.source_range.begin_pos.between?(receiver_assignment.source_range.end_pos, node.source_range.begin_pos)
+        end
+
+        def instance_state_stable?
+          sole_instance_write?(receiver_variable_name, receiver_assignment) && sole_instance_write?(variable_name, node)
+        end
+
+        def sole_instance_write?(name, expected)
+          instance_writes_to(name).then { it.one? && it.first.equal?(expected) }
+        end
+
+        def instance_writes_to(name)
+          nodes_in(state_scope&.body, :ivasgn).select { it.name == name && same_instance?(it) }
+        end
+
+        def state_scope
+          state_domain.container
+        end
+
+        def state_domain
+          @state_domain ||= RuboCop::Callbacksystems::Methods::Domain.new(node)
+        end
+
+        def same_instance?(write)
+          domain = RuboCop::Callbacksystems::Methods::Domain.new(write)
+
+          domain.container.equal?(state_scope) && domain.identity == state_domain.identity &&
+            self_preserved_between?(write, boundary: enclosing_method_of(write) || state_scope)
+        end
+
+        def receiver_variable_name
+          :"@#{receiver_name}"
+        end
+
+        def message
+          format(MESSAGE, name: method_name, receiver: receiver_name)
+        end
+    end
+end

data/lib/rubocop/cop/callbacksystems/prefer_excluding.rb

@@ -0,0 +1,204 @@
+# Detects array subtraction and record-ID exclusions that can use `excluding`.
+# The method names the excluded object directly, instead of wrapping it in a
+# throwaway array or spelling out its database identifier.
+#
+# `excluding` flattens the arguments it receives, and Enumerable supplies a
+# version whose result is an Array. Automatic correction therefore needs
+# positive evidence that the receiver is an Array and the element is not one;
+# an unknown value is still reported for a human who knows its domain.
+#
+# Relation exclusions are suggestions for human review. Active Record requires
+# an instance of the relation's model and excludes its primary key, which may
+# differ from the `id` column. Visible mismatches and custom primary keys are
+# left alone, as are safe navigation and compound negative conditions.
+#
+# @example
+#   # bad
+#   users - [admin]
+#   items - [first_item]
+#   User.where.not(id: user.id)
+#
+#   # good
+#   users.excluding(admin)
+#   items.excluding(first_item)
+#   User.excluding(user)
+#
+class RuboCop::Cop::Callbacksystems::PreferExcluding < RuboCop::Cop::Callbacksystems::Base
+  extend RuboCop::Cop::AutoCorrector
+
+  def on_send(node)
+    report Subtraction.new(node, source_comments:)
+    report RecordExclusion.new(node, source_root: processed_source.ast)
+  end
+
+  alias on_csend on_send
+
+  private
+    class Subtraction
+      include RuboCop::Callbacksystems::Helpers
+      extend RuboCop::AST::NodePattern::Macros
+
+      MESSAGE = "Use `excluding` instead of `- [element]`."
+      NON_ARRAY_LITERAL_TYPES =
+        %i[ complex dstr dsym erange false float hash int irange nil rational regexp str sym true ]
+
+      # @!method single_element_subtraction(node)
+      def_node_matcher :single_element_subtraction, <<~PATTERN
+        (call $_ :- (array $_element))
+      PATTERN
+
+      def initialize(node, source_comments:)
+        @node = node
+        @source_comments = source_comments
+        @receiver, @element = single_element_subtraction(node)
+      end
+
+      def offense
+        if receiver
+          RuboCop::Callbacksystems::Offense.new(node, MESSAGE, correcting: correction_equivalent?) { correct(it) }
+        end
+      end
+
+      private
+        attr_reader :node, :source_comments, :receiver, :element
+
+        def correction_equivalent?
+          array_value?(receiver) && non_array_value?(element) && standalone_element_source? &&
+            !source_comments.any_within?(node)
+        end
+
+        def array_value?(candidate)
+          reads_as_array?(candidate) || adjacent_assigned_value_of(candidate)&.then { reads_as_array?(it) }
+        end
+
+        def adjacent_assigned_value_of(candidate)
+          AdjacentAssignment.new(candidate, beside: node).value
+        end
+
+        def non_array_value?(candidate)
+          known_non_array?(candidate) || adjacent_assigned_value_of(candidate)&.then { known_non_array?(it) }
+        end
+
+        def known_non_array?(candidate)
+          NON_ARRAY_LITERAL_TYPES.include?(candidate.type) ||
+            (candidate.begin_type? && candidate.children.one? && known_non_array?(candidate.children.first))
+        end
+
+        def standalone_element_source?
+          !element.parent.percent_literal? || element.type?(:str, :sym)
+        end
+
+        def correct(corrector)
+          corrector.replace(node, "#{receiver.source}#{call_operator}excluding(#{argument})")
+        end
+
+        def call_operator
+          node.csend_type? ? "&." : "."
+        end
+
+        # Inside a percent literal an element is written bare, so its source alone would not survive on its own.
+        def argument
+          element.parent.percent_literal? ? element.value.inspect : element.source
+        end
+    end
+
+    class RecordExclusion
+      include RuboCop::Callbacksystems::Helpers
+      extend RuboCop::AST::NodePattern::Macros
+
+      MESSAGE = "Consider `excluding(%<record>s)` when the record belongs to this relation's model " \
+        "and its primary key is `id`."
+
+      # @!method record_exclusion(node)
+      def_node_matcher :record_exclusion, <<~PATTERN
+        (send (send $_relation :where) :not (hash (pair {(sym :id) (str "id")} (send $_record :id))))
+      PATTERN
+
+      def initialize(node, source_root:)
+        @node = node
+        @source_root = source_root
+        @relation, @record = record_exclusion(node)
+      end
+
+      def offense
+        if record && applicable?
+          RuboCop::Callbacksystems::Offense.new(node, format(MESSAGE, record: record.source))
+        end
+      end
+
+      private
+        attr_reader :node, :source_root, :relation, :record
+
+        def applicable?
+          node.each_node(:csend).none? && !non_record_value? && !different_models? && !custom_primary_key?
+        end
+
+        def non_record_value?
+          record_value.literal? || record_value.const_type? || relation&.literal?
+        end
+
+        def record_value
+          @record_value ||= AdjacentAssignment.new(record, beside: node).value || record
+        end
+
+        def different_models?
+          relation_model && record_model && relation_model != record_model
+        end
+
+        def relation_model
+          @relation_model ||= model_name_of(relation)
+        end
+
+        def model_name_of(candidate)
+          candidate = candidate.receiver while candidate&.call_type?
+          constant_name_of(candidate)&.delete_prefix("::")
+        end
+
+        def record_model
+          @record_model ||= model_name_of(record_value)
+        end
+
+        def custom_primary_key?
+          source_root.each_node(:send, :defs).any? do |candidate|
+            if candidate.defs_type?
+              candidate.method?(:primary_key)
+            else
+              candidate.method?(:primary_key=) && !default_primary_key?(candidate.first_argument)
+            end
+          end
+        end
+
+        def default_primary_key?(value)
+          value.type?(:str, :sym) && value.value.to_s == "id"
+        end
+    end
+
+    # A local's immediately preceding assignment, shared by both forms of exclusion.
+    class AdjacentAssignment
+      def initialize(variable, beside:)
+        @variable = variable
+        @node = beside
+      end
+
+      def value
+        if variable.lvar_type? && matching_assignment?
+          previous.expression
+        end
+      end
+
+      private
+        attr_reader :variable, :node
+
+        def matching_assignment?
+          previous&.lvasgn_type? && previous.name == variable.name
+        end
+
+        def previous
+          @previous ||= statement_containing_node&.left_sibling
+        end
+
+        def statement_containing_node
+          @statement_containing_node ||= [ node, *node.each_ancestor ].find { it.parent&.type?(:begin, :kwbegin) }
+        end
+    end
+end

data/lib/rubocop/cop/callbacksystems/prefer_extract_associated.rb

@@ -0,0 +1,54 @@
+# Prefers `extract_associated` when a model query preloads one association and
+# then collects that same association. Active Record supplies this exact
+# operation as one method, keeping the association's name in one place.
+#
+# The receiver is assumed to be an Active Record relation. Comments prevent
+# autocorrection, and a guarded preload followed by an unguarded map is left
+# alone because collapsing it would change what happens when the receiver is nil.
+#
+# @example
+#   # bad
+#   posts.preload(:author).map(&:author)
+#   memberships.preload(:user).collect(&:user)
+#
+#   # good
+#   posts.extract_associated(:author)
+#   memberships.extract_associated(:user)
+#
+class RuboCop::Cop::Callbacksystems::PreferExtractAssociated < RuboCop::Cop::Callbacksystems::Base
+  extend RuboCop::Cop::AutoCorrector
+
+  MESSAGE = "Use `extract_associated(%<association>s)` instead of preloading and mapping the same association."
+
+  # @!method association_extraction(node)
+  def_node_matcher :association_extraction, <<~PATTERN
+    (call $(call _ :preload $(sym _association)) {:map :collect} (block_pass (sym _association)))
+  PATTERN
+
+  def on_send(node)
+    association_extraction(node) do |preload, association|
+      next if preload.csend_type? && node.send_type?
+
+      add_extraction_offense(node, preload:, association:)
+    end
+  end
+
+  alias on_csend on_send
+
+  private
+    def add_extraction_offense(node, preload:, association:)
+      message = format(MESSAGE, association: association.source)
+
+      if source_comments.any_within?(node)
+        add_offense(node, message:)
+      else
+        add_offense(node, message:) do |corrector|
+          corrector.replace(node, replacement_for(preload, association:))
+        end
+      end
+    end
+
+    def replacement_for(preload, association:)
+      "#{call_prefix_of(preload)}extract_associated(#{association.source})"
+    end
+end