rbs 2.8.4 → 3.8.1

data/lib/rbs/collection/config/lockfile_generator.rb

@@ -4,6 +4,8 @@ module RBS
   module Collection
     class Config
       class LockfileGenerator
+        ALUMNI_STDLIBS = { "mutex_m" => ">= 0.3.0" }
+
         class GemfileLockMismatchError < StandardError
           def initialize(expected:, actual:)
             @expected = expected
@@ -20,105 +22,192 @@ module RBS
           end
         end
 
-        attr_reader :config, :lock, :gemfile_lock, :lock_path
+        attr_reader :config, :lockfile, :definition, :existing_lockfile, :gem_hash, :gem_entries
 
-        def self.generate(config_path:, gemfile_lock_path:, with_lockfile: true)
-          new(config_path: config_path, gemfile_lock_path: gemfile_lock_path, with_lockfile: with_lockfile).generate
+        def self.generate(config:, definition:, with_lockfile: true)
+          generator = new(config: config, definition: definition, with_lockfile: with_lockfile)
+          generator.generate
+          generator.lockfile
         end
 
-        def initialize(config_path:, gemfile_lock_path:, with_lockfile:)
-          @config = Config.from_path config_path
-          @lock_path = Config.to_lockfile_path(config_path)
-          @lock = Config.from_path(lock_path) if lock_path.exist? && with_lockfile
-          @gemfile_lock = Bundler::LockfileParser.new(gemfile_lock_path.read)
-          @gem_queue = []
+        def initialize(config:, definition:, with_lockfile:)
+          @config = config
+
+          @gem_entries = config.gems.each.with_object({}) do |entry, hash| #$ Hash[String, gem_entry?]
+            name = entry["name"]
+            hash[name] = entry
+          end
+
+          lockfile_path = Config.to_lockfile_path(config.config_path)
+          lockfile_dir = lockfile_path.parent
+
+          @lockfile = Lockfile.new(
+            lockfile_path: lockfile_path,
+            path: config.repo_path_data,
+            gemfile_lock_path: definition.lockfile.relative_path_from(lockfile_dir)
+          )
 
-          validate_gemfile_lock_path!(lock: lock, gemfile_lock_path: gemfile_lock_path)
+          if with_lockfile && lockfile_path.file?
+            @existing_lockfile = Lockfile.from_lockfile(lockfile_path: lockfile_path, data: YAML.load_file(lockfile_path.to_s))
+            validate_gemfile_lock_path!(lock: @existing_lockfile, gemfile_lock_path: definition.lockfile)
+          end
 
-          config.gemfile_lock_path = gemfile_lock_path
+          @definition = definition
+          @gem_hash = definition.locked_gems.specs.each.with_object({}) do |spec, hash|  #$ Hash[String, Bundler::LazySpecification]
+            hash[spec.name] = spec
+          end
         end
 
         def generate
           config.gems.each do |gem|
-            @gem_queue.push({ name: gem['name'], version: gem['version'] })
+            case
+            when gem.dig("source", "type") == "stdlib"
+              unless gem.fetch("ignore", false)
+                assign_stdlib(name: gem["name"])
+              end
+            else
+              assign_gem(name: gem["name"], version: gem["version"])
+            end
           end
 
-          gemfile_lock_gems do |spec|
-            @gem_queue.push({ name: spec.name, version: spec.version })
-          end
+          definition.dependencies.each do |dep|
+            if dep.autorequire && dep.autorequire.empty?
+              next
+            end
 
-          while gem = @gem_queue.shift
-            assign_gem(**gem)
+            if spec = gem_hash[dep.name]
+              assign_gem(name: dep.name, version: spec.version, skip: dep.source.is_a?(Bundler::Source::Gemspec))
+            end
           end
-          remove_ignored_gems!
 
-          config.dump_to(lock_path)
-          config
+          lockfile.lockfile_path.write(YAML.dump(lockfile.to_lockfile))
         end
 
         private def validate_gemfile_lock_path!(lock:, gemfile_lock_path:)
           return unless lock
-          return unless lock.gemfile_lock_path
-          return if lock.gemfile_lock_path == gemfile_lock_path
-
-          raise GemfileLockMismatchError.new(expected: lock.gemfile_lock_path, actual: gemfile_lock_path)
+          return unless lock.gemfile_lock_fullpath
+          unless File.realpath(lock.gemfile_lock_fullpath) == File.realpath(gemfile_lock_path)
+            raise GemfileLockMismatchError.new(expected: lock.gemfile_lock_fullpath, actual: gemfile_lock_path)
+          end
         end
 
