bash_utils

#!/bin/bash

################################################################################
#
# Installation script for cocosim dependencies (lustrec, zustre, kind2).
#
# Author: Maxime Arthaud <maxime.arthaud@nasa.gov>
#
# Copyright (c) 2019 United States Government as represented by the
# Administrator of the National Aeronautics and Space Administration.
# All Rights Reserved.
#
################################################################################
function init_colors() {
    if (( use_colors )); then
        coff="\033[0m"
        cbold="\033[1m"
        cred="\033[31m"
        cgreen="\033[32m"
        cyellow="\033[33m"
        cblue="\033[34m"
        cpurple="\033[35m"
        ccyan="\033[36m"
        cwhite="\033[37m"
    else
        coff=""
        cbold=""
        cred=""
        cgreen=""
        cyellow=""
        cblue=""
        cpurple=""
        ccyan=""
        cwhite=""
    fi
}

#####################
# General functions #
#####################



function usage() {
    echo "usage: $progname [OPTION]..."
    echo ""
    echo "Build and install cocosim dependencies without root access."
    echo ""
    echo "Defaults for the options are specified in brackets."
    echo ""
    echo "Configuration:"
    echo "  --prefix=PREFIX      install files in PREFIX"
    echo "  --builddir=BUILDDIR  configure for building on BUILDDIR [$build_dir]"
    echo ""
    echo "Optional arguments:"
    echo "  -h, --help           display this help and exit"
    echo "  -v, --verbose        make this script more verbose"
    echo "  -f, --force          force"
    echo "  --no-colors          disable colors"
    echo "  --jobs=N             allow N jobs at once [$njobs]"
    echo "  --lustrec-url=URL    lustrec git repository url [$lustrec_url]"
    echo "  --lustrec-branch=BR  lustrec branch [$lustrec_branch]"
    echo "  --zustre-url=URL     zustre git repository url [$zustre_url]"
    echo "  --zustre-branch=BR   zustre branch [$zustre_branch]"
    echo "  --kind2-url=URL      kind2 git repository url [$kind2_url]"
    echo "  --kind2-branch=BR    kind2 branch [$kind2_branch]"
}

function short_help() {
    echo "Try '$progname -h' for more information." >&2
}

function error() {
    echo "$progname: error: $1" >&2
}

