rubygems-update 2.6.7 → 2.6.8

data/bundler/lib/bundler/cli/gem.rb

@@ -44,7 +44,8 @@ module Bundler
         :test             => options[:test],
         :ext              => options[:ext],
         :exe              => options[:exe],
-        :bundler_version  => bundler_dependency_version
+        :bundler_version  => bundler_dependency_version,
+        :git_user_name    => git_user_name.empty? ? "[USERNAME]" : git_user_name
       }
       ensure_safe_gem_name(name, constant_array)
 
@@ -126,7 +127,7 @@ module Bundler
 
       executables.each do |file|
         path = target.join(file)
-        executable = (path.stat.mode | 0111)
+        executable = (path.stat.mode | 0o111)
         path.chmod(executable)
       end
 

data/bundler/lib/bundler/cli/inject.rb

@@ -1,33 +1,51 @@
 # frozen_string_literal: true
 module Bundler
   class CLI::Inject
-    attr_reader :options, :name, :version, :gems
+    attr_reader :options, :name, :version, :group, :source, :gems
     def initialize(options, name, version, gems)
       @options = options
       @name = name
-      @version = version
+      @version = version || last_version_number
+      @group = options[:group]
+      @source = options[:source]
       @gems = gems
     end
 
     def run
       # The required arguments allow Thor to give useful feedback when the arguments
       # are incorrect. This adds those first two arguments onto the list as a whole.
-      gems.unshift(version).unshift(name)
+      gems.unshift(source).unshift(group).unshift(version).unshift(name)
 
       # Build an array of Dependency objects out of the arguments
       deps = []
-      gems.each_slice(2) do |gem_name, gem_version|
-        deps << Bundler::Dependency.new(gem_name, gem_version)
+      gems.each_slice(4) do |gem_name, gem_version, gem_group, gem_source|
+        ops = Gem::Requirement::OPS.map {|key, _val| key }
+        has_op = ops.any? {|op| gem_version.start_with? op }
+        gem_version = "~> #{gem_version}" unless has_op
+        deps << Bundler::Dependency.new(gem_name, gem_version, "group" => gem_group, "source" => gem_source)
       end
 
-      added = Injector.inject(deps)
+      added = Injector.inject(deps, options)
 
       if added.any?
         Bundler.ui.confirm "Added to Gemfile:"
         Bundler.ui.confirm added.map {|g| "  #{g}" }.join("\n")
       else
-        Bundler.ui.confirm "All injected gems were already present in the Gemfile"
+        Bundler.ui.confirm "All gems were already present in the Gemfile"
       end
     end
+
+  private
+
+    def last_version_number
+      definition = Bundler.definition(true)
+      definition.resolve_remotely!
+      specs = definition.index[name].sort_by(&:version)
+      unless options[:pre]
+        specs.delete_if {|b| b.respond_to?(:version) && b.version.prerelease? }
+      end
+      spec = specs.last
+      spec.version.to_s
+    end
   end
 end

data/bundler/lib/bundler/cli/install.rb

@@ -11,6 +11,8 @@ module Bundler
 
       warn_if_root
 
+      warn_if_outdated
+
       [:with, :without].each do |option|
         if options[option]
           options[option] = options[option].join(":").tr(" ", ":").split(":")
@@ -53,15 +55,17 @@ module Bundler
 
       Bundler::Fetcher.disable_endpoint = options["full-index"]
 
-      # rubygems plugins sometimes hook into the gem install process
-      Gem.load_env_plugins if Gem.respond_to?(:load_env_plugins)
+      if options["binstubs"]
+        Bundler::SharedHelpers.major_deprecation \
+          "the --binstubs option will be removed in favor of `bundle binstubs`"
+      end
 
-      Plugin.gemfile_install(Bundler.default_gemfile) if Bundler.settings[:plugins]
+      Plugin.gemfile_install(Bundler.default_gemfile) if Bundler.feature_flag.plugins?
 
       definition = Bundler.definition
