n

#!/usr/bin/env sh

# Library version

VERSION="1.0.0"
N_PREFIX=${N_PREFIX-/usr/local}
VERSIONS_DIR=$N_PREFIX/n/versions
UP=$'\033[A'
DOWN=$'\033[B'

# setup

test -d $VERSIONS_DIR || mkdir -p $VERSIONS_DIR

#
# Log <type> <msg>
#

log() {
  printf "  \033[36m%10s\033[0m : \033[90m%s\033[0m\n" $1 $2
}

#
# Exit with the given <msg ...>
#

abort() {
  printf "\n  \033[31mError: $@\033[0m\n\n" && exit 1
}

# curl / wget support

GET=
GET_OK=

if command -v curl > /dev/null; then
  GET="curl -L#"
  GET_OK="curl -Is"
elif command -v wget > /dev/null; then
  GET="wget -O-"
  GET_OK="wget --spider -SqO-"
else
  abort "curl or wget required"
fi

#
# Output usage information.
#

display_help() {
  cat <<-help

  Usage: n [options] [COMMAND] [config]

  Commands:

    n                            Output versions installed
    n latest [config ...]        Install or activate the latest node release
    n stable [config ...]        Install or activate the latest stable node release
    n <version> [config ...]     Install and/or use node <version>
    n use <version> [args ...]   Execute node <version> with [args ...]
    n bin <version>              Output bin path for <version>
    n rm <version ...>           Remove the given version(s)
    n prev                       Revert to the previously activated version
    n --latest                   Output the latest node version available
    n --stable                   Output the latest stable node version available
    n ls                         Output the versions of node available

  Options:

    -V, --version   Output current version of n
    -h, --help      Display help information

  Aliases:

    which   bin
    use     as
    list    ls
    -       rm

help
  exit 0
}

#
# Hide cursor.
#

hide_cursor() {
  printf "\e[?25l"
}

#
# Show cursor.
#

show_cursor() {
  printf "\e[?25h"
}

#
# Output version after selected.
#

next_version_installed() {
  list_versions_installed | grep $selected -A 1 | tail -n 1
}

#
# Output version before selected.
#

prev_version_installed() {
  list_versions_installed | grep $selected -B 1 | head -n 1
}

#
# Output n version.
#

display_n_version() {
  echo $VERSION && exit 0
}

#
# Check for installed version, and populate $active
#

check_current_version() {
  which node &> /dev/null
  if test $? -eq 0; then
    active=`node --version`
    active=${active#v}
  fi
}

#
# Display installed versions with <selected>.
#

display_versions_with_selected() {
  selected=$1
  echo
  for dir in $VERSIONS_DIR/*; do
    local version=${dir##*/}
    local config=`test -f $dir/.config && cat $dir/.config`
    if test "$version" = "$selected"; then
      printf "  \033[36mο\033[0m $version \033[90m$config\033[0m\n"
    else
      printf "    \033[90m$version $config\033[0m\n"
    fi
  done
  echo
}

#
# List installed versions.
#

list_versions_installed() {
  for dir in $VERSIONS_DIR/*; do
    local version=${dir##*/}
    echo $version
  done
}

#
# Display current node --version
# and others installed.
#

display_versions() {
  clear
  check_current_version
  display_versions_with_selected $active

  while true; do
    read -s -n 3 c
    case "$c" in
      $UP)
        clear
        display_versions_with_selected $(prev_version_installed)
        ;;
      $DOWN)
        clear
        display_versions_with_selected $(next_version_installed)
        ;;
      *)
        clear
        activate $selected
        exit
        ;;
    esac
  done
}

#
# Move up a line and erase.
#

erase_line() {
  printf "\033[1A\033[2K"
}

#
# Check if the HEAD response of <url> is 200.
#

is_ok() {
  $GET_OK $1 2>&1 | egrep "HTTP.*?200" > /dev/null
}

#
# Determine tarball url for <version>.
#

tarball_url() {
  local version=$1
  local uname="$(uname -a)"
  local arch=x86
  local os=

  # from nave(1)
  case "$uname" in
    Linux*) os=linux ;;
    Darwin*) os=darwin ;;
    SunOS*) os=sunos ;;
  esac

  case "$uname" in
    *x86_64*) arch=x64 ;;
    *armv6l*) arch=arm-pi ;;
  esac

  echo "http://nodejs.org/dist/v${version}/node-v${version}-${os}-${arch}.tar.gz"
}

