rubocop-callbacksystems 0.1.0

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

@@ -0,0 +1,218 @@
+class RuboCop::Callbacksystems::Methods::Definitions
+  include Enumerable
+  include RuboCop::Callbacksystems::Helpers
+
+  delegate :each, to: :definitions
+
+  def initialize(ast)
+    @ast = ast
+  end
+
+  private
+    Definition = Data.define(:node, :name)
+
+    attr_reader :ast
+
+    def definitions
+      bodies = top_level_definitions_in(ast).map { Body.new(it.body, depth: 0, context: :owner) }
+
+      Traversal.new(bodies).to_a
+    end
+
+    # Definition-bearing body and statement entries walked depth first without recursive object calls.
+    class Traversal
+      include Enumerable
+
+      def initialize(entries)
+        @entries = entries
+      end
+
+      def each
+        if block_given?
+          pending = entries.reverse
+          until pending.empty?
+            entry = pending.pop
+            entry.definitions.each { yield it }
+            pending.concat(entry.children.reverse)
+          end
+        else
+          to_enum(__method__)
+        end
+      end
+
+      private
+        attr_reader :entries
+    end
+
+    class Body
+      include RuboCop::Callbacksystems::Helpers
+
+      def initialize(node, depth:, context:, singleton_owner_body: nil)
+        @node = node
+        @depth = depth
+        @context = context
+        @singleton_owner_body = singleton_owner_body
+      end
+
+      def definitions
+        []
+      end
+
+      def children
+        statements_in(node).map { Statement.new(it, body: self) }
+      end
+
+      def public_definition?(definition)
+        DefinitionVisibility.new(definition, node, singleton_owner_body:).public?
+      end
+
+      def target_definition?(definition)
+        depth_of(definition) <= 1
+      end
+
+      def target_scope?
+        depth.zero?
+      end
+
+      def body_within_singleton_section(child)
+        if depth.zero?
+          self.class.new(child, depth: 1, context: :singleton, singleton_owner_body: node)
+        end
+      end
+
+      def body_within_definition_block(child, kind:)
+        unless context == :singleton
+          self.class.new(child, depth: kind == :class_methods ? 1 : 0, context: :definition_block)
+        end
+      end
+
+      private
+        attr_reader :node, :depth, :context, :singleton_owner_body
+
+        def depth_of(definition)
+          depth + (definition.defs_type? ? 1 : 0)
+        end
+
+        class DefinitionVisibility
+          include RuboCop::Callbacksystems::Helpers
+
+          def initialize(definition, body, singleton_owner_body:)
+            @definition = definition
+            @body = body
+            @singleton_owner_body = singleton_owner_body
+          end
+
+          def public?
+            level == :public
+          end
+
+          private
+            attr_reader :definition, :body, :singleton_owner_body
+
+            def level
+              if definition.location
+                assigned_level || visibility_applied_to(definition.parent, definition) || default_level
+              else
+                :public
+              end
+            end
+
+            def assigned_level
+              assignments.max_by(&:position)&.level
+            end
+
+            def assignments
+              [
+                visibility.assignment_after(definition, singleton: definition.defs_type?),
+                singleton_owner_visibility&.assignment_after(definition, singleton: true)
+              ].compact
+            end
+
+            def visibility
+              @visibility ||= RuboCop::Callbacksystems::ClassStructure::Visibility.for(body)
+            end
+
+            def singleton_owner_visibility
+              if singleton_owner_body
+                RuboCop::Callbacksystems::ClassStructure::Visibility.for(singleton_owner_body)
+              end
+            end
+
+            def default_level
+              definition.defs_type? ? :public : visibility.level_at(definition)
+            end
+        end
+    end
+
+    class Statement
+      include RuboCop::Callbacksystems::Helpers
+
+      DEFINITION_BLOCKS = %i[ class_methods included prepended ].to_set
+
+      def initialize(node, body:)
+        @node = node
+        @body = body
+      end
+
+      def definitions
+        explicit_definitions + scope_entry
+      end
+
+      def children
+        if singleton_section?(node)
+          singleton_body.then { [ it ].compact }
+        elsif known_definition_block?
+          definition_block_body.then { [ it ].compact }
+        else
+          []
+        end
+      end
+
+      private
+        attr_reader :node, :body
+
+        def explicit_definitions
+          method_definitions.filter_map do |definition|
+            if owned_definition?(definition) && body.public_definition?(definition)
+              Definition.new(definition, definition.method_name)
+            end
+          end
+        end
+
+        def method_definitions
+          if node.any_def_type?
+            [ node ]
+          elsif node.call_type?
+            node.arguments.select(&:any_def_type?)
+          else
+            []
+          end
+        end
+
+        def owned_definition?(definition)
+          body.target_definition?(definition) && (!definition.defs_type? || definition.receiver.self_type?)
+        end
+
+        def scope_entry
+          call = call_of(node)
+
+          if body.target_scope? && scope_definition?(call)
+            [ Definition.new(call, call.first_argument.value) ]
+          else
+            []
+          end
+        end
+
+        def singleton_body
+          body.body_within_singleton_section(node.body)
+        end
+
+        def known_definition_block?
+          any_block_type?(node) && call_on_self?(call_of(node)) && DEFINITION_BLOCKS.include?(node.method_name)
+        end
+
+        def definition_block_body
+          body.body_within_definition_block(node.body, kind: node.method_name)
+        end
+    end
+end

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

