solargraph 0.60.4 → 0.61.0

data/lib/solargraph/convention.rb

@@ -38,12 +38,14 @@ module Solargraph
       result
     end
 
-    # @param doc_map [DocMap]
+    # @todo Determine what argument needs to be passed here
+    #
+    # @param object [Object]
     # @return [Environ]
-    def self.for_global doc_map
+    def self.for_global object
       result = Environ.new
       @@conventions.each do |conv|
-        result.merge conv.global(doc_map)
+        result.merge conv.global(object)
       end
       result
     end

data/lib/solargraph/diagnostics/require_not_found.rb

@@ -13,10 +13,6 @@ module Solargraph
         # @sg-ignore Need to add nil check here
         map = api_map.source_map(source.filename)
         map.requires.each { |ref| refs[ref.name] = ref }
-        api_map.missing_docs.each do |r|
-          next unless refs.key?(r)
-          result.push docs_error(r, refs[r].location)
-        end
         api_map.unresolved_requires.each do |r|
           next unless refs.key?(r)
           result.push require_error(r, refs[r].location)

data/lib/solargraph/external.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Solargraph
+  # @todo This class might need a way to track changes to the repo, e.g.,
+  #   bundle or dependency updates
+  #
+  class External
+    # @return [String]
+    attr_reader :directory
+
+    # @return [Array<String>]
+    attr_reader :requires
+
+    # @param directory [String]
+    # @param requires [Array<String>]
+    def initialize directory, requires
+      @repo = Repo.new(directory)
+      @directory = directory
+      @requires = requires
+      update!
+    end
+
+    def unresolved_requires
+      @unresolved_requires ||= []
+    end
+
+    def unresolved_dependencies
+      @unresolved_dependencies ||= []
+    end
+
+    def loaded_gems
+      @loaded_gems ||= Set.new
+    end
+
+    def unloaded_gems
+      @unloaded_gems ||= Set.new
+    end
+
+    def pins
+      @pins ||= []
+    end
+
+    # @return [Integer] incremented whenever the external pin set is rebuilt
+    def generation
+      @generation ||= 0
+    end
+
+    # @param new_requires [Array<String>]
+    # @return [Boolean]
+    def update new_requires
+      return false if requires == new_requires && !cache_changed?
+
+      requires.replace new_requires
+      update!
+      true
+    end
+
+    # @return [Array<String>]
+    def rbs_collection_paths
+      @rbs_collection_paths ||= read_rbs_collection_paths
+    end
+
+    # @return [String, nil]
+    def rbs_collection_config_path
+      # @todo Get rid of the '*' case
+      @rbs_collection_config_path ||= unless directory.nil? || directory.empty? || directory == '*'
+                                        yaml_file = File.join(directory, 'rbs_collection.yaml')
+                                        yaml_file if File.file?(yaml_file)
+                                      end
+    end
+
+    private
+
+    def update!
+      @generation = generation + 1
+      clear_all
+      load_requires
+      load_rbs_collection
+    end
+
+    def cache_changed?
+      unloaded_gems.any? { |gem| Collection::Gem.cached?(gem) }
+    end
+
+    def load_requires
+      bundler_require = false
+
+      requires.uniq.each do |path|
+        if path == 'bundler/require'
+          bundler_require = true
+        end
+        if RbsMap::Stdlib.has?(path)
+          pins.concat Collection::Stdlib.load(path)
+        else
+          metagem = @repo.find_by_path(path)
+          next unresolved_requires.push(path) unless metagem
+          process_gem metagem
+        end
+      end
+
+      return unless bundler_require
+
+      @repo.find_by_group(:default).each { |metagem| process_gem metagem }
+    end
+
+    def load_rbs_collection
+      rbs_collection_pins = rbs_collection_paths.flat_map { |path| Collection::Rbs.load(path) }
+      pins.replace RbsMap::Helpers.combine(pins, rbs_collection_pins)
+    end
+
+    def clear_all
+      pins.clear
+      unresolved_requires.clear
+      unresolved_dependencies.clear
+      loaded_gems.clear
+      unloaded_gems.clear
+    end
+
+    def process_gem metagem
+      return if loaded_gems.include?(metagem) || unloaded_gems.include?(metagem)
+
+      if metagem.cacheable?
+        if Collection::Gem.cached?(metagem)
+          loaded_gems.add metagem
+          pins.concat Collection::Gem.load(metagem)
+        else
+          unloaded_gems.add metagem
+        end
+      else
+        loaded_gems.add metagem
+        pins.concat Collection::Gem.load(metagem)
+      end
+      load_dependencies metagem
+    end
+
+    def load_dependencies parent
+      parent.dependencies.each do |name|
+        next if loaded_gems.map(&:name).include?(name) || unloaded_gems.map(&:name).include?(name)
+        metagem = @repo.find_by_name(name)
+        next unresolved_dependencies.push(name) unless metagem
+        process_gem metagem
+      end
+    end
+
+    # @return [Array<String>]
+    def read_rbs_collection_paths
+      return [] unless rbs_collection_config_path
+
+      yaml = YAML.load_file(rbs_collection_config_path)
+      [File.expand_path(yaml.fetch('path'), directory)].concat(
+        yaml.fetch('sources', [])
+            .select { |source| source['type'] == 'local' && source['path'] }
+            .map { |source| File.expand_path(source['path'], directory) }
+      ).compact
+    end
+  end
+end

