rubocop-callbacksystems 0.1.0

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

@@ -0,0 +1,154 @@
+module RuboCop::Callbacksystems::Helpers::NodeTypes
+  BLOCK_NODE_TYPES = %i[ block numblock itblock ]
+
+  def declaration_macro?(node)
+    attribute_macro?(node) || delegate_macro?(node)
+  end
+
+  def attribute_macro?(node)
+    bare_send?(node) && ATTRIBUTE_MACROS.include?(node.method_name)
+  end
+
+  def bare_send?(node)
+    node&.send_type? && node.receiver.nil?
+  end
+
+  def delegate_macro?(node)
+    bare_send?(node) && DELEGATE_MACROS.include?(node.method_name)
+  end
+
+  def mixin_macro?(node)
+    bare_send?(node) && MIXIN_MACROS.include?(node.method_name)
+  end
+
+  def association_macro?(node)
+    bare_send?(node) && ASSOCIATION_MACROS.include?(node.method_name)
+  end
+
+  def call_on_self?(node)
+    node&.call_type? && (node.receiver.nil? || node.receiver.self_type?)
+  end
+
+  def singleton_section?(node)
+    node&.sclass_type? && node.identifier.self_type?
+  end
+
+  def structural_self?(node)
+    (node.parent&.sclass_type? && node.parent.identifier.equal?(node)) ||
+      (node.parent&.defs_type? && node.parent.receiver.equal?(node))
+  end
+
+  def definition_identifier?(node)
+    node.parent&.type?(:class, :module) && node.parent.identifier.equal?(node)
+  end
+
+  def reads_of(variable_name, within:)
+    nodes_in(within, :lvar, :ivar).select { reads_variable?(it, variable_name) }
+  end
+
+  def nodes_in(tree, *types)
+    tree ? tree.each_node(*types).to_a : []
+  end
+
+  def reads_variable?(node, variable_name)
+    node&.type?(:lvar, :ivar) && node.name == variable_name
+  end
+
+  def definition_nodes_in(tree)
+    nodes_in(tree, :class, :module, :sclass)
+  end
+
+  def reads_as_string?(node)
+    node && reads_as?(node, literals: STRING_LITERAL_TYPES, methods: STRING_RESULT_METHODS)
+  end
+
+  def reads_as?(node, literals:, methods:)
+    literals.include?(node.type) || (node.call_type? && methods.include?(node.method_name))
+  end
+
+  def reads_as_array?(node)
+    node&.array_type? || array_construction?(node)
+  end
+
+  def call_of(node)
+    any_block_type?(node) ? node.send_node : node
+  end
+
+  def any_block_type?(node)
+    node && BLOCK_NODE_TYPES.include?(node.type)
+  end
+
+  def core_constant?(node)
+    node&.const_type? && (node.namespace.nil? || node.namespace.cbase_type?)
+  end
+
+  def empty_collection_literal?(node)
+    node&.type?(:array, :hash) && node.children.empty?
+  end
+
+  def loop_block?(node)
+    node.method?(:loop)
+  end
+
+  def returned_expression_of(node)
+    node.return_type? ? node.children.first : node
+  end
+
+  def hash_pairs_of(send_node)
+    send_node.arguments.select(&:hash_type?).flat_map(&:pairs)
+  end
+
+  def top_level_definitions_in(node)
+    TopLevelDefinitions.new(node).to_a
+  end
+
+  private
+    ARRAY_CONSTRUCTION_METHODS = %i[ new [] ]
+    STRING_LITERAL_TYPES = %i[ dstr str xstr ]
+    STRING_RESULT_METHODS = %i[
+      to_s to_str to_json to_param to_query inspect join strip lstrip rstrip squish chomp chop
+      gsub sub tr delete_prefix delete_suffix upcase downcase capitalize swapcase titleize humanize
+      parameterize dasherize underscore camelize classify tableize demodulize truncate name
+    ]
+
+    ATTRIBUTE_MACROS =
+      %i[ attr_reader attr_writer attr_accessor attribute class_attribute has_secure_password has_secure_token ]
+    DELEGATE_MACROS = %i[ delegate delegate_missing_to ]
+    MIXIN_MACROS = %i[ include extend prepend ]
+    ASSOCIATION_MACROS = %i[
+      belongs_to has_many has_one has_and_belongs_to_many delegated_type
+      has_one_attached has_many_attached has_rich_text accepts_nested_attributes_for
+    ]
+
+    def array_construction?(node)
+      node&.send_type? && core_constant?(node.receiver) && node.receiver.short_name == :Array &&
+        ARRAY_CONSTRUCTION_METHODS.include?(node.method_name)
+    end
+
+    # Class and module definitions opened by a file, with only top-level begin nodes transparent.
+    class TopLevelDefinitions
+      include Enumerable
+
+      def initialize(node)
+        @node = node
+      end
+
+      def each
+        if block_given?
+          pending = [ node ].compact
+          until pending.empty?
+            current = pending.pop
+            case current.type
+            when :class, :module then yield current
+            when :begin then pending.concat(current.each_child_node.to_a.reverse)
+            end
+          end
+        else
+          to_enum(__method__)
+        end
+      end
+
+      private
+        attr_reader :node
+    end
+end

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

