rubocop-callbacksystems 0.1.0

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

@@ -0,0 +1,84 @@
+# Counts only validation guards: leading `return`s that reject input by
+# returning nothing, `nil`, or `false`. Dispatch branches like
+# `return start_value if start?` are a lookup table written as control flow,
+# not validation, so they don't count. Many validations at the start of a
+# method usually means the checks belong in an extracted predicate.
+#
+# @example MaxGuards: 2 (default)
+#   # bad - three leading validation guards
+#   def process(account)
+#     return unless account
+#     return false if account.closed?
+#     return nil unless account.active?
+#     charge(account)
+#   end
+#
+#   # good - extract the validation
+#   def process(account)
+#     return unless chargeable?(account)
+#     charge(account)
+#   end
+#
+class RuboCop::Cop::Callbacksystems::TooManyValidationGuards < RuboCop::Cop::Callbacksystems::Base
+  def on_def(node)
+    report LeadingGuards.new(node, maximum: cop_config["MaxGuards"])
+  end
+
+  alias on_defs on_def
+
+  private
+    class LeadingGuards
+      include RuboCop::Callbacksystems::Helpers
+
+      MESSAGE = "Method has %<count>d leading validation guards (max %<maximum>d). Extract validation into a helper."
+
+      def initialize(node, maximum:)
+        @node = node
+        @maximum = maximum
+      end
+
+      def offense
+        RuboCop::Callbacksystems::Offense.new(node, message) if count > maximum
+      end
+
+      private
+        attr_reader :node, :maximum
+
+        def count
+          @count ||= leading_zone.count { validation_guard?(it) }
+        end
+
+        def leading_zone
+          statements_in(node.body).take_while { in_zone?(it) }
+        end
+
+        def in_zone?(statement)
+          statement.lvasgn_type? || validation_guard?(statement)
+        end
+
+        def validation_guard?(statement)
+          statement.if_type? && single_branch?(statement) && rejecting_return?(lone_branch_of(statement))
+        end
+
+        # A full `if`/`else` is a two-way choice, not a guard.
+        def single_branch?(if_node)
+          [ if_node.if_branch, if_node.else_branch ].compact.one?
+        end
+
+        def rejecting_return?(branch)
+          branch.return_type? && (branch.children.empty? || single_rejecting_value?(branch))
+        end
+
+        def single_rejecting_value?(return_node)
+          return_node.children.one? && return_node.children.first.falsey_literal?
+        end
+
+        def lone_branch_of(if_node)
+          if_node.if_branch || if_node.else_branch
+        end
+
+        def message
+          format(MESSAGE, count:, maximum:)
+        end
+    end
+end

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

