spoom 1.2.2 → 1.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5154e37a81129c70e93925cc2a545a0d7861fd645a3ec2422e6549efc0cb76b5
-  data.tar.gz: 30c9ecdc3599a37309180fea890a7888d53b430c8701e0970f503bf5731979f9
+  metadata.gz: 23df97e815cc01b35dbc960ec1921bbc1c65ae4c6f0588c690a0d9156877a013
+  data.tar.gz: d82fdb3fb66404b0c2d98ea9206be9d86ec2284bbae2ff24a5653a521ec9155e
 SHA512:
-  metadata.gz: a3246a42fa965e3ef75d0178ffe958a8cc5723812ecb86799b5e2e406d5da7487ffd738696ccb3f6d76ae140de281dab73dba3ec3d8af9fdef696820654ed869
-  data.tar.gz: ba4c8ab2d87ff4451f420e2d062c7cebdd19202bc91226fd131ff9ab9f838e7494fa43560ffa317fc0565d023ecceef184c02f762e215ba6451d3ec164e3c75a
+  metadata.gz: 67b6209ba61fbc285fc89dcf64adcde27cfecf44bb37d644cfb8aef50b7fca6e53a15e8eec5bc45030e4c838a35d3777c50a2d75fb32461792a1bc5957d7b2e3
+  data.tar.gz: c3e06e5140aac671ff8489243dee9feba3912ec12681332b2abb37ddd5c367246dc180ea80f6207afe28f81f499626f4dcf4b9628baa263854600d19d593f2f5

data/README.md

