#!/usr/bin/env bash
#
# Usage: ruby-build [-kpv] <definition> <prefix>
#        ruby-build --definitions
#        ruby-build --version
#
#   -k/--keep        Do not remove source tree after installation
#   -p/--patch       Apply a patch from stdin before building
#   -v/--verbose     Verbose mode: print compilation status to stdout
#   -4/--ipv4        Resolve names to IPv4 addresses only
#   -6/--ipv6        Resolve names to IPv6 addresses only
#   --definitions    List all local definitions
#   -l/--list        List latest stable releases for each Ruby
#   --version        Show version of ruby-build
#

RUBY_BUILD_VERSION="20231025"

OLDIFS="$IFS"

set -E
exec 3<&2 # preserve original stderr at fd 3


lib() {
  parse_options() {
    OPTIONS=()
    ARGUMENTS=()
    EXTRA_ARGUMENTS=()
    local arg option index

    while [ $# -gt 0 ]; do
      arg="$1"
      if [ "$arg" == "--" ]; then
        shift 1
        break
      elif [ "${arg:0:1}" = "-" ]; then
        if [ "${arg:1:1}" = "-" ]; then
          OPTIONS[${#OPTIONS[*]}]="${arg:2}"
        else
          index=1
          while option="${arg:$index:1}"; do
            [ -n "$option" ] || break
            OPTIONS[${#OPTIONS[*]}]="$option"
            index=$((index+1))
          done
        fi
        shift 1
      else
        ARGUMENTS[${#ARGUMENTS[*]}]="$arg"
        shift 1
      fi
    done

    EXTRA_ARGUMENTS=("$@")
  }

  if [ "$1" == "--${FUNCNAME[0]}" ]; then
    declare -f "${FUNCNAME[0]}"
    echo "${FUNCNAME[0]} \"\$1\";"
    exit
  fi
}
lib "$1"


resolve_link() {
  $(type -p greadlink readlink | head -1) "$1"
}

abs_dirname() {
  local path="$1"
  local cwd
  cwd="$(pwd || true)"

  while [ -n "$path" ]; do
    cd "${path%/*}" || return 1
    local name="${path##*/}"
    path="$(resolve_link "$name" || true)"
  done

  pwd
  cd "$cwd" || return 1
}

capitalize() {
  # shellcheck disable=SC2018,SC2019
  printf "%s" "$1" | tr 'a-z' 'A-Z'
}

sanitize() {
  printf "%s" "$1" | sed "s/[^A-Za-z0-9.-]/_/g; s/__*/_/g"
}

colorize() {
  if [ -t 1 ]; then printf "\e[%sm%s\e[m" "$1" "$2"
  else echo -n "$2"
  fi
}

os_information() {
  if type -p lsb_release >/dev/null; then
    lsb_release -sir | xargs echo
  elif type -p sw_vers >/dev/null; then
    echo "$(sw_vers -productName) $(sw_vers -productVersion)"
  elif [ -r /etc/os-release ]; then
    # shellcheck disable=SC1091
    source /etc/os-release
    # shellcheck disable=SC2153
    echo "$NAME $VERSION_ID"
  else
    local os
    os="$(cat /etc/{centos,redhat,fedora,system}-release /etc/debian_version 2>/dev/null | head -1)"
    echo "${os:-$(uname -sr)}"
  fi
}

is_mac() {
  [ "$(uname -s)" = "Darwin" ] || return 1
  [ $# -eq 0 ] || [ "$(osx_version)" -ge "$1" ]
}

is_freebsd() {
  [ "$(uname -s)" = "FreeBSD" ]
}

freebsd_package_prefix() {
  local package="$1"
  pkg info --prefix "$package" 2>/dev/null | cut -wf2
}

#  9.1  -> 901
# 10.9  -> 1009
# 10.10 -> 1010
osx_version() {
  local ver
  IFS=. read -d "" -r -a ver <<<"$(sw_vers -productVersion)" || true
  IFS="$OLDIFS"
  echo $(( ver[0]*100 + ver[1] ))
}

build_failed() {
  { echo
    colorize 1 "BUILD FAILED"
    echo " ($(os_information) using $(version))"
    echo

    if ! rmdir "${BUILD_PATH}" 2>/dev/null; then
      echo "Inspect or clean up the working tree at ${BUILD_PATH}"

      if [ -n "$(head -1 "$LOG_PATH" 2>/dev/null)" ]; then
        colorize 33 "Results logged to ${LOG_PATH}"
        printf "\n\n"
        echo "Last 10 log lines:"
        tail -n 10 "$LOG_PATH"
      fi
    fi
  } >&3
  exit 1
}

num_cpu_cores() {
  local num
  case "$(uname -s)" in
  Darwin | *BSD )
    num="$(sysctl -n hw.ncpu 2>/dev/null || true)"
    ;;
  SunOS )
    num="$(getconf NPROCESSORS_ONLN 2>/dev/null || true)"
    ;;
  * )
    num="$({ getconf _NPROCESSORS_ONLN ||
             grep -c ^processor /proc/cpuinfo; } 2>/dev/null)"
    num="${num#0}"
    ;;
  esac
  echo "${num:-2}"
}

install_package() {
  install_package_using "tarball" 1 "$@"
}

install_git() {
  install_package_using "git" 2 "$@"
}

install_package_using() {
  local package_type="$1"
  local package_type_nargs="$2"
  local package_name="$3"
  shift 3

  local fetch_args=( "$package_name" "${@:1:$package_type_nargs}" )
  local make_args=( "$package_name" )
  local arg last_arg

  for arg in "${@:$(( package_type_nargs + 1 ))}"; do
    if [ "$last_arg" = "--if" ]; then
      "$arg" || return 0
    elif [ "$arg" != "--if" ]; then
      make_args["${#make_args[@]}"]="$arg"
    fi
    last_arg="$arg"
  done

  # shellcheck disable=SC2164
  pushd "$BUILD_PATH" >&4
  "fetch_${package_type}" "${fetch_args[@]}"
  make_package "${make_args[@]}"
  # shellcheck disable=SC2164
  popd >&4

  { echo "Installed ${package_name} to ${PREFIX_PATH}"
    echo
  } >&2
}

make_package() {
  local package_name="$1"
  shift

# shellcheck disable=SC2164
  pushd "$package_name" >&4
  before_install_package "$package_name"
  build_package "$package_name" "$@"
  after_install_package "$package_name"
  # shellcheck disable=SC2164
  popd >&4
}

compute_sha2() {
  local output
  if type shasum &>/dev/null; then
    output="$(shasum -a 256 -b)" || return 1
    echo "${output% *}"
  elif type openssl &>/dev/null; then
    local openssl
    openssl="$(command -v "$(brew --prefix openssl 2>/dev/null || true)"/bin/openssl openssl | head -1)"
    output="$("$openssl" dgst -sha256 2>/dev/null)" || return 1
    echo "${output##* }"
  elif type sha256sum &>/dev/null; then
    output="$(sha256sum -b)" || return 1
    echo "${output%% *}"
  else
    return 1
  fi
}

compute_md5() {
  local output
  if type md5 &>/dev/null; then
    md5 -q
  elif type openssl &>/dev/null; then
    output="$(openssl md5)" || return 1
    echo "${output##* }"
  elif type md5sum &>/dev/null; then
    output="$(md5sum -b)" || return 1
    echo "${output%% *}"
  else
    return 1
  fi
}

has_checksum_support() {
  local checksum_command="$1"
  local has_checksum_var="HAS_CHECKSUM_SUPPORT_${checksum_command}"

  if [ -z "${!has_checksum_var+defined}" ]; then
    if "$checksum_command" <<<"test" >/dev/null; then
      printf -v "$has_checksum_var" 0 # success
    else
      printf -v "$has_checksum_var" 1 # error
    fi
  fi
  return "${!has_checksum_var}"
}

verify_checksum() {
  local checksum_command
  local filename="$1"
  local expected_checksum
  expected_checksum="$(tr 'A-F' 'a-f' <<<"$2")"

  # If the specified filename doesn't exist, return success
  [ -e "$filename" ] || return 0

  case "${#expected_checksum}" in
  0) return 0 ;; # empty checksum; return success
  32) checksum_command="compute_md5" ;;
  64) checksum_command="compute_sha2" ;;
  *)
    { echo
      echo "unexpected checksum length: ${#expected_checksum} (${expected_checksum})"
      echo "expected 0 (no checksum), 32 (MD5), or 64 (SHA2-256)"
      echo
    } >&4
    return 1 ;;
  esac

  # If chosen provided checksum algorithm isn't supported, return success
  has_checksum_support "$checksum_command" || return 0

  # If the computed checksum is empty, return failure
  local computed_checksum
  computed_checksum="$("$checksum_command" < "$filename" | tr 'A-F' 'a-f')"
  [ -n "$computed_checksum" ] || return 1

  if [ "$expected_checksum" != "$computed_checksum" ]; then
    { echo
      echo "checksum mismatch: ${filename} (file is corrupt)"
      echo "expected $expected_checksum, got $computed_checksum"
      echo
    } >&4
    return 1
  fi
}

