spoom 1.3.2 → 1.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf02e50bf4a9482c7895022115de973e0be60b79cf781760cb8e6ecb48013eaf
-  data.tar.gz: 73ba081a87afdde5b57672b5a67ca860089506254a1b65fa5309ba28a7014bf3
+  metadata.gz: e839292b23e8582e1e7b4317c6431de9b7d59e68b2c4dbb4015f75619a995601
+  data.tar.gz: 4853e7e2df4398e635e616df0f7354b8d37c67bef76ed12a0ec6efc16de1edc0
 SHA512:
-  metadata.gz: 19c39e380ddc81c38aaaf1b954232a4e068e88b14ad8a4690bb2810b62467578a3e836477c6d0c6db398eeec81a7d212e6b630b070f3b23c9990139a17ca0a60
-  data.tar.gz: ab920946c6ed779638788550f27b5c66ad1c1c21951d6cedc57b0a80fb58d7be094625d55b177e7c5479bfab9e24b733e10ec6f39de0039d3c80c98f45026514
+  metadata.gz: 940d6b9ec69c6eb767a1ccf2fc33767e552080010f94b14a77301f66b57a113f0619efb1e3ca357b04af782b3d9cbe07ff81f349adb814aef8c4d3fc8ea65de1
+  data.tar.gz: 7de4600f896698ea578887b0f417fd9a7f31d3689e6b69e514905b671197c62abf5f232c9471b364f0e4c3509c81848a7ca08d09c73c4cba4cba036963e34192

data/lib/spoom/cli/deadcode.rb

@@ -24,7 +24,7 @@ module Spoom
         desc: "Allowed mime types"
       option :exclude,
         type: :array,
-        default: ["vendor/", "sorbet/"],
+        default: ["vendor/", "sorbet/", "tmp/", "log/", "node_modules/"],
         aliases: :x,
         desc: "Exclude paths"
       option :show_files,
@@ -58,7 +58,9 @@ module Spoom
         collector = FileCollector.new(
           allow_extensions: options[:allowed_extensions],
           allow_mime_types: options[:allowed_mime_types],
-          exclude_patterns: options[:exclude].map { |p| Pathname.new(File.join(exec_path, p, "**")).cleanpath.to_s },
+          exclude_patterns: paths.flat_map do |path|
+            options[:exclude].map { |excluded| Pathname.new(File.join(path, excluded, "**")).cleanpath.to_s }
+          end,
         )
         collector.visit_paths(paths)
         files = collector.files.sort
@@ -71,32 +73,35 @@ module Spoom
           $stderr.puts
         end
 
-        plugins = Spoom::Deadcode.plugins_from_gemfile_lock(context)
+        plugin_classes = Spoom::Deadcode.plugins_from_gemfile_lock(context)
+        plugin_classes.merge(Spoom::Deadcode.load_custom_plugins(context))
         if options[:show_plugins]
-          $stderr.puts "\nLoaded #{blue(plugins.size.to_s)} plugins\n"
-          plugins.each do |plugin|
-            $stderr.puts "  #{gray(plugin.class.to_s)}"
+          $stderr.puts "\nLoaded #{blue(plugin_classes.size.to_s)} plugins\n"
+          plugin_classes.each do |plugin|
+            $stderr.puts "  #{gray(plugin.to_s)}"
           end
           $stderr.puts
         end
 
-        index = Spoom::Deadcode::Index.new
+        model = Spoom::Model.new
+        index = Spoom::Deadcode::Index.new(model)
+        plugins = plugin_classes.map { |plugin| plugin.new(index) }
 
         $stderr.puts "Indexing #{blue(files.size.to_s)} files..."
         files.each do |file|
-          content = File.read(file)
-          content = ERB.new(content).src if file.end_with?(".erb")
-
-          tree = Spoom::Deadcode.parse_ruby(content, file: file)
-          Spoom::Deadcode.index_node(index, tree, content, file: file, plugins: plugins)
-        rescue Spoom::Deadcode::ParserError => e
+          index.index_file(file, plugins: plugins)
+        rescue ParseError => e
           say_error("Error parsing #{file}: #{e.message}")
           next
