solargraph 0.60.4 → 0.61.0

data/lib/solargraph/pin_cache.rb

@@ -1,248 +0,0 @@
-require 'yard-activesupport-concern'
-require 'fileutils'
-require 'pathname' # @todo Required by RBS but not loaded in some use cases
-require 'rbs'
-
-module Solargraph
-  module PinCache
-    class << self
-      include Logging
-
-      # The base directory where cached YARD documentation and serialized pins are serialized
-      #
-      # @return [String]
-      def base_dir
-        # The directory is not stored in a variable so it can be overridden
-        # in specs.
-        ENV['SOLARGRAPH_CACHE'] ||
-          (ENV['XDG_CACHE_HOME'] ? File.join(ENV['XDG_CACHE_HOME'], 'solargraph') : nil) ||
-          File.join(Dir.home, '.cache', 'solargraph')
-      end
-
-      # The working directory for the current Ruby, RBS, and Solargraph versions.
-      #
-      # @return [String]
-      def work_dir
-        # The directory is not stored in a variable so it can be overridden
-        # in specs.
-        File.join(base_dir, "ruby-#{RUBY_VERSION}", "rbs-#{RBS::VERSION}", "solargraph-#{Solargraph::VERSION}")
-      end
-
-      # @param gemspec [Gem::Specification]
-      # @return [String]
-      def yardoc_path gemspec
-        File.join(base_dir,
-                  "yard-#{YARD::VERSION}",
-                  "yard-activesupport-concern-#{YARD::ActiveSupport::Concern::VERSION}",
-                  "#{gemspec.name}-#{gemspec.version}.yardoc")
-      end
-
-      # @return [String]
-      def stdlib_path
-        File.join(work_dir, 'stdlib')
-      end
-
-      # @param require [String]
-      # @return [String]
-      def stdlib_require_path require
-        File.join(stdlib_path, "#{require}.ser")
-      end
-
-      # @param require [String]
-      # @return [Array<Pin::Base>, nil]
-      def deserialize_stdlib_require require
-        load(stdlib_require_path(require))
-      end
-
-      # @param require [String]
-      # @param pins [Array<Pin::Base>]
-      # @return [void]
-      def serialize_stdlib_require require, pins
-        save(stdlib_require_path(require), pins)
-      end
-
-      # @return [String]
-      def core_path
-        File.join(work_dir, 'core.ser')
-      end
-
-      # @return [Array<Pin::Base>, nil]
-      def deserialize_core
-        load(core_path)
-      end
-
-      # @param pins [Array<Pin::Base>]
-      # @return [void]
-      def serialize_core pins
-        save(core_path, pins)
-      end
-
-      # @param gemspec [Gem::Specification]
-      # @return [String]
-      def yard_gem_path gemspec
-        File.join(work_dir, 'yard', "#{gemspec.name}-#{gemspec.version}.ser")
-      end
-
-      # @param gemspec [Gem::Specification]
-      # @return [Array<Pin::Base>, nil]
-      def deserialize_yard_gem gemspec
-        load(yard_gem_path(gemspec))
-      end
-
-      # @param gemspec [Gem::Specification]
-      # @param pins [Array<Pin::Base>]
-      # @return [void]
-      def serialize_yard_gem gemspec, pins
-        save(yard_gem_path(gemspec), pins)
-      end
-
-      # @param gemspec [Gem::Specification]
-      # @return [Boolean]
-      def has_yard? gemspec
-        exist?(yard_gem_path(gemspec))
-      end
-
-      # @param gemspec [Gem::Specification]
-      # @param hash [String, nil]
-      # @return [String]
-      def rbs_collection_path gemspec, hash
-        File.join(work_dir, 'rbs', "#{gemspec.name}-#{gemspec.version}-#{hash || 0}.ser")
-      end
-
-      # @param gemspec [Gem::Specification]
-      # @return [String]
-      def rbs_collection_path_prefix gemspec
-        File.join(work_dir, 'rbs', "#{gemspec.name}-#{gemspec.version}-")
-      end
-
-      # @param gemspec [Gem::Specification]
-      # @param hash [String, nil]
-      # @return [Array<Pin::Base>, nil]
-      def deserialize_rbs_collection_gem gemspec, hash
-        load(rbs_collection_path(gemspec, hash))
-      end
-
-      # @param gemspec [Gem::Specification]
-      # @param hash [String, nil]
-      # @param pins [Array<Pin::Base>]n
-      # @return [void]
-      def serialize_rbs_collection_gem gemspec, hash, pins
-        save(rbs_collection_path(gemspec, hash), pins)
-      end
-
-      # @param gemspec [Gem::Specification]
-      # @param hash [String, nil]
-      # @return [String]
-      def combined_path gemspec, hash
-        File.join(work_dir, 'combined', "#{gemspec.name}-#{gemspec.version}-#{hash || 0}.ser")
-      end
-
-      # @param gemspec [Gem::Specification]
-      # @return [String]
-      def combined_path_prefix gemspec
-        File.join(work_dir, 'combined', "#{gemspec.name}-#{gemspec.version}-")
-      end
-
-      # @param gemspec [Gem::Specification]
-      # @param hash [String, nil]
-      # @param pins [Array<Pin::Base>]
-      # @return [void]
-      def serialize_combined_gem gemspec, hash, pins
-        save(combined_path(gemspec, hash), pins)
-      end
-
-      # @param gemspec [Gem::Specification]
-      # @param hash [String, nil]
-      # @return [Array<Pin::Base>, nil]
-      def deserialize_combined_gem gemspec, hash
-        load(combined_path(gemspec, hash))
-      end
-
-      # @param gemspec [Gem::Specification]
-      # @param hash [String, nil]
-      # @return [Boolean]
-      def has_rbs_collection? gemspec, hash
-        exist?(rbs_collection_path(gemspec, hash))
-      end
-
-      # @return [void]
-      def uncache_core
-        uncache(core_path)
-      end
-
-      # @return [void]
-      def uncache_stdlib
-        uncache(stdlib_path)
-      end
-
-      # @param gemspec [Gem::Specification]
-      # @param out [IO, StringIO, nil]
-      # @return [void]
-      def uncache_gem gemspec, out: nil
-        uncache(yardoc_path(gemspec), out: out)
-        uncache_by_prefix(rbs_collection_path_prefix(gemspec), out: out)
-        uncache(yard_gem_path(gemspec), out: out)
-        uncache_by_prefix(combined_path_prefix(gemspec), out: out)
-      end
-
-      # @return [void]
-      def clear
-        FileUtils.rm_rf base_dir, secure: true
-      end
-
-      private
-
-      # @param file [String]
-      # @sg-ignore Marshal.load returns Object; we know it's Array<Pin::Base>
-      # @return [Array<Solargraph::Pin::Base>, nil]
-      def load file
-        return nil unless File.file?(file)
-        Marshal.load(File.read(file, mode: 'rb'))
-      rescue StandardError => e
-        Solargraph.logger.warn "Failed to load cached file #{file}: [#{e.class}] #{e.message}"
-        FileUtils.rm_f file
-        nil
-      end
-
-      # @param path [String]
-      def exist? *path
-        File.file? File.join(*path)
-      end
-
-      # @param file [String]
-      # @param pins [Array<Pin::Base>]
-      # @return [void]
-      def save file, pins
-        base = File.dirname(file)
-        FileUtils.mkdir_p base unless File.directory?(base)
-        ser = Marshal.dump(pins)
-        File.write file, ser, mode: 'wb'
-        logger.debug { "Cache#save: Saved #{pins.length} pins to #{file}" }
-      end
-
-      # @param path_segments [Array<String>]
-      # @return [void]
-      # @param [Object, nil] out
-      def uncache *path_segments, out: nil
-        path = File.join(*path_segments)
-        return unless File.exist?(path)
-        FileUtils.rm_rf path, secure: true
-        out&.puts "Clearing pin cache in #{path}"
-      end
-
-      # @return [void]
-      # @param path_segments [Array<String>]
-      # @param [Object, nil] out
-      def uncache_by_prefix *path_segments, out: nil
-        path = File.join(*path_segments)
-        glob = "#{path}*"
-        out&.puts "Clearing pin cache in #{glob}"
-        Dir.glob(glob).each do |file|
-          next unless File.file?(file)
-          FileUtils.rm_rf file, secure: true
-          out&.puts "Clearing pin cache in #{file}"
-        end
-      end
-    end
-  end
-end