http() {
  local method="$1"
  [ -n "$2" ] || return 1
  shift 1

  RUBY_BUILD_HTTP_CLIENT="${RUBY_BUILD_HTTP_CLIENT:-$(detect_http_client 2>&3)}"
  [ -n "$RUBY_BUILD_HTTP_CLIENT" ] || return 1

  "http_${method}_${RUBY_BUILD_HTTP_CLIENT}" "$@"
}

detect_http_client() {
  local client
  for client in aria2c curl wget; do
    if type "$client" &>/dev/null; then
      echo "$client"
      return
    fi
  done
  echo "error: install \`curl\`, \`wget\`, or \`aria2c\` to download packages" >&2
  return 1
}

http_head_aria2c() {
  # shellcheck disable=SC2086
  aria2c --dry-run --no-conf=true ${ARIA2_OPTS} "$1" >&4 2>&1
}

http_get_aria2c() {
  local out="${2:-$(mktemp "out.XXXXXX")}"
  # shellcheck disable=SC2086
  if aria2c --allow-overwrite=true --no-conf=true -o "${out}" ${ARIA2_OPTS} "$1" >&4; then
    [ -n "$2" ] || cat "${out}"
  else
    false
  fi
}

http_head_curl() {
  # shellcheck disable=SC2086
  curl -qsILf ${CURL_OPTS} "$1" >&4 2>&1
}

http_get_curl() {
  # shellcheck disable=SC2086
  curl -q -o "${2:--}" -sSLf ${CURL_OPTS} "$1"
}

http_head_wget() {
  # shellcheck disable=SC2086
  wget -q --spider ${WGET_OPTS} "$1" >&4 2>&1
}

http_get_wget() {
  # shellcheck disable=SC2086
  wget -nv ${WGET_OPTS} -O "${2:--}" "$1"
}

