spoom 1.3.0 → 1.4.2

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

@@ -125,6 +125,14 @@ module Spoom
           end
         end
 
+        sig { returns(Index) }
+        attr_reader :index
+
+        sig { params(index: Index).void }
+        def initialize(index)
+          @index = index
+        end
+
         # Indexing event methods
 
         # Called when an accessor is defined.
@@ -135,20 +143,20 @@ module Spoom
         #
         # ~~~rb
         # class MyPlugin < Spoom::Deadcode::Plugins::Base
-        #   def on_define_accessor(indexer, definition)
-        #     definition.ignored! if definition.name == "foo"
+        #   def on_define_accessor(definition)
+        #     @index.ignore(definition) if symbol_def.name == "foo"
         #   end
         # end
         # ~~~
-        sig { params(indexer: Indexer, definition: Definition).void }
-        def on_define_accessor(indexer, definition)
+        sig { params(definition: Model::Attr).void }
+        def on_define_accessor(definition)
           # 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)
+        sig { params(definition: Model::Attr).void }
+        def internal_on_define_accessor(definition)
+          on_define_accessor(definition)
         end
 
         # Called when a class is defined.
@@ -159,26 +167,26 @@ module Spoom
         #
         # ~~~rb
         # class MyPlugin < Spoom::Deadcode::Plugins::Base
-        #   def on_define_class(indexer, definition)
-        #     definition.ignored! if definition.name == "Foo"
+        #   def on_define_class(definition)
+        #     @index.ignore(definition) if definition.name == "Foo"
         #   end
         # end
         # ~~~
-        sig { params(indexer: Indexer, definition: Definition).void }
-        def on_define_class(indexer, definition)
+        sig { params(definition: Model::Class).void }
+        def on_define_class(definition)
           # 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)
+        sig { params(definition: Model::Class).void }
+        def internal_on_define_class(definition)
           if ignored_class_name?(definition.name)
-            definition.ignored!
-          elsif ignored_subclass?(indexer.nesting_class_superclass_name)
-            definition.ignored!
+            @index.ignore(definition)
+          elsif ignored_subclass?(definition)
+            @index.ignore(definition)
           end
 
-          on_define_class(indexer, definition)
+          on_define_class(definition)
         end
 
         # Called when a constant is defined.
@@ -189,22 +197,22 @@ module Spoom
         #
         # ~~~rb
         # class MyPlugin < Spoom::Deadcode::Plugins::Base
-        #   def on_define_constant(indexer, definition)
-        #     definition.ignored! if definition.name == "FOO"
+        #   def on_define_constant(definition)
+        #     @index.ignore(definition) if definition.name == "FOO"
         #   end
         # end
         # ~~~
-        sig { params(indexer: Indexer, definition: Definition).void }
-        def on_define_constant(indexer, definition)
+        sig { params(definition: Model::Constant).void }
+        def on_define_constant(definition)
           # 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)
+        sig { params(definition: Model::Constant).void }
+        def internal_on_define_constant(definition)
+          @index.ignore(definition) if ignored_constant_name?(definition.name)
 
-          on_define_constant(indexer, definition)
+          on_define_constant(definition)
         end
 
         # Called when a method is defined.
@@ -215,24 +223,22 @@ module Spoom
         #
         # ~~~rb
         # class MyPlugin < Spoom::Deadcode::Plugins::Base
-        #   def on_define_method(indexer, definition)
-        #     super # So the `ignore_method_names` DSL is still applied
-        #
-        #     definition.ignored! if definition.name == "foo"
+        #   def on_define_method(definition)
+        #     @index.ignore(definition) if definition.name == "foo"
         #   end
         # end
         # ~~~
-        sig { params(indexer: Indexer, definition: Definition).void }
-        def on_define_method(indexer, definition)
+        sig { params(definition: Model::Method).void }
+        def on_define_method(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)
+        sig { params(definition: Model::Method).void }
+        def internal_on_define_method(definition)
+          @index.ignore(definition) if ignored_method_name?(definition.name)
 
-          on_define_method(indexer, definition)
+          on_define_method(definition)
         end
 
         # Called when a module is defined.
@@ -243,52 +249,54 @@ module Spoom
         #
         # ~~~rb
         # class MyPlugin < Spoom::Deadcode::Plugins::Base
-        #   def on_define_module(indexer, definition)
-        #     definition.ignored! if definition.name == "Foo"
+        #   def on_define_module(definition)
+        #     @index.ignore(definition) if definition.name == "Foo"
         #   end
         # end
         # ~~~
