@ai-ecoverse/wasix-ruby 3.4.11-2 → 3.4.11-20

package/lib/ruby/gems/3.4.0/gems/rbs-3.8.0/lib/rbs/collection/cleaner.rb

@@ -1,38 +0,0 @@
-# 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

package/lib/ruby/gems/3.4.0/gems/rbs-3.8.0/lib/rbs/collection/config/lockfile.rb

@@ -1,92 +0,0 @@
-# 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

package/lib/ruby/gems/3.4.0/gems/rbs-3.8.0/lib/rbs/collection/config/lockfile_generator.rb

@@ -1,223 +0,0 @@
-# frozen_string_literal: true
-
-module RBS
-  module Collection
-    class Config
-      class LockfileGenerator
-        ALUMNI_STDLIBS = { "mutex_m" => ">= 0.3.0" }
-
-        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
-            RBS.logger.warn "Cannot find `#{name}` gem. Using incorrect Bundler context? (#{definition.lockfile})"
-          end
-        end
-
-        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
-
-          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

package/lib/ruby/gems/3.4.0/gems/rbs-3.8.0/lib/rbs/collection/config.rb

@@ -1,81 +0,0 @@
-# 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

package/lib/ruby/gems/3.4.0/gems/rbs-3.8.0/lib/rbs/collection/installer.rb

@@ -1,32 +0,0 @@
-# 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

package/lib/ruby/gems/3.4.0/gems/rbs-3.8.0/lib/rbs/collection/sources/base.rb

@@ -1,14 +0,0 @@
-# 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