solargraph 0.51.2 → 0.54.2

data/lib/solargraph/views/environment.erb

@@ -35,11 +35,9 @@
     <li>
       Core Cache Directory: N/A <%# @todo Fix %>
     </li>
-    <% unless Solargraph::Parser.rubyvm? %>
-      <li>
-        Parser Target Version: <%= Solargraph::Parser.version %>
-      </li>
-    <% end %>
+    <li>
+      Parser Target Version: <%= Solargraph::Parser.version %>
+    </li>
     <li>
       Using Bundler: <%= ENV.key?('BUNDLE_BIN_PATH') %>
     </li>

data/lib/solargraph/workspace/config.rb

@@ -14,7 +14,8 @@ module Solargraph
       # @return [String]
       attr_reader :directory
 
-      # @return [Hash]
+      # @todo To make this strongly typed we'll need a record syntax
+      # @return [Hash{String => undefined}]
       attr_reader :raw_data
 
       # @param directory [String]
@@ -41,6 +42,7 @@ module Solargraph
         @excluded ||= process_exclusions(@raw_data['exclude'])
       end
 
+      # @param filename [String]
       def allow? filename
         filename = File.absolute_path(filename, directory)
         filename.start_with?(directory) &&
@@ -111,7 +113,7 @@ module Solargraph
 
       # @return [String]
       def global_config_path
-        ENV['SOLARGRAPH_GLOBAL_CONFIG'] || 
+        ENV['SOLARGRAPH_GLOBAL_CONFIG'] ||
           File.join(Dir.home, '.config', 'solargraph', 'config.yml')
       end
 
@@ -121,7 +123,7 @@ module Solargraph
         File.join(@directory, '.solargraph.yml')
       end
 
-      # @return [Hash]
+      # @return [Hash{String => Array, Hash, Integer}]
       def config_data
         workspace_config = read_config(workspace_config_path)
         global_config = read_config(global_config_path)
@@ -136,15 +138,15 @@ module Solargraph
 
       # Read a .solargraph yaml config
       #
-      # @param directory [String]
-      # @return [Hash, nil]
+      # @param config_path [String]
+      # @return [Hash{String => Array, Hash, Integer}, nil]
       def read_config config_path = ''
         return nil if config_path.empty?
         return nil unless File.file?(config_path)
         YAML.safe_load(File.read(config_path))
       end
 
