rubygems-update 3.1.2 → 3.2.3

data/bundler/lib/bundler/injector.rb

@@ -74,7 +74,7 @@ module Bundler
       end
     end
 
-  private
+    private
 
     def conservative_version(spec)
       version = spec.version
@@ -179,11 +179,22 @@ module Bundler
     # @param [Pathname] gemfile_path The Gemfile from which to remove dependencies.
     def remove_gems_from_gemfile(gems, gemfile_path)
       patterns = /gem\s+(['"])#{Regexp.union(gems)}\1|gem\s*\((['"])#{Regexp.union(gems)}\2\)/
+      new_gemfile = []
+      multiline_removal = false
+      IO.readlines(gemfile_path).each do |line|
+        match_data = line.match(patterns)
+        if match_data && is_not_within_comment?(line, match_data)
+          multiline_removal = line.rstrip.end_with?(",")
+          # skip lines which match the regex
+          next
+        end
 
-      # remove lines which match the regex
-      new_gemfile = IO.readlines(gemfile_path).reject {|line| line.match(patterns) }
+        # skip followup lines until line does not end with ','
+        new_gemfile << line unless multiline_removal
+        multiline_removal = line.rstrip.end_with?(",") if multiline_removal
+      end
 
-      # remove lone \n and append them with other strings
+      # remove line \n and append them with other strings
       new_gemfile.each_with_index do |_line, index|
         if new_gemfile[index + 1] == "\n"
           new_gemfile[index] += new_gemfile[index + 1]
@@ -196,6 +207,13 @@ module Bundler
       new_gemfile.join.chomp
     end
 
+    # @param [String] line          Individual line of gemfile content.
+    # @param [MatchData] match_data Data about Regex match.
+    def is_not_within_comment?(line, match_data)
+      match_start_index = match_data.offset(0).first
+      !line[0..match_start_index].include?("#")
+    end
+
     # @param [Array] gemfile       Array of gemfile contents.
     # @param [String] block_name   Name of block name to look for.
     def remove_nested_blocks(gemfile, block_name)

data/bundler/lib/bundler/inline.rb

@@ -58,7 +58,7 @@ def gemfile(install = false, options = {}, &gemfile)
 
       Bundler.ui = install ? ui : Bundler::UI::Silent.new
       if install || definition.missing_specs?
-        Bundler.settings.temporary(:inline => true, :disable_platform_warnings => true) do
+        Bundler.settings.temporary(:inline => true) do
           installer = Bundler::Installer.install(Bundler.root, definition, :system => true)
           installer.post_install_messages.each do |name, message|
             Bundler.ui.info "Post-install message from #{name}:\n#{message}"
@@ -78,7 +78,7 @@ def gemfile(install = false, options = {}, &gemfile)
     if old_gemfile
       ENV["BUNDLE_GEMFILE"] = old_gemfile
     else
-      ENV.delete("BUNDLE_GEMFILE")
+      ENV["BUNDLE_GEMFILE"] = ""
     end
   end
 end

data/bundler/lib/bundler/installer.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "erb"
 require "rubygems/dependency_installer"
 require_relative "worker"
 require_relative "installer/parallel_installer"
@@ -135,12 +134,18 @@ module Bundler
           next
         end
 
-        File.open(binstub_path, "w", 0o777 & ~File.umask) do |f|
-          if RUBY_VERSION >= "2.6"
-            f.puts ERB.new(template, :trim_mode => "-").result(binding)
-          else
-            f.puts ERB.new(template, nil, "-").result(binding)
-          end
+        mode = Bundler::WINDOWS ? "wb:UTF-8" : "w"
+        require "erb"
+        content = if RUBY_VERSION >= "2.6"
+          ERB.new(template, :trim_mode => "-").result(binding)
+        else
+          ERB.new(template, nil, "-").result(binding)
+        end
+
+        File.write(binstub_path, content, :mode => mode, :perm => 0o777 & ~File.umask)
+        if Bundler::WINDOWS || options[:all_platforms]
+          prefix = "@ruby -x \"%~f0\" %*\n@exit /b %ERRORLEVEL%\n\n"
+          File.write("#{binstub_path}.cmd", prefix + content, :mode => mode)
         end
       end
 
@@ -159,7 +164,7 @@ module Bundler
       end
     end
 
-    def generate_standalone_bundler_executable_stubs(spec)
+    def generate_standalone_bundler_executable_stubs(spec, options = {})
       # double-assignment to avoid warnings about variables that will be used by ERB
       bin_path = Bundler.bin_path
       unless path = Bundler.settings[:path]
@@ -175,17 +180,24 @@ module Bundler
         next if executable == "bundle"
         executable_path = Pathname(spec.full_gem_path).join(spec.bindir, executable).relative_path_from(bin_path)
         executable_path = executable_path
-        File.open "#{bin_path}/#{executable}", "w", 0o755 do |f|
-          if RUBY_VERSION >= "2.6"
-            f.puts ERB.new(template, :trim_mode => "-").result(binding)
-          else
-            f.puts ERB.new(template, nil, "-").result(binding)
-          end
+
+        mode = Bundler::WINDOWS ? "wb:UTF-8" : "w"
+        require "erb"
+        content = if RUBY_VERSION >= "2.6"
+          ERB.new(template, :trim_mode => "-").result(binding)
+        else
+          ERB.new(template, nil, "-").result(binding)
+        end
+
+        File.write("#{bin_path}/#{executable}", content, :mode => mode, :perm => 0o755)
+        if Bundler::WINDOWS || options[:all_platforms]
+          prefix = "@ruby -x \"%~f0\" %*\n@exit /b %ERRORLEVEL%\n\n"
+          File.write("#{bin_path}/#{executable}.cmd", prefix + content, :mode => mode)
         end
       end
     end
 
-  private
+    private
 
     # the order that the resolver provides is significant, since
     # dependencies might affect the installation of a gem.
@@ -202,20 +214,14 @@ module Bundler
         return jobs
       end
 
-      return 1 unless can_install_in_parallel?
-
-      auto_config_jobs = Bundler.feature_flag.auto_config_jobs?
       if jobs = Bundler.settings[:jobs]
-        if auto_config_jobs
-          jobs
-        else
-          [jobs.pred, 1].max
-        end
-      elsif auto_config_jobs
-        processor_count
-      else
-        1
+        return jobs
       end
+
+      # Parallelization has some issues on Windows, so it's not yet the default
+      return 1 if Gem.win_platform?
+
+      processor_count
     end
 
     def processor_count
@@ -238,6 +244,7 @@ module Bundler
         end
       end.flatten
       Bundler.rubygems.load_plugin_files(path_plugin_files)
+      Bundler.rubygems.load_env_plugins
     end
 
     def ensure_specs_are_compatible!
@@ -274,10 +281,6 @@ module Bundler
       end
     end
 
-    def can_install_in_parallel?
-      true
-    end
-
     def install_in_parallel(size, standalone, force = false)
       spec_installations = ParallelInstaller.call(self, @definition.specs, size, standalone, force)
       spec_installations.each do |installation|
@@ -296,7 +299,7 @@ module Bundler
 
     # returns whether or not a re-resolve was needed
     def resolve_if_needed(options)
-      if !@definition.unlocking? && !options["force"] && !options["all-platforms"] && !Bundler.settings[:inline] && Bundler.default_lockfile.file?
+      if !@definition.unlocking? && !options["force"] && !Bundler.settings[:inline] && Bundler.default_lockfile.file?
         return false if @definition.nothing_changed? && !@definition.missing_specs?
       end
 

data/bundler/lib/bundler/installer/gem_installer.rb

@@ -19,15 +19,15 @@ module Bundler
       Bundler.ui.debug "#{worker}:  #{spec.name} (#{spec.version}) from #{spec.loaded_from}"
       generate_executable_stubs
       return true, post_install_message
-    rescue Bundler::InstallHookError, Bundler::SecurityError, APIResponseMismatchError
+    rescue Bundler::InstallHookError, Bundler::SecurityError, Bundler::APIResponseMismatchError
       raise
     rescue Errno::ENOSPC
       return false, out_of_space_message
-    rescue StandardError => e
+    rescue Bundler::BundlerError, Gem::InstallError, Bundler::APIResponseInvalidDependenciesError => e
       return false, specific_failure_message(e)
     end
 
-  private
+    private
 
     def specific_failure_message(e)
       message = "#{e.class}: #{e.message}\n"

data/bundler/lib/bundler/installer/parallel_installer.rb

@@ -99,7 +99,7 @@ module Bundler
         install_serially
       end
 
-      handle_error if @specs.any?(&:failed?)
+      handle_error if failed_specs.any?
       @specs
     ensure
       worker_pool && worker_pool.stop
@@ -130,7 +130,11 @@ module Bundler
       Bundler.ui.warn(warning.join("\n"))
     end
 
-  private
+    private
+
+    def failed_specs
+      @specs.select(&:failed?)
+    end
 
     def install_with_worker
       enqueue_specs
@@ -156,17 +160,13 @@ module Bundler
       gem_installer = Bundler::GemInstaller.new(
         spec_install.spec, @installer, @standalone, worker_num, @force
       )
-      success, message = begin
-        gem_installer.install_from_spec
-      rescue RuntimeError => e
-        raise e, "#{e}\n\n#{require_tree_for_spec(spec_install.spec)}"
-      end
+      success, message = gem_installer.install_from_spec
       if success
         spec_install.state = :installed
         spec_install.post_install_message = message unless message.nil?
       else
-        spec_install.state = :failed
         spec_install.error = "#{message}\n\n#{require_tree_for_spec(spec_install.spec)}"
+        spec_install.state = :failed
       end
       Plugin.hook(Plugin::Events::GEM_AFTER_INSTALL, spec_install)
       spec_install
@@ -190,11 +190,11 @@ module Bundler
     end
 
     def handle_error
-      errors = @specs.select(&:failed?).map(&:error)
+      errors = failed_specs.map(&:error)
       if exception = errors.find {|e| e.is_a?(Bundler::BundlerError) }
         raise exception
       end
-      raise Bundler::InstallError, errors.map(&:to_s).join("\n\n")
+      raise Bundler::InstallError, errors.join("\n\n")
     end
 
     def require_tree_for_spec(spec)

data/bundler/lib/bundler/installer/standalone.rb

@@ -16,12 +16,12 @@ module Bundler
         file.puts "ruby_version = RbConfig::CONFIG[\"ruby_version\"]"
         file.puts "path = File.expand_path('..', __FILE__)"
         paths.each do |path|
-          file.puts %($:.unshift "\#{path}/#{path}")
+          file.puts %($:.unshift File.expand_path("\#{path}/#{path}"))
         end
       end
     end
 
-  private
+    private
 
     def paths
       @specs.map do |spec|

data/bundler/lib/bundler/lazy_specification.rb

@@ -4,7 +4,7 @@ require_relative "match_platform"
 
 module Bundler
   class LazySpecification
-    Identifier = Struct.new(:name, :version, :source, :platform, :dependencies)
+    Identifier = Struct.new(:name, :version, :platform)
     class Identifier
       include Comparable
       def <=>(other)
@@ -12,7 +12,7 @@ module Bundler
         [name, version, platform_string] <=> [other.name, other.version, other.platform_string]
       end
 
-    protected
+      protected
 
       def platform_string
         platform_string = platform.to_s
@@ -46,6 +46,14 @@ module Bundler
       identifier == other.identifier
     end
 
+    def eql?(other)
+      identifier.eql?(other.identifier)
+    end
+
+    def hash
+      identifier.hash
+    end
+
     def satisfies?(dependency)
       @name == dependency.name && dependency.requirement.satisfied_by?(Gem::Version.new(@version))
     end
@@ -68,17 +76,20 @@ module Bundler
     end
 
     def __materialize__
-      search_object = Bundler.feature_flag.specific_platform? || Bundler.settings[:force_ruby_platform] ? self : Dependency.new(name, version)
       @specification = if source.is_a?(Source::Gemspec) && source.gemspec.name == name
         source.gemspec.tap {|s| s.source = source }
       else
-        search = source.specs.search(search_object).last
-        if search && Gem::Platform.new(search.platform) != Gem::Platform.new(platform) && !search.runtime_dependencies.-(dependencies.reject {|d| d.type == :development }).empty?
-          Bundler.ui.warn "Unable to use the platform-specific (#{search.platform}) version of #{name} (#{version}) " \
-            "because it has different dependencies from the #{platform} version. " \
-            "To use the platform-specific version of the gem, run `bundle config set specific_platform true` and install again."
-          search = source.specs.search(self).last
+        search_object = if source.is_a?(Source::Path)
+          Dependency.new(name, version)
+        else
+          ruby_platform_materializes_to_ruby_platform? ? self : Dependency.new(name, version)
         end
+        platform_object = Gem::Platform.new(platform)
+        candidates = source.specs.search(search_object)
+        same_platform_candidates = candidates.select do |spec|
+          MatchPlatform.platforms_match?(spec.platform, platform_object)
+        end
+        search = same_platform_candidates.last || candidates.last
         search.dependencies = dependencies if search && (search.is_a?(RemoteSpecification) || search.is_a?(EndpointSpecification))
         search
       end
@@ -97,7 +108,7 @@ module Bundler
     end
 
     def identifier
-      @__identifier ||= Identifier.new(name, version, source, platform, dependencies)
+      @__identifier ||= Identifier.new(name, version, platform)
     end
 
     def git_version
@@ -105,7 +116,7 @@ module Bundler
       " #{source.revision[0..6]}"
     end
 
-  private
+    private
 
     def to_ary
       nil
@@ -118,5 +129,18 @@ module Bundler
 
       @specification.send(method, *args, &blk)
     end
+
+    #
+    # For backwards compatibility with existing lockfiles, if the most specific
+    # locked platform is RUBY, we keep the previous behaviour of resolving the
+    # best platform variant at materiliazation time. For previous bundler
+    # versions (before 2.2.0) this was always the case (except when the lockfile
+    # only included non-ruby platforms), but we're also keeping this behaviour
+    # on newer bundlers unless users generate the lockfile from scratch or
+    # explicitly add a more specific platform.
+    #
+    def ruby_platform_materializes_to_ruby_platform?
+      !Bundler.most_specific_locked_platform?(Gem::Platform::RUBY)
+    end
   end
 end

data/bundler/lib/bundler/lockfile_generator.rb

@@ -25,7 +25,7 @@ module Bundler
       out
     end
 
-  private
+    private
 
     def add_sources
       definition.send(:sources).lock_sources.each_with_index do |source, idx|

data/bundler/lib/bundler/lockfile_parser.rb

@@ -109,7 +109,7 @@ module Bundler
            "bundler:#{bundler_version}#{prerelease_text}`.\n"
     end
 
-  private
+    private
 
     TYPES = {
       GIT    => Bundler::Source::Git,

data/bundler/lib/bundler/man/.document

@@ -0,0 +1 @@
+# Ignore all files in this directory

data/bundler/{man/bundle-binstubs.ronn → lib/bundler/man/bundle-binstubs.1.ronn}

@@ -37,7 +37,5 @@ Calling binstubs with [GEM [GEM]] will create binstubs for all given gems.
 * `--shebang`:
   Specify a different shebang executable name than the default (default 'ruby')
 
-## BUNDLE INSTALL --BINSTUBS
-
-To create binstubs for all the gems in the bundle you can use the `--binstubs`
-flag in [bundle install(1)](bundle-install.1.html).
+* `--all`:
+  Create binstubs for all gems in the bundle.

data/bundler/{man/bundle-config.ronn → lib/bundler/man/bundle-config.1.ronn}

@@ -11,7 +11,7 @@ This command allows you to interact with Bundler's configuration system.
 
 Bundler loads configuration settings in this order:
 
-1. Local config (`app/.bundle/config`)
+1. Local config (`<project_root>/.bundle/config` or `$BUNDLE_APP_CONFIG/config`)
 2. Environmental variables (`ENV`)
 3. Global config (`~/.bundle/config`)
 4. Bundler default config
@@ -30,8 +30,10 @@ overridden and user will be warned.
 
 Executing `bundle config set --global <name> <value>` works the same as above.
 
-Executing `bundle config set --local <name> <value>` will set that configuration to
-the local application. The configuration will be stored in `app/.bundle/config`.
+Executing `bundle config set --local <name> <value>` will set that configuration
+in the directory for the local application. The configuration will be stored in
+`<project_root>/.bundle/config`. If `BUNDLE_APP_CONFIG` is set, the configuration
+will be stored in `$BUNDLE_APP_CONFIG/config`.
 
 Executing `bundle config unset <name>` will delete the configuration in both
 local and global sources.
@@ -45,7 +47,7 @@ configuration only from the local application.
 Executing bundle with the `BUNDLE_IGNORE_CONFIG` environment variable set will
 cause it to ignore all configuration.
 
-Executing `bundle config set disable_multisource true` upgrades the warning about
+Executing `bundle config set --local disable_multisource true` upgrades the warning about
 the Gemfile containing multiple primary sources to an error. Executing `bundle
 config unset disable_multisource` downgrades this error to a warning.
 
@@ -57,7 +59,7 @@ application's configuration (normally, `./.bundle/config`).
 
 However, this will be changed in bundler 3, so it's better not to rely on this
 behavior. If these options must be remembered, it's better to set them using
-`bundle config` (e.g., `bundle config set path foo`).
+`bundle config` (e.g., `bundle config set --local path foo`).
 
 The options that can be configured are:
 
@@ -101,7 +103,7 @@ pass configuration flags to `gem install` to specify where to find the
 Since the specific location of that executable can change from machine
 to machine, you can specify these flags on a per-machine basis.
 
-    bundle config set build.mysql --with-mysql-config=/usr/local/mysql/bin/mysql_config
+    bundle config set --global build.mysql --with-mysql-config=/usr/local/mysql/bin/mysql_config
 
 After running this command, every time bundler needs to install the
 `mysql` gem, it will pass along the flags you specified.
@@ -148,7 +150,8 @@ learn more about their operation in [bundle install(1)](bundle-install.1.html).
    Install executables from gems in the bundle to the specified directory.
    Defaults to `false`.
 * `cache_all` (`BUNDLE_CACHE_ALL`):
-   Cache all gems, including path and git gems.
+   Cache all gems, including path and git gems. This needs to be explicitly
+   configured on bundler 1 and bundler 2, but will be the default on bundler 3.
 * `cache_all_platforms` (`BUNDLE_CACHE_ALL_PLATFORMS`):
    Cache gems for all platforms.
 * `cache_path` (`BUNDLE_CACHE_PATH`):
@@ -179,8 +182,6 @@ learn more about their operation in [bundle install(1)](bundle-install.1.html).
    When set, Gemfiles containing multiple sources will produce errors
    instead of warnings.
    Use `bundle config unset disable_multisource` to unset.
-* `disable_platform_warnings` (`BUNDLE_DISABLE_PLATFORM_WARNINGS`):
-   Disable warnings during bundle install when a dependency is unused on the current platform.
 * `disable_shared_gems` (`BUNDLE_DISABLE_SHARED_GEMS`):
    Stop Bundler from accessing gems installed to RubyGems' normal location.
 * `disable_version_check` (`BUNDLE_DISABLE_VERSION_CHECK`):
@@ -249,17 +250,6 @@ learn more about their operation in [bundle install(1)](bundle-install.1.html).
    be changed in the next major version.
 * `silence_root_warning` (`BUNDLE_SILENCE_ROOT_WARNING`):
    Silence the warning Bundler prints when installing gems as root.
-* `skip_default_git_sources` (`BUNDLE_SKIP_DEFAULT_GIT_SOURCES`):
-   Whether Bundler should skip adding default git source shortcuts to the
-   Gemfile DSL.
-* `specific_platform` (`BUNDLE_SPECIFIC_PLATFORM`):
-   Allow bundler to resolve for the specific running platform and store it in
-   the lockfile, instead of only using a generic platform.
-   A specific platform is the exact platform triple reported by
-   `Gem::Platform.local`, such as `x86_64-darwin-16` or `universal-java-1.8`.
-   On the other hand, generic platforms are those such as `ruby`, `mswin`, or
-   `java`. In this example, `x86_64-darwin-16` would map to `ruby` and
-   `universal-java-1.8` to `java`.
 * `ssl_ca_cert` (`BUNDLE_SSL_CA_CERT`):
    Path to a designated CA certificate file or folder containing multiple
    certificates for trusted CAs in PEM format.
@@ -302,11 +292,11 @@ Bundler also allows you to work against a git repository locally
 instead of using the remote version. This can be achieved by setting
 up a local override:
 
-    bundle config set local.GEM_NAME /path/to/local/git/repository
+    bundle config set --local local.GEM_NAME /path/to/local/git/repository
 
 For example, in order to use a local Rack repository, a developer could call:
 
-    bundle config set local.rack ~/Work/git/rack
+    bundle config set --local local.rack ~/Work/git/rack
 
 Now instead of checking out the remote git repository, the local
 override will be used. Similar to a path source, every time the local
@@ -336,21 +326,21 @@ Bundler supports overriding gem sources with mirrors. This allows you to
 configure rubygems.org as the gem source in your Gemfile while still using your
 mirror to fetch gems.
 
-    bundle config set mirror.SOURCE_URL MIRROR_URL
+    bundle config set --global mirror.SOURCE_URL MIRROR_URL
 
 For example, to use a mirror of rubygems.org hosted at rubygems-mirror.org:
 
-    bundle config set mirror.http://rubygems.org http://rubygems-mirror.org
+    bundle config set --global mirror.http://rubygems.org http://rubygems-mirror.org
 
 Each mirror also provides a fallback timeout setting. If the mirror does not
 respond within the fallback timeout, Bundler will try to use the original
 server instead of the mirror.
 
-    bundle config set mirror.SOURCE_URL.fallback_timeout TIMEOUT
+    bundle config set --global mirror.SOURCE_URL.fallback_timeout TIMEOUT
 
 For example, to fall back to rubygems.org after 3 seconds:
 
-    bundle config set mirror.https://rubygems.org.fallback_timeout 3
+    bundle config set --global mirror.https://rubygems.org.fallback_timeout 3
 
 The default fallback timeout is 0.1 seconds, but the setting can currently
 only accept whole seconds (for example, 1, 15, or 30).
@@ -360,12 +350,12 @@ only accept whole seconds (for example, 1, 15, or 30).
 Bundler allows you to configure credentials for any gem source, which allows
 you to avoid putting secrets into your Gemfile.
 
-    bundle config set SOURCE_HOSTNAME USERNAME:PASSWORD
+    bundle config set --global SOURCE_HOSTNAME USERNAME:PASSWORD
 
 For example, to save the credentials of user `claudette` for the gem source at
 `gems.longerous.com`, you would run:
 
-    bundle config set gems.longerous.com claudette:s00pers3krit
+    bundle config set --global gems.longerous.com claudette:s00pers3krit
 
 Or you can set the credentials as an environment variable like this:
 
@@ -373,7 +363,7 @@ Or you can set the credentials as an environment variable like this:
 
 For gems with a git source with HTTP(S) URL you can specify credentials like so:
 
-    bundle config set https://github.com/bundler/bundler.git username:password
+    bundle config set --global https://github.com/rubygems/rubygems.git username:password
 
 Or you can set the credentials as an environment variable like so:
 
@@ -396,4 +386,3 @@ outlines the available environment variables and their default values
     BUNDLE_USER_CACHE : $BUNDLE_USER_HOME/cache
     BUNDLE_USER_CONFIG : $BUNDLE_USER_HOME/config
     BUNDLE_USER_PLUGIN : $BUNDLE_USER_HOME/plugin
-