rubocop-callbacksystems 0.1.0

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

@@ -0,0 +1,57 @@
+# Constants are read, never mutated, so freezing one guards against a mistake
+# nobody makes and puts noise on every declaration. Core `Style/MutableConstant`
+# asks for the opposite and stays off, while `Style/RedundantFreeze` reports the
+# same line whenever the value was immutable already.
+#
+# @example
+#   # bad
+#   FORMATS = [ :json ].freeze
+#   TIMEOUT = "30s".freeze
+#
+#   # good
+#   FORMATS = [ :json ]
+#   TIMEOUT = "30s"
+#
+class RuboCop::Cop::Callbacksystems::RedundantConstantFreeze < RuboCop::Cop::Callbacksystems::Base
+  extend RuboCop::Cop::AutoCorrector
+
+  MESSAGE = "Remove `freeze`. A constant is read, not mutated."
+
+  def on_casgn(node)
+    call = frozen_call_in(node)
+
+    report call if call
+  end
+
+  private
+    def frozen_call_in(node)
+      expression = node.children.last
+      expression = expression.children.first while parenthesized_expression?(expression)
+      expression if freezing_call?(expression)
+    end
+
+    def parenthesized_expression?(node)
+      node.begin_type? && node.children.one?
+    end
+
+    def freezing_call?(node)
+      node.call_type? && node.receiver && freezes_without_arguments?(node)
+    end
+
+    def freezes_without_arguments?(node)
+      node.method?(:freeze) && node.arguments.empty?
+    end
+
+    def report(call)
+      range = freeze_range_of(call)
+      if source_comments.any_within?(range)
+        add_offense(range, message: MESSAGE)
+      else
+        add_offense(range, message: MESSAGE) { it.remove(range) }
+      end
+    end
+
+    def freeze_range_of(call)
+      call.source_range.with(begin_pos: call.loc.dot.begin_pos)
+    end
+end

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

@@ -0,0 +1,134 @@
+# A constant reference does not need to repeat the namespace it is already
+# written inside. The prefix is noise on every read, and it has to be rewritten
+# whenever the namespace moves, while the bare name resolves through the scope
+# the file already opens.
+#
+# Only the innermost lexical scope counts. Under the compact class style a
+# definition like `class PgBox::Configuration` opens a single scope, so `PgBox`
+# itself is never searched and its prefix has to stay.
+#
+# @example
+#   # bad
+#   class PgBox::Configuration
+#     def validator
+#       PgBox::Configuration::Validator
+#     end
+#   end
+#
+#   # good
+#   class PgBox::Configuration
+#     def validator
+#       Validator
+#     end
+#   end
+#
+#   # good - `PgBox` is not a lexical scope here, so the prefix is required
+#   class PgBox::Configuration
+#     def secrets
+#       PgBox::Secrets
+#     end
+#   end
+#
+class RuboCop::Cop::Callbacksystems::RedundantConstantNamespace < RuboCop::Cop::Callbacksystems::Base
+  include RuboCop::Callbacksystems::ProjectIndex::Support
+  extend RuboCop::Cop::AutoCorrector
+
+  def on_new_investigation
+    @constant_references = if project_index_reliable?
+      RuboCop::Callbacksystems::ProjectIndex::ConstantReferences.for(project_index).within(processed_source)
+    end
+  end
+
+  def on_const(node)
+    report ConstantReference.new(node, constant_references) if constant_references
+  end
+
+  private
+    attr_reader :constant_references
+
+    class ConstantReference
+      include RuboCop::Callbacksystems::Helpers
+
+      MESSAGE = "Remove the redundant `%<namespace>s::` prefix; the constant already resolves from here."
+
+      def initialize(node, constant_references)
+        @node = node
+        @constant_references = constant_references
+      end
+
+      def offense
+        RuboCop::Callbacksystems::Offense.new(node, message) { correct(it) } if reference? && redundantly_qualified?
+      end
+
+      private
+        attr_reader :node, :constant_references
+
+        def reference?
+          !node.parent&.const_type? && !definition_identifier?(node)
+        end
+
+        def redundantly_qualified?
+          enclosing_scope_name.present? && qualified_node.present? && explicitly_declared_scope? && same_declaration?
+        end
+
+        def enclosing_scope_name
+          @enclosing_scope_name ||= enclosing_definitions.map { constant_name_of(it.identifier) }.join("::")
+        end
+
+        def enclosing_definitions
+          node.each_ancestor(:class, :module).to_a.reverse
+        end
+
+        def qualified_node
+          @qualified_node ||= constant_chain.find { constant_name_of(it.namespace) == enclosing_scope_name }
+        end
+
+        def constant_chain
+          [ node, *node.each_descendant(:const) ].select(&:namespace)
+        end
+
+        def explicitly_declared_scope?
+          enclosing_scope_chain.present? && enclosing_scope_chain.all? { declared_namespace?(it) } &&
+            enclosing_scope_chain.last.owner&.name == "Object"
+        end
+
+        def enclosing_scope_chain
+          @enclosing_scope_chain ||= Enumerator.produce(enclosing_scope_declaration) { it&.owner }
+            .take_while { it.present? && it.name != "Object" }
+        end
+
+        def enclosing_scope_declaration
+          constant_references.referenced_declaration_for(qualified_node.namespace)
+        end
+
+        def declared_namespace?(declaration)
+          declaration.is_a?(Rubydex::Namespace) && declared?(declaration)
+        end
+
+        def declared?(declaration)
+          declaration&.definitions&.any?
+        end
+
+        def same_declaration?
+          written_declaration = constant_references.referenced_declaration_for(node)
+          shortened_declaration = constant_references.declaration_named(shortened_name, beside: node)
+
+          declared?(written_declaration) && declared?(shortened_declaration) &&
+            written_declaration.name == shortened_declaration.name
+        end
+
+        def shortened_name
+          chain = [ node ]
+          chain << chain.last.namespace until chain.last.equal?(qualified_node)
+          chain.reverse_each.map(&:short_name).join("::")
+        end
+
+        def message
+          format(MESSAGE, namespace: enclosing_scope_name)
+        end
+
+        def correct(corrector)
+          corrector.remove(node.source_range.with(end_pos: qualified_node.loc.name.begin_pos))
+        end
+    end
+end

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

