run

#!/usr/bin/env bash

set -o errexit
set -o pipefail

DC="${DC:-exec}"

# Disable tty allocation for Docker Compose when none is available, such as
# in CI or when you pipe something into the run script. 0 = stdin, 1 = stdout.
TTY="${TTY:-}"
if ! [ -t 0 ] || ! [ -t 1 ]; then
  TTY="-T"
fi

# -----------------------------------------------------------------------------
# Helper functions start with _ and aren't listed in this script's help menu.
# -----------------------------------------------------------------------------

_dc() {
  # shellcheck disable=SC2086
  docker compose "${DC}" ${TTY} "${@}"
}

_dc_run() {
  DC="run" _dc --no-deps --rm "${@}"
}

# -----------------------------------------------------------------------------

cmd() {
  # Run any command you want in the web container
  _dc web "${@}"
}

iex() {
  # Connect to an IEx session
  cmd iex -S mix
}

secret() {
  # Generate a random secret that can be used for secret keys and more
  mix phx.gen.secret
}

lint:dockerfile() {
  # Lint Dockerfile
  docker container run --rm -i \
    -v "${PWD}/.hadolint.yaml:/.config/hadolint.yaml" \
    hadolint/hadolint hadolint "${@}" - <Dockerfile
}

lint:shell() {
  # Lint shell scripts
  local cmd=(shellcheck)

  if ! command -v shellcheck >/dev/null 2>&1; then
    local cmd=(docker container run --rm -i -v "${PWD}:/mnt" koalaman/shellcheck:stable)
  fi

  find . -type f \
    ! -path "./.git/*" \
    ! -path "./assets/*" \
    ! -path "./priv/static/*" \
    -exec grep --quiet '^#!.*sh' {} \; -exec "${cmd[@]}" {} +
}

lint() {
  # Lint Elixir code
  mix credo
}

format:shell() {
  # Format shell scripts
  local cmd=(shfmt)

  if ! command -v shfmt >/dev/null 2>&1; then
    local cmd=(docker container run --rm -i -v "${PWD}:/mnt" -u "$(id -u):$(id -g)" -w /mnt mvdan/shfmt:v3)
  fi

  local maybe_write=("--write")

  for arg in "${@}"; do
    if [ "${arg}" == "-d" ] || [ "${arg}" == "--diff" ]; then
      unset "maybe_write[0]"
    fi
  done

  "${cmd[@]}" "${maybe_write[@]}" "${@}" .
}

format:check() {
  # Check to see if there's an unformatted code
  format --check-formatted
}

format() {
  # Run the mix formatter
  mix format
}

quality() {
  # Perform all code quality commands together
  lint:dockerfile
  lint:shell
  lint

  format:shell
  format
}

test() {
  # Run test suite
  _dc -e "MIX_ENV=test" web mix test "${@}"
}

test:coverage() {
  # Get test coverage
  _dc -e "MIX_ENV=test" web mix coveralls "${@}"
}

test:coverage:details() {
  # Get test coverage details
  _dc -e "MIX_ENV=test" web mix coveralls.detail "${@}"
}

shell() {
  # Start a shell session in the web container
  cmd bash "${@}"
}

psql() {
  # Connect to PostgreSQL
  # shellcheck disable=SC1091
  . .env
  _dc postgres psql -U "${POSTGRES_USER}" "${@}"
}

deps:install() {
  local no_build="${1:-}"

  [ -z "${no_build}" ] && docker compose down && docker compose build

  _dc_run js yarn install
  _dc_run web mix deps.get
}

mix() {
  cmd mix "${@}"
}

mix:outdated() {
  # List any installed packages that are outdated
  _dc_run web mix hex.outdated
}

yarn() {
  _dc js yarn "${@}"
}

yarn:outdated() {
  # List any installed packages that are outdated
  _dc_run js yarn outdated
}

yarn:build:js() {
  # Build JS assets, this is meant to be run from within the assets container
  mkdir -p ../priv/static/js
  node esbuild.config.mjs
}

yarn:build:css() {
  # Build CSS assets, this is meant to be run from within the assets container
  local args=()

  if [ "${NODE_ENV:-}" == "production" ]; then
    args=(--minify)
  else
    args=(--watch)
  fi

  mkdir -p ../priv/static/css
  tailwindcss -i css/app.css -o ../priv/static/css/app.css "${args[@]}"
}

prod:migrate() {
  # Run database migrations in production
  cmd bin/hello eval "Hello.Release.migrate"
}

prod:remote() {
  # Connect an IEx session to your production system
  cmd bin/hello remote
}

clean() {
  # Remove cache and other machine generates files
  rm -rf priv/static/*.* priv/static/js priv/static/css priv/static/images priv/static/fonts
  touch priv/static/.keep
}

ci:install-deps() {
  # Install Continuous Integration (CI) dependencies
  sudo apt-get install -y curl
  sudo curl \
    -L https://raw.githubusercontent.com/nickjj/wait-until/v0.2.0/wait-until \
    -o /usr/local/bin/wait-until && sudo chmod +x /usr/local/bin/wait-until
}

ci:test() {
  # Execute Continuous Integration (CI) pipeline
  lint:dockerfile "${@}"
  lint:shell
  format:shell --diff

  cp --no-clobber .env.example .env

  docker compose build
  docker compose up -d

  # shellcheck disable=SC1091
  . .env
  wait-until "docker compose exec -T \
    -e PGPASSWORD=${POSTGRES_PASSWORD} postgres \
    psql -U ${POSTGRES_USER} ${POSTGRES_USER} -c 'SELECT 1'"

  docker compose logs

  lint
  format:check
  mix ecto.setup
  test "${@}"
}

help() {
  printf "%s <task> [args]\n\nTasks:\n" "${0}"

  compgen -A function | grep -v "^_" | cat -n

  printf "\nExtended help:\n  Each task has comments for general usage\n"
}

# This idea is heavily inspired by: https://github.com/adriancooney/Taskfile
TIMEFORMAT=$'\nTask completed in %3lR'
time "${@:-help}"