rubocop-callbacksystems 0.1.0

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

@@ -0,0 +1,168 @@
+# Enforces an empty line before method definitions. The empty line is what
+# separates one definition from the next when reading down a class, so a method
+# pressed against a macro or the method above reads as a continuation of it.
+#
+# @example
+#   # bad - macro directly before method
+#   before_action :authenticate
+#   def index
+#   end
+#
+#   # bad - consecutive methods without empty line
+#   def name
+#   end
+#   def email
+#   end
+#
+#   # good - empty line before method
+#   before_action :authenticate
+#
+#   def index
+#   end
+#
+#   # good - empty line between methods
+#   def name
+#   end
+#
+#   def email
+#   end
+#
+#   # good - consecutive macros are fine
+#   validates :name
+#   validates :email
+#
+#   # good - first method in class body needs no preceding empty line
+#   class User
+#     def name
+#     end
+#   end
+#
+#   # good - method after visibility modifier needs no empty line
+#   private
+#     def helper
+#     end
+#
+class RuboCop::Cop::Callbacksystems::EmptyLineBeforeMethod < RuboCop::Cop::Callbacksystems::Base
+  extend RuboCop::Cop::AutoCorrector
+
+  def on_def(node)
+    report MethodDefinition.new(node, describing_macros)
+  end
+
+  alias on_defs on_def
+
+  private
+    def describing_macros
+      Array(cop_config["DescribingMacros"]).map(&:to_sym)
+    end
+
+    class MethodDefinition
+      include RuboCop::Callbacksystems::Helpers
+
+      MESSAGE = "Add an empty line before `%<method>s`."
+
+      def initialize(node, describing_macros)
+        @node = node
+        @describing_macros = describing_macros
+      end
+
+      def offense
+        if crowded?
+          RuboCop::Callbacksystems::Offense.new(node, message, correcting: source_ordered?) { correct(it) }
+        end
+      end
+
+      private
+        attr_reader :node, :describing_macros
+        delegate :adjacent_to_previous?, :leading_node, :previous_node, to: :description_group, private: true
+
+        def description_group
+          @description_group ||= DescriptionGroup.new(node, describing_macros)
+        end
+
+        def crowded?
+          previous_node && !after_visibility_modifier? && missing_empty_line?
+        end
+
+        def after_visibility_modifier?
+          !visibility_modifier_of(previous_node).nil?
+        end
+
+        def missing_empty_line?
+          adjacent_to_previous?
+        end
+
+        def message
+          format(MESSAGE, method: node.method_name)
+        end
+
+        def source_ordered?
+          range_through_heredocs(previous_node).end_pos <= leading_node.source_range.begin_pos
+        end
+
+        def correct(corrector)
+          if previous_node.last_line == leading_node.first_line
+            corrector.replace \
+              previous_node.source_range.end.join(leading_node.source_range.begin),
+              "\n\n#{indentation_of(previous_node)}"
+          else
+            corrector.insert_before(line_start_of(leading_node), "\n")
+          end
+        end
+
+        def line_start_of(statement)
+          position = line_start_position_of(statement)
+          statement.source_range.with(begin_pos: position, end_pos: position)
+        end
+
+        # The consecutive describing macros attached to a method and the statement immediately before that group.
+        class DescriptionGroup
+          include RuboCop::Callbacksystems::Helpers
+
+          def initialize(node, describing_macros)
+            @node = node
+            @describing_macros = describing_macros
+          end
+
+          def adjacent_to_previous?
+            previous_node && adjacent?(above: previous_node, below: leading_node)
+          end
+
+          def previous_node
+            siblings[leading_position.pred] if leading_position.positive?
+          end
+
+          def leading_node
+            siblings.fetch(leading_position)
+          end
+
+          private
+            attr_reader :node, :describing_macros
+
+            def leading_position
+              @leading_position ||= node_position.downto(1).find { !joins_description_at?(it) } || 0
+            end
+
+            def node_position
+              @node_position ||= siblings.index(node)
+            end
+
+            def siblings
+              @siblings ||= node.parent&.begin_type? ? node.parent.child_nodes : [ node ]
+            end
+
+            def joins_description_at?(position)
+              above = siblings.fetch(position.pred)
+              describing?(above) && adjacent?(above:, below: siblings.fetch(position))
+            end
+
+            def describing?(statement)
+              bare_send?(statement) && describing_macros.include?(statement.method_name)
+            end
+
+            def adjacent?(above:, below:)
+              (below.first_line - range_through_heredocs(above).last_line) <= 1
+            end
+        end
+    end
+end

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

