rubocop-callbacksystems 0.1.0

data/lib/rubocop/callbacksystems/execution/local_variable_occurrences.rb

@@ -0,0 +1,112 @@
+# Local-variable nodes indexed by lexical scope, so several readings of one scope walk its tree only once.
+class RuboCop::Callbacksystems::Execution::LocalVariableOccurrences
+  include RuboCop::Callbacksystems::Helpers
+
+  def initialize(tree)
+    @tree = tree
+    @by_scope = {}.compare_by_identity
+  end
+
+  def named(name, around:)
+    occurrences_around(around).fetch(name) { [] }
+  end
+
+  def named_in_method(name, around:)
+    occurrences_in(enclosing_method_of(around)).fetch(name) { [] }
+  end
+
+  private
+    attr_reader :tree, :by_scope
+
+    def occurrences_around(node)
+      occurrences_in(scope_of(node))
+    end
+
+    def occurrences_in(scope)
+      if scope
+        by_scope[scope] ||= OccurrencesWithin.new(scope).group_by { variable_name_of(it) }
+      else
+        {}
+      end
+    end
+
+    def scope_of(node)
+      enclosing_scope_of(node) || tree
+    end
+
+    class OccurrencesWithin
+      include Enumerable
+      include RuboCop::Callbacksystems::Helpers
+
+      def initialize(scope)
+        @scope = scope
+      end
+
+      def each
+        if block_given?
+          each_occurrence { yield it }
+        else
+          to_enum(__method__)
+        end
+      end
+
+      private
+        attr_reader :scope
+
+        def each_occurrence
+          pending = [ Candidate.new(scope, scope:, nested: false) ]
+          until pending.empty?
+            candidate = pending.pop
+            yield candidate.node if candidate.occurrence?
+            candidate.children.reverse_each { pending << it }
+          end
+        end
+
+        class Candidate
+          include RuboCop::Callbacksystems::Helpers
+
+          attr_reader :node
+
+          def initialize(node, scope:, nested:)
+            @node = node
+            @scope = scope
+            @nested = nested
+          end
+
+          def occurrence?
+            local_node? && !rebound?
+          end
+
+          def children
+            child_nodes.map { self.class.new(it, scope:, nested: true) }
+          end
+
+          private
+            attr_reader :scope, :nested
+
+            def local_node?
+              node.type?(:lvar, :lvasgn, :match_var)
+            end
+
+            def rebound?
+              name_rebound_between?(variable_name_of(node), node:, boundary: scope)
+            end
+
+            def child_nodes
+              if nested && execution_boundary?
+                immediate_inputs_of(node)
+              else
+                node.each_child_node
+              end
+            end
+
+            def execution_boundary?
+              lexical_definition?(node) || deferred_boundary?
+            end
+
+            def deferred_boundary?
+              deferred_callable_block?(node) || method_definition_block?(node)
+            end
+        end
+    end
+end

data/lib/rubocop/callbacksystems/hashes/key_transform_detection.rb