-      definition.validate_ruby!
+      definition.validate_runtime!
 
-      Installer.install(Bundler.root, definition, options)
+      installer = Installer.install(Bundler.root, definition, options)
       Bundler.load.cache if Bundler.app_cache.exist? && !options["no-cache"] && !Bundler.settings[:frozen]
 
       Bundler.ui.confirm "Bundle complete! #{dependencies_count_for(definition)}, #{gems_installed_for(definition)}."
@@ -69,14 +73,14 @@ module Bundler
 
       if Bundler.settings[:path]
         absolute_path = File.expand_path(Bundler.settings[:path])
-        relative_path = absolute_path.sub(File.expand_path("."), ".")
+        relative_path = absolute_path.sub(File.expand_path(".") + File::SEPARATOR, "." + File::SEPARATOR)
         Bundler.ui.confirm "Bundled gems are installed into #{relative_path}."
       else
         Bundler.ui.confirm "Use `bundle show [gemname]` to see where a bundled gem is installed."
       end
 
       unless Bundler.settings["ignore_messages"]
-        Installer.post_install_messages.to_a.each do |name, msg|
+        installer.post_install_messages.to_a.each do |name, msg|
           print_post_install_message(name, msg) unless Bundler.settings["ignore_messages.#{name}"]
         end
       end
@@ -114,6 +118,20 @@ module Bundler
         "application for all non-root users on this machine.", :wrap => true
     end
 
+    def warn_if_outdated
+      return if ENV["BUNDLE_POSTIT_TRAMPOLINING_VERSION"].nil?
+      installed_version = Gem::Version.new(ENV["BUNDLE_POSTIT_TRAMPOLINING_VERSION"].dup)
+      running_version = Gem::Version.new(Bundler::VERSION)
+      return if Gem::Requirement.new(installed_version).satisfied_by?(running_version)
+      if Bundler.settings[:warned_version].nil? || running_version > Gem::Version.new(Bundler.settings[:warned_version])
+        Bundler.settings[:warned_version] = running_version
+        Bundler.ui.warn "You're running Bundler #{installed_version} but this " \
+          "project uses #{running_version}. To update, run `bundle update " \
+          "--bundler`. You won't see this message again unless you upgrade " \
+          "to a newer version of Bundler.", :wrap => true
+      end
+    end
+
     def confirm_without_groups
       return unless Bundler.settings.without.any?
       require "bundler/cli/common"

data/bundler/lib/bundler/cli/lock.rb

@@ -1,4 +1,6 @@
 # frozen_string_literal: true
+require "bundler/cli/common"
+
 module Bundler
   class CLI::Lock
     attr_reader :options
@@ -17,20 +19,31 @@ module Bundler
       ui = Bundler.ui
       Bundler.ui = UI::Silent.new if print
 
-      gems = options[:update]
       Bundler::Fetcher.disable_endpoint = options["full-index"]
 
-      if gems && !gems.empty?
-        definition = Bundler.definition(:gems => gems)
-      else
-        definition = Bundler.definition(true)
+      update = options[:update]
+      update = { :gems => update, :lock_shared_dependencies => options[:conservative] } if update.is_a?(Array)
+      definition = Bundler.definition(update)
+
+      Bundler::CLI::Common.configure_gem_version_promoter(Bundler.definition, options) if options[:update]
+
+      options["remove-platform"].each do |platform|
+        definition.remove_platform(platform)
       end
 
-      options["add-platform"].each do |platform|
-        platform = Gem::Platform.new(platform)
+      options["add-platform"].each do |platform_string|
+        platform = Gem::Platform.new(platform_string)
+        if platform.to_a.compact == %w(unknown)
+          Bundler.ui.warn "The platform `#{platform_string}` is unknown to RubyGems " \
+            "and adding it will likely lead to resolution errors"
+        end
         definition.add_platform(platform)
       end
 
