solargraph 0.60.3 → 0.61.0

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

data/lib/solargraph/rbs_map/gem.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module RbsMap
+    class Gem < Base
+      # @param metagem [Metagem]
+      def initialize metagem
+        super()
+        loader.add path: Pathname.new(metagem.full_path)
+      end
+    end
+  end
+end

data/lib/solargraph/rbs_map/helpers.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module RbsMap
+    module Helpers
+      module_function
+
+      # @param  orig_pins [Array<Pin::Base>]
+      # @param rbs_pins [Array<Pin::Base>]
+      # @return [Array<Pin::Base>]
+      def combine orig_pins, rbs_pins
+        in_orig = Set.new
+        # @todo There's gotta be a better way!
+        rbs_api_map = Solargraph::ApiMap.new(pins: rbs_pins)
+        combined =  orig_pins.map do |orig_pin|
+          in_orig.add orig_pin.path
+          rbs_pin = rbs_api_map.get_path_pins(orig_pin.path).filter { |pin| pin.is_a? Pin::Method }.first
+          next orig_pin unless rbs_pin && orig_pin.instance_of?(Pin::Method)
+
+          unless rbs_pin
+            # @sg-ignore https://github.com/castwide/solargraph/pull/1114
+            Solargraph.logger.debug { "GemPins.combine: No rbs pin for #{orig_pin.path} - using YARD's '#{orig_pin.inspect} (return_type=#{orig_pin.return_type}; signatures=#{orig_pin.signatures})" }
+            next orig_pin
+          end
+
+          out = combine_method_pins(rbs_pin, orig_pin)
+          Solargraph.logger.debug { "GemPins.combine: Combining yard.path=#{orig_pin.path} - rbs=#{rbs_pin.inspect} with yard=#{orig_pin.inspect} into #{out}" }
+          out
+        end
+        in_rbs_only = rbs_pins.select do |pin|
+          pin.path.nil? || !in_orig.include?(pin.path)
+        end
+        out = combined + in_rbs_only
+        Solargraph.logger.debug { "GemPins#combine: Returning #{out.length} combined pins" }
+        out
+      end
+
+      # @param pins [Array<Pin::Method>]
+      # @return [Pin::Method, nil]
+      def combine_method_pins(*pins)
+        # @type [Pin::Method, nil]
+        combined_pin = nil
+        # @param memo [Pin::Method, nil]
+        # @param pin [Pin::Method]
+        out = pins.reduce(combined_pin) do |memo, pin|
+          next pin if memo.nil?
+          if memo == pin && memo.source != :combined
+            # @todo we should track down situations where we are handled
+            #   the same pin from the same source here and eliminate them -
+            #   this is an efficiency workaround for now
+            next memo
+          end
+          memo.combine_with(pin)
+        end
+        Solargraph.logger.debug { "GemPins.combine_method_pins(pins.length=#{pins.length}, pins=#{pins}) => #{out.inspect}" }
+        out
+      end
+    end
+  end
+end

data/lib/solargraph/rbs_map/path.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module RbsMap
+    class Path < Base
+      # @param path [String]
+      # @return [Array<Pin::Base>]
+      def self.pins path
+        new(path).pins
+      end
+
+      # @param path [String]
+      def initialize path
+        super()
+        loader.add path: Pathname.new(path)
+      end
+    end
+  end
+end

data/lib/solargraph/rbs_map/stdlib.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'rbs'
+
+module Solargraph
+  module RbsMap
+    # Ruby stdlib pins
+    #
+    class Stdlib < Base
+      def initialize library
+        super()
+        loader.add(library: library.gsub('/', '-')) if self.class.has?(library)
+      end
+
+      def repository
+        @repository ||= RBS::Repository.new(no_stdlib: false)
+      end
+
+      def self.has? library
+        !!RBS::Collection::Sources::Stdlib.instance.has?(library.gsub('/', '-'), nil)
+      end
+    end
+  end
+end

data/lib/solargraph/rbs_map.rb

@@ -1,207 +1,16 @@
 # frozen_string_literal: true
 
-require 'digest'
-require 'pathname'
 require 'rbs'
 
 module Solargraph
-  class RbsMap
+  module RbsMap
+    autoload :Base,        'solargraph/rbs_map/base'
     autoload :Conversions, 'solargraph/rbs_map/conversions'
