spoom 1.5.4 → 1.6.0

data/lib/spoom/coverage.rb

@@ -10,9 +10,7 @@ require "date"
 module Spoom
   module Coverage
     class << self
-      extend T::Sig
-
-      sig { params(context: Context, rbi: T::Boolean, sorbet_bin: T.nilable(String)).returns(Snapshot) }
+      #: (Context context, ?rbi: bool, ?sorbet_bin: String?) -> Snapshot
       def snapshot(context, rbi: true, sorbet_bin: nil)
         config = context.sorbet_config
         config.allowed_extensions.push(".rb", ".rbi") if config.allowed_extensions.empty?
@@ -79,7 +77,7 @@ module Spoom
         snapshot
       end
 
-      sig { params(context: Context, snapshots: T::Array[Snapshot], palette: D3::ColorPalette).returns(Report) }
+      #: (Context context, Array[Snapshot] snapshots, palette: D3::ColorPalette) -> Report
       def report(context, snapshots, palette:)
         intro_commit = context.sorbet_intro_commit
 
@@ -99,7 +97,7 @@ module Spoom
         )
       end
 
-      sig { params(context: Context).returns(FileTree) }
+      #: (Context context) -> FileTree
       def file_tree(context)
         config = context.sorbet_config
         config.ignore += ["test"]

data/lib/spoom/deadcode/definition.rb

@@ -5,8 +5,6 @@ module Spoom
   module Deadcode
     # A definition is a class, module, method, constant, etc. being defined in the code
     class Definition < T::Struct
-      extend T::Sig
-
       class Kind < T::Enum
         enums do
           AttrReader = new("attr_reader")
@@ -37,66 +35,66 @@ module Spoom
 
       # Kind
 
-      sig { returns(T::Boolean) }
+      #: -> bool
       def attr_reader?
         kind == Kind::AttrReader
       end
 
-      sig { returns(T::Boolean) }
+      #: -> bool
       def attr_writer?
         kind == Kind::AttrWriter
       end
 
-      sig { returns(T::Boolean) }
+      #: -> bool
       def class?
         kind == Kind::Class
       end
 
-      sig { returns(T::Boolean) }
+      #: -> bool
       def constant?
         kind == Kind::Constant
       end
 
-      sig { returns(T::Boolean) }
+      #: -> bool
       def method?
         kind == Kind::Method
       end
 
-      sig { returns(T::Boolean) }
+      #: -> bool
       def module?
         kind == Kind::Module
       end
 
       # Status
 
-      sig { returns(T::Boolean) }
+      #: -> bool
       def alive?
         status == Status::ALIVE
       end
 
-      sig { void }
+      #: -> void
       def alive!
         @status = Status::ALIVE
       end
 
-      sig { returns(T::Boolean) }
+      #: -> bool
       def dead?
         status == Status::DEAD
       end
 
-      sig { returns(T::Boolean) }
+      #: -> bool
       def ignored?
         status == Status::IGNORED
       end
 
-      sig { void }
+      #: -> void
       def ignored!
         @status = Status::IGNORED
       end
 
       # Utils
 
