release

#!/usr/bin/env bash

# MIT License
#
# Copyright (c) 2018 SciSpike, LLC
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.

# This script implements the minor-release-per-branch workflow projects using git for source control.

if [ -n "$RELEASE_DEBUG" ]; then
  set -x
fi

set -e

THIS_ABSPATH="$(cd "$(dirname "$0")"; pwd)"

ORIGIN=${ORIGIN:-origin}
MASTER=${MASTER:-master}
TAG_PREFIX=${TAG_PREFIX:-''}
TAG_SUFFIX=${TAG_SUFFIX:-''}
BRANCH_PREFIX=${BRANCH_PREFIX:-'v'}
BRANCH_SUFFIX=${BRANCH_SUFFIX:-''} # '.x' is a common one

if [ -z "$NO_GIT_DISCOVERY_ACROSS_FILESYSTEM" ]; then
  GIT_DISCOVERY_ACROSS_FILESYSTEM=1 # needed when running in a docker container
fi

MATCH=match
if ! which $MATCH; then
  MATCH="docker run --rm -i matthewadams12/$MATCH"
fi

YMLX=ymlx
if ! which $YMLX; then
  export YMLX="docker run --rm -i matthewadams12/$YMLX"
fi

# support custom "pre" tokens
PRE=${PRE:-pre}
PRE_USAGE=pre
if [ "$PRE" != "pre" ]; then
  PRE_USAGE="$PRE_USAGE|$PRE"
fi

# support custom "rc" tokens
RC=${RC:-rc}
RC_USAGE=rc
if [ "$RC" != "rc" ]; then
  RC_USAGE="$RC_USAGE|$RC"
fi

# ensure pre & rc tokens are not the same
if [ "$PRE" == "$RC" ]; then
  echo "ERROR: PRE ($PRE) cannot be the same as RC ($RC)" >&2
  exit 1
fi

# ensure pre token sorts alphabetically before rc token
if [ "$PRE" \> "$RC" ]; then
  echo "ERROR: PRE ($PRE) cannot sort alphabetically after RC ($RC)" >&2
  exit 1
fi

if [ $# -lt 2 ]; then
  echo "Insufficient arguments" >&2
  echo "Usage: $0 <technology-type>[+<technology-type2>+[<technology-type3>+...]] <release-level>" >&2
  echo "Example 1: $0 nodejs pre # releases via npm using package.json" >&2
  echo "Example 2: $0 nodejs+image pre # releases via npm using package.json and versions Dockerfile with it" >&2
  exit 1
fi

TECHNOLOGIES="$(echo "$1" | tr '+' ' ')"

# Source technology-specific file(s) for usage_xxx, getVersion_xxx & setVersion_xxx functions
for T in $TECHNOLOGIES; do
  FUNCTIONS_FILE="$THIS_ABSPATH/release-$T"
  if [ -f "$FUNCTIONS_FILE" ]; then
    source "$FUNCTIONS_FILE"
  else
    echo "Unknown technology type: $T" >&2
    echo "Usage: $0 <technology-type> <release-level>" >&2
    exit 1
  fi
done

# usage: setVersions version
setVersions() {
  for T in $TECHNOLOGIES; do
    setVersion_$T $1
  done
}

usages() {
  for T in $TECHNOLOGIES; do
    usage_$T
  done
}

RELEASE_LEVEL="${@: -1}"

case "$RELEASE_LEVEL" in
  major|minor|patch|pre|rc|$PRE|$RC)
    # ok
    ;;
  h|he|hel|help)
    usages
    exit 0
    ;;
  *)
    if [ -n "$2" ]; then
      echo "ERROR: specify release level of 'pre' or '$PRE' for prerelease, 'rc' or '$RC' for release candidate, 'patch', 'minor', or 'major'" >&2
    fi
    usages
    exit 1
    ;;
esac

echo "INFO: checking required preconditions"

git pull

# check that all versions are exactly the same
for T in $TECHNOLOGIES; do
  V="$(getVersion_$T)"
  if [ -n "$V_LAST" ] && [ "$V_LAST" != "$V" ]; then
    echo "ERROR: versions among different technology files differ: $T is at $V, but $T_LAST is at $V_LAST" >&2
    exit 33
  fi
  V_LAST="$V"
  T_LAST="$T"
done

if ! git diff --exit-code --no-patch; then
  echo 'ERROR: you have modified tracked files; only release from clean directories!' >&2
  exit 3
else
  echo 'INFO: no modified tracked files'
fi

if ! git diff --cached --exit-code --no-patch; then
  echo 'ERROR: you have cached modified tracked files; only release from clean directories!' >&2
  exit 3