@@ -0,0 +1,52 @@
+module RuboCop::Callbacksystems::Helpers::Rails
+  EAGER_LOADING_METHODS = %i[ preload eager_load includes ]
+  CONTROLLER_SUPERCLASSES = %w[ ApplicationController ActionController::Base ActionController::API ]
+  STANDARD_CONTROLLER_ACTIONS = %i[ index show new create edit update destroy ]
+  RAILS_TEST_BASE_CLASSES = %w[
+    ActiveSupport::TestCase
+    ActionDispatch::IntegrationTest
+    ActionController::TestCase
+    ActionMailer::TestCase
+    ActionView::TestCase
+    ActiveJob::TestCase
+    ActionCable::TestCase
+    ActionCable::Channel::TestCase
+  ]
+
+  def controller_class?(node)
+    node&.class_type? && controller_superclass?(node.parent_class)
+  end
+
+  def controller_superclass?(superclass_node)
+    name = constant_name_of(superclass_node)&.delete_prefix("::")
+    name && (CONTROLLER_SUPERCLASSES.include?(name) || name.end_with?("Controller"))
+  end
+
+  def application_controller_class?(node)
+    node&.class_type? && node.identifier.short_name == :ApplicationController
+  end
+
+  def scope_definition?(node)
+    bare_send?(node) && node.method?(:scope) && node.first_argument&.sym_type?
+  end
+
+  def rails_test_base_class?(superclass_node)
+    RAILS_TEST_BASE_CLASSES.include?(constant_name_of(superclass_node)&.delete_prefix("::"))
+  end
+
+  def routes_file?(path)
+    path.present? && (path.include?("config/routes") || path.end_with?("routes.rb"))
+  end
+
+  def controller_file?(path)
+    path.present? && (path.split("/").include?("controllers") || path.end_with?("_controller.rb"))
+  end
+
+  def model_file?(path)
+    path.present? && path.tr("\\", "/").match?(%r{(?:\A|/)app/models/})
+  end
+
+  def test_file?(path)
+    path.present? && path.end_with?("_test.rb")
+  end
+end

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

