ruby-lsp 0.7.4 → 0.7.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5488592df860b1fd1439a1b2780a7d0da850fcb9b9164713fbf5ce07b6e67270
-  data.tar.gz: '055789cf32db04550a7bd4f602a4e3d69a96760698c567450eceffde5a7ef152'
+  metadata.gz: a645362acbfb8b0f819bd89fbaf1e53d0f7d9eda81974e62bc0f114aeefc221e
+  data.tar.gz: 861b5c68f9355f551ebfb519507ca1c0028f0e4e2edff70ae6ad62c652bdfd2c
 SHA512:
-  metadata.gz: a3f710de0df843d8c45499b5f818433b9d25b56547d19b2a7cd3896b73ff29c6a6e2be35d091df7d9a7058d9d0d3994dc63898328efa689a198faf864ef61ffc
-  data.tar.gz: cc97f72b359d8125269d17cac6d0c8313ca7e2debcae54a81beb270f620b12b100ec89a2bf9c9a82990bb41411a9acf37f76909c09b561bf53eb7fcd74d407b6
+  metadata.gz: 4283abdb1ce9865e6dbecd0827ddd88f07a63937a9f75ba8ca78142d3536624ac374b165e7a1277adee4197553c74615ed560dad3093eb346ae3e505e174dae5
+  data.tar.gz: 6084fd63d0d780c169b8f8766f347cdb699e2490a0c8de542a3fa969ad37d7f49e281ffa7f92a7ee15a764dccac9832e5e9a49265ba9077f9d204185d0c00e64

data/VERSION

@@ -1 +1 @@
-0.7.4
+0.7.6

data/exe/ruby-lsp

@@ -1,33 +1,22 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-# We should make sure that, if we're running on a bundler project, that it has a Gemfile.lock
-if File.exist?("Gemfile") && !File.exist?("Gemfile.lock")
-  warn("Project contains a Gemfile, but no Gemfile.lock. Run `bundle install` to lock gems and restart the server")
-  exit(78)
-end
-
 # When we're running without bundler, then we need to make sure the custom bundle is fully configured and re-execute
 # using `BUNDLE_GEMFILE=.ruby-lsp/Gemfile bundle exec ruby-lsp` so that we have access to the gems that are a part of
 # the application's bundle
-if ENV["BUNDLE_GEMFILE"].nil? && File.exist?("Gemfile.lock")
+if ENV["BUNDLE_GEMFILE"].nil?
   require_relative "../lib/ruby_lsp/setup_bundler"
-  RubyLsp::SetupBundler.new(Dir.pwd).setup!
-
-  # In some cases, like when the `ruby-lsp` is already a part of the bundle, we don't generate `.ruby-lsp/Gemfile`.
-  # However, we still want to run the server with `bundle exec`. We need to make sure we're pointing to the right
-  # `Gemfile`
-  bundle_gemfile = File.exist?(".ruby-lsp/Gemfile") ? ".ruby-lsp/Gemfile" : "Gemfile"
-
-  # In addition to BUNDLE_GEMFILE, we also need to make sure that BUNDLE_PATH is absolute and not relative. For example,
-  # if BUNDLE_PATH is `vendor/bundle`, we want the top level `vendor/bundle` and not `.ruby-lsp/vendor/bundle`.
-  # Expanding to get the absolute path ensures we're pointing to the correct folder, which is the same one we use in
-  # SetupBundler to install the gems
-  path = Bundler.settings["path"]
-
-  command = +"BUNDLE_GEMFILE=#{bundle_gemfile} bundle exec ruby-lsp #{ARGV.join(" ")}"
-  command.prepend("BUNDLE_PATH=#{File.expand_path(path, Dir.pwd)} ") if path
-  exit exec(command)
+
+  begin
+    bundle_gemfile, bundle_path = RubyLsp::SetupBundler.new(Dir.pwd).setup!
+  rescue RubyLsp::SetupBundler::BundleNotLocked
+    warn("Project contains a Gemfile, but no Gemfile.lock. Run `bundle install` to lock gems and restart the server")
+    exit(78)
+  end
+
+  env = { "BUNDLE_GEMFILE" => bundle_gemfile }
+  env["BUNDLE_PATH"] = bundle_path if bundle_path
+  exit exec(env, "bundle exec ruby-lsp #{ARGV.join(" ")}")
 end
 
 require "sorbet-runtime"

data/lib/ruby_lsp/requests/show_syntax_tree.rb

