rubocop-callbacksystems 0.1.0

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

@@ -0,0 +1,261 @@
+# Detects consecutive appends to one collection. `list << a` followed by
+# `list << b` makes the reader walk the same receiver twice, where a single
+# `list.push(a, b)` states the whole addition at once.
+#
+# The run has to be adjacent statements on the same local variable, instance
+# variable or bare method call, and none of the values may read or rebind the
+# receiver, since `list << list.size` after an append counts what was pushed
+# before it, while `list << (list = other)` changes what the next append reaches.
+# `<<` also writes to a String, a Set or a stream, none of which takes several
+# values through `push`, so the rule needs positive evidence that every visible
+# assignment builds an Array and, for a local, an unconditional assignment above
+# the run. An unknown receiver is left alone. A run carrying a comment or a
+# heredoc is reported without a correction, since collapsing it would drop the
+# comment or strand the heredoc body.
+#
+# @example
+#   # bad
+#   list = []
+#   list << header
+#   list << body
+#
+#   # bad
+#   list = []
+#   list.push(header)
+#   list << body
+#
+#   # good
+#   list = []
+#   list.push(header, body)
+#
+#   # good - the second value reads the receiver
+#   list = []
+#   list << header
+#   list << list.size
+#
+class RuboCop::Cop::Callbacksystems::NoConsecutiveAppends < RuboCop::Cop::Callbacksystems::Base
+  extend RuboCop::Cop::AutoCorrector
+
+  def on_new_investigation
+    @assigned_values = AssignedValues.new(processed_source.ast)
+    @source_comments = RuboCop::Callbacksystems::Source::Comments.for(processed_source)
+  end
+
+  def on_begin(node)
+    report_each AppendRuns.new(node, assigned_values:, source_comments:)
+  end
+
+  alias on_kwbegin on_begin
+
+  private
+    attr_reader :assigned_values, :source_comments
+
+    # The runs of adjacent appends to one receiver inside a statement list.
+    class AppendRuns
+      def initialize(statement_list, assigned_values:, source_comments:)
+        @statement_list = statement_list
+        @assignment_index = assigned_values
+        @source_comments = source_comments
+      end
+
+      def each_offense
+        runs.select(&:array_receiver?).each { yield it.offense }
+      end
+
+      private
+        attr_reader :statement_list, :assignment_index, :source_comments
+
+        def runs
+          appends.chunk_while { |left, right| left.continued_by?(right) }.select(&:many?).map { run_of(it) }
+        end
+
+        def appends
+          statement_list.children.map { Append.new(it) }
+        end
+
+        def run_of(members)
+          Run.new(members, assigned_values: assignment_index, source_comments:)
+        end
+    end
+
+    # One statement read as an append, or as the statement that ends a run.
+    class Append
+      include RuboCop::Callbacksystems::Helpers
+      extend RuboCop::AST::NodePattern::Macros
+
+      attr_reader :node
+
+      # @!method appended(node)
+      def_node_matcher :appended, <<~PATTERN
+        (send ${lvar ivar (send nil? _)} {:<< :push} $!block_pass+)
+      PATTERN
+
+      def initialize(node)
+        @node = node
+      end
+
+      def continued_by?(other)
+        append? && other.append? && receiver.source == other.receiver.source
+      end
+
+      def append?
+        captures.present? && !touches_receiver?
+      end
+
+      def receiver
+        captures.first
+      end
+
+      def values
+        captures.second
+      end
+
+      private
+        def captures
+          @captures ||= appended(node)
+        end
+
+        def touches_receiver?
+          values.any? { |value| nodes_in(value, *receiver_node_types).any? { same_receiver?(it) } }
+        end
+
+        def receiver_node_types
+          if receiver.lvar_type? then %i[ lvar lvasgn match_var ]
+          elsif receiver.ivar_type? then %i[ ivar ivasgn ]
+          else [ receiver.type ]
+          end
+        end
+
+        def same_receiver?(occurrence)
+          if receiver.lvar_type?
+            variable_name_of(occurrence) == receiver.name &&
+              !name_rebound_between?(receiver.name, node: occurrence, boundary: scope)
+          elsif receiver.ivar_type?
+            occurrence.name == receiver.name
+          else
+            occurrence.source == receiver.source
+          end
+        end
+
+        def scope
+          @scope ||= enclosing_scope_of(node)
+        end
+    end
+
+    class Run
+      include RuboCop::Callbacksystems::Helpers
+
+      MESSAGE = "Append `%<values>s` to `%<receiver>s` in one `push` instead of consecutive appends."
+
+      def initialize(appends, assigned_values:, source_comments:)
+        @appends = appends
+        @assignment_index = assigned_values
+        @source_comments = source_comments
+      end
+
+      def array_receiver?
+        assigned_values.any? && assigned_values.all? { array_value?(it) } && initialized_before_run?
+      end
+
+      def offense
+        RuboCop::Callbacksystems::Offense.new(range, message, correcting: rewritable?) { correct(it) }
+      end
+
+      private
+        attr_reader :appends, :assignment_index, :source_comments
+        delegate :receiver, to: "appends.first", private: true
+
+        def assigned_values
+          @assigned_values ||= assignments.map { assigned_value_of(it) unless it.match_var_type? }
+        end
+
+        def assignments
+          assignment_index.for(receiver)
+        end
+
+        def assigned_value_of(assignment)
+          assignment.parent.or_asgn_type? ? assignment.parent.expression : assignment.expression
+        end
+
+        def array_value?(value)
+          reads_as_array?(value)
+        end
+
+        def initialized_before_run?
+          !receiver.lvar_type? || assignments.any? { direct_assignment_before_run?(it) }
+        end
+
+        def direct_assignment_before_run?(assignment)
+          assignment.parent.equal?(appends.first.node.parent) &&
+            assignment.source_range.begin_pos < appends.first.node.source_range.begin_pos
+        end
+
+        def range
+          range_spanning(appends.map(&:node))
+        end
+
+        def message
+          format(MESSAGE, values: values.map(&:source).join(", "), receiver: receiver.source)
+        end
+
+        def values
+          appends.flat_map(&:values)
+        end
+
+        def rewritable?
+          !receiver.send_type? && !commented? && appends.none? { carries_heredoc?(it.node) }
+        end
+
+        def commented?
+          source_comments.any_on_lines?(range.first_line..range.last_line)
+        end
+
+        def correct(corrector)
+          corrector.replace(range, "#{receiver.source}.push(#{values.map(&:source).join(", ")})")
+        end
+    end
+
+    # Assignments grouped once by local lexical scope or by instance-variable name for the whole file.
+    class AssignedValues
+      include RuboCop::Callbacksystems::Helpers
+
+      def initialize(ast)
+        @ast = ast
+        @local_variables = RuboCop::Callbacksystems::Execution::LocalVariableOccurrences.new(ast)
+      end
+
+      def for(receiver)
+        if receiver.lvar_type?
+          local_variables.named(receiver.name, around: receiver).select { it.type?(:lvasgn, :match_var) }
+        else
+          instance_assignments.fetch(instance_variable_key_of(receiver)) { [] }
+        end
+      end
+
+      private
+        attr_reader :ast, :local_variables
+
+        def instance_assignments
+          @instance_assignments ||= nodes_in(ast, :ivasgn).select { state_belongs_to_domain?(it) }
+            .group_by { instance_variable_key_of(it) }
+        end
+
+        def state_belongs_to_domain?(assignment)
+          self_preserved_between?(assignment, boundary: state_boundary_of(assignment))
+        end
+
+        def state_boundary_of(assignment)
+          enclosing_method_of(assignment) || RuboCop::Callbacksystems::Methods::Domain.new(assignment).container
+        end
+
+        def instance_variable_key_of(node)
+          domain = RuboCop::Callbacksystems::Methods::Domain.new(node)
+
+          [ instance_variable_name_of(node), domain.container&.object_id, domain.identity ]
+        end
+
+        def instance_variable_name_of(receiver)
+          receiver.send_type? ? :"@#{receiver.method_name}" : receiver.name
+        end
+    end
+end

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

