driller

#!/usr/bin/env bash
set -e
VERSION="v0.3.4.1"

function usage() {
  cat <<EOF
USAGE:
  $(basename -- $0) [OPTION] <dir>

OPTIONS:
  -a, --absolute            Absolute path (default).
  -b, --basename            Strip directory from path.
  -D, --dereference         Recursively find the ultimate target of a symlink.
  -d, --dirname             Strip file from path.
  -h, --help                This help.
  -s, --scm-root            Find the SCM root (git or hg) for file.
      --version             Version information.

EOF
  exit 0
}

function version() {
  echo ${VERSION}
  exit 0
}

function fatal() {
  echo "Fatal: $1" > /dev/stderr
  exit 1
}

function __strip_extraneous_slashes() {
  ${REAL_PATH} -m -s -- "$1"
}

function __check_link_loop() {
  if [[ -L $1 ]]; then
    ${REAL_PATH} -q "$1" &> /dev/null || fatal "Symlink loop."
  fi
  return 0
}

function __decorate_path() {
  # add a trailing slash if it's a dir.
  # remove trailing slashes if it's a file.

  if [[ -d $1 ]] && [[ ! -L $1 ]]; then
    path=$(echo $1 | sed -E 's#/*$#/#g')
  else
    path=$(echo $1 | sed -E 's#/*$##g')
  fi
  echo ${path}
}

function __dereference() {
  __check_link_loop "$1"
  working_dir=$(dirname -- "$1")
  pushd ${working_dir} &> /dev/null
  path=$(readlink -- $1 || echo $1)
  path=$(${REAL_PATH} -- "${path}")
  popd &> /dev/null
  __decorate_path ${path}
}

function __clean_path() {
  path=$1
  path=$(__expand_tilde "${path}")
  path=$(__strip_extraneous_slashes "${path}")
  path=$(__decorate_path "${path}")
  echo ${path}
}

function __dirname() {
  path=$1
  [[ ! -d "${path}" ]] && path=$(dirname -- "${path}")
  __clean_path "${path}"
}

function __filename() {
  basename -- "$(__clean_path "$1")"
}

function __scm_dir() {
  [[ -d "$1/.hg" || -d "$1/.git" ]] && return 0
}

function __scm_root() {
  path=$(__dereference $1)
  dir=$(__dirname ${path})
  while true; do
    [[ "${dir}" == "/" ]] && fatal "SCM dir not found"
    __scm_dir "${dir}" && break
    dir="$(__clean_path "${dir}/../")"
  done

  echo $dir
}

function __user_home() {
  user=$1
  if [[ $(uname) == "Darwin" ]]; then
    dscacheutil -q user -a name ${user} | grep ^dir: | cut -d\  -f2-
  else
    cat /etc/passwd | grep ^${user} | cut -d: -f6
  fi
}

function __expand_tilde() {
  # Expansion of ~ is usually done by your shell. This function does it too.
  path=$1
  user_section=$(echo ${path} | grep -o '^~[^\/]*')
  [[ -z ${user_section} ]] && echo ${path} && return 0
  path_section=$(echo ${path} | grep -o '\/.*$')

  if [[ ${user_section} == "~" ]]; then
    user=${USER}
  else
    user=$(echo ${user_section} | sed 's/~//g')
  fi

  echo "$(__user_home ${user})${path_section}"
}

REAL_PATH=$(which realpath || which grealpath || fatal "realpath command not found")

[[ -z $@ ]] && usage
PATH_ARGS=""
OPTION="--absolute"
PATH_ARGS=()

for i in $(seq 1 $#); do
  eval a=\$$i

  a=$(__expand_tilde "$a")
  if [[ -e "$a" ]] || [[ -L "$a" ]]; then
    PATH_ARGS+=( "$(__clean_path "$a")" )
  elif [[ "$a" =~ ^--[a-z\-]+$ ]]; then
    OPTION=$a
  elif [[ "$a" =~ ^-[a-z]$ ]]; then
    OPTION=$a
  fi
done

if [[ -p /dev/stdin ]]; then
  PATH_ARGS+=( "$(__clean_path $(cat /dev/stdin))" )
fi

for element in $(seq 0 $((${#PATH_ARGS[@]} - 1))); do
  path=${PATH_ARGS[$element]}
  [[ -z "${path}" ]] && break

  case "${OPTION}" in
    "--absolute"|"-a")             echo "$path"                              ;;
    "--basename"|"-b")             [[ ! -d "$path" ]] && __filename "$path"  ;;
    "--dereference"|"-D")          __dereference "$path"                     ;;
    "--dirname"|"-d")              __dirname "$path"                         ;;
    "--scm"|"--scm-root"|"-s")     __scm_root "$path"                        ;;
  esac
done

case "${OPTION}" in
  "--help")                   usage                                 ;;
  "--version")                version                               ;;
esac