@@ -47,7 +47,7 @@ module RubyLsp
         start_char = scanner.find_char_position(range[:start])
         end_char = scanner.find_char_position(range[:end])
 
-        queue = T.cast(@document.tree, SyntaxTree::Program).statements.body
+        queue = T.cast(@document.tree, SyntaxTree::Program).statements.body.dup
         found_nodes = []
 
         until queue.empty?

data/lib/ruby_lsp/requests/support/common.rb

@@ -26,7 +26,7 @@ module RubyLsp
           params(node: T.any(SyntaxTree::ConstPathRef, SyntaxTree::ConstRef, SyntaxTree::TopConstRef)).returns(String)
         end
         def full_constant_name(node)
-          name = +node.constant.value
+          name = node.constant.value.dup
           constant = T.let(node, SyntaxTree::Node)
 
           while constant.is_a?(SyntaxTree::ConstPathRef)

data/lib/ruby_lsp/requests/support/dependency_detector.rb

@@ -38,7 +38,10 @@ module RubyLsp
 
       sig { params(gem_pattern: Regexp).returns(T::Boolean) }
       def direct_dependency?(gem_pattern)
-        Bundler.locked_gems.dependencies.keys.grep(gem_pattern).any?
+        Bundler.with_original_env { Bundler.default_gemfile } &&
+          Bundler.locked_gems.dependencies.keys.grep(gem_pattern).any?
+      rescue Bundler::GemfileNotFound
+        false
       end
     end
   end

data/lib/ruby_lsp/setup_bundler.rb

@@ -4,6 +4,7 @@
 require "sorbet-runtime"
 require "bundler"
 require "fileutils"
+require "pathname"
 
 # 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
@@ -13,123 +14,151 @@ module RubyLsp
   class SetupBundler
     extend T::Sig
 
+    class BundleNotLocked < StandardError; end
+
     sig { params(project_path: String).void }
     def initialize(project_path)
       @project_path = project_path
-      @dependencies = T.let(load_dependencies, T::Hash[String, T.untyped])
-      @custom_bundle_dependencies = T.let(
-        if File.exist?(".ruby-lsp/Gemfile.lock")
-          Bundler::LockfileParser.new(Bundler.read_file(".ruby-lsp/Gemfile.lock")).dependencies
-        else
-          {}
+
+      # Custom bundle paths
+      @custom_dir = T.let(Pathname.new(".ruby-lsp").expand_path(Dir.pwd), Pathname)
+      @custom_gemfile = T.let(@custom_dir + "Gemfile", Pathname)
+      @custom_lockfile = T.let(@custom_dir + "Gemfile.lock", Pathname)
+
+      # Regular bundle paths
+      @gemfile = T.let(
+        begin
+          Bundler.default_gemfile
+        rescue Bundler::GemfileNotFound
+          nil
         end,
-        T::Hash[String, T.untyped],
+        T.nilable(Pathname),
       )
+      @lockfile = T.let(@gemfile ? Bundler.default_lockfile : nil, T.nilable(Pathname))
+
+      @dependencies = T.let(load_dependencies, T::Hash[String, T.untyped])
+      @custom_bundle_dependencies = T.let(custom_bundle_dependencies, T::Hash[String, T.untyped])
     end
 
-    sig { void }
+    # Setups up the custom bundle and returns the `BUNDLE_GEMFILE` and `BUNDLE_PATH` that should be used for running the
+    # server
+    sig { returns([String, T.nilable(String)]) }
     def setup!
-      # Do not setup a custom bundle if we're working on the Ruby LSP, since it's already included by default
-      if File.basename(@project_path) == "ruby-lsp"
-        warn("Ruby LSP> Skipping custom bundle setup since we're working on the Ruby LSP itself")
-        run_bundle_install
-        return
-      end
+      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 the Gemfile")
+        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
-        FileUtils.rm_r(".ruby-lsp") if Dir.exist?(".ruby-lsp")
-        run_bundle_install
-        return
+        @custom_dir.rmtree if @custom_dir.exist?
+        return run_bundle_install
       end
 
       # Automatically create and ignore the .ruby-lsp folder for users
-      FileUtils.mkdir(".ruby-lsp") unless Dir.exist?(".ruby-lsp")
-      File.write(".ruby-lsp/.gitignore", "*") unless File.exist?(".ruby-lsp/.gitignore")
+      @custom_dir.mkpath unless @custom_dir.exist?
+      ignore_file = @custom_dir + ".gitignore"
+      ignore_file.write("*") unless ignore_file.exist?
 
-      # Write the custom `.ruby-lsp/Gemfile` if it doesn't exist or if the content doesn't match
-      content = custom_gemfile_content
+      write_custom_gemfile
 
-      unless File.exist?(".ruby-lsp/Gemfile") && File.read(".ruby-lsp/Gemfile") == content
-        File.write(".ruby-lsp/Gemfile", content)
+      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
 
       # If .ruby-lsp/Gemfile.lock already exists and the top level Gemfile.lock hasn't been modified since it was last
       # updated, then we're ready to boot the server
-      if File.exist?(".ruby-lsp/Gemfile.lock") &&
-          File.stat(".ruby-lsp/Gemfile.lock").mtime > File.stat("Gemfile.lock").mtime
-        warn("Ruby LSP> Skipping custom bundle setup since .ruby-lsp/Gemfile.lock already exists and is up to date")
-        run_bundle_install(".ruby-lsp/Gemfile")
-        return
+      if @custom_lockfile.exist? && @custom_lockfile.stat.mtime > @lockfile.stat.mtime
+        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("Gemfile.lock", ".ruby-lsp/Gemfile.lock")
-      run_bundle_install(".ruby-lsp/Gemfile")
+      FileUtils.cp(@lockfile.to_s, @custom_lockfile.to_s)
+      run_bundle_install(@custom_gemfile)
     end
 
     private
 
-    sig { returns(String) }
-    def custom_gemfile_content
+    sig { returns(T::Hash[String, T.untyped]) }
+    def custom_bundle_dependencies
+      return {} unless @custom_lockfile.exist?
+
+      ENV["BUNDLE_GEMFILE"] = @custom_gemfile.to_s
+      Bundler::LockfileParser.new(@custom_lockfile.read).dependencies
+    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.",
         "",
-        "eval_gemfile(File.expand_path(\"../Gemfile\", __dir__))",
       ]
 
