study_line 0.1.6 → 0.2.1

data/vendor/bundle/ruby/3.2.0/gems/ruby-lsp-0.12.1/lib/ruby_lsp/requests/support/syntax_tree_formatting_runner.rb

@@ -1,50 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-begin
-  require "syntax_tree"
-  require "syntax_tree/cli"
-rescue LoadError
-  return
-end
-
-require "singleton"
-
-module RubyLsp
-  module Requests
-    module Support
-      # :nodoc:
-      class SyntaxTreeFormattingRunner
-        extend T::Sig
-        include Singleton
-        include Support::FormatterRunner
-
-        sig { void }
-        def initialize
-          @options =
-            T.let(
-              begin
-                opts = SyntaxTree::CLI::Options.new
-                opts.parse(SyntaxTree::CLI::ConfigFile.new.arguments)
-                opts
-              end,
-              SyntaxTree::CLI::Options,
-            )
-        end
-
-        sig { override.params(uri: URI::Generic, document: Document).returns(T.nilable(String)) }
-        def run(uri, document)
-          relative_path = Pathname.new(T.must(uri.to_standardized_path || uri.opaque))
-            .relative_path_from(T.must(WORKSPACE_URI.to_standardized_path))
-          return if @options.ignore_files.any? { |pattern| File.fnmatch(pattern, relative_path) }
-
-          SyntaxTree.format(
-            document.source,
-            @options.print_width,
-            options: @options.formatter_options,
-          )
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/ruby-lsp-0.12.1/lib/ruby_lsp/requests/workspace_symbol.rb

@@ -1,89 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module RubyLsp
-  module Requests
-    # ![Workspace symbol demo](../../workspace_symbol.gif)
-    #
-    # The [workspace symbol](https://microsoft.github.io/language-server-protocol/specification#workspace_symbol)
-    # request allows fuzzy searching declarations in the entire project. On VS Code, use CTRL/CMD + T to search for
-    # symbols.
-    #
-    # # Example
-    #
-    # ```ruby
-    # # Searching for `Floo` will fuzzy match and return all declarations according to the query, including this `Foo`
-    # class
-    # class Foo
-    # end
-    # ```
-    #
-    class WorkspaceSymbol
-      extend T::Sig
-
-      sig { params(query: T.nilable(String), index: RubyIndexer::Index).void }
-      def initialize(query, index)
-        @query = query
-        @index = index
-      end
-
-      sig { returns(T::Array[Interface::WorkspaceSymbol]) }
-      def run
-        bundle_path = begin
-          Bundler.bundle_path.to_s
-        rescue Bundler::GemfileNotFound
-          nil
-        end
-
-        @index.fuzzy_search(@query).filter_map do |entry|
-          # If the project is using Sorbet, we let Sorbet handle symbols defined inside the project itself and RBIs, but
-          # we still return entries defined in gems to allow developers to jump directly to the source
-          file_path = entry.file_path
-          if DependencyDetector.instance.typechecker && bundle_path && !file_path.start_with?(bundle_path) &&
-              !file_path.start_with?(RbConfig::CONFIG["rubylibdir"])
-
-            next
-          end
-
-          # We should never show private symbols when searching the entire workspace
-          next if entry.visibility == :private
-
-          kind = kind_for_entry(entry)
-          loc = entry.location
-
-          # We use the namespace as the container name, but we also use the full name as the regular name. The reason we
-          # do this is to allow people to search for fully qualified names (e.g.: `Foo::Bar`). If we only included the
-          # short name `Bar`, then searching for `Foo::Bar` would not return any results
-          *container, _short_name = entry.name.split("::")
-
-          Interface::WorkspaceSymbol.new(
-            name: entry.name,
-            container_name: T.must(container).join("::"),
-            kind: kind,
-            location: Interface::Location.new(
-              uri: URI::Generic.from_path(path: file_path).to_s,
-              range:  Interface::Range.new(
-                start: Interface::Position.new(line: loc.start_line - 1, character: loc.start_column),
-                end: Interface::Position.new(line: loc.end_line - 1, character: loc.end_column),
-              ),
-            ),
-          )
-        end
-      end
-
-      private
-
-      sig { params(entry: RubyIndexer::Entry).returns(T.nilable(Integer)) }
-      def kind_for_entry(entry)
-        case entry
-        when RubyIndexer::Entry::Class
-          Constant::SymbolKind::CLASS
-        when RubyIndexer::Entry::Module
-          Constant::SymbolKind::NAMESPACE
-        when RubyIndexer::Entry::Constant
-          Constant::SymbolKind::CONSTANT
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/ruby-lsp-0.12.1/lib/ruby_lsp/requests.rb