data/lib/solargraph/language_server/message/text_document/definition.rb

@@ -29,7 +29,10 @@ module Solargraph
 
           # @return [Array<Hash>, nil]
           def require_location
-            # @todo Terrible hack
+            # @todo Terrible hack - move this logic to [Solargraph::Source::Chain::Parameter]
+            #   @example
+            #     require 'click_me'
+            #             ^^^^^^^^^^
             lib = host.library_for(params['textDocument']['uri'])
             rloc = Solargraph::Location.new(uri_to_file(params['textDocument']['uri']),
                                             Solargraph::Range.from_to(@line, @column, @line, @column))

data/lib/solargraph/language_server/message/text_document/hover.rb

@@ -11,8 +11,7 @@ module Solargraph
             contents = []
             suggestions = host.definitions_at(params['textDocument']['uri'], line, col)
             last_link = nil
-            # @sg-ignore Need to add nil check here
-            suggestions.each do |pin|
+            suggestions&.each do |pin|
               parts = []
               this_link = host.options['enablePages'] ? pin.link_documentation : pin.text_documentation
               parts.push this_link if !this_link.nil? && this_link != last_link

data/lib/solargraph/library.rb

@@ -576,14 +576,8 @@ module Solargraph
       return unless source
       # @sg-ignore Wrong argument type for Solargraph::Workspace#has_file?: filename expected String, received String, nil
       return unless @current == source || workspace.has_file?(source.filename)
-      if source_map_hash.key?(source.filename)
-        new_map = Solargraph::SourceMap.map(source)
-        # @sg-ignore OK if source.filename is nil
-        source_map_hash[source.filename] = new_map
-      else
-        # @sg-ignore OK if source.filename is nil
-        source_map_hash[source.filename] = Solargraph::SourceMap.map(source)
-      end
+      # @sg-ignore OK if source.filename is nil
+      source_map_hash[source.filename] = Solargraph::SourceMap.map(source)
     end
 
     # @return [Set<Gem::Specification>]
@@ -595,10 +589,10 @@ module Solargraph
     def cache_next_gemspec
       return if @cache_progress
 
-      spec = cacheable_specs.first
+      spec = api_map.unloaded_gems.first
       return end_cache_progress unless spec
 
-      pending = api_map.uncached_gemspecs.length - cache_errors.length - 1
+      pending = api_map.unloaded_gems.length - cache_errors.length - 1
 
       if Yardoc.processing?(spec)
         logger.info "Enqueuing cache of #{spec.name} #{spec.version} (already being processed)"
@@ -615,7 +609,10 @@ module Solargraph
         logger.info "Caching #{spec.name} #{spec.version}"
         Thread.new do
           report_cache_progress spec.name, pending
-          _o, e, s = Open3.capture3(workspace.command_path, 'cache', spec.name, spec.version.to_s)
+
+          cmd = [workspace.command_path, 'cache', spec.name]
+          cmd.push('--directory', workspace.directory) if workspace.directory
+          _o, e, s = Open3.capture3(*cmd)
           if s.success?
             logger.info "Cached #{spec.name} #{spec.version}"
           else
@@ -630,17 +627,6 @@ module Solargraph
       end
     end
 
-    # @return [Array<Gem::Specification>]
-    def cacheable_specs
-      cacheable = api_map.uncached_yard_gemspecs +
-                  api_map.uncached_rbs_collection_gemspecs -
-                  queued_gemspec_cache -
-                  cache_errors.to_a
-      return cacheable unless cacheable.empty?
-
-      queued_gemspec_cache
-    end
-
     # @return [Array<Gem::Specification>]
     def queued_gemspec_cache
       @queued_gemspec_cache ||= []