@@ -0,0 +1,169 @@
+# A class body reads in sections: the mixins, the constants, the declarations of its state, the macros, the methods,
+# and the nested classes. A blank line is what tells the reader one section has ended and the next begins, so two
+# adjacent statements of different sections need one between them, while the statements of one section sit together
+# or apart as the author likes. `BodyOrder` owns the order the sections come in, and this cop asks only for the blank
+# line, whichever way round the two statements sit.
+#
+# The sections are coarser than the ranks `BodyOrder` reads. An `attribute`, an association and a `delegate` all
+# declare what the object holds, so they are one section, the way the authentication generator writes
+# `attribute :session` right above `delegate :user, ...` and `has_secure_password` right above `has_many :sessions`.
+#
+# A visibility modifier belongs to no section, so the pair it makes with the statement on either side is left to the
+# Layout cops.
+#
+# @example
+#   # bad - the token sits pressed against the constant
+#   class Key < ApplicationRecord
+#     PREFIX = "key_"
+#     has_secure_token :value
+#   end
+#
+#   # good
+#   class Key < ApplicationRecord
+#     PREFIX = "key_"
+#
+#     has_secure_token :value
+#   end
+#
+#   # good - the state declarations are one section
+#   class Current < ActiveSupport::CurrentAttributes
+#     attribute :session
+#     delegate :user, to: :session, allow_nil: true
+#   end
+#
+class RuboCop::Cop::Callbacksystems::EmptyLineBetweenSections < RuboCop::Cop::Callbacksystems::Base
+  extend RuboCop::Cop::AutoCorrector
+
+  def on_class(node)
+    report_each Body.new(node.body, processed_source)
+  end
+
+  alias on_module on_class
+  alias on_sclass on_class
+
+  private
+    class Body
+      include RuboCop::Callbacksystems::Helpers
+
+      def initialize(body, processed_source)
+        @body = body
+        @processed_source = processed_source
+      end
+
+      def each_offense(&block)
+        statements.each_cons(2).filter_map { |above, below| Boundary.new(above:, below:).offense }.each(&block)
+      end
+
+      private
+        attr_reader :body, :processed_source
+
+        def statements
+          @statements ||= nodes.map { Statement.new(it, nodes, processed_source) }
+        end
+
+        def nodes
+          @nodes ||= statements_in(body)
+        end
+    end
+
+    # Two statements written one after the other, read for the sections they belong to.
+    class Boundary
+      include RuboCop::Callbacksystems::Helpers
+
+      MESSAGE = "Separate `%<statement>s` from the %<above>s above with a blank line, since the %<below>s are " \
+        "another section."
+
+      def initialize(above:, below:)
+        @above = above
+        @below = below
+      end
+
+      def offense
+        if crowded?
+          RuboCop::Callbacksystems::Offense.new(below.node, message, correcting: source_ordered?) { correct(it) }
+        end
+      end
+
+      private
+        attr_reader :above, :below
+
+        def crowded?
+          crosses_sections? && !below.separated_from?(above)
+        end
+
+        def crosses_sections?
+          [ above, below ].none?(&:visibility_modifier?) && above.section != below.section
+        end
+
+        def message
+          format(MESSAGE, statement: below.opening_line, above: above.section, below: below.section)
+        end
+
+        def source_ordered?
+          above.last_line <= below.node.first_line
+        end
+
+        def correct(corrector)
+          if above.last_line == below.node.first_line
+            corrector.replace \
+              above.node.source_range.end.join(below.node.source_range.begin),
+              "\n\n#{indentation_of(above.node)}"
+          else
+            corrector.insert_before(below.line_start, "\n")
+          end
+        end
+    end
+
+    class Statement
+      include RuboCop::Callbacksystems::Helpers
+
+      SECTIONS = {
+        RuboCop::Callbacksystems::ClassStructure::StatementRank::MIXIN => "mixins",
+        RuboCop::Callbacksystems::ClassStructure::StatementRank::VALUE => "constants",
+        RuboCop::Callbacksystems::ClassStructure::StatementRank::CLASS_DECLARATION => "constants",
+        RuboCop::Callbacksystems::ClassStructure::StatementRank::ATTRIBUTE => "declarations",
+        RuboCop::Callbacksystems::ClassStructure::StatementRank::ASSOCIATION => "declarations",
+        RuboCop::Callbacksystems::ClassStructure::StatementRank::DELEGATE => "declarations",
+        RuboCop::Callbacksystems::ClassStructure::StatementRank::MACRO => "macros",
+        RuboCop::Callbacksystems::ClassStructure::StatementRank::METHOD => "methods",
+        RuboCop::Callbacksystems::ClassStructure::StatementRank::NESTED_CLASS => "nested classes"
+      }
+
+      attr_reader :node
+
+      def initialize(node, siblings, processed_source)
+        @node = node
+        @siblings = siblings
+        @processed_source = processed_source
+      end
+
+      def visibility_modifier?
+        visibility_modifier_of(node).present?
+      end
+
+      def section
+        @section ||= SECTIONS.fetch(RuboCop::Callbacksystems::ClassStructure::StatementRank.new(node, siblings).to_i)
+      end
+
+      def separated_from?(above)
+        processed_source.lines[above.last_line...(node.first_line - 1)].any?(&:blank?)
+      end
+
+      def last_line
+        range_through_heredocs(node).last_line
+      end
+
+      def opening_line
+        node.source.lines.first.strip
+      end
+
+      # The blank line goes above the comments introducing the statement, which travel with it.
+      def line_start
+        position = RuboCop::Callbacksystems::Source::StatementWithComments.new(node, processed_source).begin_position
+        node.source_range.with(begin_pos: position, end_pos: position)
+      end
+
+      private
+        attr_reader :siblings, :processed_source
+    end
+end

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