else
  echo 'INFO: no cached modified tracked files'
fi

if [ -n "$(git status -s)" ]; then
  echo 'ERROR: You have unignored untracked files; only release from clean directories!' >&2
  exit 3
else
  echo 'INFO: no unignored untracked files'
fi

BRANCH="$(git status | head -n 1 | awk '{ print $3 }')"
if ! $MATCH "^(master|$BRANCH_PREFIX[0-9]{1,}\.[0-9]{1,}$BRANCH_SUFFIX)$" "$BRANCH"; then # it is not a master or a release branch
  echo "ERROR: you can only release from the master branch or release branches! You are currently on $BRANCH" >&2
  exit 3
else
  echo "INFO: on branch $BRANCH, from which releases are allowed"
fi

if ! git diff --exit-code -no-patch $BRANCH $ORIGIN/$BRANCH; then
  echo "ERROR: Local branch $BRANCH differs from remote branch $ORIGIN/$BRANCH" >&2
  exit 3
else
  echo "INFO: no differences between local & remote branch $BRANCH"
fi

if [ "$BRANCH" = "$MASTER" ]; then
  case "$RELEASE_LEVEL" in
    pre|rc|$PRE|$RC)
      # ok
      ;;
    *)
      echo "ERROR: only 'pre'/'$PRE' or 'rc'/'$RC' releases are permitted from the $MASTER branch." >&2
      exit 6
      ;;
  esac
else # this is a release branch
  case "$RELEASE_LEVEL" in
      rc|patch|minor|major)
        # ok
        ;;
      *)
        echo "ERROR: only 'rc'/'$RC', 'patch', 'minor', or 'major' releases are permitted from a release branch." >&2
        exit 7
        ;;
  esac
fi

echo "INFO: ok to proceed with $RELEASE_LEVEL from branch $BRANCH"

VERSION="$V_LAST"

if ! $MATCH "\-($PRE|$RC)\.[0-9]{1,}$" "$VERSION"; then
  echo "ERROR: repository is in an inconsistent state: version does not end in a prerelease suffix! You are currently on branch $BRANCH" >&2
  exit 3
fi

# usage: apply message [tag [remote branch]]
applyChanges() {
  git add .
  git commit --allow-empty -m "$1"
  echo "INFO: committed changes with message: $1"

  MSG="INFO: pushed commits"

  if [ -n "$2" ]; then
    tag="$TAG_PREFIX$2$TAG_SUFFIX"
    git tag "$tag"
    echo "INFO: tagged $tag"
    MSG="$MSG & tags"
  fi

  SET_UPSTREAM_ARGS=
  if [ -n "$3" ] && [ -n "$4" ]; then
    SET_UPSTREAM_ARGS="-u $3 $4"
    MSG="$MSG & set tracked upstream to $3/$4"
  fi

  git push $SET_UPSTREAM_ARGS
  git push --tags

  echo "$MSG"
}

if [ "$BRANCH" = "$MASTER" ]; then # this will be either an rc, resulting in a new release branch, or a pre
  MATCHES="$($MATCH "^([0-9]{1,})\.([0-9]{1,})\.0\-$PRE\.([0-9]{1,})$" "$VERSION")"
  if [ -z "$MATCHES" ]; then
    echo "ERROR: the version does not match the format of major.minor.0-$PRE.n required in the $MASTER branch." >&2
    exit 8
  else
    echo "INFO: version $VERSION matches expected format for branch $BRANCH"
  fi

  # create release branch
  MAJOR="$(echo "$MATCHES" | awk '{ print $2 }')"
  MINOR="$(echo "$MATCHES" | awk '{ print $3 }')"
  PATCH=0
  PRERELEASE="$(echo "$MATCHES" | awk '{ print $4 }')"

  case "$RELEASE_LEVEL" in
  rc|$RC) # then it's time to create a new release branch
      NEW_RELEASE_BRANCH="$BRANCH_PREFIX$MAJOR.$MINOR$BRANCH_SUFFIX"
      git checkout -b $NEW_RELEASE_BRANCH

      NEW_RELEASE_BRANCH_VERSION="$MAJOR.$MINOR.0-$RC.0"

      setVersions $NEW_RELEASE_BRANCH_VERSION

      applyChanges "release $NEW_RELEASE_BRANCH_VERSION" $NEW_RELEASE_BRANCH_VERSION $ORIGIN $NEW_RELEASE_BRANCH
      echo "INFO: created release branch $NEW_RELEASE_BRANCH and tagged $NEW_RELEASE_BRANCH_VERSION for release"

      # return to master branch
      git checkout $MASTER
      echo "INFO: checked out $MASTER"

      git cherry-pick $NEW_RELEASE_BRANCH # cherry pick from release branch to get release candidate commit in master
      echo "INFO: cherry-picked $NEW_RELEASE_BRANCH $RC commit into $MASTER"

      # advance master version
      NEXT_VERSION="$MAJOR.$(($MINOR+1)).0-$PRE.0"

      setVersions $NEXT_VERSION $DOCKER_BUILD_STEP_NAMES

      applyChanges "bump to $NEXT_VERSION [skip ci]"

      # return to release branch & prepare for next prerelease
      git checkout $NEW_RELEASE_BRANCH
      echo "INFO: checked out $NEW_RELEASE_BRANCH"

      NEXT_RELEASE_BRANCH_VERSION="$MAJOR.$MINOR.0-$RC.1"

      setVersions $NEXT_RELEASE_BRANCH_VERSION $DOCKER_BUILD_STEP_NAMES

      applyChanges "bump to $NEXT_RELEASE_BRANCH_VERSION [skip ci]"

      exit 0
      ;;

  pre|$PRE)
      setVersions $VERSION

      applyChanges "release $VERSION" $VERSION

      NEXT_VERSION=$MAJOR.$MINOR.$PATCH-$PRE.$((PRERELEASE+1))

      setVersions $NEXT_VERSION

      applyChanges "bump to $NEXT_VERSION [skip ci]"

      exit 0
      ;;
  esac
