spoom 1.2.3 → 1.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e7ef8ebef70bc8827cdcb4b2c0e49ed6c53686e0db409908354f3762ad07c10
-  data.tar.gz: a6adb405f0379cbe040e743f177e758e2bdaadcdea13ee9c7f75d84f764434b1
+  metadata.gz: 23df97e815cc01b35dbc960ec1921bbc1c65ae4c6f0588c690a0d9156877a013
+  data.tar.gz: d82fdb3fb66404b0c2d98ea9206be9d86ec2284bbae2ff24a5653a521ec9155e
 SHA512:
-  metadata.gz: 86d74bc7d9554d67c1421908116bbab7615d77e9cb096d461f7885429d495f2b02f19d6024117f7083423cfe7c48165b18918c143f29574896bfbb76a4fb651f
-  data.tar.gz: 754d41e8f26425a42288388879fe1658214adea03002421495297486343a827d6dc79a395e895553ed15f67cdc766a16f4a174aab2a3671bd2455e305a8c6f13
+  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/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

@@ -157,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 }
@@ -230,7 +230,7 @@ module Spoom
           end
         else
           @plugins.each do |plugin|
-            plugin.on_send(self, send)
+            plugin.internal_on_send(self, send)
           end
 
           reference_method(send.name, send.node)
@@ -286,7 +286,7 @@ module Spoom
           location: node_location(node),
         )
         @index.define(definition)
-        @plugins.each { |plugin| plugin.on_define_accessor(self, definition) }
+        @plugins.each { |plugin| plugin.internal_on_define_accessor(self, definition) }
       end
 
       sig { params(name: String, full_name: String, node: SyntaxTree::Node).void }
@@ -298,7 +298,7 @@ module Spoom
           location: node_location(node),
         )
         @index.define(definition)
-        @plugins.each { |plugin| plugin.on_define_accessor(self, definition) }
+        @plugins.each { |plugin| plugin.internal_on_define_accessor(self, definition) }
       end
 
       sig { params(name: String, full_name: String, node: SyntaxTree::Node).void }
@@ -310,7 +310,7 @@ module Spoom
           location: node_location(node),
         )
         @index.define(definition)
-        @plugins.each { |plugin| plugin.on_define_class(self, definition) }
+        @plugins.each { |plugin| plugin.internal_on_define_class(self, definition) }
       end
 
       sig { params(name: String, full_name: String, node: SyntaxTree::Node).void }
@@ -322,7 +322,7 @@ module Spoom
           location: node_location(node),
         )
         @index.define(definition)
-        @plugins.each { |plugin| plugin.on_define_constant(self, definition) }
+        @plugins.each { |plugin| plugin.internal_on_define_constant(self, definition) }
       end
 
       sig { params(name: String, full_name: String, node: SyntaxTree::Node).void }
@@ -334,7 +334,7 @@ module Spoom
           location: node_location(node),
         )
         @index.define(definition)
-        @plugins.each { |plugin| plugin.on_define_method(self, definition) }
+        @plugins.each { |plugin| plugin.internal_on_define_method(self, definition) }
       end
 
       sig { params(name: String, full_name: String, node: SyntaxTree::Node).void }
@@ -346,7 +346,7 @@ module Spoom
           location: node_location(node),
         )
         @index.define(definition)
-        @plugins.each { |plugin| plugin.on_define_module(self, definition) }
+        @plugins.each { |plugin| plugin.internal_on_define_module(self, definition) }
       end
 
       # Reference indexing
@@ -361,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,6 +59,17 @@ 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 unless Location === other

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