Make dead code indexing use a Model to index classes

lib/spoom/cli/deadcode.rb

@@ -80,14 +80,16 @@ def deadcode(*paths)
           $stderr.puts
         end
 
-        index = Spoom::Deadcode::Index.new
+        model = Spoom::Model.new
+        index = Spoom::Deadcode::Index.new(model)
 
         $stderr.puts "Indexing #{blue(files.size.to_s)} files..."
         files.each do |file|
           content = File.read(file)
           content = Spoom::Deadcode::ERB.new(content).src if file.end_with?(".erb")
 
           tree = Spoom.parse_ruby(content, file: file)
+          Spoom::Model::Builder.new(model, file).visit(tree)
           Spoom::Deadcode.index_node(index, tree, content, file: file, plugins: plugins)
         rescue ParseError => e
           say_error("Error parsing #{file}: #{e.message}")
@@ -97,6 +99,8 @@ def deadcode(*paths)
           next
         end
 
+        index.finalize!(plugins: plugins)
+
         if options[:show_defs]
           $stderr.puts "\nDefinitions:"
           index.definitions.each do |name, definitions|
@@ -123,7 +127,6 @@ def deadcode(*paths)
         references_count = index.references.size.to_s
         $stderr.puts "Analyzing #{blue(definitions_count)} definitions against #{blue(references_count)} references..."
 
-        index.finalize!
         dead = index.definitions.values.flatten.select(&:dead?)
 
         if options[:sort] == "name"

lib/spoom/deadcode.rb

@@ -58,6 +58,7 @@ def index_node(index, node, ruby, file:, plugins: [])
       sig { params(index: Index, ruby: String, file: String, plugins: T::Array[Deadcode::Plugins::Base]).void }
       def index_ruby(index, ruby, file:, plugins: [])
         node = Spoom.parse_ruby(ruby, file: file)
+        Model::Builder.new(index.model, file).visit(node)
         index_node(index, node, ruby, file: file, plugins: plugins)
       end
 

lib/spoom/deadcode/index.rb

@@ -6,14 +6,18 @@ module Deadcode
     class Index
       extend T::Sig
 
+      sig { returns(Model) }
+      attr_reader :model
+
       sig { returns(T::Hash[String, T::Array[Definition]]) }
       attr_reader :definitions
 
       sig { returns(T::Hash[String, T::Array[Reference]]) }
       attr_reader :references
 
-      sig { void }
-      def initialize
+      sig { params(model: Model).void }
+      def initialize(model)
+        @model = model
         @definitions = T.let({}, T::Hash[String, T::Array[Definition]])
         @references = T.let({}, T::Hash[String, T::Array[Reference]])
       end
@@ -33,8 +37,23 @@ def reference(reference)
       # Mark all definitions having a reference of the same name as `alive`
       #
       # To be called once all the files have been indexed and all the definitions and references discovered.
-      sig { void }
-      def finalize!
+      sig { params(plugins: T::Array[Plugins::Base]).void }
+      def finalize!(plugins: [])
+        @model.symbols.each do |_full_name, symbol|
+          symbol.definitions.each do |symbol_def|
+            case symbol_def
+            when Model::Class
+              definition = Definition.new(
+                kind: Definition::Kind::Class,
+                name: symbol.name,
+                full_name: symbol.full_name,
+                location: symbol_def.location,
+              )
+              define(definition)
+              plugins.each { |plugin| plugin.internal_on_define_class(symbol_def, definition) }
+            end
+          end
+        end
         @references.keys.each do |name|
           definitions_for_name(name).each(&:alive!)
         end

lib/spoom/deadcode/indexer.rb

@@ -112,8 +112,6 @@ def visit_class_node(node)
           @names_nesting.clear
           @names_nesting << full_name
 
-          define_class(T.must(constant_path.split("::").last), full_name, node)
-
           # We do not call `super` here because we don't want to visit the `constant` again
           visit(node.superclass) if node.superclass
           visit(node.body)
@@ -123,7 +121,6 @@ def visit_class_node(node)
           @names_nesting = old_nesting
         else
           @names_nesting << constant_path
-          define_class(T.must(constant_path.split("::").last), @names_nesting.join("::"), node)
 
           # We do not call `super` here because we don't want to visit the `constant` again
           visit(node.superclass) if node.superclass
