bundler 1.13.6 → 1.17.3

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

data/lib/bundler/setup.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-require "bundler/postit_trampoline" unless ENV["BUNDLE_DISABLE_POSTIT"]
+
 require "bundler/shared_helpers"
 
 if Bundler::SharedHelpers.in_bundle?
@@ -20,12 +20,9 @@ if Bundler::SharedHelpers.in_bundle?
     Bundler.setup
   end
 
-  unless ENV["BUNDLE_POSTIT_TRAMPOLINING_VERSION"]
-    # Add bundler to the load path after disabling system gems
-    # This is guarenteed to be done already if we've trampolined
-    bundler_lib = File.expand_path("../..", __FILE__)
-    $LOAD_PATH.unshift(bundler_lib) unless $LOAD_PATH.include?(bundler_lib)
-  end
+  # Add bundler to the load path after disabling system gems
+  bundler_lib = File.expand_path("../..", __FILE__)
+  $LOAD_PATH.unshift(bundler_lib) unless $LOAD_PATH.include?(bundler_lib)
 
   Bundler.ui = nil
 end

data/lib/bundler/shared_helpers.rb

@@ -1,13 +1,18 @@
 # frozen_string_literal: true
+
+require "bundler/compatibility_guard"
+
 require "pathname"
 require "rubygems"
 
+require "bundler/version"
 require "bundler/constants"
 require "bundler/rubygems_integration"
 require "bundler/current_ruby"
 
 module Gem
   class Dependency
+    # This is only needed for RubyGems < 1.4
     unless method_defined? :requirement
       def requirement
         version_requirements
@@ -18,12 +23,16 @@ end
 
 module Bundler
   module SharedHelpers
-    attr_accessor :gem_loaded
+    def root
+      gemfile = find_gemfile
+      raise GemfileNotFound, "Could not locate Gemfile" unless gemfile
+      Pathname.new(gemfile).untaint.expand_path.parent
+    end
 
     def default_gemfile
-      gemfile = find_gemfile
+      gemfile = find_gemfile(:order_matters)
       raise GemfileNotFound, "Could not locate Gemfile" unless gemfile
-      Pathname.new(gemfile).untaint
+      Pathname.new(gemfile).untaint.expand_path
     end
 
     def default_lockfile
@@ -39,10 +48,12 @@ module Bundler
       bundle_dir = find_directory(".bundle")
       return nil unless bundle_dir
 
-      global_bundle_dir = File.join(Bundler.rubygems.user_home, ".bundle")
+      bundle_dir = Pathname.new(bundle_dir)
+
+      global_bundle_dir = Bundler.user_home.join(".bundle")
       return nil if bundle_dir == global_bundle_dir
 
-      Pathname.new(bundle_dir)
+      bundle_dir
     end
 
     def in_bundle?
@@ -62,7 +73,7 @@ module Bundler
     end
 
     def with_clean_git_env(&block)
-      keys    = %w(GIT_DIR GIT_WORK_TREE)
+      keys    = %w[GIT_DIR GIT_WORK_TREE]
       old_env = keys.inject({}) do |h, k|
         h.update(k => ENV[k])
       end
@@ -101,16 +112,24 @@ module Bundler
     #   end
     #
     # @see {Bundler::PermissionError}
-    def filesystem_access(path, action = :write)
-      yield path.dup.untaint
+    def filesystem_access(path, action = :write, &block)
+      # Use block.call instead of yield because of a bug in Ruby 2.2.2
+      # See https://github.com/bundler/bundler/issues/5341 for details
+      block.call(path.dup.untaint)
     rescue Errno::EACCES
       raise PermissionError.new(path, action)
     rescue Errno::EAGAIN
       raise TemporaryResourceError.new(path, action)
     rescue Errno::EPROTO
       raise VirtualProtocolError.new