@@ -0,0 +1,176 @@
+# Detects local variables that alias a method call that already reads as a name.
+# Call the method directly or extract a well-named declarative method instead.
+# A variable that names a computed expression (operator, block-pass, literal
+# receiver) or a multiline call is left alone: there the name does real work.
+#
+# @example
+#   # bad - variable just aliases a method call
+#   directory = forbidden_directory
+#   add_offense(node) if directory
+#
+#   # good - call the method directly
+#   add_offense(node) if forbidden_directory
+#
+#   # ok - variable names a computed expression
+#   valid_values = options.map(&:value)
+#   answer.errors.add(:base) if (submitted_values - valid_values).any?
+#
+#   # ok - call spans multiple lines
+#   record = relation.create! \
+#     type: "Report",
+#     data: {}
+#   record.deliver
+#
+#   # ok - variable used multiple times
+#   user = find_user
+#   user.activate
+#   user.notify
+#
+#   # ok - variable used inside a block (may be mutated across iterations)
+#   result = Set.new
+#   items.each { |item| result << item }
+#
+#   # ok - assignment in conditional
+#   if user = find_user
+#     user.activate
+#   end
+#
+#   # ok - variable reassigned
+#   current = first
+#   current = current.next while current
+#
+class RuboCop::Cop::Callbacksystems::UnnecessaryLocalVariable < RuboCop::Cop::Callbacksystems::Base
+  extend RuboCop::Cop::AutoCorrector
+
+  def on_new_investigation
+    @local_variables = RuboCop::Callbacksystems::Execution::LocalVariableOccurrences.new(processed_source.ast)
+    @source_comments = RuboCop::Callbacksystems::Source::Comments.for(processed_source)
+  end
+
+  def on_lvasgn(node)
+    report Assignment.new(node, @local_variables, @source_comments)
+  end
+
+  private
+    class Assignment
+      include RuboCop::Callbacksystems::Helpers
+
+      MESSAGE = "Variable `%<name>s` is unnecessary. Call the method directly or extract a well-named declarative " \
+        "method."
+
+      def initialize(node, local_variables, source_comments)
+        @node = node
+        @local_variables = local_variables
+        @source_comments = source_comments
+      end
+
+      def offense
+        RuboCop::Callbacksystems::Offense.new(node, message, correcting: inlineable?) { correct(it) } if unnecessary?
+      end
+
+      private
+        attr_reader :node, :local_variables, :source_comments
+
+        def unnecessary?
+          aliases_named_call? && !conditional? && single_use? && !used_inside_nested_block? && !used_for_restoration?
+        end
+
+        def aliases_named_call?
+          value&.type?(:call) && !computed_expression? && !value.multiline?
+        end
+
+        def value
+          node.expression
+        end
+
+        def computed_expression?
+          value.operator_method? || value.arguments.any?(&:block_pass_type?) || literal_receiver?
+        end
+
+        def literal_receiver?
+          value.receiver&.then { it.type?(:array, :hash) || it.recursive_literal? }
+        end
+
+        def conditional?
+          node.each_ancestor(:if, :while, :until, :case, :and, :or).any?
+        end
+
+        def single_use?
+          enclosing_scope && !reassigned? && references.one?
+        end
+
+        def enclosing_scope
+          @enclosing_scope ||= enclosing_scope_of(node)
+        end
+
+        def reassigned?
+          other_occurrences.any? { it.type?(:lvasgn, :match_var) }
+        end
+
+        def other_occurrences
+          @other_occurrences ||= local_variables.named(node.name, around: node).reject { it.equal?(node) }
+        end
+
+        def references
+          @references ||= other_occurrences.select(&:lvar_type?)
+        end
+
+        def used_inside_nested_block?
+          reference.each_ancestor(:any_block).any? { it != enclosing_scope }
+        end
+
+        def reference
+          references.first
+        end
+
+        def used_for_restoration?
+          reference.each_ancestor(:ensure, :resbody).any?
+        end
+
+        def message
+          format(MESSAGE, name: node.name)
+        end
+
+        # The next statement removes intervening work; its evaluation path must also keep the call eager and ordered.
+        def inlineable?
+          nodes_in(next_statement, :lvar).any? { it.equal?(reference) } && !read_by_another_assignment? &&
+            !carries_heredoc?(node) && relocation_preserves_order? && removal_uncommented?
+        end
+
+        def next_statement
+          node.right_sibling if node.parent.begin_type?
+        end
+
+        # Two corrections on one line would overwrite each other, so this one waits for the pass that follows.
+        def read_by_another_assignment?
+          reference.each_ancestor(:lvasgn).any?
+        end
+
+        def relocation_preserves_order?
+          RuboCop::Callbacksystems::Execution::EagerEvaluationPath.new(reference, within: next_statement)
+            .preserves_order?
+        end
+
+        def removal_uncommented?
+          !source_comments.any_within?(node.source_range.with(end_pos: next_statement.source_range.begin_pos))
+        end
+
+        def correct(corrector)
+          corrector.remove(node.source_range.with(end_pos: next_statement.source_range.begin_pos))
+          replace_expression(corrector, reference, with: inlined_source)
+        end
+
+        # Bare arguments at the read would swallow the following `.method` or comma, so they get parentheses.
+        def inlined_source
+          if value.arguments? && !value.parenthesized?
+            "#{call_source_through_selector}(#{value.arguments.map(&:source).join(", ")})"
+          else
+            value.source
+          end
+        end
+
+        def call_source_through_selector
+          value.source_range.with(end_pos: value.loc.selector.end_pos).source
+        end
+    end
+end

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

