rbs 4.1.0.pre.2-java

data/lib/rbs/collection/cleaner.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RBS
+  module Collection
+    class Cleaner
+      attr_reader :lock
+
+      def initialize(lockfile_path:)
+        @lock = Config.from_path(lockfile_path)
+      end
+
+      def clean
+        lock.repo_path.glob('*/*') do |dir|
+          *_, gem_name, version = dir.to_s.split('/')
+          gem_name or raise
+          version or raise
+          next if needed? gem_name, version
+
+          case
+          when dir.symlink?
+            dir.unlink
+          when dir.directory?
+            FileUtils.remove_entry_secure(dir.to_s)
+          else
+            raise
+          end
+        end
+      end
+
+      def needed?(gem_name, version)
+        gem = lock.gem(gem_name)
+        return false unless gem
+
+        gem['version'] == version
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RBS
+  module Collection
+    class Config
+      class Lockfile
+        attr_reader :lockfile_path, :lockfile_dir, :path, :gemfile_lock_path, :sources, :gems
+
+        def initialize(lockfile_path:, path:, gemfile_lock_path:)
+          @lockfile_path = lockfile_path
+          @lockfile_dir = lockfile_path.parent
+          @path = path
+          @gemfile_lock_path = gemfile_lock_path
+
+          @gems = {}
+        end
+
+        def fullpath
+          lockfile_dir + path
+        end
+
+        def gemfile_lock_fullpath
+          if gemfile_lock_path
+            lockfile_dir + gemfile_lock_path
+          end
+        end
+
+        def to_lockfile
+          # @type var data: lockfile_data
+
+          data = {
+            "path" => path.to_s,
+            "gems" => gems.each_value.sort_by {|g| g[:name] }.map {|hash| library_data(hash) },
+            "gemfile_lock_path" => gemfile_lock_path.to_s
+          }
+
+          data.delete("gems") if gems.empty?
+
+          data
+        end
+
+        def self.from_lockfile(lockfile_path:, data:)
+          path = Pathname(data["path"])
+          if p = data["gemfile_lock_path"]
+            gemfile_lock_path = Pathname(p)
+          end
+
+          lockfile = Lockfile.new(lockfile_path: lockfile_path, path: path, gemfile_lock_path: gemfile_lock_path)
+
+          if gems = data["gems"]
+            gems.each do |gem|
+              src = gem["source"]
+              source = Sources.from_config_entry(src, base_directory: lockfile_path.dirname)
+              lockfile.gems[gem["name"]] = {
+                name: gem["name"],
+                version: gem["version"],
+                source: source
+              }
+            end
+          end
+
+          lockfile
+        end
+
+        def library_data(lib)
+          {
+            "name" => lib[:name],
+            "version" => lib[:version],
+            "source" => lib[:source].to_lockfile
+          }
+        end
+
+        def check_rbs_availability!
+          raise CollectionNotAvailable unless fullpath.exist?
+
+          gems.each_value do |gem|
+            source = gem[:source]
+
+            case source
+            when Sources::Git
+              meta_path = fullpath.join(gem[:name], gem[:version], Sources::Git::METADATA_FILENAME)
+              raise CollectionNotAvailable unless meta_path.exist?
+              raise CollectionNotAvailable unless library_data(gem) == YAML.load(meta_path.read)
+            when Sources::Local
+              raise CollectionNotAvailable unless fullpath.join(gem[:name], gem[:version]).symlink?
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,269 @@
+# frozen_string_literal: true
+
+module RBS
+  module Collection
+    class Config
+      class LockfileGenerator
+        ALUMNI_STDLIBS = {
+          "mutex_m" => ">= 0.3.0",
+          "abbrev" => nil,
+          "base64" => nil,
+          "benchmark" => nil,
+          "bigdecimal" => nil,
+          "csv" => nil,
+          "kconv" => nil,
+          "logger" => nil,
+          "minitest" => nil,
+          "net-smtp" => nil,
+          "nkf" => nil,
+          "observer" => nil,
+          "cgi" => nil,
+          "pstore" => nil,
+        }
+
+        NONGEM_STDLIBS = Set[
+          "cgi-escape",
+          "coverage",
+          "monitor",
+          "objspace",
+          "pathname",
+          "pty",
+          "ripper",
+          "socket",
+        ]
+
+        class GemfileLockMismatchError < StandardError
+          def initialize(expected:, actual:)
+            @expected = expected
+            @actual = actual
+          end
+
+          def message
+            <<~MESSAGE
+              RBS Collection loads a different Gemfile.lock from before.
+              The Gemfile.lock must be the same as that is recorded in rbs_collection.lock.yaml.
+              Expected Gemfile.lock: #{@expected}
+              Actual Gemfile.lock: #{@actual}
+            MESSAGE
+          end
+        end
+
+        attr_reader :config, :lockfile, :definition, :existing_lockfile, :gem_hash, :gem_entries
+
+        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:, 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)
+          )
+
+          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
+
+          @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|
+            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
+
+          definition.dependencies.each do |dep|
+            if dep.autorequire && dep.autorequire.empty?
+              next
+            end
+
+            if spec = gem_hash[dep.name]
+              assign_gem(name: dep.name, version: spec.version, skip: dep.source.is_a?(Bundler::Source::Gemspec))
+            end
+          end
+
+          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_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:, 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
+
+          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
+            unless NONGEM_STDLIBS.include?(name)
+              RBS.logger.warn "Cannot find `#{name}` gem. Using incorrect Bundler context? (#{definition.lockfile})"
+            end
+          end
+        end
+
+        private def assign_stdlib(name:, from_gem: nil)
+          return if lockfile.gems.key?(name)
+
+          case name
+          when 'bigdecimal-math', 'kconv'
+            # These gems are never released as a gem.
+            # Therefore, `assign_gem` should not be called.
+            RBS.logger.info {
+              from = from_gem || "rbs_collection.yaml"
+              "`#{name}` is included in the RBS dependencies of `#{from}`, but the type definition as a stdlib in rbs-gem is deprecated. Delete `#{name}` from the RBS dependencies of `#{from}`."
+            }
+            source = find_source(name: name)
+            if source&.is_a?(Sources::Stdlib)
+              lockfile.gems[name] = { name: name, version: "0", source: source }
+            end
+            return
+          when 'set'
+            # set is migrated to core from stdlib.
+            RBS.logger.info {
+              from = from_gem || "rbs_collection.yaml"
+              "`#{name}` is a part of the Ruby core library. The dependency to the library can be safely deleted from #{from}."
+            }
+            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) && version
+                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 {
+                if version
+                  "`#{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."
+                else
+                  "`#{name}` as a stdlib in rbs-gem is deprecated. Delete `#{name}` from the RBS dependencies in your rbs_collection.yaml."
+                end
+              }
+            end
+          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
+
+          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, nil) }
+        end
+
+        private def find_best_version(version:, versions:)
+          candidates = versions.map { |v| Gem::Version.create(v) or raise }
+          return candidates.max || raise unless version
+
+          v = Gem::Version.create(version) or raise
+          Repository.find_best_version(v, candidates)
+        end
+      end
+    end
+  end
+end