fetch_tarball() {
  local package_name="$1"
  local package_url="$2"
  local mirror_url
  local checksum
  local extracted_dir

  if is_ruby_package "$1" && [ -n "$RUBY_BUILD_TARBALL_OVERRIDE" ]; then
    package_url="$RUBY_BUILD_TARBALL_OVERRIDE"
  fi

  if [ "$package_url" != "${package_url/\#}" ]; then
    checksum="${package_url#*#}"
    package_url="${package_url%%#*}"

    if [ -n "$RUBY_BUILD_MIRROR_URL" ]; then
      if [[ -z "$RUBY_BUILD_DEFAULT_MIRROR" || $package_url != */cache.ruby-lang.org/* ]]; then
        mirror_url="${RUBY_BUILD_MIRROR_URL}/$checksum"
      fi
    elif [ -n "$RUBY_BUILD_MIRROR_PACKAGE_URL" ]; then
      mirror_url="$RUBY_BUILD_MIRROR_PACKAGE_URL"
    fi
  fi

  local tar_args="xzf"
  local package_filename="${package_name}.tar.gz"

  if [ "$package_url" != "${package_url%bz2}" ]; then
    if ! type -p bzip2 >/dev/null; then
      echo "warning: bzip2 not found; consider installing \`bzip2\` package" >&4
    fi
    package_filename="${package_filename%.gz}.bz2"
    tar_args="${tar_args/z/j}"
  fi

  if ! reuse_existing_tarball "$package_filename" "$checksum"; then
    local tarball_filename
    tarball_filename="$(basename "$package_url")"
    echo "Downloading ${tarball_filename}..." >&2
    # shellcheck disable=SC2015
    http head "$mirror_url" &&
    download_tarball "$mirror_url" "$package_filename" "$checksum" ||
    download_tarball "$package_url" "$package_filename" "$checksum"
  fi

  { if tar "$tar_args" "$package_filename"; then
      if [ ! -d "$package_name" ]; then
        extracted_dir="$(find_extracted_directory)"
        mv "$extracted_dir" "$package_name"
      fi

      if [ -z "$KEEP_BUILD_PATH" ]; then
        rm -f "$package_filename"
      else
        true
      fi
    fi
  } >&4 2>&1
}

find_extracted_directory() {
  for f in *; do
    if [ -d "$f" ]; then
      echo "$f"
      return
    fi
  done
  echo "Extracted directory not found" >&2
  return 1
}

reuse_existing_tarball() {
  local package_filename="$1"
  local checksum="$2"

  # Reuse existing file in build location
  if [ -e "$package_filename" ] && verify_checksum "$package_filename" "$checksum"; then
    return 0
  fi

  # Reuse previously downloaded file in cache location
  [ -n "$RUBY_BUILD_CACHE_PATH" ] || return 1
  local cached_package_filename="${RUBY_BUILD_CACHE_PATH}/$package_filename"

  [ -e "$cached_package_filename" ] || return 1
  verify_checksum "$cached_package_filename" "$checksum" >&4 2>&1 || return 1
  ln -s "$cached_package_filename" "$package_filename" >&4 2>&1 || return 1
}

download_tarball() {
  local package_url="$1"
  [ -n "$package_url" ] || return 1

  local package_filename="$2"
  local checksum="$3"

  echo "-> $package_url" >&2

  if http get "$package_url" "$package_filename" >&4 2>&1; then
    verify_checksum "$package_filename" "$checksum" >&4 2>&1 || return 1
  else
    echo "error: failed to download $package_filename" >&2
    return 1
  fi

  if [ -n "$RUBY_BUILD_CACHE_PATH" ]; then
    local cached_package_filename="${RUBY_BUILD_CACHE_PATH}/$package_filename"
    { mv "$package_filename" "$cached_package_filename"
      ln -s "$cached_package_filename" "$package_filename"
    } >&4 2>&1 || return 1
  fi
}

fetch_git() {
  local package_name="$1"
  local git_url="$2"
  local git_ref="$3"

  echo "Cloning ${git_url}..." >&2

  if ! type git &>/dev/null; then
    echo "error: please install \`git\` and try again" >&2
    exit 1
  fi

  if [ -n "$RUBY_BUILD_CACHE_PATH" ]; then
    local cache_dir
    cache_dir="$RUBY_BUILD_CACHE_PATH/$(sanitize "$git_url")"
    if [ -e "$cache_dir" ]; then
      git -C "$cache_dir" fetch --force "$git_url" "+${git_ref}:${git_ref}" >&4 2>&1
    else
      git clone --bare --branch "$git_ref" "$git_url" "$cache_dir" >&4 2>&1
    fi
    git_url="$cache_dir"
  fi

  if [ -e "${package_name}" ]; then
    git -C "$package_name" fetch --depth 1 origin "+${git_ref}" >&4 2>&1
    git -C "$package_name" checkout -q -B "$git_ref" "origin/${git_ref}" >&4 2>&1
  else
    git clone --depth 1 --branch "$git_ref" "$git_url" "${package_name}" >&4 2>&1
  fi
}

build_package() {
  local package_name="$1"
  shift

  if [ "$#" -eq 0 ]; then
    local commands="standard"
  else
    local commands="$*"
  fi

  echo "Installing ${package_name}..." >&2

  [ -n "$HAS_PATCH" ] && apply_ruby_patch "$package_name"

  for command in $commands; do
    "build_package_${command}" "$package_name"
  done
}

package_option() {
  local package_name="$1"
  local command_name="$2"
  local variable
  # e.g. RUBY_CONFIGURE_OPTS_ARRAY, OPENSSL_MAKE_OPTS_ARRAY
  variable="$(capitalize "${package_name}_${command_name}")_OPTS_ARRAY"
  local array="${variable}[@]"
  shift 2
  # shellcheck disable=SC2034
  local value=( "${!array}" "$@" )
  eval "$variable=( \"\${value[@]}\" )"
}

build_package_warn_eol() {
  local package_name="$1"

  { echo
    echo "WARNING: $package_name is past its end of life and is now unsupported."
    echo "It no longer receives bug fixes or critical security updates."
    echo
  } >&3
}

build_package_warn_unsupported() {
  local package_name="$1"

  { echo
    echo "WARNING: $package_name is nearing its end of life."
    echo "It only receives critical security updates, no bug fixes."
    echo
  } >&3
}

build_package_standard_build() {
  local package_name="$1"

  if [ "${MAKEOPTS+defined}" ]; then
    MAKE_OPTS="$MAKEOPTS"
  elif [ -z "${MAKE_OPTS+defined}" ]; then
    MAKE_OPTS="-j $(num_cpu_cores)"
  fi

  # Support YAML_CONFIGURE_OPTS, RUBY_CONFIGURE_OPTS, etc.
  local package_var_name
  package_var_name="$(capitalize "${package_name%%-*}")"
  local PACKAGE_CONFIGURE="${package_var_name}_CONFIGURE"
  local PACKAGE_PREFIX_PATH="${package_var_name}_PREFIX_PATH"
  local PACKAGE_CONFIGURE_OPTS="${package_var_name}_CONFIGURE_OPTS"
  local PACKAGE_CONFIGURE_OPTS_ARRAY="${package_var_name}_CONFIGURE_OPTS_ARRAY[@]"
  local PACKAGE_MAKE_OPTS="${package_var_name}_MAKE_OPTS"
  local PACKAGE_MAKE_OPTS_ARRAY="${package_var_name}_MAKE_OPTS_ARRAY[@]"
  local PACKAGE_CFLAGS="${package_var_name}_CFLAGS"

  if [ "$package_var_name" = "RUBY" ]; then
    if [[ "$RUBY_CONFIGURE_OPTS ${RUBY_CONFIGURE_OPTS_ARRAY[*]}" != *--with-readline-dir=* ]]; then
      use_homebrew_readline || use_freebsd_readline || true
    fi
    if [[ "$RUBY_CONFIGURE_OPTS ${RUBY_CONFIGURE_OPTS_ARRAY[*]}" != *--with-libffi-dir=* ]]; then
      use_freebsd_libffi || true
    fi
    if [[ "$RUBY_CONFIGURE_OPTS ${RUBY_CONFIGURE_OPTS_ARRAY[*]}" != *--with-libyaml-dir=* ]]; then
      use_homebrew_yaml || use_freebsd_yaml || true
    fi
    if [[ "$RUBY_CONFIGURE_OPTS ${RUBY_CONFIGURE_OPTS_ARRAY[*]}" != *--with-gmp-dir=* ]]; then
      use_homebrew_gmp || true
    fi
    if [[ "$RUBY_CONFIGURE_OPTS ${RUBY_CONFIGURE_OPTS_ARRAY[*]}" != *--with-openssl-dir=* ]]; then
      if is_freebsd && [ -f /usr/local/include/openssl/ssl.h ]; then
        # use openssl installed from Ports Collection
        package_option ruby configure --with-openssl-dir="/usr/local"
      fi
    fi
  fi

  ( if [ "${CFLAGS+defined}" ] || [ "${!PACKAGE_CFLAGS+defined}" ]; then
      export CFLAGS="$CFLAGS ${!PACKAGE_CFLAGS}"
    fi
    if [ -z "$CC" ] && is_mac 1010; then
      export CC=clang
    fi
    # shellcheck disable=SC2086,SC2153
    ${!PACKAGE_CONFIGURE:-./configure} --prefix="${!PACKAGE_PREFIX_PATH:-$PREFIX_PATH}" \
      "${!PACKAGE_CONFIGURE_OPTS_ARRAY}" $CONFIGURE_OPTS ${!PACKAGE_CONFIGURE_OPTS} || return 1
  ) >&4 2>&1

  # shellcheck disable=SC2086
  { "$MAKE" "${!PACKAGE_MAKE_OPTS_ARRAY}" $MAKE_OPTS ${!PACKAGE_MAKE_OPTS}
  } >&4 2>&1
}

build_package_standard_install() {
  local package_name="$1"
  local package_var_name
  package_var_name="$(capitalize "${package_name%%-*}")"

  local PACKAGE_MAKE_INSTALL_OPTS="${package_var_name}_MAKE_INSTALL_OPTS"
  local PACKAGE_MAKE_INSTALL_OPTS_ARRAY="${package_var_name}_MAKE_INSTALL_OPTS_ARRAY[@]"

  # shellcheck disable=SC2086
  { "$MAKE" ${MAKE_INSTALL_TARGET:-install} "${!PACKAGE_MAKE_INSTALL_OPTS_ARRAY}" $MAKE_INSTALL_OPTS ${!PACKAGE_MAKE_INSTALL_OPTS}
  } >&4 2>&1
}

build_package_standard_install_with_bundled_gems() {
  { "$MAKE" update-gems
    "$MAKE" extract-gems
  } >&4 2>&1

  build_package_standard_install "$@"
}

# Backward Compatibility for standard function
build_package_standard() {
  build_package_standard_build "$@"
  build_package_standard_install "$@"
}

build_package_autoconf() {
  { autoreconf -i
  } >&4 2>&1
}

build_package_ruby() {
  local package_name="$1"

  { "$RUBY_BIN" setup.rb
  } >&4 2>&1
}

build_package_ree_installer() {
  build_package_auto_tcltk

  local options=()
  is_mac && options+=(--no-tcmalloc)

  local option
  for option in "${RUBY_CONFIGURE_OPTS_ARRAY[@]}" $RUBY_CONFIGURE_OPTS; do
    options+=(-c "$option")
  done

  # Work around install_useful_libraries crash with --dont-install-useful-gems
  mkdir -p "$PREFIX_PATH/lib/ruby/gems/1.8/gems"

  # shellcheck disable=SC2086
  { ./installer --auto "$PREFIX_PATH" --dont-install-useful-gems "${options[@]}" $CONFIGURE_OPTS
  } >&4 2>&1
}

build_package_rbx() {
  local package_name="$1"

  { [ ! -e "Gemfile" ] || bundle --path=vendor/bundle
    if [ -n "$RUBY_BUILD_CACHE_PATH" ]; then
      mkdir -p vendor
      ln -s "$RUBY_BUILD_CACHE_PATH" vendor/prebuilt
    fi

    local opt
    local -a configure_opts
    for opt in "${RUBY_CONFIGURE_OPTS_ARRAY[@]}"; do
      if [[ $opt == --with-openssl-dir=* ]]; then
        local openssl_dir="${opt#*=}"
        configure_opts[${#configure_opts[@]}]="--with-lib-dir=${openssl_dir}/lib"
        configure_opts[${#configure_opts[@]}]="--with-include-dir=${openssl_dir}/include"
      else
        configure_opts[${#configure_opts[@]}]="$opt"
      fi
    done

    # shellcheck disable=SC2086
    RUBYOPT="-rrubygems $RUBYOPT" ./configure --prefix="$PREFIX_PATH" "${configure_opts[@]}" $RUBY_CONFIGURE_OPTS
    rake install
    fix_rbx_gem_binstubs "$PREFIX_PATH"
    fix_rbx_irb "$PREFIX_PATH"
  } >&4 2>&1
}

build_package_mruby() {
  { ./minirake
    mkdir -p "$PREFIX_PATH"
    cp -fR build/host/* include "$PREFIX_PATH"
    ln -fs mruby "$PREFIX_PATH/bin/ruby"
    ln -fs mirb "$PREFIX_PATH/bin/irb"
  } >&4 2>&1
}

build_package_picoruby() {
  { ./minirake
    mkdir -p "$PREFIX_PATH"
    cp -fR build/host/* include "$PREFIX_PATH"
    ln -fs picoruby "$PREFIX_PATH/bin/ruby"
    ln -fs picoirb "$PREFIX_PATH/bin/irb"
  } >&4 2>&1
}

build_package_maglev() {
  build_package_copy

  { # shellcheck disable=SC2164
    cd "${PREFIX_PATH}"
    ./install.sh
    # shellcheck disable=SC2164
    cd "${PREFIX_PATH}/bin"
    echo "Creating symlink for ruby*"
    ln -fs maglev-ruby ruby
    echo "Creating symlink for irb*"
    ln -fs maglev-irb irb
  } >&4 2>&1
  echo
  echo "Run 'maglev start' to start up the stone before using 'ruby' or 'irb'"
}

build_package_topaz() {
  build_package_copy
  { # shellcheck disable=SC2164
    cd "${PREFIX_PATH}/bin"
    echo "Creating symlink for ruby*"
    ln -fs topaz ruby
  } >&4 2>&1
}

topaz_architecture() {
  case "$(uname -s)" in
  "Darwin") echo "osx64";;
  "Linux") [[ "$(uname -m)" = "x86_64" ]] && echo "linux64" || echo "linux32";;
  *)
    echo "no nightly builds available" >&2
    exit 1;;
  esac
}

build_package_jruby() {
  build_package_copy
  # shellcheck disable=SC2164
  cd "${PREFIX_PATH}/bin"
  ln -fs jruby ruby
  chmod +x ruby
  install_jruby_launcher
  remove_windows_files
  fix_jruby_shebangs
}

install_jruby_launcher() {
  # shellcheck disable=SC2164
  cd "${PREFIX_PATH}/bin"
  # workaround for https://github.com/jruby/jruby/issues/7799
  local jruby_version
  jruby_version="$(./ruby -e 'puts JRUBY_VERSION' 2>/dev/null)"
  [[ $jruby_version != "9.2."* ]] ||
    ./ruby gem update -q --silent --system 3.3.26 --no-document --no-post-install-message >&4 2>&1
  { ./ruby gem install jruby-launcher --no-document
  } >&4 2>&1
}

fix_jruby_shebangs() {
  for file in "${PREFIX_PATH}/bin"/*; do
    if [ "$(head -c 20 "$file" | LC_CTYPE=C tr -d '\0')" = "#!/usr/bin/env jruby" ]; then
      sed -i.bak "1 s:.*:#\!${PREFIX_PATH}\/bin\/jruby:" "$file"
      rm "$file".bak
    fi
  done
}

build_package_truffleruby() {
  clean_prefix_path_truffleruby || return $?
  build_package_copy

  # shellcheck disable=SC2164
  cd "${PREFIX_PATH}"
  "${PREFIX_PATH}/lib/truffle/post_install_hook.sh"
}

build_package_truffleruby_graalvm() {
  clean_prefix_path_truffleruby || return $?
  PREFIX_PATH="${PREFIX_PATH}/graalvm" build_package_copy

  if is_mac; then
    # shellcheck disable=SC2164
    cd "${PREFIX_PATH}/graalvm/Contents/Home"
  else
    # shellcheck disable=SC2164
    cd "${PREFIX_PATH}/graalvm"
  fi

  if [ -e bin/gu ]; then
    bin/gu install ruby || return $?
  fi

  local ruby_home
  ruby_home=$(bin/ruby -e 'print RbConfig::CONFIG["prefix"]')

  # Make gu available in PATH (useful to install other languages)
  ln -s "$PWD/bin/gu" "$ruby_home/bin/gu"

  # shellcheck disable=SC2164
  cd "${PREFIX_PATH}"
  ln -s "${ruby_home#"$PREFIX_PATH/"}/bin" . || return $?

  "$ruby_home/lib/truffle/post_install_hook.sh"
}

build_package_artichoke() {
  build_package_copy

  mkdir -p "$PREFIX_PATH/bin"
  # shellcheck disable=SC2164
  cd "${PREFIX_PATH}/bin"
  ln -fs ../artichoke ruby
  ln -fs ../airb irb
  ln -fs ../artichoke artichoke
  ln -fs ../airb airb
}

remove_windows_files() {
  # shellcheck disable=SC2164
  cd "$PREFIX_PATH"
  rm -f bin/*.exe bin/*.dll bin/*.bat bin/jruby.sh
}

clean_prefix_path_truffleruby() {
  if [ -d "$PREFIX_PATH" ] &&
     [ ! -e "$PREFIX_PATH/bin/truffleruby" ] &&
     [ -n "$(ls -A "$PREFIX_PATH")" ]; then
    echo
    echo "ERROR: cannot install TruffleRuby to $PREFIX_PATH, which does not look like a valid TruffleRuby prefix" >&2
    echo "TruffleRuby only supports being installed to a not existing directory, an empty directory, or replacing an existing TruffleRuby installation"
    echo "See https://github.com/oracle/truffleruby/issues/1389 for details" >&2
    return 1
  fi

  # Make sure there are no leftover files in $PREFIX_PATH
  rm -rf "$PREFIX_PATH"
}

build_package_copy() {
  mkdir -p "$PREFIX_PATH"
  cp -fR . "$PREFIX_PATH"
}

before_install_package() {
  local stub=1
}

after_install_package() {
  local stub=1
}

fix_rbx_gem_binstubs() {
  local prefix="$1"
  local gemdir="${prefix}/gems/bin"
  local bindir="${prefix}/bin"
  local file binstub
  # Symlink Rubinius' `gems/bin/` into `bin/`
  if [ -d "$gemdir" ] && [ ! -L "$gemdir" ]; then
    for file in "$gemdir"/*; do
      binstub="${bindir}/${file##*/}"
      rm -f "$binstub"
      { echo "#!${bindir}/ruby"
        grep -v '^#!' "$file"
      } > "$binstub"
      chmod +x "$binstub"
    done
    rm -rf "$gemdir"
    ln -s ../bin "$gemdir"
  fi
}

fix_rbx_irb() {
  local prefix="$1"
  "${prefix}/bin/irb" --version &>/dev/null ||
    "${prefix}/bin/gem" install rubysl-tracer -v '~> 2.0' --no-rdoc --no-ri &>/dev/null ||
    true
}

require_java() {
  local required="$1"
  local java_version version_string
  java_version="$(java -version 2>&1 || true)"
  version_string="$(grep 'java version' <<<"$java_version" | head -1 | grep -o '[0-9.]\+' | head -1 || true)"
  [ -n "$version_string" ] || version_string="$(grep 'openjdk version' <<<"$java_version" | head -1 | grep -o '[0-9.]\+' | head -1 || true)"
  IFS="."
  # shellcheck disable=SC2206
  local nums=($version_string)
  IFS="$OLDIFS"
  local found_version="${nums[0]}"
  [ "$found_version" -gt 1 ] 2>/dev/null || found_version="${nums[1]}"
  [ "$found_version" -ge "$required" ] 2>/dev/null && return 0
  colorize 1 "ERROR" >&3
  echo ": Java >= ${required} required, but your Java version was:" >&3
  cat <<<"$java_version" >&3
  return 1
}

# Kept for backward compatibility with JRuby <= 9.1.17 definitions.
require_java7() {
  require_java 7
}

# Kept for backward compatibility with 3rd-party Ruby definitions.
require_gcc() {
  local stub=1
}

# Kept for backward compatibility with 3rd-party Rubinius definitions.
# shellcheck disable=SC2034
require_llvm() {
  local stub=1
}

needs_yaml() {
  [[ "$RUBY_CONFIGURE_OPTS ${RUBY_CONFIGURE_OPTS_ARRAY[*]}" != *--with-libyaml-dir=* ]] &&
  ! use_homebrew_yaml
}

use_homebrew_yaml() {
  local libdir
  libdir="$(brew --prefix libyaml 2>/dev/null || true)"
  if [ -d "$libdir" ]; then
    echo "ruby-build: using libyaml from homebrew"
    package_option ruby configure --with-libyaml-dir="$libdir"
  else
    return 1
  fi
}

use_freebsd_yaml() {
  if is_freebsd; then
    local libyaml_prefix
    libyaml_prefix="$(freebsd_package_prefix libyaml)"
    if [ -n "$libyaml_prefix" ]; then
      package_option ruby configure --with-libyaml-dir="$libyaml_prefix"
    fi
  fi
}

use_homebrew_gmp() {
  local libdir
  libdir="$(brew --prefix gmp 2>/dev/null || true)"
  if [ -d "$libdir" ]; then
    echo "ruby-build: using gmp from homebrew"
    package_option ruby configure --with-gmp-dir="$libdir"
  else
    return 1
  fi
}

use_freebsd_readline() {
  if is_freebsd; then
    local readline_prefix libedit_prefix
    readline_prefix="$(freebsd_package_prefix readline)"
    libedit_prefix="$(freebsd_package_prefix libedit)"
    if [ -n "$readline_prefix" ]; then
      package_option ruby configure --with-readline-dir="$readline_prefix"
    elif [ -n "$libedit_prefix" ]; then
      package_option ruby configure --enable-libedit
      package_option ruby configure --with-libedit-dir="$libedit_prefix"
    fi
  fi
}

use_homebrew_readline() {
  local libdir
  libdir="$(brew --prefix readline 2>/dev/null || true)"
  if [ -d "$libdir" ]; then
    echo "ruby-build: using readline from homebrew"
    package_option ruby configure --with-readline-dir="$libdir"
  else
    return 1
  fi
}

use_freebsd_libffi() {
  if is_freebsd; then
    local libffi_prefix
    libffi_prefix="$(freebsd_package_prefix libffi)"
    if [ -n "$libffi_prefix" ]; then
      package_option ruby configure --with-libffi-dir="$libffi_prefix"
    fi
  fi
}

has_broken_mac_openssl() {
  is_mac || return 1
  local openssl_version
  openssl_version="$(/usr/bin/openssl version 2>/dev/null || true)"
  [[ $openssl_version = "OpenSSL 0.9.8"?* || $openssl_version = "LibreSSL"* ]]
}

system_openssl_version() {
  local version_text
  version_text=$(printf '#include <openssl/opensslv.h>\nOPENSSL_VERSION_TEXT\n' | cc -xc -E - 2>/dev/null || true)
  if [[ $version_text == *"OpenSSL "* ]]; then
    local version=${version_text#*OpenSSL }
    # shellcheck disable=SC2001
    sed 's/[^0-9]//g' <<<"${version%% *}" | sed 's/^0*//'
  else
    echo "No system openssl version was found, ensure openssl headers are installed (https://github.com/rbenv/ruby-build/wiki#suggested-build-environment)" >&2
    echo 000
  fi
}

# openssl gem 1.1.1
needs_openssl_096_102() {
  [[ "$RUBY_CONFIGURE_OPTS ${RUBY_CONFIGURE_OPTS_ARRAY[*]}" == *--with-openssl-dir=* ]] && return 1
  has_broken_mac_openssl && return 0

  local version
  version="$(system_openssl_version)"
  (( version < 96 || version >= 110 ))
}

# openssl gem 2.2.1
needs_openssl_101_111() {
  [[ "$RUBY_CONFIGURE_OPTS ${RUBY_CONFIGURE_OPTS_ARRAY[*]}" == *--with-openssl-dir=* ]] && return 1
  has_broken_mac_openssl && return 0

  local version
  version="$(system_openssl_version)"
  (( version < 101 || version >= 300 ))
}

# openssl gem 3.0.0
needs_openssl_102_300() {
  [[ "$RUBY_CONFIGURE_OPTS ${RUBY_CONFIGURE_OPTS_ARRAY[*]}" == *--with-openssl-dir=* ]] && return 1
  has_broken_mac_openssl && return 0

  local version
  version="$(system_openssl_version)"
  (( version < 102 || version >= 400 ))
}

# Kept for backward compatibility with 3rd-party Ruby definitions.
use_homebrew_openssl() {
  local ssldir
  ssldir="$(brew --prefix openssl@1.1 2>/dev/null || true)"
  if [ -d "$ssldir" ]; then
    echo "ruby-build: using openssl@1.1 from homebrew"
    package_option ruby configure --with-openssl-dir="$ssldir"
  else
    colorize 1 "ERROR openssl@1.1 from Homebrew is required, run 'brew install openssl@1.1'"
    return 1
  fi
}

build_package_openssl() {
  # Install to a subdirectory since we don't want shims for bin/openssl.
  local OPENSSL_PREFIX_PATH="${PREFIX_PATH}/openssl"

  # Put openssl.conf, certs, etc in ~/.rbenv/versions/*/openssl/ssl
  OPENSSLDIR="${OPENSSLDIR:-$OPENSSL_PREFIX_PATH/ssl}"

  # Tell Ruby to use this openssl for its extension.
  package_option ruby configure --with-openssl-dir="$OPENSSL_PREFIX_PATH"

  # Make sure pkg-config finds our build first.
  export PKG_CONFIG_PATH="${OPENSSL_PREFIX_PATH}/lib/pkgconfig${PKG_CONFIG_PATH:+:$PKG_CONFIG_PATH}"

  local nokerberos
  [[ "$1" != openssl-1.0.* ]] || nokerberos=1

  # Compile a shared lib with zlib dynamically linked.
  package_option openssl configure --openssldir="$OPENSSLDIR" zlib-dynamic no-ssl3 shared ${nokerberos:+no-ssl2 no-krb5}

  # Skip building OpenSSL docs, which is slow.
  local make_target="install_sw install_ssldirs"
  [[ "$1" != openssl-1.0.* ]] || make_target="install_sw" # OpenSSL 1.0 does not have `install_ssldirs`

  OPENSSL_CONFIGURE="${OPENSSL_CONFIGURE:-./config}" MAKE_INSTALL_TARGET="$make_target" build_package_standard "$@"

  local pem_file="$OPENSSLDIR/cert.pem"
  if is_mac; then
    # Extract root certs from the system keychain in .pem format.
    security find-certificate -a -p /Library/Keychains/System.keychain > "$pem_file"
    security find-certificate -a -p /System/Library/Keychains/SystemRootCertificates.keychain >> "$pem_file"
  elif [ -e /etc/pki/tls/cert.pem ]; then # RedHat
    # See https://github.com/rubygems/rubygems/issues/2415#issuecomment-509806259
    rm -rf "$OPENSSLDIR/certs" "$pem_file"
    ln -s /etc/pki/tls/certs "$OPENSSLDIR/certs"
    ln -s /etc/pki/tls/cert.pem "$pem_file"
  elif [ -e /etc/ssl/certs/ca-certificates.crt ]; then # Debian
    # See https://github.com/rubygems/rubygems/issues/2415#issuecomment-509806259
    rm -rf "$OPENSSLDIR/certs" "$pem_file"
    ln -s /etc/ssl/certs "$OPENSSLDIR/certs"
    ln -s /etc/ssl/certs/ca-certificates.crt "$pem_file"
  elif type -p openssl >/dev/null; then
    # symlink to the system openssl certs
    local SYSTEM_OPENSSLDIR
    SYSTEM_OPENSSLDIR=$(openssl version -d 2>/dev/null | cut -d'"' -f2)
    if [ -n "$SYSTEM_OPENSSLDIR" ]; then
      ln -sf "$SYSTEM_OPENSSLDIR/cert.pem" "$OPENSSLDIR/cert.pem"
      ln -snf "$SYSTEM_OPENSSLDIR/certs" "$OPENSSLDIR/certs"
    fi
  else
    echo "Could not find OpenSSL certificates" >&2
    exit 1
  fi
}

# Post-install check that the openssl extension was built.
build_package_verify_openssl() {
  # shellcheck disable=SC2016
  "$RUBY_BIN" -e '
    manager = ARGV[0]
    packages = {
      "apt-get" => Hash.new {|h,k| "lib#{k}-dev" }.update(
        "openssl" => "libssl-dev",
        "zlib" => "zlib1g-dev"
      ),
      "yum" => Hash.new {|h,k| "#{k}-devel" }.update(
        "yaml" => "libyaml-devel"
      )
    }

    failed = %w[openssl readline zlib yaml].reject do |lib|
      begin
        require lib
      rescue LoadError => e
        $stderr.puts "Loading the Ruby #{lib} extension failed (#{e})"
      end
    end

    if failed.size > 0
      $stderr.puts "ERROR: Ruby install aborted due to missing extensions"
      $stderr.print "Try running `%s install -y %s` to fetch missing dependencies.\n\n" % [
        manager,
        failed.map { |lib| packages.fetch(manager)[lib] }.join(" ")
      ] unless manager.empty?
      $stderr.puts "Configure options used:"
      require "rbconfig"; require "shellwords"
      RbConfig::CONFIG.fetch("configure_args").shellsplit.each { |arg| $stderr.puts "  #{arg}" }
      exit 1
    end
  ' "$(basename "$(type -p yum apt-get | head -1)")" >&4 2>&1
}

# Kept for backward compatibility with 3rd-party definitions.
build_package_ldflags_dirs() {
  true
}

build_package_enable_shared() {
  if [[ " ${RUBY_CONFIGURE_OPTS} ${RUBY_CONFIGURE_OPTS_ARRAY[*]}" != *" --disable-shared"* ]]; then
    package_option ruby configure --enable-shared
  fi
}

build_package_auto_tcltk() {
  if is_mac && [ ! -d /usr/include/X11 ]; then
    if [ -d /opt/X11/include ]; then
      if [[ "$CPPFLAGS" != *-I/opt/X11/include* ]]; then
        export CPPFLAGS="-I/opt/X11/include $CPPFLAGS"
      fi
    else
      package_option ruby configure --without-tk
    fi
  fi
}

rake() {
  if [ -e "./Gemfile" ]; then
    bundle exec rake "$@"
  else
    isolated_gem_dependency "rake --version" rake -v '~> 10.1.0'
    command rake "$@"
  fi
}

bundle() {
  isolated_gem_dependency "bundle --version" bundler -v '~> 1.3.5'
  command bundle "$@"
}

isolated_gem_dependency() {
  set +E
  ( command $1 &>/dev/null ) || {
    set -E
    shift 1
    isolated_gem_install "$@"
  }
  set -E
}

isolated_gem_install() {
  export GEM_HOME="${PWD}/.gem"
  export PATH="${GEM_HOME}/bin:${PATH}"
  gem install "$@"
}

apply_ruby_patch() {
  local patchfile
  if is_ruby_package "$1"; then
    patchfile="$(mktemp "${TMP}/ruby-patch.XXXXXX")"
    cat "${2:--}" >"$patchfile"

    local striplevel=0
    grep -q '^--- a/' "$patchfile" && striplevel=1
    patch -p$striplevel --force -i "$patchfile"
  fi
}

is_ruby_package() {
  case "$1" in
  ruby-* | jruby-* | rubinius-* | truffleruby[+-]* | mruby-* | picoruby-* )
    return 0
    ;;
  *)
    return 1
    ;;
  esac
}

