rubocop-callbacksystems 0.1.0

data/lib/rubocop/callbacksystems/source/statement_with_comments.rb

@@ -0,0 +1,131 @@
+# A statement together with the comments that read as its own: the contiguous own-line comments right above it and the
+# comment closing its last line. A rewrite that moves the statement moves them, and a range spanning it spans them.
+class RuboCop::Callbacksystems::Source::StatementWithComments
+  include RuboCop::Callbacksystems::Helpers
+
+  attr_reader :node
+
+  delegate :source, to: :range
+
+  class << self
+    def sibling_lines_for(processed_source)
+      SIBLING_LINES_LOCK.synchronize { SIBLING_LINES[processed_source.comments] ||= SiblingLines.new }
+    end
+
+    private
+      SIBLING_LINES = ObjectSpace::WeakMap.new
+      SIBLING_LINES_LOCK = Mutex.new
+  end
+
+  def initialize(node, processed_source)
+    @node = node
+    @processed_source = processed_source
+    @source_comments = RuboCop::Callbacksystems::Source::Comments.for(processed_source)
+    @sibling_lines = self.class.sibling_lines_for(processed_source)
+  end
+
+  def contains_tooling_comment?
+    source_comments.tooling_within?(range)
+  end
+
+  def range
+    @range ||= range_between(begin_position, end_position)
+  end
+
+  def begin_position
+    @begin_position ||=
+      previous_statement_on_line? ? node.source_range.begin_pos : line_start_position_of(leading_comments.first || node)
+  end
+
+  private
+    attr_reader :processed_source, :source_comments, :sibling_lines
+
+    def previous_statement_on_line?
+      sibling_lines.previous_on_line?(node)
+    end
+
+    def leading_comments
+      @leading_comments ||= comments_above(node.first_line - 1)
+    end
+
+    def comments_above(first_line)
+      comments = []
+      line = first_line
+      while (comment = source_comments.own_line_comment_on(line))
+        comments << comment
+        line -= 1
+      end
+      comments.reverse
+    end
+
+    def end_position
+      [ range_through_heredocs(node).end_pos, trailing_comment&.source_range&.end_pos ].compact.max
+    end
+
+    def trailing_comment
+      source_comments.trailing_comment_on(node.last_line) unless following_statement_on_line?
+    end
+
+    def following_statement_on_line?
+      sibling_lines.following_on_line?(node)
+    end
+
+    # Same-line sibling relationships indexed without retaining AST nodes beyond the processed source's lifetime.
+    class SiblingLines
+      def initialize
+        @relationships = {}
+        @indexed_parents = Set.new
+      end
+
+      def previous_on_line?(node)
+        relationship_for(node).first
+      end
+
+      def following_on_line?(node)
+        relationship_for(node).last
+      end
+
+      private
+        attr_reader :relationships, :indexed_parents
+
+        def relationship_for(node)
+          index(node.parent)
+          relationships.fetch(key_of(node)) { [ false, false ] }
+        end
+
+        def index(parent)
+          if parent&.type?(:begin, :kwbegin) && indexed_parents.add?(key_of(parent))
+            siblings = parent.each_child_node.to_a
+            siblings.each_with_index do |sibling, position|
+              relationships[key_of(sibling)] = Relationship.new(siblings, position).to_a
+            end
+          end
+        end
+
+        def key_of(node)
+          [ node.type, node.source_range.begin_pos, node.source_range.end_pos ]
+        end
+
+        class Relationship
+          def initialize(siblings, position)
+            @siblings = siblings
+            @position = position
+          end
+
+          def to_a
+            [ previous_on_same_line?, following_on_same_line? ]
+          end
+
+          private
+            attr_reader :siblings, :position
+
+            def previous_on_same_line?
+              position.positive? && siblings[position - 1].last_line == siblings[position].first_line
+            end
+
+            def following_on_same_line?
+              position < siblings.size - 1 && siblings[position].last_line == siblings[position + 1].first_line
+            end
+        end
+    end
+end

data/lib/rubocop/callbacksystems/testing/cop_helpers.rb

