.functions

#!/usr/bin/env bash

# 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 "$_";
}

# Function to create a directory and a file with a given path
# Example usage:
# tap mydir/myfile.txt
tap() {
    if [ "$#" -ne 1 ]; then
        echo "Usage: tap <filepath>"
        return 1
    fi

    local filepath="$1"
    local dir
    local file

    # Extract directory path and file name from the filepath
    dir=$(dirname "$filepath")
    file=$(basename "$filepath")

    # Create the directory and the file
    mkdir -p "$dir" && touch "$filepath"
}




#find text|no-binary files with dir path as stdin or cwd
function find-nb(){
  find ${1:-.} -type f -not -path '*/\.*' -exec grep -Il '.' {} \; | xargs -L 1 echo
}

# 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
  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:-9000}";
  local ip=$(ipconfig getifaddr en0);
  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;
}

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

# UTF-8-encode a string of Unicode symbols
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 ssl-get-cert-names() {
  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" \
    | $(brew --prefix)/opt/openssl/bin/openssl s_client -connect "${domain}:443" -servername "${domain}" 2>&1);

  if [[ "${tmp}" = *"-----BEGIN CERTIFICATE-----"* ]]; then
    local certText=$(echo "${tmp}" \
      | $(brew --prefix)/opt/openssl/bin/openssl x509 -text -certopt "no_aux, no_header, no_issuer, no_pubkey, \
      no_serial, no_sigdump, no_signame, no_validity, no_version");
    echo "Common Name:";
    echo ""; # newline
    echo "${certText}" | grep "Subject:" | sed -e "s/^.*CN=//" | sed -e "s/\/emailAddress=.*//";
    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;
}

#all the details
function ssl-show-remote-cert() {
  if [ -z "${1}" ]; then
    echo "ERROR: No domain specified.";
    return 1;
  fi;
  echo -n '' | $(brew --prefix)/opt/openssl/bin/openssl s_client -showcerts -connect "$1:${2:-443}" -servername "$1"
}

# just show me the dates
function ssl-check-remote-cert-expiration() {
  if [ -z "${1}" ]; then
    echo "ERROR: No domain specified.";
    return 1;
  fi;
  echo -n '' | $(brew --prefix)/opt/openssl/bin/openssl s_client -connect "$1:${2:-443}" -servername "$1"| openssl x509 -noout -dates
}

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

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

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


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

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