-        rescue Spoom::Deadcode::IndexerError => e
+        rescue Spoom::Deadcode::Index::Error => e
           say_error("Error indexing #{file}: #{e.message}")
           next
         end
 
+        model.finalize!
+        index.apply_plugins!(plugins)
+        index.finalize!
+
         if options[:show_defs]
           $stderr.puts "\nDefinitions:"
           index.definitions.each do |name, definitions|
@@ -123,7 +128,6 @@ module Spoom
         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"
@@ -148,7 +152,7 @@ module Spoom
 
       desc "remove LOCATION", "Remove dead code at LOCATION"
       def remove(location_string)
-        location = Spoom::Deadcode::Location.from_string(location_string)
+        location = Location.from_string(location_string)
         context = self.context
         remover = Spoom::Deadcode::Remover.new(context)
 
@@ -163,7 +167,7 @@ module Spoom
       rescue Spoom::Deadcode::Remover::Error => e
         say_error("Can't remove code at #{location_string}: #{e.message}")
         exit(1)
-      rescue Spoom::Deadcode::Location::LocationError => e
+      rescue Location::LocationError => e
         say_error(e.message)
         exit(1)
       end

data/lib/spoom/deadcode/index.rb

@@ -6,28 +6,113 @@ module Spoom
     class Index
       extend T::Sig
 