fi

# If we get this far, we are releasing something from a release branch.

MATCHES="$($MATCH "^([0-9]{1,})\.([0-9]{1,})\.([0-9]{1,})\-$RC\.([0-9]{1,})$" "$VERSION")"
if [ -z "$MATCHES" ]; then
  echo "ERROR: the version does not match the format of major.minor.patch-$RC.n required in the release branch." >&2
  exit 8
else
  echo "INFO: version $VERSION matches expected format for branch $BRANCH"
fi

MAJOR="$(echo "$MATCHES" | awk '{ print $2 }')"
MINOR="$(echo "$MATCHES" | awk '{ print $3 }')"
PATCH="$(echo "$MATCHES" | awk '{ print $4 }')"
PRERELEASE="$(echo "$MATCHES" | awk '{ print $5 }')"

case "$RELEASE_LEVEL" in
  major|minor|patch)

    # NOTE: if RELEASE_LEVEL is 'minor' & we're prepped for a major release, no harm, no foul.
    # A major release is the same as a minor release, only that the minor version is 0.

    if [ $RELEASE_LEVEL = major ] && [ $MINOR != 0 ]; then
      echo "ERROR: this branch is not prepared for a major release because the minor version is $MINOR, not 0." >&2
      exit 10
    else
      NEXT_RELEASE_BRANCH_VERSION="$MAJOR.$MINOR.1-$RC.0"
    fi
    if [ $RELEASE_LEVEL = minor ] && [ $PATCH != 0 ]; then
      echo "ERROR: a minor release has already been performed in this release branch; only patch releases are allowed here now." >&2
      exit 11
    else
      NEXT_RELEASE_BRANCH_VERSION="$MAJOR.$MINOR.1-$RC.0"
    fi
    if [ $RELEASE_LEVEL = patch ] && [ $PATCH = 0 ]; then
      echo "ERROR: you must release a minor release before releasing a patch in this release branch." >&2
      exit 12
    else
      NEXT_RELEASE_BRANCH_VERSION="$MAJOR.$MINOR.$((PATCH+1))-$RC.0"
    fi

    echo "INFO: $RELEASE_LEVEL ok in branch $BRANCH"

    RELEASE_VERSION="$MAJOR.$MINOR.$PATCH"

    setVersions $RELEASE_VERSION

    applyChanges "release $RELEASE_VERSION" $RELEASE_VERSION

    setVersions $NEXT_RELEASE_BRANCH_VERSION

    applyChanges "bump to $NEXT_RELEASE_BRANCH_VERSION [skip ci]"

    exit 0
    ;;

  rc|$RC)
    setVersions $VERSION

    applyChanges "release $VERSION" $VERSION

    NEXT_RELEASE_BRANCH_VERSION="$MAJOR.$MINOR.$PATCH-$RC.$((PRERELEASE+1))"

    setVersions $NEXT_RELEASE_BRANCH_VERSION

    applyChanges "bump to $NEXT_RELEASE_BRANCH_VERSION [skip ci]"

    exit 0
    ;;
esac