spoom 1.5.0 → 1.7.2

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

@@ -5,8 +5,6 @@ module Spoom
   module Deadcode
     module Plugins
       class Ruby < Base
-        extend T::Sig
-
         ignore_methods_named(
           "==",
           "extended",
@@ -20,7 +18,8 @@ module Spoom
           "to_s",
         )
 
-        sig { override.params(send: Send).void }
+        # @override
+        #: (Send send) -> void
         def on_send(send)
           case send.name
           when "const_defined?", "const_get", "const_source_location"
@@ -42,7 +41,7 @@ module Spoom
 
         private
 
-        sig { params(send: Send, node: Prism::Node).void }
+        #: (Send send, Prism::Node node) -> void
         def reference_symbol_as_constant(send, node)
           case node
           when Prism::SymbolNode

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

@@ -5,26 +5,32 @@ module Spoom
   module Deadcode
     module Plugins
       class Sorbet < Base
-        extend T::Sig
-
-        sig { override.params(definition: Model::Constant).void }
+        # @override
+        #: (Model::Constant definition) -> void
         def on_define_constant(definition)
           @index.ignore(definition) if sorbet_type_member?(definition) || sorbet_enum_constant?(definition)
         end
 
-        sig { override.params(definition: Model::Method).void }
+        # @override
+        #: (Model::Method definition) -> void
         def on_define_method(definition)
+          # Ignore signatures containing `override` or `overridable`, like `sig { override.void }`
           @index.ignore(definition) if definition.sigs.any? { |sig| sig.string =~ /(override|overridable)/ }
+
+          # Ignore comments `@override` and `@overridable`
+          @index.ignore(definition) if definition.comments.any? do |comment|
+            comment.string == "@override" || comment.string == "@overridable"
+          end
         end
 
         private
 
-        sig { params(definition: Model::Constant).returns(T::Boolean) }
+        #: (Model::Constant definition) -> bool
         def sorbet_type_member?(definition)
           definition.value.match?(/^(type_member|type_template)/)
         end
 
-        sig { params(definition: Model::Constant).returns(T::Boolean) }
+        #: (Model::Constant definition) -> bool
         def sorbet_enum_constant?(definition)
           owner = definition.owner
           return false unless owner.is_a?(Model::Class)

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

@@ -5,11 +5,10 @@ module Spoom
   module Deadcode
     module Plugins
       class Thor < Base
-        extend T::Sig
-
         ignore_methods_named("exit_on_failure?")
 
-        sig { override.params(definition: Model::Method).void }
+        # @override
+        #: (Model::Method definition) -> void
         def on_define_method(definition)
           owner = definition.owner
           return unless owner.is_a?(Model::Class)

data/lib/spoom/deadcode/plugins.rb

