From e3ea03999bd0220aea1b987a92b9003ce628038b Mon Sep 17 00:00:00 2001 From: ReachableCEO Date: Mon, 9 Dec 2024 14:51:48 -0600 Subject: [PATCH] and it self bootstraps now by using bash. no need ror a git checkout hook to set mo executable. :D --- build/build.sh | 9 +- build/mo | 1997 ------------------------------------------------ 2 files changed, 5 insertions(+), 2001 deletions(-) delete mode 100644 build/mo diff --git a/build/build.sh b/build/build.sh index 424e16b..8da6cc2 100644 --- a/build/build.sh +++ b/build/build.sh @@ -24,6 +24,7 @@ export PAGEBACKGROUND="../vendor/git.knownelement.com/ExternalVendorCode/pandoc- # Setup globals ############################################################ +readonly MO_PATH="bash ../vendor/git.knownelement.com/ExternalVendorCode/mo/mo" readonly BUILD_OUTPUT_DIR="../build-output" readonly BUILD_TEMP_DIR="../build-temp" readonly BUILDYAML_JOBBOARD="$BUILD_TEMP_DIR/JobBoard.yml" @@ -51,14 +52,14 @@ rm $ClientSubmissionMSWordOutputFile # Expand variables into rendered YAML files. These will be used by pandoc to create the output artifacts -./mo ./BuildTemplate-JobBoard.yml > $BUILDYAML_JOBBOARD -./mo ./BuildTemplate-ClientSubmission.yml > $BUILDYAML_CLIENTSUBMISSION +$MO_PATH ./BuildTemplate-JobBoard.yml > $BUILDYAML_JOBBOARD +$MO_PATH ./BuildTemplate-ClientSubmission.yml > $BUILDYAML_CLIENTSUBMISSION echo "Combining markdown files into single input file for pandoc..." # Create contact info md file -./mo ../Templates/ContactInfo/ContactInfo-JobBoard.md > $BUILD_TEMP_DIR/ContactInfo-JobBoard.md -./mo ../Templates/ContactInfo/ContactInfo-ClientSubmit.md > $BUILD_TEMP_DIR/ContactInfo-ClientSubmit.md +$MO_PATH ../Templates/ContactInfo/ContactInfo-JobBoard.md > $BUILD_TEMP_DIR/ContactInfo-JobBoard.md +$MO_PATH ../Templates/ContactInfo/ContactInfo-ClientSubmit.md > $BUILD_TEMP_DIR/ContactInfo-ClientSubmit.md #Pull in contact info cat $BUILD_TEMP_DIR/ContactInfo-JobBoard.md >> $JobBoardMarkdownOutputFile diff --git a/build/mo b/build/mo deleted file mode 100644 index b53d48a..0000000 --- a/build/mo +++ /dev/null @@ -1,1997 +0,0 @@ -#!/usr/bin/env bash -# -#/ Mo is a mustache template rendering software written in bash. It inserts -#/ environment variables into templates. -#/ -#/ Simply put, mo will change {{VARIABLE}} into the value of that -#/ environment variable. You can use {{#VARIABLE}}content{{/VARIABLE}} to -#/ conditionally display content or iterate over the values of an array. -#/ -#/ Learn more about mustache templates at https://mustache.github.io/ -#/ -#/ Simple usage: -#/ -#/ mo [OPTIONS] filenames... -#/ -#/ Options: -#/ -#/ --allow-function-arguments -#/ Permit functions to be called with additional arguments. Otherwise, -#/ the only way to get access to the arguments is to use the -#/ MO_FUNCTION_ARGS environment variable. -#/ -d, --debug -#/ Enable debug logging to stderr. -#/ -u, --fail-not-set -#/ Fail upon expansion of an unset variable. Will silently ignore by -#/ default. Alternately, set MO_FAIL_ON_UNSET to a non-empty value. -#/ -x, --fail-on-function -#/ Fail when a function returns a non-zero status code instead of -#/ silently ignoring it. Alternately, set MO_FAIL_ON_FUNCTION to a -#/ non-empty value. -#/ -f, --fail-on-file -#/ Fail when a file (from command-line or partial) does not exist. -#/ Alternately, set MO_FAIL_ON_FILE to a non-empty value. -#/ -e, --false -#/ Treat the string "false" as empty for conditionals. Alternately, -#/ set MO_FALSE_IS_EMPTY to a non-empty value. -#/ -h, --help -#/ This message. -#/ -s=FILE, --source=FILE -#/ Load FILE into the environment before processing templates. -#/ Can be used multiple times. The file must be a valid shell script -#/ and should only contain variable assignments. -#/ -o=DELIM, --open=DELIM -#/ Set the opening delimiter. Default is "{{". -#/ -c=DELIM, --close=DELIM -#/ Set the closing delimiter. Default is "}}". -#/ -- Indicate the end of options. All arguments after this will be -#/ treated as filenames only. Use when filenames may start with -#/ hyphens. -#/ -#/ Mo uses the following environment variables: -#/ -#/ MO_ALLOW_FUNCTION_ARGUMENTS - When set to a non-empty value, this allows -#/ functions referenced in templates to receive additional options and -#/ arguments. -#/ MO_CLOSE_DELIMITER - The string used when closing a tag. Defaults to "}}". -#/ Used internally. -#/ MO_CLOSE_DELIMITER_DEFAULT - The default value of MO_CLOSE_DELIMITER. Used -#/ when resetting the close delimiter, such as when parsing a partial. -#/ MO_CURRENT - Variable name to use for ".". -#/ MO_DEBUG - When set to a non-empty value, additional debug information is -#/ written to stderr. -#/ MO_FUNCTION_ARGS - Arguments passed to the function. -#/ MO_FAIL_ON_FILE - If a filename from the command-line is missing or a -#/ partial does not exist, abort with an error. -#/ MO_FAIL_ON_FUNCTION - If a function returns a non-zero status code, abort -#/ with an error. -#/ MO_FAIL_ON_UNSET - When set to a non-empty value, expansion of an unset env -#/ variable will be aborted with an error. -#/ MO_FALSE_IS_EMPTY - When set to a non-empty value, the string "false" will -#/ be treated as an empty value for the purposes of conditionals. -#/ MO_OPEN_DELIMITER - The string used when opening a tag. Defaults to "{{". -#/ Used internally. -#/ MO_OPEN_DELIMITER_DEFAULT - The default value of MO_OPEN_DELIMITER. Used -#/ when resetting the open delimiter, such as when parsing a partial. -#/ MO_ORIGINAL_COMMAND - Used to find the `mo` program in order to generate a -#/ help message. -#/ MO_PARSED - Content that has made it through the template engine. -#/ MO_STANDALONE_CONTENT - The unparsed content that preceeded the current tag. -#/ When a standalone tag is encountered, this is checked to see if it only -#/ contains whitespace. If this and the whitespace condition after a tag is -#/ met, then this will be reset to $'\n'. -#/ MO_UNPARSED - Template content yet to make it through the parser. -#/ -#/ Mo is under a MIT style licence with an additional non-advertising clause. -#/ See LICENSE.md for the full text. -#/ -#/ This is open source! Please feel free to contribute. -#/ -#/ https://github.com/tests-always-included/mo - -#: Disable these warnings for the entire file -#: -#: VAR_NAME was modified in a subshell. That change might be lost. -# shellcheck disable=SC2031 -#: -#: Modification of VAR_NAME is local (to subshell caused by (..) group). -# shellcheck disable=SC2030 - -# Public: Template parser function. Writes templates to stdout. -# -# $0 - Name of the mo file, used for getting the help message. -# $@ - Filenames to parse. -# -# Returns nothing. -mo() ( - local moSource moFiles moDoubleHyphens moParsed moContent - - #: This function executes in a subshell; IFS is reset at the end. - IFS=$' \n\t' - - #: Enable a strict mode. This is also reset at the end. - set -eEu -o pipefail - moFiles=() - moDoubleHyphens=false - MO_OPEN_DELIMITER_DEFAULT="{{" - MO_CLOSE_DELIMITER_DEFAULT="}}" - MO_FUNCTION_CACHE_HIT=() - MO_FUNCTION_CACHE_MISS=() - - if [[ $# -gt 0 ]]; then - for arg in "$@"; do - if $moDoubleHyphens; then - #: After we encounter two hyphens together, all the rest - #: of the arguments are files. - moFiles=(${moFiles[@]+"${moFiles[@]}"} "$arg") - else - case "$arg" in - -h|--h|--he|--hel|--help|-\?) - mo::usage "$0" - exit 0 - ;; - - --allow-function-arguments) - MO_ALLOW_FUNCTION_ARGUMENTS=true - ;; - - -u | --fail-not-set) - MO_FAIL_ON_UNSET=true - ;; - - -x | --fail-on-function) - MO_FAIL_ON_FUNCTION=true - ;; - - -p | --fail-on-file) - MO_FAIL_ON_FILE=true - ;; - - -e | --false) - MO_FALSE_IS_EMPTY=true - ;; - - -s=* | --source=*) - if [[ "$arg" == --source=* ]]; then - moSource="${arg#--source=}" - else - moSource="${arg#-s=}" - fi - - if [[ -e "$moSource" ]]; then - # shellcheck disable=SC1090 - . "$moSource" - else - echo "No such file: $moSource" >&2 - exit 1 - fi - ;; - - -o=* | --open=*) - if [[ "$arg" == --open=* ]]; then - MO_OPEN_DELIMITER_DEFAULT="${arg#--open=}" - else - MO_OPEN_DELIMITER_DEFAULT="${arg#-o=}" - fi - ;; - - -c=* | --close=*) - if [[ "$arg" == --close=* ]]; then - MO_CLOSE_DELIMITER_DEFAULT="${arg#--close=}" - else - MO_CLOSE_DELIMITER_DEFAULT="${arg#-c=}" - fi - ;; - - -d | --debug) - MO_DEBUG=true - ;; - - --) - #: Set a flag indicating we've encountered double hyphens - moDoubleHyphens=true - ;; - - -*) - mo::error "Unknown option: $arg (See --help for options)" - ;; - - *) - #: Every arg that is not a flag or a option should be a file - moFiles=(${moFiles[@]+"${moFiles[@]}"} "$arg") - ;; - esac - fi - done - fi - - mo::debug "Debug enabled" - MO_OPEN_DELIMITER="$MO_OPEN_DELIMITER_DEFAULT" - MO_CLOSE_DELIMITER="$MO_CLOSE_DELIMITER_DEFAULT" - mo::content moContent ${moFiles[@]+"${moFiles[@]}"} || return 1 - mo::parse moParsed "$moContent" - echo -n "$moParsed" -) - - -# Internal: Show a debug message -# -# $1 - The debug message to show -# -# Returns nothing. -mo::debug() { - if [[ -n "${MO_DEBUG:-}" ]]; then - echo "DEBUG ${FUNCNAME[1]:-?} - $1" >&2 - fi -} - - -# Internal: Show a debug message and internal state information -# -# No arguments -# -# Returns nothing. -mo::debugShowState() { - if [[ -z "${MO_DEBUG:-}" ]]; then - return - fi - - local moState moTemp moIndex moDots - - mo::escape moTemp "$MO_OPEN_DELIMITER" - moState="open: $moTemp" - mo::escape moTemp "$MO_CLOSE_DELIMITER" - moState="$moState close: $moTemp" - mo::escape moTemp "$MO_STANDALONE_CONTENT" - moState="$moState standalone: $moTemp" - mo::escape moTemp "$MO_CURRENT" - moState="$moState current: $moTemp" - moIndex=$((${#MO_PARSED} - 20)) - moDots=... - - if [[ "$moIndex" -lt 0 ]]; then - moIndex=0 - moDots= - fi - - mo::escape moTemp "${MO_PARSED:$moIndex}" - moState="$moState parsed: $moDots$moTemp" - - moDots=... - - if [[ "${#MO_UNPARSED}" -le 20 ]]; then - moDots= - fi - - mo::escape moTemp "${MO_UNPARSED:0:20}$moDots" - moState="$moState unparsed: $moTemp" - - echo "DEBUG ${FUNCNAME[1]:-?} - $moState" >&2 -} - -# Internal: Show an error message and exit -# -# $1 - The error message to show -# $2 - Error code -# -# Returns nothing. Exits the program. -mo::error() { - echo "ERROR: $1" >&2 - exit "${2:-1}" -} - - -# Internal: Show an error message with a snippet of context and exit -# -# $1 - The error message to show -# $2 - The starting point -# $3 - Error code -# -# Returns nothing. Exits the program. -mo::errorNear() { - local moEscaped - - mo::escape moEscaped "${2:0:40}" - echo "ERROR: $1" >&2 - echo "ERROR STARTS NEAR: $moEscaped" - exit "${3:-1}" -} - - -# Internal: Displays the usage for mo. Pulls this from the file that -# contained the `mo` function. Can only work when the right filename -# comes is the one argument, and that only happens when `mo` is called -# with `$0` set to this file. -# -# $1 - Filename that has the help message -# -# Returns nothing. -mo::usage() { - while read -r line; do - if [[ "${line:0:2}" == "#/" ]]; then - echo "${line:3}" - fi - done < "$MO_ORIGINAL_COMMAND" - echo "" - echo "MO_VERSION=$MO_VERSION" -} - - -# Internal: Fetches the content to parse into MO_UNPARSED. Can be a list of -# partials for files or the content from stdin. -# -# $1 - Destination variable name -# $2-@ - File names (optional), read from stdin otherwise -# -# Returns nothing. -mo::content() { - local moTarget moContent moFilename - - moTarget=$1 - shift - moContent="" - - if [[ "${#@}" -gt 0 ]]; then - for moFilename in "$@"; do - mo::debug "Using template to load content from file: $moFilename" - #: This is so relative paths work from inside template files - moContent="$moContent$MO_OPEN_DELIMITER>$moFilename$MO_CLOSE_DELIMITER" - done - else - mo::debug "Will read content from stdin" - mo::contentFile moContent || return 1 - fi - - local "$moTarget" && mo::indirect "$moTarget" "$moContent" -} - - -# Internal: Read a file into MO_UNPARSED. -# -# $1 - Destination variable name. -# $2 - Filename to load - if empty, defaults to /dev/stdin -# -# Returns nothing. -mo::contentFile() { - local moFile moResult moContent - - #: The subshell removes any trailing newlines. We forcibly add - #: a dot to the content to preserve all newlines. Reading from - #: stdin with a `read` loop does not work as expected, so `cat` - #: needs to stay. - moFile=${2:-/dev/stdin} - - if [[ -e "$moFile" ]]; then - mo::debug "Loading content: $moFile" - moContent=$( - set +Ee - cat -- "$moFile" - moResult=$? - echo -n '.' - exit "$moResult" - ) || return 1 - moContent=${moContent%.} #: Remove last dot - elif [[ -n "${MO_FAIL_ON_FILE-}" ]]; then - mo::error "No such file: $moFile" - else - mo::debug "File does not exist: $moFile" - moContent="" - fi - - local "$1" && mo::indirect "$1" "$moContent" -} - - -# Internal: Send a variable up to the parent of the caller of this function. -# -# $1 - Variable name -# $2 - Value -# -# Examples -# -# callFunc () { -# local "$1" && mo::indirect "$1" "the value" -# } -# callFunc dest -# echo "$dest" # writes "the value" -# -# Returns nothing. -mo::indirect() { - unset -v "$1" - printf -v "$1" '%s' "$2" -} - - -# Internal: Send an array as a variable up to caller of a function -# -# $1 - Variable name -# $2-@ - Array elements -# -# Examples -# -# callFunc () { -# local myArray=(one two three) -# local "$1" && mo::indirectArray "$1" "${myArray[@]}" -# } -# callFunc dest -# echo "${dest[@]}" # writes "one two three" -# -# Returns nothing. -mo::indirectArray() { - unset -v "$1" - - #: IFS must be set to a string containing space or unset in order for - #: the array slicing to work regardless of the current IFS setting on - #: bash 3. This is detailed further at - #: https://github.com/fidian/gg-core/pull/7 - eval "$(printf "IFS= %s=(\"\${@:2}\") IFS=%q" "$1" "$IFS")" -} - - -# Internal: Trim leading characters from MO_UNPARSED -# -# Returns nothing. -mo::trimUnparsed() { - local moI moC - - moI=0 - moC=${MO_UNPARSED:0:1} - - while [[ "$moC" == " " || "$moC" == $'\r' || "$moC" == $'\n' || "$moC" == $'\t' ]]; do - moI=$((moI + 1)) - moC=${MO_UNPARSED:$moI:1} - done - - if [[ "$moI" != 0 ]]; then - MO_UNPARSED=${MO_UNPARSED:$moI} - fi -} - - -# Internal: Remove whitespace and content after whitespace -# -# $1 - Name of the destination variable -# $2 - The string to chomp -# -# Returns nothing. -mo::chomp() { - local moTemp moR moN moT - - moR=$'\r' - moN=$'\n' - moT=$'\t' - moTemp=${2%% *} - moTemp=${moTemp%%"$moR"*} - moTemp=${moTemp%%"$moN"*} - moTemp=${moTemp%%"$moT"*} - - local "$1" && mo::indirect "$1" "$moTemp" -} - - -# Public: Parses text, interpolates mustache tags. Utilizes the current value -# of MO_OPEN_DELIMITER, MO_CLOSE_DELIMITER, and MO_STANDALONE_CONTENT. Those -# three variables shouldn't be changed by user-defined functions. -# -# $1 - Destination variable name - where to store the finished content -# $2 - Content to parse -# $3 - Preserve standalone status/content - truthy if not empty. When set to a -# value, that becomes the standalone content value -# -# Returns nothing. -mo::parse() { - local moOldParsed moOldStandaloneContent moOldUnparsed moResult - - #: The standalone content is a trick to make the standalone tag detection - #: possible. When it's set to content with a newline and if the tag supports - #: it, the standalone content check happens. This check ensures only - #: whitespace is after the last newline up to the tag, and only whitespace - #: is after the tag up to the next newline. If that is the case, remove - #: whitespace and the trailing newline. By setting this to $'\n', we're - #: saying we are at the beginning of content. - mo::debug "Starting parse of ${#2} bytes" - moOldParsed=${MO_PARSED:-} - moOldUnparsed=${MO_UNPARSED:-} - MO_PARSED="" - MO_UNPARSED="$2" - - if [[ -z "${3:-}" ]]; then - moOldStandaloneContent=${MO_STANDALONE_CONTENT:-} - MO_STANDALONE_CONTENT=$'\n' - else - MO_STANDALONE_CONTENT=$3 - fi - - MO_CURRENT=${MO_CURRENT:-} - mo::parseInternal - moResult="$MO_PARSED$MO_UNPARSED" - MO_PARSED=$moOldParsed - MO_UNPARSED=$moOldUnparsed - - if [[ -z "${3:-}" ]]; then - MO_STANDALONE_CONTENT=$moOldStandaloneContent - fi - - local "$1" && mo::indirect "$1" "$moResult" -} - - -# Internal: Parse MO_UNPARSED, writing content to MO_PARSED. Interpolates -# mustache tags. -# -# No arguments -# -# Returns nothing. -mo::parseInternal() { - local moChunk - - mo::debug "Starting parse" - - while [[ -n "$MO_UNPARSED" ]]; do - mo::debugShowState - moChunk=${MO_UNPARSED%%"$MO_OPEN_DELIMITER"*} - MO_PARSED="$MO_PARSED$moChunk" - MO_STANDALONE_CONTENT="$MO_STANDALONE_CONTENT$moChunk" - MO_UNPARSED=${MO_UNPARSED:${#moChunk}} - - if [[ -n "$MO_UNPARSED" ]]; then - MO_UNPARSED=${MO_UNPARSED:${#MO_OPEN_DELIMITER}} - mo::trimUnparsed - - case "$MO_UNPARSED" in - '#'*) - #: Loop, if/then, or pass content through function - mo::parseBlock false - ;; - - '^'*) - #: Display section if named thing does not exist - mo::parseBlock true - ;; - - '>'*) - #: Load partial - get name of file relative to cwd - mo::parsePartial - ;; - - '/'*) - #: Closing tag - mo::errorNear "Unbalanced close tag" "$MO_UNPARSED" - ;; - - '!'*) - #: Comment - ignore the tag content entirely - mo::parseComment - ;; - - '='*) - #: Change delimiters - #: Any two non-whitespace sequences separated by whitespace. - mo::parseDelimiter - ;; - - '&'*) - #: Unescaped - mo doesn't escape/unescape - MO_UNPARSED=${MO_UNPARSED#&} - mo::trimUnparsed - mo::parseValue - ;; - - *) - #: Normal environment variable, string, subexpression, - #: current value, key, or function call - mo::parseValue - ;; - esac - fi - done -} - - -# Internal: Handle parsing a block -# -# $1 - Invert condition ("true" or "false") -# -# Returns nothing -mo::parseBlock() { - local moInvertBlock moTokens moTokensString - - moInvertBlock=$1 - MO_UNPARSED=${MO_UNPARSED:1} - mo::tokenizeTagContents moTokens "$MO_CLOSE_DELIMITER" - MO_UNPARSED=${MO_UNPARSED#"$MO_CLOSE_DELIMITER"} - mo::tokensToString moTokensString "${moTokens[@]:1}" - mo::debug "Parsing block: $moTokensString" - - if mo::standaloneCheck; then - mo::standaloneProcess - fi - - if [[ "${moTokens[1]}" == "NAME" ]] && mo::isFunction "${moTokens[2]}"; then - mo::parseBlockFunction "$moInvertBlock" "$moTokensString" "${moTokens[@]:1}" - elif [[ "${moTokens[1]}" == "NAME" ]] && mo::isArray "${moTokens[2]}"; then - mo::parseBlockArray "$moInvertBlock" "$moTokensString" "${moTokens[@]:1}" - else - mo::parseBlockValue "$moInvertBlock" "$moTokensString" "${moTokens[@]:1}" - fi -} - - -# Internal: Handle parsing a block whose first argument is a function -# -# $1 - Invert condition ("true" or "false") -# $2-@ - The parsed tokens from inside the block tags -# -# Returns nothing -mo::parseBlockFunction() { - local moTarget moInvertBlock moTokens moTemp moUnparsed moTokensString - - moInvertBlock=$1 - moTokensString=$2 - shift 2 - moTokens=(${@+"$@"}) - mo::debug "Parsing block function: $moTokensString" - mo::getContentUntilClose moTemp "$moTokensString" - #: Pass unparsed content to the function. - #: Keep the updated delimiters if they changed. - - if [[ "$moInvertBlock" != "true" ]]; then - mo::evaluateFunction moResult "$moTemp" "${moTokens[@]:1}" - MO_PARSED="$MO_PARSED$moResult" - fi - - mo::debug "Done parsing block function: $moTokensString" -} - - -# Internal: Handle parsing a block whose first argument is an array -# -# $1 - Invert condition ("true" or "false") -# $2-@ - The parsed tokens from inside the block tags -# -# Returns nothing -mo::parseBlockArray() { - local moInvertBlock moTokens moResult moArrayName moArrayIndexes moArrayIndex moTemp moUnparsed moOpenDelimiterBefore moCloseDelimiterBefore moOpenDelimiterAfter moCloseDelimiterAfter moParsed moTokensString moCurrent - - moInvertBlock=$1 - moTokensString=$2 - shift 2 - moTokens=(${@+"$@"}) - mo::debug "Parsing block array: $moTokensString" - moOpenDelimiterBefore=$MO_OPEN_DELIMITER - moCloseDelimiterBefore=$MO_CLOSE_DELIMITER - mo::getContentUntilClose moTemp "$moTokensString" - moOpenDelimiterAfter=$MO_OPEN_DELIMITER - moCloseDelimiterAfter=$MO_CLOSE_DELIMITER - moArrayName=${moTokens[1]} - eval "moArrayIndexes=(\"\${!${moArrayName}[@]}\")" - - if [[ "${#moArrayIndexes[@]}" -lt 1 ]]; then - #: No elements - if [[ "$moInvertBlock" == "true" ]]; then - #: Restore the delimiter before parsing - MO_OPEN_DELIMITER=$moOpenDelimiterBefore - MO_CLOSE_DELIMITER=$moCloseDelimiterBefore - moCurrent=$MO_CURRENT - MO_CURRENT=$moArrayName - mo::parse moParsed "$moTemp" "blockArrayInvert$MO_STANDALONE_CONTENT" - MO_CURRENT=$moCurrent - MO_PARSED="$MO_PARSED$moParsed" - fi - else - if [[ "$moInvertBlock" != "true" ]]; then - #: Process for each element in the array - moUnparsed=$MO_UNPARSED - - for moArrayIndex in "${moArrayIndexes[@]}"; do - #: Restore the delimiter before parsing - MO_OPEN_DELIMITER=$moOpenDelimiterBefore - MO_CLOSE_DELIMITER=$moCloseDelimiterBefore - moCurrent=$MO_CURRENT - MO_CURRENT=$moArrayName.$moArrayIndex - mo::debug "Iterate over array using element: $MO_CURRENT" - mo::parse moParsed "$moTemp" "blockArray$MO_STANDALONE_CONTENT" - MO_CURRENT=$moCurrent - MO_PARSED="$MO_PARSED$moParsed" - done - - MO_UNPARSED=$moUnparsed - fi - fi - - MO_OPEN_DELIMITER=$moOpenDelimiterAfter - MO_CLOSE_DELIMITER=$moCloseDelimiterAfter - mo::debug "Done parsing block array: $moTokensString" -} - - -# Internal: Handle parsing a block whose first argument is a value -# -# $1 - Invert condition ("true" or "false") -# $2-@ - The parsed tokens from inside the block tags -# -# Returns nothing -mo::parseBlockValue() { - local moInvertBlock moTokens moResult moUnparsed moOpenDelimiterBefore moOpenDelimiterAfter moCloseDelimiterBefore moCloseDelimiterAfter moParsed moTemp moTokensString moCurrent - - moInvertBlock=$1 - moTokensString=$2 - shift 2 - moTokens=(${@+"$@"}) - mo::debug "Parsing block value: $moTokensString" - moOpenDelimiterBefore=$MO_OPEN_DELIMITER - moCloseDelimiterBefore=$MO_CLOSE_DELIMITER - mo::getContentUntilClose moTemp "$moTokensString" - moOpenDelimiterAfter=$MO_OPEN_DELIMITER - moCloseDelimiterAfter=$MO_CLOSE_DELIMITER - - #: Variable, value, or list of mixed things - mo::evaluateListOfSingles moResult "${moTokens[@]}" - - if mo::isTruthy "$moResult" "$moInvertBlock"; then - mo::debug "Block is truthy: $moResult" - #: Restore the delimiter before parsing - MO_OPEN_DELIMITER=$moOpenDelimiterBefore - MO_CLOSE_DELIMITER=$moCloseDelimiterBefore - moCurrent=$MO_CURRENT - MO_CURRENT=${moTokens[1]} - mo::parse moParsed "$moTemp" "blockValue$MO_STANDALONE_CONTENT" - MO_PARSED="$MO_PARSED$moParsed" - MO_CURRENT=$moCurrent - fi - - MO_OPEN_DELIMITER=$moOpenDelimiterAfter - MO_CLOSE_DELIMITER=$moCloseDelimiterAfter - mo::debug "Done parsing block value: $moTokensString" -} - - -# Internal: Handle parsing a partial -# -# No arguments. -# -# Indentation will be applied to the entire partial's contents before parsing. -# This indentation is based on the whitespace that ends the previously parsed -# content. -# -# Returns nothing -mo::parsePartial() { - local moFilename moResult moIndentation moN moR moTemp moT - - MO_UNPARSED=${MO_UNPARSED:1} - mo::trimUnparsed - mo::chomp moFilename "${MO_UNPARSED%%"$MO_CLOSE_DELIMITER"*}" - MO_UNPARSED="${MO_UNPARSED#*"$MO_CLOSE_DELIMITER"}" - moIndentation="" - - if mo::standaloneCheck; then - moN=$'\n' - moR=$'\r' - moT=$'\t' - moIndentation="$moN${MO_PARSED//"$moR"/"$moN"}" - moIndentation=${moIndentation##*"$moN"} - moTemp=${moIndentation// } - moTemp=${moTemp//"$moT"} - - if [[ -n "$moTemp" ]]; then - moIndentation= - fi - - mo::debug "Adding indentation to partial: '$moIndentation'" - mo::standaloneProcess - fi - - mo::debug "Parsing partial: $moFilename" - - #: Execute in subshell to preserve current cwd and environment - moResult=$( - #: It would be nice to remove `dirname` and use a function instead, - #: but that is difficult when only given filenames. - cd "$(dirname -- "$moFilename")" || exit 1 - echo "$( - local moPartialContent moPartialParsed - - if ! mo::contentFile moPartialContent "${moFilename##*/}"; then - exit 1 - fi - - #: Reset delimiters before parsing - mo::indentLines moPartialContent "$moIndentation" "$moPartialContent" - MO_OPEN_DELIMITER="$MO_OPEN_DELIMITER_DEFAULT" - MO_CLOSE_DELIMITER="$MO_CLOSE_DELIMITER_DEFAULT" - mo::parse moPartialParsed "$moPartialContent" - - #: Fix bash handling of subshells and keep trailing whitespace. - echo -n "$moPartialParsed." - )" || exit 1 - ) || exit 1 - - if [[ -z "$moResult" ]]; then - mo::debug "Error detected when trying to read the file" - exit 1 - fi - - MO_PARSED="$MO_PARSED${moResult%.}" -} - - -# Internal: Handle parsing a comment -# -# No arguments. -# -# Returns nothing -mo::parseComment() { - local moContent moContent - - MO_UNPARSED=${MO_UNPARSED#*"$MO_CLOSE_DELIMITER"} - mo::debug "Parsing comment" - - if mo::standaloneCheck; then - mo::standaloneProcess - fi -} - - -# Internal: Handle parsing the change of delimiters -# -# No arguments. -# -# Returns nothing -mo::parseDelimiter() { - local moContent moOpen moClose - - MO_UNPARSED=${MO_UNPARSED:1} - mo::trimUnparsed - mo::chomp moOpen "$MO_UNPARSED" - MO_UNPARSED=${MO_UNPARSED:${#moOpen}} - mo::trimUnparsed - mo::chomp moClose "${MO_UNPARSED%%="$MO_CLOSE_DELIMITER"*}" - MO_UNPARSED=${MO_UNPARSED#*="$MO_CLOSE_DELIMITER"} - mo::debug "Parsing delimiters: $moOpen $moClose" - - if mo::standaloneCheck; then - mo::standaloneProcess - fi - - MO_OPEN_DELIMITER="$moOpen" - MO_CLOSE_DELIMITER="$moClose" -} - - -# Internal: Handle parsing value or function call -# -# No arguments. -# -# Returns nothing -mo::parseValue() { - local moUnparsedOriginal moTokens - - moUnparsedOriginal=$MO_UNPARSED - mo::tokenizeTagContents moTokens "$MO_CLOSE_DELIMITER" - mo::evaluate moResult "${moTokens[@]:1}" - MO_PARSED="$MO_PARSED$moResult" - - if [[ "${MO_UNPARSED:0:${#MO_CLOSE_DELIMITER}}" != "$MO_CLOSE_DELIMITER" ]]; then - mo::errorNear "Did not find closing tag" "$moUnparsedOriginal" - fi - - if mo::standaloneCheck; then - mo::standaloneProcess - fi - - MO_UNPARSED=${MO_UNPARSED:${#MO_CLOSE_DELIMITER}} -} - - -# Internal: Determine if the given name is a defined function. -# -# $1 - Function name to check -# -# Be extremely careful. Even if strict mode is enabled, it is not honored -# in newer versions of Bash. Any errors that crop up here will not be -# caught automatically. -# -# Examples -# -# moo () { -# echo "This is a function" -# } -# if mo::isFunction moo; then -# echo "moo is a defined function" -# fi -# -# Returns 0 if the name is a function, 1 otherwise. -mo::isFunction() { - local moFunctionName - - for moFunctionName in "${MO_FUNCTION_CACHE_HIT[@]}"; do - if [[ "$moFunctionName" == "$1" ]]; then - return 0 - fi - done - - for moFunctionName in "${MO_FUNCTION_CACHE_MISS[@]}"; do - if [[ "$moFunctionName" == "$1" ]]; then - return 1 - fi - done - - if declare -F "$1" &> /dev/null; then - MO_FUNCTION_CACHE_HIT=( ${MO_FUNCTION_CACHE_HIT[@]+"${MO_FUNCTION_CACHE_HIT[@]}"} "$1" ) - - return 0 - fi - - MO_FUNCTION_CACHE_MISS=( ${MO_FUNCTION_CACHE_MISS[@]+"${MO_FUNCTION_CACHE_MISS[@]}"} "$1" ) - - return 1 -} - - -# Internal: Determine if a given environment variable exists and if it is -# an array. -# -# $1 - Name of environment variable -# -# Be extremely careful. Even if strict mode is enabled, it is not honored -# in newer versions of Bash. Any errors that crop up here will not be -# caught automatically. -# -# Examples -# -# var=(abc) -# if moIsArray var; then -# echo "This is an array" -# echo "Make sure you don't accidentally use \$var" -# fi -# -# Returns 0 if the name is not empty, 1 otherwise. -mo::isArray() { - #: Namespace this variable so we don't conflict with what we're testing. - local moTestResult - - moTestResult=$(declare -p "$1" 2>/dev/null) || return 1 - [[ "${moTestResult:0:10}" == "declare -a" ]] && return 0 - [[ "${moTestResult:0:10}" == "declare -A" ]] && return 0 - - return 1 -} - - -# Internal: Determine if an array index exists. -# -# $1 - Variable name to check -# $2 - The index to check -# -# Has to check if the variable is an array and if the index is valid for that -# type of array. -# -# Returns true (0) if everything was ok, 1 if there's any condition that fails. -mo::isArrayIndexValid() { - local moDeclare moTest - - moDeclare=$(declare -p "$1") - moTest="" - - if [[ "${moDeclare:0:10}" == "declare -a" ]]; then - #: Numerically indexed array - must check if the index looks like a - #: number because using a string to index a numerically indexed array - #: will appear like it worked. - if [[ "$2" == "0" ]] || [[ "$2" =~ ^[1-9][0-9]*$ ]]; then - #: Index looks like a number - eval "moTest=\"\${$1[$2]+ok}\"" - fi - elif [[ "${moDeclare:0:10}" == "declare -A" ]]; then - #: Associative array - eval "moTest=\"\${$1[$2]+ok}\"" - fi - - if [[ -n "$moTest" ]]; then - return 0; - fi - - return 1 -} - - -# Internal: Determine if a variable is assigned, even if it is assigned an empty -# value. -# -# $1 - Variable name to check. -# -# Can not use logic like this in case invalid variable names are passed. -# [[ "${!1-a}" == "${!1-b}" ]] -# -# Using logic like this gives false positives. -# [[ -v "$a" ]] -# -# Declaring a variable is not the same as assigning the variable. -# export x -# declare -p x # Output: declare -x x -# export y="" -# declare -p y # Output: declare -x y="" -# unset z -# declare -p z # Error code 1 and output: bash: declare: z: not found -# -# Returns true (0) if the variable is set, 1 if the variable is unset. -mo::isVarSet() { - if declare -p "$1" &> /dev/null && [[ -v "$1" ]]; then - return 0 - fi - - return 1 -} - - -# Internal: Determine if a value is considered truthy. -# -# $1 - The value to test -# $2 - Invert the value, either "true" or "false" -# -# Returns true (0) if truthy, 1 otherwise. -mo::isTruthy() { - local moTruthy - - moTruthy=true - - if [[ -z "${1-}" ]]; then - moTruthy=false - elif [[ -n "${MO_FALSE_IS_EMPTY-}" ]] && [[ "${1-}" == "false" ]]; then - moTruthy=false - fi - - #: XOR the results - #: moTruthy inverse desiredResult - #: true false true - #: true true false - #: false false false - #: false true true - if [[ "$moTruthy" == "$2" ]]; then - mo::debug "Value is falsy, test result: $moTruthy inverse: $2" - return 1 - fi - - mo::debug "Value is truthy, test result: $moTruthy inverse: $2" - return 0 -} - - -# Internal: Convert token list to values -# -# $1 - Destination variable name -# $2-@ - Tokens to convert -# -# Sample call: -# -# mo::evaluate dest NAME username VALUE abc123 PAREN 2 -# -# Returns nothing. -mo::evaluate() { - local moTarget moStack moValue moType moIndex moCombined moResult - - moTarget=$1 - shift - - #: Phase 1 - remove all command tokens (PAREN, BRACE) - moStack=() - - while [[ $# -gt 0 ]]; do - case "$1" in - PAREN|BRACE) - moType=$1 - moValue=$2 - mo::debug "Combining $moValue tokens" - moIndex=$((${#moStack[@]} - (2 * moValue))) - mo::evaluateListOfSingles moCombined "${moStack[@]:$moIndex}" - - if [[ "$moType" == "PAREN" ]]; then - moStack=("${moStack[@]:0:$moIndex}" NAME "$moCombined") - else - moStack=("${moStack[@]:0:$moIndex}" VALUE "$moCombined") - fi - ;; - - *) - moStack=(${moStack[@]+"${moStack[@]}"} "$1" "$2") - ;; - esac - - shift 2 - done - - #: Phase 2 - check if this is a function or if we should just concatenate values - if [[ "${moStack[0]:-}" == "NAME" ]] && mo::isFunction "${moStack[1]}"; then - #: Special case - if the first argument is a function, then the rest are - #: passed to the function. - mo::debug "Evaluating function: ${moStack[1]}" - mo::evaluateFunction moResult "" "${moStack[@]:1}" - else - #: Concatenate - mo::debug "Concatenating ${#moStack[@]} stack items" - mo::evaluateListOfSingles moResult ${moStack[@]+"${moStack[@]}"} - fi - - local "$moTarget" && mo::indirect "$moTarget" "$moResult" -} - - -# Internal: Convert an argument list to individual values. -# -# $1 - Destination variable name -# $2-@ - A list of argument types and argument name/value. -# -# This assumes each value is separate from the rest. In contrast, mo::evaluate -# will pass all arguments to a function if the first value is a function. -# -# Sample call: -# -# mo::evaluateListOfSingles dest NAME username VALUE abc123 -# -# Returns nothing. -mo::evaluateListOfSingles() { - local moResult moTarget moTemp - - moTarget=$1 - shift - moResult="" - - while [[ $# -gt 1 ]]; do - mo::evaluateSingle moTemp "$1" "$2" - moResult="$moResult$moTemp" - shift 2 - done - - mo::debug "Evaluated list of singles: $moResult" - - local "$moTarget" && mo::indirect "$moTarget" "$moResult" -} - - -# Internal: Evaluate a single argument -# -# $1 - Name of variable for result -# $2 - Type of argument, either NAME or VALUE -# $3 - Argument -# -# Returns nothing -mo::evaluateSingle() { - local moResult moType moArg - - moType=$2 - moArg=$3 - mo::debug "Evaluating $moType: $moArg ($MO_CURRENT)" - - if [[ "$moType" == "VALUE" ]]; then - moResult=$moArg - elif [[ "$moArg" == "." ]]; then - mo::evaluateVariable moResult "" - elif [[ "$moArg" == "@key" ]]; then - mo::evaluateKey moResult - elif mo::isFunction "$moArg"; then - mo::evaluateFunction moResult "" "$moArg" - else - mo::evaluateVariable moResult "$moArg" - fi - - local "$1" && mo::indirect "$1" "$moResult" -} - - -# Internal: Return the value for @key based on current's name -# -# $1 - Name of variable for result -# -# Returns nothing -mo::evaluateKey() { - local moResult - - if [[ "$MO_CURRENT" == *.* ]]; then - moResult="${MO_CURRENT#*.}" - else - moResult="${MO_CURRENT}" - fi - - local "$1" && mo::indirect "$1" "$moResult" -} - - -# Internal: Handle a variable name -# -# $1 - Destination variable name -# $2 - Variable name -# -# Returns nothing. -mo::evaluateVariable() { - local moResult moArg moNameParts - - moArg=$2 - moResult="" - mo::findVariableName moNameParts "$moArg" - mo::debug "Evaluate variable ($moArg, $MO_CURRENT): ${moNameParts[*]}" - - if [[ -z "${moNameParts[1]}" ]]; then - if mo::isArray "${moNameParts[0]}"; then - eval mo::join moResult "," "\${${moNameParts[0]}[@]}" - else - if mo::isVarSet "${moNameParts[0]}"; then - moResult=${moNameParts[0]} - moResult="${!moResult}" - elif [[ -n "${MO_FAIL_ON_UNSET-}" ]]; then - mo::error "Environment variable not set: ${moNameParts[0]}" - fi - fi - else - if mo::isArray "${moNameParts[0]}"; then - eval "set +u;moResult=\"\${${moNameParts[0]}[${moNameParts[1]%%.*}]}\"" - else - mo::error "Unable to index a scalar as an array: $moArg" - fi - fi - - local "$1" && mo::indirect "$1" "$moResult" -} - - -# Internal: Find the name of a variable to use -# -# $1 - Destination variable name, receives an array -# $2 - Variable name from the template -# -# The array contains the following values -# [0] - Variable name -# [1] - Array index, or empty string -# -# Example variables -# a="a" -# b="b" -# c=("c.0" "c.1") -# d=([b]="d.b" [d]="d.d") -# -# Given these inputs (function input, current value), produce these outputs -# a c => a -# a c.0 => a -# b d => d.b -# b d.d => d.b -# a d => d.a -# a d.d => d.a -# c.0 d => c.0 -# d.b d => d.b -# '' c => c -# '' c.0 => c.0 -# Returns nothing. -mo::findVariableName() { - local moVar moNameParts moResultBase moResultIndex moCurrent - - moVar=$2 - moResultBase=$moVar - moResultIndex="" - - if [[ -z "$moVar" ]]; then - moResultBase=${MO_CURRENT%%.*} - - if [[ "$MO_CURRENT" == *.* ]]; then - moResultIndex=${MO_CURRENT#*.} - fi - elif [[ "$moVar" == *.* ]]; then - mo::debug "Find variable name; name has dot: $moVar" - moResultBase=${moVar%%.*} - moResultIndex=${moVar#*.} - elif [[ -n "$MO_CURRENT" ]]; then - moCurrent=${MO_CURRENT%%.*} - mo::debug "Find variable name; look in array: $moCurrent" - - if mo::isArrayIndexValid "$moCurrent" "$moVar"; then - moResultBase=$moCurrent - moResultIndex=$moVar - fi - fi - - local "$1" && mo::indirectArray "$1" "$moResultBase" "$moResultIndex" -} - - -# Internal: Join / implode an array -# -# $1 - Variable name to receive the joined content -# $2 - Joiner -# $3-@ - Elements to join -# -# Returns nothing. -mo::join() { - local joiner part result target - - target=$1 - joiner=$2 - result=$3 - shift 3 - - for part in "$@"; do - result="$result$joiner$part" - done - - local "$target" && mo::indirect "$target" "$result" -} - - -# Internal: Call a function. -# -# $1 - Variable for output -# $2 - Content to pass -# $3 - Function to call -# $4-@ - Additional arguments as list of type, value/name -# -# Returns nothing. -mo::evaluateFunction() { - local moArgs moContent moFunctionResult moTarget moFunction moTemp moFunctionCall - - moTarget=$1 - moContent=$2 - moFunction=$3 - shift 3 - moArgs=() - - while [[ $# -gt 1 ]]; do - mo::evaluateSingle moTemp "$1" "$2" - moArgs=(${moArgs[@]+"${moArgs[@]}"} "$moTemp") - shift 2 - done - - mo::escape moFunctionCall "$moFunction" - - if [[ -n "${MO_ALLOW_FUNCTION_ARGUMENTS-}" ]]; then - mo::debug "Function arguments are allowed" - - if [[ ${#moArgs[@]} -gt 0 ]]; then - for moTemp in "${moArgs[@]}"; do - mo::escape moTemp "$moTemp" - moFunctionCall="$moFunctionCall $moTemp" - done - fi - fi - - mo::debug "Calling function: $moFunctionCall" - - #: Call the function in a subshell for safety. Employ the trick to preserve - #: whitespace at the end of the output. - moContent=$( - export MO_FUNCTION_ARGS=(${moArgs[@]+"${moArgs[@]}"}) - echo -n "$moContent" | eval "$moFunctionCall ; moFunctionResult=\$? ; echo -n '.' ; exit \"\$moFunctionResult\"" - ) || { - moFunctionResult=$? - if [[ -n "${MO_FAIL_ON_FUNCTION-}" && "$moFunctionResult" != 0 ]]; then - mo::error "Function failed with status code $moFunctionResult: $moFunctionCall" "$moFunctionResult" - fi - } - - local "$moTarget" && mo::indirect "$moTarget" "${moContent%.}" -} - - -# Internal: Check if a tag appears to have only whitespace before it and after -# it on a line. There must be a new line before and there must be a newline -# after or the end of a string -# -# No arguments. -# -# Returns 0 if this is a standalone tag, 1 otherwise. -mo::standaloneCheck() { - local moContent moN moR moT - - moN=$'\n' - moR=$'\r' - moT=$'\t' - - #: Check the content before - moContent=${MO_STANDALONE_CONTENT//"$moR"/"$moN"} - - #: By default, signal to the next check that this one failed - MO_STANDALONE_CONTENT="" - - if [[ "$moContent" != *"$moN"* ]]; then - mo::debug "Not a standalone tag - no newline before" - - return 1 - fi - - moContent=${moContent##*"$moN"} - moContent=${moContent//"$moT"/} - moContent=${moContent// /} - - if [[ -n "$moContent" ]]; then - mo::debug "Not a standalone tag - non-whitespace detected before tag" - - return 1 - fi - - #: Check the content after - moContent=${MO_UNPARSED//"$moR"/"$moN"} - moContent=${moContent%%"$moN"*} - moContent=${moContent//"$moT"/} - moContent=${moContent// /} - - if [[ -n "$moContent" ]]; then - mo::debug "Not a standalone tag - non-whitespace detected after tag" - - return 1 - fi - - #: Signal to the next check that this tag removed content - MO_STANDALONE_CONTENT=$'\n' - - return 0 -} - - -# Internal: Process content before and after a tag. Remove prior whitespace up -# to the previous newline. Remove following whitespace up to and including the -# next newline. -# -# No arguments. -# -# Returns nothing. -mo::standaloneProcess() { - local moI moTemp - - mo::debug "Standalone tag - processing content before and after tag" - moI=$((${#MO_PARSED} - 1)) - mo::debug "zero done ${#MO_PARSED}" - mo::escape moTemp "$MO_PARSED" - mo::debug "$moTemp" - - while [[ "${MO_PARSED:$moI:1}" == " " || "${MO_PARSED:$moI:1}" == $'\t' ]]; do - moI=$((moI - 1)) - done - - if [[ $((moI + 1)) != "${#MO_PARSED}" ]]; then - MO_PARSED="${MO_PARSED:0:${moI}+1}" - fi - - moI=0 - - while [[ "${MO_UNPARSED:${moI}:1}" == " " || "${MO_UNPARSED:${moI}:1}" == $'\t' ]]; do - moI=$((moI + 1)) - done - - if [[ "${MO_UNPARSED:${moI}:1}" == $'\r' ]]; then - moI=$((moI + 1)) - fi - - if [[ "${MO_UNPARSED:${moI}:1}" == $'\n' ]]; then - moI=$((moI + 1)) - fi - - if [[ "$moI" != 0 ]]; then - MO_UNPARSED=${MO_UNPARSED:${moI}} - fi -} - - -# Internal: Apply indentation before any line that has content in MO_UNPARSED. -# -# $1 - Destination variable name. -# $2 - The indentation string. -# $3 - The content that needs the indentation string prepended on each line. -# -# Returns nothing. -mo::indentLines() { - local moContent moIndentation moResult moN moR moChunk - - moIndentation=$2 - moContent=$3 - - if [[ -z "$moIndentation" ]]; then - mo::debug "Not applying indentation, empty indentation" - - local "$1" && mo::indirect "$1" "$moContent" - return - fi - - if [[ -z "$moContent" ]]; then - mo::debug "Not applying indentation, empty contents" - - local "$1" && mo::indirect "$1" "$moContent" - return - fi - - moResult= - moN=$'\n' - moR=$'\r' - - mo::debug "Applying indentation: '${moIndentation}'" - - while [[ -n "$moContent" ]]; do - moChunk=${moContent%%"$moN"*} - moChunk=${moChunk%%"$moR"*} - moContent=${moContent:${#moChunk}} - - if [[ -n "$moChunk" ]]; then - moResult="$moResult$moIndentation$moChunk" - fi - - moResult="$moResult${moContent:0:1}" - moContent=${moContent:1} - done - - local "$1" && mo::indirect "$1" "$moResult" -} - - -# Internal: Escape a value -# -# $1 - Destination variable name -# $2 - Value to escape -# -# Returns nothing -mo::escape() { - local moResult - - moResult=$2 - moResult=$(declare -p moResult) - moResult=${moResult#*=} - - local "$1" && mo::indirect "$1" "$moResult" -} - - -# Internal: Get the content up to the end of the block by minimally parsing and -# balancing blocks. Returns the content before the end tag to the caller and -# removes the content + the end tag from MO_UNPARSED. This can change the -# delimiters, adjusting MO_OPEN_DELIMITER and MO_CLOSE_DELIMITER. -# -# $1 - Destination variable name -# $2 - Token string to match for a closing tag -# -# Returns nothing. -mo::getContentUntilClose() { - local moChunk moResult moTemp moTokensString moTokens moTarget moTagStack moResultTemp - - moTarget=$1 - moTagStack=("$2") - mo::debug "Get content until close tag: ${moTagStack[0]}" - moResult="" - - while [[ -n "$MO_UNPARSED" ]] && [[ "${#moTagStack[@]}" -gt 0 ]]; do - moChunk=${MO_UNPARSED%%"$MO_OPEN_DELIMITER"*} - moResult="$moResult$moChunk" - MO_UNPARSED=${MO_UNPARSED:${#moChunk}} - - if [[ -n "$MO_UNPARSED" ]]; then - moResultTemp="$MO_OPEN_DELIMITER" - MO_UNPARSED=${MO_UNPARSED:${#MO_OPEN_DELIMITER}} - mo::getContentTrim moTemp - moResultTemp="$moResultTemp$moTemp" - mo::debug "First character within tag: ${MO_UNPARSED:0:1}" - - case "$MO_UNPARSED" in - '#'*) - #: Increase block - moResultTemp="$moResultTemp${MO_UNPARSED:0:1}" - MO_UNPARSED=${MO_UNPARSED:1} - mo::getContentTrim moTemp - mo::getContentWithinTag moTemp "$MO_CLOSE_DELIMITER" - moResultTemp="$moResultTemp${moTemp[0]}" - moTagStack=("${moTemp[1]}" "${moTagStack[@]}") - ;; - - '^'*) - #: Increase block - moResultTemp="$moResultTemp${MO_UNPARSED:0:1}" - MO_UNPARSED=${MO_UNPARSED:1} - mo::getContentTrim moTemp - mo::getContentWithinTag moTemp "$MO_CLOSE_DELIMITER" - moResultTemp="$moResultTemp${moTemp[0]}" - moTagStack=("${moTemp[1]}" "${moTagStack[@]}") - ;; - - '>'*) - #: Partial - ignore - moResultTemp="$moResultTemp${MO_UNPARSED:0:1}" - MO_UNPARSED=${MO_UNPARSED:1} - mo::getContentTrim moTemp - mo::getContentWithinTag moTemp "$MO_CLOSE_DELIMITER" - moResultTemp="$moResultTemp${moTemp[0]}" - ;; - - '/'*) - #: Decrease block - moResultTemp="$moResultTemp${MO_UNPARSED:0:1}" - MO_UNPARSED=${MO_UNPARSED:1} - mo::getContentTrim moTemp - mo::getContentWithinTag moTemp "$MO_CLOSE_DELIMITER" - - if [[ "${moTagStack[0]}" == "${moTemp[1]}" ]]; then - moResultTemp="$moResultTemp${moTemp[0]}" - moTagStack=("${moTagStack[@]:1}") - - if [[ "${#moTagStack[@]}" -eq 0 ]]; then - #: Erase all portions of the close tag - moResultTemp="" - fi - else - mo::errorNear "Unbalanced closing tag, expected: ${moTagStack[0]}" "${moTemp[0]}${MO_UNPARSED}" - fi - ;; - - '!'*) - #: Comment - ignore - mo::getContentComment moTemp - moResultTemp="$moResultTemp$moTemp" - ;; - - '='*) - #: Change delimiters - mo::getContentDelimiter moTemp - moResultTemp="$moResultTemp$moTemp" - ;; - - '&'*) - #: Unescaped - bypass one then ignore - moResultTemp="$moResultTemp${MO_UNPARSED:0:1}" - MO_UNPARSED=${MO_UNPARSED:1} - mo::getContentTrim moTemp - moResultTemp="$moResultTemp$moTemp" - mo::getContentWithinTag moTemp "$MO_CLOSE_DELIMITER" - moResultTemp="$moResultTemp${moTemp[0]}" - ;; - - *) - #: Normal variable - ignore - mo::getContentWithinTag moTemp "$MO_CLOSE_DELIMITER" - moResultTemp="$moResultTemp${moTemp[0]}" - ;; - esac - - moResult="$moResult$moResultTemp" - fi - done - - MO_STANDALONE_CONTENT="$MO_STANDALONE_CONTENT$moResult" - - if mo::standaloneCheck; then - moResultTemp=$MO_PARSED - MO_PARSED=$moResult - mo::standaloneProcess - moResult=$MO_PARSED - MO_PARSED=$moResultTemp - fi - - local "$moTarget" && mo::indirect "$moTarget" "$moResult" -} - - -# Internal: Convert a list of tokens to a string -# -# $1 - Destination variable for the string -# $2-$@ - Token list -# -# Returns nothing. -mo::tokensToString() { - local moTarget moString moTokens - - moTarget=$1 - shift 1 - moTokens=("$@") - moString=$(declare -p moTokens) - moString=${moString#*=} - - local "$moTarget" && mo::indirect "$moTarget" "$moString" -} - - -# Internal: Trims content from MO_UNPARSED, returns trimmed content. -# -# $1 - Destination variable -# -# Returns nothing. -mo::getContentTrim() { - local moChar moResult - - moChar=${MO_UNPARSED:0:1} - moResult="" - - while [[ "$moChar" == " " ]] || [[ "$moChar" == $'\r' ]] || [[ "$moChar" == $'\t' ]] || [[ "$moChar" == $'\n' ]]; do - moResult="$moResult$moChar" - MO_UNPARSED=${MO_UNPARSED:1} - moChar=${MO_UNPARSED:0:1} - done - - local "$1" && mo::indirect "$1" "$moResult" -} - - -# Get the content up to and including a close tag -# -# $1 - Destination variable -# -# Returns nothing. -mo::getContentComment() { - local moResult - - mo::debug "Getting content for comment" - moResult=${MO_UNPARSED%%"$MO_CLOSE_DELIMITER"*} - MO_UNPARSED=${MO_UNPARSED:${#moResult}} - - if [[ "$MO_UNPARSED" == "$MO_CLOSE_DELIMITER"* ]]; then - moResult="$moResult$MO_CLOSE_DELIMITER" - MO_UNPARSED=${MO_UNPARSED#"$MO_CLOSE_DELIMITER"} - fi - - local "$1" && mo::indirect "$1" "$moResult" -} - - -# Get the content up to and including a close tag. First two non-whitespace -# tokens become the new open and close tag. -# -# $1 - Destination variable -# -# Returns nothing. -mo::getContentDelimiter() { - local moResult moTemp moOpen moClose - - mo::debug "Getting content for delimiter" - moResult="" - mo::getContentTrim moTemp - moResult="$moResult$moTemp" - mo::chomp moOpen "$MO_UNPARSED" - MO_UNPARSED="${MO_UNPARSED:${#moOpen}}" - moResult="$moResult$moOpen" - mo::getContentTrim moTemp - moResult="$moResult$moTemp" - mo::chomp moClose "${MO_UNPARSED%%="$MO_CLOSE_DELIMITER"*}" - MO_UNPARSED="${MO_UNPARSED:${#moClose}}" - moResult="$moResult$moClose" - mo::getContentTrim moTemp - moResult="$moResult$moTemp" - MO_OPEN_DELIMITER="$moOpen" - MO_CLOSE_DELIMITER="$moClose" - - local "$1" && mo::indirect "$1" "$moResult" -} - - -# Get the content up to and including a close tag. First two non-whitespace -# tokens become the new open and close tag. -# -# $1 - Destination variable, an array -# $2 - Terminator string -# -# The array contents: -# [0] The raw content within the tag -# [1] The parsed tokens as a single string -# -# Returns nothing. -mo::getContentWithinTag() { - local moUnparsed moTokens - - moUnparsed=${MO_UNPARSED} - mo::tokenizeTagContents moTokens "$MO_CLOSE_DELIMITER" - MO_UNPARSED=${MO_UNPARSED#"$MO_CLOSE_DELIMITER"} - mo::tokensToString moTokensString "${moTokens[@]:1}" - moParsed=${moUnparsed:0:$((${#moUnparsed} - ${#MO_UNPARSED}))} - - local "$1" && mo::indirectArray "$1" "$moParsed" "$moTokensString" -} - - -# Internal: Parse MO_UNPARSED and retrieve the content within the tag -# delimiters. Converts everything into an array of string values. -# -# $1 - Destination variable for the array of contents. -# $2 - Stop processing when this content is found. -# -# The list of tokens are in RPN form. The first item in the resulting array is -# the number of actual tokens (after combining command tokens) in the list. -# -# Given: a 'bc' "de\"\n" (f {g 'h'}) -# Result: ([0]=4 [1]=NAME [2]=a [3]=VALUE [4]=bc [5]=VALUE [6]=$'de\"\n' -# [7]=NAME [8]=f [9]=NAME [10]=g [11]=VALUE [12]=h -# [13]=BRACE [14]=2 [15]=PAREN [16]=2 -# -# Returns nothing -mo::tokenizeTagContents() { - local moResult moTerminator moTemp moUnparsedOriginal moTokenCount - - moTerminator=$2 - moResult=() - moUnparsedOriginal=$MO_UNPARSED - moTokenCount=0 - mo::debug "Tokenizing tag contents until terminator: $moTerminator" - - while true; do - mo::trimUnparsed - - case "$MO_UNPARSED" in - "") - mo::errorNear "Did not find matching terminator: $moTerminator" "$moUnparsedOriginal" - ;; - - "$moTerminator"*) - mo::debug "Found terminator" - local "$1" && mo::indirectArray "$1" "$moTokenCount" ${moResult[@]+"${moResult[@]}"} - return - ;; - - '('*) - #: Do not tokenize the open paren - treat this as RPL - MO_UNPARSED=${MO_UNPARSED:1} - mo::tokenizeTagContents moTemp ')' - moResult=(${moResult[@]+"${moResult[@]}"} "${moTemp[@]:1}" PAREN "${moTemp[0]}") - MO_UNPARSED=${MO_UNPARSED:1} - ;; - - '{'*) - #: Do not tokenize the open brace - treat this as RPL - MO_UNPARSED=${MO_UNPARSED:1} - mo::tokenizeTagContents moTemp '}' - moResult=(${moResult[@]+"${moResult[@]}"} "${moTemp[@]:1}" BRACE "${moTemp[0]}") - MO_UNPARSED=${MO_UNPARSED:1} - ;; - - ')'* | '}'*) - mo::errorNear "Unbalanced closing parenthesis or brace" "$MO_UNPARSED" - ;; - - "'"*) - mo::tokenizeTagContentsSingleQuote moTemp - moResult=(${moResult[@]+"${moResult[@]}"} "${moTemp[@]}") - ;; - - '"'*) - mo::tokenizeTagContentsDoubleQuote moTemp - moResult=(${moResult[@]+"${moResult[@]}"} "${moTemp[@]}") - ;; - - *) - mo::tokenizeTagContentsName moTemp - moResult=(${moResult[@]+"${moResult[@]}"} "${moTemp[@]}") - ;; - esac - - mo::debug "Got chunk: ${moTemp[0]} ${moTemp[1]}" - moTokenCount=$((moTokenCount + 1)) - done -} - - -# Internal: Get the contents of a variable name. -# -# $1 - Destination variable name for the token list (array of strings) -# -# Returns nothing -mo::tokenizeTagContentsName() { - local moTemp - - mo::chomp moTemp "${MO_UNPARSED%%"$MO_CLOSE_DELIMITER"*}" - moTemp=${moTemp%%(*} - moTemp=${moTemp%%)*} - moTemp=${moTemp%%\{*} - moTemp=${moTemp%%\}*} - MO_UNPARSED=${MO_UNPARSED:${#moTemp}} - mo::trimUnparsed - mo::debug "Parsed default token: $moTemp" - - local "$1" && mo::indirectArray "$1" "NAME" "$moTemp" -} - - -# Internal: Get the contents of a tag in double quotes. Parses the backslash -# sequences. -# -# $1 - Destination variable name for the token list (array of strings) -# -# Returns nothing. -mo::tokenizeTagContentsDoubleQuote() { - local moResult moUnparsedOriginal - - moUnparsedOriginal=$MO_UNPARSED - MO_UNPARSED=${MO_UNPARSED:1} - moResult= - mo::debug "Getting double quoted tag contents" - - while true; do - if [[ -z "$MO_UNPARSED" ]]; then - mo::errorNear "Unbalanced double quote" "$moUnparsedOriginal" - fi - - case "$MO_UNPARSED" in - '"'*) - MO_UNPARSED=${MO_UNPARSED:1} - local "$1" && mo::indirectArray "$1" "VALUE" "$moResult" - return - ;; - - \\b*) - moResult="$moResult"$'\b' - MO_UNPARSED=${MO_UNPARSED:2} - ;; - - \\e*) - #: Note, \e is ESC, but in Bash $'\E' is ESC. - moResult="$moResult"$'\E' - MO_UNPARSED=${MO_UNPARSED:2} - ;; - - \\f*) - moResult="$moResult"$'\f' - MO_UNPARSED=${MO_UNPARSED:2} - ;; - - \\n*) - moResult="$moResult"$'\n' - MO_UNPARSED=${MO_UNPARSED:2} - ;; - - \\r*) - moResult="$moResult"$'\r' - MO_UNPARSED=${MO_UNPARSED:2} - ;; - - \\t*) - moResult="$moResult"$'\t' - MO_UNPARSED=${MO_UNPARSED:2} - ;; - - \\v*) - moResult="$moResult"$'\v' - MO_UNPARSED=${MO_UNPARSED:2} - ;; - - \\*) - moResult="$moResult${MO_UNPARSED:1:1}" - MO_UNPARSED=${MO_UNPARSED:2} - ;; - - *) - moResult="$moResult${MO_UNPARSED:0:1}" - MO_UNPARSED=${MO_UNPARSED:1} - ;; - esac - done -} - - -# Internal: Get the contents of a tag in single quotes. Only gets the raw -# value. -# -# $1 - Destination variable name for the token list (array of strings) -# -# Returns nothing. -mo::tokenizeTagContentsSingleQuote() { - local moResult moUnparsedOriginal - - moUnparsedOriginal=$MO_UNPARSED - MO_UNPARSED=${MO_UNPARSED:1} - moResult= - mo::debug "Getting single quoted tag contents" - - while true; do - if [[ -z "$MO_UNPARSED" ]]; then - mo::errorNear "Unbalanced single quote" "$moUnparsedOriginal" - fi - - case "$MO_UNPARSED" in - "'"*) - MO_UNPARSED=${MO_UNPARSED:1} - local "$1" && mo::indirectArray "$1" VALUE "$moResult" - return - ;; - - *) - moResult="$moResult${MO_UNPARSED:0:1}" - MO_UNPARSED=${MO_UNPARSED:1} - ;; - esac - done -} - - -# Save the original command's path for usage later -MO_ORIGINAL_COMMAND="$(cd "${BASH_SOURCE[0]%/*}" || exit 1; pwd)/${BASH_SOURCE[0]##*/}" -MO_VERSION="3.0.7" - -# If sourced, load all functions. -# If executed, perform the actions as expected. -if [[ "$0" == "${BASH_SOURCE[0]}" ]] || [[ -z "${BASH_SOURCE[0]}" ]]; then - mo "$@" -fi