dockerc

#!/bin/sh

# DockerC (v2.2.2)
# Wrapper for docker compose commands in your project.
# https://github.com/matiboux/dockerc
# MIT License
# Copyright (c) 2023 Matiboux
# This project is not affiliated with Docker, Inc.

VERSION='2.2.2'

ERROR_CODE=''

escape_shell_args()
{
	ARGS=''
	for ARG in "$@"; do

		if [ -z "$ARG" ]; then
			# Skip empty arguments
			continue
		fi

		if [ "$(echo "$ARG" | grep "[ '\"\$\`;*&#<>|]")" ]; then
			# Escape argument with spaces or special shell characters
			# Replace single quotes with escaped single quotes
			ARG="'$(echo "$ARG" | sed "s/'/'\"'\"'/g")'"
		fi

		ARGS="$ARGS $ARG"

	done

	# Remove leading space
	ARGS="${ARGS# }"

	echo "$ARGS"
}

# Parse arguments
# Dummy while loop to allow breaking
while true; do

	# Parse options arguments
	while [ "$#" -gt 0 ]; do

		case "$1" in

			'--help' | '-h' )
				# Print general help
				DOCKERC_PRINT_HELP='true'
				shift
				;;

			'--version' | '-v' )
				# Print version
				DOCKERC_PRINT_VERSION='true'
				shift
				;;

			'--force' | '-f' )
				# Force, for example ignores abstract contexts
				DOCKERC_FORCE='true'
				shift
				;;

			'--dry-run' | '-n' )
				# Dry run, print docker compose command without running it
				DOCKERC_DRY_RUN='true'
				shift
				;;

			'--quiet' | '-q' )
				# Quiet, do not print docker compose command
				DOCKERC_QUIET='true'
				shift
				;;

			'--uid' | '-u' )
				# Set user & group id environment variable
				DOCKERC_UID='true'
				shift
				;;

			'--update' )
				# Update DockerC
				DOCKERC_UPDATE='true'
				shift
				;;

			'--install-dir' | '-i' )
				shift
				# Check for installation directory argument
				if [ -z "$1" ]; then
					echo 'Error: Missing installation directory.' >&2
					DOCKERC_PRINT_HELP='true'
					DOCKERC_UPDATE='true'
					ERROR_CODE=1
					break
				fi
				# Set installation directory
				DOCKERC_INSTALL_DIR=$(escape_shell_args "$1")
				shift
				;;

			'-' | '--' )
				# Stop parsing options
				break
				;;

			'--'* | '-'? )
				# Unknown option
				echo "Error: Unknown option '$1'" >&2
				DOCKERC_PRINT_HELP='true'
				ERROR_CODE=1
				break
				;;

			* )
				# Stop parsing options
				break
				;;

		esac

	done

	if
		[ "$DOCKERC_PRINT_HELP" = 'true' ] ||
		[ "$DOCKERC_PRINT_VERSION" = 'true' ]
	then
		# Stop parsing arguments
		break
	fi

	# Check for optional positional arguments
	if [ "$#" -le 0 ]; then
		# No more arguments
		break
	fi

	if [ "$DOCKERC_UPDATE" = 'true' ]; then
		# Parse update arguments

		if [ "$1" = '--' ]; then
			# Skip '--' argument
			shift
		fi

		# Parse update install args
		DOCKERC_INSTALL_ARGS=$(escape_shell_args "$@")

		break
	fi

	# Parse first optional positional argument

	if [ "$1" = '?' ]; then
		# Print context help
		DOCKERC_PRINT_HELP_CONTEXT='true'
		# Stop parsing arguments
		break
	fi

	# Parse docker command preset
	if [ "$(echo "$1" | cut -c1)" = '@' ]; then
		if [ "$1" = '@' ]; then
			# Print docker preset help
			DOCKERC_PRINT_HELP_DOCKER_PRESET='true'
			# Stop parsing arguments
			break
		fi

		DOCKERC_DOCKER_PRESET="$1"
		shift

	# Parse context argument
	else
		DOCKERC_CONTEXT="$1"
		shift
	fi

	# Check for optional positional arguments
	if [ "$#" -le 0 ]; then
		# No more arguments
		break
	fi

	# Parse second optional positional argument

	# Parse docker command preset
	if
		[ -z "$DOCKERC_DOCKER_PRESET" ] &&
		(
			[ "$1" = '$' ] ||
			[ "$(echo "$1" | cut -c1)" = '@' ]
		)
	then
		if [ "$1" = '@' ]; then
			# Print docker command preset help
			DOCKERC_PRINT_HELP_COMPOSE_PRESET='true'
			# Stop parsing arguments
			break
		fi

		DOCKERC_COMPOSE_PRESET="$1"
		shift

		# Check for optional positional arguments
		if [ "$#" -le 0 ]; then
			# No more arguments
			break
		fi

	# Else, this is a command argument
	fi

	# Parse trailing positional arguments for command args
	# Parse command args
	DOCKERC_COMMAND_ARGS=$(escape_shell_args "$@")

	# Stop parsing arguments
	break

done

if [ "$DOCKERC_DEBUG_ARGS" = 'true' ]; then
	# Print parsed arguments
	echo "DOCKERC_PRINT_HELP: $DOCKERC_PRINT_HELP"
	echo "DOCKERC_PRINT_HELP_CONTEXT: $DOCKERC_PRINT_HELP_CONTEXT"
	echo "DOCKERC_PRINT_HELP_DOCKER_PRESET: $DOCKERC_PRINT_HELP_DOCKER_PRESET"
	echo "DOCKERC_PRINT_HELP_COMPOSE_PRESET: $DOCKERC_PRINT_HELP_COMPOSE_PRESET"
	echo "DOCKERC_PRINT_VERSION: $DOCKERC_PRINT_VERSION"
	echo "DOCKERC_FORCE: $DOCKERC_FORCE"
	echo "DOCKERC_DRY_RUN: $DOCKERC_DRY_RUN"
	echo "DOCKERC_QUIET: $DOCKERC_QUIET"
	echo "DOCKERC_UID: $DOCKERC_UID"
	echo "DOCKERC_UPDATE: $DOCKERC_UPDATE"
	echo "DOCKERC_INSTALL_DIR: $DOCKERC_INSTALL_DIR"
	echo "DOCKERC_INSTALL_ARGS: $DOCKERC_INSTALL_ARGS"
	echo "DOCKERC_CONTEXT: $DOCKERC_CONTEXT"
	echo "DOCKERC_COMPOSE_PRESET: $DOCKERC_COMPOSE_PRESET"
	echo "DOCKERC_COMMAND_ARGS: $DOCKERC_COMMAND_ARGS"
	exit ${ERROR_CODE:-0}
fi

FORCE='false'
if [ -n "$DOCKERC_FORCE" ]; then
	# Use from argument or environment variable
	FORCE="$DOCKERC_FORCE"
fi

DRY_RUN='false'
if [ -n "$DOCKERC_DRY_RUN" ]; then
	# Use from argument or environment variable
	DRY_RUN="$DOCKERC_DRY_RUN"
fi

QUIET='false'
if [ -n "$DOCKERC_QUIET" ]; then
	# Use from argument or environment variable
	QUIET="$DOCKERC_QUIET"
fi

SET_UID='false'
if [ -n "$DOCKERC_UID" ]; then
	# Use from argument or environment variable
	SET_UID="$DOCKERC_UID"
fi

UPDATE='false'
if [ -n "$DOCKERC_UPDATE" ]; then
	# Use from argument or environment variable
	UPDATE="$DOCKERC_UPDATE"
fi

INSTALL_DIR="$(escape_shell_args "$(dirname "$0")")"
if [ -n "$DOCKERC_INSTALL_DIR" ]; then
	# Use from argument or environment variable
	INSTALL_DIR="$DOCKERC_INSTALL_DIR"
fi

INSTALL_ARGS=''
if [ -n "$DOCKERC_INSTALL_ARGS" ]; then
	# Use from argument or environment variable
	INSTALL_ARGS="$DOCKERC_INSTALL_ARGS"