@@ -0,0 +1,124 @@
+# Keeps routes on the standard resource actions. A custom action is a verb
+# bolted onto a controller, and the noun it acts on is a resource of its own
+# waiting to be named, so `confirm` on messages becomes a `confirmation`
+# resource with a `create` action and the controller stays one noun with the
+# seven actions a reader expects.
+#
+# @example
+#   # bad - custom action through an option
+#   resources :messages do
+#     post :confirm, on: :member
+#   end
+#
+#   # bad - custom actions through a block
+#   resources :messages do
+#     member do
+#       post :confirm
+#     end
+#   end
+#
+#   # good - the action becomes a resource
+#   resources :messages do
+#     resource :confirmation, only: :create
+#   end
+#
+class RuboCop::Cop::Callbacksystems::NoCustomRouteActions < RuboCop::Cop::Callbacksystems::Base
+  def on_new_investigation
+    @immediate_nodes = {}.compare_by_identity
+    RuboCop::Callbacksystems::Execution::Immediate.new(processed_source.ast).each { @immediate_nodes[it] = true }
+  end
+
+  def on_block(node)
+    report ScopeBlock.new(node) if in_routes_file? && immediately_executed?(node)
+  end
+  alias on_numblock on_block
+  alias on_itblock on_block
+
+  def on_send(node)
+    report VerbRoute.new(node) if in_routes_file? && immediately_executed?(node)
+  end
+  alias on_csend on_send
+
+  private
+    CUSTOM_SCOPES = %i[ member collection new ]
+
+    def in_routes_file?
+      routes_file?(processed_source.file_path)
+    end
+
+    def immediately_executed?(node)
+      @immediate_nodes.key?(node)
+    end
+
+    class ScopeBlock
+      include RuboCop::Callbacksystems::Helpers
+
+      MESSAGE = "Custom actions belong to their own resource. Replace the `%<scope>s` block with nested resources."
+
+      def initialize(node)
+        @node = node
+      end
+
+      def offense
+        if scoped_block?
+          RuboCop::Callbacksystems::Offense.new(node.send_node, format(MESSAGE, scope: node.method_name))
+        end
+      end
+
+      private
+        attr_reader :node
+
+        def scoped_block?
+          CUSTOM_SCOPES.include?(node.method_name) && bare_send?(node.send_node) &&
+            node.send_node.arguments.empty? && inside_resources?
+        end
+
+        def inside_resources?
+          node.each_ancestor(*BLOCK_NODE_TYPES).any? do |block|
+            bare_send?(block.send_node) && %i[ resources resource ].include?(block.method_name)
+          end
+        end
+    end
+
+    class VerbRoute
+      include RuboCop::Callbacksystems::Helpers
+
+      MESSAGE = "Custom actions belong to their own resource. Route `%<action>s` as a resource instead of `on: " \
+        ":%<scope>s`."
+      ROUTE_VERBS = %i[ get post patch put delete match ]
+
+      def initialize(node)
+        @node = node
+      end
+
+      def offense
+        if scoped_route?
+          RuboCop::Callbacksystems::Offense.new(node, format(MESSAGE, action: action_name, scope: custom_scope))
+        end
+      end
+
+      private
+        attr_reader :node
+        delegate :first_argument, to: :node, private: true
+
+        def scoped_route?
+          ROUTE_VERBS.include?(node.method_name) && bare_send?(node) && custom_scope.present?
+        end
+
+        def custom_scope
+          @custom_scope ||= on_option_value&.then { it.value if it.sym_type? && CUSTOM_SCOPES.include?(it.value) }
+        end
+
+        def on_option_value
+          keyword_options.option_for(:on)&.value
+        end
+
+        def keyword_options
+          @keyword_options ||= RuboCop::Callbacksystems::Hashes::KeywordOptions.new(*node.arguments.select(&:hash_type?))
+        end
+
+        def action_name
+          literal_name_of(first_argument)
+        end
+    end
+end

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