data/lib/solargraph/rbs_map/stdlib_map.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-require 'rbs'
-
-module Solargraph
-  class RbsMap
-    # Ruby stdlib pins
-    #
-    class StdlibMap < RbsMap
-      include Logging
-
-      # @type [Hash{String => RbsMap}]
-      @stdlib_maps_hash = {}
-
-      # @param rebuild [Boolean] build pins regardless of whether we
-      #   have cached them already
-      # @param library [String]
-      # @param out [StringIO, IO, nil] where to log messages
-      def initialize library, rebuild: false, out: $stderr
-        cached_pins = PinCache.deserialize_stdlib_require library
-        if cached_pins && !rebuild
-          @pins = cached_pins
-          @resolved = true
-          @loaded = true
-          logger.debug { "Deserialized #{cached_pins.length} cached pins for stdlib require #{library.inspect}" }
-        elsif self.class.source.has? library, nil
-          super(library, out: out)
-          unless resolved?
-            @pins = []
-            logger.debug { "StdlibMap could not resolve #{library.inspect}" }
-            return
-          end
-          generated_pins = pins
-          logger.debug { "Found #{generated_pins.length} pins for stdlib library #{library}" }
-          PinCache.serialize_stdlib_require library, generated_pins
-        end
-      end
-
-      # @return [RBS::Collection::Sources::Stdlib]
-      def self.source
-        @source ||= RBS::Collection::Sources::Stdlib.instance
-      end
-
-      # @param name [String]
-      # @param version [String, nil]
-      # @return [Array<Hash{String => String}>, nil]
-      def self.stdlib_dependencies name, version = nil
-        if source.has?(name, version)
-          # @sg-ignore we are relying on undocumented behavior where
-          #   passing version=nil gives the latest version it has
-          source.dependencies_of(name, version)
-        else
-          []
-        end
-      end
-
-      def resolve_dependencies?
-        # there are 'virtual' dependencies for stdlib gems in RBS that
-        # aren't represented in the actual gemspecs that we'd
-        # otherwise use
-        true
-      end
-
-      # @param library [String]
-      # @return [StdlibMap]
-      def self.load library
-        @stdlib_maps_hash[library] ||= StdlibMap.new(library)
-      end
-    end
-  end
-end