fi

DOCKER_PRESET=''
if [ -n "$DOCKERC_DOCKER_PRESET" ]; then
	# Use from argument or environment variable
	DOCKER_PRESET="$DOCKERC_DOCKER_PRESET"
fi

CONTEXT=''
if [ -n "$DOCKERC_CONTEXT" ]; then
	# Use from argument or environment variable
	CONTEXT="$DOCKERC_CONTEXT"
fi

COMPOSE_PRESET=''
if [ -n "$DOCKERC_COMPOSE_PRESET" ]; then
	# Use from argument or environment variable
	COMPOSE_PRESET="$DOCKERC_COMPOSE_PRESET"
fi

COMMAND_ARGS=''
if [ -n "$DOCKERC_COMMAND_ARGS" ]; then
	# Use from argument or environment variable
	COMMAND_ARGS="$DOCKERC_COMMAND_ARGS"
fi

if [ "$DOCKERC_PRINT_HELP" = 'true' ]; then

	if [ "$UPDATE" = 'true' ]; then
		# Print update help & exit
		echo "Usage: $0 --update [options] [tag]"
		echo ''
		echo 'Options:'
		echo '  -h, --help         Print this help message'
		echo '  -i, --install-dir  Set installation directory'
		echo "    (defaults to directory '$(dirname "$0")')"
		echo ''
		echo 'Arguments:'
		echo '  tag  DockerC tag/version to install (defaults to HEAD)'
		exit ${ERROR_CODE:-0}
	fi

	# Print help & exit
	echo 'Usage:'
	echo "  $0 [options] [ <context> [@compose_preset] [...args] ]"
	echo "  $0 [options] <@docker_preset> [...args]"
	echo ''
	echo 'Options:'
	echo '  -h, --help     Print this help message'
	echo '  -v, --version  Print version'
	echo '  --update       Update DockerC'
	echo '  -f, --force    Force, for example ignores abstract contexts'
	echo '  -n, --dry-run  Dry run, print docker compose command without running it'
	echo '  -q, --quiet    Quiet, do not print docker compose command'
	echo ''
	echo 'Arguments:'
	echo '  options          DockerC options'
	echo '  context          Docker compose files context'
	echo '  @compose_preset  Docker compose command preset (shorthand)'
	echo '  @docker_preset   Docker command preset (shorthand)'
	echo '  args             Arguments appended to the docker compose command'
	echo ''
	echo 'Help commands:'
	echo "  $0 ?    See context argument help"
	echo "  $0 - @  See @compose_preset argument help"
	echo "  $0 @    See @docker_preset argument help"
	exit ${ERROR_CODE:-0}
fi

if [ "$DOCKERC_PRINT_HELP_CONTEXT" = 'true' ]; then
	# Print context help & exit
	echo 'DockerC context argument values:'
	echo ''
	echo '  (empty), -'
	echo '    Look for default docker compose files'
	echo '    Usage:'
	echo "      $0 [options]"
	echo "      $0 [options] - [@compose_preset] [...args]"
	echo '    Used default docker compose files are:'
	echo '      - docker-compose.yml'
	echo '      - docker-compose.override.yml (if it exists)'
	echo ''
	echo '  --'
	echo '    Run docker compose without file arguments'
	echo '    Usage:'
	echo "      $0 [options] -- [@compose_preset] [...args]"
	echo ''
	echo '  level1[.level2[...]]]'
	echo '    Look for docker compose files matching context levels'
	echo '    Usage:'
	echo "      $0 [options] level1[.level2[...] [@compose_preset] [...args]"
	echo '    Example:'
	echo "      '$0 prod.boosted' will look for:"
	echo '        - docker-compose.yml'
	echo '        - docker-compose.prod.yml'
	echo '        - docker-compose.prod.boosted.yml'
	echo ''
	echo 'Use dry run option (--dry-run or -n) to see the docker compose command'
	echo 'and files that will be used without running it.'
	echo ''
	echo "Use '$0 --help' for more help."
	exit ${ERROR_CODE:-0}
fi

if [ "$DOCKERC_PRINT_HELP_DOCKER_PRESET" = 'true' ]; then
	# Print docker preset help & exit
	echo "Usage: $0 [options] <@docker_preset> [...args]"
	echo ''
	echo 'Docker command presets:'
	echo '  prune:'
	echo '    @rfc   Remove unused containers'
	echo '    @rfi   Remove dangling images'
	echo '    @rfia  Remove all unused images'
	echo '    @rf    Remove unused containers, networks and images'
	echo '    @rfa   Remove all unused containers, networks and images'
	echo '    @rfav  Remove all unused containers, networks, images and volumes'
	echo '  stop:'
	echo '    @sa    Stop all running containers'
	echo '  rm:'
	echo '    @rmf   Remove running containers, force'
	echo '    @rms   Remove stopped containers'
	echo '    @rmsf  Remove stopped containers, force'
	echo '      (aliases: @rmfs)'
	echo '    @rma   Remove all containers'
	echo '    @rmaf  Remove all containers, force'
	echo '      (aliases: @rmfa)'
	echo ''
	echo 'Arguments will be appended to the docker command that will be run.'
	echo ''
	echo "Use '$0 --help' for more help."
	exit ${ERROR_CODE:-0}
fi

if [ "$DOCKERC_PRINT_HELP_COMPOSE_PRESET" = 'true' ]; then
	# Print compose preset help & exit
	echo "Usage: $0 [options] <context> [@compose_preset] [...args]"
	echo ''
	echo 'Compose command presets:'
	echo '  up:'
	echo '    @u[suffix]  up -d'
	echo '    Suffixes to combine:'
	echo '      a  Removes the -d flag (attached)'
	echo '      b  --build'
	echo '      f  --force-recreate'
	echo '      p  --pull always'
	echo '      r  --remove-orphans'
	echo '      (e.g. @uba, @ubfapr)'
	echo '  build:'
	echo '    @b[suffix]  build'
	echo '    Suffixes to combine:'
	echo '      p  --pull'
	echo '      f  --no-cache'
	echo '      n  --dry-run'
	echo '      (e.g. @bp, @bfn)'
	echo '  watch:'
	echo '    @w[suffix]  watch'
	echo '    Suffixes to combine:'
	echo '      q  --quiet'
	echo '      w  --no-up'
	echo '      n  --dry-run'
	echo '      (e.g. @wq, @wwqn)'
	echo '  down:'
	echo '    @d[suffix]  down'
	echo '    Preset suffixes:'
	echo '      a   --remove-orphans'
	echo '      r   --remove-orphans --rmi local'
	echo '      ra  --remove-orphans --rmi all'
	echo '    Suffixes to combine:'
	echo '      v  -v (volumes)'
	echo '      (e.g. @da, @drv, @drav)'
	echo '  run:'
	echo '    @r[suffix]  run --rm'
	echo '    Suffixes to combine:'
	echo '      b  --build'
	echo '      d  -d (detached)'
	echo '      n  --dry-run'
	echo '      i  -i (interactive)'
	echo '      t  -t (tty)'
	echo '      o  --no-deps'
	echo '      q  --quiet'
	echo '      k  Removes the --rm flag (keep)'
	echo '      p  --service-ports'
	echo '      w  -w /pwd -v $(pwd):/pwd'
	echo '      (e.g. @rb, @rbkpd)'
	echo '  run shells:'
	echo '    @sh[suffix]    like: @ri --entrypoint /bin/sh'
	echo '    @$[suffix]     like: @riw --entrypoint /bin/sh'
	echo '    $[suffix]      like: @$'
	echo '    @ash[suffix]   like: @ri --entrypoint /bin/ash'
	echo '    @bash[suffix]  like: @ri --entrypoint /bin/bash'
	echo '    @zsh[suffix]   like: @ri --entrypoint /bin/zsh'
	echo '    Suffixes to combine:'
	echo '      See suffixes for @r (run)'
	echo '  logs:'
	echo '    @l[suffix]  logs -n 100'
	echo '    Suffixes to combine:'
	echo '      n  --dry-run'
	echo '      f  -f (follow)'
	echo '      C  --no-color'
	echo '      s  --no-log-prefix'
	echo '      t  -t (timestamps)'
	echo '      l  Remove the -n flag (no tail)'
	echo '      (e.g. @lf, @llfs)'
	echo '  ps:'
	echo '    @p   ps'
	echo '    @pa  ps -a'
	echo '  push:'
	echo '    @pu  push'
	echo '  pull:'
	echo '    @pl  pull'
	echo '  rm:'
	echo '    @rs[suffix]  rm --stop'
	echo '    @rf[suffix]  rm -f'
	echo '    Suffixes to combine:'
	echo '      n  --dry-run'
	echo '      f  -f (force)'
	echo '      s  --stop'
	echo '      v  -v (remove volumes)'
	echo '      (e.g. @rfv)'
	echo ''
	echo 'Arguments will be appended to the docker command that will be run.'
	echo 'If the preset is empty, the arguments should include the command.'
	echo ''
	echo "Use '$0 --help' for more help."
	exit ${ERROR_CODE:-0}
