.bash_profile_functions.sh

# Simple calculator
function calc() {
    local result=""
    result="$(printf "scale=10;$*\n" | bc --mathlib | tr -d '\\\n')"
    #                       └─ default (when `--mathlib` is used) is 20
    #
    if [[ "$result" == *.* ]]; then
        # improve the output for decimal numbers
        printf "$result" |
        sed -e 's/^\./0./'        `# add "0" for cases like ".5"` \
            -e 's/^-\./-0./'      `# add "0" for cases like "-.5"`\
            -e 's/0*$//;s/\.$//'   # remove trailing zeros
    else
        printf "$result"
    fi
    printf "\n"
}



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



# Change working directory to the top-most Finder window location
function cdf() { # short for `cdfinder`
    cd "$(osascript -e 'tell app "Finder" to POSIX path of (insertion location as alias)')"
}



# Create a .tar.gz archive, using `zopfli`, `pigz` or `gzip` for compression
function targz() {
    local tmpFile="${@%/}.tar"
    tar -cvf "${tmpFile}" --exclude=".DS_Store" "${@}" || return 1

    size=$(
        stat -f"%z" "${tmpFile}" 2> /dev/null; # OS X `stat`
        stat -c"%s" "${tmpFile}" 2> /dev/null # GNU `stat`
    )

    local cmd=""
    if (( size < 52428800 )) && hash zopfli 2> /dev/null; then
        # the .tar file is smaller than 50 MB and Zopfli is available; use it
        cmd="zopfli"
    else
        if hash pigz 2> /dev/null; then
            cmd="pigz"
        else
            cmd="gzip"
        fi
    fi

    echo "Compressing .tar using \`${cmd}\`…"
    "${cmd}" -v "${tmpFile}" || return 1
    [ -f "${tmpFile}" ] && rm "${tmpFile}"
    echo "${tmpFile}.gz created successfully."
}



# Determine size of a file or total size of a directory
function fs() {
    if du -b /dev/null > /dev/null 2>&1; then
        local arg=-sbh
    else
        local arg=-sh
    fi
    if [[ -n "$@" ]]; then
        du $arg -- "$@"
    else
        du $arg .[^.]* *
    fi
}



# Use Git’s colored diff when available
hash git &>/dev/null
if [ $? -eq 0 ]; then



    # Use Git’s colored diff when available
    function diff() {
        git diff --no-index --color-words "$@"
    }
fi



