bundler 1.15.2 → 2.4.12

data/lib/bundler/runtime.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-require "digest/sha1"
 
 module Bundler
   class Runtime
@@ -11,38 +10,25 @@ module Bundler
     end
 
     def setup(*groups)
-      @definition.ensure_equivalent_gemfile_and_lockfile if Bundler.settings[:frozen]
-
-      groups.map!(&:to_sym)
+      @definition.ensure_equivalent_gemfile_and_lockfile if Bundler.frozen_bundle?
 
       # Has to happen first
       clean_load_path
 
-      specs = groups.any? ? @definition.specs_for(groups) : requested_specs
+      specs = @definition.specs_for(groups)
 
       SharedHelpers.set_bundle_environment
       Bundler.rubygems.replace_entrypoints(specs)
 
       # Activate the specs
       load_paths = specs.map do |spec|
-        unless spec.loaded_from
-          raise GemNotFound, "#{spec.full_name} is missing. Run `bundle install` to get it."
-        end
-
         check_for_activated_spec!(spec)
 
         Bundler.rubygems.mark_loaded(spec)
         spec.load_paths.reject {|path| $LOAD_PATH.include?(path) }
       end.reverse.flatten
 
-      # See Gem::Specification#add_self_to_load_path (since RubyGems 1.8)
-      if insert_index = Bundler.rubygems.load_path_insert_index
-        # Gem directories must come after -I and ENV['RUBYLIB']
-        $LOAD_PATH.insert(insert_index, *load_paths)
-      else
-        # We are probably testing in core, -I and RUBYLIB don't apply
-        $LOAD_PATH.unshift(*load_paths)
-      end
+      Bundler.rubygems.add_to_load_path(load_paths)
 
       setup_manpath
 
@@ -51,14 +37,6 @@ module Bundler
       self
     end
 
-    REQUIRE_ERRORS = [
-      /^no such file to load -- (.+)$/i,
-      /^Missing \w+ (?:file\s*)?([^\s]+.rb)$/i,
-      /^Missing API definition file in (.+)$/i,
-      /^cannot load such file -- (.+)$/i,
-      /^dlopen\([^)]*\): Library not loaded: (.+)$/i,
-    ].freeze
-
     def require(*groups)
       groups.map!(&:to_sym)
       groups = [:default] if groups.empty?
@@ -80,23 +58,21 @@ module Bundler
             required_file = file
             begin
               Kernel.require file
-            rescue => e
+            rescue RuntimeError => e
               raise e if e.is_a?(LoadError) # we handle this a little later
               raise Bundler::GemRequireError.new e,
                 "There was an error while trying to load the gem '#{file}'."
             end
           end
         rescue LoadError => e
-          REQUIRE_ERRORS.find {|r| r =~ e.message }
-          raise if dep.autorequire || $1 != required_file
+          raise if dep.autorequire || e.path != required_file
 
           if dep.autorequire.nil? && dep.name.include?("-")
             begin
               namespaced_file = dep.name.tr("-", "/")
               Kernel.require namespaced_file
             rescue LoadError => e
-              REQUIRE_ERRORS.find {|r| r =~ e.message }
-              raise if $1 != namespaced_file
+              raise if e.path != namespaced_file
             end
           end
         end
@@ -124,7 +100,7 @@ module Bundler
 
     alias_method :gems, :specs
 
-    def cache(custom_path = nil)
+    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)
@@ -132,11 +108,23 @@ module Bundler
 
       Bundler.ui.info "Updating files in #{Bundler.settings.app_cache_path}"
 
-      specs_to_cache = Bundler.settings[:cache_all_platforms] ? @definition.resolve.materialized_for_all_platforms : specs
+      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"
         next if spec.source.is_a?(Source::Gemspec)
-        spec.source.send(:fetch_gem, spec) if Bundler.settings[:cache_all_platforms] && spec.source.respond_to?(:fetch_gem, true)
         spec.source.cache(spec, custom_path) if spec.source.respond_to?(:cache)
       end
 
@@ -164,6 +152,7 @@ module Bundler
       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
@@ -171,7 +160,8 @@ module Bundler
       spec_gem_executables = []
       spec_cache_paths     = []
       spec_gemspec_paths   = []
-      specs.each do |spec|
+      spec_extension_paths = []
+      Bundler.rubygems.add_default_gems_to(specs).values.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)
@@ -182,6 +172,7 @@ module Bundler
         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!
@@ -193,6 +184,7 @@ module Bundler
       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) }
@@ -205,8 +197,10 @@ module Bundler
             FileUtils.rm(file) if File.exist?(file)
           end
         end
-        stale_git_cache_dirs.each do |cache_dir|
-          SharedHelpers.filesystem_access(cache_dir) do |dir|
+
+        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
@@ -215,7 +209,7 @@ module Bundler
       output
     end
 