+      if definition.platforms.empty?
+        raise InvalidOption, "Removing all platforms from the bundle is not allowed"
+      end
+
       definition.resolve_remotely! unless options[:local]
 
       if print

data/bundler/lib/bundler/cli/outdated.rb

@@ -4,6 +4,7 @@ require "bundler/cli/common"
 module Bundler
   class CLI::Outdated
     attr_reader :options, :gems
+
     def initialize(options, gems)
       @options = options
       @gems = gems
@@ -18,7 +19,7 @@ module Bundler
         Bundler::CLI::Common.select_spec(gem_name)
       end
 
-      Bundler.definition.validate_ruby!
+      Bundler.definition.validate_runtime!
       current_specs = Bundler.ui.silence { Bundler.load.specs }
       current_dependencies = {}
       Bundler.ui.silence { Bundler.load.dependencies.each {|dep| current_dependencies[dep.name] = dep } }
@@ -30,7 +31,11 @@ module Bundler
         Bundler.definition(:gems => gems, :sources => sources)
       end
 
-      definition_resolution = proc { options["local"] ? definition.resolve_with_cache! : definition.resolve_remotely! }
+      Bundler::CLI::Common.configure_gem_version_promoter(Bundler.definition, options)
+      # the patch level options don't work without strict also being true
+      strict = options[:strict] || Bundler::CLI::Common.patch_level_options(options).any?
+
+      definition_resolution = proc { options[:local] ? definition.resolve_with_cache! : definition.resolve_remotely! }
       if options[:parseable]
         Bundler.ui.silence(&definition_resolution)
       else
@@ -38,8 +43,9 @@ module Bundler
       end
 
       Bundler.ui.info ""
+      outdated_gems_by_groups = {}
+      outdated_gems_list = []
 
-      out_count = 0
       # Loop through the current specs
       gemfile_specs, dependency_specs = current_specs.partition {|spec| current_dependencies.key? spec.name }
       [gemfile_specs.sort_by(&:name), dependency_specs.sort_by(&:name)].flatten.each do |current_spec|
@@ -47,7 +53,7 @@ module Bundler
 
         dependency = current_dependencies[current_spec.name]
 
-        if options["strict"]
+        if strict
           active_spec = definition.specs.detect {|spec| spec.name == current_spec.name && spec.platform == current_spec.platform }
         else
           active_specs = definition.index[current_spec.name].select {|spec| spec.platform == current_spec.platform }.sort_by(&:version)
@@ -55,11 +61,11 @@ module Bundler
             active_spec = active_specs.delete_if {|b| b.respond_to?(:version) && b.version.prerelease? }
           end
           active_spec = active_specs.last
+        end
 
-          if options[:major] || options[:minor] || options[:patch]
-            update_present = update_present_via_semver_portions(current_spec, active_spec, options)
-            active_spec = nil unless update_present
-          end
+        if options["filter-major"] || options["filter-minor"] || options["filter-patch"]
+          update_present = update_present_via_semver_portions(current_spec, active_spec, options)
+          active_spec = nil unless update_present
         end
 
         next if active_spec.nil?
@@ -67,47 +73,101 @@ module Bundler
         gem_outdated = Gem::Version.new(active_spec.version) > Gem::Version.new(current_spec.version)
         git_outdated = current_spec.git_version != active_spec.git_version
         if gem_outdated || git_outdated
