spoom 1.5.0 → 1.7.2

data/lib/spoom/deadcode/indexer.rb

@@ -4,15 +4,13 @@
 module Spoom
   module Deadcode
     class Indexer < Visitor
-      extend T::Sig
-
-      sig { returns(String) }
+      #: String
       attr_reader :path
 
-      sig { returns(Index) }
+      #: Index
       attr_reader :index
 
-      sig { params(path: String, index: Index, plugins: T::Array[Plugins::Base]).void }
+      #: (String path, Index index, ?plugins: Array[Plugins::Base]) -> void
       def initialize(path, index, plugins: [])
         super()
 
@@ -23,7 +21,8 @@ module Spoom
 
       # Visit
 
-      sig { override.params(node: Prism::CallNode).void }
+      # @override
+      #: (Prism::CallNode node) -> void
       def visit_call_node(node)
         visit(node.receiver)
 

data/lib/spoom/deadcode/plugins/action_mailer.rb

@@ -5,9 +5,8 @@ module Spoom
   module Deadcode
     module Plugins
       class ActionMailer < Base
-        extend T::Sig
-
-        sig { override.params(send: Send).void }
+        # @override
+        #: (Send send) -> void
         def on_send(send)
           return unless send.recv.nil? && ActionPack::CALLBACKS.include?(send.name)
 

data/lib/spoom/deadcode/plugins/action_mailer_preview.rb

@@ -5,11 +5,10 @@ module Spoom
   module Deadcode
     module Plugins
       class ActionMailerPreview < Base
-        extend T::Sig
-
         ignore_classes_inheriting_from("ActionMailer::Preview")
 
-        sig { override.params(definition: Model::Method).void }
+        # @override
+        #: (Model::Method definition) -> void
         def on_define_method(definition)
           owner = definition.owner
           return unless owner.is_a?(Model::Class)

data/lib/spoom/deadcode/plugins/actionpack.rb

@@ -5,29 +5,25 @@ module Spoom
   module Deadcode
     module Plugins
       class ActionPack < Base
-        extend T::Sig
-
         ignore_classes_inheriting_from("ApplicationController")
 
-        CALLBACKS = T.let(
-          [
-            "after_action",
-            "append_after_action",
-            "append_around_action",
-            "append_before_action",
-            "around_action",
-            "before_action",
-            "prepend_after_action",
-            "prepend_around_action",
-            "prepend_before_action",
-            "skip_after_action",
-            "skip_around_action",
-            "skip_before_action",
-          ].freeze,
-          T::Array[String],
-        )
-
-        sig { override.params(definition: Model::Method).void }
+        CALLBACKS = [
+          "after_action",
+          "append_after_action",
+          "append_around_action",
+          "append_before_action",
+          "around_action",
+          "before_action",
+          "prepend_after_action",
+          "prepend_around_action",
+          "prepend_before_action",
+          "skip_after_action",
+          "skip_around_action",
+          "skip_before_action",
+        ].freeze #: Array[String]
+
+        # @override
+        #: (Model::Method definition) -> void
         def on_define_method(definition)
           owner = definition.owner
           return unless owner.is_a?(Model::Class)
@@ -35,7 +31,8 @@ module Spoom
           @index.ignore(definition) if ignored_subclass?(owner)
         end
 
-        sig { override.params(send: Send).void }
+        # @override
+        #: (Send send) -> void
         def on_send(send)
           return unless send.recv.nil? && CALLBACKS.include?(send.name)
 

data/lib/spoom/deadcode/plugins/active_model.rb

@@ -5,12 +5,11 @@ module Spoom
   module Deadcode
     module Plugins
       class ActiveModel < Base
-        extend T::Sig
-
         ignore_classes_inheriting_from("ActiveModel::EachValidator")
         ignore_methods_named("validate_each", "persisted?")
 
-        sig { override.params(send: Send).void }
+        # @override
+        #: (Send send) -> void
         def on_send(send)
           return if send.recv
 

data/lib/spoom/deadcode/plugins/active_record.rb

@@ -5,8 +5,6 @@ module Spoom
   module Deadcode
     module Plugins
       class ActiveRecord < Base