@@ -0,0 +1,42 @@
+module RuboCop::Callbacksystems::Testing::CopHelpers
+  extend RuboCop::AST::NodePattern::Macros
+
+  # @!method test_block?(node)
+  def_node_matcher :test_block?, <<~PATTERN
+    (any_block (send {nil? (self)} :test (str $_)) ...)
+  PATTERN
+
+  # @!method setup_block?(node)
+  def_node_matcher :setup_block?, <<~PATTERN
+    (any_block (send {nil? (self)} :setup) ...)
+  PATTERN
+
+  private
+    HTTP_METHODS = %i[ get post put patch delete ]
+    RESPONSE_ASSERTIONS = %i[ assert_response assert_redirected_to ]
+
+    def test_blocks(scope = processed_source.ast)
+      nodes_in(scope, :any_block).select { test_block?(it) }
+    end
+
+    def setup_blocks(scope = processed_source.ast)
+      nodes_in(scope, :any_block).select { setup_block?(it) }
+    end
+
+    def immediate_calls_in(statement)
+      immediate_calls_by_statement[statement] ||= RuboCop::Callbacksystems::Execution::Immediate.new(statement)
+        .nodes_of_type(:send, :csend)
+    end
+
+    def immediate_calls_by_statement
+      @immediate_calls_by_statement ||= {}.compare_by_identity
+    end
+
+    def response_assertion?(send_node)
+      call_on_self?(send_node) && RESPONSE_ASSERTIONS.include?(send_node.method_name)
+    end
+
+    def http_request?(send_node)
+      call_on_self?(send_node) && HTTP_METHODS.include?(send_node.method_name)
+    end
+end

data/lib/rubocop/callbacksystems/testing/fixture_call.rb

@@ -0,0 +1,30 @@
+class RuboCop::Callbacksystems::Testing::FixtureCall < Data.define(:node)
+  include RuboCop::Callbacksystems::Helpers
+
+  def valid?
+    bare_send?(node) &&
+      node.arguments.size == 1 &&
+      node.first_argument.sym_type? &&
+      fixture_set?
+  end
+
+  def signature
+    "#{node.method_name}(#{node.first_argument.source})"
+  end
+
+  def identity
+    [ node.method_name, node.first_argument.value ]
+  end
+
+  private
+    delegate :source_buffer, to: "node.source_range", private: true
+
+    # A helper reads like a fixture call, so the project's own fixture sets are what tells the two apart.
+    def fixture_set?
+      RuboCop::Callbacksystems::Testing::FixtureNames.new(file_path, lifetime: source_buffer).include?(node.method_name)
+    end
+
+    def file_path
+      source_buffer.name
+    end
+end

data/lib/rubocop/callbacksystems/testing/fixture_names.rb

@@ -0,0 +1,62 @@
+# The fixture sets a project defines, read from the yml files under the `test/fixtures` directory of the tree the test
+# file sits in, since a project can hold more than one of those. Rails names the accessor after the path of the file, so
+# `test/fixtures/webhook/deliveries.yml` answers `webhook_deliveries(:name)`, and what sits under `files` stays out
+# because `file_fixture_path` points there.
+class RuboCop::Callbacksystems::Testing::FixtureNames
+  def initialize(test_file, lifetime: nil)
+    @test_file = test_file
+    @lifetime = lifetime
+  end
+
+  def include?(name)
+    accessors.include?(name.to_s)
+  end
+
+  private
+    TEST_DIRECTORY = "test"
+    FIXTURE_DIRECTORY = "fixtures"
+    FILE_FIXTURE_DIRECTORY = "files"
+
+    # Calls made while one source is being investigated share a walk, while the weak lifetime makes the next
+    # investigation read the project again and lets completed ones leave no cache behind.
+    ACCESSORS_BY_LIFETIME = ObjectSpace::WeakMap.new
+    ACCESSORS_LOCK = Mutex.new
+
+    attr_reader :test_file, :lifetime
+
+    def accessors
+      @accessors ||= lifetime ? shared_accessors : discovered_accessors
+    end
+
+    def shared_accessors
+      ACCESSORS_LOCK.synchronize { ACCESSORS_BY_LIFETIME[lifetime] ||= discovered_accessors }
+    end
+
+    def discovered_accessors
+      directory ? accessors_in(directory) : Set[]
+    end
+
+    def directory
+      @directory ||= test_directory&.join(FIXTURE_DIRECTORY)
+    end
+
+    def test_directory
+      Pathname.new(test_file).ascend.find { it.basename.to_s == TEST_DIRECTORY } if test_file
+    end
+
+    def accessors_in(directory)
+      Pathname.glob(directory.join("**/*.yml")).reject { file_fixture?(it) }.to_set { accessor_for(it) }
+    end
+
+    def file_fixture?(file)
+      relative_path_of(file).each_filename.first == FILE_FIXTURE_DIRECTORY
+    end
+
+    def relative_path_of(file)
+      file.relative_path_from(directory)
+    end
+
+    def accessor_for(file)
+      relative_path_of(file).sub_ext("").to_s.tr("/", "_")
+    end
+end