@@ -25,39 +25,31 @@ 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)],
-    )
+    DEFAULT_PLUGINS = Set.new([
+      Spoom::Deadcode::Plugins::Namespaces,
+      Spoom::Deadcode::Plugins::Ruby,
+    ]).freeze #: Set[singleton(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)],
-    )
+    PLUGINS_FOR_GEM = {
+      "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 #: Hash[String, singleton(Plugins::Base)]
 
     class << self
-      extend T::Sig
-
-      sig { params(context: Context).returns(T::Set[T.class_of(Plugins::Base)]) }
+      #: (Context context) -> Set[singleton(Plugins::Base)]
       def plugins_from_gemfile_lock(context)
         # These plugins are always loaded
         plugin_classes = DEFAULT_PLUGINS.dup
@@ -71,7 +63,7 @@ module Spoom
         plugin_classes
       end
 
-      sig { params(context: Context).returns(T::Array[T.class_of(Plugins::Base)]) }
+      #: (Context context) -> Array[singleton(Plugins::Base)]
       def load_custom_plugins(context)
         context.glob("#{DEFAULT_CUSTOM_PLUGINS_PATH}/*.rb").each do |path|
           require("#{context.absolute_path}/#{path}")

data/lib/spoom/deadcode/remover.rb

@@ -4,16 +4,14 @@
 module Spoom
   module Deadcode
     class Remover
-      extend T::Sig
-
       class Error < Spoom::Error; end
 
-      sig { params(context: Context).void }
+      #: (Context context) -> void
       def initialize(context)
         @context = context
       end
 
-      sig { params(kind: T.nilable(Definition::Kind), location: Location).returns(String) }
+      #: (Definition::Kind? kind, Location location) -> String
       def remove_location(kind, location)
         file = location.file
 
@@ -27,22 +25,20 @@ module Spoom
       end
 
       class NodeRemover
-        extend T::Sig
-
-        sig { returns(String) }
+        #: String
         attr_reader :new_source
 
-        sig { params(source: String, kind: T.nilable(Definition::Kind), location: Location).void }
+        #: (String source, Definition::Kind? kind, Location location) -> void
         def initialize(source, kind, location)
           @old_source = source
-          @new_source = T.let(source.dup, String)
+          @new_source = source.dup #: String
           @kind = kind
           @location = location
 
-          @node_context = T.let(NodeFinder.find(source, location, kind), NodeContext)
+          @node_context = NodeFinder.find(source, location, kind) #: NodeContext
         end
 
-        sig { void }
+        #: -> void
         def apply_edit
           sclass_context = @node_context.sclass_context
           if sclass_context
@@ -69,7 +65,7 @@ module Spoom
 
         private
 
-        sig { params(context: NodeContext).void }
+        #: (NodeContext context) -> void
         def delete_constant_assignment(context)
           case context.node
           when Prism::ConstantWriteNode, Prism::ConstantOperatorWriteNode,
@@ -103,8 +99,10 @@ module Spoom
           prev_node = context.previous_node
           next_node = context.next_node
 
-          if (prev_node && prev_node.location.end_line != node.location.start_line) &&
-              (next_node && next_node.location.start_line != node.location.end_line)
+          has_prev_node_on_different_line = prev_node && prev_node.location.end_line != node.location.start_line
+          has_next_node_on_different_line = next_node && next_node.location.start_line != node.location.end_line
+
+          if has_prev_node_on_different_line && has_next_node_on_different_line
             # We have a node before and after, but on different lines, we need to remove the whole line
             #
             # ~~~
@@ -149,7 +147,7 @@ module Spoom
           end
         end
 
-        sig { params(context: NodeContext).void }
+        #: (NodeContext context) -> void
         def delete_attr_accessor(context)
           args_context = context.parent_context
           send_context = args_context.parent_context
@@ -168,8 +166,10 @@ module Spoom
           prev_node = context.previous_node
           next_node = context.next_node
 
-          if (prev_node && prev_node.location.end_line != context.node.location.start_line) &&
-              (next_node && next_node.location.start_line != context.node.location.end_line)
+          has_prev_node_on_different_line = prev_node && prev_node.location.end_line != context.node.location.start_line
+          has_next_node_on_different_line = next_node && next_node.location.start_line != context.node.location.end_line
+
+          if has_prev_node_on_different_line && has_next_node_on_different_line
             # We have a node before and after, but on different lines, we need to remove the whole line
             #
             # ~~~
@@ -208,13 +208,7 @@ module Spoom
           insert_accessor(context.node, send_context, was_removed: false) if need_accessor
         end
 
-        sig do
-          params(
-            node: Prism::Node,
-            send_context: NodeContext,
-            was_removed: T::Boolean,
-          ).void
-        end
+        #: (Prism::Node node, NodeContext send_context, was_removed: bool) -> void
         def insert_accessor(node, send_context, was_removed:)
           name = node.slice
           code = case @kind
@@ -257,7 +251,7 @@ module Spoom
           @new_source = lines.join
         end
 
-        sig { params(context: NodeContext).void }
+        #: (NodeContext context) -> void
         def delete_node_and_comments_and_sigs(context)
           start_line = context.node.location.start_line
           end_line = context.node.location.end_line
@@ -285,7 +279,7 @@ module Spoom
 
           # Adjust the lines to remove to include previous blank lines
           prev_context = NodeContext.new(@old_source, @node_context.comments, first_node, context.nesting)
-          before = T.let(prev_context.previous_node, T.nilable(T.any(Prism::Node, Prism::Comment)))
+          before = prev_context.previous_node #: (Prism::Node | Prism::Comment)?
 
           # There may be an unrelated comment between the current node and the one before
           # if there is, we only want to delete lines up to the last comment found
@@ -320,26 +314,26 @@ module Spoom
           delete_lines(start_line, end_line)
         end
 
-        sig { params(start_line: Integer, end_line: Integer).void }
+        #: (Integer start_line, Integer end_line) -> void
         def delete_lines(start_line, end_line)
           lines = @new_source.lines
           lines[start_line - 1...end_line] = []
           @new_source = lines.join
         end
 
-        sig { params(start_char: Integer, end_char: Integer).void }
+        #: (Integer start_char, Integer end_char) -> void
         def delete_chars(start_char, end_char)
           @new_source[start_char...end_char] = ""
         end
 
-        sig { params(start_char: Integer, end_char: Integer, replacement: String).void }
+        #: (Integer start_char, Integer end_char, String replacement) -> void
         def replace_chars(start_char, end_char, replacement)
           @new_source[start_char...end_char] = replacement
         end
 
-        sig { params(node: Prism::CallNode, name: String, kind: T.nilable(Definition::Kind)).returns(String) }
+        #: (Prism::CallNode node, name: String, kind: Definition::Kind?) -> String
         def transform_sig(node, name:, kind:)
-          type = T.let(nil, T.nilable(String))
+          type = nil #: String?
 
           block = T.cast(node.block, Prism::BlockNode)
           statements = T.cast(block.body, Prism::StatementsNode)
@@ -370,25 +364,16 @@ module Spoom
       end
 
       class NodeContext
-        extend T::Sig
-
-        sig { returns(T::Hash[Integer, Prism::Comment]) }
+        #: Hash[Integer, Prism::Comment]
         attr_reader :comments
 
-        sig { returns(Prism::Node) }
+        #: Prism::Node
         attr_reader :node
 
-        sig { returns(T::Array[Prism::Node]) }
+        #: Array[Prism::Node]
         attr_accessor :nesting
 
-        sig do
-          params(
-            source: String,
-            comments: T::Hash[Integer, Prism::Comment],
-            node: Prism::Node,
-            nesting: T::Array[Prism::Node],
-          ).void
-        end
+        #: (String source, Hash[Integer, Prism::Comment] comments, Prism::Node node, Array[Prism::Node] nesting) -> void
         def initialize(source, comments, node, nesting)
           @source = source
           @comments = comments
@@ -396,7 +381,7 @@ module Spoom
           @nesting = nesting
         end
 
-        sig { returns(Prism::Node) }
+        #: -> Prism::Node
         def parent_node
           parent = @nesting.last
           raise Error, "No parent for node #{node}" unless parent
@@ -404,7 +389,7 @@ module Spoom
           parent
         end
 
-        sig { returns(NodeContext) }
+        #: -> NodeContext
         def parent_context
           nesting = @nesting.dup
           parent = nesting.pop
@@ -413,7 +398,7 @@ module Spoom
           NodeContext.new(@source, @comments, parent, nesting)
         end
 
-        sig { returns(T::Array[Prism::Node]) }
+        #: -> Array[Prism::Node]
         def previous_nodes
           parent = parent_node
           child_nodes = parent.child_nodes.compact
@@ -424,12 +409,12 @@ module Spoom
           T.must(child_nodes[0...index])
         end
 
-        sig { returns(T.nilable(Prism::Node)) }
+        #: -> Prism::Node?
         def previous_node
           previous_nodes.last
         end
 
-        sig { returns(T::Array[Prism::Node]) }
+        #: -> Array[Prism::Node]
         def next_nodes
           parent = parent_node
           child_nodes = parent.child_nodes.compact
@@ -440,14 +425,14 @@ module Spoom
           T.must(child_nodes.compact[(index + 1)..-1])
         end
 
-        sig { returns(T.nilable(Prism::Node)) }
+        #: -> Prism::Node?
         def next_node
           next_nodes.first
         end
 
-        sig { returns(T.nilable(NodeContext)) }
+        #: -> NodeContext?
         def sclass_context
-          sclass = T.let(nil, T.nilable(Prism::SingletonClassNode))
+          sclass = nil #: Prism::SingletonClassNode?
 
           nesting = @nesting.dup
           until nesting.empty? || sclass
@@ -473,12 +458,12 @@ module Spoom
           nil
         end
 
-        sig { params(node: T.nilable(Prism::Node)).returns(T::Boolean) }
+        #: (Prism::Node? node) -> bool
         def sorbet_signature?(node)
           node.is_a?(Prism::CallNode) && node.name == :sig
         end
 
-        sig { params(node: T.nilable(Prism::Node)).returns(T::Boolean) }
+        #: (Prism::Node? node) -> bool
         def sorbet_extend_sig?(node)
           return false unless node.is_a?(Prism::CallNode)
           return false unless node.name == :extend
@@ -490,9 +475,9 @@ module Spoom
           args.arguments.first&.slice == "T::Sig"
         end
 
-        sig { params(start_line: Integer, end_line: Integer).returns(T::Array[Prism::Comment]) }
+        #: (Integer start_line, Integer end_line) -> Array[Prism::Comment]
         def comments_between_lines(start_line, end_line)
-          comments = T.let([], T::Array[Prism::Comment])
+          comments = [] #: Array[Prism::Comment]
 
           (start_line + 1).upto(end_line - 1) do |line|
             comment = @comments[line]
@@ -502,9 +487,9 @@ module Spoom
           comments
         end
 
-        sig { params(node: Prism::Node).returns(T::Array[Prism::Comment]) }
+        #: (Prism::Node node) -> Array[Prism::Comment]
         def attached_comments(node)
-          comments = T.let([], T::Array[Prism::Comment])
+          comments = [] #: Array[Prism::Comment]
 
           start_line = node.location.start_line - 1
           start_line.downto(1) do |line|
@@ -517,9 +502,9 @@ module Spoom
           comments.reverse
         end
 
-        sig { returns(T::Array[Prism::Node]) }
+        #: -> Array[Prism::Node]
         def attached_sigs
-          nodes = T.let([], T::Array[Prism::Node])
+          nodes = [] #: Array[Prism::Node]
 
           previous_nodes.reverse_each do |prev_node|
             break unless sorbet_signature?(prev_node)
@@ -530,7 +515,7 @@ module Spoom
           nodes.reverse
         end
 
-        sig { returns(T.nilable(Prism::CallNode)) }
+        #: -> Prism::CallNode?
         def attached_sig
           previous_nodes.reverse_each do |node|
             if node.is_a?(Prism::Comment)
@@ -547,12 +532,8 @@ module Spoom
       end
 
       class NodeFinder < Visitor
-        extend T::Sig
-
         class << self
-          extend T::Sig
-
-          sig { params(source: String, location: Location, kind: T.nilable(Definition::Kind)).returns(NodeContext) }
+          #: (String source, Location location, Definition::Kind? kind) -> NodeContext
           def find(source, location, kind)
             result = Prism.parse(source)
 
@@ -576,17 +557,14 @@ module Spoom
               raise Error, "Can't find node at #{location}, expected #{kind} but got #{node.class}"
             end
 
-            comments_by_line = T.let(
-              result.comments.to_h do |comment|
-                [comment.location.start_line, comment]
-              end,
-              T::Hash[Integer, Prism::Comment],
-            )
+            comments_by_line = result.comments.to_h do |comment|
+              [comment.location.start_line, comment]
+            end #: Hash[Integer, Prism::Comment]
 
             NodeContext.new(source, comments_by_line, node, visitor.nodes_nesting)
           end
 
-          sig { params(node: Prism::Node, kind: Definition::Kind).returns(T::Boolean) }
+          #: (Prism::Node node, Definition::Kind kind) -> bool
           def node_match_kind?(node, kind)
             case kind
             when Definition::Kind::AttrReader, Definition::Kind::AttrWriter
@@ -611,22 +589,23 @@ module Spoom
           end
         end
 
-        sig { returns(T.nilable(Prism::Node)) }
+        #: Prism::Node?
         attr_reader :node
 
-        sig { returns(T::Array[Prism::Node]) }
+        #: Array[Prism::Node]
         attr_reader :nodes_nesting
 
-        sig { params(location: Location, kind: T.nilable(Definition::Kind)).void }
+        #: (Location location, Definition::Kind? kind) -> void
         def initialize(location, kind)
           super()
           @location = location
           @kind = kind
-          @node = T.let(nil, T.nilable(Prism::Node))
-          @nodes_nesting = T.let([], T::Array[Prism::Node])
+          @node = nil #: Prism::Node?
+          @nodes_nesting = [] #: Array[Prism::Node]
         end
 
-        sig { override.params(node: T.nilable(Prism::Node)).void }
+        # @override
+        #: (Prism::Node? node) -> void
         def visit(node)
           return unless node
 

data/lib/spoom/deadcode/send.rb

@@ -5,8 +5,6 @@ module Spoom
   module Deadcode
     # An abstraction to simplify handling of Prism::CallNode nodes.
     class Send < T::Struct
-      extend T::Sig
-
       const :node, Prism::CallNode
       const :name, String
       const :recv, T.nilable(Prism::Node), default: nil
@@ -14,18 +12,14 @@ module Spoom
       const :block, T.nilable(Prism::Node), default: nil
       const :location, Location
 
-      sig do
-        type_parameters(:T)
-          .params(arg_type: T::Class[T.type_parameter(:T)], block: T.proc.params(arg: T.type_parameter(:T)).void)
-          .void
-      end
+      #: [T] (Class[T] arg_type) { (T arg) -> void } -> void
       def each_arg(arg_type, &block)
         args.each do |arg|
           yield(T.unsafe(arg)) if arg.is_a?(arg_type)
         end
       end
 
-      sig { params(block: T.proc.params(key: Prism::Node, value: T.nilable(Prism::Node)).void).void }
+      #: { (Prism::Node key, Prism::Node? value) -> void } -> void
       def each_arg_assoc(&block)
         args.each do |arg|
           next unless arg.is_a?(Prism::KeywordHashNode) || arg.is_a?(Prism::HashNode)

data/lib/spoom/file_collector.rb

@@ -3,9 +3,7 @@
 
 module Spoom
   class FileCollector
-    extend T::Sig
-
-    sig { returns(T::Array[String]) }
+    #: Array[String]
     attr_reader :files
 
     # Initialize a new file collector
@@ -16,26 +14,20 @@ module Spoom
     # If `allow_mime_types` is empty, all files are collected.
     # If `allow_mime_types` is an array of mimetypes, files without an extension are collected if their mimetype is in
     # the list.
-    sig do
-      params(
-        allow_extensions: T::Array[String],
-        allow_mime_types: T::Array[String],
-        exclude_patterns: T::Array[String],
-      ).void
-    end
+    #: (?allow_extensions: Array[String], ?allow_mime_types: Array[String], ?exclude_patterns: Array[String]) -> void
     def initialize(allow_extensions: [], allow_mime_types: [], exclude_patterns: [])
-      @files = T.let([], T::Array[String])
+      @files = [] #: Array[String]
       @allow_extensions = allow_extensions
       @allow_mime_types = allow_mime_types
       @exclude_patterns = exclude_patterns
     end
 
-    sig { params(paths: T::Array[String]).void }
+    #: (Array[String] paths) -> void
     def visit_paths(paths)
       paths.each { |path| visit_path(path) }
     end
 
-    sig { params(path: String).void }
+    #: (String path) -> void
     def visit_path(path)
       path = clean_path(path)
 
@@ -52,24 +44,24 @@ module Spoom
 
     private
 
-    sig { params(path: String).returns(String) }
+    #: (String path) -> String
     def clean_path(path)
       Pathname.new(path).cleanpath.to_s
     end
 
-    sig { params(path: String).void }
+    #: (String path) -> void
     def visit_file(path)
       return if excluded_file?(path)
 
       @files << path
     end
 
-    sig { params(path: String).void }
+    #: (String path) -> void
     def visit_directory(path)
       visit_paths(Dir.glob("#{path}/*"))
     end
 
-    sig { params(path: String).returns(T::Boolean) }
+    #: (String path) -> bool
     def excluded_file?(path)
       return false if @allow_extensions.empty?
 
@@ -84,7 +76,7 @@ module Spoom
       end
     end
 
-    sig { params(path: String).returns(T::Boolean) }
+    #: (String path) -> bool
     def excluded_path?(path)
       @exclude_patterns.any? do |pattern|
         # Use `FNM_PATHNAME` so patterns do not match directory separators
@@ -93,7 +85,7 @@ module Spoom
       end
     end
 
-    sig { params(path: String).returns(T.nilable(String)) }
+    #: (String path) -> String?
     def mime_type_for(path)
       # The `file` command appears to be hanging on MacOS for some files so we timeout after 1s.
       %x{timeout 1s file --mime-type -b '#{path}'}.split("; ").first&.strip