rubocop-callbacksystems 0.1.0

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

@@ -0,0 +1,47 @@
+# Detects `str.strip.gsub(/\s+/, " ")` patterns that should use `squish`. The
+# method names the whole transformation, where the chain spells out a regexp
+# the reader has to decode.
+#
+# @example
+#   # bad
+#   text.strip.gsub(/\s+/, " ")
+#   name.strip.gsub(/[[:space:]]+/, " ")
+#
+#   # good
+#   text.squish
+#   name.squish
+#
+class RuboCop::Cop::Callbacksystems::PreferSquish < RuboCop::Cop::Callbacksystems::Base
+  extend RuboCop::Cop::AutoCorrector
+
+  MESSAGE = 'Use `squish` instead of `strip.gsub(/\s+/, " ")`.'
+  WHITESPACE_PATTERNS = %w[ \s+ [[:space:]]+ ]
+
+  # @!method strip_gsub_pattern(node)
+  def_node_matcher :strip_gsub_pattern, <<~PATTERN
+    (call $(call _ :strip) :gsub (regexp (str $_pattern) (regopt)) (str " "))
+  PATTERN
+
+  def on_send(node)
+    strip_gsub_pattern(node) do |strip_call, pattern|
+      next if WHITESPACE_PATTERNS.exclude?(pattern)
+
+      add_squish_offense(node, strip_call:)
+    end
+  end
+
+  alias on_csend on_send
+
+  private
+    def add_squish_offense(node, strip_call:)
+      if source_comments.any_within?(node)
+        add_offense(node, message: MESSAGE)
+      else
+        add_offense(node, message: MESSAGE) { it.replace(node, replacement_for(strip_call)) }
+      end
+    end
+
+    def replacement_for(call)
+      "#{call_prefix_of(call)}squish"
+    end
+end

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

@@ -0,0 +1,24 @@
+# Detects `hash.transform_keys(&:to_s)` patterns that should use `stringify_keys`.
+# The Active Support method names what the keys become, where the transform
+# makes the reader work it out from the block.
+#
+# @example
+#   # bad
+#   hash.transform_keys(&:to_s)
+#   hash.transform_keys { |k| k.to_s }
+#
+#   # good
+#   hash.stringify_keys
+#
+class RuboCop::Cop::Callbacksystems::PreferStringifyKeys < RuboCop::Cop::Callbacksystems::Base
+  include RuboCop::Callbacksystems::Hashes::KeyTransformDetection
+
+  private
+    def source_method
+      :to_s
+    end
+
+    def preferred_method
+      :stringify_keys
+    end
+end

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

@@ -0,0 +1,24 @@
+# Detects `hash.transform_keys(&:to_sym)` patterns that should use `symbolize_keys`.
+# The Active Support method names what the keys become, where the transform
+# makes the reader work it out from the block.
+#
+# @example
+#   # bad
+#   hash.transform_keys(&:to_sym)
+#   hash.transform_keys { |k| k.to_sym }
+#
+#   # good
+#   hash.symbolize_keys
+#
+class RuboCop::Cop::Callbacksystems::PreferSymbolizeKeys < RuboCop::Cop::Callbacksystems::Base
+  include RuboCop::Callbacksystems::Hashes::KeyTransformDetection
+
+  private
+    def source_method
+      :to_sym
+    end
+
+    def preferred_method
+      :symbolize_keys
+    end
+end

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