@@ -348,6 +348,16 @@ Find all the symbols for a file:
 puts client.document_symbols("file://path/to/my/file.rb")
 ```
 
+### Backtrace Filtering
+
+Spoom provides a backtrace filter for Minitest to remove the Sorbet frames from test failures, giving a more readable output. To enable it:
+
+```ruby
+# test/test_helper.rb
+require "spoom/backtrace_filter/minitest"
+Minitest.backtrace_filter = Spoom::BacktraceFilter::Minitest.new
+```
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment. Don't forget to run `bin/sanity` before pushing your changes.

data/lib/spoom/backtrace_filter/minitest.rb

@@ -0,0 +1,21 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "minitest"
+
+module Spoom
+  module BacktraceFilter
+    class Minitest < ::Minitest::BacktraceFilter
+      extend T::Sig
+
+      SORBET_PATHS = T.let(Gem.loaded_specs["sorbet-runtime"].full_require_paths.freeze, T::Array[String])
+
+      sig { override.params(bt: T.nilable(T::Array[String])).returns(T::Array[String]) }
+      def filter(bt)
+        super.select do |line|
+          SORBET_PATHS.none? { |path| line.include?(path) }
+        end
+      end
+    end
+  end
+end

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/erb.rb

@@ -44,7 +44,7 @@ module Spoom
 
       private
 
-      sig { params(text: T.untyped).void }
+      sig { override.params(text: T.untyped).void }
       def add_text(text)
         return if text.empty?
 
@@ -62,7 +62,7 @@ module Spoom
 
       BLOCK_EXPR = /\s*((\s+|\))do|\{)(\s*\|[^|]*\|)?\s*\Z/
 
-      sig { params(indicator: T.untyped, code: T.untyped).void }
+      sig { override.params(indicator: T.untyped, code: T.untyped).void }
       def add_expression(indicator, code)
         flush_newline_if_pending(src)
 
@@ -79,13 +79,13 @@ module Spoom
         end
       end
 
-      sig { params(code: T.untyped).void }
+      sig { override.params(code: T.untyped).void }
       def add_code(code)
         flush_newline_if_pending(src)
         super
       end
 
-      sig { params(_: T.untyped).void }
+      sig { override.params(_: T.untyped).void }
       def add_postamble(_)
         flush_newline_if_pending(src)
         super

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])
@@ -156,10 +157,10 @@ module Spoom
 
       sig { override.params(node: SyntaxTree::DefNode).void }
       def visit_def(node)
-        super
-
         name = node_string(node.name)
         define_method(name, [*@names_nesting, name].join("::"), node)
+
+        super
       end
 
       sig { override.params(node: SyntaxTree::Field).void }
@@ -228,6 +229,10 @@ module Spoom
             define_attr_writer("#{name}=", "#{full_name}=", arg)
           end
         else
+          @plugins.each do |plugin|
+            plugin.internal_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.internal_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.internal_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.internal_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.internal_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.internal_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.internal_on_define_module(self, definition) }
       end
 
       # Reference indexing
@@ -352,6 +361,74 @@ module Spoom
         @index.reference(Reference.new(name: name, kind: Reference::Kind::Method, location: node_location(node)))
       end
 
+      # Context
+
+      sig { returns(SyntaxTree::Node) }
+      def current_node
+        T.must(@nodes_nesting.last)
+      end
+
+      sig { type_parameters(:N).params(type: T::Class[T.type_parameter(:N)]).returns(T.nilable(T.type_parameter(:N))) }
+      def nesting_node(type)
+        @nodes_nesting.reverse_each do |node|
+          return T.unsafe(node) if node.is_a?(type)
+        end
+
+        nil
+      end
+
+      sig { returns(T.nilable(SyntaxTree::ClassDeclaration)) }
+      def nesting_class
+        nesting_node(SyntaxTree::ClassDeclaration)
+      end
+
+      sig { returns(T.nilable(SyntaxTree::BlockNode)) }
+      def nesting_block
+        nesting_node(SyntaxTree::BlockNode)
+      end
+
+      sig { returns(T.nilable(SyntaxTree::MethodAddBlock)) }
+      def nesting_block_call
+        nesting_node(SyntaxTree::MethodAddBlock)
+      end
+
+      sig { returns(T.nilable(String)) }
+      def nesting_block_call_name
+        block = nesting_block_call
+        return unless block.is_a?(SyntaxTree::MethodAddBlock)
+
+        call = block.call
+        case call
+        when SyntaxTree::ARef
+          node_string(call.collection)
+        when SyntaxTree::CallNode, SyntaxTree::Command, SyntaxTree::CommandCall
+          node_string(call.message)
+        end
+      end
+
+      sig { returns(T.nilable(String)) }
+      def nesting_class_name
+        nesting_class = self.nesting_class
+        return unless nesting_class
+
+        node_string(nesting_class.constant)
+      end
+
+      sig { returns(T.nilable(String)) }
+      def nesting_class_superclass_name
+        nesting_class_superclass = nesting_class&.superclass
+        return unless nesting_class_superclass
+
+        node_string(nesting_class_superclass).delete_prefix("::")
+      end
+
+      sig { returns(T.nilable(String)) }
+      def last_sig
+        return unless @previous_node.is_a?(SyntaxTree::MethodAddBlock)
+
+        node_string(@previous_node)
+      end
+
       # Node utils
 
       sig { params(node: T.any(Symbol, SyntaxTree::Node)).returns(String) }

data/lib/spoom/deadcode/location.rb

@@ -13,6 +13,23 @@ module Spoom
       class << self
         extend T::Sig
 
+        sig { params(location_string: String).returns(Location) }
+        def from_string(location_string)
+          file, rest = location_string.split(":", 2)
+          raise LocationError, "Invalid location string: #{location_string}" unless file && rest
+
+          start_line, rest = rest.split(":", 2)
+          raise LocationError, "Invalid location string: #{location_string}" unless start_line && rest
+
+          start_column, rest = rest.split("-", 2)
+          raise LocationError, "Invalid location string: #{location_string}" unless start_column && rest
+
+          end_line, end_column = rest.split(":", 2)
+          raise LocationError, "Invalid location string: #{location_string}" unless end_line && end_column
+
+          new(file, start_line.to_i, start_column.to_i, end_line.to_i, end_column.to_i)
+        end
+
         sig { params(file: String, location: SyntaxTree::Location).returns(Location) }
         def from_syntax_tree(file, location)
           new(file, location.start_line, location.start_column, location.end_line, location.end_column)
@@ -42,9 +59,20 @@ module Spoom
         @end_column = end_column
       end
 
+      sig { params(other: Location).returns(T::Boolean) }
+      def include?(other)
+        return false unless @file == other.file
+        return false if @start_line > other.start_line
+        return false if @start_line == other.start_line && @start_column > other.start_column
+        return false if @end_line < other.end_line
+        return false if @end_line == other.end_line && @end_column < other.end_column
+
+        true
+      end
+
       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/action_mailer.rb

@@ -0,0 +1,21 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Deadcode
+    module Plugins
+      class ActionMailer < Base
+        extend T::Sig
+
+        sig { override.params(indexer: Indexer, send: Send).void }
+        def on_send(indexer, send)
+          return unless send.recv.nil? && ActionPack::CALLBACKS.include?(send.name)
+
+          send.each_arg(SyntaxTree::SymbolLiteral) do |arg|
+            indexer.reference_method(indexer.node_string(arg.value), send.node)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Deadcode
+    module Plugins
+      class ActionPack < Base
+        extend T::Sig
+
+        CALLBACKS = T.let(
+          [
+            "after_action",
+            "append_after_action",
+            "append_around_action",
+            "append_before_action",
+            "around_action",
+            "before_action",
+            "prepend_after_action",
+            "prepend_around_action",
+            "prepend_before_action",
+            "skip_after_action",
+            "skip_around_action",
+            "skip_before_action",
+          ].freeze,
+          T::Array[String],
+        )
+
+        ignore_classes_named(/Controller$/)
+
+        sig { override.params(indexer: Indexer, definition: Definition).void }
+        def on_define_method(indexer, definition)
+          definition.ignored! if ignored_class_name?(indexer.nesting_class_name)
+        end
+
+        sig { override.params(indexer: Indexer, send: Send).void }
+        def on_send(indexer, send)
+          return unless send.recv.nil? && CALLBACKS.include?(send.name)
+
+          arg = send.args.first
+          case arg
+          when SyntaxTree::SymbolLiteral
+            indexer.reference_method(indexer.node_string(arg.value), send.node)
+          when SyntaxTree::VarRef
+            indexer.reference_constant(indexer.node_string(arg), send.node)
+          end
+
+          send.each_arg_assoc do |key, value|
+            key = indexer.node_string(key).delete_suffix(":")
+
+            case key
+            when "if", "unless"
+              indexer.reference_method(indexer.symbol_string(value), send.node) if value
+            else
+              indexer.reference_constant(camelize(key), send.node)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Deadcode
+    module Plugins
+      class ActiveJob < Base
+        ignore_classes_named("ApplicationJob")
+        ignore_methods_named("perform", "build_enumerator", "each_iteration")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Deadcode
+    module Plugins
+      class ActiveModel < Base
+        extend T::Sig
+
+        ignore_classes_inheriting_from(/^(::)?ActiveModel::EachValidator$/)
+        ignore_methods_named("validate_each")
+
+        sig { override.params(indexer: Indexer, send: Send).void }
+        def on_send(indexer, send)
+          return if send.recv
+
+          case send.name
+          when "attribute", "attributes"
+            send.each_arg(SyntaxTree::SymbolLiteral) do |arg|
+              indexer.reference_method(indexer.node_string(arg.value), send.node)
+            end
+          when "validate", "validates", "validates!", "validates_each"
+            send.each_arg(SyntaxTree::SymbolLiteral) do |arg|
+              indexer.reference_method(indexer.node_string(arg.value), send.node)
+            end
+            send.each_arg_assoc do |key, value|
+              key = indexer.node_string(key).delete_suffix(":")
+
+              case key
+              when "if", "unless"
+                indexer.reference_method(indexer.symbol_string(value), send.node) if value
+              else
+                indexer.reference_constant(camelize(key), send.node)
+              end
+            end
+          when "validates_with"
+            arg = send.args.first
+            if arg.is_a?(SyntaxTree::SymbolLiteral)
+              indexer.reference_constant(indexer.node_string(arg.value), send.node)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,111 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Deadcode
+    module Plugins
+      class ActiveRecord < Base
+        extend T::Sig
+
+        ignore_classes_inheriting_from(/^(::)?ActiveRecord::Migration/)
+
+        ignore_methods_named(
+          "change",
+          "down",
+          "up",
+          "table_name_prefix",
+          "to_param",
+        )
+
+        CALLBACKS = T.let(
+          [
+            "after_commit",
+            "after_create_commit",
+            "after_create",
+            "after_destroy_commit",
+            "after_destroy",
+            "after_find",
+            "after_initialize",
+            "after_rollback",
+            "after_save_commit",
+            "after_save",
+            "after_touch",
+            "after_update_commit",
+            "after_update",
+            "after_validation",
+            "around_create",
+            "around_destroy",
+            "around_save",
+            "around_update",
+            "before_create",
+            "before_destroy",
+            "before_save",
+            "before_update",
+            "before_validation",
+          ].freeze,
+          T::Array[String],
+        )
+
+        CRUD_METHODS = T.let(
+          [
+            "assign_attributes",
+            "create",
+            "create!",
+            "insert",
+            "insert!",
+            "new",
+            "update",
+            "update!",
+            "upsert",
+          ].freeze,
+          T::Array[String],
+        )
+
+        ARRAY_METHODS = T.let(
+          [
+            "insert_all",
+            "insert_all!",
+            "upsert_all",
+          ].freeze,
+          T::Array[String],
+        )
+
+        sig { override.params(indexer: Indexer, send: Send).void }
+        def on_send(indexer, send)
+          if send.recv.nil? && CALLBACKS.include?(send.name)
+            send.each_arg(SyntaxTree::SymbolLiteral) do |arg|
+              indexer.reference_method(indexer.node_string(arg.value), send.node)
+            end
+            return
+          end
+
+          return unless send.recv
+
+          case send.name
+          when *CRUD_METHODS
+            send.each_arg_assoc do |key, _value|
+              key = indexer.symbol_string(key).delete_suffix(":")
+              indexer.reference_method("#{key}=", send.node)
+            end
+          when *ARRAY_METHODS
+            send.each_arg(SyntaxTree::ArrayLiteral) do |arg|
+              args = arg.contents
+              next unless args.is_a?(SyntaxTree::Args)
+
+              args.parts.each do |part|
+                next unless part.is_a?(SyntaxTree::HashLiteral)
+
+                part.assocs.each do |assoc|
+                  next unless assoc.is_a?(SyntaxTree::Assoc)
+
+                  key = indexer.symbol_string(assoc.key).delete_suffix(":")
+                  indexer.reference_method("#{key}=", send.node)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Deadcode
+    module Plugins
+      class ActiveSupport < Base
+        ignore_classes_inheriting_from(/^(::)?ActiveSupport::TestCase$/)
+
+        ignore_methods_named(
+          "after_all",
+          "after_setup",
+          "after_teardown",
+          "before_all",
+          "before_setup",
+          "before_teardown",
+        )
+      end
+    end
+  end
+end