data/lib/rbs/collection/config.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RBS
+  module Collection
+
+    # This class represent the configuration file.
+    class Config
+      class CollectionNotAvailable < StandardError
+        def initialize
+          super <<~MSG
+            rbs collection is not initialized.
+            Run `rbs collection install` to install RBSs from collection.
+          MSG
+        end
+      end
+
+      PATH = Pathname('rbs_collection.yaml')
+
+      attr_reader :config_path, :data
+
+      def self.find_config_path
+        current = Pathname.pwd
+
+        loop do
+          config_path = current.join(PATH)
+          return config_path if config_path.exist?
+          current = current.join('..')
+          return nil if current.root?
+        end
+      end
+
+      # 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:, 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.to_lockfile_path(config_path)
+        config_path.sub_ext('.lock' + config_path.extname)
+      end
+
+      def initialize(data, config_path:)
+        @data = data
+        @config_path = config_path
+      end
+
+      def gem(gem_name)
+        gems.find { |gem| gem['name'] == gem_name }
+      end
+
+      def repo_path
+        @config_path.dirname.join repo_path_data
+      end
+
+      def repo_path_data
+        Pathname(@data["path"])
+      end
+
+      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'] ||= (
+          [] #: Array[gem_entry]
+        )
+      end
+    end
+  end
+end

data/lib/rbs/collection/installer.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RBS
+  module Collection
+    class Installer
+      attr_reader :lockfile
+      attr_reader :stdout
+
+      def initialize(lockfile_path:, stdout: $stdout)
+        @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.fullpath
+        install_to.mkpath
+        selected = lockfile.gems.select do |name, gem|
+          gem[:source].has?(name, gem[:version])
+        end
+        selected.each_value do |gem|
+          gem[:source].install(
+            dest: install_to,
+            name: gem[:name],
+            version: gem[:version],
+            stdout: stdout
+          )
+        end
+        CLI::ColoredIO.new(stdout: stdout).puts_green("It's done! #{selected.size} gems' RBSs now installed.")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RBS
+  module Collection
+    module Sources
+      module Base
+        def dependencies_of(name, version)
+          manifest = manifest_of(name, version) or return
+          manifest['dependencies']
+        end
+      end
+    end
+  end
+end