rubygems-update 3.3.11 → 3.3.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f9f133a10adb0dca16feb1c6dd3d12c2da126c621dcf6ac086a5434f62cdecb
-  data.tar.gz: 0b48275de222559f54a44e6cdf9c1105e40ff156d57d26d2a5a246d1fcc50521
+  metadata.gz: 9314857143aa2b095c0028db4bbc09949f82782bd34c0d893d65deb6931945af
+  data.tar.gz: a2d4832c42b5fa2849ff2d912c1b88fdbe7d0181fdddb8cf901e30c1f7930d33
 SHA512:
-  metadata.gz: ab1dc93b4c3748bc3580c8d4047ec956a52271b389fcb1c306ebecbf665670231648126aed8b84c711d7444025323a27cf665fefe801180bfeb3cc5d5a26ad25
-  data.tar.gz: 24d7c27ed7fdfff099d291b7524c377296ea4f3622c9c1880c3f2bd55b9fafcca79ee138df9d00138cc22dd5be5d5db376d6b145ec96566ccbc63dd7fd4cd507
+  metadata.gz: 6e1db6cb3a120848b7888a4f1b93289386e16354028c72edae9b3db54024a80cc53b469112ee2e9fba2aeb9bdb741e3f67d5a146eeec096b916d3f189d9fdd16
+  data.tar.gz: 9c295eacaa13320c41af660ef26d81440d07af5ceeef8a0e4ed426b6af9029a4f59897424d5e81519c6097384aa88afd4bf35cf4669784d27a1452a138da278c

data/CHANGELOG.md

@@ -1,3 +1,20 @@
+# 3.3.12 / 2022-04-20
+
+## Enhancements:
+
+* Less error swallowing when installing gems. Pull request #5475 by
+  deivid-rodriguez
+* Stop considering `RUBY_PATCHLEVEL` for resolution. Pull request #5472 by
+  deivid-rodriguez
+* Bump vendored optparse to latest master. Pull request #5466 by
+  deivid-rodriguez
+* Installs bundler 2.3.12 as a default gem.
+
+## Documentation:
+
+* Fix formatting in docs. Pull request #5470 by peterzhu2118
+* Fix a typo. Pull request #5401 by znz
+
 # 3.3.11 / 2022-04-07
 
 ## Enhancements:

data/bundler/CHANGELOG.md