version() {
  local git_revision
  # Read the revision from git if the remote points to "ruby-build" repository
  if GIT_DIR="$RUBY_BUILD_INSTALL_PREFIX/.git" git remote -v 2>/dev/null | grep -q /ruby-build; then
    git_revision="$(GIT_DIR="$RUBY_BUILD_INSTALL_PREFIX/.git" git describe --tags HEAD 2>/dev/null || true)"
    git_revision="${git_revision#v}"
  fi
  echo "ruby-build ${git_revision:-$RUBY_BUILD_VERSION}"
}

usage() {
  sed -ne '/^#/!q;s/.\{1,2\}//;1,2d;p' < "$0"
  [ -z "$1" ] || exit "$1"
}

# list all versions
list_definitions() {
  { for DEFINITION_DIR in "${RUBY_BUILD_DEFINITIONS[@]}"; do
      [ -d "$DEFINITION_DIR" ] && ls "$DEFINITION_DIR"
    done
  } | sort_versions | uniq
}

# list only latest stable versions excluding RC, preview, dev and EoL'ed
list_maintained_versions() {
  { for DEFINITION_DIR in "${RUBY_BUILD_DEFINITIONS[@]}"; do
      [ -d "$DEFINITION_DIR" ] && \
        grep -L -e warn_eol "$DEFINITION_DIR"/* 2>/dev/null | \
        sed 's|.*/||' | \
        grep -v -e '-rc[0-9]*$' -e '-preview[0-9]*$' -e '-dev$'
    done
  } | extract_latest_versions | sort_versions | uniq
}

