Fix bundler improperly resolving archful gems in Gemfile.lock.

For more information see:
https://github.com/sclorg/s2i-ruby-container/issues/469

Upstream backport requested in
https://bugs.ruby-lang.org/issues/19576

Resolves: rhbz#2178171

ruby-1.9.3-mkmf-verbose.patch

@@ -1,25 +0,0 @@
-From 28cc0749d6729aa2444661ee7b411e183fe220b0 Mon Sep 17 00:00:00 2001
-From: =?UTF-8?q?V=C3=ADt=20Ondruch?= <vondruch@redhat.com>
-Date: Mon, 19 Nov 2012 15:14:51 +0100
-Subject: [PATCH] Verbose mkmf.
-
----
- lib/mkmf.rb | 2 +-
- 1 file changed, 1 insertion(+), 1 deletion(-)
-
-diff --git a/lib/mkmf.rb b/lib/mkmf.rb
-index 682eb46..e6b1445 100644
---- a/lib/mkmf.rb
-+++ b/lib/mkmf.rb
-@@ -1974,7 +1974,7 @@ def configuration(srcdir)
- SHELL = /bin/sh
- 
- # V=0 quiet, V=1 verbose.  other values don't work.
--V = 0
-+V = 1
- V0 = $(V:0=)
- Q1 = $(V:1=)
- Q = $(Q1:0=@)
--- 
-1.8.3.1
-

ruby-2.1.0-Enable-configuration-of-archlibdir.patch

@@ -11,7 +11,7 @@ diff --git a/configure.ac b/configure.ac
 index d261ea57b5..3c13076b82 100644
 --- a/configure.ac
 +++ b/configure.ac