@@ -0,0 +1,40 @@
+# Enforces Turbo page refreshes over targeted stream broadcasts.
+#
+# Targeted broadcasts (append, prepend, replace, remove, and friends) and the
+# macros that generate them tie the server to specific partials and DOM targets.
+# Page refresh broadcasts let the client morph the current page instead, which
+# keeps the broadcasting code declarative and the views as the single source of
+# truth.
+#
+# @example
+#   # bad
+#   broadcasts_to :board
+#   message.broadcast_append_to :messages
+#   broadcast_replace_later_to room
+#
+#   # good - macro
+#   broadcasts_refreshes
+#   broadcasts_refreshes_to :board
+#
+#   # good - granular, manual refresh
+#   broadcast_refresh_to :board
+#   broadcast_refresh_later_to room
+#
+class RuboCop::Cop::Callbacksystems::PreferTurboPageRefreshBroadcasts < RuboCop::Cop::Callbacksystems::Base
+  MESSAGE = "Prefer Turbo page refreshes over `%<name>s`."
+
+  def on_send(node)
+    add_offense(node, message: format(MESSAGE, name: node.method_name)) if targeted_broadcast?(node)
+  end
+
+  alias on_csend on_send
+
+  private
+    MACROS = %i[ broadcasts broadcasts_to ]
+    TARGETED_BROADCAST =
+      /\Abroadcast_(append|prepend|replace|update|remove|before|after|action|render)(_later)?(_to)?\z/
+
+    def targeted_broadcast?(node)
+      (bare_send?(node) && MACROS.include?(node.method_name)) || TARGETED_BROADCAST.match?(node.method_name)
+    end
+end

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

@@ -0,0 +1,160 @@
+# A constant that only serves the implementation belongs in the private
+# section, where every other implementation detail already lives. Marking it
+# with `private_constant` from the top of the class says the same thing twice
+# and leaves the declaration among the public ones.
+#
+# The marker earns its place when class-level code above the private section
+# reads the constant, since the declaration cannot move below the code that
+# reads it. Class-level code inside the section moves down with it.
+#
+# @example
+#   # bad - only method bodies read it
+#   class Backend
+#     Route = Data.define(:host, :matcher)
+#     private_constant :Route
+#
+#     def route_for(host)
+#       Route.new(host, nil)
+#     end
+#   end
+#
+#   # good - declared where the implementation lives
+#   class Backend
+#     def route_for(host)
+#       Route.new(host, nil)
+#     end
+#
+#     private
+#       Route = Data.define(:host, :matcher)
+#   end
+#
+#   # bad - the reader is private too, so both move
+#   class Backend
+#     MEMBERS = [ :host, :matcher ]
+#     private_constant :MEMBERS
+#
+#     private
+#       Route = Data.define(*MEMBERS)
+#   end
+#
+#   # good
+#   class Backend
+#     private
+#       MEMBERS = [ :host, :matcher ]
+#       Route = Data.define(*MEMBERS)
+#   end
+#
+#   # good - class-level code above reads it, so it has to stay there
+#   class Backend
+#     FORMATS = [ :json ]
+#     private_constant :FORMATS
+#
+#     validates :format, inclusion: { in: FORMATS }
+#   end
+#
+class RuboCop::Cop::Callbacksystems::PrivateConstantsInPrivateSection < RuboCop::Cop::Callbacksystems::Base
+  def on_send(node)
+    report_each PrivateConstantMarker.new(node)
+  end
+
+  alias on_csend on_send
+
+  private
+    DEFERRED_MACROS = %i[ test setup teardown ]
+
+    class PrivateConstantMarker
+      include RuboCop::Callbacksystems::Helpers
+
+      MESSAGE = "Declare `%<name>s` in the private section instead of marking it with `private_constant`."
+      REDUNDANT_MESSAGE = "Remove `private_constant` from `%<name>s`, which is already declared in the private section."
+
+      def initialize(node)
+        @node = node
+      end
+
+      def each_offense
+        movable_arguments.each { yield RuboCop::Callbacksystems::Offense.new(it, message_for(it)) }
+      end
+
+      private
+        attr_reader :node
+
+        def movable_arguments
+          enclosing_body ? names_marked_by(node, macro: :private_constant).reject { pinned?(it) } : []
+        end
+
+        def enclosing_body
+          enclosing_class_or_module_of(node)&.body
+        end
+
+        def pinned?(argument)
+          pinning_names.include?(argument.value.to_s)
+        end
+
+        def pinning_names
+          @pinning_names ||= constant_reads.select(&:pins_declaration?).map(&:name)
+        end
+
+        def constant_reads
+          constant_nodes.map { ConstantRead.new(it, enclosing_body) }
+        end
+
+        def constant_nodes
+          nodes_in(enclosing_body, :const)
+        end
+
+        def message_for(argument)
+          format(template_for(argument.value.to_sym), name: argument.value)
+        end
+
+        def template_for(name)
+          declared_privately?(declaration_of(name)) ? REDUNDANT_MESSAGE : MESSAGE
+        end
+
+        def declared_privately?(declaration)
+          declaration && in_private_section?(declaration, enclosing_body)
+        end
+
+        def declaration_of(name)
+          statements_in(enclosing_body).find { declared_name_of(it) == name }
+        end
+    end
+
+    # A read that would break if the declaration moved, made by class-level code above the private section.
+    class ConstantRead
+      include RuboCop::Callbacksystems::Helpers
+
+      def initialize(node, body)
+        @node = node
+        @body = body
+      end
+
+      def pins_declaration?
+        own_constant? && class_level? && !in_private_section?(node, body)
+      end
+
+      def name
+        node.short_name.to_s
+      end
+
+      private
+        attr_reader :node, :body
+
+        # `Other::Namespace::NAME` reads a constant of its own that happens to end in the same name.
+        def own_constant?
+          node.namespace.nil?
+        end
+
+        def class_level?
+          !runs_later? && !definition_identifier?(node)
+        end
+
+        def runs_later?
+          enclosing_method_of(node).present? || inside_deferred_block?
+        end
+
+        def inside_deferred_block?
+          node.each_ancestor(:any_block).any? { DEFERRED_MACROS.include?(it.method_name) }
+        end
+    end
+end

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

