1 |
8291
|
aaronmk
|
#!/bin/bash -e
|
2 |
8952
|
aaronmk
|
set -o errexit # in case caller did not have -e in #! line
|
3 |
|
|
|
4 |
9018
|
aaronmk
|
if test ! "$_util_sh_include_guard_utils"; then
|
5 |
|
|
_util_sh_include_guard_utils=1
|
6 |
|
|
|
7 |
9074
|
aaronmk
|
isset() { test "${!1+isset}"; }
|
8 |
9002
|
aaronmk
|
|
9 |
9074
|
aaronmk
|
realpath() { readlink -f -- "$1"; }
|
10 |
8703
|
aaronmk
|
|
11 |
9168
|
aaronmk
|
include_guard_var() { realpath "$1"|builtin command sed 's/[^a-zA-Z0-9_]/_/g'; }
|
12 |
8716
|
aaronmk
|
|
13 |
9074
|
aaronmk
|
self_not_included() # usage: if self_not_included; then ... fi
|
14 |
8703
|
aaronmk
|
{
|
15 |
8971
|
aaronmk
|
test $# -ge 1 || set -- "${BASH_SOURCE[1]}"
|
16 |
8703
|
aaronmk
|
local include_guard="$(include_guard_var "$1")"
|
17 |
8793
|
aaronmk
|
alias self_being_included=false
|
18 |
9003
|
aaronmk
|
! isset "$include_guard" && \
|
19 |
8793
|
aaronmk
|
{ eval "$include_guard"=1; alias self_being_included=true; }
|
20 |
8703
|
aaronmk
|
}
|
21 |
|
|
|
22 |
8793
|
aaronmk
|
# to load newly-defined aliases for use in functions in the same file:
|
23 |
|
|
## fi # load new aliases
|
24 |
|
|
## if self_being_included; then
|
25 |
|
|
# this is needed because aliases defined inside an if statement are not
|
26 |
|
|
# available inside that if statement
|
27 |
|
|
|
28 |
9018
|
aaronmk
|
fi
|
29 |
9017
|
aaronmk
|
|
30 |
9018
|
aaronmk
|
|
31 |
8704
|
aaronmk
|
if self_not_included "${BASH_SOURCE[0]}"; then
|
32 |
|
|
|
33 |
9017
|
aaronmk
|
|
34 |
|
|
#### options
|
35 |
|
|
|
36 |
8709
|
aaronmk
|
shopt -s expand_aliases
|
37 |
|
|
|
38 |
9017
|
aaronmk
|
|
39 |
|
|
#### aliases
|
40 |
|
|
|
41 |
9074
|
aaronmk
|
unalias() { builtin unalias "$@" 2>&- || true; } # no error if undefined
|
42 |
8889
|
aaronmk
|
|
43 |
9017
|
aaronmk
|
|
44 |
9082
|
aaronmk
|
#### functions
|
45 |
|
|
|
46 |
|
|
alias self='command "$FUNCNAME"' # usage: wrapper() { self ...; }
|
47 |
|
|
|
48 |
|
|
|
49 |
8886
|
aaronmk
|
#### exceptions
|
50 |
|
|
|
51 |
9032
|
aaronmk
|
# usage: cmd || { save_e; ...; rethrow; }
|
52 |
9031
|
aaronmk
|
alias export_e='e=$?'
|
53 |
9032
|
aaronmk
|
alias save_e='declare e=$?'
|
54 |
8976
|
aaronmk
|
alias rethrow='return "$e"'
|
55 |
|
|
alias rethrow_subshell='exit "$e"'
|
56 |
|
|
|
57 |
8978
|
aaronmk
|
fi # load new aliases
|
58 |
|
|
if self_being_included; then
|
59 |
|
|
|
60 |
8886
|
aaronmk
|
# usage: try cmd...; ignore status; if catch status; then ...; fi; end_try
|
61 |
|
|
|
62 |
9074
|
aaronmk
|
function try() { e=0; "$@" || { export_e; true; }; }
|
63 |
9177
|
aaronmk
|
alias try='declare e; "try" ' # last space alias-expands next word
|
64 |
8886
|
aaronmk
|
|
65 |
9074
|
aaronmk
|
catch() { test "$e" -eq "$1"; e=0; }
|
66 |
8886
|
aaronmk
|
|
67 |
9074
|
aaronmk
|
ignore() { catch "$@" || true; }
|
68 |
8886
|
aaronmk
|
|
69 |
8977
|
aaronmk
|
alias end_try='rethrow'
|
70 |
|
|
alias end_try_subshell='rethrow_subshell'
|
71 |
8886
|
aaronmk
|
|
72 |
9020
|
aaronmk
|
fi # load new aliases
|
73 |
|
|
if self_being_included; then
|
74 |
9017
|
aaronmk
|
|
75 |
9020
|
aaronmk
|
|
76 |
8899
|
aaronmk
|
#### integers
|
77 |
|
|
|
78 |
9074
|
aaronmk
|
let!() { let "$@" || true; } # always returns true; safe to use for setting
|
79 |
8899
|
aaronmk
|
# "If the last ARG evaluates to 0, let returns 1" (`help let`)
|
80 |
|
|
|
81 |
9074
|
aaronmk
|
bool2int() { try test ! "$1"; echo "$e"; } # empty->0; non-empty->1
|
82 |
9004
|
aaronmk
|
|
83 |
9017
|
aaronmk
|
|
84 |
9079
|
aaronmk
|
#### strings
|
85 |
|
|
|
86 |
9081
|
aaronmk
|
repeat() # usage: str=... n=... repeat
|
87 |
|
|
{
|
88 |
|
|
: "${str?}" "${n:?}"; local n="$n" # will be modified in function
|
89 |
|
|
for (( ; n > 0; n-- )); do printf '%q' "$str"; done
|
90 |
|
|
}
|
91 |
|
|
|
92 |
9079
|
aaronmk
|
sed_ere_flag="$(test "$(uname)" = Darwin && echo E || echo r)"
|
93 |
|
|
|
94 |
|
|
sed() { self -"$sed_ere_flag" "$@";}
|
95 |
|
|
|
96 |
9085
|
aaronmk
|
rtrim() { sed 's/[[:space:]]+$//' <<<"$1"; }
|
97 |
9079
|
aaronmk
|
|
98 |
9085
|
aaronmk
|
|
99 |
8854
|
aaronmk
|
#### arrays
|
100 |
8694
|
aaronmk
|
|
101 |
9074
|
aaronmk
|
join() { local IFS="$delim"; echo "$*"; } # usage: delim=... join elems...
|
102 |
8816
|
aaronmk
|
|
103 |
9074
|
aaronmk
|
reverse() # usage: array=($(reverse args...))
|
104 |
8691
|
aaronmk
|
{
|
105 |
|
|
local i
|
106 |
9080
|
aaronmk
|
for (( i=$#; i > 0; i-- )); do printf '%q ' "${!i}"; done
|
107 |
8691
|
aaronmk
|
}
|
108 |
|
|
|
109 |
9097
|
aaronmk
|
contains() # usage: contains value in_array...
|
110 |
|
|
{
|
111 |
|
|
local value="$1"; shift
|
112 |
|
|
local elem
|
113 |
|
|
for elem in "$@"; do if test "$elem" = "$value"; then return 0; fi; done
|
114 |
|
|
return 1
|
115 |
|
|
}
|
116 |
9017
|
aaronmk
|
|
117 |
9097
|
aaronmk
|
|
118 |
9040
|
aaronmk
|
#### paths
|
119 |
|
|
|
120 |
9074
|
aaronmk
|
canon_rel_path()
|
121 |
9040
|
aaronmk
|
{
|
122 |
|
|
local path="$1"
|
123 |
|
|
path="$(realpath "$path")" # canonicalize
|
124 |
|
|
path="${path#$(pwd -P)/}" # remove any shared prefix with the current dir
|
125 |
|
|
echo "$path"
|
126 |
|
|
}
|
127 |
|
|
|
128 |
9051
|
aaronmk
|
# makes $1 a canon_rel_path if it's a filesystem path
|
129 |
|
|
alias cmd2rel_path="$(cat <<'EOF'
|
130 |
|
|
if test "$(type -t "$1")" = file && test -e "$1"; then # not relative to PATH
|
131 |
|
|
declare _1="$1"; shift
|
132 |
|
|
set -- "$(canon_rel_path "$_1")" "$@"
|
133 |
|
|
fi
|
134 |
|
|
EOF
|
135 |
|
|
)"
|
136 |
9040
|
aaronmk
|
|
137 |
9051
|
aaronmk
|
|
138 |
8854
|
aaronmk
|
#### verbose output
|
139 |
|
|
|
140 |
9110
|
aaronmk
|
|
141 |
8973
|
aaronmk
|
# usage: (stdout2stderr; cmd...) || return
|
142 |
9112
|
aaronmk
|
# `|| return` needed on Mac because of bug where -e doesn't apply to ()
|
143 |
9074
|
aaronmk
|
stdout2stderr() { exec >&2; }
|
144 |
8914
|
aaronmk
|
|
145 |
9111
|
aaronmk
|
usage() { echo "Usage: $1" >&2; return 2; }
|
146 |
9110
|
aaronmk
|
|
147 |
|
|
|
148 |
|
|
### logging
|
149 |
|
|
|
150 |
9142
|
aaronmk
|
if test "$explicit_errors_only"; then verbosity=0; fi # hide startup logging
|
151 |
|
|
|
152 |
9006
|
aaronmk
|
# set verbosity
|
153 |
9005
|
aaronmk
|
if isset verbose; then : "${verbosity:=$(bool2int "$verbose")}"; fi
|
154 |
9145
|
aaronmk
|
if isset vb; then : "${verbosity:=$vb}"; fi
|
155 |
9006
|
aaronmk
|
: "${verbosity=3}" # default
|
156 |
|
|
: "${verbosity:=0}" # ensure non-empty
|
157 |
9119
|
aaronmk
|
export verbosity # propagate to invoked commands
|
158 |
8710
|
aaronmk
|
|
159 |
9179
|
aaronmk
|
: "${log_level_indent= }" "${log_indent=}"
|
160 |
9176
|
aaronmk
|
export log_level_indent log_indent # propagate to invoked commands
|
161 |
|
|
alias indent='declare log_indent="$log_indent$log_level_indent"'
|
162 |
|
|
|
163 |
|
|
# usage: in func: PS4++; ...
|
164 |
|
|
# outside func: PS4++; ...; PS4--
|
165 |
|
|
alias PS4++='declare PS4="${PS4:0:1}$PS4"'
|
166 |
|
|
alias PS4--='declare PS4="${PS4#${PS4:0:1}}"'
|
167 |
|
|
|
168 |
|
|
# usage: in func: log++; ...
|
169 |
|
|
# outside func: log++; ...; log--
|
170 |
|
|
alias log++='{ PS4++; declare verbosity="$verbosity"; let! verbosity--; }'
|
171 |
|
|
alias log--='{ PS4--; declare verbosity="$verbosity"; let! verbosity++; }'
|
172 |
|
|
|
173 |
9074
|
aaronmk
|
can_log() { test "$verbosity" -gt 0; } # verbosity=0 turns off all logging
|
174 |
8895
|
aaronmk
|
|
175 |
9119
|
aaronmk
|
log() { if can_log; then echo "$log_indent$PS4$1" >&2; fi; }
|
176 |
9064
|
aaronmk
|
|
177 |
9070
|
aaronmk
|
# usage: symbol=... log_custom msg
|
178 |
9074
|
aaronmk
|
log_custom() { local PS4="${PS4%[^ ] }$symbol "; log "$@"; }
|
179 |
9070
|
aaronmk
|
|
180 |
9143
|
aaronmk
|
log_err() { symbol=! verbosity=1 log_custom "$@" 2>&22; } #ensure errors visible
|
181 |
9070
|
aaronmk
|
|
182 |
9074
|
aaronmk
|
log_info() { symbol=? log_custom "$@"; }
|
183 |
9070
|
aaronmk
|
|
184 |
9067
|
aaronmk
|
# usage: cmd || { save_e; log_e; ...; rethrow; }
|
185 |
9074
|
aaronmk
|
log_e() { log_err "command exited with error $e"; }
|
186 |
9067
|
aaronmk
|
|
187 |
9072
|
aaronmk
|
# usage: cmd || [type=...] die msg
|
188 |
9074
|
aaronmk
|
die() { save_e; "log_${type:-err}" "$1"; rethrow; }
|
189 |
9069
|
aaronmk
|
|
190 |
8919
|
aaronmk
|
|
191 |
9165
|
aaronmk
|
### command echoing
|
192 |
|
|
|
193 |
|
|
alias echo_params='log "$*"'
|
194 |
|
|
|
195 |
8995
|
aaronmk
|
fi # load new aliases
|
196 |
|
|
if self_being_included; then
|
197 |
|
|
|
198 |
9074
|
aaronmk
|
echo_cmd()
|
199 |
9056
|
aaronmk
|
{
|
200 |
9163
|
aaronmk
|
case "$1" in builtin|command) shift;; esac
|
201 |
9165
|
aaronmk
|
echo_params
|
202 |
9056
|
aaronmk
|
}
|
203 |
|
|
|
204 |
9173
|
aaronmk
|
alias echo_run_prep='{ cmd2rel_path; echo_cmd "$@"; indent; }'
|
205 |
9157
|
aaronmk
|
|
206 |
|
|
fi # load new aliases
|
207 |
|
|
if self_being_included; then
|
208 |
|
|
|
209 |
9123
|
aaronmk
|
## internal commands
|
210 |
|
|
|
211 |
9166
|
aaronmk
|
.()
|
212 |
|
|
{
|
213 |
9174
|
aaronmk
|
cmd2rel_path; set -- . "$@"; (log++; echo_params); indent
|
214 |
9166
|
aaronmk
|
builtin "$@"
|
215 |
|
|
}
|
216 |
9158
|
aaronmk
|
|
217 |
9165
|
aaronmk
|
echo_eval() { echo_params; builtin eval "$@"; }
|
218 |
9123
|
aaronmk
|
|
219 |
9110
|
aaronmk
|
## external commands
|
220 |
|
|
|
221 |
9134
|
aaronmk
|
function command() # usage: [stderr_is_errors=1] command extern_cmd...
|
222 |
9138
|
aaronmk
|
# to view only explicitly-displayed errors: explicit_errors_only=1 script...
|
223 |
9134
|
aaronmk
|
{
|
224 |
9168
|
aaronmk
|
test "$cmd_echoed" || echo_run_prep
|
225 |
9134
|
aaronmk
|
set -- -- "$@" # prepend -- so command name not treated as `command` option
|
226 |
|
|
set -- builtin command "$@"
|
227 |
|
|
if test "$stderr_is_errors"; then "$@" 2>&22 # ensure errors are visible
|
228 |
|
|
else "$@"; fi
|
229 |
|
|
}
|
230 |
9133
|
aaronmk
|
|
231 |
9160
|
aaronmk
|
# auto-echo common external commands
|
232 |
|
|
for cmd in env rm; do alias "$cmd=command $cmd"; done; unset cmd
|
233 |
9110
|
aaronmk
|
|
234 |
|
|
## functions
|
235 |
|
|
|
236 |
|
|
function echo_func()
|
237 |
|
|
{
|
238 |
9174
|
aaronmk
|
log++
|
239 |
9110
|
aaronmk
|
local script="$(canon_rel_path "${BASH_SOURCE[1]}")"
|
240 |
|
|
echo_cmd "$script:${BASH_LINENO[0]}" "${FUNCNAME[1]}" "$@"
|
241 |
|
|
}
|
242 |
9178
|
aaronmk
|
alias echo_func='{ "echo_func" "$@"; indent; }'
|
243 |
|
|
alias echo_minor_func='{ (log++; "echo_func"); indent; }'
|
244 |
9110
|
aaronmk
|
|
245 |
|
|
## vars
|
246 |
|
|
|
247 |
|
|
echo_vars() # usage: echo_vars var...
|
248 |
|
|
{
|
249 |
9174
|
aaronmk
|
log++; log++
|
250 |
9110
|
aaronmk
|
if can_log; then
|
251 |
|
|
local var
|
252 |
9121
|
aaronmk
|
for var in "${@%%=*}"; do log "$(declare -p "$var")"; done
|
253 |
9110
|
aaronmk
|
fi
|
254 |
|
|
}
|
255 |
|
|
|
256 |
|
|
echo_export() { builtin export "$@"; echo_vars "$@"; }
|
257 |
|
|
|
258 |
|
|
if test "$verbosity" -ge 2; then
|
259 |
|
|
alias export="echo_export" # automatically echo env vars when they are set
|
260 |
|
|
fi
|
261 |
|
|
|
262 |
|
|
|
263 |
|
|
### external command verbose output
|
264 |
|
|
|
265 |
9104
|
aaronmk
|
# usage: ([stdout2stderr=1] limit_stderr; cmd...) || return
|
266 |
9103
|
aaronmk
|
# `|| return` needed on Mac because of bug where -e doesn't apply to ()
|
267 |
9107
|
aaronmk
|
function limit_stderr()
|
268 |
9104
|
aaronmk
|
{
|
269 |
9174
|
aaronmk
|
log++ # should only apply during this function for use by can_log
|
270 |
9115
|
aaronmk
|
if test "$stdout2stderr"; then
|
271 |
9141
|
aaronmk
|
local stderr_is_errors="${stderr_is_errors-1}"
|
272 |
9115
|
aaronmk
|
if ! can_log; then exec 1>/dev/null; else stdout2stderr; fi
|
273 |
|
|
else
|
274 |
|
|
if ! can_log; then exec 2>/dev/null; fi
|
275 |
|
|
fi
|
276 |
9104
|
aaronmk
|
}
|
277 |
8904
|
aaronmk
|
|
278 |
9074
|
aaronmk
|
limit_stderr_cmd() # usage: [stdout2stderr=1] limit_stderr_cmd cmd...
|
279 |
8915
|
aaronmk
|
{
|
280 |
9168
|
aaronmk
|
case "$1" in command) echo_run_prep; local cmd_echoed=1;; esac
|
281 |
9108
|
aaronmk
|
(limit_stderr; "$@") || return
|
282 |
8915
|
aaronmk
|
}
|
283 |
9177
|
aaronmk
|
alias limit_stderr_cmd='"limit_stderr_cmd" ' #last space alias-expands next word
|
284 |
9148
|
aaronmk
|
alias limit_stdout_cmd='stdout2stderr=1 limit_stderr_cmd '
|
285 |
|
|
# last space alias-expands next word
|
286 |
8911
|
aaronmk
|
|
287 |
8984
|
aaronmk
|
|
288 |
9110
|
aaronmk
|
### external command input/output
|
289 |
8907
|
aaronmk
|
|
290 |
8997
|
aaronmk
|
# usage: cmd1 | { pipe_delay; cmd2; }
|
291 |
|
|
alias pipe_delay='sleep 0.1' # s; display after leading output of cmd1
|
292 |
|
|
|
293 |
|
|
fi # load new aliases
|
294 |
|
|
if self_being_included; then
|
295 |
|
|
|
296 |
9074
|
aaronmk
|
echo_stdin() # usage: input|echo_stdin|cmd
|
297 |
8702
|
aaronmk
|
{
|
298 |
9174
|
aaronmk
|
log++
|
299 |
8897
|
aaronmk
|
if can_log; then
|
300 |
8998
|
aaronmk
|
pipe_delay
|
301 |
8897
|
aaronmk
|
echo ----- >&2
|
302 |
|
|
tee -a /dev/stderr;
|
303 |
|
|
echo ----- >&2
|
304 |
|
|
else cat
|
305 |
|
|
fi
|
306 |
8702
|
aaronmk
|
}
|
307 |
8275
|
aaronmk
|
|
308 |
9044
|
aaronmk
|
alias echo_stdout='echo_stdin' # usage: cmd|echo_stdout
|
309 |
|
|
|
310 |
8873
|
aaronmk
|
fi # load new aliases
|
311 |
|
|
if self_being_included; then
|
312 |
|
|
|
313 |
9017
|
aaronmk
|
|
314 |
9125
|
aaronmk
|
#### streams
|
315 |
|
|
|
316 |
9129
|
aaronmk
|
fd_exists() { (: <&"$1") 2>/dev/null; }
|
317 |
9125
|
aaronmk
|
|
318 |
|
|
require_fd_not_exists() # usage: require_fd_not_exists fd || return 0
|
319 |
|
|
{ ! fd_exists "$1" || type=info die "fd $1 already exists, skipping"; }
|
320 |
|
|
|
321 |
9129
|
aaronmk
|
set_fd() # usage: dest=fd dir='[<>]' src=fd [noclobber=1] set_fd
|
322 |
9125
|
aaronmk
|
{
|
323 |
9174
|
aaronmk
|
log++; echo_func
|
324 |
9125
|
aaronmk
|
: "${dest:?}" "${dir:?}" "${src:?}"
|
325 |
|
|
test ! "$noclobber" || require_fd_not_exists "$dest" || return 0
|
326 |
|
|
echo_eval exec "$dest$dir&$src"
|
327 |
|
|
}
|
328 |
|
|
|
329 |
9129
|
aaronmk
|
shadow_fd() # usage: prefix=# src=fd dir='[<>]' shadow_fd
|
330 |
9125
|
aaronmk
|
{
|
331 |
|
|
echo_minor_func
|
332 |
|
|
: "${prefix:?}" "${src:?}" "${dir:?}"
|
333 |
|
|
dest="$prefix$src" noclobber=1 set_fd
|
334 |
|
|
}
|
335 |
|
|
|
336 |
9126
|
aaronmk
|
# convention: use fd 10/11/12 for command-specific alternate stdin/stdout/stderr
|
337 |
9125
|
aaronmk
|
|
338 |
9129
|
aaronmk
|
set_global_fds()
|
339 |
9128
|
aaronmk
|
# allows commands to access global stdin/stdout/stderr using fd 20/21/22
|
340 |
9127
|
aaronmk
|
# this works even when /dev/tty isn't available
|
341 |
9128
|
aaronmk
|
{
|
342 |
9174
|
aaronmk
|
log++; echo_func
|
343 |
9128
|
aaronmk
|
local prefix=2
|
344 |
|
|
# ignore errors if a source fd isn't open
|
345 |
|
|
src=0 dir='<' shadow_fd || true
|
346 |
|
|
src=1 dir='>' shadow_fd || true
|
347 |
|
|
src=2 dir='>' shadow_fd || true
|
348 |
|
|
}
|
349 |
|
|
set_global_fds
|
350 |
9126
|
aaronmk
|
|
351 |
9139
|
aaronmk
|
# usage: explicit_errors_only=1 script...
|
352 |
9135
|
aaronmk
|
# show only explicitly-displayed errors (which have been redirected to fd 22)
|
353 |
9137
|
aaronmk
|
# most of the time this has the same effect as `verbosity=0 script...`,
|
354 |
|
|
# which displays everything that isn't explicitly hidden
|
355 |
9140
|
aaronmk
|
# this option should only be used for testing the explicit error displaying
|
356 |
9135
|
aaronmk
|
if test "$explicit_errors_only"; then exec 2>/dev/null; fi
|
357 |
9127
|
aaronmk
|
|
358 |
9135
|
aaronmk
|
|
359 |
8854
|
aaronmk
|
#### vars
|
360 |
|
|
|
361 |
9074
|
aaronmk
|
set_var() { eval "$1"'="$2"'; }
|
362 |
8854
|
aaronmk
|
|
363 |
9074
|
aaronmk
|
set_inv() { set_var no_"$1" "$(test "${!1}" || echo 1)"; }
|
364 |
8857
|
aaronmk
|
|
365 |
8859
|
aaronmk
|
# usage: local var=...; local_inv
|
366 |
9050
|
aaronmk
|
alias local_inv='declare "no_$var=$(test "${!var}" || echo 1)"'
|
367 |
8859
|
aaronmk
|
|
368 |
9090
|
aaronmk
|
get_prefix_vars() { : "${prefix:?}"; eval echo '${!'$prefix'*}'; }
|
369 |
|
|
|
370 |
8863
|
aaronmk
|
# usage: local prefix=..._; import_vars
|
371 |
9093
|
aaronmk
|
# when used inside another alias 2+ levels deep, *must* be run inside a function
|
372 |
8863
|
aaronmk
|
alias import_vars="$(cat <<'EOF'
|
373 |
|
|
: "${prefix:?}"
|
374 |
9089
|
aaronmk
|
declare src_var dest_var
|
375 |
9091
|
aaronmk
|
for src_var in $(get_prefix_vars); do
|
376 |
8863
|
aaronmk
|
dest_var="${src_var#$prefix}"
|
377 |
9089
|
aaronmk
|
declare "$dest_var=${!src_var}"; echo_vars "$dest_var"
|
378 |
8863
|
aaronmk
|
done
|
379 |
|
|
EOF
|
380 |
|
|
)"
|
381 |
|
|
|
382 |
9017
|
aaronmk
|
|
383 |
9068
|
aaronmk
|
#### functions
|
384 |
|
|
|
385 |
9074
|
aaronmk
|
func_exists() { declare -f "$1" >/dev/null; }
|
386 |
9068
|
aaronmk
|
|
387 |
9074
|
aaronmk
|
copy_func() # usage: from=... to=... copy_func
|
388 |
9068
|
aaronmk
|
# $to must not exist. to get around the no-clobber restriction, use `unset -f`.
|
389 |
|
|
{
|
390 |
|
|
: "${from:?}" "${to:?}"
|
391 |
|
|
func_exists "$from" || die "function does not exist: $from"
|
392 |
|
|
! func_exists "$to" || die "function already exists: $to"
|
393 |
|
|
local from_def="$(declare -f "$from")"
|
394 |
|
|
eval "$to${from_def#$from}"
|
395 |
|
|
}
|
396 |
|
|
|
397 |
9074
|
aaronmk
|
func_override() # usage: func_override old_name__suffix
|
398 |
9068
|
aaronmk
|
{ from="${1%%__*}" to="$1" copy_func; }
|
399 |
|
|
|
400 |
9098
|
aaronmk
|
ensure_nested_func() # usage: func__nested_func() { ensure_nested_func; ... }
|
401 |
|
|
{
|
402 |
|
|
local nested_func="${FUNCNAME[1]}"
|
403 |
|
|
local func="${nested_func%%__*}"
|
404 |
|
|
contains "$func" "${FUNCNAME[@]}" || \
|
405 |
|
|
die "$nested_func() must be used by $func()"
|
406 |
|
|
}
|
407 |
9068
|
aaronmk
|
|
408 |
9098
|
aaronmk
|
|
409 |
8854
|
aaronmk
|
#### commands
|
410 |
|
|
|
411 |
8934
|
aaronmk
|
top_script="$0" # outermost script
|
412 |
|
|
top_dir="$(dirname "$top_script")"
|
413 |
8272
|
aaronmk
|
|
414 |
9122
|
aaronmk
|
require_not_exists() # usage: require_not_exists file || return 0
|
415 |
9073
|
aaronmk
|
{ test ! -e "$1" || type=info die "file "$1" already exists, skipping"; }
|
416 |
9062
|
aaronmk
|
|
417 |
8986
|
aaronmk
|
# auto-removes a command's output file on error (like make's .DELETE_ON_ERROR)
|
418 |
9074
|
aaronmk
|
function to_file() # usage: stdout=... [if_not_exists=1] to_file cmd...
|
419 |
9048
|
aaronmk
|
{
|
420 |
|
|
echo_func
|
421 |
|
|
: "${stdout?}"; echo_vars stdout
|
422 |
9122
|
aaronmk
|
test ! "$if_not_exists" || require_not_exists "$stdout" || return 0
|
423 |
9048
|
aaronmk
|
"$@" >"$stdout" || { save_e; log_e; rm "$stdout"; rethrow; }
|
424 |
|
|
}
|
425 |
9177
|
aaronmk
|
alias to_file='"to_file" ' # last space alias-expands next word
|
426 |
8986
|
aaronmk
|
|
427 |
9074
|
aaronmk
|
run_args_cmd() # runs the command line args command
|
428 |
8272
|
aaronmk
|
{
|
429 |
8971
|
aaronmk
|
test $? -eq 0 || return
|
430 |
8693
|
aaronmk
|
eval set -- "$(reverse "${BASH_ARGV[@]}")"
|
431 |
8971
|
aaronmk
|
test $# -ge 1 || set -- all
|
432 |
8648
|
aaronmk
|
echo_cmd "$(canon_rel_path "$0")" "$@"; "$@"
|
433 |
8272
|
aaronmk
|
}
|
434 |
|
|
|
435 |
9074
|
aaronmk
|
fwd() # usage: subdirs=(...); fwd "$FUNCNAME" "$@"
|
436 |
8272
|
aaronmk
|
{
|
437 |
8881
|
aaronmk
|
echo_func
|
438 |
8284
|
aaronmk
|
: "${subdirs?}"
|
439 |
|
|
|
440 |
8272
|
aaronmk
|
for subdir in "${subdirs[@]}"; do
|
441 |
8280
|
aaronmk
|
"$(dirname "${BASH_SOURCE[1]}")"/"$subdir"/run "$@"
|
442 |
8272
|
aaronmk
|
done
|
443 |
|
|
}
|
444 |
|
|
|
445 |
9017
|
aaronmk
|
|
446 |
8966
|
aaronmk
|
#### URLs
|
447 |
|
|
|
448 |
9074
|
aaronmk
|
localize_url() { test _"$1" = _"$(hostname -f)" || echo "$1"; }
|
449 |
8966
|
aaronmk
|
|
450 |
8704
|
aaronmk
|
fi
|