rake-compiler-dock 1.9.1 → 1.10.0

data/Dockerfile.mri.erb

@@ -1,6 +1,8 @@
 <% image = "ubuntu:20.04" %>
 FROM <%= image %>
 
+ARG TARGETPLATFORM
+
 ##
 ## Install required base packages for compiling ruby
 ##
@@ -24,6 +26,24 @@ COPY --from=larskanis/mingw64-ucrt:20.04 \
     /debs/
 RUN dpkg -i /debs/*.deb
 
+<% elsif platform =~ /aarch64-mingw-ucrt/ %>
+
+RUN <<EOF
+    if [ "$TARGETPLATFORM" = "linux/amd64" ]; then
+        DOWNLOAD_PLATFORM="x86_64";
+    elif [ "$TARGETPLATFORM" = "linux/arm64" ]; then
+        DOWNLOAD_PLATFORM="aarch64";
+    else
+        echo "Unsupported platform $TARGETPLATFORM";
+        exit 1;
+    fi &&
+    wget https://github.com/mstorsjo/llvm-mingw/releases/download/20250114/llvm-mingw-20250114-ucrt-ubuntu-20.04-$DOWNLOAD_PLATFORM.tar.xz &&
+    tar xf llvm-mingw*.tar.xz &&
+    mv `ls -d llvm-mingw-*/` /llvm-mingw &&
+    echo "export PATH=/llvm-mingw/bin:\$PATH" >> /etc/rubybashrc &&
+    rm -r /llvm-mingw/bin/i686-w64* /llvm-mingw/bin/armv7-w64* /llvm-mingw/bin/x86_64-w64* /llvm-mingw/i686-w64* /llvm-mingw/armv7-w64* /llvm-mingw/x86_64-w64*
+EOF
+
 <% elsif platform =~ /linux-musl/ %>
 COPY build/mk_musl_cross.sh /tmp
 RUN /tmp/mk_musl_cross.sh <%= target %>
@@ -44,6 +64,20 @@ if platform =~ /x64-mingw32/       %> gcc-mingw-w64-x86-64 g++-mingw-w64-x86-64
 <% if platform =~ /darwin/ %>
 COPY build/mk_osxcross.sh /tmp
 RUN /tmp/mk_osxcross.sh
+
+# Install mig which is a Macos specific RPC code generator, which is part of xcode
+RUN apt-get -y update && \
+    apt-get install -y bison flex && \
+    rm -rf /var/lib/apt/lists/*
+RUN git clone --branch=cross_platform https://github.com/markmentovai/bootstrap_cmds && \
+    cd bootstrap_cmds && \
+    autoreconf --install && \
+    sh configure && \
+    make && \
+    sed -E -i 's/^cppflags=(.*)/cppflags=(\1 "-D<%= platform =~ /arm64/ ? "__arm64__" : "__x86_64__" %>" "-I\/opt\/osxcross\/target\/SDK\/MacOSX11.1.sdk\/usr\/include")/' migcom.tproj/mig.sh && \
+    sudo make install && \
+    cd .. && \
+    rm -rf bootstrap_cmds
 <% end %>
 
 
@@ -74,7 +108,7 @@ ENV BASH_ENV=/etc/rubybashrc
 ##
 USER rubyuser
 
-ENV RBENV_RUBIES="2.5.9 3.1.6 3.4.1"
+ENV RBENV_RUBIES="3.1.7 3.4.5"
 
 # Install the bootstrap rubies
 RUN bash -c " \
@@ -106,7 +140,6 @@ RUN sudo mkdir -p /usr/local/rake-compiler && \
 
 <%
 #
-# Build ruby versions prior to ruby2_keywords using ruby-2.5
 # Build ruby versions with ruby2_keywords using ruby-3.x
 #
 # Note that parallel builds of ruby with make flag `-j` are often flaky, see
@@ -115,23 +148,25 @@ RUN sudo mkdir -p /usr/local/rake-compiler && \
 xrubies_build_plan = if platform =~ /x64-mingw-ucrt/
   [
     # Rubyinstaller-3.1+ is platform x64-mingw-ucrt
-    ["3.4.1:3.3.7:3.2.6:3.1.6", "3.4.1"],
+    ["3.4.5:3.3.9:3.2.9:3.1.7", "3.4.5"],
+  ]
+elsif platform =~ /aarch64-mingw-ucrt/
+  [
+    ["3.4.5", "3.1.7"],
   ]
 elsif platform =~ /x64-mingw32/
   [
     # Rubyinstaller prior to 3.1 is platform x64-mingw32
-    ["2.6.10:2.5.9:2.4.10", "2.5.9"],
-    ["3.0.7:2.7.8", "3.1.6"],
+    ["3.0.7:2.7.8", "3.1.7"],
   ]
 else
   [
-    ["2.6.10:2.5.9:2.4.10", "2.5.9"],
-    ["2.7.8", "3.1.6"],
-    ["3.4.1:3.3.7:3.2.6:3.1.6:3.0.7", "3.4.1"],
+    ["2.7.8", "3.1.7"],
+    ["3.4.5:3.3.9:3.2.9:3.1.7:3.0.7", "3.4.5"],
   ]
 end
 
-strip = '-s' if platform !~ /darwin/
+strip = '-s' if platform !~ /darwin|aarch64-mingw/
 
 xrubies_build_plan.each do |xrubies, bootstrap_ruby_version| %>
 RUN bash -c " \
@@ -139,7 +174,7 @@ RUN bash -c " \
   export CPPFLAGS='<%= "-D__USE_MINGW_ANSI_STDIO=1" if platform =~ /x64-mingw-ucrt/ %>' && \
   export CFLAGS='-O1 -fno-omit-frame-pointer -fno-fast-math -fstack-protector-strong <%= strip %>' && \
   export LDFLAGS='-pipe <%= strip %>' && \
-  <%= "export LIBS='-l:libssp.a' &&" if platform =~ /mingw/ %> \
+  <%= "export LIBS='-l:libssp.a -lpthread' &&" if platform =~ /mingw/ %> \
   <%= "export CC=#{target}-clang &&" if platform =~ /darwin/ %> \
   export MAKE='make V=1' && \
   rake-compiler cross-ruby VERSION=<%= xrubies %> HOST=<%= target %> && \
@@ -160,15 +195,10 @@ RUN find /usr/local/rake-compiler/ruby/*linux*/ -name mkmf.rb | while read f ; d
 <% if platform =~ /mingw/ %>
 # RubyInstaller doesn't install libgcc -> link it static.
 RUN find /usr/local/rake-compiler/ruby/*mingw*/ -name rbconfig.rb | while read f ; do sed -i 's/."LDFLAGS". = "/&-static-libgcc /' $f ; done
-# Raise Windows-API to Vista (affects ruby < 2.6 only)
-RUN find /usr/local/rake-compiler/ruby -name rbconfig.rb | while read f ; do sed -i 's/0x0501/0x0600/' $f ; done
 # Don't link to static libruby
 RUN find /usr/local/rake-compiler/ruby -name lib*-ruby*.dll.a | while read f ; do n=`echo $f | sed s/.dll//` ; mv $f $n ; done
 <% end %>
 
