ruby-lsp 0.12.2 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f60569fbb67f1c78fcffed58dbf540cb4e68fe10200841e54cd8a68859cf0de
-  data.tar.gz: 07c4419c763e590e1fbed7fe14a2660c1bf6ddbd92ca791948a8c2235208f6e9
+  metadata.gz: d6bace664e1540c1333df9dabfb2e7bdd8bda0f910033b47b188e4a82ddacb15
+  data.tar.gz: be9e5da0492b26b5cb6e07074d01d7874104b70286c1578342b9639158fed147
 SHA512:
-  metadata.gz: 5284be197a27351a845cbcfc1735a0e9546472d60f9600ffd4ee55ba3ab0998438110c1ec59f684e0cf2fbaa7ff99f89878919ae3954022372e50116182c59dd
-  data.tar.gz: f706c17b0cd47c1001bffb42f6c9a1c43efbd390e548ffe7b51fb3c58bdb433c868a7f907a3aa32175d7742ccbb3c1c29606a0c7c979246bfe887500e6531676
+  metadata.gz: 7d8e61433686271a68dafe8db79765ed509a115ab6f06060d7669d279f48218fe2eada2c12e3b45f155d27a41774771681cdab92700d27f426e75ed89287ca03
+  data.tar.gz: 611c050b751050934d0fd93e9e52089fe63fc4d947be75a440dfa0465933814d2682268a10135d036c2cee83fa739156d2b11e42e679ecbed7de62acfee9d621

data/README.md