-    autoload :CoreMap,     'solargraph/rbs_map/core_map'
+    autoload :Core,        'solargraph/rbs_map/core'
     autoload :CoreFills,   'solargraph/rbs_map/core_fills'
-    autoload :StdlibMap,   'solargraph/rbs_map/stdlib_map'
-
-    include Logging
-
-    # @type [Hash{String => RbsMap}]
-    @@rbs_maps_hash = {}
-
-    attr_reader :library, :rbs_collection_paths, :rbs_collection_config_path
-
-    # @param library [String]
-    # @param version [String, nil]
-    # @param rbs_collection_config_path [String, Pathname, nil]
-    # @param rbs_collection_paths [Array<Pathname, String>]
-    # @param out [StringIO, IO, nil] where to log messages
-    def initialize library, version = nil, rbs_collection_config_path: nil, rbs_collection_paths: [], out: $stderr
-      if rbs_collection_config_path.nil? && !rbs_collection_paths.empty?
-        raise 'Please provide rbs_collection_config_path if you provide rbs_collection_paths'
-      end
-      @library = library
-      @version = version
-      @rbs_collection_config_path = rbs_collection_config_path
-      @rbs_collection_paths = rbs_collection_paths
-      add_library loader, library, version
-    end
-
-    CACHE_KEY_GEM_EXPORT = 'gem-export'
-    CACHE_KEY_UNRESOLVED = 'unresolved'
-    CACHE_KEY_STDLIB = 'stdlib'
-    CACHE_KEY_LOCAL = 'local'
-
-    # @param cache_key [String, nil]
-    # @return [String, nil] a description of the source of the RBS info
-    def self.rbs_source_desc cache_key
-      case cache_key
-      when CACHE_KEY_GEM_EXPORT
-        'RBS gem export'
-      when CACHE_KEY_UNRESOLVED
-        nil
-      when CACHE_KEY_STDLIB
-        'RBS standard library'
-      when CACHE_KEY_LOCAL
-        'local RBS shims'
-      else
-        'RBS collection'
-      end
-    end
-
-    # @return [RBS::EnvironmentLoader]
-    def loader
-      @loader ||= RBS::EnvironmentLoader.new(core_root: nil, repository: repository)
-    end
-
-    # @return [String] representing the version of the RBS info fetched
-    #   for the given library.  Must change when the RBS info is
-    #   updated upstream for the same library and version.  May change
-    #   if the config for where information comes form changes.
-    def cache_key
-      return CACHE_KEY_UNRESOLVED unless resolved?
-
-      @cache_key ||= begin
-        # @type [String, nil]
-        data = nil
-        # @type gem_config [nil, Hash{String => Hash{String => String}}]
-        gem_config = nil
-        if rbs_collection_config_path
-          # @sg-ignore rbs_collection_config_path is not nil here
-          lockfile_path = RBS::Collection::Config.to_lockfile_path(Pathname.new(rbs_collection_config_path))
-          if lockfile_path.exist?
-            collection_config = RBS::Collection::Config.from_path lockfile_path
-            gem_config = collection_config.gem(library)
-            data = gem_config&.to_s
-          end
-        end
-        if gem_config.nil?
-          CACHE_KEY_STDLIB
-        else
-          # @type [String]
-          source = gem_config.dig('source', 'type')
-          case source
-          when 'rubygems'
-            CACHE_KEY_GEM_EXPORT
-          when 'local'
-            CACHE_KEY_LOCAL
-          when 'stdlib'
-            CACHE_KEY_STDLIB
-          else
-            Digest::SHA1.hexdigest(data || '')
-          end
-        end
-      end
-    end
-
-    # @param gemspec [Gem::Specification, Bundler::LazySpecification]
-    # @param rbs_collection_path [String, Pathname, nil]
-    # @param rbs_collection_config_path [String, Pathname, nil]
-    # @return [RbsMap]
-    def self.from_gemspec gemspec, rbs_collection_path, rbs_collection_config_path
-      # prefers stdlib RBS if available
-      rbs_map = RbsMap::StdlibMap.new(gemspec.name)
-      return rbs_map if rbs_map.resolved?
-
-      rbs_map = RbsMap.new(gemspec.name, gemspec.version,
-                           rbs_collection_paths: [rbs_collection_path].compact,
-                           rbs_collection_config_path: rbs_collection_config_path)
-      return rbs_map if rbs_map.resolved?
-
-      # try any version of the gem in the collection
-      RbsMap.new(gemspec.name, nil,
-                 rbs_collection_paths: [rbs_collection_path].compact,
-                 rbs_collection_config_path: rbs_collection_config_path)
-    end
-
-    # @param out [IO, nil] where to log messages
-    # @return [Array<Pin::Base>]
-    def pins out: $stderr
-      @pins ||= if resolved?
-                  conversions.pins
-                else
-                  []
-                end
-    end
-
-    # @generic T
-    # @param path [String]
-    # @param klass [Class<generic<T>>]
-    #
-    # @sg-ignore Need to be able to resolve generics based on a
-    #   Class<generic<T>> param
-    # @return [generic<T>, nil]
-    def path_pin path, klass = Pin::Base
-      pin = pins.find { |p| p.path == path }
-      pin if pin.is_a?(klass)
-    end
-
-    # @param path [String]
-    # @return [Array<Pin::Base>]
-    def path_pins path
-      pins.select { |p| p.path == path }
-    end
-
-    def resolved?
-      @resolved
-    end
-
-    # @return [RBS::Repository]
-    def repository
-      @repository ||= RBS::Repository.new(no_stdlib: false).tap do |repo|
-        @rbs_collection_paths.each do |dir|
-          dir_path = Pathname.new(dir)
-          repo.add(dir_path) if dir_path.exist? && dir_path.directory?
-        end
-      end
-    end
-
-    # @param library [String]
-    # @return [RbsMap]
-    def self.load library
-      @@rbs_maps_hash[library] ||= RbsMap.new(library)
-    end
-
-    private
-
-    # @return [Conversions]
-    def conversions
-      @conversions ||= Conversions.new(loader: loader)
-    end
-
-    def resolve_dependencies?
-      # we need to resolve dependencies via gemfile.lock manually for
-      # YARD regardless, so use same mechanism here so we don't
-      # duplicate work generating pins from dependencies
-      false
-    end
-
-    # @param loader [RBS::EnvironmentLoader]
-    # @param library [String]
-    # @param version [String, nil] the version of the library to load, or nil for any
-    # @param out [StringIO, IO, nil] where to log messages
-    # @return [Boolean] true if adding the library succeeded
-    def add_library loader, library, version, out: $stderr
-      @resolved = if loader.has_library?(library: library, version: version)
-                    loader.add library: library, version: version, resolve_dependencies: resolve_dependencies?
-                    logger.debug { "#{short_name} successfully loaded library #{library}:#{version}" }
-                    true
-                  else
-                    logger.info { "#{short_name} did not find data for library #{library}:#{version}" }
-                    false
-                  end
-    end
-
-    # @return [String]
-    def short_name
-      self.class.name.split('::').last
-    end
+    autoload :Gem,         'solargraph/rbs_map/gem'
+    autoload :Helpers,     'solargraph/rbs_map/helpers'
+    autoload :Path,        'solargraph/rbs_map/path'
+    autoload :Stdlib,      'solargraph/rbs_map/stdlib'
   end
 end