-# ruby-2.5 links to libcrypt, which isn't necessary for extensions
-RUN find /usr/local/rake-compiler/ruby -name rbconfig.rb | while read f ; do sed -i 's/-lcrypt//' $f ; done
-
 <% if platform =~ /darwin/ %>
 # for rubies which use `-bundle_loader` on darwin
 # - the upstream change: https://github.com/ruby/ruby/pull/6193
@@ -187,7 +217,7 @@ RUN find /usr/local/rake-compiler/ruby/*/*/lib/ruby -name rbconfig.rb | while re
 ##
 USER root
 
-<% if platform =~ /mingw/ %>
+<% if platform =~ /(x64|x86)-mingw/ %>
 # Install wrappers for strip commands as a workaround for "Protocol error" in boot2docker.
 COPY build/strip_wrapper_vbox /root/
 RUN mv /usr/bin/<%= target %>-strip /usr/bin/<%= target %>-strip.bin && \
@@ -200,6 +230,16 @@ RUN printf "1\n" | update-alternatives --config <%= target %>-gcc && \
     printf "1\n" | update-alternatives --config <%= target %>-g++
 <% end %>
 
+<% if platform =~ /aarch64-mingw/ %>
+# Fool libtool to allow building a shared library although linking to libclang_rt.builtins-aarch64.a
+#
+# Linker option "-llibclang_rt.builtins-aarch64.a" is required on Windows on ARM when compiling C++ and when clang is called with -nostdlib (due to be invoked by libtool).
+# Unfortunately libtool then forces a static build.
+# This is a ugly hack to make libtool beleave that the library is a DLL instead of an archive and to allow building a DLL instand.
+#
+RUN sudo cp /llvm-mingw/aarch64-w64-mingw32/bin/libc++.dll /llvm-mingw/aarch64-w64-mingw32/lib/libclang_rt.builtins-aarch64.0
+<% end %>
+
 <% if platform =~ /darwin/ %>
 # Install wrapper around strip to re-sign binaries (ad-hoc signature)
 COPY build/strip_wrapper_codesign /root/
