mirror of
https://github.com/rbenv/ruby-build.git
synced 2025-09-04 08:11:14 +02:00
9b8749105f
Same with linking libyaml, gmp, etc. to Homebrew. This considers all user configuration inputs when checking for existing flags.
1525 lines
40 KiB
Bash
Executable file
1525 lines
40 KiB
Bash
Executable file
#!/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="20231012"
|
|
|
|
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 [ "$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
|
|
if [ -n "$RUBY_BUILD_CACHE_PATH" ]; then
|
|
# shellcheck disable=SC2164
|
|
pushd "$RUBY_BUILD_CACHE_PATH" >&4
|
|
local clone_name
|
|
clone_name="$(sanitize "$git_url")"
|
|
if [ -e "$clone_name" ]; then
|
|
{ # shellcheck disable=SC2164
|
|
cd "$clone_name"
|
|
git fetch --force "$git_url" "+${git_ref}:${git_ref}"
|
|
} >&4 2>&1
|
|
else
|
|
git clone --bare --branch "$git_ref" "$git_url" "${clone_name}" >&4 2>&1
|
|
fi
|
|
git_url="$RUBY_BUILD_CACHE_PATH/${clone_name}"
|
|
# shellcheck disable=SC2164
|
|
popd >&4
|
|
fi
|
|
|
|
if [ -e "${package_name}" ]; then
|
|
( # shellcheck disable=SC2164
|
|
cd "${package_name}"
|
|
git fetch --depth 1 origin "+${git_ref}"
|
|
git 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
|
|
else
|
|
echo "error: please install \`git\` and try again" >&2
|
|
exit 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
|
|
} >&4 2>&1
|
|
}
|
|
|
|
fix_jruby_shebangs() {
|
|
for file in "${PREFIX_PATH}/bin"/*; do
|
|
if [ "$(head -c 20 "$file" | 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 $?
|
|
build_package_copy_to "${PREFIX_PATH}/graalvm"
|
|
|
|
# shellcheck disable=SC2164
|
|
cd "${PREFIX_PATH}/graalvm"
|
|
if is_mac; then
|
|
cd Contents/Home || return $?
|
|
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_to() {
|
|
to="$1"
|
|
mkdir -p "$to"
|
|
cp -fR . "$to"
|
|
}
|
|
|
|
build_package_copy() {
|
|
build_package_copy_to "$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 ))
|
|
}
|
|
|
|
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.
|
|
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}"
|
|
|
|
# Hint OpenSSL that we prefer a 64-bit build.
|
|
export KERNEL_BITS="64"
|
|
OPENSSL_CONFIGURE="${OPENSSL_CONFIGURE:-./config}"
|
|
|
|
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}
|
|
|
|
# Default MAKE_OPTS are -j 2 which can confuse the build. Thankfully, make
|
|
# gives precedence to the last -j option, so we can override that.
|
|
package_option openssl make -j 1
|
|
|
|
# Use install_sw install_ssldirs instead of install to skip building docs which is slow.
|
|
# OpenSSL 1.1+ also needs install_ssldirs, 1.0 does not have that target.
|
|
if [[ "$1" == openssl-1.0.* ]]; then
|
|
MAKE_INSTALL_TARGET="install_sw" build_package_standard "$@"
|
|
else
|
|
MAKE_INSTALL_TARGET="install_sw install_ssldirs" build_package_standard "$@"
|
|
fi
|
|
|
|
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
|
|
}
|
|
|
|
# Ensure that directories listed in LDFLAGS exist
|
|
build_package_ldflags_dirs() {
|
|
local ldflags
|
|
read -d '' -r -a ldflags <<<"$LDFLAGS" || true
|
|
local index=0
|
|
local dir
|
|
while [ "$index" -lt "${#ldflags[@]}" ]; do
|
|
dir=""
|
|
case "${ldflags[index]}" in
|
|
-L ) dir="${ldflags[index+1]}" ;;
|
|
-L* ) dir="${ldflags[index]#-L}" ;;
|
|
esac
|
|
[ -z "$dir" ] || mkdir -p "$dir"
|
|
index=$((index+1))
|
|
done
|
|
}
|
|
|
|
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
|
|
case "$1" in
|
|
ruby-* | jruby-* | rubinius-* | truffleruby-* )
|
|
patchfile="$(mktemp "${TMP}/ruby-patch.XXXXXX")"
|
|
cat "${2:--}" >"$patchfile"
|
|
|
|
local striplevel=0
|
|
grep -q '^--- a/' "$patchfile" && striplevel=1
|
|
patch -p$striplevel --force -i "$patchfile"
|
|
;;
|
|
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
|
|
|
|
export LDFLAGS="-L${PREFIX_PATH}/lib ${LDFLAGS}"
|
|
export CPPFLAGS="-I${PREFIX_PATH}/include ${CPPFLAGS}"
|
|
|
|
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
|