.rc.common

#!/usr/bin/env sh
# vim:tw=80:ts=4:sw=4:ai:et:ff=unix:fenc=utf-8:et:fixeol:eol:fdm=marker:fdl=0:fen:
#
# Utilities for all shell scripts.
#
# More stuff to do here. {{{
#
# - [ ] figure out a better way to name functions (shell doesn't have namespaces)
#
# }}}

if [ -z "$_THIS_FILE" ]; then
    _THIS_FILE="$0"; readonly _THIS_FILE
fi

# Source personal stuff.
if [ -f "$HOME/bin/commonp.sh" ]; then
    . "$HOME/bin/commonp.sh"
fi

# Defaults to 'set -e'.
mm_set() {
  local mode="$1"

  if [ "$mode" = "all" ]; then
    set -euxo pipefail
  elif  [ "$mode" = "u" ]; then
    # Exit on undefined variable.
    set -u
  elif  [ "$mode" = "x" ]; then
    # Print all commands before execution.
    set -x
  else
    # Exit on error.
    set -e
  fi
}

mm_now() {
    local mode="$1"

    if [ "$mode" = "--path" ]; then
        echo "$(date '+%F_%T' | tr ':' '-')"
    elif [ "$mode" = "--simple" ]; then
        echo "$(date '+%d%b%y/%Hh%M')"
    else
        if [ -z "$mode" ]; then
            mode='+%F %T'
        fi
        echo "$(date "$mode")"
    fi
}
alias mcra_now=mm_now

# In shell, for return values, 0 is success (eq to true in a conditional) and 1 is failure (eq
# to false in a conditional).
is_debug() {
  # If the variable is empty, we are not in debug mode.
  if [ -z "$MCRA_DEBUG" ]; then
    # Not debug mode.
    return 1
  else
    # Debug mode.
    return 0
  fi
}

debug() {
  if ! is_debug; then
    return 0
  fi

  echo "[$(date '+%F %T')] [debug] $@"
}

alias mm_debug=debug
alias mm_is_debug=is_debug

if is_debug; then
  echo '----------------------------------------------------------------------------'
  echo 'DEBUG MODE ENABLED!'
  echo '----------------------------------------------------------------------------'

  if [ "$MCRA_DEBUG" = "test" ]; then
    debug '$MCRA_DEBUG == test: tests will run'
  fi
fi

error() {
  debug $1

  return 1
}

fatal() {
    echo
    echo "$@"

    exit 1
}

has_prefix() {
  if [ $# -ne 2 ]; then
    error 'Usage: has_prefix "original string" "prefix to check".'
  fi

  if [ "${1#$2}" != "$1" ]; then
    # The `${1#$2}` substitution replaces $2 at the beginning of $1, making it different from
    # itself, hence entering this branch and confirming that $2 is a prefix on $1.
    return 0  # true
  else
    return 1  # false
  fi
}

count=1
assert() {
  if ! is_debug; then
    return 0
  fi

  local test_name=$1
  local expected=$2
  local actual=$3

  echo -n "[$(date '+%F %T')] [test] $count "
  if [ "$expected" != "$actual" ]; then
    echo -n "failure: $test_name\n\n"
    echo "expected:\n\n$expected\n"
    echo "actual:\n\n$actual"
  else
    echo -n "success: $test_name"
  fi

  echo

  count=$((count + 1))
}


get_this_file_dir() {
  echo "$(command -v readlink >/dev/null 2>&1 && dirname $(readlink -f "$1") || dirname "$1")"
}
alias mm_this_file_dir=get_this_file_dir

mm_is_command() {
  command -v "$1" >/dev/null 2>&1
}

mm_file_path() {
  local filepath="$1"
  if mm_is_command readlink; then
    echo "$(readlink -f "$filepath")"
  elif mm_is_command realpath; then
    echo "$(realpath "$filepath")"
  else
    echo "Need 'readlink' or 'realpath' and they were not found."
  fi
}

mm_dir_path() {
  echo "$(dirname $(mm_file_path "$1"))"
}

mm_grep() {
  local grep_cmd='grep' # Default.

  echo 'rg egrep' | tr ' ' '\n' | while read cmd; do
    if mm_is_command $cmd; then
      grep_cmd="$cmd"
      break
    fi
  done

  $grep_cmd "$@"
}

mm_remove_leading_spaces() {
    local num_spaces="${1:-8}"
    local usage="\nUsage: $0 [num]\n\nRemoves [num] leading spaces (default=8)."

    case "$num_spaces" in
        help|-h|--help)
            echo $usage
            return 1
            ;;
    esac

    local check_number="$(echo "$num_spaces" | sed -E -e 's/[1-9][0-9]*//')"

    if [ ! -z "$check_number" ]; then
        echo $usage
        echo "\nInvalid [num]: $1"
        return 1
    fi

    sed -E -e "s/^\s{0,$num_spaces}//"
}