-        sig { params(indexer: Indexer, definition: Definition).void }
-        def on_define_module(indexer, definition)
+        sig { params(definition: Model::Module).void }
+        def on_define_module(definition)
           # 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)
+        sig { params(definition: Model::Module).void }
+        def internal_on_define_module(definition)
+          @index.ignore(definition) if ignored_module_name?(definition.name)
 
-          on_define_module(indexer, definition)
+          on_define_module(definition)
         end
 
         # Called when a send is being processed
         #
         # ~~~rb
         # class MyPlugin < Spoom::Deadcode::Plugins::Base
-        #   def on_send(indexer, send)
+        #   def on_send(send)
         #     return unless send.name == "dsl_method"
         #     return if send.args.empty?
         #
         #     method_name = send.args.first.slice.delete_prefix(":")
-        #     indexer.reference_method(method_name, send.node)
+        #     @index.reference_method(method_name, send.node, send.loc)
         #   end
         # end
         # ~~~
-        sig { params(indexer: Indexer, send: Send).void }
-        def on_send(indexer, send)
+        sig { params(send: Send).void }
+        def on_send(send)
           # 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(definition: Model::Namespace, superclass_name: String).returns(T::Boolean) }
+        def subclass_of?(definition, superclass_name)
+          superclass_symbol = @index.model.symbols[superclass_name]
+          return false unless superclass_symbol
+
+          @index.model.symbols_hierarchy.edge?(definition.symbol, superclass_symbol)
+        end
+
         sig { params(name: T.nilable(String)).returns(T::Boolean) }
         def ignored_class_name?(name)
           return false unless name
@@ -296,11 +304,16 @@ module Spoom
           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
+        sig { params(definition: Model::Class).returns(T::Boolean) }
+        def ignored_subclass?(definition)
+          superclass_name = definition.superclass_name
+          return true if superclass_name && ignored_name?(
+            superclass_name,
+            :@ignored_subclasses_of_names,
+            :@ignored_subclasses_of_patterns,
+          )
 
-          ignored_name?(superclass_name, :@ignored_subclasses_of_names, :@ignored_subclasses_of_patterns)
+          names(:@ignored_subclasses_of_names).any? { |superclass_name| subclass_of?(definition, superclass_name) }
         end
 
         sig { params(name: String).returns(T::Boolean) }

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

@@ -8,10 +8,10 @@ module Spoom
         extend T::Sig
 
         ignore_classes_inheriting_from(
-          /^(::)?GraphQL::Schema::Enum$/,
-          /^(::)?GraphQL::Schema::Object$/,
-          /^(::)?GraphQL::Schema::Scalar$/,
-          /^(::)?GraphQL::Schema::Union$/,
+          "GraphQL::Schema::Enum",
+          "GraphQL::Schema::Object",
+          "GraphQL::Schema::Scalar",
+          "GraphQL::Schema::Union",
         )
 
         ignore_methods_named(
@@ -24,21 +24,21 @@ module Spoom
           "unsubscribed",
         )
 
-        sig { override.params(indexer: Indexer, send: Send).void }
-        def on_send(indexer, send)
+        sig { override.params(send: Send).void }
+        def on_send(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)
+          @index.reference_method(arg.unescaped, send.location)
 
           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)
+            @index.reference_method(value.slice.delete_prefix(":"), send.location)
           end
         end
       end

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

@@ -18,9 +18,21 @@ module Spoom
           "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_/)
+        sig { override.params(definition: Model::Method).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 }
+        def on_send(send)
+          case send.name
+          when "assert_predicate", "refute_predicate"
+            name = send.args[1]&.slice
+            return unless name
+
+            @index.reference_method(name.delete_prefix(":"), send.location)
+          end
         end
       end
     end

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

@@ -7,24 +7,21 @@ module Spoom
       class Namespaces < Base
         extend T::Sig
 
-        sig { override.params(indexer: Indexer, definition: Definition).void }
-        def on_define_class(indexer, definition)
-          definition.ignored! if used_as_namespace?(indexer)
+        sig { override.params(definition: Model::Class).void }
+        def on_define_class(definition)
+          @index.ignore(definition) if used_as_namespace?(definition)
         end
 
-        sig { override.params(indexer: Indexer, definition: Definition).void }
-        def on_define_module(indexer, definition)
-          definition.ignored! if used_as_namespace?(indexer)
+        sig { override.params(definition: Model::Module).void }
+        def on_define_module(definition)
+          @index.ignore(definition) if used_as_namespace?(definition)
         end
 
         private
 