extract_latest_versions() {
  # sort in this function looks redundunt but it is necessary
  # rbx-3.99 appears latest unless the sort
  sed 'h; s/[-]/./g; s/.p\([[:digit:]]\)/.z.\1/; s/$/.z/; G; s/\n/ /' | \
    LC_ALL=C sort -t. -k 1,1 -k 2,2n -k 3,3n -k 4,4n -k 5,5n | \
    sed 's/[.]/ /; s/[0-9].*z //; s/^\([0-9].[0-9]\)/mri\1 \1/' | \
    awk '{ latest[$1] =$2 } END{ for(key in latest) { print latest[key] } }'
}

sort_versions() {
  sed 'h; s/[-]/./g; s/.p\([[:digit:]]\)/.z.\1/; s/$/.z/; G; s/\n/ /' | \
    LC_ALL=C sort -t. -k 1,1 -k 2,2n -k 3,3n -k 4,4n -k 5,5n | awk '{print $2}'
}


unset VERBOSE
unset KEEP_BUILD_PATH
unset HAS_PATCH
unset IPV4
unset IPV6
unset EARLY_EXIT

RUBY_BUILD_INSTALL_PREFIX="$(abs_dirname "$0")/.."

# shellcheck disable=SC2206
IFS=: RUBY_BUILD_DEFINITIONS=($RUBY_BUILD_DEFINITIONS ${RUBY_BUILD_ROOT:-$RUBY_BUILD_INSTALL_PREFIX}/share/ruby-build)
IFS="$OLDIFS"