-      sig { params(args: T.untyped).returns(String) }
+      #: (*untyped args) -> String
       def to_json(*args)
         {
           kind: kind,

data/lib/spoom/deadcode/erb.rb

@@ -27,9 +27,7 @@ module Spoom
   module Deadcode
     # Custom engine to handle ERB templates as used by Rails
     class ERB < ::Erubi::Engine
-      extend T::Sig
-
-      sig { params(input: T.untyped, properties: T.untyped).void }
+      #: (untyped input, ?untyped properties) -> void
       def initialize(input, properties = {})
         @newline_pending = 0
 
@@ -44,7 +42,8 @@ module Spoom
 
       private
 
-      sig { override.params(text: T.untyped).void }
+      # @override
+      #: (untyped text) -> void
       def add_text(text)
         return if text.empty?
 
@@ -62,7 +61,8 @@ module Spoom
 
       BLOCK_EXPR = /\s*((\s+|\))do|\{)(\s*\|[^|]*\|)?\s*\Z/
 
-      sig { override.params(indicator: T.untyped, code: T.untyped).void }
+      # @override
+      #: (untyped indicator, untyped code) -> void
       def add_expression(indicator, code)
         flush_newline_if_pending(src)
 
@@ -79,19 +79,21 @@ module Spoom
         end
       end
 
-      sig { override.params(code: T.untyped).void }
+      # @override
+      #: (untyped code) -> void
       def add_code(code)
         flush_newline_if_pending(src)
         super
       end
 
-      sig { override.params(_: T.untyped).void }
+      # @override
+      #: (untyped _) -> void
       def add_postamble(_)
         flush_newline_if_pending(src)
         super
       end
 
-      sig { params(src: T.untyped).void }
+      #: (untyped src) -> void
       def flush_newline_if_pending(src)
         if @newline_pending > 0
           src << bufvar << ".safe_append='#{"\n" * @newline_pending}'.freeze;"

data/lib/spoom/deadcode/index.rb

@@ -4,28 +4,24 @@
 module Spoom
   module Deadcode
     class Index
-      extend T::Sig
-
       class Error < Spoom::Error
-        extend T::Sig
-
-        sig { params(message: String, parent: Exception).void }
+        #: (String message, parent: Exception) -> void
         def initialize(message, parent:)
           super(message)
           set_backtrace(parent.backtrace)
         end
       end
 
-      sig { returns(Model) }
+      #: Model
       attr_reader :model
 
-      sig { returns(T::Hash[String, T::Array[Definition]]) }
+      #: Hash[String, Array[Definition]]
       attr_reader :definitions
 
-      sig { returns(T::Hash[String, T::Array[Model::Reference]]) }
+      #: Hash[String, Array[Model::Reference]]
       attr_reader :references
 
-      sig { params(model: Model).void }
+      #: (Model model) -> void
       def initialize(model)
         @model = model
         @definitions = T.let({}, T::Hash[String, T::Array[Definition]])
@@ -35,7 +31,7 @@ module Spoom
 
       # Indexing
 
-      sig { params(file: String, plugins: T::Array[Plugins::Base]).void }
+      #: (String file, ?plugins: Array[Plugins::Base]) -> void
       def index_file(file, plugins: [])
         if file.end_with?(".erb")
           erb = File.read(file)
@@ -46,17 +42,17 @@ module Spoom
         end
       end
 
-      sig { params(erb: String, file: String, plugins: T::Array[Plugins::Base]).void }
+      #: (String erb, file: String, ?plugins: 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 }
+      #: (String rb, file: String, ?plugins: Array[Plugins::Base]) -> void
       def index_ruby(rb, file:, plugins: [])
-        node = Spoom.parse_ruby(rb, file: file)
+        node, comments = Spoom.parse_ruby_with_comments(rb, file: file)
 
         # Index definitions
-        model_builder = Model::Builder.new(@model, file)
+        model_builder = Model::Builder.new(@model, file, comments: comments)
         model_builder.visit(node)
 
         # Index references
@@ -75,27 +71,27 @@ module Spoom
         raise Error.new("Error while indexing #{file} (#{e.message})", parent: e)
       end
 
-      sig { params(definition: Definition).void }
+      #: (Definition definition) -> void
       def define(definition)
         (@definitions[definition.name] ||= []) << definition
       end
 
-      sig { params(name: String, location: Location).void }
+      #: (String name, Location location) -> void
       def reference_constant(name, location)
         (@references[name] ||= []) << Model::Reference.constant(name, location)
       end
 
-      sig { params(name: String, location: Location).void }
+      #: (String name, Location location) -> void
       def reference_method(name, location)
         (@references[name] ||= []) << Model::Reference.method(name, location)
       end
 
-      sig { params(symbol_def: Model::SymbolDef).void }
+      #: (Model::SymbolDef symbol_def) -> void
       def ignore(symbol_def)
         @ignored << symbol_def
       end
 
-      sig { params(plugins: T::Array[Plugins::Base]).void }
+      #: (Array[Plugins::Base] plugins) -> void
       def apply_plugins!(plugins)
         @model.symbols.each do |_full_name, symbol|
           symbol.definitions.each do |symbol_def|
@@ -118,7 +114,7 @@ module Spoom
       # Mark all definitions having a reference of the same name as `alive`
       #
       # To be called once all the files have been indexed and all the definitions and references discovered.
-      sig { void }
+      #: -> void
       def finalize!
         @model.symbols.each do |_full_name, symbol|
           symbol.definitions.each do |symbol_def|
@@ -210,17 +206,17 @@ module Spoom
 
       # Utils
 
-      sig { params(name: String).returns(T::Array[Definition]) }
+      #: (String name) -> Array[Definition]
       def definitions_for_name(name)
         @definitions[name] || []
       end
 
-      sig { returns(T::Array[Definition]) }
+      #: -> Array[Definition]
       def all_definitions
         @definitions.values.flatten
       end
 
-      sig { returns(T::Array[Model::Reference]) }
+      #: -> Array[Model::Reference]
       def all_references
         @references.values.flatten
       end

data/lib/spoom/deadcode/indexer.rb

@@ -4,15 +4,13 @@
 module Spoom
   module Deadcode
     class Indexer < Visitor
-      extend T::Sig
-
-      sig { returns(String) }
+      #: String
       attr_reader :path
 
-      sig { returns(Index) }
+      #: Index
       attr_reader :index
 
-      sig { params(path: String, index: Index, plugins: T::Array[Plugins::Base]).void }
+      #: (String path, Index index, ?plugins: Array[Plugins::Base]) -> void
       def initialize(path, index, plugins: [])
         super()
 
@@ -23,7 +21,8 @@ module Spoom
 
       # Visit
 
-      sig { override.params(node: Prism::CallNode).void }
+      # @override
+      #: (Prism::CallNode node) -> void
       def visit_call_node(node)
         visit(node.receiver)
 

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

@@ -5,9 +5,8 @@ module Spoom
   module Deadcode
     module Plugins
       class ActionMailer < Base
-        extend T::Sig
-
-        sig { override.params(send: Send).void }
+        # @override
+        #: (Send send) -> void
         def on_send(send)
           return unless send.recv.nil? && ActionPack::CALLBACKS.include?(send.name)
 

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

@@ -5,11 +5,10 @@ module Spoom
   module Deadcode
     module Plugins
       class ActionMailerPreview < Base
-        extend T::Sig
-
         ignore_classes_inheriting_from("ActionMailer::Preview")
 
-        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/actionpack.rb

@@ -5,8 +5,6 @@ module Spoom
   module Deadcode
     module Plugins
       class ActionPack < Base
-        extend T::Sig
-
         ignore_classes_inheriting_from("ApplicationController")
 
         CALLBACKS = T.let(
@@ -27,7 +25,8 @@ module Spoom
           T::Array[String],
         )
 
-        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)
@@ -35,7 +34,8 @@ module Spoom
           @index.ignore(definition) if ignored_subclass?(owner)
         end
 