data/lib/rubocop/callbacksystems/testing/path_mapping.rb

@@ -0,0 +1,104 @@
+class RuboCop::Callbacksystems::Testing::PathMapping
+  def initialize(path)
+    @path = path
+  end
+
+  def source_path
+    return @source_path if defined?(@source_path)
+
+    app_path = source_path_in("app")
+    lib_path = source_path_in("lib")
+
+    @source_path = if app_path != path && File.exist?(app_path)
+      app_path
+    elsif lib_path != path && File.exist?(lib_path)
+      lib_path
+    else
+      namespaced_gem_source_path
+    end
+  end
+
+  def gem_project?
+    return @gem_project if defined?(@gem_project)
+
+    @gem_project = Dir.glob(File.join(project_root_path, "*.gemspec")).any?
+  end
+
+  def test_path
+    return @test_path if defined?(@test_path)
+
+    @test_path = candidate_test_paths.find { File.exist?(it) }
+  end
+
+  private
+    attr_reader :path
+
+    def source_path_in(directory)
+      path.sub(%r{(^|/)test/(.+)_test\.rb$}) do
+        "#{Regexp.last_match(1)}#{directory}/#{Regexp.last_match(2)}.rb"
+      end
+    end
+
+    def namespaced_gem_source_path
+      if gem_project? && path.match?(%r{(^|/)test/.+_test\.rb$})
+        relative_source = path.match(%r{(^|/)test/(.+)_test\.rb$}).captures.second
+        candidates = Dir.glob(File.join(project_root_path, "lib", "*", "#{relative_source}.rb"))
+        candidates.one? ? candidates.first : nil
+      end
+    end
+
+    def project_root_path
+      project_root.empty? ? "." : project_root
+    end
+
+    def project_root
+      project_directory_match ? matched_project_root : path
+    end
+
+    def project_directory_match
+      @project_directory_match ||= path.match(%r{\A(?:(.*?)/)?(?:app|lib|test)/})
+    end
+
+    def matched_project_root
+      project_directory_match.captures.first.to_s.presence || absolute_root
+    end
+
+    def absolute_root
+      path.start_with?(File::SEPARATOR) ? File::SEPARATOR : ""
+    end
+
+    def candidate_test_paths
+      lib_test_paths + flat_gem_test_paths + app_test_paths
+    end
+
+    def lib_test_paths
+      test_paths_for("lib")
+    end
+
+    def test_paths_for(root)
+      if path.match?(%r{(^|/)#{root}/})
+        [ rewrite(root, "test/#{root}/"), rewrite(root, "test/") ]
+      else
+        []
+      end
+    end
+
+    def rewrite(root, prefix)
+      path.sub(%r{(^|/)#{root}/(.+)\.rb$}) { "#{Regexp.last_match(1)}#{prefix}#{Regexp.last_match(2)}_test.rb" }
+    end
+
+    def flat_gem_test_paths
+      if gem_project?
+        candidate = path.sub(%r{(^|/)lib/[^/]+/(.+)\.rb$}) do
+          "#{Regexp.last_match(1)}test/#{Regexp.last_match(2)}_test.rb"
+        end
+        candidate == path ? [] : [ candidate ]
+      else
+        []
+      end
+    end
+
+    def app_test_paths
+      test_paths_for("app").last(1)
+    end
+end

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

@@ -0,0 +1,44 @@
+# Prohibits defining methods directly in ApplicationController.
+#
+# Methods in ApplicationController should be extracted into concerns
+# to keep the base controller clean and maintainable. Include concerns
+# instead of defining methods directly.
+#
+# @example
+#   # bad - method defined directly
+#   class ApplicationController < ActionController::Base
+#     def current_user
+#       @current_user ||= User.find(session[:user_id])
+#     end
+#   end
+#
+#   # good - use concerns
+#   class ApplicationController < ActionController::Base
+#     include Authentication
+#     include CurrentUser
+#   end
+#
+#   # app/controllers/concerns/current_user.rb
+#   module CurrentUser
+#     extend ActiveSupport::Concern
+#
+#     included do
+#       helper_method :current_user
+#     end
+#
+#     def current_user
+#       @current_user ||= User.find(session[:user_id])
+#     end
+#   end
+#
+class RuboCop::Cop::Callbacksystems::ApplicationControllerMethodDefinition < RuboCop::Cop::Callbacksystems::Base
+  MESSAGE = "Don't define methods in ApplicationController. Extract to a concern and include it."
+
+  def on_def(node)
+    if direct_method_definition?(node) && application_controller_class?(enclosing_class_or_module_of(node))
+      add_offense(node, message: MESSAGE)
+    end
+  end
+
+  alias on_defs on_def
+end

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

@@ -0,0 +1,60 @@
+# `assert expected, actual` passes whenever `expected` is truthy, so a
+# two-argument `assert` usually means `assert_equal`. The second argument is
+# legitimate when it reads as a failure message: a string, or a variable or
+# method whose name says so. This replaces `Minitest/AssertWithExpectedArgument`,
+# which only recognizes string literals and the bare names `message` and `msg`.
+#
+# @example
+#   # bad
+#   assert(3, my_list.length)
+#   assert(expected, actual)
+#
+#   # good
+#   assert_equal(3, my_list.length)
+#   assert foo, "must be present"
+#   assert foo, msg
+#   assert foo, error_message
+#   assert audit.passed?, audit.failure_message
+#   assert user.valid?, user.errors
+#
+class RuboCop::Cop::Callbacksystems::AssertWithExpectedArgument < RuboCop::Cop::Callbacksystems::Base
+  MESSAGE = "Did you mean to use `assert_equal(%<arguments>s)`?"
+  RESTRICT_ON_SEND = %i[ assert ]
+  MESSAGE_NAME = /message\z|\Amsg\z/
+  BOOLEAN_NODE_TYPES = %i[ and false match_pattern_p or true ]
+  BOOLEAN_METHODS = %i[ ! =~ !~ ]
+
+  # @!method assert_with_two_arguments?(node)
+  def_node_matcher :assert_with_two_arguments?, <<~PATTERN
+    (call {nil? (self)} :assert $_ $_)
+  PATTERN
+
+  def on_send(node)
+    if test_file?(processed_source.file_path)
+      assert_with_two_arguments?(node) do |asserted, second_argument|
+        unless predicate?(asserted) || message_argument?(second_argument)
+          add_offense(node, message: format(MESSAGE, arguments: node.arguments.map(&:source).join(", ")))
+        end
+      end
+    end
+  end
+
+  alias on_csend on_send
+
+  private
+    # With a predicate asserted there is no expected/actual confusion, so the second argument is a message by intention.
+    def predicate?(argument)
+      BOOLEAN_NODE_TYPES.include?(argument.type) ||
+        (argument.call_type? && (argument.predicate_method? || argument.comparison_method? ||
+          BOOLEAN_METHODS.include?(argument.method_name)))
+    end
+
+    def message_argument?(argument)
+      argument.type?(:str, :dstr) || deferred_callable_block?(argument) || named_like_a_message?(argument)
+    end
+
+    def named_like_a_message?(argument)
+      name = argument.send_type? ? argument.method_name : argument.source
+      name.to_s.match?(MESSAGE_NAME)
+    end
+end

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

@@ -0,0 +1,134 @@
+class RuboCop::Cop::Callbacksystems::Base < RuboCop::Cop::Base
+  include RuboCop::Callbacksystems::Helpers
+
+  exclude_from_registry
+
+  def add_offense(node_or_range, message: nil, severity: nil, rewrites_comments: false, &correction)
+    if autocorrect? && !flushing_corrections?
+      request = CorrectionRequest.new \
+        range_from_node_or_range(node_or_range), message:, severity:, correction:, rewrites_comments: rewrites_comments
+      if reserve(request.range)
+        correction_queue.add(request, enabled: correction_enabled?(request.range))
+      end
+    else
+      super(node_or_range, message:, severity:, &correction)
+    end
+  end
+
+  def on_investigation_end
+    flush_corrections
+    super
+  end
+
+  private
+    def flushing_corrections?
+      correction_queue.flushing?
+    end
+
+    def correction_queue
+      @correction_queue ||= CorrectionQueue.new
+    end
+
+    def reserve(range)
+      reserved_locations.add?(range)
+    end
+
+    def reserved_locations
+      if @reservation_source != processed_source
+        @reservation_source = processed_source
+        @reserved_locations = Set.new
+      end
+      @reserved_locations
+    end
+
+    def correction_enabled?(range)
+      if processed_source.comment_config.respond_to?(:cop_enabled_at_lines?)
+        range.first_line.upto(range.last_line).all? { enabled_line?(it) }
+      else
+        enabled_line?(range.first_line)
+      end
+    end
+
+    def flush_corrections
+      correction_queue.flush(processed_source) do |offense, correction|
+        add_offense offense.range, message: offense.message, severity: offense.severity, &correction
+      end
+    end
+
+    def source_comments
+      RuboCop::Callbacksystems::Source::Comments.for(processed_source)
+    end
+
+    def project_root
+      @config.base_dir_for_path_parameters
+    end
+
+    # Measuring against any width but the enforced one leaves two corrections undoing each other.
+    def max_line_length
+      config.for_cop("Layout/LineLength")["Max"]
+    end
+
+    def report(analysis, rewrites_comments: false)
+      offense = analysis.offense
+      add_offense(offense.range, message: offense.message, rewrites_comments:, &offense.correction) if offense
+    end
+
+    def report_each(analyses, rewrites_comments: false)
+      analyses.each_offense do |offense|
+        add_offense(offense.range, message: offense.message, rewrites_comments:, &offense.correction)
+      end
+    end
+
+    class CorrectionRequest
+      attr_reader :range, :message, :severity, :correction
+
+      def initialize(range, message:, severity:, correction:, rewrites_comments:)
+        @range = range
+        @message = message
+        @severity = severity
+        @correction = correction
+        @rewrites_comments = rewrites_comments
+      end
+
+      def batchable?(enabled:)
+        correction && enabled
+      end
+
+      def rewrites_comments?
+        rewrites_comments
+      end
+
+      private
+        attr_reader :rewrites_comments
+    end
+
+    class CorrectionQueue
+      def initialize
+        @offenses = []
+        @corrections = []
+        @flushing = false
+      end
+
+      def add(request, enabled:)
+        offenses << request
+        corrections << request if request.batchable?(enabled:)
+      end
+
+      def flushing?
+        flushing
+      end
+
+      def flush(processed_source)
+        batch = RuboCop::Callbacksystems::Autocorrection::Batch.new(corrections, processed_source)
+        @flushing = true
+        offenses.each { yield it, batch.correction_for(it) }
+      ensure
+        @flushing = false
+        offenses.clear
+        corrections.clear
+      end
+
+      private
+        attr_reader :offenses, :corrections, :flushing
+    end
+end