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

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

@@ -1,199 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  class CLI::Install
-    attr_reader :options
-    def initialize(options)
-      @options = options
-    end
-
-    def run
-      Bundler.ui.level = "warn" if options[:quiet]
-
-      warn_if_root
-
-      if options[:local]
-        Bundler.self_manager.restart_with_locked_bundler_if_needed
-      else
-        Bundler.self_manager.install_locked_bundler_and_restart_with_it_if_needed
-      end
-
-      Bundler::SharedHelpers.set_env "RB_USER_INSTALL", "1" if Gem.freebsd_platform?
-
-      # Disable color in deployment mode
-      Bundler.ui.shell = Thor::Shell::Basic.new if options[:deployment]
-
-      if target_rbconfig_path = options[:"target-rbconfig"]
-        Bundler.rubygems.set_target_rbconfig(target_rbconfig_path)
-      end
-
-      check_for_options_conflicts
-
-      check_trust_policy
-
-      if options[:deployment] || options[:frozen] || Bundler.frozen_bundle?
-        unless Bundler.default_lockfile.exist?
-          flag = "--deployment flag" if options[:deployment]
-          flag ||= "--frozen flag" if options[:frozen]
-          flag ||= "deployment setting" if Bundler.settings[:deployment]
-          flag ||= "frozen setting" if Bundler.settings[:frozen]
-          raise ProductionError, "The #{flag} requires a lockfile. Please make " \
-                                 "sure you have checked your #{SharedHelpers.relative_lockfile_path} into version control " \
-                                 "before deploying."
-        end
-
-        options[:local] = true if Bundler.app_cache.exist?
-
-        Bundler.settings.set_command_option :deployment, true if options[:deployment]
-        Bundler.settings.set_command_option :frozen, true if options[:frozen]
-      end
-
-      # When install is called with --no-deployment, disable deployment mode
-      if options[:deployment] == false
-        Bundler.settings.set_command_option :frozen, nil
-        options[:system] = true
-      end
-
-      normalize_settings
-
-      Bundler::Fetcher.disable_endpoint = options["full-index"]
-
-      if options["binstubs"]
-        Bundler::SharedHelpers.major_deprecation 2,
-          "The --binstubs option will be removed in favor of `bundle binstubs --all`",
-          removed_message: "The --binstubs option have been removed in favor of `bundle binstubs --all`"
-      end
-
-      Plugin.gemfile_install(Bundler.default_gemfile) if Bundler.feature_flag.plugins?
-
-      definition = Bundler.definition
-      definition.validate_runtime!
-
-      installer = Installer.install(Bundler.root, definition, options)
-
-      Bundler.settings.temporary(cache_all_platforms: options[:local] ? false : Bundler.settings[:cache_all_platforms]) do
-        Bundler.load.cache(nil, options[:local]) if Bundler.app_cache.exist? && !options["no-cache"] && !Bundler.frozen_bundle?
-      end
-
-      Bundler.ui.confirm "Bundle complete! #{dependencies_count_for(definition)}, #{gems_installed_for(definition)}."
-      Bundler::CLI::Common.output_without_groups_message(:install)
-
-      if Bundler.use_system_gems?
-        Bundler.ui.confirm "Use `bundle info [gemname]` to see where a bundled gem is installed."
-      else
-        relative_path = Bundler.configured_bundle_path.base_path_relative_to_pwd
-        Bundler.ui.confirm "Bundled gems are installed into `#{relative_path}`"
-      end
-
-      Bundler::CLI::Common.output_post_install_messages installer.post_install_messages
-
-      warn_ambiguous_gems
-
-      if CLI::Common.clean_after_install?
-        require_relative "clean"
-        Bundler::CLI::Clean.new(options).run
-      end
-
-      Bundler::CLI::Common.output_fund_metadata_summary
-    rescue Gem::InvalidSpecificationException
-      Bundler.ui.warn "You have one or more invalid gemspecs that need to be fixed."
-      raise
-    end
-
-    private
-
-    def warn_if_root
-      return if Bundler.settings[:silence_root_warning] || Gem.win_platform? || !Process.uid.zero?
-      Bundler.ui.warn "Don't run Bundler as root. Installing your bundle as root " \
-                      "will break this application for all non-root users on this machine.", wrap: true
-    end
-
-    def dependencies_count_for(definition)
-      count = definition.dependencies.count
-      "#{count} Gemfile #{count == 1 ? "dependency" : "dependencies"}"
-    end
-
-    def gems_installed_for(definition)
-      count = definition.specs.count
-      "#{count} #{count == 1 ? "gem" : "gems"} now installed"
-    end
-
-    def check_for_group_conflicts_in_cli_options
-      conflicting_groups = Array(options[:without]) & Array(options[:with])
-      return if conflicting_groups.empty?
-      raise InvalidOption, "You can't list a group in both with and without." \
-        " The offending groups are: #{conflicting_groups.join(", ")}."
-    end
-
-    def check_for_options_conflicts
-      if (options[:path] || options[:deployment]) && options[:system]
-        error_message = String.new
-        error_message << "You have specified both --path as well as --system. Please choose only one option.\n" if options[:path]
-        error_message << "You have specified both --deployment as well as --system. Please choose only one option.\n" if options[:deployment]
-        raise InvalidOption.new(error_message)
-      end
-    end
-
-    def check_trust_policy
-      trust_policy = options["trust-policy"]
-      unless Bundler.rubygems.security_policies.keys.unshift(nil).include?(trust_policy)
-        raise InvalidOption, "RubyGems doesn't know about trust policy '#{trust_policy}'. " \
-          "The known policies are: #{Bundler.rubygems.security_policies.keys.join(", ")}."
-      end
-      Bundler.settings.set_command_option_if_given :"trust-policy", trust_policy
-    end
-
-    def normalize_groups
-      check_for_group_conflicts_in_cli_options
-
-      # need to nil them out first to get around validation for backwards compatibility
-      Bundler.settings.set_command_option :without, nil
-      Bundler.settings.set_command_option :with,    nil
-      Bundler.settings.set_command_option :without, options[:without]
-      Bundler.settings.set_command_option :with,    options[:with]
-    end
-
-    def normalize_settings
-      Bundler.settings.set_command_option :path, nil if options[:system]
-      Bundler.settings.set_command_option_if_given :path, options[:path]
-
-      if options["standalone"] && Bundler.settings[:path].nil? && !options["local"]
-        Bundler.settings.temporary(path_relative_to_cwd: false) do
-          Bundler.settings.set_command_option :path, "bundle"
-        end
-      end
-
-      bin_option = options["binstubs"]
-      bin_option = nil if bin_option&.empty?
-      Bundler.settings.set_command_option :bin, bin_option if options["binstubs"]
-
-      Bundler.settings.set_command_option_if_given :shebang, options["shebang"]
-
-      Bundler.settings.set_command_option_if_given :jobs, options["jobs"]
-
-      Bundler.settings.set_command_option_if_given :no_prune, options["no-prune"]
-
-      Bundler.settings.set_command_option_if_given :no_install, options["no-install"]
-
-      Bundler.settings.set_command_option_if_given :clean, options["clean"]
-
-      normalize_groups if options[:without] || options[:with]
-
-      options[:force] = options[:redownload]
-    end
-
-    def warn_ambiguous_gems
-      # TODO: remove this when we drop Bundler 1.x support
-      Installer.ambiguous_gems.to_a.each do |name, installed_from_uri, *also_found_in_uris|
-        Bundler.ui.warn "Warning: the gem '#{name}' was found in multiple sources."
-        Bundler.ui.warn "Installed from: #{installed_from_uri}"
-        Bundler.ui.warn "Also found in:"
-        also_found_in_uris.each {|uri| Bundler.ui.warn "  * #{uri}" }
-        Bundler.ui.warn "You should add a source requirement to restrict this gem to your preferred source."
-        Bundler.ui.warn "For example:"
-        Bundler.ui.warn "    gem '#{name}', :source => '#{installed_from_uri}'"
-        Bundler.ui.warn "Then uninstall the gem '#{name}' (or delete all bundled gems) and then install again."
-      end
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require "rbconfig"
-
-module Bundler
-  class CLI::Issue
-    def run
-      Bundler.ui.info <<~EOS
-        Did you find an issue with Bundler? Before filing a new issue,
-        be sure to check out these resources:
-
-        1. Check out our troubleshooting guide for quick fixes to common issues:
-        https://github.com/rubygems/rubygems/blob/master/doc/bundler/TROUBLESHOOTING.md
-
-        2. Instructions for common Bundler uses can be found on the documentation
-        site: https://bundler.io/
-
-        3. Information about each Bundler command can be found in the Bundler
-        man pages: https://bundler.io/man/bundle.1.html
-
-        Hopefully the troubleshooting steps above resolved your problem!  If things
-        still aren't working the way you expect them to, please let us know so
-        that we can diagnose and help fix the problem you're having, by filling
-        in the new issue form located at
-        https://github.com/rubygems/rubygems/issues/new?labels=Bundler&template=bundler-related-issue.md,
-        and copy and pasting the information below.
-
-      EOS
-
-      Bundler.ui.info Bundler::Env.report
-
-      Bundler.ui.info "\n## Bundle Doctor"
-      doctor
-    end
-
-    def doctor
-      require_relative "doctor/diagnose"
-      Bundler::CLI::Doctor::Diagnose.new({}).run
-    end
-  end
-end

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

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  class CLI::List
-    def initialize(options)
-      @options = options
-      @without_group = options["without-group"].map(&:to_sym)
-      @only_group = options["only-group"].map(&:to_sym)
-    end
-
-    def run
-      raise InvalidOption, "The `--only-group` and `--without-group` options cannot be used together" if @only_group.any? && @without_group.any?
-
-      raise InvalidOption, "The `--name-only` and `--paths` options cannot be used together" if @options["name-only"] && @options[:paths]
-
-      specs = if @only_group.any? || @without_group.any?
-        filtered_specs_by_groups
-      else
-        begin
-          Bundler.load.specs
-        rescue GemNotFound => e
-          Bundler.ui.error e.message
-          Bundler.ui.warn "Install missing gems with `bundle install`."
-          exit 1
-        end
-      end.reject {|s| s.name == "bundler" }.sort_by(&:name)
-
-      return Bundler.ui.info "No gems in the Gemfile" if specs.empty?
-
-      return specs.each {|s| Bundler.ui.info s.name } if @options["name-only"]
-      return specs.each {|s| Bundler.ui.info s.full_gem_path } if @options["paths"]
-
-      Bundler.ui.info "Gems included by the bundle:"
-
-      specs.each {|s| Bundler.ui.info "  * #{s.name} (#{s.version}#{s.git_version})" }
-
-      Bundler.ui.info "Use `bundle info` to print more detailed information about a gem"
-    end
-
-    private
-
-    def verify_group_exists(groups)
-      (@without_group + @only_group).each do |group|
-        raise InvalidOption, "`#{group}` group could not be found." unless groups.include?(group)
-      end
-    end
-
-    def filtered_specs_by_groups
-      definition = Bundler.definition
-      groups = definition.groups
-
-      verify_group_exists(groups)
-
-      show_groups =
-        if @without_group.any?
-          groups.reject {|g| @without_group.include?(g) }
-        elsif @only_group.any?
-          groups.select {|g| @only_group.include?(g) }
-        else
-          groups
-        end.map(&:to_sym)
-
-      definition.specs_for(show_groups)
-    end
-  end
-end

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

