bundler_pack 4.0.15

data/lib/bundler/runtime.rb

@@ -0,0 +1,331 @@
+# frozen_string_literal: true
+
+module Bundler
+  class Runtime
+    include SharedHelpers
+
+    def initialize(root, definition)
+      @root = root
+      @definition = definition
+    end
+
+    def setup(*groups)
+      @definition.ensure_equivalent_gemfile_and_lockfile
+
+      # Has to happen first
+      clean_load_path
+
+      specs = @definition.specs_for(groups)
+
+      SharedHelpers.set_bundle_environment
+      Bundler.rubygems.replace_entrypoints(specs)
+
+      # Activate the specs
+      load_paths = specs.map do |spec|
+        check_for_activated_spec!(spec)
+
+        Bundler.rubygems.mark_loaded(spec)
+        spec.load_paths.reject {|path| $LOAD_PATH.include?(path) }
+      end.reverse.flatten
+
+      Gem.add_to_load_path(*load_paths)
+
+      setup_manpath
+
+      lock(preserve_unknown_sections: true)
+
+      self
+    end
+
+    def require(*groups)
+      groups.map!(&:to_sym)
+      groups = [:default] if groups.empty?
+
+      dependencies = @definition.dependencies.select do |dep|
+        # Select the dependency if it is in any of the requested groups, and
+        # for the current platform, and matches the gem constraints.
+        (dep.groups & groups).any? && dep.should_include?
+      end
+
+      Plugin.hook(Plugin::Events::GEM_BEFORE_REQUIRE_ALL, dependencies)
+
+      dependencies.each do |dep|
+        Plugin.hook(Plugin::Events::GEM_BEFORE_REQUIRE, dep)
+
+        # Loop through all the specified autorequires for the
+        # dependency. If there are none, use the dependency's name
+        # as the autorequire.
+        Array(dep.autorequire || dep.name).each do |file|
+          # Allow `require: true` as an alias for `require: <name>`
+          file = dep.name if file == true
+          required_file = file
+          begin
+            Kernel.require required_file
+          rescue LoadError => e
+            if dep.autorequire.nil? && e.path == required_file
+              if required_file.include?("-")
+                required_file = required_file.tr("-", "/")
+                retry
+              end
+            else
+              raise Bundler::GemRequireError.new e,
+                "There was an error while trying to load the gem '#{file}'."
+            end
+          rescue StandardError => e
+            raise Bundler::GemRequireError.new e,
+              "There was an error while trying to load the gem '#{file}'."
+          end
+        end
+
+        Plugin.hook(Plugin::Events::GEM_AFTER_REQUIRE, dep)
+      end
+
+      Plugin.hook(Plugin::Events::GEM_AFTER_REQUIRE_ALL, dependencies)
+
+      dependencies
+    end
+
+    def self.definition_method(meth)
+      define_method(meth) do
+        raise ArgumentError, "no definition when calling Runtime##{meth}" unless @definition
+        @definition.send(meth)
+      end
+    end
+    private_class_method :definition_method
+
+    definition_method :requested_specs
+    definition_method :specs
+    definition_method :dependencies
+    definition_method :current_dependencies
+    definition_method :requires
+
+    def lock(opts = {})
+      return if @definition.no_resolve_needed?
+      @definition.lock(opts[:preserve_unknown_sections])
+    end
+
+    alias_method :gems, :specs
+
+    def cache(custom_path = nil, local = false)
+      cache_path = Bundler.app_cache(custom_path)
+      SharedHelpers.filesystem_access(cache_path) do |p|
+        FileUtils.mkdir_p(p)
+      end unless File.exist?(cache_path)
+
+      Bundler.ui.info "Updating files in #{Bundler.settings.app_cache_path}"
+
+      specs_to_cache = if Bundler.settings[:cache_all_platforms]
+        @definition.resolve.materialized_for_all_platforms
+      else
+        begin
+          specs
+        rescue GemNotFound
+          if local
+            Bundler.ui.warn "Some gems seem to be missing from your #{Bundler.settings.app_cache_path} directory."
+          end
+
+          raise
+        end
+      end
+
+      specs_to_cache.each do |spec|
+        next if spec.name == "bundler"
+
+        source = spec.source
+        next if source.is_a?(Source::Gemspec)
+
+        if source.respond_to?(:migrate_cache)
+          source.migrate_cache(custom_path, local: local)
+        elsif source.respond_to?(:cache)
+          source.cache(spec, custom_path)
+        end
+      end
+
+      Dir[cache_path.join("*/.git")].each do |git_dir|
+        FileUtils.rm_rf(git_dir)
+        FileUtils.touch(File.expand_path("../.bundlecache", git_dir))
+      end
+
+      prune_cache(cache_path) unless Bundler.settings[:no_prune]
+    end
+
+    def prune_cache(cache_path)
+      SharedHelpers.filesystem_access(cache_path) do |p|
+        FileUtils.mkdir_p(p)
+      end unless File.exist?(cache_path)
+      resolve = @definition.resolve
+      prune_gem_cache(resolve, cache_path)
+      prune_git_and_path_cache(resolve, cache_path)
+    end
+
+    def clean(dry_run = false)
+      gem_bins             = Dir["#{Gem.dir}/bin/*"]
+      git_dirs             = Dir["#{Gem.dir}/bundler/gems/*"]
+      git_cache_dirs       = Dir["#{Gem.dir}/cache/bundler/git/*"]
+      gem_dirs             = Dir["#{Gem.dir}/gems/*"]
+      gem_files            = Dir["#{Gem.dir}/cache/*.gem"]
+      gemspec_files        = Dir["#{Gem.dir}/specifications/*.gemspec"]
+      extension_dirs       = Dir["#{Gem.dir}/extensions/*/*/*"] + Dir["#{Gem.dir}/bundler/gems/extensions/*/*/*"]
+      spec_gem_paths       = []
+      # need to keep git sources around
+      spec_git_paths       = @definition.spec_git_paths
+      spec_git_cache_dirs  = []
+      spec_gem_executables = []
+      spec_cache_paths     = []
+      spec_gemspec_paths   = []
+      spec_extension_paths = []
+      specs_to_keep = Bundler.rubygems.add_default_gems_to(specs).values
+
+      current_bundler = Bundler.rubygems.find_bundler(Bundler.gem_version)
+      if current_bundler
+        specs_to_keep << current_bundler
+      end
+
+      specs_to_keep.each do |spec|
+        spec_gem_paths << spec.full_gem_path
+        # need to check here in case gems are nested like for the rails git repo
+        md = %r{(.+bundler/gems/.+-[a-f0-9]{7,12})}.match(spec.full_gem_path)
+        spec_git_paths << md[1] if md
+        spec_gem_executables << spec.executables.collect do |executable|
+          e = "#{Bundler.rubygems.gem_bindir}/#{executable}"
+          [e, "#{e}.bat"]
+        end
+        spec_cache_paths << spec.cache_file
+        spec_gemspec_paths << spec.spec_file
+        spec_extension_paths << spec.extension_dir if spec.respond_to?(:extension_dir)
+        spec_git_cache_dirs << spec.source.cache_path.to_s if spec.source.is_a?(Bundler::Source::Git)
+      end
+      spec_gem_paths.uniq!
+      spec_gem_executables.flatten!
+
+      stale_gem_bins       = gem_bins - spec_gem_executables
+      stale_git_dirs       = git_dirs - spec_git_paths - ["#{Gem.dir}/bundler/gems/extensions"]
+      stale_git_cache_dirs = git_cache_dirs - spec_git_cache_dirs
+      stale_gem_dirs       = gem_dirs - spec_gem_paths
+      stale_gem_files      = gem_files - spec_cache_paths
+      stale_gemspec_files  = gemspec_files - spec_gemspec_paths
+      stale_extension_dirs = extension_dirs - spec_extension_paths
+
+      removed_stale_gem_dirs = stale_gem_dirs.collect {|dir| remove_dir(dir, dry_run) }
+      removed_stale_git_dirs = stale_git_dirs.collect {|dir| remove_dir(dir, dry_run) }
+      output = removed_stale_gem_dirs + removed_stale_git_dirs
+
+      unless dry_run
+        stale_files = stale_gem_bins + stale_gem_files + stale_gemspec_files
+        stale_files.each do |file|
+          SharedHelpers.filesystem_access(File.dirname(file)) do |_p|
+            FileUtils.rm(file) if File.exist?(file)
+          end
+        end
+
+        stale_dirs = stale_git_cache_dirs + stale_extension_dirs
+        stale_dirs.each do |stale_dir|
+          SharedHelpers.filesystem_access(stale_dir) do |dir|
+            FileUtils.rm_rf(dir) if File.exist?(dir)
+          end
+        end
+      end
+
+      output
+    end
+
+    private
+
+    def prune_gem_cache(resolve, cache_path)
+      cached = Dir["#{cache_path}/*.gem"]
+
+      cached = cached.delete_if do |path|
+        spec = Bundler.rubygems.spec_from_gem path
+
+        resolve.any? do |s|
+          s.name == spec.name && s.version == spec.version && !s.source.is_a?(Bundler::Source::Git)
+        end
+      end
+
+      if cached.any?
+        Bundler.ui.info "Removing outdated .gem files from #{Bundler.settings.app_cache_path}"
+
+        cached.each do |path|
+          Bundler.ui.info "  * #{File.basename(path)}"
+
+          begin
+            File.delete(path)
+          rescue Errno::ENOENT
+          end
+        end
+      end
+    end
+
+    def prune_git_and_path_cache(resolve, cache_path)
+      cached = Dir["#{cache_path}/*/.bundlecache"]
+
+      cached = cached.delete_if do |path|
+        name = File.basename(File.dirname(path))
+
+        resolve.any? do |s|
+          source = s.source
+          source.respond_to?(:app_cache_dirname) && source.app_cache_dirname == name
+        end
+      end
+
+      if cached.any?
+        Bundler.ui.info "Removing outdated git and path gems from #{Bundler.settings.app_cache_path}"
+
+        cached.each do |path|
+          path = File.dirname(path)
+          Bundler.ui.info "  * #{File.basename(path)}"
+          FileUtils.rm_rf(path)
+        end
+      end
+    end
+
+    def setup_manpath
+      # Add man/ subdirectories from activated bundles to MANPATH for man(1)
+      manuals = $LOAD_PATH.filter_map do |path|
+        man_subdir = path.sub(/lib$/, "man")
+        man_subdir unless Dir[man_subdir + "/man?/"].empty?
+      end
+
+      return if manuals.empty?
+      Bundler::SharedHelpers.set_env "MANPATH", manuals.concat(
+        ENV["MANPATH"] ? ENV["MANPATH"].to_s.split(File::PATH_SEPARATOR) : [""]
+      ).uniq.join(File::PATH_SEPARATOR)
+    end
+
+    def remove_dir(dir, dry_run)
+      full_name = Pathname.new(dir).basename.to_s
+
+      parts    = full_name.split("-")
+      name     = parts[0..-2].join("-")
+      version  = parts.last
+      output   = "#{name} (#{version})"
+
+      if dry_run
+        Bundler.ui.info "Would have removed #{output}"
+      else
+        Bundler.ui.info "Removing #{output}"
+        FileUtils.rm_rf(dir)
+      end
+
+      output
+    end
+
+    def check_for_activated_spec!(spec)
+      return unless activated_spec = Bundler.rubygems.loaded_specs(spec.name)
+      return if activated_spec.version == spec.version
+
+      suggestion = if activated_spec.default_gem?
+        "Since #{spec.name} is a default gem, you can either remove your dependency on it" \
+        " or try updating to a newer version of bundler that supports #{spec.name} as a default gem."
+      else
+        "Prepending `bundle exec` to your command may solve this."
+      end
+
+      e = Gem::LoadError.new "You have already activated #{activated_spec.name} #{activated_spec.version}, " \
+                             "but your Gemfile requires #{spec.name} #{spec.version}. #{suggestion}"
+      e.name = spec.name
+      e.requirement = Gem::Requirement.new(spec.version.to_s)
+      raise e
+    end
+  end
+end