@@ -0,0 +1,342 @@
+# `delegate ... private: true` declares private methods, so it belongs in the
+# private section next to the other private declarations. Left above, it hides
+# private methods among the public API; left below the section's methods, it
+# hides a declaration among behavior.
+#
+# @example
+#   # bad
+#   class Report
+#     delegate :total, to: :order, private: true
+#
+#     def to_s
+#       total.to_s
+#     end
+#
+#     private
+#       attr_reader :order
+#   end
+#
+#   # bad - below the methods of its section
+#   class Report
+#     private
+#       def formatted_total
+#         total.to_s
+#       end
+#
+#       delegate :total, to: :order, private: true
+#   end
+#
+#   # good
+#   class Report
+#     def to_s
+#       total.to_s
+#     end
+#
+#     private
+#       attr_reader :order
+#       delegate :total, to: :order, private: true
+#   end
+#
+class RuboCop::Cop::Callbacksystems::PrivateDelegatePlacement < RuboCop::Cop::Callbacksystems::Base
+  extend RuboCop::Cop::AutoCorrector
+
+  def on_send(node)
+    report Delegate.new(node, processed_source)
+  end
+
+  alias on_csend on_send
+
+  private
+    class Delegate
+      include RuboCop::Callbacksystems::Helpers
+
+      MESSAGE = "Move this `delegate` into the private section; it declares private methods."
+      STRAYED_MESSAGE = "Move this `delegate` up beside the other private declarations."
+
+      def initialize(node, processed_source)
+        @node = node
+        @processed_source = processed_source
+      end
+
+      def offense
+        RuboCop::Callbacksystems::Offense.new(node, message, correcting: correctable?) { correct(it) } if misplaced?
+      end
+
+      private
+        attr_reader :node, :processed_source
+
+        def misplaced?
+          private_delegate? && statements.include?(node) && !placed_with_declarations?
+        end
+
+        def private_delegate?
+          macro.macro? && macro.private?
+        end
+
+        def macro
+          @macro ||= RuboCop::Callbacksystems::Methods::DelegateMacro.new(node)
+        end
+
+        def statements
+          @statements ||= statements_in(enclosing_body)
+        end
+
+        def enclosing_body
+          @enclosing_body ||= enclosing_definition_of(node)&.body
+        end
+
+        def placed_with_declarations?
+          declarations_after_private_modifier.include?(node)
+        end
+
+        def declarations_after_private_modifier
+          statements_after_private_modifier.take_while { declaration?(it) }
+        end
+
+        def statements_after_private_modifier
+          private_modifier ? statements.drop(statements.index(private_modifier) + 1) : []
+        end
+
+        def private_modifier
+          @private_modifier ||= private_modifier_in(enclosing_body)
+        end
+
+        def declaration?(statement)
+          statement.casgn_type? || declaration_macro?(statement)
+        end
+
+        def message
+          outside_private_section? ? MESSAGE : STRAYED_MESSAGE
+        end
+
+        def outside_private_section?
+          visibility_at(node, enclosing_body) != :private
+        end
+
+        def correctable?
+          movement_safe? && relocation_safe?
+        end
+
+        def movement_safe?
+          !blocked_by_constant? && !blocked_by_method_definition? && !blocked_by_comment? &&
+            !blocked_by_executable_statement? && tooling_scope_kept?
+        end
+
+        # Moving up over the assignment of a constant the delegate reads would break the class at load time.
+        def blocked_by_constant?
+          referenced_constant_names.intersect?(constant_names_crossed_moving_up)
+        end
+
+        def referenced_constant_names
+          node.arguments.flat_map { it.each_node(:const).map(&:short_name) }
+        end
+
+        def constant_names_crossed_moving_up
+          if anchor_index && anchor_index < node_index
+            statements[(anchor_index + 1)...node_index].select(&:casgn_type?).map(&:name)
+          else
+            []
+          end
+        end
+
+        def anchor_index
+          statements.index(anchor)
+        end
+
+        def anchor
+          declarations_after_private_modifier.last || private_modifier || statements.excluding(node).last
+        end
+
+        def node_index
+          statements.index(node)
+        end
+
+        # Swapping two declarations of the same method would change which implementation the class keeps.
+        def blocked_by_method_definition?
+          names = macro.defined_method_names&.to_set
+          crossed_names = method_names_defined_by(crossed_statements)
+
+          names.nil? || crossed_names.nil? || names.intersect?(crossed_names)
+        end
+
+        def method_names_defined_by(found)
+          names = found.map { RuboCop::Callbacksystems::Methods::StatementDefinitions.new(it).names }
+
+          names.flat_map(&:to_a).to_set if names.none?(&:nil?)
+        end
+
+        def crossed_statements
+          if anchor_index
+            if node_index < anchor_index
+              statements[(node_index + 1)..anchor_index]
+            else
+              statements[(anchor_index + 1)...node_index]
+            end
+          else
+            []
+          end
+        end
+
+        def blocked_by_comment?
+          movement_blocks.each_cons(2).any? do |above, below|
+            above.range.end.join(below.range.begin).source.strip.present?
+          end
+        end
+
+        def movement_blocks
+          movement_statements.map { RuboCop::Callbacksystems::Source::StatementWithComments.new(it, processed_source) }
+        end
+
+        def movement_statements
+          if anchor_index
+            first, last = [ node_index, anchor_index ].minmax
+            statements[first..last]
+          else
+            [ node ]
+          end
+        end
+
+        # Method bodies do not run while the class loads. Unknown statements do, so their relative order is kept.
+        def blocked_by_executable_statement?
+          crossed_statements.any? { !movable_across?(it) }
+        end
+
+        def movable_across?(statement)
+          statement.type?(:def, :defs) || visibility_modifier_of(statement) || declaration_macro?(statement)
+        end
+
+        def tooling_scope_kept?
+          movement_blocks.none?(&:contains_tooling_comment?)
+        end
+
+        def relocation_safe?
+          relocation_ranges_proven? && relocated_source.possible?
+        end
+
+        def relocation_ranges_proven?
+          statement_owns_line?(node) && (!anchor || statement_owns_line?(anchor))
+        end
+
+        def statement_owns_line?(statement)
+          StatementLine.new(statement).owned?
+        end
+
+        def relocated_source
+          @relocated_source ||= RelocatedSource.new(block, to: section_indentation)
+        end
+
+        def block
+          @block ||= RuboCop::Callbacksystems::Source::StatementWithComments.new(node, processed_source)
+        end
+
+        def section_indentation
+          statements_after_private_modifier.first&.then { indentation_of(it) } ||
+            "#{body_indentation}#{indentation_step}"
+        end
+
+        def body_indentation
+          indentation_of(statements.first)
+        end
+
+        def indentation_step
+          " " * (statements.first.source_range.column - enclosing_definition_of(node).source_range.column)
+        end
+
+        def correct(corrector)
+          if anchor
+            corrector.insert_after(anchor_block.range, relocated_delegate)
+            corrector.remove(statement_removal_range_of(block.range))
+          else
+            corrector.replace(block.range, private_section)
+          end
+        end
+
+        def anchor_block
+          @anchor_block ||= RuboCop::Callbacksystems::Source::StatementWithComments.new(anchor, processed_source)
+        end
+
+        def relocated_delegate
+          private_modifier ? indented_delegate : "\n\n#{body_indentation}private#{indented_delegate}"
+        end
+
+        def indented_delegate
+          "\n#{relocated_source.source}"
+        end
+
+        def private_section
+          "#{body_indentation}private#{indented_delegate}"
+        end
+    end
+
+    # Whether a statement range can be moved without consuming code that shares either edge line.
+    class StatementLine
+      def initialize(node)
+        @node = node
+      end
+
+      def owned?
+        code_before.strip.empty? && (code_after.strip.empty? || code_after.lstrip.start_with?("#"))
+      end
+
+      private
+        attr_reader :node
+
+        def code_before
+          node.source_range.source_line[0...node.source_range.column]
+        end
+
+        def code_after
+          node.source_range.end.source_line[node.source_range.end.column..]
+        end
+    end
+
+    # Source shifted by one indentation delta, with relative whitespace and heredoc contents left intact.
+    class RelocatedSource
+      def initialize(statement, to:)
+        @statement = statement
+        @target_indentation = to
+      end
+
+      def possible?
+        indentation_removable? && heredocs_preserved?
+      end
+
+      def source
+        lines.map { reindented(it) }.join
+      end
+
+      private
+        attr_reader :statement, :target_indentation
+
+        def indentation_removable?
+          delta >= 0 || lines.all? { it.strip.empty? || it.start_with?(removed_indentation) }
+        end
+
+        def delta
+          target_indentation.length - statement.node.source_range.column
+        end
+
+        def lines
+          @lines ||= statement.source.lines
+        end
+
+        def removed_indentation
+          " " * -delta
+        end
+
+        def heredocs_preserved?
+          delta.zero? || heredocs.all? { it.source.start_with?("<<~") }
+        end
+
+        def heredocs
+          statement.node.each_node(:str, :dstr, :xstr).select { it.loc?(:heredoc_body) }
+        end
+
+        def reindented(line)
+          if line.strip.empty? then line
+          elsif delta.positive? then "#{" " * delta}#{line}"
+          else line.delete_prefix(removed_indentation)
+          end
+        end
+    end
+end

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