+      class Error < Spoom::Error
+        extend T::Sig
+
+        sig { params(message: String, parent: Exception).void }
+        def initialize(message, parent:)
+          super(message)
+          set_backtrace(parent.backtrace)
+        end
+      end
+
+      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]]) }
+      sig { returns(T::Hash[String, T::Array[Model::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]])
+        @references = T.let({}, T::Hash[String, T::Array[Model::Reference]])
+        @ignored = T.let(Set.new, T::Set[Model::SymbolDef])
       end
 
       # Indexing
 
+      sig { params(file: String, plugins: T::Array[Plugins::Base]).void }
+      def index_file(file, plugins: [])
+        if file.end_with?(".erb")
+          erb = File.read(file)
+          index_erb(erb, file: file, plugins: plugins)
+        else
+          rb = File.read(file)
+          index_ruby(rb, file: file, plugins: plugins)
+        end
+      end
+
+      sig { params(erb: String, file: String, plugins: T::Array[Plugins::Base]).void }
+      def index_erb(erb, file:, plugins: [])
+        index_ruby(Deadcode::ERB.new(erb).src, file: file, plugins: plugins)
+      end
+
+      sig { params(rb: String, file: String, plugins: T::Array[Plugins::Base]).void }
+      def index_ruby(rb, file:, plugins: [])
+        node = Spoom.parse_ruby(rb, file: file)
+
+        # Index definitions
+        model_builder = Model::Builder.new(@model, file)
+        model_builder.visit(node)
+
+        # Index references
+        refs_visitor = Model::ReferencesVisitor.new(file)
+        refs_visitor.visit(node)
+        refs_visitor.references.each do |ref|
+          (@references[ref.name] ||= []) << ref
+        end
+
+        # Index references and sends
+        indexer = Indexer.new(file, self, plugins: plugins)
+        indexer.visit(node)
+      rescue ParseError => e
+        raise e
+      rescue => e
+        raise Error.new("Error while indexing #{file} (#{e.message})", parent: e)
+      end
+
       sig { params(definition: Definition).void }
       def define(definition)
         (@definitions[definition.name] ||= []) << definition
       end
 
-      sig { params(reference: Reference).void }
-      def reference(reference)
-        (@references[reference.name] ||= []) << reference
+      sig { params(name: String, location: Location).void }
+      def reference_constant(name, location)
+        (@references[name] ||= []) << Model::Reference.constant(name, location)
+      end
+
+      sig { params(name: String, location: Location).void }
+      def reference_method(name, location)
+        (@references[name] ||= []) << Model::Reference.method(name, location)
+      end
+
+      sig { params(symbol_def: Model::SymbolDef).void }
+      def ignore(symbol_def)
+        @ignored << symbol_def
+      end
+
+      sig { params(plugins: T::Array[Plugins::Base]).void }
+      def apply_plugins!(plugins)
+        @model.symbols.each do |_full_name, symbol|
+          symbol.definitions.each do |symbol_def|
+            case symbol_def
+            when Model::Class
+              plugins.each { |plugin| plugin.internal_on_define_class(symbol_def) }
+            when Model::Module
+              plugins.each { |plugin| plugin.internal_on_define_module(symbol_def) }
+            when Model::Constant
+              plugins.each { |plugin| plugin.internal_on_define_constant(symbol_def) }
+            when Model::Method
+              plugins.each { |plugin| plugin.internal_on_define_method(symbol_def) }
+            when Model::Attr
+              plugins.each { |plugin| plugin.internal_on_define_accessor(symbol_def) }
+            end
+          end
+        end
       end
 
       # Mark all definitions having a reference of the same name as `alive`
@@ -35,8 +120,91 @@ module Spoom
       # To be called once all the files have been indexed and all the definitions and references discovered.
       sig { void }
       def finalize!
-        @references.keys.each do |name|
-          definitions_for_name(name).each(&:alive!)
+        @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,
+              )
+              definition.ignored! if @ignored.include?(symbol_def)
+              definition.alive! if @references.key?(symbol.name)
+              define(definition)
+            when Model::Module
+              definition = Definition.new(
+                kind: Definition::Kind::Module,
+                name: symbol.name,
+                full_name: symbol.full_name,
+                location: symbol_def.location,
+              )
+              definition.ignored! if @ignored.include?(symbol_def)
+              definition.alive! if @references.key?(symbol.name)
+              define(definition)
+            when Model::Constant
+              definition = Definition.new(
+                kind: Definition::Kind::Constant,
+                name: symbol.name,
+                full_name: symbol.full_name,
+                location: symbol_def.location,
+              )
+              definition.ignored! if @ignored.include?(symbol_def)
+              definition.alive! if @references.key?(symbol.name)
+              define(definition)
+            when Model::Method
+              definition = Definition.new(
+                kind: Definition::Kind::Method,
+                name: symbol.name,
+                full_name: symbol.full_name,
+                location: symbol_def.location,
+              )
+              definition.ignored! if @ignored.include?(symbol_def)
+              definition.alive! if @references.key?(symbol.name)
+              define(definition)
+            when Model::AttrAccessor
+              definition = Definition.new(
+                kind: Definition::Kind::AttrReader,
+                name: symbol.name,
+                full_name: symbol.full_name,
+                location: symbol_def.location,
+              )
+              definition.ignored! if @ignored.include?(symbol_def)
+              definition.alive! if @references.key?(symbol.name)
+              define(definition)
+
+              definition = Definition.new(
+                kind: Definition::Kind::AttrWriter,
+                name: "#{symbol.name}=",
+                full_name: "#{symbol.full_name}=",
+                location: symbol_def.location,
+              )
+              definition.ignored! if @ignored.include?(symbol_def)
+              definition.alive! if @references.key?(symbol.name)
+              define(definition)
+            when Model::AttrReader
+              definition = Definition.new(
+                kind: Definition::Kind::AttrReader,
+                name: symbol.name,
+                full_name: symbol.full_name,
+                location: symbol_def.location,
+              )
+              definition.ignored! if @ignored.include?(symbol_def)
+              definition.alive! if @references.key?(symbol.name)
+              define(definition)
+            when Model::AttrWriter
+              definition = Definition.new(
+                kind: Definition::Kind::AttrWriter,
+                name: "#{symbol.name}=",
+                full_name: "#{symbol.full_name}=",
+                location: symbol_def.location,
+              )
+              definition.ignored! if @ignored.include?(symbol_def)
+              definition.alive! if @references.key?(symbol.name)
+              define(definition)
+            end
+          end
         end
       end
 
@@ -52,7 +220,7 @@ module Spoom
         @definitions.values.flatten
       end
 
-      sig { returns(T::Array[Reference]) }
+      sig { returns(T::Array[Model::Reference]) }
       def all_references
         @references.values.flatten
       end