rubocop-callbacksystems 0.1.0

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

@@ -0,0 +1,238 @@
+class RuboCop::Callbacksystems::Methods::MacroReferences
+  include Enumerable
+  include RuboCop::Callbacksystems::Helpers
+
+  delegate :each, to: :names_in_source_order
+
+  def initialize(body)
+    @body = body
+  end
+
+  private
+    attr_reader :body
+
+    def names_in_source_order
+      @names_in_source_order ||= References.new(body).to_a.uniq
+    end
+
+    # References in one lexical owner, with method bodies skipped and nested class domains pruned.
+    class References
+      include Enumerable
+
+      def initialize(body)
+        @body = body
+      end
+
+      def each
+        if block_given?
+          pending = [ Visit.new(body, block_calls_collected: false) ]
+          until pending.empty?
+            visit = pending.pop
+            unless visit.boundary?
+              visit.method_names.each { yield it }
+              pending.concat(visit.children.reverse)
+            end
+          end
+        else
+          to_enum(__method__)
+        end
+      end
+
+      private
+        attr_reader :body
+
+        class Visit
+          include RuboCop::Callbacksystems::Helpers
+
+          def initialize(node, block_calls_collected:)
+            @node = node
+            @block_calls_collected = block_calls_collected
+          end
+
+          def boundary?
+            node.nil? || node.type?(:def, :defs, :class, :module, :sclass)
+          end
+
+          def method_names
+            if any_block_type?(node)
+              block_calls_collected ? [] : BlockCalls.new(node.body).to_a
+            else
+              Statement.new(node).references
+            end
+          end
+
+          def children
+            node.each_child_node.map do |child|
+              self.class.new(child, block_calls_collected: block_calls_collected || any_block_type?(node))
+            end
+          end
+
+          private
+            attr_reader :node, :block_calls_collected
+        end
+    end
+
+    # Receiverless calls in the first block of a nested block tree, including its method definitions as before.
+    class BlockCalls
+      include Enumerable
+      include RuboCop::Callbacksystems::Helpers
+
+      def initialize(body)
+        @body = body
+      end
+
+      def each
+        if block_given?
+          pending = [ body ].compact
+          until pending.empty?
+            node = pending.pop
+            unless node.type?(:class, :module, :sclass)
+              yield node.method_name if bare_send?(node)
+              pending.concat(node.each_child_node.to_a.reverse)
+            end
+          end
+        else
+          to_enum(__method__)
+        end
+      end
+
+      private
+        attr_reader :body
+    end
+
+    class Statement
+      include RuboCop::Callbacksystems::Helpers
+
+      CALLBACK_OPTIONS = %i[ if unless ]
+
+      # Unknown class macros can take symbols as data (`validates :name`), so only these known callbacks let a
+      # positional symbol make a method look referenced.
+      METHOD_REFERENCE_MACROS = %i[
+        after_action after_commit after_create after_create_commit after_destroy after_destroy_commit
+        after_deliver after_discard after_enqueue after_find after_initialize after_perform after_rollback
+        after_save after_save_commit after_touch after_update after_update_commit after_validation before_action
+        before_commit before_create before_deliver before_destroy before_enqueue before_perform before_save
+        before_update before_validation around_action around_create around_deliver around_destroy around_enqueue
+        around_perform around_save around_update append_after_action append_around_action append_before_action
+        helper_method prepend_after_action prepend_around_action prepend_before_action rescue_from setup
+        skip_after_action skip_around_action skip_before_action teardown validate
+      ]
+      CALLBACK_CONFIGURATION_MACROS = %i[ set_callback skip_callback ]
+
+      # `delegate` defines its leading names as the accessors do, and its `to:` target still counts through the options.
+      DEFINING_MACROS = %i[
+        attr_reader attr_writer attr_accessor
+        mattr_reader mattr_writer mattr_accessor
+        cattr_reader cattr_writer cattr_accessor
+        thread_mattr_accessor thread_cattr_accessor
+        class_attribute store_accessor attribute delegate
+      ]
+
+      def initialize(node)
+        @node = node
+      end
+
+      def references
+        node.send_type? ? from_send : []
+      end
+
+      private
+        attr_reader :node
+
+        # A callback's `if:`/`unless:` runs before the action it guards, so the hash options lead.
+        def from_send
+          hash_option_references + symbol_arguments + lambda_argument_calls
+        end
+
+        def hash_option_references
+          hash_pairs_of(node).flat_map { OptionReference.new(node, it).to_a }
+        end
+
+        def symbol_arguments
+          if CALLBACK_CONFIGURATION_MACROS.include?(node.method_name)
+            configured_callback_arguments
+          elsif METHOD_REFERENCE_MACROS.include?(node.method_name) && DEFINING_MACROS.exclude?(node.method_name)
+            node.arguments.select(&:sym_type?).map(&:value)
+          else
+            []
+          end
+        end
+
+        # The event and timing in `set_callback :save, :before, :normalize` are data; only the remaining filters name
+        # methods.
+        def configured_callback_arguments
+          node.arguments.drop(2).select(&:sym_type?).map(&:value)
+        end
+
+        def lambda_argument_calls
+          node.arguments.select { any_block_type?(it) }.flat_map { receiverless_method_names_in(it.body) }
+        end
+
+        # One callback option read as the method names its key and value can reference.
+        class OptionReference
+          include RuboCop::Callbacksystems::Helpers
+
+          def initialize(macro, pair)
+            @macro = macro
+            @key = pair.key
+            @value = pair.value
+          end
+
+          def to_a
+            if key.sym_type?
+              case key.value
+              when :to then delegate_target
+              when *CALLBACK_OPTIONS then callback_condition
+              when :with then rescue_handler
+              else []
+              end
+            else
+              []
+            end
+          end
+
+          private
+            attr_reader :macro, :key, :value
+
+            def delegate_target
+              case value.type
+              when :sym then [ value.value ]
+              when :str then Array(value.value.split(".").first&.to_sym)
+              else []
+              end
+            end
+
+            def callback_condition
+              if value.sym_type?
+                [ value.value ]
+              elsif any_block_type?(value)
+                receiverless_method_names_in(value.body)
+              else
+                []
+              end
+            end
+
+            def rescue_handler
+              macro.method?(:rescue_from) && value.sym_type? ? [ value.value ] : []
+            end
+        end
+    end
+
+    class ContainerIndex
+      def initialize
+        @by_container = {}.compare_by_identity
+      end
+
+      def include?(name, beside:)
+        container = RuboCop::Callbacksystems::Methods::Domain.new(beside).container
+        container && references_in(container).include?(name)
+      end
+
+      private
+        attr_reader :by_container
+
+        def references_in(container)
+          by_container[container] ||= RuboCop::Callbacksystems::Methods::MacroReferences.new(container.body).to_set
+        end
+    end
+end

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

