#!/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:
#/
#/    -u, --fail-not-set
#/          Fail upon expansion of an unset variable.
#/    -x, --fail-on-function
#/          Fail when a function returns a non-zero status code.
#/    -e, --false
#/          Treat the string "false" as empty for conditionals.
#/    -h, --help
#/          This message.
#/    -s=FILE, --source=FILE
#/          Load FILE into the environment before processing templates.
#/          Can be used multiple times.
#
# 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


# Public: Template parser function.  Writes templates to stdout.
#
# $0 - Name of the mo file, used for getting the help message.
# $@ - Filenames to parse.
#
# Options:
#
#     --allow-function-arguments
#
# Permit functions in templates to be called with additional arguments.  This
# puts template data directly in to the path of an eval statement. Use with
# caution. Not listed in the help because it only makes sense when mo is
# sourced.
#
#     -u, --fail-not-set
#
# Fail upon expansion of an unset variable.  Default behavior is to silently
# ignore and expand into empty string.
#
#     -x, --fail-on-function
#
# Fail when a function used by a template returns an error status code.
# Alternately, ou may set the MO_FAIL_ON_FUNCTION environment variable to a
# non-empty value to enable this behavior.
#
#     -e, --false
#
# Treat "false" as an empty value.  You may set the MO_FALSE_IS_EMPTY
# environment variable instead to a non-empty value to enable this behavior.
#
#     -h, --help
#
# Display a help message.
#
#     -s=FILE, --source=FILE
#
# Source a file into the environment before processing template files.
# This can be used multiple times.
#
#     --
#
# Used to indicate the end of options.  You may optionally use this when
# filenames may start with two 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. This puts the content from the
#                  template directly into an eval statement. Use with extreme
#                  care.
# MO_FUNCTION_ARGS - Arguments passed to the function
# 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_ORIGINAL_COMMAND - Used to find the `mo` program in order to generate a
#                  help message.
#
# Returns nothing.
mo() (
    # This function executes in a subshell so IFS is reset.
    # Namespace this variable so we don't conflict with desired values.
    local moContent f2source files doubleHyphens

    IFS=$' \n\t'
    files=()
    doubleHyphens=false

    if [[ $# -gt 0 ]]; then
        for arg in "$@"; do
            if $doubleHyphens; then
                #: After we encounter two hyphens together, all the rest
                #: of the arguments are files.
                files=("${files[@]}" "$arg")
            else
                case "$arg" in
                    -h|--h|--he|--hel|--help|-\?)
                        moUsage "$0"
                        exit 0
                        ;;

                    --allow-function-arguments)
                        # shellcheck disable=SC2030
                        MO_ALLOW_FUNCTION_ARGUMENTS=true
                        ;;

                    -u | --fail-not-set)
                        # shellcheck disable=SC2030
                        MO_FAIL_ON_UNSET=true
                        ;;

                    -x | --fail-on-function)
                        # shellcheck disable=SC2030
                        MO_FAIL_ON_FUNCTION=true
                        ;;

                    -e | --false)
                        # shellcheck disable=SC2030
                        MO_FALSE_IS_EMPTY=true
                        ;;

                    -s=* | --source=*)
                        if [[ "$arg" == --source=* ]]; then
                            f2source="${arg#--source=}"
                        else
                            f2source="${arg#-s=}"
                        fi

                        if [[ -f "$f2source" ]]; then
                            # shellcheck disable=SC1090
                            . "$f2source"
                        else
                            echo "No such file: $f2source" >&2
                            exit 1
                        fi
                        ;;

                    --)
                        #: Set a flag indicating we've encountered double hyphens
                        doubleHyphens=true
                        ;;

                    *)
                        #: Every arg that is not a flag or a option should be a file
                        files=(${files[@]+"${files[@]}"} "$arg")
                        ;;
                esac
            fi
        done
    fi

    moGetContent moContent "${files[@]}" || return 1
    moParse "$moContent" "" true
)


