rubocop-callbacksystems 0.1.0

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

@@ -0,0 +1,336 @@
+# Ensures a `module:` option repeated across routes is extracted to a `scope`
+# block. Repeated, the namespace sits on every line and a reader compares them
+# to learn that the routes share a controller directory, where one
+# `scope module:` says it once and lets the routes read bare.
+#
+# Autocorrection consolidates the routes only when they are contiguous, so it
+# never reorders a route past another and changes matching precedence.
+#
+# @example
+#   # bad - module: repeated multiple times
+#   resources :users, module: :admin
+#   resources :posts, module: :admin
+#   resources :comments, module: :admin
+#
+#   # good - use scope block
+#   scope module: :admin do
+#     resources :users
+#     resources :posts
+#     resources :comments
+#   end
+#
+class RuboCop::Cop::Callbacksystems::RoutesModuleScope < RuboCop::Cop::Callbacksystems::Base
+  extend RuboCop::Cop::AutoCorrector
+
+  def on_new_investigation
+    if routes_file?(processed_source.file_path)
+      @source_comments = RuboCop::Callbacksystems::Source::Comments.for(processed_source)
+      @statement_positions = StatementPositions.new
+      repeated_route_groups.each { report_each RouteGroup.new(it, source_comments:, statement_positions:) }
+    end
+  end
+
+  private
+    ROUTE_METHODS = %i[ resources resource get post put patch delete match root ]
+
+    attr_reader :source_comments, :statement_positions
+
+    def repeated_route_groups
+      routes_with_module.group_by(&:group_key).values.select(&:many?)
+    end
+
+    def routes_with_module
+      route_calls.map { Route.new(it) }.select(&:module_value)
+    end
+
+    def route_calls
+      RuboCop::Callbacksystems::Execution::Immediate.new(processed_source.ast).nodes_of_type(:send)
+        .select { bare_send?(it) && ROUTE_METHODS.include?(it.method_name) }
+    end
+
+    # Routes repeating one `module:`, where only the first offense carries the correction that rewrites the whole run.
+    class RouteGroup
+      MESSAGE = "Extract repeated `module: %<module>s` to a `scope module: %<module>s do` block."
+
+      def initialize(routes, source_comments:, statement_positions:)
+        @routes = routes
+        @source_comments = source_comments
+        @statement_positions = statement_positions
+      end
+
+      def each_offense
+        yield offense_for(routes.first, correcting: consolidation.applicable?)
+        routes.drop(1).each { yield offense_for(it, correcting: false) }
+      end
+
+      private
+        attr_reader :routes, :source_comments, :statement_positions
+
+        def offense_for(route, correcting:)
+          RuboCop::Callbacksystems::Offense.new(route.node, message_for(route), correcting:) { consolidation.rewrite(it) }
+        end
+
+        def message_for(route)
+          format(MESSAGE, module: route.module_value)
+        end
+
+        def consolidation
+          @consolidation ||= Consolidation.new(routes, source_comments:, statement_positions:)
+        end
+    end
+
+    # One group of routes rewritten as a `scope module:` block, when they sit together with no comment among them.
+    class Consolidation
+      include RuboCop::Callbacksystems::Helpers
+
+      def initialize(routes, source_comments:, statement_positions:)
+        @routes = routes
+        @source_comments = source_comments
+        @statement_positions = statement_positions
+      end
+
+      def applicable?
+        contiguous? && routes.all?(&:literal_module?) && routes.all?(&:module_removable?) && source_self_contained? &&
+          !comments_within_span?
+      end
+
+      def rewrite(corrector)
+        corrector.replace(span, scope_block)
+      end
+
+      private
+        attr_reader :routes, :source_comments, :statement_positions
+
+        def contiguous?
+          container.begin_type? && nodes.all? { it.parent.equal?(container) } && consecutive?(positions_in_container)
+        end
+
+        def container
+          @container ||= nodes.first.parent
+        end
+
+        def nodes
+          @nodes ||= routes.map(&:node)
+        end
+
+        def consecutive?(indexes)
+          indexes.sort.each_cons(2).all? { |left, right| right == left + 1 }
+        end
+
+        def positions_in_container
+          nodes.map { statement_positions.position_of(it) }
+        end
+
+        def source_self_contained?
+          routes.none? { carries_heredoc?(it.node) }
+        end
+
+        def comments_within_span?
+          source_comments.any_on_lines?(span.first_line..span.last_line)
+        end
+
+        def span
+          @span ||= range_spanning(ordered_routes.map(&:node))
+        end
+
+        def ordered_routes
+          @ordered_routes ||= routes.sort_by { it.node.source_range.begin_pos }
+        end
+
+        def scope_block
+          [ "scope module: #{module_source} do", *route_lines, "#{indent}end" ].join("\n")
+        end
+
+        def module_source
+          routes.first.module_value
+        end
+
+        def route_lines
+          ordered_routes.map { "#{indent}  #{it.source_without_module}" }
+        end
+
+        def indent
+          @indent ||= indentation_of(ordered_routes.first.node)
+        end
+    end
+
+    # Statement positions shared by route groups, preserving node identity when two routes have identical syntax.
+    class StatementPositions
+      def initialize
+        @by_container = {}.compare_by_identity
+      end
+
+      def position_of(node)
+        positions_in(node.parent).fetch(node)
+      end
+
+      private
+        attr_reader :by_container
+
+        def positions_in(container)
+          by_container[container] ||= positions_of(container.children)
+        end
+
+        def positions_of(statements)
+          statements.each_with_index.with_object({}.compare_by_identity) do |(statement, position), positions|
+            positions[statement] = position
+          end
+        end
+    end
+
+    class Route
+      include RuboCop::Callbacksystems::Helpers
+
+      attr_reader :node
+
+      def initialize(node)
+        @node = node
+      end
+
+      def group_key
+        [ parent_block, normalized_module ]
+      end
+
+      def module_value
+        module_node&.source
+      end
+
+      def literal_module?
+        module_node.type?(:sym, :str)
+      end
+
+      def module_removable?
+        module_pairs.one?
+      end
+
+      def source_without_module
+        before_module.source + after_module.source
+      end
+
+      private
+        # Two blocks written alike compare equal as nodes, so the position tells the parents apart.
+        def parent_block
+          node.each_ancestor(*BLOCK_NODE_TYPES).first&.then { it.source_range.begin_pos } || :root
+        end
+
+        def normalized_module
+          [ module_node.type, literal_name_of(module_node) ]
+        end
+
+        def module_node
+          module_pair&.value
+        end
+
+        def module_pair
+          keyword_options.option_for(:module)
+        end
+
+        def keyword_options
+          @keyword_options ||= RuboCop::Callbacksystems::Hashes::KeywordOptions.new(*node.arguments.select(&:hash_type?))
+        end
+
+        def module_pairs
+          keyword_options.explicit_options_for(:module)
+        end
+
+        def before_module
+          node.source_range.with(end_pos: module_gap.begin_pos)
+        end
+
+        def module_gap
+          explicit_options? ? explicit_module_gap : implicit_module_gap
+        end
+
+        def explicit_options?
+          options.loc.begin
+        end
+
+        def options
+          module_pair.parent
+        end
+
+        def explicit_module_gap
+          if option_after_module
+            module_pair.source_range.with(end_pos: option_after_module.source_range.begin_pos)
+          elsif option_before_module
+            option_before_module.source_range.end.join(module_pair.source_range.end)
+          else
+            options_argument_gap
+          end
+        end
+
+        def option_after_module
+          option_elements[option_index + 1]
+        end
+
+        def option_elements
+          options.children
+        end
+
+        def option_index
+          option_elements.index { it.equal?(module_pair) }
+        end
+
+        def option_before_module
+          option_elements[option_index - 1] if option_index.positive?
+        end
+
+        def options_argument_gap
+          following_options_gap || preceding_options_gap || sole_options_gap
+        end
+
+        def following_options_gap
+          argument_after_options&.then { options.source_range.with(end_pos: it.source_range.begin_pos) }
+        end
+
+        def argument_after_options
+          node.arguments[options_index + 1]
+        end
+
+        def options_index
+          node.arguments.index { it.equal?(options) }
+        end
+
+        def preceding_options_gap
+          argument_before_options&.then { it.source_range.end.join(options.source_range.end) }
+        end
+
+        def argument_before_options
+          node.arguments[options_index - 1] if options_index.positive?
+        end
+
+        def sole_options_gap
+          node.loc.begin.join(node.loc.end)
+        end
+
+        def implicit_module_gap
+          if element_after_module
+            module_pair.source_range.join(element_after_module.source_range.begin)
+          elsif element_before_module
+            element_before_module.source_range.end.join(module_pair.source_range)
+          else
+            node.loc.selector.end.join(node.source_range.end)
+          end
+        end
+
+        def element_after_module
+          elements[module_index + 1]
+        end
+
+        def elements
+          @elements ||= node.arguments.flat_map { it.hash_type? ? it.children : [ it ] }
+        end
+
+        def module_index
+          elements.index { it.equal?(module_pair) }
+        end
+
+        def element_before_module
+          elements[module_index - 1] if module_index.positive?
+        end
+
+        def after_module
+          node.source_range.with(begin_pos: module_gap.end_pos)
+        end
+    end
+end

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