-          unless options[:parseable]
-            if out_count == 0
-              if options["pre"]
-                Bundler.ui.info "Outdated gems included in the bundle (including pre-releases):"
-              else
-                Bundler.ui.info "Outdated gems included in the bundle:"
-              end
-            end
-          end
-
-          spec_version    = "#{active_spec.version}#{active_spec.git_version}"
-          current_version = "#{current_spec.version}#{current_spec.git_version}"
-          dependency_version = %(, requested #{dependency.requirement}) if dependency && dependency.specific?
-
+          groups = nil
           if dependency && !options[:parseable]
             groups = dependency.groups.join(", ")
-            pl = (dependency.groups.length > 1) ? "s" : ""
-            groups = " in group#{pl} \"#{groups}\""
           end
 
-          spec_outdated_info = "#{active_spec.name} (newest #{spec_version}, installed #{current_version}#{dependency_version})"
-          if options[:parseable]
-            Bundler.ui.info spec_outdated_info.to_s.rstrip
-          else
-            Bundler.ui.info "  * #{spec_outdated_info}#{groups}".rstrip
-          end
+          outdated_gems_list << { :active_spec => active_spec,
+                                  :current_spec => current_spec,
+                                  :dependency => dependency,
+                                  :groups => groups }
 
-          out_count += 1
+          outdated_gems_by_groups[groups] ||= []
+          outdated_gems_by_groups[groups] << { :active_spec => active_spec,
+                                               :current_spec => current_spec,
+                                               :dependency => dependency,
+                                               :groups => groups }
         end
+
         Bundler.ui.debug "from #{active_spec.loaded_from}"
       end
 
-      if out_count.zero?
-        Bundler.ui.info "Bundle up to date!\n" unless options[:parseable]
+      if outdated_gems_list.empty?
+        display_nothing_outdated_message
       else
+        unless options[:parseable]
+          if options[:pre]
+            Bundler.ui.info "Outdated gems included in the bundle (including pre-releases):"
+          else
+            Bundler.ui.info "Outdated gems included in the bundle:"
+          end
+        end
+
+        options_include_groups = [:group, :groups].select {|v| options.keys.include?(v.to_s) }
+        if options_include_groups.any?
+          ordered_groups = outdated_gems_by_groups.keys.compact.sort
+          [nil, ordered_groups].flatten.each do |groups|
+            gems = outdated_gems_by_groups[groups]
+            contains_group = if groups
+              groups.split(",").include?(options[:group])
+            else
+              options[:group] == "group"
+            end
+
+            next if (!options[:groups] && !contains_group) || gems.nil?
+
+            unless options[:parseable]
+              if groups
+                Bundler.ui.info "===== Group #{groups} ====="
+              else
+                Bundler.ui.info "===== Without group ====="
+              end
+            end
+
+            gems.each do |gem|
+              print_gem(gem[:current_spec], gem[:active_spec], gem[:dependency], groups, options_include_groups.any?)
+            end
+          end
+        else
+          outdated_gems_list.each do |gem|
+            print_gem(gem[:current_spec], gem[:active_spec], gem[:dependency], gem[:groups], options_include_groups.any?)
+          end
+        end
+
         exit 1
       end
     end
 
   private
 
+    def display_nothing_outdated_message
+      unless options[:parseable]
+        filter_options = options.keys & %w(filter-major filter-minor filter-patch)
+        if filter_options.any?
+          display = filter_options.map {|o| o.sub("filter-", "") }.join(" or ")
+          Bundler.ui.info "No #{display} updates to display.\n"
+        else
+          Bundler.ui.info "Bundle up to date!\n"
+        end
+      end
+    end
+
+    def print_gem(current_spec, active_spec, dependency, groups, options_include_groups)
+      spec_version = "#{active_spec.version}#{active_spec.git_version}"
+      current_version = "#{current_spec.version}#{current_spec.git_version}"
+      dependency_version = %(, requested #{dependency.requirement}) if dependency && dependency.specific?
+
+      spec_outdated_info = "#{active_spec.name} (newest #{spec_version}, installed #{current_version}#{dependency_version})"
+      if options[:parseable]
+        Bundler.ui.info spec_outdated_info.to_s.rstrip
+      elsif options_include_groups || !groups
+        Bundler.ui.info "  * #{spec_outdated_info}".rstrip
+      else
+        Bundler.ui.info "  * #{spec_outdated_info} in groups \"#{groups}\"".rstrip
+      end
+    end
+
     def check_for_deployment_mode
       if Bundler.settings[:frozen]
         error_message = "You are trying to check outdated gems in deployment mode. " \
@@ -123,16 +183,15 @@ module Bundler
       active_major = active_spec.version.segments.first
 
       update_present = false
+      update_present = active_major > current_major if options["filter-major"]
 
-      update_present = active_major > current_major if options[:major]
-
-      if !update_present && (options[:minor] || options[:patch]) && current_major == active_major
+      if !update_present && (options["filter-minor"] || options["filter-patch"]) && current_major == active_major
         current_minor = get_version_semver_portion_value(current_spec, 1)
         active_minor = get_version_semver_portion_value(active_spec, 1)
 
-        update_present = active_minor > current_minor if options[:minor]
+        update_present = active_minor > current_minor if options["filter-minor"]
 
-        if !update_present && options[:patch] && current_minor == active_minor
+        if !update_present && options["filter-patch"] && current_minor == active_minor
           current_patch = get_version_semver_portion_value(current_spec, 2)
           active_patch = get_version_semver_portion_value(active_spec, 2)
 

data/bundler/lib/bundler/cli/platform.rb

@@ -29,7 +29,7 @@ module Bundler
           output << "Your Gemfile specifies a Ruby version requirement:\n* #{ruby_version}"
 
           begin
-            Bundler.definition.validate_ruby!
+            Bundler.definition.validate_runtime!
             output << "Your current platform satisfies the Ruby version requirement."
           rescue RubyVersionMismatch => e
             output << e.message

data/bundler/lib/bundler/cli/show.rb

@@ -13,7 +13,7 @@ module Bundler
 
     def run
       Bundler.ui.silence do
-        Bundler.definition.validate_ruby!
+        Bundler.definition.validate_runtime!
         Bundler.load.lock
       end
 

data/bundler/lib/bundler/cli/update.rb

@@ -1,4 +1,6 @@
 # frozen_string_literal: true
+require "bundler/cli/common"
+
 module Bundler
   class CLI::Update
     attr_reader :options, :gems
@@ -10,6 +12,8 @@ module Bundler
     def run
       Bundler.ui.level = "error" if options[:quiet]
 
+      Plugin.gemfile_install(Bundler.default_gemfile) if Bundler.feature_flag.plugins?
+
       sources = Array(options[:source])
       groups  = Array(options[:group]).map(&:to_sym)
 
@@ -25,7 +29,6 @@ module Bundler
         names = Bundler.locked_gems.specs.map(&:name)
         gems.each do |g|
           next if names.include?(g)
-          require "bundler/cli/common"
           raise GemNotFound, Bundler::CLI::Common.gem_not_found_message(g, names)
         end
 
@@ -34,9 +37,12 @@ module Bundler
           gems.concat(specs.map(&:name))
         end
 
-        Bundler.definition(:gems => gems, :sources => sources, :ruby => options[:ruby])
+        Bundler.definition(:gems => gems, :sources => sources, :ruby => options[:ruby],
+                           :lock_shared_dependencies => options[:conservative])
       end
 
+      Bundler::CLI::Common.configure_gem_version_promoter(Bundler.definition, options)
+
       Bundler::Fetcher.disable_endpoint = options["full-index"]
 
       opts = options.dup
@@ -45,10 +51,7 @@ module Bundler
 
       Bundler.settings[:jobs] = opts["jobs"] if opts["jobs"]
 
-      # rubygems plugins sometimes hook into the gem install process
-      Gem.load_env_plugins if Gem.respond_to?(:load_env_plugins)
-
-      Bundler.definition.validate_ruby!
+      Bundler.definition.validate_runtime!
       Installer.install Bundler.root, Bundler.definition, opts
       Bundler.load.cache if Bundler.app_cache.exist?