# Internal: Call a function.
#
# $1 - Variable for output
# $2 - Function to call
# $3 - Content to pass
# $4 - Additional arguments as a single string
#
# This can be dangerous, especially if you are using tags like
# {{someFunction ; rm -rf / }}
#
# Returns nothing.
moCallFunction() {
    local moArgs moContent moFunctionArgs moFunctionResult

    moArgs=()
    moTrimWhitespace moFunctionArgs "$4"

    # shellcheck disable=SC2031
    if [[ -n "${MO_ALLOW_FUNCTION_ARGUMENTS-}" ]]; then
        # Intentionally bad behavior
        # shellcheck disable=SC2206
        moArgs=($4)
    fi

    moContent=$(echo -n "$3" | MO_FUNCTION_ARGS="$moFunctionArgs" eval "$2" "${moArgs[@]}") || {
        moFunctionResult=$?
        # shellcheck disable=SC2031
        if [[ -n "${MO_FAIL_ON_FUNCTION-}" && "$moFunctionResult" != 0 ]]; then
            echo "Function '$2' with args (${moArgs[*]+"${moArgs[@]}"}) failed with status code $moFunctionResult"
            exit "$moFunctionResult"
        fi
    }

    # shellcheck disable=SC2031
    local "$1" && moIndirect "$1" "$moContent"
}


# Internal: Scan content until the right end tag is found.  Creates an array
# with the following members:
#
#   [0] = Content before end tag
#   [1] = End tag (complete tag)
#   [2] = Content after end tag
#
# Everything using this function uses the "standalone tags" logic.
#
# $1 - Name of variable for the array
# $2 - Content
# $3 - Name of end tag
# $4 - If -z, do standalone tag processing before finishing
#
# Returns nothing.
moFindEndTag() {
    local content remaining scanned standaloneBytes tag

    #: Find open tags
    scanned=""
    moSplit content "$2" '{{' '}}'

    while [[ "${#content[@]}" -gt 1 ]]; do
        moTrimWhitespace tag "${content[1]}"

        #: Restore content[1] before we start using it
        content[1]='{{'"${content[1]}"'}}'

        case $tag in
            '#'* | '^'*)
                #: Start another block
                scanned="${scanned}${content[0]}${content[1]}"
                moTrimWhitespace tag "${tag:1}"
                moFindEndTag content "${content[2]}" "$tag" "loop"
                scanned="${scanned}${content[0]}${content[1]}"
                remaining=${content[2]}
                ;;

            '/'*)
                #: End a block - could be ours
                moTrimWhitespace tag "${tag:1}"
                scanned="$scanned${content[0]}"

                if [[ "$tag" == "$3" ]]; then
                    #: Found our end tag
                    if [[ -z "${4-}" ]] && moIsStandalone standaloneBytes "$scanned" "${content[2]}" true; then
                        #: This is also a standalone tag - clean up whitespace
                        #: and move those whitespace bytes to the "tag" element
                        # shellcheck disable=SC2206
                        standaloneBytes=( $standaloneBytes )
                        content[1]="${scanned:${standaloneBytes[0]}}${content[1]}${content[2]:0:${standaloneBytes[1]}}"
                        scanned="${scanned:0:${standaloneBytes[0]}}"
                        content[2]="${content[2]:${standaloneBytes[1]}}"
                    fi

                    local "$1" && moIndirectArray "$1" "$scanned" "${content[1]}" "${content[2]}"
                    return 0
                fi

                scanned="$scanned${content[1]}"
                remaining=${content[2]}
                ;;

            *)
                #: Ignore all other tags
                scanned="${scanned}${content[0]}${content[1]}"
                remaining=${content[2]}
                ;;
        esac

        moSplit content "$remaining" '{{' '}}'
    done

    #: Did not find our closing tag
    scanned="$scanned${content[0]}"
    local "$1" && moIndirectArray "$1" "${scanned}" "" ""
}


