rubygems-update 3.4.10 → 3.5.22

data/bundler/lib/bundler/man/gemfile.5.ronn

@@ -69,6 +69,16 @@ should be the Ruby version that the engine is compatible with.
 
     ruby "3.1.2"
 
+If you wish to derive your Ruby version from a version file (ie .ruby-version),
+you can use the `file` option instead.
+
+    ruby file: ".ruby-version"
+
+The version file should conform to any of the following formats:
+
+  - `3.1.2` (.ruby-version)
+  - `ruby 3.1.2` (.tool-versions, read: https://asdf-vm.com/manage/configuration.html#tool-versions)
+
 ### ENGINE
 
 Each application _may_ specify a Ruby engine. If an engine is specified, an
@@ -86,7 +96,7 @@ What exactly is an Engine?
 
   - [Other implementations](https://www.ruby-lang.org/en/about/) of Ruby exist.
     Some of the more well-known implementations include
-    [JRuby](http://jruby.org/) and [TruffleRuby](https://www.graalvm.org/ruby/).
+    [JRuby](https://www.jruby.org/) and [TruffleRuby](https://www.graalvm.org/ruby/).
     Rubinius is an alternative implementation of Ruby written in Ruby.
     JRuby is an implementation of Ruby on the JVM, short for Java Virtual Machine.
     TruffleRuby is a Ruby implementation on the GraalVM, a language toolkit built on the JVM.
@@ -228,6 +238,16 @@ All operations involving groups ([`bundle install`](bundle-install.1.html), `Bun
 `Bundler.require`) behave exactly the same as if any groups not
 matching the current platform were explicitly excluded.
 
+The following platform values are deprecated and should be replaced with `windows`:
+
+  * `mswin`, `mswin64`, `mingw32`, `x64_mingw`
+
+Note that, while unfortunately using the same terminology, the values of this
+option are different from the values that `bundle lock --add-platform` can take.
+The values of this option are more closer to "Ruby Implementation" while the
+values that `bundle lock --add-platform` understands are more related to OS and
+architecture of the different systems where your lockfile will be used.
+
 ### FORCE_RUBY_PLATFORM
 
 If you always want the pure ruby variant of a gem to be chosen over platform
@@ -495,7 +515,7 @@ software is installed or some other conditions are met.
 
 ## GEMSPEC
 
-The [`.gemspec`](http://guides.rubygems.org/specification-reference/) file is where
+The [`.gemspec`](https://guides.rubygems.org/specification-reference/) file is where
  you provide metadata about your gem to Rubygems. Some required Gemspec
  attributes include the name, description, and homepage of your gem. This is
  also where you specify the dependencies your gem needs to run.
@@ -514,7 +534,7 @@ paths.
 
 The `gemspec` method supports optional `:path`, `:glob`, `:name`, and `:development_group`
 options, which control where bundler looks for the `.gemspec`, the glob it uses to look
-for the gemspec (defaults to: "{,*,*/*}.gemspec"), what named `.gemspec` it uses
+for the gemspec (defaults to: `{,*,*/*}.gemspec`), what named `.gemspec` it uses
 (if more than one is present), and which group development dependencies are included in.
 
 When a `gemspec` dependency encounters version conflicts during resolution, the

data/bundler/lib/bundler/match_metadata.rb

@@ -2,6 +2,10 @@
 
 module Bundler
   module MatchMetadata
+    def matches_current_metadata?
+      matches_current_ruby? && matches_current_rubygems?
+    end
+
     def matches_current_ruby?
       @required_ruby_version.satisfied_by?(Gem.ruby_version)
     end

data/bundler/lib/bundler/match_platform.rb

@@ -12,7 +12,7 @@ module Bundler
 
     def self.platforms_match?(gemspec_platform, local_platform)
       return true if gemspec_platform.nil?
-      return true if Gem::Platform::RUBY == gemspec_platform
+      return true if gemspec_platform == Gem::Platform::RUBY
       return true if local_platform == gemspec_platform
       gemspec_platform = Gem::Platform.new(gemspec_platform)
       return true if gemspec_platform === local_platform

data/bundler/lib/bundler/mirror.rb

@@ -47,7 +47,7 @@ module Bundler
 
       def fetch_valid_mirror_for(uri)
         downcased = uri.to_s.downcase
-        mirror = @mirrors[downcased] || @mirrors[Bundler::URI(downcased).host] || Mirror.new(uri)
+        mirror = @mirrors[downcased] || @mirrors[Gem::URI(downcased).host] || Mirror.new(uri)
         mirror.validate!(@prober)
         mirror = Mirror.new(uri) unless mirror.valid?
         mirror
@@ -74,7 +74,7 @@ module Bundler
         @uri = if uri.nil?
           nil
         else
-          Bundler::URI(uri.to_s)
+          Gem::URI(uri.to_s)
         end
         @valid = nil
       end
@@ -126,7 +126,7 @@ module Bundler
         if uri == "all"
           @all = true
         else
-          @uri = Bundler::URI(uri).absolute? ? Settings.normalize_uri(uri) : uri
+          @uri = Gem::URI(uri).absolute? ? Settings.normalize_uri(uri) : uri
         end
         @value = value
       end

data/bundler/lib/bundler/plugin/api/source.rb

@@ -39,7 +39,7 @@ module Bundler
       #     is present to be compatible with `Definition` and is used by
       #     rubygems source.
       module Source
-        attr_reader :uri, :options, :name
+        attr_reader :uri, :options, :name, :checksum_store
         attr_accessor :dependency_names
 
         def initialize(opts)
@@ -48,6 +48,7 @@ module Bundler
           @uri = opts["uri"]
           @type = opts["type"]
           @name = opts["name"] || "#{@type} at #{@uri}"
+          @checksum_store = Checksum::Store.new
         end
 
         # This is used by the default `spec` method to constructs the
@@ -95,7 +96,7 @@ module Bundler
         #
         # Note: Do not override if you don't know what you are doing.
         def post_install(spec, disable_exts = false)
-          opts = { :env_shebang => false, :disable_extensions => disable_exts }
+          opts = { env_shebang: false, disable_extensions: disable_exts }
           installer = Bundler::Source::Path::Installer.new(spec, opts)
           installer.post_install
         end
@@ -106,7 +107,7 @@ module Bundler
         def install_path
           @install_path ||=
             begin
-              base_name = File.basename(Bundler::URI.parse(uri).normalize.path)
+              base_name = File.basename(Gem::URI.parse(uri).normalize.path)
 
               gem_install_dir.join("#{base_name}-#{uri_hash[0..11]}")
             end
@@ -130,7 +131,7 @@ module Bundler
           Bundler::Index.build do |index|
             files.each do |file|
               next unless spec = Bundler.load_gemspec(file)
-              Bundler.rubygems.set_installed_by_version(spec)
+              spec.installed_by_version = Gem::VERSION
 
               spec.source = self
               Bundler.rubygems.validate(spec)
@@ -175,7 +176,7 @@ module Bundler
         #
         # This is used by `app_cache_path`
         def app_cache_dirname
-          base_name = File.basename(Bundler::URI.parse(uri).normalize.path)
+          base_name = File.basename(Gem::URI.parse(uri).normalize.path)
           "#{base_name}-#{uri_hash}"
         end
 
@@ -195,6 +196,7 @@ module Bundler
 
           FileUtils.rm_rf(new_cache_path)
           FileUtils.cp_r(install_path, new_cache_path)
+          FileUtils.rm_rf(app_cache_path.join(".git"))
           FileUtils.touch(app_cache_path.join(".bundlecache"))
         end
 

data/bundler/lib/bundler/plugin/index.rb

@@ -136,6 +136,14 @@ module Bundler
         @hooks[event] || []
       end
 
+      # This plugin is installed inside the .bundle/plugin directory,
+      # and thus is managed solely by Bundler
+      def installed_in_plugin_root?(name)
+        return false unless (path = installed?(name))
+
+        path.start_with?("#{Plugin.root}/")
+      end
+
       private
 
       # Reads the index file from the directory and initializes the instance
@@ -146,7 +154,7 @@ module Bundler
       # @param [Boolean] is the index file global index
       def load_index(index_file, global = false)
         SharedHelpers.filesystem_access(index_file, :read) do |index_f|
-          valid_file = index_f && index_f.exist? && !index_f.size.zero?
+          valid_file = index_f&.exist? && !index_f.size.zero?
           break unless valid_file
 
           data = index_f.read

data/bundler/lib/bundler/plugin/installer/path.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Bundler
+  module Plugin
+    class Installer
+      class Path < Bundler::Source::Path
+        def root
+          SharedHelpers.in_bundle? ? Bundler.root : Plugin.root
+        end
+
+        def generate_bin(spec, disable_extensions = false)
+          # Need to find a way without code duplication
+          # For now, we can ignore this
+        end
+      end
+    end
+  end
+end

data/bundler/lib/bundler/plugin/installer.rb

@@ -10,6 +10,7 @@ module Bundler
     class Installer
       autoload :Rubygems, File.expand_path("installer/rubygems", __dir__)
       autoload :Git,      File.expand_path("installer/git", __dir__)
+      autoload :Path, File.expand_path("installer/path", __dir__)
 
       def install(names, options)
         check_sources_consistency!(options)
@@ -18,8 +19,8 @@ module Bundler
 
         if options[:git]
           install_git(names, version, options)
-        elsif options[:local_git]
-          install_local_git(names, version, options)
+        elsif options[:path]
+          install_path(names, version, options[:path])
         else
           sources = options[:source] || Gem.sources
           install_rubygems(names, version, sources)
@@ -45,20 +46,40 @@ module Bundler
         if options.key?(:git) && options.key?(:local_git)
           raise InvalidOption, "Remote and local plugin git sources can't be both specified"
         end
+
+        # back-compat; local_git is an alias for git
+        if options.key?(:local_git)
+          Bundler::SharedHelpers.major_deprecation(2, "--local_git is deprecated, use --git")
+          options[:git] = options.delete(:local_git)
+        end
+
+        if (options.keys & [:source, :git, :path]).length > 1
+          raise InvalidOption, "Only one of --source, --git, or --path may be specified"
+        end
+
+        if (options.key?(:branch) || options.key?(:ref)) && !options.key?(:git)
+          raise InvalidOption, "--#{options.key?(:branch) ? "branch" : "ref"} can only be used with git sources"
+        end
+
+        if options.key?(:branch) && options.key?(:ref)
+          raise InvalidOption, "--branch and --ref can't be both specified"
+        end
       end
 
       def install_git(names, version, options)
-        uri = options.delete(:git)
-        options["uri"] = uri
+        source_list = SourceList.new
+        source = source_list.add_git_source({ "uri" => options[:git],
+                                              "branch" => options[:branch],
+                                              "ref" => options[:ref] })
 
-        install_all_sources(names, version, options, options[:source])
+        install_all_sources(names, version, source_list, source)
       end
 
-      def install_local_git(names, version, options)
-        uri = options.delete(:local_git)
-        options["uri"] = uri
+      def install_path(names, version, path)
+        source_list = SourceList.new
+        source = source_list.add_path_source({ "path" => path, "root_path" => SharedHelpers.pwd })
 
-        install_all_sources(names, version, options, options[:source])
+        install_all_sources(names, version, source_list, source)
       end
 
       # Installs the plugin from rubygems source and returns the path where the
@@ -70,20 +91,19 @@ module Bundler
       #
       # @return [Hash] map of names to the specs of plugins installed
       def install_rubygems(names, version, sources)
-        install_all_sources(names, version, nil, sources)
-      end
-
-      def install_all_sources(names, version, git_source_options, rubygems_source)
         source_list = SourceList.new
 
-        source_list.add_git_source(git_source_options) if git_source_options
-        Array(rubygems_source).each {|remote| source_list.add_global_rubygems_remote(remote) } if rubygems_source
+        Array(sources).each {|remote| source_list.add_global_rubygems_remote(remote) }
+
+        install_all_sources(names, version, source_list)
+      end
 
-        deps = names.map {|name| Dependency.new name, version }
+      def install_all_sources(names, version, source_list, source = nil)
+        deps = names.map {|name| Dependency.new(name, version, { "source" => source }) }
 
         Bundler.configure_gem_home_and_path(Plugin.root)
 
-        Bundler.settings.temporary(:deployment => false, :frozen => false) do
+        Bundler.settings.temporary(deployment: false, frozen: false) do
           definition = Definition.new(nil, deps, source_list, true)
 
           install_definition(definition)

data/bundler/lib/bundler/plugin/source_list.rb

@@ -9,6 +9,10 @@ module Bundler
         add_source_to_list Plugin::Installer::Git.new(options), git_sources
       end
 
+      def add_path_source(options = {})
+        add_source_to_list Plugin::Installer::Path.new(options), path_sources
+      end
+
       def add_rubygems_source(options = {})
         add_source_to_list Plugin::Installer::Rubygems.new(options), @rubygems_sources
       end
@@ -17,10 +21,6 @@ module Bundler
         path_sources + git_sources + rubygems_sources + [metadata_source]
       end
 
-      def default_source
-        git_sources.first || global_rubygems_source
-      end
-
       private
 
       def rubygems_aggregate_class

data/bundler/lib/bundler/plugin.rb

@@ -62,7 +62,8 @@ module Bundler
       if names.any?
         names.each do |name|
           if index.installed?(name)
-            Bundler.rm_rf(index.plugin_path(name))
+            path = index.plugin_path(name).to_s
+            Bundler.rm_rf(path) if index.installed_in_plugin_root?(name)
             index.unregister_plugin(name)
             Bundler.ui.info "Uninstalled plugin #{name}"
           else
@@ -100,7 +101,7 @@ module Bundler
     # @param [Pathname] gemfile path
     # @param [Proc] block that can be evaluated for (inline) Gemfile
     def gemfile_install(gemfile = nil, &inline)
-      Bundler.settings.temporary(:frozen => false, :deployment => false) do
+      Bundler.settings.temporary(frozen: false, deployment: false) do
         builder = DSL.new
         if block_given?
           builder.instance_eval(&inline)
@@ -197,7 +198,7 @@ module Bundler
     # @param [Hash] The options that are present in the lock file
     # @return [API::Source] the instance of the class that handles the source
     #                       type passed in locked_opts
-    def source_from_lock(locked_opts)
+    def from_lock(locked_opts)
       src = source(locked_opts["type"])
 
       src.new(locked_opts.merge("uri" => locked_opts["remote"]))
@@ -227,7 +228,7 @@ module Bundler
       plugins = index.hook_plugins(event)
       return unless plugins.any?
 
-      (plugins - @loaded_plugin_names).each {|name| load_plugin(name) }
+      plugins.each {|name| load_plugin(name) }
 
       @hooks_by_event[event].each {|blk| blk.call(*args, &arg_blk) }
     end
@@ -239,6 +240,11 @@ module Bundler
       Index.new.installed?(plugin)
     end
 
+    # @return [true, false] whether the plugin is loaded
+    def loaded?(plugin)
+      @loaded_plugin_names.include?(plugin)
+    end
+
     # Post installation processing and registering with index
     #
     # @param [Array<String>] plugins list to be installed
@@ -301,7 +307,7 @@ module Bundler
       @hooks_by_event = Hash.new {|h, k| h[k] = [] }
 
       load_paths = spec.load_paths
-      Bundler.rubygems.add_to_load_path(load_paths)
+      Gem.add_to_load_path(*load_paths)
       path = Pathname.new spec.full_gem_path
 
       begin
@@ -329,13 +335,14 @@ module Bundler
     # @param [String] name of the plugin
     def load_plugin(name)
       return unless name && !name.empty?
+      return if loaded?(name)
 
       # Need to ensure before this that plugin root where the rest of gems
       # are installed to be on load path to support plugin deps. Currently not
       # done to avoid conflicts
       path = index.plugin_path(name)
 
-      Bundler.rubygems.add_to_load_path(index.load_paths(name))
+      Gem.add_to_load_path(*index.load_paths(name))
 
       load path.join(PLUGIN_FILE_NAME)
 

data/bundler/lib/bundler/remote_specification.rb

@@ -88,6 +88,10 @@ module Bundler
       end
     end
 
+    def runtime_dependencies
+      dependencies.select(&:runtime?)
+    end
+
     def git_version
       return unless loaded_from && source.is_a?(Bundler::Source::Git)
       " #{source.revision[0..6]}"

data/bundler/lib/bundler/resolver/base.rb

@@ -24,20 +24,22 @@ module Bundler
 
           name = dep.name
 
-          @packages[name] = Package.new(name, dep_platforms, **options.merge(:dependency => dep))
+          @packages[name] = Package.new(name, dep_platforms, **options.merge(dependency: dep))
 
           dep
         end.compact
       end
 
+      def specs_compatible_with(result)
+        @base.specs_compatible_with(result)
+      end
+
       def [](name)
         @base[name]
       end
 
       def delete(specs)
-        specs.each do |spec|
-          @base.delete(spec)
-        end
+        @base.delete(specs)
       end
 
       def get_package(name)
@@ -70,6 +72,12 @@ module Bundler
         end
       end
 
+      def include_remote_specs(names)
+        names.each do |name|
+          get_package(name).consider_remote_versions!
+        end
+      end
+
       private
 
       def indirect_pins(names)

data/bundler/lib/bundler/resolver/candidate.rb

@@ -15,7 +15,7 @@ module Bundler
     # considered separately.
     #
     # Some candidates may also keep some information explicitly about the
-    # package the refer to. These candidates are referred to as "canonical" and
+    # package they refer to. These candidates are referred to as "canonical" and
     # are used when materializing resolution results back into RubyGems
     # specifications that can be installed, written to lock files, and so on.
     #
@@ -24,10 +24,10 @@ module Bundler
 
       attr_reader :version
 
-      def initialize(version, specs: [])
-        @spec_group = Resolver::SpecGroup.new(specs)
+      def initialize(version, group: nil, priority: -1)
+        @spec_group = group || SpecGroup.new([])
         @version = Gem::Version.new(version)
-        @ruby_only = specs.map(&:platform).uniq == [Gem::Platform::RUBY]
+        @priority = priority
       end
 
       def dependencies
@@ -40,18 +40,6 @@ module Bundler
         @spec_group.to_specs(package.force_ruby_platform?)
       end
 
-      def generic!
-        @ruby_only = true
-
-        self
-      end
-
-      def platform_specific!
-        @ruby_only = false
-
-        self
-      end
-
       def prerelease?
         @version.prerelease?
       end
@@ -61,7 +49,7 @@ module Bundler
       end
 
       def sort_obj
-        [@version, @ruby_only ? -1 : 1]
+        [@version, @priority]
       end
 
       def <=>(other)

data/bundler/lib/bundler/resolver/incompatibility.rb

@@ -8,7 +8,7 @@ module Bundler
       def initialize(terms, cause:, custom_explanation: nil, extended_explanation: nil)
         @extended_explanation = extended_explanation
 
-        super(terms, :cause => cause, :custom_explanation => custom_explanation)
+        super(terms, cause: cause, custom_explanation: custom_explanation)
       end
     end
   end

data/bundler/lib/bundler/resolver/package.rb

@@ -15,13 +15,19 @@ module Bundler
     class Package
       attr_reader :name, :platforms, :dependency, :locked_version
 
-      def initialize(name, platforms, locked_specs:, unlock:, prerelease: false, dependency: nil)
+      def initialize(name, platforms, locked_specs:, unlock:, prerelease: false, prefer_local: false, dependency: nil)
         @name = name
         @platforms = platforms
         @locked_version = locked_specs[name].first&.version
         @unlock = unlock
         @dependency = dependency || Dependency.new(name, @locked_version)
+        @top_level = !dependency.nil?
         @prerelease = @dependency.prerelease? || @locked_version&.prerelease? || prerelease ? :consider_first : :ignore
+        @prefer_local = prefer_local
+      end
+
+      def platform_specs(specs)
+        platforms.map {|platform| GemHelpers.select_best_platform_match(specs, platform, prefer_locked: !unlock?) }
       end
 
       def to_s
@@ -32,6 +38,10 @@ module Bundler
         false
       end
 
+      def top_level?
+        @top_level
+      end
+
       def meta?
         @name.end_with?("\0")
       end
@@ -60,6 +70,14 @@ module Bundler
         @prerelease = :consider_last
       end
 
+      def prefer_local?
+        @prefer_local
+      end
+
+      def consider_remote_versions!
+        @prefer_local = false
+      end
+
       def force_ruby_platform?
         @dependency.force_ruby_platform
       end

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

@@ -3,6 +3,8 @@
 module Bundler
   class Resolver
     class SpecGroup
+      attr_reader :specs
+
       def initialize(specs)
         @specs = specs
       end
@@ -25,9 +27,8 @@ module Bundler
 
       def to_specs(force_ruby_platform)
         @specs.map do |s|
-          lazy_spec = LazySpecification.new(name, version, s.platform, source)
+          lazy_spec = LazySpecification.from_spec(s)
           lazy_spec.force_ruby_platform = force_ruby_platform
-          lazy_spec.dependencies.replace s.dependencies
           lazy_spec
         end
       end
@@ -39,17 +40,33 @@ module Bundler
       def dependencies
         @dependencies ||= @specs.map do |spec|
           __dependencies(spec) + metadata_dependencies(spec)
-        end.flatten.uniq
+        end.flatten.uniq.sort
+      end
+
+      def ==(other)
+        sorted_spec_names == other.sorted_spec_names
+      end
+
+      def merge(other)
+        return false unless equivalent?(other)
+
+        @specs |= other.specs
+
+        true
       end
 
       protected
 
       def sorted_spec_names
-        @sorted_spec_names ||= @specs.map(&:full_name).sort
+        @specs.map(&:full_name).sort
       end
 
       private
 
+      def equivalent?(other)
+        name == other.name && version == other.version && source == other.source && dependencies == other.dependencies
+      end
+
       def exemplary_spec
         @specs.first
       end
@@ -64,8 +81,6 @@ module Bundler
       end
 
       def metadata_dependencies(spec)
-        return [] if spec.is_a?(LazySpecification)
-
         [
           metadata_dependency("Ruby", spec.required_ruby_version),
           metadata_dependency("RubyGems", spec.required_rubygems_version),