-@@ -3368,6 +3368,11 @@ AS_IF([test ${multiarch+set}], [
+@@ -3381,6 +3381,11 @@ AS_IF([test ${multiarch+set}], [
  ])
  
  archlibdir='${libdir}/${arch}'

ruby-2.1.0-Prevent-duplicated-paths-when-empty-version-string-i.patch

@@ -14,7 +14,7 @@ diff --git a/configure.ac b/configure.ac
 index c42436c23d..d261ea57b5 100644
 --- a/configure.ac
 +++ b/configure.ac
-@@ -4026,7 +4026,8 @@ AS_CASE(["$ruby_version_dir_name"],
+@@ -4039,7 +4039,8 @@ AS_CASE(["$ruby_version_dir_name"],
  ruby_version_dir=/'${ruby_version_dir_name}'
  
  if test -z "${ruby_version_dir_name}"; then

ruby-2.1.0-always-use-i386.patch

@@ -11,7 +11,7 @@ diff --git a/configure.ac b/configure.ac
 index 3c13076b82..93af30321d 100644
 --- a/configure.ac
 +++ b/configure.ac
-@@ -4090,6 +4090,8 @@ AC_SUBST(vendorarchdir)dnl
+@@ -4103,6 +4103,8 @@ AC_SUBST(vendorarchdir)dnl
  AC_SUBST(CONFIGURE, "`echo $0 | sed 's|.*/||'`")dnl
  AC_SUBST(configure_args, "`echo "${ac_configure_args}" | sed 's/\\$/$$/g'`")dnl
  

ruby-2.1.0-custom-rubygems-location.patch

@@ -15,7 +15,7 @@ diff --git a/configure.ac b/configure.ac
 index 93af30321d..bc13397e0e 100644
 --- a/configure.ac
 +++ b/configure.ac
-@@ -4062,6 +4062,10 @@ AC_ARG_WITH(vendorarchdir,
+@@ -4075,6 +4075,10 @@ AC_ARG_WITH(vendorarchdir,
              [vendorarchdir=$withval],
              [vendorarchdir=${multiarch+'${rubysitearchprefix}/vendor_ruby'${ruby_version_dir}}${multiarch-'${vendorlibdir}/${sitearch}'}])
  
@@ -26,7 +26,7 @@ index 93af30321d..bc13397e0e 100644
  AS_IF([test "${LOAD_RELATIVE+set}"], [
      AC_DEFINE_UNQUOTED(LOAD_RELATIVE, $LOAD_RELATIVE)
      RUBY_EXEC_PREFIX=''
-@@ -4086,6 +4090,7 @@ AC_SUBST(sitearchdir)dnl
+@@ -4099,6 +4104,7 @@ AC_SUBST(sitearchdir)dnl
  AC_SUBST(vendordir)dnl
  AC_SUBST(vendorlibdir)dnl
  AC_SUBST(vendorarchdir)dnl

ruby-2.3.0-ruby_version.patch

@@ -20,7 +20,7 @@ diff --git a/configure.ac b/configure.ac
 index 80b137e380..63cd3b4f8b 100644
 --- a/configure.ac
 +++ b/configure.ac
-@@ -3977,9 +3977,6 @@ AS_CASE(["$target_os"],
+@@ -3990,9 +3990,6 @@ AS_CASE(["$target_os"],
      rubyw_install_name='$(RUBYW_INSTALL_NAME)'
      ])
  
@@ -30,7 +30,7 @@ index 80b137e380..63cd3b4f8b 100644
  rubyarchprefix=${multiarch+'${archlibdir}/${RUBY_BASE_NAME}'}${multiarch-'${rubylibprefix}/${arch}'}
  AC_ARG_WITH(rubyarchprefix,
  	    AS_HELP_STRING([--with-rubyarchprefix=DIR],
-@@ -4002,56 +3999,62 @@ AC_ARG_WITH(ridir,
+@@ -4015,56 +4015,62 @@ AC_ARG_WITH(ridir,
  AC_SUBST(ridir)
  AC_SUBST(RI_BASE_NAME)
  
@@ -120,7 +120,7 @@ index 80b137e380..63cd3b4f8b 100644
  
  AS_IF([test "${LOAD_RELATIVE+set}"], [
      AC_DEFINE_UNQUOTED(LOAD_RELATIVE, $LOAD_RELATIVE)
-@@ -4068,6 +4071,7 @@ AC_SUBST(sitearchincludedir)dnl
+@@ -4081,6 +4081,7 @@ AC_SUBST(sitearchincludedir)dnl
  AC_SUBST(arch)dnl
  AC_SUBST(sitearch)dnl
  AC_SUBST(ruby_version)dnl
@@ -202,8 +202,8 @@ index d4ff4a262c..3f9a5bf590 100644
    # specified in the environment
  
    def self.default_dir
--    @default_dir ||= File.join(RbConfig::CONFIG['rubylibprefix'], 'gems', RbConfig::CONFIG['ruby_version'])
-+    @default_dir ||= File.join(RbConfig::CONFIG['rubylibprefix'], 'gems', RbConfig::CONFIG['ruby_version_dir_name'] || RbConfig::CONFIG['ruby_version'])
+-    @default_dir ||= File.join(RbConfig::CONFIG["rubylibprefix"], "gems", RbConfig::CONFIG["ruby_version"])
++    @default_dir ||= File.join(RbConfig::CONFIG["rubylibprefix"], "gems", RbConfig::CONFIG["ruby_version_dir_name"] || RbConfig::CONFIG["ruby_version"])
    end
  
    ##
@@ -211,18 +211,18 @@ index d4ff4a262c..3f9a5bf590 100644
      gem_dir = File.join(Gem.user_home, ".gem")
      gem_dir = File.join(Gem.data_home, "gem") unless File.exist?(gem_dir)
      parts = [gem_dir, ruby_engine]
--    parts << RbConfig::CONFIG['ruby_version'] unless RbConfig::CONFIG['ruby_version'].empty?
-+    ruby_version_dir_name = RbConfig::CONFIG['ruby_version_dir_name'] || RbConfig::CONFIG['ruby_version']
+-    parts << RbConfig::CONFIG["ruby_version"] unless RbConfig::CONFIG["ruby_version"].empty?
++    ruby_version_dir_name = RbConfig::CONFIG["ruby_version_dir_name"] || RbConfig::CONFIG["ruby_version"]
 +    parts << ruby_version_dir_name unless ruby_version_dir_name.empty?
      File.join parts
    end
  
 @@ -234,7 +235,7 @@ def self.vendor_dir # :nodoc:
-     return nil unless RbConfig::CONFIG.key? 'vendordir'
+     return nil unless RbConfig::CONFIG.key? "vendordir"
  
-     File.join RbConfig::CONFIG['vendordir'], 'gems',
--              RbConfig::CONFIG['ruby_version']
-+              RbConfig::CONFIG['ruby_version_dir_name'] || RbConfig::CONFIG['ruby_version']
+     File.join RbConfig::CONFIG["vendordir"], "gems",
+-              RbConfig::CONFIG["ruby_version"]
++              RbConfig::CONFIG["ruby_version_dir_name"] || RbConfig::CONFIG["ruby_version"]
    end
  
    ##
@@ -230,22 +230,22 @@ diff --git a/test/rubygems/test_gem.rb b/test/rubygems/test_gem.rb
 index b25068405d..e9fef4a311 100644
 --- a/test/rubygems/test_gem.rb
 +++ b/test/rubygems/test_gem.rb
-@@ -1410,7 +1410,8 @@ def test_self_use_paths
+@@ -1395,7 +1395,8 @@ def test_self_use_paths
  
    def test_self_user_dir
-     parts = [@userhome, '.gem', Gem.ruby_engine]
--    parts << RbConfig::CONFIG['ruby_version'] unless RbConfig::CONFIG['ruby_version'].empty?
-+    ruby_version_dir_name = RbConfig::CONFIG['ruby_version_dir_name'] || RbConfig::CONFIG['ruby_version']
+     parts = [@userhome, ".gem", Gem.ruby_engine]
+-    parts << RbConfig::CONFIG["ruby_version"] unless RbConfig::CONFIG["ruby_version"].empty?
++    ruby_version_dir_name = RbConfig::CONFIG["ruby_version_dir_name"] || RbConfig::CONFIG["ruby_version"]
 +    parts << ruby_version_dir_name unless ruby_version_dir_name.empty?
  
      FileUtils.mkdir_p File.join(parts)
  
-@@ -1486,7 +1487,7 @@ def test_self_vendor_dir
-     vendordir(File.join(@tempdir, 'vendor')) do
+@@ -1471,7 +1472,7 @@ def test_self_vendor_dir
+     vendordir(File.join(@tempdir, "vendor")) do
        expected =
-         File.join RbConfig::CONFIG['vendordir'], 'gems',
--                  RbConfig::CONFIG['ruby_version']
-+                  RbConfig::CONFIG['ruby_version_dir_name'] || RbConfig::CONFIG['ruby_version']
+         File.join RbConfig::CONFIG["vendordir"], "gems",
+-                  RbConfig::CONFIG["ruby_version"]
++                  RbConfig::CONFIG["ruby_version_dir_name"] || RbConfig::CONFIG["ruby_version"]
  
        assert_equal expected, Gem.vendor_dir
      end
@@ -267,7 +267,7 @@ diff --git a/configure.ac b/configure.ac
 index a00f2b6776..999e2d6d5d 100644
 --- a/configure.ac
 +++ b/configure.ac
-@@ -108,7 +108,7 @@ RUBY_BASE_NAME=`echo ruby | sed "$program_transform_name"`
+@@ -115,7 +115,7 @@ RUBY_BASE_NAME=`echo ruby | sed "$program_transform_name"`
  RUBYW_BASE_NAME=`echo rubyw | sed "$program_transform_name"`
  AC_SUBST(RUBY_BASE_NAME)
  AC_SUBST(RUBYW_BASE_NAME)

ruby-2.7.0-Initialize-ABRT-hook.patch

@@ -45,7 +45,7 @@ index b2e5b2b6d0..f39f81da5c 100644
 +++ b/common.mk
 @@ -82,7 +82,8 @@ ENC_MK        = enc.mk
  MAKE_ENC      = -f $(ENC_MK) V="$(V)" UNICODE_HDR_DIR="$(UNICODE_HDR_DIR)" \
- 		RUBY="$(MINIRUBY)" MINIRUBY="$(MINIRUBY)" $(mflags)
+ 		RUBY="$(BOOTSTRAPRUBY)" MINIRUBY="$(BOOTSTRAPRUBY)" $(mflags)
  
 -COMMONOBJS    = array.$(OBJEXT) \
 +COMMONOBJS    = abrt.$(OBJEXT) \
@@ -57,7 +57,7 @@ diff --git a/ruby.c b/ruby.c
 index 60c57d6259..1eec16f2c8 100644
 --- a/ruby.c
 +++ b/ruby.c
-@@ -1611,10 +1611,14 @@ proc_options(long argc, char **argv, ruby_cmdline_options_t *opt, int envopt)
+@@ -1623,10 +1623,14 @@ proc_options(long argc, char **argv, ruby_cmdline_options_t *opt, int envopt)
  
  void Init_builtin_features(void);
  

ruby-3.1.4-Skip-test_compaction_bug_19529-if-compaction-unsupported.patch

@@ -0,0 +1,23 @@
+From bffadcd6d46ccfccade79ce0efb60ced8eac4483 Mon Sep 17 00:00:00 2001
+From: Peter Zhu <peter@peterzhu.ca>
+Date: Thu, 6 Apr 2023 13:35:25 -0400
+Subject: [PATCH] Add guard to compaction test in WeakMap
+
+Some platforms don't support compaction, so we should skip this test.
+---
+ test/ruby/test_weakmap.rb | 2 ++
+ 1 file changed, 2 insertions(+)
+
+diff --git a/test/ruby/test_weakmap.rb b/test/ruby/test_weakmap.rb
+index c72e7310db101..7fc956dfae474 100644
+--- a/test/ruby/test_weakmap.rb
++++ b/test/ruby/test_weakmap.rb
+@@ -178,6 +178,8 @@ def test_no_memory_leak
+   end
+ 
+   def test_compaction_bug_19529
++    omit "compaction is not supported on this platform" unless GC.respond_to?(:compact)
++
+     obj = Object.new
+     100.times do |i|
+       GC.compact

ruby-3.2.0-Build-extension-libraries-in-bundled-gems.patch

@@ -1,338 +0,0 @@
-From 111f8422427d78becc9183ae149b2105a16bf327 Mon Sep 17 00:00:00 2001
-From: Nobuyoshi Nakada <nobu@ruby-lang.org>
-Date: Tue, 5 Apr 2022 23:24:00 +0900
-Subject: [PATCH 1/5] Bundled gems are expanded under `.bundle/gems` now
-
----
- ext/extmk.rb          | 13 +++++++------
- template/exts.mk.tmpl |  2 +-
- 2 files changed, 8 insertions(+), 7 deletions(-)
-
-diff --git a/ext/extmk.rb b/ext/extmk.rb
-index 4a087f294ac9..1da9e2704521 100755
---- a/ext/extmk.rb
-+++ b/ext/extmk.rb
-@@ -146,7 +146,7 @@ def extmake(target, basedir = 'ext', maybestatic = true)
-     top_srcdir = $top_srcdir
-     topdir = $topdir
-     hdrdir = $hdrdir
--    prefix = "../" * (target.count("/")+1)
-+    prefix = "../" * (basedir.count("/")+target.count("/")+1)
-     $top_srcdir = relative_from(top_srcdir, prefix)
-     $hdrdir = relative_from(hdrdir, prefix)
-     $topdir = prefix + $topdir
-@@ -460,10 +460,11 @@ def $mflags.defined?(var)
- end unless $extstatic
- 
- @gemname = nil
--if ARGV[0]
--  ext_prefix, exts = ARGV.shift.split('/', 2)
-+if exts = ARGV.shift
-+  ext_prefix = exts[%r[\A(?>\.bundle/)?[^/]+(?:/(?=(.+)?)|\z)]]
-+  exts = $1
-   $extension = [exts] if exts
--  if ext_prefix == 'gems'
-+  if ext_prefix.start_with?('.')
-     @gemname = exts
-   elsif exts
-     $static_ext.delete_if {|t, *| !File.fnmatch(t, exts)}
-@@ -515,7 +516,7 @@ def $mflags.defined?(var)
-     exts.delete_if {|d| File.fnmatch?("-*", d)}
-   end
- end
--ext_prefix = File.basename(ext_prefix)
-+ext_prefix = ext_prefix[$top_srcdir.size+1..-2]
- 
- extend Module.new {
-   def timestamp_file(name, target_prefix = nil)
-@@ -634,7 +635,7 @@ def initialize(src)
-   end
- }
- 
--Dir.chdir ".."
-+Dir.chdir dir
- unless $destdir.to_s.empty?
-   $mflags.defined?("DESTDIR") or $mflags << "DESTDIR=#{$destdir}"
- end
-diff --git a/template/exts.mk.tmpl b/template/exts.mk.tmpl
-index 2f37f4480ac5..964939e365a1 100644
---- a/template/exts.mk.tmpl
-+++ b/template/exts.mk.tmpl
-@@ -25,7 +25,7 @@ macros["old_extensions"] = []
- 
- contpat = /(?>(?>[^\\\n]|\\.)*\\\n)*(?>[^\\\n]|\\.)*/
- Dir.glob("{ext,.bundle/gems}/*/exts.mk") do |e|
--  gem = /\Agems(?=\/)/ =~ e
-+  gem = e.start_with?(".bundle/gems/")
-   s = File.read(e)
-   s.scan(/^(extensions|SUBMAKEOPTS|EXT[A-Z]+|MFLAGS|NOTE_[A-Z]+)[ \t]*=[ \t]*(#{contpat})$/o) do |n, v|
-     v.gsub!(/\\\n[ \t]*/, ' ')
-
-From 6ea34cac22131d28a9cc50e7875e854aed9bdb88 Mon Sep 17 00:00:00 2001
-From: Nobuyoshi Nakada <nobu@ruby-lang.org>
-Date: Wed, 6 Apr 2022 20:25:53 +0900
-Subject: [PATCH 2/5] Retrieve configured gems info
-
----
- template/configure-ext.mk.tmpl | 2 +-
- template/exts.mk.tmpl          | 4 ++--
- 2 files changed, 3 insertions(+), 3 deletions(-)
-
-diff --git a/template/configure-ext.mk.tmpl b/template/configure-ext.mk.tmpl
-index 6636a7759c54..8ba6b963e3ec 100644
---- a/template/configure-ext.mk.tmpl
-+++ b/template/configure-ext.mk.tmpl
-@@ -27,7 +27,7 @@ SCRIPT_ARGS = <%=script_args.gsub("#", "\\#")%>
- EXTMK_ARGS = $(SCRIPT_ARGS) --gnumake=$(gnumake) --extflags="$(EXTLDFLAGS)" \
- 	   --make-flags="MINIRUBY='$(MINIRUBY)'"
- 
--all: exts # gems
-+all: exts gems
- exts:
- gems:
- 
-diff --git a/template/exts.mk.tmpl b/template/exts.mk.tmpl
-index 964939e365a1..e544c4c88bd7 100644
---- a/template/exts.mk.tmpl
-+++ b/template/exts.mk.tmpl
-@@ -19,7 +19,7 @@ opt = OptionParser.new do |o|
-   o.on('--configure-exts=FILE') {|v| confexts = v}
-   o.order!(ARGV)
- end
--confexts &&= File.read(confexts).scan(/^exts: (.*\.mk)/).flatten rescue nil
-+confexts &&= File.read(confexts).scan(/^(?:ext|gem)s: (.*\.mk)/).flatten rescue nil
- confexts ||= []
- macros["old_extensions"] = []
- 
-@@ -30,7 +30,7 @@ Dir.glob("{ext,.bundle/gems}/*/exts.mk") do |e|
-   s.scan(/^(extensions|SUBMAKEOPTS|EXT[A-Z]+|MFLAGS|NOTE_[A-Z]+)[ \t]*=[ \t]*(#{contpat})$/o) do |n, v|
-     v.gsub!(/\\\n[ \t]*/, ' ')
-     next if v.empty?
--    next if gem and n != "extensions"
-+    next if n != "extensions"
-     n = "old_extensions" if n == "extensions" and !confexts.include?(e)
-     v = v.split
-     m = macros[n] ||= []
-
-From be9d00ee7c72766551ba8c3530f1538034498a6a Mon Sep 17 00:00:00 2001
-From: Nobuyoshi Nakada <nobu@ruby-lang.org>
-Date: Wed, 6 Apr 2022 20:28:00 +0900
-Subject: [PATCH 3/5] Move the target directory of bundled gems like as
- rubygems
-
----
- ext/extmk.rb | 6 +++++-
- 1 file changed, 5 insertions(+), 1 deletion(-)
-
-diff --git a/ext/extmk.rb b/ext/extmk.rb
-index 1da9e2704521..a440af27fc5d 100755
---- a/ext/extmk.rb
-+++ b/ext/extmk.rb
-@@ -2,6 +2,9 @@
- # -*- mode: ruby; coding: us-ascii -*-
- # frozen_string_literal: false
- 
-+module Gem; end # only needs Gem::Platform
-+require 'rubygems/platform'
-+
- # :stopdoc:
- $extension = nil
- $extstatic = nil
-@@ -535,11 +538,12 @@ def create_makefile(*args, &block)
-     super(*args) do |conf|
-       conf.find do |s|
-         s.sub!(/^(TARGET_SO_DIR *= *)\$\(RUBYARCHDIR\)/) {
--          "TARGET_GEM_DIR = $(extout)/gems/$(arch)/#{@gemname}\n"\
-+          "TARGET_GEM_DIR = $(topdir)/.bundle/extensions/$(gem_platform)/$(ruby_version)/#{@gemname}\n"\
-           "#{$1}$(TARGET_GEM_DIR)$(target_prefix)"
-         }
-       end
-       conf.any? {|s| /^TARGET *= *\S/ =~ s} and conf << %{
-+gem_platform = #{Gem::Platform.local}
- 
- # default target
- all:
-
-From c4daf8e445925695c34bab8bf5135dcd1e8575a3 Mon Sep 17 00:00:00 2001
-From: Nobuyoshi Nakada <nobu@ruby-lang.org>
-Date: Wed, 6 Apr 2022 22:57:01 +0900
-Subject: [PATCH 4/5] Obey spec file locations to rubygems
-
----
- common.mk          | 3 ++-
- defs/gmake.mk      | 2 +-
- tool/gem-unpack.rb | 5 +++--
- 3 files changed, 6 insertions(+), 4 deletions(-)
-
-diff --git a/common.mk b/common.mk
-index 7c552cba1e04..b4adb2729c0e 100644
---- a/common.mk
-+++ b/common.mk
-@@ -1359,10 +1359,11 @@ extract-gems$(gnumake:yes=-nongnumake): PHONY
- 	$(Q) $(RUNRUBY) -C "$(srcdir)" \
- 	    -Itool -rgem-unpack -answ \
- 	    -e 'BEGIN {FileUtils.mkdir_p(d = ".bundle/gems")}' \
-+	    -e 'BEGIN {FileUtils.mkdir_p(s = ".bundle/specifications")}' \
- 	    -e 'gem, ver = *$$F' \
- 	    -e 'next if !ver or /^#/=~gem' \
- 	    -e 'g = "#{gem}-#{ver}"' \
--	    -e 'File.directory?("#{d}/#{g}") or Gem.unpack("gems/#{g}.gem", d)' \
-+	    -e 'File.directory?("#{d}/#{g}") or Gem.unpack("gems/#{g}.gem", d, s)' \
- 	    gems/bundled_gems
- 
- update-bundled_gems: PHONY
-diff --git a/defs/gmake.mk b/defs/gmake.mk
-index a625379a6804..27e3e21cc4d6 100644
---- a/defs/gmake.mk
-+++ b/defs/gmake.mk
-@@ -290,7 +290,7 @@ extract-gems: | $(patsubst %,.bundle/gems/%,$(bundled-gems))
- 	$(ECHO) Extracting bundle gem $*...
- 	$(Q) $(BASERUBY) -C "$(srcdir)" \
- 	    -Itool -rgem-unpack \
--	    -e 'Gem.unpack("gems/$(@F).gem", ".bundle/gems")'
-+	    -e 'Gem.unpack("gems/$(@F).gem", ".bundle/gems", ".bundle/specifications")'
- 
- $(srcdir)/.bundle/gems:
- 	$(MAKEDIRS) $@
-diff --git a/tool/gem-unpack.rb b/tool/gem-unpack.rb
-index cb05719463f2..fe10b0e420fa 100644
---- a/tool/gem-unpack.rb
-+++ b/tool/gem-unpack.rb
-@@ -5,13 +5,14 @@
- # This library is used by "make extract-gems" to
- # unpack bundled gem files.
- 
--def Gem.unpack(file, dir = nil)
-+def Gem.unpack(file, dir = nil, spec_dir = nil)
-   pkg = Gem::Package.new(file)
-   spec = pkg.spec
-   target = spec.full_name
-   target = File.join(dir, target) if dir
-   pkg.extract_files target
--  spec_file = File.join(target, "#{spec.name}-#{spec.version}.gemspec")
-+  FileUtils.mkdir_p(spec_dir ||= target)
-+  spec_file = File.join(spec_dir, "#{spec.name}-#{spec.version}.gemspec")
-   open(spec_file, 'wb') do |f|
-     f.print spec.to_ruby
-   end
-
-From 3de652d8198be9cd2998c095903889a80e738275 Mon Sep 17 00:00:00 2001
-From: Nobuyoshi Nakada <nobu@ruby-lang.org>
-Date: Thu, 7 Apr 2022 01:44:43 +0900
-Subject: [PATCH 5/5] Install built gem extension binaries
-
----
- tool/rbinstall.rb | 56 ++++++++++++++---------------------------------
- 1 file changed, 16 insertions(+), 40 deletions(-)
-
-diff --git a/tool/rbinstall.rb b/tool/rbinstall.rb
-index 9d9b672be472..624961b4eee6 100755
---- a/tool/rbinstall.rb
-+++ b/tool/rbinstall.rb
-@@ -858,6 +858,9 @@ class UnpackedInstaller < GemInstaller
-     def write_cache_file
-     end
- 
-+    def build_extensions
-+    end
-+
-     def shebang(bin_file_name)
-       path = File.join(gem_dir, spec.bindir, bin_file_name)
-       first_line = File.open(path, "rb") {|file| file.gets}
-@@ -940,13 +943,12 @@ def ensure_writable_dir(dir)
-   install_default_gem('ext', srcdir, bindir)
- end
- 
--def load_gemspec(file, expanded = false)
-+def load_gemspec(file, base = nil)
-   file = File.realpath(file)
-   code = File.read(file, encoding: "utf-8:-")
-   code.gsub!(/(?:`git[^\`]*`|%x\[git[^\]]*\])\.split\([^\)]*\)/m) do
-     files = []
--    if expanded
--      base = File.dirname(file)
-+    if base
-       Dir.glob("**/*", File::FNM_DOTMATCH, base: base) do |n|
-         case File.basename(n); when ".", ".."; next; end
-         next if File.directory?(File.join(base, n))
-@@ -959,7 +961,7 @@ def load_gemspec(file, expanded = false)
-   unless Gem::Specification === spec
-     raise TypeError, "[#{file}] isn't a Gem::Specification (#{spec.class} instead)."
-   end
--  spec.loaded_from = file
-+  spec.loaded_from = base ? File.join(base, File.basename(file)) : file
-   spec.files.reject! {|n| n.end_with?(".gemspec") or n.start_with?(".git")}
- 
-   spec
-@@ -1014,20 +1016,6 @@ def install_default_gem(dir, srcdir, bindir)
- end
- 
- install?(:ext, :comm, :gem, :'bundled-gems') do
--  if CONFIG['CROSS_COMPILING'] == 'yes'
--    # The following hacky steps set "$ruby = BASERUBY" in tool/fake.rb
--    $hdrdir = ''
--    $extmk = nil
--    $ruby = nil  # ...
--    ruby_path = $ruby + " -I#{Dir.pwd}" # $baseruby + " -I#{Dir.pwd}"
--  else
--    # ruby_path = File.expand_path(with_destdir(File.join(bindir, ruby_install_name)))
--    ENV['RUBYLIB'] = nil
--    ENV['RUBYOPT'] = nil
--    ruby_path = File.expand_path(with_destdir(File.join(bindir, ruby_install_name))) + " --disable=gems -I#{with_destdir(archlibdir)}"
--  end
--  Gem.instance_variable_set(:@ruby, ruby_path) if Gem.ruby != ruby_path
--
-   gem_dir = Gem.default_dir
-   install_dir = with_destdir(gem_dir)
-   prepare "bundled gems", gem_dir
-@@ -1047,40 +1035,28 @@ def install_default_gem(dir, srcdir, bindir)
-     :wrappers => true,
-     :format_executable => true,
-   }
--  gem_ext_dir = "#$extout/gems/#{CONFIG['arch']}"
--  extensions_dir = with_destdir(Gem::StubSpecification.gemspec_stub("", gem_dir, gem_dir).extensions_dir)
-+
-+  extensions_dir = Gem::StubSpecification.gemspec_stub("", gem_dir, gem_dir).extensions_dir
-+  specifications_dir = File.join(gem_dir, "specifications")
-+  build_dir = Gem::StubSpecification.gemspec_stub("", ".bundle", ".bundle").extensions_dir
- 
-   File.foreach("#{srcdir}/gems/bundled_gems") do |name|
-     next if /^\s*(?:#|$)/ =~ name
-     next unless /^(\S+)\s+(\S+).*/ =~ name
-     gem_name = "#$1-#$2"
--    path = "#{srcdir}/.bundle/gems/#{gem_name}/#{gem_name}.gemspec"
--    if File.exist?(path)
--      spec = load_gemspec(path)
--    else
--      path = "#{srcdir}/.bundle/gems/#{gem_name}/#$1.gemspec"
--      next unless File.exist?(path)
--      spec = load_gemspec(path, true)
--    end
-+    path = "#{srcdir}/.bundle/specifications/#{gem_name}.gemspec"
-+    next unless File.exist?(path)
-+    spec = load_gemspec(path, "#{srcdir}/.bundle/gems/#{gem_name}")
-     next unless spec.platform == Gem::Platform::RUBY
-     next unless spec.full_name == gem_name
--    if !spec.extensions.empty? && CONFIG["EXTSTATIC"] == "static"
--      puts "skip installation of #{spec.name} #{spec.version}; bundled gem with an extension library is not supported on --with-static-linked-ext"
--      next
--    end
-     spec.extension_dir = "#{extensions_dir}/#{spec.full_name}"
--    if File.directory?(ext = "#{gem_ext_dir}/#{spec.full_name}")
--      spec.extensions[0] ||= "-"
--    end
-     package = RbInstall::DirPackage.new spec
-     ins = RbInstall::UnpackedInstaller.new(package, options)
-     puts "#{INDENT}#{spec.name} #{spec.version}"
-     ins.install
--    unless $dryrun
--      File.chmod($data_mode, File.join(install_dir, "specifications", "#{spec.full_name}.gemspec"))
--    end
--    unless spec.extensions.empty?
--      install_recursive(ext, spec.extension_dir)
-+    install_recursive("#{build_dir}/#{gem_name}", "#{extensions_dir}/#{gem_name}") do |src, dest|
-+      # puts "#{INDENT}    #{dest[extensions_dir.size+gem_name.size+2..-1]}"
-+      install src, dest, :mode => (File.executable?(src) ? $prog_mode : $data_mode)
-     end
-     installed_gems[spec.full_name] = true
-   end

ruby-3.2.0-Detect-compaction-support-during-runtime.patch

@@ -0,0 +1,291 @@
+From 4d9cc9afa47981520d991d19fd78b322f1ba9f2a Mon Sep 17 00:00:00 2001
+From: Jarek Prokop <jprokop@redhat.com>
+Date: Wed, 22 Jun 2022 01:03:49 +0200
+Subject: [PATCH] Detect compaction support during runtime.
+
+The patch is created by backporting 3 commits from
+the upstream Ruby master branch in the chronological order below.
+
+https://github.com/ruby/ruby/commit/52d42e702375446746164a0251e1a10bce813b78
+https://github.com/ruby/ruby/commit/79eaaf2d0b641710613f16525e4b4c439dfe854e
+https://github.com/ruby/ruby/commit/2c190863239bee3f54cfb74b16bb6ea4cae6ed20
+
+== How to create this patch ==
+
+Download Ruby source code.
+```
+$ git clone https://github.com/ruby/ruby.git
+$ cd ruby
+```
+
+First create a commit squashed from the 3 commits above.
+Checkout the second commmit above, and create a temporary branch.
+```
+$ git checkout 79eaaf2d0b641710613f16525e4b4c439dfe854e
+$ git checkout -b wip/detect-compaction-runtime-tmp
+```
+
+Cherry pick the third commit on the second commit.
+```
+$ git cherry-pick 2c190863239bee3f54cfb74b16bb6ea4cae6ed20
+```
+
+Squash the last 3 commits on the branch.
+```
+$ git rebase -i 2223eb082afa6d05321b69df783d4133b9aacba6
+```
+
+Then checkout Ruby 3.1.2 branch.
+Create a new branch.
+Merge the Fedora Ruby's
+ruby-3.2.0-define-unsupported-gc-compaction-methods-as-rb_f_notimplement.patch.
+```
+$ git checkout v3_1_2
+$ git checkout -b wip/detect-compaction-runtime
+$ patch -p1 <
+~/fed/ruby/ruby-3.2.0-define-unsupported-gc-compaction-methods-as-rb_f_notimplement.patch
+$ git add gc.c gc.rb test/ruby/test_gc_compact.rb
+$ git commit
+```
+
+Merge the squashed one commit on the
+`wip/detect-compaction-runtime-tmp` branch
+into the `wip/detect-compaction-runtime` branch.
+```
+$ git cherry-pick <the squashed commit above>
+```
+
+Fix conflicts seeing the difference by `git show <the squashed commit
+above>`
+on another terminal.
+```
+$ vi gc.c
+$ git add gc.c
+$ git commit
+```
+
+== Notes for the patch ==
+
+```
++# define GC_COMPACTION_SUPPORTED (GC_CAN_COMPILE_COMPACTION && USE_MMAP_ALIGNED_ALLOC)
+```
+
+We use the USE_MMAP_ALIGNED_ALLOC instead of HEAP_PAGE_ALLOC_USE_MMAP on
+the line above. Because while the Ruby on the master branch replaced the
+USE_MMAP_ALIGNED_ALLOC with HEAP_PAGE_ALLOC_USE_MMAP, Ruby 3.1.2 doesn't.
+See <https://github.com/ruby/ruby/commit/fe21b7794af0cdb7ebd502e2c0da38c68fd89839>.
+
+```
++        rb_define_singleton_method(rb_mGC, "verify_compaction_references", gc_verify_compaction_references, -1);
+```
+
+We added the line in the case that GC_COMPACTION_SUPPORTED is true.
+Because while the Ruby on the master branch defines the
+GC.verify_compaction_references in the gc.rb in
+the case that GC_COMPACTION_SUPPORTED is true, Ruby 3.1.2
+doesn't define it in the gc.rb.
+See <https://github.com/ruby/ruby/commit/b96a3a6fd2093e1dbea5491c002da515652dd347>.
+
+```
++	OPT(GC_COMPACTION_SUPPORTED);
+```
+
+We added the line to expose the C macro to Ruby level.
+In Ruby the macro existance can then be checked like so:
+```Ruby
+GC::OPTS.include?("GC_COMPACTION_SUPPORTED")
+```
+It will return `true` if the GC_COMPACTION_SUPPORTED evaluates to `true` on the
+C level, `false` otherwise.
+See <https://github.com/ruby/ruby/blob/b96a3a6fd2093e1dbea5491c002da515652dd347/gc.c#L14091>
+
+== Original commit messages ==
+
+This is a combination of 3 commits.
+This is the 1st commit message:
+~~~
+Rename GC_COMPACTION_SUPPORTED
+
+Naming this macro GC_COMPACTION_SUPPORTED is misleading because it
+only checks whether compaction is supported at compile time.
+
+[Bug #18829]
+~~~
+
+This is the commit message #2:
+~~~
+Include runtime checks for compaction support
+
+Commit 0c36ba53192c5a0d245c9b626e4346a32d7d144e changed GC compaction
+methods to not be implemented when not supported. However, that commit
+only does compile time checks (which currently only checks for WASM),
+but there are additional compaction support checks during run time.
+
+This commit changes it so that GC compaction methods aren't defined
+during run time if the platform does not support GC compaction.
+
+[Bug #18829]
+~~~
+
+This is the commit message #3:
+~~~
+Suppress code unused unless GC_CAN_COMPILE_COMPACTION
+~~~
+---
+ gc.c | 63 +++++++++++++++++++++++++++++++++++++++++-------------------
+ 1 file changed, 43 insertions(+), 20 deletions(-)
+
+diff --git a/gc.c b/gc.c
+index 1c35856c44..bff0666a17 100644
+--- a/gc.c
++++ b/gc.c
+@@ -4985,6 +4985,23 @@ gc_unprotect_pages(rb_objspace_t *objspace, rb_heap_t *heap)
+ static void gc_update_references(rb_objspace_t * objspace);
+ static void invalidate_moved_page(rb_objspace_t *objspace, struct heap_page *page);
+ 
++#ifndef GC_CAN_COMPILE_COMPACTION
++#if defined(__wasi__) /* WebAssembly doesn't support signals */
++# define GC_CAN_COMPILE_COMPACTION 0
++#else
++# define GC_CAN_COMPILE_COMPACTION 1
++#endif
++#endif
++
++#if defined(__MINGW32__) || defined(_WIN32)
++# define GC_COMPACTION_SUPPORTED 1
++#else
++/* If not MinGW, Windows, or does not have mmap, we cannot use mprotect for
++ * the read barrier, so we must disable compaction. */
++# define GC_COMPACTION_SUPPORTED (GC_CAN_COMPILE_COMPACTION && USE_MMAP_ALIGNED_ALLOC)
++#endif
++
++#if GC_CAN_COMPILE_COMPACTION
+ static void
+ read_barrier_handler(uintptr_t address)
+ {
+@@ -5005,6 +5022,7 @@ read_barrier_handler(uintptr_t address)
+     }
+     RB_VM_LOCK_LEAVE();
+ }
++#endif
+ 
+ #if defined(_WIN32)
+ static LPTOP_LEVEL_EXCEPTION_FILTER old_handler;
+@@ -9268,13 +9286,7 @@ gc_start_internal(rb_execution_context_t *ec, VALUE self, VALUE full_mark, VALUE
+ 
+     /* For now, compact implies full mark / sweep, so ignore other flags */
+     if (RTEST(compact)) {
+-        /* If not MinGW, Windows, or does not have mmap, we cannot use mprotect for
+-         * the read barrier, so we must disable compaction. */
+-#if !defined(__MINGW32__) && !defined(_WIN32)
+-        if (!USE_MMAP_ALIGNED_ALLOC) {
+-            rb_raise(rb_eNotImpError, "Compaction isn't available on this platform");
+-        }
+-#endif
++        GC_ASSERT(GC_COMPACTION_SUPPORTED);
+ 
+         reason |= GPR_FLAG_COMPACT;
+     }
+@@ -9439,7 +9451,7 @@ gc_move(rb_objspace_t *objspace, VALUE scan, VALUE free, size_t slot_size)
+     return (VALUE)src;
+ }
+ 
+-#if GC_COMPACTION_SUPPORTED
++#if GC_CAN_COMPILE_COMPACTION
+ static int
+ compare_free_slots(const void *left, const void *right, void *dummy)
+ {
+@@ -10167,7 +10179,7 @@ gc_update_references(rb_objspace_t *objspace)
+     gc_update_table_refs(objspace, finalizer_table);
+ }
+ 
+-#if GC_COMPACTION_SUPPORTED
++#if GC_CAN_COMPILE_COMPACTION
+ /*
+  *  call-seq:
+  *     GC.latest_compact_info -> {:considered=>{:T_CLASS=>11}, :moved=>{:T_CLASS=>11}}
+@@ -10208,7 +10220,7 @@ gc_compact_stats(VALUE self)
+ #  define gc_compact_stats rb_f_notimplement
+ #endif
+ 
+-#if GC_COMPACTION_SUPPORTED
++#if GC_CAN_COMPILE_COMPACTION
+ static void
+ root_obj_check_moved_i(const char *category, VALUE obj, void *data)
+ {
+@@ -10287,7 +10299,7 @@ gc_compact(VALUE self)
+ #  define gc_compact rb_f_notimplement
+ #endif
+ 
+-#if GC_COMPACTION_SUPPORTED
++#if GC_CAN_COMPILE_COMPACTION
+ /*
+  * call-seq:
+  *    GC.verify_compaction_references(toward: nil, double_heap: false) -> hash
+@@ -10818,7 +10830,7 @@ gc_disable(rb_execution_context_t *ec, VALUE _)
+     return rb_gc_disable();
+ }
+ 
+-#if GC_COMPACTION_SUPPORTED
++#if GC_CAN_COMPILE_COMPACTION
+ /*
+  *  call-seq:
+  *     GC.auto_compact = flag
+@@ -10832,8 +10844,7 @@ gc_disable(rb_execution_context_t *ec, VALUE _)
+ static VALUE
+ gc_set_auto_compact(VALUE _, VALUE v)
+ {
+-    /* If not MinGW, Windows, or does not have mmap, we cannot use mprotect for
+-     * the read barrier, so we must disable automatic compaction. */
++    GC_ASSERT(GC_COMPACTION_SUPPORTED);
+ 
+     ruby_enable_autocompact = RTEST(v);
+     return v;
+@@ -10842,7 +10853,8 @@ gc_set_auto_compact(VALUE _, VALUE v)
+ #  define gc_set_auto_compact rb_f_notimplement
+ #endif
+ 
+-#if GC_COMPACTION_SUPPORTED
++
++#if GC_CAN_COMPILE_COMPACTION
+ /*
+  *  call-seq:
+  *     GC.auto_compact    -> true or false
+@@ -13753,11 +13776,21 @@ Init_GC(void)
+     rb_define_singleton_method(rb_mGC, "malloc_allocated_size", gc_malloc_allocated_size, 0);
+     rb_define_singleton_method(rb_mGC, "malloc_allocations", gc_malloc_allocations, 0);
+ #endif
+-    rb_define_singleton_method(rb_mGC, "compact", gc_compact, 0);
+-    rb_define_singleton_method(rb_mGC, "auto_compact", gc_get_auto_compact, 0);
+-    rb_define_singleton_method(rb_mGC, "auto_compact=", gc_set_auto_compact, 1);
+-    rb_define_singleton_method(rb_mGC, "latest_compact_info", gc_compact_stats, 0);
+-    rb_define_singleton_method(rb_mGC, "verify_compaction_references", gc_verify_compaction_references, -1);
++    if (GC_COMPACTION_SUPPORTED) {
++        rb_define_singleton_method(rb_mGC, "compact", gc_compact, 0);
++        rb_define_singleton_method(rb_mGC, "auto_compact", gc_get_auto_compact, 0);
++        rb_define_singleton_method(rb_mGC, "auto_compact=", gc_set_auto_compact, 1);
++        rb_define_singleton_method(rb_mGC, "latest_compact_info", gc_compact_stats, 0);
++        rb_define_singleton_method(rb_mGC, "verify_compaction_references", gc_verify_compaction_references, -1);
++    }
++    else {
++        rb_define_singleton_method(rb_mGC, "compact", rb_f_notimplement, 0);
++        rb_define_singleton_method(rb_mGC, "auto_compact", rb_f_notimplement, 0);
++        rb_define_singleton_method(rb_mGC, "auto_compact=", rb_f_notimplement, 1);
++        rb_define_singleton_method(rb_mGC, "latest_compact_info", rb_f_notimplement, 0);
++        /* When !GC_COMPACTION_SUPPORTED, this method is not defined in gc.rb */
++        rb_define_singleton_method(rb_mGC, "verify_compaction_references", rb_f_notimplement, -1);
++    }
+ 
+ #if GC_DEBUG_STRESS_TO_CLASS
+     rb_define_singleton_method(rb_mGC, "add_stress_to_class", rb_gcdebug_add_stress_to_class, -1);
+@@ -13781,6 +13803,7 @@ Init_GC(void)
+ 	OPT(MALLOC_ALLOCATED_SIZE);
+ 	OPT(MALLOC_ALLOCATED_SIZE_CHECK);
+ 	OPT(GC_PROFILE_DETAIL_MEMORY);
++	OPT(GC_COMPACTION_SUPPORTED);
+ #undef OPT
+ 	OBJ_FREEZE(opts);
+     }
+-- 
+2.36.1
+

ruby-3.2.0-define-unsupported-gc-compaction-methods-as-rb_f_notimplement.patch

@@ -0,0 +1,502 @@
+From 1b3502156a665e2782f366aa5ac8c3bfd7637ab8 Mon Sep 17 00:00:00 2001
+From: Mike Dalessio <mike.dalessio@gmail.com>
+Date: Mon, 23 May 2022 15:40:22 -0400
+Subject: [PATCH 1/2] Move compaction-related methods into gc.c
+
+These methods are removed from gc.rb and added to gc.c:
+
+- GC.compact
+- GC.auto_compact
+- GC.auto_compact=
+- GC.latest_compact_info
+- GC.verify_compaction_references
+
+This is a prefactor to allow setting these methods to
+`rb_f_notimplement` in a followup commit.
+---
+ gc.c  | 101 ++++++++++++++++++++++++++++++++++++++++++++++++++++------
+ gc.rb |  68 ---------------------------------------
+ 2 files changed, 91 insertions(+), 78 deletions(-)
+
+diff --git a/gc.c b/gc.c
+index ef9327df1f..1c35856c44 100644
+--- a/gc.c
++++ b/gc.c
+@@ -10165,8 +10165,20 @@ gc_update_references(rb_objspace_t *objspace)
+     gc_update_table_refs(objspace, finalizer_table);
+ }
+ 
++/*
++ *  call-seq:
++ *     GC.latest_compact_info -> {:considered=>{:T_CLASS=>11}, :moved=>{:T_CLASS=>11}}
++ *
++ *  Returns information about object moved in the most recent GC compaction.
++ *
++ * The returned hash has two keys :considered and :moved.  The hash for
++ * :considered lists the number of objects that were considered for movement
++ * by the compactor, and the :moved hash lists the number of objects that
++ * were actually moved.  Some objects can't be moved (maybe they were pinned)
++ * so these numbers can be used to calculate compaction efficiency.
++ */
+ static VALUE
+-gc_compact_stats(rb_execution_context_t *ec, VALUE self)
++gc_compact_stats(VALUE self)
+ {
+     size_t i;
+     rb_objspace_t *objspace = &rb_objspace;
+@@ -10239,22 +10251,70 @@ heap_check_moved_i(void *vstart, void *vend, size_t stride, void *data)
+     return 0;
+ }
+ 
++/*
++ *  call-seq:
++ *     GC.compact
++ *
++ * This function compacts objects together in Ruby's heap.  It eliminates
++ * unused space (or fragmentation) in the heap by moving objects in to that
++ * unused space.  This function returns a hash which contains statistics about
++ * which objects were moved.  See `GC.latest_gc_info` for details about
++ * compaction statistics.
++ *
++ * This method is implementation specific and not expected to be implemented
++ * in any implementation besides MRI.
++ */
+ static VALUE
+-gc_compact(rb_execution_context_t *ec, VALUE self)
++gc_compact(VALUE self)
+ {
+     /* Run GC with compaction enabled */
+-    gc_start_internal(ec, self, Qtrue, Qtrue, Qtrue, Qtrue);
++    gc_start_internal(NULL, self, Qtrue, Qtrue, Qtrue, Qtrue);
+ 
+-    return gc_compact_stats(ec, self);
++    return gc_compact_stats(self);
+ }
+ 
++/*
++ * call-seq:
++ *    GC.verify_compaction_references(toward: nil, double_heap: false) -> hash
++ *
++ * Verify compaction reference consistency.
++ *
++ * This method is implementation specific.  During compaction, objects that
++ * were moved are replaced with T_MOVED objects.  No object should have a
++ * reference to a T_MOVED object after compaction.
++ *
++ * This function doubles the heap to ensure room to move all objects,
++ * compacts the heap to make sure everything moves, updates all references,
++ * then performs a full GC.  If any object contains a reference to a T_MOVED
++ * object, that object should be pushed on the mark stack, and will
++ * make a SEGV.
++ */
+ static VALUE
+-gc_verify_compaction_references(rb_execution_context_t *ec, VALUE self, VALUE double_heap, VALUE toward_empty)
++gc_verify_compaction_references(int argc, VALUE *argv, VALUE self)
+ {
+     rb_objspace_t *objspace = &rb_objspace;
++    VALUE kwargs, double_heap = Qfalse, toward_empty = Qfalse;
++    static ID id_toward, id_double_heap, id_empty;
++
++    if (!id_toward) {
++        id_toward = rb_intern("toward");
++        id_double_heap = rb_intern("double_heap");
++        id_empty = rb_intern("empty");
++    }
++
++    rb_scan_args(argc, argv, ":", &kwargs);
++    if (!NIL_P(kwargs)) {
++        if (rb_hash_has_key(kwargs, ID2SYM(id_toward))) {
++            VALUE toward = rb_hash_aref(kwargs, ID2SYM(id_toward));
++            toward_empty = (toward == ID2SYM(id_empty)) ? Qtrue : Qfalse;
++        }
++        if (rb_hash_has_key(kwargs, ID2SYM(id_double_heap))) {
++            double_heap = rb_hash_aref(kwargs, ID2SYM(id_double_heap));
++        }
++    }
+ 
+     /* Clear the heap. */
+-    gc_start_internal(ec, self, Qtrue, Qtrue, Qtrue, Qfalse);
++    gc_start_internal(NULL, self, Qtrue, Qtrue, Qtrue, Qfalse);
+ 
+     RB_VM_LOCK_ENTER();
+     {
+@@ -10274,12 +10334,12 @@ gc_verify_compaction_references(rb_execution_context_t *ec, VALUE self, VALUE do
+     }
+     RB_VM_LOCK_LEAVE();
+ 
+-    gc_start_internal(ec, self, Qtrue, Qtrue, Qtrue, Qtrue);
++    gc_start_internal(NULL, self, Qtrue, Qtrue, Qtrue, Qtrue);
+ 
+     objspace_reachable_objects_from_root(objspace, root_obj_check_moved_i, NULL);
+     objspace_each_objects(objspace, heap_check_moved_i, NULL, TRUE);
+ 
+-    return gc_compact_stats(ec, self);
++    return gc_compact_stats(self);
+ }
+ 
+ VALUE
+@@ -10740,8 +10800,18 @@ gc_disable(rb_execution_context_t *ec, VALUE _)
+     return rb_gc_disable();
+ }
+ 
++/*
++ *  call-seq:
++ *     GC.auto_compact = flag
++ *
++ *  Updates automatic compaction mode.
++ *
++ *  When enabled, the compactor will execute on every major collection.
++ *
++ *  Enabling compaction will degrade performance on major collections.
++ */
+ static VALUE
+-gc_set_auto_compact(rb_execution_context_t *ec, VALUE _, VALUE v)
++gc_set_auto_compact(VALUE _, VALUE v)
+ {
+     /* If not MinGW, Windows, or does not have mmap, we cannot use mprotect for
+      * the read barrier, so we must disable automatic compaction. */
+@@ -10755,8 +10825,14 @@ gc_set_auto_compact(rb_execution_context_t *ec, VALUE _, VALUE v)
+     return v;
+ }
+ 
++/*
++ *  call-seq:
++ *     GC.auto_compact    -> true or false
++ *
++ *  Returns whether or not automatic compaction has been enabled.
++ */
+ static VALUE
+-gc_get_auto_compact(rb_execution_context_t *ec, VALUE _)
++gc_get_auto_compact(VALUE _)
+ {
+     return RBOOL(ruby_enable_autocompact);
+ }
+@@ -13656,6 +13732,11 @@ Init_GC(void)
+     rb_define_singleton_method(rb_mGC, "malloc_allocated_size", gc_malloc_allocated_size, 0);
+     rb_define_singleton_method(rb_mGC, "malloc_allocations", gc_malloc_allocations, 0);
+ #endif
++    rb_define_singleton_method(rb_mGC, "compact", gc_compact, 0);
++    rb_define_singleton_method(rb_mGC, "auto_compact", gc_get_auto_compact, 0);
++    rb_define_singleton_method(rb_mGC, "auto_compact=", gc_set_auto_compact, 1);
++    rb_define_singleton_method(rb_mGC, "latest_compact_info", gc_compact_stats, 0);
++    rb_define_singleton_method(rb_mGC, "verify_compaction_references", gc_verify_compaction_references, -1);
+ 
+ #if GC_DEBUG_STRESS_TO_CLASS
+     rb_define_singleton_method(rb_mGC, "add_stress_to_class", rb_gcdebug_add_stress_to_class, -1);
+diff --git a/gc.rb b/gc.rb
+index 72637f3796..9265dd7b57 100644
+--- a/gc.rb
++++ b/gc.rb
+@@ -38,27 +38,6 @@ def garbage_collect full_mark: true, immediate_mark: true, immediate_sweep: true
+     Primitive.gc_start_internal full_mark, immediate_mark, immediate_sweep, false
+   end
+ 
+-  #  call-seq:
+-  #     GC.auto_compact    -> true or false
+-  #
+-  #  Returns whether or not automatic compaction has been enabled.
+-  #
+-  def self.auto_compact
+-    Primitive.gc_get_auto_compact
+-  end
+-
+-  #  call-seq:
+-  #     GC.auto_compact = flag
+-  #
+-  #  Updates automatic compaction mode.
+-  #
+-  #  When enabled, the compactor will execute on every major collection.
+-  #
+-  #  Enabling compaction will degrade performance on major collections.
+-  def self.auto_compact=(flag)
+-    Primitive.gc_set_auto_compact(flag)
+-  end
+-
+   #  call-seq:
+   #     GC.enable    -> true or false
+   #
+@@ -210,53 +189,6 @@ def self.latest_gc_info hash_or_key = nil
+     Primitive.gc_latest_gc_info hash_or_key
+   end
+ 
+-  #  call-seq:
+-  #     GC.latest_compact_info -> {:considered=>{:T_CLASS=>11}, :moved=>{:T_CLASS=>11}}
+-  #
+-  #  Returns information about object moved in the most recent GC compaction.
+-  #
+-  # The returned hash has two keys :considered and :moved.  The hash for
+-  # :considered lists the number of objects that were considered for movement
+-  # by the compactor, and the :moved hash lists the number of objects that
+-  # were actually moved.  Some objects can't be moved (maybe they were pinned)
+-  # so these numbers can be used to calculate compaction efficiency.
+-  def self.latest_compact_info
+-    Primitive.gc_compact_stats
+-  end
+-
+-  #  call-seq:
+-  #     GC.compact
+-  #
+-  # This function compacts objects together in Ruby's heap.  It eliminates
+-  # unused space (or fragmentation) in the heap by moving objects in to that
+-  # unused space.  This function returns a hash which contains statistics about
+-  # which objects were moved.  See `GC.latest_gc_info` for details about
+-  # compaction statistics.
+-  #
+-  # This method is implementation specific and not expected to be implemented
+-  # in any implementation besides MRI.
+-  def self.compact
+-    Primitive.gc_compact
+-  end
+-
+-  # call-seq:
+-  #    GC.verify_compaction_references(toward: nil, double_heap: false) -> hash
+-  #
+-  # Verify compaction reference consistency.
+-  #
+-  # This method is implementation specific.  During compaction, objects that
+-  # were moved are replaced with T_MOVED objects.  No object should have a
+-  # reference to a T_MOVED object after compaction.
+-  #
+-  # This function doubles the heap to ensure room to move all objects,
+-  # compacts the heap to make sure everything moves, updates all references,
+-  # then performs a full GC.  If any object contains a reference to a T_MOVED
+-  # object, that object should be pushed on the mark stack, and will
+-  # make a SEGV.
+-  def self.verify_compaction_references(toward: nil, double_heap: false)
+-    Primitive.gc_verify_compaction_references(double_heap, toward == :empty)
+-  end
+-
+   # call-seq:
+   #     GC.using_rvargc? -> true or false
+   #
+
+From d3273559356db6852d1fd794f0f076fba100e09e Mon Sep 17 00:00:00 2001
+From: Mike Dalessio <mike.dalessio@gmail.com>
+Date: Mon, 23 May 2022 17:31:14 -0400
+Subject: [PATCH 2/2] Define unsupported GC compaction methods as
+ rb_f_notimplement
+
+Fixes [Bug #18779]
+
+Define the following methods as `rb_f_notimplement` on unsupported
+platforms:
+
+- GC.compact
+- GC.auto_compact
+- GC.auto_compact=
+- GC.latest_compact_info
+- GC.verify_compaction_references
+
+This change allows users to call `GC.respond_to?(:compact)` to
+properly test for compaction support. Previously, it was necessary to
+invoke `GC.compact` or `GC.verify_compaction_references` and check if
+those methods raised `NotImplementedError` to determine if compaction
+was supported.
+
+This follows the precedent set for other platform-specific
+methods. For example, in `process.c` for methods such as
+`Process.fork`, `Process.setpgid`, and `Process.getpriority`.
+---
+ gc.c                         | 31 +++++++++++++++----
+ test/ruby/test_gc_compact.rb | 58 ++++++++++++++++++++++++++----------
+ 2 files changed, 69 insertions(+), 20 deletions(-)
+
+diff --git a/gc.c b/gc.c
+index 92ed76cf96..d71924846a 100644
+--- a/gc.c
++++ b/gc.c
+@@ -9439,6 +9439,7 @@ gc_move(rb_objspace_t *objspace, VALUE scan, VALUE free, size_t slot_size)
+     return (VALUE)src;
+ }
+ 
++#if GC_COMPACTION_SUPPORTED
+ static int
+ compare_free_slots(const void *left, const void *right, void *dummy)
+ {
+@@ -9486,6 +9487,7 @@ gc_sort_heap_by_empty_slots(rb_objspace_t *objspace)
+         free(page_list);
+     }
+ }
++#endif
+ 
+ static void
+ gc_ref_update_array(rb_objspace_t * objspace, VALUE v)
+@@ -10165,6 +10167,7 @@ gc_update_references(rb_objspace_t *objspace)
+     gc_update_table_refs(objspace, finalizer_table);
+ }
+ 
++#if GC_COMPACTION_SUPPORTED
+ /*
+  *  call-seq:
+  *     GC.latest_compact_info -> {:considered=>{:T_CLASS=>11}, :moved=>{:T_CLASS=>11}}
+@@ -10201,7 +10204,11 @@ gc_compact_stats(VALUE self)
+ 
+     return h;
+ }
++#else
++#  define gc_compact_stats rb_f_notimplement
++#endif
+ 
++#if GC_COMPACTION_SUPPORTED
+ static void
+ root_obj_check_moved_i(const char *category, VALUE obj, void *data)
+ {
+@@ -10263,6 +10270,10 @@ heap_check_moved_i(void *vstart, void *vend, size_t stride, void *data)
+  *
+  * This method is implementation specific and not expected to be implemented
+  * in any implementation besides MRI.
++ *
++ * To test whether GC compaction is supported, use the idiom:
++ *
++ *   GC.respond_to?(:compact)
+  */
+ static VALUE
+ gc_compact(VALUE self)
+@@ -10272,7 +10283,11 @@ gc_compact(VALUE self)
+ 
+     return gc_compact_stats(self);
+ }
++#else
++#  define gc_compact rb_f_notimplement
++#endif
+ 
++#if GC_COMPACTION_SUPPORTED
+ /*
+  * call-seq:
+  *    GC.verify_compaction_references(toward: nil, double_heap: false) -> hash
+@@ -10341,6 +10356,9 @@ gc_verify_compaction_references(int argc, VALUE *argv, VALUE self)
+ 
+     return gc_compact_stats(self);
+ }
++#else
++#  define gc_verify_compaction_references rb_f_notimplement
++#endif
+ 
+ VALUE
+ rb_gc_start(void)
+@@ -10800,6 +10818,7 @@ gc_disable(rb_execution_context_t *ec, VALUE _)
+     return rb_gc_disable();
+ }
+ 
++#if GC_COMPACTION_SUPPORTED
+ /*
+  *  call-seq:
+  *     GC.auto_compact = flag
+@@ -10815,16 +10834,15 @@ gc_set_auto_compact(VALUE _, VALUE v)
+ {
+     /* If not MinGW, Windows, or does not have mmap, we cannot use mprotect for
+      * the read barrier, so we must disable automatic compaction. */
+-#if !defined(__MINGW32__) && !defined(_WIN32)
+-    if (!USE_MMAP_ALIGNED_ALLOC) {
+-        rb_raise(rb_eNotImpError, "Automatic compaction isn't available on this platform");
+-    }
+-#endif
+ 
+     ruby_enable_autocompact = RTEST(v);
+     return v;
+ }
++#else
++#  define gc_set_auto_compact rb_f_notimplement
++#endif
+ 
++#if GC_COMPACTION_SUPPORTED
+ /*
+  *  call-seq:
+  *     GC.auto_compact    -> true or false
+@@ -10836,6 +10854,9 @@ gc_get_auto_compact(VALUE _)
+ {
+     return RBOOL(ruby_enable_autocompact);
+ }
++#else
++#  define gc_get_auto_compact rb_f_notimplement
++#endif
+ 
+ static int
+ get_envparam_size(const char *name, size_t *default_value, size_t lower_bound)
+diff --git a/test/ruby/test_gc_compact.rb b/test/ruby/test_gc_compact.rb
+index 42ad028530..411d5eab69 100644
+--- a/test/ruby/test_gc_compact.rb
++++ b/test/ruby/test_gc_compact.rb
+@@ -9,14 +9,7 @@
+ end
+ 
+ class TestGCCompact < Test::Unit::TestCase
+-  module SupportsCompact
+-    def setup
+-      skip "autocompact not supported on this platform" unless supports_auto_compact?
+-      super
+-    end
+-
+-    private
+-
++  module CompactionSupportInspector
+     def supports_auto_compact?
+       return true unless defined?(Etc::SC_PAGE_SIZE)
+ 
+@@ -30,10 +23,19 @@ def supports_auto_compact?
+     end
+   end
+ 
+-  include SupportsCompact
++  module OmitUnlessCompactSupported
++    include CompactionSupportInspector
++
++    def setup
++      omit "autocompact not supported on this platform" unless supports_auto_compact?
++      super
++    end
++  end
++
++  include OmitUnlessCompactSupported
+ 
+   class AutoCompact < Test::Unit::TestCase
+-    include SupportsCompact
++    include OmitUnlessCompactSupported
+ 
+     def test_enable_autocompact
+       before = GC.auto_compact
+@@ -87,13 +89,39 @@ def test_implicit_compaction_does_something
+     end
+   end
+ 
+-  def os_page_size
+-    return true unless defined?(Etc::SC_PAGE_SIZE)
++  class CompactMethodsNotImplemented < Test::Unit::TestCase
++    include CompactionSupportInspector
++
++    def assert_not_implemented(method, *args)
++      omit "autocompact is supported on this platform" if supports_auto_compact?
++
++      assert_raise(NotImplementedError) { GC.send(method, *args) }
++      refute(GC.respond_to?(method), "GC.#{method} should be defined as rb_f_notimplement")
++    end
++
++    def test_gc_compact_not_implemented
++      assert_not_implemented(:compact)
++    end
++
++    def test_gc_auto_compact_get_not_implemented
++      assert_not_implemented(:auto_compact)
++    end
++
++    def test_gc_auto_compact_set_not_implemented
++      assert_not_implemented(:auto_compact=, true)
++    end
++
++    def test_gc_latest_compact_info_not_implemented
++      assert_not_implemented(:latest_compact_info)
++    end
++
++    def test_gc_verify_compaction_references_not_implemented
++      assert_not_implemented(:verify_compaction_references)
++    end
+   end
+ 
+-  def setup
+-    skip "autocompact not supported on this platform" unless supports_auto_compact?
+-    super
++  def os_page_size
++    return true unless defined?(Etc::SC_PAGE_SIZE)
+   end
+ 
+   def test_gc_compact_stats

ruby-3.2.0-define-unsupported-gc-compaction-methods_generated-files.patch

@@ -0,0 +1,502 @@
+--- ruby-3.1.3/gc.rbinc	2022-11-24 11:20:33.000000000 +0100
++++ ruby/gc.rbinc	2022-11-25 11:50:19.939820992 +0100
+@@ -9,27 +9,27 @@
+ #include "builtin.h"                /* for RB_BUILTIN_FUNCTION */
+ struct rb_execution_context_struct; /* in vm_core.h */
+ 
+-static VALUE builtin_inline_class_277(struct rb_execution_context_struct *ec, const VALUE self)
++static VALUE builtin_inline_class_209(struct rb_execution_context_struct *ec, const VALUE self)
+ {
+ MAYBE_UNUSED(const VALUE) flag = rb_vm_lvar(ec, -3);
+-#line 277 "gc.rb"
++#line 209 "gc.rb"
+ 
+       rb_objspace.flags.measure_gc = RTEST(flag) ? TRUE : FALSE;
+       return flag;
+ #line 20 "gc.rbinc"
+ }
+ 
+-static VALUE builtin_inline_class_289(struct rb_execution_context_struct *ec, const VALUE self)
++static VALUE builtin_inline_class_221(struct rb_execution_context_struct *ec, const VALUE self)
+ {
+-#line 289 "gc.rb"
++#line 221 "gc.rb"
+ return 
+       RBOOL(rb_objspace.flags.measure_gc);
+ #line 28 "gc.rbinc"
+ }
+ 
+-static VALUE builtin_inline_class_299(struct rb_execution_context_struct *ec, const VALUE self)
++static VALUE builtin_inline_class_231(struct rb_execution_context_struct *ec, const VALUE self)
+ {
+-#line 299 "gc.rb"
++#line 231 "gc.rb"
+ return 
+       ULL2NUM(rb_objspace.profile.total_time_ns);
+ #line 36 "gc.rbinc"
+@@ -52,31 +52,6 @@
+ }
+ 
+ static void
+-mjit_compile_invokebuiltin_for_gc_get_auto_compact(FILE *f, long index, unsigned stack_size, bool inlinable_p)
+-{
+-    fprintf(f, "    VALUE self = GET_SELF();\n");
+-    fprintf(f, "    typedef VALUE (*func)(rb_execution_context_t *, VALUE);\n");
+-    fprintf(f, "    func f = (func)%"PRIuVALUE"; /* == gc_get_auto_compact */\n", (VALUE)gc_get_auto_compact);
+-    fprintf(f, "    val = f(ec, self);\n");
+-}
+-
+-static void
+-mjit_compile_invokebuiltin_for_gc_set_auto_compact(FILE *f, long index, unsigned stack_size, bool inlinable_p)
+-{
+-    fprintf(f, "    VALUE self = GET_SELF();\n");
+-    fprintf(f, "    typedef VALUE (*func)(rb_execution_context_t *, VALUE, VALUE);\n");
+-    if (index == -1) {
+-        fprintf(f, "    const VALUE *argv = &stack[%d];\n", stack_size - 1);
+-    }
+-    else {
+-        fprintf(f, "    const unsigned int lnum = GET_ISEQ()->body->local_table_size;\n");
+-        fprintf(f, "    const VALUE *argv = GET_EP() - lnum - VM_ENV_DATA_SIZE + 1 + %ld;\n", index);
+-    }
+-    fprintf(f, "    func f = (func)%"PRIuVALUE"; /* == gc_set_auto_compact */\n", (VALUE)gc_set_auto_compact);
+-    fprintf(f, "    val = f(ec, self, argv[0]);\n");
+-}
+-
+-static void
+ mjit_compile_invokebuiltin_for_gc_enable(FILE *f, long index, unsigned stack_size, bool inlinable_p)
+ {
+     fprintf(f, "    VALUE self = GET_SELF();\n");
+@@ -161,40 +136,6 @@
+ }
+ 
+ static void
+-mjit_compile_invokebuiltin_for_gc_compact_stats(FILE *f, long index, unsigned stack_size, bool inlinable_p)
+-{
+-    fprintf(f, "    VALUE self = GET_SELF();\n");
+-    fprintf(f, "    typedef VALUE (*func)(rb_execution_context_t *, VALUE);\n");
+-    fprintf(f, "    func f = (func)%"PRIuVALUE"; /* == gc_compact_stats */\n", (VALUE)gc_compact_stats);
+-    fprintf(f, "    val = f(ec, self);\n");
+-}
+-
+-static void
+-mjit_compile_invokebuiltin_for_gc_compact(FILE *f, long index, unsigned stack_size, bool inlinable_p)
+-{
+-    fprintf(f, "    VALUE self = GET_SELF();\n");
+-    fprintf(f, "    typedef VALUE (*func)(rb_execution_context_t *, VALUE);\n");
+-    fprintf(f, "    func f = (func)%"PRIuVALUE"; /* == gc_compact */\n", (VALUE)gc_compact);
+-    fprintf(f, "    val = f(ec, self);\n");
+-}
+-
+-static void
+-mjit_compile_invokebuiltin_for_gc_verify_compaction_references(FILE *f, long index, unsigned stack_size, bool inlinable_p)
+-{
+-    fprintf(f, "    VALUE self = GET_SELF();\n");
+-    fprintf(f, "    typedef VALUE (*func)(rb_execution_context_t *, VALUE, VALUE, VALUE);\n");
+-    if (index == -1) {
+-        fprintf(f, "    const VALUE *argv = &stack[%d];\n", stack_size - 2);
+-    }
+-    else {
+-        fprintf(f, "    const unsigned int lnum = GET_ISEQ()->body->local_table_size;\n");
+-        fprintf(f, "    const VALUE *argv = GET_EP() - lnum - VM_ENV_DATA_SIZE + 1 + %ld;\n", index);
+-    }
+-    fprintf(f, "    func f = (func)%"PRIuVALUE"; /* == gc_verify_compaction_references */\n", (VALUE)gc_verify_compaction_references);
+-    fprintf(f, "    val = f(ec, self, argv[0], argv[1]);\n");
+-}
+-
+-static void
+ mjit_compile_invokebuiltin_for__bi0(FILE *f, long index, unsigned stack_size, bool inlinable_p)
+ {
+     fprintf(f, "    VALUE self = GET_SELF();\n");
+@@ -202,7 +143,7 @@
+     if (inlinable_p) {
+         fprintf(f, "%s", "    {\n");
+         fprintf(f, "%s", "    MAYBE_UNUSED(const VALUE) flag = rb_vm_lvar(ec, -3);\n");
+-        fprintf(f, "%s", "#line 277 \"gc.rb\"\n");
++        fprintf(f, "%s", "#line 209 \"gc.rb\"\n");
+         fprintf(f, "%s", "    \n");
+         fprintf(f, "%s", "          rb_objspace.flags.measure_gc = RTEST(flag) ? TRUE : FALSE;\n");
+         fprintf(f, "%s", "          return flag;\n");
+@@ -211,7 +152,7 @@
+         fprintf(f, "%s", "    \n");
+         return;
+     }
+-    fprintf(f, "    func f = (func)%"PRIuVALUE"; /* == builtin_inline_class_277 */\n", (VALUE)builtin_inline_class_277);
++    fprintf(f, "    func f = (func)%"PRIuVALUE"; /* == builtin_inline_class_209 */\n", (VALUE)builtin_inline_class_209);
+     fprintf(f, "    val = f(ec, self);\n");
+ }
+ 
+@@ -222,7 +163,7 @@
+     fprintf(f, "    typedef VALUE (*func)(rb_execution_context_t *, VALUE);\n");
+     if (inlinable_p) {
+         fprintf(f, "%s", "    {\n");
+-        fprintf(f, "%s", "#line 289 \"gc.rb\"\n");
++        fprintf(f, "%s", "#line 221 \"gc.rb\"\n");
+         fprintf(f, "%s", "    return \n");
+         fprintf(f, "%s", "          RBOOL(rb_objspace.flags.measure_gc);\n");
+         fprintf(f, "%s", "#line 52 \"gc.rbinc\"\n");
+@@ -230,7 +171,7 @@
+         fprintf(f, "%s", "    \n");
+         return;
+     }
+-    fprintf(f, "    func f = (func)%"PRIuVALUE"; /* == builtin_inline_class_289 */\n", (VALUE)builtin_inline_class_289);
++    fprintf(f, "    func f = (func)%"PRIuVALUE"; /* == builtin_inline_class_221 */\n", (VALUE)builtin_inline_class_221);
+     fprintf(f, "    val = f(ec, self);\n");
+ }
+ 
+@@ -241,7 +182,7 @@
+     fprintf(f, "    typedef VALUE (*func)(rb_execution_context_t *, VALUE);\n");
+     if (inlinable_p) {
+         fprintf(f, "%s", "    {\n");
+-        fprintf(f, "%s", "#line 299 \"gc.rb\"\n");
++        fprintf(f, "%s", "#line 231 \"gc.rb\"\n");
+         fprintf(f, "%s", "    return \n");
+         fprintf(f, "%s", "          ULL2NUM(rb_objspace.profile.total_time_ns);\n");
+         fprintf(f, "%s", "#line 59 \"gc.rbinc\"\n");
+@@ -249,7 +190,7 @@
+         fprintf(f, "%s", "    \n");
+         return;
+     }
+-    fprintf(f, "    func f = (func)%"PRIuVALUE"; /* == builtin_inline_class_299 */\n", (VALUE)builtin_inline_class_299);
++    fprintf(f, "    func f = (func)%"PRIuVALUE"; /* == builtin_inline_class_231 */\n", (VALUE)builtin_inline_class_231);
+     fprintf(f, "    val = f(ec, self);\n");
+ }
+ 
+@@ -258,21 +199,16 @@
+   // table definition
+   static const struct rb_builtin_function gc_table[] = {
+     RB_BUILTIN_FUNCTION(0, gc_start_internal, gc_start_internal, 4, mjit_compile_invokebuiltin_for_gc_start_internal),
+-    RB_BUILTIN_FUNCTION(1, gc_get_auto_compact, gc_get_auto_compact, 0, mjit_compile_invokebuiltin_for_gc_get_auto_compact),
+-    RB_BUILTIN_FUNCTION(2, gc_set_auto_compact, gc_set_auto_compact, 1, mjit_compile_invokebuiltin_for_gc_set_auto_compact),
+-    RB_BUILTIN_FUNCTION(3, gc_enable, gc_enable, 0, mjit_compile_invokebuiltin_for_gc_enable),
+-    RB_BUILTIN_FUNCTION(4, gc_disable, gc_disable, 0, mjit_compile_invokebuiltin_for_gc_disable),
+-    RB_BUILTIN_FUNCTION(5, gc_stress_get, gc_stress_get, 0, mjit_compile_invokebuiltin_for_gc_stress_get),
+-    RB_BUILTIN_FUNCTION(6, gc_stress_set_m, gc_stress_set_m, 1, mjit_compile_invokebuiltin_for_gc_stress_set_m),
+-    RB_BUILTIN_FUNCTION(7, gc_count, gc_count, 0, mjit_compile_invokebuiltin_for_gc_count),
+-    RB_BUILTIN_FUNCTION(8, gc_stat, gc_stat, 1, mjit_compile_invokebuiltin_for_gc_stat),
+-    RB_BUILTIN_FUNCTION(9, gc_latest_gc_info, gc_latest_gc_info, 1, mjit_compile_invokebuiltin_for_gc_latest_gc_info),
+-    RB_BUILTIN_FUNCTION(10, gc_compact_stats, gc_compact_stats, 0, mjit_compile_invokebuiltin_for_gc_compact_stats),
+-    RB_BUILTIN_FUNCTION(11, gc_compact, gc_compact, 0, mjit_compile_invokebuiltin_for_gc_compact),
+-    RB_BUILTIN_FUNCTION(12, gc_verify_compaction_references, gc_verify_compaction_references, 2, mjit_compile_invokebuiltin_for_gc_verify_compaction_references),
+-    RB_BUILTIN_FUNCTION(13, _bi0, builtin_inline_class_277, 0, mjit_compile_invokebuiltin_for__bi0),
+-    RB_BUILTIN_FUNCTION(14, _bi1, builtin_inline_class_289, 0, mjit_compile_invokebuiltin_for__bi1),
+-    RB_BUILTIN_FUNCTION(15, _bi2, builtin_inline_class_299, 0, mjit_compile_invokebuiltin_for__bi2),
++    RB_BUILTIN_FUNCTION(1, gc_enable, gc_enable, 0, mjit_compile_invokebuiltin_for_gc_enable),
++    RB_BUILTIN_FUNCTION(2, gc_disable, gc_disable, 0, mjit_compile_invokebuiltin_for_gc_disable),
++    RB_BUILTIN_FUNCTION(3, gc_stress_get, gc_stress_get, 0, mjit_compile_invokebuiltin_for_gc_stress_get),
++    RB_BUILTIN_FUNCTION(4, gc_stress_set_m, gc_stress_set_m, 1, mjit_compile_invokebuiltin_for_gc_stress_set_m),
++    RB_BUILTIN_FUNCTION(5, gc_count, gc_count, 0, mjit_compile_invokebuiltin_for_gc_count),
++    RB_BUILTIN_FUNCTION(6, gc_stat, gc_stat, 1, mjit_compile_invokebuiltin_for_gc_stat),
++    RB_BUILTIN_FUNCTION(7, gc_latest_gc_info, gc_latest_gc_info, 1, mjit_compile_invokebuiltin_for_gc_latest_gc_info),
++    RB_BUILTIN_FUNCTION(8, _bi0, builtin_inline_class_209, 0, mjit_compile_invokebuiltin_for__bi0),
++    RB_BUILTIN_FUNCTION(9, _bi1, builtin_inline_class_221, 0, mjit_compile_invokebuiltin_for__bi1),
++    RB_BUILTIN_FUNCTION(10, _bi2, builtin_inline_class_231, 0, mjit_compile_invokebuiltin_for__bi2),
+     RB_BUILTIN_FUNCTION(-1, NULL, NULL, 0, 0),
+   };
+ 
+@@ -282,8 +218,6 @@
+ COMPILER_WARNING_ERROR(-Wincompatible-pointer-types)
+ #endif
+   if (0) rb_builtin_function_check_arity4(gc_start_internal);
+-  if (0) rb_builtin_function_check_arity0(gc_get_auto_compact);
+-  if (0) rb_builtin_function_check_arity1(gc_set_auto_compact);
+   if (0) rb_builtin_function_check_arity0(gc_enable);
+   if (0) rb_builtin_function_check_arity0(gc_disable);
+   if (0) rb_builtin_function_check_arity0(gc_stress_get);
+@@ -291,12 +225,9 @@
+   if (0) rb_builtin_function_check_arity0(gc_count);
+   if (0) rb_builtin_function_check_arity1(gc_stat);
+   if (0) rb_builtin_function_check_arity1(gc_latest_gc_info);
+-  if (0) rb_builtin_function_check_arity0(gc_compact_stats);
+-  if (0) rb_builtin_function_check_arity0(gc_compact);
+-  if (0) rb_builtin_function_check_arity2(gc_verify_compaction_references);
+-  if (0) rb_builtin_function_check_arity0(builtin_inline_class_277);
+-  if (0) rb_builtin_function_check_arity0(builtin_inline_class_289);
+-  if (0) rb_builtin_function_check_arity0(builtin_inline_class_299);
++  if (0) rb_builtin_function_check_arity0(builtin_inline_class_209);
++  if (0) rb_builtin_function_check_arity0(builtin_inline_class_221);
++  if (0) rb_builtin_function_check_arity0(builtin_inline_class_231);
+ COMPILER_WARNING_POP
+ 
+   // load
+--- ruby-3.1.3/miniprelude.c	2022-11-24 11:20:33.000000000 +0100
++++ ruby/miniprelude.c	2022-11-25 11:50:20.012820803 +0100
+@@ -545,11 +545,10 @@
+ 
+ static const char prelude_name2[] = "<internal:gc>";
+ static const struct {
+-    char L0[479]; /* 1..58 */
+-    char L58[508]; /* 59..204 */
+-    char L204[504]; /* 205..275 */
+-    char L275[490]; /* 276..306 */
+-    char L306[128]; /* 307..312 */
++    char L0[492]; /* 1..70 */
++    char L70[468]; /* 71..197 */
++    char L197[470]; /* 198..237 */
++    char L237[211]; /* 238..244 */
+ } prelude_code2 = {
+ #line 1 "gc.rb"
+ ""/* for gc.c */
+@@ -593,29 +592,6 @@
+ "  end\n"
+ "\n"
+ "\n"/*  call-seq: */
+-"\n"/*     GC.auto_compact    -> true or false */
+-"\n"/*  */
+-"\n"/*  Returns whether or not automatic compaction has been enabled. */
+-"\n"/*  */
+-"  def self.auto_compact\n"
+-"    Primitive.gc_get_auto_compact\n"
+-"  end\n"
+-"\n"
+-"\n"/*  call-seq: */
+-"\n"/*     GC.auto_compact = flag */
+-"\n"/*  */
+-"\n"/*  Updates automatic compaction mode. */
+-"\n"/*  */
+-"\n"/*  When enabled, the compactor will execute on every major collection. */
+-"\n"/*  */
+-"\n"/*  Enabling compaction will degrade performance on major collections. */
+-"  def self.auto_compact=(flag)\n"
+-,
+-#line 59 "gc.rb"
+-"    Primitive.gc_set_auto_compact(flag)\n"
+-"  end\n"
+-"\n"
+-"\n"/*  call-seq: */
+ "\n"/*     GC.enable    -> true or false */
+ "\n"/*  */
+ "\n"/*  Enables garbage collection, returning +true+ if garbage */
+@@ -645,6 +621,8 @@
+ "\n"/*    GC.stress	    -> integer, true or false */
+ "\n"/*  */
+ "\n"/*  Returns current status of GC stress mode. */
++,
++#line 71 "gc.rb"
+ "  def self.stress\n"
+ "    Primitive.gc_stress_get\n"
+ "  end\n"
+@@ -758,8 +736,6 @@
+ "\n"/*     GC.latest_gc_info(:major_by) -> :malloc */
+ "\n"/*  */
+ "\n"/*  Returns information about the most recent garbage collection. */
+-,
+-#line 205 "gc.rb"
+ "\n"/*  */
+ "\n"/* If the optional argument, hash, is given, */
+ "\n"/* it is overwritten and returned. */
+@@ -768,59 +744,14 @@
+ "    Primitive.gc_latest_gc_info hash_or_key\n"
+ "  end\n"
+ "\n"
+-"\n"/*  call-seq: */
+-"\n"/*     GC.latest_compact_info -> {:considered=>{:T_CLASS=>11}, :moved=>{:T_CLASS=>11}} */
+-"\n"/*  */
+-"\n"/*  Returns information about object moved in the most recent GC compaction. */
+-"\n"/*  */
+-"\n"/* The returned hash has two keys :considered and :moved.  The hash for */
+-"\n"/* :considered lists the number of objects that were considered for movement */
+-"\n"/* by the compactor, and the :moved hash lists the number of objects that */
+-"\n"/* were actually moved.  Some objects can't be moved (maybe they were pinned) */
+-"\n"/* so these numbers can be used to calculate compaction efficiency. */
+-"  def self.latest_compact_info\n"
+-"    Primitive.gc_compact_stats\n"
+-"  end\n"
+-"\n"
+-"\n"/*  call-seq: */
+-"\n"/*     GC.compact */
+-"\n"/*  */
+-"\n"/* This function compacts objects together in Ruby's heap.  It eliminates */
+-"\n"/* unused space (or fragmentation) in the heap by moving objects in to that */
+-"\n"/* unused space.  This function returns a hash which contains statistics about */
+-"\n"/* which objects were moved.  See `GC.latest_gc_info` for details about */
+-"\n"/* compaction statistics. */
+-"\n"/*  */
+-"\n"/* This method is implementation specific and not expected to be implemented */
+-"\n"/* in any implementation besides MRI. */
+-"  def self.compact\n"
+-"    Primitive.gc_compact\n"
+-"  end\n"
+-"\n"
+-"\n"/* call-seq: */
+-"\n"/*    GC.verify_compaction_references(toward: nil, double_heap: false) -> hash */
+-"\n"/*  */
+-"\n"/* Verify compaction reference consistency. */
+-"\n"/*  */
+-"\n"/* This method is implementation specific.  During compaction, objects that */
+-"\n"/* were moved are replaced with T_MOVED objects.  No object should have a */
+-"\n"/* reference to a T_MOVED object after compaction. */
+-"\n"/*  */
+-"\n"/* This function doubles the heap to ensure room to move all objects, */
+-"\n"/* compacts the heap to make sure everything moves, updates all references, */
+-"\n"/* then performs a full GC.  If any object contains a reference to a T_MOVED */
+-"\n"/* object, that object should be pushed on the mark stack, and will */
+-"\n"/* make a SEGV. */
+-"  def self.verify_compaction_references(toward: nil, double_heap: false)\n"
+-"    Primitive.gc_verify_compaction_references(double_heap, toward == :empty)\n"
+-"  end\n"
+-"\n"
+ "\n"/* call-seq: */
+ "\n"/*     GC.using_rvargc? -> true or false */
+ "\n"/*  */
+ "\n"/* Returns true if using experimental feature Variable Width Allocation, false */
+ "\n"/* otherwise. */
+ "  def self.using_rvargc?\n"/* :nodoc: */
++,
++#line 198 "gc.rb"
+ "    GC::INTERNAL_CONSTANTS[:SIZE_POOL_COUNT] > 1\n"
+ "  end\n"
+ "\n"
+@@ -831,8 +762,6 @@
+ "\n"/* Enable to measure GC time. */
+ "\n"/* You can get the result with <tt>GC.stat(:time)</tt>. */
+ "\n"/* Note that GC time measurement can cause some performance overhead. */
+-,
+-#line 276 "gc.rb"
+ "  def self.measure_total_time=(flag)\n"
+ "    Primitive.cstmt! %{\n"
+ "      rb_objspace.flags.measure_gc = RTEST(flag) ? TRUE : FALSE;\n"
+@@ -863,15 +792,15 @@
+ "end\n"
+ "\n"
+ "module ObjectSpace\n"
+-"  def garbage_collect full_mark: true, immediate_mark: true, immediate_sweep: true\n"
+ ,
+-#line 307 "gc.rb"
++#line 238 "gc.rb"
++"  def garbage_collect full_mark: true, immediate_mark: true, immediate_sweep: true\n"
+ "    Primitive.gc_start_internal full_mark, immediate_mark, immediate_sweep, false\n"
+ "  end\n"
+ "\n"
+ "  module_function :garbage_collect\n"
+ "end\n"
+-#line 875 "miniprelude.c"
++#line 804 "miniprelude.c"
+ };
+ 
+ static const char prelude_name3[] = "<internal:numeric>";
+@@ -1223,7 +1152,7 @@
+ "  end\n"
+ "\n"
+ "end\n"
+-#line 1227 "miniprelude.c"
++#line 1156 "miniprelude.c"
+ };
+ 
+ static const char prelude_name4[] = "<internal:io>";
+@@ -1354,7 +1283,7 @@
+ "    Primitive.io_write_nonblock(buf, exception)\n"
+ "  end\n"
+ "end\n"
+-#line 1358 "miniprelude.c"
++#line 1287 "miniprelude.c"
+ };
+ 
+ static const char prelude_name5[] = "<internal:marshal>";
+@@ -1402,7 +1331,7 @@
+ "    alias restore load\n"
+ "  end\n"
+ "end\n"
+-#line 1406 "miniprelude.c"
++#line 1335 "miniprelude.c"
+ };
+ 
+ static const char prelude_name6[] = "<internal:pack>";
+@@ -1724,7 +1653,7 @@
+ "    Primitive.pack_unpack1(fmt, offset)\n"
+ "  end\n"
+ "end\n"
+-#line 1728 "miniprelude.c"
++#line 1657 "miniprelude.c"
+ };
+ 
+ static const char prelude_name7[] = "<internal:trace_point>";
+@@ -2111,7 +2040,7 @@
+ "    Primitive.tracepoint_attr_instruction_sequence\n"
+ "  end\n"
+ "end\n"
+-#line 2115 "miniprelude.c"
++#line 2044 "miniprelude.c"
+ };
+ 
+ static const char prelude_name8[] = "<internal:warning>";
+@@ -2172,7 +2101,7 @@
+ "    Primitive.rb_warn_m(msgs, uplevel, category)\n"
+ "  end\n"
+ "end\n"
+-#line 2176 "miniprelude.c"
++#line 2105 "miniprelude.c"
+ };
+ 
+ static const char prelude_name9[] = "<internal:array>";
+@@ -2249,7 +2178,7 @@
+ "    end\n"
+ "  end\n"
+ "end\n"
+-#line 2253 "miniprelude.c"
++#line 2182 "miniprelude.c"
+ };
+ 
+ static const char prelude_name10[] = "<internal:kernel>";
+@@ -2438,7 +2367,7 @@
+ "    end\n"
+ "  end\n"
+ "end\n"
+-#line 2442 "miniprelude.c"
++#line 2371 "miniprelude.c"
+ };
+ 
+ static const char prelude_name11[] = "<internal:ractor>";
+@@ -3309,7 +3238,7 @@
+ "    }\n"
+ "  end\n"
+ "end\n"
+-#line 3313 "miniprelude.c"
++#line 3242 "miniprelude.c"
+ };
+ 
+ static const char prelude_name12[] = "<internal:timev>";
+@@ -3632,7 +3561,7 @@
+ "    Primitive.time_init_args(year, mon, mday, hour, min, sec, zone)\n"
+ "  end\n"
+ "end\n"
+-#line 3636 "miniprelude.c"
++#line 3565 "miniprelude.c"
+ };
+ 
+ static const char prelude_name13[] = "<internal:nilclass>";
+@@ -3665,7 +3594,7 @@
+ "    return 0.0\n"
+ "  end\n"
+ "end\n"
+-#line 3669 "miniprelude.c"
++#line 3598 "miniprelude.c"
+ };
+ 
+ static const char prelude_name14[] = "<internal:prelude>";
+@@ -3695,7 +3624,7 @@
+ "\n"
+ "  private :pp\n"
+ "end\n"
+-#line 3699 "miniprelude.c"
++#line 3628 "miniprelude.c"
+ };
+ 
+ static const char prelude_name15[] = "<internal:gem_prelude>";
+@@ -3722,7 +3651,7 @@
+ "rescue LoadError\n"
+ "  warn \"`did_you_mean' was not loaded.\"\n"
+ "end if defined?(DidYouMean)\n"
+-#line 3726 "miniprelude.c"
++#line 3655 "miniprelude.c"
+ };
+ 
+ static const char prelude_name16[] = "<internal:yjit>";
+@@ -4063,7 +3992,7 @@
+ "    end\n"
+ "  end\n"
+ "end\n"
+-#line 4067 "miniprelude.c"
++#line 3996 "miniprelude.c"
+ };
+ 
+ COMPILER_WARNING_POP