@@ -0,0 +1,108 @@
+# The reading PreferStringifyKeys and PreferSymbolizeKeys share: a `transform_keys` that only sends one method to each
+# key, given as a block pass or as a block. An including cop names that method as `source_method` and the Active Support
+# method saying the same thing as `preferred_method`.
+module RuboCop::Callbacksystems::Hashes::KeyTransformDetection
+  extend ActiveSupport::Concern
+
+  included do
+    extend RuboCop::Cop::AutoCorrector
+  end
+
+  def on_send(node)
+    report key_transform_of(node)
+  end
+
+  alias on_csend on_send
+
+  def on_block(node)
+    report key_transform_of(node)
+  end
+
+  alias on_numblock on_block
+  alias on_itblock on_block
+
+  private
+    def key_transform_of(node)
+      KeyTransform.new(node, source_method:, preferred_method:, source_comments:)
+    end
+
+    class KeyTransform
+      include RuboCop::Callbacksystems::Helpers
+
+      MESSAGE = "Use `%<preferred_method>s` instead of `transform_keys(&:%<source_method>s)`."
+
+      def initialize(node, source_method:, preferred_method:, source_comments:)
+        @node = node
+        @source_method = source_method
+        @preferred_method = preferred_method
+        @source_comments = source_comments
+      end
+
+      def offense
+        if sends_source_method_to_keys?
+          RuboCop::Callbacksystems::Offense.new(node, message, correcting: uncommented?) { correct(it) }
+        end
+      end
+
+      private
+        attr_reader :node, :source_method, :preferred_method, :source_comments
+
+        def sends_source_method_to_keys?
+          transform_keys? && sends_source_method?
+        end
+
+        def transform_keys?
+          keys_call.method?(:transform_keys) && keys_call.receiver
+        end
+
+        def keys_call
+          node.call_type? ? node : node.send_node
+        end
+
+        def sends_source_method?
+          node.call_type? ? passes_source_method? : sends_source_method_to_parameter?
+        end
+
+        def passes_source_method?
+          keys_call.arguments.one? && block_pass_value&.sym_type? &&
+            block_pass_value.value == source_method
+        end
+
+        def block_pass_value
+          node.first_argument.children.first if node.first_argument.block_pass_type?
+        end
+
+        def sends_source_method_to_parameter?
+          keys_call.arguments.empty? && single_parameter_block? && exact_source_method_send?
+        end
+
+        def single_parameter_block?
+          any_block_type?(node) && node.argument_list.one? && block_parameter.arg_type?
+        end
+
+        def block_parameter
+          node.argument_list.first
+        end
+
+        def exact_source_method_send?
+          node.body&.send_type? && node.body.method?(source_method) && node.body.arguments.empty? &&
+            reads_variable?(node.body.receiver, block_parameter.name)
+        end
+
+        def message
+          format(MESSAGE, preferred_method: preferred_method, source_method: source_method)
+        end
+
+        def uncommented?
+          !source_comments.any_within?(node)
+        end
+
+        def correct(corrector)
+          corrector.replace(node, "#{keys_call.receiver.source}#{call_operator}#{preferred_method}")
+        end
+
+        def call_operator
+          keys_call.csend_type? ? "&." : "."
+        end
+    end
+end

data/lib/rubocop/callbacksystems/hashes/keyword_options.rb

@@ -0,0 +1,37 @@
+# Keyword options resolved in Ruby's evaluation order: the last explicit pair wins unless a later splat can replace it.
+class RuboCop::Callbacksystems::Hashes::KeywordOptions
+  attr_reader :elements
+
+  def initialize(*hashes)
+    @elements = hashes.compact.flat_map(&:children)
+  end
+
+  def known?(key)
+    option_for(key).present? || elements.none? { unknown_option?(it) }
+  end
+
+  def option_for(key)
+    explicit = explicit_options_for(key).last
+
+    explicit unless unknown_option_follows?(explicit)
+  end
+
+  def explicit_options_for(key)
+    elements.select { it.pair_type? && it.key.sym_type? && it.key.value == key }
+  end
+
+  private
+    def unknown_option_follows?(option)
+      option && elements.drop(index_of(option) + 1).any? { unknown_option?(it) }
+    end
+
+    def index_of(option)
+      elements.index { it.equal?(option) }
+    end
+
+    # A non-literal key can evaluate to the option being queried just as a keyword splat can. Literal non-symbol keys
+    # cannot replace it, but abstaining for those uncommon calls keeps this reader sound without evaluating Ruby.
+    def unknown_option?(element)
+      element.kwsplat_type? || (element.pair_type? && !element.key.sym_type?)
+    end
+end

data/lib/rubocop/callbacksystems/helpers/bodies.rb

