placebo

#!/usr/bin/env bash

_usage() {
  case "$1" in
  "main")
    echo "Usage: . $0 [-h]"
    ;;
  "attach")
    echo "Usage: pill_attach [-h] \
command=command1[,command2,...] data_path=path/to/responses"
    ;;
  "playback")
    echo "Usage: pill_playback [-h]"
    echo "Sets Placebo to playback mode"
    ;;
  "record")
    echo "Usage: pill_record [-h]"
    echo "Sets Placebo to record mode"
    ;;
  "detach")
    echo "Usage: pill_detach [-h]"
    echo "Detaches Placebo and cleans \
up functions and variables"
    ;;
  esac
  return 0
}

if [ "$0" == "${BASH_SOURCE[0]}" ] ; then
  _usage main ; false
fi

if [ "$1" == "-h" ] ; then
  _usage main ; true
fi

pill_attach() {
  local _command _data_path c

  [ "$1" == "-h" ] && \
    _usage attach && return

  _command="$1"
  _data_path="$2"

  { [[ ! "$_command" =~ command= ]] || \
    [[ ! "$_data_path" =~ data_path= ]] ; } \
    && _usage attach && return 1

  _command="${_command#command=}"
  IFS=',' read -r -a COMMANDS <<< "$_command"

  DATA_PATH="${_data_path#data_path=}"

  if [ ! -d "$DATA_PATH" ] ; then
    echo "DATA_PATH should be a directory"
    _usage attach && return 1
  fi

  _mock

  true > commands_log
}

pill_playback() {
  [ "$1" == "-h" ] && \
    _usage playback && return
  # shellcheck disable=SC2034
  PILL=playback
}

pill_record() {
  [ "$1" == "-h" ] && \
    _usage record && return
  # shellcheck disable=SC2034
  PILL=record
}

pill_log() {
  [ "$1" == "-h" ] && \
    _usage log && return
  [ -f commands_log ] && \
    cat commands_log
}

pill_detach() {
  local f funcs

  [ "$1" == "-h" ] && \
    _usage detach && return

  funcs="_usage
pill_attach
pill_playback
pill_record
pill_log
pill_detach
_mock
_cli_to_comm
_comm_to_file
_create_new
_update_existing
_filter
_record"
  for f in $funcs "${COMMANDS[@]}"; do
    unset -f "$f"
  done
  unset PILL DATA_PATH COMMANDS
  command rm -f commands_log
}

# private functions.

_comm_to_file() {
  echo "$DATA_PATH"/"$1".sh
}

_filter() {
  sed -E "
    s/ +$//
    s/ +'/'/
    "
}

_mock() {
  local c code
  for c in "${COMMANDS[@]}" ; do
    # shellcheck disable=SC2016,SC1004
    code="$c"'() {
      local file comm

      comm="${FUNCNAME[0]}"
      file=$(_comm_to_file "$comm")

      if [ -z "$DATA_PATH" ] ; then
        echo "\
DATA_PATH must be set. \
Try pill_attach"
        return 1
      fi

      if [ -z "$PILL" ] ; then
        echo "\
PILL must be set to \
playback or record. Try pill_playback \
or pill_record"
        return 1
      fi

      if { [ ! -f "$file" ] && \
    [ "$PILL" == "playback" ] ; }; then
        echo "\
$file not found. \
Make sure you firstly record it"
        return 1
      fi

      echo "$comm $*" | \
        _filter >> commands_log

      case "$PILL" in
      "playback")
        source "$file" "$@"
        ;;
      "record")
        _record "$file" "$comm $*"
        ;;
      esac
    }'
    eval "$code"
  done
}

_cli_to_comm() {
  awk '{print $1}' <<< "$1"
}

_record() {
  local file cli comm temp_file rc lines

  file="$1" ; cli="$2"

  comm=$(_cli_to_comm "$cli")
  temp_file=/tmp/"$$"

  if [ -s "$file" ] ; then
    _update_existing "$comm"
  else
    _create_new "$comm"
  fi

  # capture response data and exit status.
  # shellcheck disable=SC2086
  command $cli | tee -a "$temp_file" ; rc="${PIPESTATUS[0]}"

  response=$(<"$temp_file")
  lines=$(wc -l <<< "$response")

  if [ "$lines" -eq 1 ] ; then
    if [ "$rc" -eq 0 ] ; then
      if [ -z "$response" ] ; then echo \
 "'$cli') true ;;"
      else echo \
 "'$cli') echo '$response' ;;"
      fi
    else
      if [ -z "$response" ] ; then echo \
 "'$cli') (exit $rc) ;;"
      else echo \
 "'$cli') echo '$response' ; (exit $rc) ;;"
      fi
    fi
  elif [ "$lines" -gt 1 ] ; then echo \
 "'$cli')
  cat <<'EOF'
$response
EOF
"
    [ "$rc" -ne 0 ] && echo \
 "  (exit $rc)"
    echo \
 "  ;;"
  fi \
    >> "$file"

  cat >> "$file" <<EOD
*)
  echo "No responses for: $comm \$*" | \
tee -a unknown_commands
  ;;
esac
EOD

  command rm -f "$temp_file"

  (exit "$rc")
}

_create_new() {
  local comm f
  comm="$1" ; f=$(_comm_to_file "$comm")
  echo 'case "'"$comm"' $*" in' > "$f"
}

_update_existing() {
  local comm f
  comm="$1" ; f=$(_comm_to_file "$comm")
  awk '
    $0 == "*)" {
      exit
    }
    {
      print
    }
    ' "$f" > "$f.bak"
  mv "$f.bak" "$f"
}

# vim: ft=sh