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

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

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  module CIDetector
-    # NOTE: Any changes made here will need to be made to both lib/rubygems/ci_detector.rb and
-    # bundler/lib/bundler/ci_detector.rb (which are enforced duplicates).
-    # TODO: Drop that duplication once bundler drops support for RubyGems 3.4
-    #
-    # ## Recognized CI providers, their signifiers, and the relevant docs ##
-    #
-    # Travis CI   - CI, TRAVIS            https://docs.travis-ci.com/user/environment-variables/#default-environment-variables
-    # Cirrus CI   - CI, CIRRUS_CI         https://cirrus-ci.org/guide/writing-tasks/#environment-variables
-    # Circle CI   - CI, CIRCLECI          https://circleci.com/docs/variables/#built-in-environment-variables
-    # Gitlab CI   - CI, GITLAB_CI         https://docs.gitlab.com/ee/ci/variables/
-    # AppVeyor    - CI, APPVEYOR          https://www.appveyor.com/docs/environment-variables/
-    # CodeShip    - CI_NAME               https://docs.cloudbees.com/docs/cloudbees-codeship/latest/pro-builds-and-configuration/environment-variables#_default_environment_variables
-    # dsari       - CI, DSARI             https://github.com/rfinnie/dsari#running
-    # Jenkins     - BUILD_NUMBER          https://www.jenkins.io/doc/book/pipeline/jenkinsfile/#using-environment-variables
-    # TeamCity    - TEAMCITY_VERSION      https://www.jetbrains.com/help/teamcity/predefined-build-parameters.html#Predefined+Server+Build+Parameters
-    # Appflow     - CI_BUILD_ID           https://ionic.io/docs/appflow/automation/environments#predefined-environments
-    # TaskCluster - TASKCLUSTER_ROOT_URL  https://docs.taskcluster.net/docs/manual/design/env-vars
-    # Semaphore   - CI, SEMAPHORE         https://docs.semaphoreci.com/ci-cd-environment/environment-variables/
-    # BuildKite   - CI, BUILDKITE         https://buildkite.com/docs/pipelines/environment-variables
-    # GoCD        - GO_SERVER_URL         https://docs.gocd.org/current/faq/dev_use_current_revision_in_build.html
-    # GH Actions  - CI, GITHUB_ACTIONS    https://docs.github.com/en/actions/learn-github-actions/variables#default-environment-variables
-    #
-    # ### Some "standard" ENVs that multiple providers may set ###
-    #
-    # * CI - this is set by _most_ (but not all) CI providers now; it's approaching a standard.
-    # * CI_NAME - Not as frequently used, but some providers set this to specify their own name
-
-    # Any of these being set is a reasonably reliable indicator that we are
-    # executing in a CI environment.
-    ENV_INDICATORS = [
-      "CI",
-      "CI_NAME",
-      "CONTINUOUS_INTEGRATION",
-      "BUILD_NUMBER",
-      "CI_APP_ID",
-      "CI_BUILD_ID",
-      "CI_BUILD_NUMBER",
-      "RUN_ID",
-      "TASKCLUSTER_ROOT_URL",
-    ].freeze
-
-    # For each CI, this env suffices to indicate that we're on _that_ CI's
-    # containers. (A few of them only supply a CI_NAME variable, which is also
-    # nice). And if they set "CI" but we can't tell which one they are, we also
-    # want to know that - a bare "ci" without another token tells us as much.
-    ENV_DESCRIPTORS = {
-      "TRAVIS" => "travis",
-      "CIRCLECI" => "circle",
-      "CIRRUS_CI" => "cirrus",
-      "DSARI" => "dsari",
-      "SEMAPHORE" => "semaphore",
-      "JENKINS_URL" => "jenkins",
-      "BUILDKITE" => "buildkite",
-      "GO_SERVER_URL" => "go",
-      "GITLAB_CI" => "gitlab",
-      "GITHUB_ACTIONS" => "github",
-      "TASKCLUSTER_ROOT_URL" => "taskcluster",
-      "CI" => "ci",
-    }.freeze
-
-    def self.ci?
-      ENV_INDICATORS.any? {|var| ENV.include?(var) }
-    end
-
-    def self.ci_strings
-      matching_names = ENV_DESCRIPTORS.select {|env, _| ENV[env] }.values
-      matching_names << ENV["CI_NAME"].downcase if ENV["CI_NAME"]
-      matching_names.reject(&:empty?).sort.uniq
-    end
-  end
-end