@@ -1,59 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module RubyLsp
-  # Supported features
-  #
-  # - [DocumentSymbol](rdoc-ref:RubyLsp::Requests::DocumentSymbol)
-  # - [DocumentLink](rdoc-ref:RubyLsp::Requests::DocumentLink)
-  # - [Hover](rdoc-ref:RubyLsp::Requests::Hover)
-  # - [FoldingRange](rdoc-ref:RubyLsp::Requests::FoldingRanges)
-  # - [SelectionRange](rdoc-ref:RubyLsp::Requests::SelectionRanges)
-  # - [SemanticHighlighting](rdoc-ref:RubyLsp::Requests::SemanticHighlighting)
-  # - [Formatting](rdoc-ref:RubyLsp::Requests::Formatting)
-  # - [OnTypeFormatting](rdoc-ref:RubyLsp::Requests::OnTypeFormatting)
-  # - [Diagnostic](rdoc-ref:RubyLsp::Requests::Diagnostics)
-  # - [CodeAction](rdoc-ref:RubyLsp::Requests::CodeActions)
-  # - [CodeActionResolve](rdoc-ref:RubyLsp::Requests::CodeActionResolve)
-  # - [DocumentHighlight](rdoc-ref:RubyLsp::Requests::DocumentHighlight)
-  # - [InlayHint](rdoc-ref:RubyLsp::Requests::InlayHints)
-  # - [Completion](rdoc-ref:RubyLsp::Requests::Completion)
-  # - [CodeLens](rdoc-ref:RubyLsp::Requests::CodeLens)
-  # - [Definition](rdoc-ref:RubyLsp::Requests::Definition)
-  # - [ShowSyntaxTree](rdoc-ref:RubyLsp::Requests::ShowSyntaxTree)
-  # - [WorkspaceSymbol](rdoc-ref:RubyLsp::Requests::WorkspaceSymbol)
-
-  module Requests
-    autoload :BaseRequest, "ruby_lsp/requests/base_request"
-    autoload :DocumentSymbol, "ruby_lsp/requests/document_symbol"
-    autoload :DocumentLink, "ruby_lsp/requests/document_link"
-    autoload :Hover, "ruby_lsp/requests/hover"
-    autoload :FoldingRanges, "ruby_lsp/requests/folding_ranges"
-    autoload :SelectionRanges, "ruby_lsp/requests/selection_ranges"
-    autoload :SemanticHighlighting, "ruby_lsp/requests/semantic_highlighting"
-    autoload :Formatting, "ruby_lsp/requests/formatting"
-    autoload :OnTypeFormatting, "ruby_lsp/requests/on_type_formatting"
-    autoload :Diagnostics, "ruby_lsp/requests/diagnostics"
-    autoload :CodeActions, "ruby_lsp/requests/code_actions"
-    autoload :CodeActionResolve, "ruby_lsp/requests/code_action_resolve"
-    autoload :DocumentHighlight, "ruby_lsp/requests/document_highlight"
-    autoload :InlayHints, "ruby_lsp/requests/inlay_hints"
-    autoload :Completion, "ruby_lsp/requests/completion"
-    autoload :CodeLens, "ruby_lsp/requests/code_lens"
-    autoload :Definition, "ruby_lsp/requests/definition"
-    autoload :ShowSyntaxTree, "ruby_lsp/requests/show_syntax_tree"
-    autoload :WorkspaceSymbol, "ruby_lsp/requests/workspace_symbol"
-
-    # :nodoc:
-    module Support
-      autoload :RuboCopDiagnostic, "ruby_lsp/requests/support/rubocop_diagnostic"
-      autoload :SelectionRange, "ruby_lsp/requests/support/selection_range"
-      autoload :SemanticTokenEncoder, "ruby_lsp/requests/support/semantic_token_encoder"
-      autoload :Annotation, "ruby_lsp/requests/support/annotation"
-      autoload :Sorbet, "ruby_lsp/requests/support/sorbet"
-      autoload :RailsDocumentClient, "ruby_lsp/requests/support/rails_document_client"
-      autoload :Common, "ruby_lsp/requests/support/common"
-      autoload :FormatterRunner, "ruby_lsp/requests/support/formatter_runner"
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/ruby-lsp-0.12.1/lib/ruby_lsp/server.rb