fi

get_latest_version() {
	# Syntax: '"tag_name": "v1.0.0",'
	LATEST_VERSION_JSON=$(
		curl -fsSL "https://api.github.com/repos/matiboux/dockerc/releases/latest" 2>/dev/null \
		| grep -Eo '"tag_name": "(.+?)",'
	)

	if [ -n "$LATEST_VERSION_JSON" ]; then
		# Extract version from matched string
		# Remove `"tag_name": "` (13 characters) and `",` (2 characters)
		if [ "$(uname -s)" = 'Darwin' ]; then
			# MacOS
			LATEST_VERSION="${LATEST_VERSION_JSON:13:$((${#LATEST_VERSION_JSON}-13-2))}"
		else
			# Linux
			LATEST_VERSION=$(expr substr "$LATEST_VERSION_JSON" $(expr 1 + 13) $(expr length "$LATEST_VERSION_JSON" - 13 - 2))
		fi

		echo "$LATEST_VERSION"
	fi
}

if [ "$DOCKERC_PRINT_VERSION" = 'true' ]; then
	# Print version & exit

	if [ "$QUIET" = 'false' ]; then
		echo "DockerC (v$VERSION) - https://github.com/matiboux/dockerc"

		if [ "$DRY_RUN" = 'false' ]; then
			LATEST_VERSION=$(get_latest_version)
			if [ -z "$LATEST_VERSION" ]; then
				echo 'Notice: Failed to get DockerC latest version.' >&2
			elif [ "$VERSION" != "${LATEST_VERSION#v}" ]; then
				echo "Notice: DockerC is not up to date, latest version is $LATEST_VERSION!" >&2
			fi
		fi

	else
		echo "v$VERSION"
	fi

	exit ${ERROR_CODE:-0}

fi

if [ "$UPDATE" = 'true' ]; then
	# Update DockerC & exit

	if [ -n "$INSTALL_ARGS" ]; then
		INSTALL_ARGS=" $INSTALL_ARGS"
	fi

	if [ "$QUIET" = 'false' ]; then
		# Print install script command
		if [ "$DOCKERC_FIRST_NEWLINE" != 'false' ]; then
			echo ''
		fi
		echo "> curl -fsSL \"https://raw.githubusercontent.com/matiboux/dockerc/HEAD/install.sh\" | /bin/sh -s -- --install-dir ${INSTALL_DIR}${INSTALL_ARGS}"
		echo ''
	fi

	if [ "$DRY_RUN" = 'false' ]; then
		# Run install script command
		exec sh -c "curl -fsSL \"https://raw.githubusercontent.com/matiboux/dockerc/HEAD/install.sh\" | /bin/sh -s -- --install-dir ${INSTALL_DIR}${INSTALL_ARGS}"
	fi

	exit ${ERROR_CODE:-0}
fi

# Set user & group id environment variable
if [ "$SET_UID" = 'true' ]; then
	export UID="$(id -u)"
	export GID="$(id -g)"
fi

# Handle docker presets
if [ -n "$DOCKER_PRESET" ]; then

	DOCKER_ARGS=''

	case "$DOCKER_PRESET" in

		# Prune presets
		'@rfc' )
			DOCKER_ARGS='container prune -f'
			;;
		'@rfi' )
			DOCKER_ARGS='image prune -f'
			;;
		'@rfia' )
			DOCKER_ARGS='image prune -f -a'
			;;
		'@rf' )
			DOCKER_ARGS='system prune -f'
			;;
		'@rfa' )
			DOCKER_ARGS='system prune -f -a'
			;;
		'@rfav' )
			DOCKER_ARGS='system prune -f -a --volumes'
			;;

		# Stop presets
		'@sa' )
			# Stop all containers
			DOCKER_ARGS='stop $(docker ps -q)'
			;;

		# Remove presets
		'@rmf' )
			# Remove running containers, force
			DOCKER_ARGS='rm -f $(docker ps -a -q)'
			;;
		'@rms' )
			# Remove stopped containers
			DOCKER_ARGS='rm $(docker ps -a -q -f status=exited -f status=dead)'
			;;
		'@rmsf' | '@rmfs' )
			# Remove stopped containers, force
			DOCKER_ARGS='rm -f $(docker ps -a -q -f status=exited -f status=dead)'
			;;
		'@rma' )
			# Remove all containers
			DOCKER_ARGS='rm $(docker ps -a -q)'
			;;
		'@rmaf' | '@rmfa' )
			# Remove all containers, force
			DOCKER_ARGS='rm -f $(docker ps -q)'
			;;

	esac

	if [ -z "$DOCKER_ARGS" ]; then
		echo "Error: Unknown docker preset '$DOCKER_PRESET'" >&2
		exit 1
	fi

	if [ "$QUIET" = 'false' ]; then
		# Print docker command
		if [ "$DOCKERC_FIRST_NEWLINE" != 'false' ]; then
			echo ''
		fi
		echo "> docker ${DOCKER_ARGS}${ARGS}"
		echo ''
	fi

	if [ "$DRY_RUN" = 'false' ]; then
		# Run docker command
		exec sh -c "docker ${DOCKER_ARGS}${ARGS}"
	fi

	exit ${ERROR_CODE:-0}

fi

look_env_files() {
	# Usage: look_env_files <dir> <base> <part>

	# Extract arguments
	ARG_DIR="${1:-.}" # eg. '.' or './docker'
	ARG_BASE="${2:-}"
	ARG_PART="${3:-}" # e.g. '' or 'prod' or 'dev'

	# Reformat base argument: ensure leading dot if not empty
	if [ -n "$ARG_PART" ]; then
		ARG_PART=".${ARG_PART#.}"
	fi

	ENV_FILE_FOUND='false'

	ENV_FILE_PATH="$ARG_DIR/.env$ARG_BASE$ARG_PART"
	if [ -f "$ENV_FILE_PATH" ]; then
		# Env file found
		echo "$ENV_FILE_PATH"
		ENV_FILE_FOUND='true'
	fi

	ENV_FILE_LOCAL_PATH="$ENV_FILE_PATH.local"
	if [ -f "$ENV_FILE_LOCAL_PATH" ]; then
		# Local env file found
		echo "$ENV_FILE_LOCAL_PATH"
		ENV_FILE_FOUND='true'
	fi

	if [ "$ENV_FILE_FOUND" = 'false' ]; then
		# No env file found
		return 1
	fi

	return 0
}

