More changes towards minor release 0.9.0

Author: razziel89

.github/workflows/test-lint-deploy.yml

@@ -41,7 +41,7 @@ jobs:
         run: |
           sudo apt-get update -qq
           sudo apt-get install -qqy --no-install-recommends \
-            build-essential ca-certificates coreutils curl gawk gcc git jq \
+            build-essential ca-certificates coreutils curl gcc git jq \
             kcov make parallel shellcheck
 
       - name: Install bats

README.md

@@ -50,15 +50,14 @@ The following tools are needed to use `shellmock`:
 - `bash` (at least version 4.4)
 - `cat`
 - `chmod`
-- `flock`
 - `mkdir`
 - `mktemp`
 - `rm`
 
 On Debian-based systems, they can be installed via:
 
 ```bash
-sudo apt install -yqq bash coreutils util-linux
+sudo apt install -yqq bash coreutils
 ```
 
 You also need the [bats-core] testing framework that
@@ -69,6 +68,8 @@ the version installable via `npm` is up to date.
 
 To run the [`commands` command](./docs/usage.md#commands), you also need a
 [Golang][golang] toolchain.
+For optimal performance, install `flock`, which is contained within the
+`util-linux` package on Debian-based systems.
 
 [bats-npm-install]: https://bats-core.readthedocs.io/en/stable/installation.html#any-os-npm
 [golang]: https://go.dev/doc/install

bin/mock_exe.sh

@@ -28,57 +28,112 @@
 
 # Check whether required environment variables are set.
 env_var_check() {
-  local var
-  for var in __SHELLMOCK_MOCKBIN __SHELLMOCK_FUNCSTORE __SHELLMOCK_OUTPUT; do
-    if ! [[ -d ${!var-} ]]; then
-      echo >&2 "Vairable ${var} not defined or no directory."
-      exit 1
+  local var dir
+  local vars=(
+    __SHELLMOCK_ORGPATH
+  )
+  local dirs=(
+    __SHELLMOCK_MOCKBIN
+    __SHELLMOCK_FUNCSTORE
+    __SHELLMOCK_OUTPUT
+  )
+  for dir in "${dirs[@]}"; do
+    if ! [[ -d ${!dir-} ]]; then
+      echo >&2 "Variable ${dir} not defined or no directory."
+      _kill_parent
     fi
   done
+  for var in "${vars[@]}"; do
+    if [[ -z ${!var-} ]]; then
+      echo >&2 "Variable ${var} not defined."
+      _kill_parent
+    fi
+  done
+}
+
+# Remove shellmock's mockbin directory from PATH. We do so by using the env var
+# set by the main shellmock code.
+rm_mock_path() {
+  export PATH="${__SHELLMOCK_ORGPATH}"
+}
+
+# Make sure that we can find all the executables we need.
+binary_deps_check() {
+  local has_err=0
+  local cmd
+  for cmd in base32 cat mkdir; do
+    if ! command -v "${cmd}" &> /dev/null; then
+      echo >&2 "Required executable ${cmd} not found."
+      has_err=1
+    fi
+  done
+  if ! command -v flock &> /dev/null; then
+    echo >&2 "SHELLMOCK: Optional executable flock not found." \
+      "Please install for best performance."
+  fi
+  if [[ ${has_err} -ne 0 ]]; then
+    _kill_parent
+    return 1
+  fi
+  return 0
 }
 
 get_and_ensure_outdir() {
   local cmd_b32="$1"
 
-  local max_num_calls=${SHELLMOCK_MAX_CALLS_PER_MOCK:-1000}
+  local max_num_calls=${SHELLMOCK_MAX_CALLS_PER_MOCK:-100}
   if ! [[ ${max_num_calls} =~ ^[0-9][0-9]*$ ]]; then
     echo >&2 "SHELLMOCK_MAX_CALLS_PER_MOCK must be a number."
-    _kill_parent "${PPID}"
+    _kill_parent
     return 1
   fi
   local tmp
   tmp=$((max_num_calls - 1))
   local max_digits=${#tmp}
 
+  # shellmock: uses-command=flock
+  local _flock=flock
+  if
+    ! command -v flock &> /dev/null \
+      || [[ ${__SHELLMOCK_TESTING_WO_FLOCK-0} -eq 1 ]]
+  then
+    _flock=true
+  fi
+
   # Ensure no two calls overwrite each other in a thread-safe way.
-  local count
-  count=$(printf "%0${max_digits}d" "0")
-  local outdir="${__SHELLMOCK_OUTPUT}/${cmd_b32}/${count}"
+  local padded count=0
+  padded=$(printf "%0${max_digits}d" "${count}")
+  mkdir -p "${__SHELLMOCK_OUTPUT}/${cmd_b32}"
+  local outdir="${__SHELLMOCK_OUTPUT}/${cmd_b32}/${padded}"
   while ! (
     # Increment the counter until we find one that has not been used before.
-    flock -n 9 || exit 1
-    [[ -d ${outdir} ]] && exit 1
-    mkdir -p "${outdir}"
+    "${_flock}" -n 9 || exit 1
+    mkdir "${outdir}" &> /dev/null
   ) 9> "${__SHELLMOCK_OUTPUT}/lockfile_${cmd_b32}_${count}"; do
-    count=$(printf "%0${max_digits}d" "$((count + 1))")
-    outdir="${__SHELLMOCK_OUTPUT}/${cmd_b32}/${count}"
+    count=$((count + 1))
+    padded=$(printf "%0${max_digits}d" "${count}")
+    outdir="${__SHELLMOCK_OUTPUT}/${cmd_b32}/${padded}"
+
+    if [[ ${count} -ge ${max_num_calls} ]]; then
+      echo >&2 "The maximum number of calls per mock is ${max_num_calls}." \
+        "Consider increasing SHELLMOCK_MAX_CALLS_PER_MOCK, which is currently" \
+        "set to '${max_num_calls}'."
+      _kill_parent
+      return 1
+    fi
   done
 
-  if [[ ${count} -ge ${max_num_calls} ]]; then
-    echo >&2 "The maximum number of calls per mock is ${max_num_calls}." \
-      "Consider increasing SHELLMOCK_MAX_CALLS_PER_MOCK, which is currently" \
-      "set to '${max_num_calls}'."
-    _kill_parent "${PPID}"
-    return 1
-  fi
-
   echo "${outdir}"
 }
 
 # When called, this script will write its own errors to a file so that they can
 # be retrieved later when asserting expectations.
 errecho() {
-  echo >> "${STDERR}" "$@"
+  if [[ -n ${STDERR} ]]; then
+    echo >> "${STDERR}" "$@"
+  else
+    echo >&2 "$@"
+  fi
 }
 
 output_args_and_stdin() {
@@ -103,6 +158,7 @@ _find_arg() {
   shift
   local args=("$@")
 
+  local check
   for check in "${args[@]}"; do
     if [[ ${arg} == "${check}" ]]; then
       return 0
@@ -117,6 +173,7 @@ _find_regex_arg() {
   shift
   local args=("$@")
 
+  local check
   for check in "${args[@]}"; do
     if [[ ${check} =~ ${regex} ]]; then
       return 0
@@ -135,8 +192,8 @@ _match_spec() {
   local spec
   while read -r spec; do
     local id val
-    read -r -d ':' id <<< "${spec}"
-    val="${spec##"${id}":}"
+    id="${spec%%:*}"
+    val="${spec#*:}"
 
     if [[ ${spec} =~ ^any: ]]; then
       if ! _find_arg "${val}" "$@"; then
@@ -183,7 +240,7 @@ _is_bats_process() {
 }
 
 _kill_parent() {
-  local parent="$1"
+  local parent="${PPID}"
 
   # Do not kill the parent process if it is a bats process. If we did, bats
   # would no longer be able to track the test.
@@ -224,7 +281,7 @@ find_matching_argspec() {
   ) && wait $! || return 1
 
   errecho "SHELLMOCK: unexpected call '${cmd} $*'"
-  _kill_parent "${PPID}"
+  _kill_parent
   return 1
 }
 
@@ -254,7 +311,7 @@ run_hook() {
       # output. Anything output via errecho will end up in a file that is only
       # looked at when asserting expectations.
       echo >&2 "SHELLMOCK: error calling hook '${!hook_env_var}'"
-      _kill_parent "${PPID}"
+      _kill_parent
       return 1
     fi
   fi
@@ -291,21 +348,25 @@ forward() {
   shift
   local args=("$@")
 
-  while read -r -d: path; do
-    if
-      [[ ${path} != "${__SHELLMOCK_MOCKBIN}" ]] \
-        && PATH="${path}" command -v "${cmd}" &> /dev/null
-    then
-      local exe="${path}/${cmd}"
-      echo >&2 "SHELLMOCK: forwarding call: ${exe} $*"
-      exec "${exe}" "${args[@]}"
-    fi
-  done <<< "${__SHELLMOCK_FUNCSTORE}:${PATH}"
+  local exe
+  local path="${__SHELLMOCK_FUNCSTORE}:${PATH}"
+  # Extend PATH by shellmock's funcstore because we may want to forward to a
+  # function instead of a binary.
+  if
+    ! exe=$(PATH="${path}" command -v "${cmd}")
+  then
+    echo >&2 "SHELLMOCK: failed to find executable to forward to: ${cmd}"
+    _kill_parent
+  fi
+  echo >&2 "SHELLMOCK: forwarding call: ${exe@Q} ${*@Q}"
+  exec "${exe}" "${args[@]}"
 }
 
 main() {
   # Make sure that shell aliases never interfere with this mock.
   unalias -a
+  rm_mock_path
+  binary_deps_check
   env_var_check
   # Determine our name. This assumes that the first value in argv is the name of
   # the command. This is almost always so.

docs/build.md

@@ -20,4 +20,4 @@
 
 Simply run the script `./generate_deployable.sh` at the top level of this
 repository to generate `shellmock.bash`.
-It uses only the standard Unix tools `bash` and `cat` to generate it.
+It uses only `bash` to generate it.

generate_deployable.sh

@@ -22,6 +22,16 @@
 
 __SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/" &> /dev/null && pwd)"
 
+_cat() {
+  (
+    local line
+    IFS=
+    while read -d $'\n' -r line; do
+      printf -- '%s\n' "${line}"
+    done
+  )
+}
+
 deployable() {
   # Output header including the licence file.
   echo '#!/bin/bash'
@@ -31,7 +41,7 @@ deployable() {
       echo "# ${line}"
     done < LICENSE
   )
-  cat << 'EOF'
+  _cat << 'EOF'
 
 # This file is auto-generated. It is the main deployable of shellmock. To make
 # contributions to shellmock, please visit the repository under:
@@ -41,17 +51,20 @@ EOF
   # Output all bats helper files containing function definitions.
   for bats_file in lib/*.bash; do
     printf -- "\n# FILE: %s\n" "${bats_file}"
-    cat "${bats_file}"
+    _cat < "${bats_file}"
   done
 
   # Create a function providing the help text.
-  cat << 'ENDOFFILE'
+  _cat << 'ENDOFFILE'
 __shellmock__help() {
   "${PAGER-cat}" << 'EOF'
 This is shellmock, a tool to mock executables called within shell scripts.
 ENDOFFILE
 
+  # Add helptexts from the usage docs, but only a reduced version. The docs are
+  # enclosed by the HTML comments given below.
   (
+    local line
     IFS=
     do_print=0
     while read -r line; do
@@ -67,22 +80,22 @@ ENDOFFILE
     done < ./docs/usage.md
   )
 
-  cat << 'ENDOFFILE'
+  _cat << 'ENDOFFILE'
 EOF
 }
 ENDOFFILE
 
   # Create a function that outputs the mock executable to its stdout.
-  cat << 'EOF'
+  _cat << 'EOF'
 
 # Mock executable writer.
 __shellmock_write_mock_exe() {
 EOF
 
-  echo "cat << 'ENDOFFILE'"
-  cat ./bin/mock_exe.sh
+  echo "PATH=\"\${__SHELLMOCK_ORGPATH}\" cat << 'ENDOFFILE'"
+  _cat < ./bin/mock_exe.sh
 
-  cat << 'EOF'
+  _cat << 'EOF'
 ENDOFFILE
 }
 
@@ -91,17 +104,17 @@ __shellmock_internal_init_command_search() {
   local path=$1
 EOF
 
-  echo "cat > \"\${path}/go.mod\"  << 'ENDOFFILE'"
-  cat ./go/go.mod
+  echo "PATH=\"\${__SHELLMOCK_ORGPATH}\" cat > \"\${path}/go.mod\"  << 'ENDOFFILE'"
+  _cat < ./go/go.mod
 
-  cat << 'EOF'
+  _cat << 'EOF'
 ENDOFFILE
 EOF
 
-  echo "cat > \"\${path}/main.go\"  << 'ENDOFFILE'"
-  cat ./go/main.go
+  echo "PATH=\"\${__SHELLMOCK_ORGPATH}\" cat > \"\${path}/main.go\"  << 'ENDOFFILE'"
+  _cat < ./go/main.go
 
-  cat << 'EOF'
+  _cat << 'EOF'
 ENDOFFILE
 }
 

lib/command_commands.bash

@@ -41,7 +41,7 @@ __shellmock__commands() {
     shift
   done
 
-  if ! command -v go &> /dev/null; then
+  if ! PATH="${__SHELLMOCK_ORGPATH}" command -v go &> /dev/null; then
     echo >&2 "The 'commands' command requires a Go toolchain." \
       "Get it from here: https://go.dev/doc/install"
     return 1
@@ -52,13 +52,15 @@ __shellmock__commands() {
     return 1
   fi
   local code
-  code="$(cat -)"
+  code="$(PATH="${__SHELLMOCK_ORGPATH}" cat -)"
 
   # Build the binary used to analyse the shell code.
   local bin="${__SHELLMOCK_GO_MOD}/main"
   if ! [[ -x ${bin} ]]; then
     __shellmock_internal_init_command_search "${__SHELLMOCK_GO_MOD}"
-    (cd "${__SHELLMOCK_GO_MOD}" && go get && go build) 1>&2
+    (cd "${__SHELLMOCK_GO_MOD}" \
+      && PATH="${__SHELLMOCK_ORGPATH}" go get \
+      && PATH="${__SHELLMOCK_ORGPATH}" go build) 1>&2
   fi
 
   declare -A builtins