@@ -351,18 +348,6 @@ def define_attr_writer(name, full_name, node)
         @plugins.each { |plugin| plugin.internal_on_define_accessor(self, definition) }
       end
 
-      sig { params(name: String, full_name: String, node: Prism::Node).void }
-      def define_class(name, full_name, node)
-        definition = Definition.new(
-          kind: Definition::Kind::Class,
-          name: name,
-          full_name: full_name,
-          location: node_location(node),
-        )
-        @index.define(definition)
-        @plugins.each { |plugin| plugin.internal_on_define_class(self, definition) }
-      end
-
       sig { params(name: String, full_name: String, node: Prism::Node).void }
       def define_constant(name, full_name, node)
         definition = Definition.new(

lib/spoom/deadcode/plugins/base.rb

@@ -159,26 +159,26 @@ def internal_on_define_accessor(indexer, definition)
         #
         # ~~~rb
         # class MyPlugin < Spoom::Deadcode::Plugins::Base
-        #   def on_define_class(indexer, definition)
-        #     definition.ignored! if definition.name == "Foo"
+        #   def on_define_class(symbol_def, definition)
+        #     definition.ignored! if symbol_def.name == "Foo"
         #   end
         # end
         # ~~~
-        sig { params(indexer: Indexer, definition: Definition).void }
-        def on_define_class(indexer, definition)
+        sig { params(symbol_def: Model::Class, definition: Definition).void }
+        def on_define_class(symbol_def, 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)
-          if ignored_class_name?(definition.name)
+        sig { params(symbol_def: Model::Class, definition: Definition).void }
+        def internal_on_define_class(symbol_def, definition)
+          if ignored_class_name?(symbol_def.name)
             definition.ignored!
-          elsif ignored_subclass?(indexer.nesting_class_superclass_name)
+          elsif ignored_subclass?(symbol_def.superclass_name&.delete_prefix("::"))
             definition.ignored!
           end
 
-          on_define_class(indexer, definition)
+          on_define_class(symbol_def, definition)
         end
 
         # Called when a constant is defined.

lib/spoom/deadcode/plugins/namespaces.rb

@@ -7,9 +7,9 @@ module Plugins
       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(symbol_def: Model::Class, definition: Definition).void }
+        def on_define_class(symbol_def, definition)
+          definition.ignored! unless symbol_def.children.empty?
         end
 
         sig { override.params(indexer: Indexer, definition: Definition).void }

lib/spoom/deadcode/plugins/rails.rb

@@ -9,9 +9,9 @@ class Rails < Base
 
         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(symbol_def: Model::Class, definition: Definition).void }
+        def on_define_class(symbol_def, definition)
+          definition.ignored! if symbol_def.location.file.match?(%r{app/helpers/.*\.rb$})
         end
 
         sig { override.params(indexer: Indexer, definition: Definition).void }

test/helpers/deadcode_helper.rb

@@ -21,7 +21,8 @@ def deadcode_index(plugins: [])
             allow_mime_types: ["text/x-ruby", "text/x-ruby-script"],
           )
 
-          index = Deadcode::Index.new
+          model = Model.new
+          index = Deadcode::Index.new(model)
 
           files.each do |file|
             content = project.read(file)
@@ -32,7 +33,7 @@ def deadcode_index(plugins: [])
             end
           end
 
-          index.finalize!
+          index.finalize!(plugins: plugins)
           index
         end
 

test/spoom/deadcode/plugins/base_test.rb

@@ -31,8 +31,8 @@ def on_define_accessor(indexer, definition)
 
         def test_on_define_class
           plugin = Class.new(Base) do
-            def on_define_class(indexer, definition)
-              definition.ignored! if definition.name == "Class1"
+            def on_define_class(symbol_def, definition)
+              definition.ignored! if symbol_def.name == "Class1"
             end
           end
 

test/spoom/deadcode/remover_test.rb

@@ -1611,11 +1611,13 @@ def foo
 
       sig { params(ruby_string: String, def_name: String).returns(String) }
       def remove(ruby_string, def_name)
+        file = "file.rb"
         context = Context.mktmp!
-        context.write!("file.rb", ruby_string)
+        context.write!(file, ruby_string)
 
-        index = Index.new
-        Deadcode.index_ruby(index, ruby_string, file: "file.rb")
+        model = Model.new
+        index = Index.new(model)
+        Deadcode.index_ruby(index, ruby_string, file: file)
         index.finalize!
 
         definitions = definitions_for_name(index, def_name)