@@ -696,8 +682,9 @@ module Solargraph
         source_map_hash.each_value { |map| find_external_requires(map) }
         api_map.catalog bench
         logger.info "Catalog complete (#{api_map.source_maps.length} files, #{api_map.pins.length} pins)"
-        logger.info "#{api_map.uncached_yard_gemspecs.length} uncached YARD gemspecs"
-        logger.info "#{api_map.uncached_rbs_collection_gemspecs.length} uncached RBS collection gemspecs"
+        # @todo This needs work
+        # logger.info "#{api_map.uncached_yard_gemspecs.length} uncached YARD gemspecs"
+        # logger.info "#{api_map.uncached_rbs_collection_gemspecs.length} uncached RBS collection gemspecs"
         cache_next_gemspec
         @sync_count = 0
       end

data/lib/solargraph/metagem.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Metagem
+    include Equality
+
+    # @return [String]
+    attr_reader :name
+
+    # @return [String]
+    attr_reader :full_path
+
+    # @return [String]
+    attr_reader :spec_file
+
+    # @return [String]
+    attr_reader :source
+
+    # @return [String]
+    attr_reader :version
+
+    # @return [Array<String>]
+    attr_reader :require_paths
+
+    # @return [Array<String>]
+    attr_reader :dependencies
+
+    # @return [String]
+    attr_reader :cache_name
+
+    def initialize name:, full_path:, spec_file:, source:, version:, require_paths:, dependencies:
+      @name = name
+      @full_path = full_path
+      @spec_file = spec_file
+      @source = source
+      @version = version
+      @require_paths = require_paths
+      @dependencies = dependencies
+      # @todo Possible change to cache names to make them more specific to sources
+      # @cache_name = "#{File.basename(full_path)}__#{source.gsub(/[^a-z0-9\-_]/i, '_')}" unless source.end_with?('Path')
+      # @todo Better path source detection
+      @cache_name = File.basename(full_path) unless source.start_with?('source at') || source.to_s.end_with?('::Path')
+    end
+
+    def cacheable?
+      !!@cache_name
+    end
+
+    def require? path
+      require_paths.any? do |req|
+        File.file?(File.join(full_path, req, "#{path}.rb"))
+      end
+    end
+
+    def to_specification
+      Gem::Specification.load(spec_file)
+    end
+
+    alias full_gem_path full_path
+
+    # @return [Array]
+    def equality_fields
+      # A version arrives as a String from a bundle definition and as a
+      # Gem::Version from a specification, so compare its string form.
+      [name, version.to_s, full_path, source]
+    end
+
+    # @param gem [Gem::Specification]
+    # @return [Metagem]
+    def self.from_specification gem
+      Metagem.new(name: gem.name,
+                  full_path: gem.full_gem_path,
+                  spec_file: gem.spec_file,
+                  source: gem.source.to_s,
+                  version: gem.version,
+                  require_paths: gem.require_paths,
+                  dependencies: gem.runtime_dependencies.map(&:name))
+    end
+  end
+end

data/lib/solargraph/parser/parser_gem/node_chainer.rb

@@ -13,10 +13,12 @@ module Solargraph
         # @param node [Parser::AST::Node]
         # @param filename [String, nil]
         # @param parent [Parser::AST::Node, nil]
-        def initialize node, filename = nil, parent = nil
+        # @param tree [Array<Parser::AST::Node>, nil]
+        def initialize node, filename = nil, parent = nil, tree = nil
           @node = node
           @filename = filename
           @parent = parent
+          @tree = tree
         end
 
         # @return [Source::Chain]
@@ -29,9 +31,10 @@ module Solargraph
           # @param node [Parser::AST::Node]
           # @param filename [String, nil]
           # @param parent [Parser::AST::Node, nil]
+          # @param tree [Parser::AST::Node, nil]
           # @return [Source::Chain]
-          def chain node, filename = nil, parent = nil
-            NodeChainer.new(node, filename, parent).chain
+          def chain node, filename = nil, parent = nil, tree = nil
+            NodeChainer.new(node, filename, parent, tree).chain
           end
 
           # @param code [String]
@@ -150,6 +153,13 @@ module Solargraph
           elsif n.type == :array
             chained_children = n.children.map { |c| NodeChainer.chain(c) }
             result.push Source::Chain::Array.new(chained_children, n)
+          elsif inside_method_call? # If the node is inside a method call, it may be a parameter.
+            lit = infer_literal_node_type(n)
+            if lit
+              method_call_chain = NodeChainer.chain(send_node, @filename, nil, [])
+              literal = Chain::Literal.new(lit, n)
+              result.push Chain::Parameter.new(literal, method_call_chain)
+            end
           else
             lit = infer_literal_node_type(n)
             result.push(lit ? Chain::Literal.new(lit, n) : Chain::Link.new)