ruby-bundler-2.4.0-bundle-update-bundler-test-in-ruby.patch

@@ -1,31 +0,0 @@
-From bfa2f72cfa3bfde34049d26dcb24976316074ad7 Mon Sep 17 00:00:00 2001
-From: Jun Aruga <jaruga@redhat.com>
-Date: Mon, 21 Mar 2022 15:36:51 +0100
-Subject: [PATCH] Fix a test for `bin/bundle update --bundler` to pass on
- ruby/ruby.
-
-Consider the case that the latest Bundler version on RubyGems is higher than
-the `system_bundler_version` (= `Bundler::VERSION`) in `make test-bundler` on
-ruby/ruby.
-
-See <https://bugs.ruby-lang.org/issues/18643>.
----
- spec/bundler/commands/binstubs_spec.rb | 5 ++++-
- 1 file changed, 4 insertions(+), 1 deletion(-)
-
-diff --git a/spec/bundler/commands/binstubs_spec.rb b/spec/bundler/commands/binstubs_spec.rb
-index 198226207bc..2634f43417c 100644
---- a/spec/bundler/commands/binstubs_spec.rb
-+++ b/spec/bundler/commands/binstubs_spec.rb
-@@ -226,7 +226,10 @@
- 
-         it "calls through to the latest bundler version" do
-           sys_exec "bin/bundle update --bundler", :env => { "DEBUG" => "1" }
--          expect(out).to include %(Using bundler #{system_bundler_version}\n)
-+          using_bundler_line = /Using bundler ([\w\.]+)\n/.match(out)
-+          expect(using_bundler_line).to_not be_nil
-+          latest_version = using_bundler_line[1]
-+          expect(Gem::Version.new(latest_version)).to be >= Gem::Version.new(system_bundler_version)
-         end
- 
-         it "calls through to the explicit bundler version" do

ruby-irb-1.4.1-drop-rdoc-hard-dep.patch

@@ -0,0 +1,24 @@
+From 54c8df06ff9e161012f89d19a4e3aa2e0e37e1b0 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?V=C3=ADt=20Ondruch?= <vondruch@redhat.com>
+Date: Tue, 23 Aug 2022 10:41:28 +0200
+Subject: [PATCH] Drop hard dependency on RDoc.
+
+This has been introduced in 026700499dfd640b2072d7bf0370247a98d5ac40,
+but it seems that this is just be mistake, otherwise the later handling
+of `LoadError` would not be needed.
+---
+ lib/irb/input-method.rb | 1 -
+ 1 file changed, 1 deletion(-)
+
+diff --git a/lib/irb/input-method.rb b/lib/irb/input-method.rb
+index fd68239e..a8227caa 100644
+--- a/lib/irb/input-method.rb
++++ b/lib/irb/input-method.rb
+@@ -14,7 +14,6 @@
+ require_relative 'completion'
+ require 'io/console'
+ require 'reline'
+-require 'rdoc'
+ 
+ module IRB
+   STDIN_FILE_NAME = "(line)" # :nodoc:

ruby-irb-1.4.1-set-rdoc-soft-dep.patch

@@ -0,0 +1,35 @@
+From b24852058fc87c940252c8a711c60ae2eb298082 Mon Sep 17 00:00:00 2001
+From: Jun Aruga <jaruga@redhat.com>
+Date: Thu, 25 Aug 2022 20:11:34 +0200
+Subject: [PATCH] Require RDoc in `input-method.rb` again in a limited scope.
+
+RDoc is implemented as soft dependency in IRB. See how the rdoc is required in
+the files. I reverted the commit below.
+
+```
+$ grep -ril rdoc lib/
+lib/irb/cmd/help.rb
+lib/irb/completion.rb
+lib/irb/easter-egg.rb
+lib/irb/input-method.rb
+```
+---
+ lib/irb/input-method.rb | 5 +++++
+ 1 file changed, 5 insertions(+)
+
+diff --git a/lib/irb/input-method.rb b/lib/irb/input-method.rb
+index a8227ca..b77fd32 100644
+--- a/lib/irb/input-method.rb
++++ b/lib/irb/input-method.rb
+@@ -320,6 +320,11 @@ def auto_indent(&block)
+         [195, 164], # The "ä" that appears when Alt+d is pressed on xterm.
+         [226, 136, 130] # The "∂" that appears when Alt+d in pressed on iTerm2.
+       ]
++      begin
++        require 'rdoc'
++      rescue LoadError
++        return nil
++      end
+ 
+       if just_cursor_moving and completion_journey_data.nil?
+         return nil

