spoom 1.2.2 → 1.2.4

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

@@ -0,0 +1,354 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "set"
+
+module Spoom
+  module Deadcode
+    module Plugins
+      class Base
+        extend T::Sig
+        extend T::Helpers
+
+        abstract!
+
+        class << self
+          extend T::Sig
+
+          # 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:
+          #
+          # ~~~rb
+          # class MyPlugin < Spoom::Deadcode::Plugins::Base
+          #   ignore_method_names(
+          #     "foo",
+          #     "bar",
+          #     /baz.*/,
+          #   )
+          # end
+          # ~~~
+          sig { params(names: T.any(String, Regexp)).void }
+          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 }
+          def save_names_and_patterns(names, names_variable, patterns_variable)
+            ignored_names = instance_variable_set(names_variable, Set.new)
+            ignored_patterns = instance_variable_set(patterns_variable, [])
+
+            names.each do |name|
+              case name
+              when String
+                ignored_names << name.delete_prefix("::")
+              when Regexp
+                ignored_patterns << name
+              end
+            end
+          end
+        end
+
+        # Indexing event methods
+
+        # Called when an accessor is defined.
+        #
+        # Will be called when the indexer processes a `attr_reader`, `attr_writer` or `attr_accessor` node.
+        # Note that when this method is called, the definition for the node has already been added to the index.
+        # It is still possible to ignore it from the plugin:
+        #
+        # ~~~rb
+        # class MyPlugin < Spoom::Deadcode::Plugins::Base
+        #   def on_define_accessor(indexer, definition)
+        #     definition.ignored! if definition.name == "foo"
+        #   end
+        # end
+        # ~~~
+        sig { params(indexer: Indexer, definition: Definition).void }
+        def on_define_accessor(indexer, 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)
+        end
+
+        # Called when a class is defined.
+        #
+        # Will be called when the indexer processes a `class` node.
+        # Note that when this method is called, the definition for the node has already been added to the index.
+        # It is still possible to ignore it from the plugin:
+        #
+        # ~~~rb
+        # class MyPlugin < Spoom::Deadcode::Plugins::Base
+        #   def on_define_class(indexer, definition)
+        #     definition.ignored! if definition.name == "Foo"
+        #   end
+        # end
+        # ~~~
+        sig { params(indexer: Indexer, definition: Definition).void }
+        def on_define_class(indexer, 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)
+            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.
+        # Note that when this method is called, the definition for the node has already been added to the index.
+        # It is still possible to ignore it from the plugin:
+        #
+        # ~~~rb
+        # class MyPlugin < Spoom::Deadcode::Plugins::Base
+        #   def on_define_constant(indexer, definition)
+        #     definition.ignored! if definition.name == "FOO"
+        #   end
+        # end
+        # ~~~
+        sig { params(indexer: Indexer, definition: Definition).void }
+        def on_define_constant(indexer, 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)
+
+          on_define_constant(indexer, definition)
+        end
+
+        # Called when a method is defined.
+        #
+        # Will be called when the indexer processes a `def` or `defs` node.
+        # Note that when this method is called, the definition for the node has already been added to the index.
+        # It is still possible to ignore it from the plugin:
+        #
+        # ~~~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"
+        #   end
+        # end
+        # ~~~
+        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.
+        #
+        # Will be called when the indexer processes a `module` node.
+        # Note that when this method is called, the definition for the node has already been added to the index.
+        # It is still possible to ignore it from the plugin:
+        #
+        # ~~~rb
+        # class MyPlugin < Spoom::Deadcode::Plugins::Base
+        #   def on_define_module(indexer, definition)
+        #     definition.ignored! if definition.name == "Foo"
+        #   end
+        # end
+        # ~~~
+        sig { params(indexer: Indexer, definition: Definition).void }
+        def on_define_module(indexer, 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)
+
+          on_define_module(indexer, definition)
+        end
+
+        # Called when a send is being processed
+        #
+        # ~~~rb
+        # class MyPlugin < Spoom::Deadcode::Plugins::Base
+        #   def on_send(indexer, send)
+        #     return unless send.name == "dsl_method"
+        #     return if send.args.empty?
+        #
+        #     method_name = indexer.node_string(send.args.first).delete_prefix(":")
+        #     indexer.reference_method(method_name, send.node)
+        #   end
+        # end
+        # ~~~
+        sig { params(indexer: Indexer, send: Send).void }
+        def on_send(indexer, 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(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(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) }
+        def ignored_name?(name, names_variable, patterns_variable)
+          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
+
+        # Plugin utils
+
+        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
+  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

@@ -0,0 +1,65 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Deadcode
+    module Plugins
+      class Ruby < Base
+        extend T::Sig
+
+        ignore_methods_named(
+          "==",
+          "extended",
+          "included",
+          "inherited",
+          "initialize",
+          "method_added",
+          "method_missing",
+          "prepended",
+          "respond_to_missing?",
+          "to_s",
+        )
+
+        sig { override.params(indexer: Indexer, send: Send).void }
+        def on_send(indexer, send)
+          case send.name
+          when "const_defined?", "const_get", "const_source_location"
+            reference_symbol_as_constant(indexer, send, T.must(send.args.first))
+          when "send", "__send__", "try"
+            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
+
+            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
+            end
+
+            return unless name
+
+            indexer.reference_method(name, send.node)
+          end
+        end
+
+        private
+
+        sig { params(indexer: Indexer, send: Send, node: SyntaxTree::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|
+              indexer.reference_constant(name, send.node) unless name.empty?
+            end
+          end
+        end
+      end
+    end
+  end
+end

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