-        sig { params(indexer: Indexer).returns(T::Boolean) }
-        def used_as_namespace?(indexer)
-          node = indexer.current_node
-          return false unless node.is_a?(Prism::ClassNode) || node.is_a?(Prism::ModuleNode)
-
-          !!node.body
+        sig { params(symbol_def: Model::Namespace).returns(T::Boolean) }
+        def used_as_namespace?(symbol_def)
+          symbol_def.children.any?
         end
       end
     end

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

@@ -9,21 +9,21 @@ module Spoom
 
         ignore_constants_named("APP_PATH", "ENGINE_PATH", "ENGINE_ROOT")
 
-        sig { override.params(indexer: Indexer, definition: Definition).void }
-        def on_define_class(indexer, definition)
-          definition.ignored! if file_is_helper?(indexer)
+        sig { override.params(definition: Model::Class).void }
+        def on_define_class(definition)
+          @index.ignore(definition) if file_is_helper?(definition)
         end
 
-        sig { override.params(indexer: Indexer, definition: Definition).void }
-        def on_define_module(indexer, definition)
-          definition.ignored! if file_is_helper?(indexer)
+        sig { override.params(definition: Model::Module).void }
+        def on_define_module(definition)
+          @index.ignore(definition) if file_is_helper?(definition)
         end
 
         private
 
-        sig { params(indexer: Indexer).returns(T::Boolean) }
-        def file_is_helper?(indexer)
-          indexer.path.match?(%r{app/helpers/.*\.rb$})
+        sig { params(symbol_def: Model::Namespace).returns(T::Boolean) }
+        def file_is_helper?(symbol_def)
+          symbol_def.location.file.match?(%r{app/helpers/.*\.rb$})
         end
       end
     end

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

@@ -10,30 +10,26 @@ module Spoom
         RUBOCOP_CONSTANTS = T.let(["MSG", "RESTRICT_ON_SEND"].to_set.freeze, T::Set[String])
 
         ignore_classes_inheriting_from(
-          /^(::)?RuboCop::Cop::Cop$/,
-          /^(::)?RuboCop::Cop::Base$/,
+          "RuboCop::Cop::Cop",
+          "RuboCop::Cop::Base",
         )
 
-        sig { override.params(indexer: Indexer, definition: Definition).void }
-        def on_define_constant(indexer, definition)
-          definition.ignored! if rubocop_constant?(indexer, definition)
-        end
+        sig { override.params(definition: Model::Constant).void }
+        def on_define_constant(definition)
+          owner = definition.owner
+          return false unless owner.is_a?(Model::Class)
 
-        sig { override.params(indexer: Indexer, definition: Definition).void }
-        def on_define_method(indexer, definition)
-          definition.ignored! if rubocop_method?(indexer, definition)
+          @index.ignore(definition) if ignored_subclass?(owner) && RUBOCOP_CONSTANTS.include?(definition.name)
         end
 
-        private
+        sig { override.params(definition: Model::Method).void }
+        def on_define_method(definition)
+          return unless definition.name == "on_send"
 
-        sig { params(indexer: Indexer, definition: Definition).returns(T::Boolean) }
-        def rubocop_constant?(indexer, definition)
-          ignored_subclass?(indexer.nesting_class_superclass_name) && RUBOCOP_CONSTANTS.include?(definition.name)
-        end
+          owner = definition.owner
+          return unless owner.is_a?(Model::Class)
 
-        sig { params(indexer: Indexer, definition: Definition).returns(T::Boolean) }
-        def rubocop_method?(indexer, definition)
-          ignored_subclass?(indexer.nesting_class_superclass_name) && definition.name == "on_send"
+          @index.ignore(definition) if ignored_subclass?(owner)
         end
       end
     end

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

@@ -20,33 +20,33 @@ module Spoom
           "to_s",
         )
 
-        sig { override.params(indexer: Indexer, send: Send).void }
-        def on_send(indexer, send)
+        sig { override.params(send: Send).void }
+        def on_send(send)
           case send.name
           when "const_defined?", "const_get", "const_source_location"
-            reference_symbol_as_constant(indexer, send, T.must(send.args.first))
+            reference_symbol_as_constant(send, T.must(send.args.first))
           when "send", "__send__", "try"
             arg = send.args.first