@@ -52,6 +52,7 @@ The Ruby LSP provides an addon system that allows other gems to enhance the base
 features. This is the mechanism that powers addons like
 
 - [Ruby LSP Rails](https://github.com/Shopify/ruby-lsp-rails)
+- [Ruby LSP RSpec](https://github.com/st0012/ruby-lsp-rspec)
 
 For instructions on how to create addons, see the [addons documentation](ADDONS.md).
 

data/VERSION

@@ -1 +1 @@
-0.12.2
+0.13.0

data/exe/ruby-lsp-check

@@ -17,8 +17,6 @@ end
 $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
 require "ruby_lsp/internal"
 
-RubyLsp::Addon.load_addons
-
 T::Utils.run_all_sig_blocks
 
 files = Dir.glob("#{Dir.pwd}/**/*.rb")
@@ -28,6 +26,7 @@ puts "Verifying that all automatic LSP requests execute successfully. This may t
 errors = {}
 store = RubyLsp::Store.new
 message_queue = Thread::Queue.new
+RubyLsp::Addon.load_addons(message_queue)
 executor = RubyLsp::Executor.new(store, message_queue)
 
 files.each_with_index do |file, index|
@@ -50,13 +49,30 @@ end
 puts "\n"
 message_queue.close
 
+# Indexing
+puts "Verifying that indexing executes successfully. This may take a while..."
+
+index = RubyIndexer::Index.new
+indexables = RubyIndexer.configuration.indexables
+
+indexables.each_with_index do |indexable, i|
+  result = Prism.parse(File.read(indexable.full_path))
+  collector = RubyIndexer::Collector.new(index, result, indexable.full_path)
+  collector.collect(result.value)
+rescue => e
+  errors[indexable.full_path] = e
+ensure
+  print("\033[M\033[0KIndexed #{i + 1}/#{indexables.length}") unless ENV["CI"]
+end
+puts "\n"
+
 if errors.empty?
-  puts "All automatic LSP requests executed successfully"
+  puts "All operations completed successfully!"
   exit
 end
 
 puts <<~ERRORS
-  Errors while executing requests:
+  Errors while executing:
 
   #{errors.map { |file, error| "#{file}: #{error.message}" }.join("\n")}
 ERRORS

data/exe/ruby-lsp-doctor

@@ -10,6 +10,6 @@ RubyIndexer.configuration.indexables.each do |indexable|
   puts "indexing: #{indexable.full_path}"
   content = File.read(indexable.full_path)
   result = Prism.parse(content)
-  visitor = RubyIndexer::IndexVisitor.new(index, result, indexable.full_path)
-  result.value.accept(visitor)
+  collector = RubyIndexer::Collector.new(index, result, indexable.full_path)
+  collector.collect(result.value)
 end

data/lib/ruby_indexer/lib/ruby_indexer/{visitor.rb → collector.rb}

@@ -2,9 +2,11 @@
 # frozen_string_literal: true
 
 module RubyIndexer
-  class IndexVisitor < Prism::Visitor
+  class Collector
     extend T::Sig
 
+    LEAVE_EVENT = T.let(Object.new.freeze, Object)
+
     sig { params(index: Index, parse_result: Prism::ParseResult, file_path: String).void }
     def initialize(index, parse_result, file_path)
       @index = index
@@ -16,26 +18,67 @@ module RubyIndexer
         end,
         T::Hash[Integer, Prism::Comment],
       )
+      @queue = T.let([], T::Array[Object])
+      @current_owner = T.let(nil, T.nilable(Entry::Namespace))
 
       super()
     end
 
-    sig { override.params(node: Prism::ClassNode).void }
-    def visit_class_node(node)
-      add_class_entry(node)
+    sig { params(node: Prism::Node).void }
+    def collect(node)
+      @queue = [node]
+
+      until @queue.empty?
+        node_or_event = @queue.shift
+
+        case node_or_event
+        when Prism::ProgramNode
+          @queue << node_or_event.statements
+        when Prism::StatementsNode
+          T.unsafe(@queue).prepend(*node_or_event.body)
+        when Prism::ClassNode
+          add_class_entry(node_or_event)
+        when Prism::ModuleNode
+          add_module_entry(node_or_event)
+        when Prism::MultiWriteNode
+          handle_multi_write_node(node_or_event)
+        when Prism::ConstantPathWriteNode
+          handle_constant_path_write_node(node_or_event)
+        when Prism::ConstantPathOrWriteNode
+          handle_constant_path_or_write_node(node_or_event)
+        when Prism::ConstantPathOperatorWriteNode
+          handle_constant_path_operator_write_node(node_or_event)
+        when Prism::ConstantPathAndWriteNode
+          handle_constant_path_and_write_node(node_or_event)
+        when Prism::ConstantWriteNode
+          handle_constant_write_node(node_or_event)
+        when Prism::ConstantOrWriteNode
+          name = fully_qualify_name(node_or_event.name.to_s)
+          add_constant(node_or_event, name)
+        when Prism::ConstantAndWriteNode
+          name = fully_qualify_name(node_or_event.name.to_s)
+          add_constant(node_or_event, name)
+        when Prism::ConstantOperatorWriteNode
+          name = fully_qualify_name(node_or_event.name.to_s)
+          add_constant(node_or_event, name)
+        when Prism::CallNode
+          handle_call_node(node_or_event)
+        when Prism::DefNode
+          handle_def_node(node_or_event)
+        when LEAVE_EVENT
+          @stack.pop
+        end
+      end
     end
 
-    sig { override.params(node: Prism::ModuleNode).void }
-    def visit_module_node(node)
-      add_module_entry(node)
-    end
+    private
 
-    sig { override.params(node: Prism::MultiWriteNode).void }
-    def visit_multi_write_node(node)
+    sig { params(node: Prism::MultiWriteNode).void }
+    def handle_multi_write_node(node)
       value = node.value
       values = value.is_a?(Prism::ArrayNode) && value.opening_loc ? value.elements : []
 
-      node.targets.each_with_index do |target, i|
+      [*node.lefts, *node.rest, *node.rights].each_with_index do |target, i|
         current_value = values[i]
         # The moment we find a splat on the right hand side of the assignment, we can no longer figure out which value
         # gets assigned to what
@@ -50,8 +93,8 @@ module RubyIndexer
       end
     end
 
-    sig { override.params(node: Prism::ConstantPathWriteNode).void }
-    def visit_constant_path_write_node(node)
+    sig { params(node: Prism::ConstantPathWriteNode).void }
+    def handle_constant_path_write_node(node)
       # ignore variable constants like `var::FOO` or `self.class::FOO`
       target = node.target
       return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
@@ -60,8 +103,8 @@ module RubyIndexer
       add_constant(node, name)
     end
 
-    sig { override.params(node: Prism::ConstantPathOrWriteNode).void }
-    def visit_constant_path_or_write_node(node)
+    sig { params(node: Prism::ConstantPathOrWriteNode).void }
+    def handle_constant_path_or_write_node(node)
       # ignore variable constants like `var::FOO` or `self.class::FOO`
       target = node.target
       return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
@@ -70,8 +113,8 @@ module RubyIndexer
       add_constant(node, name)
     end
 
-    sig { override.params(node: Prism::ConstantPathOperatorWriteNode).void }
-    def visit_constant_path_operator_write_node(node)
+    sig { params(node: Prism::ConstantPathOperatorWriteNode).void }
+    def handle_constant_path_operator_write_node(node)
       # ignore variable constants like `var::FOO` or `self.class::FOO`
       target = node.target
       return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
@@ -80,8 +123,8 @@ module RubyIndexer
       add_constant(node, name)
     end
 
-    sig { override.params(node: Prism::ConstantPathAndWriteNode).void }
-    def visit_constant_path_and_write_node(node)
+    sig { params(node: Prism::ConstantPathAndWriteNode).void }
+    def handle_constant_path_and_write_node(node)
       # ignore variable constants like `var::FOO` or `self.class::FOO`
       target = node.target
       return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
@@ -90,50 +133,54 @@ module RubyIndexer
       add_constant(node, name)
     end
 
-    sig { override.params(node: Prism::ConstantWriteNode).void }
-    def visit_constant_write_node(node)
+    sig { params(node: Prism::ConstantWriteNode).void }
+    def handle_constant_write_node(node)
       name = fully_qualify_name(node.name.to_s)
       add_constant(node, name)
     end
 
-    sig { override.params(node: Prism::ConstantOrWriteNode).void }
-    def visit_constant_or_write_node(node)
-      name = fully_qualify_name(node.name.to_s)
-      add_constant(node, name)
-    end
-
-    sig { override.params(node: Prism::ConstantAndWriteNode).void }
-    def visit_constant_and_write_node(node)
-      name = fully_qualify_name(node.name.to_s)
-      add_constant(node, name)
-    end
-
-    sig { override.params(node: Prism::ConstantOperatorWriteNode).void }
-    def visit_constant_operator_write_node(node)
-      name = fully_qualify_name(node.name.to_s)
-      add_constant(node, name)
-    end
-
-    sig { override.params(node: Prism::CallNode).void }
-    def visit_call_node(node)
-      message = node.message
-      handle_private_constant(node) if message == "private_constant"
+    sig { params(node: Prism::CallNode).void }
+    def handle_call_node(node)
+      message = node.name
+
+      case message
+      when :private_constant
+        handle_private_constant(node)
+      when :attr_reader
+        handle_attribute(node, reader: true, writer: false)
+      when :attr_writer
+        handle_attribute(node, reader: false, writer: true)
+      when :attr_accessor
+        handle_attribute(node, reader: true, writer: true)
+      end
     end
 
-    sig { override.params(node: Prism::DefNode).void }
-    def visit_def_node(node)
+    sig { params(node: Prism::DefNode).void }
+    def handle_def_node(node)
       method_name = node.name.to_s
       comments = collect_comments(node)
       case node.receiver
       when nil
-        @index << Entry::InstanceMethod.new(method_name, @file_path, node.location, comments, node.parameters)
+        @index << Entry::InstanceMethod.new(
+          method_name,
+          @file_path,
+          node.location,
+          comments,
+          node.parameters,
+          @current_owner,
+        )
       when Prism::SelfNode
-        @index << Entry::SingletonMethod.new(method_name, @file_path, node.location, comments, node.parameters)
+        @index << Entry::SingletonMethod.new(
+          method_name,
+          @file_path,
+          node.location,
+          comments,
+          node.parameters,
+          @current_owner,
+        )
       end
     end
 
-    private
-
     sig { params(node: Prism::CallNode).void }
     def handle_private_constant(node)
       arguments = node.arguments&.arguments
@@ -189,12 +236,12 @@ module RubyIndexer
 
         # If the right hand side is another constant assignment, we need to visit it because that constant has to be
         # indexed too
-        visit(value)
+        @queue.prepend(value)
         Entry::UnresolvedAlias.new(value.name.to_s, @stack.dup, name, @file_path, node.location, comments)
       when Prism::ConstantPathWriteNode, Prism::ConstantPathOrWriteNode, Prism::ConstantPathOperatorWriteNode,
         Prism::ConstantPathAndWriteNode
 
-        visit(value)
+        @queue.prepend(value)
         Entry::UnresolvedAlias.new(value.target.slice, @stack.dup, name, @file_path, node.location, comments)
       else
         Entry::Constant.new(name, @file_path, node.location, comments)
@@ -204,20 +251,26 @@ module RubyIndexer
     sig { params(node: Prism::ModuleNode).void }
     def add_module_entry(node)
       name = node.constant_path.location.slice
-      return visit_child_nodes(node) unless /^[A-Z:]/.match?(name)
+      unless /^[A-Z:]/.match?(name)
+        @queue << node.body
+        return
+      end
 
       comments = collect_comments(node)
-
-      @index << Entry::Module.new(fully_qualify_name(name), @file_path, node.location, comments)
+      @current_owner = Entry::Module.new(fully_qualify_name(name), @file_path, node.location, comments)
+      @index << @current_owner
       @stack << name
-      visit_child_nodes(node)
-      @stack.pop
+      @queue.prepend(node.body, LEAVE_EVENT)
     end
 
     sig { params(node: Prism::ClassNode).void }
     def add_class_entry(node)
       name = node.constant_path.location.slice
-      return visit_child_nodes(node) unless /^[A-Z:]/.match?(name)
+
+      unless /^[A-Z:]/.match?(name)
+        @queue << node.body
+        return
+      end
 
       comments = collect_comments(node)
 
@@ -227,10 +280,16 @@ module RubyIndexer
         superclass.slice
       end
 
-      @index << Entry::Class.new(fully_qualify_name(name), @file_path, node.location, comments, parent_class)
+      @current_owner = Entry::Class.new(
+        fully_qualify_name(name),
+        @file_path,
+        node.location,
+        comments,
+        parent_class,
+      )
+      @index << @current_owner
       @stack << name
-      visit(node.body)
-      @stack.pop
+      @queue.prepend(node.body, LEAVE_EVENT)
     end
 
     sig { params(node: Prism::Node).returns(T::Array[String]) }
@@ -249,7 +308,7 @@ module RubyIndexer
 
         comment_content.delete_prefix!("#")
         comment_content.delete_prefix!(" ")
-        comments.unshift(comment_content)
+        comments.prepend(comment_content)
       end
 
       comments
@@ -263,5 +322,29 @@ module RubyIndexer
         "#{@stack.join("::")}::#{name}"
       end.delete_prefix("::")
     end
+
+    sig { params(node: Prism::CallNode, reader: T::Boolean, writer: T::Boolean).void }
+    def handle_attribute(node, reader:, writer:)
+      arguments = node.arguments&.arguments
+      return unless arguments
+
+      receiver = node.receiver
+      return unless receiver.nil? || receiver.is_a?(Prism::SelfNode)
+
+      comments = collect_comments(node)
+      arguments.each do |argument|
+        name, loc = case argument
+        when Prism::SymbolNode
+          [argument.value, argument.value_loc]
+        when Prism::StringNode
+          [argument.content, argument.content_loc]
+        end
+
+        next unless name && loc
+
+        @index << Entry::Accessor.new(name, @file_path, loc, comments, @current_owner) if reader
+        @index << Entry::Accessor.new("#{name}=", @file_path, loc, comments, @current_owner) if writer
+      end
+    end
   end
 end

data/lib/ruby_indexer/lib/ruby_indexer/configuration.rb

@@ -71,8 +71,13 @@ module RubyIndexer
 
         Dir.glob(pattern, File::FNM_PATHNAME | File::FNM_EXTGLOB).map! do |path|
           # All entries for the same pattern match the same $LOAD_PATH entry. Since searching the $LOAD_PATH for every
-          # entry is expensive, we memoize it for the entire pattern
-          load_path_entry ||= $LOAD_PATH.find { |load_path| path.start_with?(load_path) }
+          # entry is expensive, we memoize it until we find a path that doesn't belong to that $LOAD_PATH. This happens
+          # on repositories that define multiple gems, like Rails. All frameworks are defined inside the Dir.pwd, but
+          # each one of them belongs to a different $LOAD_PATH entry
+          if load_path_entry.nil? || !path.start_with?(load_path_entry)
+            load_path_entry = $LOAD_PATH.find { |load_path| path.start_with?(load_path) }
+          end
+
           IndexablePath.new(load_path_entry, path)
         end
       end
@@ -115,7 +120,7 @@ module RubyIndexer
               IndexablePath.new(RbConfig::CONFIG["rubylibdir"], path)
             end,
           )
