skylab/MasterPassword
2
0
Fork 0
Code Releases Activity
1.4
MasterPassword/Scripts/bashlib

1169 lines
37 KiB
Plaintext
Raw Permalink Normal View History

Artwork + copying of password.
2012-01-12 16:28:20 +00:00
#! /usr/bin/env bash
# ___________________________________________________________________________ #
# #
# BashLIB -- A library for Bash scripting convenience. #
# #
# #
# Licensed under the Apache License, Version 2.0 (the "License"); #
# you may not use this file except in compliance with the License. #
# You may obtain a copy of the License at #
# #
# http://www.apache.org/licenses/LICENSE-2.0 #
# #
# Unless required by applicable law or agreed to in writing, software #
# distributed under the License is distributed on an "AS IS" BASIS, #
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
# See the License for the specific language governing permissions and #
# limitations under the License. #
# ___________________________________________________________________________ #
# #
# #
# Copyright 2007-2010, lhunath #
# * http://www.lhunath.com #
# * Maarten Billemont #
# #
# ______________________________________________________________________
# | |
# | .:: GLOBAL CONFIGURATION ::. |
# |______________________________________________________________________|
{
shopt -s extglob
shopt -s globstar
} 2>/dev/null ||:
# Unset all exported functions. Exported functions are evil.
while read _ _ func; do
unset -f "$func"
done < <(declare -Fx)
# ______________________________________________________________________
# | |
# | .:: GLOBAL DECLARATIONS ::. |
# |______________________________________________________________________|
# Variables for global internal operation.
bobber=( '.' 'o' 'O' 'o' )
spinner=( '-' \\ '|' '/' )
crosser=( '+' 'x' '+' 'x' )
runner=( '> >' \
'>> ' \
'>>>' \
' >>' )
# Variables for terminal requests.
[[ -t 1 ]] && {
hide=$( tput civis || tput vi )
show=$( tput cvvis || tput vs )
save=$( tput sc )
load=$( tput rc )
bold=$( tput bold || tput md )
reset=$( tput sgr0 || tput me )
#blink=$( tput blink || tput mb )
italic=$( tput sitm || tput ZH )
[[ $TERM != *-m ]] && {
red=$( tput setaf 1|| tput AF 1 )
green=$( tput setaf 2|| tput AF 2 )
yellow=$( tput setaf 3|| tput AF 3 )
blue=$( tput setaf 4|| tput AF 4 )
magenta=$( tput setaf 5|| tput AF 5 )
cyan=$( tput setaf 6|| tput AF 6 )
}
white=$( tput setaf 7|| tput AF 7 )
default=$( tput op )
eed=$( tput ed || tput cd ) # Erase to end of display
eel=$( tput el || tput ce ) # Erase to end of line
ebl=$( tput el1 || tput cb ) # Erase to beginning of line
ewl=$eel$ebl # Erase whole line
draw=$( tput -S <<< ' enacs
smacs
acsc
rmacs' || { \
tput eA; tput as;
tput ac; tput ae; } ) # Drawing characters
back=$'\b'
} 2>/dev/null ||:
# ______________________________________________________________________
# | |
# | .:: FUNCTION DECLARATIONS ::. |
# |______________________________________________________________________|
# ______________________________________________________________________
# |__ Chr _______________________________________________________________|
#
# chr decimal
#
# Outputs the character that has the given decimal ASCII value.
#
chr() {
printf \\"$(printf '%03o' "$1")"
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ Ord _______________________________________________________________|
#
# ord character
#
# Outputs the decimal ASCII value of the given character.
#
ord() {
printf %d "'$1"
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ Hex _______________________________________________________________|
#
# hex character
#
# Outputs the hexadecimal ASCII value of the given character.
#
hex() {
printf '%x' "'$1"
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ Unhex _______________________________________________________________|
#
# unhex character
#
# Outputs the character that has the given decimal ASCII value.
#
unhex() {
printf \\x"$1"
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ Exists ____________________________________________________________|
#
# exists application
#
# Returns successfully if the application is in PATH and is executable
# by the current user.
#
exists() {
[[ -x $(type -P "$1" 2>/dev/null) ]]
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ Eol _______________________________________________________________|
#
# eol message
#
# Return termination punctuation for a message, if necessary.
#
eol() {
: #[[ $1 && $1 != *[\!\?.,:\;\|] ]] && printf .. ||:
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ CLoc ______________________________________________________________|
#
# cloc
#
# Outputs the current cursor location as two space-separated numbers: row column
#
cloc() {
local old=$(stty -g)
stty raw
# If the tty has input waiting then we can't read back its response. We'd only break and pollute the tty input buffer.
read -t 0 < /dev/tty 2>/dev/null && {
stty "$old"
return 1
}
printf '\e[6n' > /dev/tty
IFS='[;' read -dR _ row col < /dev/tty
printf '%d %d' "$row" "$col"
stty "$old"
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ Latest ____________________________________________________________|
#
# latest [file...]
#
# Output the argument that represents the file with the latest modification time.
#
latest() (
shopt -s nullglob
local file latest=$1
for file; do
[[ $file -nt $latest ]] && latest=$file
done
printf '%s\n' "$latest"
)
# ______________________________________________________________________
# |__ Emit ______________________________________________________________|
#
# emit [options] message... [-- [command args...]]
#
# Display a message with contextual coloring.
#
# When a command is provided, a spinner will be activated in front of the
# message for as long as the command runs. When the command ends, its
# exit status will result in a message 'done' or 'failed' to be displayed.
#
# It is possible to only specify -- as final argument. This will prepare
# a spinner for you with the given message but leave it up to you to
# notify the spinner that it needs to stop. See the documentation for
# 'spinner' to learn how to do this.
#
# -n Do not end the line with a newline.
# -b Activate bright (bold) mode.
# -d Activate half-bright (dim) mode.
# -g Display in green.
# -y Display in yellow.
# -r Display in red.
# -w Display in the default color.
#
# -[code] A proxy-call to 'spinner -[code]'.
#
# Non-captialized versions of these options affect the * or the spinner
# in front of the message. Capitalized options affect the message text
# displayed.
#
emit() {
# Proxy call to spinner.
[[ $# -eq 1 && $1 = -+([0-9]) ]] \
&& { spinner $1; return; }
# Initialize the vars.
local arg
local style=
local color=
local textstyle=
local textcolor=
local noeol=0
local cmd=0
# Parse the options.
spinArgs=()
for arg in $(getArgs odbwgyrDBWGYRn "$@"); do
case ${arg%% } in
d) style=$dim ;;
b) style=$bold ;;
w) color=$white ;;
g) color=$green ;;
y) color=$yellow ;;
r) color=$red ;;
D) textstyle=$dim ;;
B) textstyle=$bold ;;
W) textcolor=$white ;;
G) textcolor=$green ;;
Y) textcolor=$yellow ;;
R) textcolor=$red ;;
n) noeol=1
spinArgs+=(-n) ;;
o) spinArgs+=("-$arg") ;;
esac
done
shift $(getArgs -c odbwgyrDBWGYRn "$@")
while [[ $1 = +* ]]; do
spinArgs+=("-${1#+}")
shift
done
# Defaults.
color=${color:-$textcolor}
color=${color:-$green}
[[ $color = $textcolor && -z $style ]] && style=$bold
# Get the text message.
local text= origtext=
for arg; do [[ $arg = -- ]] && break; origtext+="$arg "; done
origtext=${origtext%% }
(( noeol )) && text=$origtext || text=$origtext$reset$(eol "$origtext")$'\n'
# Trim off everything up to --
while [[ $# -gt 1 && $1 != -- ]]; do shift; done
[[ $1 = -- ]] && { shift; cmd=1; }
# Figure out what FD to use for our messages.
[[ -t 1 ]]; local fd=$(( $? + 1 ))
# Display the message or spinner.
if (( cmd )); then
# Don't let this Bash handle SIGINT.
#trap : INT
# Create the spinner in the background.
spinPipe=${TMPDIR:-/tmp}/bashlib.$$
{ touch "$spinPipe" && rm -f "$spinPipe" && mkfifo "$spinPipe"; } 2>/dev/null \
|| unset spinPipe
{ spinner "${spinArgs[@]}" "$origtext" -- "$style" "$color" "$textstyle" "$textcolor" < "${spinPipe:-/dev/null}" & } 2>/dev/null
[[ $spinPipe ]] && echo > "$spinPipe"
spinPid=$!
# Execute the command for the spinner if one is given.
#sleep 1 # Let the spinner initialize itself properly first. # Can probably remove this now that we echo > spinPipe?
if (( $# == 1 )); then command=$1
elif (( $# > 1 )); then command=$(printf '%q ' "$@")
else return 0; fi
eval "$command" >/dev/null \
&& spinner -0 \
|| spinner -1
else
# Make reset codes restore the initial font.
local font=$reset$textstyle$textcolor
text=$font${text//$reset/$font}
printf "\r$reset $style$color* %s$reset" "$text" >&$fd
fi
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ Spinner ___________________________________________________________|
#
# spinner message... [-- style color textstyle textcolor]
# or
# spinner -[code]
#
# Displays a spinner on the screen that waits until a certain time.
# Best used through its interface provided by 'emit'.
#
# style A terminal control string that defines the style of the spinner.
# color A terminal control string that defines the color of the spinner.
# textstyle A terminal control string that defines the style of the message.
# textcolor A terminal control string that defines the color of the message.
#
# -[code] Shut down a previously activated spinner with the given exit
# code. If the exit code is 0, a green message 'done' will be
# displayed. Otherwise a red message 'failed' will appear.
# The function will return with this exit code as result.
#
# You can manually specify a previously started spinner by putting its PID in
# the 'spinPid' variable. If this variable is not defined, the PID of the most
# recently backgrounded process is used. The 'spinPid' variable is unset upon
# each call to 'spinner' and reset to the PID of the spinner if one is created.
#
spinner() {
# Check usage.
(( ! $# )) || getArgs -q :h "$@" && {
emit -y 'Please specify a message as argument or a status option.'
return 1
}
# Initialize spinner vars.
# Make sure monitor mode is off or we won't be able to trap INT properly.
local monitor=0; [[ $- = *m* ]] && monitor=1
local done=
# Place the trap for interrupt signals.
trap 'done="${red}failed"' USR2
trap 'done="${green}done"' USR1
# Initialize the vars.
local pid=${spinPid:-$!}
local graphics=( "${bobber[@]}" )
local style=$bold
local color=$green
local textstyle=
local textcolor=
local output=
local noeol=
unset spinPid
# Any remaining options are the exit status of an existing spinner or spinner type.
while [[ $1 = -* ]]; do
arg=${1#-}
shift
# Stop parsing when arg is --
[[ $arg = - ]] && break
# Process arg: Either a spinner type or result code.
if [[ $arg = *[^0-9]* ]]; then
case $arg in
b) graphics=( "${bobber[@]}" ) ;;
c) graphics=( "${crosser[@]}" ) ;;
r) graphics=( "${runner[@]}" ) ;;
s) graphics=( "${spinner[@]}" ) ;;
o) output=1 ;;
n) noeol=1 ;;
esac
elif [[ $pid ]]; then
[[ $arg = 0 ]] \
&& kill -USR1 $pid 2>/dev/null \
|| kill -USR2 $pid 2>/dev/null
trap - INT
wait $pid 2>/dev/null
return $arg
fi
done
# Read arguments.
local text= origtext=
for arg; do [[ $arg = -- ]] && break; origtext+="$arg "; done
origtext=${origtext% }
local styles=$*; [[ $styles = *' -- '* ]] || styles=
read -a styles <<< "${styles##* -- }"
[[ ${styles[0]} ]] && style=${styles[0]}
[[ ${styles[1]} ]] && color=${styles[1]}
[[ ${styles[2]} ]] && textstyle=${styles[2]}
[[ ${styles[3]} ]] && textcolor=${styles[3]}
# Figure out what FD to use for our messages.
[[ -t 1 ]]; local fd=$(( $? + 1 ))
# Make reset codes restore the initial font.
local font=$reset$textstyle$textcolor
origtext=$font${origtext//$reset/$font}
(( noeol )) && text=$origtext || text=$origtext$reset$(eol "$origtext")
# Spinner initial status.
printf "\r$save$eel$reset $style$color* %s$reset" "$text" >&$fd
(( output )) && printf "\n" >&$fd
# Render the spinner.
set +m
local i=0
while [[ ! $done ]]; do
IFS= read -r -d '' newtext || true
newtext=${newtext%%$'\n'}; newtext=${newtext##*$'\n'}
if [[ $newtext = +* ]]; then
newtext="$origtext [${newtext#+}]"
fi
if [[ $newtext ]]; then
newtext="$font${newtext//$reset/$font}"
(( noeol )) && text=$newtext || text=$newtext$reset$(eol "$newtext")
fi
if (( output ))
then printf "\r" >&$fd
else printf "$load$eel" >&$fd
fi
if (( output ))
then printf "$reset $style$color$blue%s %s$reset" \
"${graphics[i++ % 4]}" "$text" >&$fd
else printf "$reset $style$color%s %s$reset" \
"${graphics[i++ % 4]}" "$text" >&$fd
fi
sleep .25 # Four iterations make one second.
# Cancel when calling script disappears.
kill -0 $$ >/dev/null || done="${red}aborted"
done
# Get rid of the spinner traps.
trap - USR1 USR2; (( monitor )) && set -m
# Spinner final status.
if (( output ))
then text=; printf "\r" >&$fd
else printf "$load" >&$fd
fi
printf "$eel$reset $style$color* %s${text:+ }$bold%s$font.$reset\n" \
"$text" "$done" >&$fd
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ report ___________________________________________________________|
#
# report [-code] [-e] failure-message [success-message]
#
# This is a convenience function for replacement of spinner -code.
#
# It checks either the exit code of the previously completed command or
# the code provided as option to determine whether to display the success
# or failure message. It calls spinner -code to complete an actively
# emitted message if there is one. The success message is optional.
#
# -[code] The exit code to use.
# -e Exit the script on failure.
#
report() {
# Exit Status of previous command.
local code=$?
# Parse the options.
while [[ $1 = -* && $2 ]]; do
arg=${1#-}
shift
# Stop parsing when arg is --
[[ $arg = - ]] && break
# Process arg: Either a spinner type or result code.
if [[ $arg = *[^0-9]* ]]; then
case $arg in
esac
else code=$arg
fi
done
# Initialize the vars.
local failure=$1
local success=$2
# Check usage.
(( ! $# )) || getArgs -q :h "$@" && {
emit -y 'Please specify at least a failure message as argument.'
return 1
}
# Proxy call to spinner.
(( spinPid )) \
&& { spinner -$code; }
# Success or failure message.
if (( ! code ))
then [[ $success ]] && emit " $success"
else [[ $failure ]] && emit -R " $failure"
fi
# Pass on exit code.
return $code
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ Ask _______________________________________________________________|
#
# ask [-optionchars|+default] message...
#
# Ask a question and read the user's reply to it.
#
# By default, a reply is terminated by a newline.
#
# You may use the options to switch into key mode. In key mode, only a
# single character is read. The valid characters are specified in the
# optionchars. A capital option character makes that option the default.
#
# If the reply character in key mode was not amoungst the provided options
# the default is assumed instead. If no default was given, an exit code
# of 2 is returned.
#
# You may mark an optionchar as 'valid' by appending a '!' to it. As a
# result, an exit code of 0 will only be returned if this valid option
# is replied. If not, an exit code of 1 will be returned.
#
# If no option is marked as valid, the given reply is echoed and an exit
# code of 0 is returned.
#
# You can specify the -# option to make ask hide the user's input.
#
# If you prefix the first argument with a + instead of a -, the remaining
# argument is taken as the default string value and returned when no input
# was received. In this case, the exit code is 0 either way.
#
ask() {
# Check usage.
(( ! $# )) || getArgs -q :h "$@" && {
emit -y 'Please specify a question as argument.'
return 1
}
# Initialize the vars.
local arg
local option=
local options=
local default=
local silent=
local valid=
local muteChar=
# Parse the options.
if [[ $1 = +* ]]; then
option=${1#+}
default=$option
shift
else
for arg in $(getArgs "$(printf "%s" {a..z} {A..Z})!#%" "$@"); do
[[ $arg = [[:upper:]] ]] \
&& default=$arg
[[ $arg = ! ]] \
&& { valid=${options: -1}; continue; }
[[ $arg = '#' ]] \
&& { silent=1 arg=; }
[[ $arg = '%' ]] \
&& { silent=1 muteChar='*' arg=; }
options+=$arg
done
fi
# Trim off the options.
while [[ $1 = -* ]]; do shift; done
# Figure out what FD to use for our messages.
[[ -t 1 ]]; local fd=$(( $? + 1 ))
# Ask the question.
emit -yn "$*${option:+ [$option]}${options:+ [$options]} "
# Read the reply.
if [[ $muteChar ]]; then
local reply
while read -s -n1 && [[ $REPLY ]]; do
reply+=$REPLY
printf "%s" "$muteChar" >&$fd
done
REPLY=$reply
else
read ${options:+-n1} ${silent:+-s}
fi
[[ $options && $REPLY ]] || (( silent )) && printf "\n" >&$fd
# Evaluate the reply.
while true; do
if [[ $REPLY && ( ! $options || $options = *$REPLY* ) ]]; then
if [[ $valid ]]
then [[ $REPLY = $valid ]]
else printf "%s" "$REPLY"
fi
return
fi
[[ -z $default || $REPLY = $default ]] \
&& return 2
REPLY=$default
done
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ Trim ______________________________________________________________|
#
# trim lines ...
#
# Trim the whitespace off of the beginning and end of the given lines.
# Each argument is considdered one line; is treated and printed out.
#
# When no arguments are given, lines will be read from standard input.
#
trim() {
# Initialize the vars.
local lines
local line
local oIFS
# Get the lines.
lines=( "$@" )
if (( ! ${#lines[@]} )); then
oIFS=$IFS; IFS=$'\n'
lines=( $(cat) )
IFS=$oIFS
fi
# Trim the lines
for line in "${lines[@]}"; do
line=${line##*([[:space:]])}; line=${line%%*([[:space:]])}
printf "%s" "$line"
done
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ Reverse ___________________________________________________________|
#
# reverse [-0] [elements ...] [<<< elements]
#
# Reverse the order of the given elements. Elements are read from command
# arguments or standard input if no element arguments are given.
# They are reversed and output on standard output.
#
# If the -0 option is given, input and output are delimited by NUL bytes.
# Otherwise, they are delimited by newlines.
#
reverse() {
# Initialize the vars.
local elements delimitor=$'\n'
# Parse the options.
while [[ $1 = -* ]]; do
case $1 in
-0) delimitor=$'\0' ;;
--) shift; break ;;
esac
shift
done
# Get the elements.
elements=( "$@" )
if (( ! ${#elements[@]} )); then
while IFS= read -r -d "$delimitor"; do
elements+=("$REPLY")
done
fi
# Iterate in reverse order.
for (( i=${#elements[@]} - 1; i >=0; --i )); do
printf '%s%s' "${elements[i]}" "$delimitor"
done
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ SWait _____________________________________________________________|
#
# swait pid...
#
# Wait for the given PID(s). The PID does not need to be a child of the
# running shell. Note that relying on PIDs always introduces race conditions
# which may be potentially harmful and sometimes even a security issue.
#
# This implementation requires the necessary permissions to send signals
# to the PID(s) provided.
#
swait() {
# Check usage.
(( ! $# )) || getArgs -q :h "$@" && {
emit -y 'Please provide one or more PIDs to wait for as argument.'
return 1
}
# Time to wait.
local pid
for pid; do
while kill -0 $pid 2>/dev/null
do sleep .1; done
done
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ GetArgs ___________________________________________________________|
#
# getArgs [options] optstring [args...]
#
# Retrieve all options present in the given arguments.
#
# This is a wrapper for getopts(P) which will safely work inside functions.
# It manages OPTIND for you and returns a list of options found in the
# provided arguments.
#
# optstring This is a string of characters in which each character
# represents an option to look for in the arguments.
# See getopts(P) for a description of the optstring syntax.
#
# args This is a list of arguments in which to look for options.
# Most commonly, you will use "$@" to supply these arguments.
#
# -c Instead of output the arguments, output OPTARGS.
# -q Be quiet. No arguments are displayed. Only the exit code is set.
# -n Use newlines as a separator between the options that were found.
# -0 Use NULL-bytes as a separator between the options that were found.
#
# If any given arguments are found, an exit code of 0 is returned. If none
# are found, an exit code of 1 is returned.
#
# After the operation, OPTARGS is set the the index of the last argument
# that has been parsed by getArgs. Ready for you to use shift $OPTARGS.
#
getArgs() {
# Check usage.
(( ! $# )) && {
emit -y 'Please provide the arguments to search for in' \
'getopts(P) format followed by the positional parameters.'
return 1
}
# Initialize the defaults.
local arg
local found=0
local quiet=0
local count=0
local delimitor=' '
# Parse the options.
while [[ $1 = -* ]]; do
case $1 in
-q) quiet=1 ;;
-c) count=1 ;;
-n) delimitor=$'\n' ;;
-0) delimitor=$'\0' ;;
esac
shift
done
# Get the optstring.
local optstring=$1; shift
local oOPTIND=$OPTIND OPTIND=1
# Enumerate the arguments.
while getopts "$optstring" arg; do
[[ $arg != '?' ]] && found=1
(( quiet + count )) || \
printf "%s${OPTARG:+ }%s%s" "$arg" "$OPTARG" "$delimitor"
done
OPTARGS=$(( OPTIND - 1 ))
OPTIND=$oOPTIND
# Any arguments found?
(( count )) && printf "%s" "$OPTARGS"
return $(( ! found ))
} # _____________________________________________________________________
# |__ ShowHelp __________________________________________________________|
#
# showHelp name description author [option description]...
#
# Generate a prettily formatted usage description of the application.
#
# name Provide the name of the application.
#
# description Provide a detailed description of the application's
# purpose and usage.
#
# option An option the application can take as argument.
#
# description A description of the effect of the preceding option.
#
showHelp() {
# Check usage.
(( $# < 3 )) || getArgs -q :h "$@" && {
emit -y 'Please provide the name, description, author and options' \
'of the application.'
return 1
}
# Parse the options.
local appName=$1; shift
local appDesc=${1//+([[:space:]])/ }; shift
local appAuthor=$1; shift
local cols=$(tput cols)
(( cols = ${cols:-80} - 10 ))
# Figure out what FD to use for our messages.
[[ -t 1 ]]; local fd=$(( $? + 1 ))
# Print out the help header.
printf "$reset$bold\n" >&$fd
printf "\t\t%s\n" "$appName" >&$fd
printf "$reset\n" >&$fd
printf "%s\n" "$appDesc" | fmt -w "$cols" | sed $'s/^/\t/' >&$fd
printf "\t $reset$bold~ $reset$bold%s\n" "$appAuthor" >&$fd
printf "$reset\n" >&$fd
# Print out the application options and columnize them.
while (( $# )); do
local optName=$1; shift
local optDesc=$1; shift
printf " %s\t" "$optName"
printf "%s\n" "${optDesc//+( )/ }" | fmt -w "$cols" | sed $'1!s/^/ \t/'
printf "\n"
done | column -t -s $'\t' \
| sed "s/^\( [^ ]*\)/$bold$green\1$reset/" >&$fd
printf "\n" >&$fd
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ Quote _____________________________________________________________|
#
# quote [-e] [argument...]
#
# Output a single string where all arguments are quoted
# such that the string is safe to be passed as shell
# command arguments as though given arguments had been
# passed.
#
# When no arguments are passed; no output is generated.
#
# -e Use backslashes rather than single quotes.
#
quote() {
# Initialize the defaults.
local arg escape=0 quotedArgs=()
# Parse the options.
while [[ $1 = -* ]]; do
case $1 in
-e) escape=1 ;;
--) shift; break ;;
esac
shift
done
# Print out each argument, quoting it properly.
for arg; do
if (( escape )); then
quotedArgs+=("$(printf "%q" "$arg")")
else
quotedArgs+=("$(printf "'%s'" "${arg//"'"/"\\'"}")")
fi
done
printf '%s\n' "$(IFS=' '; echo "${quotedArgs[*]}")"
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ Shorten ___________________________________________________________|
#
# shorten [-p pwd] path [suffix]...
#
# Shorten an absolute path for pretty printing by cutting
# off PWD and replacing HOME by ~.
#
# -p Use the given pathname as the base for relative filenames instead of PWD.
# path The path string to shorten.
# suffix Suffix strings that must be cut off from the end.
# Only the first suffix string matched will be cut off.
#
shorten() {
# Check usage.
(( $# < 1 )) || getArgs -q :h "$@" && {
emit -y 'Please provide the path to shorten.'
return 1
}
# Parse the options.
local suffix path pwd=$PWD
[[ $1 = -p ]] && { pwd=$2; shift 2; }
path=$1; shift
# Make path absolute.
[[ $path = /* ]] || path=$PWD/$path
# If the path denotes something that exists; it's easy.
if [[ -d $path ]]
then path=$(cd "$path"; printf "%s" "$PWD")
elif [[ -d ${path%/*} ]]
then path=$(cd "${path%/*}"; printf "%s" "$PWD/${path##*/}")
# If not, we'll try readlink -m.
elif readlink -m / >/dev/null 2>&1; then
path=$(readlink -m "$path")
# If we don't have that - unleash the sed(1) madness.
else
local oldpath=/
while [[ $oldpath != $path ]]; do
oldpath=$path
path=$(sed -e 's,///*,/,g' -e 's,\(^\|/\)\./,\1,g' -e 's,\(^\|/\)[^/]*/\.\.\($\|/\),\1,g' <<< "$path")
done
fi
# Replace special paths.
path=${path#$pwd/}
path=${path/#$HOME/'~'}
# Cut off suffix.
for suffix; do
[[ $path = *$suffix ]] && {
path=${path%$suffix}
break
}
done
printf "%s" "$path"
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ InArray ___________________________________________________________|
#
# inArray element array
#
# Checks whether a certain element is in the given array.
#
# element The element to search the array for.
# array This is a list of elements to search through.
#
inArray() {
# Check usage.
(( $# < 1 )) || getArgs -q :h "$@" && {
emit -y 'Please provide the element to search for and the array' \
'to search through.'
return 1
}
# Parse the options.
local element
local search=$1; shift
# Perform the search.
for element
do [[ $element = $search ]] && return 0; done
return 1
} # _____________________________________________________________________
# ______________________________________________________________________
# |__ xpathNodes ________________________________________________________|
#
# xpathNodes query [filename]
#
# Outputs every xpath node that matches the query on a separate line.
# Leading and trailing whitespace is always stripped.
#
# filename The path to the file that contains the document to run the query on.
# query The XPath query to run on the document.
#
xpathNodes() {
local query=$1 filename=$2
[[ $filename ]] || filename=<(cat)
{
if xpath -e / <(echo '<a></a>') >/dev/null 2>&1; then
xpath -e "$query" "$filename" 2>&1
else
xpath "$filename" "$query" 2>&1
fi
} | {
read
sed -ne $'s/-- NODE --/\\\n/g' -e 's/^[[:space:]]*\(.*[^[:space:]]\)[[:space:]]*$/\1/p'
}
return "${PIPESTATUS[0]}"
}
# ______________________________________________________________________
# |__ HideDebug _________________________________________________________|
#
# hideDebug [ on | off ]
#
# Toggle Bash's debugging mode off temporarily. To hide Bash's debugging
# output for a function, you should have a hideDebug on as its first line
# and hideDebug off as its last.
#
hideDebug() {
if [[ $1 = on ]]; then
: -- HIDING DEBUG OUTPUT ..
[[ $- != *x* ]]; bashlib_debugWasOn=$?
set +x
elif [[ $1 = off ]]; then
: -- SHOWING DEBUG OUTPUT ..
(( bashlib_debugWasOn )) && \
set -x
fi
}
# ______________________________________________________________________
# |__ StackTrace ________________________________________________________|
#
# stackTrace
#
# Retrieve a mapping of a key from the given map or modify the given map by
# assigning a new value for the given key if stdin is not the terminal.
#
stackTrace() {
# Some general debug information.
printf "\t$bold%s$reset v$bold%s$reset" "$BASH" "$BASH_VERSION\n"
printf " Was running: $bold%s %s$reset" "$BASH_COMMAND" "$*\n"
printf "\n"
printf " [Shell : $bold%15s$reset] [Subshells : $bold%5s$reset]\n" "$SHLVL" "$BASH_SUBSHELL"
printf " [Locale : $bold%15s$reset] [Runtime : $bold%5s$reset]\n" "$LC_ALL" "${SECONDS}s"
printf "\n"
# Search through the map.
local arg=0
for i in ${!FUNCNAME[@]}; do
#if (( i )); then
# Print this execution stack's location.
printf "$reset $bold-$reset $green"
[[ ${BASH_SOURCE[i+1]} ]] \
&& printf "%s$reset:$green$bold%s" "${BASH_SOURCE[i+1]}" "${BASH_LINENO[i]}" \
|| printf "${bold}Prompt"
# Print this execution stack's function and positional parameters.
printf "$reset :\t$bold%s(" "${FUNCNAME[i]}"
[[ ${BASH_ARGC[i]} ]] && \
for (( j = 0; j < ${BASH_ARGC[i]}; j++ )); do
(( j )) && printf ', '
printf "%s" "${BASH_ARGV[arg]}"
let arg++
done
# Print the end of this execution stack's line.
printf ")$reset\n"
#fi
done
printf "\n"
} # _____________________________________________________________________
# ______________________________________________________________________
# | |
# | .:: ENTRY POINT ::. |
# |______________________________________________________________________|
# Make sure this file is sourced and not executed.
(( ! BASH_LINENO )) && {
emit -R "You should source this file, not execute it."
exit 1
}
:
: .:: END SOURCING ::.
: ______________________________________________________________________
:
Copy Permalink