parse_options "$@"

for option in "${OPTIONS[@]}"; do
  case "$option" in
  "h" | "help" )
    EARLY_EXIT=help
    ;;
  "definitions" )
    EARLY_EXIT=list_definitions
    ;;
  "l" | "list")
    EARLY_EXIT=list_maintained_versions
    ;;
  "k" | "keep" )
    KEEP_BUILD_PATH=true
    ;;
  "v" | "verbose" )
    VERBOSE=true
    ;;
  "p" | "patch" )
    HAS_PATCH=true
    ;;
  "4" | "ipv4")
    IPV4=true
    ;;
  "6" | "ipv6")
    IPV6=true
    ;;
  "version" )
    EARLY_EXIT=version
    ;;
  * )
    printf "ruby-build: invalid flag '%s'\n" "$option" >&2
    EARLY_EXIT=usage_error
    ;;
  esac
done

DEFINITION_PATH="${ARGUMENTS[0]}"
PREFIX_PATH="${ARGUMENTS[1]}"

if [ -z "$EARLY_EXIT" ] && [ -z "$DEFINITION_PATH" ]; then
  echo "ruby-build: missing definition argument" >&2
  EARLY_EXIT=usage_error
fi

if [ -z "$EARLY_EXIT" ] && [ -z "$PREFIX_PATH" ]; then
  echo "ruby-build: missing prefix argument" >&2
  EARLY_EXIT=usage_error