@@ -0,0 +1,74 @@
+# Source nodes that can name or expose a method, indexed in one walk and shared by every cop reading the same AST.
+class RuboCop::Callbacksystems::Methods::ReferenceEvidence
+  IDENTIFIER_PATTERN = /[a-zA-Z_]\w*[?!=]?/
+
+  delegate :calls, :block_passes, :alias_nodes, :literals, :interpolated_literals, to: :nodes
+
+  class << self
+    def for(root)
+      mutex.synchronize { cache[root] ||= new(root) }
+    end
+
+    private
+      def mutex
+        @mutex ||= Mutex.new
+      end
+
+      def cache
+        @cache ||= ObjectSpace::WeakMap.new
+      end
+  end
+
+  def initialize(root)
+    @root = root
+  end
+
+  def macro_referenced_methods
+    @macro_referenced_methods ||= RuboCop::Callbacksystems::Methods::MacroReferences.new(root).to_set
+  end
+
+  def literal_method_names
+    @literal_method_names ||= literals.flat_map do |literal|
+      if literal.sym_type?
+        literal.value.to_s
+      else
+        literal.value.to_s.scrub.scan(IDENTIFIER_PATTERN)
+      end
+    end.to_set
+  end
+
+  private
+    attr_reader :root
+
+    def nodes
+      @nodes ||= Nodes.new(root)
+    end
+
+    # The relevant node kinds partitioned during one traversal without losing source order between send and csend.
+    class Nodes
+      TYPES = %i[ alias block_pass csend dstr dsym send str sym ]
+
+      attr_reader :calls, :block_passes, :alias_nodes, :literals, :interpolated_literals
+
+      def initialize(root)
+        @calls = []
+        @block_passes = []
+        @alias_nodes = []
+        @literals = []
+        @interpolated_literals = []
+
+        root.each_node(*TYPES).each { partition(it) }
+      end
+
+      private
+        def partition(node)
+          case node.type
+          when :send, :csend then calls << node
+          when :block_pass then block_passes << node
+          when :alias then alias_nodes << node
+          when :str, :sym then literals << node
+          when :dstr, :dsym then interpolated_literals << node
+          end
+        end
+    end
+end

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