@@ -0,0 +1,150 @@
+module RuboCop::Callbacksystems::Helpers::Bodies
+  def assignment_count(body, *types)
+    ScopedAssignments.new(body, types).to_set { variable_name_of(it) }.size
+  end
+
+  def immediate_inputs_of(node)
+    if any_block_type?(node)
+      call_of(node).then { [ it.receiver, *it.arguments ].compact }
+    else
+      case node.type
+      when :defs then [ node.receiver ]
+      when :class then [ node.identifier, node.parent_class ].compact
+      when :sclass then [ node.identifier ]
+      else []
+      end
+    end
+  end
+
+  def lexical_definition?(node)
+    node.type?(:def, :defs, :class, :module, :sclass)
+  end
+
+  def statements_before(node)
+    node.parent&.type?(:begin, :kwbegin) ? node.parent.children.take_while { !it.equal?(node) } : []
+  end
+
+  def direct_definitions_in(body, type)
+    statements_in(body).select { it.type?(type) }
+  end
+
+  def statements_in(body)
+    if body
+      body.type?(:begin, :kwbegin) ? body.children.to_a : [ body ]
+    else
+      []
+    end
+  end
+
+  def runs_in(body)
+    statements_in(body).chunk_while { |left, right| yield(left) && yield(right) }.select { yield it.first }
+  end
+
+  def receiverless_method_names_in(body)
+    nodes_in(body, :send).filter_map { it.method_name if bare_send?(it) }
+  end
+
+  def first_statement_in(body)
+    edge_statement(body, side: :first)
+  end
+
+  def last_statement_in(body)
+    edge_statement(body, side: :last)
+  end
+
+  def direct_method_nodes_in(body)
+    DirectMethodNodes.new(body).to_a
+  end
+
+  private
+    def edge_statement(body, side:)
+      current = body
+      loop do
+        current = case current&.type
+        when :begin, :kwbegin then current.children.public_send(side)
+        when :rescue then current.body
+        when :ensure then current.children.first
+        else return current
+        end
+      end
+    end
+
+    # Method definitions belonging directly to a body, with singleton sections transparent and other owners pruned.
+    class DirectMethodNodes
+      include Enumerable
+
+      def initialize(body)
+        @body = body
+      end
+
+      def each
+        if block_given?
+          pending = [ body ].compact
+          until pending.empty?
+            node = pending.pop
+            case node.type
+            when :def, :defs then yield node
+            when :begin, :kwbegin then pending.concat(node.each_child_node.to_a.reverse)
+            when :sclass then pending << node.body if node.body
+            end
+          end
+        else
+          to_enum(__method__)
+        end
+      end
+
+      private
+        attr_reader :body
+    end
+
+    # Assignments executed in one lexical scope, with callable and definition bodies left for their own scopes.
+    class ScopedAssignments
+      include Enumerable
+      include RuboCop::Callbacksystems::Helpers
+
+      def initialize(body, types)
+        @body = body
+        @types = types
+      end
+
+      def each
+        if block_given?
+          @pending = [ body ].compact
+          until pending.empty?
+            advance
+            visit { yield it }
+          end
+        else
+          to_enum(__method__)
+        end
+      end
+
+      private
+        attr_reader :body, :types, :pending, :current
+
+        def advance
+          @current = pending.pop
+        end
+
+        def visit
+          if scope_boundary?
+            queue immediate_inputs_of(current)
+          else
+            yield current if current.type?(*types)
+            queue current.each_child_node
+          end
+        end
+
+        def scope_boundary?
+          (!current.equal?(body) && lexical_definition?(current)) || deferred_boundary?
+        end
+
+        def deferred_boundary?
+          deferred_callable_block?(current) || method_definition_block?(current)
+        end
+
+        def queue(nodes)
+          pending.concat(nodes.to_a.reverse)
+        end
+    end
+end

data/lib/rubocop/callbacksystems/helpers/builders.rb