+      # 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\", __dir__))"
+      else
+        parts.unshift('source "https://rubygems.org"')
+      end
+
       unless @dependencies["ruby-lsp"]
-        parts << 'gem "ruby-lsp", require: false, group: :development, source: "https://rubygems.org"'
+        parts << 'gem "ruby-lsp", require: false, group: :development'
       end
 
       unless @dependencies["debug"]
-        parts << 'gem "debug", require: false, group: :development, platforms: :mri, source: "https://rubygems.org"'
+        parts << 'gem "debug", require: false, group: :development, platforms: :mri'
       end
 
-      parts.join("\n")
+      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(Bundler.read_file("Gemfile.lock")).dependencies
+      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
-      gemspec_path = Dir.glob("*.gemspec").first
-      if gemspec_path
-        gemspec_dependencies = Bundler.load_gemspec(gemspec_path).dependencies.to_h { |dep| [dep.name, dep] }
-        dependencies.merge!(gemspec_dependencies)
+      # 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.untyped).void }
-    def run_bundle_install(bundle_gemfile = nil)
+    sig { params(bundle_gemfile: T.nilable(Pathname)).returns([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"]
 
-      command = +""
       # Use the absolute `BUNDLE_PATH` to prevent accidentally creating unwanted folders under `.ruby-lsp`
-      command << "BUNDLE_PATH=#{File.expand_path(path, Dir.pwd)} " if path
-      command << "BUNDLE_GEMFILE=#{bundle_gemfile} " if bundle_gemfile
+      env = {}
+      env["BUNDLE_GEMFILE"] = bundle_gemfile.to_s
+      env["BUNDLE_PATH"] = File.expand_path(path, Dir.pwd) if 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
+      command = +""
+
       if (@dependencies["ruby-lsp"] && @dependencies["debug"]) ||
           @custom_bundle_dependencies["ruby-lsp"].nil? || @custom_bundle_dependencies["debug"].nil?
         # Install gems using the custom bundle
@@ -147,7 +176,8 @@ module RubyLsp
 
       # Add bundle update
       warn("Ruby LSP> Running bundle install for the custom bundle. This may take a while...")
-      system(command)
+      system(env, command)
+      [bundle_gemfile.to_s, path]
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.7.4
+  version: 0.7.6
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-07-25 00:00:00.000000000 Z
+date: 2023-08-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -140,7 +140,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.16
+rubygems_version: 3.4.17
 signing_key: 
 specification_version: 4
 summary: An opinionated language server for Ruby