ruby.spec

@@ -1,6 +1,6 @@
 %global major_version 3
 %global minor_version 1
-%global teeny_version 2
+%global teeny_version 4
 %global major_minor_version %{major_version}.%{minor_version}
 
 %global ruby_version %{major_minor_version}.%{teeny_version}
@@ -22,7 +22,7 @@
 %endif
 
 
-%global release 164
+%global release 175
 %{!?release_string:%define release_string %{?development_release:0.}%{release}%{?development_release:.%{development_release}}%{?dist}}
 
 # The RubyGems library has to stay out of Ruby directory tree, since the
@@ -30,20 +30,22 @@
 %global rubygems_dir %{_datadir}/rubygems
 
 # Bundled libraries versions
-%global rubygems_version 3.3.7
+%global rubygems_version 3.3.26
 %global rubygems_molinillo_version 0.7.0
+%global rubygems_optparse_version 0.2.0
+%global rubygems_tsort_version 0.1.0
 
 # Default gems.
-%global bundler_version 2.3.7
+%global bundler_version 2.3.26
 %global bundler_connection_pool_version 2.3.0
 %global bundler_fileutils_version 1.4.1
-%global bundler_molinillo_version 0.7.0
+%global bundler_molinillo_version 0.8.0
 %global bundler_net_http_persistent_version 4.0.0
 %global bundler_thor_version 1.2.1
 %global bundler_tmpdir_version 0.1.0
 # TODO: Check the version if/when available in library.
 %global bundler_tsort_version 0.1.1