# Internal: Find the first index of a substring.  If not found, sets the
# index to -1.
#
# $1 - Destination variable for the index
# $2 - Haystack
# $3 - Needle
#
# Returns nothing.
moFindString() {
    local pos string

    string=${2%%$3*}
    [[ "$string" == "$2" ]] && pos=-1 || pos=${#string}
    local "$1" && moIndirect "$1" "$pos"
}


# Internal: Generate a dotted name based on current context and target name.
#
# $1 - Target variable to store results
# $2 - Context name
# $3 - Desired variable name
#
# Returns nothing.
moFullTagName() {
    if [[ -z "${2-}" ]] || [[ "$2" == *.* ]]; then
        local "$1" && moIndirect "$1" "$3"
    else
        local "$1" && moIndirect "$1" "${2}.${3}"
    fi
}


# Internal: Fetches the content to parse into a variable.  Can be a list of
# partials for files or the content from stdin.
#
# $1   - Variable name to assign this content back as
# $2-@ - File names (optional)
#
# Returns nothing.
moGetContent() {
    local moContent moFilename moTarget

    moTarget=$1
    shift
    if [[ "${#@}" -gt 0 ]]; then
        moContent=""

        for moFilename in "$@"; do
            #: This is so relative paths work from inside template files
            moContent="$moContent"'{{>'"$moFilename"'}}'
        done
    else
        moLoadFile moContent || return 1
    fi

    local "$moTarget" && moIndirect "$moTarget" "$moContent"
}


# Internal: Indent a string, placing the indent at the beginning of every
# line that has any content.
#
# $1 - Name of destination variable to get an array of lines
# $2 - The indent string
# $3 - The string to reindent
#
# Returns nothing.
moIndentLines() {
    local content fragment len posN posR result trimmed

    result=""

    #: Remove the period from the end of the string.
    len=$((${#3} - 1))
    content=${3:0:$len}

    if [[ -z "${2-}" ]]; then
        local "$1" && moIndirect "$1" "$content"

        return 0
    fi

    moFindString posN "$content" $'\n'
    moFindString posR "$content" $'\r'

    while [[ "$posN" -gt -1 ]] || [[ "$posR" -gt -1 ]]; do
        if [[ "$posN" -gt -1 ]]; then
            fragment="${content:0:$posN + 1}"
            content=${content:$posN + 1}
        else
            fragment="${content:0:$posR + 1}"
            content=${content:$posR + 1}
        fi

        moTrimChars trimmed "$fragment" false true " " $'\t' $'\n' $'\r'

        if [[ -n "$trimmed" ]]; then
            fragment="$2$fragment"
        fi

        result="$result$fragment"

        moFindString posN "$content" $'\n'
        moFindString posR "$content" $'\r'

        # If the content ends in a newline, do not indent.
        if [[ "$posN" -eq ${#content} ]]; then
            # Special clause for \r\n
            if [[ "$posR" -eq "$((posN - 1))" ]]; then
                posR=-1
            fi

            posN=-1
        fi

        if [[ "$posR" -eq ${#content} ]]; then
            posR=-1
        fi
    done

    moTrimChars trimmed "$content" false true " " $'\t'

    if [[ -n "$trimmed" ]]; then
        content="$2$content"
    fi

    result="$result$content"

    local "$1" && moIndirect "$1" "$result"
}


# Internal: Send a variable up to the parent of the caller of this function.
#
# $1 - Variable name
# $2 - Value
#
# Examples
#
#   callFunc () {
#       local "$1" && moIndirect "$1" "the value"
#   }
#   callFunc dest
#   echo "$dest"  # writes "the value"
#
# Returns nothing.
moIndirect() {
    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" && moIndirectArray "$1" "${myArray[@]}"
#   }
#   callFunc dest
#   echo "${dest[@]}" # writes "one two three"
#
# Returns nothing.
moIndirectArray() {
    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: 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.
moIsArray() {
    # 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 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 moIsFunction moo; then
#       echo "moo is a defined function"
#   fi
#
# Returns 0 if the name is a function, 1 otherwise.
moIsFunction() {
    local functionList functionName

    functionList=$(declare -F)
    # shellcheck disable=SC2206
    functionList=( ${functionList//declare -f /} )

    for functionName in "${functionList[@]}"; do
        if [[ "$functionName" == "$1" ]]; then
            return 0
        fi
    done

    return 1
}


# Internal: Determine if the tag is a standalone tag based on whitespace
# before and after the tag.
#
# Passes back a string containing two numbers in the format "BEFORE AFTER"
# like "27 10".  It indicates the number of bytes remaining in the "before"
# string (27) and the number of bytes to trim in the "after" string (10).
# Useful for string manipulation:
#
# $1 - Variable to set for passing data back
# $2 - Content before the tag
# $3 - Content after the tag
# $4 - true/false: is this the beginning of the content?
#
# Examples
#
#   moIsStandalone RESULT "$before" "$after" false || return 0
#   RESULT_ARRAY=( $RESULT )
#   echo "${before:0:${RESULT_ARRAY[0]}}...${after:${RESULT_ARRAY[1]}}"
#
# Returns nothing.
moIsStandalone() {
    local afterTrimmed beforeTrimmed char

    moTrimChars beforeTrimmed "$2" false true " " $'\t'
    moTrimChars afterTrimmed "$3" true false " " $'\t'
    char=$((${#beforeTrimmed} - 1))
    char=${beforeTrimmed:$char}

    # If the content before didn't end in a newline
    if [[ "$char" != $'\n' ]] && [[ "$char" != $'\r' ]]; then
        # and there was content or this didn't start the file
        if [[ -n "$char" ]] || ! $4; then
            # then this is not a standalone tag.
            return 1
        fi
    fi

    char=${afterTrimmed:0:1}

    # If the content after doesn't start with a newline and it is something
    if [[ "$char" != $'\n' ]] && [[ "$char" != $'\r' ]] && [[ -n "$char" ]]; then
        # then this is not a standalone tag.
        return 2
    fi

    if [[ "$char" == $'\r' ]] && [[ "${afterTrimmed:1:1}" == $'\n' ]]; then
        char="$char"$'\n'
    fi

    local "$1" && moIndirect "$1" "$((${#beforeTrimmed})) $((${#3} + ${#char} - ${#afterTrimmed}))"
}


# Internal: Join / implode an array
#
# $1    - Variable name to receive the joined content
# $2    - Joiner
# $3-$* - Elements to join
#
# Returns nothing.
moJoin() {
    local joiner part result target

    target=$1
    joiner=$2
    result=$3
    shift 3

    for part in "$@"; do
        result="$result$joiner$part"
    done

    local "$target" && moIndirect "$target" "$result"
}


# Internal: Read a file into a variable.
#
# $1 - Variable name to receive the file's content
# $2 - Filename to load - if empty, defaults to /dev/stdin
#
# Returns nothing.
moLoadFile() {
    local content len

    # The subshell removes any trailing newlines.  We forcibly add
    # a dot to the content to preserve all newlines.
    # As a future optimization, it would be worth considering removing
    # cat and replacing this with a read loop.

    content=$(cat -- "${2:-/dev/stdin}" && echo '.') || return 1
    len=$((${#content} - 1))
    content=${content:0:$len}  # Remove last dot

    local "$1" && moIndirect "$1" "$content"
}


# Internal: Process a chunk of content some number of times.  Writes output
# to stdout.
#
# $1   - Content to parse repeatedly
# $2   - Tag prefix (context name)
# $3-@ - Names to insert into the parsed content
#
# Returns nothing.
moLoop() {
    local content context contextBase

    content=$1
    contextBase=$2
    shift 2

    while [[ "${#@}" -gt 0 ]]; do
        moFullTagName context "$contextBase" "$1"
        moParse "$content" "$context" false
        shift
    done
}


# Internal: Parse a block of text, writing the result to stdout.
#
# $1 - Block of text to change
# $2 - Current name (the variable NAME for what {{.}} means)
# $3 - true when no content before this, false otherwise
#
# Returns nothing.
moParse() {
    # Keep naming variables mo* here to not overwrite needed variables
    # used in the string replacements
    local moArgs moBlock moContent moCurrent moIsBeginning moNextIsBeginning moTag

    moCurrent=$2
    moIsBeginning=$3

    # Find open tags
    moSplit moContent "$1" '{{' '}}'

    while [[ "${#moContent[@]}" -gt 1 ]]; do
        moTrimWhitespace moTag "${moContent[1]}"
        moNextIsBeginning=false

        case $moTag in
            '#'*)
                # Loop, if/then, or pass content through function
                # Sets context
                moStandaloneAllowed moContent "${moContent[@]}" "$moIsBeginning"
                moTrimWhitespace moTag "${moTag:1}"

                # Split arguments from the tag name. Arguments are passed to
                # functions.
                moArgs=$moTag
                moTag=${moTag%% *}
                moTag=${moTag%%$'\t'*}
                moArgs=${moArgs:${#moTag}}
                moFindEndTag moBlock "$moContent" "$moTag"
                moFullTagName moTag "$moCurrent" "$moTag"

                if moTest "$moTag"; then
                    # Show / loop / pass through function
                    if moIsFunction "$moTag"; then
                        moCallFunction moContent "$moTag" "${moBlock[0]}" "$moArgs"
                        moParse "$moContent" "$moCurrent" false
                        moContent="${moBlock[2]}"
                    elif moIsArray "$moTag"; then
                        eval "moLoop \"\${moBlock[0]}\" \"$moTag\" \"\${!${moTag}[@]}\""
                    else
                        moParse "${moBlock[0]}" "$moCurrent" true
                    fi
                fi

                moContent="${moBlock[2]}"
                ;;

            '>'*)
                # Load partial - get name of file relative to cwd
                moPartial moContent "${moContent[@]}" "$moIsBeginning" "$moCurrent"
                moNextIsBeginning=${moContent[1]}
                moContent=${moContent[0]}
                ;;

            '/'*)
                # Closing tag - If hit in this loop, we simply ignore
                # Matching tags are found in moFindEndTag
                moStandaloneAllowed moContent "${moContent[@]}" "$moIsBeginning"
                ;;

            '^'*)
                # Display section if named thing does not exist
                moStandaloneAllowed moContent "${moContent[@]}" "$moIsBeginning"
                moTrimWhitespace moTag "${moTag:1}"
                moFindEndTag moBlock "$moContent" "$moTag"
                moFullTagName moTag "$moCurrent" "$moTag"

                if ! moTest "$moTag"; then
                    moParse "${moBlock[0]}" "$moCurrent" false "$moCurrent"
                fi

                moContent="${moBlock[2]}"
                ;;

            '!'*)
                # Comment - ignore the tag content entirely
                # Trim spaces/tabs before the comment
                moStandaloneAllowed moContent "${moContent[@]}" "$moIsBeginning"
                ;;

            .)
                # Current content (environment variable or function)
                moStandaloneDenied moContent "${moContent[@]}"
                moShow "$moCurrent" "$moCurrent"
                ;;

            '=')
                # Change delimiters
                # Any two non-whitespace sequences separated by whitespace.
                # This tag is ignored.
                moStandaloneAllowed moContent "${moContent[@]}" "$moIsBeginning"
                ;;

            '{'*)
                # Unescaped - split on }}} not }}
                moStandaloneDenied moContent "${moContent[@]}"
                moContent="${moTag:1}"'}}'"$moContent"
                moSplit moContent "$moContent" '}}}'
                moTrimWhitespace moTag "${moContent[0]}"
                moArgs=$moTag
                moTag=${moTag%% *}
                moTag=${moTag%%$'\t'*}
                moArgs=${moArgs:${#moTag}}
                moFullTagName moTag "$moCurrent" "$moTag"
                moContent=${moContent[1]}

                # Now show the value
                # Quote moArgs here, do not quote it later.
                moShow "$moTag" "$moCurrent" "$moArgs"
                ;;

            '&'*)
                # Unescaped
                moStandaloneDenied moContent "${moContent[@]}"
                moTrimWhitespace moTag "${moTag:1}"
                moFullTagName moTag "$moCurrent" "$moTag"
                moShow "$moTag" "$moCurrent"
                ;;

            *)
                # Normal environment variable or function call
                moStandaloneDenied moContent "${moContent[@]}"
                moArgs=$moTag
                moTag=${moTag%% *}
                moTag=${moTag%%$'\t'*}
                moArgs=${moArgs:${#moTag}}
                moFullTagName moTag "$moCurrent" "$moTag"

                # Quote moArgs here, do not quote it later.
                moShow "$moTag" "$moCurrent" "$moArgs"
                ;;
        esac

        moIsBeginning=$moNextIsBeginning
        moSplit moContent "$moContent" '{{' '}}'
    done

    echo -n "${moContent[0]}"
}


# Internal: Process a partial.
#
# Indentation should be applied to the entire partial.
#
# This sends back the "is beginning" flag because the newline after a
# standalone partial is consumed. That newline is very important in the middle
# of content. We send back this flag to reset the processing loop's
# `moIsBeginning` variable, so the software thinks we are back at the
# beginning of a file and standalone processing continues to work.
#
# Prefix all variables.
#
# $1 - Name of destination variable. Element [0] is the content, [1] is the
#      true/false flag indicating if we are at the beginning of content.
# $2 - Content before the tag that was not yet written
# $3 - Tag content
# $4 - Content after the tag
# $5 - true/false: is this the beginning of the content?
# $6 - Current context name
#
# Returns nothing.
moPartial() {
    # Namespace variables here to prevent conflicts.
    local moContent moFilename moIndent moIsBeginning moPartial moStandalone moUnindented

    if moIsStandalone moStandalone "$2" "$4" "$5"; then
        # shellcheck disable=SC2206
        moStandalone=( $moStandalone )
        echo -n "${2:0:${moStandalone[0]}}"
        moIndent=${2:${moStandalone[0]}}
        moContent=${4:${moStandalone[1]}}
        moIsBeginning=true
    else
        moIndent=""
        echo -n "$2"
        moContent=$4
        moIsBeginning=$5
    fi

    moTrimWhitespace moFilename "${3:1}"

    # Execute in subshell to preserve current cwd and environment
    (
        # It would be nice to remove `dirname` and use a function instead,
        # but that's difficult when you're only given filenames.
        cd "$(dirname -- "$moFilename")" || exit 1
        moUnindented="$(
            moLoadFile moPartial "${moFilename##*/}" || exit 1
            moParse "${moPartial}" "$6" true

            # Fix bash handling of subshells and keep trailing whitespace.
            # This is removed in moIndentLines.
            echo -n "."
        )" || exit 1
        moIndentLines moPartial "$moIndent" "$moUnindented"
        echo -n "$moPartial"
    ) || exit 1

    # If this is a standalone tag, the trailing newline after the tag is
    # removed and the contents of the partial are added, which typically
    # contain a newline. We need to send a signal back to the processing
    # loop that the moIsBeginning flag needs to be turned on again.
    #
    # [0] is the content, [1] is that flag.
    local "$1" && moIndirectArray "$1" "$moContent" "$moIsBeginning"
}


# Internal: Show an environment variable or the output of a function to
# stdout.
#
# Limit/prefix any variables used.
#
# $1 - Name of environment variable or function
# $2 - Current context
# $3 - Arguments string if $1 is a function
#
# Returns nothing.
moShow() {
    # Namespace these variables
    local moJoined moNameParts moContent

    if moIsFunction "$1"; then
        moCallFunction moContent "$1" "" "$3"
        moParse "$moContent" "$2" false
        return 0
    fi

    moSplit moNameParts "$1" "."

    if [[ -z "${moNameParts[1]-}" ]]; then
        if moIsArray "$1"; then
            eval moJoin moJoined "," "\${$1[@]}"
            echo -n "$moJoined"
        else
            # shellcheck disable=SC2031
            if moTestVarSet "$1"; then
                echo -n "${!1}"
            elif [[ -n "${MO_FAIL_ON_UNSET-}" ]]; then
                echo "Env variable not set: $1" >&2
                exit 1
            fi
        fi
    else
        # Further subindexes are disallowed
        eval "echo -n \"\${${moNameParts[0]}[${moNameParts[1]%%.*}]}\""
    fi
}


# Internal: Split a larger string into an array.
#
# $1 - Destination variable
# $2 - String to split
# $3 - Starting delimiter
# $4 - Ending delimiter (optional)
#
# Returns nothing.
moSplit() {
    local pos result

    result=( "$2" )
    moFindString pos "${result[0]}" "$3"

    if [[ "$pos" -ne -1 ]]; then
        # The first delimiter was found
        result[1]=${result[0]:$pos + ${#3}}
        result[0]=${result[0]:0:$pos}

        if [[ -n "${4-}" ]]; then
            moFindString pos "${result[1]}" "$4"

            if [[ "$pos" -ne -1 ]]; then
                # The second delimiter was found
                result[2]="${result[1]:$pos + ${#4}}"
                result[1]="${result[1]:0:$pos}"
            fi
        fi
    fi

    local "$1" && moIndirectArray "$1" "${result[@]}"
}


# Internal: Handle the content for a standalone tag.  This means removing
# whitespace (not newlines) before a tag and whitespace and a newline after
# a tag.  That is, assuming, that the line is otherwise empty.
#
# $1 - Name of destination "content" variable.
# $2 - Content before the tag that was not yet written
# $3 - Tag content (not used)
# $4 - Content after the tag
# $5 - true/false: is this the beginning of the content?
#
# Returns nothing.
moStandaloneAllowed() {
    local bytes

    if moIsStandalone bytes "$2" "$4" "$5"; then
        # shellcheck disable=SC2206
        bytes=( $bytes )
        echo -n "${2:0:${bytes[0]}}"
        local "$1" && moIndirect "$1" "${4:${bytes[1]}}"
    else
        echo -n "$2"
        local "$1" && moIndirect "$1" "$4"
    fi
}


# Internal: Handle the content for a tag that is never "standalone".  No
# adjustments are made for newlines and whitespace.
#
# $1 - Name of destination "content" variable.
# $2 - Content before the tag that was not yet written
# $3 - Tag content (not used)
# $4 - Content after the tag
#
# Returns nothing.
moStandaloneDenied() {
    echo -n "$2"
    local "$1" && moIndirect "$1" "$4"
}


# Internal: Determines if the named thing is a function or if it is a
# non-empty environment variable.  When MO_FALSE_IS_EMPTY is set to a
# non-empty value, then "false" is also treated is an empty value.
#
# Do not use variables without prefixes here if possible as this needs to
# check if any name exists in the environment
#
# $1                - Name of environment variable or function
# $2                - Current value (our context)
# MO_FALSE_IS_EMPTY - When set to a non-empty value, this will say the
#                     string value "false" is empty.
#
# Returns 0 if the name is not empty, 1 otherwise.  When MO_FALSE_IS_EMPTY
# is set, this returns 1 if the name is "false".
moTest() {
    # Test for functions
    moIsFunction "$1" && return 0

    if moIsArray "$1"; then
        # Arrays must have at least 1 element
        eval "[[ \"\${#${1}[@]}\" -gt 0 ]]" && return 0
    else
        # If MO_FALSE_IS_EMPTY is set, then return 1 if the value of
        # the variable is "false".
        # shellcheck disable=SC2031
        [[ -n "${MO_FALSE_IS_EMPTY-}" ]] && [[ "${!1-}" == "false" ]] && return 1

        # Environment variables must not be empty
        [[ -n "${!1-}" ]] && 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.
#
# Returns true (0) if the variable is set, 1 if the variable is unset.
moTestVarSet() {
    [[ "${!1-a}" == "${!1-b}" ]]
}


# Internal: Trim the leading whitespace only.
#
# $1   - Name of destination variable
# $2   - The string
# $3   - true/false - trim front?
# $4   - true/false - trim end?
# $5-@ - Characters to trim
#
# Returns nothing.
moTrimChars() {
    local back current front last target varName

    target=$1
    current=$2
    front=$3
    back=$4
    last=""
    shift 4 # Remove target, string, trim front flag, trim end flag

    while [[ "$current" != "$last" ]]; do
        last=$current

        for varName in "$@"; do
            $front && current="${current/#$varName}"
            $back && current="${current/%$varName}"
        done
    done

    local "$target" && moIndirect "$target" "$current"
}


# Internal: Trim leading and trailing whitespace from a string.
#
# $1 - Name of variable to store trimmed string
# $2 - The string
#
# Returns nothing.
moTrimWhitespace() {
    local result

    moTrimChars result "$2" true true $'\r' $'\n' $'\t' " "
    local "$1" && moIndirect "$1" "$result"
}


# 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.
moUsage() {
    grep '^#/' "${MO_ORIGINAL_COMMAND}" | cut -c 4-
    echo ""
    echo "MO_VERSION=$MO_VERSION"
}


# Save the original command's path for usage later
MO_ORIGINAL_COMMAND="$(cd "${BASH_SOURCE[0]%/*}" || exit 1; pwd)/${BASH_SOURCE[0]##*/}"
MO_VERSION="2.2.0"

# If sourced, load all functions.
# If executed, perform the actions as expected.
if [[ "$0" == "${BASH_SOURCE[0]}" ]] || [[ -z "${BASH_SOURCE[0]}" ]]; then
    mo "$@"
fi