package/lib/ruby/3.4.11/bundler/cli/add.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  class CLI::Add
-    attr_reader :gems, :options, :version
-
-    def initialize(options, gems)
-      @gems = gems
-      @options = options
-      @options[:group] = options[:group].split(",").map(&:strip) unless options[:group].nil?
-      @version = options[:version].split(",").map(&:strip) unless options[:version].nil?
-    end
-
-    def run
-      Bundler.ui.level = "warn" if options[:quiet]
-
-      validate_options!
-      inject_dependencies
-      perform_bundle_install unless options["skip-install"]
-    end
-
-    private
-
-    def perform_bundle_install
-      Installer.install(Bundler.root, Bundler.definition)
-      Bundler.load.cache if Bundler.app_cache.exist?
-    end
-
-    def inject_dependencies
-      dependencies = gems.map {|g| Bundler::Dependency.new(g, version, options) }
-
-      Injector.inject(dependencies,
-        conservative_versioning: options[:version].nil?, # Perform conservative versioning only when version is not specified
-        optimistic: options[:optimistic],
-        strict: options[:strict])
-    end
-
-    def validate_options!
-      raise InvalidOption, "You cannot specify `--strict` and `--optimistic` at the same time." if options[:strict] && options[:optimistic]
-
-      # raise error when no gems are specified
-      raise InvalidOption, "Please specify gems to add." if gems.empty?
-
-      version.to_a.each do |v|
-        raise InvalidOption, "Invalid gem requirement pattern '#{v}'" unless Gem::Requirement::PATTERN.match?(v.to_s)
-      end
-    end
-  end
-end

package/lib/ruby/3.4.11/bundler/cli/binstubs.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  class CLI::Binstubs
-    attr_reader :options, :gems
-    def initialize(options, gems)
-      @options = options
-      @gems = gems
-    end
-
-    def run
-      Bundler.definition.validate_runtime!
-      path_option = options["path"]
-      path_option = nil if path_option&.empty?
-      Bundler.settings.set_command_option :bin, path_option if options["path"]
-      Bundler.settings.set_command_option_if_given :shebang, options["shebang"]
-      installer = Installer.new(Bundler.root, Bundler.definition)
-
-      installer_opts = {
-        force: options[:force],
-        binstubs_cmd: true,
-        all_platforms: options["all-platforms"],
-      }
-
-      if options[:all]
-        raise InvalidOption, "Cannot specify --all with specific gems" unless gems.empty?
-        @gems = Bundler.definition.specs.map(&:name)
-        installer_opts.delete(:binstubs_cmd)
-      elsif gems.empty?
-        Bundler.ui.error "`bundle binstubs` needs at least one gem to run."
-        exit 1
-      end
-
-      gems.each do |gem_name|
-        spec = Bundler.definition.specs.find {|s| s.name == gem_name }
-        unless spec
-          raise GemNotFound, Bundler::CLI::Common.gem_not_found_message(
-            gem_name, Bundler.definition.specs
-          )
-        end
-
-        if options[:standalone]
-          if gem_name == "bundler"
-            Bundler.ui.warn("Sorry, Bundler can only be run via RubyGems.") unless options[:all]
-            next
-          end
-
-          Bundler.settings.temporary(path: Bundler.settings[:path] || Bundler.root) do
-            installer.generate_standalone_bundler_executable_stubs(spec, installer_opts)
-          end
-        else
-          installer.generate_bundler_executable_stubs(spec, installer_opts)
-        end
-      end
-    end
-  end
-end

