@ai-ecoverse/wasix-ruby 3.4.11-3 → 3.4.11-4

package/lib/ruby/3.4.11/bundler/index.rb

@@ -1,205 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  class Index
-    include Enumerable
-
-    def self.build
-      i = new
-      yield i
-      i
-    end
-
-    attr_reader :specs, :duplicates, :sources
-    protected :specs, :duplicates
-
-    RUBY = "ruby"
-    NULL = "\0"
-
-    def initialize
-      @sources = []
-      @cache = {}
-      @specs = {}
-      @duplicates = {}
-    end
-
-    def initialize_copy(o)
-      @sources = o.sources.dup
-      @cache = {}
-      @specs = {}
-      @duplicates = {}
-
-      o.specs.each do |name, hash|
-        @specs[name] = hash.dup
-      end
-      o.duplicates.each do |name, array|
-        @duplicates[name] = array.dup
-      end
-    end
-
-    def inspect
-      "#<#{self.class}:0x#{object_id} sources=#{sources.map(&:inspect)} specs.size=#{specs.size}>"
-    end
-
-    def empty?
-      each { return false }
-      true
-    end
-
-    def search_all(name, &blk)
-      return enum_for(:search_all, name) unless blk
-      specs_by_name(name).each(&blk)
-      @duplicates[name]&.each(&blk)
-      @sources.each {|source| source.search_all(name, &blk) }
-    end
-
-    # Search this index's specs, and any source indexes that this index knows
-    # about, returning all of the results.
-    def search(query)
-      results = local_search(query)
-      return results unless @sources.any?
-
-      @sources.each do |source|
-        results = safe_concat(results, source.search(query))
-      end
-      results.uniq!(&:full_name) unless results.empty? # avoid modifying frozen EMPTY_SEARCH
-      results
-    end
-
-    alias_method :[], :search
-
-    def local_search(query)
-      case query
-      when Gem::Specification, RemoteSpecification, LazySpecification, EndpointSpecification then search_by_spec(query)
-      when String then specs_by_name(query)
-      when Array then specs_by_name_and_version(*query)
-      else
-        raise "You can't search for a #{query.inspect}."
-      end
-    end
-
-    def add(spec)
-      (@specs[spec.name] ||= {}).store(spec.full_name, spec)
-    end
-    alias_method :<<, :add
-
-    def each(&blk)
-      return enum_for(:each) unless blk
-      specs.values.each do |spec_sets|
-        spec_sets.values.each(&blk)
-      end
-      sources.each {|s| s.each(&blk) }
-      self
-    end
-
-    def spec_names
-      names = specs.keys + sources.map(&:spec_names)
-      names.uniq!
-      names
-    end
-
-    def unmet_dependency_names
-      dependency_names.select do |name|
-        search(name).empty?
-      end
-    end
-
-    def dependency_names
-      names = []
-      each do |spec|
-        spec.dependencies.each do |dep|
-          next if dep.type == :development
-          names << dep.name
-        end
-      end
-      names.uniq
-    end
-
-    # Combines indexes proritizing existing specs, like `Hash#reverse_merge!`
-    # Duplicate specs found in `other` are stored in `@duplicates`.
-    def use(other)
-      return unless other
-      other.each do |spec|
-        exist?(spec) ? add_duplicate(spec) : add(spec)
-      end
-      self
-    end
-
-    # Combines indexes proritizing specs from `other`, like `Hash#merge!`
-    # Duplicate specs found in `self` are saved in `@duplicates`.
-    def merge!(other)
-      return unless other
-      other.each do |spec|
-        if existing = find_by_spec(spec)
-          add_duplicate(existing)
-        end
-        add spec
-      end
-      self
-    end
-
-    def size
-      @sources.inject(@specs.size) do |size, source|
-        size += source.size
-      end
-    end
-
-    # Whether all the specs in self are in other
-    def subset?(other)
-      all? do |spec|
-        other_spec = other[spec].first
-        other_spec && dependencies_eql?(spec, other_spec) && spec.source == other_spec.source
-      end
-    end
-
-    def dependencies_eql?(spec, other_spec)
-      deps       = spec.dependencies.select {|d| d.type != :development }
-      other_deps = other_spec.dependencies.select {|d| d.type != :development }
-      deps.sort == other_deps.sort
-    end
-
-    def add_source(index)
-      raise ArgumentError, "Source must be an index, not #{index.class}" unless index.is_a?(Index)
-      @sources << index
-      @sources.uniq! # need to use uniq! here instead of checking for the item before adding
-    end
-
-    private
-
-    def safe_concat(a, b)
-      return a if b.empty?
-      return b if a.empty?
-      a.concat(b)
-    end
-
-    def add_duplicate(spec)
-      (@duplicates[spec.name] ||= []) << spec
-    end
-
-    def specs_by_name_and_version(name, version)
-      results = @specs[name]&.values
-      return EMPTY_SEARCH unless results
-      results.select! {|spec| spec.version == version }
-      results
-    end
-
-    def specs_by_name(name)
-      @specs[name]&.values || EMPTY_SEARCH
-    end
-
-    EMPTY_SEARCH = [].freeze
-
-    def search_by_spec(spec)
-      spec = find_by_spec(spec)
-      spec ? [spec] : EMPTY_SEARCH
-    end
-
-    def find_by_spec(spec)
-      @specs[spec.name]&.fetch(spec.full_name, nil)
-    end
-
-    def exist?(spec)
-      @specs[spec.name]&.key?(spec.full_name)
-    end
-  end
-end