-  private
+    private
 
     def prune_gem_cache(resolve, cache_path)
       cached = Dir["#{cache_path}/*.gem"]
@@ -262,9 +256,6 @@ module Bundler
     end
 
     def setup_manpath
-      # Store original MANPATH for restoration later in with_clean_env()
-      ENV["BUNDLER_ORIG_MANPATH"] = ENV["MANPATH"]
-
       # Add man/ subdirectories from activated bundles to MANPATH for man(1)
       manuals = $LOAD_PATH.map do |path|
         man_subdir = path.sub(/lib$/, "man")
@@ -272,8 +263,8 @@ module Bundler
       end.compact
 
       return if manuals.empty?
-      ENV["MANPATH"] = manuals.concat(
-        ENV["MANPATH"].to_s.split(File::PATH_SEPARATOR)
+      Bundler::SharedHelpers.set_env "MANPATH", manuals.concat(
+        ENV["MANPATH"] ? ENV["MANPATH"].to_s.split(File::PATH_SEPARATOR) : [""]
       ).uniq.join(File::PATH_SEPARATOR)
     end
 
@@ -299,7 +290,7 @@ module Bundler
       return unless activated_spec = Bundler.rubygems.loaded_specs(spec.name)
       return if activated_spec.version == spec.version
 
-      suggestion = if Bundler.rubygems.spec_default_gem?(activated_spec)
+      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
@@ -309,11 +300,7 @@ module Bundler
       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
-      if e.respond_to?(:requirement=)
-        e.requirement = Gem::Requirement.new(spec.version.to_s)
-      else
-        e.version_requirement = Gem::Requirement.new(spec.version.to_s)
-      end
+      e.requirement = Gem::Requirement.new(spec.version.to_s)
       raise e
     end
   end

data/lib/bundler/self_manager.rb

@@ -0,0 +1,168 @@
+# 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
+      return unless needs_switching? && installed?
+
+      restart_with(lockfile_version)
+    end
+
+    def install_locked_bundler_and_restart_with_it_if_needed
+      return unless needs_switching?
+
+      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."
+
+      install_and_restart_with(lockfile_version)
+    end
+
+    def update_bundler_and_restart_with_it_if_needed(target)
+      return unless autoswitching_applies?
+
+      spec = resolve_update_version_from(target)
+      return unless spec
+
+      version = spec.version
+
+      Bundler.ui.info "Updating bundler to #{version}."
+
+      install(spec)
+
+      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.install(spec)
+    end
+
+    def restart_with(version)
+      configured_gem_home = ENV["GEM_HOME"]
+      configured_gem_path = ENV["GEM_PATH"]
+
+      cmd = [$PROGRAM_NAME, *ARGV]
+      cmd.unshift(Gem.ruby) unless File.executable?($PROGRAM_NAME)
+
+      Bundler.with_original_env do
+        Kernel.exec(
+          { "GEM_HOME" => configured_gem_home, "GEM_PATH" => configured_gem_path, "BUNDLER_VERSION" => version.to_s },
+          *cmd
+        )
+      end
+    end
+
+    def needs_switching?
+      autoswitching_applies? &&
+        released?(lockfile_version) &&
+        !running?(lockfile_version) &&
+        !updating?
+    end
+
+    def autoswitching_applies?
+      ENV["BUNDLER_VERSION"].nil? &&
+        Bundler.rubygems.supports_bundler_trampolining? &&
+        SharedHelpers.in_bundle? &&
+        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
+      end
+    end
+
+    def find_latest_matching_spec(requirement)
+      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 updating?
+      "update".start_with?(ARGV.first || " ") && ARGV[1..-1].any? {|a| a.start_with?("--bundler") }
+    end
+
+    def installed?
+      Bundler.configure
+
+      Bundler.rubygems.find_bundler(lockfile_version.to_s)
+    end
+
+    def current_version
+      @current_version ||= Gem::Version.new(Bundler::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
+    end
+  end
+end

data/lib/bundler/settings/validator.rb

@@ -0,0 +1,102 @@
+# 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[path], "relative paths are expanded relative to the current working directory" do |key, value, settings|
+        next if value.nil?
+
+        path = Pathname.new(value)
+        next if !path.relative? || !Bundler.feature_flag.path_relative_to_cwd?
+
+        path = path.expand_path
+
+        root = begin
+                 Bundler.root
+               rescue GemfileNotFound
+                 Pathname.pwd.expand_path
+               end
+
+        path = begin
+                 path.relative_path_from(root)
+               rescue ArgumentError
+                 path
+               end
+
+        set(settings, key, path.to_s)
+      end
+    end
+  end
+end