package/lib/ruby/3.4.11/bundler/cli/cache.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  class CLI::Cache
-    attr_reader :options
-
-    def initialize(options)
-      @options = options
-    end
-
-    def run
-      Bundler.ui.level = "warn" if options[:quiet]
-      Bundler.settings.set_command_option_if_given :path, options[:path]
-      Bundler.settings.set_command_option_if_given :cache_path, options["cache-path"]
-
-      setup_cache_all
-      install
-
-      # TODO: move cache contents here now that all bundles are locked
-      custom_path = Bundler.settings[:path] if options[:path]
-
-      Bundler.settings.temporary(cache_all_platforms: options["all-platforms"]) do
-        Bundler.load.cache(custom_path)
-      end
-    end
-
-    private
-
-    def install
-      require_relative "install"
-      options = self.options.dup
-      options["local"] = false if Bundler.settings[:cache_all_platforms]
-      options["no-cache"] = true
-      Bundler::CLI::Install.new(options).run
-    end
-
-    def setup_cache_all
-      all = options.fetch(:all, Bundler.feature_flag.cache_all? || nil)
-
-      Bundler.settings.set_command_option_if_given :cache_all, all
-    end
-  end
-end

package/lib/ruby/3.4.11/bundler/cli/check.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  class CLI::Check
-    attr_reader :options
-
-    def initialize(options)
-      @options = options
-    end
-
-    def run
-      Bundler.settings.set_command_option_if_given :path, options[:path]
-
-      definition = Bundler.definition
-      definition.validate_runtime!
-
-      begin
-        definition.check!
-        not_installed = definition.missing_specs
-      rescue GemNotFound, GitError, SolveFailure
-        Bundler.ui.error "Bundler can't satisfy your Gemfile's dependencies."
-        Bundler.ui.warn "Install missing gems with `bundle install`."
-        exit 1
-      end
-
-      if not_installed.any?
-        Bundler.ui.error "The following gems are missing"
-        not_installed.each {|s| Bundler.ui.error " * #{s.name} (#{s.version})" }
-        Bundler.ui.warn "Install missing gems with `bundle install`"
-        exit 1
-      elsif !Bundler.default_lockfile.file? && Bundler.frozen_bundle?
-        Bundler.ui.error "This bundle has been frozen, but there is no #{SharedHelpers.relative_lockfile_path} present"
-        exit 1
-      else
-        definition.lock(true) unless options[:"dry-run"]
-        Bundler.ui.info "The Gemfile's dependencies are satisfied"
-      end
-    end
-  end
-end

package/lib/ruby/3.4.11/bundler/cli/clean.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  class CLI::Clean
-    attr_reader :options
-
-    def initialize(options)
-      @options = options
-    end
-
-    def run
-      require_path_or_force unless options[:"dry-run"]
-      Bundler.load.clean(options[:"dry-run"])
-    end
-
-    protected
-
-    def require_path_or_force
-      return unless Bundler.use_system_gems? && !options[:force]
-      raise InvalidOption, "Cleaning all the gems on your system is dangerous! " \
-        "If you're sure you want to remove every system gem not in this " \
-        "bundle, run `bundle clean --force`."
-    end
-  end
-end

package/lib/ruby/3.4.11/bundler/cli/common.rb

