spoom 1.2.3 → 1.3.0

data/lib/spoom/deadcode/location.rb

@@ -13,8 +13,25 @@ module Spoom
       class << self
         extend T::Sig
 
-        sig { params(file: String, location: SyntaxTree::Location).returns(Location) }
-        def from_syntax_tree(file, location)
+        sig { params(location_string: String).returns(Location) }
+        def from_string(location_string)
+          file, rest = location_string.split(":", 2)
+          raise LocationError, "Invalid location string: #{location_string}" unless file && rest
+
+          start_line, rest = rest.split(":", 2)
+          raise LocationError, "Invalid location string: #{location_string}" unless start_line && rest
+
+          start_column, rest = rest.split("-", 2)
+          raise LocationError, "Invalid location string: #{location_string}" unless start_column && rest
+
+          end_line, end_column = rest.split(":", 2)
+          raise LocationError, "Invalid location string: #{location_string}" unless end_line && end_column
+
+          new(file, start_line.to_i, start_column.to_i, end_line.to_i, end_column.to_i)
+        end
+
+        sig { params(file: String, location: Prism::Location).returns(Location) }
+        def from_prism(file, location)
           new(file, location.start_line, location.start_column, location.end_line, location.end_column)
         end
       end
@@ -42,6 +59,17 @@ module Spoom
         @end_column = end_column
       end
 
+      sig { params(other: Location).returns(T::Boolean) }
+      def include?(other)
+        return false unless @file == other.file
+        return false if @start_line > other.start_line
+        return false if @start_line == other.start_line && @start_column > other.start_column
+        return false if @end_line < other.end_line
+        return false if @end_line == other.end_line && @end_column < other.end_column
+
+        true
+      end
+
       sig { override.params(other: BasicObject).returns(T.nilable(Integer)) }
       def <=>(other)
         return unless Location === other

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