@@ -0,0 +1,133 @@
+# A comment block wrapped to a narrower column than the project uses costs the
+# reader extra lines for nothing. When a line breaks mid-sentence and the first
+# word of the next line still fits under the Layout/LineLength Max, the block
+# is refilled to the full width. A break on a sentence boundary may be
+# deliberate, and a block carrying a list, an indented example, a code tail,
+# a backtick fence, or an unbreakable word keeps the shape its author gave it.
+# A line opening with a label (`Slot 1: ...`) or reading as code is an item of
+# its own, so it keeps its line too.
+#
+# @example
+#   # bad - the break falls mid-sentence with room left on the line
+#   # A comment that stops
+#   # mid-sentence.
+#
+#   # good - filled to the full width
+#   # A comment that stops mid-sentence.
+#
+#   # good - every break lands on a sentence boundary
+#   # First idea ends here.
+#   # Second idea starts here.
+#
+class RuboCop::Cop::Callbacksystems::ReflowComments < RuboCop::Cop::Callbacksystems::Base
+  extend RuboCop::Cop::AutoCorrector
+
+  def on_new_investigation
+    comment_blocks_in(processed_source, reject_tooling_runs: true).each do |comments|
+      report ProseBlock.new(comments, max_line_length), rewrites_comments: true
+    end
+  end
+
+  private
+    class ProseBlock
+      include RuboCop::Callbacksystems::Helpers
+
+      MESSAGE = "This comment breaks mid-sentence with room left on the line. Fill it to %d columns."
+      MARKER_WIDTH = "# ".length
+      SENTENCE_END = /[.:;!?]["'`)\]]?\z/
+      STRUCTURE = /\A(?:\s|[-*|>+@#=]|\d+[.)]|:[a-z][\w-]*:|(?:--|\+\+)\z)/i
+      CODE_TAIL = /[{(=]\z/
+      LABELED = /\A[A-Za-z][^:\n]{0,30}:\s/
+      CODE = /\A[\w.]+(?:\(|\s+[A-Z]\w*::|\s+:\w|\s+["']|\s*=\s)/
+
+      def initialize(comments, max_length)
+        @comments = comments
+        @max_length = max_length
+      end
+
+      def offense
+        RuboCop::Callbacksystems::Offense.new(range, message) { correct(it) } if narrow_wrap?
+      end
+
+      private
+        attr_reader :comments, :max_length
+
+        def narrow_wrap?
+          prose? && lines.each_index.any? { absorbs_next?(it) }
+        end
+
+        def prose?
+          lines.all? { prose_line?(it) }
+        end
+
+        def lines
+          @lines ||= comments.map { it.text.delete_prefix("#").delete_prefix(" ").rstrip }
+        end
+
+        def prose_line?(line)
+          !line.match?(STRUCTURE) && !line.match?(CODE_TAIL) && line.exclude?("```") &&
+            line.split.all? { width_of(it) <= max_length }
+        end
+
+        def width_of(text)
+          indent + MARKER_WIDTH + text.length
+        end
+
+        def indent
+          comments.first.source_range.column
+        end
+
+        def absorbs_next?(index)
+          continues_at?(index) && width_of("#{lines[index]} #{lines[index + 1].split.first}") <= max_length
+        end
+
+        # A line opening with a label or reading as code is an item of its own, not the tail of the sentence above it.
+        def continues_at?(index)
+          following = lines[index + 1]
+          following.present? && !lines[index].empty? && !lines[index].match?(SENTENCE_END) &&
+            !following.match?(LABELED) && !following.match?(CODE)
+        end
+
+        def range
+          range_spanning(comments)
+        end
+
+        def message
+          format(MESSAGE, max_length)
+        end
+
+        def correct(corrector)
+          corrector.replace(range, filled_text)
+        end
+
+        def filled_text
+          paragraphs.flat_map { filled(it) }.join("\n#{" " * indent}")
+        end
+
+        def paragraphs
+          lines.each_index.slice_when { |index, _| !continues_at?(index) }
+            .map { lines.values_at(*it) }
+            .flat_map { detached_blank(it) }
+            .reject(&:empty?)
+        end
+
+        def detached_blank(slice)
+          slice.last == "" ? [ slice[0...-1], [ "" ] ] : [ slice ]
+        end
+
+        def filled(paragraph)
+          words = paragraph.join(" ").split
+          words.any? ? wrapped(words).map { "# #{it}" } : [ "#" ]
+        end
+
+        def wrapped(words)
+          words.each_with_object([]) do |word, filled|
+            if filled.any? && width_of("#{filled.last} #{word}") <= max_length
+              filled[-1] = "#{filled.last} #{word}"
+            else
+              filled << word
+            end
+          end
+        end
+    end
+end

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

@@ -0,0 +1,106 @@
+# Detects a fixture called in several tests of one file. Each test then repeats
+# the line naming the record, and a reader learns which record the file is
+# about only by comparing them, where one `setup` says it once and every test
+# reads it from there.
+#
+# @example
+#   # bad - same fixture in multiple tests
+#   test "validates name" do
+#     user = users(:john)
+#     assert user.valid?
+#   end
+#
+#   test "validates email" do
+#     user = users(:john)
+#     assert user.email.present?
+#   end
+#
+#   # good - fixture in setup
+#   setup do
+#     @user = users(:john)
+#   end
+#
+#   test "validates name" do
+#     assert @user.valid?
+#   end
+#
+#   test "validates email" do
+#     assert @user.email.present?
+#   end
+#
+class RuboCop::Cop::Callbacksystems::RepeatedFixtureInTests < RuboCop::Cop::Callbacksystems::Base
+  include RuboCop::Callbacksystems::Testing::CopHelpers
+
+  def external_dependency_checksum
+    RuboCop::Callbacksystems::Source::FilesChecksum.for \
+      "**/test/fixtures/**/*.yml", root: project_root, include_contents: false
+  end
+
+  def on_new_investigation
+    tests_by_class.each_value { report_each RepeatedFixtures.new(it, test_blocks:) }
+  end
+
+  private
+    def tests_by_class
+      test_blocks.each_with_object({}.compare_by_identity) do |test, groups|
+        (groups[test_domain_of(test)] ||= []) << test
+      end
+    end
+
+    def test_domain_of(test)
+      RuboCop::Callbacksystems::Methods::Domain.new(test).container || processed_source.ast
+    end
+
+    class RepeatedFixtures
+      include RuboCop::Callbacksystems::Helpers
+
+      MESSAGE = "Fixture `%<fixture>s` is used in multiple tests. Move it to `setup`."
+
+      def initialize(tests, test_blocks:)
+        @tests = tests
+        @test_block_index = {}.compare_by_identity
+        test_blocks.each { @test_block_index[it] = true }
+      end
+
+      def each_offense
+        repeated_calls.each { yield RuboCop::Callbacksystems::Offense.new(it.node, message_for(it)) }
+      end
+
+      private
+        attr_reader :tests, :test_block_index
+
+        def repeated_calls
+          calls.group_by(&:identity).values.select { spans_several_tests?(it) }.flat_map { beyond_first_test(it) }
+        end
+
+        def calls
+          tests.flat_map { calls_in(it) }
+        end
+
+        def calls_in(test)
+          RuboCop::Callbacksystems::Execution::Immediate.new(test.body, deferred_blocks: nested_tests_in(test))
+            .nodes_of_type(:send)
+            .map { RuboCop::Callbacksystems::Testing::FixtureCall.new(it) }.select(&:valid?).map { Call.new(test, it) }
+        end
+
+        def nested_tests_in(test)
+          nodes_in(test.body, :any_block).select { test_block_index.key?(it) }
+        end
+
+        def spans_several_tests?(calls)
+          calls.map(&:test).uniq(&:object_id).many?
+        end
+
+        def beyond_first_test(calls)
+          calls.reject { it.test.equal?(calls.first.test) }
+        end
+
+        def message_for(call)
+          format(MESSAGE, fixture: call.signature)
+        end
+
+        class Call < Data.define(:test, :fixture)
+          delegate :identity, :node, :signature, to: :fixture
+        end
+    end
+end

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

@@ -0,0 +1,85 @@
+# Restricts controller actions to the seven standard Rails actions. A custom
+# action is a verb bolted onto a controller, so the controllers stop reading the
+# same way and routes grow one-off entries. The verb turned into a noun gets a
+# controller of its own, `Users::ActivationsController#create`, with the same
+# shape as every other one.
+#
+# Only classes inheriting from a controller are read. A concern is a module,
+# and its methods are not actions.
+#
+# @example
+#   # bad - custom public action
+#   class UsersController < ApplicationController
+#     def activate
+#       # ...
+#     end
+#   end
+#
+#   # good - use standard actions
+#   class UsersController < ApplicationController
+#     def update
+#       # ...
+#     end
+#   end
+#
+#   # good - create a new controller for the action
+#   class Users::ActivationsController < ApplicationController
+#     def create
+#       # ...
+#     end
+#   end
+#
+#   # good - concerns can have any methods
+#   module Authentication
+#     def current_user
+#       # ...
+#     end
+#   end
+#
+class RuboCop::Cop::Callbacksystems::RestrictedControllerActions < RuboCop::Cop::Callbacksystems::Base
+  def on_def(node)
+    report Action.new(node)
+  end
+
+  private
+    class Action
+      include RuboCop::Callbacksystems::Helpers
+
+      MESSAGE = "Only standard Rails actions (index, show, new, create, edit, update, destroy) are allowed in " \
+        "controllers. Extract `%<method>s` to a new controller."
+
+      def initialize(node)
+        @node = node
+      end
+
+      def offense
+        RuboCop::Callbacksystems::Offense.new(node, message) if restricted?
+      end
+
+      private
+        attr_reader :node
+
+        def restricted?
+          custom? && direct_method_definition?(node) && instance_method? && in_restricted_controller? &&
+            public_method?(node)
+        end
+
+        def custom?
+          STANDARD_CONTROLLER_ACTIONS.exclude?(node.method_name)
+        end
+
+        def instance_method?
+          RuboCop::Callbacksystems::Methods::Domain.new(node).scope == :instance
+        end
+
+        def in_restricted_controller?
+          enclosing_class_or_module_of(node).then do |controller|
+            controller_class?(controller) && !application_controller_class?(controller)
+          end
+        end
+
+        def message
+          format(MESSAGE, method: node.method_name)
+        end
+    end
+end