look_compose_file() {
	# Usage: look_compose_file <dir> <compose_prefix> <base> <part> <extension>

	# Extract arguments
	ARG_DIR="${1:-.}" # eg. '.' or './docker'
	ARG_COMPOSE_PREFIX="${2:-docker-compose}" # eg. 'docker-compose' or 'compose'
	ARG_BASE="${3:-}"
	ARG_PART="${4:-}" # e.g. '' or 'override' or 'prod'
	ARG_EXTENSION="${5:-yml}" # e.g. 'yml' or 'yaml'

	# Reformat base argument: ensure leading dot if not empty
	if [ -n "$ARG_PART" ]; then
		ARG_PART=".${ARG_PART#.}"
	fi

	COMPOSE_FILE_PATH="${ARG_DIR}/${ARG_COMPOSE_PREFIX}${ARG_BASE}${ARG_PART}.${ARG_EXTENSION}"
	if [ ! -f "$COMPOSE_FILE_PATH" ]; then
		# Compose file not found
		return 1
	fi

	# Return found compose file path
	echo "$COMPOSE_FILE_PATH"

	if cat "$COMPOSE_FILE_PATH" | grep -q "^#:dockerc.abstract$"; then
		# Compose file is abstract
		return 2
	fi

	return 0
}

COMPOSE_FILE_ARGS=''
ENV_FILE_ARGS=''
ABSTRACT_CONTEXT='false'

