spoom 1.2.2 → 1.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5154e37a81129c70e93925cc2a545a0d7861fd645a3ec2422e6549efc0cb76b5
-  data.tar.gz: 30c9ecdc3599a37309180fea890a7888d53b430c8701e0970f503bf5731979f9
+  metadata.gz: 8e7ef8ebef70bc8827cdcb4b2c0e49ed6c53686e0db409908354f3762ad07c10
+  data.tar.gz: a6adb405f0379cbe040e743f177e758e2bdaadcdea13ee9c7f75d84f764434b1
 SHA512:
-  metadata.gz: a3246a42fa965e3ef75d0178ffe958a8cc5723812ecb86799b5e2e406d5da7487ffd738696ccb3f6d76ae140de281dab73dba3ec3d8af9fdef696820654ed869
-  data.tar.gz: ba4c8ab2d87ff4451f420e2d062c7cebdd19202bc91226fd131ff9ab9f838e7494fa43560ffa317fc0565d023ecceef184c02f762e215ba6451d3ec164e3c75a
+  metadata.gz: 86d74bc7d9554d67c1421908116bbab7615d77e9cb096d461f7885429d495f2b02f19d6024117f7083423cfe7c48165b18918c143f29574896bfbb76a4fb651f
+  data.tar.gz: 754d41e8f26425a42288388879fe1658214adea03002421495297486343a827d6dc79a395e895553ed15f67cdc766a16f4a174aab2a3671bd2455e305a8c6f13

data/lib/spoom/cli/coverage.rb

@@ -187,7 +187,7 @@ module Spoom
 
       no_commands do
         def parse_time(string, option)
-          return nil unless string
+          return unless string
 
           Time.parse(string)
         rescue ArgumentError

data/lib/spoom/context/git.rb

@@ -13,7 +13,7 @@ module Spoom
         sig { params(string: String).returns(T.nilable(Commit)) }
         def parse_line(string)
           sha, epoch = string.split(" ", 2)
-          return nil unless sha && epoch
+          return unless sha && epoch
 
           time = Time.strptime(epoch, "%s")
           Commit.new(sha: sha, time: time)
@@ -88,7 +88,7 @@ module Spoom
       sig { returns(T.nilable(String)) }
       def git_current_branch
         res = git("branch --show-current")
-        return nil unless res.status
+        return unless res.status
 
         res.out.strip
       end
@@ -103,10 +103,10 @@ module Spoom
       sig { params(short_sha: T::Boolean).returns(T.nilable(Spoom::Git::Commit)) }
       def git_last_commit(short_sha: true)
         res = git_log("HEAD --format='%#{short_sha ? "h" : "H"} %at' -1")
-        return nil unless res.status
+        return unless res.status
 
         out = res.out.strip
-        return nil if out.empty?
+        return if out.empty?
 
         Spoom::Git::Commit.parse_line(out)
       end

data/lib/spoom/context/sorbet.rb

@@ -52,7 +52,7 @@ module Spoom
           sorbet_bin: sorbet_bin,
           capture_err: capture_err,
         )
-        return nil unless file?(metrics_file)
+        return unless file?(metrics_file)
 
         metrics_path = absolute_path_to(metrics_file)
         metrics = Spoom::Sorbet::MetricsParser.parse_file(metrics_path)
@@ -109,7 +109,7 @@ module Spoom
       sig { params(arg: String, sorbet_bin: T.nilable(String), capture_err: T::Boolean).returns(T.nilable(String)) }
       def srb_version(*arg, sorbet_bin: nil, capture_err: true)
         res = T.unsafe(self).srb_tc("--no-config", "--version", *arg, sorbet_bin: sorbet_bin, capture_err: capture_err)
-        return nil unless res.status
+        return unless res.status
 
         res.out.split(" ")[2]
       end
@@ -147,10 +147,10 @@ module Spoom
       sig { returns(T.nilable(Spoom::Git::Commit)) }
       def sorbet_intro_commit
         res = git_log("--diff-filter=A --format='%h %at' -1 -- sorbet/config")
-        return nil unless res.status
+        return unless res.status
 
         out = res.out.strip
-        return nil if out.empty?
+        return if out.empty?
 
         Spoom::Git::Commit.parse_line(out)
       end
@@ -159,10 +159,10 @@ module Spoom
       sig { returns(T.nilable(Spoom::Git::Commit)) }
       def sorbet_removal_commit
         res = git_log("--diff-filter=D --format='%h %at' -1 -- sorbet/config")
-        return nil unless res.status
+        return unless res.status
 
         out = res.out.strip
-        return nil if out.empty?
+        return if out.empty?
 
         Spoom::Git::Commit.parse_line(out)
       end