@@ -0,0 +1,24 @@
+# Direct method definitions indexed within a class or module and its instance/singleton sides.
+class RuboCop::Callbacksystems::Methods::Siblings
+  include RuboCop::Callbacksystems::Helpers
+
+  def initialize
+    @by_container = {}.compare_by_identity
+  end
+
+  def named(name, beside:)
+    domain = RuboCop::Callbacksystems::Methods::Domain.new(beside)
+    definitions_in(domain.container).fetch([ domain.identity, name ]) { [] }
+  end
+
+  private
+    attr_reader :by_container
+
+    def definitions_in(container)
+      return {} if container.nil?
+
+      by_container[container] ||= direct_method_nodes_in(container.body).group_by do |method_node|
+        [ RuboCop::Callbacksystems::Methods::Domain.new(method_node).identity, method_node.method_name ]
+      end
+    end
+end

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

@@ -0,0 +1,68 @@
+# The method names one class-body statement defines. A missing result means the statement does define methods, but their
+# complete names cannot be proven without executing the file.
+class RuboCop::Callbacksystems::Methods::StatementDefinitions
+  include RuboCop::Callbacksystems::Helpers
+
+  RUBY_ACCESSOR_MACROS = %i[ attr_reader attr_writer attr_accessor ]
+
+  def initialize(statement)
+    @statement = statement
+  end
+
+  def names
+    @names ||= explicit_definition_names || macro_definition_names
+  end
+
+  private
+    attr_reader :statement
+
+    def explicit_definition_names
+      Set[statement.method_name] if statement.type?(:def, :defs)
+    end
+
+    def macro_definition_names
+      if delegate_macro?(macro)
+        RuboCop::Callbacksystems::Methods::DelegateMacro.new(macro).defined_method_names&.to_set
+      elsif scope_macro?
+        scope_names
+      elsif ruby_accessor_macro?
+        accessor_names
+      elsif attribute_macro?(macro) || association_macro?(macro)
+        nil
+      else
+        Set.new
+      end
+    end
+
+    def macro
+      @macro ||= call_of(statement)
+    end
+
+    def scope_macro?
+      bare_send?(macro) && macro.method?(:scope)
+    end
+
+    def scope_names
+      name = macro.first_argument
+
+      name&.type?(:sym, :str) ? Set[name.value.to_sym] : nil
+    end
+
+    def ruby_accessor_macro?
+      bare_send?(macro) && RUBY_ACCESSOR_MACROS.include?(macro.method_name)
+    end
+
+    def accessor_names
+      return if macro.arguments.any? { !it.type?(:sym, :str) }
+
+      names = name_arguments_of(macro).to_set { it.value.to_sym }
+
+      if macro.method?(:attr_reader)
+        names
+      elsif macro.method?(:attr_writer)
+        names.to_set { :"#{it}=" }
+      else
+        names | names.to_set { :"#{it}=" }
+      end
+    end
+end

data/lib/rubocop/callbacksystems/offense.rb

@@ -0,0 +1,13 @@
+class RuboCop::Callbacksystems::Offense
+  attr_reader :range, :message, :correction
+
+  def initialize(range, message, correcting: true, &correction)
+    @range = range
+    @message = message
+    @correction = correcting ? correction : nil
+  end
+
+  def correct(corrector)
+    correction&.call(corrector)
+  end
+end

data/lib/rubocop/callbacksystems/plugin.rb

