rbs 2.8.4 → 3.0.0.dev.1

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

@@ -20,93 +20,134 @@ module RBS
           end
         end
 
-        attr_reader :config, :lock, :gemfile_lock, :lock_path
+        attr_reader :config, :lockfile, :gemfile_lock, :existing_lockfile
 
-        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:, gemfile_lock_path:, with_lockfile: true)
+          generator = new(config: config, gemfile_lock_path: gemfile_lock_path, 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:, gemfile_lock_path:, with_lockfile:)
+          @config = config
+
+          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: gemfile_lock_path.relative_path_from(lockfile_dir)
+          )
+          config.sources.each do |source|
+            case source
+            when Sources::Git
+              lockfile.sources[source.name] = source
+            end
+          end
 
-          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: gemfile_lock_path)
+          end
 
-          config.gemfile_lock_path = gemfile_lock_path
+          @gemfile_lock = Bundler::LockfileParser.new(gemfile_lock_path.read)
         end
 
         def generate
+          ignored_gems = config.gems.select {|gem| gem["ignore"] }.map {|gem| gem["name"] }.to_set
+
           config.gems.each do |gem|
-            @gem_queue.push({ name: gem['name'], version: gem['version'] })
+            if Sources::Stdlib.instance.has?(gem["name"], nil) || gem.dig("source", "type") == "stdlib"
+              unless ignored_gems.include?(gem["name"])
+                assign_stdlib(name: gem["name"], from_gem: nil)
+              end
+            else
+              assign_gem(name: gem["name"], version: gem["version"], ignored_gems: ignored_gems, src_data: gem["source"])
+            end
           end
 
           gemfile_lock_gems do |spec|
-            @gem_queue.push({ name: spec.name, version: spec.version })
+            assign_gem(name: spec.name, version: spec.version, ignored_gems: ignored_gems, src_data: nil)
           end
 
-          while gem = @gem_queue.shift
-            assign_gem(**gem)
-          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 lock.gemfile_lock_fullpath == 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)
+        private def assign_gem(name:, version:, ignored_gems:, src_data:)
+          return if ignored_gems.include?(name)
+          return if lockfile.gems.key?(name)
 
-          return if specified&.dig('ignore')
-          return if specified&.dig('source') # skip if the source is already filled
+          # @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 = find_source(name: name)
+            source =
+              if src_data
+                Sources.from_config_entry(src_data)
+              else
+                find_source(name: name)
+              end
             return unless source
 
             installed_version = version
-            best_version = find_best_version(version: installed_version, versions: source.versions({ 'name' => name }))
+            best_version = find_best_version(version: installed_version, versions: source.versions(name))
 
             locked = {
-              'name' => name,
-              'version' => best_version.to_s,
-              'source' => source.to_lockfile,
+              name: name,
+              version: best_version.to_s,
+              source: source,
             }
           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} )
+          lockfile.gems[name] = locked
+          source = locked[:source]
+
+          source.dependencies_of(locked[:name], locked[:version])&.each do |dep|
+            assign_stdlib(name: dep["name"], from_gem: name)
           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:)
+          return if lockfile.gems.key?(name)
+
+          if name == 'rubygems'
+            if from_gem
+                RBS.logger.warn "`rubygems` has been moved to core library, so it is always loaded. Remove explicit loading `rubygems` from `#{from_gem}`"
+            else
+              RBS.logger.warn '`rubygems` has been moved to core library, so it is always loaded. Remove explicit loading `rubygems`'
+            end
+
+            return
           end
-        end
 
-        private def remove_ignored_gems!
-          config.gems.reject! { |gem| gem['ignore'] }
+          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
+
+          if deps = source.dependencies_of(name, "0")
+            deps.each do |dep|
+              assign_stdlib(name: dep["name"], from_gem: name)
+            end
+          end
         end
 
         private def gemfile_lock_gems(&block)
@@ -118,7 +159,7 @@ module RBS
         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
 
@@ -30,18 +32,16 @@ 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)
+        config = from_path(config_path)
+        lockfile = LockfileGenerator.generate(config: config, gemfile_lock_path: gemfile_lock_path, 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,16 +51,16 @@ 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 repo_path_data
+        Pathname(@data["path"])
       end
 
       def sources
@@ -72,37 +72,9 @@ module RBS
         )
       end
 
-      def dump_to(io)
-        YAML.dump(@data, io)
-      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
-      end
     end
   end
 end

data/lib/rbs/collection/installer.rb

@@ -7,27 +7,23 @@ 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)
+        lockfile.gems.each_value do |gem|
+          gem[:source].install(
+            dest: install_to,
+            name: gem[:name],
+            version: gem[:version],
+            stdout: stdout
+          )
         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"
-        end
-        @source_for[key] ||= Sources.from_config_entry(key)
-      end
     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

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

@@ -13,64 +13,78 @@ module RBS
 
         class CommandError < StandardError; end
 