data/lib/spoom/deadcode/indexer.rb

@@ -12,14 +12,15 @@ module Spoom
       sig { returns(Index) }
       attr_reader :index
 
-      sig { params(path: String, source: String, index: Index).void }
-      def initialize(path, source, index)
+      sig { params(path: String, source: String, index: Index, plugins: T::Array[Plugins::Base]).void }
+      def initialize(path, source, index, plugins: [])
         super()
 
         @path = path
         @file_name = T.let(File.basename(path), String)
         @source = source
         @index = index
+        @plugins = plugins
         @previous_node = T.let(nil, T.nilable(SyntaxTree::Node))
         @names_nesting = T.let([], T::Array[String])
         @nodes_nesting = T.let([], T::Array[SyntaxTree::Node])
@@ -228,6 +229,10 @@ module Spoom
             define_attr_writer("#{name}=", "#{full_name}=", arg)
           end
         else
+          @plugins.each do |plugin|
+            plugin.on_send(self, send)
+          end
+
           reference_method(send.name, send.node)
           visit_all(send.args)
           visit(send.block)
@@ -270,8 +275,6 @@ module Spoom
         visit_send(Send.new(node: node, name: node_string(node.value)))
       end
 
-      private
-
       # Definition indexing
 
       sig { params(name: String, full_name: String, node: SyntaxTree::Node).void }
@@ -283,6 +286,7 @@ module Spoom
           location: node_location(node),
         )
         @index.define(definition)
+        @plugins.each { |plugin| plugin.on_define_accessor(self, definition) }
       end
 
       sig { params(name: String, full_name: String, node: SyntaxTree::Node).void }
@@ -294,6 +298,7 @@ module Spoom
           location: node_location(node),
         )
         @index.define(definition)
+        @plugins.each { |plugin| plugin.on_define_accessor(self, definition) }
       end
 
       sig { params(name: String, full_name: String, node: SyntaxTree::Node).void }
@@ -305,6 +310,7 @@ module Spoom
           location: node_location(node),
         )
         @index.define(definition)
+        @plugins.each { |plugin| plugin.on_define_class(self, definition) }
       end
 
       sig { params(name: String, full_name: String, node: SyntaxTree::Node).void }
@@ -316,6 +322,7 @@ module Spoom
           location: node_location(node),
         )
         @index.define(definition)
+        @plugins.each { |plugin| plugin.on_define_constant(self, definition) }
       end
 
       sig { params(name: String, full_name: String, node: SyntaxTree::Node).void }
@@ -327,6 +334,7 @@ module Spoom
           location: node_location(node),
         )
         @index.define(definition)
+        @plugins.each { |plugin| plugin.on_define_method(self, definition) }
       end
 
       sig { params(name: String, full_name: String, node: SyntaxTree::Node).void }
@@ -338,6 +346,7 @@ module Spoom
           location: node_location(node),
         )
         @index.define(definition)
+        @plugins.each { |plugin| plugin.on_define_module(self, definition) }
       end
 
       # Reference indexing

data/lib/spoom/deadcode/location.rb

@@ -44,7 +44,7 @@ module Spoom
 
       sig { override.params(other: BasicObject).returns(T.nilable(Integer)) }
       def <=>(other)
-        return nil unless Location === other
+        return unless Location === other
 
         to_s <=> other.to_s
       end

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