@@ -0,0 +1,21 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Deadcode
+    module Plugins
+      class ActionMailer < Base
+        extend T::Sig
+
+        sig { override.params(indexer: Indexer, send: Send).void }
+        def on_send(indexer, send)
+          return unless send.recv.nil? && ActionPack::CALLBACKS.include?(send.name)
+
+          send.each_arg(Prism::SymbolNode) do |arg|
+            indexer.reference_method(arg.unescaped, send.node)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Deadcode
+    module Plugins
+      class ActionMailerPreview < Base
+        extend T::Sig
+
+        ignore_classes_inheriting_from("ActionMailer::Preview")
+
+        sig { override.params(indexer: Indexer, definition: Definition).void }
+        def on_define_method(indexer, definition)
+          definition.ignored! if indexer.nesting_class_superclass_name == "ActionMailer::Preview"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Deadcode
+    module Plugins
+      class ActionPack < Base
+        extend T::Sig
+
+        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],
+        )
+
+        ignore_classes_named(/Controller$/)
+
+        sig { override.params(indexer: Indexer, definition: Definition).void }
+        def on_define_method(indexer, definition)
+          definition.ignored! if ignored_class_name?(indexer.nesting_class_name)
+        end
+
+        sig { override.params(indexer: Indexer, send: Send).void }
+        def on_send(indexer, send)
+          return unless send.recv.nil? && CALLBACKS.include?(send.name)
+
+          arg = send.args.first
+          case arg
+          when Prism::SymbolNode
+            indexer.reference_method(arg.unescaped, send.node)
+          end
+
+          send.each_arg_assoc do |key, value|
+            key = key.slice.delete_suffix(":")
+
+            case key
+            when "if", "unless"
+              indexer.reference_method(value.slice.delete_prefix(":"), send.node) if value
+            else
+              indexer.reference_constant(camelize(key), send.node)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Deadcode
+    module Plugins
+      class ActiveJob < Base
+        ignore_classes_named("ApplicationJob")
+        ignore_methods_named("perform", "build_enumerator", "each_iteration")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Deadcode
+    module Plugins
+      class ActiveModel < Base
+        extend T::Sig
+
+        ignore_classes_inheriting_from(/^(::)?ActiveModel::EachValidator$/)
+        ignore_methods_named("validate_each")
+
+        sig { override.params(indexer: Indexer, send: Send).void }
+        def on_send(indexer, send)
+          return if send.recv
+
+          case send.name
+          when "attribute", "attributes"
+            send.each_arg(Prism::SymbolNode) do |arg|
+              indexer.reference_method(arg.unescaped, send.node)
+            end
+          when "validate", "validates", "validates!", "validates_each"
+            send.each_arg(Prism::SymbolNode) do |arg|
+              indexer.reference_method(arg.unescaped, send.node)
+            end
+            send.each_arg_assoc do |key, value|
+              key = key.slice.delete_suffix(":")
+
+              case key
+              when "if", "unless"
+                indexer.reference_method(value.slice.delete_prefix(":"), send.node) if value
+              else
+                indexer.reference_constant(camelize(key), send.node)
+              end
+            end
+          when "validates_with"
+            arg = send.args.first
+            if arg.is_a?(Prism::SymbolNode)
+              indexer.reference_constant(arg.unescaped, send.node)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Deadcode
+    module Plugins
+      class ActiveRecord < Base
+        extend T::Sig
+
+        ignore_classes_inheriting_from(/^(::)?ActiveRecord::Migration/)
+
+        ignore_methods_named(
+          "change",
+          "down",
+          "up",
+          "table_name_prefix",
+          "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],
+        )
+
+        CRUD_METHODS = T.let(
+          [
+            "assign_attributes",
+            "create",
+            "create!",
+            "insert",
+            "insert!",
+            "new",
+            "update",
+            "update!",
+            "upsert",
+          ].freeze,
+          T::Array[String],
+        )
+
+        ARRAY_METHODS = T.let(
+          [
+            "insert_all",
+            "insert_all!",
+            "upsert_all",
+          ].freeze,
+          T::Array[String],
+        )
+
+        sig { override.params(indexer: Indexer, send: Send).void }
+        def on_send(indexer, send)
+          if send.recv.nil? && CALLBACKS.include?(send.name)
+            send.each_arg(Prism::SymbolNode) do |arg|
+              indexer.reference_method(arg.unescaped, send.node)
+            end
+            return
+          end
+
+          return unless send.recv
+
+          case send.name
+          when *CRUD_METHODS
+            send.each_arg_assoc do |key, _value|
+              key = key.slice.delete_suffix(":")
+              indexer.reference_method("#{key}=", send.node)
+            end
+          when *ARRAY_METHODS
+            send.each_arg(Prism::ArrayNode) do |arg|
+              arg.elements.each do |part|
+                next unless part.is_a?(Prism::HashNode)
+
+                part.elements.each do |assoc|
+                  next unless assoc.is_a?(Prism::AssocNode)
+
+                  key = assoc.key.slice.delete_suffix(":")
+                  indexer.reference_method("#{key}=", send.node)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Deadcode
+    module Plugins
+      class ActiveSupport < Base
+        ignore_classes_inheriting_from(/^(::)?ActiveSupport::TestCase$/)
+
+        ignore_methods_named(
+          "after_all",
+          "after_setup",
+          "after_teardown",
+          "before_all",
+          "before_setup",
+          "before_teardown",
+        )
+
+        SETUP_AND_TEARDOWN_METHODS = T.let(["setup", "teardown"], T::Array[String])
+
+        sig { override.params(indexer: Indexer, send: Send).void }
+        def on_send(indexer, send)
+          return unless send.recv.nil? && SETUP_AND_TEARDOWN_METHODS.include?(send.name)
+
+          send.each_arg(Prism::SymbolNode) do |arg|
+            indexer.reference_method(T.must(arg.value), send.node)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -17,6 +17,60 @@ module Spoom
 
           # Plugins DSL
 
+          # Mark classes matching `names` as ignored.
+          #
+          # Names can be either strings or regexps:
+          #
+          # ~~~rb
+          # class MyPlugin < Spoom::Deadcode::Plugins::Base
+          #   ignore_class_names(
+          #     "Foo",
+          #     "Bar",
+          #     /Baz.*/,
+          #   )
+          # end
+          # ~~~
+          sig { params(names: T.any(String, Regexp)).void }
+          def ignore_classes_named(*names)
+            save_names_and_patterns(names, :@ignored_class_names, :@ignored_class_patterns)
+          end
+
+          # Mark classes directly subclassing a class matching `names` as ignored.
+          #
+          # Names can be either strings or regexps:
+          #
+          # ~~~rb
+          # class MyPlugin < Spoom::Deadcode::Plugins::Base
+          #   ignore_classes_inheriting_from(
+          #     "Foo",
+          #     "Bar",
+          #     /Baz.*/,
+          #   )
+          # end
+          # ~~~
+          sig { params(names: T.any(String, Regexp)).void }
+          def ignore_classes_inheriting_from(*names)
+            save_names_and_patterns(names, :@ignored_subclasses_of_names, :@ignored_subclasses_of_patterns)
+          end
+
+          # Mark constants matching `names` as ignored.
+          #
+          # Names can be either strings or regexps:
+          #
+          # ~~~rb
+          # class MyPlugin < Spoom::Deadcode::Plugins::Base
+          #   ignore_class_names(
+          #     "FOO",
+          #     "BAR",
+          #     /BAZ.*/,
+          #   )
+          # end
+          # ~~~
+          sig { params(names: T.any(String, Regexp)).void }
+          def ignore_constants_named(*names)
+            save_names_and_patterns(names, :@ignored_constant_names, :@ignored_constant_patterns)
+          end
+
           # Mark methods matching `names` as ignored.
           #
           # Names can be either strings or regexps:
@@ -31,10 +85,28 @@ module Spoom
           # end
           # ~~~
           sig { params(names: T.any(String, Regexp)).void }
-          def ignore_method_names(*names)
+          def ignore_methods_named(*names)
             save_names_and_patterns(names, :@ignored_method_names, :@ignored_method_patterns)
           end
 
+          # Mark modules matching `names` as ignored.
+          #
+          # Names can be either strings or regexps:
+          #
+          # ~~~rb
+          # class MyPlugin < Spoom::Deadcode::Plugins::Base
+          #   ignore_class_names(
+          #     "Foo",
+          #     "Bar",
+          #     /Baz.*/,
+          #   )
+          # end
+          # ~~~
+          sig { params(names: T.any(String, Regexp)).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 }
@@ -45,7 +117,7 @@ module Spoom
             names.each do |name|
               case name
               when String
-                ignored_names << name
+                ignored_names << name.delete_prefix("::")
               when Regexp
                 ignored_patterns << name
               end
@@ -73,6 +145,12 @@ module Spoom
           # no-op
         end
 
+        # Do not override this method, use `on_define_accessor` instead.
+        sig { params(indexer: Indexer, definition: Definition).void }
+        def internal_on_define_accessor(indexer, definition)
+          on_define_accessor(indexer, definition)
+        end
+
         # Called when a class is defined.
         #
         # Will be called when the indexer processes a `class` node.
@@ -91,6 +169,18 @@ module Spoom
           # no-op
         end
 
+        # Do not override this method, use `on_define_class` instead.
+        sig { params(indexer: Indexer, definition: Definition).void }
+        def internal_on_define_class(indexer, definition)
+          if ignored_class_name?(definition.name)
+            definition.ignored!
+          elsif ignored_subclass?(indexer.nesting_class_superclass_name)
+            definition.ignored!
+          end
+
+          on_define_class(indexer, definition)
+        end
+
         # Called when a constant is defined.
         #
         # Will be called when the indexer processes a `CONST =` node.
@@ -109,6 +199,14 @@ module Spoom
           # no-op
         end
 
+        # Do not override this method, use `on_define_constant` instead.
+        sig { params(indexer: Indexer, definition: Definition).void }
+        def internal_on_define_constant(indexer, definition)
+          definition.ignored! if ignored_constant_name?(definition.name)
+
+          on_define_constant(indexer, definition)
+        end
+
         # Called when a method is defined.
         #
         # Will be called when the indexer processes a `def` or `defs` node.
@@ -126,7 +224,15 @@ module Spoom
         # ~~~
         sig { params(indexer: Indexer, definition: Definition).void }
         def on_define_method(indexer, definition)
+          # no-op
+        end
+
+        # Do not override this method, use `on_define_method` instead.
+        sig { params(indexer: Indexer, definition: Definition).void }
+        def internal_on_define_method(indexer, definition)
           definition.ignored! if ignored_method_name?(definition.name)
+
+          on_define_method(indexer, definition)
         end
 
         # Called when a module is defined.
@@ -147,6 +253,14 @@ module Spoom
           # no-op
         end
 
+        # Do not override this method, use `on_define_module` instead.
+        sig { params(indexer: Indexer, definition: Definition).void }
+        def internal_on_define_module(indexer, definition)
+          definition.ignored! if ignored_module_name?(definition.name)
+
+          on_define_module(indexer, definition)
+        end
+
         # Called when a send is being processed
         #
         # ~~~rb
@@ -155,7 +269,7 @@ module Spoom
         #     return unless send.name == "dsl_method"
         #     return if send.args.empty?
         #
-        #     method_name = indexer.node_string(send.args.first).delete_prefix(":")
+        #     method_name = send.args.first.slice.delete_prefix(":")
         #     indexer.reference_method(method_name, send.node)
         #   end
         # end
@@ -165,16 +279,43 @@ module Spoom
           # no-op
         end
 