mm_trim() {
    # Remove leading spaces.
    local output1="$(echo "$1" | mm_remove_leading_spaces "$2")"

    # Remove first newline character.
    local output2="${output1#"\n"}"

    # Remove last newline character and output.
    echo "${output2%"\n"}"
}

mcra_doc() {
    local usage="
        USAGE:

            mcra_doc \$@ '<docs>'
            mcra_doc \$@ \"<docs>\"

        NOTES:

            1) The first argument should be literally that. It is what detects
            whether the user wants more information about the function (by
            detecting '-h', '--help' and 'help').

            2) If you want, you can write the <docs> part using newlines and
            leading spaces, as the function will remove them for you. For
            example:

            mcra_doc \$@ '
                Here goes your function documentation. The first newline (above)
                along with up to 8 leading spaces
                <--- here
                will be removed for you, as will the last newline right after
                this line.
                <--- here.
            '

            3) You might want to use variable/process substitution, in which
            case you would use the second variation (with double quotes). You
            can still write it as described in 2 above, just replace the single
            quotes for double. In this case, remember to escape double quotes or
            other stuff that should be displayed literally.

            4) If you want a full example, check the following function in this
            file: mm_example_documented_function. It provides the common use
            case for this function.
    "

    # Either this will be called with one or two arguments.
    #
    # If called with only one, the user is trying to get info about this
    # particular function, so show the help.
    #
    # If called with two, the user is documenting their function. In this case,
    # if later the function is called with the first argument being one of the
    # help ones, print the help.
    case "$1" in
        help|-h|--help)
            if [ -z "$2" ]; then
                mm_trim $usage
                return 1
            fi

            mm_trim "$2"
            return 1
            ;;
    esac
    return 0
}

mm_example_documented_function() {
    mcra_doc $@ "
        NAME: $0

        DESCRIPTION:

            Shows some example \"mcra_doc\" usage and output.

            Run this with different arguments to see different behaviors.
    " || return 0

    echo 'Print this if first argument above is not "help|-h|--help"'
}

main() {
    local editor="${EDITOR:-vi}"

    mcra_get_last_edit() {
        date '+%F_%T' -r "$1" | tr ':' '-'
    }

    local this_file_last_edit_time="$(mcra_get_last_edit "$_THIS_FILE")"

    if [ "$MCRA_COMMON" = "$this_file_last_edit_time" ]; then
        # No need to rerun this file, as it wasn't editted since last run.
        return 0
    fi

    export MCRA_COMMON="$this_file_last_edit_time"
    export MCRA_LOGFILE="$HOME/.mcra.logfile.txt"

    mcra_log_base() {
        if [ -z "$1" ] || [ -z "$2" ]
        then
            mm_trim "
                Usage: $0 [mode] [message to log] [additional info (optional)]

                Mode:
                    - log: append to logfile as log and return 0
                    - err: append to logfile as err and return 1

                Additional info:
                    Any extra arguments after [mode] and [message] will be
                    appended to the logfile as provided.
            "
            return 1
        fi

        local logfile="$MCRA_LOGFILE"

        if [ ! -f $logfile ]; then
            touch $logfile
        fi

        local mode=log
        local msg="$1"
        if [ "$1" = "err" ]; then
            mode=err
            msg="$2"
        elif [ "$1" = "cat" ]; then
            cat $MCRA_LOGFILE
            return 0
        elif [ "$1" = "edit" ]; then
            $editor $MCRA_LOGFILE
            return 0
        fi

        echo "[$(mm_now)] [$mode] $msg" >> $logfile

        shift; shift;  # Ignore the first two arguments and use all the others.
        count=1
        while [ $# -ne 0 ]; do
            echo -n "\n    [metadata $count] $1" >> $logfile
            count=$((count+1))
            shift
        done

        if [ $count -gt 1 ]; then
            echo '\n' >> $logfile
        fi
    }

    alias mcra_log="mcra_log_base log"
    alias mcra_err="mcra_log_base err"

    #
    # Next function above this line.
    #
}

main "$@"

# /////////////////////////////////////////////////////////////////////////
# Tests.
# /////////////////////////////////////////////////////////////////////////
#
# Functions are tested here, but ignored when debug is disabled.

# Run tests.
if [ "$MCRA_DEBUG" = "test" ]
then
  has_prefix "hello world" "hello" && assert "prefix match" $? 0
  has_prefix "hello world" "world" || assert "prefix doesn't match" $? 1
  has_prefix "hello world" "not there" || assert "prefix doesn't match with completely different strings" $? 1

  assert "get_this_file_dir" $(get_this_file_dir $0) "$HOME/projects/dotfiles"
fi