@@ -1,138 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  module CLI::Common
-    def self.output_post_install_messages(messages)
-      return if Bundler.settings["ignore_messages"]
-      messages.to_a.each do |name, msg|
-        print_post_install_message(name, msg) unless Bundler.settings["ignore_messages.#{name}"]
-      end
-    end
-
-    def self.print_post_install_message(name, msg)
-      Bundler.ui.confirm "Post-install message from #{name}:"
-      Bundler.ui.info msg
-    end
-
-    def self.output_fund_metadata_summary
-      return if Bundler.settings["ignore_funding_requests"]
-      definition = Bundler.definition
-      current_dependencies = definition.requested_dependencies
-      current_specs = definition.specs
-
-      count = current_dependencies.count {|dep| current_specs[dep.name].first.metadata.key?("funding_uri") }
-
-      return if count.zero?
-
-      intro = count > 1 ? "#{count} installed gems you directly depend on are" : "#{count} installed gem you directly depend on is"
-      message = "#{intro} looking for funding.\n  Run `bundle fund` for details"
-      Bundler.ui.info message
-    end
-
-    def self.output_without_groups_message(command)
-      return if Bundler.settings[:without].empty?
-      Bundler.ui.confirm without_groups_message(command)
-    end
-
-    def self.without_groups_message(command)
-      command_in_past_tense = command == :install ? "installed" : "updated"
-      groups = Bundler.settings[:without]
-      "Gems in the #{verbalize_groups(groups)} were not #{command_in_past_tense}."
-    end
-
-    def self.verbalize_groups(groups)
-      groups.map! {|g| "'#{g}'" }
-      group_list = [groups[0...-1].join(", "), groups[-1..-1]].
-        reject {|s| s.to_s.empty? }.join(" and ")
-      group_str = groups.size == 1 ? "group" : "groups"
-      "#{group_str} #{group_list}"
-    end
-
-    def self.select_spec(name, regex_match = nil)
-      specs = []
-      regexp = Regexp.new(name) if regex_match
-
-      Bundler.definition.specs.each do |spec|
-        return spec if spec.name == name
-        specs << spec if regexp && spec.name.match?(regexp)
-      end
-
-      default_spec = default_gem_spec(name)
-      specs << default_spec if default_spec
-
-      case specs.count
-      when 0
-        dep_in_other_group = Bundler.definition.current_dependencies.find {|dep|dep.name == name }
-
-        if dep_in_other_group
-          raise GemNotFound, "Could not find gem '#{name}', because it's in the #{verbalize_groups(dep_in_other_group.groups)}, configured to be ignored."
-        else
-          raise GemNotFound, gem_not_found_message(name, Bundler.definition.dependencies)
-        end
-      when 1
-        specs.first
-      else
-        ask_for_spec_from(specs)
-      end
-    rescue RegexpError
-      raise GemNotFound, gem_not_found_message(name, Bundler.definition.dependencies)
-    end
-
-    def self.default_gem_spec(name)
-      gem_spec = Gem::Specification.find_all_by_name(name).last
-      gem_spec if gem_spec&.default_gem?
-    end
-
-    def self.ask_for_spec_from(specs)
-      specs.each_with_index do |spec, index|
-        Bundler.ui.info "#{index.succ} : #{spec.name}", true
-      end
-      Bundler.ui.info "0 : - exit -", true
-
-      num = Bundler.ui.ask("> ").to_i
-      num > 0 ? specs[num - 1] : nil
-    end
-
-    def self.gem_not_found_message(missing_gem_name, alternatives)
-      require_relative "../similarity_detector"
-      message = "Could not find gem '#{missing_gem_name}'."
-      alternate_names = alternatives.map {|a| a.respond_to?(:name) ? a.name : a }
-      suggestions = SimilarityDetector.new(alternate_names).similar_word_list(missing_gem_name)
-      message += "\nDid you mean #{suggestions}?" if suggestions
-      message
-    end
-
-    def self.ensure_all_gems_in_lockfile!(names, locked_gems = Bundler.locked_gems)
-      return unless locked_gems
-
-      locked_names = locked_gems.specs.map(&:name).uniq
-      names.-(locked_names).each do |g|
-        raise GemNotFound, gem_not_found_message(g, locked_names)
-      end
-    end
-
-    def self.configure_gem_version_promoter(definition, options)
-      patch_level = patch_level_options(options)
-      patch_level << :patch if patch_level.empty? && Bundler.settings[:prefer_patch]
-      raise InvalidOption, "Provide only one of the following options: #{patch_level.join(", ")}" unless patch_level.length <= 1
-
-      definition.gem_version_promoter.tap do |gvp|
-        gvp.level = patch_level.first || :major
-        gvp.strict = options[:strict] || options["filter-strict"]
-        gvp.pre = options[:pre]
-      end
-    end
-
-    def self.patch_level_options(options)
-      [:major, :minor, :patch].select {|v| options.keys.include?(v.to_s) }
-    end
-
-    def self.clean_after_install?
-      clean = Bundler.settings[:clean]
-      return clean unless clean.nil?
-      clean ||= Bundler.feature_flag.auto_clean_without_path? && Bundler.settings[:path].nil?
-      clean &&= !Bundler.use_system_gems?
-      clean
-    end
-  end
-end