data/lib/bundler/safe_marshal.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Bundler
+  module SafeMarshal
+    ALLOWED_CLASSES = [
+      Array,
+      FalseClass,
+      Gem::Specification,
+      Gem::Version,
+      Hash,
+      String,
+      Symbol,
+      Time,
+      TrueClass,
+    ].freeze
+
+    ERROR = "Unexpected class %s present in marshaled data. Only %s are allowed."
+
+    PROC = proc do |object|
+      object.tap do
+        unless ALLOWED_CLASSES.include?(object.class)
+          raise TypeError, format(ERROR, object.class, ALLOWED_CLASSES.join(", "))
+        end
+      end
+    end
+
+    def self.proc
+      PROC
+    end
+  end
+end

data/lib/bundler/self_manager.rb

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

data/lib/bundler/settings/validator.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Bundler
+  class Settings
+    class Validator
+      class Rule
+        attr_reader :description
+
+        def initialize(keys, description, &validate)
+          @keys = keys
+          @description = description
+          @validate = validate
+        end
+
+        def validate!(key, value, settings)
+          instance_exec(key, value, settings, &@validate)
+        end
+
+        def fail!(key, value, *reasons)
+          reasons.unshift @description
+          raise InvalidOption, "Setting `#{key}` to #{value.inspect} failed:\n#{reasons.map {|r| " - #{r}" }.join("\n")}"
+        end
+
+        def set(settings, key, value, *reasons)
+          hash_key = k(key)
+          return if settings[hash_key] == value
+          reasons.unshift @description
+          Bundler.ui.info "Setting `#{key}` to #{value.inspect}, since #{reasons.join(", ")}"
+          if value.nil?
+            settings.delete(hash_key)
+          else
+            settings[hash_key] = value
+          end
+        end
+
+        def k(key)
+          Bundler.settings.key_for(key)
+        end
+      end
+
+      def self.rules
+        @rules ||= Hash.new {|h, k| h[k] = [] }
+      end
+      private_class_method :rules
+
+      def self.rule(keys, description, &blk)
+        rule = Rule.new(keys, description, &blk)
+        keys.each {|k| rules[k] << rule }
+      end
+      private_class_method :rule
+
+      def self.validate!(key, value, settings)
+        rules_to_validate = rules[key]
+        rules_to_validate.each {|rule| rule.validate!(key, value, settings) }
+      end
+
+      rule %w[path path.system], "path and path.system are mutually exclusive" do |key, value, settings|
+        if key == "path" && value
+          set(settings, "path.system", nil)
+        elsif key == "path.system" && value
+          set(settings, :path, nil)
+        end
+      end
+
+      rule %w[with without], "a group cannot be in both `with` & `without` simultaneously" do |key, value, settings|
+        with = settings.fetch(k(:with), "").split(":").map(&:to_sym)
+        without = settings.fetch(k(:without), "").split(":").map(&:to_sym)
+
+        other_key = key == "with" ? :without : :with
+        other_setting = key == "with" ? without : with
+
+        conflicting = with & without
+        if conflicting.any?
+          fail!(key, value, "`#{other_key}` is current set to #{other_setting.inspect}", "the `#{conflicting.join("`, `")}` groups conflict")
+        end
+      end
+
+      rule %w[default_cli_command], "default_cli_command must be either 'install' or 'cli_help'" do |key, value, _settings|
+        valid_values = %w[install cli_help]
+        if !value.nil? && !valid_values.include?(value.to_s)
+          fail!(key, value, "must be one of: #{valid_values.join(", ")}")
+        end
+      end
+    end
+  end
+end