spoom 1.2.3 → 1.2.4

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
@@ -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?(SyntaxTree::SymbolLiteral)
+
+          indexer.reference_method(indexer.node_string(arg.value), send.node)
+
+          send.each_arg_assoc do |key, value|
+            key = indexer.node_string(key).delete_suffix(":")
+            next unless key == "resolver_method"
+            next unless value
+
+            indexer.reference_method(indexer.symbol_string(value), 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

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

@@ -0,0 +1,34 @@
+# 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?(SyntaxTree::ClassDeclaration) || node.is_a?(SyntaxTree::ModuleDeclaration)
+
+          node.bodystmt.statements.body.any? do |stmt|
+            !stmt.is_a?(SyntaxTree::VoidStmt)
+          end
+        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,7 +26,8 @@ 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(indexer.node_string(arg.value), send.node) if arg.is_a?(SyntaxTree::SymbolLiteral)
           when "alias_method"
             last_arg = send.args.last
 

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

@@ -0,0 +1,46 @@
+# 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(SyntaxTree::Assign)
+          return false unless assign
+
+          value = assign.value
+
+          case value
+          when SyntaxTree::MethodAddBlock
+            indexer.node_string(value.call).match?(/^(type_member|type_template)/)
+          when SyntaxTree::VCall
+            indexer.node_string(value.value).match?(/^(type_member|type_template)/)
+          else
+            false
+          end
+        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_block_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,94 @@
 # frozen_string_literal: true
 
 require_relative "plugins/base"
+
+require_relative "plugins/actionpack"
+require_relative "plugins/active_job"
+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