@@ -0,0 +1,107 @@
+# Asks for `{ }` over `do end` on a single-line setup or teardown block. The
+# `do end` form is the shape of a body with several lines, so wrapping one
+# statement in it spends two lines on a body that never grew.
+#
+# @example
+#   # bad
+#   setup do
+#     @user = users(:bruno)
+#   end
+#
+#   # good
+#   setup { @user = users(:bruno) }
+#
+#   # good (multi-line is fine with do/end)
+#   setup do
+#     @user = users(:bruno)
+#     @account = accounts(:callback)
+#   end
+#
+class RuboCop::Cop::Callbacksystems::SingleLineSetupBlock < RuboCop::Cop::Callbacksystems::Base
+  extend RuboCop::Cop::AutoCorrector
+
+  def on_new_investigation
+    @source_comments = RuboCop::Callbacksystems::Source::Comments.for(processed_source)
+  end
+
+  def on_block(node)
+    report SetupBlock.new(node, @source_comments)
+  end
+
+  alias on_numblock on_block
+  alias on_itblock on_block
+
+  private
+    class SetupBlock
+      include RuboCop::Callbacksystems::Helpers
+      extend RuboCop::AST::NodePattern::Macros
+
+      MESSAGE = "Use `%<method>s { ... }` for single-line blocks instead of `do ... end`."
+
+      # @!method setup_or_teardown_block?(node)
+      def_node_matcher :setup_or_teardown_block?, <<~PATTERN
+        (any_block (send nil? ${:setup :teardown} ...) ...)
+      PATTERN
+
+      def initialize(node, source_comments)
+        @node = node
+        @source_comments = source_comments
+      end
+
+      def offense
+        offense_for_block if expanded_one_liner?
+      end
+
+      private
+        attr_reader :node, :source_comments
+
+        def expanded_one_liner?
+          setup_or_teardown_block?(node) && !node.braces? && node.body&.single_line? && statements_in(node.body).one?
+        end
+
+        def offense_for_block
+          RuboCop::Callbacksystems::Offense.new(node, message, correcting: correctable?) { correct(it) }
+        end
+
+        def message
+          format(MESSAGE, method: node.method_name)
+        end
+
+        # Braces bind tighter than command-style arguments, so a multiline command stays untouched until its comments
+        # and indentation can be preserved. A single-line command can become an explicit argument list.
+        def correctable?
+          comments_movable? && !carries_heredoc?(node.body) &&
+            (node.send_node.arguments.empty? || node.send_node.parenthesized? || node.send_node.single_line?)
+        end
+
+        # One prose comment has an unambiguous home after the compact block. Several comments encode a layout of their
+        # own, and tooling directives can change meaning when moved, so neither is rewritten.
+        def comments_movable?
+          comments_on_block_lines.size <= 1 && comments_on_block_lines.none? { tooling_comment?(it) }
+        end
+
+        def comments_on_block_lines
+          @comments_on_block_lines ||= source_comments.on_lines(node.first_line..node.last_line)
+        end
+
+        def correct(corrector)
+          corrector.replace(node, "#{call_source} { #{parameters}#{node.body.source.strip} }")
+        end
+
+        def call_source
+          if node.send_node.arguments? && !node.send_node.parenthesized?
+            "#{node.method_name}(#{call_arguments_source})"
+          else
+            node.send_node.source
+          end
+        end
+
+        def call_arguments_source
+          node.send_node.first_argument.source_range.join(node.send_node.last_argument.source_range).source
+        end
+
+        def parameters
+          "#{node.arguments.source} " unless node.arguments.empty?
+        end
+    end
+end

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

