rwx/sh/core/code.sh

# ╭──────╮
# │ code │
# ╰──────╯

# ╭──────┬───────────╮
# │ code │ variables │
# ╰──────┴───────────╯

# main modules code cache
rwx_code_cache_main=""
# user modules code cache
rwx_code_cache_user=""
# main modules names
rwx_code_modules_main=""
# user modules names
rwx_code_modules_user=""
# user root directory of the project
rwx_code_root="${HOME}/${RWX_MAIN_NAME}"

# cache of all sourced code modules
_rwx_code=""
# cache for the parsing awk script
_rwx_code_awk="$(cat "${rwx_main_root}/core/code.awk")"
# cache for code aliases
_rwx_code_aliases=""
# cache for code aliases functions
_rwx_code_aliases_functions=""
# cache for code binaries
_rwx_code_binaries=""
# cache for code commands
_rwx_code_commands=""
# cache for code commands functions
_rwx_code_commands_functions=""
# cache for code constants
_rwx_code_constants=""
# cache for code functions
_rwx_code_functions=""
# cache for code variables
_rwx_code_variables=""

# ╭──────┬───────╮
# │ code │ cache │
# ╰──────┴───────╯

# output all cached code
rwx_code_cache() {
	rwx_code_cache_main
	rwx_code_cache_user
}

# output cached main code
rwx_code_cache_main() {
	echo "${rwx_code_cache_main}"
}

# output cached user code
rwx_code_cache_user() {
	echo "${rwx_code_cache_user}"
}

# ╭──────┬──────╮
# │ code │ help │
# ╰──────┴──────╯

# output help message
rwx_code_help() {
	rwx_log "" \
		"rwx_… = functions" \
		" a__… = aliases" \
		" u__… = user"
}

# ╭──────┬─────────╮
# │ code │ install │
# ╰──────┴─────────╯

#/ rwx_install
rwx_code_install() {
	local target="${1}"
	local command file name root
	# code
	if [ -n "${target}" ]; then
		root="${target}${rwx_main_root}"
		rwx_remove "${root}"
		cp --recursive "${rwx_main_root}" "${root}"
	fi
	# commands
	root="${target}/usr/local/bin"
	name="${RWX_MAIN_NAME}.${RWX_MAIN_EXTENSION}"
	file="${root}/${name}"
	rwx_remove "${file}"
	rwx_link "${file}" "${rwx_main_path}"
	while IFS= read -r command; do
		file="${root}/${command}"
		rwx_remove "${file}"
		rwx_link "${file}" "${name}"
	done <<EOF
${_rwx_code_commands}
EOF
	# sh
	file="${target}/etc/profile.d/${RWX_MAIN_NAME}.${RWX_MAIN_EXTENSION}"
	rwx_remove "${file}"
	rwx_file_write "${file}" "\
export ENV=\"${rwx_main_path}\"
"
	# bash
	file="${target}/etc/bash.bashrc"
	rwx_remove "${file}"
	rwx_link "${file}" "${rwx_main_path}"
}

# ╭──────┬───────╮
# │ code │ parts │
# ╰──────┴───────╯

# show the cached code
#= rc
rwx_code() {
	echo "${_rwx_code}"
}

# show the cached awk script
rwx_code_awk() {
	echo "${_rwx_code_awk}"
}

# show the cached aliases
#= rca
rwx_code_aliases() {
	echo "${_rwx_code_aliases}"
}

# find command function
rwx_code_command_function() {
	local name="${1}"
	[ -n "${name}" ] || return
	rwx_code |
		awk \
			-v action="command function" \
			-v target="${name}" \
			"${_rwx_code_awk}"
}

# show the cached aliases and functions
#= rcaf
rwx_code_aliases_functions() {
	echo "${_rwx_code_aliases_functions}"
}

# show the cached binaries
rwx_code_binaries() {
	echo "${_rwx_code_binaries}"
}

# show the cached commands
rwx_code_commands() {
	echo "${_rwx_code_commands}"
}

# show the cached commands and functions
#= rccf
rwx_code_commands_functions() {
	echo "${_rwx_code_commands_functions}"
}