+        # Do not override this method, use `on_send` instead.
+        sig { params(indexer: Indexer, send: Send).void }
+        def internal_on_send(indexer, send)
+          on_send(indexer, send)
+        end
+
         private
 
+        # DSL support
+
+        sig { params(name: T.nilable(String)).returns(T::Boolean) }
+        def ignored_class_name?(name)
+          return false unless name
+
+          ignored_name?(name, :@ignored_class_names, :@ignored_class_patterns)
+        end
+
+        sig { params(superclass_name: T.nilable(String)).returns(T::Boolean) }
+        def ignored_subclass?(superclass_name)
+          return false unless superclass_name
+
+          ignored_name?(superclass_name, :@ignored_subclasses_of_names, :@ignored_subclasses_of_patterns)
+        end
+
+        sig { params(name: String).returns(T::Boolean) }
+        def ignored_constant_name?(name)
+          ignored_name?(name, :@ignored_constant_names, :@ignored_constant_patterns)
+        end
+
         sig { params(name: String).returns(T::Boolean) }
         def ignored_method_name?(name)
           ignored_name?(name, :@ignored_method_names, :@ignored_method_patterns)
         end
 
-        sig { params(const: Symbol).returns(T::Set[String]) }
-        def names(const)
-          self.class.instance_variable_get(const) || Set.new
+        sig { params(name: String).returns(T::Boolean) }
+        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) }
@@ -182,18 +323,30 @@ module Spoom
           names(names_variable).include?(name) || patterns(patterns_variable).any? { |pattern| pattern.match?(name) }
         end
 
+        sig { params(const: Symbol).returns(T::Set[String]) }
+        def names(const)
+          self.class.instance_variable_get(const) || Set.new
+        end
+
         sig { params(const: Symbol).returns(T::Array[Regexp]) }
         def patterns(const)
           self.class.instance_variable_get(const) || []
         end
 
-        sig { params(indexer: Indexer, send: Send).void }
-        def reference_send_first_symbol_as_method(indexer, send)
-          first_arg = send.args.first
-          return unless first_arg.is_a?(SyntaxTree::SymbolLiteral)
+        # Plugin utils
 
-          name = indexer.node_string(first_arg.value)
-          indexer.reference_method(name, send.node)
+        sig { params(name: String).returns(String) }
+        def camelize(name)
+          name = T.must(name.split("::").last)
+          name = T.must(name.split("/").last)
+          name = name.gsub(/[^a-zA-Z0-9_]/, "")
+          name = name.sub(/^[a-z\d]*/, &:capitalize)
+          name = name.gsub(%r{(?:_|(/))([a-z\d]*)}) do
+            s1 = Regexp.last_match(1)
+            s2 = Regexp.last_match(2)
+            "#{s1}#{s2&.capitalize}"
+          end
+          name
         end
       end
     end

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

@@ -0,0 +1,47 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Deadcode
+    module Plugins
+      class GraphQL < Base
+        extend T::Sig
+
+        ignore_classes_inheriting_from(
+          /^(::)?GraphQL::Schema::Enum$/,
+          /^(::)?GraphQL::Schema::Object$/,
+          /^(::)?GraphQL::Schema::Scalar$/,
+          /^(::)?GraphQL::Schema::Union$/,
+        )
+
+        ignore_methods_named(
+          "coerce_input",
+          "coerce_result",
+          "graphql_name",
+          "resolve",
+          "resolve_type",
+          "subscribed",
+          "unsubscribed",
+        )
+
+        sig { override.params(indexer: Indexer, send: Send).void }
+        def on_send(indexer, send)
+          return unless send.recv.nil? && send.name == "field"
+
+          arg = send.args.first
+          return unless arg.is_a?(Prism::SymbolNode)
+
+          indexer.reference_method(arg.unescaped, send.node)
+
+          send.each_arg_assoc do |key, value|
+            key = key.slice.delete_suffix(":")
+            next unless key == "resolver_method"
+            next unless value
+
+            indexer.reference_method(value.slice.delete_prefix(":"), send.node)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Deadcode
+    module Plugins
+      class Minitest < Base
+        extend T::Sig
+
+        ignore_classes_named(/Test$/)
+
+        ignore_methods_named(
+          "after_all",
+          "around",
+          "around_all",
+          "before_all",
+          "setup",
+          "teardown",
+        )
+
+        sig { override.params(indexer: Indexer, definition: Definition).void }
+        def on_define_method(indexer, definition)
+          definition.ignored! if indexer.path.match?(%r{test/.*test\.rb$}) && definition.name.match?(/^test_/)
+        end
+      end
+    end
+  end
+end