# Handle context
# Unless context is '--': in this case, use no compose file argument
if [ "$CONTEXT" != '--' ]; then

	CONTEXT_SKIP_ROOT_STANDARD='false'

	if [ "$CONTEXT" = '-' ]; then
		# Use default context
		CONTEXT=''

	elif [ "$(echo "$CONTEXT" | cut -c1)" = '-' ]; then
		# Only look for standard root level compose files
		CONTEXT_SKIP_ROOT_STANDARD='true'
		# Remove leading dash
		CONTEXT="${CONTEXT#-}"
	fi

	# Iterate over directories:
	# - Current directory '.'
	# - Directory './docker'
	while read -r COMPOSE_DIR; do

		# Iterate over compose file naming schemes:
		# - 'docker-compose.yml'
		# - 'docker-compose.yaml'
		# - 'compose.yml'
		# - 'compose.yaml'
		while read -r COMPOSE_SCHEME; do

			# If $COMPOSE_SCHEME <= 2, use 'docker-compose' compose file prefix name
			# Else,                    use 'compose' compose file prefix name
			COMPOSE_PREFIX=$([ "${COMPOSE_SCHEME:-1}" -le 2 ] && echo 'docker-compose' || echo 'compose')

			# If $COMPOSE_SCHEME is odd, use 'yml' compose file extension
			# Else,                      use 'yaml' compose file extension
			COMPOSE_EXTENSION=$([ "$((${COMPOSE_SCHEME:-1} % 2))" -eq 1 ] && echo 'yml' || echo 'yaml')

			LVL1_COMPOSE_FILE_ARGS=''
			LVL1_ENV_FILE_ARGS=''
			LVL1_ABSTRACT_CONTEXT='false'

			# Look for global env files
			ENV_LOOK_FILES=$(look_env_files "$COMPOSE_DIR" '' '')
			ENV_LOOK_CODE=$?
			if [ "$ENV_LOOK_CODE" -eq 0 ]; then
				while read -r ENV_LOOK_FILE; do
					LVL1_ENV_FILE_ARGS="$LVL1_ENV_FILE_ARGS --env-file $ENV_LOOK_FILE"
				done <<-EOF
				$(echo "$ENV_LOOK_FILES")
				EOF
			fi

			if [ "$CONTEXT_SKIP_ROOT_STANDARD" != 'true' ]; then

				# Check for standard root level compose file

				# Look for root compose file
				COMPOSE_LOOK_FILE=$(look_compose_file "$COMPOSE_DIR" "$COMPOSE_PREFIX" '' '' "$COMPOSE_EXTENSION")
				COMPOSE_LOOK_CODE=$?
				if [ "$COMPOSE_LOOK_CODE" -ne 1 ]; then
					# Compose file found
					LVL1_COMPOSE_FILE_ARGS="$LVL1_COMPOSE_FILE_ARGS -f $COMPOSE_LOOK_FILE"
					LVL1_ABSTRACT_CONTEXT=$([ "$COMPOSE_LOOK_CODE" -eq 0 ] && echo 'false' || echo 'true')
				fi

			fi

			# Parse context parts
			if [ -n "$CONTEXT" ] && [ "$CONTEXT" != '.' ]; then

				if [ -n "$LVL1_COMPOSE_FILE_ARGS" ]; then

					# Check for standard root level compose files

					LVL2_COMPOSE_FILE_ARGS="$LVL1_COMPOSE_FILE_ARGS"
					LVL2_ENV_FILE_ARGS="$LVL1_ENV_FILE_ARGS"
					LVL2_ABSTRACT_CONTEXT='false'
					LVL2_PREFIX=''

					while read -r CONTEXT_PART; do

						if [ -z "$CONTEXT_PART" ]; then
							# Skip empty parts
							continue
						fi

						LVL2_PREFIX="$LVL2_PREFIX.$CONTEXT_PART"

						# Look for universal env files
						ENV_LOOK_FILES=$(look_env_files "$COMPOSE_DIR" '.-' "$CONTEXT_PART")
						ENV_LOOK_CODE=$?
						if [ "$ENV_LOOK_CODE" -eq 0 ]; then
							while read -r ENV_LOOK_FILE; do
								LVL2_ENV_FILE_ARGS="$LVL2_ENV_FILE_ARGS --env-file $ENV_LOOK_FILE"
							done <<-EOF
							$(echo "$ENV_LOOK_FILES")
							EOF
						fi

						# Look for context env files
						ENV_LOOK_FILES=$(look_env_files "$COMPOSE_DIR" '' "$LVL2_PREFIX")
						ENV_LOOK_CODE=$?
						if [ "$ENV_LOOK_CODE" -eq 0 ]; then
							while read -r ENV_LOOK_FILE; do
								LVL2_ENV_FILE_ARGS="$LVL2_ENV_FILE_ARGS --env-file $ENV_LOOK_FILE"
							done <<-EOF
							$(echo "$ENV_LOOK_FILES")
							EOF
						fi

						# Look for context compose file
						COMPOSE_LOOK_FILE=$(look_compose_file "$COMPOSE_DIR" "$COMPOSE_PREFIX" '' "$LVL2_PREFIX" "$COMPOSE_EXTENSION")
						COMPOSE_LOOK_CODE=$?
						if [ "$COMPOSE_LOOK_CODE" -ne 1 ]; then
							# Context compose file found
							LVL2_COMPOSE_FILE_ARGS="$LVL2_COMPOSE_FILE_ARGS -f $COMPOSE_LOOK_FILE"
							LVL2_ABSTRACT_CONTEXT=$([ "$COMPOSE_LOOK_CODE" -eq 0 ] && echo 'false' || echo 'true')

						else
							# Context compose file not found: invalidate LVL2 and break loop
							LVL2_COMPOSE_FILE_ARGS=''
							break
						fi

					done <<-EOF
					$(echo "$CONTEXT" | tr '.' "\n")
					EOF

					if [ -n "$LVL2_COMPOSE_FILE_ARGS" ]; then
						# Context resolved: break loop
						break
					fi

				fi

				LVL2_COMPOSE_FILE_ARGS=''
				LVL2_ENV_FILE_ARGS="$LVL1_ENV_FILE_ARGS"
				LVL2_ABSTRACT_CONTEXT='false'

				# Check for non-standard root level compose files

				# Extract first context part
				CONTEXT_FIRST="${CONTEXT%%.*}"
				CONTEXT_REST="$([ "$CONTEXT" = "$CONTEXT_FIRST" ] && echo '' || echo "${CONTEXT#*.}")"

				# Look for universal env files
				ENV_LOOK_FILES=$(look_env_files "$COMPOSE_DIR" '.-' "$CONTEXT_FIRST")
				ENV_LOOK_CODE=$?
				if [ "$ENV_LOOK_CODE" -eq 0 ]; then
					while read -r ENV_LOOK_FILE; do
						LVL2_ENV_FILE_ARGS="$LVL2_ENV_FILE_ARGS --env-file $ENV_LOOK_FILE"
					done <<-EOF
					$(echo "$ENV_LOOK_FILES")
					EOF
				fi

				# Look for context env files
				ENV_LOOK_FILES=$(look_env_files "$COMPOSE_DIR" '' "$CONTEXT_FIRST")
				ENV_LOOK_CODE=$?
				if [ "$ENV_LOOK_CODE" -eq 0 ]; then
					while read -r ENV_LOOK_FILE; do
						LVL2_ENV_FILE_ARGS="$LVL2_ENV_FILE_ARGS --env-file $ENV_LOOK_FILE"
					done <<-EOF
					$(echo "$ENV_LOOK_FILES")
					EOF
				fi

				# Look for root compose file
				COMPOSE_LOOK_FILE=$(look_compose_file "$COMPOSE_DIR" "$COMPOSE_PREFIX" "-$CONTEXT_FIRST" '' "$COMPOSE_EXTENSION")
				COMPOSE_LOOK_CODE=$?
				if [ "$COMPOSE_LOOK_CODE" -ne 1 ]; then
					# Compose file found
					LVL2_COMPOSE_FILE_ARGS="$LVL2_COMPOSE_FILE_ARGS -f $COMPOSE_LOOK_FILE"
					LVL2_ABSTRACT_CONTEXT=$([ "$COMPOSE_LOOK_CODE" -eq 0 ] && echo 'false' || echo 'true')
				fi

				# Parse context parts
				if [ -n "$CONTEXT_REST" ]; then

					LVL2_PREFIX=''

					while read -r CONTEXT_PART; do

						if [ -z "$CONTEXT_PART" ]; then
							# Skip empty parts
							continue
						fi

						LVL2_PREFIX="$LVL2_PREFIX.$CONTEXT_PART"

						# Look for universal env files
						ENV_LOOK_FILES=$(look_env_files "$COMPOSE_DIR" '.-' "$CONTEXT_PART")
						ENV_LOOK_CODE=$?
						if [ "$ENV_LOOK_CODE" -eq 0 ]; then
							while read -r ENV_LOOK_FILE; do
								LVL2_ENV_FILE_ARGS="$LVL2_ENV_FILE_ARGS --env-file $ENV_LOOK_FILE"
							done <<-EOF
							$(echo "$ENV_LOOK_FILES")
							EOF
						fi

						# Look for context env files
						ENV_LOOK_FILES=$(look_env_files "$COMPOSE_DIR" '' "$LVL2_PREFIX")
						ENV_LOOK_CODE=$?
						if [ "$ENV_LOOK_CODE" -eq 0 ]; then
							while read -r ENV_LOOK_FILE; do
								LVL2_ENV_FILE_ARGS="$LVL2_ENV_FILE_ARGS --env-file $ENV_LOOK_FILE"
							done <<-EOF
							$(echo "$ENV_LOOK_FILES")
							EOF
						fi

						# Look for context compose file
						COMPOSE_LOOK_FILE=$(look_compose_file "$COMPOSE_DIR" "$COMPOSE_PREFIX" "-$CONTEXT_FIRST" "$LVL2_PREFIX" "$COMPOSE_EXTENSION")
						COMPOSE_LOOK_CODE=$?
						if [ "$COMPOSE_LOOK_CODE" -ne 1 ]; then
							# Context compose file found
							LVL2_COMPOSE_FILE_ARGS="$LVL2_COMPOSE_FILE_ARGS -f $COMPOSE_LOOK_FILE"
							LVL2_ABSTRACT_CONTEXT=$([ "$COMPOSE_LOOK_CODE" -eq 0 ] && echo 'false' || echo 'true')

						else
							# Context compose file not found: invalidate LVL2 and break loop
							LVL2_COMPOSE_FILE_ARGS=''
							break
						fi

					done <<-EOF
					$(echo "$CONTEXT_REST" | tr '.' "\n")
					EOF

					if [ -n "$LVL2_COMPOSE_FILE_ARGS" ]; then
						# Context resolved: break loop
						break
					fi

				fi

			fi

			if [ -n "$LVL2_COMPOSE_FILE_ARGS" ]; then
				# Context resolved: break loop
				break
			fi

			if [ -n "$LVL1_COMPOSE_FILE_ARGS" ]; then

				# Check for special contexts

				if [ -z "$CONTEXT" ] || [ "$CONTEXT" = 'dev' ]; then

					# Look for standard override compose file
					COMPOSE_LOOK_FILE=$(look_compose_file "$COMPOSE_DIR" "$COMPOSE_PREFIX" '' 'override' "$COMPOSE_EXTENSION")
					COMPOSE_LOOK_CODE=$?
					if [ "$COMPOSE_LOOK_CODE" -ne 1 ]; then
						# Standard override compose file found
						LVL1_COMPOSE_FILE_ARGS="$LVL1_COMPOSE_FILE_ARGS -f $COMPOSE_LOOK_FILE"
						LVL1_ABSTRACT_CONTEXT=$([ "$COMPOSE_LOOK_CODE" -eq 0 ] && echo 'false' || echo 'true')
						break

					elif [ "$CONTEXT" = 'dev' ]; then
						# Standard override compose file not found, but was required: invalidate LVL1 & break loop
						LVL1_COMPOSE_FILE_ARGS=''
						break
					fi

				elif [ "$CONTEXT" != '.' ] && [ "$CONTEXT" != 'prod' ]; then
					# Neither "root" nor "prod" context
					# Context not resolved: invalidate LVL1 & break loop
					LVL1_COMPOSE_FILE_ARGS=''
					break
				fi

				if [ -n "$LVL1_COMPOSE_FILE_ARGS" ]; then
					# Context resolved: break loop
					break
				fi

			fi

		# End of while loop over compose file naming schemes
		done <<-EOF
		1
		2
		3
		4
		EOF

		if [ -n "$LVL2_COMPOSE_FILE_ARGS" ]; then
			# Context resolved: use LVL2 arguments & break loop
			COMPOSE_FILE_ARGS="$COMPOSE_FILE_ARGS $LVL2_COMPOSE_FILE_ARGS"
			ENV_FILE_ARGS="$ENV_FILE_ARGS $LVL2_ENV_FILE_ARGS"
			ABSTRACT_CONTEXT="$LVL2_ABSTRACT_CONTEXT"
			break

		elif [ -n "$LVL1_COMPOSE_FILE_ARGS" ]; then
			# Context resolved: use LVL1 arguments & break loop
			COMPOSE_FILE_ARGS="$COMPOSE_FILE_ARGS $LVL1_COMPOSE_FILE_ARGS"
			ENV_FILE_ARGS="$ENV_FILE_ARGS $LVL1_ENV_FILE_ARGS"
			ABSTRACT_CONTEXT="$LVL1_ABSTRACT_CONTEXT"
			break
		fi

		if [ -n "$COMPOSE_FILE_ARGS" ]; then
			# Context resolved: break loop
			break
		fi

	# End of while loop over directories
	done <<-EOF
	.
	./docker
	EOF

	if [ -z "$COMPOSE_FILE_ARGS" ]; then
		# Context not found, exit with error
		if [ -z "$CONTEXT" ]; then
			echo 'Error: Default context not found' >&2
		else
			echo "Error: Unknown context '$CONTEXT'" >&2
		fi
		exit 1
	fi

	# Context found, trim leading spaces
	COMPOSE_FILE_ARGS="$(echo "$COMPOSE_FILE_ARGS" | sed 's/^ *//')"
	ENV_FILE_ARGS="$(echo "$ENV_FILE_ARGS" | sed 's/^ *//')"

	# Unless force option is set,
	# If compose file arguments are abstract, exit with error
	if [ "$FORCE" = 'false' ] && [ "$ABSTRACT_CONTEXT" = 'true' ]; then
		echo 'Error: Abstract context found' >&2
		exit 1
	fi

fi

is_tty_session()
{
	# TTY session unless requested otherwise or stdin/stdout are not TTYs
	[ "${DEBIAN_FRONTEND}" != 'noninteractive' ] && [ -t 0 ] && [ -t 1 ]
}

handle_compose_presets_up()
{
	COMPOSE_UP_PULL="${COMPOSE_UP_PULL:-false}" # 'p'
	COMPOSE_UP_BUILD="${COMPOSE_UP_BUILD:-false}" # 'b'
	COMPOSE_UP_FORCE_RECREATE="${COMPOSE_UP_FORCE_RECREATE:-false}" # 'f'
	COMPOSE_UP_REMOVE_ORPHANS="${COMPOSE_UP_REMOVE_ORPHANS:-false}" # 'r'
	COMPOSE_UP_DETACHED="${COMPOSE_UP_DETACHED:-true}" # != 'a'

	# Iterate over COMPOSE_PRESET_SUFFIX characters
	i=1
	while [ $i -le ${#COMPOSE_PRESET_SUFFIX} ]; do
		COMPOSE_PRESET_CHAR=$(echo "$COMPOSE_PRESET_SUFFIX" | cut -c$i)
		case "$COMPOSE_PRESET_CHAR" in
			'p')
				COMPOSE_UP_PULL='true'
				;;
			'b')
				COMPOSE_UP_BUILD='true'
				;;
			'f')
				COMPOSE_UP_FORCE_RECREATE='true'
				;;
			'r')
				COMPOSE_UP_REMOVE_ORPHANS='true'
				;;
			'a')
				COMPOSE_UP_DETACHED='false'
				;;
			*)
				echo "Warning: Unknown compose up preset character '$COMPOSE_PRESET_CHAR'" >&2
				;;
		esac
		i=$((i + 1))
	done

	COMPOSE_ARGS='up'
	if [ "$COMPOSE_UP_PULL" = 'true' ]; then
		COMPOSE_ARGS="$COMPOSE_ARGS --pull always"
	fi
	if [ "$COMPOSE_UP_BUILD" = 'true' ]; then
		COMPOSE_ARGS="$COMPOSE_ARGS --build"
	fi
	if [ "$COMPOSE_UP_FORCE_RECREATE" = 'true' ]; then
		COMPOSE_ARGS="$COMPOSE_ARGS --force-recreate"
	fi
	if [ "$COMPOSE_UP_REMOVE_ORPHANS" = 'true' ]; then
		COMPOSE_ARGS="$COMPOSE_ARGS --remove-orphans"
	fi
	if [ "$COMPOSE_UP_DETACHED" = 'true' ]; then
		COMPOSE_ARGS="$COMPOSE_ARGS -d"
	fi
}