# Create a data URL from a file
function dataurl() {
    local mimeType=$(file -b --mime-type "$1")
    if [[ $mimeType == text/* ]]; then
        mimeType="${mimeType};charset=utf-8"
    fi
    echo "data:${mimeType};base64,$(openssl base64 -in "$1" | tr -d '\n')"
}



# Create a git.io short URL
function gitio() {
    if [ -z "${1}" -o -z "${2}" ]; then
        echo "Usage: \`gitio slug url\`"
        return 1
    fi
    curl -i http://git.io/ -F "url=${2}" -F "code=${1}"
}



# Start an HTTP server from a directory, optionally specifying the port
function 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"
}




# Start a PHP server from a directory, optionally specifying the port
# (Requires PHP 5.4.0+.)
function phpserver() {
    local port="${1:-4000}"
    local ip=$(ipconfig getifaddr en1)
    sleep 1 && open "http://${ip}:${port}/" &
    php -S "${ip}:${port}"
}




# Compare original and gzipped file size
function gz() {
    local origsize=$(wc -c < "$1")
    local gzipsize=$(gzip -c "$1" | wc -c)
    local ratio=$(echo "$gzipsize * 100/ $origsize" | bc -l)
    printf "orig: %d bytes\n" "$origsize"
    printf "gzip: %d bytes (%2.2f%%)\n" "$gzipsize" "$ratio"
}




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



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



# All the dig info
function digga() {
    dig +nocmd "$1" any +multiline +noall +answer
}




# Escape UTF-8 characters into their 3-byte format
function escape() {
    printf "\\\x%s" $(printf "$@" | xxd -p -c1 -u)
    # print a newline unless we’re piping the output to another program
    if [ -t 1 ]; then
        echo # newline
    fi
}



# Decode \x{ABCD}-style Unicode escape sequences
function unidecode() {
    perl -e "binmode(STDOUT, ':utf8'); print \"$@\""
    # print a newline unless we’re piping the output to another program
    if [ -t 1 ]; then
        echo # newline
    fi
}



# Get a character’s Unicode code point
function codepoint() {
    perl -e "use utf8; print sprintf('U+%04X', ord(\"$@\"))"
    # print a newline unless we’re piping the output to another program
    if [ -t 1 ]; then
        echo # newline
    fi
}


# Show all the names (CNs and SANs) listed in the SSL certificate
# for a given domain
function getcertnames() {
    if [ -z "${1}" ]; then
        echo "ERROR: No domain specified."
        return 1
    fi

    local domain="${1}"
    echo "Testing ${domain}…"
    echo # newline

    local tmp=$(echo -e "GET / HTTP/1.0\nEOT" \
        | openssl s_client -connect "${domain}:443" 2>&1);

    if [[ "${tmp}" = *"-----BEGIN CERTIFICATE-----"* ]]; then
        local certText=$(echo "${tmp}" \
            | openssl x509 -text -certopt "no_header, no_serial, no_version, \
            no_signame, no_validity, no_issuer, no_pubkey, no_sigdump, no_aux");
            echo "Common Name:"
            echo # newline
            echo "${certText}" | grep "Subject:" | sed -e "s/^.*CN=//";
            echo # newline
            echo "Subject Alternative Name(s):"
            echo # newline
            echo "${certText}" | grep -A 1 "Subject Alternative Name:" \
                | sed -e "2s/DNS://g" -e "s/ //g" | tr "," "\n" | tail -n +2
            return 0
    else
        echo "ERROR: Certificate not found.";
        return 1
    fi
}



# Add note to Notes.app (OS X 10.8)
# Usage: `note 'title' 'body'` or `echo 'body' | note`
# Title is optional. 
function note() {
    local title
    local body
    if [ -t 0 ]; then
        title="$1"
        body="$2"
    else
        title=$(cat)
    fi
    osascript >/dev/null <<EOF
tell application "Notes"
    tell account "iCloud"
        tell folder "Notes"
            make new note with properties {name:"$title", body:"$title" & "<br><br>" & "$body"}
        end tell
    end tell
end tell
EOF
}



# Add reminder to Reminders.app (OS X 10.8)
# Usage: `remind 'foo'` or `echo 'foo' | remind`
function remind() {
    local text
    if [ -t 0 ]; then
        text="$1" # argument
    else
        text=$(cat) # pipe
    fi
    osascript >/dev/null <<EOF
tell application "Reminders"
    tell the default list
        make new reminder with properties {name:"$text"}
    end tell
end tell
EOF
}



# Manually remove a downloaded app or file from the quarantine
function unquarantine() {
    for attribute in com.apple.metadata:kMDItemDownloadedDate com.apple.metadata:kMDItemWhereFroms com.apple.quarantine; do
        xattr -r -d "$attribute" "$@"
    done
}


# Install Grunt plugins and add them as `devDependencies` to `package.json`
# Usage: `gi contrib-watch contrib-uglify zopfli`
function gi() {
    local IFS=,
    eval npm install --save-dev grunt-{"$*"}
}



# Resize Canvas of image (needs imagemagick)
function canvas {
    if [[ $1 == "" ]]; then
        echo "Usage: canvas [WIDTH_SIZE_IN_PIXELS]"
    else
        for IMAGE in *.png; do
            WIDTH_AND_HEIGHT=`identify -verbose ${IMAGE} | grep Geometry | sed -E 's/.+Geometry: //'| awk -F'+' '{print $1}'`
            WIDTH=`echo $WIDTH_AND_HEIGHT|awk -F'x' '{print $1}'`
            HEIGHT=`echo $WIDTH_AND_HEIGHT|awk -F'x' '{print $2}'`
            echo "Image=${IMAGE}, Width=${WIDTH}, Height: ${HEIGHT}"
            if [[ $WIDTH -lt $1  ]]; then
                echo "Image is < ${1}px wide. Brigning it up to ${1}px"
                cp ${IMAGE} ${IMAGE}.bak
                convert ${IMAGE} -gravity west -extent ${1}x${HEIGHT} ${IMAGE}
            fi
        done
    fi
}



# Install an OSX app using brew cask
function installcask() {
  if brew cask info "${@}" | grep "Not installed" > /dev/null; then
    brew cask install "${@}"
  else
    echo "${@} is already installed."
  fi
}



# Show cheatsheets
function cheatsheets() {

    if [[ $# -ne 1 ]]; then
        echo "Usage: cheatsheets cheatsheet_name"
        echo " "
        echo "List of cheatcheet "
        for fullfile in ~/cheatsheets/*.md; do
            filename=$(basename "$fullfile")
            extension="${filename##*.}"
            filename="${filename%.*}"
            echo $filename
        done
    else
        markdown ~/cheatsheets/$1.md|lynx -stdin
    fi
}



# Check OpenSSL Expiration date
function opensslcheckexpiration() {

    local PORT
    if [[ "x$2" == "x" ]]; then
        PORT=443
    else
        PORT=$2
    fi

    openssl_output=$(echo "
GET / HTTP/1.0
EOT" | openssl s_client -connect $1:$PORT 2>&1)

    #echo $openssl_output

    if [[ "$openssl_output" = *"-----BEGIN CERTIFICATE-----"* ]]; then
        
        cert_expiry_date=$(echo "$openssl_output" \
            | sed -n '/-----BEGIN CERTIFICATE-----/,/-----END CERTIFICATE-----/p' \
            | openssl x509 -enddate \
            | awk -F= ' /notAfter/ { printf("%s\n",$NF); } ');
        
        echo "Expire on $cert_expiry_date"
        seconds_until_expiry=$(echo "$(date --date="$cert_expiry_date" +%s) - $(date +%s)" |bc);
        days_until_expiry=$(echo "$seconds_until_expiry/(60*60*24)" |bc);
        if [[ $days_until_expiry -ge 0 ]]; then
            echo "In $days_until_expiry days";
        else
            echo "EXPIRED ($days_until_expiry days)"
        fi
    else
        echo "NOT_FOUND"
    fi
}



# List all the availables functions from the ~/.bash_profile_functions.sh file
function functions() {

    egrep -o -B 3 'function .+\(\)' ~/.bash_profile_functions.sh

}



# Word frenquency alanyzer
function wf() {
    if [[ $# -eq 1 ]]; then
        sed -e 's/\.//g' -e 's/\,//g' -e 's/ /\
/g' "$1" | tr 'A-Z' 'a-z' | sort | uniq -c | sort -nr | perl -lape 'chomp $F[-1]; $_ = join " ", reverse @F' > /tmp/temp.txt
    else
        sed -e 's/\.//g' -e 's/\,//g' -e 's/ /\
/g' "$1" | tr 'A-Z' 'a-z' | sort | uniq -c | sort -nr | perl -lape 'chomp $F[-1]; $_ = join " ", reverse @F' | head -$2 > /tmp/temp.txt
    fi
    gnuplot -p -e "set xtics rotate; plot '/tmp/temp.txt' using 2:xticlabels(1) with impulses"
}



# ssh-copy-id equivalent
function ssh-copy-id(){
    if [[ $# -ne 1 ]]; then
        echo "Usage: ssh-copy-id username@machine"
        echo " "
    else
        cat ~/.ssh/id_rsa.pub | ssh $1 "mkdir ~/.ssh; cat >> ~/.ssh/authorized_keys"
    fi
}



# Fix permissions for ssh related files 
function ssh-fix-permissions(){
    chmod g-w $HOME
    chmod 700 $HOME/.ssh
    chmod 600 $HOME/.ssh/authorized_keys
}



# Show all available bash colors
function colors() {
    #
    #   Echoes a bunch of color codes to the 
    #   terminal to demonstrate what's available.  Each 
    #   line is the color code of one forground color,
    #   out of 17 (default + 16 escapes), followed by a 
    #   test use of that color on all nine background 
    #   colors (default + 8 escapes).
    #

    T='gYw'   # The test text

    echo -e "\n                 40m     41m     42m     43m     44m     45m     46m     47m";

    for FGs in '    m' '   1m' '  30m' '1;30m' '  31m' '1;31m' '  32m' \
               '1;32m' '  33m' '1;33m' '  34m' '1;34m' '  35m' '1;35m' \
               '  36m' '1;36m' '  37m' '1;37m';
      do FG=${FGs// /}
      echo -en " $FGs \033[$FG  $T  "
      for BG in 40m 41m 42m 43m 44m 45m 46m 47m;
        do echo -en "$EINS \033[$FG\033[$BG  $T  \033[0m";
      done
      echo;
    done
    echo
}



# Show title for term window/tab
function show_title() {
    echo -n -e "\033]0;$1\007"
}

# echo -e "\033]6;1;bg;red;brightness;255\a"