solargraph 0.39.7

data/lib/solargraph/diagnostics/rubocop_helpers.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Diagnostics
+    # Utility methods for the RuboCop diagnostics reporter.
+    #
+    module RubocopHelpers
+      module_function
+
+      # Generate command-line options for the specified filename and code.
+      #
+      # @param filename [String]
+      # @param code [String]
+      # @return [Array(Array<String>, Array<String>)]
+      def generate_options filename, code
+        args = ['-f', 'j']
+        rubocop_file = find_rubocop_file(filename)
+        args.push('-c', fix_drive_letter(rubocop_file)) unless rubocop_file.nil?
+        args.push filename
+        base_options = RuboCop::Options.new
+        options, paths = base_options.parse(args)
+        options[:stdin] = code
+        [options, paths]
+      end
+
+      # Find a RuboCop configuration file in a file's directory tree.
+      #
+      # @param filename [String]
+      # @return [String, nil]
+      def find_rubocop_file filename
+        return nil unless File.exist?(filename)
+        filename = File.realpath(filename)
+        dir = File.dirname(filename)
+        until File.dirname(dir) == dir
+          here = File.join(dir, '.rubocop.yml')
+          return here if File.exist?(here)
+          dir = File.dirname(dir)
+        end
+        nil
+      end
+
+      # RuboCop internally uses capitalized drive letters for Windows paths,
+      # so we need to convert the paths provided to the command.
+      #
+      # @param path [String]
+      # @return [String]
+      def fix_drive_letter path
+        return path unless path.match(/^[a-z]:/)
+        path[0].upcase + path[1..-1]
+      end
+
+      # @todo This is a smelly way to redirect output, but the RuboCop specs do
+      #   the same thing.
+      # @return [String]
+      def redirect_stdout
+        redir = StringIO.new
+        $stdout = redir
+        yield if block_given?
+        $stdout = STDOUT
+        redir.string
+      end
+    end
+  end
+end

data/lib/solargraph/diagnostics/severities.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Diagnostics
+    # These severity constants match the DiagnosticSeverity constants in the
+    # language server protocol.
+    #
+    module Severities
+      ERROR = 1
+      WARNING = 2
+      INFORMATION = 3
+      HINT = 4
+    end
+  end
+end

data/lib/solargraph/diagnostics/type_check.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Diagnostics
+    # TypeCheck reports methods with undefined return types, untagged
+    # parameters, and invalid param tags.
+    #
+    class TypeCheck < Base
+      def diagnose source, api_map
+        return [] unless args.include?('always') || api_map.workspaced?(source.filename)
+        severity = Diagnostics::Severities::ERROR
+        level = (args.reverse.find { |a| ['normal', 'typed', 'strict', 'strong'].include?(a) }) || :normal
+        checker = Solargraph::TypeChecker.new(source.filename, api_map: api_map, level: level.to_sym)
+        checker.problems
+          .sort { |a, b| a.location.range.start.line <=> b.location.range.start.line }
+          .map do |problem|
+            {
+              range: extract_first_line(problem.location, source),
+              severity: severity,
+              source: 'Typecheck',
+              message: problem.message
+            }
+          end
+      end
+
+      private
+
+      # @param location [Location]
+      # @param source [Source]
+      # @return [Hash]
+      def extract_first_line location, source
+        return location.range.to_hash if location.range.start.line == location.range.ending.line
+        {
+          start: {
+            line: location.range.start.line,
+            character: location.range.start.character
+          },
+          end: {
+            line: location.range.start.line,
+            character: last_character(location.range.start, source)
+          }
+        }
+      end
+
+      # @param position [Solargraph::Position]
+      # @param source [Solargraph::Source]
+      # @return [Integer]
+      def last_character position, source
+        cursor = Position.to_offset(source.code, position)
+        source.code.index(/[\r\n]/, cursor) || source.code.length
+      end
+    end
+  end
+end