-        private def assign_gem(name:, version:)
-          # @type var locked: gem_entry?
-          locked = lock&.gem(name)
-          specified = config.gem(name)
-
-          return if specified&.dig('ignore')
-          return if specified&.dig('source') # skip if the source is already filled
-
-          # If rbs_collection.lock.yaml contain the gem, use it.
-          # Else find the gem from gem_collection.
-          unless locked
-            source = find_source(name: name)
-            return unless source
-
-            installed_version = version
-            best_version = find_best_version(version: installed_version, versions: source.versions({ 'name' => name }))
-
-            locked = {
-              'name' => name,
-              'version' => best_version.to_s,
-              'source' => source.to_lockfile,
-            }
+        private def assign_gem(name:, version:, skip: false)
+          entry = gem_entries[name]
+          src_data = entry&.fetch("source", nil)
+          ignored = entry&.fetch("ignore", false)
+
+          return if ignored
+          return if lockfile.gems.key?(name)
+
+          unless skip
+            # @type var locked: Lockfile::library?
+
+            if existing_lockfile
+              locked = existing_lockfile.gems[name]
+            end
+
+            # If rbs_collection.lock.yaml contain the gem, use it.
+            # Else find the gem from gem_collection.
+            unless locked
+              source =
+                if src_data
+                  Sources.from_config_entry(src_data, base_directory: config.config_path.dirname)
+                else
+                  find_source(name: name)
+                end
+
+              if source.is_a?(Sources::Stdlib)
+                assign_stdlib(name: name)
+                return
+              end
+
+              if source
+                installed_version = version
+                best_version = find_best_version(version: installed_version, versions: source.versions(name))
+
+                locked = {
+                  name: name,
+                  version: best_version.to_s,
+                  source: source,
+                }
+              end
+            end
+
+            if locked
+              lockfile.gems[name] = locked
+
+              begin
+                locked[:source].dependencies_of(locked[:name], locked[:version])&.each do |dep|
+                  assign_stdlib(name: dep["name"], from_gem: name)
+                end
+              rescue
+                RBS.logger.warn "Cannot find `#{locked[:name]}-#{locked[:version]}` gem. Using incorrect Bundler context? (#{definition.lockfile})"
+              end
+            end
           end
 
-          locked or raise
-
-          upsert_gem specified, locked
-          source = Sources.from_config_entry(locked['source'] || raise)
-          source.dependencies_of(locked)&.each do |dep|
-            @gem_queue.push({ name: dep['name'], version: nil} )
+          if spec = gem_hash.fetch(name, nil)
+            spec.dependencies.each do |dep|
+              if dep_spec = gem_hash[dep.name]
+                assign_gem(name: dep.name, version: dep_spec.version)
+              end
+            end
+          else
+            RBS.logger.warn "Cannot find `#{name}` gem. Using incorrect Bundler context? (#{definition.lockfile})"
           end
         end
 
-        private def upsert_gem(old, new)
-          if old
-            old.merge! new
-          else
-            config.add_gem new
+        private def assign_stdlib(name:, from_gem: nil)
+          return if lockfile.gems.key?(name)
+
+          case name
+          when 'rubygems', 'set'
+            msg = "`#{name}` has been moved to core library, so it is always loaded. Remove explicit loading `#{name}`"
+            msg << " from `#{from_gem}`" if from_gem
+            msg << "."
+            return
+          when *ALUMNI_STDLIBS.keys
+            version = ALUMNI_STDLIBS.fetch(name)
+            if from_gem
+              # From `dependencies:` of a `manifest.yaml` of a gem
+              source = find_source(name: name) or raise
+              if source.is_a?(Sources::Stdlib)
+                RBS.logger.warn {
+                  "`#{name}` is included in the RBS dependencies of `#{from_gem}`, but the type definition as a stdlib in rbs-gem is deprecated. Add `#{name}` (#{version}) to the dependency of your Ruby program to use the gem-bundled type definition."
+                }
+              else
+                RBS.logger.info {
+                  "`#{name}` is included in the RBS dependencies of `#{from_gem}`, but the type definition as a stdlib in rbs-gem is deprecated. Delete `#{name}` from the RBS dependencies of `#{from_gem}`."
+                }
+                assign_gem(name: name, version: nil)
+                return
+              end
+            else
+              # From `gems:` of a `rbs_collection.yaml`
+              RBS.logger.warn {
+                "`#{name}` as a stdlib in rbs-gem is deprecated. Add `#{name}` (#{version}) to the dependency of your Ruby program to use the gem-bundled type definition."
+              }
+            end
           end
-        end
 
-        private def remove_ignored_gems!
-          config.gems.reject! { |gem| gem['ignore'] }
-        end
+          source = Sources::Stdlib.instance
+          lockfile.gems[name] = { name: name, version: "0", source: source }
+
+          unless source.has?(name, nil)
+            raise "Cannot find `#{name}` from standard libraries"
+          end
 
-        private def gemfile_lock_gems(&block)
-          gemfile_lock.specs.each do |spec|
-            yield spec
+          if deps = source.dependencies_of(name, "0")
+            deps.each do |dep|
+              assign_stdlib(name: dep["name"], from_gem: name)
+            end
           end
         end
 
         private def find_source(name:)
           sources = config.sources
 
-          sources.find { |c| c.has?({ 'name' => name, 'revision' => nil } ) }
+          sources.find { |c| c.has?(name, nil) }
         end
 
         private def find_best_version(version:, versions:)

data/lib/rbs/collection/config.rb

@@ -16,6 +16,8 @@ module RBS
 
       PATH = Pathname('rbs_collection.yaml')
 
