spoom 1.2.3 → 1.3.0

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

@@ -0,0 +1,32 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Deadcode
+    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)
+        end
+
+        sig { override.params(indexer: Indexer, definition: Definition).void }
+        def on_define_module(indexer, definition)
+          definition.ignored! if used_as_namespace?(indexer)
+        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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Deadcode
+    module Plugins
+      class Rails < Base
+        extend T::Sig
+
+        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)
+        end
+
+        sig { override.params(indexer: Indexer, definition: Definition).void }
+        def on_define_module(indexer, definition)
+          definition.ignored! if file_is_helper?(indexer)
+        end
+
+        private
+
+        sig { params(indexer: Indexer).returns(T::Boolean) }
+        def file_is_helper?(indexer)
+          indexer.path.match?(%r{app/helpers/.*\.rb$})
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Deadcode
+    module Plugins
+      class Rake < Base
+        ignore_constants_named("APP_RAKEFILE")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Deadcode
+    module Plugins
+      class RSpec < Base
+        ignore_classes_named(/Spec$/)
+
+        ignore_methods_named(
+          "after_setup",
+          "after_teardown",
+          "before_setup",
+          "before_teardown",
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# typed: strict
+# frozen_string_literal: true
+
+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])
+
+        ignore_classes_inheriting_from(
+          /^(::)?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(indexer: Indexer, definition: Definition).void }
+        def on_define_method(indexer, definition)
+          definition.ignored! if rubocop_method?(indexer, definition)
+        end
+
+        private
+
+        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
+
+        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"
+        end
+      end
+    end
+  end
+end

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

@@ -7,7 +7,7 @@ module Spoom
       class Ruby < Base
         extend T::Sig
 