-        else
+        elsif pathname.extname == ".rb"
           # If the default_path is a Ruby file, we index it
           indexables << IndexablePath.new(RbConfig::CONFIG["rubylibdir"], default_path)
         end
@@ -144,7 +149,7 @@ module RubyIndexer
         # just ignore if they're missing
       end
 
-      indexables.uniq!
+      indexables.uniq!(&:full_path)
       indexables
     end
 

data/lib/ruby_indexer/lib/ruby_indexer/entry.rb

@@ -90,15 +90,67 @@ module RubyIndexer
       end
     end
 
+    # A required method parameter, e.g. `def foo(a)`
     class RequiredParameter < Parameter
     end
 
-    class Method < Entry
+    # An optional method parameter, e.g. `def foo(a = 123)`
+    class OptionalParameter < Parameter
+    end
+
+    # An required keyword method parameter, e.g. `def foo(a:)`
+    class KeywordParameter < Parameter
+    end
+
+    # An optional keyword method parameter, e.g. `def foo(a: 123)`
+    class OptionalKeywordParameter < Parameter
+    end
+
+    class Member < Entry
+      extend T::Sig
+      extend T::Helpers
+
+      abstract!
+
+      sig { returns(T.nilable(Entry::Namespace)) }
+      attr_reader :owner
+
+      sig do
+        params(
+          name: String,
+          file_path: String,
+          location: Prism::Location,
+          comments: T::Array[String],
+          owner: T.nilable(Entry::Namespace),
+        ).void
+      end
+      def initialize(name, file_path, location, comments, owner)
+        super(name, file_path, location, comments)
+        @owner = owner
+      end
+
+      sig { abstract.returns(T::Array[Parameter]) }
+      def parameters; end
+    end
+
+    class Accessor < Member
+      extend T::Sig
+
+      sig { override.returns(T::Array[Parameter]) }
+      def parameters
+        params = []
+        params << RequiredParameter.new(name: name.delete_suffix("=").to_sym) if name.end_with?("=")
+        params
+      end
+    end
+
+    class Method < Member
       extend T::Sig
       extend T::Helpers