-        extend T::Sig
-
         ignore_classes_inheriting_from(/^(::)?ActiveRecord::Migration/)
 
         ignore_methods_named(
@@ -17,65 +15,76 @@ module Spoom
           "to_param",
         )
 
-        CALLBACKS = T.let(
-          [
-            "after_commit",
-            "after_create_commit",
-            "after_create",
-            "after_destroy_commit",
-            "after_destroy",
-            "after_find",
-            "after_initialize",
-            "after_rollback",
-            "after_save_commit",
-            "after_save",
-            "after_touch",
-            "after_update_commit",
-            "after_update",
-            "after_validation",
-            "around_create",
-            "around_destroy",
-            "around_save",
-            "around_update",
-            "before_create",
-            "before_destroy",
-            "before_save",
-            "before_update",
-            "before_validation",
-          ].freeze,
-          T::Array[String],
-        )
+        CALLBACKS = [
+          "after_commit",
+          "after_create_commit",
+          "after_create",
+          "after_destroy_commit",
+          "after_destroy",
+          "after_find",
+          "after_initialize",
+          "after_rollback",
+          "after_save_commit",
+          "after_save",
+          "after_touch",
+          "after_update_commit",
+          "after_update",
+          "after_validation",
+          "around_create",
+          "around_destroy",
+          "around_save",
+          "around_update",
+          "before_create",
+          "before_destroy",
+          "before_save",
+          "before_update",
+          "before_validation",
+        ].freeze #: Array[String]
 
-        CRUD_METHODS = T.let(
-          [
-            "assign_attributes",
-            "create",
-            "create!",
-            "insert",
-            "insert!",
-            "new",
-            "update",
-            "update!",
-            "upsert",
-          ].freeze,
-          T::Array[String],
-        )
+        CALLBACK_CONDITIONS = [
+          "if",
+          "unless",
+        ].freeze #: Array[String]
 
-        ARRAY_METHODS = T.let(
-          [
-            "insert_all",
-            "insert_all!",
-            "upsert_all",
-          ].freeze,
-          T::Array[String],
-        )
+        CRUD_METHODS = [
+          "assign_attributes",
+          "create",
+          "create!",
+          "insert",
+          "insert!",
+          "new",
+          "update",
+          "update!",
+          "upsert",
+        ].freeze #: Array[String]
+
+        ARRAY_METHODS = [
+          "insert_all",
+          "insert_all!",
+          "upsert_all",
+        ].freeze #: Array[String]
 
-        sig { override.params(send: Send).void }
+        # @override
+        #: (Send send) -> void
         def on_send(send)
           if send.recv.nil? && CALLBACKS.include?(send.name)
+            # Process direct symbol arguments
             send.each_arg(Prism::SymbolNode) do |arg|
               @index.reference_method(arg.unescaped, send.location)
             end
+
+            # Process hash arguments for conditions like if: :method_name
+            send.each_arg_assoc do |key, value|
+              key = key.slice.delete_suffix(":")
+
+              case key
+              when *CALLBACK_CONDITIONS
+                if value&.is_a?(Prism::SymbolNode)
+                  @index.reference_method(value.unescaped, send.location)
+                end
+              end
+            end
+
             return
           end
 

data/lib/spoom/deadcode/plugins/active_support.rb

@@ -16,9 +16,10 @@ module Spoom
           "before_teardown",
         )
 
-        SETUP_AND_TEARDOWN_METHODS = T.let(["setup", "teardown"], T::Array[String])
+        SETUP_AND_TEARDOWN_METHODS = ["setup", "teardown"] #: Array[String]
 
-        sig { override.params(send: Send).void }
+        # @override
+        #: (Send send) -> void
         def on_send(send)
           return unless send.recv.nil? && SETUP_AND_TEARDOWN_METHODS.include?(send.name)
 

data/lib/spoom/deadcode/plugins/base.rb

@@ -7,14 +7,11 @@ module Spoom
   module Deadcode
     module Plugins
       class Base
-        extend T::Sig
         extend T::Helpers
 
         abstract!
 
         class << self
-          extend T::Sig
-
           # Plugins DSL
 
           # Mark classes matching `names` as ignored.
@@ -30,7 +27,7 @@ module Spoom
           #   )
           # end
           # ~~~