@@ -158,6 +168,15 @@ module Solargraph
           result
         end
 
+        def inside_method_call?
+          !send_node.nil? && send_node != @node
+        end
+
+        # @return [Parser::AST::Node, nil]
+        def send_node
+          @send_node ||= @tree&.find { |n| n.type == :send }
+        end
+
         # @param node [Parser::AST::Node]
         def hash_is_splatted? node
           return false unless Parser.is_ast_node?(node) && node.type == :hash

data/lib/solargraph/pin/closure.rb

@@ -6,6 +6,23 @@ module Solargraph
       # @return [::Symbol] :class or :instance
       attr_reader :scope
 
+      # Override the pin's scope.
+      #
+      # Scope is normally determined by the syntax that declared the pin, but
+      # YARD's `@!scope` directive can change it after the fact. Any values
+      # derived from the scope, such as the pin's path and context, are
+      # recalculated.
+      #
+      # @param scope [::Symbol] :class or :instance
+      # @return [void]
+      def scope= scope
+        return if @scope == scope
+
+        @scope = scope
+        # remove cached values generated from scope
+        reset_generated!
+      end
+
       # @param scope [::Symbol] :class or :instance
       # @param generics [::Array<Pin::String>, nil]
       # @param generic_defaults [Hash{String => ComplexType}]

data/lib/solargraph/pin/factory_parameter.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    # A method parameter with a literal value used in a factory method.
+    #
+    # @example
+    #   RSpec.shared_examples 'some examples'
+    #
+    #   FactoryParameter.new(
+    #     method_name: 'shared_examples',
+    #     method_namespace: 'RSpec',
+    #     method_scope: :class,
+    #     param_name: 'name',
+    #     value: 'some examples',
+    #     decl: :arg,
+    #     return_type: 'void'
+    #   )
+    class FactoryParameter < Base
+      # @return [String]
+      attr_reader :method_name
+      # @return [String]
+      attr_reader :method_namespace
+      # @return [Symbol] :class or :instance
+      attr_reader :method_scope
+      # @return [String, nil]
+      attr_reader :param_name
+      # @return [::String, ::Symbol] The literal value
+      attr_reader :value
+      # @return [::Symbol] :arg, :optarg, :kwarg, :kwoptarg, :restarg, :kwrestarg, :block, :blockarg
+      attr_reader :decl
+      # @return [Location, nil]
+      attr_reader :location
+
+      # @param method_name [String] The name of the method that this parameter belongs to
+      # @param method_namespace [String] The class of the method that this parameter belongs to
+      # @param method_scope [Symbol] The scope of the method, either :class or :instance
+      # @param param_name [String, nil] The name of the parameter
+      # @param value [String, Symbol] The value of the parameter
+      # @param decl [::Symbol] :arg, :kwarg
+      # @param location [Location, nil] The location of the parameter in the source code
+      # @param return_type [String, nil] The return type of the method that this parameter belongs to
+      def initialize method_name:,
+                     method_namespace:,
+                     method_scope:,
+                     param_name:,
+                     value:,
+                     return_type:,
+                     decl: :arg,
+                     location: nil
+        super(location: location)
+        @method_name = method_name
+        @method_namespace = method_namespace
+        @method_scope = method_scope
+        @param_name = param_name
+        @value = value
+        @decl = decl
+        @return_type = return_type
+      end
+
+      def name
+        param_name
+      end
+
+      def text_documentation
+        "#{method_path}(#{param_name}) = #{value.inspect}"
+      end
+
+      # @return [String]
+      def method_path
+        # @sg-ignore false failure on method_scope "Wrong argument type for Solargraph::Pin::Base#==: other expected
+        # Solargraph::Pin::Base, received :instance"
+        @method_path ||= "#{method_namespace}#{method_scope == :instance ? '#' : '.'}#{method_name}"
+      end
+
+      private
+
+      def inner_desc
+        "method_path=#{method_path}, value=#{value.inspect}, decl=#{decl.inspect}, " \
+          "return_type=#{return_type&.to_s || 'nil'}"
+      end
+    end
+  end
+end

data/lib/solargraph/pin.rb

@@ -38,6 +38,7 @@ module Solargraph
     autoload :Until,            'solargraph/pin/until'
     autoload :While,            'solargraph/pin/while'
     autoload :Callable,         'solargraph/pin/callable'