-        sig { override.params(send: Send).void }
+        # @override
+        #: (Send send) -> void
         def on_send(send)
           return unless send.recv.nil? && CALLBACKS.include?(send.name)
 

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

@@ -5,12 +5,11 @@ module Spoom
   module Deadcode
     module Plugins
       class ActiveModel < Base
-        extend T::Sig
-
         ignore_classes_inheriting_from("ActiveModel::EachValidator")
         ignore_methods_named("validate_each", "persisted?")
 
-        sig { override.params(send: Send).void }
+        # @override
+        #: (Send send) -> void
         def on_send(send)
           return if send.recv
 

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

@@ -5,8 +5,6 @@ module Spoom
   module Deadcode
     module Plugins
       class ActiveRecord < Base
-        extend T::Sig
-
         ignore_classes_inheriting_from(/^(::)?ActiveRecord::Migration/)
 
         ignore_methods_named(
@@ -70,7 +68,8 @@ module Spoom
           T::Array[String],
         )
 
-        sig { override.params(send: Send).void }
+        # @override
+        #: (Send send) -> void
         def on_send(send)
           if send.recv.nil? && CALLBACKS.include?(send.name)
             send.each_arg(Prism::SymbolNode) do |arg|

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

@@ -18,7 +18,8 @@ module Spoom
 
         SETUP_AND_TEARDOWN_METHODS = T.let(["setup", "teardown"], T::Array[String])
 
