binstub

#!/usr/bin/env bash
set -e

# If stdin comes from a pipe, save its content for later
if ! [ -t 0 ]; then
	input="$(cat)"
fi

status=0
program="${0##*/}"
PROGRAM="$(echo "$program" | tr a-z- A-Z_)"

_STUB_PLAN="${PROGRAM}_STUB_PLAN"
_STUB_RUN="${PROGRAM}_STUB_RUN"
_STUB_INDEX="${PROGRAM}_STUB_INDEX"
_STUB_RESULT="${PROGRAM}_STUB_RESULT"
_STUB_END="${PROGRAM}_STUB_END"
_STUB_DEBUG="${PROGRAM}_STUB_DEBUG"

debug() {
  if [ -n "${!_STUB_DEBUG}" ] ; then
    echo "bats-mock($program): $*" >&${!_STUB_DEBUG}
  fi
}

[ -e "${!_STUB_PLAN}" ] || exit 1
[ -n "${!_STUB_RUN}" ] || eval "${_STUB_RUN}"="${BATS_MOCK_TMPDIR}/${program}-stub-run"

# Initialize or load the stub run information.
eval "${_STUB_INDEX}"=1
eval "${_STUB_RESULT}"=0
[ ! -e "${!_STUB_RUN}" ] || source "${!_STUB_RUN}"

if [ -z "${!_STUB_END}" ] && [ -n "${!_STUB_DEBUG}" ]; then
  debug "got $program $*" >&${!_STUB_DEBUG}
fi

# Loop over each line in the plan.
index=0
while IFS= read -r line; do
  index=$((index + 1))

  # if [ -n "${!_STUB_DEBUG}" ]; then
  #   echo "bats-mock: [idx $index, want ${!_STUB_INDEX}] $line" >&${!_STUB_DEBUG}
  # fi

  if [ -z "${!_STUB_END}" ] && [ $index -eq "${!_STUB_INDEX}" ]; then
    # We found the plan line we're interested in.
    # Start off by assuming success.
    result=0

    # Split the line into an array of arguments to
    # match and a command to run to produce output.
    command=" $line"
    if [ "$command" != "${command/ : }" ]; then
      patterns="${command%% : *}"
      command="${command#* : }"
    fi

    arguments=("$@")
    parsed_patterns=()

    # Parse patterns into tokens using eval to respect quoted
    # strings. This is less than ideal, but the pattern input
    # is also already eval'd elsewhere. At least this handles
    # things like newlines (which xargs doesn't)
    eval "parsed_patterns=(${patterns})"

    debug "patterns  [${#parsed_patterns[@]}] = $(printf "'%q' " "${parsed_patterns[@]}")"
    debug "arguments [${#arguments[@]}] = $(printf "'%q' " "${arguments[@]}")"

    # Match the expected argument patterns to actual
    # arguments.
    for (( i=0; i<${#parsed_patterns[@]}; i++ )); do
      pattern="${parsed_patterns[$i]}"
      argument="${arguments[$i]}"

      if [[ "$pattern" != "$argument" ]] && [[ "$pattern" != "*" ]] ; then
        debug "$(printf "match failed at idx %d, expected '%q', got '%q'" $i "$pattern" "$argument")"
        result=1
        break
      fi
    done

    # Check if there are unmatched arguments
    if [[ ${#arguments[@]} -gt ${#parsed_patterns[@]} ]] ; then
      idx="${#parsed_patterns[@]}"
      argument="${arguments[$idx]}"
      debug "$(printf "unexpected argument '%q' at idx %d" "$argument" "$idx")"
      result=2
      break
    fi

    # If the arguments matched, evaluate the command
    # in a subshell. Otherwise, log the failure.
    if [ $result -eq 0 ] ; then
      debug "running $command"
      debug "command input is $input"
      set +e
      ( eval "$command"  <<< "$input" )
      status="$?"
      debug "command result was $status"
      set -e
    else
      eval "${_STUB_RESULT}"=1
    fi
  fi
done < "${!_STUB_PLAN}"


if [ -n "${!_STUB_END}" ]; then
  echo "${_STUB_DEBUG}"
  debug "unstubbing"

  if [ ! -f "${!_STUB_RUN}" ] && [ -n "${!_STUB_DEBUG}" ] ; then
    echo "The stub for ${program} wasn't run"
    exit 1
  fi

  # Clean up the run file.
  rm -f "${!_STUB_RUN}"

  # If the number of lines in the plan is larger than
  # the requested index, we failed.
  if [ $index -ge "${!_STUB_INDEX}" ]; then
    eval "${_STUB_RESULT}"=1
  fi

  # Return the result.
  exit "${!_STUB_RESULT}"
else
  # If the requested index is larger than the number
  # of lines in the plan file, we failed.
  if [ "${!_STUB_INDEX}" -gt $index ]; then
    debug "no plan row found"
    eval "${_STUB_RESULT}"=1
  fi

  # Write out the run information.
  { echo "${_STUB_INDEX}=$((${!_STUB_INDEX} + 1))"
    echo "${_STUB_RESULT}=${!_STUB_RESULT}"
  } > "${!_STUB_RUN}"

  debug "result ${!_STUB_RESULT}"
  exit "${!_STUB_RESULT}"
fi