+    rescue Errno::ENOSPC
+      raise NoSpaceOnDeviceError.new(path, action)
     rescue *[const_get_safely(:ENOTSUP, Errno)].compact
       raise OperationNotSupportedError.new(path, action)
+    rescue Errno::EEXIST, Errno::ENOENT
+      raise
+    rescue SystemCallError => e
+      raise GenericSystemCallError.new(e, "There was an error accessing `#{path}`.")
     end
 
     def const_get_safely(constant_name, namespace)
@@ -120,28 +139,120 @@ module Bundler
       namespace.const_get(constant_name)
     end
 
-    def major_deprecation(message)
+    def major_deprecation(major_version, message)
+      if Bundler.bundler_major_version >= major_version
+        require "bundler/errors"
+        raise DeprecatedError, "[REMOVED FROM #{major_version}.0] #{message}"
+      end
+
       return unless prints_major_deprecations?
       @major_deprecation_ui ||= Bundler::UI::Shell.new("no-color" => true)
       ui = Bundler.ui.is_a?(@major_deprecation_ui.class) ? Bundler.ui : @major_deprecation_ui
-      ui.warn("[DEPRECATED FOR #{Bundler::VERSION.split(".").first.to_i + 1}.0] #{message}")
+      ui.warn("[DEPRECATED FOR #{major_version}.0] #{message}")
     end
 
     def print_major_deprecations!
-      deprecate_gemfile(find_gemfile) if find_gemfile == find_file("Gemfile")
+      multiple_gemfiles = search_up(".") do |dir|
+        gemfiles = gemfile_names.select {|gf| File.file? File.expand_path(gf, dir) }
+        next if gemfiles.empty?
+        break false if gemfiles.size == 1
+      end
+      if multiple_gemfiles && Bundler.bundler_major_version == 1
+        Bundler::SharedHelpers.major_deprecation 2, \
+          "gems.rb and gems.locked will be preferred to Gemfile and Gemfile.lock."
+      end
+
       if RUBY_VERSION < "2"
-        major_deprecation("Bundler will only support ruby >= 2.0, you are running #{RUBY_VERSION}")
+        major_deprecation(2, "Bundler will only support ruby >= 2.0, you are running #{RUBY_VERSION}")
       end
       return if Bundler.rubygems.provides?(">= 2")
-      major_deprecation("Bundler will only support rubygems >= 2.0, you are running #{Bundler.rubygems.version}")
+      major_deprecation(2, "Bundler will only support rubygems >= 2.0, you are running #{Bundler.rubygems.version}")
+    end
+
+    def trap(signal, override = false, &block)
+      prior = Signal.trap(signal) do
+        block.call
+        prior.call unless override
+      end
+    end
+
+    def ensure_same_dependencies(spec, old_deps, new_deps)
+      new_deps = new_deps.reject {|d| d.type == :development }
+      old_deps = old_deps.reject {|d| d.type == :development }
+
+      without_type = proc {|d| Gem::Dependency.new(d.name, d.requirements_list.sort) }
+      new_deps.map!(&without_type)
+      old_deps.map!(&without_type)
+
+      extra_deps = new_deps - old_deps
+      return if extra_deps.empty?
+
+      Bundler.ui.debug "#{spec.full_name} from #{spec.remote} has either corrupted API or lockfile dependencies" \
+        " (was expecting #{old_deps.map(&:to_s)}, but the real spec has #{new_deps.map(&:to_s)})"
+      raise APIResponseMismatchError,
+        "Downloading #{spec.full_name} revealed dependencies not in the API or the lockfile (#{extra_deps.join(", ")})." \
+        "\nEither installing with `--full-index` or running `bundle update #{spec.name}` should fix the problem."
+    end
+
+    def pretty_dependency(dep, print_source = false)
+      msg = String.new(dep.name)
+      msg << " (#{dep.requirement})" unless dep.requirement == Gem::Requirement.default
+
+      if dep.is_a?(Bundler::Dependency)
+        platform_string = dep.platforms.join(", ")
+        msg << " " << platform_string if !platform_string.empty? && platform_string != Gem::Platform::RUBY
+      end
+
+      msg << " from the `#{dep.source}` source" if print_source && dep.source
+      msg
+    end
+
+    def md5_available?
+      return @md5_available if defined?(@md5_available)
+      @md5_available = begin
+        require "openssl"
+        OpenSSL::Digest::MD5.digest("")
+        true
+      rescue LoadError
+        true
+      rescue OpenSSL::Digest::DigestError
+        false
+      end
+    end
+
+    def digest(name)
+      require "digest"
+      Digest(name)
+    end
+
+    def write_to_gemfile(gemfile_path, contents)
+      filesystem_access(gemfile_path) {|g| File.open(g, "w") {|file| file.puts contents } }
     end
 
   private
 
