goenv-install

#!/usr/bin/env bash
#
# Summary: Install a Go version using go-build
#
# Usage: goenv install [-f] [-kvpq] <version>|latest|unstable
#        goenv install [-f] [-kvpq] <definition-file>
#        goenv install -l|--list
#        goenv install --version
#
#   -l/--list          List all available versions
#   -f/--force         Install even if the version appears to be installed already
#   -s/--skip-existing Skip if the version appears to be installed already
#
#   go-build options:
#
#   -k/--keep          Keep source tree in $GOENV_BUILD_ROOT after installation
#                      (defaults to $GOENV_ROOT/sources)
#   -p/--patch         Apply a patch from stdin before building
#   -v/--verbose       Verbose mode: print compilation status to stdout
#   -q/--quiet         Disable Progress Bar
#   --version          Show version of go-build
#   -g/--debug         Build a debug version
#
# For detailed information on installing Go versions with
# go-build, including a list of environment variables for adjusting
# compilation, see: https://github.com/go-nv/goenv#readme
#
set -e
[ -n "$GOENV_DEBUG" ] && set -x

# Add `share/go-build/` directory from each goenv plugin to the list of
# paths where build definitions are looked up.
shopt -s nullglob
for plugin_path in "$GOENV_ROOT"/plugins/*/share/go-build; do
  GO_BUILD_DEFINITIONS="${GO_BUILD_DEFINITIONS}:${plugin_path}"
done
export GO_BUILD_DEFINITIONS
shopt -u nullglob

# Provide goenv completions
if [ "$1" = "--complete" ]; then
  echo --list
  echo --force
  echo --skip-existing
  echo --keep
  echo --patch
  echo --verbose
  echo --version
  echo --debug
  echo --quiet
  exec go-build --definitions
fi

# Load shared library functions
eval "$(go-build --lib)"

usage() {
  goenv-help install 2>/dev/null
  [ -z "$1" ] || exit "$1"
}

definitions() {
  local query="$1"
  go-build --definitions | $(type -p ggrep grep | head -1) -F "$query" || true
}

latest_version() {
  definitions | grep -oE "^$1\\.([0-9]+)?$" | tail -1
}

latest_includes_unstable_version() {
  definitions | grep -ioE "^$1\\.?([0-9]+|beta[0-9]+|rc[0-9]+)?$" | tail -1
}

indent() {
  sed 's/^/  /'
}

unset FORCE
unset SKIP_EXISTING
unset KEEP
unset VERBOSE
unset HAS_PATCH
unset DEBUG

parse_options "$@"
for option in "${OPTIONS[@]}"; do
  case "$option" in
  "h" | "help")
    usage 0
    ;;
  "l" | "list")
    echo "Available versions:"
    definitions | indent
    exit
    ;;
  "f" | "force")
    FORCE=true
    ;;
  "s" | "skip-existing")
    SKIP_EXISTING=true
    ;;
  "k" | "keep")
    [ -n "${GOENV_BUILD_ROOT}" ] || GOENV_BUILD_ROOT="${GOENV_ROOT}/sources"
    ;;
  "v" | "verbose")
    VERBOSE="-v"
    ;;
  "p" | "patch")
    HAS_PATCH="-p"
    ;;
  "q" | "quiet")
    QUIET="-q"
    ;;
  "g" | "debug")
    DEBUG="-g"
    ;;
  "version")
    exec go-build --version
    ;;
  *)
    usage 1 >&2
    ;;
  esac
done

[ "${#ARGUMENTS[@]}" -le 1 ] || usage 1 >&2

unset VERSION_NAME

# The first argument contains the definition to install. If the
# argument is missing, try to install whatever local app-specific
# version is specified by goenv. Show usage instructions if a local
# version is not specified.
DEFINITION="${ARGUMENTS[0]}"

# If latest is supplied, install the latest available (stable) version
if [[ ${DEFINITION} == "latest" ]]; then
  LATEST=$(latest_version "[0-9]\\.[0-9]+")
  echo "Installing latest version ${LATEST}..."
  DEFINITION=$LATEST
# If unstable is supplied, install the latest available (including beta/rc) version
elif [[ ${DEFINITION} == "unstable" ]]; then
  LATEST_UNSTABLE=$(latest_includes_unstable_version "[0-9]\\.[0-9]+")
  echo "Installing latest (including unstable) version ${LATEST_UNSTABLE}..."
  DEFINITION=$LATEST_UNSTABLE
fi

[ -n "$DEFINITION" ] || DEFINITION="$(goenv-local 2>/dev/null || true)"
[ -n "$DEFINITION" ] || usage 1 >&2

# The latest patch version will be located, e.g if 1.11 is supplied they'll be changed to `1.11.x`.
# NOTE: Try to capture semantic versions such as `1.11` which don't have a patch version and install latest patch.
if grep -q -E "^[0-9]+\.[0-9]+(\s*)$" <<<${DEFINITION}; then
  REGEX=$(echo $DEFINITION | sed s/\\./\\\\./)
  LATEST_PATCH=$(latest_version $REGEX)
  echo "Using latest patch version $LATEST_PATCH"
  DEFINITION=$LATEST_PATCH
fi

# Define `before_install` and `after_install` functions that allow
# plugin hooks to register a string of code for execution before or
# after the installation process.
declare -a before_hooks after_hooks

before_install() {
  local hook="$1"
  before_hooks["${#before_hooks[@]}"]="$hook"
}

after_install() {
  local hook="$1"
  after_hooks["${#after_hooks[@]}"]="$hook"
}

OLDIFS="$IFS"
IFS=$'\n' scripts=($(goenv-hooks install))
IFS="$OLDIFS"
for script in "${scripts[@]}"; do
  source "$script"
done

# Set VERSION_NAME from $DEFINITION, if it is not already set. Then
# compute the installation prefix.
[ -n "$VERSION_NAME" ] || VERSION_NAME="${DEFINITION##*/}"
[ -n "$DEBUG" ] && VERSION_NAME="${VERSION_NAME}-debug"
PREFIX="${GOENV_ROOT}/versions/${VERSION_NAME}"