data/lib/solargraph/workspace/gemspecs.rb

@@ -1,373 +0,0 @@
-# frozen_string_literal: true
-
-require 'rubygems'
-require 'bundler'
-
-module Solargraph
-  class Workspace
-    # Manages determining which gemspecs are available in a workspace
-    class Gemspecs
-      include Logging
-
-      attr_reader :directory, :preferences
-
-      # @param directory [String, nil] If nil, assume no bundle is present
-      # @param preferences [Array<Gem::Specification>]
-      def initialize directory, preferences: []
-        # @todo an issue with both external bundles and the potential
-        #   preferences feature is that bundler gives you a 'clean'
-        #   rubygems environment with only the specified versions
-        #   installed.  Possible alternatives:
-        #
-        #   *) prompt the user to run solargraph outside of bundler
-        #      and treat all bundles as external
-        #   *) reinstall the needed gems dynamically each time
-        #   *) manipulate the rubygems/bundler environment
-        @directory = directory && File.absolute_path(directory)
-        # @todo implement preferences as a config-exposed feature
-        @preferences = preferences
-      end
-
-      # Take the path given to a 'require' statement in a source file
-      # and return the Gem::Specifications which will be brought into
-      # scope with it, so we can load pins for them.
-      #
-      # @param require [String] The string sent to 'require' in the code to resolve, e.g. 'rails', 'bundler/require'
-      # @return [::Array<Gem::Specification>, nil]
-      def resolve_require require
-        return nil if require.empty?
-
-        # This is added in the parser when it sees 'Bundler.require' -
-        # see https://bundler.io/guides/bundler_setup.html '
-        #
-        # @todo handle different arguments to Bundler.require
-        return auto_required_gemspecs_from_bundler if require == 'bundler/require'
-
-        # Determine gem name based on the require path
-        file = "lib/#{require}.rb"
-        spec_with_path = Gem::Specification.find_by_path(file)
-
-        all_gemspecs = all_gemspecs_from_bundle
-
-        gem_names_to_try = [
-          spec_with_path&.name,
-          require.tr('/', '-'),
-          require.split('/').first
-        ].compact.uniq
-        # @param gem_name [String]
-        gem_names_to_try.each do |gem_name|
-          # @sg-ignore Unresolved call to == on Boolean
-          gemspec = all_gemspecs.find { |gemspec| gemspec.name == gem_name }
-          # @sg-ignore flow sensitive typing should be able to handle redefinition
-          return [gemspec_or_preference(gemspec)] if gemspec
-
-          begin
-            gemspec = Gem::Specification.find_by_name(gem_name)
-            # @sg-ignore flow sensitive typing should be able to handle redefinition
-            return [gemspec_or_preference(gemspec)] if gemspec
-          rescue Gem::MissingSpecError
-            logger.debug do
-              "Require path #{require} could not be resolved to a gem via find_by_path or guess of #{gem_name}"
-            end
-          end
-
-          # look ourselves just in case this is hanging out somewhere
-          # that find_by_path doesn't index
-          gemspec = all_gemspecs.find do |spec|
-            spec = to_gem_specification(spec) unless spec.respond_to?(:files)
-
-            # @sg-ignore Translate to something flow sensitive typing understands
-            spec&.files&.any? { |gemspec_file| file == gemspec_file }
-          end
-          # @sg-ignore flow sensitive typing should be able to handle redefinition
-          return [gemspec_or_preference(gemspec)] if gemspec
-        end
-
-        nil
-      end
-
-      # @param stdlib_name [String]
-      #
-      # @return [Array<String>]
-      def stdlib_dependencies stdlib_name
-        deps = RbsMap::StdlibMap.stdlib_dependencies(stdlib_name, nil) || []
-        deps.map { |dep| dep['name'] }.compact
-      end
-
-      # @param name [String]
-      # @param version [String, nil]
-      # @param out [IO, nil] output stream for logging
-      #
-      # @return [Gem::Specification, nil]
-      def find_gem name, version = nil, out: $stderr
-        # @sg-ignore flow sensitive typing should be able to handle redefinition
-        specish = all_gemspecs_from_bundle.find { |specish| specish.name == name && specish.version == version }
-        return to_gem_specification specish if specish
-
-        # @sg-ignore flow sensitive typing should be able to handle redefinition
-        specish = all_gemspecs_from_bundle.find { |specish| specish.name == name }
-        # @sg-ignore flow sensitive typing needs to create separate ranges for postfix if
-        return to_gem_specification specish if specish
-
-        resolve_gem_ignoring_local_bundle name, version, out: out
-      end
-
-      # @param gemspec [Gem::Specification]
-      # @param out[IO, nil] output stream for logging
-      #
-      # @return [Array<Gem::Specification>]
-      def fetch_dependencies gemspec, out: $stderr
-        all_gemspecs_from_bundle
-
-        # @type [Hash{String => Gem::Specification}]
-        deps_so_far = {}
-
-        # @param runtime_dep [Gem::Dependency]
-        # @param deps [Hash{String => Gem::Specification}]
-        gem_dep_gemspecs = only_runtime_dependencies(gemspec).each_with_object(deps_so_far) do |runtime_dep, deps|
-          dep = find_gem(runtime_dep.name, runtime_dep.requirement)
-          next unless dep
-
-          fetch_dependencies(dep, out: out).each { |sub_dep| deps[sub_dep.name] ||= sub_dep }
-
-          deps[dep.name] ||= dep
-        end
-
-        # RBS tracks implicit dependencies, like how the YAML standard
-        # library implies pulling in the psych library.
-        stdlib_deps = RbsMap::StdlibMap.stdlib_dependencies(gemspec.name, gemspec.version) || []
-        stdlib_dep_gemspecs = stdlib_deps.map { |dep| find_gem(dep['name'], dep['version']) }.compact
-        (gem_dep_gemspecs.values.compact + stdlib_dep_gemspecs).uniq(&:name)
-      end
-
-      # Returns all gemspecs directly depended on by this workspace's
-      # bundle (does not include transitive dependencies).
-      #
-      # @return [Array<Gem::Specification, Bundler::LazySpecification, Bundler::StubSpecification>]
-      def all_gemspecs_from_bundle
-        return [] unless directory
-
-        @all_gemspecs_from_bundle ||=
-          if in_this_bundle?
-            all_gemspecs_from_this_bundle
-          else
-            all_gemspecs_from_external_bundle
-          end
-      end
-
-      # @return [Hash{Gem::Specification, Bundler::LazySpecification, Bundler::StubSpecification => Gem::Specification}]
-      def self.gem_specification_cache
-        @gem_specification_cache ||= {}
-      end
-
-      private
-
-      # @param specish [Gem::Specification, Bundler::LazySpecification, Bundler::StubSpecification]
-      #
-      # @return [Gem::Specification, nil]
-      # @sg-ignore flow sensitive typing needs better handling of ||= on lvars
-      def to_gem_specification specish
-        # print time including milliseconds
-        self.class.gem_specification_cache[specish] ||= case specish
-                                                        when Gem::Specification
-                                                          specish
-                                                        when Bundler::LazySpecification
-                                                          # materializing didn't work.  Let's look in the local
-                                                          # rubygems without bundler's help
-                                                          resolve_gem_ignoring_local_bundle specish.name,
-                                                                                            specish.version
-                                                        when Bundler::StubSpecification
-                                                          # turns a Bundler::StubSpecification into a
-                                                          # Gem::StubSpecification if we can
-                                                          if specish.respond_to?(:stub)
-                                                            # @sg-ignore flow sensitive typing ought to be able to handle 'when ClassName'
-                                                            to_gem_specification specish.stub
-                                                          else
-                                                            # A Bundler::StubSpecification is a Bundler::
-                                                            # RemoteSpecification which ought to proxy a Gem::
-                                                            # Specification
-                                                            specish
-                                                          end
-                                                        # @sg-ignore Unresolved constant Gem::StubSpecification
-                                                        when Gem::StubSpecification
-                                                          # @sg-ignore Unresolved call to to_spec on Gem::Specification, Bundler::LazySpecification, Bundler::StubSpecification
-                                                          specish.to_spec
-                                                        else
-                                                          raise "Unexpected type while resolving gem: #{specish.class}"
-                                                        end
-      end
-
-      # @param command [String] The expression to evaluate in the external bundle
-      # @sg-ignore Need a JSON type
-      # @yield [undefined, nil]
-      def query_external_bundle command
-        Solargraph.with_clean_env do
-          cmd = [
-            'ruby', '-e',
-            "require 'bundler'; require 'json'; Dir.chdir('#{directory}') { puts begin; #{command}; end.to_json }"
-          ]
-          o, e, s = Open3.capture3(*cmd)
-          if s.success?
-            Solargraph.logger.debug "External bundle: #{o}"
-            o && !o.empty? ? JSON.parse(o.split("\n").last) : nil
-          else
-            Solargraph.logger.warn e
-            raise BundleNotFoundError, "Failed to load gems from bundle at #{directory}"
-          end
-        end
-      end
-
-      # @sg-ignore need boolish support for ? methods
-      def in_this_bundle?
-        Bundler.definition&.lockfile&.to_s&.start_with?(directory)
-      rescue Bundler::GemfileNotFound
-        # Solargraph itself isn't running under a discoverable Gemfile
-        # (e.g. installed and invoked as a standalone gem), so it can't
-        # be "this bundle" - fall back to treating the workspace as an
-        # external bundle.
-        false
-      end
-
-      # @return [Array<Gem::Specification, Bundler::LazySpecification, Bundler::StubSpecification>]
-      def all_gemspecs_from_this_bundle
-        # Find only the gems bundler is now using
-        specish_objects = Bundler.definition.locked_gems.specs
-        if specish_objects.first.respond_to?(:materialize_for_installation)
-          specish_objects = specish_objects.map(&:materialize_for_installation)
-        end
-        specish_objects.map do |specish|
-          if specish.respond_to?(:name) && specish.respond_to?(:version) && specish.respond_to?(:gem_dir)
-            # duck type is good enough for outside uses!
-            specish
-          else
-            to_gem_specification(specish)
-          end
-        end.compact
-      end
-
-      # @return [Array<Gem::Specification, Bundler::LazySpecification, Bundler::StubSpecification>]
-      def auto_required_gemspecs_from_bundler
-        return [] unless directory
-
-        logger.info 'Fetching gemspecs autorequired from Bundler (bundler/require)'
-        @auto_required_gemspecs_from_bundler ||=
-          if in_this_bundle?
-            auto_required_gemspecs_from_this_bundle
-          else
-            auto_required_gemspecs_from_external_bundle
-          end
-      end
-
-      # @return [Array<Gem::Specification, Bundler::LazySpecification, Bundler::StubSpecification>]
-      def auto_required_gemspecs_from_this_bundle
-        # Adapted from require() in lib/bundler/runtime.rb
-        dep_names = Bundler.definition.dependencies.select do |dep|
-          dep.groups.include?(:default) && dep.should_include?
-        end.map(&:name)
-
-        all_gemspecs_from_bundle.select { |gemspec| dep_names.include?(gemspec.name) }
-      end
-
-      # @return [Array<Gem::Specification, Bundler::LazySpecification, Bundler::StubSpecification>]
-      def auto_required_gemspecs_from_external_bundle
-        @auto_required_gemspecs_from_external_bundle ||=
-          begin
-            logger.info 'Fetching auto-required gemspecs from Bundler (bundler/require)'
-            command =
-              'Bundler.definition.dependencies' \
-              '.select { |dep| dep.groups.include?(:default) && dep.should_include? }' \
-              '.map(&:name)'
-            # @sg-ignore
-            # @type [Array<String>]
-            dep_names = query_external_bundle command
-
-            all_gemspecs_from_bundle.select { |gemspec| dep_names.include?(gemspec.name) }
-          end
-      end
-
-      # @param gemspec [Gem::Specification]
-      # @return [Array<Gem::Dependency>]
-      def only_runtime_dependencies gemspec
-        unless gemspec.respond_to?(:dependencies) && gemspec.respond_to?(:development_dependencies)
-          gemspec = to_gem_specification(gemspec)
-        end
-        return [] if gemspec.nil?
-
-        gemspec.dependencies - gemspec.development_dependencies
-      end
-
-      # @todo Should this be using Gem::SpecFetcher and pull them automatically?
-      #
-      # @param name [String]
-      # @param version_or_requirement [String, nil]
-      # @param out [IO, nil] output stream for logging
-      #
-      # @return [Gem::Specification, nil]
-      def resolve_gem_ignoring_local_bundle name, version_or_requirement = nil, out: $stderr
-        Gem::Specification.find_by_name(name, version_or_requirement)
-      rescue Gem::MissingSpecError
-        begin
-          Gem::Specification.find_by_name(name)
-        rescue Gem::MissingSpecError
-          stdlibmap = RbsMap::StdlibMap.new(name)
-          unless stdlibmap.resolved?
-            gem_desc = name
-            gem_desc += ":#{version_or_requirement}" if version_or_requirement
-            out&.puts "Please install the gem #{gem_desc} in Solargraph's Ruby environment"
-          end
-          nil # either not here or in stdlib
-        end
-      end
-
-      # @sg-ignore return type could not be inferred
-      # @return [Array<Gem::Specification>]
-      def all_gemspecs_from_external_bundle
-        @all_gemspecs_from_external_bundle ||=
-          begin
-            logger.info 'Fetching gemspecs required from external bundle'
-
-            command = 'specish_objects = Bundler.definition.locked_gems&.specs; ' \
-                      'if specish_objects.first.respond_to?(:materialize_for_installation);' \
-                      'specish_objects = specish_objects.map(&:materialize_for_installation);' \
-                      'end;' \
-                      'specish_objects.map { |specish| [specish.name, specish.version] }'
-            # @type [Array<Gem::Specification>]
-            query_external_bundle(command).map do |name, version|
-              resolve_gem_ignoring_local_bundle(name, version)
-            end.compact
-          rescue Solargraph::BundleNotFoundError => e
-            Solargraph.logger.info e.message
-            # @sg-ignore Need to add nil check here
-            Solargraph.logger.debug e.backtrace.join("\n")
-            []
-          end
-      end
-
-      # @return [Hash{String => Gem::Specification}]
-      def preference_map
-        @preference_map ||= preferences.to_h { |gemspec| [gemspec.name, gemspec] }
-      end
-
-      # @param gemspec [Gem::Specification]
-      #
-      # @return [Gem::Specification]
-      def gemspec_or_preference gemspec
-        return gemspec unless preference_map.key?(gemspec.name)
-        return gemspec if gemspec.version == preference_map[gemspec.name].version
-
-        change_gemspec_version gemspec, preference_map[gemspec.name].version
-      end
-
-      # @param gemspec [Gem::Specification]
-      # @param version [String]
-      # @return [Gem::Specification]
-      def change_gemspec_version gemspec, version
-        Gem::Specification.find_by_name(gemspec.name, "= #{version}")
-      rescue Gem::MissingSpecError
-        Solargraph.logger.info "Gem #{gemspec.name} version #{version.inspect} not found. " \
-                               "Using #{gemspec.version} instead"
-        gemspec
-      end
-    end
-  end
-end