-            indexer.reference_method(arg.unescaped, send.node) if arg.is_a?(Prism::SymbolNode)
+            @index.reference_method(arg.unescaped, send.location) if arg.is_a?(Prism::SymbolNode)
           when "alias_method"
             last_arg = send.args.last
 
             if last_arg.is_a?(Prism::SymbolNode) || last_arg.is_a?(Prism::StringNode)
-              indexer.reference_method(last_arg.unescaped, send.node)
+              @index.reference_method(last_arg.unescaped, send.location)
             end
           end
         end
 
         private
 
-        sig { params(indexer: Indexer, send: Send, node: Prism::Node).void }
-        def reference_symbol_as_constant(indexer, send, node)
+        sig { params(send: Send, node: Prism::Node).void }
+        def reference_symbol_as_constant(send, node)
           case node
           when Prism::SymbolNode
-            indexer.reference_constant(node.unescaped, send.node)
+            @index.reference_constant(node.unescaped, send.location)
           when Prism::StringNode
             node.unescaped.split("::").each do |name|
-              indexer.reference_constant(name, send.node) unless name.empty?
+              @index.reference_constant(name, send.location) unless name.empty?
             end
           end
         end

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

@@ -7,32 +7,29 @@ module Spoom
       class Sorbet < Base
         extend T::Sig
 
-        sig { override.params(indexer: Indexer, definition: Definition).void }
-        def on_define_constant(indexer, definition)
-          definition.ignored! if sorbet_type_member?(indexer, definition) || sorbet_enum_constant?(indexer, definition)
+        sig { override.params(definition: Model::Constant).void }
+        def on_define_constant(definition)
+          @index.ignore(definition) if sorbet_type_member?(definition) || sorbet_enum_constant?(definition)
         end
 
-        sig { override.params(indexer: Indexer, definition: Definition).void }
-        def on_define_method(indexer, definition)
-          definition.ignored! if indexer.last_sig =~ /(override|overridable)/
+        sig { override.params(definition: Model::Method).void }
+        def on_define_method(definition)
+          @index.ignore(definition) if definition.sigs.any? { |sig| sig.string =~ /(override|overridable)/ }
         end
 
         private
 
-        sig { params(indexer: Indexer, definition: Definition).returns(T::Boolean) }
-        def sorbet_type_member?(indexer, definition)
-          assign = indexer.nesting_node(Prism::ConstantWriteNode)
-          return false unless assign
-
-          value = assign.value
-          return false unless value.is_a?(Prism::CallNode)
-
-          value.name == :type_member || value.name == :type_template
+        sig { params(definition: Model::Constant).returns(T::Boolean) }
+        def sorbet_type_member?(definition)
+          definition.value.match?(/^(type_member|type_template)/)
         end
 
-        sig { params(indexer: Indexer, definition: Definition).returns(T::Boolean) }
-        def sorbet_enum_constant?(indexer, definition)
-          /^(::)?T::Enum$/.match?(indexer.nesting_class_superclass_name) && indexer.nesting_call&.name == :enums
+        sig { params(definition: Model::Constant).returns(T::Boolean) }
+        def sorbet_enum_constant?(definition)
+          owner = definition.owner
+          return false unless owner.is_a?(Model::Class)
+
+          subclass_of?(owner, "T::Enum")
         end
       end
     end

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

@@ -9,11 +9,12 @@ module Spoom
 
         ignore_methods_named("exit_on_failure?")
 
-        sig { override.params(indexer: Indexer, definition: Definition).void }
-        def on_define_method(indexer, definition)
-          return if indexer.nesting_block # method defined in `no_commands do ... end`, we don't want to ignore it
+        sig { override.params(definition: Model::Method).void }
+        def on_define_method(definition)
+          owner = definition.owner
+          return unless owner.is_a?(Model::Class)
 
-          definition.ignored! if indexer.nesting_class_superclass_name =~ /^(::)?Thor$/
+          @index.ignore(definition) if subclass_of?(owner, "Thor")
         end
       end
     end

data/lib/spoom/deadcode/plugins.rb

@@ -57,7 +57,7 @@ module Spoom
     class << self
       extend T::Sig
 
-      sig { params(context: Context).returns(T::Array[Plugins::Base]) }
+      sig { params(context: Context).returns(T::Set[T.class_of(Plugins::Base)]) }
       def plugins_from_gemfile_lock(context)
         # These plugins are always loaded
         plugin_classes = DEFAULT_PLUGINS.dup
@@ -68,16 +68,16 @@ module Spoom
           plugin_classes << plugin_class if plugin_class
         end
 
-        plugin_classes.map(&:new)
+        plugin_classes
       end
 