# `e` with no arguments opens the current directory in PROJECT_EDITOR env var, otherwise
# opens the given location
function e() {
  if [ $# -eq 0 ]; then
    open -na "${PROJECT_EDITOR}" --args .;
  else
    open -na "${PROJECT_EDITOR}" --args "$@";
  fi;
}

# open last files from commit to default editor or stdin
function orc(){
   ${1:-${PROJECT_EDITOR}} . && echo  $(git diff-tree --no-commit-id --name-only -r $(git rev-parse HEAD)) | xargs -L1 ${1:-${PROJECT_EDITOR}}
}

# open all the files i've worked on in the last 24hrs
function oy(){
  ${1:-${PROJECT_EDITOR}} . && echo  $(git log --since=1.days --author="$(git config user.name)" --pretty=format:"%h" | xargs -L1  git diff-tree --no-commit-id --name-only -r --stdin) | xargs -L1 ${1:-${PROJECT_EDITOR}}
}


# list top level npm packages
function npml() {
  npm list $@ | grep ^[├└]
}

# list top level npm packages globally
function npmgl() {
  npm -g list $@ | grep ^[├└]
}

# `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.
function tre() {
  tree -aC -I '.git|node_modules|bower_components' --dirsfirst "$@" | less -FRNX;
}

# Opens the github page for the current git repository (and branch) in your browser
function gp() {
  giturl=$(git config --get remote.origin.url)
  if [ "$giturl" == "" ]
    then
     echo "Not a git repository or no remote.origin.url set"
     exit 1;
  fi

  gitbranch=$(git symbolic-ref --quiet --short HEAD)

  giturl=${giturl/git\@github\.com\:/https://github.com/}
  giturl=${giturl/\.git//tree/$gitbranch}
  echo $giturl
  open $giturl
}

function git-ag () {
  if [[ "$1" = "-a" ]]
  then
    all=1
    shift
  else
    all=0
  fi
  pattern="$1"
  shift
  if [[ "$all" = 1 ]]
  then
    git ls-files -- "$@" | ag -S "$pattern"
  else
    git ls-files -- "$@" | grep -vf .gitignore | ag -S "$pattern"
  fi
}

function mat () {
  pandoc $1 | lynx -stdin
}

# keep host working directory in vagrant
function vagrant_working_dir {
    current_dir=`pwd`
    echo ${current_dir/$HOME\/projects/\/vagrant}
}


# Search the current directory and all parent directories for a gruntfile.
function _grunt_file() {
  local curpath="$PWD"
  while [[ "$curpath" ]]; do
    for grunt_file in "$curpath/"{G,g}runtfile.{js,coffee}; do
      if [[ -e "$grunt_file" ]]; then
        echo "$grunt_file"
        return
      fi
    done
    curpath="${curpath%/*}"
  done
  return 1
}

# Enable grunt bash autocompletion.
function _grunt_completions() {
  # The currently-being-completed word.
  local cur="${COMP_WORDS[COMP_CWORD]}"
  # The current gruntfile, if it exists.
  local grunt_file="$(_grunt_file)"
  # The current grunt version, available tasks, options, etc.
  local grunt_info="$(grunt --version --verbose 2>/dev/null)"
  # Options and tasks.
  local opts="$(echo "$grunt_info" | awk '/Available options: / {$1=$2=""; print $0}')"
  local compls="$(echo "$grunt_info" | awk '/Available tasks: / {$1=$2=""; print $0}')"
  # Only add -- or - options if the user has started typing -
  [[ "$cur" == -* ]] && compls="$compls $opts"
  # Tell complete what stuff to show.
  COMPREPLY=($(compgen -W "$compls" -- "$cur"))
}

complete -o default -F _grunt_completions grunt


# Search the current directory and all parent directories for a gulpfile.
function _gulp_file() {
  local curpath="$PWD"
  while [[ "$curpath" ]]; do
    for gulp_file in "$curpath/"{G,g}ulpfile.{js,coffee}; do
      if [[ -e "$gulp_file" ]]; then
        echo "$gulp_file"
        return
      fi
    done
    curpath="${curpath%/*}"
  done
  return 1
}

# Search the current directory and all parent directories for a gulptasksfile.
function _gulp_tasks() {
  local curpath="$PWD"
  while [[ "$curpath" ]]; do
    for gulp_tasks in "$curpath/".gulp_tasks; do
      if [[ -e "$gulp_tasks" ]]; then
        echo "$gulp_tasks"
        return
      fi
    done
    curpath="${curpath%/*}"
  done
  return 1
}

# Enable gulp bash autocompletion.
function _gulp_completions() {
  # The currently-being-completed word.
  local cur="${COMP_WORDS[COMP_CWORD]}"
  # The current gulpfile, if it exists.
  local gulp_file="$(_gulp_file)"
  # The current gulp_tasks file, if it exists.
  local gulp_tasks="$(_gulp_tasks)"

  #exit function if we don't have a gulpfile
  if [ ! -e "$gulp_file" ] ; then
    return
  fi

  #if we don't find a .gulp_tasks file create one, add the tasks and pull it's path back in
  if [ ! -e "$gulp_tasks" ] ; then
    touch ".gulp_tasks"
    #save tasks
    echo $(gulp --tasks-simple) > .gulp_tasks
    local gulp_tasks=$(realpath .gulp_tasks)
  else
    if test $gulp_file -nt $gulp_tasks; then
      # gulpfile is newer than our gulp_tasks file, we need to update it
      echo $(gulp --tasks-simple) > $gulp_tasks
    fi
  fi

  #now let's get those damn tasks
  local compls=$(cat $gulp_tasks)

  # Tell complete what stuff to show.
  COMPREPLY=($(compgen -W "$compls" -- "$cur"))
}

complete -o default -F _gulp_completions gulp

#keep casks up to date the right way
function witches-brew() {
  brew update && brew upgrade && brew cu -fa && brew cleanup && brew doctor
}

function keyme () {
  if [ -z "$1" -o -z "$2" ]; then
    echo "Please provide your email and a name for the key (preferably the server domain) - usage: newkey <email> <keyname>"
    return 1
  fi
  ssh-keygen -t rsa -b 4096 -C "$1" -f "$HOME/.ssh/${2}_rsa"

  read -r -p "Would you like to upload this key to a server now? [y/N] " response
  response=${response}    # tolower
  if [[ $response =~ ^(yes|y)$ ]]; then
    echo -n "Enter the server hostname or IP address and press [ENTER]: "
    read server
    echo -n "Enter your username for $server and press [ENTER]: "
    read username
    ssh-copy-id -i "$HOME/.ssh/${2}_rsa.pub" "$username@$server"
  fi
}

function getkey2 () {
  if [ -z "$1" ]; then
    echo "Please provide a keyname (it's probably the domain) - usage: getkey2 <keyname>"
    return 1
  fi
  local keyname="$1"

  if [ -z "$keyname" ]; then
    keyname="id"
  fi

  echo "Public key from file $HOME/.ssh/${keyname}_rsa.pub" && echo ""
  cat "$HOME/.ssh/${keyname}_rsa.pub"
}

#auto completion for composer
_composer()
{
    local cur=${COMP_WORDS[COMP_CWORD]}
    local cmd=${COMP_WORDS[0]}
    if ($cmd > /dev/null 2>&1)
    then
        COMPREPLY=( $(compgen -W "$($cmd list --raw | cut -f 1 -d " " | tr "\n" " ")" -- $cur) )
    fi
}
complete  -o default -F _composer composer
complete  -o default -F _composer composer.phar


#auto switch node version if nvmrc file is found
function nvm_auto_switch() {
  local NVM_RC_FILE
  local DEFAULT_VERSION
  local NVM_VERSION
  NVM_RC_FILE=$(nvm_find_nvmrc)

  if [ "$NVM_RC_FILE"  == "" ]; then
    DEFAULT_VERSION="$(nvm_alias default 2>/dev/null || echo)"
    NVM_VERSION="$(nvm_version "$DEFAULT_VERSION")"
  else
    NVM_VERSION=$(cat "$NVM_RC_FILE")
  fi

  #use whatever .python_version in local dir for npm installs
  npm config set python ~/.pyenv/shims/python

  [ "$(nvm_version_path "$NVM_VERSION")/bin" == "$NVM_BIN" ] || nvm use "$NVM_VERSION"
}

#upgrade current version of node to it's latest lts
function nvm-upgrade {
  local prev_ver=$(nvm current)
  nvm install --lts --latest-npm
  if [ "$prev_ver" != "$(nvm current)" ]
  then
    nvm reinstall-packages $prev_ver
    nvm uninstall $prev_ver
  fi
  nvm cache clear
}

#docker functions
function docker-stop-all() {
  docker stop $(docker ps -q)
}
function docker-kill-all() {
  docker kill $(docker ps -q)
}
function docker-remove-all-containers() {
  docker rm $(docker ps -a -q) --force
}
function docker-remove-all-images() {
  docker rmi $(docker images -q) --force
}



#aritsan autocompletes
function _artisan() {
    COMP_WORDBREAKS=${COMP_WORDBREAKS//:}

    if [ -f "$ARTISAN_CMDS_FILE" ]; then
        COMMANDS=$(cat "$ARTISAN_CMDS_FILE")
    else
        COMMANDS=$(php artisan --raw --no-ansi list | awk '{print $1}')
    fi

    COMPREPLY=(`compgen -W "$COMMANDS" -- "${COMP_WORDS[COMP_CWORD]}"`)

    return 0
}

function art_cache() {
    if [[ "$1" == "clear" ]]; then
        echo -n "Removing commands cache file..."
        rm -f "$ARTISAN_CMDS_FILE"
        echo "done."
    else
        php artisan --raw --no-ansi list | awk '{print $1}' > "$ARTISAN_CMDS_FILE"
        echo $(wc -l "$ARTISAN_CMDS_FILE" | awk '{print $1}')" artisan commands cached."
    fi
}