@@ -1,169 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module RubyLsp
-  # rubocop:disable RubyLsp/UseLanguageServerAliases
-  Interface = LanguageServer::Protocol::Interface
-  Constant = LanguageServer::Protocol::Constant
-  Transport = LanguageServer::Protocol::Transport
-  # rubocop:enable RubyLsp/UseLanguageServerAliases
-
-  class Server
-    extend T::Sig
-
-    sig { void }
-    def initialize
-      @writer = T.let(Transport::Stdio::Writer.new, Transport::Stdio::Writer)
-      @reader = T.let(Transport::Stdio::Reader.new, Transport::Stdio::Reader)
-      @store = T.let(Store.new, Store)
-
-      # The job queue is the actual list of requests we have to process
-      @job_queue = T.let(Thread::Queue.new, Thread::Queue)
-      # The jobs hash is just a way of keeping a handle to jobs based on the request ID, so we can cancel them
-      @jobs = T.let({}, T::Hash[T.any(String, Integer), Job])
-      @mutex = T.let(Mutex.new, Mutex)
-      @worker = T.let(new_worker, Thread)
-
-      # The messages queue includes requests and notifications to be sent to the client
-      @message_queue = T.let(Thread::Queue.new, Thread::Queue)
-
-      # The executor is responsible for executing requests
-      @executor = T.let(Executor.new(@store, @message_queue), Executor)
-
-      # Create a thread to watch the messages queue and send them to the client
-      @message_dispatcher = T.let(
-        Thread.new do
-          current_request_id = 1
-
-          loop do
-            message = @message_queue.pop
-            break if message.nil?
-
-            @mutex.synchronize do
-              case message
-              when Notification
-                @writer.write(method: message.message, params: message.params)
-              when Request
-                @writer.write(id: current_request_id, method: message.message, params: message.params)
-                current_request_id += 1
-              end
-            end
-          end
-        end,
-        Thread,
-      )
-
-      Thread.main.priority = 1
-    end
-
-    sig { void }
-    def start
-      warn("Starting Ruby LSP...")
-
-      # Requests that have to be executed sequentially or in the main process are implemented here. All other requests
-      # fall under the else branch which just pushes requests to the queue
-      @reader.read do |request|
-        case request[:method]
-        when "initialize", "initialized", "textDocument/didOpen", "textDocument/didClose", "textDocument/didChange"
-          result = @executor.execute(request)
-          finalize_request(result, request)
-        when "$/cancelRequest"
-          # Cancel the job if it's still in the queue
-          @mutex.synchronize { @jobs[request[:params][:id]]&.cancel }
-        when "$/setTrace"
-          VOID
-        when "shutdown"
-          warn("Shutting down Ruby LSP...")
-
-          @message_queue.close
-          # Close the queue so that we can no longer receive items
-          @job_queue.close
-          # Clear any remaining jobs so that the thread can terminate
-          @job_queue.clear
-          @jobs.clear
-          # Wait until the thread is finished
-          @worker.join
-          @message_dispatcher.join
-          @store.clear
-
-          Addon.addons.each(&:deactivate)
-          finalize_request(Result.new(response: nil), request)
-        when "exit"
-          # We return zero if shutdown has already been received or one otherwise as per the recommendation in the spec
-          # https://microsoft.github.io/language-server-protocol/specification/#exit
-          status = @store.empty? ? 0 : 1
-          warn("Shutdown complete with status #{status}")
-          exit(status)
-        else
-          # Default case: push the request to the queue to be executed by the worker
-          job = Job.new(request: request, cancelled: false)
-
-          @mutex.synchronize do
-            # Remember a handle to the job, so that we can cancel it
-            @jobs[request[:id]] = job
-
-            # We must parse the document under a mutex lock or else we might switch threads and accept text edits in the
-            # source. Altering the source reference during parsing will put the parser in an invalid internal state,
-            # since it started parsing with one source but then it changed in the middle
-            uri = request.dig(:params, :textDocument, :uri)
-            @store.get(URI(uri)).parse if uri
-          end
-
-          @job_queue << job
-        end
-      end
-    end
-
-    private
-
-    sig { returns(Thread) }
-    def new_worker
-      Thread.new do
-        # Thread::Queue#pop is thread safe and will wait until an item is available
-        loop do
-          job = T.let(@job_queue.pop, T.nilable(Job))
-          # The only time when the job is nil is when the queue is closed and we can then terminate the thread
-          break if job.nil?
-
-          request = job.request
-          @mutex.synchronize { @jobs.delete(request[:id]) }
-
-          result = if job.cancelled
-            # We need to return nil to the client even if the request was cancelled
-            Result.new(response: nil)
-          else
-            @executor.execute(request)
-          end
-
-          finalize_request(result, request)
-        end
-      end
-    end
-
-    # Finalize a Queue::Result. All IO operations should happen here to avoid any issues with cancelling requests
-    sig { params(result: Result, request: T::Hash[Symbol, T.untyped]).void }
-    def finalize_request(result, request)
-      @mutex.synchronize do
-        error = result.error
-        response = result.response
-
-        if error
-          @writer.write(
-            id: request[:id],
-            error: {
-              code: Constant::ErrorCodes::INTERNAL_ERROR,
-              message: error.inspect,
-              data: {
-                errorClass: error.class.name,
-                errorMessage: error.message,
-                backtrace: error.backtrace&.map { |bt| bt.sub(/^#{Dir.home}/, "~") }&.join("\n"),
-              },
-            },
-          )
-        elsif response != VOID
-          @writer.write(id: request[:id], result: response)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/ruby-lsp-0.12.1/lib/ruby_lsp/setup_bundler.rb

@@ -1,229 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-require "sorbet-runtime"
-require "bundler"
-require "fileutils"
-require "pathname"
-require "digest"
-require "time"
-
-# This file is a script that will configure a custom bundle for the Ruby LSP. The custom bundle allows developers to use
-# the Ruby LSP without including the gem in their application's Gemfile while at the same time giving us access to the
-# exact locked versions of dependencies.
-
-module RubyLsp
-  class SetupBundler
-    extend T::Sig
-
-    class BundleNotLocked < StandardError; end
-
-    FOUR_HOURS = T.let(4 * 60 * 60, Integer)
-
-    sig { params(project_path: String, options: T.untyped).void }
-    def initialize(project_path, **options)
-      @project_path = project_path
-      @branch = T.let(options[:branch], T.nilable(String))
-      @experimental = T.let(options[:experimental], T.nilable(T::Boolean))
-
-      # Regular bundle paths
-      @gemfile = T.let(
-        begin
-          Bundler.default_gemfile
-        rescue Bundler::GemfileNotFound
-          nil
-        end,
-        T.nilable(Pathname),
-      )
-      @lockfile = T.let(@gemfile ? Bundler.default_lockfile : nil, T.nilable(Pathname))
-
-      @gemfile_name = T.let(@gemfile&.basename&.to_s || "Gemfile", String)
-
-      # Custom bundle paths
-      @custom_dir = T.let(Pathname.new(".ruby-lsp").expand_path(Dir.pwd), Pathname)
-      @custom_gemfile = T.let(@custom_dir + @gemfile_name, Pathname)
-      @custom_lockfile = T.let(@custom_dir + (@lockfile&.basename || "Gemfile.lock"), Pathname)
-      @lockfile_hash_path = T.let(@custom_dir + "main_lockfile_hash", Pathname)
-      @last_updated_path = T.let(@custom_dir + "last_updated", Pathname)
-
-      @dependencies = T.let(load_dependencies, T::Hash[String, T.untyped])
-    end
-
-    # Sets up the custom bundle and returns the `BUNDLE_GEMFILE`, `BUNDLE_PATH` and `BUNDLE_APP_CONFIG` that should be
-    # used for running the server
-    sig { returns([String, T.nilable(String), T.nilable(String)]) }
-    def setup!
-      raise BundleNotLocked if @gemfile&.exist? && !@lockfile&.exist?
-
-      # Do not setup a custom bundle if both `ruby-lsp` and `debug` are already in the Gemfile
-      if @dependencies["ruby-lsp"] && @dependencies["debug"]
-        warn("Ruby LSP> Skipping custom bundle setup since both `ruby-lsp` and `debug` are already in #{@gemfile}")
-
-        # If the user decided to add the `ruby-lsp` and `debug` to their Gemfile after having already run the Ruby LSP,
-        # then we need to remove the `.ruby-lsp` folder, otherwise we will run `bundle install` for the top level and
-        # try to execute the Ruby LSP using the custom bundle, which will fail since the gems are not installed there
-        @custom_dir.rmtree if @custom_dir.exist?
-        return run_bundle_install
-      end
-
-      # Automatically create and ignore the .ruby-lsp folder for users
-      @custom_dir.mkpath unless @custom_dir.exist?
-      ignore_file = @custom_dir + ".gitignore"
-      ignore_file.write("*") unless ignore_file.exist?
-
-      write_custom_gemfile
-
-      unless @gemfile&.exist? && @lockfile&.exist?
-        warn("Ruby LSP> Skipping lockfile copies because there's no top level bundle")
-        return run_bundle_install(@custom_gemfile)
-      end
-
-      lockfile_contents = @lockfile.read
-      current_lockfile_hash = Digest::SHA256.hexdigest(lockfile_contents)
-
-      if @custom_lockfile.exist? && @lockfile_hash_path.exist? && @lockfile_hash_path.read == current_lockfile_hash
-        warn("Ruby LSP> Skipping custom bundle setup since #{@custom_lockfile} already exists and is up to date")
-        return run_bundle_install(@custom_gemfile)
-      end
-
-      FileUtils.cp(@lockfile.to_s, @custom_lockfile.to_s)
-      @lockfile_hash_path.write(current_lockfile_hash)
-      run_bundle_install(@custom_gemfile)
-    end
-
-    private
-
-    sig { returns(T::Hash[String, T.untyped]) }
-    def custom_bundle_dependencies
-      @custom_bundle_dependencies ||= T.let(
-        begin
-          if @custom_lockfile.exist?
-            ENV["BUNDLE_GEMFILE"] = @custom_gemfile.to_s
-            Bundler::LockfileParser.new(@custom_lockfile.read).dependencies
-          else
-            {}
-          end
-        end,
-        T.nilable(T::Hash[String, T.untyped]),
-      )
-    ensure
-      ENV.delete("BUNDLE_GEMFILE")
-    end
-
-    sig { void }
-    def write_custom_gemfile
-      parts = [
-        "# This custom gemfile is automatically generated by the Ruby LSP.",
-        "# It should be automatically git ignored, but in any case: do not commit it to your repository.",
-        "",
-      ]
-
-      # If there's a top level Gemfile, we want to evaluate from the custom bundle. We get the source from the top level
-      # Gemfile, so if there isn't one we need to add a default source
-      if @gemfile&.exist?
-        parts << "eval_gemfile(File.expand_path(\"../#{@gemfile_name}\", __dir__))"
-      else
-        parts.unshift('source "https://rubygems.org"')
-      end
-
-      unless @dependencies["ruby-lsp"]
-        ruby_lsp_entry = +'gem "ruby-lsp", require: false, group: :development'
-        ruby_lsp_entry << ", github: \"Shopify/ruby-lsp\", branch: \"#{@branch}\"" if @branch
-        parts << ruby_lsp_entry
-      end
-
-      unless @dependencies["debug"]
-        parts << 'gem "debug", require: false, group: :development, platforms: :mri'
-      end
-
-      content = parts.join("\n")
-      @custom_gemfile.write(content) unless @custom_gemfile.exist? && @custom_gemfile.read == content
-    end
-
-    sig { returns(T::Hash[String, T.untyped]) }
-    def load_dependencies
-      return {} unless @lockfile&.exist?
-
-      # We need to parse the Gemfile.lock manually here. If we try to do `bundler/setup` to use something more
-      # convenient, we may end up with issues when the globally installed `ruby-lsp` version mismatches the one included
-      # in the `Gemfile`
-      dependencies = Bundler::LockfileParser.new(@lockfile.read).dependencies
-
-      # When working on a gem, the `ruby-lsp` might be listed as a dependency in the gemspec. We need to make sure we
-      # check those as well or else we may get version mismatch errors. Notice that bundler allows more than one
-      # gemspec, so we need to make sure we go through all of them
-      Dir.glob("{,*}.gemspec").each do |path|
-        dependencies.merge!(Bundler.load_gemspec(path).dependencies.to_h { |dep| [dep.name, dep] })
-      end
-
-      dependencies
-    end
-
-    sig { params(bundle_gemfile: T.nilable(Pathname)).returns([String, T.nilable(String), T.nilable(String)]) }
-    def run_bundle_install(bundle_gemfile = @gemfile)
-      # If the user has a custom bundle path configured, we need to ensure that we will use the absolute and not
-      # relative version of it when running `bundle install`. This is necessary to avoid installing the gems under the
-      # `.ruby-lsp` folder, which is not the user's intention. For example, if the path is configured as `vendor`, we
-      # want to install it in the top level `vendor` and not `.ruby-lsp/vendor`
-      path = Bundler.settings["path"]
-      expanded_path = File.expand_path(path, Dir.pwd) if path
-
-      # Use the absolute `BUNDLE_PATH` to prevent accidentally creating unwanted folders under `.ruby-lsp`
-      env = {}
-      env["BUNDLE_GEMFILE"] = bundle_gemfile.to_s
-      env["BUNDLE_PATH"] = expanded_path if expanded_path
-
-      local_config_path = File.join(Dir.pwd, ".bundle")
-      env["BUNDLE_APP_CONFIG"] = local_config_path if Dir.exist?(local_config_path)
-
-      # If both `ruby-lsp` and `debug` are already in the Gemfile, then we shouldn't try to upgrade them or else we'll
-      # produce undesired source control changes. If the custom bundle was just created and either `ruby-lsp` or `debug`
-      # weren't a part of the Gemfile, then we need to run `bundle install` for the first time to generate the
-      # Gemfile.lock with them included or else Bundler will complain that they're missing. We can only update if the
-      # custom `.ruby-lsp/Gemfile.lock` already exists and includes both gems
-
-      # When not updating, we run `(bundle check || bundle install)`
-      # When updating, we run `((bundle check && bundle update ruby-lsp debug) || bundle install)`
-      command = +"(bundle check"
-
-      if should_bundle_update?
-        # If ruby-lsp or debug are not in the Gemfile, try to update them to the latest version
-        command.prepend("(")
-        command << " && bundle update "
-        command << "ruby-lsp " unless @dependencies["ruby-lsp"]
-        command << "debug " unless @dependencies["debug"]
-        command << "--pre" if @experimental
-        command.delete_suffix!(" ")
-        command << ")"
-
-        @last_updated_path.write(Time.now.iso8601)
-      end
-
-      command << " || bundle install) "
-
-      # Redirect stdout to stderr to prevent going into an infinite loop. The extension might confuse stdout output with
-      # responses
-      command << "1>&2"
-
-      # Add bundle update
-      warn("Ruby LSP> Running bundle install for the custom bundle. This may take a while...")
-      warn("Ruby LSP> Command: #{command}")
-      system(env, command)
-      [bundle_gemfile.to_s, expanded_path, env["BUNDLE_APP_CONFIG"]]
-    end
-
-    sig { returns(T::Boolean) }
-    def should_bundle_update?
-      # If both `ruby-lsp` and `debug` are in the Gemfile, then we shouldn't try to upgrade them or else it will produce
-      # version control changes
-      return false if @dependencies["ruby-lsp"] && @dependencies["debug"]
-
-      # If the custom lockfile doesn't include either the `ruby-lsp` or `debug`, we need to run bundle install before
-      # updating
-      return false if custom_bundle_dependencies["ruby-lsp"].nil? || custom_bundle_dependencies["debug"].nil?
-
-      # If the last updated file doesn't exist or was updated more than 4 hours ago, we should update
-      !@last_updated_path.exist? || Time.parse(@last_updated_path.read) < (Time.now - FOUR_HOURS)
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/ruby-lsp-0.12.1/lib/ruby_lsp/store.rb

@@ -1,79 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-require "ruby_lsp/document"
-
-module RubyLsp
-  class Store
-    extend T::Sig
-
-    sig { returns(String) }
-    attr_accessor :encoding
-
-    sig { returns(String) }
-    attr_accessor :formatter
-
-    sig { returns(T::Boolean) }
-    attr_accessor :supports_progress
-
-    sig { returns(T::Boolean) }
-    attr_accessor :experimental_features
-
-    sig { void }
-    def initialize
-      @state = T.let({}, T::Hash[String, Document])
-      @encoding = T.let(Constant::PositionEncodingKind::UTF8, String)
-      @formatter = T.let("auto", String)
-      @supports_progress = T.let(true, T::Boolean)
-      @experimental_features = T.let(false, T::Boolean)
-    end
-
-    sig { params(uri: URI::Generic).returns(Document) }
-    def get(uri)
-      document = @state[uri.to_s]
-      return document unless document.nil?
-
-      path = T.must(uri.to_standardized_path)
-      set(uri: uri, source: File.binread(path), version: 0)
-      T.must(@state[uri.to_s])
-    end
-
-    sig { params(uri: URI::Generic, source: String, version: Integer).void }
-    def set(uri:, source:, version:)
-      document = Document.new(source: source, version: version, uri: uri, encoding: @encoding)
-      @state[uri.to_s] = document
-    end
-
-    sig { params(uri: URI::Generic, edits: T::Array[Document::EditShape], version: Integer).void }
-    def push_edits(uri:, edits:, version:)
-      T.must(@state[uri.to_s]).push_edits(edits, version: version)
-    end
-
-    sig { void }
-    def clear
-      @state.clear
-    end
-
-    sig { returns(T::Boolean) }
-    def empty?
-      @state.empty?
-    end
-
-    sig { params(uri: URI::Generic).void }
-    def delete(uri)
-      @state.delete(uri.to_s)
-    end
-
-    sig do
-      type_parameters(:T)
-        .params(
-          uri: URI::Generic,
-          request_name: String,
-          block: T.proc.params(document: Document).returns(T.type_parameter(:T)),
-        ).returns(T.type_parameter(:T))
-    end
-    def cache_fetch(uri, request_name, &block)
-      get(uri).cache_fetch(request_name, &block)
-    end
-  end
-end