@@ -1,3 +1,11 @@
+# 2.3.12 (April 20, 2022)
+
+## Enhancements:
+
+  - Improve Ruby version resolution conflicts [#5474](https://github.com/rubygems/rubygems/pull/5474)
+  - Stop considering `RUBY_PATCHLEVEL` for resolution [#5472](https://github.com/rubygems/rubygems/pull/5472)
+  - Add modern rubies as valid platform values in Gemfile DSL [#5469](https://github.com/rubygems/rubygems/pull/5469)
+
 # 2.3.11 (April 7, 2022)
 
 ## Enhancements:

data/bundler/lib/bundler/build_metadata.rb

@@ -4,8 +4,8 @@ module Bundler
   # Represents metadata from when the Bundler gem was built.
   module BuildMetadata
     # begin ivars
-    @built_at = "2022-04-07".freeze
-    @git_commit_sha = "9b6c5a801a".freeze
+    @built_at = "2022-04-20".freeze
+    @git_commit_sha = "75031e03f4".freeze
     @release = true
     # end ivars
 

data/bundler/lib/bundler/current_ruby.rb

@@ -21,6 +21,7 @@ module Bundler
       2.6
       2.7
       3.0
+      3.1
     ].freeze
 
     KNOWN_MAJOR_VERSIONS = KNOWN_MINOR_VERSIONS.map {|v| v.split(".", 2).first }.uniq.freeze

data/bundler/lib/bundler/definition.rb

@@ -732,30 +732,13 @@ module Bundler
 
     def metadata_dependencies
       @metadata_dependencies ||= begin
-        ruby_versions = ruby_version_requirements(@ruby_version)
         [
-          Dependency.new("Ruby\0", ruby_versions),
+          Dependency.new("Ruby\0", RubyVersion.system.gem_version),
           Dependency.new("RubyGems\0", Gem::VERSION),
         ]
       end
     end
 
-    def ruby_version_requirements(ruby_version)
-      return [] unless ruby_version
-      if ruby_version.patchlevel
-        [ruby_version.to_gem_version_with_patchlevel]
-      else
-        ruby_version.versions.map do |version|
-          requirement = Gem::Requirement.new(version)
-          if requirement.exact?
-            "~> #{version}.0"
-          else
-            requirement
-          end
-        end
-      end
-    end
-
     def expand_dependencies(dependencies, remote = false)
       deps = []
       dependencies.each do |dep|

data/bundler/lib/bundler/dependency.rb

@@ -20,6 +20,9 @@ module Bundler
       :ruby_24  => Gem::Platform::RUBY,
       :ruby_25  => Gem::Platform::RUBY,
       :ruby_26  => Gem::Platform::RUBY,
+      :ruby_27  => Gem::Platform::RUBY,
+      :ruby_30  => Gem::Platform::RUBY,
+      :ruby_31  => Gem::Platform::RUBY,
       :mri      => Gem::Platform::RUBY,
       :mri_18   => Gem::Platform::RUBY,
       :mri_19   => Gem::Platform::RUBY,
@@ -30,6 +33,9 @@ module Bundler
       :mri_24   => Gem::Platform::RUBY,
       :mri_25   => Gem::Platform::RUBY,
       :mri_26   => Gem::Platform::RUBY,
+      :mri_27   => Gem::Platform::RUBY,
+      :mri_30   => Gem::Platform::RUBY,
+      :mri_31   => Gem::Platform::RUBY,
       :rbx      => Gem::Platform::RUBY,
       :truffleruby => Gem::Platform::RUBY,
       :jruby    => Gem::Platform::JAVA,
@@ -45,6 +51,9 @@ module Bundler
       :mswin_24 => Gem::Platform::MSWIN,
       :mswin_25 => Gem::Platform::MSWIN,
       :mswin_26 => Gem::Platform::MSWIN,
+      :mswin_27 => Gem::Platform::MSWIN,
+      :mswin_30 => Gem::Platform::MSWIN,
+      :mswin_31 => Gem::Platform::MSWIN,
       :mswin64    => Gem::Platform::MSWIN64,
       :mswin64_19 => Gem::Platform::MSWIN64,
       :mswin64_20 => Gem::Platform::MSWIN64,
@@ -54,6 +63,9 @@ module Bundler
       :mswin64_24 => Gem::Platform::MSWIN64,
       :mswin64_25 => Gem::Platform::MSWIN64,
       :mswin64_26 => Gem::Platform::MSWIN64,
+      :mswin64_27 => Gem::Platform::MSWIN64,
+      :mswin64_30 => Gem::Platform::MSWIN64,
+      :mswin64_31 => Gem::Platform::MSWIN64,
       :mingw    => Gem::Platform::MINGW,
       :mingw_18 => Gem::Platform::MINGW,
       :mingw_19 => Gem::Platform::MINGW,
@@ -64,6 +76,9 @@ module Bundler
       :mingw_24 => Gem::Platform::MINGW,
       :mingw_25 => Gem::Platform::MINGW,
       :mingw_26 => Gem::Platform::MINGW,
+      :mingw_27 => Gem::Platform::MINGW,
+      :mingw_30 => Gem::Platform::MINGW,
+      :mingw_31 => Gem::Platform::MINGW,
       :x64_mingw    => Gem::Platform::X64_MINGW,
       :x64_mingw_20 => Gem::Platform::X64_MINGW,
       :x64_mingw_21 => Gem::Platform::X64_MINGW,
@@ -72,6 +87,9 @@ module Bundler
       :x64_mingw_24 => Gem::Platform::X64_MINGW,
       :x64_mingw_25 => Gem::Platform::X64_MINGW,
       :x64_mingw_26 => Gem::Platform::X64_MINGW,
+      :x64_mingw_27 => Gem::Platform::X64_MINGW,
+      :x64_mingw_30 => Gem::Platform::X64_MINGW,
+      :x64_mingw_31 => Gem::Platform::X64_MINGW,
     }.freeze
 
     def initialize(name, version, options = {}, &blk)

data/bundler/lib/bundler/resolver/spec_group.rb

@@ -97,10 +97,10 @@ module Bundler
         spec = @specs[platform].first
         return [] if spec.is_a?(LazySpecification)
         dependencies = []
-        if !spec.required_ruby_version.nil? && !spec.required_ruby_version.none?
+        unless spec.required_ruby_version.none?
           dependencies << DepProxy.get_proxy(Gem::Dependency.new("Ruby\0", spec.required_ruby_version), platform)
         end
-        if !spec.required_rubygems_version.nil? && !spec.required_rubygems_version.none?
+        unless spec.required_rubygems_version.none?
           dependencies << DepProxy.get_proxy(Gem::Dependency.new("RubyGems\0", spec.required_rubygems_version), platform)
         end
         dependencies

data/bundler/lib/bundler/resolver.rb

@@ -312,29 +312,66 @@ module Bundler
 
       e = Molinillo::VersionConflict.new(conflicts, e.specification_provider) unless conflicts.empty?
 
-      solver_name = "Bundler"
-      possibility_type = "gem"
       e.message_with_trees(
-        :solver_name => solver_name,
-        :possibility_type => possibility_type,
-        :reduce_trees => lambda do |trees|
+        :full_message_for_conflict => lambda do |name, conflict|
+          o = if name.end_with?("\0")
+            String.new("Bundler found conflicting requirements for the #{name} version:")
+          else
+            String.new("Bundler could not find compatible versions for gem \"#{name}\":")
+          end
+          o << %(\n)
+          if conflict.locked_requirement
+            o << %(  In snapshot (#{name_for_locking_dependency_source}):\n)
+            o << %(    #{SharedHelpers.pretty_dependency(conflict.locked_requirement)}\n)
+            o << %(\n)
+          end
+          o << %(  In #{name_for_explicit_dependency_source}:\n)
+          trees = conflict.requirement_trees
+
           # called first, because we want to reduce the amount of work required to find maximal empty sets
           trees = trees.uniq {|t| t.flatten.map {|dep| [dep.name, dep.requirement] } }
 
           # bail out if tree size is too big for Array#combination to make any sense
-          return trees if trees.size > 15
-          maximal = 1.upto(trees.size).map do |size|
-            trees.map(&:last).flatten(1).combination(size).to_a
-          end.flatten(1).select do |deps|
-            Bundler::VersionRanges.empty?(*Bundler::VersionRanges.for_many(deps.map(&:requirement)))
-          end.min_by(&:size)
-
-          trees.reject! {|t| !maximal.include?(t.last) } if maximal
-
-          trees.sort_by {|t| t.reverse.map(&:name) }
-        end,
-        :printable_requirement => lambda {|req| SharedHelpers.pretty_dependency(req) },
-        :additional_message_for_conflict => lambda do |o, name, conflict|
+          if trees.size <= 15
+            maximal = 1.upto(trees.size).map do |size|
+              trees.map(&:last).flatten(1).combination(size).to_a
+            end.flatten(1).select do |deps|
+              Bundler::VersionRanges.empty?(*Bundler::VersionRanges.for_many(deps.map(&:requirement)))
+            end.min_by(&:size)
+
+            trees.reject! {|t| !maximal.include?(t.last) } if maximal
+
+            trees.sort_by! {|t| t.reverse.map(&:name) }
+          end
+
+          metadata_requirements = {}
+
+          o << trees.map do |tree|
+            t = "".dup
+            depth = 2
+
+            base_tree = tree.first
+            base_tree_name = base_tree.name
+
+            if base_tree_name.end_with?("\0")
+              metadata_requirements[base_tree_name] = base_tree
+              t = nil
+            else
+              tree.each do |req|
+                t << "  " * depth << SharedHelpers.pretty_dependency(req)
+                unless tree.last == req
+                  if spec = conflict.activated_by_name[req.name]
+                    t << %( was resolved to #{spec.version}, which)
+                  end
+                  t << %( depends on)
+                end
+                t << %(\n)
+                depth += 1
+              end
+            end
+            t
+          end.compact.join("\n")
+
           if name == "bundler"
             o << %(\n  Current Bundler version:\n    bundler (#{Bundler::VERSION}))
 
@@ -355,11 +392,13 @@ module Bundler
                 o << "Your bundle requires a different version of Bundler than the one you're running, and that version could not be found.\n"
               end
             end
+          elsif name.end_with?("\0")
+            o << %(\n  Current #{name} version:\n    #{SharedHelpers.pretty_dependency(metadata_requirements[name])}\n\n)
           elsif conflict.locked_requirement
             o << "\n"
             o << %(Running `bundle update` will rebuild your snapshot from scratch, using only\n)
             o << %(the gems in your Gemfile, which may resolve the conflict.\n)
-          elsif !conflict.existing && !name.end_with?("\0")
+          elsif !conflict.existing
             o << "\n"
 
             relevant_source = conflict.requirement.source || source_for(name)
@@ -372,14 +411,8 @@ module Bundler
 
             o << gem_not_found_message(name, conflict.requirement, relevant_source, extra_message)
           end
-        end,
-        :version_for_spec => lambda {|spec| spec.version },
-        :incompatible_version_message_for_conflict => lambda do |name, _conflict|
-          if name.end_with?("\0")
-            %(#{solver_name} found conflicting requirements for the #{name} version:)
-          else
-            %(#{solver_name} could not find compatible versions for #{possibility_type} "#{name}":)
-          end
+
+          o
         end
       )
     end

data/bundler/lib/bundler/ruby_version.rb

@@ -110,19 +110,6 @@ module Bundler
       @ruby_version ||= RubyVersion.new(ruby_version, patchlevel, ruby_engine, ruby_engine_version)
     end
 
-    def to_gem_version_with_patchlevel
-      @gem_version_with_patch ||= begin
-        Gem::Version.create("#{@gem_version}.#{@patchlevel}")
-      rescue ArgumentError
-        @gem_version
-      end
-    end
-
-    def exact?
-      return @exact if defined?(@exact)
-      @exact = versions.all? {|v| Gem::Requirement.create(v).exact? }
-    end
-
     private
 
     def matches?(requirements, version)

data/bundler/lib/bundler/rubygems_ext.rb

@@ -67,6 +67,23 @@ module Gem
       full_gem_path
     end
 
+    unless const_defined?(:LATEST_RUBY_WITHOUT_PATCH_VERSIONS)
+      LATEST_RUBY_WITHOUT_PATCH_VERSIONS = Gem::Version.new("2.1")
+
+      alias_method :rg_required_ruby_version=, :required_ruby_version=
+      def required_ruby_version=(req)
+        self.rg_required_ruby_version = req
+
+        @required_ruby_version.requirements.map! do |op, v|
+          if v >= LATEST_RUBY_WITHOUT_PATCH_VERSIONS && v.release.segments.size == 4
+            [op == "~>" ? "=" : op, Gem::Version.new(v.segments.tap {|s| s.delete_at(3) }.join("."))]
+          else
+            [op, v]
+          end
+        end
+      end
+    end
+
     def groups
       @groups ||= []
     end

data/bundler/lib/bundler/source/metadata.rb

@@ -5,7 +5,7 @@ module Bundler
     class Metadata < Source
       def specs
         @specs ||= Index.build do |idx|
-          idx << Gem::Specification.new("Ruby\0", RubyVersion.system.to_gem_version_with_patchlevel)
+          idx << Gem::Specification.new("Ruby\0", RubyVersion.system.gem_version)
           idx << Gem::Specification.new("RubyGems\0", Gem::VERSION) do |s|
             s.required_rubygems_version = Gem::Requirement.default
           end

data/bundler/lib/bundler/vendor/molinillo/lib/molinillo/dependency_graph.rb

@@ -32,7 +32,7 @@ module Bundler::Molinillo
     #   all belong to the same graph.
     # @return [Array<Vertex>] The sorted vertices.
     def self.tsort(vertices)
-      TSort.tsort(
+      Bundler::TSort.tsort(
         lambda { |b| vertices.each(&b) },
         lambda { |v, &b| (v.successors & vertices).each(&b) }
       )

data/bundler/lib/bundler/vendor/molinillo/lib/molinillo/errors.rb

@@ -107,36 +107,42 @@ module Bundler::Molinillo
         end
       end
 
-      conflicts.sort.reduce(''.dup) do |o, (name, conflict)|
-        o << "\n" << incompatible_version_message_for_conflict.call(name, conflict) << "\n"
-        if conflict.locked_requirement
-          o << %(  In snapshot (#{name_for_locking_dependency_source}):\n)
-          o << %(    #{printable_requirement.call(conflict.locked_requirement)}\n)
-          o << %(\n)
-        end
-        o << %(  In #{name_for_explicit_dependency_source}:\n)
-        trees = reduce_trees.call(conflict.requirement_trees)
-
-        o << trees.map do |tree|
-          t = ''.dup
-          depth = 2
-          tree.each do |req|
-            t << '  ' * depth << printable_requirement.call(req)
-            unless tree.last == req
-              if spec = conflict.activated_by_name[name_for(req)]
-                t << %( was resolved to #{version_for_spec.call(spec)}, which)
+      full_message_for_conflict = opts.delete(:full_message_for_conflict) do
+        proc do |name, conflict|
+          o = "\n".dup << incompatible_version_message_for_conflict.call(name, conflict) << "\n"
+          if conflict.locked_requirement
+            o << %(  In snapshot (#{name_for_locking_dependency_source}):\n)
+            o << %(    #{printable_requirement.call(conflict.locked_requirement)}\n)
+            o << %(\n)
+          end
+          o << %(  In #{name_for_explicit_dependency_source}:\n)
+          trees = reduce_trees.call(conflict.requirement_trees)
+
+          o << trees.map do |tree|
+            t = ''.dup
+            depth = 2
+            tree.each do |req|
+              t << '  ' * depth << printable_requirement.call(req)
+              unless tree.last == req
+                if spec = conflict.activated_by_name[name_for(req)]
+                  t << %( was resolved to #{version_for_spec.call(spec)}, which)
+                end
+                t << %( depends on)
               end
-              t << %( depends on)
+              t << %(\n)
+              depth += 1
             end
-            t << %(\n)
-            depth += 1
-          end
-          t
-        end.join("\n")
+            t
+          end.join("\n")
 
-        additional_message_for_conflict.call(o, name, conflict)
+          additional_message_for_conflict.call(o, name, conflict)
 
-        o
+          o
+        end
+      end
+
+      conflicts.sort.reduce(''.dup) do |o, (name, conflict)|
+        o << full_message_for_conflict.call(name, conflict)
       end.strip
     end
   end

data/bundler/lib/bundler/vendor/molinillo/lib/molinillo/gem_metadata.rb

@@ -2,5 +2,5 @@
 
 module Bundler::Molinillo
   # The version of Bundler::Molinillo.
-  VERSION = '0.7.0'.freeze
+  VERSION = '0.8.0'.freeze
 end