+    autoload :FactoryParameter, 'solargraph/pin/factory_parameter'
     autoload :CompoundStatement,
              'solargraph/pin/compound_statement'
 

data/lib/solargraph/rbs_map/base.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module RbsMap
+    class Base
+      def pins
+        @pins ||= RbsMap::Conversions.new(loader: loader).pins
+      end
+
+      # @return [RBS::Repository]
+      def repository
+        @repository ||= RBS::Repository.new(no_stdlib: true)
+      end
+
+      # @return [RBS::EnvironmentLoader]
+      def loader
+        @loader ||= RBS::EnvironmentLoader.new(core_root: nil, repository: repository)
+      end
+
+      # @param path [String]
+      # @return [Array<Pin::Base>]
+      def path_pins path
+        pins.select { |p| p.path == path }
+      end
+
+      def self.pins(...)
+        new(...).pins
+      end
+    end
+  end
+end

data/lib/solargraph/rbs_map/conversions.rb

@@ -3,7 +3,7 @@
 require 'rbs'
 
 module Solargraph
-  class RbsMap
+  module RbsMap
     # Functions for converting RBS declarations to Solargraph pins
     #
     class Conversions
@@ -49,6 +49,8 @@ module Solargraph
           return
         end
         environment.declarations.each { |decl| convert_decl_to_pin(decl, Solargraph::Pin::ROOT_PIN) }
+      rescue RBS::DuplicatedDeclarationError => e
+        Solargraph.logger.warn "RBS conversion failed due to duplicate declarations: [#{e.class}] #{e.message}"
       end
 
       # @param decl [RBS::AST::Declarations::Base]

data/lib/solargraph/rbs_map/{core_map.rb → core.rb}

@@ -1,39 +1,32 @@
 # frozen_string_literal: true
 
 module Solargraph
-  class RbsMap
-    # Ruby core pins
-    #
-    class CoreMap
-      include Logging
+  module RbsMap
+    class Core < Base
+      FILLS_DIRECTORY = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'rbs', 'fills'))
 
-      def resolved?
-        true
+      def pins
+        @pins ||= generate_pins
       end
 
-      FILLS_DIRECTORY = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'rbs', 'fills'))
-
-      def initialize; end
+      # @return [RBS::EnvironmentLoader]
+      def loader
+        @loader ||= RBS::EnvironmentLoader.new(repository: repository)
+      end
 
-      # @param out [IO, nil] output stream for logging
-      # @return [Enumerable<Pin::Base>]
-      def pins out: $stderr
-        return @pins if @pins
-        @pins = cache_core(out: out)
+      def repository
+        @repository ||= RBS::Repository.new(no_stdlib: false)
       end
 
-      # @param out [StringIO, IO, nil] output stream for logging
+      private
+
       # @return [Array<Pin::Base>]
-      def cache_core out: $stderr
-        new_pins = []
-        cache = PinCache.deserialize_core
-        return cache if cache
-        new_pins.concat conversions.pins
+      def generate_pins
+        new_pins = RbsMap::Conversions.new(loader: loader).pins
 
         # Avoid RBS::DuplicatedDeclarationError by loading in a different EnvironmentLoader
         fill_loader = RBS::EnvironmentLoader.new(core_root: nil, repository: RBS::Repository.new(no_stdlib: false))
         fill_loader.add(path: Pathname(FILLS_DIRECTORY))
-        out&.puts 'Caching RBS pins for Ruby core'
         fill_conversions = Conversions.new(loader: fill_loader)
         new_pins.concat fill_conversions.pins
 
@@ -42,23 +35,9 @@ module Solargraph
 
         # process overrides, then remove any which couldn't be resolved
         processed = ApiMap::Store.new(new_pins).pins.reject { |p| p.is_a?(Solargraph::Pin::Reference::Override) }
-        new_pins.replace processed
-
-        PinCache.serialize_core new_pins
-
-        new_pins
-      end
-
-      private
-
-      # @return [RBS::EnvironmentLoader]
-      def loader
-        @loader ||= RBS::EnvironmentLoader.new(repository: RBS::Repository.new(no_stdlib: false))
-      end
-
-      # @return [Conversions]
-      def conversions
-        @conversions ||= Conversions.new(loader: loader)
+        # serial = Marshal.dump(processed)
+        # File.write cache_file, serial, mode: 'wb'
+        processed
       end
     end
   end

data/lib/solargraph/rbs_map/core_fills.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Solargraph
-  class RbsMap
+  module RbsMap
     # Override pins to fill gaps in RbsMap::CoreMap coverage
     #
     module CoreFills