@@ -0,0 +1,107 @@
+module RuboCop::Callbacksystems::Helpers::Ranges
+  include RuboCop::Cop::RangeHelp, RuboCop::Cop::Util
+
+  def statement_removal_range_for(node)
+    inline_statement_removal_range_for(node) || statement_removal_range_of(node.source_range)
+  end
+
+  # The buffer given explicitly is what frees this from a cop's processed source, so plain objects can use it too.
+  def statement_removal_range_of(source_range)
+    range = range_by_whole_lines(source_range, include_final_newline: true, buffer: source_range.source_buffer)
+    blank_line_above(range) || blank_line_below(range) || range
+  end
+
+  # Statements with only blank lines between them share one range, so their removal takes one blank line, not one each.
+  def statement_removal_ranges_of(source_ranges)
+    source_ranges
+      .slice_when { |left, right| code_between?(left, right) }
+      .map { statement_removal_range_of(span_of(it)) }
+  end
+
+  def span_of(ranges)
+    ranges.first.join(ranges.last)
+  end
+
+  def line_removal_range_for(node)
+    line_removal_range_of(node.source_range)
+  end
+
+  def line_removal_range_of(source_range)
+    range_by_whole_lines(source_range, include_final_newline: true, buffer: source_range.source_buffer)
+  end
+
+  def indentation_of(node)
+    " " * node.source_range.column
+  end
+
+  def call_prefix_of(node)
+    node.source_range.with(end_pos: node.loc.selector.begin_pos).source
+  end
+
+  def carries_heredoc?(node)
+    node.each_node(:str, :dstr, :xstr).any? { it.loc?(:heredoc_body) }
+  end
+
+  def range_through_heredocs(node)
+    node.source_range.with(end_pos: [ node.source_range.end_pos, *heredoc_ends_in(node) ].max)
+  end
+
+  def range_spanning(nodes)
+    span_of(nodes.map(&:source_range))
+  end
+
+  def fits_on_line?(node, source, max_line_length)
+    node.source_range.column + source.length + trailing_length_of(node) <= max_line_length
+  end
+
+  def trailing_length_of(node)
+    ending = node.source_range.end
+    ending.source_line.length - ending.column
+  end
+
+  def line_start_position_of(node)
+    range = node.source_range
+    range.begin_pos - range.column
+  end
+
+  private
+    def inline_statement_removal_range_for(node)
+      if same_line_siblings?([ node, node.right_sibling ])
+        node.source_range.with(end_pos: node.right_sibling.source_range.begin_pos)
+      elsif same_line_siblings?([ node.left_sibling, node ])
+        node.source_range.with(begin_pos: node.left_sibling.source_range.end_pos)
+      end
+    end
+
+    def same_line_siblings?(nodes)
+      left, right = nodes
+
+      left && right && left.parent.type?(:begin, :kwbegin) && left.parent.equal?(right.parent) &&
+        left.last_line == right.first_line
+    end
+
+    def blank_line_above(range)
+      buffer = range.source_buffer
+      line = buffer.line_for_position(range.begin_pos) - 1
+      range.with(begin_pos: buffer.line_range(line).begin_pos) if blank_line?(buffer, line)
+    end
+
+    def blank_line?(buffer, line)
+      line.between?(1, buffer.last_line) && buffer.source_line(line).match?(/\A[ \t]*\z/)
+    end
+
+    def blank_line_below(range)
+      buffer = range.source_buffer
+      line = buffer.line_for_position(range.end_pos)
+      end_of_blank = [ buffer.line_range(line).end_pos + 1, buffer.source.length ].min
+      range.with(end_pos: end_of_blank) if blank_line?(buffer, line)
+    end
+
+    def code_between?(left, right)
+      left.end.join(right.begin).source.strip.present?
+    end
+
+    def heredoc_ends_in(node)
+      node.each_node(:str, :dstr, :xstr).filter_map { it.loc.heredoc_end.end_pos if it.loc?(:heredoc_end) }
+    end
+end

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

@@ -0,0 +1,29 @@
+module RuboCop::Callbacksystems::Helpers::Recursion
+  # A recursion subject is a name passed both bare and as the receiver of a derived value: `walk(node.child, node)`.
+  def recursion_subject_names_in(node)
+    if node
+      calls = node.each_node(:send, :csend)
+      calls = [ node ].chain(calls) if node.call_type?
+      calls.flat_map { recursion_subjects_in(it) }.to_set
+    else
+      Set.new
+    end
+  end
+
+  def recursion_subjects_in(call)
+    receiver_names = derived_receiver_names_in(call)
+    direct_argument_names_in(call).select { receiver_names.include?(it) }
+  end
+
+  def derived_receiver_names_in(call)
+    call.arguments.filter_map { local_variable_name_of(it.receiver) if it.call_type? }.to_set
+  end
+
+  def local_variable_name_of(argument)
+    argument.children.first.to_s if argument&.lvar_type?
+  end
+
+  def direct_argument_names_in(call)
+    call.arguments.filter_map { local_variable_name_of(it) }
+  end
+end

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