-        attr_reader :name, :remote, :repo_dir
+        attr_reader :name, :remote, :repo_dir, :revision
 
         def initialize(name:, revision:, remote:, repo_dir:)
           @name = name
           @remote = remote
           @repo_dir = repo_dir || 'gems'
-
-          setup!(revision: revision)
+          @revision = revision
+          @need_setup = true
         end
 
-        def has?(config_entry)
-          gem_name = config_entry['name']
-          gem_repo_dir.join(gem_name).directory?
+        def has?(name, version)
+          setup! do
+            if version
+              (gems_versions[name] || Set[]).include?(version)
+            else
+              gems_versions.key?(name)
+            end
+          end
         end
 
-        def versions(config_entry)
-          gem_name = config_entry['name']
-          gem_repo_dir.join(gem_name).glob('*/').map { |path| path.basename.to_s }
+        def versions(name)
+          setup! do
+            versions = gems_versions[name] or raise "Git source `#{name}` doesn't have `#{name}`"
+            versions.sort
+          end
         end
 
-        def install(dest:, config_entry:, stdout:)
-          gem_name = config_entry['name']
-          version = config_entry['version'] or raise
-          gem_dir = dest.join(gem_name, version)
+        def install(dest:, name:, version:, stdout:)
+          setup!()
+
+          gem_dir = dest.join(name, version)
 
           if gem_dir.directory?
-            if (prev = YAML.load_file(gem_dir.join(METADATA_FILENAME))) == config_entry
-              stdout.puts "Using #{format_config_entry(config_entry)}"
+            prev = load_metadata(dir: gem_dir)
+
+            if prev == metadata_content(name: name, version: version)
+              stdout.puts "Using #{format_config_entry(name, version)}"
             else
-              # @type var prev: RBS::Collection::Config::gem_entry
-              stdout.puts "Updating to #{format_config_entry(config_entry)} from #{format_config_entry(prev)}"
+              stdout.puts "Updating to #{format_config_entry(name, version)} from #{format_config_entry(prev["name"], prev["version"])}"
               FileUtils.remove_entry_secure(gem_dir.to_s)
-              _install(dest: dest, config_entry: config_entry)
+              _install(dest: dest, name: name, version: version)
             end
           else
-            stdout.puts "Installing #{format_config_entry(config_entry)}"
-            _install(dest: dest, config_entry: config_entry)
+            stdout.puts "Installing #{format_config_entry(name, version)}"
+            _install(dest: dest, name: name, version: version)
           end
         end
 
-        def manifest_of(config_entry)
-          gem_name = config_entry['name']
-          version = config_entry['version'] or raise
-          gem_dir = gem_repo_dir.join(gem_name, version)
-
-          manifest_path = gem_dir.join('manifest.yaml')
-          YAML.safe_load(manifest_path.read) if manifest_path.exist?
+        def manifest_of(name, version)
+          setup! do
+            path = File.join(repo_dir, name, version, 'manifest.yaml')
+            content = git('cat-file', '-p', "#{resolved_revision}:#{path}")
+            YAML.safe_load(content)
+          rescue CommandError
+            if has?(name, version)
+              nil
+            else
+              raise
+            end
+          end
         end
 
-        private def _install(dest:, config_entry:)
-          gem_name = config_entry['name']
-          version = config_entry['version'] or raise
-          dest = dest.join(gem_name, version)
-          dest.mkpath
-          src = gem_repo_dir.join(gem_name, version)
+        private def _install(dest:, name:, version:)
+          # Should checkout that revision to support symlinks
+          git("reset", "--hard", resolved_revision)
 
-          cp_r(src, dest)
-          dest.join(METADATA_FILENAME).write(YAML.dump(config_entry))
+          dir = dest.join(name, version)
+          dir.mkpath
+          src = gem_repo_dir.join(name, version)
+
+          cp_r(src, dir)
+          write_metadata(dir: dir, name: name, version: version)
         end
 
         private def cp_r(src, dest)
@@ -97,40 +111,37 @@ module RBS
           }
         end
 
-        private def format_config_entry(config_entry)
-          name = config_entry['name']
-          v = config_entry['version']
-
+        private def format_config_entry(name, version)
           rev = resolved_revision[0..10]
           desc = "#{name}@#{rev}"
 
-          "#{name}:#{v} (#{desc})"
+          "#{name}:#{version} (#{desc})"
         end
 
-        private def setup!(revision:)
-          git_dir.mkpath
-          if git_dir.join('.git').directory?
-            if need_to_fetch?(revision)
-              git 'fetch', 'origin'
-            end
-          else
-            begin
-              # git v2.27.0 or greater
-              git 'clone', '--filter=blob:none', remote, git_dir.to_s, chdir: nil
-            rescue CommandError
-              git 'clone', remote, git_dir.to_s, chdir: nil
+        private def setup!
+          if @need_setup
+            git_dir.mkpath
+            if git_dir.join('.git').directory?
+              if need_to_fetch?(revision)
+                git 'fetch', 'origin'
+              end
+            else
+              begin
+                # git v2.27.0 or greater
+                git 'clone', '--filter=blob:none', remote, git_dir.to_s, chdir: nil
+              rescue CommandError
+                git 'clone', remote, git_dir.to_s, chdir: nil
+              end
             end