@@ -0,0 +1,49 @@
+# A class declares its class-level methods in a single `class << self` section.
+# Splitting them across several blocks scatters the class API and hides which
+# part of it is private.
+#
+# @example
+#   # bad - two singleton sections
+#   class Configuration
+#     class << self
+#       def create_from(file)
+#       end
+#     end
+#
+#     def initialize(raw_config)
+#     end
+#
+#     class << self
+#       private
+#         def load_config_files(file)
+#         end
+#     end
+#   end
+#
+#   # good - one singleton section
+#   class Configuration
+#     class << self
+#       def create_from(file)
+#       end
+#
+#       private
+#         def load_config_files(file)
+#         end
+#     end
+#
+#     def initialize(raw_config)
+#     end
+#   end
+#
+class RuboCop::Cop::Callbacksystems::SingleSingletonClass < RuboCop::Cop::Callbacksystems::Base
+  MESSAGE = "Merge this `class << self` into the one declared above; a class has a single singleton section."
+
+  def on_class(node)
+    singleton_sections_in(node).drop(1).each { add_offense(it, message: MESSAGE) }
+  end
+
+  private
+    def singleton_sections_in(node)
+      statements_in(node.body).select { singleton_section?(it) }
+    end
+end

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

@@ -0,0 +1,160 @@
+# Forbids a second class or module at the top level of a file. Zeitwerk expects
+# the path of a file to name the constant it defines, so a second definition is
+# one nothing autoloads, and a reader looking for it by name never finds the
+# file it sits in.
+#
+# A class extending one written above it in the same file is left alone. Moving it
+# out would need a `require` back, so the two sitting together is a hierarchy
+# rather than the sprawl this looks for.
+#
+# @example
+#   # bad - multiple top-level classes
+#   class User
+#   end
+#
+#   class Admin
+#   end
+#
+#   # bad - multiple top-level modules
+#   module Authentication
+#   end
+#
+#   module Authorization
+#   end
+#
+#   # bad - mixed top-level class and module
+#   class User
+#   end
+#
+#   module UserHelpers
+#   end
+#
+#   # good - single top-level class
+#   class User
+#   end
+#
+#   # good - single top-level module
+#   module Authentication
+#   end
+#
+#   # good - nested classes/modules inside one top-level
+#   class User
+#     class Profile
+#     end
+#
+#     module Validations
+#     end
+#   end
+#
+#   # good - a hierarchy the file declares together
+#   class BaseTest < ActiveSupport::TestCase
+#   end
+#
+#   class VariantTest < BaseTest
+#   end
+#
+class RuboCop::Cop::Callbacksystems::SingleTopLevelClassOrModule < RuboCop::Cop::Callbacksystems::Base
+  def on_new_investigation
+    report_each TopLevelDefinitions.new(processed_source.ast)
+  end
+
+  private
+    class TopLevelDefinitions
+      include RuboCop::Callbacksystems::Helpers
+
+      MESSAGE = "Only one top-level class or module is allowed per file."
+      TRANSPARENT_NODES = %i[
+        begin kwbegin if case case_match when in_pattern rescue resbody ensure
+      ]
+
+      def initialize(ast)
+        @ast = ast
+      end
+
+      def each_offense
+        standalone.each { yield RuboCop::Callbacksystems::Offense.new(it, MESSAGE) }
+      end
+
+      private
+        attr_reader :ast
+
+        def standalone
+          definitions.drop(1).reject { it.extends?(definitions) }.map(&:node)
+        end
+
+        def definitions
+          @definitions ||= definitions_in(ast)
+        end
+
+        def definitions_in(node)
+          Enumerator.new do |definitions|
+            pending = [ node ].compact
+            until pending.empty?
+              current = pending.pop
+              definition = Definition.new(current)
+              if definition.declared?
+                definitions << definition
+              elsif current.type?(*TRANSPARENT_NODES)
+                pending.concat(current.child_nodes.reverse)
+              end
+            end
+          end.to_a
+        end
+
+        class Definition
+          include RuboCop::Callbacksystems::Helpers
+
+          attr_reader :node
+
+          def initialize(node)
+            @node = node
+          end
+
+          def declared?
+            node.type?(:class, :module) || builder_declaration?
+          end
+
+          def extends?(definitions)
+            parent_class.then { |parent| parent && definitions.any? { it.name == parent.source } }
+          end
+
+          def name
+            node.type?(:class, :module) ? node.identifier.source : assigned_constant_name
+          end
+
+          private
+            def builder_declaration?
+              if node.casgn_type?
+                builder_assignment.builds_class? || builder_assignment.builds_module?
+              else
+                false
+              end
+            end
+
+            def builder_assignment
+              @builder_assignment ||= RuboCop::Callbacksystems::ClassStructure::BuilderAssignment.new(node)
+            end
+
+            def parent_class
+              if node.class_type?
+                node.parent_class
+              elsif node.casgn_type? && class_new_builder?
+                builder_call.first_argument
+              end
+            end
+
+            def class_new_builder?
+              builder_call&.method?(:new) && core_constant?(builder_call.receiver) &&
+                builder_call.receiver.short_name == :Class
+            end
+
+            def builder_call
+              @builder_call ||= call_of(node.expression)
+            end
+
+            def assigned_constant_name
+              node.source_range.with(end_pos: node.loc.operator.begin_pos).source.rstrip
+            end
+        end
+    end
+end