package/lib/ruby/3.4.11/bundler/cli/config.rb

@@ -1,204 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  class CLI::Config < Thor
-    class_option :parseable, type: :boolean, banner: "Use minimal formatting for more parseable output"
-
-    def self.scope_options
-      method_option :global, type: :boolean, banner: "Only change the global config"
-      method_option :local, type: :boolean, banner: "Only change the local config"
-    end
-    private_class_method :scope_options
-
-    desc "base NAME [VALUE]", "The Bundler 1 config interface", hide: true
-    scope_options
-    method_option :delete, type: :boolean, banner: "delete"
-    def base(name = nil, *value)
-      new_args =
-        if ARGV.size == 1
-          ["config", "list"]
-        elsif ARGV.include?("--delete")
-          ARGV.map {|arg| arg == "--delete" ? "unset" : arg }
-        elsif ARGV.include?("--global") || ARGV.include?("--local") || ARGV.size == 3
-          ["config", "set", *ARGV[1..-1]]
-        else
-          ["config", "get", ARGV[1]]
-        end
-
-      message = "Using the `config` command without a subcommand [list, get, set, unset] is deprecated and will be removed in the future. Use `bundle #{new_args.join(" ")}` instead."
-      removed_message = "Using the `config` command without a subcommand [list, get, set, unset] is has been removed. Use `bundle #{new_args.join(" ")}` instead."
-      SharedHelpers.major_deprecation 3, message, removed_message: removed_message
-
-      Base.new(options, name, value, self).run
-    end
-
-    desc "list", "List out all configured settings"
-    def list
-      Base.new(options, nil, nil, self).run
-    end
-
-    desc "get NAME", "Returns the value for the given key"
-    def get(name)
-      Base.new(options, name, nil, self).run
-    end
-
-    desc "set NAME VALUE", "Sets the given value for the given key"
-    scope_options
-    def set(name, value, *value_)
-      Base.new(options, name, value_.unshift(value), self).run
-    end
-
-    desc "unset NAME", "Unsets the value for the given key"
-    scope_options
-    def unset(name)
-      options[:delete] = true
-      Base.new(options, name, nil, self).run
-    end
-
-    default_task :base
-
-    class Base
-      attr_reader :name, :value, :options, :scope, :thor
-
-      def initialize(options, name, value, thor)
-        @options = options
-        @name = name
-        value = Array(value)
-        @value = value.empty? ? nil : value.join(" ")
-        @thor = thor
-        validate_scope!
-      end
-
-      def run
-        unless name
-          warn_unused_scope "Ignoring --#{scope}"
-          confirm_all
-          return
-        end
-
-        if options[:delete]
-          if !explicit_scope? || scope != "global"
-            Bundler.settings.set_local(name, nil)
-          end
-          if !explicit_scope? || scope != "local"
-            Bundler.settings.set_global(name, nil)
-          end
-          return
-        end
-
-        if value.nil?
-          warn_unused_scope "Ignoring --#{scope} since no value to set was given"
-
-          if options[:parseable]
-            if value = Bundler.settings[name]
-              Bundler.ui.info("#{name}=#{value}")
-            end
-            return
-          end
-
-          confirm(name)
-          return
-        end
-
-        Bundler.ui.info(message) if message
-        Bundler.settings.send("set_#{scope}", name, new_value)
-      end
-
-      def confirm_all
-        if @options[:parseable]
-          thor.with_padding do
-            Bundler.settings.all.each do |setting|
-              val = Bundler.settings[setting]
-              Bundler.ui.info "#{setting}=#{val}"
-            end
-          end
-        else
-          Bundler.ui.confirm "Settings are listed in order of priority. The top value will be used.\n"
-          Bundler.settings.all.each do |setting|
-            Bundler.ui.confirm setting
-            show_pretty_values_for(setting)
-            Bundler.ui.confirm ""
-          end
-        end
-      end
-
-      def confirm(name)
-        Bundler.ui.confirm "Settings for `#{name}` in order of priority. The top value will be used"
-        show_pretty_values_for(name)
-      end
-
-      def new_value
-        pathname = Pathname.new(value)
-        if name.start_with?("local.") && pathname.directory?
-          pathname.expand_path.to_s
-        else
-          value
-        end
-      end
-
-      def message
-        locations = Bundler.settings.locations(name)
-        if @options[:parseable]
-          "#{name}=#{new_value}" if new_value
-        elsif scope == "global"
-          if !locations[:local].nil?
-            "Your application has set #{name} to #{locations[:local].inspect}. " \
-              "This will override the global value you are currently setting"
-          elsif locations[:env]
-            "You have a bundler environment variable for #{name} set to " \
-              "#{locations[:env].inspect}. This will take precedence over the global value you are setting"
-          elsif !locations[:global].nil? && locations[:global] != value
-            "You are replacing the current global value of #{name}, which is currently " \
-              "#{locations[:global].inspect}"
-          end
-        elsif scope == "local" && !locations[:local].nil? && locations[:local] != value
-          "You are replacing the current local value of #{name}, which is currently " \
-            "#{locations[:local].inspect}"
-        end
-      end
-
-      def show_pretty_values_for(setting)
-        thor.with_padding do
-          Bundler.settings.pretty_values_for(setting).each do |line|
-            Bundler.ui.info line
-          end
-        end
-      end
-
-      def explicit_scope?
-        @explicit_scope
-      end
-
-      def warn_unused_scope(msg)
-        return unless explicit_scope?
-        return if options[:parseable]
-
-        Bundler.ui.warn(msg)
-      end
-
-      def validate_scope!
-        @explicit_scope = true
-        scopes = %w[global local].select {|s| options[s] }
-        case scopes.size
-        when 0
-          @scope = inside_app? ? "local" : "global"
-          @explicit_scope = false
-        when 1
-          @scope = scopes.first
-        else
-          raise InvalidOption,
-            "The options #{scopes.join " and "} were specified. Please only use one of the switches at a time."
-        end
-      end
-
-      private
-
-      def inside_app?
-        Bundler.root
-        true
-      rescue GemfileNotFound
-        false
-      end
-    end
-  end
-end

package/lib/ruby/3.4.11/bundler/cli/console.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  class CLI::Console
-    attr_reader :options, :group
-    def initialize(options, group)
-      @options = options
-      @group = group
-    end
-
-    def run
-      group ? Bundler.require(:default, *group.split(" ").map!(&:to_sym)) : Bundler.require
-      ARGV.clear
-
-      console = get_console(Bundler.settings[:console] || "irb")
-      console.start
-    end
-
-    def get_console(name)
-      require name
-      get_constant(name)
-    rescue LoadError
-      if name == "irb"
-        Bundler.ui.error "#{name} is not available"
-        exit 1
-      else
-        Bundler.ui.error "Couldn't load console #{name}, falling back to irb"
-        name = "irb"
-        retry
-      end
-    end
-
-    def get_constant(name)
-      const_name = {
-        "pry" => :Pry,
-        "ripl" => :Ripl,
-        "irb" => :IRB,
-      }[name]
-      Object.const_get(const_name)
-    end
-  end
-end