-          sig { params(names: T.any(String, Regexp)).void }
+          #: (*(String | Regexp) names) -> void
           def ignore_classes_named(*names)
             save_names_and_patterns(names, :@ignored_class_names, :@ignored_class_patterns)
           end
@@ -48,7 +45,7 @@ module Spoom
           #   )
           # end
           # ~~~
-          sig { params(names: T.any(String, Regexp)).void }
+          #: (*(String | Regexp) names) -> void
           def ignore_classes_inheriting_from(*names)
             save_names_and_patterns(names, :@ignored_subclasses_of_names, :@ignored_subclasses_of_patterns)
           end
@@ -66,7 +63,7 @@ module Spoom
           #   )
           # end
           # ~~~
-          sig { params(names: T.any(String, Regexp)).void }
+          #: (*(String | Regexp) names) -> void
           def ignore_constants_named(*names)
             save_names_and_patterns(names, :@ignored_constant_names, :@ignored_constant_patterns)
           end
@@ -84,7 +81,7 @@ module Spoom
           #   )
           # end
           # ~~~
-          sig { params(names: T.any(String, Regexp)).void }
+          #: (*(String | Regexp) names) -> void
           def ignore_methods_named(*names)
             save_names_and_patterns(names, :@ignored_method_names, :@ignored_method_patterns)
           end
@@ -102,14 +99,14 @@ module Spoom
           #   )
           # end
           # ~~~
-          sig { params(names: T.any(String, Regexp)).void }
+          #: (*(String | Regexp) names) -> void
           def ignore_modules_named(*names)
             save_names_and_patterns(names, :@ignored_module_names, :@ignored_module_patterns)
           end
 
           private
 
-          sig { params(names: T::Array[T.any(String, Regexp)], names_variable: Symbol, patterns_variable: Symbol).void }
+          #: (Array[(String | Regexp)] names, Symbol names_variable, Symbol patterns_variable) -> void
           def save_names_and_patterns(names, names_variable, patterns_variable)
             ignored_names = instance_variable_set(names_variable, Set.new)
             ignored_patterns = instance_variable_set(patterns_variable, [])
@@ -125,10 +122,10 @@ module Spoom
           end
         end
 
-        sig { returns(Index) }
+        #: Index
         attr_reader :index
 
-        sig { params(index: Index).void }
+        #: (Index index) -> void
         def initialize(index)
           @index = index
         end
@@ -148,13 +145,13 @@ module Spoom
         #   end
         # end
         # ~~~
-        sig { params(definition: Model::Attr).void }
+        #: (Model::Attr definition) -> void
         def on_define_accessor(definition)
           # no-op
         end
 
         # Do not override this method, use `on_define_accessor` instead.
-        sig { params(definition: Model::Attr).void }
+        #: (Model::Attr definition) -> void
         def internal_on_define_accessor(definition)
           on_define_accessor(definition)
         end
@@ -172,13 +169,13 @@ module Spoom
         #   end
         # end
         # ~~~
-        sig { params(definition: Model::Class).void }
+        #: (Model::Class definition) -> void
         def on_define_class(definition)
           # no-op
         end
 
         # Do not override this method, use `on_define_class` instead.
-        sig { params(definition: Model::Class).void }
+        #: (Model::Class definition) -> void
         def internal_on_define_class(definition)
           if ignored_class_name?(definition.name)
             @index.ignore(definition)
@@ -202,13 +199,13 @@ module Spoom
         #   end
         # end
         # ~~~
-        sig { params(definition: Model::Constant).void }
+        #: (Model::Constant definition) -> void
         def on_define_constant(definition)
           # no-op
         end
 
         # Do not override this method, use `on_define_constant` instead.
-        sig { params(definition: Model::Constant).void }
+        #: (Model::Constant definition) -> void
         def internal_on_define_constant(definition)
           @index.ignore(definition) if ignored_constant_name?(definition.name)
 
@@ -228,13 +225,13 @@ module Spoom
         #   end
         # end
         # ~~~
-        sig { params(definition: Model::Method).void }
+        #: (Model::Method definition) -> void
         def on_define_method(definition)
           # no-op
         end
 
         # Do not override this method, use `on_define_method` instead.
