backup

#!/bin/bash

driver=

opt_n=false

main() {
    case "$1" in
        backup)
            shift 1
            extract_opts "$@"
            run backup "${opts[0]}" "${args[@]}"
            res=$?
            banner_results $res
            exit $res
            ;;
        list)
            shift 1
            extract_opts "$@"
            run list "${opts[0]}" "${args[@]}"
            res=$?
            banner_results $res
            exit $res
            ;;
        restore)
            shift 1
            extract_opts "$@"
            run restore "${opts[0]}" "${args[@]}"
            res=$?
            banner_results $res
            exit $res
            ;;
        *)
            cat <<EOF
USAGE

    ${0##*/} backup DESCIPTOR  [OPTIONS...] [-- [...]]
    ${0##*/} restore DESCIPTOR [OPTIONS...] [-- [...]]
    ${0##*/} list DESCIPTOR    [OPTIONS...] [-- [...]]
    ${0##*/} help

NOTES ABOUT OPTIONS

    Key-values options are specified by one of these three syntax:
    
        --option=value
        --option value
        option=value

    Boolean options can be specified by one of these syntax:
    
        -option          enable option
        +option          disable option
        --no-option      disable option
        --disable-option disable option
        --enable-option  enable option
        
    Setting an option that isn't documented can result in undefined behaviour.

GANERAL OPTIONS

    -n  only print the commant that will be executed, do not run them

EOF
            return 1
            ;;
    esac
}

# READ  $@                 : Extract --VAR=VALUE --VAR VALUE, -BOOLOPT, +BOOLOPT
# WRITE $opt_<OPTNAME>     : the option extracted
# WRITE $opts              : option output array containing unparsed arguments
# WRITE $args              : anything after --
extract_opts(){
    opts=()
    args=()
    local _optname
    local _optval
    while [[ $# -gt 0 ]]; do
      case "$1" in
        --)
          shift
          args=("$@")
          break
        ;;
        --*=*)
          _optname="${1%%=*}"
          _optname="${_optname#--}"
          _optval="${1#*=}"
          _optval="${_optval//-/_}"
          eval "opt_$_optname='${_optval//'/'\"'\"'}'"
          shift
        ;;
        --*)
          _optname="${1#--}"
          _optval="$2"
          
          eval "opt_$_optname='${_optval//'/'\"'\"'}'"
          shift 2
        ;;
        --no-*)
          _optname="${1#--no-}"
          eval "opt_$_optname=false"
          shift
        ;;
        --disable-*)
          _optname="${1#--disable-}"
          eval "opt_$_optname=false"
          shift
        ;;
        --enable-*)
          _optname="${1#--enable-}"
          eval "opt_$_optname=true"
          shift
        ;;
        -*)
          _optname="${1#-}"
          eval "opt_$_optname=true"
          shift
        ;;
        +*)
          _optname="${1#+}"
          eval "opt_$_optname=false"
          shift
        ;;
        *)
          opts+=("$1")
          shift
        ;;
      esac
    done
}

# READ $driver
# READ $driver_dir
driver(){
    export BACKUP_DRY_RUN=$opt_n
    export BACKUP_DIR="$driver_dir/$subdir"
    export BACKUP_DRIVER_DIR="$driver_dir"
    export BACKUP_DRIVER_SOURCE_DIR="$(readlink -f $driver)"
    export BACKUP_DRIVER_SOURCE_DIR="${BACKUP_DRIVER_DIR%/*}"
    if "$driver" "$@"; then :; else
        local res=$?
        banner_error "Driver failed with status $res"
        (
        echo "    driver: $driver"
        echo "    arguments: $@"
        echo "    BACKUP_DRY_RUN=$BACKUP_DRY_RUN"
        echo "    BACKUP_DIR=$BACKUP_DIR"
        echo "    BACKUP_DRIVER_DIR=$BACKUP_DRIVER_DIR"
        echo "    BACKUP_DRIVER_SOURCE_DIR=$BACKUP_DRIVER_SOURCE_DIR"
        ) >&2
        return $res
    fi
}