data/lib/solargraph/repo.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'json'
+
+module Solargraph
+  # A repository for the gems available in the specified directory. If the
+  # directory has a Gemfile, Repo will use its gem definitions. Otherwise it
+  # uses the system gems.
+  #
+  class Repo
+    # @return [String, nil]
+    attr_reader :directory
+
+    # @param directory [String, nil]
+    def initialize directory
+      @directory = File.expand_path(directory) if directory
+      build_from_directory
+    end
+
+    # Find a metagem by path from the directory's bundle definition or the
+    # system gems.
+    #
+    # @param path [String]
+    # @return [Metagem, nil]
+    def find_by_path path
+      return system_find_by_path(path) unless bundled?
+
+      bundled_metagem_path_map[path]
+    end
+
+    # Find a metagem by name from the directory's bundle definition or the
+    # system gems.
+    #
+    # @param name [String]
+    # @return [Metagem, nil]
+    def find_by_name name
+      return system_find_by_name(name) unless bundled?
+
+      bundled_metagem_name_map[name]
+    end
+
+    # Get an array of metagems by its bundle group name. Returns an empty array
+    # if the repo isn't bundled or the group doesn't exist.
+    #
+    # @param group [Symbol]
+    # @return [Array<Metagem>]
+    def find_by_group group
+      return system_find_by_group(group) unless bundled?
+
+      bundled_group_map[group] || []
+    end
+
+    # True if the directory has a bundle definition.
+    #
+    # @note If Solargraph itself is running in this directory's bundled
+    #   environment, `bundled?` is false.
+    #
+    def bundled?
+      !!@metagems
+    end
+    alias bundle? bundled?
+
+    # Metagems from the directory's bundle definition, or an empty array if a
+    # bundle definition does not exist.
+    #
+    # @return [Array<Solargraph::Metagem>]
+    def bundled
+      @metagems || []
+    end
+
+    private
+
+    # @return [String, nil]
+    def gemfile
+      @gemfile ||= File.expand_path('Gemfile', directory) if directory
+    end
+
+    # @return [String, nil]
+    def lockfile
+      @lockfile ||= File.expand_path('Gemfile.lock', directory) if directory
+    end
+
+    def bundled_directory?
+      directory && File.file?(gemfile) && File.file?(lockfile)
+    end
+
+    # Load metagems from the directory's bundle definition if available.
+    #
+    # This method performs gem collection in a separate process to suppress
+    # output from the `Bundler.definition.specs` call.
+    #
+    # @return [Array<Metagem>, nil]
+    def build_from_directory
+      return unless bundled_directory? && ENV['BUNDLE_GEMFILE'] != gemfile
+
+      Solargraph.with_clean_env do
+        cmd = ['ruby', '-e', bundle_script]
+        o, e, s = Open3.capture3(*cmd, chdir: directory)
+        if s.success?
+          json = o && !o.empty? ? JSON.parse(o.strip.split("\n").last, symbolize_names: true) : []
+          @metagems = json[:metagems].map { |data| Metagem.new(**data) }
+          @bundled_group_map = json[:groups].transform_values { |names| names.map { |name| bundled_metagem_name_map[name] } }
+        else
+          Solargraph.logger.warn "Failed to load gems from bundle at #{directory}: #{e}"
+          nil
+        end
+      end
+    end
+
+    def bundle_script
+      "
+        require 'bundler/setup'
+        require 'json'
+
+        puts Bundler.definition.specs.length
+        metagems = Bundler.definition.specs.map do |spec|
+          {
+            name: spec.name,
+            full_path: spec.full_gem_path,
+            spec_file: spec.spec_file,
+            source: spec.source.to_s,
+            version: spec.version,
+            require_paths: spec.require_paths,
+            dependencies: spec.dependencies.map(&:name)
+          }
+        end
+        groups = Bundler.definition.groups.to_h do |group|
+          [group, Bundler.definition.specs_for([group]).map(&:name)]
+        end
+        puts({ groups: groups, metagems: metagems }.to_json)
+      "
+    end
+
+    # @param path [String]
+    # @return [Metagem, nil]
+    def system_find_by_path path
+      gem = Gem::Specification.find_by_path(path)
+      gem && Metagem.from_specification(gem)
+    end
+
+    # @param name [String]
+    # @return [Metagem, nil]
+    def system_find_by_name name
+      gem = Gem::Specification.find_by_name(name)
+      gem && Metagem.from_specification(gem)
+    rescue Gem::MissingSpecError => _e
+      nil
+    end
+
+    # @param group [Symbol]
+    # @return [Array<Metagem>]
+    def system_find_by_group group
+      return [] unless ENV['BUNDLE_GEMFILE']
+
+      Bundler.definition
+             .specs_for([group])
+             .map { |spec| Metagem.from_specification(spec) }
+    end
+
+    def bundled_metagem_name_map
+      @bundled_metagem_name_map ||= bundled.to_set
+                                           .classify(&:name)
+                                           .transform_values(&:first)
+    end
+
+    def bundled_metagem_path_map
+      @bundled_metagem_path_map ||= Hash.new do |hash, path|
+        hash[path] = bundled.find { |mg| mg.require?(path) }
+      end
+    end
+
+    def bundled_group_map
+      @bundled_group_map ||= {}
+    end
+  end
+end