fi

if [ "${#ARGUMENTS[@]}" -gt 2 ]; then
  echo "ruby-build: expected at most 2 arguments, got [${ARGUMENTS[*]}]" >&2
  EARLY_EXIT=usage_error
fi

if [ "${#EXTRA_ARGUMENTS[@]}" -gt 0 ]; then
  RUBY_CONFIGURE_OPTS_ARRAY=("${EXTRA_ARGUMENTS[@]}")
fi

case "$EARLY_EXIT" in
help )
  version
  echo
  usage 0
  ;;
version | list_definitions | list_maintained_versions )
  "$EARLY_EXIT"
  exit 0
  ;;
usage_error )
  echo >&2
  usage 1 >&2
  ;;
'' )
  ;;
* )
  echo "unimplemented EARLY_EXIT: $EARLY_EXIT" >&2
  exit 1
  ;;
esac

# expand the <definition> argument to full path of the definition file
if [ ! -f "$DEFINITION_PATH" ]; then
  for DEFINITION_DIR in "${RUBY_BUILD_DEFINITIONS[@]}"; do
    if [ -f "${DEFINITION_DIR}/${DEFINITION_PATH}" ]; then
      DEFINITION_PATH="${DEFINITION_DIR}/${DEFINITION_PATH}"
      break
    fi
  done

  if [ ! -f "$DEFINITION_PATH" ]; then
    echo "ruby-build: definition not found: ${DEFINITION_PATH}" >&2
    exit 2
  fi
