main@bashbox%bashbox ()

{

if test "${BASH_VERSINFO[0]}${BASH_VERSINFO[1]}" -lt 43; then

{

printf '[!!!] \033[1;31m%s\033[0m[%s]: %s\n' ERROR 1 "At least bash 4.3 is required to run this." "Please upgrade bash or use the correct interpreter." "If you're on MacOS, you can install latest bash using brew or nix." 1>&2;

exit 1

};

fi;

function process::self::exit ()

{

local _r=$?;

( kill -USR1 "$___self_PID" 2> /dev/null || : ) & exit $_r

};

function process::self::forcekill ()

{

kill -9 "$___self_PID" 2> /dev/null

};

function log::error ()

{

local _retcode="${2:-$?}";

local _exception_line="$1";

local _source="${BB_ERR_SOURCE:-"${BASH_SOURCE[-1]}"}";

function ___errmsg ()

{

printf '[!!!] \033[1;31m%s\033[0m[%s]: %s\n' ERROR "$_retcode" "$@" 1>&2

};

if [[ ! "$_exception_line" == \(*\) ]]; then

{

___errmsg "${_source##*/}[${BASH_LINENO[0]}]: ${BB_ERR_MSG:-"$_exception_line"}";

if test -v BB_ERR_MSG; then

{

printf "STACK TRACE: (TOKEN: %s)\n" "$_exception_line" 1>&2;

local -i _frame=0;

local _treestack='|-';

local _line _caller _source;

while read -r _line _caller _source < <(caller "$_frame"); do

{

printf '%s >> %s\n' "$_treestack ${_caller}" "${_source##*/}:${_line}" 1>&2;

_frame+=1;

_treestack+='-'

};

done

};

fi

};

else

{

___errmsg "${_source##*/}[${BASH_LINENO[0]}]: SUBSHELL EXITED WITH NON-ZERO STATUS"

};

fi;

return "$_retcode"

};

\command unalias -a || true;

set -eEuT -o pipefail;

shopt -sq inherit_errexit expand_aliases nullglob;

trap 'exit' USR1;

trap 'BB_ERR_MSG="UNCAUGHT EXCEPTION" log::error "$BASH_COMMAND" || process::self::exit' ERR;

___self="$0";

___self_PID="$$";

___self_DIR="$(cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd)";

___MAIN_FUNCNAME='main@bashbox%bashbox';

___self_NAME="BashBox";

___self_CODENAME="bashbox";

___self_AUTHORS=("AXON <[email protected]>");

___self_VERSION="0.4.1";

___self_DEPENDENCIES=(https://github.com/bashbox/std.git::15dc26b argbash::0.1.1);

___self_REPOSITORY="https://github.com/bashbox/bashbox";

___self_BASHBOX_COMPAT="0.3.9~";

function bashbox::build::after ()

{

cp "$_target_workfile" "$_arg_path/$CODENAME";

chmod +x "$_arg_path/$CODENAME"

};

function pkgfun ()

{

( echo "$@" )

};

function bb_bootstrap_header ()

{

if test "${BASH_VERSINFO[0]}${BASH_VERSINFO[1]}" -lt 43; then

{

printf '[!!!] \033[1;31m%s\033[0m[%s]: %s\n' ERROR 1 "At least bash 4.3 is required to run this." "Please upgrade bash or use the correct interpreter." "If you're on MacOS, you can install latest bash using brew or nix." 1>&2;

exit 1

};

fi;

function process::self::exit ()

{

local _r=$?;

( kill -USR1 "$___self_PID" 2> /dev/null || : ) & exit $_r

};

function process::self::forcekill ()

{

kill -9 "$___self_PID" 2> /dev/null

};

function log::error ()

{

local _retcode="${2:-$?}";

local _exception_line="$1";

local _source="${BB_ERR_SOURCE:-"${BASH_SOURCE[-1]}"}";

function ___errmsg ()

{

printf '[!!!] \033[1;31m%s\033[0m[%s]: %s\n' ERROR "$_retcode" "$@" 1>&2

};

if [[ ! "$_exception_line" == \(*\) ]]; then

{

___errmsg "${_source##*/}[${BASH_LINENO[0]}]: ${BB_ERR_MSG:-"$_exception_line"}";

if test -v BB_ERR_MSG; then

{

printf "STACK TRACE: (TOKEN: %s)\n" "$_exception_line" 1>&2;

local -i _frame=0;

local _treestack='|-';

local _line _caller _source;

while read -r _line _caller _source < <(caller "$_frame"); do

{

printf '%s >> %s\n' "$_treestack ${_caller}" "${_source##*/}:${_line}" 1>&2;

_frame+=1;

_treestack+='-'

};

done

};

fi

};

else

{

___errmsg "${_source##*/}[${BASH_LINENO[0]}]: SUBSHELL EXITED WITH NON-ZERO STATUS"

};

fi;

return "$_retcode"

};

\command unalias -a || true;

set -eEuT -o pipefail;

shopt -sq inherit_errexit expand_aliases nullglob;

trap 'exit' USR1;

trap 'BB_ERR_MSG="UNCAUGHT EXCEPTION" log::error "$BASH_COMMAND" || process::self::exit' ERR

};

unset -f bashbox::build::before bashbox::build::after bashbox::run::before bashbox::run::after;

readonly _bashbox_meta_name="Bashbox.sh";

readonly _src_dir_name="src";

readonly _bashbox_home="${HOME:-"${0%/*}"}/.bashbox" && mkdir -p "$_bashbox_home";

readonly _bashbox_registrydir="$_bashbox_home/registry" && mkdir -p "$_bashbox_registrydir";

readonly _bashbox_bindir="$_bashbox_home/bin" && mkdir -p "$_bashbox_bindir";

readonly _bashbox_posix_envfile="$_bashbox_home/env";

readonly _bashbox_fish_envfile="$_bashbox_home/env.fish";

readonly _bashbox_compat_var_name="BASHBOX_COMPAT";

readonly SUBCOMMANDS_DESC=("" "Create a new bashbox project" "Compile a bashbox project" "Cleanup target/ directories" "Install a bashbox project from repo" "Install bashbox into PATH");

_var_exports=(_bashbox_registrydir);

for _var in "${_var_exports[@]}";

do

{

export "$_var"

};

done;

( for _envfile in "$_bashbox_posix_envfile" "$_bashbox_fish_envfile";

do

{

if test ! -e "$_envfile"; then

{

case "$_envfile" in

"$_bashbox_posix_envfile")

echo "export PATH=\"$_bashbox_bindir:\$PATH\"" > "$_envfile"

;;

"$_bashbox_fish_envfile")

echo "set PATH \"$_bashbox_bindir\" \"\$PATH\" && export PATH" > "$_envfile"

;;

esac

};

fi

};

done ) & function log::info ()

{

echo -e "[%%%] \033[1;37minfo\033[0m: $@"

};

function log::warn ()

{

echo -e "[***] \033[1;37mwarn\033[0m: $@"

};

function println::helpgen ()

{

_positionals=();

_arg_helpname=;

_arg_short_desc=;

_arg_usage=;

_arg_options_desc=;

_arg_subcommands=;

_arg_examples=;

_arg_footer_msg=;

function print_help ()

{

printf '%s\n' "<The general help message of my script>";

printf 'Usage: %s [--short-desc <arg>] [--usage <arg>] [--options-desc <arg>] [--subcommands <arg>] [--examples <arg>] [--footer-msg <arg>] [-h|--help] <helpname>\n' "$0";

printf '\t%s\n' "-h, --help: Prints help"

};

function parse_commandline ()

{

_positionals_count=0;

while test $# -gt 0; do

_key="$1";

case "$_key" in

--short-desc)

test $# -lt 2 && println::error "Missing value for the optional argument '$_key'." 1;

_arg_short_desc="$2";

shift

;;

--short-desc=*)

_arg_short_desc="${_key##--short-desc=}"

;;

--usage)

test $# -lt 2 && println::error "Missing value for the optional argument '$_key'." 1;

_arg_usage="$2";

shift

;;

--usage=*)

_arg_usage="${_key##--usage=}"

;;

--options-desc)

test $# -lt 2 && println::error "Missing value for the optional argument '$_key'." 1;

_arg_options_desc="$2";

shift

;;

--options-desc=*)

_arg_options_desc="${_key##--options-desc=}"

;;

--subcommands)

test $# -lt 2 && println::error "Missing value for the optional argument '$_key'." 1;

_arg_subcommands="$2";

shift

;;

--subcommands=*)

_arg_subcommands="${_key##--subcommands=}"

;;

--examples)

test $# -lt 2 && println::error "Missing value for the optional argument '$_key'." 1;

_arg_examples="$2";

shift

;;

--examples=*)

_arg_examples="${_key##--examples=}"

;;

--footer-msg)

test $# -lt 2 && println::error "Missing value for the optional argument '$_key'." 1;

_arg_footer_msg="$2";

shift

;;

--footer-msg=*)

_arg_footer_msg="${_key##--footer-msg=}"

;;

-h | --help)

print_help;

exit 0

;;

-h*)

print_help;

exit 0

;;

*)

_last_positional="$1";

_positionals+=("$_last_positional");

_positionals_count=$((_positionals_count + 1))

;;

esac;

shift;

done

};

function handle_passed_args_count ()

{

local _required_args_string="'helpname'";

test "${_positionals_count}" -ge 1 || _PRINT_HELP=yes println::error "FATAL ERROR: Not enough positional arguments - we require exactly 1 (namely: $_required_args_string), but got only ${_positionals_count}." 1;

test "${_positionals_count}" -le 1 || _PRINT_HELP=yes println::error "FATAL ERROR: There were spurious positional arguments --- we expect exactly 1 (namely: $_required_args_string), but got ${_positionals_count} (the last one was: '${_last_positional}')." 1

};

function assign_positional_args ()

{

local _positional_name _shift_for=$1;

_positional_names="_arg_helpname ";

shift "$_shift_for";

for _positional_name in ${_positional_names};

do

test $# -gt 0 || break;

eval "$_positional_name=\${1}" || println::error "Error during argument parsing." 1;

shift;

done

};

parse_commandline "$@";

handle_passed_args_count;

assign_positional_args 1 "${_positionals[@]}";

echo -e "${_arg_helpname}\c";

if test -n "$_arg_short_desc"; then

echo -e " - $_arg_short_desc\n";

else

echo;

fi;

if test -n "$_arg_usage"; then

echo -e "USAGE:";

while read -r line; do

echo -e " $line";

done < <(echo "$_arg_usage");

echo;

fi;

for child in "$_arg_options_desc" "$_arg_subcommands";

do

if test -n "$child"; then

local _startString _endString gapVar;

_startString="$(sed 's|<^>.*||g' <<<"${child}")";

_endString="$(sed 's|.*<^>||g' <<<"${child}")";

mapfile -t _startString < <(echo "$_startString");

mapfile -t _endString < <(echo "$_endString");

local i=0;

local firstChild=false;

! "$firstChild" && echo -e "OPTIONS:" || echo -e 'SUBCOMMANDS:' && firstChild=true;

for line in "${_startString[@]}";

do

gapVar="$(

echo -e " $line${gapVar}${_endString[$i]}";

i=$((i+1));

done;

echo;

fi;

done;

if test -n "$_arg_examples"; then

echo -e "EXAMPLES:";

while read -r line; do

echo -e " $line";

done < <(echo "$_arg_examples");

echo;

fi;

if test -n "$_arg_footer_msg"; then

echo -e "$_arg_footer_msg\n";

fi

};

readonly RC='\033[0m' RED='\033[0;31m' BRED='\033[1;31m' GRAY='\033[1;30m';

readonly BLUE='\033[0;34m' BBLUE='\033[1;34m' CYAN='\033[0;34m' BCYAN='\033[1;34m';

readonly WHITE='\033[1;37m' GREEN='\033[0;32m' BGREEN='\033[1;32m' YELLOW='\033[1;33m';

readonly PURPLE='\033[0;35m' BPURPLE='\033[1;35m' ORANGE='\033[0;33m';

function io::file::check_newline ()

{

local _input="$1";

if ! [[ $(tail -c1 "$_input" | wc -l) -gt 0 ]]; then

{

echo >> "$_input"

};

fi

};

function get_temp::file ()

{

if test -w /tmp; then

{

printf '/tmp/%s\n' ".$$_$((RANDOM * RANDOM))"

};

else

if res="$(mktemp -u)"; then

{

printf '%s\n' "$res" && unset res

};

else

{

return 1

};

fi;

fi

};

function get_temp::dir ()

{

if test -w /tmp; then

{

printf '%s\n' '/tmp'

};

else

if res="$(mktemp -u)"; then

{

printf '%s\n' "${res%/*}" && unset res

};

else

{

return 1

};

fi;

fi

};

function trap::stack_name ()

{

local sig=${1//[^a-zA-Z0-9]/_};

printf '__trap_stack_%s\n' "$sig"

};

function trap::extract ()

{

printf '%s\n' "${3:-}"

};

function trap::get ()

{

eval "trap::extract $(trap -p "$1")"

};

function trap::push ()

{

local new_trap="$1" && shift;

local sig;

for sig in $*;

do

local stack_name="$(trap::stack_name "$sig")";

local old_trap=$(trap::get "$sig");

if test ! -v "$stack_name"; then

{

eval "${stack_name}=()"

};

fi;

eval "${stack_name}"'[${#'"${stack_name}"'[@]}]=${old_trap:-}';

trap "${new_trap}" "$sig";

done

};

function trap::append ()

{

local new_trap="$1" && shift;

local sig;

for sig in $*;

do

if [[ -z "$(trap::get "$sig")" ]]; then

trap::push "$new_trap" "$sig";

else

trap::push "$(trap::get $sig) ; $new_trap" "$sig";

fi;

done

};

function lockfile ()

{

local name="$1";

local lock_file;

lock_file="$(get_temp::dir)/.${name}.lock";

if test -e "$lock_file"; then

{

if ! {

kill -0 "$(< "$lock_file")"

}; then

{

rm "$lock_file" 2> /dev/null || :

};

fi;

log::info "Awaiting for another ${name} job to finish"

};

fi;

for _ in {1..5};

do

{

while {

kill -0 "$(< "$lock_file")"

}; do

{

sleep 0.5

};

done

};

done;

until ( set -o noclobber && printf '%s\n' "$$" > "$lock_file" ); do

{

sleep 0.5

};

done;

trap::append "rm -f '$lock_file' 2>/dev/null" ${SIGNALS:-EXIT}

} 2> /dev/null;

function sleep ()

{

[[ -n "${_snore_fd:-}" ]] || {

exec {_snore_fd}<> <(:)

} 2> /dev/null || {

local fifo;

fifo=$(mktemp -u);

mkfifo -m 700 "$fifo";

exec {_snore_fd}<> "$fifo";

rm "$fifo"

};

IFS='' read ${1:+-t "$1"} -u $_snore_fd || :

};

function begins_with_short_option ()

{

local first_option all_short_options='h';

first_option="${1:0:1}";

test "$all_short_options" = "${all_short_options/$first_option/}" && return 1 || return 0

};

function subcommand::new ()

{

_positionals=();

_arg_path=;

_arg_codename=;

function print_help ()

{

println::helpgen "${_self_name^^}-${_subcommand_argv^^}" --short-desc "${SUBCOMMANDS_DESC[1]}" --usage "${_self_name} ${_subcommand_argv} [OPTIONAL-OPTIONS] <path>" --options-desc "-c, --codename<^>Avoid directory-as-codename

-h, --help<^>Prints this help information" --examples "### The basic way:

};

function parse_commandline ()

{

_positionals_count=0;

while test $# -gt 0; do

_key="$1";

case "$_key" in

--codename | -c)

test $# -lt 2 && log::error "Missing value for the optional argument '$_key'." 1 || exit;

_arg_codename="$2";

shift

;;

--codename=*)

_arg_codename="${_key##--codename=}"

;;

-h | --help)

print_help;

exit 0

;;

-h*)

print_help;

exit 0

;;

*)

_last_positional="$1";

_positionals+=("$_last_positional");

_positionals_count=$((_positionals_count + 1))

;;

esac;

shift;

done

};

function handle_passed_args_count ()

{

local _required_args_string="'path'";

test "${_positionals_count}" -ge 1 || log::error "Not enough positional arguments - we require exactly 1 (namely: $_required_args_string), but got only ${_positionals_count}." 1 || exit;

test "${_positionals_count}" -le 1 || log::error "There were spurious positional arguments --- we expect exactly 1 (namely: $_required_args_string), but got ${_positionals_count} (the last one was: '${_last_positional}')." 1 || exit

};

function assign_positional_args ()

{

local _positional_name _shift_for=$1;

_positional_names="_arg_path ";

shift "$_shift_for";

for _positional_name in ${_positional_names};

do

test $# -gt 0 || break;

eval "$_positional_name=\${1}" || log::error "Error during argument parsing." 1 || exit;

shift;

done

};

parse_commandline "$@";

handle_passed_args_count;

assign_positional_args 1 "${_positionals[@]}";

_path_codename="${_arg_path##*/}";

: "${_arg_codename:="$_path_codename"}";

_arg_codename="$(tr -d '[:space:]' <<<"${_arg_codename,,}")";

if test -e "$_arg_path"; then

log::error "Destination \`$_arg_path\` already exists.\n\t You may either remove that project dir or use a different path for setup." 1 || exit;

fi;

log::info "Setting up project at \`$_arg_path\`";

mkdir -p "$_arg_path" || log::error "Failed to initialize the project directory" 1 || exit;

mkdir -p "$_arg_path/$_src_dir_name";

cat <<'EOF' > "$_arg_path/$_src_dir_name/main.sh"

cat <<EOF > "$_arg_path/$_bashbox_meta_name"

log::info "Initializing git version control for your project";

if command -v git > /dev/null; then

git init "$_arg_path" > /dev/null || {

_r=$?;

rm -r "$_arg_path";

log::error "Failed to initialize git at \`$_arg_path\`" $_r || exit

};

echo -e '/target' > "$_arg_path/.gitignore";

else

rm -r "$_arg_path";

log::error "git does not seem to be available, please install it" 1 || exit;

fi

};

function subcommand::install ()

{

function trim_leading_trailing ()

{

local _stream="${1:-}";

local _stdin;

if test -z "${_stream}"; then

{

read -r _stdin;

_stream="$_stdin"

};

fi;

_stream="${_stream#"${_stream%%[![:space:]]*}"}";

_stream="${_stream%"${_stream##*[![:space:]]}"}";

printf '%s\n' "$_stream"

};

function trim_string ()

{

: "${1#"${1%%[![:space:]]*}"}";

: "${_%"${_##*[![:space:]]}"}";

printf '%s\n' "$_"

};

function trim_all ()

{

set -f;

set -- $*;

printf '%s\n' "$*";

set +f

};

function trim_quotes ()

{

: "${1//\'}";

printf '%s\n' "${_//\"}"

};

function string::matches ()

{

local _string _match _arg;

local _print=false;

for _arg in "${@}";

do

{

case "$_arg" in

--print | -p)

shift;

_print=true

;;

esac

};

done;

if [[ $1 =~ $2 ]]; then

{

if [ "$_print" == "true" ]; then

{

echo "${BASH_REMATCH[@]}"

};

fi;

return 0

};

else

{

return 1

};

fi

};

lockfile "install";

local _arg_force=off;

local _arg_syncmeta=off;

local _arg_eval;

for _arg_eval in "force" "syncmeta";

do

{

case "$@" in

*${_arg_eval}*)

eval "_arg_${_arg_eval}=on"

;;

esac

};

done;

unset _arg_eval;

local _github_api_root _registry_meta_file;

readonly _registry_meta_file="${_bashbox_home}/registry.meta" && touch "$_registry_meta_file";

readonly _github_api_root="https://api.github.com";

function box::syncmeta ()

{

local _registry_meta_url _registry_lastsync_file;

readonly _registry_meta_url="https://raw.githubusercontent.com/bashbox/registry/main/registry.meta";

readonly _registry_lastsync_file="${_bashbox_home}/.registry.lastsync" && touch "$_registry_lastsync_file";

local _user_repo _check_file _branch;

readonly _user_repo="bashbox/registry";

readonly _check_file="registry.meta";

readonly _branch="main";

local _lock_file="$_bashbox_home/.registry.lastdate";

local _date && _date="$(date '+%d-%m')";

if test "$_arg_offline" == "off"; then

{

touch "$_lock_file";

if [ "$_arg_syncmeta" == "on" ] || [ "$(< "$_lock_file")" != "$_date" ]; then

{

echo "$_date" > "$_lock_file";

log::info "Syncing repository metadata";

local _local_sha _remote_sha;

_local_sha="$(< "$_registry_lastsync_file")";

_remote_sha="$(curl --silent "${_github_api_root}/repos/${_user_repo}/contents/${_check_file}?ref=${_branch}" | head -n4 | grep -I '"sha":' | sed -E 's/.*"([^"]+)".*/\1/')" || return 0;

readonly _local_sha _remote_sha;

if test "$_arg_syncmeta" == "on" || test "$_local_sha" != "$_remote_sha"; then

{

log::info "Updating registry.meta";

curl --silent -o "$_registry_meta_file" -L "$_registry_meta_url";

echo "$_remote_sha" > "$_registry_lastsync_file"

};

fi

};

fi

};

fi

};

function box::parsemeta ()

{

local _input="$1";

local _box_dir _box_name;

local _repo_source _repo_url _tag_name;

IFS='|' read -r _repo_source _tag_name <<< "${_input//::/|}";

: "${_tag_name:="HEAD"}";

if string::matches "$_repo_source" '^file://.*'; then

{

_box_dir="$_repo_source";

if test ! -e "$_box_dir"; then

{

log::error "$_box_dir does not exist" 1 || exit

};

fi;

_arg_force=off;

_repo_url=;

_box_name="${_box_dir##*/}"

};

else

if string::matches "$_repo_source" '^.*://.*'; then

{

local _repo_user _repo_name;

_repo_source="${_repo_source%.git}";

_repo_url="${_repo_source}";

IFS='|' read -r _repo_user _repo_name < <(

_box_dir="$_bashbox_registrydir/${_repo_user}_${_repo_name}-${_tag_name}";

_box_name="${_repo_name}"

};

else

if string::matches "$_repo_source" "[a-zA-Z0-9_]"; then

{

_repo_url="$(grep ".*/${_repo_source}$" "$_registry_meta_file")" || log::error "No such box as $_repo_source was found in the registry" 1 || exit;

_box_dir="$_bashbox_registrydir/${_repo_source}-${_tag_name}";

_box_name="${_repo_source##*/}"

};

fi;

fi;

fi;

echo "${_box_name}|${_box_dir}|${_repo_url}|${_tag_name}"

};

box::syncmeta;

local _box _box_dir _gitmod_file;

local _path _url _install_path _install_executable _built_executable;

for _box in "${@}";

do

{

if [[ "$_box" =~ ^-- ]]; then

{

continue

};

fi;

local _box_name _box_dir _repo_url _tag_name;

IFS='|' read -r _box_name _box_dir _repo_url _tag_name <<< "$(box::parsemeta "$_box")";

if test "${EXPORT_USEMOL:-}" == "true"; then

{

export "_usemol_${_box_name}=${_box_dir}"

};

fi;

if test -e "$_box_dir"; then

{

if [ "$_arg_force" == "off" ] && [ -e "$_box_dir/$_bashbox_meta_name" ]; then

{

if test ! -v EXPORT_USEMOL; then

{

log::warn "$_box_name already exists"

};

fi;

continue

};

else

{

rm -rf "$_box_dir"

};

fi

};

fi;

mkdir -p "$_box_dir";

log::info "Downloading box $_box_name $_tag_name";

curl --silent -L "${_repo_url}/archive/${_tag_name}.tar.gz" | tar --strip-components=1 -C "$_box_dir" -xpzf -;

_gitmod_file="$_box_dir/.gitmodules";

if test -e "$_gitmod_file"; then

{

log::info "Resolving git submodules";

while read -r _line; do

{

_line="${_line%%:*}";

_path="$(sed "${_line}q;d" "$_gitmod_file" | cut -d '=' -f2 | trim_leading_trailing)";

_url="$(sed "$(( _line + 1 ))q;d" "$_gitmod_file" | cut -d '=' -f2 | trim_leading_trailing)";

_install_path="${_box_dir}/${_path}";

log::info "Downloading git submodule: $_path";

mkdir -p "$_install_path";

curl --silent -L "${_url}/archive/${_tag_name}.tar.gz" | tar --strip-components=1 -C "$_install_path" -xpzf -

};

done < <(grep -n 'path.*=' "$_gitmod_file")

};

fi;

if test -e "$_box_dir/$_src_dir_name/main.sh" && test ! -v "EXPORT_USEMOL"; then

{

log::info "Compiling $_box in release mode";

( main -C "$_box_dir" build --release ) || {

log::error "Errors were found while compiling $_box, operation failed" 1 || exit

};

source "$_box_dir/$_bashbox_meta_name";

_built_executable="$_box_dir/target/release/$CODENAME";

_install_executable="$_bashbox_bindir/$CODENAME";

chmod +x "$_built_executable";

ln -srf "$_built_executable" "$_install_executable";

chmod +x "$_install_executable";

log::info "$_box was successfully installed as $CODENAME"

};

else

{

log::info "$_box was installed as a library"

};

fi

};

done

};

function subcommand::build ()

{

lockfile "build";

function print_help ()

{

println::helpgen ${_self_name^^}-${_subcommand_argv^^} --short-desc "${SUBCOMMANDS_DESC[3]}" --usage "${_self_name} ${_subcommand_argv} [OPTIONAL-OPTIONS] <path>" --options-desc "--release<^>Build in release mode

-h, --help<^>Prints this help information" --examples "### The basic way:

};

clap "$@";

local _orig_PWD="$PWD";

function Resolve::Colons ()

{

local result="$1";

if [[ "$result" =~ (use\ )?([^[:space:]]+)\;$ ]]; then

{

result="${BASH_REMATCH[2]//::/\/}";

result="${result/box\//}";

result="${result//\/\*/}"

};

fi;

printf '%s\n' "$result"

};

function perform_task ()

{

local _task="bashbox::$1";

if declare -F "$_task" > /dev/null; then

{

"$_task"

};

fi

};

function Resolve::UseSymbols ()

{

local _input="$1";

local _parsed_input;

_parsed_input="$(Resolve::Colons "$_input")";

local _parsed_input_name="${_parsed_input##*/}" && {

local _modname="${_parsed_input_name}";

_parsed_input="${_parsed_input/${_parsed_input_name}/${_parsed_input_name#_}}";

unset _parsed_input_name

};

local _ref="_usemol_${_parsed_input%%/*}";

local _src && {

if [[ "$_input" =~ use\ box:: ]]; then

{

_src="${PWD%%/src*}/src"

};

else

if test -v "$_ref"; then

{

local _reg_mod_path="${!_ref}";

local _reg_mod_target="${_local_build_registrydir}/${_reg_mod_path##*/}";

if test ! -e "$_reg_mod_target"; then

{

cp -r "$_reg_mod_path" "$_reg_mod_target"

};

fi;

_src="$_reg_mod_target/src";

_parsed_input="${_parsed_input#*/}"

};

else

{

_src="$PWD"

};

fi;

fi;

_parsed_input="$_src/$_parsed_input"

};

if test "${_modname::1}" == "_" || [[ "$_input" =~ ^[[:space:]]+use ]] || ! [[ "$(< "${_used_symbols_statfile}")" =~ "${_parsed_input}.sh" ]]; then

{

if test "$_arg_verbose" == "off"; then

{

echo -e " ${BGREEN}Compiling${RC} $_modname"

};

else

{

echo -e "---------- $_modname"

};

fi;

if test ! -e "${_parsed_input}.sh" && test ! -e "${_parsed_input}"; then

{

log::error "$_input is missing" 5 || exit

};

fi;

if [[ "$_input" =~ \*\;$ ]]; then

{

printf '\n' > "$_compiled_mod_bundle.sh";

for _modFile in "$_parsed_input/"*;

do

{

printf '%s\n' "$(< "$modFile")" >> "$_compiled_mod_bundle"

};

done;

_parsed_input="$_compiled_mod_bundle"

};

else

if test ! -e "${_parsed_input}.sh" && test -d "$_parsed_input"; then

{

_parsed_input="$_parsed_input/mod"

};

fi;

fi;

cd "$(dirname "$_parsed_input")";

if test "$_arg_verbose" == "on"; then

{

echo -e "${RED}PWD${RC}: $PWD";

echo -e "${CYAN}File${RC}: ${_parsed_input}.sh"

};

fi;

mapfile -t _use_symbols < <(grep -w -I -x -E '^\s+use .*;$|^use .*;$' "${_parsed_input}.sh" || true);

: ${_last_parsed_input:="${_parsed_input}"};

if test "$_arg_verbose" == "on"; then

{

echo -e "${PURPLE}Caller${RC}: $_last_parsed_input\n"

};

fi;

for _symbol in "${_use_symbols[@]}";

do

( _last_parsed_input="${_parsed_input}";

Resolve::UseSymbols "$_symbol" ) || exit 1;

done;

if test "${_parsed_input}.sh" != "${_last_parsed_input}.sh"; then

{

bash -n "${_parsed_input}.sh" || log::error "Syntax errors were found" || exit 1;

local _insert_stream _input_stream;

_insert_stream=$(< "${_parsed_input}.sh");

_input_stream=$(< "${_last_parsed_input}.sh");

printf '%s\n' "${_input_stream/$_input/$_insert_stream}" > "${_last_parsed_input}.sh";

unset _insert_stream _input_stream;

printf '%s\n' "${_parsed_input}.sh" >> "$_used_symbols_statfile"

};

fi;

if test "$_arg_verbose" == "on"; then

{

echo "$_parsed_input.sh ++ ${_last_parsed_input}.sh($_input)"

};

fi

};

else

{

local _input_stream;

_input_stream=$(< "${_last_parsed_input}.sh");