-        sig { override.params(send: Send).void }
+        # @override
+        #: (Send send) -> void
         def on_send(send)
           return unless send.recv.nil? && SETUP_AND_TEARDOWN_METHODS.include?(send.name)
 

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

@@ -7,14 +7,11 @@ 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.
@@ -30,7 +27,7 @@ module Spoom
           #   )
           # end
           # ~~~
-          sig { params(names: T.any(String, Regexp)).void }
+          #: (*(String | Regexp) names) -> void
           def ignore_classes_named(*names)
             save_names_and_patterns(names, :@ignored_class_names, :@ignored_class_patterns)
           end
@@ -48,7 +45,7 @@ module Spoom
           #   )
           # end
           # ~~~
-          sig { params(names: T.any(String, Regexp)).void }
+          #: (*(String | Regexp) names) -> void
           def ignore_classes_inheriting_from(*names)
             save_names_and_patterns(names, :@ignored_subclasses_of_names, :@ignored_subclasses_of_patterns)
           end
@@ -66,7 +63,7 @@ module Spoom
           #   )
           # end
           # ~~~
-          sig { params(names: T.any(String, Regexp)).void }
+          #: (*(String | Regexp) names) -> void
           def ignore_constants_named(*names)
             save_names_and_patterns(names, :@ignored_constant_names, :@ignored_constant_patterns)
           end
@@ -84,7 +81,7 @@ module Spoom
           #   )
           # end
           # ~~~
-          sig { params(names: T.any(String, Regexp)).void }
+          #: (*(String | Regexp) names) -> void
           def ignore_methods_named(*names)
             save_names_and_patterns(names, :@ignored_method_names, :@ignored_method_patterns)
           end
@@ -102,14 +99,14 @@ module Spoom
           #   )
           # end
           # ~~~
-          sig { params(names: T.any(String, Regexp)).void }
+          #: (*(String | Regexp) names) -> 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 }
+          #: (Array[(String | Regexp)] names, Symbol names_variable, Symbol patterns_variable) -> 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, [])
@@ -125,10 +122,10 @@ module Spoom
           end
         end
 
-        sig { returns(Index) }
+        #: Index
         attr_reader :index
 
-        sig { params(index: Index).void }
+        #: (Index index) -> void
         def initialize(index)
           @index = index
         end
@@ -148,13 +145,13 @@ module Spoom
         #   end
         # end
         # ~~~
-        sig { params(definition: Model::Attr).void }
+        #: (Model::Attr definition) -> void
         def on_define_accessor(definition)
           # no-op
         end
 
         # Do not override this method, use `on_define_accessor` instead.
-        sig { params(definition: Model::Attr).void }
+        #: (Model::Attr definition) -> void
         def internal_on_define_accessor(definition)
           on_define_accessor(definition)
         end
@@ -172,13 +169,13 @@ module Spoom
         #   end
         # end
         # ~~~
-        sig { params(definition: Model::Class).void }
+        #: (Model::Class definition) -> void
         def on_define_class(definition)
           # no-op
         end
 
         # Do not override this method, use `on_define_class` instead.
-        sig { params(definition: Model::Class).void }
+        #: (Model::Class definition) -> void
         def internal_on_define_class(definition)
           if ignored_class_name?(definition.name)
             @index.ignore(definition)
@@ -202,13 +199,13 @@ module Spoom
         #   end
         # end
         # ~~~