fi

# normalize the <prefix> argument
if [ "${PREFIX_PATH#/}" = "$PREFIX_PATH" ]; then
  PREFIX_PATH="${PWD}/${PREFIX_PATH}"
fi

if [ -z "$TMPDIR" ]; then
  TMP="/tmp"
else
  TMP="${TMPDIR%/}"
fi

# Check if TMPDIR is accessible and can hold executables.
tmp_executable="${TMP}/ruby-build-test.$$"
noexec=""
if mkdir -p "$TMP" && touch "$tmp_executable" 2>/dev/null; then
  cat > "$tmp_executable" <<-EOF
	#!${BASH}
	exit 0
	EOF
  chmod +x "$tmp_executable"
else
  echo "ruby-build: TMPDIR=$TMP is set to a non-accessible location" >&2
  exit 1
fi
"$tmp_executable" 2>/dev/null || noexec=1
rm -f "$tmp_executable"
if [ -n "$noexec" ]; then
  echo "ruby-build: TMPDIR=$TMP cannot hold executables (partition possibly mounted with \`noexec\`)" >&2
  exit 1
fi

if [ -z "$MAKE" ]; then
  if is_freebsd && [[ ${ARGUMENTS[0]} == jruby-* ]]; then
    # jruby-launcher requires gmake: https://github.com/ruby/ruby/pull/8591
    export MAKE="gmake"
  else
    export MAKE="make"
  fi
fi

if [ -n "$RUBY_BUILD_CACHE_PATH" ] && [ -d "$RUBY_BUILD_CACHE_PATH" ]; then
  RUBY_BUILD_CACHE_PATH="${RUBY_BUILD_CACHE_PATH%/}"
else
  unset RUBY_BUILD_CACHE_PATH
fi

if [ -z "$RUBY_BUILD_MIRROR_URL" ] && [ -z "$RUBY_BUILD_MIRROR_PACKAGE_URL" ]; then
  RUBY_BUILD_MIRROR_URL="https://dqw8nmjcqpjn7.cloudfront.net"
  RUBY_BUILD_DEFAULT_MIRROR=1
else
  RUBY_BUILD_MIRROR_URL="${RUBY_BUILD_MIRROR_URL%/}"
  RUBY_BUILD_DEFAULT_MIRROR=
fi

if [ -n "$RUBY_BUILD_SKIP_MIRROR" ] || ! has_checksum_support compute_sha2; then
  unset RUBY_BUILD_MIRROR_URL RUBY_BUILD_MIRROR_PACKAGE_URL
fi

ARIA2_OPTS="${RUBY_BUILD_ARIA2_OPTS} ${IPV4+--disable-ipv6=true} ${IPV6+--disable-ipv6=false}"
CURL_OPTS="${RUBY_BUILD_CURL_OPTS} ${IPV4+--ipv4} ${IPV6+--ipv6}"
WGET_OPTS="${RUBY_BUILD_WGET_OPTS} ${IPV4+--inet4-only} ${IPV6+--inet6-only}"

SEED="$(date "+%Y%m%d%H%M%S").$$"
LOG_PATH="${TMP}/ruby-build.${SEED}.log"
RUBY_BIN="${PREFIX_PATH}/bin/ruby"

if [ -z "$RUBY_BUILD_BUILD_PATH" ]; then
  BUILD_PATH="$(mktemp -d "${LOG_PATH%.log}.XXXXXX")"
else
  BUILD_PATH="$RUBY_BUILD_BUILD_PATH"
fi

exec 4<> "$LOG_PATH" # open the log file at fd 4
if [ -n "$VERBOSE" ]; then
  tail -f "$LOG_PATH" &
  TAIL_PID=$!
  trap 'kill $TAIL_PID' SIGINT SIGTERM EXIT
else
  if [ -z "$RUBY_BUILD_TESTING" ]; then
    echo "To follow progress, use 'tail -f $LOG_PATH' or pass --verbose" >&2
  fi
fi

unset RUBYOPT
unset RUBYLIB

trap build_failed ERR
mkdir -p "$BUILD_PATH"
# shellcheck disable=SC1090
source "$DEFINITION_PATH"
[ -z "${KEEP_BUILD_PATH}" ] && rm -fr "$BUILD_PATH"
trap - ERR