+
       abstract!
 
-      sig { returns(T::Array[Parameter]) }
+      sig { override.returns(T::Array[Parameter]) }
       attr_reader :parameters
 
       sig do
@@ -108,10 +160,12 @@ module RubyIndexer
           location: Prism::Location,
           comments: T::Array[String],
           parameters_node: T.nilable(Prism::ParametersNode),
+          owner: T.nilable(Entry::Namespace),
         ).void
       end
-      def initialize(name, file_path, location, comments, parameters_node)
-        super(name, file_path, location, comments)
+      def initialize(name, file_path, location, comments, parameters_node, owner) # rubocop:disable Metrics/ParameterLists
+        super(name, file_path, location, comments, owner)
+
         @parameters = T.let(list_params(parameters_node), T::Array[Parameter])
       end
 
@@ -121,23 +175,46 @@ module RubyIndexer
       def list_params(parameters_node)
         return [] unless parameters_node
 
-        parameters_node.requireds.filter_map do |required|
+        parameters = []
+
+        parameters_node.requireds.each do |required|
           name = parameter_name(required)
           next unless name
 
-          RequiredParameter.new(name: name)
+          parameters << RequiredParameter.new(name: name)
         end
-      end
 
-      sig do
-        params(node: Prism::Node).returns(T.nilable(Symbol))
+        parameters_node.optionals.each do |optional|
+          name = parameter_name(optional)
+          next unless name
+
+          parameters << OptionalParameter.new(name: name)
+        end
+
+        parameters_node.keywords.each do |keyword|
+          name = parameter_name(keyword)
+          next unless name
+
+          case keyword
+          when Prism::RequiredKeywordParameterNode
+            parameters << KeywordParameter.new(name: name)
+          when Prism::OptionalKeywordParameterNode
+            parameters << OptionalKeywordParameter.new(name: name)
+          end
+        end
+
+        parameters
       end