@@ -0,0 +1,107 @@
+# A `private` keyword with nothing after it declares a section that holds
+# nothing. Remove it and let the class end where it ends.
+#
+# The correction stays away when another expression observes the value of the
+# class or module definition: `private` returns `nil`, while the statement above
+# it may return something else.
+#
+# @example
+#   # bad
+#   class Order
+#     def total
+#     end
+#
+#     private
+#   end
+#
+#   # good
+#   class Order
+#     def total
+#     end
+#   end
+#
+class RuboCop::Cop::Callbacksystems::EmptyPrivateSection < RuboCop::Cop::Callbacksystems::Base
+  extend RuboCop::Cop::AutoCorrector
+
+  def on_send(node)
+    report PrivateSection.new(node, trailing_comment: trailing_comment_on(node))
+  end
+
+  alias on_csend on_send
+
+  private
+    def trailing_comment_on(node)
+      RuboCop::Callbacksystems::Source::Comments.for(processed_source).trailing_comment_on(node.last_line)
+    end
+
+    class PrivateSection
+      include RuboCop::Callbacksystems::Helpers
+
+      MESSAGE = "Remove the empty `private` section."
+
+      def initialize(node, trailing_comment:)
+        @node = node
+        @trailing_comment = trailing_comment
+      end
+
+      def offense
+        if empty?
+          RuboCop::Callbacksystems::Offense.new(node, MESSAGE, correcting: correctable?) do |corrector|
+            correct(corrector)
+          end
+        end
+      end
+
+      private
+        attr_reader :node, :trailing_comment
+
+        def empty?
+          private_modifier? && closes_enclosing_body?
+        end
+
+        def private_modifier?
+          visibility_modifier_of(node) == :private
+        end
+
+        def closes_enclosing_body?
+          statements_in(enclosing_body).last.equal?(node)
+        end
+
+        # `enclosing_body_for` reports only multi-statement bodies, and a body of just the modifier has one statement.
+        def enclosing_body
+          enclosing_definition_of(node)&.body
+        end
+
+        def correctable?
+          definition_result_discarded? && !moves_tooling_comment?
+        end
+
+        def definition_result_discarded?
+          RuboCop::Callbacksystems::Execution::DiscardedExpression.new(enclosing_definition_of(node)).discarded?
+        end
+
+        def moves_tooling_comment?
+          trailing_comment && tooling_comment?(trailing_comment)
+        end
+
+        def correct(corrector)
+          if inline_removal_range && trailing_comment
+            corrector.replace(inline_removal_range.join(trailing_comment.source_range), standing_comment)
+          else
+            corrector.remove(statement_removal_range_for(node))
+          end
+        end
+
+        def inline_removal_range
+          @inline_removal_range ||= inline_statement_removal_range_for(node)
+        end
+
+        def standing_comment
+          "\n#{line_indentation}#{trailing_comment.text}"
+        end
+
+        def line_indentation
+          node.source_range.source_line[/\A[ \t]*/]
+        end
+    end
+end

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