@@ -0,0 +1,27 @@
+require "lint_roller"
+
+class RuboCop::Callbacksystems::Plugin < LintRoller::Plugin
+  GEM_NAME = "rubocop-callbacksystems"
+  CONFIGURATION_PATH = File.expand_path("../../../config/default.yml", __dir__)
+
+  def about
+    LintRoller::About.new \
+      name: specification.name,
+      version: specification.version.to_s,
+      homepage: specification.homepage,
+      description: specification.summary
+  end
+
+  def supported?(context)
+    context.engine == :rubocop
+  end
+
+  def rules(context)
+    LintRoller::Rules.new(type: :path, config_format: :rubocop, value: CONFIGURATION_PATH)
+  end
+
+  private
+    def specification
+      @specification ||= Gem.loaded_specs.fetch(GEM_NAME)
+    end
+end

data/lib/rubocop/callbacksystems/project_index/cache.rb

@@ -0,0 +1,16 @@
+# One derived reading per consumer, replaced whenever its project graph or in-memory revision changes.
+module RuboCop::Callbacksystems::ProjectIndex::Cache
+  def for(project_index)
+    generation = RuboCop::Callbacksystems::ProjectIndex::Freshness.generation(project_index)
+    cached_index_reading.then do |index, cached_generation, reading|
+      if index.equal?(project_index) && cached_generation == generation
+        reading
+      else
+        new(project_index).tap { self.cached_index_reading = [ project_index, generation, it ] }
+      end
+    end
+  end
+
+  private
+    attr_accessor :cached_index_reading
+end

data/lib/rubocop/callbacksystems/project_index/confinement_cache.rb

@@ -0,0 +1,40 @@
+# Nested-class confinement analyses shared by every cop investigating the same AST. The weak key lets a completed source
+# leave the cache, while graph identity and generation keep an analysis from crossing project revisions.
+class RuboCop::Callbacksystems::ProjectIndex::ConfinementCache
+  class << self
+    def for(nested_class, declaration:, project_index:)
+      generation = RuboCop::Callbacksystems::ProjectIndex::Freshness.generation(project_index)
+      mutex.synchronize do
+        cached = cache[nested_class]
+
+        if cached&.matches?(declaration, project_index, generation:)
+          cached.confinement
+        else
+          confinement = RuboCop::Callbacksystems::ProjectIndex::NestedClassConfinement.new \
+            nested_class,
+            declaration: declaration,
+            project_index: project_index
+          cache[nested_class] = Entry.new(declaration.name, project_index, generation, confinement)
+          confinement
+        end
+      end
+    end
+
+    private
+      def mutex
+        @mutex ||= Mutex.new
+      end
+
+      def cache
+        @cache ||= ObjectSpace::WeakMap.new
+      end
+  end
+
+  private
+    class Entry < Data.define(:declaration_name, :project_index, :generation, :confinement)
+      def matches?(other_declaration, other_project_index, generation:)
+        declaration_name == other_declaration.name && project_index.equal?(other_project_index) &&
+          self.generation == generation
+      end
+    end
+end

data/lib/rubocop/callbacksystems/project_index/constant_references.rb