#
# Activate <version>
#

activate() {
  local version=$1
  local dir=$VERSIONS_DIR/$version
  check_current_version
  echo $active > $VERSIONS_DIR/.prev
  cp -fR $dir/* $N_PREFIX
}

#
# Activate previous node.
#

activate_previous() {
  test -f $VERSIONS_DIR/.prev || abort "no previous versions activated"
  local prev=$(cat $VERSIONS_DIR/.prev)
  activate $prev
  echo
  log activate $prev
  echo
}

#
# Install <version>
#

install_node() {
  local version=${1#v}
  local config=$@
  local dir=$VERSIONS_DIR/$version
  local url=$(tarball_url $version)

  if test -d $dir; then
    activate $version
    exit
  fi

  echo
  log install $version

  is_ok $url || abort "invalid version $version"

  log mkdir $dir
  mkdir -p $dir
  cd $dir

  log fetch $url
  $GET $url | tar -zx --strip 1
  erase_line

  activate $version
  log installed $(node --version)
  echo
}

#
# Remove <version ...>
#

remove_version() {
  test -z $1 && abort "version(s) required"
  local version=${1#v}
  while test $# -ne 0; do
    rm -rf $VERSIONS_DIR/$version
    shift
  done
}

#
# Output bin path for <version>
#

display_bin_path_for_version() {
  test -z $1 && abort "version required"
  local version=${1#v}
  local bin=$VERSIONS_DIR/$version/bin/node
  if test -f $bin; then
    printf $bin
  else
    abort "$1 is not installed"
  fi
}

#
# Execute the given <version> of node
# with [args ...]
#

execute_with_version() {
  test -z $1 && abort "version required"
  local version=${1#v}
  local bin=$VERSIONS_DIR/$version/bin/node

  shift # remove version

  if test -f $bin; then
    $bin $@
  else
    abort "$version is not installed"
  fi
}

#
# Display the latest node release version.
#

display_latest_version() {
  $GET 2> /dev/null http://nodejs.org/dist/ \
    | egrep -o '[0-9]+\.[0-9]+\.[0-9]+' \
    | sort -u -k 1,1n -k 2,2n -k 3,3n -t . \
    | tail -n1
}

#
# Display the latest stable node release version.
#

display_latest_stable_version() {
  $GET 2> /dev/null http://nodejs.org/dist/ \
    | egrep -o '[0-9]+\.[0-9]*[02468]\.[0-9]+' \
    | sort -u -k 1,1n -k 2,2n -k 3,3n -t . \
    | tail -n1
}

#
# Display the versions of node available.
#

display_remote_versions() {
  check_current_version
  local versions=""
  versions=`$GET 2> /dev/null http://nodejs.org/dist/ \
    | egrep -o '[0-9]+\.[0-9]+\.[0-9]+' \
    | egrep -v '^0\.[0-7]\.' \
    | egrep -v '^0\.8\.[0-5]$' \
    | sort -u -k 1,1n -k 2,2n -k 3,3n -t . \
    | awk '{ print "  " $1 }'`

  echo
  for v in $versions; do
    if test "$active" = "$v"; then
      printf "  \033[36mο\033[0m $v \033[0m\n"
    else
      if test -d $VERSIONS_DIR/$v; then
        printf "    $v \033[0m\n"
      else
        printf "    \033[90m$v\033[0m\n"
      fi
    fi
  done
  echo
}

# Handle arguments

if test $# -eq 0; then
  display_versions
else
  while test $# -ne 0; do
    case $1 in
      -V|--version) display_n_version ;;
      -h|--help|help) display_help ;;
      --latest) display_latest_version $2; exit ;;
      --stable) display_latest_stable_version $2; exit ;;
      bin|which) display_bin_path_for_version $2; exit ;;
      as|use) shift; execute_with_version $@; exit ;;
      rm|-) remove_version $2; exit ;;
      latest) install_node `n --latest`; exit ;;
      stable) install_node `n --stable`; exit ;;
      ls|list) display_remote_versions $2; exit ;;
      prev) activate_previous; exit ;;
      *) install_node $@; exit ;;
    esac
    shift
  done
fi