-%global bundler_uri_version 0.10.1
+%global bundler_uri_version 0.10.2
 
 %global bigdecimal_version 3.1.1
 %global did_you_mean_version 1.6.1
@@ -51,8 +53,8 @@
 %global io_console_version 0.5.11
 %global irb_version 1.4.1
 %global json_version 2.6.1
-%global openssl_version 3.0.0
-%global psych_version 4.0.3
+%global openssl_version 3.0.1
+%global psych_version 4.0.4
 %global racc_version 1.6.0
 %global rdoc_version 6.4.0
 %global stringio_version 3.0.1
@@ -70,9 +72,9 @@
 %global net_smtp_version 0.3.1
 %global matrix_version 0.4.2
 %global prime_version 0.1.2
-%global rbs_version 2.1.0
-%global typeprof_version 0.21.2
-%global debug_version 1.4.0
+%global rbs_version 2.7.0
+%global typeprof_version 0.21.3
+%global debug_version 1.6.3
 
 %global tapset_libdir %(echo %{_libdir} | sed 's/64//')*
 
@@ -143,8 +145,6 @@ Patch3: ruby-2.1.0-always-use-i386.patch
 # Allows to install RubyGems into custom directory, outside of Ruby's tree.
 # http://bugs.ruby-lang.org/issues/5617
 Patch4: ruby-2.1.0-custom-rubygems-location.patch