data/lib/solargraph/diagnostics/update_errors.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Diagnostics
+    class UpdateErrors < Base
+      def diagnose source, api_map
+        result = []
+        combine_ranges(source.code, source.error_ranges).each do |range|
+          result.push(
+            range: range.to_hash,
+            severity: Diagnostics::Severities::ERROR,
+            source: 'Solargraph',
+            message: 'Syntax error'
+          )
+        end
+        result
+      end
+
+      private
+
+      # Combine an array of ranges by their starting lines.
+      #
+      # @param code [String]
+      # @param ranges [Array<Range>]
+      # @return [Array<Range>]
+      def combine_ranges code, ranges
+        result = []
+        lines = []
+        ranges.sort{|a, b| a.start.line <=> b.start.line}.each do |rng|
+          next if rng.nil? || lines.include?(rng.start.line)
+          lines.push rng.start.line
+          next if rng.start.line >= code.lines.length
+          scol = code.lines[rng.start.line].index(/[^\s]/) || 0
+          ecol = code.lines[rng.start.line].length
+          result.push Range.from_to(rng.start.line, scol, rng.start.line, ecol)
+        end
+        result
+      end
+    end
+  end
+end

data/lib/solargraph/documentor.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'bundler'
+require 'json'
+require 'open3'
+require 'shellwords'
+require 'yard'
+require 'fileutils'
+
+module Solargraph
+  class Documentor
+    RDOC_GEMS = %w[
+      actioncable actionmailbox actionmailer actionpack actiontext actionview
+      activejob activemodel activerecord activestorage activesupport railties
+    ]
+
+    def initialize directory, rebuild: false, out: File.new(File::NULL, 'w')
+      @directory = directory
+      @rebuild = rebuild
+      @out = out
+    end
+
+    # @return [Boolean] True if all specs were found and documented.
+    def document
+      failures = 0
+      Documentor.specs_from_bundle(@directory).each_pair do |name, version|
+        yd = YARD::Registry.yardoc_file_for_gem(name, "= #{version}")
+        if !yd || @rebuild
+          FileUtils.safe_unlink File.join(YardMap::CoreDocs.cache_dir, 'gems', "#{name}-#{version}.ser")
+          @out.puts "Documenting #{name} #{version}"
+          `yard gems #{name} #{version} #{@rebuild ? '--rebuild' : ''}`
+          yd = YARD::Registry.yardoc_file_for_gem(name, "= #{version}")
+          # HACK: Ignore errors documenting bundler
+          if !yd && name != 'bundler'
+            @out.puts "#{name} #{version} YARD documentation failed"
+            failures += 1
+          end
+        end
+        if yd && RDOC_GEMS.include?(name)
+          cache = File.join(Solargraph::YardMap::CoreDocs.cache_dir, 'gems', "#{name}-#{version}", 'yardoc')
+          if !File.exist?(cache) || @rebuild
+            @out.puts "Caching custom documentation for #{name} #{version}"
+            spec = Gem::Specification.find_by_name(name, "= #{version}")
+            Solargraph::YardMap::RdocToYard.run(spec)
+          end
+        end
+      end
+      if failures > 0
+        @out.puts "#{failures} gem#{failures == 1 ? '' : 's'} could not be documented. You might need to run `bundle install`."
+      end
+      failures == 0
+    rescue Solargraph::BundleNotFoundError => e
+      @out.puts "[#{e.class}] #{e.message}"
+      @out.puts "No bundled gems are available in #{@directory}"
+      false
+    end
+
+    def self.specs_from_bundle directory
+      Solargraph.with_clean_env do
+        Dir.chdir directory do
+          cmd = [
+            'bundle', 'exec', 'ruby', '-e',
+            "require 'bundler'; require 'json'; puts Bundler.definition.specs_for([:default]).map { |spec| [spec.name, spec.version] }.to_h.to_json"
+          ]
+          o, e, s = Open3.capture3(*cmd)
+          if s.success?
+            o && !o.empty? ? JSON.parse(o.split("\n").last) : {}
+          else
+            Solargraph.logger.warn e
+            raise BundleNotFoundError, "Failed to load gems from bundle at #{directory}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/environ.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Environ
+    # @return [Array<String>]
+    attr_reader :requires
+
+    # @return [Array<String>]
+    attr_reader :domains
+
+    # @return [Array<Pin::Reference::Override>]
+    attr_reader :overrides
+
+    # @param requires [Array<String>]
+    # @param domains [Array<String>]
+    # @param overrides [Array<Pin::Reference::Override>]
+    def initialize requires: [], domains: [], overrides: []
+      @requires = requires
+      @domains = domains
+      @overrides = overrides
+    end
+
+    # @return [self]
+    def clear
+      domains.clear
+      requires.clear
+      overrides.clear
+      self
+    end
+
+    # @param other [Environ]
+    # @return [self]
+    def merge other
+      domains.concat other.domains
+      requires.concat other.requires
+      overrides.concat other.overrides
+      self
+    end
+  end
+end