# READ   $driver_dir    : the location where to find the driver
# READ   $driver        : if different than ":", will recurse parent directories
#                        to find driver
# WRITE  $driver        : the driver that was found
# WRITE  $driver_dir    : where the driver was found
# APPEND $driver_lookup : where the driver was looked up (array)
# WRITE  $?             : failure if driver was not found
find_driver(){
    if [[ -e $driver_dir/driver.sh ]]; then
        . "$driver_dir/driver.sh"
        return 0
    elif [[ -x $driver_dir/driver ]]; then
        driver="$driver_dir/driver"
        return 0
    fi

    driver_lookup+=("$driver_dir/driver.sh" "$driver_dir/driver")

    if [[ $driver != : ]]; then
        local old_driver_dir="$driver_dir"
        driver_dir="${driver_dir%/*}"
        if [[ $old_driver_dir != $driver_dir ]]; then
            if ! find_driver; then
                driver_dir="$old_driver_dir"
                return 1
            else
                return 0
            fi
        fi
    fi

    return 1
}

# READ  $descriptor : the descriptor
# WRITE $type       : the descriptor type
get_type(){
    # Get the extension
    local basename=${descriptor##*/}
    type=${basename##*.}

    if [[ $type = ${basename} ]] && [[ -d $descriptor ]]; then
        # If no extension and is a directory, consider it a sub
        type=sub
    elif [[ $type == dir ]] && [[ -L $descriptor ]]; then
        # Alias *.dir links as link
        type=link
    elif [[ $type == d ]]; then
        # Alias *.d are sub
        type=sub
    elif [[ $type == md ]]; then
        # Alias *.md are txt
        type=txt
    fi
}

# READ $1      : the action (backup, list)
# READ $2      : the backup descriptor
# READ $3...   : the backup options
# READ $driver : the driver to use. If empty, the descriptor must be a directory
run() {
    local type
    local res=0
    local driver=$driver
    local driver_change=false
    local action="$1"
    local descriptor="$2"
    local up_driver_dir="$driver_dir"
    local driver_dir="${descriptor%/}"
    local Action="$(tr a-z A-Z <<<${action:0:1})${action:1}"
    shift 2

    get_type

    # look in the same directory of the driver for anything else but sub
    if [[ $type != sub ]]; then
        driver_dir="${driver_dir%/?*}"
    fi

    if [[ $type = sub ]] || [[ $driver = : ]]; then
        local old_driver_dir="$driver_dir"
        local driver_lookup=()
        if find_driver; then
            driver init $action || return 1
            banner_info "Found driver: $driver"
            driver_change=true
        elif [[ $driver = : ]]; then
            banner_error "$old_driver_dir: Could not find driver in $driver_dir"
            for location in "${driver_lookup[@]}"; do
                echo "   Not found: $location"
            done
            return 1
        fi
    fi

    if ! $driver_change; then
        driver_dir="$up_driver_dir"
    fi

    if type "run_$type" >/dev/null 2>&1; then
        "run_$type" "$@"
        ((res+=$?))
    else
        banner_warning "$descriptor: Unknown type $type"
    fi

    if [[ $res = 0 ]] && $driver_change; then
        if ! driver commit $action; then
            ((res++))
        fi
    fi

    return $res
}

banner_error(){
    echo -e "$Bold--> ${BIRed}Error: $1$Color_Off" >&2
}

banner_warning(){
    echo -e "$Bold--> ${BIYellow}Warning: $1$Color_Off" >&2
}

banner_action(){
    echo -e "$Bold--> $BIGreen$Action $1$Color_Off"
}

banner_info(){
    echo -e "$Bold--> $BIGreen$1$Color_Off"
}

banner_results(){
    if [[ $1 -eq 0 ]]; then
        echo -e "$Bold--> $BIGreen${2:-Success}$Color_Off"
    else
        echo -e "$Bold--> $BIRed${2:-Failure} ($1)$Color_Off"
    fi
}

run_sub(){
    local res=0
    local up_subdir="$subdir"
    local subdir="$up_subdir"
    banner_action "$descriptor/..."
    for f in "$descriptor"/*; do
        [[ ${f##*/} = driver    ]] && continue
        [[ ${f##*/} = driver.sh ]] && continue
        subdir="$up_subdir/${f##*/}"
        subdir="${subdir#/}"
        run $action "$f" "$@"
        ((res+=$?))
    done
    return $res
}

run_link(){
    local link="$(readlink "$descriptor")"
    if [[ -d $link ]]; then
        link="${link%/}/"
    fi
    banner_action "$descriptor -> $link"
    driver $action "$link" "$@"
}

run_exec(){
    banner_action "$descriptor (execute)"
    "$descriptor" "$action" "$@"
}

run_sh(){
    banner_action "$descriptor (plug-in)"
    local args=("$@")
    . "$descriptor"
}

run_conf(){ : ; }

run_txt(){
    true
}

run_md(){
    true
}

# Reset
Color_Off='\e[0m'       # Text Reset

# Regular Colors
Black='\e[0;30m'        # Black
Red='\e[0;31m'          # Red
Green='\e[0;32m'        # Green
Yellow='\e[0;33m'       # Yellow
Blue='\e[0;34m'         # Blue
Purple='\e[0;35m'       # Purple
Cyan='\e[0;36m'         # Cyan
White='\e[0;37m'        # White

# Bold
Bold='\e[1m'            # No Color Change
BBlack='\e[1;30m'       # Black
BRed='\e[1;31m'         # Red
BGreen='\e[1;32m'       # Green
BYellow='\e[1;33m'      # Yellow
BBlue='\e[1;34m'        # Blue
BPurple='\e[1;35m'      # Purple
BCyan='\e[1;36m'        # Cyan
BWhite='\e[1;37m'       # White

# Underline
UBlack='\e[4;30m'       # Black
URed='\e[4;31m'         # Red
UGreen='\e[4;32m'       # Green
UYellow='\e[4;33m'      # Yellow
UBlue='\e[4;34m'        # Blue
UPurple='\e[4;35m'      # Purple
UCyan='\e[4;36m'        # Cyan
UWhite='\e[4;37m'       # White

# Background
On_Black='\e[40m'       # Black
On_Red='\e[41m'         # Red
On_Green='\e[42m'       # Green
On_Yellow='\e[43m'      # Yellow
On_Blue='\e[44m'        # Blue
On_Purple='\e[45m'      # Purple
On_Cyan='\e[46m'        # Cyan
On_White='\e[47m'       # White

# High Intensity
IBlack='\e[0;90m'       # Black
IRed='\e[0;91m'         # Red
IGreen='\e[0;92m'       # Green
IYellow='\e[0;93m'      # Yellow
IBlue='\e[0;94m'        # Blue
IPurple='\e[0;95m'      # Purple
ICyan='\e[0;96m'        # Cyan
IWhite='\e[0;97m'       # White

# Bold High Intensity
BIBlack='\e[1;90m'      # Black
BIRed='\e[1;91m'        # Red
BIGreen='\e[1;92m'      # Green
BIYellow='\e[1;93m'     # Yellow
BIBlue='\e[1;94m'       # Blue
BIPurple='\e[1;95m'     # Purple
BICyan='\e[1;96m'       # Cyan
BIWhite='\e[1;97m'      # White

# High Intensity backgrounds
On_IBlack='\e[0;100m'   # Black
On_IRed='\e[0;101m'     # Red
On_IGreen='\e[0;102m'   # Green
On_IYellow='\e[0;103m'  # Yellow
On_IBlue='\e[0;104m'    # Blue
On_IPurple='\e[0;105m'  # Purple
On_ICyan='\e[0;106m'    # Cyan
On_IWhite='\e[0;107m'   # White

main "$@"
exit $?