+
+      sig { params(node: Prism::Node).returns(T.nilable(Symbol)) }
       def parameter_name(node)
         case node
-        when Prism::RequiredParameterNode
+        when Prism::RequiredParameterNode, Prism::OptionalParameterNode,
+          Prism::RequiredKeywordParameterNode, Prism::OptionalKeywordParameterNode
           node.name
-        when Prism::RequiredDestructuredParameterNode
-          names = node.parameters.map { |parameter_node| parameter_name(parameter_node) }
+        when Prism::MultiTargetNode
+          names = [*node.lefts, *node.rest, *node.rights].map { |parameter_node| parameter_name(parameter_node) }
+
           names_with_commas = names.join(", ")
           :"(#{names_with_commas})"
         end

data/lib/ruby_indexer/lib/ruby_indexer/index.rb

@@ -93,8 +93,14 @@ module RubyIndexer
     #   [#<Entry::Class name="Foo::Baz">],
     # ]
     # ```
-    sig { params(query: String, nesting: T::Array[String]).returns(T::Array[T::Array[Entry]]) }
-    def prefix_search(query, nesting)
+    sig { params(query: String, nesting: T.nilable(T::Array[String])).returns(T::Array[T::Array[Entry]]) }
+    def prefix_search(query, nesting = nil)
+      unless nesting
+        results = @entries_tree.search(query)
+        results.uniq!
+        return results
+      end
+
       results = nesting.length.downto(0).flat_map do |i|
         prefix = T.must(nesting[0...i]).join("::")
         namespaced_query = prefix.empty? ? query : "#{prefix}::#{query}"
