env.ab

import * from "std/fs"
import * from "std/text"

/// Retrieves the value of an environment variable, optionally sourcing it from a file if not already set.
pub fun get_env_var(var: Text, file: Text = ".env"): Text {
    let _var = trust $ echo "\$\{!var}" $
    if _var != "" {
        return _var
    }

    if file_exist(file) {
        trust $ source "{file}" $
        return trust $ echo "\$\{!var}" $
    }

    return ""
}

/// Loads the env file in the environment, using `xargs`.
pub fun load_env_file(file: Text = ".env"): Null {
    trust $ export "\$(xargs < {file})" > /dev/null $
}

/// Checks if a variable inside the shell session exists.
pub fun shell_isset(name: Text): Bool {
    $ [[ ! -z \$\{!{nameof name}+z} ]] $ failed {
        return false
    }
    return true
}

/// Sets a constant inside the shell session.
pub fun shell_constant_set(name: Text, val: Text): Null? {
    $ readonly \${nameof name}="\${nameof val}" 2> /dev/null $?
}

/// Gets a constant inside the shell session.
pub fun shell_constant_get(name: Text): Text? {
    return $ echo \$\{!{nameof name}} $?
}

/// Sets a constant inside the shell session.
pub fun shell_var_set(name: Text, val: Text): Null? {
    $ export \${nameof name}="\${nameof val}" 2> /dev/null $?
}

/// Gets a constant inside the shell session.
pub fun shell_var_get(name: Text): Text? {
    return $ echo \$\{!{nameof name}} $?
}

/// Removes a variable inside the shell session.
pub fun shell_unset(name: Text): Null? {
    $ unset {name} $?
}

/// Checks if a command exists.
pub fun is_command(command: Text): Bool {
    $ [ -x "\$(command -v {command})" ] $ failed {
        return false
    }
    return true
}

/// Creates a prompt and returns the value.
pub fun input(prompt: Text): Text {
    trust $ read -p "\${nameof prompt}" $
    return "\$REPLY"
}

/// Creates a prompt, hides any user input and returns the value.
pub fun input_hidden(prompt: Text): Text {
    trust {
        $ read -s -p "\${nameof prompt}" $
        $ echo "" >&2 $
    }
    return "\$REPLY"
}

/// Creates a confirm prompt (Yes/No), and returns true if the choice is Yes.
///
/// "No" is the default choice, set default_yes to true for "Yes" as default choice.
pub fun confirm(prompt: Text, default_yes: Bool = false): Bool {
    let choice_default = default_yes then " [\x1b[1mY/\x1b[0mn]" else " [y/\x1b[1mN\x1b[0m]"
    trust {
        $ printf "\x1b[1m{prompt}\x1b[0m{choice_default}" $
        $ read -s -n 1 $
        $ printf "\n" $
    }
    let result = lower(trust $ echo \$REPLY $)
    return result == "y" or (result == "" and default_yes)
}

/// Checks if the command has failed.
pub fun has_failed(command: Text): Bool {
    trust silent $ eval {command} $
    return status != 0
}

/// Checks if the script is running with a user with root permission.
pub fun is_root(): Bool {
    if trust $ id -u $ == "0" {
        return true
    }

    return false
}

/// `printf` the text following the arguments.
pub fun printf(format: Text, args: [Text] = [""]): Null {
    trust $ {nameof args}=("{format}" "\$\{{nameof args}[@]}") $
    trust $ printf "\$\{{nameof args}[@]}" $
}

/// Escapes the text to be used with `printf`.
pub fun printf_escape(text: Text): Text {
    return trust $ echo \${nameof text} | sed -e 's/\\\\/\\\\\\\\/g' -e "s/%/%%/g" $
}

/// Prepares a text with formatting options for `printf`.
pub fun text_shell(message: Text, style: Num, fg: Num, bg: Num): Text {
    return "\x1b[{style};{fg};{bg}m{printf_escape(message)}\x1b[0m"
}

/// Returns a text as bold.
pub fun text_bold(message: Text): Text {
    return "\x1b[1m{printf_escape(message)}\x1b[0m"
}

/// Returns a text as italic.
pub fun text_italic(message: Text): Text {
    return "\x1b[3m{printf_escape(message)}\x1b[0m"
}

/// Returns a text as underlined.
pub fun text_underlined(message: Text): Text {
    return "\x1b[4m{printf_escape(message)}\x1b[0m"
}

/// Prints a text with a specified color.
pub fun color_echo(message: Text, color: Num): Null {
    printf("\x1b[{color as Text}m%s\x1b[0m\n", [message])
}

/// Prints a text as a info message.
pub fun echo_info(message: Text): Null {
    printf("\x1b[1;3;97;44m%s\x1b[0m\n", [message])
}

/// Prints a text as a success message.
pub fun echo_success(message: Text): Null {
    printf("\x1b[1;3;97;42m%s\x1b[0m\n", [message])
}

/// Prints a text as a warning message.
pub fun echo_warning(message: Text): Null {
    printf("\x1b[1;3;97;43m%s\x1b[0m\n", [message])
}

/// Prints a text as a error and exits if the status code is greater than 0.
pub fun error(message: Text, exit_code: Num = 1): Null {
    printf("\x1b[1;3;97;41m%s\x1b[0m\n", [message])
    if exit_code > 0 : exit(exit_code)
}