run

#!/usr/bin/env bash

set -euo pipefail

current_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)"

. "${current_dir}/scripts/run/css.sh"
. "${current_dir}/scripts/run/docker_file.sh"
. "${current_dir}/scripts/run/git.sh"
. "${current_dir}/scripts/run/html.sh"
. "${current_dir}/scripts/run/javascript.sh"
. "${current_dir}/scripts/run/markdown.sh"
. "${current_dir}/scripts/run/prettier.sh"
. "${current_dir}/scripts/run/release.sh"
. "${current_dir}/scripts/run/shell.sh"
. "${current_dir}/scripts/run/spellcheck.sh"
. "${current_dir}/scripts/lib/utils.sh"

export DOCKER_BUILDKIT=1
export COMPOSE_DOCKER_CLI_BUILD=1

function help {
  cat <<EOF

$0 [command] [OPTIONS] [sub-command]

Example: $0 --dc-dev dc:exec ./run test

Options:
  -h, --help      Print this message
  --dc-ci         Use "ci" file when docker compose
  --dc-dev        Use "dev" file when docker compose

Main commands:
  help            Print this message
  check           Test and lint the whole project
  format          Format code of the whole project
  install:deps    Install all dependencies
  lint            Lint the whole project
  lint:staged     Lint staged files
  pre-commit      Lint staged files and test the whole project
  test            Test the whole project

docker compose commands:
  dc:build        Build all docker services
  dc:console      Build, start, up all services and console of "app" docker service
  dc:exec         Execute a command in a "app" docker service
  dc:run          Run a command inside the "app" docker service and remove stopped containers
  dc:up           Starts all docker services
EOF

  help:release
  help:css
  help:html
  help:js
  help:markdown
  help:prettier
  help:shell
  help:dockerfile
  help:spellcheck
  help:git
}

# —————————————————————————————————————————————— #
#                Helper functions                #
# —————————————————————————————————————————————— #

# Check if the command is from the docker container or the host.
function is_inside_docker {
  [[ ${INSIDE_DOCKER:-false} == true ]]
}

function is_ci {
  [[ "${CI:-false}" == true ]]
}

# If we're running in CI we need to disable TTY allocation for docker-compose
# commands that enable it by default, such as exec and run.
# Idea from: https://github.com/nickjj/docker-flask-example/blob/main/run
TTY=""
if [[ ! -t 1 ]] || is_ci; then
  TTY="-T"
fi

# —————————————————————————————————————————————— #
#                   Application                  #
# —————————————————————————————————————————————— #

# TODO: Call your application tests below

test_checks=$(
  cat <<EOF
test:release
EOF
)

lint_checks=$(
  cat <<EOF
lint:css
lint:dockerfile
lint:html
lint:js
lint:markdown
lint:prettier
lint:shell
lint:spellcheck
EOF
)

function check {
  local status=0
  local all_checks

  all_checks=$(echo "${test_checks}" && echo "${lint_checks}")

  # Options
  for opt in "${@}"; do
    case ${opt} in
      --include)
        local param_value="${2:-}"
        if [[ -z "${param_value}" ]]; then alert_die "'--include' should contains a string"; fi

        all_checks=$(echo "${all_checks}" && echo "${param_value}")

        shift 2
        ;;
      -h | --help)
        cat <<EOF
Test and lint the whole project

$0 check [OPTIONS]

Example: $0 check

Options:
  --include cmd1              Include an additional check from "./run"
  -h, --help                  Print this message
EOF
        close
        ;;
    esac
  done

  # Run all checks concurrently
  echo "${all_checks}" \
    | parallel --keep-order --tagstring "[{1}]" "./run {1}" \
    || status=${?}

  if [[ ${status} -ne 0 ]]; then
    alert "✖ Project checked: issue(s) found"
    exit ${status}
  fi

  success "✔ Project checked"
}