@@ -0,0 +1,201 @@
+# 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 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_method_names(*names)
+            save_names_and_patterns(names, :@ignored_method_names, :@ignored_method_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
+              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
+
+        # 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
+
+        # 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
+
+        # 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)
+          definition.ignored! if ignored_method_name?(definition.name)
+        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
+
+        # 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
+
+        private
+
+        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
+        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::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)
+
+          name = indexer.node_string(first_arg.value)
+          indexer.reference_method(name, send.node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Deadcode
+    module Plugins
+      class Ruby < Base
+        extend T::Sig
+
+        ignore_method_names(
+          "==",
+          "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"
+            reference_send_first_symbol_as_method(indexer, send)
+          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.rb

@@ -0,0 +1,5 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "plugins/base"
+require_relative "plugins/ruby"

data/lib/spoom/deadcode.rb

@@ -12,6 +12,7 @@ require_relative "deadcode/location"
 require_relative "deadcode/definition"
 require_relative "deadcode/reference"
 require_relative "deadcode/send"
+require_relative "deadcode/plugins"
 
 module Spoom
   module Deadcode
@@ -34,10 +35,10 @@ module Spoom
     class << self
       extend T::Sig
 
-      sig { params(index: Index, ruby: String, file: String).void }
-      def index_ruby(index, ruby, file:)
+      sig { params(index: Index, ruby: String, file: String, plugins: T::Array[Deadcode::Plugins::Base]).void }
+      def index_ruby(index, ruby, file:, plugins: [])
         node = SyntaxTree.parse(ruby)
-        visitor = Spoom::Deadcode::Indexer.new(file, ruby, index)
+        visitor = Spoom::Deadcode::Indexer.new(file, ruby, index, plugins: plugins)
         visitor.visit(node)
       rescue SyntaxTree::Parser::ParseError => e
         raise ParserError.new("Error while parsing #{file} (#{e.message} at #{e.lineno}:#{e.column})", parent: e)
@@ -45,10 +46,10 @@ module Spoom
         raise IndexerError.new("Error while indexing #{file} (#{e.message})", parent: e)
       end
 
-      sig { params(index: Index, erb: String, file: String).void }
-      def index_erb(index, erb, file:)
+      sig { params(index: Index, erb: String, file: String, plugins: T::Array[Deadcode::Plugins::Base]).void }
+      def index_erb(index, erb, file:, plugins: [])
         ruby = ERB.new(erb).src
-        index_ruby(index, ruby, file: file)
+        index_ruby(index, ruby, file: file, plugins: plugins)
       end
     end
   end

data/lib/spoom/sorbet/lsp.rb

@@ -53,7 +53,7 @@ module Spoom
       sig { returns(T.nilable(T::Hash[T.untyped, T.untyped])) }
       def read
         raw_string = read_raw
-        return nil unless raw_string
+        return unless raw_string
 
         json = JSON.parse(raw_string)
 
@@ -101,7 +101,7 @@ module Spoom
           },
         ))
 
-        return nil unless json && json["result"]
+        return unless json && json["result"]
 
         Hover.from_json(json["result"])
       end

data/lib/spoom/sorbet/sigils.rb

@@ -28,7 +28,7 @@ module Spoom
         T::Array[String],
       )
 
-      SIGIL_REGEXP = T.let(/^#[\ t]*typed[\ t]*:[ \t]*(\w*)[ \t]*/, Regexp)
+      SIGIL_REGEXP = T.let(/^#[[:blank:]]*typed:[[:blank:]]*(\S*)/, Regexp)
 
       class << self
         extend T::Sig
@@ -61,7 +61,7 @@ module Spoom
         # * returns nil if no sigil
         sig { params(path: T.any(String, Pathname)).returns(T.nilable(String)) }
         def file_strictness(path)
-          return nil unless File.file?(path)
+          return unless File.file?(path)
 
           content = File.read(path, encoding: Encoding::ASCII_8BIT)
           strictness_in_content(content)

data/lib/spoom/sorbet.rb

@@ -35,6 +35,7 @@ module Spoom
 
     CONFIG_PATH = "sorbet/config"
     GEM_PATH = T.let(Gem::Specification.find_by_name("sorbet-static").full_gem_path, String)
+    GEM_VERSION = T.let(Gem::Specification.find_by_name("sorbet-static-and-runtime").version.to_s, String)
     BIN_PATH = T.let((Pathname.new(GEM_PATH) / "libexec" / "sorbet").to_s, String)
 
     KILLED_CODE = 137

data/lib/spoom/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Spoom
-  VERSION = "1.2.2"
+  VERSION = "1.2.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spoom
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 1.2.3
 platform: ruby
 authors:
 - Alexandre Terrasa
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-06-21 00:00:00.000000000 Z
+date: 2023-08-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -81,7 +81,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 1.10.0
 - !ruby/object:Gem::Dependency
-  name: sorbet
+  name: sorbet-static-and-runtime
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -94,20 +94,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.5.10187
-- !ruby/object:Gem::Dependency
-  name: sorbet-runtime
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.5.9204
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.5.9204
 - !ruby/object:Gem::Dependency
   name: syntax_tree
   requirement: !ruby/object:Gem::Requirement
@@ -177,6 +163,9 @@ files:
 - lib/spoom/deadcode/index.rb
 - lib/spoom/deadcode/indexer.rb
 - lib/spoom/deadcode/location.rb
+- lib/spoom/deadcode/plugins.rb
+- lib/spoom/deadcode/plugins/base.rb
+- lib/spoom/deadcode/plugins/ruby.rb
 - lib/spoom/deadcode/reference.rb
 - lib/spoom/deadcode/send.rb
 - lib/spoom/file_collector.rb
@@ -216,7 +205,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.14
+rubygems_version: 3.4.17
 signing_key: 
 specification_version: 4
 summary: Useful tools for Sorbet enthusiasts.