handle_compose_presets_build()
{
	COMPOSE_BUILD_DRY_RUN="${COMPOSE_BUILD_DRY_RUN:-false}" # 'n'
	COMPOSE_BUILD_PULL="${COMPOSE_BUILD_PULL:-false}" # 'p'
	COMPOSE_BUILD_NO_CACHE="${COMPOSE_BUILD_NO_CACHE:-false}" # 'f'

	# Iterate over COMPOSE_PRESET_SUFFIX characters
	i=1
	while [ $i -le ${#COMPOSE_PRESET_SUFFIX} ]; do
		COMPOSE_PRESET_CHAR=$(echo "$COMPOSE_PRESET_SUFFIX" | cut -c$i)
		case "$COMPOSE_PRESET_CHAR" in
			'n')
				COMPOSE_BUILD_DRY_RUN='true'
				;;
			'p')
				COMPOSE_BUILD_PULL='true'
				;;
			'f')
				COMPOSE_BUILD_NO_CACHE='true'
				;;
			*)
				echo "Warning: Unknown compose build preset character '$COMPOSE_PRESET_CHAR'" >&2
				;;
		esac
		i=$((i + 1))
	done

	COMPOSE_ARGS='build'
	if [ "$COMPOSE_BUILD_DRY_RUN" = 'true' ]; then
		COMPOSE_ARGS="$COMPOSE_ARGS --dry-run"
	fi
	if [ "$COMPOSE_BUILD_PULL" = 'true' ]; then
		COMPOSE_ARGS="$COMPOSE_ARGS --pull"
	fi
	if [ "$COMPOSE_BUILD_NO_CACHE" = 'true' ]; then
		COMPOSE_ARGS="$COMPOSE_ARGS --no-cache"
	fi
}

handle_compose_presets_watch()
{
	COMPOSE_WATCH_DRY_RUN="${COMPOSE_WATCH_DRY_RUN:-false}" # 'n'
	COMPOSE_WATCH_QUIET="${COMPOSE_WATCH_QUIET:-false}" # 'q'
	COMPOSE_WATCH_NO_UP="${COMPOSE_WATCH_NO_UP:-false}" # 'w'

	# Iterate over COMPOSE_PRESET_SUFFIX characters
	i=1
	while [ $i -le ${#COMPOSE_PRESET_SUFFIX} ]; do
		COMPOSE_PRESET_CHAR=$(echo "$COMPOSE_PRESET_SUFFIX" | cut -c$i)
		case "$COMPOSE_PRESET_CHAR" in
			'n')
				COMPOSE_WATCH_DRY_RUN='true'
				;;
			'q')
				COMPOSE_WATCH_QUIET='true'
				;;
			'w')
				COMPOSE_WATCH_NO_UP='true'
				;;
			*)
				echo "Warning: Unknown compose watch preset character '$COMPOSE_PRESET_CHAR'" >&2
				;;
		esac
		i=$((i + 1))
	done

	COMPOSE_ARGS='watch'
	if [ "$COMPOSE_WATCH_DRY_RUN" = 'true' ]; then
		COMPOSE_ARGS="$COMPOSE_ARGS --dry-run"
	fi
	if [ "$COMPOSE_WATCH_QUIET" = 'true' ]; then
		COMPOSE_ARGS="$COMPOSE_ARGS --quiet"
	fi
	if [ "$COMPOSE_WATCH_NO_UP" = 'true' ]; then
		COMPOSE_ARGS="$COMPOSE_ARGS --no-up"
	fi
}

handle_compose_presets_down()
{
	COMPOSE_DOWN_REMOVE_LEVEL="${COMPOSE_DOWN_REMOVE_LEVEL:-false}" # 'a', 'r', 'ra'
	COMPOSE_DOWN_VOLUMES="${COMPOSE_DOWN_VOLUMES:-false}" # 'v'

	# Iterate over COMPOSE_PRESET_SUFFIX characters
	i=1
	while [ $i -le ${#COMPOSE_PRESET_SUFFIX} ]; do
		COMPOSE_PRESET_CHAR=$(echo "${COMPOSE_PRESET_SUFFIX}" | cut -c$i)
		case "${COMPOSE_PRESET_CHAR}" in
			'a')
				[ "${COMPOSE_DOWN_REMOVE_LEVEL}" = 'false' ] && COMPOSE_DOWN_REMOVE_LEVEL='1'
				[ "${COMPOSE_DOWN_REMOVE_LEVEL}" = '2' ] && COMPOSE_DOWN_REMOVE_LEVEL='3'
				;;
			'r')
				{ [ "${COMPOSE_DOWN_REMOVE_LEVEL}" = 'false' ] || [ "${COMPOSE_DOWN_REMOVE_LEVEL}" = '1' ]; } && COMPOSE_DOWN_REMOVE_LEVEL='2'
				;;
			'v')
				COMPOSE_DOWN_VOLUMES='true'
				;;
			*)
				echo "Warning: Unknown compose down preset character '${COMPOSE_PRESET_CHAR}'" >&2
				;;
		esac
		i=$((i + 1))
	done

	COMPOSE_ARGS='down'
	if [ "${COMPOSE_DOWN_REMOVE_LEVEL}" = '1' ]; then
		COMPOSE_ARGS="${COMPOSE_ARGS} --remove-orphans"
	elif [ "${COMPOSE_DOWN_REMOVE_LEVEL}" = '2' ]; then
		COMPOSE_ARGS="${COMPOSE_ARGS} --remove-orphans --rmi local"
	elif [ "${COMPOSE_DOWN_REMOVE_LEVEL}" = '3' ]; then
		COMPOSE_ARGS="${COMPOSE_ARGS} --remove-orphans --rmi all"
	fi
	if [ "${COMPOSE_DOWN_VOLUMES}" = 'true' ]; then
		COMPOSE_ARGS="${COMPOSE_ARGS} -v" # --volumes
	fi
}