function test {
  if is_inside_docker; then
    local status=0

    # Run all tests concurrently
    echo "${test_checks}" | parallel --keep-order --tagstring "[{1}]" "./run {1}" \
      || status=${?}

    if [[ ${status} -ne 0 ]]; then
      alert "✖ Project tested: issue(s) found"
      exit ${status}
    fi

    success "✔ Project tested"
  else
    dc:exec ./run test
  fi
}

function lint {
  # shellcheck disable=SC2119
  if is_inside_docker; then
    local status=0

    # Run all lints concurrently
    echo "${lint_checks}" | parallel --keep-order --tagstring "[{1}]" "./run {1}" \
      || status=${?}

    if [[ ${status} -ne 0 ]]; then
      alert "✖ Project linted: issue(s) found"
      exit ${status}
    fi

    success "✔ Project linted"
  else
    dc:exec ./run lint
  fi
}

function format {
  # shellcheck disable=SC2119
  if is_inside_docker; then
    local status=0

    # Run all formatters concurrently
    (
      cat <<EOF
format:css
format:dockerfile
format:js
format:shell
EOF
    ) | parallel --keep-order --tagstring "[{1}]" "./run {1}" \
      || status=${?}

    # Prettier format should be done after CSS and JS format
    print "\e[30;47m———[prettier]———\e[0m"
    ./run format:prettier || status=${?}

    if [[ ${status} -ne 0 ]]; then
      alert "✖ Project could not be formatted completely: issue(s) found"
      exit ${status}
    fi

    success "✔ Project formatted"
  else
    dc:exec ./run format
  fi
}

function pre-commit {
  if is_inside_docker; then
    local status=0
    local pre_commit_checks

    pre_commit_checks=$(echo "${test_checks}" && echo lint:staged)

    # Run all checks concurrently
    echo "${pre_commit_checks}" \
      | parallel --keep-order --tagstring "[{1}]" "./run {1}" \
      || status=${?}

    if [[ ${status} -ne 0 ]]; then
      alert "✖ Project checked: issue(s) found"
      exit ${status}
    fi

    success "✔ Project checked"
  else
    dc:exec ./run pre-commit
  fi
}

function lint:staged {
  npx lint-staged
}

function install:deps {
  if is_inside_docker; then
    npm ci --quiet

    success "✔ Dependencies installed"
  else
    dc:exec ./run install:deps
  fi
}

# —————————————————————————————————————————————— #
#                 docker compose                 #
# —————————————————————————————————————————————— #

dc_options=()

ci_dc_options=(
  -f docker-compose.yml
  -f docker-compose.ci.yml
)

dev_dc_options=(
  -f docker-compose.yml
  -f docker-compose.dev.yml
)

function dc {
  docker compose "${dc_options[@]}" "${@}"
}

function dc:build {
  docker buildx bake "${dc_options[@]}"
}

function dc:exec {
  dc exec ${TTY} app "${@}"
}

function dc:run {
  dc run ${TTY} app "${@}"
  dc rm -f -v
}

function dc:up {
  dc up -d --remove-orphans
}

function dc:console {
  dc:build
  dc:up
  dc:exec bash
}

# —————————————————————————————————————————————— #
#                       run                      #
# —————————————————————————————————————————————— #

opt_dc_ci=
opt_dc_dev=

# Options
for opt in "${@}"; do
  case ${opt} in
    --dc-ci)
      if [[ -n ${opt_dc_dev} ]]; then
        alert_die "--dc-ci is not compatible with --dc-dev"
      fi

      dc_options=("${ci_dc_options[@]}")
      opt_dc_ci=1

      shift
      ;;
    --dc-dev)
      if [[ -n ${opt_dc_ci} ]]; then
        alert_die "--dc-dev is not compatible with --dc-ci"
      fi

      dc_options=("${dev_dc_options[@]}")
      opt_dc_dev=1

      shift
      ;;
    -h | --help)
      if [[ "${#}" -eq 1 ]]; then
        help
        close
      fi
      ;;
  esac
done

# Idea from: https://github.com/adriancooney/Taskfile
TIMEFORMAT=$'\nTask completed in %3lR'
time "${@:-help}"