-        ignore_method_names(
+        ignore_methods_named(
           "==",
           "extended",
           "included",
@@ -26,34 +26,26 @@ module Spoom
           when "const_defined?", "const_get", "const_source_location"
             reference_symbol_as_constant(indexer, send, T.must(send.args.first))
           when "send", "__send__", "try"
-            reference_send_first_symbol_as_method(indexer, send)
+            arg = send.args.first
+            indexer.reference_method(arg.unescaped, send.node) if arg.is_a?(Prism::SymbolNode)
           when "alias_method"
             last_arg = send.args.last
 
-            name = case last_arg
-            when SyntaxTree::SymbolLiteral
-              indexer.node_string(last_arg.value)
-            when SyntaxTree::StringLiteral
-              last_arg.parts.map { |part| indexer.node_string(part) }.join
+            if last_arg.is_a?(Prism::SymbolNode) || last_arg.is_a?(Prism::StringNode)
+              indexer.reference_method(last_arg.unescaped, send.node)
             end
-
-            return unless name
-
-            indexer.reference_method(name, send.node)
           end
         end
 
         private
 
-        sig { params(indexer: Indexer, send: Send, node: SyntaxTree::Node).void }
+        sig { params(indexer: Indexer, send: Send, node: Prism::Node).void }
         def reference_symbol_as_constant(indexer, send, node)
           case node
-          when SyntaxTree::SymbolLiteral
-            name = indexer.node_string(node.value)
-            indexer.reference_constant(name, send.node)
-          when SyntaxTree::StringLiteral
-            string = T.must(indexer.node_string(node)[1..-2])
-            string.split("::").each do |name|
+          when Prism::SymbolNode
+            indexer.reference_constant(node.unescaped, send.node)
+          when Prism::StringNode
+            node.unescaped.split("::").each do |name|
               indexer.reference_constant(name, send.node) unless name.empty?
             end
           end

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

@@ -0,0 +1,40 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Deadcode
+    module Plugins
+      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)
+        end
+
+        sig { override.params(indexer: Indexer, definition: Definition).void }
+        def on_define_method(indexer, definition)
+          definition.ignored! if indexer.last_sig =~ /(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
+        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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Deadcode
+    module Plugins
+      class Thor < Base
+        extend T::Sig
+
+        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
+
+          definition.ignored! if indexer.nesting_class_superclass_name =~ /^(::)?Thor$/
+        end
+      end
+    end
+  end
+end

data/lib/spoom/deadcode/plugins.rb

@@ -2,4 +2,95 @@
 # frozen_string_literal: true
 
 require_relative "plugins/base"
+
+require_relative "plugins/actionpack"
+require_relative "plugins/active_job"
+require_relative "plugins/action_mailer_preview"
+require_relative "plugins/action_mailer"
+require_relative "plugins/active_model"
+require_relative "plugins/active_record"
+require_relative "plugins/active_support"
+require_relative "plugins/graphql"
+require_relative "plugins/minitest"
+require_relative "plugins/namespaces"
+require_relative "plugins/rails"
+require_relative "plugins/rake"
+require_relative "plugins/rspec"
+require_relative "plugins/rubocop"
 require_relative "plugins/ruby"
+require_relative "plugins/sorbet"
+require_relative "plugins/thor"
+
+module Spoom
+  module Deadcode
+    DEFAULT_CUSTOM_PLUGINS_PATH = ".spoom/deadcode/plugins"
+
+    DEFAULT_PLUGINS = T.let(
+      Set.new([
+        Spoom::Deadcode::Plugins::Namespaces,
+        Spoom::Deadcode::Plugins::Ruby,
+      ]).freeze,
+      T::Set[T.class_of(Plugins::Base)],
+    )
+
+    PLUGINS_FOR_GEM = T.let(
+      {
+        "actionmailer" => Spoom::Deadcode::Plugins::ActionMailer,
+        "actionpack" => Spoom::Deadcode::Plugins::ActionPack,
+        "activejob" => Spoom::Deadcode::Plugins::ActiveJob,
+        "activemodel" => Spoom::Deadcode::Plugins::ActiveModel,
+        "activerecord" => Spoom::Deadcode::Plugins::ActiveRecord,
+        "activesupport" => Spoom::Deadcode::Plugins::ActiveSupport,
+        "graphql" => Spoom::Deadcode::Plugins::GraphQL,
+        "minitest" => Spoom::Deadcode::Plugins::Minitest,
+        "rails" => Spoom::Deadcode::Plugins::Rails,
+        "rake" => Spoom::Deadcode::Plugins::Rake,
+        "rspec" => Spoom::Deadcode::Plugins::RSpec,
+        "rubocop" => Spoom::Deadcode::Plugins::Rubocop,
+        "sorbet-runtime" => Spoom::Deadcode::Plugins::Sorbet,
+        "sorbet-static" => Spoom::Deadcode::Plugins::Sorbet,
+        "thor" => Spoom::Deadcode::Plugins::Thor,
+      }.freeze,
+      T::Hash[String, T.class_of(Plugins::Base)],
+    )
+
+    class << self
+      extend T::Sig
+
+      sig { params(context: Context).returns(T::Array[Plugins::Base]) }
+      def plugins_from_gemfile_lock(context)
+        # These plugins are always loaded
+        plugin_classes = DEFAULT_PLUGINS.dup
+
+        # These plugins depends on the gems used by the project
+        context.gemfile_lock_specs.keys.each do |name|
+          plugin_class = PLUGINS_FOR_GEM[name]
+          plugin_classes << plugin_class if plugin_class
+        end
+
+        plugin_classes.map(&:new)
+      end
+
+      sig { params(context: Context).returns(T::Array[Plugins::Base]) }
+      def load_custom_plugins(context)
+        context.glob("#{DEFAULT_CUSTOM_PLUGINS_PATH}/*.rb").each do |path|
+          require("#{context.absolute_path}/#{path}")
+        end
+
+        ObjectSpace
+          .each_object(Class)
+          .select do |klass|
+            next unless T.unsafe(klass).name # skip anonymous classes, we only use them in tests
+            next unless T.unsafe(klass) < Plugins::Base
+
+            location = Object.const_source_location(T.unsafe(klass).to_s)&.first
+            next unless location
+            next unless location.start_with?("#{context.absolute_path}/#{DEFAULT_CUSTOM_PLUGINS_PATH}")
+
+            true
+          end
+          .map { |klass| T.unsafe(klass).new }
+      end
+    end
+  end
+end