-      # @return [Hash]
+      # @return [Hash{String => Array, Hash, Integer}]
       def default_config
         {
           'include' => ['**/*.rb'],
@@ -222,6 +224,7 @@ module Solargraph
         glob.gsub(/(\/\*|\/\*\*\/\*\*?)$/, '')
       end
 
+      # @return [Array<String>]
       def excluded_directories
         @raw_data['exclude']
           .select { |g| glob_is_directory?(g) }

data/lib/solargraph/workspace.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'open3'
-require 'rubygems'
 require 'json'
 
 module Solargraph
@@ -26,9 +25,11 @@ module Solargraph
 
     # @param directory [String]
     # @param config [Config, nil]
-    def initialize directory = '', config = nil
+    # @param server [Hash]
+    def initialize directory = '', config = nil, server = {}
       @directory = directory
       @config = config
+      @server = server
       load_sources
       @gemnames = []
       @require_paths = generate_require_paths
@@ -104,7 +105,8 @@ module Solargraph
     # @return [Boolean]
     def would_require? path
       require_paths.each do |rp|
-        return true if File.exist?(File.join(rp, "#{path}.rb"))
+        full = File.join rp, path
+        return true if File.exist?(full) or File.exist?(full << ".rb")
       end
       false
     end
@@ -126,6 +128,11 @@ module Solargraph
       end
     end
 
+    # @return [String, nil]
+    def rbs_collection_path
+      @gem_rbs_collection ||= read_rbs_collection_path
+    end
+
     # Synchronize the workspace from the provided updater.
     #
     # @param updater [Source::Updater]
@@ -134,8 +141,19 @@ module Solargraph
       source_hash[updater.filename] = source_hash[updater.filename].synchronize(updater)
     end
 
+    # @return [String]
+    def command_path
+      server['commandPath'] || 'solargraph'
+    end
+
     private
 
+    # The language server configuration (or an empty hash if the workspace was
+    # not initialized from a server).
+    #
+    # @return [Hash]
+    attr_reader :server
+
     # @return [Hash{String => Solargraph::Source}]
     def source_hash
       @source_hash ||= {}
@@ -199,6 +217,7 @@ module Solargraph
       config.require_paths.map{|p| File.join(directory, p)}
     end
 
+    # @return [void]
     def require_plugins
       config.plugins.each do |plugin|
         begin
@@ -208,5 +227,13 @@ module Solargraph
         end
       end
     end
+
+    # @return [String, nil]
+    def read_rbs_collection_path
+      yaml_file = File.join(directory, 'rbs_collection.yaml')
+      return unless File.file?(yaml_file)
+
+      YAML.load_file(yaml_file)&.fetch('path')
+    end
   end
 end

data/lib/solargraph/yard_map/cache.rb

@@ -4,13 +4,19 @@ module Solargraph
   class YardMap
     class Cache
       def initialize
+        # @type [Hash{String => Array<Solargraph::Pin::Base>}]
         @path_pins = {}
       end
 
+      # @param path [String]
+      # @param pins [Array<Solargraph::Pin::Base>]
+      # @return [Array<Solargraph::Pin::Base>]
       def set_path_pins path, pins
         @path_pins[path] = pins
       end
 
+      # @param path [String]
+      # @return [Array<Solargraph::Pin::Base>]
       def get_path_pins path
         @path_pins[path]
       end

data/lib/solargraph/yard_map/helpers.rb

@@ -4,7 +4,7 @@ module Solargraph
       module_function
 
       # @param code_object [YARD::CodeObjects::Base]
-      # @param spec [Gem::Specification]
+      # @param spec [Gem::Specification, nil]
       # @return [Solargraph::Location, nil]
       def object_location code_object, spec
         return nil if spec.nil? || code_object.nil? || code_object.file.nil? || code_object.line.nil?

data/lib/solargraph/yard_map/mapper/to_method.rb

@@ -6,23 +6,33 @@ module Solargraph
       module ToMethod
         extend YardMap::Helpers
 
+        # @param code_object [YARD::CodeObjects::Base]
+        # @param name [String, nil]
+        # @param scope [Symbol, nil]
+        # @param visibility [Symbol, nil]
+        # @param closure [Solargraph::Pin::Namespace, nil]
+        # @param spec [Gem::Specification, nil]
+        # @return [Solargraph::Pin::Method]
         def self.make code_object, name = nil, scope = nil, visibility = nil, closure = nil, spec = nil
           closure ||= Solargraph::Pin::Namespace.new(
             name: code_object.namespace.to_s,
             gates: [code_object.namespace.to_s]
           )
           location = object_location(code_object, spec)
+          name ||= code_object.name.to_s
+          return_type = ComplexType::SELF if name == 'new'
           comments = code_object.docstring ? code_object.docstring.all.to_s : ''
           pin = Pin::Method.new(
             location: location,
             closure: closure,
-            name: name || code_object.name.to_s,
+            name: name,
             comments: comments,
             scope: scope || code_object.scope,
             visibility: visibility || code_object.visibility,
             # @todo Might need to convert overloads to signatures
             parameters: [],
-            explicit: code_object.is_explicit?
+            explicit: code_object.is_explicit?,
+            return_type: return_type
           )
           pin.parameters.concat get_parameters(code_object, location, comments, pin)
           pin
@@ -32,6 +42,9 @@ module Solargraph
           private
 
           # @param code_object [YARD::CodeObjects::Base]
+          # @param location [Location],
+          # @param comments [String]
+          # @param pin [Pin::Base]
           # @return [Array<Solargraph::Pin::Parameter>]
           def get_parameters code_object, location, comments, pin
             return [] unless code_object.is_a?(YARD::CodeObjects::MethodObject)
@@ -51,7 +64,7 @@ module Solargraph
             end
           end
 
-          # @param a [Array]
+          # @param a [Array<String>]
           # @return [String]
           def arg_name a
             a[0].gsub(/[^a-z0-9_]/i, '')

data/lib/solargraph/yard_map/mapper.rb

@@ -8,7 +8,7 @@ module Solargraph
       autoload :ToConstant, 'solargraph/yard_map/mapper/to_constant'
 
       # @param code_objects [Array<YARD::CodeObjects::Base>]
-      # @param spec [Gem::Specification]
+      # @param spec [Gem::Specification, nil]
       def initialize code_objects, spec = nil
         @code_objects = code_objects
         @spec = spec

data/lib/solargraph/yard_map/to_method.rb

@@ -7,6 +7,8 @@ module Solargraph
         module_function
 
         # @param code_object [YARD::CodeObjects::Base]
+        # @param location [Solargraph::Location]
+        # @param comments [String]
         # @return [Array<Solargraph::Pin::Parameter>]
         def get_parameters code_object, location, comments
           return [] unless code_object.is_a?(YARD::CodeObjects::MethodObject)
@@ -26,7 +28,7 @@ module Solargraph
           end
         end
 
-        # @param a [Array]
+        # @param a [Array<String>]
         # @return [String]
         def arg_name a
           a[0].gsub(/[^a-z0-9_]/i, '')
@@ -52,10 +54,15 @@ module Solargraph
       end
       private_constant :InnerMethods
 
-      # include YardMixin
-      # extend YardMixin
-      extend Helpers
+      include Helpers
 
+      # @param code_object [YARD::CodeObjects::Base]
+      # @param name [String, nil]
+      # @param scope [Symbol, nil]
+      # @param visibility [Symbol, nil]
+      # @param closure [Solargraph::Pin::Base, nil]
+      # @param spec [Solargraph::Pin::Base, nil]
+      # @return [Solargraph::Pin::Method]
       def make code_object, name = nil, scope = nil, visibility = nil, closure = nil, spec = nil
         closure ||= Solargraph::Pin::Namespace.new(
           name: code_object.namespace.to_s,

data/lib/solargraph/yard_map.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
 require 'yard'
-require 'yard-solargraph'
-require 'rubygems/package'
-require 'set'
+require 'solargraph/yard_tags'
 
 module Solargraph
   # The YardMap provides access to YARD documentation for the Ruby core, the
@@ -14,296 +12,7 @@ module Solargraph
 
     autoload :Cache,       'solargraph/yard_map/cache'
     autoload :Mapper,      'solargraph/yard_map/mapper'
-    autoload :RdocToYard,  'solargraph/yard_map/rdoc_to_yard'
     autoload :Helpers,     'solargraph/yard_map/helpers'
     autoload :ToMethod,    'solargraph/yard_map/to_method'
-
-    include ApiMap::BundlerMethods
-
-    # @return [Boolean]
-    attr_writer :with_dependencies
-
-    # @param required [Array<String>, Set<String>]
-    # @param directory [String]
-    # @param source_gems [Array<String>, Set<String>]
-    # @param with_dependencies [Boolean]
-    def initialize(required: [], directory: '', source_gems: [], with_dependencies: true)
-      @with_dependencies = with_dependencies
-      change required.to_set, directory, source_gems.to_set
-    end
-
-    # @return [Array<Solargraph::Pin::Base>]
-    def pins
-      @pins ||= []
-    end
-
-    def with_dependencies?
-      @with_dependencies ||= true unless @with_dependencies == false
-      @with_dependencies
-    end
-
-    # @param new_requires [Set<String>] Required paths to use for loading gems
-    # @param new_directory [String] The workspace directory
-    # @param new_source_gems [Set<String>] Gems under local development (i.e., part of the workspace)
-    # @return [Boolean]
-    def change new_requires, new_directory, new_source_gems
-      return false if new_requires == base_required && new_directory == @directory && new_source_gems == @source_gems
-      @gem_paths = {}
-      base_required.replace new_requires
-      required.replace new_requires
-      # HACK: Hardcoded YAML handling
-      required.add 'psych' if new_requires.include?('yaml')
-      @source_gems = new_source_gems
-      @directory = new_directory
-      process_requires
-      @rebindable_method_names = nil
-      @pin_class_hash = nil
-      @pin_select_cache = {}
-      pins.each { |p| p.source = :yard }
-      true
-    end
-
-    # @return [Set<String>]
-    def rebindable_method_names
-      @rebindable_method_names ||= pins_by_class(Pin::Method)
-        .select { |pin| pin.comments && pin.comments.include?('@yieldself') }
-        .map(&:name)
-        .concat(['instance_eval', 'instance_exec', 'class_eval', 'class_exec', 'module_eval', 'module_exec', 'define_method'])
-        .to_set
-    end
-
-    # @return [Array<String>]
-    def yardocs
-      @yardocs ||= []
-    end
-
-    # @return [Set<String>]
-    def required
-      @required ||= Set.new
-    end
-
-    # @return [Array<String>]
-    def unresolved_requires
-      @unresolved_requires ||= []
-    end
-
-    # @return [Array<String>]
-    def missing_docs
-      @missing_docs ||= []
-    end
-
-    # @param y [String]
-    # @return [YARD::Registry]
-    def load_yardoc y
-      if y.is_a?(Array)
-        YARD::Registry.load y, true
-      else
-        YARD::Registry.load! y
-      end
-    rescue StandardError => e
-      Solargraph::Logging.logger.warn "Error loading yardoc '#{y}' #{e.class} #{e.message}"
-      yardocs.delete y
-      nil
-    end
-
-    # @param path [String]
-    # @return [Pin::Base]
-    def path_pin path
-      pins.select { |p| p.path == path }.first
-    end
-
-    # Get the location of a file referenced by a require path.
-    #
-    # @param path [String]
-    # @return [Location]
-    def require_reference path
-      # @type [Gem::Specification]
-      spec = spec_for_require(path)
-      spec.full_require_paths.each do |rp|
-        file = File.join(rp, "#{path}.rb")
-        next unless File.file?(file)
-        return Solargraph::Location.new(file, Solargraph::Range.from_to(0, 0, 0, 0))
-      end
-      nil
-    rescue Gem::LoadError
-      nil
-    end
-
-    def base_required
-      @base_required ||= Set.new
-    end
-
-    def directory
-      @directory ||= ''
-    end
-
-    private
-
-    # @return [YardMap::Cache]
-    def cache
-      @cache ||= YardMap::Cache.new
-    end
-
-    # @return [Hash]
-    def pin_class_hash
-      @pin_class_hash ||= pins.to_set.classify(&:class).transform_values(&:to_a)
-    end
-
-    # @return [Array<Pin::Base>]
-    def pins_by_class klass
-      @pin_select_cache[klass] ||= pin_class_hash.select { |key, _| key <= klass }.values.flatten
-    end
-
-    # @param ns [YARD::CodeObjects::NamespaceObject]
-    # @return [Array<YARD::CodeObjects::Base>]
-    def recurse_namespace_object ns
-      result = []
-      ns.children.each do |c|
-        result.push c
-        result.concat recurse_namespace_object(c) if c.respond_to?(:children)
-      end
-      result
-    end
-
-    # @return [void]
-    def process_requires
-      @gemset = process_gemsets
-      required.merge @gemset.keys if required.include?('bundler/require')
-      pins.clear
-      unresolved_requires.clear
-      missing_docs.clear
-      environ = Convention.for_global(self)
-      done = []
-      already_errored = []
-      (required + environ.requires).each do |r|
-        next if r.nil? || r.empty? || done.include?(r)
-        done.push r
-        cached = cache.get_path_pins(r)
-        unless cached.nil?
-          pins.concat cached
-          next
-        end
-        result = pins_for_require r, already_errored
-        result.delete_if(&:nil?)
-        unless result.empty?
-          cache.set_path_pins r, result
-          pins.concat result
-        end
-      end
-      if required.include?('yaml') && required.include?('psych')
-        # HACK: Hardcoded YAML handling
-        # @todo Why can't this be handled with an override or a virtual pin?
-        pin = path_pin('YAML')
-        pin.instance_variable_set(:@return_type, ComplexType.parse('Module<Psych>')) unless pin.nil?
-      end
-      pins.concat environ.pins
-    end
-
-    def process_error(req, result, already_errored, yd = 1)
-      base = req.split('/').first
-      return if already_errored.include?(base)
-      already_errored.push base
-      if yd.nil?
-        missing_docs.push req
-      else
-        unresolved_requires.push req
-      end
-    end
-
-    def process_gemsets
-      return {} if directory.empty? || !File.file?(File.join(directory, 'Gemfile'))
-      require_from_bundle(directory)
-    end
-
-    # @param r [String]
-    def pins_for_require r, already_errored
-      result = []
-      begin
-        name = r.split('/').first.to_s
-        return [] if name.empty?
-
-        spec = spec_for_require(r)
-        return [] if @source_gems.include?(spec.name) || @gem_paths.key?(spec.name)
-        @gem_paths[spec.name] = spec.full_gem_path
-
-        yd = yardoc_file_for_spec(spec)
-        # YARD detects gems for certain libraries that do not have a yardoc
-        # but exist in the stdlib. `fileutils` is an example. Treat those
-        # cases as errors and check the stdlib yardoc.
-        if yd.nil?
-          process_error(r, result, already_errored, nil)
-          return []
-        end
-        unless yardocs.include?(yd)
-          yardocs.unshift yd
-          result.concat process_yardoc yd, spec
-          if with_dependencies?
-            (spec.dependencies - spec.development_dependencies).each do |dep|
-              result.concat pins_for_require dep.name, already_errored
-            end
-          end
-        end
-      rescue Gem::LoadError, NoYardocError
-        process_error(r, result, already_errored)
-      end
-      return result
-    end
-
-    # @param y [String, nil]
-    # @param spec [Gem::Specification, nil]
-    # @return [Array<Pin::Base>]
-    def process_yardoc y, spec = nil
-      return [] if y.nil?
-      if spec
-        cache = Solargraph::Cache.load('gems', "#{spec.name}-#{spec.version}.ser")
-        return cache if cache
-      end
-      size = Dir.glob(File.join(y, '**', '*'))
-        .map{ |f| File.size(f) }
-        .inject(:+)
-      if !size.nil? && size > 20_000_000
-        Solargraph::Logging.logger.warn "Yardoc at #{y} is too large to process (#{size} bytes)"
-        return []
-      end
-      Solargraph.logger.info "Loading #{spec.name} #{spec.version} from #{y}"
-      load_yardoc y
-      result = Mapper.new(YARD::Registry.all, spec).map
-      raise NoYardocError, "Yardoc at #{y} is empty" if result.empty?
-      if spec
-        Solargraph::Cache.save 'gems', "#{spec.name}-#{spec.version}.ser", result
-      end
-      result
-    end
-
-    # @param spec [Gem::Specification]
-    # @return [String]
-    def yardoc_file_for_spec spec
-      YARD::Registry.yardoc_file_for_gem(spec.name, "= #{spec.version}")
-    end
-
-    # @param path [String]
-    # @return [Gem::Specification]
-    def spec_for_require path
-      relatives = path.split('/')
-      spec = nil
-      while spec.nil? && !relatives.empty?
-        name = relatives.join('-')
-        spec = Gem::Specification.find_by_name(name, @gemset[name])
-        relatives.pop
-      end
-      raise Gem::LoadError if spec.nil?
-
-      # Avoid loading the spec again if it's going to be skipped anyway
-      return spec if @source_gems.include?(spec.name)
-      # Avoid loading the spec again if it's already the correct version
-      if @gemset[spec.name] && spec.version != @gemset[spec.name]
-        begin
-          return Gem::Specification.find_by_name(spec.name, "= #{@gemset[spec.name]}")
-        rescue Gem::LoadError
-          Solargraph.logger.warn "Unable to load #{spec.name} #{@gemset[spec.name]} specified by workspace, using #{spec.version} instead"
-        end
-      end
-      spec
-    end
   end
 end

data/lib/solargraph/yard_tags.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'yard'
+
+# Change YARD log IO to avoid sending unexpected messages to STDOUT
+YARD::Logger.instance.io = File.new(File::NULL, 'w')
+
+module Solargraph
+  # A placeholder for the @!domain directive. It doesn't need to do anything
+  # for yardocs. It's only used for Solargraph API maps.
+  class DomainDirective < YARD::Tags::Directive
+    def call; end
+  end
+end
+
+# Define a @type tag for documenting variables
+YARD::Tags::Library.define_tag("Type", :type, :with_types_and_name)
+
+# Define an @!override directive for overriding method tags
+YARD::Tags::Library.define_directive("override", :with_name, Solargraph::DomainDirective)

data/lib/solargraph/yardoc.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Solargraph
+  # Methods for caching and loading YARD documentation for gems.
+  #
+  module Yardoc
+    module_function
+
+    # Build and cache a gem's yardoc and return the path. If the cache already
+    # exists, do nothing and return the path.
+    #
+    # @param gemspec [Gem::Specification]
+    # @return [String] The path to the cached yardoc.
+    def cache(gemspec)
+      path = path_for(gemspec)
+      return path if cached?(gemspec)
+
+      Solargraph.logger.info "Caching yardoc for #{gemspec.name} #{gemspec.version}"
+      Dir.chdir gemspec.gem_dir do
+        `yardoc --db #{path} --no-output --plugin solargraph`
+      end
+      path
+    end
+
+    # True if the gem yardoc is cached.
+    #
+    # @param gemspec [Gem::Specification]
+    def cached?(gemspec)
+      yardoc = File.join(path_for(gemspec), 'complete')
+      File.exist?(yardoc)
+    end
+
+    # Get the absolute path for a cached gem yardoc.
+    #
+    # @param gemspec [Gem::Specification]
+    # @return [String]
+    def path_for(gemspec)
+      File.join(Solargraph::Cache.work_dir, 'gems', "#{gemspec.name}-#{gemspec.version}.yardoc")
+    end
+
+    # Load a gem's yardoc and return its code objects.
+    #
+    # @note This method modifies the global YARD registry.
+    #
+    # @param gemspec [Gem::Specification]
+    # @return [Array<YARD::CodeObjects::Base>]
+    def load!(gemspec)
+      YARD::Registry.load! path_for(gemspec)
+      YARD::Registry.all
+    end
+  end
+end