@@ -0,0 +1,144 @@
+class RuboCop::Callbacksystems::Methods::DelegateMacro
+  include RuboCop::Callbacksystems::Helpers
+
+  MISSING_DELEGATE_METHODS = %i[ method_missing respond_to_missing? ]
+
+  def initialize(node)
+    @node = node
+  end
+
+  def macro?
+    delegate_macro?(node) && !options.nil?
+  end
+
+  def target
+    value_of(:to)&.then { name_of(it) }
+  end
+
+  # The methods read on the delegation target, before a prefix changes the methods this macro defines.
+  def target_method_names
+    literal_method_names if node.method?(:delegate)
+  end
+
+  # Nothing is returned when a dynamic argument or option leaves the names unknowable without executing the file.
+  def defined_method_names
+    if node.method?(:delegate_missing_to)
+      MISSING_DELEGATE_METHODS
+    elsif node.method?(:delegate)
+      prefixed_method_names
+    end
+  end
+
+  def private?
+    visibility == :private
+  end
+
+  def plain?(private:)
+    visibility == (private ? :private : :public) && inactive_option?(:prefix) && inactive_option?(:allow_nil)
+  end
+
+  def private_option_known?
+    options && option_known?(:private)
+  end
+
+  def private_option
+    option_for(:private)
+  end
+
+  def first_option
+    keyword_options.elements.first || options
+  end
+
+  def last_option
+    keyword_options.elements.last || options
+  end
+
+  private
+    attr_reader :node
+
+    def options
+      node.last_argument if node.last_argument&.hash_type?
+    end
+
+    def value_of(key)
+      option_for(key)&.value
+    end
+
+    def option_for(key)
+      keyword_options.option_for(key) if options
+    end
+
+    def keyword_options
+      @keyword_options ||= RuboCop::Callbacksystems::Hashes::KeywordOptions.new(options)
+    end
+
+    def name_of(value)
+      literal_name_of(value) if value.type?(:sym, :str, :const)
+    end
+
+    def literal_method_names
+      method_arguments.filter_map { literal_method_name_of(it) }.then do |names|
+        names if names.size == method_arguments.size
+      end
+    end
+
+    def method_arguments
+      @method_arguments ||= node.arguments.reject { it.equal?(options) }
+    end
+
+    def literal_method_name_of(argument)
+      argument.value.to_sym if argument.type?(:sym, :str)
+    end
+
+    def prefixed_method_names
+      if target_method_names && option_known?(:prefix)
+        prefix = prefix_name
+
+        if prefix || !prefix_active?
+          target_method_names.map { prefix ? :"#{prefix}_#{it}" : it }
+        end
+      end
+    end
+
+    def option_known?(key)
+      options.nil? || keyword_options.known?(key)
+    end
+
+    def prefix_name
+      value = value_of(:prefix)
+
+      if value&.true_type?
+        target if target&.match?(/\A[a-z_]/)
+      elsif value&.type?(:sym, :str)
+        value.value.to_s
+      end
+    end
+
+    def prefix_active?
+      value = value_of(:prefix)
+
+      value && !value.falsey_literal?
+    end
+
+    def visibility
+      if private_option
+        literal_visibility
+      elsif options && keyword_options.known?(:private)
+        :public
+      end
+    end
+
+    def literal_visibility
+      if private_option.value.true_type?
+        :private
+      elsif private_option.value.falsey_literal?
+        :public
+      end
+    end
+
+    def inactive_option?(key)
+      option = option_for(key)
+
+      option ? option.value.falsey_literal? : options && keyword_options.known?(key)
+    end
+end

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