-          end
 
-          begin
-            git 'checkout', "origin/#{revision}" # for branch name as `revision`
-          rescue CommandError
-            git 'checkout', revision
+            @need_setup = false
           end
+
+          yield if block_given?
         end
 
         private def need_to_fetch?(revision)
-          return true unless revision.match?(/\A[a-f0-9]{40}\z/)
+          return true unless commit_hash?
 
           begin
             git('cat-file', '-e', revision)
@@ -154,18 +165,31 @@ module RBS
           git_dir.join @repo_dir
         end
 
-        private def resolved_revision
-          @resolved_revision ||= resolve_revision
+        def resolved_revision
+          @resolved_revision ||=
+            begin
+              if commit_hash?
+                revision
+              else
+                setup! { git('rev-parse', revision).chomp }
+              end
+            end
         end
 
-        private def resolve_revision
-          git('rev-parse', 'HEAD').chomp
+        private def commit_hash?
+          revision.match?(/\A[a-f0-9]{40}\z/)
         end
 
         private def git(*cmd, **opt)
           sh! 'git', *cmd, **opt
         end
 
+        private def git?(*cmd, **opt)
+          git(*cmd, **opt)
+        rescue CommandError
+          nil
+        end
+
         private def sh!(*cmd, **opt)
           RBS.logger.debug "$ #{cmd.join(' ')}"
           opt = { chdir: git_dir }.merge(opt).compact
@@ -175,6 +199,55 @@ module RBS
             out
           end
         end
+
+        def metadata_content(name:, version:)
+          {
+            "name" => name,
+            "version" => version,
+            "source" => to_lockfile
+          }
+        end
+
+        def write_metadata(dir:, name:, version:)
+          dir.join(METADATA_FILENAME).write(
+            YAML.dump(
+              metadata_content(name: name, version: version)
+            )
+          )
+        end
+
+        def load_metadata(dir:)
+          # @type var content: Hash[String, untyped]
+          content = YAML.load_file(dir.join(METADATA_FILENAME).to_s)
+          _ = content.slice("name", "version", "source")
+        end
+
+        private def gems_versions
+          @gems_versions ||= begin
+            repo_path = Pathname(repo_dir)
+
+            paths = git('ls-tree', '--full-tree', '-dr', '--name-only', '-z', resolved_revision, File.join(repo_dir, "")).split("\0").map {|line| Pathname(line) }
+
+            # @type var versions: Hash[String, Set[String]]
+            versions = {}
+
+            paths.each do |full_path|
+              path = full_path.relative_path_from(repo_path)
+
+              gem_name, version = path.descend.take(2)
+
+              if gem_name
+                versions[gem_name.to_s] ||= Set[]
+
+                if version
+                  versions[gem_name.to_s] << version.basename.to_s
+                end
+              end
+            end
+
+            versions
+          end
+        end
       end
     end
   end

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

@@ -10,26 +10,24 @@ module RBS
         include Base
         include Singleton
 
-        def has?(config_entry)
-          gem_sig_path(config_entry)
+        def has?(name, version)
+          gem_sig_path(name, version)
         end
 
-        def versions(config_entry)
-          spec, _ = gem_sig_path(config_entry)
+        def versions(name)
+          spec, _ = gem_sig_path(name, nil)
           spec or raise
           [spec.version.to_s]
         end
 
-        def install(dest:, config_entry:, stdout:)
+        def install(dest:, name:, version:, stdout:)
           # Do nothing because stdlib RBS is available by default
-          name = config_entry['name']
-          version = config_entry['version'] or raise
-          _, from = gem_sig_path(config_entry)
+          _, from = gem_sig_path(name, version)
           stdout.puts "Using #{name}:#{version} (#{from})"
         end
 
-        def manifest_of(config_entry)
-          _, sig_path = gem_sig_path(config_entry)
+        def manifest_of(name, version)
+          _, sig_path = gem_sig_path(name, version)
           sig_path or raise
           manifest_path = sig_path.join('manifest.yaml')
           YAML.safe_load(manifest_path.read) if manifest_path.exist?
@@ -41,8 +39,8 @@ module RBS
           }
         end
 
-        private def gem_sig_path(config_entry)
-          RBS::EnvironmentLoader.gem_sig_path(config_entry['name'], config_entry['version'])
+        private def gem_sig_path(name, version)
+          RBS::EnvironmentLoader.gem_sig_path(name, version)
         end
       end
     end