-# Make mkmf verbose by default
-Patch5: ruby-1.9.3-mkmf-verbose.patch
 # The ABRT hook used to be initialized by preludes via following patches:
 # https://bugs.ruby-lang.org/issues/8566
 # https://bugs.ruby-lang.org/issues/15306
@@ -163,14 +163,48 @@ Patch7: ruby-3.1.0-Don-t-query-RubyVM-FrozenCore-for-class-path.patch
 # Avoid possible timeout errors in TestBugReporter#test_bug_reporter_add.
 # https://bugs.ruby-lang.org/issues/16492
 Patch19: ruby-2.7.1-Timeout-the-test_bug_reporter_add-witout-raising-err.patch
-# Fix a test for `bin/bundle update --bundler` in `make test-bundler`.
-# https://bugs.ruby-lang.org/issues/18643
-# https://github.com/rubygems/rubygems/commit/bfa2f72cfa3bfde34049d26dcb24976316074ad7
-Patch20: ruby-bundler-2.4.0-bundle-update-bundler-test-in-ruby.patch
-# Workaround gem binary extensions build and installation issues.
-# https://bugs.ruby-lang.org/issues/18373
-# https://github.com/ruby/ruby/pull/5774
-Patch21: ruby-3.2.0-Build-extension-libraries-in-bundled-gems.patch
+# If GC compaction is not supported on platform, define the
+# corresponding GC methods as not implemented.
+# https://bugs.ruby-lang.org/issues/18779
+# https://github.com/ruby/ruby/pull/5934
+Patch22: ruby-3.2.0-define-unsupported-gc-compaction-methods-as-rb_f_notimplement.patch
+# To regenerate the patch you need to have ruby, autoconf, xz, tar and make installed:
+# tar -Jxvf ./ruby-3.1.4.tar.xz
+# git clone https://github.com/ruby/ruby.git
+# cd ruby && git checkout v3_1_4
+# patch -p1 < ../ruby-3.2.0-define-unsupported-gc-compaction-methods-as-rb_f_notimplement.patch
+# ./autogen.sh && ./configure
+# make gc.rbinc miniprelude.c
+# cd ..
+# diff -u {ruby-3.1.4,ruby}/gc.rbinc > ruby-3.2.0-define-unsupported-gc-compaction-methods_generated-files.patch
+# diff -u {ruby-3.1.4,ruby}/miniprelude.c >> ruby-3.2.0-define-unsupported-gc-compaction-methods_generated-files.patch
+Patch23: ruby-3.2.0-define-unsupported-gc-compaction-methods_generated-files.patch
+# Define the GC compaction support macro at run time.
+# https://bugs.ruby-lang.org/issues/18829
+# https://github.com/ruby/ruby/pull/6019
+# https://github.com/ruby/ruby/commit/2c190863239bee3f54cfb74b16bb6ea4cae6ed20
+Patch24: ruby-3.2.0-Detect-compaction-support-during-runtime.patch
+# Drop hard dependency on RDoc in IRB.
+# https://github.com/ruby/irb/pull/393
+Patch27: ruby-irb-1.4.1-drop-rdoc-hard-dep.patch
+# Set soft dependency on RDoc in input-method.rb in IRB.
+# https://github.com/ruby/irb/pull/395
+Patch28: ruby-irb-1.4.1-set-rdoc-soft-dep.patch
+# A Weakmap test uses compaction without safeguarding if the method is defined.
+# This test should be skipped if compaction is not supported on the platform.
+# https://github.com/ruby/ruby/commit/bffadcd6d46ccfccade79ce0efb60ced8eac4483
+# https://bugs.ruby-lang.org/issues/19529#note-7
+Patch29: ruby-3.1.4-Skip-test_compaction_bug_19529-if-compaction-unsupported.patch
+# Bundler does not correctly resolve archful gems in 2.3.26.
+# Example of such an issue
+# https://github.com/sclorg/s2i-ruby-container/issues/469
+# The patch is an amalgamation of the following:
+# https://github.com/rubygems/rubygems/pull/6225
+# https://github.com/rubygems/rubygems/commit/7b64c64262a7a980c0eb23b96ea56cf72ea06e89
+# Backport requested in
+# https://bugs.ruby-lang.org/issues/19576
+Patch30: rubygem-bundler-2.3.26-Provide-fix-for-bundler-Gemfile-resolving-regression.patch
+Patch31: rubygem-bundler-2.3.26-Tests-from-bundler-PR-6225.patch
 
 Requires: %{name}-libs%{?_isa} = %{version}-%{release}
 Suggests: rubypick
