solargraph 0.47.2 → 0.53.3

data/lib/solargraph/diagnostics/rubocop.rb

@@ -11,6 +11,7 @@ module Solargraph
 
       # Conversion of RuboCop severity names to LSP constants
       SEVERITIES = {
+        'info' => Severities::HINT,
         'refactor' => Severities::HINT,
         'convention' => Severities::INFORMATION,
         'warning' => Severities::WARNING,
@@ -22,16 +23,20 @@ module Solargraph
       # @param _api_map [Solargraph::ApiMap]
       # @return [Array<Hash>]
       def diagnose source, _api_map
+        @source = source
         require_rubocop(rubocop_version)
         options, paths = generate_options(source.filename, source.code)
         store = RuboCop::ConfigStore.new
         runner = RuboCop::Runner.new(options, store)
         result = redirect_stdout{ runner.run(paths) }
+
+        return [] if result.empty?
+
         make_array JSON.parse(result)
       rescue RuboCop::ValidationError, RuboCop::ConfigNotFoundError => e
         raise DiagnosticsError, "Error in RuboCop configuration: #{e.message}"
-      rescue JSON::ParserError
-        raise DiagnosticsError, 'RuboCop returned invalid data'
+      rescue JSON::ParserError => e
+        raise DiagnosticsError, "RuboCop returned invalid data: #{e.message}"
       end
 
       private
@@ -43,7 +48,7 @@ module Solargraph
         args.find { |a| a =~ /version=/ }.to_s.split('=').last
       end
 
-      # @param resp [Hash]
+      # @param resp [Hash{String => Array<Hash{String => Array<Hash{String => undefined}>}>}]
       # @return [Array<Hash>]
       def make_array resp
         diagnostics = []
@@ -57,8 +62,8 @@ module Solargraph
 
       # Convert a RuboCop offense to an LSP diagnostic
       #
-      # @param off [Hash] Offense received from Rubocop
-      # @return [Hash] LSP diagnostic
+      # @param off [Hash{String => unknown}] Offense received from Rubocop
+      # @return [Hash{Symbol => Hash, String, Integer}] LSP diagnostic
       def offense_to_diagnostic off
         {
           range: offense_range(off).to_hash,
@@ -76,20 +81,30 @@ module Solargraph
         Range.new(offense_start_position(off), offense_ending_position(off))
       end
 
-      # @param off [Hash]
+      # @param off [Hash{String => Hash{String => Integer}}]
       # @return [Position]
       def offense_start_position off
         Position.new(off['location']['start_line'] - 1, off['location']['start_column'] - 1)
       end
 
-      # @param off [Hash]
+      # @param off [Hash{String => Hash{String => Integer}}]
       # @return [Position]
       def offense_ending_position off
         if off['location']['start_line'] != off['location']['last_line']
           Position.new(off['location']['start_line'], 0)
         else
+          start_line = off['location']['start_line'] - 1
+          # @type [Integer]
+          last_column = off['location']['last_column']
+          line = @source.code.lines[start_line]
+          col_off = if line.nil? || line.empty?
+            1
+          else
+            0
+          end
+
           Position.new(
-            off['location']['start_line'] - 1, off['location']['last_column'] - 1
+            start_line, last_column - col_off
           )
         end
       end

data/lib/solargraph/diagnostics/rubocop_helpers.rb

@@ -10,13 +10,16 @@ module Solargraph
       # Requires a specific version of rubocop, or the latest installed version
       # if _version_ is `nil`.
       #
-      # @param version [String]
+      # @param version [String, nil]
       # @raise [InvalidRubocopVersionError] if _version_ is not installed
+      # @return [void]
       def require_rubocop(version = nil)
         begin
           gem_path = Gem::Specification.find_by_name('rubocop', version).full_gem_path
           gem_lib_path = File.join(gem_path, 'lib')
           $LOAD_PATH.unshift(gem_lib_path) unless $LOAD_PATH.include?(gem_lib_path)
+        # @todo Gem::MissingSpecVersionError is undocumented for some reason
+        # @sg-ignore
         rescue Gem::MissingSpecVersionError => e
           raise InvalidRubocopVersionError,
                 "could not find '#{e.name}' (#{e.requirement}) - "\

data/lib/solargraph/diagnostics/type_check.rb

@@ -6,6 +6,7 @@ module Solargraph
     # parameters, and invalid param tags.
     #
     class TypeCheck < Base
+      # @return [Array<Hash>]
       def diagnose source, api_map
         # return [] unless args.include?('always') || api_map.workspaced?(source.filename)
         severity = Diagnostics::Severities::ERROR

data/lib/solargraph/diagnostics.rb

@@ -33,14 +33,14 @@ module Solargraph
       # Find a reporter by name.
       #
       # @param name [String] The name with which the reporter was registered
-      # @return [Class<Solargraph::Diagnostics::Base>]
+      # @return [Class<Solargraph::Diagnostics::Base>, nil]
       def reporter name
         reporter_hash[name]
       end
 
       private
 
-      # @return [Hash]
+      # @return [Hash{String => Class<Solargraph::Diagnostics::Base>}]
       def reporter_hash
         @reporter_hash ||= {}
       end

data/lib/solargraph/doc_map.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module Solargraph
+  # A collection of pins generated from required gems.
+  #
+  class DocMap
+    # @return [Array<String>]
+    attr_reader :requires
+
+    # @return [Array<Gem::Specification>]
+    attr_reader :preferences
+
+    # @return [Array<Pin::Base>]
+    attr_reader :pins
+
+    # @return [Array<Gem::Specification>]
+    attr_reader :uncached_gemspecs
+
+    # @param requires [Array<String>]
+    # @param preferences [Array<Gem::Specification>]
+    def initialize(requires, preferences)
+      @requires = requires.compact
+      @preferences = preferences.compact
+      generate
+    end
+
+    # @return [Array<Gem::Specification>]
+    def gemspecs
+      @gemspecs ||= required_gem_map.values.compact
+    end
+
+    # @return [Array<String>]
+    def unresolved_requires
+      @unresolved_requires ||= required_gem_map.select { |_, gemspec| gemspec.nil? }.keys
+    end
+
+    # @return [Hash{Gem::Specification => Array[Pin::Base]}]
+    def self.gems_in_memory
+      @gems_in_memory ||= {}
+    end
+
+    def dependencies
+      @dependencies ||= (gemspecs.flat_map { |spec| fetch_dependencies(spec) } - gemspecs).to_set
+    end
+
+    private
+
+    # @return [void]
+    def generate
+      @pins = []
+      @uncached_gemspecs = []
+      required_gem_map.each do |path, gemspec|
+        if gemspec
+          try_cache gemspec
+        else
+          try_stdlib_map path
+        end
+      end
+      dependencies.each { |dep| try_cache dep }
+    end
+
+    # @return [Hash{String => Gem::Specification, nil}]
+    def required_gem_map
+      @required_gem_map ||= requires.to_h { |path| [path, resolve_path_to_gemspec(path)] }
+    end
+
+    # @return [Hash{String => Gem::Specification}]
+    def preference_map
+      @preference_map ||= preferences.to_h { |gemspec| [gemspec.name, gemspec] }
+    end
+
+    # @param gemspec [Gem::Specification]
+    # @return [void]
+    def try_cache gemspec
+      return if try_gem_in_memory(gemspec)
+      cache_file = File.join('gems', "#{gemspec.name}-#{gemspec.version}.ser")
+      if Cache.exist?(cache_file)
+        gempins = Cache.load(cache_file)
+        self.class.gems_in_memory[gemspec] = gempins
+        @pins.concat gempins
+      else
+        Solargraph.logger.debug "No pin cache for #{gemspec.name} #{gemspec.version}"
+        @uncached_gemspecs.push gemspec
+      end
+    end
+
+    # @param path [String] require path that might be in the RBS stdlib collection
+    # @return [void]
+    def try_stdlib_map path
+      map = RbsMap::StdlibMap.load(path)
+      if map.resolved?
+        Solargraph.logger.debug "Loading stdlib pins for #{path}"
+        @pins.concat map.pins
+      else
+        # @todo Temporarily ignoring unresolved `require 'set'`
+        Solargraph.logger.warn "Require path #{path} could not be resolved" unless path == 'set'
+      end
+    end
+
+    # @param gemspec [Gem::Specification]
+    # @return [Boolean]
+    def try_gem_in_memory gemspec
+      gempins = DocMap.gems_in_memory[gemspec]
+      return false unless gempins
+      Solargraph.logger.debug "Found #{gemspec.name} #{gemspec.version} in memory"
+      @pins.concat gempins
+      true
+    end
+
+    # @param path [String]
+    # @return [Gem::Specification, nil]
+    def resolve_path_to_gemspec path
+      return nil if path.empty?
+
+      gemspec = Gem::Specification.find_by_path(path)
+      if gemspec.nil?
+        gem_name_guess = path.split('/').first
+        begin
+          # this can happen when the gem is included via a local path in
+          # a Gemfile; Gem doesn't try to index the paths in that case.
+          #
+          # See if we can make a good guess:
+          potential_gemspec = Gem::Specification.find_by_name(gem_name_guess)
+          file = "lib/#{path}.rb"
+          gemspec = potential_gemspec if potential_gemspec.files.any? { |gemspec_file| file == gemspec_file }
+        rescue Gem::MissingSpecError
+          Solargraph.logger.debug "Require path #{path} could not be resolved to a gem via find_by_path or guess of #{gem_name_guess}"
+          nil
+        end
+      end
+      gemspec_or_preference gemspec
+    end
+
+    # @param gemspec [Gem::Specification, nil]
+    # @return [Gem::Specification, nil]
+    def gemspec_or_preference gemspec
+      return gemspec unless gemspec && preference_map.key?(gemspec.name)
+      return gemspec if gemspec.version == preference_map[gemspec.name].version
+
+      change_gemspec_version gemspec, preference_map[by_path.name].version
+    end
+
+    # @param gemspec [Gem::Specification]
+    # @param version [Gem::Version]
+    # @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} not found. Using #{gemspec.version} instead"
+      gemspec
+    end
+
+    # @param gemspec [Gem::Specification]
+    # @return [Array<Gem::Specification>]
+    def fetch_dependencies gemspec
+      only_runtime_dependencies(gemspec).each_with_object(Set.new) do |spec, deps|
+        Solargraph.logger.info "Adding #{spec.name} dependency for #{gemspec.name}"
+        dep = Gem::Specification.find_by_name(spec.name, spec.requirement)
+        deps.merge fetch_dependencies(dep) if deps.add?(dep)
+      rescue Gem::MissingSpecError
+        Solargraph.logger.warn "Gem dependency #{spec.name} #{spec.requirements} for #{gemspec.name} not found."
+      end.to_a
+    end
+
+    # @param gemspec [Gem::Specification]
+    # @return [Array<Gem::Dependency>]
+    def only_runtime_dependencies gemspec
+      gemspec.dependencies - gemspec.development_dependencies
+    end
+  end
+end

data/lib/solargraph/gem_pins.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'rbs'
+
+module Solargraph
+  # A utility for building gem pins from a combination of YARD and RBS
+  # documentation.
+  #
+  module GemPins
+    # Build an array of pins from a gem specification. The process starts with
+    # YARD, enhances the resulting pins with RBS definitions, and appends RBS
+    # pins that don't exist in the YARD mapping.
+    #
+    # @param gemspec [Gem::Specification]
+    # @return [Array<Pin::Base>]
+    def self.build(gemspec)
+      yard_pins = build_yard_pins(gemspec)
+      rbs_map = RbsMap.from_gemspec(gemspec)
+      in_yard = Set.new
+      combined = yard_pins.map do |yard|
+        in_yard.add yard.path
+        next yard unless yard.is_a?(Pin::Method)
+        rbs = rbs_map.path_pin(yard.path, Pin::Method)
+        next yard unless rbs
+        # @todo Could not include: attribute and anon_splat
+        # @sg-ignore
+        yard.class.new(
+          location: yard.location,
+          closure: yard.closure,
+          name: yard.name,
+          comments: yard.comments,
+          scope: yard.scope,
+          parameters: rbs.parameters,
+          generics: rbs.generics,
+          node: yard.node,
+          signatures: yard.signatures,
+          return_type: best_return_type(rbs.return_type, yard.return_type)
+        )
+      end
+      in_rbs = rbs_map.pins.reject { |pin| in_yard.include?(pin.path) }
+      combined + in_rbs
+    end
+
+    class << self
+      private
+
+      # @param gemspec [Gem::Specification]
+      # @return [Array<Pin::Base>]
+      def build_yard_pins(gemspec)
+        Yardoc.cache(gemspec) unless Yardoc.cached?(gemspec)
+        yardoc = Yardoc.load!(gemspec)
+        YardMap::Mapper.new(yardoc, gemspec).map
+      end
+
+      # Select the first defined type.
+      #
+      # @param choices [Array<ComplexType>]
+      # @return [ComplexType]
+      def best_return_type *choices
+        choices.find { |pin| pin.defined? } || choices.first || ComplexType::UNDEFINED
+      end
+    end
+  end
+end

data/lib/solargraph/language_server/host/cataloger.rb

@@ -6,6 +6,7 @@ module Solargraph
       # An asynchronous library cataloging handler.
       #
       class Cataloger
+        # @param host [Host]
         def initialize host
           @host = host
           @stopped = true
@@ -34,7 +35,7 @@ module Solargraph
           Thread.new do
             until stopped?
               tick
-              sleep 0.01
+              sleep 0.1
             end
           end
         end

data/lib/solargraph/language_server/host/diagnoser.rb

@@ -38,7 +38,7 @@ module Solargraph
 
         # Start the diagnosis thread.
         #
-        # @return [self]
+        # @return [self, nil]
         def start
           return unless @stopped
           @stopped = false
@@ -81,7 +81,7 @@ module Solargraph
         # @return [Mutex]
         attr_reader :mutex
 
-        # @return [Array]
+        # @return [::Array]
         attr_reader :queue
       end
     end

data/lib/solargraph/language_server/host/dispatch.rb

@@ -6,6 +6,12 @@ module Solargraph
       # Methods for associating sources with libraries via URIs.
       #
       module Dispatch
+        # @abstract
+        # @return [Host::Diagnoser]
+        def diagnoser
+          raise NotImplementedError, 'Host::Dispatch requires a diagnoser method'
+        end
+
         # @return [Sources]
         def sources
           @sources ||= begin
@@ -15,7 +21,7 @@ module Solargraph
           end
         end
 
-        # @return [Array<Library>]
+        # @return [::Array<Library>]
         def libraries
           @libraries ||= []
         end
@@ -27,9 +33,9 @@ module Solargraph
         # @return [void]
         def update_libraries uri
           src = sources.find(uri)
-          libraries.each do |lib|
-            lib.merge src if lib.contain?(src.filename)
-          end
+          using = libraries.select { |lib| lib.contain?(src.filename) }
+          using.push generic_library_for(uri) if using.empty?
+          using.each { |lib| lib.merge src }
           diagnoser.schedule uri
         end
 
@@ -89,6 +95,10 @@ module Solargraph
           nil
         end
 
+        def options
+          @options ||= {}.freeze
+        end
+
         # Get a generic library for the given URI and attach the corresponding
         # source.
         #
@@ -103,7 +113,7 @@ module Solargraph
 
         # @return [Library]
         def generic_library
-          @generic_library ||= Solargraph::Library.new
+          @generic_library ||= Solargraph::Library.new(Solargraph::Workspace.new('', nil, options), nil)
         end
       end
     end

data/lib/solargraph/language_server/host/message_worker.rb

@@ -16,6 +16,7 @@ module Solargraph
         end
 
         # pending handle messages
+        # @return [Array<Hash>]
         def messages
           @messages ||= []
         end
@@ -24,6 +25,7 @@ module Solargraph
           @stopped
         end
 
+        # @return [void]
         def stop
           @stopped = true
         end
@@ -37,6 +39,7 @@ module Solargraph
           end
         end
 
+        # @return [void]
         def start
           return unless @stopped
           @stopped = false
@@ -45,6 +48,7 @@ module Solargraph
           end
         end
 
+        # @return [void]
         def tick
           message = @mutex.synchronize do
             @resource.wait(@mutex) if messages.empty?

data/lib/solargraph/language_server/host/sources.rb

@@ -43,6 +43,7 @@ module Solargraph
           end
         end
 
+        # @param uri [String]
         # @return [void]
         def add_uri(uri)
           queue.push(uri)
@@ -72,6 +73,8 @@ module Solargraph
           open_source_hash[uri] = source
         end
 
+        # @param uri [String]
+        # @return [void]
         def open_from_disk uri
           source = Solargraph::Source.load(UriHelpers.uri_to_file(uri))
           open_source_hash[uri] = source
@@ -83,7 +86,7 @@ module Solargraph
         #
         # @param uri [String]
         # @param updater [Source::Updater]
-        # @return [Source]
+        # @return [void]
         def update uri, updater
           src = find(uri)
           mutex.synchronize { open_source_hash[uri] = src.synchronize(updater) }
@@ -109,7 +112,7 @@ module Solargraph
         # @raise [FileNotFoundError] if the URI does not match an open source.
         #
         # @param uri [String]
-        # @return [Source]
+        # @return [Solargraph::Source]
         def find uri
           open_source_hash[uri] || raise(Solargraph::FileNotFoundError, "Host could not find #{uri}")
         end
@@ -136,7 +139,7 @@ module Solargraph
 
         private
 
-        # @return [Hash]
+        # @return [Hash{String => Solargraph::Source}]
         def open_source_hash
           @open_source_hash ||= {}
         end
@@ -146,7 +149,7 @@ module Solargraph
 
         # An array of source URIs that are waiting to finish synchronizing.
         #
-        # @return [Array<String>]
+        # @return [::Array<String>]
         def queue
           @queue ||= []
         end