# Split command line arguments, i.e:
#   -ab -> -a -b
#   --foo=bar -> --foo bar
#
# Split arguments are stored in the ARGS array
#
# Parameters:
#   $1,$2,$3,...,$n: arguments to split
function explode_args() {
    unset ARGS
    local arg=$1 key value

    while [[ $arg ]]; do
        [[ $arg = "--" ]] && ARGS+=("$@") && break

        # Short options
        if [[ ${arg:0:1} = "-" && ${arg:1:1} != "-" ]]; then
            ARGS+=("-${arg:1:1}")
            (( ${#arg} > 2 )) && arg="-${arg:2}" || { shift; arg=$1; }
        # Long options
        elif [[ ${arg:0:2} = "--" ]]; then
            # Split argument at '=':
            # e.g --foo=bar -> key=--foo, value=bar
            key=${arg%%=*}; value=${arg#*=}
            ARGS+=("$key")
            [[ "$key" != "$value" ]] && ARGS+=("$value")
            shift; arg=$1
        else
            ARGS+=("$arg"); shift; arg=$1
        fi
    done
}


# Return a concatenation of strings separated by a given separator, i.e:
#   , a b c -> a,b,c
#
# Parameters:
#   $1: separator
#   $2,$2,$4,...,$n: arguments to join
function join() {
    local sep=$1; shift
    echo -n "$1"; shift
    printf "%s" "${@/#/$sep}"
}

# Check if a command exists
function command_exists() {
    command -v "$1" >/dev/null 2>&1
}

# Return the absolute path of the given filename
function abs_path() {
    local arg=${1/#\~/$HOME}
    local dirname=$(dirname "$arg") basename=$(basename "$arg")

    while [[ ! -d "$dirname" ]]; do
        basename="$(basename "$dirname")/$basename"
        dirname=$(dirname "$dirname")
    done

    pushd . >/dev/null
    cd "$dirname"
    dirname=$(pwd)
    popd >/dev/null

    if [[ "$dirname" = "/" ]]; then
        echo -n "/$basename"
    else
        echo -n "$dirname/$basename"
    fi
}


# Find a pattern within the standard input
#
# If found, return 0 and print the given captured group
# Otherwise, return 1
#
# Parameters:
#   $1: regular expression
#   $2: parenthesis group number to capture
function match() {
    while read -r line; do
        if [[ "$line" =~ $1 ]]; then
            echo -n "${BASH_REMATCH[$2]}"
            return 0
        fi
    done

    return 1
}

# Return the name of all binaries in the PATH matching a regular expression
function glob_binaries() {
    local IFS=:
    find $PATH \
        -maxdepth 1 \
        -regex ".*/$1" \
        -exec basename {} \; 2>/dev/null | sort -u
}

########################
# Download and extract #
########################

# Download a file from an URL.
#
# The file is stored under $download_dir and is named after the remote file
function download() {
    local url=$1 filename=$(basename "$1")

    cd "$download_dir"
    if [[ -f "$filename" ]]; then
        progress "Using already downloaded $filename from $url"
    else
        progress "Downloading $url"

        # Note: do not try to capture curl/wget output because it contains
        # the progress bar
        $download_agent "$url" || {
            rm -f "$filename"; error "Error while fetching $filename"; exit 6;
        }
    fi
}

# Download a file from an URL.
#
# Parameters:
#   $1: url
#   $2: new name for the archive
function download_rename() {
    local url=$1 filename=$2

    cd "$download_dir"
    if [[ -f "$filename" ]]; then
        progress "Using already downloaded $filename from $url"
    else
        progress "Downloading $url"

        # Note: do not try to capture curl/wget output because it contains
        # the progress bar
        $download_agent "$url" || {
            rm -f "$(basename "$1")"; error "Error while fetching $filename"; exit 6;
        }

        mv "$(basename "$1")" "$filename"
    fi
}

# Extract an archive and move the root directory
#
# Parameters:
#   $1: path to the archive
#   $2: destination path
function extract() {
    local archive_path=$1 destination_path=$2
    local archive_filename=$(basename "$archive_path")
    local archive_directory=$(dirname "$archive_path")

    progress "Extracting $archive_filename"

    cd "$archive_directory"
    run_log_debug tar xf "$archive_filename" || {
        error "Error while extracting $archive_filename"; exit 7;
    }

    root_directory=$archive_filename
    for ext in .gz .xz .bz2 .tar; do
        root_directory=${root_directory%$ext}
    done

    [[ -d "$root_directory" ]] || assert_failed "$root_directory does not exist"

    rm -rf "$destination_path"
    mv "$root_directory" "$destination_path"
}

# Download an archive from an URL and extract it at the given location
#
# Parameters:
#   $1: URL
#   $2: destination path
function download_extract() {
    local url=$1 destination_path=$2
    download "$url"
    extract "$download_dir/$(basename "$url")" "$destination_path"
}

# Clone a git repository in the download directory, and copy it at the given
# location
#
# Parameters:
#   $1: URL
#   $2: branch name (e.g, master)
#   $3: destination path
function git_clone() {
    local url=$1 branch=$2 destination_path=$3 dirname=$(basename "$3")

    # download
    cd "$download_dir"
    if [[ -d "$dirname" ]]; then
        progress "Using already downloaded $dirname from $url branch $branch"
        cd "$dirname"
        git pull
        git checkout $branch
    else
        progress "Downloading $url branch $branch"

        if (( verbose == 0 )); then
            run_log_quiet git clone --depth 1 --branch "$branch" "$url" "$dirname"
        else
            git clone --depth 1 --branch "$branch" "$url" "$dirname"
        fi || {
            rm -rf "$dirname"; error "Error while fetching $dirname"; exit 6;
        }
    fi

    # copy
    rm -rf "$destination_path"
    cp -r "$download_dir/$dirname" "$destination_path"
}

#####################
# Version detection #
#####################

version_regex='[0-9]+(\.[0-9a-z\-]+)*'

# Parse and detect the version of cmake, given the command name
function cmake_parse_version() {
    local version_output=$("$1" --version 2>&1)

    debug "'$1 --version':\n$version_output"

    echo "$version_output" | match "^cmake version ($version_regex)$" 1
}

# Parse and detect the version of m4, given the command name
function m4_parse_version() {
    local version_output=$("$1" --version 2>&1)

    debug "'$1 --version':\n$version_output"

    echo "$version_output" | match "^((GNU M4)|(m4 \(GNU M4\))) ($version_regex)$" 4
}

# Parse and detect the version of python, given the command name
function python_parse_version() {
    local version_output=$("$1" --version 2>&1)

    debug "'$1 --version':\n$version_output"

    echo "$version_output" | match "^Python ($version_regex)$" 1
}

# Check if a python version satisfies cocosim requirements
function python_satisfies_requirements() {
    local version=$1

    #Check that the version that was found is greater than or equal to the required version.
    [ "$(printf '%s\n' "$version" "$python_required_version" | sort -V | head -n1)" = "$python_required_version" ]
}

# Parse and detect the version of autoconf, given the command name
function autoconf_parse_version() {
    local version_output=$("$1" --version 2>&1)

    debug "'$1 --version':\n$version_output"

    echo "$version_output" | match "^autoconf ((GNU Autoconf)) ($version_regex)$" 4
}

# Parse and detect the version of ocaml, given the command name
function ocaml_parse_version() {
    local version_output=$("$1" -version 2>&1)

    debug "'$1 -version':\n$version_output"

    echo "$version_output" | match "^The ((OCaml)|(Objective Caml)) toplevel, version ($version_regex)$" 4
}

# Parse and detect the version of ocamlbuild, given the command name
function ocamlbuild_parse_version() {
    local version_output=$("$1" -version 2>&1)

    debug "'$1 -version':\n$version_output"

    echo "$version_output" | match "^ocamlbuild ($version_regex)$" 1
}

# Parse and detect the version of menhir, given the command name
function menhir_parse_version() {
    local version_output=$("$1" --version 2>&1)

    debug "'$1 --version':\n$version_output"

    echo "$version_output" | match "^menhir, version ($version_regex)$" 1
}

# Parse and detect the version of spacer, given the command name
function spacer_parse_version() {
    local version_output=$("$1" --version 2>&1)

    debug "'$1 --version':\n$version_output"

    echo "$version_output" | match "^Z3 version ($version_regex).*$" 1
}

# Parse and detect the version of lustrec, given the command name
function lustrec_parse_version() {
    local version_output=$("$1" -version 2>&1)

    debug "'$1 -version':\n$version_output"

    echo "$version_output" | match "^Lustrec compiler, version ($version_regex)(\-[ \n\t]*[0-9]+)? \(.+\)$" 1
}

# Parse and detect the version of kind2, given the command name
function kind2_parse_version() {
    local version_output=$("$1" --version 2>&1)

    debug "'$1 --version':\n$version_output"
    echo "$version_output" | match "^kind2 ([a-zA-Z0-9\.\-]+)?$" 1
    #echo "$version_output" | match "^kind2 v($version_regex)(\-[0-9]+)?(\-[a-zA-Z0-9]+)?$" 1
}


######################
# Output and logging #
######################

function strip_colors() {
    echo -en "$1" | sed -E 's#'$(echo -en '\x1B')'\[([0-9]{1,3}((;[0-9]{1,3})*)?)?[m|K]##g'
}

function log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] [$1] $(strip_colors "$2")" >> "$log_file"
}

function error_msg() {
    echo -e "${cbold}${cred}==> Error: $1${coff}"
    log error "$1"
}

function warning() {
    echo -e "${cbold}${cyellow}==> Warning: $1${coff}"
    log warning "$1"
}

function success() {
    echo -e "${cbold}${cgreen}==> ${coff}${cbold}$1${coff}"
    log success "$1"
}

function progress() {
    echo -e "${cbold}${cblue}==> ${coff}${cbold}$1${coff}"
    log progress "$1"
}

function info() {
    echo -e "$1${coff}"
    log info "$1"
}

function debug() {
    if (( verbose >= 1 )); then
        echo -e "$1${coff}" >&2
    fi
    log debug "$1"
}

function assert_failed() {
    error_msg "Assertion failed: $1";
    exit 3;
}

function error_parse_version() {
    error_msg "Unable to detect the version of '$1'"; 
    #exit 5;
}

function error_patch() {
    error_msg "Error while patching $1. see $log_file_orig for more details."
    #exit 8
}

function error_configure() {
    if (( verbose == 0 )); then
        error_msg "Error while configuring $1. see $log_file_orig for more details."
    else
        error_msg "Error while configuring $1."
    fi
    # exit 9
}

function error_make() {
    if (( verbose == 0 )); then
        error_msg "Error while building $1. see $log_file_orig for more details."
    else
        error_msg "Error while building $1."
    fi
    # exit 10
}

function error_install() {
    if (( verbose == 0 )); then
        error_msg "Error while installing $1. see $log_file_orig for more details."
    else
        error_msg "Error while installing $1."
    fi
    # exit 11
}

function error_test() {
    if (( verbose == 0 )); then
        error_msg "Error while testing $1. see $log_file_orig for more details."
    else
        error_msg "Error while testing $1."
    fi
    #exit 12
}

# log everything, display everything
function run_log_debug() {
    "$@" 2>&1 | tee -a "$log_file" >&2
    return ${PIPESTATUS[0]}
}

# log everything, only display stderr
function run_log_verbose() {
    { "$@" >> "$log_file" 2>&3; } 3>&1 | tee -a "$log_file" >&2
    return ${PIPESTATUS[0]}
}

# log everything, do not display anything
function run_log_quiet() {
    "$@" >> "$log_file" 2>&1
}

function progress_run() {
    progress "$*"
    if (( verbose >= 2 )); then
        run_log_debug "$@"
    elif (( verbose == 1 )); then
        run_log_verbose "$@"
    else
        run_log_quiet "$@"
    fi
}


######################
# Activation scripts #
######################
function prepend_path() {
    PATH="$1:$PATH"
    act_prepend_path+=("$1")
}

function prepend_manpath() {
    export MANPATH="$1${MANPATH:+:$MANPATH}"
    act_prepend_manpath+=("$1")
}

function prepend_infopath() {
    export INFOPATH="$1${INFOPATH:+:$INFOPATH}"
    act_prepend_infopath+=("$1")
}

function prepend_python_path() {
    export PYTHONPATH="$1${PYTHONPATH:+:$PYTHONPATH}"
    act_prepend_python_path+=("$1")
}

function generate_env_path_line() {
    local var_name=$1; shift

    if (( $# > 0 )); then
        echo "export ${var_name}=\"$(join ':' "$@")\${${var_name}:+:\$${var_name}}\""
    fi
}