[ -d "${PREFIX}" ] && PREFIX_EXISTS=1

# If the installation prefix exists, prompt for confirmation unless
# the --force option was specified.
if [ -d "${PREFIX}/bin" ]; then
  if [ -z "$FORCE" ] && [ -z "$SKIP_EXISTING" ]; then
    echo "goenv: $PREFIX already exists" >&2
    read -p "continue with installation? (y/N) "

    case "$REPLY" in
    y* | Y*) ;;
    *) exit 1 ;;
    esac
  elif [ -n "$SKIP_EXISTING" ]; then
    # Since we know the go version is already installed, and are opting to
    # not force installation of existing versions, we just `exit 0` here to
    # leave things happy
    exit 0
  fi
fi

# If GOENV_BUILD_ROOT is set, always pass keep options to go-build.
if [ -n "${GOENV_BUILD_ROOT}" ]; then
  export GO_BUILD_BUILD_PATH="${GOENV_BUILD_ROOT}/${VERSION_NAME}"
  KEEP="-k"
fi

# Set GO_BUILD_CACHE_PATH to $GOENV_ROOT/cache, if the directory
# exists and the variable is not already set.
if [ -z "${GO_BUILD_CACHE_PATH}" ] && [ -d "${GOENV_ROOT}/cache" ]; then
  export GO_BUILD_CACHE_PATH="${GOENV_ROOT}/cache"
fi

# Execute `before_install` hooks.
for hook in "${before_hooks[@]}"; do
  eval "$hook"
done

# Plan cleanup on unsuccessful installation.
cleanup() {
  [ -z "${PREFIX_EXISTS}" ] && rm -rf "$PREFIX"
}

trap cleanup SIGINT

# Invoke `go-build` and record the exit status in $STATUS.
STATUS=0
go-build $KEEP $VERBOSE $HAS_PATCH $QUIET $DEBUG "$DEFINITION" "$PREFIX" || STATUS="$?"

# Display a more helpful message if the definition wasn't found.
if [ "$STATUS" == "2" ]; then
  {
    candidates="$(definitions "$DEFINITION")"
    here="$(dirname "${0%/*}")/../.."
    if [ -n "$candidates" ]; then
      echo
      echo "The following versions contain '$DEFINITION' in the name:"
      echo "$candidates" | indent
    fi
    echo
    echo "See all available versions with 'goenv install --list'."
    echo
    echo -n "If the version you need is missing, try upgrading goenv"
    if [ "$here" != "${here#$(brew --prefix 2>/dev/null)}" ]; then
      printf ":\n\n"
      echo "  brew update && brew upgrade goenv"
    elif [ -d "${here}/.git" ]; then
      printf ":\n\n"
      echo "  cd ${here} && git pull && cd -"
    else
      printf ".\n"
    fi
  } >&2
fi

# Execute `after_install` hooks.
for hook in "${after_hooks[@]}"; do
  eval "$hook"
done

# Run `goenv-rehash` after a successful installation.
if [ "$STATUS" == "0" ]; then
  goenv-rehash
else
  cleanup
fi

exit "$STATUS"