@@ -0,0 +1,103 @@
+module RuboCop::Callbacksystems::Helpers::Builders
+  SELF_REBINDING_METHODS = %i[ instance_eval instance_exec class_eval class_exec module_eval module_exec ]
+
+  def self_preserved_between?(node, boundary:)
+    SelfPreservation.new(node, boundary:).preserved?
+  end
+
+  def self_rebinding_boundary?(node)
+    SelfBoundary.new(node).rebinds?
+  end
+
+  def nested_body?(node)
+    class_with_body?(node) || module_with_body?(node)
+  end
+
+  def class_with_body?(node)
+    node.class_type? ? node.body.present? : builder_assignment_for(node).builds_class_with_body?
+  end
+
+  def module_with_body?(node)
+    node.module_type? ? node.body.present? : builder_assignment_for(node).builds_module_with_body?
+  end
+
+  private
+    def builder_assignment_for(node)
+      RuboCop::Callbacksystems::ClassStructure::BuilderAssignment.new(node)
+    end
+
+    # Whether one node keeps its lexical self before reaching a caller-selected boundary.
+    class SelfPreservation
+      def initialize(node, boundary:)
+        @node = node
+        @boundary = boundary
+      end
+
+      def preserved?
+        ancestors.none? { SelfBoundary.new(it, descendant: node).rebinds_around_descendant? }
+      end
+
+      private
+        attr_reader :node, :boundary
+
+        def ancestors
+          node.each_ancestor.take_while { !it.equal?(boundary) }
+        end
+    end
+
+    # A lexical construct or block whose body observes a self other than the surrounding expression.
+    class SelfBoundary
+      include RuboCop::Callbacksystems::Helpers
+
+      def initialize(node, descendant: nil)
+        @node = node
+        @descendant = descendant
+      end
+
+      def rebinds_around_descendant?
+        rebinds? && rebound_parts.any? { contains_descendant?(it) }
+      end
+
+      def rebinds?
+        lexical_definition?(node) || (any_block_type?(node) && self_rebinding_block?)
+      end
+
+      private
+        attr_reader :node, :descendant
+
+        def self_rebinding_block?
+          method_definition_block?(node) || self_rebinding_builder? || self_rebinding_evaluator?
+        end
+
+        def self_rebinding_builder?
+          core_constant?(block_call.receiver) &&
+            builder_method_for(block_call.receiver.short_name) == block_call.method_name
+        end
+
+        def block_call
+          @block_call ||= call_of(node)
+        end
+
+        def builder_method_for(name)
+          RuboCop::Callbacksystems::ClassStructure::BuilderAssignment::CLASS_BUILDERS[name] ||
+            RuboCop::Callbacksystems::ClassStructure::BuilderAssignment::MODULE_BUILDERS[name]
+        end
+
+        def self_rebinding_evaluator?
+          block_call.receiver && !block_call.receiver.self_type? &&
+            SELF_REBINDING_METHODS.include?(block_call.method_name)
+        end
+
+        def rebound_parts
+          if any_block_type?(node) || node.any_def_type?
+            [ node.arguments, node.body ].compact
+          else
+            [ node.body ].compact
+          end
+        end
+
+        def contains_descendant?(part)
+          part.equal?(descendant) || part.source_range&.contains?(descendant.source_range)
+        end
+    end
+end

data/lib/rubocop/callbacksystems/helpers/comments.rb