-        sig { params(definition: Model::Method).void }
+        #: (Model::Method definition) -> void
         def internal_on_define_method(definition)
           @index.ignore(definition) if ignored_method_name?(definition.name)
 
@@ -254,13 +251,13 @@ module Spoom
         #   end
         # end
         # ~~~
-        sig { params(definition: Model::Module).void }
+        #: (Model::Module definition) -> void
         def on_define_module(definition)
           # no-op
         end
 
         # Do not override this method, use `on_define_module` instead.
-        sig { params(definition: Model::Module).void }
+        #: (Model::Module definition) -> void
         def internal_on_define_module(definition)
           @index.ignore(definition) if ignored_module_name?(definition.name)
 
@@ -280,7 +277,7 @@ module Spoom
         #   end
         # end
         # ~~~
-        sig { params(send: Send).void }
+        #: (Send send) -> void
         def on_send(send)
           # no-op
         end
@@ -289,7 +286,7 @@ module Spoom
 
         # DSL support
 
-        sig { params(definition: Model::Namespace, superclass_name: String).returns(T::Boolean) }
+        #: (Model::Namespace definition, String superclass_name) -> bool
         def subclass_of?(definition, superclass_name)
           superclass_symbol = @index.model.symbols[superclass_name]
           return false unless superclass_symbol
@@ -297,14 +294,14 @@ module Spoom
           @index.model.symbols_hierarchy.edge?(definition.symbol, superclass_symbol)
         end
 
-        sig { params(name: T.nilable(String)).returns(T::Boolean) }
+        #: (String? name) -> bool
         def ignored_class_name?(name)
           return false unless name
 
           ignored_name?(name, :@ignored_class_names, :@ignored_class_patterns)
         end
 