handle_compose_presets_run()
{
	COMPOSE_RUN_DRY_RUN="${COMPOSE_RUN_DRY_RUN:-false}" # 'n'
	COMPOSE_RUN_QUIET="${COMPOSE_RUN_QUIET:-false}" # 'q'
	COMPOSE_RUN_NO_DEPS="${COMPOSE_RUN_NO_DEPS:-false}" # 'o'
	COMPOSE_RUN_PULL="${COMPOSE_RUN_PULL:-false}"
	COMPOSE_RUN_BUILD="${COMPOSE_RUN_BUILD:-false}" # 'b'
	COMPOSE_RUN_WORKDIR="${COMPOSE_RUN_WORKDIR:-false}" # 'w'
	COMPOSE_RUN_ENTRYPOINT="${COMPOSE_RUN_ENTRYPOINT:-}"
	COMPOSE_RUN_INTERACTIVE="${COMPOSE_RUN_INTERACTIVE:-false}" # 'i'
	COMPOSE_RUN_TTY="${COMPOSE_RUN_TTY:-false}" # 't'
	COMPOSE_RUN_SERVICE_PORTS="${COMPOSE_RUN_SERVICE_PORTS:-false}" # 'p'
	COMPOSE_RUN_DETACHED="${COMPOSE_RUN_DETACHED:-false}" # 'd'
	COMPOSE_RUN_RM="${COMPOSE_RUN_RM:-true}" # != 'k'

	# Iterate over COMPOSE_PRESET_SUFFIX characters
	i=1
	while [ $i -le ${#COMPOSE_PRESET_SUFFIX} ]; do
		COMPOSE_PRESET_CHAR=$(echo "$COMPOSE_PRESET_SUFFIX" | cut -c$i)
		case "$COMPOSE_PRESET_CHAR" in
			'n')
				COMPOSE_RUN_DRY_RUN='true'
				;;
			'q')
				COMPOSE_RUN_QUIET='true'
				;;
			'o')
				COMPOSE_RUN_NO_DEPS='true'
				;;
			'b')
				COMPOSE_RUN_BUILD='true'
				;;
			'w')
				COMPOSE_RUN_WORKDIR='true'
				;;
			'i')
				COMPOSE_RUN_INTERACTIVE='true'
				;;
			't')
				COMPOSE_RUN_TTY='true'
				;;
			'p')
				COMPOSE_RUN_SERVICE_PORTS='true'
				;;
			'd')
				COMPOSE_RUN_DETACHED='true'
				;;
			'k')
				COMPOSE_RUN_RM=false
				;;
			*)
				echo "Warning: Unknown compose run preset character '$COMPOSE_PRESET_CHAR'" >&2
				;;
		esac
		i=$((i + 1))
	done

	COMPOSE_ARGS='run'
	if [ "$COMPOSE_RUN_DRY_RUN" = 'true' ]; then
		COMPOSE_ARGS="$COMPOSE_ARGS --dry-run"
	fi
	if [ "$COMPOSE_RUN_QUIET" = 'true' ]; then
		COMPOSE_ARGS="$COMPOSE_ARGS --quiet"
	fi
	if [ "$COMPOSE_RUN_NO_DEPS" = 'true' ]; then
		COMPOSE_ARGS="$COMPOSE_ARGS --no-deps"
	fi
	if [ "$COMPOSE_RUN_PULL" = 'true' ]; then
		COMPOSE_ARGS="$COMPOSE_ARGS --pull always"
	fi
	if [ "$COMPOSE_RUN_BUILD" = 'true' ]; then
		COMPOSE_ARGS="$COMPOSE_ARGS --build"
	fi
	if [ "$COMPOSE_RUN_WORKDIR" = 'true' ]; then
		COMPOSE_ARGS="$COMPOSE_ARGS"' -w /pwd -v $(pwd):/pwd'
	fi
	if [ -n "$COMPOSE_RUN_ENTRYPOINT" ]; then
		COMPOSE_ARGS="$COMPOSE_ARGS --entrypoint $COMPOSE_RUN_ENTRYPOINT"
	fi
	if [ "$COMPOSE_RUN_INTERACTIVE" = 'true' ]; then
		COMPOSE_ARGS="$COMPOSE_ARGS -i"
	fi
	if [ "$COMPOSE_RUN_TTY" = 'true' ]; then
		if ! is_tty_session; then
			COMPOSE_RUN_TTY='false'
		else
			COMPOSE_ARGS="$COMPOSE_ARGS -t"
		fi
	fi
	if [ "$COMPOSE_RUN_SERVICE_PORTS" = 'true' ]; then
		COMPOSE_ARGS="$COMPOSE_ARGS --service-ports"
	fi
	if [ "$COMPOSE_RUN_DETACHED" = 'true' ]; then
		COMPOSE_ARGS="$COMPOSE_ARGS -d"
	fi
	if [ "$COMPOSE_RUN_RM" = 'true' ]; then
		COMPOSE_ARGS="$COMPOSE_ARGS --rm"
	fi
}

handle_compose_presets_logs()
{
	COMPOSE_LOGS_DRY_RUN="${COMPOSE_LOGS_DRY_RUN:-false}" # 'n'
	COMPOSE_LOGS_TAIL="${COMPOSE_LOGS_TAIL:-100}" # != 'l'
	COMPOSE_LOGS_NO_COLOR="${COMPOSE_LOGS_NO_COLOR:-false}" # 'C'
	COMPOSE_LOGS_NO_LOG_PREFIX="${COMPOSE_LOGS_NO_LOG_PREFIX:-false}" # 's', 'P'
	COMPOSE_LOGS_TIMESTAMPS="${COMPOSE_LOGS_TIMESTAMPS:-false}" # 't'
	COMPOSE_LOGS_FOLLOW="${COMPOSE_LOGS_FOLLOW:-false}" # 'f'

	# Iterate over COMPOSE_PRESET_SUFFIX characters
	i=1
	while [ $i -le ${#COMPOSE_PRESET_SUFFIX} ]; do
		COMPOSE_PRESET_CHAR=$(echo "$COMPOSE_PRESET_SUFFIX" | cut -c$i)
		case "$COMPOSE_PRESET_CHAR" in
			'n')
				COMPOSE_LOGS_DRY_RUN='true'
				;;
			'l')
				COMPOSE_LOGS_TAIL=''
				;;
			'C')
				COMPOSE_LOGS_NO_COLOR='true'
				;;
			's'|'P')
				COMPOSE_LOGS_NO_LOG_PREFIX='true'
				;;
			't')
				COMPOSE_LOGS_TIMESTAMPS='true'
				;;
			'f')
				COMPOSE_LOGS_FOLLOW='true'
				;;
			*)
				echo "Warning: Unknown compose logs preset character '$COMPOSE_PRESET_CHAR'" >&2
				;;
		esac
		i=$((i + 1))
	done

	COMPOSE_ARGS='logs'
	if [ "$COMPOSE_LOGS_DRY_RUN" = 'true' ]; then
		COMPOSE_ARGS="$COMPOSE_ARGS --dry-run"
	fi
	if [ -n "$COMPOSE_LOGS_TAIL" ]; then
		COMPOSE_ARGS="$COMPOSE_ARGS -n $COMPOSE_LOGS_TAIL"
	fi
	if [ "$COMPOSE_LOGS_NO_COLOR" = 'true' ]; then
		COMPOSE_ARGS="$COMPOSE_ARGS --no-color"
	fi
	if [ "$COMPOSE_LOGS_NO_LOG_PREFIX" = 'true' ]; then
		COMPOSE_ARGS="$COMPOSE_ARGS --no-log-prefix"
	fi
	if [ "$COMPOSE_LOGS_TIMESTAMPS" = 'true' ]; then
		COMPOSE_ARGS="$COMPOSE_ARGS -t"
	fi
	if [ "$COMPOSE_LOGS_FOLLOW" = 'true' ]; then
		COMPOSE_ARGS="$COMPOSE_ARGS -f"
	fi
}