+      attr_reader :config_path, :data
+
       def self.find_config_path
         current = Pathname.pwd
 
@@ -29,19 +31,17 @@ module RBS
 
       # Generate a rbs lockfile from Gemfile.lock to `config_path`.
       # If `with_lockfile` is true, it respects existing rbs lockfile.
-      def self.generate_lockfile(config_path:, gemfile_lock_path:, with_lockfile: true)
-        LockfileGenerator.generate(config_path: config_path, gemfile_lock_path: gemfile_lock_path, with_lockfile: with_lockfile)
+      def self.generate_lockfile(config_path:, definition:, with_lockfile: true)
+        config = from_path(config_path)
+        lockfile = LockfileGenerator.generate(config: config, definition: definition, with_lockfile: with_lockfile)
+
+        [config, lockfile]
       end
 
       def self.from_path(path)
         new(YAML.load(path.read), config_path: path)
       end
 
-      def self.lockfile_of(config_path)
-        lock_path = to_lockfile_path(config_path)
-        from_path lock_path if lock_path.exist?
-      end
-
       def self.to_lockfile_path(config_path)
         config_path.sub_ext('.lock' + config_path.extname)
       end
@@ -51,57 +51,30 @@ module RBS
         @config_path = config_path
       end
 
-      def add_gem(gem)
-        gems << gem
-      end
-
       def gem(gem_name)
         gems.find { |gem| gem['name'] == gem_name }
       end
 
       def repo_path
-        @config_path.dirname.join @data['path']
+        @config_path.dirname.join repo_path_data
       end
 
-      def sources
-        @sources ||= (
-          @data['sources']
-            .map { |c| Sources.from_config_entry(c) }
-            .push(Sources::Stdlib.instance)
-            .push(Sources::Rubygems.instance)
-        )
+      def repo_path_data
+        Pathname(@data["path"])
       end
 
-      def dump_to(io)
-        YAML.dump(@data, io)
+      def sources
+        @sources ||= [
+          Sources::Rubygems.instance,
+          *@data['sources'].map { |c| Sources.from_config_entry(c, base_directory: @config_path.dirname) },
+          Sources::Stdlib.instance
+        ]
       end
 
       def gems
-        @data['gems'] ||= []
-      end
-
-      def gemfile_lock_path=(path)
-        @data['gemfile_lock_path'] = path.relative_path_from(@config_path.dirname).to_s
-      end
-
-      def gemfile_lock_path
-        path = @data['gemfile_lock_path']
-        return unless path
-        @config_path.dirname.join path
-      end
-
-      # It raises an error when there are non-available libraries
-      def check_rbs_availability!
-        raise CollectionNotAvailable unless repo_path.exist?
-
-        gems.each do |gem|
-          case gem['source']['type']
-          when 'git'
-            meta_path = repo_path.join(gem['name'], gem['version'], Sources::Git::METADATA_FILENAME)
-            raise CollectionNotAvailable unless meta_path.exist?
-            raise CollectionNotAvailable unless gem == YAML.load(meta_path.read)
-          end
-        end
+        @data['gems'] ||= (
+          [] #: Array[gem_entry]
+        )
       end
     end
   end

data/lib/rbs/collection/installer.rb

@@ -7,26 +7,25 @@ module RBS
       attr_reader :stdout
 
       def initialize(lockfile_path:, stdout: $stdout)
-        @lockfile = Config.from_path(lockfile_path)
+        @lockfile = Config::Lockfile.from_lockfile(lockfile_path: lockfile_path, data: YAML.load_file(lockfile_path))
         @stdout = stdout
       end
 
       def install_from_lockfile
-        install_to = lockfile.repo_path
+        install_to = lockfile.fullpath
         install_to.mkpath
-        lockfile.gems.each do |config_entry|
-          source_for(config_entry).install(dest: install_to, config_entry: config_entry, stdout: stdout)
+        selected = lockfile.gems.select do |name, gem|
+          gem[:source].has?(name, gem[:version])
         end
-        stdout.puts "It's done! #{lockfile.gems.size} gems' RBSs now installed."
-      end
-
-      private def source_for(config_entry)
-        @source_for ||= {}
-        key = config_entry['source']
-        unless key
-          raise "Cannot find source of '#{config_entry['name']}' gem"
+        selected.each_value do |gem|
+          gem[:source].install(
+            dest: install_to,
+            name: gem[:name],
+            version: gem[:version],
+            stdout: stdout
+          )
         end
-        @source_for[key] ||= Sources.from_config_entry(key)
+        CLI::ColoredIO.new(stdout: stdout).puts_green("It's done! #{selected.size} gems' RBSs now installed.")
       end
     end
   end

data/lib/rbs/collection/sources/base.rb

@@ -4,8 +4,8 @@ module RBS
   module Collection
     module Sources
       module Base
-        def dependencies_of(config_entry)
-          manifest = manifest_of(config_entry) or return
+        def dependencies_of(name, version)
+          manifest = manifest_of(name, version) or return
           manifest['dependencies']
         end
       end