.bashrc.funcs

# ap - append `dir` to the var if it's not already there and it exists.
#      `var` defaults to PATH if not given.
#      `-n` requires `dir` to be nonempty
#      `-v` be verbose about what happens
#      If `after` is given, the dir is inserted after `after` in the `var`
#      instead of at the end of var.
function ap() {
  local OPTARG
  local OPTIND
  local append
  local after
  local dir
  local nonempty=0
  local var=PATH
  local verbose=0

  function usage() {
    echo "usage: ap [-nv] [-a after] [-p var] dir..."
    echo ""
    echo "  -a add the path after the \`before\` directory in the var"
    echo "     instead of at the beginning of the var"
    echo "  -n only add if the directory is not empty"
    echo "  -p add paths to \`var\` instead of PATH"
    echo "  -v be verbose about what we do"
  }

  function vecho() {
    if [[ $verbose -eq 1 ]]; then
      echo "$@"
    fi
  }

  function append() {
    local dir="$1"
    local dotglob=0

    if [[ ("${!var}" =~ ":${dir}:") || ("${!var}" =~ ^"${dir}:") || \
      ("${!var}" =~ ":${dir}"$) ]]; then
      vecho "${dir} is already in the ${var}"
      return
    fi

    if [[ ! -d "${dir}" ]]; then
      vecho "${dir} doesn't exist"
      return
    fi

    if [[ ${nonempty} -eq 1 ]]; then
      if [[ "$(shopt dotglob)" =~ on ]]; then
        dotglob=1
      fi
      shopt -s dotglob
      if [[ $(echo -n "$dir/*") = "$dir/*" ]]; then
        vecho "${dir} is empty, not adding to ${var}"
        if [[ $dotglob = 0 ]]; then
          shopt -u dotglob
        fi
        return
      else
        if [[ $dotglob = 0 ]]; then
          shopt -u dotglob
        fi
      fi
    fi

    if [[ "${after}" == "" ]]; then
      export ${var}="${!var}:${dir}"
      vecho "${dir} appended to ${var}"
      return
    fi

    if [[ ( "${!var}" = "${after}" ) || ( "${!var}" =~ ^"${after}:" ) ]] ; then
      export ${var}=${!var/${after}/"${after}:${dir}"}
      vecho "${dir} added to ${var} after ${after}"
    elif [[ "${!var}" =~ ":${after}:" ]] ; then
      export ${var}=${!var/:${after}:/:"${after}:${dir}":}
      vecho "${dir} added to ${var} after ${after}"
    elif [[ "${!var}" =~ ":${after}"$ ]] ; then
      export ${var}=${!var/:${after}/:"${after}:${dir}"}
      vecho "${dir} added to ${var} after ${after}"
    else
      vecho "${after} isn't in the ${var}"
    fi
  }

  while getopts "a:hnp:v" opt; do
    case ${opt} in
      a) after=${OPTARG} ;;
      n) nonempty=1 ;;
      p) var=${OPTARG} ;;
      v) verbose=1 ;;
      h | ?)
        usage
        return
        ;;
    esac
  done

  shift $(( $OPTIND - 1))

  if [[ $# -eq 0 ]]; then
    usage
    return
  fi

  if [[ ("${!var}" == "") && ("${after}" == "") ]]; then
    export ${var}="$1"
    shift
  fi

  while [[ $# -gt 0 ]]; do
    if [[ -d "$1" ]]; then
      append "$1"
      # after="$1"
    fi
    shift
  done
}

function atrack() {
  racket -ile scribble/reader "(use-at-readtable)" "$@"
}

function atx() {
  $src/pyfloyd/utils/at-exp "$@"
}

function df() {
  command df -h "$@"
}

function dt() {
    cd $dt/"$@"
}

function du() {
  command du -h "$@"
}

function dve() {
  # deactivate current python venv; see also ve().
  deactivate
}

# csrc - cd to $csrc/$*
function csrc() {
  if [ ! -z "$csrc" ]
  then
    cd ${csrc}/"$@"
  else
    echo "not in a view"
  fi
}

function gb() {
  git map-branches "$@"
}

function gdu() {
  git diff @{u} "$@"
}

function gdun() {
  git diff @{u} --name-only "$@"
}

function geu() {
  ge $(git diff --name-only @{u} "$@")
}

function gng() {
  git grep "$@" -- \*.gn \*.gni
}

function h() {
  history "$@"
}

function home() {
  cd "$HOME/$@"
}

# insert path into var
function ip() {
  local OPTARG
  local OPTIND
  local before
  local dir
  local nonempty=0
  local opt_nonempty
  local opt_v
  local prepend
  local var=PATH
  local verbose=0

  function usage() {
    echo "usage: ip [-nv] [-b before] [-p var] dir..."
    echo ""
    echo "  -b add the directories before the \`before\` dir in the var"
    echo "     instead of at the beginning of the var"
    echo "  -n only add if the directory is not empty"
    echo "  -p add paths to \`var\` instead of PATH"
    echo "  -v be verbose about what we do"
  }

  function vecho() {
    if [[ $verbose -eq 1 ]] ; then
      echo "$@"
    fi
  }

  function prepend() {
    local dir="$1"

    if [[ ("${!var}" =~ ":${dir}:") || ("${!var}" =~ ^"${dir}:") || \
      ("${!var}" =~ ":${dir}"$) ]]
    then
      vecho "${dir} is already in the ${var}"
      return
    fi

    if [[ ! -d "${dir}" ]]; then
      vecho "${dir} doesn't exist"
      return
    fi

    if [[ ${nonempty} -eq 1 ]]; then
      local dotglob=0
      if [[ "$(shopt dotglob)" =~ on ]]; then
        dotglob=1
      fi
      shopt -s dotglob
      if [[ $(echo -n "$dir/*") = "$dir/*" ]]; then
        vecho "${dir} is empty, not adding to ${var}"
        if [[ $dotglob = 0 ]]; then
          shopt -u dotglob
        fi
        return
      else
        if [[ $dotglob = 0 ]]; then
          shopt -u dotglob
        fi
      fi
    fi

    if [[ "${before}" == "" ]]; then
      export ${var}="${dir}:${!var}"
      vecho "${dir} prepended to ${var}"
      return
    fi

    if [[ "${!var}" =~ "${before}" ]]; then
      export ${var}="${!var/${before}/"${dir}:${before}"}"
      vecho "${dir} added to ${var} before ${before}"
    else
      vecho "${before} isn't in the ${var}"
    fi

    return
  }

  while getopts "b:hnp:v" opt
  do
    case ${opt} in
      b) before=${OPTARG} ;;
      n) nonempty=1 ; opt_nonempty="-n";;
      p) var=${OPTARG} ;;
      v) verbose=1 ; opt_v="-v" ;;
      h | ?)
        usage
        return
        ;;
    esac
  done

  shift $(( $OPTIND - 1))
  if [[ $# -eq 0 ]]; then
    usage
    return
  fi

  first="$1"

  if [[ ("${!var}" == "") && ("${after}" == "") ]]; then
    export ${var}="${first}"
    shift
  else
    prepend "${first}"
    shift
  fi

  if [[ $# -gt 0 ]]; then
    ap -a "${first}" -p "${var}" $opt_nonempty $opt_v "$@"
  fi
}

alias ls='ls -F'

function pset() {
  set | pset_aux "$@"
}

function py() {
  local use_pdb=0
  local use_continue=0
  local use_module=0
  local script=''

  # Note that this function doesn't *quite* work the way you'd want.
  # If you run `py argv.py -h` then pdb will intercept the `-h` and
  # show *its* help. There doesn't seem to be a way around this; passing
  # `--` will cause pdb to ignore the arg, but it will also cause
  # the script or module to ignore the arg. This applies to any flag
  # pdb recognizes.

  # set -x
  function usage() {
    echo "py [-p | --pm] [-d | --pdb] [-h | --help] [-m module | script] ..."
  }

  if [[ "$1" = "-h" || "$1" = "--help" ]] ; then
    usage
    # set +x
    return
  fi

  while [[ $# -gt 0 ]] ; do
    if [[ "$1" = "-d" || "$1" = "--pdb" ]] ; then
      use_pdb=1
    elif [[ "$1" = "-p" || "$1" = "--pm" ]] ; then
      use_continue=1
    elif [[ "$1" = "-m" ]] ; then
      use_module=1
      shift
      script="$1"
      shift
      break
    else
      script="$1"
      shift
      break
    fi
    shift
  done

  if [[ $# -eq 0 && "$script" = "" ]] ; then
    usage
    # set +x
    return
  fi

  if [[ $use_continue -eq 1 ]] ; then
    if [[ $use_module -eq 1 ]] ; then
      python3 -m pdb -c continue -m "$script" "$@"
    else
      python3 -m pdb -c continue "$script" "$@"
    fi
  elif [[ $use_pdb -eq 1 ]]; then
    if [[ $use_module -eq 1 ]] ; then
      python3 -m pdb -m "$script" "$@"
    else
      python3 -m pdb "$script" "$@"
    fi
  else
    if [[ $use_module -eq 1 ]] ; then
      python3 -m "$script" "$@"
    else
      python3 "$script" "$@"
    fi
  fi

  # set +x
}

function r() {
  if [[ "$csrc" = "" ]]; then
    echo "Not in a checkout"
  else 
    "$csrc/run" "$@"
  fi
}

# redot - re-read dot files
function redot() {
  local old_view
  old_view=$view
  . ~/.bashrc
  if [ -n "$old_view" ]
  then
    sv $old_view
    cd -
  fi
}

function repeat() {
  count=$1
  shift

  while [ $count -ne 0 ]
  do
    "$@"
    if [ $? -gt 128 ]
    then
      return
    fi
    count=$((count - 1))
  done
}

# rp - remove directories from path-like env var
#   usage: rp [-p var] dir...
function rp() {
  local comp
  local var

  function usage() {
    echo "usage: rp [-v] [-p var] dir..."
    echo ""
    echo "  -p remove paths from \`var\` instead of PATH"
    echo "  -v be verbose about what we do"
  }

  function vecho() {
    if [[ $verbose -eq 1 ]] ; then
      echo "$@"
    fi
  }

  var=PATH
  while getopts "hp:v" opt ; do
    case ${opt} in
      p) var="${OPTARG}" ;;
      v) verbose=1 ;;
      h | ?)
        usage
        return
        ;;
    esac
  done

  shift $(( $OPTIND - 1))

  if [[ $# -eq 0 ]]; then
    usage
    return
  fi

  while [[ $# -gt 0 ]]; do
    comp="$1"
    if [[ "${!var}" = "${comp}" ]] ; then
      export ${!var}=
      vecho "removed ${comp} from ${!var}"
    elif [[ "${!var}" =~ ^"${comp}:" ]] ; then
      # front
      export ${var}="${!var/#${comp}:/}"
      vecho "removed ${comp} from ${!var}"
    elif [[ "${!var}" =~ ":${comp}:" ]] ; then
      # middle
      export ${var}="${PATH/:${comp}:/:}"
      vecho "removed ${comp} from ${!var}"
    elif [[ "${!var}" =~ ":${comp}"$ ]]
    then
      # end
      export ${var}="${!var/%:$comp/}"
      vecho "removed ${comp} from ${!var}"
    else
      vecho "did not find ${comp} in ${!var}"
    fi
    shift
  done
}

function scrib() {
    f=scrib-tmp
    fn="${f}.txt"
    if [[ -e "$fn" ]]; then
        echo "Error: $fn exists; delete first"
        return
    fi
    scribble --text --dest-name "$f" --quiet "$@"
    cat -e "$fn"
    rm "$fn"
}

function setprompt() {
  if [ "$TERM" = "xterm" -o "$TERM" = "xterm-color" -o \
       "$TERM" = "xterm-256color" -o "$TERM" = "msys" -o "$TERM" = "cygwin" ]
  then
    if [ ! -z "$view" ]
    then
      if [ "$GIT_PRESENT" = "1" -a "$OSNAME" != "cygwin" ]
      then
        PS1='\[\e]0;\u@\h ($view|$(gitbranch)):\w\a\]\W $ '
      else
        PS1='\[\e]0;\u@\h ($view):\w\a\]\W $ '
      fi
    else
      PS1='\[\e]0;\u@\h:\w\a\]\W $ '
    fi
  else
    if [ ! -z "$view" ]
    then
      PS1="($view) \W $ "
    else
      PS1="\W $ "
    fi
  fi
}

# Turn on shell tracing if necessary, execute a command, then turn off tracing
# if we turned it on before. If tracing is already on, just execute the command.
function shdbg() {
  local x=0
  if [[ !("$-" =~ "x") ]]; then
    x=1
    set -x
  fi

  "$@"

  if [[ $x = 1 ]]; then
    set +x
  fi
}

function src() {
  cd "$src/$@"
}

function sv() {
  if [ "$1" = "-d" ]
  then
    unset view csrc
    setprompt
    return
  fi

  local new_view=$1

  if [ ! -d "$src/$new_view" ]
  then
    echo "no such view '$new_view' under $src"
    return
  fi

  export view=$new_view
  export csrc=$(gcsrc $src/$new_view)
  setprompt
  cd $csrc
}

function uhome() {
  cd "$HOME/$@"
}

function ve() {
  if [[ "${1}" == "" ]]; then
    if [[ -e ./.venv/pyvenv.cfg ]]; then
      source ".venv/bin/activate"
    elif [[ -d "${csrc}/.venv/pyvenv.cfg" ]]; then
      source "${csrc}/.venv/bin/activate"
    else
      echo "No venv found in current directory"
    fi
  elif [[ -e "${1}/pyvenv.cfg" ]]; then
    source "${1}/bin/activate"
  else
    echo "No venv found in ${1}"
  fi
}

# echo current window size
function ws() {
    echo "${COLUMNS}x${LINES}"
}

# Bash completion for sv()
# return any directories matching $src/c\.*
function _sv_comp() {
  local cur prev opts
  COMPREPLY=()
  cur="${COMP_WORDS[COMP_CWORD]}"
  prev="${COMP_WORDS[COMP_CWORD-1]}"
  opts=$(cd $src ; \ls -1 | grep '^c\.' | sed 's/c\.//g' | tr "\n" " ")

  COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
  return 0
}

complete -F _sv_comp sv