@@ -0,0 +1,90 @@
+# Keeps preload, eager_load, and includes inside app/models. Which associations
+# a query loads is knowledge about the model, so every caller asks for a named
+# scope instead of repeating that knowledge at each call site.
+# Methods defined on a known receiver in the same source are left alone; calls
+# on unknown receivers are assumed to use the Active Record query API.
+#
+# @example
+#   # bad - direct eager loading in controller
+#   class UsersController < ApplicationController
+#     def index
+#       @users = User.includes(:posts).all
+#     end
+#   end
+#
+#   # good - use a scope
+#   class UsersController < ApplicationController
+#     def index
+#       @users = User.with_posts.all
+#     end
+#   end
+#
+#   # In the model:
+#   class User < ApplicationRecord
+#     scope :with_posts, -> { includes(:posts) }
+#   end
+#
+class RuboCop::Cop::Callbacksystems::NoDirectEagerLoading < RuboCop::Cop::Callbacksystems::Base
+  MESSAGE = "Don't use `%<method>s` outside `app/models`. Define a scope in the model instead."
+
+  def on_new_investigation
+    @custom_methods = CustomMethods.new(processed_source.ast)
+  end
+
+  def on_send(node)
+    add_offense(node, message: format(MESSAGE, method: node.method_name)) if direct_eager_loading?(node)
+  end
+
+  alias on_csend on_send
+
+  private
+    attr_reader :custom_methods
+
+    def direct_eager_loading?(node)
+      !model_file?(processed_source.file_path) && EAGER_LOADING_METHODS.include?(node.method_name) &&
+        node.arguments.any? && !custom_methods.defines?(node)
+    end
+
+    # Explicit definitions distinguish an application method from the homonymous query API without guessing types.
+    class CustomMethods
+      include RuboCop::Callbacksystems::Helpers
+
+      def initialize(root)
+        @root = root
+      end
+
+      def defines?(call)
+        if call_on_self?(call)
+          siblings.named(call.method_name, beside: call).any?
+        elsif call.receiver.const_type?
+          singleton_definition_for?(call)
+        else
+          false
+        end
+      end
+
+      private
+        attr_reader :root
+
+        def siblings
+          @siblings ||= RuboCop::Callbacksystems::Methods::Siblings.new
+        end
+
+        def singleton_definition_for?(call)
+          singleton_definitions.any? do |definition|
+            definition.method?(call.method_name) && receiver_names_match?(call.receiver, definition:)
+          end
+        end
+
+        def singleton_definitions
+          @singleton_definitions ||= nodes_in(root, :def, :defs).select do |definition|
+            RuboCop::Callbacksystems::Methods::Domain.new(definition).identity == [ :self ] &&
+              direct_method_definition?(definition)
+          end
+        end
+
+        def receiver_names_match?(receiver, definition:)
+          enclosing_class_or_module_of(definition).identifier.short_name == receiver.short_name
+        end
+    end
+end

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