@@ -224,8 +264,8 @@ RUN echo 'source /etc/profile.d/rcd-env.sh' >> /etc/rubybashrc
 # Install sudoers configuration
 COPY build/sudoers /etc/sudoers.d/rake-compiler-dock
 
-RUN bash -c "rbenv global 3.4.1"
+RUN bash -c "rbenv global 3.4.5"
 
-ENV RUBY_CC_VERSION=3.4.1:3.3.7:3.2.6:3.1.6:3.0.7:2.7.8:2.6.10:2.5.9:2.4.10
+ENV RUBY_CC_VERSION=3.4.5:3.3.9:3.2.9:3.1.7:3.0.7:2.7.8
 
 CMD bash

data/README.md

@@ -2,7 +2,7 @@
 
 **Easy to use and reliable cross compiler environment for building Windows, Linux, Mac and JRuby binary gems.**
 
-It provides cross compilers and Ruby environments for 2.4 and newer versions of the [RubyInstaller](http://rubyinstaller.org/) and Linux runtime environments.
+It provides cross compilers and Ruby environments for 2.6 and newer versions of the [RubyInstaller](http://rubyinstaller.org/) and Linux runtime environments.
 They are prepared for use with [rake-compiler](https://github.com/rake-compiler/rake-compiler).
 It is used by [many gems with C or JRuby extentions](https://github.com/rake-compiler/rake-compiler-dock/wiki/Projects-using-rake-compiler-dock).
 
@@ -16,6 +16,7 @@ The following platforms are supported for cross-compilation by rake-compiler-doc
 
 - `aarch64-linux` and `aarch64-linux-gnu`
 - `aarch64-linux-musl`
+- `aarch64-mingw-ucrt`
 - `arm-linux` and `arm-linux-gnu`
 - `arm-linux-musl`
 - `arm64-darwin`
@@ -72,8 +73,6 @@ Ruby version 3.1 and later ship with a sufficient Rubygems version. For earlier
 - ruby: "3.0", rubygems: "3.5.5" # or possibly higher
 - ruby: "2.7", rubygems: "3.4.22"
 - ruby: "2.6", rubygems: "3.4.22"
-- ruby: "2.5", rubygems: "3.3.26"
-- ruby: "2.4", rubygems: "3.3.26"
 
 **It's strongly suggested that you use rake-compiler v1.2.7 or later to build `linux-musl` and/or `linux-gnu` native gems.** That version of rake-compiler sets `required_rubygems_version` automatically in the native platform gems' gemspecs.
 
@@ -193,6 +192,7 @@ This can be done like this:
 PLATFORMS = %w[
   aarch64-linux-gnu
   aarch64-linux-musl
+  aarch64-mingw-ucrt
   arm-linux-gnu
   arm-linux-musl
   arm64-darwin
@@ -207,7 +207,8 @@ PLATFORMS = %w[
 ]
 task 'gem:native' do
   require 'rake_compiler_dock'
-  sh "bundle package --all"   # Avoid repeated downloads of gems by using gem files from the host.
+  sh "bundle config set cache_all true"   # Avoid repeated downloads of gems by using gem files from the host.
+  sh "bundle package"
   PLATFORMS.each do |plat|
     RakeCompilerDock.sh "bundle --local && rake native:#{plat} gem", platform: plat
   end
@@ -231,7 +232,8 @@ Please note, that parallel builds only work reliable, if the specific platform g
     task 'prepare' do
       require 'rake_compiler_dock'
       require 'io/console'
-      sh "bundle package --all"
+      sh "bundle config set cache_all true"
+      sh "bundle package"
       sh "cp ~/.gem/gem-*.pem build/gem/ || true"
       ENV["GEM_PRIVATE_KEY_PASSPHRASE"] = STDIN.getpass("Enter passphrase of gem signature key: ")
     end
@@ -313,6 +315,7 @@ OCI images snapshotted from `main` are published weekly to Github Container Regi
 - `ghcr.io/rake-compiler/rake-compiler-dock-image:snapshot-mri-x86_64-linux-gnu`
 
 These images are intended for integration testing. They may not work properly and should not be considered production ready.
+Snapshot images can be used by setting `RCD_IMAGE_VERSION` environment variable.
 
 
 ## Environment Variables
@@ -328,6 +331,9 @@ The following variables are recognized by rake-compiler-dock:
     It is ignored when `rubyvm` is set to `:jruby`.
 * `RCD_IMAGE` - The docker image that is downloaded and started.
     Defaults to "ghcr.io/rake-compiler/rake-compiler-dock-image:IMAGE_VERSION-PLATFORM" with an image version that is determined by the gem version.
+* `RCD_IMAGE_VERSION` - The docker image version that is downloaded and started.
+    Defaults to the version of the rake-compiler-dock gem in use.
+    Can be set to `snapshot` in order to use the latest images from main branch.
 
 The following variables are passed through to the docker container without modification:
 
@@ -352,6 +358,42 @@ Other environment variables can be set or passed through to the container like t
 RakeCompilerDock.sh "rake cross native gem OPENSSL_VERSION=#{ENV['OPENSSL_VERSION']}"
 ```
 
+### Choosing the version of ruby to run in the build container
+
+There are [multiple versions of Ruby installed in the build container](https://github.com/rake-compiler/rake-compiler-dock/blob/d3e6b44916d9d63d4c431b8c749a2c58bf1fe8e8/Dockerfile.mri.erb#L77). The latest version will be the default, but you may need to choose a different version to run during your build process.
+
+You can do this by passing a `ruby:` keyword argument to `RakeCompilerDock.sh`:
+
+```ruby
+RakeCompilerDock.sh "ruby -v"
+# => ruby 3.4.1 (2024-12-25 revision 48d4efcb85) +PRISM [x86_64-linux]
+
+RakeCompilerDock.sh "ruby -v", ruby: "3.1.6"
+# => ruby 3.1.6p260 (2024-05-29 revision a777087be6) [x86_64-linux]48d4efcb85) +PRISM [x86_64-linux]
+```
+
+Or by setting the environment variable `RCD_RUBY_VERSION`:
+
+``` sh
+$ rake-compiler-dock bash -c "ruby -v"
+ruby 3.4.1 (2024-12-25 revision 48d4efcb85) +PRISM [x86_64-linux]
+
+$ RCD_RUBY_VERSION=3.1.6 rake-compiler-dock bash -c "ruby -v"
+ruby 3.1.6p260 (2024-05-29 revision a777087be6) [x86_64-linux]
+```
+
+Or by running `rbenv shell` in the command:
+
+``` ruby
+RakeCompilerDock.sh "rbenv shell 3.1.6 && ruby -v", platform: "x86_64-linux-gnu"
+# => ruby 3.1.6p260 (2024-05-29 revision a777087be6) [x86_64-linux]
+```
+
+``` sh
+$ rake-compiler-dock bash -c "rbenv shell 3.1.6 && ruby -v"
+ruby 3.1.6p260 (2024-05-29 revision a777087be6) [x86_64-linux]
+```
+
 ### Choosing specific Ruby versions to support
 
 If you only want to precompile for certain Ruby versions, you can specify those versions by overwriting the `RUBY_CC_VERSION` environment variable.
@@ -362,7 +404,7 @@ For example, if you wanted to only support Ruby 3.4 and 3.3, you might set this
 ENV["RUBY_CC_VERSION"] = "3.4.1:3.3.7"
 ```
 
-In practice, though, hardcoding these versions is brittle because the patch versions in the container may very from release to release.
+In practice, though, hardcoding these versions is brittle because the patch versions in the container may vary from release to release.
 
 A more robust way to do this is to use `RakeCompilerDock.ruby_cc_version` which accepts an array of Ruby minor versions or patch version requirements.
 

data/Rakefile

@@ -8,10 +8,32 @@ CLEAN.include("tmp")
 
 RakeCompilerDock::GemHelper.install_tasks
 
+def build_mri_images(platforms, host_platforms, output: )
+  plats = host_platforms.map(&:first).join(",")
+  platforms.each do |platform, _|
+    sdf = "tmp/docker/Dockerfile.mri.#{platform}.#{host_platforms.first[1]}"
+    image_name = RakeCompilerDock::Starter.container_image_name(platform: platform)
+
+    RakeCompilerDock.docker_build(sdf, tag: image_name, platform: plats, output: output)
+
+    if image_name.include?("linux-gnu")
+      RakeCompilerDock.docker_build(sdf, tag: image_name.sub("linux-gnu", "linux"), platform: plats, output: output)
+    end
+  end
+end
+
+def build_jruby_images(host_platforms, output: )
+  image_name = RakeCompilerDock::Starter.container_image_name(rubyvm: "jruby")
+  plats = host_platforms.map(&:first).join(",")
+  sdf = "tmp/docker/Dockerfile.jruby.#{host_platforms.first[1]}"
+  RakeCompilerDock.docker_build(sdf, tag: image_name, platform: plats, output: output)
+end
+
 platforms = [
   # tuple is [platform, target]
   ["aarch64-linux-gnu", "aarch64-linux-gnu"],
   ["aarch64-linux-musl", "aarch64-linux-musl"],
+  ["aarch64-mingw-ucrt", "aarch64-w64-mingw32"],
   ["arm-linux-gnu", "arm-linux-gnueabihf"],
   ["arm-linux-musl", "arm-linux-musleabihf"],
   ["arm64-darwin", "aarch64-apple-darwin"],
@@ -25,52 +47,91 @@ platforms = [
   ["x86_64-linux-musl", "x86_64-unknown-linux-musl"],
 ]
 
+host_platforms = [
+  # tuple is [docker platform, rake task, RUBY_PLATFORM matcher]
+  ["linux/amd64", "x86", /^x86_64|^x64|^amd64/],
+  ["linux/arm64", "arm", /^aarch64|arm64/],
+]
+local_platform = host_platforms.find { |_,_,reg| reg =~ RUBY_PLATFORM } or
+    raise("RUBY_PLATFORM #{RUBY_PLATFORM} is not supported as host")
+
 namespace :build do
 
-  platforms.each do |platform, target|
-    sdf = "Dockerfile.mri.#{platform}"
-
-    desc "Build image for platform #{platform}"
-    task platform => sdf
-    task sdf do
-      image_name = RakeCompilerDock::Starter.container_image_name(platform: platform)
-      sh(*RakeCompilerDock.docker_build_cmd(platform), "-t", image_name, "-f", "Dockerfile.mri.#{platform}", ".")
-      if image_name.include?("linux-gnu")
-        sh("docker", "tag", image_name, image_name.sub("linux-gnu", "linux"))
-      end
-    end
+  mkdir_p "tmp/docker"
 
+  docker_platform, rake_platform, _ = local_platform
+  platforms.each do |platform, target|
+    sdf = "tmp/docker/Dockerfile.mri.#{platform}.#{rake_platform}"
     df = ERB.new(File.read("Dockerfile.mri.erb"), trim_mode: ">").result(binding)
     File.write(sdf, df)
     CLEAN.include(sdf)
   end
+  sdf = "tmp/docker/Dockerfile.jruby.#{rake_platform}"
+  df = File.read("Dockerfile.jruby")
+  File.write(sdf, df)
+
+  RakeCompilerDock::ParallelDockerBuild.new(platforms.map{|pl, _| "tmp/docker/Dockerfile.mri.#{pl}.#{rake_platform}" } + ["tmp/docker/Dockerfile.jruby.#{rake_platform}"], workdir: "tmp/docker", task_prefix: "common-#{rake_platform}-", platform: docker_platform)
 
-  desc "Build image for JRuby"
-  task :jruby => "Dockerfile.jruby"
-  task "Dockerfile.jruby" do
-    image_name = RakeCompilerDock::Starter.container_image_name(rubyvm: "jruby")
-    sh(*RakeCompilerDock.docker_build_cmd("jruby"), "-t", image_name, "-f", "Dockerfile.jruby", ".")
+  platforms.each do |platform, target|
+    sdf = "tmp/docker/Dockerfile.mri.#{platform}.#{rake_platform}"
+
+    # Load image after build on local platform only
+    desc "Build and load image for platform #{platform} on #{docker_platform}"
+    task platform => sdf do
+      build_mri_images([platform], [local_platform], output: 'load')
+    end
+    multitask :all => platform
   end
 
-  RakeCompilerDock::ParallelDockerBuild.new(platforms.map{|pl, _| "Dockerfile.mri.#{pl}" } + ["Dockerfile.jruby"], workdir: "tmp/docker")
+  sdf = "tmp/docker/Dockerfile.jruby.#{rake_platform}"
+  # Load image after build on local platform only
+  desc "Build and load image for JRuby on #{docker_platform}"
+  task :jruby => sdf do
+    build_jruby_images([local_platform], output: 'load')
+  end
+  multitask :all => :jruby
 
+  all_mri_images = platforms.map(&:first)
   desc "Build images for all MRI platforms in parallel"
   if ENV['RCD_USE_BUILDX_CACHE']
-    task :mri => platforms.map(&:first)
+    task :mri => all_mri_images
   else
-    multitask :mri => platforms.map(&:first)
+    multitask :mri => all_mri_images
   end
 
+  all_images = all_mri_images + ["jruby"]
   desc "Build images for all platforms in parallel"
   if ENV['RCD_USE_BUILDX_CACHE']
-    task :all => platforms.map(&:first) + ["jruby"]
+    task :all => all_images
   else
-    multitask :all => platforms.map(&:first) + ["jruby"]
+    multitask :all => all_images
   end
 end
 
 task :build => "build:all"
 
+namespace :release do
+  host_pl = host_platforms.map(&:first).join(",")
+
+  desc "Push image for JRuby on #{host_pl}"
+  task :jruby do
+    build_jruby_images(host_platforms, output: 'push')
+  end
+
+  desc "Push all docker images on #{host_pl}"
+  multitask :images => :jruby
+
+  platforms.each do |platform, target|
+    desc "Push image for platform #{platform} on #{host_pl}"
+    task platform do
+      build_mri_images([platform], host_platforms, output: 'push')
+    end
+
+    desc "Push all docker images on #{host_pl}"
+    multitask :images => platform
+  end
+end
+
 namespace :prepare do
   desc "Build cross compiler for x64-mingw-ucrt aka RubyInstaller-3.1+"
   task "mingw64-ucrt" do
@@ -113,20 +174,3 @@ task :update_lists do
     EOT
   end
 end
-
-namespace :release do
-  desc "push all docker images"
-  task :images do
-    image_name = RakeCompilerDock::Starter.container_image_name(rubyvm: "jruby")
-    sh("docker", "push", image_name)
-
-    platforms.each do |platform, _|
-      image_name = RakeCompilerDock::Starter.container_image_name(platform: platform)
-      sh("docker", "push", image_name)
-
-      if image_name.include?("linux-gnu")
-        sh("docker", "push", image_name.sub("linux-gnu", "linux"))
-      end
-    end
-  end
-end

data/build/buildkitd.toml

@@ -0,0 +1,2 @@
+[worker.oci]
+  gc = false

data/build/gem_helper.rb

@@ -13,7 +13,7 @@ module RakeCompilerDock
     end
 
     def hfile
-      "History.md"
+      "CHANGELOG.md"
     end
 
     def headline

data/build/mk_musl_cross.sh

@@ -29,7 +29,7 @@ GCC_CONFIG += --disable-libquadmath --disable-decimal-float
 GCC_CONFIG += --disable-multilib
 EOF
 
-make -j$(nproc) install
+make -j$(nproc) install LINUX_HEADERS_SITE=http://mirrors.2f30.org/sabotage/tarballs/
 
 popd
 

data/build/parallel_docker_build.rb

@@ -9,22 +9,34 @@ module RakeCompilerDock
         if platform
           cache_version = RakeCompilerDock::IMAGE_VERSION.split(".").take(2).join(".")
           cache = File.join("cache", cache_version, platform)
-          "docker buildx build --cache-to=type=local,dest=#{cache},mode=max --cache-from=type=local,src=#{cache} --load"
+          "docker buildx build --cache-to=type=local,dest=#{cache},mode=max --cache-from=type=local,src=#{cache} --progress=plain"
         else
           return nil
         end
       else
-        ENV['RCD_DOCKER_BUILD'] || "docker build"
+        ENV['RCD_DOCKER_BUILD'] || "docker buildx build --progress=plain"
       end
       Shellwords.split(cmd)
     end
+
+    # Run an intermediate dockerfile without tag
+    #
+    # The layers will be reused in subsequent builds, even if they run in parallel.
+    def docker_build(filename, tag: nil, output: false, platform: )
+      cmd = docker_build_cmd(platform)
+      return if cmd.nil?
+      tag_args = ["-t", tag] if tag
+      push_args = ["--push"] if output == 'push'
+      push_args = ["--load"] if output == 'load'
+      Class.new.extend(FileUtils).sh(*cmd, "-f", filename, ".", "--platform", platform, *tag_args, *push_args)
+    end
   end
 
   # Run docker builds in parallel, but ensure that common docker layers are reused
   class ParallelDockerBuild
     include Rake::DSL
 
-    def initialize(dockerfiles, workdir: "tmp/docker", inputdir: ".", task_prefix: "common-")
+    def initialize(dockerfiles, workdir: "tmp/docker", inputdir: ".", task_prefix: "common-", platform: "local")
       FileUtils.mkdir_p(workdir)
 
       files = parse_dockerfiles(dockerfiles, inputdir)
@@ -34,6 +46,7 @@ module RakeCompilerDock
       # pp vcs
 
       define_common_tasks(vcs, workdir, task_prefix)
+      @platform = platform
     end
 
     # Read given dockerfiles from inputdir and split into a list of commands.
@@ -96,7 +109,7 @@ module RakeCompilerDock
         fn = "#{task_prefix}#{Digest::SHA1.hexdigest(files.join)}"
         File.write(File.join(workdir, fn), (plines + lines).join)
         task fn do
-          docker_build(fn, workdir)
+          RakeCompilerDock.docker_build(File.join(workdir, fn), platform: @platform)
         end
 
         nfn = define_common_tasks(nvcs, workdir, task_prefix, plines + lines)
@@ -109,14 +122,5 @@ module RakeCompilerDock
         fn
       end
     end
-
-    # Run an intermediate dockerfile without tag
-    #
-    # The layers will be reused in subsequent builds, even if they run in parallel.
-    def docker_build(filename, workdir)
-      cmd = RakeCompilerDock.docker_build_cmd
-      return if cmd.nil?
-      sh(*RakeCompilerDock.docker_build_cmd, "-f", File.join(workdir, filename), ".")
-    end
   end
 end

data/build/patches/rake-compiler-1.2.9/0004-Enable-build-of-static-libruby.patch

@@ -2,16 +2,18 @@ diff --git a/tasks/bin/cross-ruby.rake b/tasks/bin/cross-ruby.rake
 index 8317a2a3..8ed21718 100644
 --- a/tasks/bin/cross-ruby.rake
 +++ b/tasks/bin/cross-ruby.rake
-@@ -116,11 +116,30 @@
+@@ -116,11 +116,32 @@
          "--host=#{mingw_host}",
          "--target=#{mingw_target}",
          "--build=#{RUBY_BUILD}",
 -        '--enable-shared',
 +        '--enable-install-static-library',
 +        '--disable-jit-support',
++        '--disable-rpath',
 +        'ac_cv_lib_z_uncompress=no',
 +        'ac_cv_lib_crypt_crypt=no',
 +        'ac_cv_func_crypt_r=no',
++        'extra_warnflags=-Wno-shorten-64-to-32 -Wno-dll-attribute-on-redeclaration',
          '--disable-install-doc',
          '--with-ext=',
        ]

data/build/sudoers

@@ -1 +1 @@
-Defaults        env_keep += "http_proxy https_proxy ftp_proxy GEM_PRIVATE_KEY_PASSPHRASE RCD_HOST_RUBY_PLATFORM RCD_HOST_RUBY_VERSION RCD_IMAGE RUBY_CC_VERSION LD_LIBRARY_PATH DEVTOOLSET_ROOTPATH SOURCE_DATE_EPOCH"
+Defaults        env_keep += "http_proxy https_proxy ftp_proxy GEM_PRIVATE_KEY_PASSPHRASE RCD_HOST_RUBY_PLATFORM RCD_HOST_RUBY_VERSION RCD_IMAGE RUBY_CC_VERSION LD_LIBRARY_PATH DEVTOOLSET_ROOTPATH SOURCE_DATE_EPOCH RBENV_VERSION"

data/lib/rake_compiler_dock/starter.rb

@@ -41,6 +41,11 @@ module RakeCompilerDock
         user = options.fetch(:username){ current_user }
         group = options.fetch(:groupname){ current_group }
 
+        ruby_version = options[:ruby] || ENV['RCD_RUBY_VERSION']
+        rbenv_opts = if ruby_version
+          ["-e", "RBENV_VERSION=#{ruby_version}"]
+        end
+
         platforms(options).split(" ").each do |platform|
           image_name = container_image_name(options.merge(platform: platform))
 
@@ -73,6 +78,7 @@ module RakeCompilerDock
               "-e", "RCD_HOST_RUBY_PLATFORM=#{RUBY_PLATFORM}",
               "-e", "RCD_HOST_RUBY_VERSION=#{RUBY_VERSION}",
               "-e", "RCD_IMAGE=#{image_name}",
+              *rbenv_opts,
               "-w", make_valid_path(workdir),
               *docker_opts,
               image_name,
@@ -167,7 +173,7 @@ module RakeCompilerDock
 
           "%s/rake-compiler-dock-image:%s-%s%s" % [
             container_registry,
-            options.fetch(:version) { IMAGE_VERSION },
+            options.fetch(:version) { image_version },
             container_rubyvm(options),
             container_jrubyvm?(options) ? "" : "-#{options.fetch(:platform)}",
           ]
@@ -178,6 +184,10 @@ module RakeCompilerDock
         ENV['CONTAINER_REGISTRY'] || "ghcr.io/rake-compiler"
       end
 
+      def image_version
+        ENV['RCD_IMAGE_VERSION'] || IMAGE_VERSION
+      end
+
       def container_rubyvm(options={})
         return "jruby" if options[:platform] == "jruby"
         options.fetch(:rubyvm) { ENV['RCD_RUBYVM'] } || "mri"

data/lib/rake_compiler_dock/version.rb

@@ -1,4 +1,4 @@
 module RakeCompilerDock
-  VERSION = "1.9.1"
-  IMAGE_VERSION = "1.9.1"
+  VERSION = "1.10.0"
+  IMAGE_VERSION = "1.10.0"
 end