@@ -0,0 +1,55 @@
+# The receiver of a hand-written delegation, read as the target a `delegate` macro would name. A constant stands for
+# itself (`to: Currency`), a call on self becomes a symbol (`to: :registry`), and a chain of them becomes a dotted
+# string (`to: "config.postgres"`). Anything else in the chain gives up the whole reading.
+class RuboCop::Callbacksystems::Methods::DelegationTarget
+  def initialize(receiver)
+    @receiver = receiver
+  end
+
+  def delegable?
+    constant? || chain_names.any?
+  end
+
+  def source
+    constant? ? name : quoted_name
+  end
+
+  def name
+    constant? ? receiver.source : chain_names.join(".")
+  end
+
+  def nested?
+    chain_names.many?
+  end
+
+  private
+    attr_reader :receiver
+
+    def constant?
+      receiver&.const_type? || false
+    end
+
+    def chain_names
+      @chain_names ||= names_in(receiver) || []
+    end
+
+    def names_in(node)
+      names = []
+      current = node
+
+      while chained_call?(current)
+        names << current.method_name
+        current = current.receiver
+      end
+
+      names.reverse if current.nil? || current.self_type?
+    end
+
+    def chained_call?(node)
+      node&.send_type? && node.arguments.empty?
+    end
+
+    def quoted_name
+      nested? ? "\"#{name}\"" : ":#{name}"
+    end
+end

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

@@ -0,0 +1,77 @@
+# The class or module and instance/singleton side where a method definition or receiverless call resolves.
+class RuboCop::Callbacksystems::Methods::Domain
+  include RuboCop::Callbacksystems::Helpers
+
+  def initialize(node)
+    @node = node
+  end
+
+  def container
+    @container ||= domain_node.each_ancestor.find { method_owner_boundary?(it) }
+  end
+
+  def scope
+    singleton? ? :singleton : :instance
+  end
+
+  def singleton?
+    singleton_depth.positive?
+  end
+
+  def singleton_depth
+    identity.size
+  end
+
+  def identity
+    @identity ||= singleton_path.freeze
+  end
+
+  private
+    attr_reader :node
+
+    def domain_node
+      method_node || node
+    end
+
+    def method_node
+      node.any_def_type? ? node : enclosing_method_of(node)
+    end
+
+    # A block around a definition may establish its receiver only when it runs (`Class.new`, `included`, `class_eval`,
+    # and user macros). Treat it as an opaque owner rather than attributing the definition to the named outer class.
+    def method_owner_boundary?(candidate)
+      candidate.type?(:class, :module) || any_block_type?(candidate)
+    end
+
+    def singleton_path
+      lexical_singleton_classes.reverse_each.map { singleton_class_identity(it) }.tap do |path|
+        path << explicit_singleton_identity if explicit_singleton?
+      end
+    end
+
+    def lexical_singleton_classes
+      domain_node.each_ancestor(:sclass, :class, :module).take_while { !it.type?(:class, :module) }.to_a
+    end
+
+    def singleton_class_identity(singleton_class)
+      singleton_class.children.first.self_type? ? :self : [ :expression, singleton_class.source_range.begin_pos ]
+    end
+
+    def explicit_singleton?
+      if method_node
+        method_node.defs_type?
+      else
+        !container.nil?
+      end
+    end
+
+    # A definition on some other object does not belong to the container's class side. Its own body still shares this
+    # identity with the receiverless calls it holds, while definitions on unrelated expressions remain separate.
+    def explicit_singleton_identity
+      if method_node&.defs_type? && !method_node.receiver.self_type?
+        [ :expression, method_node.receiver.source_range.begin_pos ]
+      else
+        :self
+      end
+    end
+end

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

@@ -0,0 +1,17 @@
+module RuboCop::Callbacksystems::Methods::ImplicitInvocations
+  # These hooks supplement the smaller runtime set shipped by RuboCop 1.89.
+  RUNTIME_METHODS = %i[
+    coerce instance_variables_to_inspect
+    inherited included extended prepended
+    append_features extend_object prepend_features
+    const_missing const_added
+    method_added method_removed method_undefined
+    singleton_method_added singleton_method_removed singleton_method_undefined
+  ].to_set | RuboCop::Cop::Lint::UnusedPrivateMethod::IMPLICITLY_INVOKED_METHODS
+  PROTOCOL_METHODS = %i[
+    initialize to_hash to_h to_str to_s to_ary to_a to_proc to_int to_i to_path
+    == eql? hash <=> === each call inspect as_json to_json
+    deconstruct deconstruct_keys encode_with init_with yaml_initialize
+  ].to_set
+  METHOD_NAMES = RUNTIME_METHODS | PROTOCOL_METHODS
+end