@@ -0,0 +1,58 @@
+# Detects `each` blocks that `return` an element from inside a condition. The
+# loop is a search written by hand, and `find` says so in one line, while the
+# `each` form makes a reader trace the `return` to learn that the method hands
+# back the first match and `nil` otherwise.
+#
+# @example
+#   # bad - each with early return
+#   items.each do |item|
+#     return item if item.valid?
+#   end
+#   nil
+#
+#   # good - use find
+#   items.find { it.valid? }
+#
+#   # bad - each with early return (implicit nil)
+#   def find_valid
+#     items.each do |item|
+#       return item if item.valid?
+#     end
+#   end
+#
+#   # good
+#   def find_valid
+#     items.find { it.valid? }
+#   end
+#
+class RuboCop::Cop::Callbacksystems::NoEachWithEarlyReturn < RuboCop::Cop::Callbacksystems::Base
+  def on_block(node)
+    report EachBlock.new(node)
+  end
+
+  alias on_numblock on_block
+  alias on_itblock on_block
+
+  private
+    class EachBlock
+      include RuboCop::Callbacksystems::Helpers
+
+      MESSAGE = "Don't use `each` with early `return`. Use `find` instead."
+
+      def initialize(node)
+        @node = node
+      end
+
+      def offense
+        RuboCop::Callbacksystems::Offense.new(node, MESSAGE) if node.method?(:each) && returns_conditionally?
+      end
+
+      private
+        attr_reader :node
+
+        def returns_conditionally?
+          RuboCop::Callbacksystems::Execution::Immediate.new(node.body).nodes_of_type(:return)
+            .any? { conditional_return_of_block_argument?(it, block: node) }
+        end
+    end
+end

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

