mirror of
https://github.com/ghostty-org/ghostty.git
synced 2026-09-14 18:01:58 +00:00
5d6615fc43
https://github.com/rcaloras/bash-preexec/releases/tag/0.7.0 We only source bash-preexec for bash < 4.4, so most of this release is inert for us: the PS0 function-substitution hook (bash >= 5.3) and the array PROMPT_COMMAND handling (bash >= 5.1) are never reached. What we do pick up is the simpler install string, per-prompt re-adjustment of PROMPT_COMMAND when something else modifies it, preservation of $? and $_ on early returns, and the first-command preexec fix. We continue to carry one local modification: __bp_adjust_histcontrol stays disabled in the DEBUG trap hook so the user's HISTCONTROL is respected (#2269). The original justification was that we didn't use the preexec command argument, which is no longer true because we use it for the window title. The comment now explains the current reasoning: our bash >= 4.4 integration also uses `history 1` without adjusting HISTCONTROL and accepts the same inaccuracy for space-prefixed commands, so the legacy path is kept consistent with it.
573 lines
22 KiB
Bash
573 lines
22 KiB
Bash
# bash-preexec.sh -- Bash support for ZSH-like 'preexec' and 'precmd' functions.
|
|
# https://github.com/rcaloras/bash-preexec
|
|
#
|
|
#
|
|
# 'preexec' functions are executed before each interactive command is
|
|
# executed, with the interactive command as its argument. The 'precmd'
|
|
# function is executed before each prompt is displayed.
|
|
#
|
|
# Author: Ryan Caloras (ryan@bashhub.com)
|
|
# Forked from Original Author: Glyph Lefkowitz
|
|
#
|
|
# V0.7.0
|
|
#
|
|
|
|
# General Usage:
|
|
#
|
|
# 1. Source this file at the end of your bash profile so as not to interfere
|
|
# with anything else that's using PROMPT_COMMAND.
|
|
#
|
|
# 2. Add any precmd or preexec functions by appending them to their arrays:
|
|
# e.g.
|
|
# precmd_functions+=(my_precmd_function)
|
|
# precmd_functions+=(some_other_precmd_function)
|
|
#
|
|
# preexec_functions+=(my_preexec_function)
|
|
#
|
|
# 3. Consider changing anything using the DEBUG trap or PROMPT_COMMAND
|
|
# to use preexec and precmd instead. Preexisting usages will be
|
|
# preserved, but doing so manually may be less surprising.
|
|
#
|
|
# Note: This module requires two Bash features which you must not otherwise be
|
|
# using: the "DEBUG" trap, and the "PROMPT_COMMAND" variable. If you override
|
|
# either of these after bash-preexec has been installed it will most likely break.
|
|
|
|
# Tell shellcheck what kind of file this is.
|
|
# shellcheck shell=bash
|
|
|
|
# Make sure this is bash that's running and return otherwise.
|
|
# Use POSIX syntax for this line:
|
|
if [ -z "${BASH_VERSION-}" ]; then
|
|
return 1
|
|
fi
|
|
|
|
# We only support Bash 3.1+.
|
|
# Note: BASH_VERSINFO is first available in Bash-2.0.
|
|
if [[ -z "${BASH_VERSINFO-}" ]] || (( BASH_VERSINFO[0] < 3 || (BASH_VERSINFO[0] == 3 && BASH_VERSINFO[1] < 1) )); then
|
|
return 1
|
|
fi
|
|
|
|
# Avoid duplicate inclusion
|
|
if [[ -n "${bash_preexec_imported:-}" || -n "${__bp_imported:-}" ]]; then
|
|
return 0
|
|
fi
|
|
bash_preexec_imported="defined"
|
|
|
|
# WARNING: This variable is no longer used and should not be relied upon.
|
|
# Use ${bash_preexec_imported} instead.
|
|
# shellcheck disable=SC2034
|
|
__bp_imported="${bash_preexec_imported}"
|
|
|
|
# Should be available to each precmd and preexec
|
|
# functions, should they want it. $? and $_ are available as $? and $_, but
|
|
# $PIPESTATUS is available only in a copy, $BP_PIPESTATUS.
|
|
# TODO: Figure out how to restore PIPESTATUS before each precmd or preexec
|
|
# function.
|
|
__bp_last_ret_value="$?"
|
|
BP_PIPESTATUS=("${PIPESTATUS[@]}")
|
|
__bp_last_argument_prev_command="$_"
|
|
|
|
__bp_inside_precmd=0
|
|
__bp_inside_preexec=0
|
|
|
|
# Initial PROMPT_COMMAND string that is removed from PROMPT_COMMAND post __bp_install
|
|
# shellcheck disable=SC2016
|
|
__bp_install_string='__bp_install "$_"'
|
|
|
|
# Fails if any of the given variables are readonly
|
|
# Reference https://stackoverflow.com/a/4441178
|
|
__bp_require_not_readonly() {
|
|
local var
|
|
for var; do
|
|
if ! ( unset "$var" 2> /dev/null ); then
|
|
echo "bash-preexec requires write access to ${var}" >&2
|
|
return 1
|
|
fi
|
|
done
|
|
}
|
|
|
|
# Remove ignorespace and or replace ignoreboth from HISTCONTROL
|
|
# so we can accurately invoke preexec with a command from our
|
|
# history even if it starts with a space.
|
|
__bp_adjust_histcontrol() {
|
|
local histcontrol
|
|
histcontrol="${HISTCONTROL:-}"
|
|
histcontrol="${histcontrol//ignorespace}"
|
|
# Replace ignoreboth with ignoredups
|
|
if [[ "$histcontrol" == *"ignoreboth"* ]]; then
|
|
histcontrol="ignoredups:${histcontrol//ignoreboth}"
|
|
fi
|
|
export HISTCONTROL="$histcontrol"
|
|
}
|
|
|
|
# This variable describes whether we are currently in "interactive mode";
|
|
# i.e. whether this shell has just executed a prompt and is waiting for user
|
|
# input. It documents whether the current command invoked by the trace hook is
|
|
# run interactively by the user; it's set immediately after the prompt hook,
|
|
# and unset as soon as the trace hook is run.
|
|
__bp_preexec_interactive_mode=""
|
|
|
|
# These global arrays are used to add functions to be run before, or after,
|
|
# prompts. Note that Bash < 4.2 does not have the "-g" option of the "declare"
|
|
# builtin. We actually do not need to explicitly initialize these arrays.
|
|
#declare -ga precmd_functions
|
|
#declare -ga preexec_functions
|
|
|
|
# Trims leading and trailing whitespace from $2 and writes it to the variable
|
|
# name passed as $1
|
|
__bp_trim_whitespace() {
|
|
local var=${1:?} text=${2:-}
|
|
text="${text#"${text%%[![:space:]]*}"}" # remove leading whitespace characters
|
|
text="${text%"${text##*[![:space:]]}"}" # remove trailing whitespace characters
|
|
printf -v "$var" '%s' "$text"
|
|
}
|
|
|
|
|
|
# Trims whitespace and removes any leading or trailing semicolons from $2 and
|
|
# writes the resulting string to the variable name passed as $1. This also
|
|
# removes the no-op colons, which are converted from the hooks to remove. Used
|
|
# for manipulating substrings in PROMPT_COMMAND
|
|
__bp_sanitize_string() {
|
|
local var=${1:?} sanitized=${2:-}
|
|
|
|
local unset_extglob=
|
|
if ! shopt -q extglob; then
|
|
unset_extglob=yes
|
|
shopt -s extglob
|
|
fi
|
|
|
|
# We specify newline character through the variable `nl' because $'\n'
|
|
# inside "${var//...}" is treated literally as "\$'\\n'" when `extquote' is
|
|
# unset (shopt -u extquote). (Note: Bash 5.2's extquote seems to be buggy.)
|
|
local tmp nl=$'\n'
|
|
while
|
|
# Note: Quoting parameter expansions $nl in PAT of ${var//PAT/REP} is
|
|
# required by shellcheck. On the other hand, we should not quote the
|
|
# parameter expansions $nl in REP because the quotes will remain in the
|
|
# replaced result with `shopt -s compat42'.
|
|
# Note: We use ?(+([[:blank:]])) instead of *([[:blank:]]) to work
|
|
# around a bug of Bash 3.2 that *(...) is not properly processed as
|
|
# extglob at the beginning of the pattern in ${var//pat/rep}.
|
|
tmp="${sanitized//?(+([[:blank:]]))[";$nl"]*([[:blank:]]):*([[:blank:]])[";$nl"]*([[:blank:]])/$nl}"
|
|
[[ "$tmp" != "$sanitized" ]]
|
|
do
|
|
sanitized="$tmp"
|
|
done
|
|
sanitized="${sanitized#:*([[:blank:]])[";$nl"]}"
|
|
sanitized="${sanitized%[";$nl"]*([[:blank:]]):}"
|
|
__bp_trim_whitespace sanitized "$sanitized"
|
|
sanitized=${sanitized%;}
|
|
sanitized=${sanitized#;}
|
|
__bp_trim_whitespace sanitized "$sanitized"
|
|
if [[ "$sanitized" == ":" ]]; then
|
|
sanitized=
|
|
fi
|
|
printf -v "$var" '%s' "$sanitized"
|
|
|
|
if [[ -n "$unset_extglob" ]]; then
|
|
shopt -u extglob
|
|
fi
|
|
}
|
|
|
|
|
|
# Bash >= 5.1 supports the array version of PROMPT_COMMAND.
|
|
__bp_use_array_prompt_command() {
|
|
(( BASH_VERSINFO[0] > 5 || (BASH_VERSINFO[0] == 5 && BASH_VERSINFO[1] >= 1) ))
|
|
}
|
|
|
|
|
|
# Remove $1 and sanitize each elements of PROMPT_COMMAND. We want to keep
|
|
# PROMPT_COMMAND scalar in bash < 5.1 because some configuration tests the
|
|
# support for the array PROMPT_COMMAND by checking the array attribute of
|
|
# PROMPT_COMMAND.
|
|
__bp_remove_command_from_prompt_command() {
|
|
local removed_command="${1-}"
|
|
if __bp_use_array_prompt_command; then
|
|
local i sanitized_prompt_command
|
|
for i in "${!PROMPT_COMMAND[@]}"; do
|
|
sanitized_prompt_command="${PROMPT_COMMAND[i]:-}"
|
|
sanitized_prompt_command="${sanitized_prompt_command//"$removed_command"/:}"
|
|
__bp_sanitize_string sanitized_prompt_command "$sanitized_prompt_command"
|
|
if [[ -n "$sanitized_prompt_command" ]]; then
|
|
PROMPT_COMMAND[i]="$sanitized_prompt_command"
|
|
else
|
|
unset -v 'PROMPT_COMMAND[i]'
|
|
fi
|
|
done
|
|
else
|
|
local sanitized_prompt_command="${PROMPT_COMMAND:-}"
|
|
sanitized_prompt_command="${sanitized_prompt_command//"$removed_command"/:}" # no-op
|
|
__bp_sanitize_string PROMPT_COMMAND "$sanitized_prompt_command"
|
|
fi
|
|
}
|
|
|
|
|
|
# This function is installed as part of the PROMPT_COMMAND;
|
|
# It sets a variable to indicate that the prompt was just displayed,
|
|
# to allow the DEBUG trap to know that the next command is likely interactive.
|
|
__bp_interactive_mode() {
|
|
if [[ "${1-}" != "force" && ! "${BATS_VERSION-}" ]] && (( ${#FUNCNAME[*]} > 1 )); then
|
|
# When this function is not called from the top level, the current
|
|
# function call is probably performed via PROMPT_COMMAND saved by
|
|
# another framework (e.g., starship). In this case, we do not want to
|
|
# turn on the "interactive mode" here.
|
|
return 0
|
|
fi
|
|
|
|
__bp_preexec_interactive_mode="on"
|
|
}
|
|
|
|
|
|
# This function is installed as part of the PROMPT_COMMAND.
|
|
# It will invoke any functions defined in the precmd_functions array.
|
|
__bp_precmd_invoke_cmd() {
|
|
# Save the returned value and the last argument from our last command, and
|
|
# the returned value from each process in its pipeline. Note: this MUST be
|
|
# the first thing done in this function.
|
|
# BP_PIPESTATUS may be unused, ignore
|
|
# shellcheck disable=SC2034
|
|
__bp_last_ret_value="$?" __bp_last_argument_prev_command="$_" \
|
|
BP_PIPESTATUS=("${PIPESTATUS[@]}")
|
|
|
|
|
|
# Don't invoke precmds if we are inside an execution of an "original
|
|
# prompt command" by another precmd execution loop. This avoids infinite
|
|
# recursion.
|
|
if (( __bp_inside_precmd > 0 )); then
|
|
return "$__bp_last_ret_value"
|
|
fi
|
|
|
|
# Check and adjust PROMPT_COMMAND to make sure that PROMPT_COMMAND has the
|
|
# form "__bp_precmd_invoke_cmd; ...; __bp_interactive_mode"
|
|
if ! __bp_install_prompt_command; then
|
|
if [[ "${1-}" != "force" && ! "${BATS_VERSION-}" ]] && (( ${#FUNCNAME[*]} > 1 )); then
|
|
# When PROMPT_COMMAND is already properly set up but this function
|
|
# is not called from the top level, the current function call is
|
|
# probably performed via PROMPT_COMMAND saved by another framework
|
|
# (e.g., starship). In this case, we do not need to invoke precmd
|
|
# because it is supposed to be already processed by the top-level
|
|
# __bp_precmd_invoke_cmd.
|
|
return "$__bp_last_ret_value"
|
|
fi
|
|
fi
|
|
|
|
local __bp_inside_precmd=1
|
|
__bp_invoke_precmd_functions "$__bp_last_ret_value" "$__bp_last_argument_prev_command"
|
|
|
|
__bp_set_ret_value "$__bp_last_ret_value" "$__bp_last_argument_prev_command"
|
|
}
|
|
|
|
# This function invokes every function defined in the "precmd_functions" array.
|
|
# This function receives the arguments $1 and $2 for $? and $_, respectively,
|
|
# which will be set for each precmd function. This function returns the last
|
|
# non-zero exit status of the hook functions. If there is no error, this
|
|
# function returns 0.
|
|
__bp_invoke_precmd_functions() {
|
|
local lastexit=$1 lastarg=$2
|
|
# Invoke every function defined in our function array.
|
|
local precmd_function
|
|
local precmd_function_ret_value
|
|
local precmd_ret_value=0
|
|
for precmd_function in "${precmd_functions[@]}"; do
|
|
|
|
# Only execute this function if it actually exists.
|
|
# Test existence of functions with: declare -[Ff]
|
|
if type -t "$precmd_function" 1>/dev/null; then
|
|
__bp_set_ret_value "$lastexit" "$lastarg"
|
|
# Quote our function invocation to prevent issues with IFS
|
|
"$precmd_function"
|
|
precmd_function_ret_value=$?
|
|
if [[ "$precmd_function_ret_value" != 0 ]]; then
|
|
precmd_ret_value="$precmd_function_ret_value"
|
|
fi
|
|
fi
|
|
done
|
|
|
|
__bp_set_ret_value "$precmd_ret_value"
|
|
}
|
|
|
|
# Sets a return value in $?. We may want to get access to the $? variable in our
|
|
# precmd functions. This is available for instance in zsh. We can simulate it in bash
|
|
# by setting the value here.
|
|
__bp_set_ret_value() {
|
|
return ${1:+"$1"}
|
|
}
|
|
|
|
__bp_in_prompt_command() {
|
|
|
|
local prompt_command_array IFS=$'\n;'
|
|
read -rd '' -a prompt_command_array <<< "${PROMPT_COMMAND[*]:-}"
|
|
|
|
local trimmed_arg
|
|
__bp_trim_whitespace trimmed_arg "${1:-}"
|
|
|
|
local command trimmed_command
|
|
for command in "${prompt_command_array[@]:-}"; do
|
|
__bp_trim_whitespace trimmed_command "$command"
|
|
if [[ "$trimmed_command" == "$trimmed_arg" ]]; then
|
|
return 0
|
|
fi
|
|
done
|
|
|
|
return 1
|
|
}
|
|
|
|
__bp_load_this_command_from_history() {
|
|
this_command=$(LC_ALL=C HISTTIMEFORMAT='' builtin history 1)
|
|
this_command="${this_command#*[[:digit:]][* ] }"
|
|
|
|
# Sanity check to make sure we have something to invoke our function with.
|
|
[[ -n "$this_command" ]]
|
|
}
|
|
|
|
# This function is installed as the DEBUG trap. It is invoked before each
|
|
# interactive prompt display. Its purpose is to inspect the current
|
|
# environment to attempt to detect if the current command is being invoked
|
|
# interactively, and invoke 'preexec' if so.
|
|
__bp_preexec_invoke_exec() {
|
|
local lastarg=$_
|
|
|
|
# Don't invoke preexecs if we are inside of another preexec.
|
|
if (( __bp_inside_preexec > 0 )); then
|
|
return
|
|
fi
|
|
local __bp_inside_preexec=1
|
|
|
|
# Checks if the file descriptor is not standard out (i.e. '1')
|
|
# __bp_delay_install checks if we're in test. Needed for bats to run.
|
|
# Prevents preexec from being invoked for functions in PS1
|
|
if [[ ! -t 1 && -z "${__bp_delay_install:-}" ]]; then
|
|
return
|
|
fi
|
|
|
|
if [[ -n "${COMP_POINT:-}" || -n "${READLINE_POINT:-}" ]]; then
|
|
# We're in the middle of a completer or a keybinding set up by "bind
|
|
# -x". This obviously can't be an interactively issued command.
|
|
return
|
|
fi
|
|
if [[ -z "${__bp_preexec_interactive_mode:-}" ]]; then
|
|
# We're doing something related to displaying the prompt. Let the
|
|
# prompt set the title instead of me.
|
|
return
|
|
else
|
|
# If we're in a subshell, then the prompt won't be re-displayed to put
|
|
# us back into interactive mode, so let's not set the variable back.
|
|
# In other words, if you have a subshell like
|
|
# (sleep 1; sleep 2)
|
|
# You want to see the 'sleep 2' as a set_command_title as well.
|
|
if [[ 0 -eq "${BASH_SUBSHELL:-}" ]]; then
|
|
__bp_preexec_interactive_mode=""
|
|
fi
|
|
fi
|
|
|
|
if __bp_in_prompt_command "${BASH_COMMAND:-}"; then
|
|
# If we're executing something inside our prompt_command then we don't
|
|
# want to call preexec. Bash prior to 3.1 can't detect this at all :/
|
|
__bp_preexec_interactive_mode=""
|
|
return
|
|
fi
|
|
|
|
# Save the contents of $_ so that it can be restored later on.
|
|
# https://stackoverflow.com/questions/40944532/bash-preserve-in-a-debug-trap#40944702
|
|
__bp_last_argument_prev_command=$lastarg
|
|
|
|
local this_command
|
|
__bp_load_this_command_from_history || return
|
|
|
|
__bp_invoke_preexec_functions "${__bp_last_ret_value:-}" "$__bp_last_argument_prev_command" "$this_command"
|
|
local preexec_ret_value=$?
|
|
|
|
# Restore the last argument of the last executed command, and set the return
|
|
# value of the DEBUG trap to be the return code of the last preexec function
|
|
# to return an error.
|
|
# If `extdebug` is enabled a non-zero return value from any preexec function
|
|
# will cause the user's command not to execute.
|
|
# Run `shopt -s extdebug` to enable
|
|
__bp_set_ret_value "$preexec_ret_value" "$__bp_last_argument_prev_command"
|
|
}
|
|
|
|
__bp_invoke_preexec_from_ps0() {
|
|
__bp_last_argument_prev_command="${1:-}"
|
|
|
|
local this_command
|
|
__bp_load_this_command_from_history || return
|
|
|
|
__bp_invoke_preexec_functions "${__bp_last_ret_value:-}" "$__bp_last_argument_prev_command" "$this_command"
|
|
}
|
|
|
|
# This function invokes every function defined in the "preexec_functions"
|
|
# array. This function receives the arguments $1 and $2 for $? and $_,
|
|
# respectively, which will be set for each preexec function. The third
|
|
# argument $3 specifies the user command that is going to be executed
|
|
# (corresponding to BASH_COMMAND in the DEBUG trap). This function returns the
|
|
# last non-zero exit status from the preexec functions. If there is no error,
|
|
# this function returns `0`.
|
|
__bp_invoke_preexec_functions() {
|
|
local lastexit=$1 lastarg=$2 this_command=$3
|
|
local preexec_function
|
|
local preexec_function_ret_value
|
|
local preexec_ret_value=0
|
|
for preexec_function in "${preexec_functions[@]:-}"; do
|
|
|
|
# Only execute each function if it actually exists.
|
|
# Test existence of function with: declare -[fF]
|
|
if type -t "$preexec_function" 1>/dev/null; then
|
|
__bp_set_ret_value "$lastexit" "$lastarg"
|
|
# Quote our function invocation to prevent issues with IFS
|
|
"$preexec_function" "$this_command"
|
|
preexec_function_ret_value="$?"
|
|
if [[ "$preexec_function_ret_value" != 0 ]]; then
|
|
preexec_ret_value="$preexec_function_ret_value"
|
|
fi
|
|
fi
|
|
done
|
|
__bp_set_ret_value "$preexec_ret_value"
|
|
}
|
|
|
|
__bp_hook_preexec_into_debug() {
|
|
local trap_string
|
|
trap_string=$(trap -p DEBUG)
|
|
trap '__bp_preexec_invoke_exec "$_"' DEBUG
|
|
|
|
# Preserve any prior DEBUG trap as a preexec function
|
|
eval "local trap_argv=(${trap_string:-})"
|
|
local prior_trap=${trap_argv[2]:-}
|
|
if [[ -n "$prior_trap" ]]; then
|
|
eval '__bp_original_debug_trap() {
|
|
'"$prior_trap"'
|
|
}'
|
|
preexec_functions+=(__bp_original_debug_trap)
|
|
fi
|
|
|
|
# Adjust our HISTCONTROL Variable if needed.
|
|
#
|
|
# GHOSTTY: Don't modify HISTCONTROL (#2269). This only improves the
|
|
# accuracy of the command passed to preexec functions when the user has
|
|
# ignorespace set. Our bash >= 4.4 integration reads `history 1` without
|
|
# adjusting HISTCONTROL and accepts the same inaccuracy, so keep the
|
|
# legacy path consistent with it and respect the user's setting.
|
|
#__bp_adjust_histcontrol
|
|
|
|
# Issue #25. Setting debug trap for subshells causes sessions to exit for
|
|
# backgrounded subshell commands (e.g. (pwd)& ). Believe this is a bug in Bash.
|
|
#
|
|
# Disabling this by default. It can be enabled by setting this variable.
|
|
if [[ -n "${__bp_enable_subshells:-}" ]]; then
|
|
|
|
# Set so debug trap will work be invoked in subshells.
|
|
set -o functrace > /dev/null 2>&1
|
|
shopt -s extdebug > /dev/null 2>&1
|
|
fi
|
|
}
|
|
|
|
__bp_hook_preexec_into_ps0() {
|
|
# shellcheck disable=SC2016
|
|
PS0=${PS0-}'${ __bp_invoke_preexec_from_ps0 "$_" >&2; }'
|
|
|
|
# Adjust our HISTCONTROL Variable if needed.
|
|
__bp_adjust_histcontrol
|
|
}
|
|
|
|
if (( BASH_VERSINFO[0] > 5 || (BASH_VERSINFO[0] == 5 && BASH_VERSINFO[1] >= 3) )); then
|
|
__bp_hook_preexec_proc=__bp_hook_preexec_into_ps0
|
|
else
|
|
__bp_hook_preexec_proc=__bp_hook_preexec_into_debug
|
|
fi
|
|
|
|
__bp_install() {
|
|
local lastexit=$? lastarg=$_
|
|
# Exit if we already have this installed.
|
|
# shellcheck disable=SC2016
|
|
if [[ "${PROMPT_COMMAND[*]:-}" == *'__bp_precmd_invoke_cmd "$_"'* ]]; then
|
|
return 1
|
|
fi
|
|
|
|
"$__bp_hook_preexec_proc"
|
|
|
|
# Remove setting our trap install string and sanitize the existing prompt command string
|
|
__bp_remove_command_from_prompt_command "$__bp_install_string"
|
|
|
|
__bp_install_prompt_command || true
|
|
|
|
# Add two functions to our arrays for convenience
|
|
# of definition.
|
|
precmd_functions+=(precmd)
|
|
preexec_functions+=(preexec)
|
|
|
|
# Invoke our two functions manually that were added to $PROMPT_COMMAND
|
|
__bp_set_ret_value "$lastexit" "$lastarg"
|
|
__bp_precmd_invoke_cmd force
|
|
__bp_interactive_mode force
|
|
}
|
|
|
|
# Note: We need to add the "trace" attribute to these functions so that "trap
|
|
# ... DEBUG" inside "__bp_install" and "__bp_hook_preexec_into_debug" takes
|
|
# effect even when there is an existing DEBUG trap.
|
|
declare -ft __bp_install __bp_hook_preexec_into_debug
|
|
|
|
# Encloses PROMPT_COMMAND hooks within __bp_precmd_invoke_cmd and
|
|
# __bp_interactive_mode. If all the PROMPT_COMMAND hooks are already surrounded
|
|
# by __bp_precmd_invoke_cmd and __bp_interactive_mode, the function exits with
|
|
# status 1.
|
|
__bp_install_prompt_command() {
|
|
local prompt_command="${PROMPT_COMMAND:-}"
|
|
if __bp_use_array_prompt_command; then
|
|
local IFS=$'\n'
|
|
prompt_command="${PROMPT_COMMAND[*]:-}"
|
|
IFS=$' \t\n'
|
|
fi
|
|
|
|
# Exit if we already have a properly set-up hooks in PROMPT_COMMAND
|
|
# shellcheck disable=SC2016
|
|
local prologue='__bp_precmd_invoke_cmd "$_"'
|
|
local epilogue='__bp_interactive_mode'
|
|
if [[ "$prompt_command" == "$prologue"$'\n'* && "$prompt_command" == *$'\n'"$epilogue" ]]; then
|
|
return 1
|
|
fi
|
|
|
|
__bp_remove_command_from_prompt_command "$prologue"
|
|
__bp_remove_command_from_prompt_command "$epilogue"
|
|
|
|
# Install our hooks in PROMPT_COMMAND to allow our trap to know when we've
|
|
# actually entered something.
|
|
# shellcheck disable=SC2128,SC2178 # PROMPT_COMMAND is not an array in bash <= 5.0
|
|
PROMPT_COMMAND=$prologue${PROMPT_COMMAND:+$'\n'$PROMPT_COMMAND}
|
|
if __bp_use_array_prompt_command; then
|
|
PROMPT_COMMAND+=("$epilogue")
|
|
else
|
|
# shellcheck disable=SC2179 # PROMPT_COMMAND is not an array in bash <= 5.0
|
|
PROMPT_COMMAND+=$'\n'$epilogue
|
|
fi
|
|
return 0
|
|
}
|
|
|
|
# Sets an installation string as part of our PROMPT_COMMAND to install
|
|
# after our session has started. This allows bash-preexec to be included
|
|
# at any point in our bash profile.
|
|
__bp_install_after_session_init() {
|
|
# bash-preexec needs to modify these variables in order to work correctly
|
|
# if it can't, just stop the installation
|
|
__bp_require_not_readonly PROMPT_COMMAND HISTCONTROL HISTTIMEFORMAT || return
|
|
if [[ $__bp_hook_preexec_proc == '__bp_hook_preexec_into_ps0' ]]; then
|
|
__bp_require_not_readonly PS0 || return
|
|
fi
|
|
|
|
if __bp_use_array_prompt_command; then
|
|
PROMPT_COMMAND+=("${__bp_install_string}")
|
|
else
|
|
local sanitized_prompt_command
|
|
__bp_sanitize_string sanitized_prompt_command "${PROMPT_COMMAND:-}"
|
|
if [[ -n "$sanitized_prompt_command" ]]; then
|
|
# shellcheck disable=SC2178 # PROMPT_COMMAND is not an array in bash <= 5.0
|
|
PROMPT_COMMAND=${sanitized_prompt_command}$'\n'
|
|
fi
|
|
# shellcheck disable=SC2179 # PROMPT_COMMAND is not an array in bash <= 5.0
|
|
PROMPT_COMMAND+=${__bp_install_string}
|
|
fi
|
|
}
|
|
|
|
# Run our install so long as we're not delaying it.
|
|
if [[ -z "${__bp_delay_install:-}" ]]; then
|
|
__bp_install_after_session_init
|
|
fi
|