@@ -180,8 +186,8 @@ module RubyIndexer
     def index_single(indexable_path, source = nil)
       content = source || File.read(indexable_path.full_path)
       result = Prism.parse(content)
-      visitor = IndexVisitor.new(self, result, indexable_path.full_path)
-      result.value.accept(visitor)
+      collector = Collector.new(self, result, indexable_path.full_path)
+      collector.collect(result.value)
 
       require_path = indexable_path.require_path
       @require_paths_tree.insert(require_path, indexable_path) if require_path
@@ -231,6 +237,18 @@ module RubyIndexer
       real_parts.join("::")
     end
 
+    # Attempts to find a given method for a resolved fully qualified receiver name. Returns `nil` if the method does not
+    # exist on that receiver
+    sig { params(method_name: String, receiver_name: String).returns(T.nilable(Entry::Method)) }
+    def resolve_method(method_name, receiver_name)
+      method_entries = T.cast(self[method_name], T.nilable(T::Array[Entry::Method]))
+      owner_entries = self[receiver_name]
+      return unless owner_entries && method_entries
+
+      owner_name = T.must(owner_entries.first).name
+      method_entries.find { |entry| entry.owner&.name == owner_name }
+    end
+
     private
 
     # Attempts to resolve an UnresolvedAlias into a resolved Alias. If the unresolved alias is pointing to a constant

data/lib/ruby_indexer/ruby_indexer.rb

@@ -5,7 +5,7 @@ require "yaml"
 require "did_you_mean"
 
 require "ruby_indexer/lib/ruby_indexer/indexable_path"
-require "ruby_indexer/lib/ruby_indexer/visitor"
+require "ruby_indexer/lib/ruby_indexer/collector"
 require "ruby_indexer/lib/ruby_indexer/index"
 require "ruby_indexer/lib/ruby_indexer/entry"
 require "ruby_indexer/lib/ruby_indexer/configuration"

data/lib/ruby_indexer/test/configuration_test.rb

@@ -84,6 +84,16 @@ module RubyIndexer
       )
     end
 
+    def test_indexables_does_not_include_non_ruby_files_inside_rubylibdir
+      path = Pathname.new(RbConfig::CONFIG["rubylibdir"]).join("extra_file.txt").to_s
+      FileUtils.touch(path)
+      indexables = @config.indexables
+
+      assert(indexables.none? { |indexable| indexable.full_path == path })
+    ensure
+      FileUtils.rm(T.must(path))
+    end
+
     def test_paths_are_unique
       @config.load_config
       indexables = @config.indexables