handle_compose_presets_rm()
{
	COMPOSE_RM_DRY_RUN="${COMPOSE_RM_DRY_RUN:-false}" # 'n'
	COMPOSE_RM_STOP="${COMPOSE_RM_STOP:-false}" # 's'
	COMPOSE_RM_FORCE="${COMPOSE_RM_FORCE:-false}" # 'f'
	COMPOSE_RM_VOLUMES="${COMPOSE_RM_VOLUMES:-false}" # 'v'

	# Iterate over COMPOSE_PRESET_SUFFIX characters
	i=1
	while [ $i -le ${#COMPOSE_PRESET_SUFFIX} ]; do
		COMPOSE_PRESET_CHAR=$(echo "$COMPOSE_PRESET_SUFFIX" | cut -c$i)
		case "$COMPOSE_PRESET_CHAR" in
			'n')
				COMPOSE_RM_DRY_RUN='true'
				;;
			's')
				COMPOSE_RM_STOP='true'
				;;
			'f')
				COMPOSE_RM_FORCE='true'
				;;
			'v')
				COMPOSE_RM_VOLUMES='true'
				;;
			*)
				echo "Warning: Unknown compose rm preset character '$COMPOSE_PRESET_CHAR'" >&2
				;;
		esac
		i=$((i + 1))
	done

	COMPOSE_ARGS='rm'
	if [ "$COMPOSE_RM_DRY_RUN" = 'true' ]; then
		COMPOSE_ARGS="$COMPOSE_ARGS --dry-run"
	fi
	if [ "$COMPOSE_RM_STOP" = 'true' ]; then
		COMPOSE_ARGS="$COMPOSE_ARGS --stop"
	fi
	if [ "$COMPOSE_RM_FORCE" = 'true' ]; then
		COMPOSE_ARGS="$COMPOSE_ARGS -f"
	fi
	if [ "$COMPOSE_RM_VOLUMES" = 'true' ]; then
		COMPOSE_ARGS="$COMPOSE_ARGS -v"
	fi
}

# Handle compose presets
COMPOSE_ARGS=''
if [ -n "$COMPOSE_PRESET" ]; then

	case "$COMPOSE_PRESET" in

		# Up presets
		'@u'*)
			COMPOSE_PRESET_SUFFIX="${COMPOSE_PRESET#@u}"
			handle_compose_presets_up
			;;

		# Watch presets
		'@w'*)
			COMPOSE_PRESET_SUFFIX="${COMPOSE_PRESET#@w}"
			handle_compose_presets_watch
			;;

		# Down presets
		'@d'*)
			COMPOSE_PRESET_SUFFIX="${COMPOSE_PRESET#@d}"
			handle_compose_presets_down
			;;

		# Rm presets
		'@rs'*)
			COMPOSE_PRESET_SUFFIX="${COMPOSE_PRESET#@rs}"
			COMPOSE_RM_STOP='true'
			handle_compose_presets_rm
			;;
		'@rf'*)
			COMPOSE_PRESET_SUFFIX="${COMPOSE_PRESET#@rf}"
			COMPOSE_RM_FORCE='true'
			handle_compose_presets_rm
			;;

		# Run presets
		'@r'*)
			COMPOSE_PRESET_SUFFIX="${COMPOSE_PRESET#@r}"
			COMPOSE_RUN_ENTRYPOINT=''
			handle_compose_presets_run
			;;
		'@sh'*)
			COMPOSE_PRESET_SUFFIX="${COMPOSE_PRESET#@sh}"
			COMPOSE_RUN_INTERACTIVE='true'
			COMPOSE_RUN_ENTRYPOINT='/bin/sh'
			handle_compose_presets_run
			;;
		'@$'*)
			COMPOSE_PRESET_SUFFIX="${COMPOSE_PRESET#@$}"
			COMPOSE_RUN_INTERACTIVE='true'
			COMPOSE_RUN_WORKDIR='true'
			COMPOSE_RUN_ENTRYPOINT='/bin/sh'
			handle_compose_presets_run
			;;
		'$'*)
			COMPOSE_PRESET_SUFFIX="${COMPOSE_PRESET#$}"
			COMPOSE_RUN_INTERACTIVE='true'
			COMPOSE_RUN_WORKDIR='true'
			COMPOSE_RUN_ENTRYPOINT='/bin/sh'
			handle_compose_presets_run
			;;
		'@ash'*)
			COMPOSE_PRESET_SUFFIX="${COMPOSE_PRESET#@ash}"
			COMPOSE_RUN_INTERACTIVE='true'
			COMPOSE_RUN_ENTRYPOINT='/bin/ash'
			handle_compose_presets_run
			;;
		'@bash'*)
			COMPOSE_PRESET_SUFFIX="${COMPOSE_PRESET#@bash}"
			COMPOSE_RUN_INTERACTIVE='true'
			COMPOSE_RUN_ENTRYPOINT='/bin/bash'
			handle_compose_presets_run
			;;
		'@zsh'*)
			COMPOSE_PRESET_SUFFIX="${COMPOSE_PRESET#@zsh}"
			COMPOSE_RUN_INTERACTIVE='true'
			COMPOSE_RUN_ENTRYPOINT='/bin/zsh'
			handle_compose_presets_run
			;;

		# Build presets
		'@b'*)
			COMPOSE_PRESET_SUFFIX="${COMPOSE_PRESET#@b}"
			handle_compose_presets_build
			;;

		# Logs presets
		'@l'*)
			COMPOSE_PRESET_SUFFIX="${COMPOSE_PRESET#@l}"
			handle_compose_presets_logs
			;;

		# Ps presets
		'@p')
			COMPOSE_ARGS='ps'
			;;
		'@pa')
			COMPOSE_ARGS='ps -a'
			;;

		# Push presets
		'@pu')
			COMPOSE_ARGS='push'
			;;

		# Pull presets
		'@pl')
			COMPOSE_ARGS='pull'
			;;

	esac

	if [ -z "$COMPOSE_ARGS" ]; then
		echo "Error: Unknown compose preset '$COMPOSE_PRESET'" >&2
		exit 1
	fi

fi

if [ -z "$COMPOSE_ARGS" ] && [ -z "$COMMAND_ARGS" ]; then
	# No command preset or arguments, use the default compose command arguments
	COMPOSE_ARGS='up -d'
fi

# Format variables with leading space
if [ -n "$COMPOSE_FILE_ARGS" ]; then
	COMPOSE_FILE_ARGS=" $COMPOSE_FILE_ARGS"
fi
if [ -n "$ENV_FILE_ARGS" ]; then
	ENV_FILE_ARGS=" $ENV_FILE_ARGS"
fi
if [ -n "$COMPOSE_ARGS" ]; then
	COMPOSE_ARGS=" $COMPOSE_ARGS"
fi
if [ -n "$COMMAND_ARGS" ]; then
	COMMAND_ARGS=" $COMMAND_ARGS"
fi

if [ "$QUIET" = 'false' ]; then
	# Print docker compose command
	if [ "$DOCKERC_FIRST_NEWLINE" != 'false' ]; then
		echo ''
	fi
	echo "> docker compose${COMPOSE_FILE_ARGS}${ENV_FILE_ARGS}${COMPOSE_ARGS}${COMMAND_ARGS}"
	echo ''
fi

if [ "$DRY_RUN" = 'false' ]; then
	# Run docker compose command
	exec sh -c "docker compose${COMPOSE_FILE_ARGS}${ENV_FILE_ARGS}${COMPOSE_ARGS}${COMMAND_ARGS}"
fi