-      sig { params(context: Context).returns(T::Array[Plugins::Base]) }
+      sig { params(context: Context).returns(T::Array[T.class_of(Plugins::Base)]) }
       def load_custom_plugins(context)
         context.glob("#{DEFAULT_CUSTOM_PLUGINS_PATH}/*.rb").each do |path|
           require("#{context.absolute_path}/#{path}")
         end
 
-        ObjectSpace
+        T.unsafe(ObjectSpace)
           .each_object(Class)
           .select do |klass|
             next unless T.unsafe(klass).name # skip anonymous classes, we only use them in tests
@@ -89,7 +89,6 @@ module Spoom
 
             true
           end
-          .map { |klass| T.unsafe(klass).new }
       end
     end
   end

data/lib/spoom/deadcode/remover.rb

@@ -145,7 +145,7 @@ module Spoom
             delete_chars(node.location.start_offset, next_node.location.start_offset)
           else
             # Should have been removed as a single MLHS node
-            raise "Unexpected case while removing constant assignment"
+            raise Error, "Unexpected case while removing constant assignment"
           end
         end
 
@@ -202,7 +202,7 @@ module Spoom
             # ~~~
             delete_chars(context.node.location.start_offset, next_node.location.start_offset)
           else
-            raise "Unexpected case while removing attr_accessor"
+            raise Error, "Unexpected case while removing attr_accessor"
           end
 
           insert_accessor(context.node, send_context, was_removed: false) if need_accessor
@@ -312,7 +312,7 @@ module Spoom
           # Adjust the lines to remove to include following blank lines
           after = context.next_node
           if before.nil? && after && after.location.start_line > end_line + 1
-            end_line = after.location.end_line - 1
+            end_line = after.location.start_line - 1
           elsif after.nil? && context.parent_node.location.end_line > end_line + 1
             end_line = context.parent_node.location.end_line - 1
           end
@@ -399,7 +399,7 @@ module Spoom
         sig { returns(Prism::Node) }
         def parent_node
           parent = @nesting.last
-          raise "No parent for node #{node}" unless parent
+          raise Error, "No parent for node #{node}" unless parent
 
           parent
         end
@@ -408,7 +408,7 @@ module Spoom
         def parent_context
           nesting = @nesting.dup
           parent = nesting.pop
-          raise "No parent context for node #{@node}" unless parent
+          raise Error, "No parent context for node #{@node}" unless parent
 
           NodeContext.new(@source, @comments, parent, nesting)
         end
@@ -419,7 +419,7 @@ module Spoom
           child_nodes = parent.child_nodes.compact
 
           index = child_nodes.index(@node)
-          raise "Node #{@node} not found in parent #{parent}" unless index
+          raise Error, "Node #{@node} not found in parent #{parent}" unless index
 
           T.must(child_nodes[0...index])
         end
@@ -435,7 +435,7 @@ module Spoom
           child_nodes = parent.child_nodes.compact
 
           index = child_nodes.index(node)
-          raise "Node #{@node} not found in nesting node #{parent}" unless index
+          raise Error, "Node #{@node} not found in nesting node #{parent}" unless index
 
           T.must(child_nodes.compact[(index + 1)..-1])
         end
@@ -561,10 +561,10 @@ module Spoom
                 "#{e.message} (at #{e.location.start_line}:#{e.location.start_column})."
               end.join(" ")
 
-              raise ParserError, "Error while parsing #{location.file}: #{message}"
+              raise ParseError, "Error while parsing #{location.file}: #{message}"
             end
 
-            visitor = new(location)
+            visitor = new(location, kind)
             visitor.visit(result.value)
 
             node = visitor.node
@@ -617,10 +617,11 @@ module Spoom
         sig { returns(T::Array[Prism::Node]) }
         attr_reader :nodes_nesting
 
-        sig { params(location: Location).void }
-        def initialize(location)
+        sig { params(location: Location, kind: T.nilable(Definition::Kind)).void }
+        def initialize(location, kind)
           super()
           @location = location
+          @kind = kind
           @node = T.let(nil, T.nilable(Prism::Node))
           @nodes_nesting = T.let([], T::Array[Prism::Node])
         end
@@ -635,6 +636,9 @@ module Spoom
             # We found the node we're looking for at `@location`
             @node = node
 
+            # The node we found matches the kind we're looking for, we can stop here
+            return if @kind && self.class.node_match_kind?(node, @kind)
+
             # There may be a more precise child inside the node that also matches `@location`, let's visit them
             @nodes_nesting << node
             super(node)