@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  class CLI::Lock
-    attr_reader :options
-
-    def initialize(options)
-      @options = options
-    end
-
-    def run
-      unless Bundler.default_gemfile
-        Bundler.ui.error "Unable to find a Gemfile to lock"
-        exit 1
-      end
-
-      check_for_conflicting_options
-
-      print = options[:print]
-      previous_output_stream = Bundler.ui.output_stream
-      Bundler.ui.output_stream = :stderr if print
-
-      Bundler::Fetcher.disable_endpoint = options["full-index"]
-
-      update = options[:update]
-      conservative = options[:conservative]
-      bundler = options[:bundler]
-
-      if update.is_a?(Array) # unlocking specific gems
-        Bundler::CLI::Common.ensure_all_gems_in_lockfile!(update)
-        update = { gems: update, conservative: conservative }
-      elsif update && conservative
-        update = { conservative: conservative }
-      elsif update && bundler
-        update = { bundler: bundler }
-      end
-
-      file = options[:lockfile]
-      file = file ? Pathname.new(file).expand_path : Bundler.default_lockfile
-
-      Bundler.settings.temporary(frozen: false) do
-        definition = Bundler.definition(update, file)
-        definition.add_checksums if options["add-checksums"]
-
-        Bundler::CLI::Common.configure_gem_version_promoter(definition, options) if options[:update]
-
-        options["remove-platform"].each do |platform_string|
-          platform = Gem::Platform.new(platform_string)
-          definition.remove_platform(platform)
-        end
-
-        options["add-platform"].each do |platform_string|
-          platform = Gem::Platform.new(platform_string)
-          if platform.to_s == "unknown"
-            Bundler.ui.error "The platform `#{platform_string}` is unknown to RubyGems and can't be added to the lockfile."
-            exit 1
-          end
-          definition.add_platform(platform)
-        end
-
-        if definition.platforms.empty?
-          raise InvalidOption, "Removing all platforms from the bundle is not allowed"
-        end
-
-        definition.remotely! unless options[:local]
-
-        if options["normalize-platforms"]
-          definition.normalize_platforms
-        end
-
-        if print
-          puts definition.to_lock
-        else
-          puts "Writing lockfile to #{file}"
-          definition.lock
-        end
-      end
-
-      Bundler.ui.output_stream = previous_output_stream
-    end
-
-    private
-
-    def check_for_conflicting_options
-      if options["normalize-platforms"] && options["add-platform"].any?
-        raise InvalidOption, "--normalize-platforms can't be used with --add-platform"
-      end
-
-      if options["normalize-platforms"] && options["remove-platform"].any?
-        raise InvalidOption, "--normalize-platforms can't be used with --remove-platform"
-      end
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  class CLI::Open
-    attr_reader :options, :name, :path
-    def initialize(options, name)
-      @options = options
-      @name = name
-      @path = options[:path] unless options[:path].nil?
-    end
-
-    def run
-      raise InvalidOption, "Cannot specify `--path` option without a value" if !@path.nil? && @path.empty?
-      editor = [ENV["BUNDLER_EDITOR"], ENV["VISUAL"], ENV["EDITOR"]].find {|e| !e.nil? && !e.empty? }
-      return Bundler.ui.info("To open a bundled gem, set $EDITOR or $BUNDLER_EDITOR") unless editor
-      return unless spec = Bundler::CLI::Common.select_spec(name, :regex_match)
-      if spec.default_gem?
-        Bundler.ui.info "Unable to open #{name} because it's a default gem, so the directory it would normally be installed to does not exist."
-      else
-        root_path = spec.full_gem_path
-        require "shellwords"
-        command = Shellwords.split(editor) << File.join([root_path, path].compact)
-        Bundler.with_original_env do
-          system(*command, { chdir: root_path })
-        end || Bundler.ui.info("Could not run '#{command.join(" ")}'")
-      end
-    end
-  end
-end