.functions

#!/bin/bash

# see: https://github.com/jessfraz/dotfiles/blob/master/.functions

# Create a new directory and enter it
mkd() {
    mkdir -p "$@"
    cd "$@" || exit
}

# Make a temporary directory and enter it
tmpd() {
    local dir
    if [ $# -eq 0 ]; then
        dir=$(mktemp -d)
    else
        dir=$(mktemp -d -t "${1}.XXXXXXXXXX")
    fi
    cd "$dir" || exit
}

# Search for text within the current directory
qt() {
    # arrays of directories and file patterns to exclude:
    local excludedDirs=(".git" "node_modules" ".next")
    local excludedFiles=("*bootstrap*")

    local stringDirs=()
    local stringFiles=()
    for dir in "${excludedDirs[@]}"; do
        stringDirs+=($(printf -- "--exclude-dir=%s" $dir))
    done
    unset dir

    for file in "${excludedFiles[@]}"; do
        stringFiles+=($(printf -- "--exclude=%s" $file))
    done
    unset file

    grep -ir --color=always "$1" "${@:2}" "${stringDirs[@]}" "${stringFiles[@]}" | less -RX
    #     ││                  │     │        │                  └─ ignore these file patterns (--exclude=)
    #     ││                  │     │        └─ ignore these directories (--exclude-dir=)
    #     ││                  │     └─ passed arguments
    #     ││                  └─ search pattern
    #     │└─ search all files under each directory, recursively
    #     └─ ignore case
}

# Start an HTTP server from a directory, optionally specifying the port
server() {
    local port="${1:-8000}"
    sleep 1 && open "http://localhost:${port}/" &
    # Set the default Content-Type to `text/plain` instead of `application/octet-stream`
    # And serve everything as UTF-8 (although not technically correct, this doesn’t break anything for binary files)
    python -c $'import SimpleHTTPServer;\nmap = SimpleHTTPServer.SimpleHTTPRequestHandler.extensions_map;\nmap[""] = "text/plain";\nfor key, value in map.items():\n\tmap[key] = value + ";charset=UTF-8";\nSimpleHTTPServer.test();' "$port"
}

# Syntax-highlight JSON strings or files
# Usage: `json '{"foo":42}'` or `echo '{"foo":42}' | json`
json() {
    if [ -t 0 ]; then # argument
        python -mjson.tool <<< "$*" | pygmentize -l javascript
    else # pipe
        python -mjson.tool | pygmentize -l javascript
    fi
}

# Run `dig` and display the most useful info
digga() {
    dig +nocmd "$1" any +multiline +noall +answer
}

# `v` with no arguments opens the current directory in Vim, otherwise opens the
# given location
v() {
    if [ $# -eq 0 ]; then
        vim .
    else
        vim "$@"
    fi
}

# `o` with no arguments opens the current directory, otherwise opens the given
# location
o() {
    if [ $# -eq 0 ]; then
        xdg-open .  > /dev/null 2>&1
    else
        xdg-open "$@" > /dev/null 2>&1
    fi
}

# `tre` is a shorthand for `tree` with hidden files and color enabled, ignoring
# the `.git` directory, listing directories first. The output gets piped into
# `less` with options to preserve color and line numbers, unless the output is
# small enough for one screen.
tre() {
    tree -aC -I '.git' --dirsfirst "$@" | less -FRNX
}

# Call from a local repo to open the repository on github/bitbucket in browser
# Modified version of https://github.com/zeke/ghwd
repo() {
    # Figure out github repo base URL
    local base_url
    base_url=$(git config --get remote.origin.url)
    base_url=${base_url%\.git} # remove .git from end of string

    # Fix git@github.com: URLs
    base_url=${base_url//git@github\.com:/https:\/\/github\.com\/}

    # Fix git://github.com URLS
    base_url=${base_url//git:\/\/github\.com/https:\/\/github\.com\/}

    # Fix git@bitbucket.org: URLs
    base_url=${base_url//git@bitbucket.org:/https:\/\/bitbucket\.org\/}

    # Fix git@gitlab.com: URLs
    base_url=${base_url//git@gitlab\.com:/https:\/\/gitlab\.com\/}

    # Validate that this folder is a git folder
    if ! git branch 2>/dev/null 1>&2 ; then
        echo "Not a git repo!"
        exit $?
    fi

    # Find current directory relative to .git parent
    full_path=$(pwd)
    git_base_path=$(cd "./$(git rev-parse --show-cdup)" || exit 1; pwd)
    relative_path=${full_path#$git_base_path} # remove leading git_base_path from working directory

    # If filename argument is present, append it
    if [ "$1" ]; then
        relative_path="$relative_path/$1"
    fi

    # Figure out current git branch
    # git_where=$(command git symbolic-ref -q HEAD || command git name-rev --name-only --no-undefined --always HEAD) 2>/dev/null
    git_where=$(command git name-rev --name-only --no-undefined --always HEAD) 2>/dev/null

    # Remove cruft from branchname
    branch=${git_where#refs\/heads\/}

    [[ $base_url == *bitbucket* ]] && tree="src" || tree="tree"
    url="$base_url/$tree/$branch$relative_path"


    echo "Calling $(type open) for $url"

    xdg-open "$url" &> /dev/null || (echo "Using $(type open) to open URL failed." && exit 1);
}

# Use feh to nicely view images
openimage() {
    local types='*.jpg *.png *.gif *.jpeg'

    cwd=$(pwd)
    cd "$(dirname "$1")" || exit
    local file
    file=$(basename "$1")

    feh -q $types --auto-zoom \
        --sort filename --borderless \
        --scale-down --draw-filename \
        --image-bg black \
        --start-at "$file"
    cd "$cwd"
}

# Print man page(s) to pdf
man2pdf() {
    if [ "$#" -eq 0 ]
    then
        echo "Usage: man2pdf MANPAGE..." >&2
        return 1
    fi

    mkdir -p "$HOME/man"
    for i; do
        man -Tpdf "$i" > "$HOME/man/$i.pdf"
        echo "Printing $i man page to $HOME/man/$i.pdf"
    done
}

# check if uri is up
isup() {
    local uri=$1

    if curl -s --head  --request GET "$uri" | grep "200 OK" > /dev/null ; then
        notify-send --urgency=critical "$uri is down"
    else
        notify-send --urgency=low "$uri is up"
    fi
}

# build go static binary from root of project
gostatic(){
    local dir=$1
    local arg=$2

    if [[ -z $dir ]]; then
        dir=$(pwd)
    fi

    local name
    name=$(basename "$dir")
    (
    cd "$dir" || exit
    export GOOS=linux
    echo "Building static binary for $name in $dir"

    case $arg in
        "netgo")
            set -x
            go build -a \
                -tags 'netgo static_build' \
                -installsuffix netgo \
                -ldflags "-w" \
                -o "$name" .
            ;;
        "cgo")
            set -x
            CGO_ENABLED=1 go build -a \
                -tags 'cgo static_build' \
                -ldflags "-w -extldflags -static" \
                -o "$name" .
            ;;
        *)
            set -x
            CGO_ENABLED=0 go build -a \
                -installsuffix cgo \
                -ldflags "-w" \
                -o "$name" .
            ;;
    esac
    )
}

# go to a folder easily in your gopath
gogo(){
    local d=$1

    if [[ -z $d ]]; then
        echo "You need to specify a project name."
        return 1
    fi

    if [[ "$d" == github* ]]; then
        d=$(echo "$d" | sed 's/.*\///')
    fi
    d=${d%/}

    # search for the project dir in the GOPATH
    mapfile -t path < <(find "${GOPATH}/src" \( -type d -o -type l \) -iname "$d"  | awk '{print length, $0;}' | sort -n | awk '{print $2}')

    if [ "${path[0]}" == "" ] || [ "${path[*]}" == "" ]; then
        echo "Could not find a directory named $d in $GOPATH"
        echo "Maybe you need to 'go get' it ;)"
        return 1
    fi

    # enter the first path found
    cd "${path[0]}" || return 1
}

golistdeps(){
    (
    if [[ ! -z "$1" ]]; then
        gogo "$@"
fi

    go list -e -f '{{join .Deps "\n"}}' ./... | xargs go list -e -f '{{if not .Standard}}{{.ImportPath}}{{end}}'
    )
}