@@ -0,0 +1,56 @@
+module RuboCop::Callbacksystems::Helpers::Comments
+  TOOLING_MARKER = %r{
+    \A\#\s*
+    (?:
+      :?[a-z][\w-]*(?::[a-z][\w-]*)+:?
+      |
+      :[a-z][\w-]*:
+      |
+      (?:typed|rbs_inline):\s+(?:disabled|enabled|false|ignore|strict|strong|true|weak)
+      |
+      @(?:dynamic|implements|rbs|type)
+      |
+      :?(?:nocov|nodoc):?
+      |
+      [a-z][\w-]*-ignore
+    )
+    (?:\s|\z)
+  }ix
+
+  def comment_removal_range_for(comment)
+    own_line_comment?(comment) ? line_removal_range_for(comment) : trailing_comment_range_for(comment)
+  end
+
+  def own_line_comment?(comment)
+    range = comment.source_range
+    range.source_line[0...range.column].strip.empty?
+  end
+
+  def comment_blocks_in(processed_source, reject_tooling_runs: false)
+    RuboCop::Callbacksystems::Source::CommentBlocks.new(processed_source, reject_tooling_runs:)
+  end
+
+  def prose_comments_in(processed_source)
+    processed_source.comments.reject { tooling_comment?(it) }
+  end
+
+  def tooling_comment?(comment)
+    comment.text.start_with?("#!") || RuboCop::MagicComment.parse(comment.text).any? ||
+      RuboCop::DirectiveComment.new(comment).start_with_marker? || rdoc_directive?(comment) ||
+      comment.text.match?(TOOLING_MARKER)
+  end
+
+  private
+    def trailing_comment_range_for(comment)
+      range = comment.source_range
+      range.with(begin_pos: range.begin_pos - range.column + code_before(range).rstrip.length)
+    end
+
+    def code_before(range)
+      range.source_line[0...range.column]
+    end
+
+    def rdoc_directive?(comment)
+      comment.text.match?(/\A#(?:--|\+\+)\s*\z/)
+    end
+end

data/lib/rubocop/callbacksystems/helpers/corrections.rb

@@ -0,0 +1,15 @@
+module RuboCop::Callbacksystems::Helpers::Corrections
+  # A shorthand keyword's synthetic value shares the key's source range, so replacing that node would rename the key.
+  def replace_expression(corrector, node, with:)
+    if shorthand_keyword_value?(node)
+      corrector.insert_after(node.parent, " #{with}")
+    else
+      corrector.replace(node, with)
+    end
+  end
+
+  private
+    def shorthand_keyword_value?(node)
+      node.parent&.pair_type? && node.equal?(node.parent.value) && node.parent.value_omission?
+    end
+end

data/lib/rubocop/callbacksystems/helpers/methods.rb

@@ -0,0 +1,46 @@
+module RuboCop::Callbacksystems::Helpers::Methods
+  PARAMETER_TYPES = %i[ arg optarg kwarg kwoptarg ]
+
+  BUILDER_METHODS = %i[
+    new
+    create build update
+    assign_attributes update_attribute update_column update_columns
+    find find_by find_sole_by
+    find_or_create_by find_or_initialize_by create_or_find_by
+    destroy_by delete_by
+    permit expect
+  ].to_set
+
+  def builder_method?(node)
+    BUILDER_METHODS.include?(node.method_name)
+  end
+
+  def parameter_names_of(method_node)
+    parameter_nodes_of(method_node).map { it.children.first.to_s }
+  end
+
+  def parameter_nodes_of(method_node)
+    method_node.arguments.children.select { parameter_node?(it) }
+  end
+
+  def parameter_node?(node)
+    node&.type?(*PARAMETER_TYPES)
+  end
+
+  def inside_initialize?(node)
+    node.each_ancestor(:any_def).any? { it.method?(:initialize) }
+  end
+
+  # A definition below another method or a block may belong to a receiver established only at runtime. Attribute only
+  # definitions whose path to the nearest named class or module crosses neither boundary.
+  def direct_method_definition?(node)
+    enclosing_class_or_module_of(node)&.then do |owner|
+      node.each_ancestor.take_while { !it.equal?(owner) }
+        .none? { it.any_def_type? || any_block_type?(it) }
+    end || false
+  end
+
+  def single_send_private_non_predicate?(method_node)
+    method_node.body&.send_type? && private_method?(method_node) && !method_node.predicate_method?
+  end
+end

data/lib/rubocop/callbacksystems/helpers/names.rb

@@ -0,0 +1,65 @@
+module RuboCop::Callbacksystems::Helpers::Names
+  def literal_name_of(node)
+    node.type?(:sym, :str) ? node.value.to_s : node.source
+  end
+
+  def declared_name_of(statement)
+    case statement.type
+    when :casgn, :lvasgn then statement.name
+    when :class, :module then statement.identifier.short_name
+    end
+  end
+
+  def name_arguments_of(node)
+    node.arguments.select { it.type?(:sym, :str) }
+  end
+
+  def class_name_of(node)
+    node.class_type? ? node.identifier.source : node.name.to_s
+  end
+
+  def name_without_sigil(name)
+    name.to_s.sub(/\A(?:@@|@|\$)/, "")
+  end
+
+  def constant_name_of(node)
+    if node
+      ConstantName.new(node).to_s
+    end
+  end
+
+  private
+    class ConstantName
+      def initialize(node)
+        @current = node
+        @names = []
+      end
+
+      def to_s
+        traverse
+        name if complete?
+      end
+
+      private
+        attr_reader :current, :names
+
+        def traverse
+          while current&.const_type?
+            names << current.short_name
+            @current = current.namespace
+          end
+        end
+
+        def complete?
+          current.nil? || current.cbase_type?
+        end
+
+        def name
+          "#{prefix}#{names.reverse.join("::")}"
+        end
+
+        def prefix
+          "::" if current && names.any?
+        end
+    end
+end