mirror of
https://git.decapod.one/brethil/dotfiles
synced 2024-11-21 19:11:30 +01:00
388 lines
9.2 KiB
Bash
Executable File
388 lines
9.2 KiB
Bash
Executable File
###########################
|
|
#### Function Definitions #
|
|
###########################
|
|
## Selfupdate
|
|
function dotfiles_selfupdate
|
|
{
|
|
(DOTFILES_FORCEUPDATE=1 source $DOTFILES/extras/check_for_update.zsh || echo "[dotfiles_selfupdate] failed")
|
|
}
|
|
|
|
## get cheat sheets for commands from cheat.sh. Usage: cheat commandname
|
|
function cheat
|
|
{
|
|
curl "https://cheat.sh/$1"
|
|
}
|
|
# get cheat sheets for commands matching $1
|
|
function cheatall
|
|
{
|
|
curl "https://cheat.sh/~$1"
|
|
}
|
|
|
|
# List all docker tags for an image
|
|
function dockertags
|
|
{
|
|
if [[ -z $(command -v jq) ]]; then
|
|
echo "jq not installed. Please install jq." 1>&2
|
|
return
|
|
fi
|
|
i=0
|
|
while [[ $? == 0 ]]; do
|
|
i=$(($i+1))
|
|
curl "https://registry.hub.docker.com/v2/repositories/library/$1/tags/?page=$i" 2>/dev/null | jq '."results"[]["name"]'
|
|
done
|
|
}
|
|
|
|
# watch with grc enabled
|
|
function watchgrc
|
|
{
|
|
watch -n 1 -c grc --colour=on "$@"
|
|
}
|
|
|
|
## Simple calculator. Usage: calc 1+1, calc 5/7, calc "sqrt(2)"
|
|
function calc
|
|
{
|
|
awk "BEGIN { print $* }"
|
|
}
|
|
|
|
function warning {
|
|
echo -e "${Yellow}Warning:$CLEAR $@" >&2
|
|
}
|
|
|
|
function error {
|
|
echo -e "${Red}Error:$CLEAR $@" >&2
|
|
}
|
|
|
|
function info {
|
|
echo -e "${Green}Info:$CLEAR $@"
|
|
}
|
|
|
|
|
|
## Flashes the screen until user presses a key
|
|
function flasher
|
|
{
|
|
while true; do printf "\e[?5h\007"; sleep 0.25; printf "\e[?5l"; read -s -n -t1 && break; done;
|
|
}
|
|
|
|
## Beep until user presses a key
|
|
function beeper
|
|
{
|
|
while true; do printf "\e[?5h\007"; sleep 0.25; printf "\e[?5l"; read -s -n -t1 && break; done;
|
|
}
|
|
|
|
# set an alarm in seconds, minutes, hours
|
|
function alarm {
|
|
if [[ -z $1 ]]; then
|
|
echo "Usage: alarm 5[s]|5m|1h"
|
|
return 1
|
|
fi
|
|
value=$1
|
|
|
|
local t
|
|
if [[ $value = *"m" ]]; then
|
|
t=$((${value/m/}*60))
|
|
elif [[ $value = *"h" ]]; then
|
|
t=$((${value/h/}*3600))
|
|
elif [[ $value = *"s" ]]; then
|
|
t=${value/s/}
|
|
else
|
|
t=$value
|
|
fi
|
|
|
|
function format(){
|
|
if [[ $1 -lt 60 ]]; then
|
|
printf "00:%02is" $1
|
|
return
|
|
fi
|
|
|
|
if [[ $1 -lt 3600 ]]; then
|
|
minutes=$(($1/60))
|
|
seconds=$(($1%60))
|
|
printf "%dm:%02dm" $minutes $seconds
|
|
return
|
|
fi
|
|
|
|
hours=$(($1/3600))
|
|
remainder=$(($1%3600))
|
|
printf "%dh:%s" hours "$(format $remainder)"
|
|
}
|
|
|
|
count=$t
|
|
while [[ $count -ge 0 ]]; do
|
|
echo -en "Set a timer for $1 │ remaining=$(format $count)"
|
|
count=$((count-1))
|
|
sleep 1
|
|
echo -en "\r"
|
|
done
|
|
echo -e "\nDone!"
|
|
beeper
|
|
}
|
|
|
|
|
|
## Simple http server for current directory (or path)
|
|
function httpserver
|
|
{
|
|
(
|
|
if [[ -d $1 ]]; then
|
|
cd "$1" && echo "Starting webserver in $(realpath $1)/" || echo "directory: $1 does not exist" >&2 || exit 1
|
|
else
|
|
echo "Starting webserver in $PWD/"
|
|
fi
|
|
open "http://localhost:8000" &>/dev/null &
|
|
python -m http.server 8000
|
|
)
|
|
}
|
|
alias webserver='httpserver'
|
|
|
|
## Upload something using the 0x0.st service. Usage: upload [filename|url]
|
|
function upload
|
|
{
|
|
local url
|
|
if echo "$@" | grep -E -s -q "^http[s]://"; then
|
|
url=true
|
|
fi
|
|
if [[ $url == true ]]; then
|
|
out="$(curl -F"url=$@" https://0x0.st)"
|
|
else
|
|
out=$(curl --progress-bar -F"file=@$@" "https://0x0.st/")
|
|
fi
|
|
if [[ $? -ne 0 ]]; then
|
|
echo -e "Failed uploading $@:\n $out" >&2
|
|
return
|
|
fi
|
|
|
|
echo -e "Done, file at:\t$out"
|
|
if [[ $(uname) == "Darwin" ]]; then
|
|
clipboard="pbcopy"
|
|
elif command -v wl-copy &>/dev/null; then
|
|
clipboard="wl-copy"
|
|
elif command -v xclip &>/dev/null ; then
|
|
clipboard="xclip"
|
|
else
|
|
clipboard="cat"
|
|
fi
|
|
echo -en "$out" | $clipboard
|
|
}
|
|
|
|
## If connecting through ssh and reverse forwarding port 2222 (ssh -R 2222:localhost:22 ), this function allows to copy the files back to the machine one is connecting from by typing 'mecp filename' (configure the username for "localhost" in ~/.ssh/config or add an username)
|
|
function mecp
|
|
{
|
|
rsync -r -P -e "ssh -p 2222" -R "$@" localhost:~/Desktop/
|
|
}
|
|
|
|
|
|
## generate a password using pwgen, generate_password 20 generates a 20 characters long password
|
|
function generate_password
|
|
{
|
|
pwgen -1sycn $1
|
|
}
|
|
|
|
## Generate a password from dev urandom using only printable characters
|
|
function genpwd
|
|
{
|
|
if [[ $1 ]]; then
|
|
strlen=$1
|
|
else
|
|
strlen=32
|
|
fi
|
|
# All characters excluding backlash
|
|
env LC_CTYPE=C tr -dc '[:graph]\' < /dev/urandom | fold -w $strlen | head -n 1
|
|
}
|
|
|
|
|
|
## List defined functions in $DOTFILES/functions.sh
|
|
function list_functions
|
|
{
|
|
grep --color=no -A 1 '^##' $DOTFILES/functions/*.zsh| sed -E 's/function (.*)/\1/g'
|
|
}
|
|
|
|
|
|
# MacOS only
|
|
if [[ "$(uname)" == "Darwin" ]]; then
|
|
## Create a RAM disk. Default size 1GB. If supplied, first argument defines the RAM disk size in GB
|
|
function ramdisk
|
|
{
|
|
if [[ -e $1 ]]; then
|
|
sizeingb=$1
|
|
else
|
|
sizeingb=1
|
|
fi
|
|
|
|
# Numsectors is size in bytes / 512 (sector size in bytes)
|
|
name='RAM_disk'
|
|
sizeinbytes=$(($sizeingb*1000**3))
|
|
NUMSECTORS=$(($sizeinbytes/512))
|
|
mydev=$(hdiutil attach -nomount ram://$NUMSECTORS )
|
|
# strip whitespace (hdiutil outputs a lot of spaces/tabs along with the device name)
|
|
mydev=$(echo "$mydev"| xargs echo)
|
|
newfs_hfs "$mydev"
|
|
mkdir -p "/tmp/$name"
|
|
mount -t hfs "$mydev" "/tmp/$name"
|
|
echo "RAM Disk mounted: /tmp/$name"
|
|
echo "To eject (destroy) RAM disk, use:"
|
|
echo " $ diskutil eject $mydev"
|
|
}
|
|
fi
|
|
|
|
|
|
# unzip file to directory with the same name of the zip file (without extension)
|
|
function unzipd {
|
|
zip_file="$1"
|
|
filename=$(basename -- "$zip_file")
|
|
extension="${filename##*.}"
|
|
name="${filename%.*}"
|
|
unzip -d "$name" "$zip_file"
|
|
}
|
|
|
|
fvim() {
|
|
if [[ -n "$@" ]]; then
|
|
vim `fzf -q $@`
|
|
else
|
|
vim `fzf`
|
|
fi
|
|
}
|
|
|
|
# retry command until it succeeds (waiting one second or $RETRY_INTERVAL)
|
|
function retry() {
|
|
until $@; do sleep ${RETRY_INTERVAL:-1}; done
|
|
}
|
|
|
|
|
|
__completion_wrapper(){
|
|
# Wrapper for completion functions.
|
|
# These can be used to force loading of all completions
|
|
# for the given command in order to access specialized
|
|
# completion functions
|
|
local _completion_function=$1
|
|
local _completion_base=$2
|
|
if ! command -v $_completion_function &>/dev/null; then
|
|
$_completion_base
|
|
fi
|
|
$_completion_function
|
|
}
|
|
|
|
|
|
if command -v pacman &>/dev/null ; then
|
|
pacbins() {
|
|
pacman -Ql $1 | sed -n -e 's/.*\/bin\///p' | tail -n +2
|
|
}
|
|
_pacbins(){
|
|
# fix completion
|
|
__completion_wrapper _pacman_completions_installed_packages _pacman
|
|
}
|
|
compdef _pacbins pacbins
|
|
fi
|
|
|
|
if command -v rustc &>/dev/null
|
|
then
|
|
rexplain() {
|
|
rustc --explain $@ | bat --language=rust -
|
|
}
|
|
fi
|
|
|
|
if command -v fzf &>/dev/null ; then
|
|
falias() {
|
|
alias | fzf $@ | cut -d= -f 1
|
|
}
|
|
fi
|
|
|
|
make_backup() {
|
|
name="$1"
|
|
backup_name="backup_$1_$(date +%Y-%m-%d).tar.gz"
|
|
echo "Backing up to $backup_name"
|
|
tar -czf "$backup_name" "$1"
|
|
echo "done"
|
|
}
|
|
|
|
function find_by_mtime() {
|
|
find $@ -printf "%T+ %p\n" | sort
|
|
}
|
|
|
|
|
|
function mangrep() {
|
|
if [[ -z "$@" ]]; then
|
|
echo "Usage: $0 <pattern> <command>"
|
|
echo "Opens man page for <command> at the first match for <pattern>"
|
|
return
|
|
fi
|
|
pattern=$1
|
|
cmd=$2
|
|
if [[ -z "$cmd" ]]; then
|
|
man "$cmd"
|
|
return
|
|
fi
|
|
|
|
MANPAGER="less -p \"$pattern\"" man "$cmd"
|
|
}
|
|
|
|
|
|
# watches the given file/directory and executes the given action whenever anything is changed. Usage: watch_and_run <file|directory> <command>
|
|
function watch_and_run() {
|
|
if ! which inotifywait 2>&1 &>/dev/null ; then echo "$0 requires inotifywait"; return 1; fi
|
|
|
|
[[ -z "$1" ]] && echo "Usage: $0 <file|directory> <action>" && return 1
|
|
local to_watch=$1
|
|
shift
|
|
|
|
[[ -z "$@" ]] && echo "Usage: $0 <file|directory> <action>" && return 1
|
|
|
|
local action="$@"
|
|
local _bg_job_pid
|
|
|
|
local TRAPINT(){
|
|
|
|
if [[ -n ${_bg_job_pid} ]]; then
|
|
kill -9 ${_bg_job_pid}
|
|
fi
|
|
yellow '\nQuitting.'
|
|
break;
|
|
}
|
|
|
|
{
|
|
set +m # disable job control messages
|
|
while true; do
|
|
if [[ ! -e "$to_watch" ]]; then
|
|
echo "\"$to_watch\" does not exist";
|
|
break
|
|
fi
|
|
zsh -c "$action" &
|
|
_bg_job_pid=$!
|
|
disown
|
|
echo -e "$Cyan ==> Running \"$action\" with pid=${_bg_job_pid}$CLEAR"
|
|
|
|
# block until the file/directory has been written to
|
|
inotifywait -e close_write -r "$to_watch" &>/dev/null
|
|
|
|
# the job might have failed, ignore errors
|
|
kill -9 ${_bg_job_pid} &>/dev/null || true
|
|
done
|
|
} always {
|
|
# remove ctrl-c trap
|
|
unset -f TRAPINT
|
|
set -m # restore job control messages
|
|
}
|
|
}
|
|
|
|
# use watch and force color with grc
|
|
function watchc() {
|
|
watch --differences --interval 1 --color grc --colour=on $@
|
|
}
|
|
|
|
# make a backup copy of the argument adding the .bak suffix
|
|
function bak() {
|
|
cp $1{,.bak}
|
|
}
|
|
|
|
# restore a backup copy created using `bak`
|
|
function unbak() {
|
|
mv $1{.bak,}
|
|
}
|
|
|
|
# highlight functions with when calling which
|
|
function which(){
|
|
if ! (($+commands[bat])); then
|
|
builtin which $@
|
|
else
|
|
builtin which $@ | bat --language=zsh
|
|
fi
|
|
}
|