package/lib/ruby/3.4.11/bundler/injector.rb

@@ -1,285 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  class Injector
-    INJECTED_GEMS = "injected gems"
-
-    def self.inject(new_deps, options = {})
-      injector = new(new_deps, options)
-      injector.inject(Bundler.default_gemfile, Bundler.default_lockfile)
-    end
-
-    def self.remove(gems, options = {})
-      injector = new(gems, options)
-      injector.remove(Bundler.default_gemfile, Bundler.default_lockfile)
-    end
-
-    def initialize(deps, options = {})
-      @deps = deps
-      @options = options
-    end
-
-    # @param [Pathname] gemfile_path The Gemfile in which to inject the new dependency.
-    # @param [Pathname] lockfile_path The lockfile in which to inject the new dependency.
-    # @return [Array]
-    def inject(gemfile_path, lockfile_path)
-      Bundler.definition.ensure_equivalent_gemfile_and_lockfile(true)
-
-      # temporarily unfreeze
-      Bundler.settings.temporary(deployment: false, frozen: false) do
-        # evaluate the Gemfile we have now
-        builder = Dsl.new
-        builder.eval_gemfile(gemfile_path)
-
-        # don't inject any gems that are already in the Gemfile
-        @deps -= builder.dependencies
-
-        # add new deps to the end of the in-memory Gemfile
-        # Set conservative versioning to false because
-        # we want to let the resolver resolve the version first
-        builder.eval_gemfile(INJECTED_GEMS, build_gem_lines(false)) if @deps.any?
-
-        # resolve to see if the new deps broke anything
-        @definition = builder.to_definition(lockfile_path, {})
-        @definition.remotely!
-
-        # since nothing broke, we can add those gems to the gemfile
-        append_to(gemfile_path, build_gem_lines(@options[:conservative_versioning])) if @deps.any?
-
-        # since we resolved successfully, write out the lockfile
-        @definition.lock
-
-        # invalidate the cached Bundler.definition
-        Bundler.reset_paths!
-
-        # return an array of the deps that we added
-        @deps
-      end
-    end
-
-    # @param [Pathname] gemfile_path The Gemfile from which to remove dependencies.
-    # @param [Pathname] lockfile_path The lockfile from which to remove dependencies.
-    # @return [Array]
-    def remove(gemfile_path, lockfile_path)
-      # remove gems from each gemfiles we have
-      Bundler.definition.gemfiles.each do |path|
-        deps = remove_deps(path)
-
-        show_warning("No gems were removed from the gemfile.") if deps.empty?
-
-        deps.each {|dep| Bundler.ui.confirm "#{SharedHelpers.pretty_dependency(dep)} was removed." }
-      end
-
-      # Invalidate the cached Bundler.definition.
-      # This prevents e.g. `bundle remove ...` from using outdated information.
-      Bundler.reset_paths!
-    end
-
-    private
-
-    def conservative_version(spec)
-      version = spec.version
-      return ">= 0" if version.nil?
-      segments = version.segments
-      seg_end_index = version >= Gem::Version.new("1.0") ? 1 : 2
-
-      prerelease_suffix = version.to_s.delete_prefix(version.release.to_s) if version.prerelease?
-      "#{version_prefix}#{segments[0..seg_end_index].join(".")}#{prerelease_suffix}"
-    end
-
-    def version_prefix
-      if @options[:strict]
-        "= "
-      elsif @options[:optimistic]
-        ">= "
-      else
-        "~> "
-      end
-    end
-
-    def build_gem_lines(conservative_versioning)
-      @deps.map do |d|
-        name = d.name.dump
-
-        requirement = if conservative_versioning
-          ", \"#{conservative_version(@definition.specs[d.name][0])}\""
-        else
-          ", #{d.requirement.as_list.map(&:dump).join(", ")}"
-        end
-
-        if d.groups != Array(:default)
-          group = d.groups.size == 1 ? ", group: #{d.groups.first.inspect}" : ", groups: #{d.groups.inspect}"
-        end
-
-        source = ", source: \"#{d.source}\"" unless d.source.nil?
-        path = ", path: \"#{d.path}\"" unless d.path.nil?
-        git = ", git: \"#{d.git}\"" unless d.git.nil?
-        github = ", github: \"#{d.github}\"" unless d.github.nil?
-        branch = ", branch: \"#{d.branch}\"" unless d.branch.nil?
-        ref = ", ref: \"#{d.ref}\"" unless d.ref.nil?
-        glob = ", glob: \"#{d.glob}\"" unless d.glob.nil?
-        require_path = ", require: #{convert_autorequire(d.autorequire)}" unless d.autorequire.nil?
-
-        %(gem #{name}#{requirement}#{group}#{source}#{path}#{git}#{github}#{branch}#{ref}#{glob}#{require_path})
-      end.join("\n")
-    end
-
-    def append_to(gemfile_path, new_gem_lines)
-      gemfile_path.open("a") do |f|
-        f.puts
-        f.puts new_gem_lines
-      end
-    end
-
-    # evaluates a gemfile to remove the specified gem
-    # from it.
-    def remove_deps(gemfile_path)
-      initial_gemfile = File.readlines(gemfile_path)
-
-      Bundler.ui.info "Removing gems from #{gemfile_path}"
-
-      # evaluate the Gemfile we have
-      builder = Dsl.new
-      builder.eval_gemfile(gemfile_path)
-
-      removed_deps = remove_gems_from_dependencies(builder, @deps, gemfile_path)
-
-      # abort the operation if no gems were removed
-      # no need to operate on gemfile further
-      return [] if removed_deps.empty?
-
-      cleaned_gemfile = remove_gems_from_gemfile(@deps, gemfile_path)
-
-      SharedHelpers.write_to_gemfile(gemfile_path, cleaned_gemfile)
-
-      # check for errors
-      # including extra gems being removed
-      # or some gems not being removed
-      # and return the actual removed deps
-      cross_check_for_errors(gemfile_path, builder.dependencies, removed_deps, initial_gemfile)
-    end
-
-    # @param [Dsl]      builder Dsl object of current Gemfile.
-    # @param [Array]    gems Array of names of gems to be removed.
-    # @param [Pathname] gemfile_path Path of the Gemfile.
-    # @return [Array]   Array of removed dependencies.
-    def remove_gems_from_dependencies(builder, gems, gemfile_path)
-      removed_deps = []
-
-      gems.each do |gem_name|
-        deleted_dep = builder.dependencies.find {|d| d.name == gem_name }
-
-        if deleted_dep.nil?
-          raise GemfileError, "`#{gem_name}` is not specified in #{gemfile_path} so it could not be removed."
-        end
-
-        builder.dependencies.delete(deleted_dep)
-
-        removed_deps << deleted_dep
-      end
-
-      removed_deps
-    end
-
-    # @param [Array] gems            Array of names of gems to be removed.
-    # @param [Pathname] gemfile_path The Gemfile from which to remove dependencies.
-    def remove_gems_from_gemfile(gems, gemfile_path)
-      patterns = /gem\s+(['"])#{Regexp.union(gems)}\1|gem\s*\((['"])#{Regexp.union(gems)}\2.*\)/
-      new_gemfile = []
-      multiline_removal = false
-      File.readlines(gemfile_path).each do |line|
-        match_data = line.match(patterns)
-        if match_data && is_not_within_comment?(line, match_data)
-          multiline_removal = line.rstrip.end_with?(",")
-          # skip lines which match the regex
-          next
-        end
-
-        # skip followup lines until line does not end with ','
-        new_gemfile << line unless multiline_removal
-        multiline_removal = line.rstrip.end_with?(",") if multiline_removal
-      end
-
-      # remove line \n and append them with other strings
-      new_gemfile.each_with_index do |_line, index|
-        if new_gemfile[index + 1] == "\n"
-          new_gemfile[index] += new_gemfile[index + 1]
-          new_gemfile.delete_at(index + 1)
-        end
-      end
-
-      %w[group source env install_if].each {|block| remove_nested_blocks(new_gemfile, block) }
-
-      new_gemfile.join.chomp
-    end
-
-    # @param [String] line          Individual line of gemfile content.
-    # @param [MatchData] match_data Data about Regex match.
-    def is_not_within_comment?(line, match_data)
-      match_start_index = match_data.offset(0).first
-      !line[0..match_start_index].include?("#")
-    end
-
-    # @param [Array] gemfile       Array of gemfile contents.
-    # @param [String] block_name   Name of block name to look for.
-    def remove_nested_blocks(gemfile, block_name)
-      nested_blocks = 0
-
-      # count number of nested blocks
-      gemfile.each_with_index {|line, index| nested_blocks += 1 if !gemfile[index + 1].nil? && gemfile[index + 1].include?(block_name) && line.include?(block_name) }
-
-      while nested_blocks >= 0
-        nested_blocks -= 1
-
-        gemfile.each_with_index do |line, index|
-          next unless !line.nil? && line.strip.start_with?(block_name)
-          if /^\s*end\s*$/.match?(gemfile[index + 1])
-            gemfile[index] = nil
-            gemfile[index + 1] = nil
-          end
-        end
-
-        gemfile.compact!
-      end
-    end
-
-    # @param [Pathname] gemfile_path   The Gemfile from which to remove dependencies.
-    # @param [Array] original_deps     Array of original dependencies.
-    # @param [Array] removed_deps      Array of removed dependencies.
-    # @param [Array] initial_gemfile   Contents of original Gemfile before any operation.
-    def cross_check_for_errors(gemfile_path, original_deps, removed_deps, initial_gemfile)
-      # evaluate the new gemfile to look for any failure cases
-      builder = Dsl.new
-      builder.eval_gemfile(gemfile_path)
-
-      # record gems which were removed but not requested
-      extra_removed_gems = original_deps - builder.dependencies
-
-      # if some extra gems were removed then raise error
-      # and revert Gemfile to original
-      unless extra_removed_gems.empty?
-        SharedHelpers.write_to_gemfile(gemfile_path, initial_gemfile.join)
-
-        raise InvalidOption, "Gems could not be removed. #{extra_removed_gems.join(", ")} would also have been removed. Bundler cannot continue."
-      end
-
-      # record gems which could not be removed due to some reasons
-      errored_deps = builder.dependencies.select {|d| d.gemfile == gemfile_path } & removed_deps.select {|d| d.gemfile == gemfile_path }
-
-      show_warning "#{errored_deps.map(&:name).join(", ")} could not be removed." unless errored_deps.empty?
-
-      # return actual removed dependencies
-      removed_deps - errored_deps
-    end
-
-    def show_warning(message)
-      Bundler.ui.info Bundler.ui.add_color(message, :yellow)
-    end
-
-    def convert_autorequire(autorequire)
-      autorequire = autorequire.first
-      return autorequire if autorequire == "false"
-      autorequire.inspect
-    end
-  end
-end

package/lib/ruby/3.4.11/bundler/inline.rb

@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-
-# Allows for declaring a Gemfile inline in a ruby script, installing any gems
-# that aren't already installed on the user's system.
-#
-# @note Every gem that is specified in this 'Gemfile' will be `require`d, as if
-#       the user had manually called `Bundler.require`. To avoid a requested gem
-#       being automatically required, add the `:require => false` option to the
-#       `gem` dependency declaration.
-#
-# @param force_latest_compatible [Boolean] Force installing the *latest*
-#                                          compatible versions of the gems,
-#                                          even if compatible versions are
-#                                          already installed locally.
-#                                          This also logs output if the
-#                                          `:quiet` option is not set.
-#                                          Defaults to `false`.
-#
-# @param gemfile [Proc]    a block that is evaluated as a `Gemfile`.
-#
-# @example Using an inline Gemfile
-#
-#          #!/usr/bin/env ruby
-#
-#          require 'bundler/inline'
-#
-#          gemfile do
-#            source 'https://rubygems.org'
-#            gem 'json', require: false
-#            gem 'nap', require: 'rest'
-#            gem 'cocoapods', '~> 0.34.1'
-#          end
-#
-#          puts Pod::VERSION # => "0.34.4"
-#
-def gemfile(force_latest_compatible = false, options = {}, &gemfile)
-  require_relative "../bundler"
-  Bundler.reset!
-
-  opts = options.dup
-  ui = opts.delete(:ui) { Bundler::UI::Shell.new }
-  ui.level = "silent" if opts.delete(:quiet) || !force_latest_compatible
-  Bundler.ui = ui
-  raise ArgumentError, "Unknown options: #{opts.keys.join(", ")}" unless opts.empty?
-
-  old_gemfile = ENV["BUNDLE_GEMFILE"]
-
-  Bundler.unbundle_env!
-
-  begin
-    Bundler.instance_variable_set(:@bundle_path, Pathname.new(Gem.dir))
-    Bundler::SharedHelpers.set_env "BUNDLE_GEMFILE", "Gemfile"
-
-    Bundler::Plugin.gemfile_install(&gemfile) if Bundler.feature_flag.plugins?
-    builder = Bundler::Dsl.new
-    builder.instance_eval(&gemfile)
-
-    Bundler.settings.temporary(deployment: false, frozen: false) do
-      definition = builder.to_definition(nil, true)
-      definition.validate_runtime!
-
-      if force_latest_compatible || definition.missing_specs?
-        Bundler.settings.temporary(inline: true, no_install: false) do
-          installer = Bundler::Installer.install(Bundler.root, definition, system: true)
-          installer.post_install_messages.each do |name, message|
-            Bundler.ui.info "Post-install message from #{name}:\n#{message}"
-          end
-        end
-      end
-
-      begin
-        runtime = Bundler::Runtime.new(nil, definition).setup
-      rescue Gem::LoadError => e
-        name = e.name
-        version = e.requirement.requirements.first[1]
-        activated_version = Gem.loaded_specs[name].version
-
-        Bundler.ui.info \
-          "The #{name} gem was resolved to #{version}, but #{activated_version} was activated by Bundler while installing it, causing a conflict. " \
-          "Bundler will now retry resolving with #{activated_version} instead."
-
-        builder.dependencies.delete_if {|d| d.name == name }
-        builder.instance_eval { gem name, activated_version }
-        definition = builder.to_definition(nil, true)
-
-        retry
-      end
-
-      runtime.require
-    end
-  ensure
-    if old_gemfile
-      ENV["BUNDLE_GEMFILE"] = old_gemfile
-    else
-      ENV["BUNDLE_GEMFILE"] = ""
-    end
-  end
-end

package/lib/ruby/3.4.11/bundler/installer/gem_installer.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  class GemInstaller
-    attr_reader :spec, :standalone, :worker, :force, :local, :installer
-
-    def initialize(spec, installer, standalone = false, worker = 0, force = false, local = false)
-      @spec = spec
-      @installer = installer
-      @standalone = standalone
-      @worker = worker
-      @force = force
-      @local = local
-    end
-
-    def install_from_spec
-      post_install_message = install
-      Bundler.ui.debug "#{worker}:  #{spec.name} (#{spec.version}) from #{spec.loaded_from}"
-      generate_executable_stubs
-      [true, post_install_message]
-    rescue Bundler::InstallHookError, Bundler::SecurityError, Bundler::APIResponseMismatchError, Bundler::InsecureInstallPathError
-      raise
-    rescue Errno::ENOSPC
-      [false, out_of_space_message]
-    rescue Bundler::BundlerError, Gem::InstallError => e
-      [false, specific_failure_message(e)]
-    end
-
-    private
-
-    def specific_failure_message(e)
-      message = "#{e.class}: #{e.message}\n"
-      message += "  " + e.backtrace.join("\n  ") + "\n\n"
-      message = message.lines.first + Bundler.ui.add_color(message.lines.drop(1).join, :clear)
-      message + Bundler.ui.add_color(failure_message, :red)
-    end
-
-    def failure_message
-      install_error_message
-    end
-
-    def install_error_message
-      "An error occurred while installing #{spec.name} (#{spec.version}), and Bundler cannot continue."
-    end
-
-    def spec_settings
-      # Fetch the build settings, if there are any
-      if settings = Bundler.settings["build.#{spec.name}"]
-        require "shellwords"
-        Shellwords.shellsplit(settings)
-      end
-    end
-
-    def install
-      spec.source.install(
-        spec,
-        force: force,
-        local: local,
-        build_args: Array(spec_settings),
-        previous_spec: previous_spec,
-      )
-    end
-
-    def previous_spec
-      locked_gems = installer.definition.locked_gems
-      return unless locked_gems
-
-      locked_gems.specs.find {|s| s.name == spec.name }
-    end
-
-    def out_of_space_message
-      "#{install_error_message}\nYour disk is out of space. Free some space to be able to install your bundle."
-    end
-
-    def generate_executable_stubs
-      return if Bundler.feature_flag.forget_cli_options?
-      return if Bundler.settings[:inline]
-      if Bundler.settings[:bin] && standalone
-        installer.generate_standalone_bundler_executable_stubs(spec)
-      elsif Bundler.settings[:bin]
-        installer.generate_bundler_executable_stubs(spec, force: true)
-      end
-    end
-  end
-end