data/lib/solargraph/language_server.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'solargraph/language_server/error_codes'
+require 'solargraph/language_server/completion_item_kinds'
+require 'solargraph/language_server/symbol_kinds'
+
+module Solargraph
+  # The LanguageServer namespace contains the classes and modules that compose
+  # concrete implementations of language servers.
+  #
+  module LanguageServer
+    autoload :Host,         'solargraph/language_server/host'
+    autoload :Message,      'solargraph/language_server/message'
+    autoload :UriHelpers,   'solargraph/language_server/uri_helpers'
+    autoload :MessageTypes, 'solargraph/language_server/message_types'
+    autoload :Request,      'solargraph/language_server/request'
+    autoload :Transport,    'solargraph/language_server/transport'
+  end
+end

data/lib/solargraph/language_server/completion_item_kinds.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module LanguageServer
+    # The CompletionItemKind constants for the language server protocol.
+    #
+    module CompletionItemKinds
+      TEXT = 1
+      METHOD = 2
+      FUNCTION = 3
+      CONSTRUCTOR = 4
+      FIELD = 5
+      VARIABLE = 6
+      CLASS = 7
+      INTERFACE = 8
+      MODULE = 9
+      PROPERTY = 10
+      UNIT = 11
+      VALUE = 12
+      ENUM = 13
+      KEYWORD = 14
+      SNIPPET = 15
+      COLOR = 16
+      FILE = 17
+      REFERENCE = 18
+      FOLDER = 19
+      ENUM_MEMBER = 20
+      CONSTANT = 21
+      STRUCT = 22
+      EVENT = 23
+      OPERATOR = 24
+      TYPE_PARAMETER = 25
+    end
+  end
+end

data/lib/solargraph/language_server/error_codes.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module LanguageServer
+    # The ErrorCode constants for the language server protocol.
+    #
+    module ErrorCodes
+      PARSE_ERROR =            -32700
+      INVALID_REQUEST =        -32600
+      METHOD_NOT_FOUND =       -32601
+      INVALID_PARAMS =         -32602
+      INTERNAL_ERROR =         -32603
+      SERVER_ERROR_START =     -32099
+      SERVER_ERROR_END =       -32000
+      SERVER_NOT_INITIALIZED = -32002
+      UNKNOWN_ERROR_CODE =     -32001
+      REQUEST_CANCELLED =      -32800
+    end
+  end
+end

data/lib/solargraph/language_server/host.rb