@@ -0,0 +1,44 @@
+module RuboCop::Callbacksystems::Helpers::Variables
+  def deferred_callable_block?(node)
+    if any_block_type?(node)
+      call = call_of(node)
+
+      kernel_callable?(call) || proc_constructor?(call)
+    else
+      false
+    end
+  end
+
+  def method_definition_block?(node)
+    any_block_type?(node) && METHOD_DEFINITION_CALLS.include?(call_of(node).method_name)
+  end
+
+  def variable_name_of(node)
+    node.match_var_type? ? node.children.first : node.name
+  end
+
+  def conditional_return_of_block_argument?(return_node, block:)
+    value = return_node.children.first
+
+    return_node.parent.if_type? && value&.lvar_type? && block.argument_list.any? { it.name == value.name } &&
+      !name_rebound_between?(value.name, node: return_node, boundary: block)
+  end
+
+  def name_rebound_between?(name, node:, boundary:)
+    node.each_ancestor(:any_block).take_while { !it.equal?(boundary) }.any? do |block|
+      block.argument_list.any? { it.respond_to?(:name) && it.name.to_s == name.to_s }
+    end
+  end
+
+  private
+    METHOD_DEFINITION_CALLS = %i[ define_method define_singleton_method ]
+
+    def kernel_callable?(call)
+      %i[ lambda proc ].include?(call.method_name) &&
+        (call.receiver.nil? || (core_constant?(call.receiver) && call.receiver.short_name == :Kernel))
+    end
+
+    def proc_constructor?(call)
+      call.method?(:new) && core_constant?(call.receiver) && call.receiver.short_name == :Proc
+    end
+end

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

@@ -0,0 +1,121 @@
+module RuboCop::Callbacksystems::Helpers::Visibility
+  LEVELS = %i[ public protected private ]
+
+  def public_method?(node)
+    visibility_for(node).public?
+  end
+
+  def visibility_of(node)
+    visibility_for(node).level
+  end
+
+  def visibility_at(node, body)
+    visibility_for(node).level_in(body)
+  end
+
+  def enclosing_body_for(node)
+    visibility_for(node).enclosing_body
+  end
+
+  def enclosing_definition_of(node)
+    visibility_for(node).enclosing_definition
+  end
+
+  def private_modifier_in(body)
+    sections_in(body).private_modifier
+  end
+
+  def in_private_section?(node, body)
+    sections_in(body).in_private_section?(node)
+  end
+
+  def visibility_applied_to(node, definition)
+    if bare_send?(node) && node.arguments.include?(definition)
+      wrapped_visibility(node.method_name, definition)
+    end
+  end
+
+  def private_method?(node)
+    visibility_for(node).private?
+  end
+
+  def protected_method?(node)
+    visibility_for(node).protected?
+  end
+
+  def private_non_predicate?(node)
+    visibility_for(node).private_non_predicate?
+  end
+
+  def private_nested_class?(class_node)
+    enclosing = enclosing_class_or_module_of(class_node)
+    enclosing && private_nested_classes_in(enclosing).include?(class_node)
+  end
+
+  def enclosing_class_or_module_of(node)
+    node.each_ancestor(:class, :module).first
+  end
+
+  def private_nested_classes_in(class_node)
+    sections_in(class_node.body).private_nested_classes
+  end
+
+  def public_methods_in(class_node)
+    sections_in(class_node.body).public_method_nodes
+  end
+
+  def private_methods_in(class_node)
+    sections_in(class_node.body).private_method_nodes
+  end
+
+  def enclosing_method_of(node)
+    node.each_ancestor(:any_def).first
+  end
+
+  def enclosing_scope_of(node)
+    node.each_ancestor(:any_def, :any_block).first
+  end
+
+  def sibling_method_nodes_of(node)
+    direct_method_nodes_in(enclosing_class_or_module_of(node)&.body)
+  end
+
+  def leaves_public_section?(node)
+    %i[ private protected ].include?(visibility_modifier_of(node))
+  end
+
+  def visibility_modifier_of(node)
+    if bare_send?(node) && node.arguments.empty?
+      node.method_name if LEVELS.include?(node.method_name)
+    end
+  end
+
+  def private_constant_names_of(node)
+    names_marked_by(node, macro: :private_constant).map { it.value.to_sym }
+  end
+
+  def names_marked_by(node, macro:)
+    bare_send?(node) && node.method?(macro) ? name_arguments_of(node) : []
+  end
+
+  private
+    def visibility_for(node)
+      RuboCop::Callbacksystems::ClassStructure::NodeVisibility.new(node)
+    end
+
+    def sections_in(body)
+      RuboCop::Callbacksystems::ClassStructure::ClassBody.new(body)
+    end
+
+    def wrapped_visibility(modifier, definition)
+      case modifier
+      when *LEVELS then modifier if definition.def_type?
+      when :private_class_method then :private if self_singleton_definition?(definition)
+      when :public_class_method then :public if self_singleton_definition?(definition)
+      end
+    end
+
+    def self_singleton_definition?(definition)
+      definition.defs_type? && definition.receiver.self_type?
+    end
+end