@@ -323,6 +357,7 @@ Requires:   ruby(rubygems) >= %{rubygems_version}
 # ruby-default-gems is required to run irb.
 # https://bugs.ruby-lang.org/issues/16951
 Requires:   ruby-default-gems >= %{ruby_version}
+Recommends: rubygem(rdoc) >= %{rdoc_version}
 Provides:   irb = %{version}-%{release}
 Provides:   rubygem(irb) = %{version}-%{release}
 # Obsoleted by Ruby 2.6 in F30 timeframe.
@@ -462,6 +497,8 @@ many machines, systematically and repeatably.
 %package bundled-gems
 Summary:    Bundled gems which are part of Ruby StdLib
 Requires:   ruby(rubygems) >= %{rubygems_version}
+# Runtime dependency of rubygem(debug).
+Recommends: rubygem(irb) >= %{irb_version}
 Provides:   rubygem(net-ftp) = %{net_ftp_version}
 Provides:   rubygem(net-imap) = %{net_imap_version}
 Provides:   rubygem(net-pop) = %{net_pop_version}
@@ -631,18 +668,20 @@ rm -rf ext/fiddle/libffi*
 %patch2 -p1
 %patch3 -p1
 %patch4 -p1
-%patch5 -p1
 %patch6 -p1
 %patch7 -p1
 %patch19 -p1
-%patch20 -p1
+%patch22 -p1
+%patch23 -p1
+%patch24 -p1
+%patch27 -p1
+%patch28 -p1
+%patch29 -p1
+%patch30 -p2
 
-# Once the upstream tarball contains the files on the right place, this code
-# won't be necessary. This should happen at the same moment when the patch21
-# is not needed anymore.
-mkdir .bundle/specifications
-find .bundle/gems -name '*-[0-9]*.gemspec' -exec cp -t .bundle/specifications/ {} +
-%patch21 -p1
+pushd spec/bundler
+%patch31 -p3
+popd
 
 # Provide an example of usage of the tapset:
 cp -a %{SOURCE3} .
@@ -666,13 +705,14 @@ autoconf
         --with-ruby-pc='%{name}.pc' \
         --with-compress-debug-sections=no \
         --disable-rpath \
+        --enable-mkmf-verbose \
         --enable-shared \
         --with-ruby-version='' \
         --enable-multiarch \
 
-# Q= makes the build output more verbose and allows to check Fedora
-# compiler options.
-%make_build COPY="cp -p" Q=
+# V=1 in %%make_build outputs the compiler options more verbosely.
+# https://bugs.ruby-lang.org/issues/18756
+%make_build COPY="cp -p"
 
 %install
 rm -rf %{buildroot}
@@ -859,6 +899,21 @@ checksec --file=libruby.so.%{ruby_version} | \
   puts Gem::Resolver::Molinillo::VERSION\\\"\" | tail -1`" \
   == '%{rubygems_molinillo_version}' ]
 
+# OptParse.
+make runruby TESTRUN_SCRIPT="-e \" \
+  module Gem; end; \
+  require 'rubygems/optparse/lib/optparse'; \
+  puts '%%{rubygems_optparse_version}: %{rubygems_optparse_version}'; \
+  puts %Q[Gem::OptionParser::Version: #{Gem::OptionParser::Version}]; \
+  exit 1 if Gem::OptionParser::Version != '%{rubygems_optparse_version}'; \
+\""
+
+# tsort
+# TODO: Provide some real version test if version is available.
+make runruby TESTRUN_SCRIPT="-e \" \
+  module Gem; end;\
+  require 'rubygems/tsort/lib/tsort'\""
+
 # Check Bundler bundled dependencies versions.
 
 # connection_pool.
@@ -930,9 +985,6 @@ MSPECOPTS=""
 # Avoid `hostname' dependency.
 %{!?with_hostname:MSPECOPTS="-P 'Socket.gethostname returns the host name'"}
 
-# https://bugs.ruby-lang.org/issues/18380
-DISABLE_TESTS="$DISABLE_TESTS -n !/TestAddressResolve#test_socket_getnameinfo_domain_blocking/"
-
 %ifarch armv7hl
 # TestReadline#test_interrupt_in_other_thread fails on 32 bit arches according
 # to upstream, but the test is disabled just on Travis, not in test suite.
@@ -944,6 +996,9 @@ DISABLE_TESTS="$DISABLE_TESTS -n !/TestReadline#test_interrupt_in_other_thread/"
 # other components are fixed.
 # https://bugzilla.redhat.com/show_bug.cgi?id=2040380
 mv test/fiddle/test_import.rb{,.disable}
+mv test/fiddle/test_closure.rb{,.disable}
+DISABLE_TESTS="$DISABLE_TESTS -n !/Fiddle::TestFunc#test_qsort1/"
+DISABLE_TESTS="$DISABLE_TESTS -n !/Fiddle::TestFunction#test_argument_count/"
 
 # Give an option to increase the timeout in tests.
 # https://bugs.ruby-lang.org/issues/16921
@@ -1201,8 +1256,8 @@ mv test/fiddle/test_import.rb{,.disable}
 %{gem_dir}/specifications/default/abbrev-0.1.0.gemspec
 %{gem_dir}/specifications/default/base64-0.1.1.gemspec
 %{gem_dir}/specifications/default/benchmark-0.2.0.gemspec
-%{gem_dir}/specifications/default/cgi-0.3.1.gemspec
-%{gem_dir}/specifications/default/csv-3.2.2.gemspec
+%{gem_dir}/specifications/default/cgi-0.3.6.gemspec
+%{gem_dir}/specifications/default/csv-3.2.5.gemspec
 %{gem_dir}/specifications/default/date-3.2.2.gemspec
 %{gem_dir}/specifications/default/delegate-0.2.0.gemspec
 %{gem_dir}/specifications/default/did_you_mean-%{did_you_mean_version}.gemspec
@@ -1223,7 +1278,7 @@ mv test/fiddle/test_import.rb{,.disable}
 %{gem_dir}/specifications/default/ipaddr-1.2.4.gemspec
 %{gem_dir}/specifications/default/logger-1.5.0.gemspec
 %{gem_dir}/specifications/default/mutex_m-0.1.1.gemspec
-%{gem_dir}/specifications/default/net-http-0.2.0.gemspec
+%{gem_dir}/specifications/default/net-http-0.3.0.gemspec
 %{gem_dir}/specifications/default/net-protocol-0.1.2.gemspec
 %{gem_dir}/specifications/default/nkf-0.1.1.gemspec
 %{gem_dir}/specifications/default/observer-0.1.1.gemspec