@@ -0,0 +1,741 @@
+# frozen_string_literal: true
+
+require 'observer'
+require 'set'
+
+module Solargraph
+  module LanguageServer
+    # The language server protocol's data provider. Hosts are responsible for
+    # querying the library and processing messages. They also provide thread
+    # safety for multi-threaded transports.
+    #
+    class Host
+      autoload :Diagnoser, 'solargraph/language_server/host/diagnoser'
+      autoload :Cataloger, 'solargraph/language_server/host/cataloger'
+      autoload :Sources,   'solargraph/language_server/host/sources'
+      autoload :Dispatch,  'solargraph/language_server/host/dispatch'
+
+      include UriHelpers
+      include Logging
+      include Dispatch
+      include Observable
+
+      attr_writer :client_capabilities
+
+      def initialize
+        @cancel_semaphore = Mutex.new
+        @buffer_semaphore = Mutex.new
+        @register_semaphore = Mutex.new
+        @cancel = []
+        @buffer = String.new
+        @stopped = true
+        @next_request_id = 0
+        @dynamic_capabilities = Set.new
+        @registered_capabilities = Set.new
+      end
+
+      # Start asynchronous process handling.
+      #
+      # @return [void]
+      def start
+        return unless stopped?
+        @stopped = false
+        diagnoser.start
+        cataloger.start
+        sources.start
+      end
+
+      # Update the configuration options with the provided hash.
+      #
+      # @param update [Hash]
+      # @return [void]
+      def configure update
+        return if update.nil?
+        options.merge! update
+        logger.level = LOG_LEVELS[options['logLevel']] || DEFAULT_LOG_LEVEL
+      end
+
+      # @return [Hash]
+      def options
+        @options ||= default_configuration
+      end
+
+      # Cancel the method with the specified ID.
+      #
+      # @param id [Integer]
+      # @return [void]
+      def cancel id
+        @cancel_semaphore.synchronize { @cancel.push id }
+      end
+
+      # True if the host received a request to cancel the method with the
+      # specified ID.
+      #
+      # @param id [Integer]
+      # @return [Boolean]
+      def cancel? id
+        result = false
+        @cancel_semaphore.synchronize { result = @cancel.include? id }
+        result
+      end
+
+      # Delete the specified ID from the list of cancelled IDs if it exists.
+      #
+      # @param id [Integer]
+      # @return [void]
+      def clear id
+        @cancel_semaphore.synchronize { @cancel.delete id }
+      end
+
+      # Start processing a request from the client. After the message is
+      # processed, the transport is responsible for sending the response.
+      #
+      # @param request [Hash] The contents of the message.
+      # @return [Solargraph::LanguageServer::Message::Base] The message handler.
+      def receive request
+        if request['method']
+          logger.info "Server received #{request['method']}"
+          logger.debug request
+          message = Message.select(request['method']).new(self, request)
+          begin
+            message.process
+          rescue StandardError => e
+            logger.warn "Error processing request: [#{e.class}] #{e.message}"
+            logger.warn e.backtrace.join("\n")
+            message.set_error Solargraph::LanguageServer::ErrorCodes::INTERNAL_ERROR, "[#{e.class}] #{e.message}"
+          end
+          message
+        elsif request['id']
+          # @todo What if the id is invalid?
+          requests[request['id']].process(request['result'])
+          requests.delete request['id']
+        else
+          logger.warn "Invalid message received."
+          logger.debug request
+        end
+      end
+
+      # Respond to a notification that a file was created in the workspace.
+      # The libraries will determine whether the file should be merged; see
+      # Solargraph::Library#create_from_disk.
+      #
+      # @param uri [String] The file uri.
+      # @return [Boolean] True if a library accepted the file.
+      def create uri
+        filename = uri_to_file(uri)
+        result = false
+        libraries.each do |lib|
+          result = true if lib.create_from_disk(filename)
+        end
+        diagnoser.schedule uri if open?(uri)
+        result
+      end
+
+      # Delete the specified file from the library.
+      #
+      # @param uri [String] The file uri.
+      # @return [void]
+      def delete uri
+        filename = uri_to_file(uri)
+        libraries.each do |lib|
+          lib.delete(filename)
+        end
+        send_notification "textDocument/publishDiagnostics", {
+          uri: uri,
+          diagnostics: []
+        }
+      end
+
+      # Open the specified file in the library.
+      #
+      # @param uri [String] The file uri.
+      # @param text [String] The contents of the file.
+      # @param version [Integer] A version number.
+      # @return [void]
+      def open uri, text, version
+        src = sources.open(uri, text, version)
+        libraries.each do |lib|
+          lib.merge src
+        end
+        diagnoser.schedule uri
+      end
+
+      # @param uri [String]
+      # @return [void]
+      def open_from_disk uri
+        sources.open_from_disk(uri)
+        library = library_for(uri)
+        # library.open_from_disk uri_to_file(uri)
+        diagnoser.schedule uri
+      end
+
+      # True if the specified file is currently open in the library.
+      #
+      # @param uri [String]
+      # @return [Boolean]
+      def open? uri
+        sources.include? uri
+      end
+
+      # Close the file specified by the URI.
+      #
+      # @param uri [String]
+      # @return [void]
+      def close uri
+        logger.info "Closing #{uri}"
+        sources.close uri
+        diagnoser.schedule uri
+      end
+
+      # @param uri [String]
+      # @return [void]
+      def diagnose uri
+        if sources.include?(uri)
+          library = library_for(uri)
+          if library.synchronized?
+            logger.info "Diagnosing #{uri}"
+            begin
+              results = library.diagnose uri_to_file(uri)
+              send_notification "textDocument/publishDiagnostics", {
+                uri: uri,
+                diagnostics: results
+              }
+            rescue DiagnosticsError => e
+              logger.warn "Error in diagnostics: #{e.message}"
+              options['diagnostics'] = false
+              send_notification 'window/showMessage', {
+                type: LanguageServer::MessageTypes::ERROR,
+                message: "Error in diagnostics: #{e.message}"
+              }
+            rescue FileNotFoundError => e
+              # @todo This appears to happen when an external file is open and
+              #   scheduled for diagnosis, but the file was closed (i.e., the
+              #   editor moved to a different file) before diagnosis started
+              logger.warn "Unable to diagnose #{uri} : #{e.message}"
+              send_notification 'textDocument/publishDiagnostics', {
+                uri: uri,
+                diagnostics: []
+              }
+            end
+          else
+            logger.info "Deferring diagnosis of #{uri}"
+            diagnoser.schedule uri
+          end
+        else
+          send_notification 'textDocument/publishDiagnostics', {
+            uri: uri,
+            diagnostics: []
+          }
+        end
+      end
+
+      # Update a document from the parameters of a textDocument/didChange
+      # method.
+      #
+      # @param params [Hash]
+      # @return [void]
+      def change params
+        updater = generate_updater(params)
+        sources.async_update params['textDocument']['uri'], updater
+        diagnoser.schedule params['textDocument']['uri']
+      end
+
+      # Queue a message to be sent to the client.
+      #
+      # @param message [String] The message to send.
+      # @return [void]
+      def queue message
+        @buffer_semaphore.synchronize { @buffer += message }
+        changed
+        notify_observers
+      end
+
+      # Clear the message buffer and return the most recent data.
+      #
+      # @return [String] The most recent data or an empty string.
+      def flush
+        tmp = ''
+        @buffer_semaphore.synchronize do
+          tmp = @buffer.clone
+          @buffer.clear
+        end
+        tmp
+      end
+
+      # Prepare a library for the specified directory.
+      #
+      # @param directory [String]
+      # @param name [String, nil]
+      # @return [void]
+      def prepare directory, name = nil
+        # No need to create a library without a directory. The generic library
+        # will handle it.
+        return if directory.nil?
+        logger.info "Preparing library for #{directory}"
+        path = ''
+        path = normalize_separators(directory) unless directory.nil?
+        begin
+          lib = Solargraph::Library.load(path, name)
+          libraries.push lib
+        rescue WorkspaceTooLargeError => e
+          send_notification 'window/showMessage', {
+            'type' => Solargraph::LanguageServer::MessageTypes::WARNING,
+            'message' => e.message
+          }
+        end
+      end
+
+      # Prepare multiple folders.
+      #
+      # @param array [Array<Hash{String => String}>]
+      # @return [void]
+      def prepare_folders array
+        return if array.nil?
+        array.each do |folder|
+          prepare uri_to_file(folder['uri']), folder['name']
+        end
+      end
+
+      # Remove a directory.
+      #
+      # @param directory [String]
+      # @return [void]
+      def remove directory
+        logger.info "Removing library for #{directory}"
+        # @param lib [Library]
+        libraries.delete_if do |lib|
+          next false if lib.workspace.directory != directory
+          true
+        end
+      end
+
+      # @param array [Array<Hash>]
+      # @return [void]
+      def remove_folders array
+        array.each do |folder|
+          remove uri_to_file(folder['uri'])
+        end
+      end
+
+      # @return [Array<String>]
+      def folders
+        libraries.map { |lib| lib.workspace.directory }
+      end
+
+      # Send a notification to the client.
+      #
+      # @param method [String] The message method
+      # @param params [Hash] The method parameters
+      # @return [void]
+      def send_notification method, params
+        response = {
+          jsonrpc: "2.0",
+          method: method,
+          params: params
+        }
+        json = response.to_json
+        envelope = "Content-Length: #{json.bytesize}\r\n\r\n#{json}"
+        queue envelope
+        logger.info "Server sent #{method}"
+        logger.debug params
+      end
+
+      # Send a request to the client and execute the provided block to process
+      # the response. If an ID is not provided, the host will use an auto-
+      # incrementing integer.
+      #
+      # @param method [String] The message method
+      # @param params [Hash] The method parameters
+      # @param block [Proc] The block that processes the response
+      # @yieldparam [Hash] The result sent by the client
+      # @return [void]
+      def send_request method, params, &block
+        message = {
+          jsonrpc: "2.0",
+          method: method,
+          params: params,
+          id: @next_request_id
+        }
+        json = message.to_json
+        requests[@next_request_id] = Request.new(@next_request_id, &block)
+        envelope = "Content-Length: #{json.bytesize}\r\n\r\n#{json}"
+        queue envelope
+        @next_request_id += 1
+        logger.info "Server sent #{method}"
+        logger.debug params
+      end
+
+      # Register the methods as capabilities with the client.
+      # This method will avoid duplicating registrations and ignore methods
+      # that were not flagged for dynamic registration by the client.
+      #
+      # @param methods [Array<String>] The methods to register
+      # @return [void]
+      def register_capabilities methods
+        logger.debug "Registering capabilities: #{methods}"
+        registrations = methods.select{|m| can_register?(m) and !registered?(m)}.map { |m|
+          @registered_capabilities.add m
+          {
+            id: m,
+            method: m,
+            registerOptions: dynamic_capability_options[m]
+          }
+        }
+        return if registrations.empty?
+        @register_semaphore.synchronize do
+          send_request 'client/registerCapability', {
+            registrations: registrations
+          }
+        end
+      end
+
+      # Unregister the methods with the client.
+      # This method will avoid duplicating unregistrations and ignore methods
+      # that were not flagged for dynamic registration by the client.
+      #
+      # @param methods [Array<String>] The methods to unregister
+      # @return [void]
+      def unregister_capabilities methods
+        logger.debug "Unregistering capabilities: #{methods}"
+        unregisterations = methods.select{|m| registered?(m)}.map{ |m|
+          @registered_capabilities.delete m
+          {
+            id: m,
+            method: m
+          }
+        }
+        return if unregisterations.empty?
+        @register_semaphore.synchronize do
+          send_request 'client/unregisterCapability', {
+            unregisterations: unregisterations
+          }
+        end
+      end
+
+      # Flag a method as available for dynamic registration.
+      #
+      # @param method [String] The method name, e.g., 'textDocument/completion'
+      # @return [void]
+      def allow_registration method
+        @register_semaphore.synchronize do
+          @dynamic_capabilities.add method
+        end
+      end
+
+      # True if the specified LSP method can be dynamically registered.
+      #
+      # @param method [String]
+      # @return [Boolean]
+      def can_register? method
+        @dynamic_capabilities.include?(method)
+      end
+
+      # True if the specified method has been registered.
+      #
+      # @param method [String] The method name, e.g., 'textDocument/completion'
+      # @return [Boolean]
+      def registered? method
+        @registered_capabilities.include?(method)
+      end
+
+      def synchronizing?
+        !libraries.all?(&:synchronized?)
+      end
+
+      # @return [void]
+      def stop
+        return if @stopped
+        @stopped = true
+        cataloger.stop
+        diagnoser.stop
+        sources.stop
+        changed
+        notify_observers
+      end
+
+      def stopped?
+        @stopped
+      end
+
+      # Locate multiple pins that match a completion item. The first match is
+      # based on the corresponding location in a library source if available.
+      # Subsequent matches are based on path.
+      #
+      # @param params [Hash] A hash representation of a completion item
+      # @return [Array<Pin::Base>]
+      def locate_pins params
+        return [] unless params['data'] && params['data']['uri']
+        library = library_for(params['data']['uri'])
+        result = []
+        if params['data']['location']
+          location = Location.new(
+            params['data']['location']['filename'],
+            Range.from_to(
+              params['data']['location']['range']['start']['line'],
+              params['data']['location']['range']['start']['character'],
+              params['data']['location']['range']['end']['line'],
+              params['data']['location']['range']['end']['character']
+            )
+          )
+          result.concat library.locate_pins(location).select{ |pin| pin.name == params['label'] }
+        end
+        if params['data']['path']
+          result.concat library.path_pins(params['data']['path'])
+        end
+        # Selecting by both location and path can result in duplicate pins
+        result.uniq { |p| [p.path, p.location] }
+      end
+
+      # @param uri [String]
+      # @return [String]
+      def read_text uri
+        library = library_for(uri)
+        filename = uri_to_file(uri)
+        library.read_text(filename)
+      end
+
+      # @param uri [String]
+      # @param line [Integer]
+      # @param column [Integer]
+      # @return [Solargraph::SourceMap::Completion]
+      def completions_at uri, line, column
+        library = library_for(uri)
+        library.completions_at uri_to_file(uri), line, column
+      end
+
+      # @param uri [String]
+      # @param line [Integer]
+      # @param column [Integer]
+      # @return [Array<Solargraph::Pin::Base>]
+      def definitions_at uri, line, column
+        library = library_for(uri)
+        library.definitions_at(uri_to_file(uri), line, column)
+      end
+
+      # @param uri [String]
+      # @param line [Integer]
+      # @param column [Integer]
+      # @return [Array<Solargraph::Pin::Base>]
+      def signatures_at uri, line, column
+        library = library_for(uri)
+        library.signatures_at(uri_to_file(uri), line, column)
+      end
+
+      # @param uri [String]
+      # @param line [Integer]
+      # @param column [Integer]
+      # @param strip [Boolean] Strip special characters from variable names
+      # @return [Array<Solargraph::Range>]
+      def references_from uri, line, column, strip: true
+        library = library_for(uri)
+        library.references_from(uri_to_file(uri), line, column, strip: strip)
+      end
+
+      # @param query [String]
+      # @return [Array<Solargraph::Pin::Base>]
+      def query_symbols query
+        result = []
+        (libraries + [generic_library]).each { |lib| result.concat lib.query_symbols(query) }
+        result.uniq
+      end
+
+      # @param query [String]
+      # @return [Array<String>]
+      def search query
+        result = []
+        libraries.each { |lib| result.concat lib.search(query) }
+        result
+      end
+
+      # @param query [String]
+      # @return [Array]
+      def document query
+        result = []
+        libraries.each { |lib| result.concat lib.document(query) }
+        result
+      end
+
+      # @param uri [String]
+      # @return [Array<Solargraph::Pin::Base>]
+      def document_symbols uri
+        library = library_for(uri)
+        # At this level, document symbols should be unique; e.g., a
+        # module_function method should return the location for Module.method
+        # or Module#method, but not both.
+        library.document_symbols(uri_to_file(uri)).uniq(&:location)
+      end
+
+      # Send a notification to the client.
+      #
+      # @param text [String]
+      # @param type [Integer] A MessageType constant
+      # @return [void]
+      def show_message text, type = LanguageServer::MessageTypes::INFO
+        send_notification 'window/showMessage', {
+          type: type,
+          message: text
+        }
+      end
+
+      # Send a notification with optional responses.
+      #
+      # @param text [String]
+      # @param type [Integer] A MessageType constant
+      # @param actions [Array<String>] Response options for the client
+      # @param block The block that processes the response
+      # @yieldparam [String] The action received from the client
+      # @return [void]
+      def show_message_request text, type, actions, &block
+        send_request 'window/showMessageRequest', {
+          type: type,
+          message: text,
+          actions: actions
+        }, &block
+      end
+
+      # Get a list of IDs for server requests that are waiting for responses
+      # from the client.
+      #
+      # @return [Array<Integer>]
+      def pending_requests
+        requests.keys
+      end
+
+      # @return [Hash{String => Object}]
+      def default_configuration
+        {
+          'completion' => true,
+          'hover' => true,
+          'symbols' => true,
+          'definitions' => true,
+          'rename' => true,
+          'references' => true,
+          'autoformat' => false,
+          'diagnostics' => false,
+          'formatting' => false,
+          'folding' => true,
+          'logLevel' => 'warn'
+        }
+      end
+
+      # @param uri [String]
+      # @return [Array<Range>]
+      def folding_ranges uri
+        sources.find(uri).folding_ranges
+      end
+
+      # @return [void]
+      def catalog
+        libraries.each(&:catalog)
+      end
+
+      def client_capabilities
+        @client_capabilities ||= {}
+      end
+
+      private
+
+      # @return [Diagnoser]
+      def diagnoser
+        @diagnoser ||= Diagnoser.new(self)
+      end
+
+      # @return [Cataloger]
+      def cataloger
+        @cataloger ||= Cataloger.new(self)
+      end
+
+      # A hash of client requests by ID. The host uses this to keep track of
+      # pending responses.
+      #
+      # @return [Hash{Integer => Hash}]
+      def requests
+        @requests ||= {}
+      end
+
+      # @param path [String]
+      # @return [String]
+      def normalize_separators path
+        return path if File::ALT_SEPARATOR.nil?
+        path.gsub(File::ALT_SEPARATOR, File::SEPARATOR)
+      end
+
+      # @param params [Hash]
+      # @return [Source::Updater]
+      def generate_updater params
+        changes = []
+        params['contentChanges'].each do |chng|
+          changes.push Solargraph::Source::Change.new(
+            (chng['range'].nil? ? 
+              nil :
+              Solargraph::Range.from_to(chng['range']['start']['line'], chng['range']['start']['character'], chng['range']['end']['line'], chng['range']['end']['character'])
+            ),
+            chng['text']
+          )
+        end
+        Solargraph::Source::Updater.new(
+          uri_to_file(params['textDocument']['uri']),
+          params['textDocument']['version'],
+          changes
+        )
+      end
+
+      # @return [Hash]
+      def dynamic_capability_options
+        @dynamic_capability_options ||= {
+          # textDocumentSync: 2, # @todo What should this be?
+          'textDocument/completion' => {
+            resolveProvider: true,
+            triggerCharacters: ['.', ':', '@']
+          },
+          # hoverProvider: true,
+          # definitionProvider: true,
+          'textDocument/signatureHelp' => {
+            triggerCharacters: ['(', ',', ' ']
+          },
+          # documentFormattingProvider: true,
+          'textDocument/onTypeFormatting' => {
+            firstTriggerCharacter: '{',
+            moreTriggerCharacter: ['(']
+          },
+          # documentSymbolProvider: true,
+          # workspaceSymbolProvider: true,
+          # workspace: {
+            # workspaceFolders: {
+              # supported: true,
+              # changeNotifications: true
+            # }
+          # }
+          'textDocument/definition' => {
+            definitionProvider: true
+          },
+          'textDocument/references' => {
+            referencesProvider: true
+          },
+          'textDocument/rename' => {
+            renameProvider: prepare_rename? ? { prepareProvider: true } : true
+          },
+          'textDocument/documentSymbol' => {
+            documentSymbolProvider: true
+          },
+          'workspace/symbol' => {
+            workspaceSymbolProvider: true
+          },
+          'textDocument/formatting' => {
+            formattingProvider: true
+          },
+          'textDocument/foldingRange' => {
+            foldingRangeProvider: true
+          },
+          'textDocument/codeAction' => {
+            codeActionProvider: true
+          }
+        }
+      end
+
+      def prepare_rename?
+        client_capabilities['rename'] && client_capabilities['rename']['prepareSupport']
+      end
+    end
+  end
+end