@@ -0,0 +1,71 @@
+# An empty class or module keeps its `end` on a line of its own, the way
+# `Style/EmptyMethod` already asks of an empty method.
+#
+# A nested empty class is left to `PreferClassNewForEmptyNestedClass`, which
+# turns it into a constant rather than a definition.
+#
+# @example
+#   # bad
+#   class PgBox::ConfigurationError < StandardError; end
+#
+#   # good
+#   class PgBox::ConfigurationError < StandardError
+#   end
+#
+class RuboCop::Cop::Callbacksystems::ExpandedEmptyClassOrModule < RuboCop::Cop::Callbacksystems::Base
+  extend RuboCop::Cop::AutoCorrector
+
+  def on_class(node)
+    report SingleLineDefinition.new(node)
+  end
+
+  alias on_module on_class
+
+  private
+    class SingleLineDefinition
+      include RuboCop::Callbacksystems::Helpers
+
+      MESSAGE = "Put `end` on its own line."
+
+      def initialize(node)
+        @node = node
+      end
+
+      def offense
+        if expandable?
+          RuboCop::Callbacksystems::Offense.new(node, MESSAGE, correcting: superclass_without_heredoc?) { correct(it) }
+        end
+      end
+
+      private
+        attr_reader :node
+
+        def expandable?
+          node.body.nil? && node.single_line? && stays_a_definition?
+        end
+
+        def stays_a_definition?
+          node.module_type? || enclosing_class_or_module_of(node).nil?
+        end
+
+        def superclass_without_heredoc?
+          node.module_type? || node.parent_class.nil? || !carries_heredoc?(node.parent_class)
+        end
+
+        def correct(corrector)
+          corrector.replace(gap_before_end, "\n#{indentation_of(node)}")
+        end
+
+        def gap_before_end
+          node.source_range.with(begin_pos: header_end, end_pos: node.loc.end.begin_pos)
+        end
+
+        def header_end
+          (superclass || node.identifier).source_range.end_pos
+        end
+
+        def superclass
+          node.parent_class if node.class_type?
+        end
+    end
+end

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

@@ -0,0 +1,110 @@
+# Detects memoization methods that delegate to another method in the same class.
+# The second method exists only to serve the first, so the reading is split
+# across two definitions for nothing, and the computation belongs in the method
+# that caches it.
+#
+# @example
+#   # bad - delegates to another method
+#   def user
+#     @user ||= find_user
+#   end
+#
+#   private
+#     def find_user
+#       User.find(params[:id])
+#     end
+#
+#   # good - computation is inline
+#   def user
+#     @user ||= User.find(params[:id])
+#   end
+#
+#   # good - calls a method on a receiver (not delegation)
+#   def owner
+#     @owner ||= account.owner
+#   end
+#
+#   # good - calls method with arguments
+#   def formatted_name
+#     @formatted_name ||= format_name(first, last)
+#   end
+#
+#   # good - has additional logic
+#   def user
+#     @user ||= find_user || default_user
+#   end
+#
+class RuboCop::Cop::Callbacksystems::InlineMemoizedComputation < RuboCop::Cop::Callbacksystems::Base
+  def on_new_investigation
+    @method_calls = RuboCop::Callbacksystems::Methods::Calls.new(processed_source.ast)
+    @sibling_methods = RuboCop::Callbacksystems::Methods::Siblings.new
+    @macro_referenced_methods = RuboCop::Callbacksystems::Methods::MacroReferences::ContainerIndex.new
+  end
+
+  def on_def(node)
+    report Memoization.new(node, method_calls:, sibling_methods:, macro_referenced_methods:)
+  end
+
+  alias on_defs on_def
+
+  private
+    attr_reader :macro_referenced_methods, :method_calls, :sibling_methods
+
+    class Memoization
+      include RuboCop::Callbacksystems::Helpers
+
+      MESSAGE = "Inline the computation from `%<method>s` instead of delegating."
+
+      def initialize(node, method_calls:, sibling_methods:, macro_referenced_methods:)
+        @node = node
+        @method_calls = method_calls
+        @sibling_methods = sibling_methods
+        @macro_referenced_methods = macro_referenced_methods
+      end
+
+      def offense
+        RuboCop::Callbacksystems::Offense.new(node, message) if delegates_to_own_method?
+      end
+
+      private
+        attr_reader :node, :method_calls, :sibling_methods, :macro_referenced_methods
+        delegate :expression, to: "node.body", private: true
+
+        def delegates_to_own_method?
+          node.body&.or_asgn_type? && delegating_call? && private_delegated_definition? && sole_call_site? &&
+            !macro_referenced?
+        end
+
+        def delegating_call?
+          bare_send?(expression) && expression.arguments.empty?
+        end
+
+        def private_delegated_definition?
+          delegated_definition && private_method?(delegated_definition)
+        end
+
+        def delegated_definition
+          @delegated_definition ||= sibling_methods.named(delegated_method, beside: node).first
+        end
+
+        def delegated_method
+          expression.method_name
+        end
+
+        def sole_call_site?
+          calls_to_delegated_method.one? && calls_to_delegated_method.first.equal?(expression)
+        end
+
+        def calls_to_delegated_method
+          @calls_to_delegated_method ||= method_calls.named(delegated_method, from: node)
+        end
+
+        def macro_referenced?
+          macro_referenced_methods.include?(delegated_method, beside: node)
+        end
+
+        def message
+          format(MESSAGE, method: delegated_method)
+        end
+    end
+end