@@ -0,0 +1,81 @@
+# Do not use an explicit `public` modifier. A class reads top-down, public
+# methods first and a single `private` after them, so a `public` that reopens
+# visibility later makes a reader track which section each method sits in
+# instead of trusting the order.
+#
+# @example
+#   # bad - using explicit public modifier
+#   class Foo
+#     private
+#       def private_method; end
+#
+#     public
+#       def public_method; end
+#   end
+#
+#   # bad - using public with method name
+#   class Foo
+#     def some_method; end
+#     public :some_method
+#   end
+#
+#   # good - public methods at the beginning
+#   class Foo
+#     def public_method; end
+#
+#     private
+#       def private_method; end
+#   end
+#
+class RuboCop::Cop::Callbacksystems::NoExplicitPublicModifier < RuboCop::Cop::Callbacksystems::Base
+  extend RuboCop::Cop::AutoCorrector
+
+  def on_send(node)
+    report PublicModifier.new(node, source_comments:)
+  end
+
+  alias on_csend on_send
+
+  private
+    class PublicModifier
+      include RuboCop::Callbacksystems::Helpers
+
+      MESSAGE = "Do not use `public` modifier. Public methods should be defined at the beginning of the class."
+
+      def initialize(node, source_comments:)
+        @node = node
+        @source_comments = source_comments
+      end
+
+      def offense
+        if explicit?
+          RuboCop::Callbacksystems::Offense.new(node, MESSAGE, correcting: redundant? && uncommented?) { correct(it) }
+        end
+      end
+
+      private
+        attr_reader :node, :source_comments
+
+        def explicit?
+          bare_send?(node) && node.method?(:public) && !inside_nested_class?
+        end
+
+        def inside_nested_class?
+          node.each_ancestor(:class, :module).drop(1).any?
+        end
+
+        # A bare `public` after `private` is what keeps the methods below it public, so a human reorders that one.
+        def redundant?
+          node.arguments.empty? && enclosing_definition_of(node) &&
+            statements_before(node).none? { leaves_public_section?(it) }
+        end
+
+        def uncommented?
+          !source_comments.any_on_lines?(node.first_line..node.last_line)
+        end
+
+        def correct(corrector)
+          corrector.remove(statement_removal_range_for(node))
+        end
+    end
+end

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

@@ -0,0 +1,68 @@
+# Detects `Hash.new` with a default block that initializes missing keys to an
+# empty collection. The pattern reaches for an imperative accumulator when the
+# declarative equivalent (`group_by`, `group_by + transform_values`) is almost
+# always clearer.
+#
+# `NoTapCollectionBuilding` only catches the `.tap { ... }` flavor of this
+# pattern; this cop also catches it when used standalone, passed to
+# `each_with_object`, assigned to a variable, etc.
+#
+# @example
+#   # bad - building a hash of groups imperatively
+#   groups = Hash.new { |h, k| h[k] = [] }
+#   items.each { |i| groups[i.type] << i }
+#
+#   # bad - same with each_with_object
+#   items.each_with_object(Hash.new { |h, k| h[k] = [] }) do |item, groups|
+#     groups[item.type] << item
+#   end
+#
+#   # bad - hash of sets
+#   tags = Hash.new { |h, k| h[k] = Set.new }
+#
+#   # good - use group_by
+#   items.group_by(&:type)
+#
+#   # good - group_by + transform_values when the values need more shaping
+#   items.group_by(&:type).transform_values { Set.new(it.map(&:tag)) }
+#
+class RuboCop::Cop::Callbacksystems::NoHashWithDefaultBlock < RuboCop::Cop::Callbacksystems::Base
+  MESSAGE = "Avoid `Hash.new { |h, k| h[k] = ... }`. Use `group_by` (or `group_by + transform_values`) instead."
+
+  # @!method value_assigned_to_key(body, hash_name, key_name)
+  def_node_matcher :value_assigned_to_key, <<~PATTERN
+    (send (lvar %1) :[]= (lvar %2) $_)
+  PATTERN
+
+  def on_block(node)
+    if hash_new_block?(node) && core_collection_constructor?(node.send_node, :Hash)
+      hash_name, key_name = node.argument_list.map(&:name)
+      if empty_collection?(value_assigned_to_key(node.body, hash_name, key_name))
+        add_offense(node, message: MESSAGE)
+      end
+    end
+  end
+
+  alias on_numblock on_block
+  alias on_itblock on_block
+
+  private
+    def hash_new_block?(node)
+      call = node.send_node
+      call.send_type? && call.method?(:new) && node.argument_list.size == 2 &&
+        node.argument_list.all?(&:arg_type?)
+    end
+
+    def core_collection_constructor?(node, *receivers)
+      node&.send_type? && node.method?(:new) && core_constant?(node.receiver) &&
+        receivers.include?(node.receiver.short_name)
+    end
+
+    def empty_collection?(node)
+      empty_collection_literal?(node) || collection_constructor?(node)
+    end
+
+    def collection_constructor?(node)
+      node&.send_type? && node.arguments.empty? && core_collection_constructor?(node, :Array, :Hash, :Set)
+    end
+end