data/lib/rubocop/callbacksystems/helpers.rb

@@ -0,0 +1,43 @@
+module RuboCop::Callbacksystems::Helpers
+  extend self
+
+  def const_added(name)
+    super
+    helper = const_get(name)
+    Wiring.new(self, helper).connect unless helper.is_a?(Class)
+  end
+
+  private
+    class Wiring
+      def initialize(helpers, submodule)
+        @helpers = helpers
+        @submodule = submodule
+      end
+
+      def connect
+        if helper_module?(submodule)
+          siblings.each { extend_mutually(it) }
+          helpers.include(submodule)
+        end
+      end
+
+      private
+        attr_reader :helpers, :submodule
+
+        def helper_module?(const)
+          const.is_a?(Module) && !const.is_a?(Class)
+        end
+
+        def siblings
+          helpers.constants.filter_map do |name|
+            candidate = helpers.const_get(name)
+            candidate if helper_module?(candidate) && candidate != submodule
+          end
+        end
+
+        def extend_mutually(other)
+          submodule.extend(other) unless submodule.singleton_class < other
+          other.extend(submodule) unless other.singleton_class < submodule
+        end
+    end
+end

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

@@ -0,0 +1,38 @@
+# Calls on self indexed by their enclosing class and method domain, so several definitions can ask who calls them
+# without each walking the whole class again.
+class RuboCop::Callbacksystems::Methods::Calls
+  include RuboCop::Callbacksystems::Helpers
+
+  def initialize(ast)
+    @ast = ast
+  end
+
+  def named(name, from:)
+    domain = RuboCop::Callbacksystems::Methods::Domain.new(from)
+    calls_in(domain.container, identity: domain.identity).fetch(name) { [] }
+  end
+
+  private
+    attr_reader :ast
+
+    def calls_in(container, identity:)
+      calls_by_container[container]&.fetch(identity, {}) || {}
+    end
+
+    def calls_by_container
+      @calls_by_container ||= {}.compare_by_identity.tap do |index|
+        nodes_in(ast, :send, :csend).each { add(it, to: index) if call_on_self?(it) }
+      end
+    end
+
+    def add(call, to:)
+      domain = domain_of_call(call)
+      scopes = to[domain.container] ||= {}
+      calls = scopes[domain.identity] ||= {}
+      (calls[call.method_name] ||= []) << call
+    end
+
+    def domain_of_call(call)
+      RuboCop::Callbacksystems::Methods::Domain.new(call)
+    end
+end