@@ -0,0 +1,203 @@
+# Detects private methods of a visually private nested class that nothing
+# calls. When the project index confirms that no other file reaches or reopens
+# the class, a private method no line of the file names is dead code a reader
+# still has to account for.
+#
+# @example
+#   # bad - unused private method
+#   class Foo
+#     def process
+#       Bar.new.run
+#       nil
+#     end
+#
+#     private
+#       class Bar
+#         def run
+#           helper
+#         end
+#
+#         private
+#           def helper; end
+#           def unused; end  # never called
+#       end
+#   end
+#
+#   # good - all private methods are used
+#   class Foo
+#     def process
+#       Bar.new.run
+#       nil
+#     end
+#
+#     private
+#       class Bar
+#         def run
+#           helper
+#         end
+#
+#         private
+#           def helper; end
+#       end
+#   end
+#
+class RuboCop::Cop::Callbacksystems::UnusedPrivateMethodInNestedClass < RuboCop::Cop::Callbacksystems::Base
+  include RuboCop::Callbacksystems::ProjectIndex::Support
+
+  def on_new_investigation
+    @file_references = FileReferences.new(processed_source.ast) if project_index
+  end
+
+  def on_class(node)
+    if project_index_reliable?
+      private_nested_classes_in(node).each do |nested_class|
+        confined_declaration_of(nested_class)&.then do |declaration|
+          report_each UnusedMethods.new(nested_class, declaration:, references: file_references)
+        end
+      end
+    end
+  end
+
+  alias on_module on_class
+
+  private
+    attr_reader :file_references
+
+    # Every source-level way the file can name or discover one of the nested class's methods, indexed once.
+    class FileReferences
+      include RuboCop::Callbacksystems::Helpers
+
+      NAME_PREFIX_PATTERN = /[a-zA-Z_]\w*\z/
+      DYNAMIC_METHOD_LOOKUPS = %i[
+        send __send__ public_send method public_method private_method instance_method public_instance_method
+        respond_to? method_defined? public_method_defined? protected_method_defined? private_method_defined?
+        alias_method
+      ]
+      METHOD_ENUMERATIONS = %i[
+        methods public_methods protected_methods private_methods singleton_methods
+        instance_methods public_instance_methods protected_instance_methods private_instance_methods
+      ]
+
+      def initialize(root)
+        @evidence = RuboCop::Callbacksystems::Methods::ReferenceEvidence.for(root)
+      end
+
+      def complete?
+        dynamic_calls_resolved? && !methods_enumerated?
+      end
+
+      def include?(method_name)
+        called_methods.include?(method_name) || dynamically_called_methods.include?(method_name) ||
+          aliased_methods.include?(method_name) || macro_referenced_methods.include?(method_name) ||
+          literal_method_names.include?(method_name.to_s) ||
+          literal_method_prefixes.any? { method_name.to_s.start_with?(it) }
+      end
+
+      private
+        attr_reader :evidence
+
+        delegate :macro_referenced_methods, :literal_method_names, to: :evidence, private: true
+
+        def dynamic_calls_resolved?
+          dynamic_calls.all? do |send_node|
+            method_name_arguments_of(send_node).all? { it.type?(:sym, :str) }
+          end
+        end
+
+        def dynamic_calls
+          @dynamic_calls ||= evidence.calls.select { DYNAMIC_METHOD_LOOKUPS.include?(it.method_name) }
+        end
+
+        def method_name_arguments_of(send_node)
+          send_node.method?(:alias_method) ? send_node.arguments : [ send_node.first_argument ].compact
+        end
+
+        def methods_enumerated?
+          evidence.calls.any? { METHOD_ENUMERATIONS.include?(it.method_name) }
+        end
+
+        def called_methods
+          @called_methods ||= evidence.calls.to_set(&:method_name)
+        end
+
+        def dynamically_called_methods
+          @dynamically_called_methods ||= dynamic_calls.flat_map do |send_node|
+            method_name_arguments_of(send_node).filter_map { literal_method_name_of(it) }
+          end.to_set
+        end
+
+        def literal_method_name_of(literal)
+          literal.value.to_s.then { it.to_sym if it.valid_encoding? }
+        end
+
+        def aliased_methods
+          @aliased_methods ||= evidence.alias_nodes.flat_map do |alias_node|
+            alias_node.children.filter_map { literal_method_name_of(it) if it.type?(:sym, :str) }
+          end.to_set
+        end
+
+        def literal_method_prefixes
+          @literal_method_prefixes ||= evidence.interpolated_literals.filter_map do |literal|
+            interpolation_prefix(literal)
+          end.to_set
+        end
+
+        def interpolation_prefix(node)
+          if node.children.any? { !it.str_type? }
+            node.children.first.then { it.value.to_s.scrub[NAME_PREFIX_PATTERN] if it.str_type? }
+          end
+        end
+    end
+
+    class UnusedMethods
+      include RuboCop::Callbacksystems::Helpers
+
+      MESSAGE = "Private method `%<method>s` in nested class `%<class>s` is never called. Remove it."
+      STRUCTURAL_METHODS = RuboCop::Callbacksystems::Methods::ImplicitInvocations::METHOD_NAMES
+
+      def initialize(nested_class, declaration:, references:)
+        @nested_class = nested_class
+        @declaration = declaration
+        @references = references
+      end
+
+      def each_offense
+        unused_methods.each { yield RuboCop::Callbacksystems::Offense.new(it, message_for(it)) }
+      end
+
+      private
+        attr_reader :nested_class, :declaration, :references
+
+        def unused_methods
+          provable? ? uncalled_methods : []
+        end
+
+        # A superclass calls the hooks its subclass overrides, and that call is nowhere in this file.
+        def provable?
+          nested_class.parent_class.nil? && !subclassed_elsewhere? && references.complete?
+        end
+
+        def subclassed_elsewhere?
+          declaration.descendants.any? { it.name != declaration.name }
+        end
+
+        def uncalled_methods
+          private_methods_in(nested_class).reject do |method_node|
+            STRUCTURAL_METHODS.include?(method_node.method_name) || override?(method_node.method_name) ||
+              referenced?(method_node.method_name)
+          end
+        end
+
+        def override?(method_name)
+          declaration.find_member("#{method_name}()", only_inherited: true).present?
+        end
+
+        def referenced?(method_name)
+          references.include?(method_name)
+        end
+
+        def message_for(method_node)
+          format(MESSAGE, method: method_node.method_name, class: nested_class.identifier.short_name)
+        end
+    end
+end

data/lib/rubocop-callbacksystems.rb

@@ -0,0 +1,21 @@
+require "zeitwerk"
+require "rubocop"
+require "active_support/concern"
+require "active_support/core_ext/array/access"
+require "active_support/core_ext/enumerable"
+require "active_support/core_ext/module/delegation"
+require "active_support/core_ext/object/blank"
+require "active_support/core_ext/string/exclude"
+require "active_support/core_ext/string/inflections"
+
+module RubocopCallbacksystems
+end
+
+loader = Zeitwerk::Loader.new
+loader.tag = "rubocop-callbacksystems"
+loader.push_dir("#{__dir__}/rubocop", namespace: RuboCop)
+loader.ignore("#{__dir__}/rubocop/callbacksystems/cops_document.rb")
+loader.setup
+loader.eager_load
+RuboCop::ProjectIndexLoader.singleton_class.prepend RuboCop::Callbacksystems::ProjectIndex::Loader
+RuboCop::Cop::Team.prepend RuboCop::Callbacksystems::ProjectIndex::Corrections