-        sig { params(definition: Model::Class).returns(T::Boolean) }
+        #: (Model::Class definition) -> bool
         def ignored_subclass?(definition)
           superclass_name = definition.superclass_name
           return true if superclass_name && ignored_name?(
@@ -316,39 +313,39 @@ module Spoom
           names(:@ignored_subclasses_of_names).any? { |superclass_name| subclass_of?(definition, superclass_name) }
         end
 
-        sig { params(name: String).returns(T::Boolean) }
+        #: (String name) -> bool
         def ignored_constant_name?(name)
           ignored_name?(name, :@ignored_constant_names, :@ignored_constant_patterns)
         end
 
-        sig { params(name: String).returns(T::Boolean) }
+        #: (String name) -> bool
         def ignored_method_name?(name)
           ignored_name?(name, :@ignored_method_names, :@ignored_method_patterns)
         end
 
-        sig { params(name: String).returns(T::Boolean) }
+        #: (String name) -> bool
         def ignored_module_name?(name)
           ignored_name?(name, :@ignored_module_names, :@ignored_module_patterns)
         end
 
-        sig { params(name: String, names_variable: Symbol, patterns_variable: Symbol).returns(T::Boolean) }
+        #: (String name, Symbol names_variable, Symbol patterns_variable) -> bool
         def ignored_name?(name, names_variable, patterns_variable)
           names(names_variable).include?(name) || patterns(patterns_variable).any? { |pattern| pattern.match?(name) }
         end
 
-        sig { params(const: Symbol).returns(T::Set[String]) }
+        #: (Symbol const) -> Set[String]
         def names(const)
           self.class.instance_variable_get(const) || Set.new
         end
 
-        sig { params(const: Symbol).returns(T::Array[Regexp]) }
+        #: (Symbol const) -> Array[Regexp]
         def patterns(const)
           self.class.instance_variable_get(const) || []
         end
 
         # Plugin utils
 
-        sig { params(name: String).returns(String) }
+        #: (String name) -> String
         def camelize(name)
           name = T.must(name.split("::").last)
           name = T.must(name.split("/").last)

data/lib/spoom/deadcode/plugins/graphql.rb

@@ -5,8 +5,6 @@ module Spoom
   module Deadcode
     module Plugins
       class GraphQL < Base
-        extend T::Sig
-
         ignore_classes_inheriting_from(
           "GraphQL::Schema::Enum",
           "GraphQL::Schema::Object",
@@ -24,7 +22,8 @@ module Spoom
           "unsubscribed",
         )
 
-        sig { override.params(send: Send).void }
+        # @override
+        #: (Send send) -> void
         def on_send(send)
           return unless send.recv.nil? && send.name == "field"
 

data/lib/spoom/deadcode/plugins/minitest.rb

@@ -5,8 +5,6 @@ module Spoom
   module Deadcode
     module Plugins
       class Minitest < Base
-        extend T::Sig
-
         ignore_classes_named(/Test$/)
 
         ignore_methods_named(
@@ -18,13 +16,15 @@ module Spoom
           "teardown",
         )
 
-        sig { override.params(definition: Model::Method).void }
+        # @override
+        #: (Model::Method definition) -> void
         def on_define_method(definition)
           file = definition.location.file
           @index.ignore(definition) if file.match?(%r{test/.*test\.rb$}) && definition.name.match?(/^test_/)
         end
 
-        sig { override.params(send: Send).void }
+        # @override
+        #: (Send send) -> void
         def on_send(send)
           case send.name
           when "assert_predicate", "refute_predicate"

data/lib/spoom/deadcode/plugins/namespaces.rb

@@ -5,21 +5,21 @@ module Spoom
   module Deadcode
     module Plugins
       class Namespaces < Base
-        extend T::Sig
-
-        sig { override.params(definition: Model::Class).void }
+        # @override
+        #: (Model::Class definition) -> void
         def on_define_class(definition)
           @index.ignore(definition) if used_as_namespace?(definition)
         end
 
-        sig { override.params(definition: Model::Module).void }
+        # @override
+        #: (Model::Module definition) -> void
         def on_define_module(definition)
           @index.ignore(definition) if used_as_namespace?(definition)
         end
 
         private
 
-        sig { params(symbol_def: Model::Namespace).returns(T::Boolean) }
+        #: (Model::Namespace symbol_def) -> bool
         def used_as_namespace?(symbol_def)
           symbol_def.children.any?
         end

data/lib/spoom/deadcode/plugins/rails.rb

@@ -5,23 +5,23 @@ module Spoom
   module Deadcode
     module Plugins
       class Rails < Base
-        extend T::Sig
-
         ignore_constants_named("APP_PATH", "ENGINE_PATH", "ENGINE_ROOT")
 
-        sig { override.params(definition: Model::Class).void }
+        # @override
+        #: (Model::Class definition) -> void
         def on_define_class(definition)
           @index.ignore(definition) if file_is_helper?(definition)
         end
 
-        sig { override.params(definition: Model::Module).void }
+        # @override
+        #: (Model::Module definition) -> void
         def on_define_module(definition)
           @index.ignore(definition) if file_is_helper?(definition)
         end
 
         private
 
-        sig { params(symbol_def: Model::Namespace).returns(T::Boolean) }
+        #: (Model::Namespace symbol_def) -> bool
         def file_is_helper?(symbol_def)
           symbol_def.location.file.match?(%r{app/helpers/.*\.rb$})
         end

data/lib/spoom/deadcode/plugins/rubocop.rb

@@ -5,16 +5,15 @@ module Spoom
   module Deadcode
     module Plugins
       class Rubocop < Base
-        extend T::Sig
-
-        RUBOCOP_CONSTANTS = T.let(["MSG", "RESTRICT_ON_SEND"].to_set.freeze, T::Set[String])
+        RUBOCOP_CONSTANTS = ["MSG", "RESTRICT_ON_SEND"].to_set.freeze #: Set[String]
 
         ignore_classes_inheriting_from(
           "RuboCop::Cop::Cop",
           "RuboCop::Cop::Base",
         )
 
-        sig { override.params(definition: Model::Constant).void }
+        # @override
+        #: (Model::Constant definition) -> void
         def on_define_constant(definition)
           owner = definition.owner
           return false unless owner.is_a?(Model::Class)
@@ -22,7 +21,8 @@ module Spoom
           @index.ignore(definition) if ignored_subclass?(owner) && RUBOCOP_CONSTANTS.include?(definition.name)
         end
 
-        sig { override.params(definition: Model::Method).void }
+        # @override
+        #: (Model::Method definition) -> void
         def on_define_method(definition)
           return unless definition.name == "on_send"