-    def find_gemfile
+    def validate_bundle_path
+      path_separator = Bundler.rubygems.path_separator
+      return unless Bundler.bundle_path.to_s.split(path_separator).size > 1
+      message = "Your bundle path contains text matching #{path_separator.inspect}, " \
+                "which is the path separator for your system. Bundler cannot " \
+                "function correctly when the Bundle path contains the " \
+                "system's PATH separator. Please change your " \
+                "bundle path to not match #{path_separator.inspect}." \
+                "\nYour current bundle path is '#{Bundler.bundle_path}'."
+      raise Bundler::PathError, message
+    end
+
+    def find_gemfile(order_matters = false)
       given = ENV["BUNDLE_GEMFILE"]
       return given if given && !given.empty?
-      find_file("Gemfile", "gems.rb")
+      names = gemfile_names
+      names.reverse! if order_matters && Bundler.feature_flag.prefer_gems_rb?
+      find_file(*names)
+    end
+
+    def gemfile_names
+      ["Gemfile", "gems.rb"]
     end
 
     def find_file(*names)
@@ -163,7 +274,15 @@ module Bundler
       until !File.directory?(current) || current == previous
         if ENV["BUNDLE_SPEC_RUN"]
           # avoid stepping above the tmp directory when testing
-          return nil if File.file?(File.join(current, "bundler.gemspec"))
+          gemspec = if ENV["BUNDLE_RUBY"] && ENV["BUNDLE_GEM"]
+            # for Ruby Core
+            "lib/bundler.gemspec"
+          else
+            "bundler.gemspec"
+          end
+
+          # avoid stepping above the tmp directory when testing
+          return nil if File.file?(File.join(current, gemspec))
         end
 
         names.each do |name|
@@ -175,67 +294,91 @@ module Bundler
       end
     end
 
+    def set_env(key, value)
+      raise ArgumentError, "new key #{key}" unless EnvironmentPreserver::BUNDLER_KEYS.include?(key)
+      orig_key = "#{EnvironmentPreserver::BUNDLER_PREFIX}#{key}"
+      orig = ENV[key]
+      orig ||= EnvironmentPreserver::INTENTIONALLY_NIL
+      ENV[orig_key] ||= orig
+
+      ENV[key] = value
+    end
+    public :set_env
+
     def set_bundle_variables
       begin
-        ENV["BUNDLE_BIN_PATH"] = Bundler.rubygems.bin_path("bundler", "bundle", VERSION)
+        exe_file = Bundler.rubygems.bin_path("bundler", "bundle", VERSION)
+        unless File.exist?(exe_file)
+          exe_file = File.expand_path("../../../exe/bundle", __FILE__)
+        end
+        Bundler::SharedHelpers.set_env "BUNDLE_BIN_PATH", exe_file
       rescue Gem::GemNotFoundException