@@ -0,0 +1,70 @@
+# A method you define goes in the private section, not above it with a
+# `private :name` afterwards. The section already says what the marker repeats.
+#
+# The marker earns its place when the method is not defined here, since a
+# section cannot reach a method that arrives from a superclass or a macro.
+# `Data.define` generating readers you would rather hide is the usual case.
+#
+# @example
+#   # bad
+#   class Report
+#     def total
+#     end
+#     private :total
+#   end
+#
+#   # good
+#   class Report
+#     private
+#       def total
+#       end
+#   end
+#
+#   # good - the reader comes from the superclass, so nothing here can hold it
+#   class Request < Data.define(:lock_held)
+#     alias lock_held? lock_held
+#
+#     private :lock_held
+#   end
+#
+class RuboCop::Cop::Callbacksystems::PrivateMethodsInPrivateSection < RuboCop::Cop::Callbacksystems::Base
+  def on_send(node)
+    report_each PrivateCall.new(node)
+  end
+
+  alias on_csend on_send
+
+  private
+    class PrivateCall
+      include RuboCop::Callbacksystems::Helpers
+
+      MESSAGE = "Declare `%<name>s` in the private section instead of marking it with `private :%<name>s`."
+
+      def initialize(node)
+        @node = node
+      end
+
+      def each_offense
+        movable_arguments.each { yield RuboCop::Callbacksystems::Offense.new(it, format(MESSAGE, name: it.value)) }
+      end
+
+      private
+        attr_reader :node
+
+        def movable_arguments
+          names_marked_by(node, macro: :private).select { defined_here?(it) }
+        end
+
+        def defined_here?(argument)
+          method_names.include?(argument.value.to_sym)
+        end
+
+        def method_names
+          @method_names ||= direct_definitions_in(enclosing_body, :def).map(&:method_name)
+        end
+
+        def enclosing_body
+          enclosing_definition_of(node)&.body
+        end
+    end
+end