rake-compiler-dock 1.1.0 → 1.2.2

data/README.md

@@ -1,8 +1,8 @@
 # rake-compiler-dock
 
-**Easy to use and reliable cross compiler environment for building Windows, Linux and JRuby binary gems.**
+**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.2 and newer versions of the [RubyInstaller](http://rubyinstaller.org/) and Linux runtime environments.
+It provides cross compilers and Ruby environments for 2.4 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).
 
@@ -12,11 +12,7 @@ It is also more reliable, since the underlying docker images are versioned and i
 
 ## Installation
 
-Install docker natively on Linux:
-
-    $ sudo apt-get install docker.io
-
-... or install [docker-toolbox for Windows and OSX](https://github.com/docker/toolbox/releases) or boot2docker on [Windows](https://github.com/boot2docker/windows-installer/releases) or [OS X](https://github.com/boot2docker/osx-installer/releases) .
+Install docker [following the instructions on the docker website](https://docs.docker.com/engine/install/) ... or install [docker-toolbox for Windows and OSX](https://github.com/docker/toolbox/releases) or boot2docker on [Windows](https://github.com/boot2docker/windows-installer/releases) or [OS X](https://github.com/boot2docker/osx-installer/releases) .
 
 Install rake-compiler-dock as a gem. The docker image is downloaded later on demand:
 
@@ -34,10 +30,12 @@ Rake-compiler-dock provides the necessary tools to build Ruby extensions for Win
 It is intended to be used in conjunction with [rake-compiler's](https://github.com/rake-compiler/rake-compiler) cross build capability.
 Your Rakefile should enable cross compilation like so:
 
-    exttask = Rake::ExtensionTask.new('my_extension', my_gem_spec) do |ext|
-      ext.cross_compile = true
-      ext.cross_platform = %w[x86-mingw32 x64-mingw32 x86-linux x86_64-linux]
-    end
+```ruby
+exttask = Rake::ExtensionTask.new('my_extension', my_gem_spec) do |ext|
+  ext.cross_compile = true
+  ext.cross_platform = %w[x86-mingw32 x64-mingw-ucrt x64-mingw32 x86-linux x86_64-linux x86_64-darwin arm64-darwin]
+end
+```
 
 See below, how to invoke cross builds in your Rakefile.
 
@@ -46,7 +44,9 @@ Additionally it may also be used to build ffi based binary gems like [libusb](ht
 ### Interactive Usage
 
 Rake-compiler-dock offers the shell command `rake-compiler-dock` and a [ruby API](http://www.rubydoc.info/gems/rake-compiler-dock/RakeCompilerDock) for issuing commands within the docker image, described below.
-There dedicated are images for `x86-mingw32`, `x64-mingw32`, `x86-linux`, `x86_64-linux` and `jruby` targets.
+There are dedicated images for `x86-mingw32`, `x64-mingw-ucrt`, `x64-mingw32`, `x86-linux`, `x86_64-linux`, `x86_64-darwin`, `arm64-darwin` and `jruby` targets.
+The images contain all supported cross ruby versions, with the exception of `x64-mingw32`, which has versions before 3.1 only, and `x64-mingw-ucrt`, which has only ruby-3.1+.
+This is to match the [changed platform of RubyInstaller-3.1](https://rubyinstaller.org/2021/12/31/rubyinstaller-3.1.0-1-released.html).
 
 `rake-compiler-dock` without arguments starts an interactive shell session.
 This is best suited to try out and debug a build.
@@ -81,13 +81,19 @@ Or non-interactive:
 
 The environment variable `RUBY_CC_VERSION` is predefined as described [below](#environment-variables).
 
-If necessary, additional software from the Ubuntu repositories can be installed, prior to the build command.
-This is local to the running session, only:
+If necessary, additional software can be installed, prior to the build command.
+This is local to the running session, only.
+
+For Windows and Mac:
 
     sudo apt-get update && sudo apt-get install your-package
 
+For Linux:
+
+    sudo yum install your-package
+
 You can also choose between different executable ruby versions by `rvm use <version>` .
-The current default is 2.5.
+The current default is 3.1.
 
 ### JRuby support
 
@@ -111,17 +117,19 @@ To build java binary gems interactively, it can be called like this:
 To make the build process reproducible for other parties, it is recommended to add rake-compiler-dock to your Rakefile.
 This can be done like this:
 
-    task 'gem:native' do
-      require 'rake_compiler_dock'
-      sh "bundle package"   # Avoid repeated downloads of gems by using gem files from the host.
-      %w[ x86-mingw32 x64-mingw32 x86-linux x86_64-linux ].each do |plat|
-        RakeCompilerDock.sh "bundle --local && rake native:#{plat} gem", platform: plat
-      end
-      RakeCompilerDock.sh "bundle --local && rake java gem", rubyvm: :jruby
-    end
+```ruby
+task 'gem:native' do
+  require 'rake_compiler_dock'
+  sh "bundle package --all"   # Avoid repeated downloads of gems by using gem files from the host.
+  %w[ x86-mingw32 x64-mingw-ucrt x64-mingw32 x86-linux x86_64-linux arm-linux aarch64-linux x86_64-darwin arm64-darwin ].each do |plat|
+    RakeCompilerDock.sh "bundle --local && rake native:#{plat} gem", platform: plat
+  end
+  RakeCompilerDock.sh "bundle --local && rake java gem", rubyvm: :jruby
+end
+```
 
 This runs the `bundle` and `rake` commands once for each platform.
-That is once for the jruby gems and 4 times for the specified MRI platforms.
+That is once for the jruby gems and 6 times for the specified MRI platforms.
 
 ### Run builds in parallel
 
@@ -133,17 +141,19 @@ Please note, that parallel builds only work reliable, if the specific platform g
 
 ```ruby
   namespace "gem" do
+    task 'prepare' do
+      require 'rake_compiler_dock'
+      require 'io/console'
+      sh "bundle package --all"
+      sh "cp ~/.gem/gem-*.pem build/gem/ || true"
+      ENV["GEM_PRIVATE_KEY_PASSPHRASE"] = STDIN.getpass("Enter passphrase of gem signature key: ")
+    end
+
     exttask.cross_platform.each do |plat|
-      desc "Build the native binary gems"
+      desc "Build all native binary gems in parallel"
       multitask 'native' => plat
 
-      task 'prepare' do
-        require 'rake_compiler_dock'
-        sh "cp ~/.gem/gem-*.pem build/gem/ || true"
-        require 'io/console'
-        ENV["GEM_PRIVATE_KEY_PASSPHRASE"] = STDIN.getpass("Enter passphrase of gem signature key: ")
-      end
-
+      desc "Build the native gem for #{plat}"
       task plat => 'prepare' do
         RakeCompilerDock.sh <<-EOT, platform: plat
           (cp build/gem/gem-*.pem ~/.gem/ || true) &&
@@ -159,10 +169,54 @@ Please note, that parallel builds only work reliable, if the specific platform g
 
 Rake-compiler-dock uses [semantic versioning](http://semver.org/), so you should add it into your Gemfile, to make sure, that future changes will not break your build.
 
-    gem 'rake-compiler-dock', '~> 1.0'
+```ruby
+gem 'rake-compiler-dock', '~> 1.2'
+```
 
 See [the wiki](https://github.com/rake-compiler/rake-compiler-dock/wiki/Projects-using-rake-compiler-dock) for projects which make use of rake-compiler-dock.
 
+### As a CI System Container
+
+The OCI images provided by rake-compiler-dock can be used without the `rake-compiler-dock` gem or wrapper. This may be useful if your CI pipeline is building native gems.
+
+For example, a Github Actions job might look like this:
+
+``` yaml
+jobs:
+  native-gem:
+    name: "native-gem"
+    runs-on: ubuntu-latest
+    container:
+      image: "larskanis/rake-compiler-dock-mri-x86_64-linux:1.2.1"
+    steps:
+      - uses: actions/checkout@v2
+      - run: bundle install && bundle exec rake gem:x86_64-linux:rcd
+      - uses: actions/upload-artifact@v2
+        with:
+          name: native-gem
+          path: gems
+          retention-days: 1
+```
+
+Where the referenced rake task might be defined by:
+
+``` ruby
+cross_platforms = ["x64-mingw32", "x86_64-linux", "x86_64-darwin", "arm64-darwin"]
+
+namespace "gem" do
+  cross_platforms.each do |platform|
+    namespace platform do
+      task "rcd" do
+        Rake::Task["native:#{platform}"].invoke
+        Rake::Task["pkg/#{rcee_precompiled_spec.full_name}-#{Gem::Platform.new(platform)}.gem"].invoke
+      end
+    end
+  end
+end
+
+```
+
+For an example of rake tasks that support this style of invocation, visit https://github.com/flavorjones/ruby-c-extensions-explained/tree/main/precompiled
 
 ## Environment Variables
 
@@ -173,7 +227,7 @@ The following variables are recognized by rake-compiler-dock:
 * `RCD_RUBYVM` - The ruby VM and toolchain to be used.
     Must be one of `mri`, `jruby`.
 * `RCD_PLATFORM` - The target rubygems platform.
-    Must be a space separated list out of `x86-mingw32`, `x64-mingw32`, `x86-linux` and `x86_64-linux`.
+    Must be a space separated list out of `x86-mingw32`, `x64-mingw-ucrt`, `x64-mingw32`, `x86-linux`, `x86_64-linux`, `arm-linux`, `aarch64-linux`, `x86_64-darwin` and `arm64-darwin`.
     It is ignored when `rubyvm` is set to `:jruby`.
 * `RCD_IMAGE` - The docker image that is downloaded and started.
     Defaults to "larskanis/rake-compiler-dock:IMAGE_VERSION" with an image version that is determined by the gem version.
@@ -189,7 +243,7 @@ The following variables are provided to the running docker container:
 * `RCD_HOST_RUBY_PLATFORM` - The `RUBY_PLATFORM` of the host ruby.
 * `RCD_HOST_RUBY_VERSION` - The `RUBY_VERSION` of the host ruby.
 * `RUBY_CC_VERSION` - The target ruby versions for rake-compiler.
-    The default is defined in the [Dockerfile](https://github.com/rake-compiler/rake-compiler-dock/blob/master/Dockerfile), but can be changed as a parameter to rake.
+    The default is defined in the [Dockerfile](https://github.com/rake-compiler/rake-compiler-dock/blob/94770238d68d71df5f70abe76097451a575ce46c/Dockerfile.mri.erb#L229), but can be changed as a parameter to rake.
 * `RCD_MOUNTDIR` - The directory which is mounted into the docker container.
     Defaults to pwd.
 * `RCD_WORKDIR` - The working directory within the docker container.
@@ -197,7 +251,9 @@ The following variables are provided to the running docker container:
 
 Other environment variables can be set or passed through to the container like this:
 
-    RakeCompilerDock.sh "rake cross native gem OPENSSL_VERSION=#{ENV['OPENSSL_VERSION']}"
+```ruby
+RakeCompilerDock.sh "rake cross native gem OPENSSL_VERSION=#{ENV['OPENSSL_VERSION']}"
+```
 
 
 ## More information

data/Rakefile

@@ -7,26 +7,32 @@ require_relative "build/parallel_docker_build"
 RakeCompilerDock::GemHelper.install_tasks
 
 DOCKERHUB_USER = ENV['DOCKERHUB_USER'] || "larskanis"
+docker_build_cmd = Shellwords.split(ENV['RCD_DOCKER_BUILD'] || "docker build")
+
+platforms = [
+  ["x86-mingw32", "i686-w64-mingw32"],
+  ["x64-mingw32", "x86_64-w64-mingw32"],
+  ["x64-mingw-ucrt", "x86_64-w64-mingw32"],
+  ["x86-linux", "i686-redhat-linux"],
+  ["x86_64-linux", "x86_64-redhat-linux"],
+  ["x86_64-darwin", "x86_64-apple-darwin"],
+  ["arm64-darwin", "aarch64-apple-darwin"],
+  ["arm-linux", "arm-linux-gnueabihf"],
+  ["aarch64-linux", "aarch64-linux-gnu"],
+]
 
 namespace :build do
-  platforms = [
-    ["x86-mingw32", "i686-w64-mingw32"],
-    ["x64-mingw32", "x86_64-w64-mingw32"],
-    ["x86-linux", "i686-redhat-linux"],
-    ["x86_64-linux", "x86_64-redhat-linux"],
-    ["x86_64-darwin", "x86_64-apple-darwin"],
-    ["arm64-darwin", "aarch64-apple-darwin"],
-  ]
+
   platforms.each do |platform, target|
     sdf = "Dockerfile.mri.#{platform}"
 
     desc "Build image for platform #{platform}"
     task platform => sdf
     task sdf do
-      sh "docker build -t #{DOCKERHUB_USER}/rake-compiler-dock-mri-#{platform}:#{RakeCompilerDock::IMAGE_VERSION} -f Dockerfile.mri.#{platform} ."
+      sh(*docker_build_cmd, "-t", "#{DOCKERHUB_USER}/rake-compiler-dock-mri-#{platform}:#{RakeCompilerDock::IMAGE_VERSION}", "-f", "Dockerfile.mri.#{platform}", ".")
     end
 
-    df = ERB.new(File.read("Dockerfile.mri.erb")).result(binding)
+    df = ERB.new(File.read("Dockerfile.mri.erb"), trim_mode: ">").result(binding)
     File.write(sdf, df)
     CLEAN.include(sdf)
   end
@@ -34,10 +40,10 @@ namespace :build do
   desc "Build image for JRuby"
   task :jruby => "Dockerfile.jruby"
   task "Dockerfile.jruby" do
-    sh "docker build -t #{DOCKERHUB_USER}/rake-compiler-dock-jruby:#{RakeCompilerDock::IMAGE_VERSION} -f Dockerfile.jruby ."
+    sh(*docker_build_cmd, "-t", "#{DOCKERHUB_USER}/rake-compiler-dock-jruby:#{RakeCompilerDock::IMAGE_VERSION}", "-f", "Dockerfile.jruby", ".")
   end
 
-  RakeCompilerDock::ParallelDockerBuild.new(platforms.map{|pl, _| "Dockerfile.mri.#{pl}" } + ["Dockerfile.jruby"], workdir: "tmp/docker")
+  RakeCompilerDock::ParallelDockerBuild.new(platforms.map{|pl, _| "Dockerfile.mri.#{pl}" } + ["Dockerfile.jruby"], workdir: "tmp/docker", docker_build_cmd: docker_build_cmd)
 
   desc "Build images for all MRI platforms in parallel"
   multitask :mri => platforms.map(&:first)
@@ -48,6 +54,14 @@ end
 
 task :build => "build:all"
 
+namespace :prepare do
+  desc "Build cross compiler for x64-mingw-ucrt aka RubyInstaller-3.1+"
+  task "mingw64-ucrt" do
+    sh(*docker_build_cmd, "-t", "#{DOCKERHUB_USER}/mingw64-ucrt:20.04", ".",
+       chdir: "mingw64-ucrt")
+  end
+end
+
 desc "Run tests"
 task :test do
   sh "ruby -w -W2 -I. -Ilib -e \"#{Dir["test/test_*.rb"].map{|f| "require '#{f}';"}.join}\" -- -v"
@@ -74,3 +88,16 @@ task :update_lists do
     EOT
   end
 end
+
+namespace :release do
+  desc "push all docker images"
+  task :images do
+    jimg = "#{DOCKERHUB_USER}/rake-compiler-dock-jruby:#{RakeCompilerDock::IMAGE_VERSION}"
+    sh "docker", "push", jimg
+
+    platforms.each do |platform, _|
+      img = "#{DOCKERHUB_USER}/rake-compiler-dock-mri-#{platform}:#{RakeCompilerDock::IMAGE_VERSION}"
+      sh "docker", "push", img
+    end
+  end
+end

data/build/math_h.patch

@@ -0,0 +1,189 @@
+--- centos7/math.h	2020-12-31 23:15:40.678843646 +0100
++++ builtin/math.h	2022-03-16 21:35:13.086169875 +0100
+@@ -206,68 +206,142 @@
+       FP_NORMAL
+   };
+ 
++
++/* Depending on the type of TG_ARG, call an appropriately suffixed
++   version of FUNC with arguments (including parentheses) ARGS.
++   Suffixed functions may not exist for long double if it has the same
++   format as double, or for other types with the same format as float,
++   double or long double.  The behavior is undefined if the argument
++   does not have a real floating type.  The definition may use a
++   conditional expression, so all suffixed versions of FUNC must
++   return the same type (FUNC may include a cast if necessary rather
++   than being a single identifier).  */
++#ifdef __NO_LONG_DOUBLE_MATH
++# if __HAVE_DISTINCT_FLOAT128
++#  error "Distinct _Float128 without distinct long double not supported."
++# endif
++# define __MATH_TG(TG_ARG, FUNC, ARGS)					\
++  (sizeof (TG_ARG) == sizeof (float) ? FUNC ## f ARGS : FUNC ARGS)
++#elif __HAVE_DISTINCT_FLOAT128
++# if __HAVE_GENERIC_SELECTION
++#  if __HAVE_FLOATN_NOT_TYPEDEF && __HAVE_FLOAT32
++#   define __MATH_TG_F32(FUNC, ARGS) _Float32: FUNC ## f ARGS,
++#  else
++#   define __MATH_TG_F32(FUNC, ARGS)
++#  endif
++#  if __HAVE_FLOATN_NOT_TYPEDEF && __HAVE_FLOAT64X
++#   if __HAVE_FLOAT64X_LONG_DOUBLE
++#    define __MATH_TG_F64X(FUNC, ARGS) _Float64x: FUNC ## l ARGS,
++#   else
++#    define __MATH_TG_F64X(FUNC, ARGS) _Float64x: FUNC ## f128 ARGS,
++#   endif
++#  else
++#   define __MATH_TG_F64X(FUNC, ARGS)
++#  endif
++#  define __MATH_TG(TG_ARG, FUNC, ARGS)	\
++     _Generic ((TG_ARG),			\
++	       float: FUNC ## f ARGS,		\
++	       __MATH_TG_F32 (FUNC, ARGS)	\
++	       default: FUNC ARGS,		\
++	       long double: FUNC ## l ARGS,	\
++	       __MATH_TG_F64X (FUNC, ARGS)	\
++	       _Float128: FUNC ## f128 ARGS)
++# else
++#  if __HAVE_FLOATN_NOT_TYPEDEF
++#   error "Non-typedef _FloatN but no _Generic."
++#  endif
++#  define __MATH_TG(TG_ARG, FUNC, ARGS)					\
++     __builtin_choose_expr						\
++     (__builtin_types_compatible_p (__typeof (TG_ARG), float),		\
++      FUNC ## f ARGS,							\
++      __builtin_choose_expr						\
++      (__builtin_types_compatible_p (__typeof (TG_ARG), double),	\
++       FUNC ARGS,							\
++       __builtin_choose_expr						\
++       (__builtin_types_compatible_p (__typeof (TG_ARG), long double),	\
++	FUNC ## l ARGS,							\
++	FUNC ## f128 ARGS)))
++# endif
++#else
++# define __MATH_TG(TG_ARG, FUNC, ARGS)		\
++  (sizeof (TG_ARG) == sizeof (float)		\
++   ? FUNC ## f ARGS				\
++   : sizeof (TG_ARG) == sizeof (double)		\
++   ? FUNC ARGS					\
++   : FUNC ## l ARGS)
++#endif
++
+ /* Return number of classification appropriate for X.  */
+-# ifdef __NO_LONG_DOUBLE_MATH
+-#  define fpclassify(x) \
+-     (sizeof (x) == sizeof (float) ? __fpclassifyf (x) : __fpclassify (x))
+-# else
+-#  define fpclassify(x) \
+-     (sizeof (x) == sizeof (float)					      \
+-      ? __fpclassifyf (x)						      \
+-      : sizeof (x) == sizeof (double)					      \
+-      ? __fpclassify (x) : __fpclassifyl (x))
++# if ((__GNUC_PREREQ (4,4) && !defined __SUPPORT_SNAN__)		      \
++      )					      \
++     && (!defined __OPTIMIZE_SIZE__ || defined __cplusplus)
++     /* The check for __cplusplus allows the use of the builtin, even
++	when optimization for size is on.  This is provided for
++	libstdc++, only to let its configure test work when it is built
++	with -Os.  No further use of this definition of fpclassify is
++	expected in C++ mode, since libstdc++ provides its own version
++	of fpclassify in cmath (which undefines fpclassify).  */
++#  define fpclassify(x) __builtin_fpclassify (FP_NAN, FP_INFINITE,	      \
++     FP_NORMAL, FP_SUBNORMAL, FP_ZERO, x)
++# else
++#  define fpclassify(x) __MATH_TG ((x), __fpclassify, (x))
+ # endif
+ 
+ /* Return nonzero value if sign of X is negative.  */
+-# ifdef __NO_LONG_DOUBLE_MATH
+-#  define signbit(x) \
+-     (sizeof (x) == sizeof (float) ? __signbitf (x) : __signbit (x))
+-# else
+-#  define signbit(x) \
+-     (sizeof (x) == sizeof (float)					      \
+-      ? __signbitf (x)							      \
+-      : sizeof (x) == sizeof (double)					      \
+-      ? __signbit (x) : __signbitl (x))
++# if __GNUC_PREREQ (6,0)
++#  define signbit(x) __builtin_signbit (x)
++# elif defined __cplusplus
++  /* In C++ mode, __MATH_TG cannot be used, because it relies on
++     __builtin_types_compatible_p, which is a C-only builtin.
++     The check for __cplusplus allows the use of the builtin instead of
++     __MATH_TG. This is provided for libstdc++, only to let its configure
++     test work. No further use of this definition of signbit is expected
++     in C++ mode, since libstdc++ provides its own version of signbit
++     in cmath (which undefines signbit). */
++#  define signbit(x) __builtin_signbitl (x)
++# elif __GNUC_PREREQ (4,0)
++#  define signbit(x) __MATH_TG ((x), __builtin_signbit, (x))
++# else
++#  define signbit(x) __MATH_TG ((x), __signbit, (x))
+ # endif
+ 
+ /* Return nonzero value if X is not +-Inf or NaN.  */
+-# ifdef __NO_LONG_DOUBLE_MATH
+-#  define isfinite(x) \
+-     (sizeof (x) == sizeof (float) ? __finitef (x) : __finite (x))
+-# else
+-#  define isfinite(x) \
+-     (sizeof (x) == sizeof (float)					      \
+-      ? __finitef (x)							      \
+-      : sizeof (x) == sizeof (double)					      \
+-      ? __finite (x) : __finitel (x))
++# if (__GNUC_PREREQ (4,4) && !defined __SUPPORT_SNAN__)
++#  define isfinite(x) __builtin_isfinite (x)
++# else
++#  define isfinite(x) __MATH_TG ((x), __finite, (x))
+ # endif
+ 
+ /* Return nonzero value if X is neither zero, subnormal, Inf, nor NaN.  */
+-# define isnormal(x) (fpclassify (x) == FP_NORMAL)
++# if (__GNUC_PREREQ (4,4) && !defined __SUPPORT_SNAN__)
++#  define isnormal(x) __builtin_isnormal (x)
++# else
++#  define isnormal(x) (fpclassify (x) == FP_NORMAL)
++# endif
+ 
+ /* Return nonzero value if X is a NaN.  We could use `fpclassify' but
+    we already have this functions `__isnan' and it is faster.  */
+-# ifdef __NO_LONG_DOUBLE_MATH
+-#  define isnan(x) \
+-     (sizeof (x) == sizeof (float) ? __isnanf (x) : __isnan (x))
+-# else
+-#  define isnan(x) \
+-     (sizeof (x) == sizeof (float)					      \
+-      ? __isnanf (x)							      \
+-      : sizeof (x) == sizeof (double)					      \
+-      ? __isnan (x) : __isnanl (x))
++# if (__GNUC_PREREQ (4,4) && !defined __SUPPORT_SNAN__)
++#  define isnan(x) __builtin_isnan (x)
++# else
++#  define isnan(x) __MATH_TG ((x), __isnan, (x))
+ # endif
+ 
+ /* Return nonzero value if X is positive or negative infinity.  */
+-# ifdef __NO_LONG_DOUBLE_MATH
++# if __HAVE_DISTINCT_FLOAT128 && !__GNUC_PREREQ (7,0) \
++     && !defined __SUPPORT_SNAN__ && !defined __cplusplus
++   /* Since __builtin_isinf_sign is broken for float128 before GCC 7.0,
++      use the helper function, __isinff128, with older compilers.  This is
++      only provided for C mode, because in C++ mode, GCC has no support
++      for __builtin_types_compatible_p (and when in C++ mode, this macro is
++      not used anyway, because libstdc++ headers undefine it).  */
+ #  define isinf(x) \
+-     (sizeof (x) == sizeof (float) ? __isinff (x) : __isinf (x))
++    (__builtin_types_compatible_p (__typeof (x), _Float128) \
++     ? __isinff128 (x) : __builtin_isinf_sign (x))
++# elif (__GNUC_PREREQ (4,4) && !defined __SUPPORT_SNAN__)
++#  define isinf(x) __builtin_isinf_sign (x)
+ # else
+-#  define isinf(x) \
+-     (sizeof (x) == sizeof (float)					      \
+-      ? __isinff (x)							      \
+-      : sizeof (x) == sizeof (double)					      \
+-      ? __isinf (x) : __isinfl (x))
++#  define isinf(x) __MATH_TG ((x), __isinf, (x))
+ # endif
+ 
+ /* Bitmasks for the math_errhandling macro.  */

data/build/parallel_docker_build.rb

@@ -6,7 +6,11 @@ module RakeCompilerDock
   class ParallelDockerBuild
     include Rake::DSL
 
-    def initialize(dockerfiles, workdir: "tmp/docker", inputdir: ".", task_prefix: "common-")
+    attr_reader :docker_build_cmd
+
+    def initialize(dockerfiles, workdir: "tmp/docker", inputdir: ".", task_prefix: "common-",
+                   docker_build_cmd: %w["docker", "build"])
+      @docker_build_cmd = docker_build_cmd
       FileUtils.mkdir_p(workdir)
 
       files = parse_dockerfiles(dockerfiles, inputdir)
@@ -25,7 +29,7 @@ module RakeCompilerDock
     #    "File1"=>["      FROM a\n",
     #    ...
     def parse_dockerfiles(dockerfiles, inputdir)
-      files = dockerfiles.map do |fn|
+      dockerfiles.map do |fn|
         [fn, File.read(File.join(inputdir, fn))]
       end.map do |fn, f|
         # Split file contant in lines unless line ends with backslash
@@ -96,7 +100,7 @@ module RakeCompilerDock
     #
     # The layers will be reused in subsequent builds, even if they run in parallel.
     def docker_build(filename, workdir)
-      sh "docker", "build", "-f", File.join(workdir, filename), "."
+      sh(*docker_build_cmd, "-f", File.join(workdir, filename), ".")
     end
   end
 end

data/build/patches2/{rake-compiler-1.1.1 → rake-compiler-1.1.6}/0004-Enable-build-of-static-libruby.patch

@@ -1,8 +1,8 @@
 diff --git a/tasks/bin/cross-ruby.rake b/tasks/bin/cross-ruby.rake
-index 8edf5cd..5d25b82 100644
+index 8317a2a..5a1b3ea 100644
 --- a/tasks/bin/cross-ruby.rake
 +++ b/tasks/bin/cross-ruby.rake
-@@ -116,11 +116,22 @@ RUBY_CC_VERSIONS.split(":").each do |ruby_cc_version|
+@@ -116,10 +116,22 @@ RUBY_CC_VERSIONS.split(":").each do |ruby_cc_version|
          "--host=#{mingw_host}",
          "--target=#{mingw_target}",
          "--build=#{RUBY_BUILD}",
@@ -11,7 +11,6 @@ index 8edf5cd..5d25b82 100644
 +        '--disable-jit-support',
          '--disable-install-doc',
          '--with-ext=',
--        'LDFLAGS=-pipe -s',
        ]
 +      if mingw_host=~/darwin/
 +        options += [
@@ -24,6 +23,6 @@ index 8edf5cd..5d25b82 100644
 +          '--enable-shared',
 +        ]
 +      end
-
+ 
        # Force Winsock2 for Ruby 1.8, 1.9 defaults to it
        options << "--with-winsock2" if major == "1.8"

data/build/rcd-env.sh

@@ -0,0 +1,6 @@
+# set up a working RCD build environment
+export RAKE_EXTENSION_TASK_NO_NATIVE=true
+if ! test -e "$HOME"/.rake-compiler ; then
+  ln -s /usr/local/rake-compiler "$HOME"/.rake-compiler
+fi
+mkdir -p "$HOME"/.gem

data/build/runas

@@ -4,12 +4,4 @@ groupadd -o -g "$GID" "$GROUP"
 mkdir -p /tmp/home
 useradd -o -g "$GID" -u "$UID" -G rvm,sudo -p "" -b /tmp/home -m "$USER"
 
-HOME=$(bash <<< "echo ~$USER")
-ln -s /usr/local/rake-compiler "$HOME"/.rake-compiler
-mkdir -p "$HOME"/.gem
-chown "$USER" "$HOME"/.gem
-
-/usr/bin/sudo -u "$USER" -H \
-    BASH_ENV=/etc/rubybashrc \
-    RAKE_EXTENSION_TASK_NO_NATIVE=true \
-    -- "$@"
+/usr/bin/sudo -u "$USER" -H BASH_ENV=/etc/rubybashrc -- "$@"

data/lib/rake_compiler_dock/starter.rb

@@ -41,11 +41,12 @@ module RakeCompilerDock
         user = options.fetch(:username){ current_user }
         group = options.fetch(:groupname){ current_group }
         rubyvm = options.fetch(:rubyvm){ ENV['RCD_RUBYVM'] } || "mri"
+        jrubyvm = rubyvm.to_s == "jruby"
 
-        platforms = options.fetch(:platform){ ENV['RCD_PLATFORM'] } || "x86-mingw32 x64-mingw32"
+        platforms = options.fetch(:platform){ ENV['RCD_PLATFORM'] } || (jrubyvm ? "jruby" : "x86-mingw32 x64-mingw32")
         platforms.split(" ").each do |platform|
           image_name = options.fetch(:image) do
-            platform_postfix = rubyvm.to_s == "jruby" ? "" : "-#{platform}"
+            platform_postfix = jrubyvm ? "" : "-#{platform}"
             ENV['RCD_IMAGE'] ||
                 ENV['RAKE_COMPILER_DOCK_IMAGE'] ||
                 "larskanis/rake-compiler-dock-#{rubyvm}#{platform_postfix}:#{IMAGE_VERSION}"

data/lib/rake_compiler_dock/version.rb

@@ -1,4 +1,4 @@
 module RakeCompilerDock
-  VERSION = "1.1.0"
-  IMAGE_VERSION = "1.1.0"
+  VERSION = "1.2.2"
+  IMAGE_VERSION = "1.2.2"
 end

data/mingw64-ucrt/Dockerfile

@@ -0,0 +1,62 @@
+FROM ubuntu:20.04
+
+ARG DEBIAN_FRONTEND=noninteractive
+
+RUN set -ex \
+    && sed -i -- 's/# deb-src/deb-src/g' /etc/apt/sources.list \
+    && apt-get update \
+    && apt-get install -y --no-install-recommends \
+               build-essential \
+               cdbs \
+               devscripts \
+               equivs \
+               fakeroot \
+               pkg-config \
+    && apt-get clean \
+    && rm -rf /tmp/* /var/tmp/*
+
+WORKDIR /build
+
+# Download mingw sources
+RUN apt-get source mingw-w64-common && \
+    cd mingw-w64-* && \
+    mk-build-deps -ir -t "apt-get -o Debug::pkgProblemResolver=yes -y --no-install-recommends"
+
+# Patch build for UCRT and build UCRT enabled deb-packages
+ADD mingw-w64-*.patch ./
+RUN cd mingw-w64-* && \
+    cat debian/rules && \
+    ls ../mingw-w64-*.patch | xargs -n1 patch --verbose -p1 -i && \
+    dpkg-buildpackage -b && \
+    rm -rf ../*.ddeb ../*i686* `pwd`
+
+# Install UCRT enabled deb-packages
+RUN dpkg -i mingw-w64-common_7.0.0-2_all.deb \
+    mingw-w64-tools_7.0.0-2_amd64.deb \
+    mingw-w64-x86-64-dev_7.0.0-2_all.deb
+
+# Download gcc-binutils sources for mingw
+RUN apt-get source binutils-mingw-w64 && \
+    cd binutils-mingw-w64-* && \
+    mk-build-deps -ir -t "apt-get -o Debug::pkgProblemResolver=yes -y --no-install-recommends"
+
+# Build gcc-binutils based on UCRT headers and crt
+ADD binutils-mingw-w64-*.patch ./
+RUN cd binutils-mingw-w64-* && \
+    ls ../binutils-mingw-w64-*.patch | xargs -n1 patch --verbose -p1 -i && \
+    dpkg-buildpackage -b --jobs=auto && \
+    rm -rf ../*.ddeb ../*i686* `pwd`
+
+# Download gcc sources for mingw
+RUN apt-get source gcc-mingw-w64 && \
+    cd gcc-mingw-w64-* && \
+    mk-build-deps -ir -t "apt-get -o Debug::pkgProblemResolver=yes -y --no-install-recommends"
+
+# Build gcc (only C and C++) based on UCRT headers and crt
+ADD gcc-mingw-w64-*.patch ./
+RUN cd gcc-mingw-w64-* && \
+    ls ../gcc-mingw-w64-*.patch | xargs -n1 patch --verbose -p1 -i && \
+    dpkg-buildpackage -b --jobs=auto && \
+    rm -rf ../*.ddeb ../*i686* `pwd`
+
+RUN ls -l *.deb