-        ENV["BUNDLE_BIN_PATH"] = File.expand_path("../../../exe/bundle", __FILE__)
+        exe_file = File.expand_path("../../../exe/bundle", __FILE__)
+        # for Ruby core repository
+        exe_file = File.expand_path("../../../../bin/bundle", __FILE__) unless File.exist?(exe_file)
+        Bundler::SharedHelpers.set_env "BUNDLE_BIN_PATH", exe_file
       end
 
       # Set BUNDLE_GEMFILE
-      ENV["BUNDLE_GEMFILE"] = find_gemfile.to_s
-      ENV["BUNDLER_VERSION"] = Bundler::VERSION
+      Bundler::SharedHelpers.set_env "BUNDLE_GEMFILE", find_gemfile(:order_matters).to_s
+      Bundler::SharedHelpers.set_env "BUNDLER_VERSION", Bundler::VERSION
     end
 
     def set_path
+      validate_bundle_path
       paths = (ENV["PATH"] || "").split(File::PATH_SEPARATOR)
       paths.unshift "#{Bundler.bundle_path}/bin"
-      ENV["PATH"] = paths.uniq.join(File::PATH_SEPARATOR)
+      Bundler::SharedHelpers.set_env "PATH", paths.uniq.join(File::PATH_SEPARATOR)
     end
 
     def set_rubyopt
       rubyopt = [ENV["RUBYOPT"]].compact
       return if !rubyopt.empty? && rubyopt.first =~ %r{-rbundler/setup}
       rubyopt.unshift %(-rbundler/setup)
-      ENV["RUBYOPT"] = rubyopt.join(" ")
+      Bundler::SharedHelpers.set_env "RUBYOPT", rubyopt.join(" ")
     end
 
     def set_rubylib
       rubylib = (ENV["RUBYLIB"] || "").split(File::PATH_SEPARATOR)
-      rubylib.unshift File.expand_path("../..", __FILE__)
-      ENV["RUBYLIB"] = rubylib.uniq.join(File::PATH_SEPARATOR)
+      rubylib.unshift bundler_ruby_lib
+      Bundler::SharedHelpers.set_env "RUBYLIB", rubylib.uniq.join(File::PATH_SEPARATOR)
+    end
+
+    def bundler_ruby_lib
+      resolve_path File.expand_path("../..", __FILE__)
     end
 
     def clean_load_path
       # handle 1.9 where system gems are always on the load path
-      if defined?(::Gem)
-        me = File.expand_path("../../", __FILE__)
-        me = /^#{Regexp.escape(me)}/
+      return unless defined?(::Gem)
 
-        loaded_gem_paths = Bundler.rubygems.loaded_gem_paths
+      bundler_lib = bundler_ruby_lib
 
-        $LOAD_PATH.reject! do |p|
-          next if File.expand_path(p) =~ me
-          loaded_gem_paths.delete(p)
-        end
-        $LOAD_PATH.uniq!
+      loaded_gem_paths = Bundler.rubygems.loaded_gem_paths
+
+      $LOAD_PATH.reject! do |p|
+        next if resolve_path(p).start_with?(bundler_lib)
+        loaded_gem_paths.delete(p)
       end
+      $LOAD_PATH.uniq!
+    end
+
+    def resolve_path(path)
+      expanded = File.expand_path(path)
+      return expanded unless File.respond_to?(:realpath) && File.exist?(expanded)
+
+      File.realpath(expanded)
     end
 
     def prints_major_deprecations?
       require "bundler"
-      return false unless Bundler.settings[:major_deprecations]
+      deprecation_release = Bundler::VERSION.split(".").drop(1).include?("99")
+      return false if !deprecation_release && !Bundler.settings[:major_deprecations]
       require "bundler/deprecate"
       return false if Bundler::Deprecate.skip
       true
     end
 
-    def deprecate_gemfile(gemfile)
-      return unless gemfile && File.basename(gemfile) == "Gemfile"
-      Bundler::SharedHelpers.major_deprecation \
-        "gems.rb and gems.locked will be prefered to Gemfile and Gemfile.lock."
-    end
-
     extend self
   end
 end