# show the cached constants
#= rcc
rwx_code_constants() {
	echo "${_rwx_code_constants}"
}

# show the cached functions
#= rcf
rwx_code_functions() {
	echo "${_rwx_code_functions}"
}

# show all the cached main modules
#= rcm
rwx_code_modules() {
	rwx_code_modules_main
	rwx_code_modules_user
}

# show the cached main modules
#= rcmm
rwx_code_modules_main() {
	echo "${rwx_code_modules_main}"
}

# show the cached user modules
#= rcmu
rwx_code_modules_user() {
	echo "${rwx_code_modules_user}"
}

# show the cached variables
#= rcv
rwx_code_variables() {
	echo "${_rwx_code_variables}"
}

# ╭──────┬───────╮
# │ code │ parse │
# ╰──────┴───────╯

# check source code
rwx_code_check() {
	# check format
	rwx_log
	rwx_shfmt "${rwx_main_root}"
	# check syntax
	rwx_log
	rwx_shellcheck "${rwx_main_root}"
}

# fetch matching doc for given name
#= rcd
rwx_code_doc() {
	local name="${1}"
	[ -n "${name}" ] || return
	rwx_code |
		awk \
			-v action="doc" \
			-v target="${name}" \
			"${_rwx_code_awk}"
}

rwx_code_load() {
	local line
	# parse aliases functions
	_rwx_code_aliases_functions="$(rwx_code_parse "aliases functions")"
	while IFS= read -r line; do
		eval "${line}"
	done <<EOF
${_rwx_code_aliases_functions}
EOF
	# parse commands functions
	_rwx_code_commands_functions="$(rwx_code_parse "commands functions")"
	while IFS= read -r line; do
		eval "${line}"
	done <<EOF
${_rwx_code_commands_functions}
EOF
	# parse aliases
	_rwx_code_aliases="$(rwx_code_parse "aliases")"
	# parse binaries
	_rwx_code_binaries="$(rwx_code_parse "binaries")"
	# parse commands
	_rwx_code_commands="$(rwx_code_parse "commands")"
	# parse constants
	_rwx_code_constants="$(rwx_code_parse "constants")"
	# parse functions
	_rwx_code_functions="$(rwx_code_parse "functions")"
	# parse variables
	_rwx_code_variables="$(rwx_code_parse "variables")"
}

rwx_code_parse() {
	local action="${1}"
	rwx_code |
		awk \
			-v action="${action}" \
			"${_rwx_code_awk}"
}

# ╭──────┬──────╮
# │ code │ main │
# ╰──────┴──────╯

rwx_code_main() {
	local modules_main="${1}"
	local module
	rwx_code_modules_main="${modules_main}"
	# find user modules
	rwx_code_modules_user="$(rwx_main_find "${rwx_code_root}")"
	# source user modules
	while IFS= read -r module; do
		# shellcheck disable=SC1090
		. "${rwx_code_root}/${module}.${RWX_MAIN_EXTENSION}"
	done <<EOF
${rwx_code_modules_user}
EOF
	# cache main modules
	while IFS= read -r module; do
		# cache main module
		_rwx_code="${_rwx_code}#. ${module}
$(cat "${rwx_main_root}/${module}.${RWX_MAIN_EXTENSION}")
"
	done <<EOF
${modules_main}
EOF
	# cache user modules
	while IFS= read -r module; do
		# cache user module
		_rwx_code="${_rwx_code}#. ${module}
$(cat "${rwx_code_root}/${module}.${RWX_MAIN_EXTENSION}")
"
	done <<EOF
${rwx_code_modules_user}
EOF
	# load code cache
	rwx_code_load
	# set command
	local command
	# command name used to run
	# (stripped from hyphen interactive flag)
	command="$(basename "${0}" | sed "s|^-||")"
	case "${command}" in
	"bash" | "dash" | "sh") unset command ;;
	*) ;;
	esac
	# context / shell
	if rwx_shell_interactive; then
		# display help
		rwx_code_help
	# context / command
	else
		local function
		# find the matching function
		function="$(rwx_code_command_function "${command}")"
		if [ -n "${function}" ]; then
			"${function}" "${@}"
		fi
	fi
}