@@ -1239,12 +1294,12 @@ mv test/fiddle/test_import.rb{,.disable}
 %{gem_dir}/specifications/default/racc-%{racc_version}.gemspec
 %{gem_dir}/specifications/default/readline-0.0.3.gemspec
 %{gem_dir}/specifications/default/readline-ext-0.1.4.gemspec
-%{gem_dir}/specifications/default/reline-0.3.0.gemspec
+%{gem_dir}/specifications/default/reline-0.3.1.gemspec
 %{gem_dir}/specifications/default/resolv-0.2.1.gemspec
 %{gem_dir}/specifications/default/resolv-replace-0.1.0.gemspec
 %{gem_dir}/specifications/default/rinda-0.1.1.gemspec
 %{gem_dir}/specifications/default/ruby2_keywords-0.0.5.gemspec
-%{gem_dir}/specifications/default/securerandom-0.1.1.gemspec
+%{gem_dir}/specifications/default/securerandom-0.2.0.gemspec
 %{gem_dir}/specifications/default/set-1.0.2.gemspec
 %{gem_dir}/specifications/default/shellwords-0.1.0.gemspec
 %{gem_dir}/specifications/default/singleton-0.1.1.gemspec
@@ -1252,12 +1307,12 @@ mv test/fiddle/test_import.rb{,.disable}
 %{gem_dir}/specifications/default/strscan-3.0.1.gemspec
 %{gem_dir}/specifications/default/syslog-0.1.0.gemspec
 %{gem_dir}/specifications/default/tempfile-0.1.2.gemspec
-%{gem_dir}/specifications/default/time-0.2.0.gemspec
+%{gem_dir}/specifications/default/time-0.2.2.gemspec
 %{gem_dir}/specifications/default/timeout-0.2.0.gemspec
 %{gem_dir}/specifications/default/tmpdir-0.1.2.gemspec
 %{gem_dir}/specifications/default/tsort-0.1.0.gemspec
 %{gem_dir}/specifications/default/un-0.2.0.gemspec
-%{gem_dir}/specifications/default/uri-0.11.0.gemspec
+%{gem_dir}/specifications/default/uri-0.12.1.gemspec
 %{gem_dir}/specifications/default/weakref-0.1.1.gemspec
 #%%{gem_dir}/specifications/default/win32ole-1.8.8.gemspec
 %{gem_dir}/specifications/default/yaml-0.2.0.gemspec
@@ -1343,7 +1398,6 @@ mv test/fiddle/test_import.rb{,.disable}
 %doc %{gem_dir}/gems/debug-%{debug_version}/README.md
 %{gem_dir}/gems/debug-%{debug_version}/Rakefile
 %doc %{gem_dir}/gems/debug-%{debug_version}/TODO.md
-%{gem_dir}/gems/debug-%{debug_version}/bin
 %{gem_dir}/gems/debug-%{debug_version}/exe
 %{gem_dir}/gems/debug-%{debug_version}/lib
 %{gem_dir}/gems/debug-%{debug_version}/misc
@@ -1434,7 +1488,7 @@ mv test/fiddle/test_import.rb{,.disable}
 %license %{gem_dir}/gems/rbs-%{rbs_version}/BSDL
 %doc %{gem_dir}/gems/rbs-%{rbs_version}/CHANGELOG.md
 %license %{gem_dir}/gems/rbs-%{rbs_version}/COPYING
-%{gem_dir}/gems/rbs-%{rbs_version}/Gemfile
+%{gem_dir}/gems/rbs-%{rbs_version}/Gemfile*
 %doc %{gem_dir}/gems/rbs-%{rbs_version}/README.md
 %{gem_dir}/gems/rbs-%{rbs_version}/Rakefile
 %{gem_dir}/gems/rbs-%{rbs_version}/Steepfile
@@ -1491,7 +1545,6 @@ mv test/fiddle/test_import.rb{,.disable}
 %{gem_dir}/gems/typeprof-%{typeprof_version}/lib
 %doc %{gem_dir}/gems/typeprof-%{typeprof_version}/tools
 %exclude %{gem_dir}/gems/typeprof-%{typeprof_version}/typeprof-lsp
-%exclude %{gem_dir}/gems/typeprof-%{typeprof_version}/vscode
 %{gem_dir}/specifications/typeprof-%{typeprof_version}.gemspec
 %doc %{gem_dir}/gems/typeprof-%{typeprof_version}/Gemfile*
 %doc %{gem_dir}/gems/typeprof-%{typeprof_version}/README.md
@@ -1499,6 +1552,48 @@ mv test/fiddle/test_import.rb{,.disable}
 
 
 %changelog
+* Fri Mar 31 2023 Jarek Prokop jprokop@redhat.com - 3.1.4-175
+- Upgrade to Ruby 3.1.4.
+- Fix ReDoS vulnerability in URI (CVE-2023-28755)
+- Fix ReDoS vulnerability in Time (CVE-2023-28756)
+- Fix bundler improperly resolving archful gems in Gemfile.lock.
+  Resolves: rhbz#2178171
+
+* Fri Jan 20 2023 Jun Aruga <jaruga@redhat.com> - 3.1.3-174
+- Fix for tzdata-2022g.
+
+* Thu Dec 08 2022 Vít Ondruch <vondruch@redhat.com> - 3.1.3-173
+- Fix CGI causing issue with leading '.' in domain names.
+
+* Thu Nov 24 2022 Vít Ondruch <vondruch@redhat.com> - 3.1.3-172
+- Upgrade to Ruby 3.1.3.
+
+* Thu Nov 03 2022 Jun Aruga <jaruga@redhat.com> - 3.1.2-170
+- Bypass git submodule test failure on Git >= 2.38.1.
+
+* Fri Sep 02 2022 Jarek Prokop <jprokop@redhat.com> - 3.1.2-169
+- Disable fiddle tests that use FFI closures.
+  Related: rhbz#2040380
+
+* Mon Aug 29 2022 Jun Aruga <jaruga@redhat.com> - 3.1.2-168
+- Make RDoc soft dependnecy in IRB.
+  Resolves: rhbz#2119964
+- Add IRB to ruby-bundled-gems recommends.
+  Resolves: rhbz#2120562
+
+* Wed Aug 24 2022 Jun Aruga <jaruga@redhat.com> - 3.1.2-168
+- Fix tests with Europe/Amsterdam pre-1970 time on tzdata version 2022b.
+  Resolves: rhbz#2120354
+
+* Mon Jul 25 2022 Jarek Prokop <jprokop@redhat.com> - 3.1.2-167
+- Fix directory permissions in one of the rubygems tests.
+
+* Thu Jun 16 2022 Jarek Prokop <jprokop@redhat.com> - 3.1.2-166
+- Detect compaction support during run time.
+
+* Tue Jun 07 2022 Jarek Prokop <jprokop@redhat.com> - 3.1.2-165
+- Define GC compaction methods as rb_f_notimplement on unsupported platforms.
+
 * Thu Apr 14 2022 Vít Ondruch <vondruch@redhat.com> - 3.1.2-164
 - Upgrade to Ruby 3.1.2.
 - Use upstream patch for correct build of gem extensions.

rubygem-bundler-2.3.26-Provide-fix-for-bundler-Gemfile-resolving-regression.patch

@@ -0,0 +1,144 @@
+From 0985592ad2d815ac461100807f5b2621e5f49b21 Mon Sep 17 00:00:00 2001
+From: Jarek Prokop <jprokop@redhat.com>
+Date: Fri, 31 Mar 2023 11:54:07 +0200
+Subject: [PATCH 1/2] Provide fix for bundler Gemfile resolving regression.
+
+Instead of resolving to correct Ruby platform, it preferred the
+archful package, that is actually incompatible.
+
+See https://github.com/sclorg/s2i-ruby-container/issues/469
+for an example of the bug.
+
+Commit taken from:
+<https://github.com/rubygems/rubygems/pull/6225>
+and adapted:
+<https://github.com/rubygems/rubygems/commit/7b64c64262a7a980c0eb23b96ea56cf72ea06e89>
+for the PR#6225.
+---
+ bundler/lib/bundler/index.rb              |  5 ++
+ bundler/lib/bundler/lazy_specification.rb | 64 ++++++++++-------------
+ 2 files changed, 34 insertions(+), 35 deletions(-)
+
+diff --git a/bundler/lib/bundler/index.rb b/bundler/lib/bundler/index.rb
+index ed16c90a3..903e220d5 100644
+--- a/bundler/lib/bundler/index.rb
++++ b/bundler/lib/bundler/index.rb
+@@ -71,6 +71,7 @@ def local_search(query)
+       when Gem::Specification, RemoteSpecification, LazySpecification, EndpointSpecification then search_by_spec(query)
+       when String then specs_by_name(query)
+       when Gem::Dependency then search_by_dependency(query)
++      when Array then search_by_name_and_version(*query)
+       else
+         raise "You can't search for a #{query.inspect}."
+       end
+@@ -173,6 +174,10 @@ def search_by_dependency(dependency)
+       end
+     end
+ 
++    def search_by_name_and_version(name, version)
++      specs_by_name(name).select { |spec| spec.version == version }
++    end
++
+     EMPTY_SEARCH = [].freeze
+ 
+     def search_by_spec(spec)
+diff --git a/bundler/lib/bundler/lazy_specification.rb b/bundler/lib/bundler/lazy_specification.rb
+index 949e8264b..e8bee25ab 100644
+--- a/bundler/lib/bundler/lazy_specification.rb
++++ b/bundler/lib/bundler/lazy_specification.rb
+@@ -13,7 +13,6 @@ def initialize(name, version, platform, source = nil)
+       @dependencies  = []
+       @platform      = platform || Gem::Platform::RUBY
+       @source        = source
+-      @specification = nil
+     end
+ 
+     def full_name
+@@ -76,37 +75,41 @@ def to_lock
+     def materialize_for_installation
+       source.local!
+ 
+-      candidates = if source.is_a?(Source::Path) || !ruby_platform_materializes_to_ruby_platform?
+-        target_platform = ruby_platform_materializes_to_ruby_platform? ? platform : local_platform
++      matching_specs = source.specs.search(use_exact_resolved_specifications? ? self : [name, version])
++      return self if matching_specs.empty?
+ 
+-        GemHelpers.select_best_platform_match(source.specs.search(Dependency.new(name, version)), target_platform)
+-      else
+-        source.specs.search(self)
+-      end
++      candidates = if use_exact_resolved_specifications?
++                     matching_specs
++                   else
++                     target_platform = ruby_platform_materializes_to_ruby_platform? ? platform : local_platform
++
++                     installable_candidates = GemHelpers.select_best_platform_match(matching_specs, target_platform)
++
++                     specification = __materialize__(installable_candidates)
++                     return specification unless specification.nil?
+ 
+-      return self if candidates.empty?
++                     if target_platform != platform
++                       installable_candidates = GemHelpers.select_best_platform_match(matching_specs, platform)
++                     end
++
++                     installable_candidates
++                   end
+ 
+       __materialize__(candidates)
+     end
+ 
+     def __materialize__(candidates)
+-      @specification = begin
+-        search = candidates.reverse.find do |spec|
+-          spec.is_a?(StubSpecification) ||
+-            (spec.matches_current_ruby? &&
+-              spec.matches_current_rubygems?)
+-        end
+-        if search.nil? && Bundler.frozen_bundle?
+-          search = candidates.last
+-        else
+-          search.dependencies = dependencies if search && search.full_name == full_name && (search.is_a?(RemoteSpecification) || search.is_a?(EndpointSpecification))
+-        end
+-        search
++      search = candidates.reverse.find do |spec|
++        spec.is_a?(StubSpecification) ||
++          (spec.matches_current_ruby? &&
++           spec.matches_current_rubygems?)
+       end
+-    end
+-
+-    def respond_to?(*args)
+-      super || @specification ? @specification.respond_to?(*args) : nil
++      if search.nil? && Bundler.frozen_bundle?
++        search = candidates.last
++      else
++        search.dependencies = dependencies if search && search.full_name == full_name && (search.is_a?(RemoteSpecification) || search.is_a?(EndpointSpecification))
++      end
++      search
+     end
+ 
+     def to_s
+@@ -127,17 +130,8 @@ def git_version
+     end
+ 
+     private
+-
+-    def to_ary
+-      nil
+-    end
+-
+-    def method_missing(method, *args, &blk)
+-      raise "LazySpecification has not been materialized yet (calling :#{method} #{args.inspect})" unless @specification
+-
+-      return super unless respond_to?(method)
+-
+-      @specification.send(method, *args, &blk)
++    def use_exact_resolved_specifications?
++      @use_exact_resolved_specifications ||= !source.is_a?(Source::Path) && ruby_platform_materializes_to_ruby_platform?
+     end
+ 
+     #
+-- 
+2.40.0
+

rubygem-bundler-2.3.26-Tests-from-bundler-PR-6225.patch

@@ -0,0 +1,60 @@
+From cb3d287a91e9b6762e47635137d6024fe39e117d Mon Sep 17 00:00:00 2001
+From: Jarek Prokop <jprokop@redhat.com>
+Date: Fri, 31 Mar 2023 12:06:21 +0200
+Subject: [PATCH] Tests from bundler's PR#6225.
+
+See <https://github.com/rubygems/rubygems/pull/6225>.
+---
+ .../install/gemfile/specific_platform_spec.rb | 36 +++++++++++++++++++
+ 1 file changed, 36 insertions(+)
+
+diff --git a/bundler/spec/install/gemfile/specific_platform_spec.rb b/bundler/spec/install/gemfile/specific_platform_spec.rb
+index 98efec396..a29446305 100644
+--- a/bundler/spec/install/gemfile/specific_platform_spec.rb
++++ b/bundler/spec/install/gemfile/specific_platform_spec.rb
+@@ -104,6 +104,42 @@
+       L
+     end
+ 
++    it "still installs the generic RUBY variant if necessary even when running on a legacy lockfile locked only to RUBY" do
++      build_repo4 do
++        build_gem "nokogiri", "1.3.10"
++        build_gem "nokogiri", "1.3.10" do |s|
++          s.platform = "arm64-darwin"
++          s.required_ruby_version = "< #{Gem.ruby_version}"
++        end
++
++        build_gem "bundler", "2.1.4"
++      end
++
++      gemfile <<~G
++        source "#{file_uri_for(gem_repo4)}"
++        gem "nokogiri"
++      G
++
++      lockfile <<-L
++        GEM
++          remote: #{file_uri_for(gem_repo4)}/
++          specs:
++            nokogiri (1.3.10)
++        PLATFORMS
++          ruby
++        DEPENDENCIES
++          nokogiri
++        RUBY VERSION
++          2.5.3p105
++        BUNDLED WITH
++           2.1.4
++      L
++
++      simulate_platform "arm64-darwin-22" do
++        bundle "update --bundler", :artifice => "compact_index", :env => { "BUNDLER_SPEC_GEM_REPO" => gem_repo4.to_s }
++      end
++    end
++
+     it "doesn't discard previously installed platform specific gem and fall back to ruby on subsequent bundles" do
+       build_repo2 do
+         build_gem("libv8", "8.4.255.0")
+-- 
+2.40.0
+

sources

@@ -1 +1 @@
-SHA512 (ruby-3.1.2.tar.xz) = 4a74e9efc6ea4b3eff4fec7534eb1fff4794d021531defc2e9937e53c6668db8ecdc0fff2bc23d5e6602d0df344a2caa85b31c5414309541e3d5313ec82b6e21
+SHA512 (ruby-3.1.4.tar.xz) = a627bb629a10750b8b2081ad451a41faea0fc85d95aa1e267e3d2a0f56a35bb58195d4a8d13bbdbd82f4197a96dae22b1cee1dfc83861ec33a67ece07aef5633