@@ -0,0 +1,74 @@
+# Resolved constant references from Rubydex, indexed once by their exact source location so AST readers can ask which
+# declaration a constant names without rebuilding or walking the project graph.
+class RuboCop::Callbacksystems::ProjectIndex::ConstantReferences
+  extend RuboCop::Callbacksystems::ProjectIndex::Cache
+
+  def within(processed_source)
+    Source.new \
+      project_index,
+      references_by_location,
+      RuboCop::Callbacksystems::ProjectIndex::SourceFile.new(processed_source.file_path).uri
+  end
+
+  private
+    attr_reader :project_index
+
+    def initialize(project_index)
+      @project_index = project_index
+    end
+
+    def references_by_location
+      @references_by_location ||= project_index.constant_references.grep(Rubydex::ResolvedConstantReference)
+        .group_by { RuboCop::Callbacksystems::ProjectIndex::Location.for_rubydex(it.location) }
+    end
+
+    # The references and resolver belonging to one source file.
+    class Source
+      include RuboCop::Cop::ProjectIndexHelp
+
+      def initialize(project_index, references_by_location, uri)
+        @project_index = project_index
+        @references_by_location = references_by_location
+        @uri = uri
+      end
+
+      def referenced_declaration_for(constant_node)
+        declarations_at(constant_node.loc.name).grep_v(Rubydex::SingletonClass)
+          .uniq(&:name).then { it.first if it.one? }
+      end
+
+      def declaration_named(name, beside:)
+        nesting = name.to_s.start_with?("::") ? [] : lexical_nesting_of(beside)
+        query = Resolution.new(name.to_s, nesting)
+
+        resolutions.fetch(query) { resolutions[query] = query.declaration_in(project_index) }
+      end
+
+      private
+        attr_reader :project_index, :references_by_location, :uri
+
+        def declarations_at(range)
+          location = RuboCop::Callbacksystems::ProjectIndex::Location.for_ast(range, uri:)
+          references_by_location.fetch(location) { [] }.map(&:declaration)
+        end
+
+        def resolutions
+          @resolutions ||= {}
+        end
+
+        class Resolution < Data.define(:name, :nesting)
+          def declaration_in(project_index)
+            segments.drop(1).reduce(project_index.resolve_constant(segments.first, nesting)) do |declaration, segment|
+              declaration.find_member(segment) if declaration.is_a?(Rubydex::Namespace)
+            end
+          rescue
+            nil
+          end
+
+          private
+            def segments
+              name.delete_prefix("::").split("::")
+            end
+        end
+    end
+end

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

@@ -0,0 +1,35 @@
+# Keeps the project index synchronized with RuboCop's in-memory autocorrection iterations. RuboCop has no public
+# correction lifecycle hook, so this adapter stays at the narrow write boundary and delegates the update itself to an
+# object that can fail closed.
+module RuboCop::Callbacksystems::ProjectIndex::Corrections
+  private
+    def apply_correction(processed_source, new_source)
+      Correction.new(cops, processed_source, new_source).update_project_index
+      super
+    end
+
+    class Correction
+      def initialize(cops, processed_source, new_source)
+        @cops = cops
+        @processed_source = processed_source
+        @new_source = new_source
+      end
+
+      def update_project_index
+        if project_index
+          RuboCop::Callbacksystems::ProjectIndex::Freshness.update(project_index, processed_source, new_source)
+        end
+      end
+
+      private
+        attr_reader :cops, :processed_source, :new_source
+
+        def project_index
+          @project_index ||= indexes.first if indexes.all? { it.equal?(indexes.first) }
+        end
+
+        def indexes
+          @indexes ||= cops.filter_map(&:project_index)
+        end
+    end
+end

data/lib/rubocop/callbacksystems/project_index/coverage.rb

@@ -0,0 +1,56 @@
+class RuboCop::Callbacksystems::ProjectIndex::Coverage
+  class << self
+    def register(project_index, paths:)
+      self.cached = [ project_index, new(project_index, paths:) ]
+    rescue
+      self.cached = [ project_index, nil ]
+    end
+
+    def complete?(project_index)
+      cached.then do |index, coverage|
+        coverage ? index.equal?(project_index) && coverage.complete? : false
+      end
+    end
+
+    private
+      attr_accessor :cached
+  end
+
+  def initialize(project_index, paths:)
+    @project_index = project_index
+    @expected_files = paths.to_set { RuboCop::Callbacksystems::ProjectIndex::SourceFile.new(it) }
+    @complete = missing_files.empty? || (supplemented? && indexed_files == expected_files)
+  end
+
+  def complete?
+    complete
+  end
+
+  private
+    attr_reader :project_index, :expected_files, :complete
+
+    def missing_files
+      @missing_files ||= expected_files - indexed_files
+    end
+
+    def indexed_files
+      project_index.documents.filter_map do |document|
+        if document.uri.start_with?(RuboCop::Cop::ProjectIndexHelp::FILE_URI_PREFIX)
+          RuboCop::Callbacksystems::ProjectIndex::SourceFile.for_document(document)
+        end
+      end.to_set
+    end
+
+    def supplemented?
+      missing_files.map { index_file(it) }.all?.tap { project_index.resolve }
+    rescue
+      false
+    end
+
+    def index_file(file)
+      project_index.index_source(file.uri, file.source, "ruby")
+      true
+    rescue
+      false
+    end
+end