-        sig { params(definition: Model::Constant).void }
+        #: (Model::Constant definition) -> void
         def on_define_constant(definition)
           # no-op
         end
 
         # Do not override this method, use `on_define_constant` instead.
-        sig { params(definition: Model::Constant).void }
+        #: (Model::Constant definition) -> void
         def internal_on_define_constant(definition)
           @index.ignore(definition) if ignored_constant_name?(definition.name)
 
@@ -228,13 +225,13 @@ module Spoom
         #   end
         # end
         # ~~~
-        sig { params(definition: Model::Method).void }
+        #: (Model::Method definition) -> void
         def on_define_method(definition)
           # no-op
         end
 
         # Do not override this method, use `on_define_method` instead.
-        sig { params(definition: Model::Method).void }
+        #: (Model::Method definition) -> void
         def internal_on_define_method(definition)
           @index.ignore(definition) if ignored_method_name?(definition.name)
 
@@ -254,13 +251,13 @@ module Spoom
         #   end
         # end
         # ~~~
-        sig { params(definition: Model::Module).void }
+        #: (Model::Module definition) -> void
         def on_define_module(definition)
           # no-op
         end
 
         # Do not override this method, use `on_define_module` instead.
-        sig { params(definition: Model::Module).void }
+        #: (Model::Module definition) -> void
         def internal_on_define_module(definition)
           @index.ignore(definition) if ignored_module_name?(definition.name)
 
@@ -280,7 +277,7 @@ module Spoom
         #   end
         # end
         # ~~~
-        sig { params(send: Send).void }
+        #: (Send send) -> void
         def on_send(send)
           # no-op
         end
@@ -289,7 +286,7 @@ module Spoom
 
         # DSL support
 
-        sig { params(definition: Model::Namespace, superclass_name: String).returns(T::Boolean) }
+        #: (Model::Namespace definition, String superclass_name) -> bool
         def subclass_of?(definition, superclass_name)
           superclass_symbol = @index.model.symbols[superclass_name]
           return false unless superclass_symbol
@@ -297,14 +294,14 @@ module Spoom
           @index.model.symbols_hierarchy.edge?(definition.symbol, superclass_symbol)
         end
 
-        sig { params(name: T.nilable(String)).returns(T::Boolean) }
+        #: (String? name) -> bool
         def ignored_class_name?(name)
           return false unless name
 
           ignored_name?(name, :@ignored_class_names, :@ignored_class_patterns)
         end
 
-        sig { params(definition: Model::Class).returns(T::Boolean) }
+        #: (Model::Class definition) -> bool
         def ignored_subclass?(definition)
           superclass_name = definition.superclass_name
           return true if superclass_name && ignored_name?(
@@ -316,39 +313,39 @@ module Spoom
           names(:@ignored_subclasses_of_names).any? { |superclass_name| subclass_of?(definition, superclass_name) }
         end
 
-        sig { params(name: String).returns(T::Boolean) }
+        #: (String name) -> bool
         def ignored_constant_name?(name)
           ignored_name?(name, :@ignored_constant_names, :@ignored_constant_patterns)
         end
 
-        sig { params(name: String).returns(T::Boolean) }
+        #: (String name) -> bool
         def ignored_method_name?(name)
           ignored_name?(name, :@ignored_method_names, :@ignored_method_patterns)
         end
 
-        sig { params(name: String).returns(T::Boolean) }
+        #: (String name) -> bool
         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) }
+        #: (String name, Symbol names_variable, Symbol patterns_variable) -> bool
         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]) }
+        #: (Symbol const) -> Set[String]
         def names(const)
           self.class.instance_variable_get(const) || Set.new
         end
 
-        sig { params(const: Symbol).returns(T::Array[Regexp]) }
+        #: (Symbol const) -> Array[Regexp]
         def patterns(const)
           self.class.instance_variable_get(const) || []
         end
 
         # Plugin utils
 
-        sig { params(name: String).returns(String) }
+        #: (String name) -> String
         def camelize(name)
           name = T.must(name.split("::").last)
           name = T.must(name.split("/").last)