1131 lines
32 KiB
Bash
1131 lines
32 KiB
Bash
# Node Version Manager
|
|
# Implemented as a POSIX-compliant function
|
|
# Should work on sh, dash, bash, ksh, zsh
|
|
# To use source this file from your bash profile
|
|
#
|
|
# Implemented by Tim Caswell <tim@creationix.com>
|
|
# with much bash help from Matthew Ranney
|
|
|
|
NVM_SCRIPT_SOURCE="$_"
|
|
|
|
nvm_has() {
|
|
type "$1" > /dev/null 2>&1
|
|
}
|
|
|
|
nvm_get_latest() {
|
|
local NVM_LATEST_URL
|
|
if nvm_has "curl"; then
|
|
NVM_LATEST_URL="$(curl -w "%{url_effective}\n" -L -s -S http://latest.nvm.sh -o /dev/null)"
|
|
elif nvm_has "wget"; then
|
|
NVM_LATEST_URL="$(wget http://latest.nvm.sh --server-response -O /dev/null 2>&1 | awk '/^ Location: /{DEST=$2} END{ print DEST }')"
|
|
else
|
|
>&2 echo 'nvm needs curl or wget to proceed.'
|
|
return 1
|
|
fi
|
|
if [ "_$NVM_LATEST_URL" = "_" ]; then
|
|
>&2 echo "http://latest.nvm.sh did not redirect to the latest release on Github"
|
|
return 2
|
|
else
|
|
echo "$NVM_LATEST_URL" | awk -F'/' '{print $NF}'
|
|
fi
|
|
}
|
|
|
|
nvm_download() {
|
|
if nvm_has "curl"; then
|
|
curl $*
|
|
elif nvm_has "wget"; then
|
|
# Emulate curl with wget
|
|
ARGS=$(echo "$*" | sed -e 's/--progress-bar /--progress=bar /' \
|
|
-e 's/-L //' \
|
|
-e 's/-I /--server-response /' \
|
|
-e 's/-s /-q /' \
|
|
-e 's/-o /-O /' \
|
|
-e 's/-C - /-c /')
|
|
eval wget $ARGS
|
|
fi
|
|
}
|
|
|
|
nvm_has_system_node() {
|
|
[ "$(nvm deactivate >/dev/null 2>&1 && command -v node)" != '' ]
|
|
}
|
|
|
|
# Make zsh glob matching behave same as bash
|
|
# This fixes the "zsh: no matches found" errors
|
|
if nvm_has "unsetopt"; then
|
|
unsetopt nomatch 2>/dev/null
|
|
NVM_CD_FLAGS="-q"
|
|
fi
|
|
|
|
# Auto detect the NVM_DIR when not set
|
|
if [ -z "$NVM_DIR" ]; then
|
|
if [ -n "$BASH_SOURCE" ]; then
|
|
NVM_SCRIPT_SOURCE="${BASH_SOURCE[0]}"
|
|
fi
|
|
export NVM_DIR=$(cd $NVM_CD_FLAGS $(dirname "${NVM_SCRIPT_SOURCE:-$0}") > /dev/null && \pwd)
|
|
fi
|
|
unset NVM_SCRIPT_SOURCE 2> /dev/null
|
|
|
|
|
|
# Setup mirror location if not already set
|
|
if [ -z "$NVM_NODEJS_ORG_MIRROR" ]; then
|
|
export NVM_NODEJS_ORG_MIRROR="https://nodejs.org/dist"
|
|
fi
|
|
|
|
nvm_tree_contains_path() {
|
|
local tree
|
|
tree="$1"
|
|
local node_path
|
|
node_path="$2"
|
|
|
|
if [ "@$tree@" = "@@" ] || [ "@$node_path@" = "@@" ]; then
|
|
>&2 echo "both the tree and the node path are required"
|
|
return 2
|
|
fi
|
|
|
|
local pathdir
|
|
pathdir=$(dirname "$node_path")
|
|
while [ "$pathdir" != "" ] && [ "$pathdir" != "." ] && [ "$pathdir" != "/" ] && [ "$pathdir" != "$tree" ]; do
|
|
pathdir=$(dirname "$pathdir")
|
|
done
|
|
[ "$pathdir" = "$tree" ]
|
|
}
|
|
|
|
# Traverse up in directory tree to find containing folder
|
|
nvm_find_up() {
|
|
local path
|
|
path=$PWD
|
|
while [ "$path" != "" ] && [ ! -f "$path/$1" ]; do
|
|
path=${path%/*}
|
|
done
|
|
echo "$path"
|
|
}
|
|
|
|
|
|
nvm_find_nvmrc() {
|
|
local dir
|
|
dir="$(nvm_find_up '.nvmrc')"
|
|
if [ -e "$dir/.nvmrc" ]; then
|
|
echo "$dir/.nvmrc"
|
|
fi
|
|
}
|
|
|
|
# Obtain nvm version from rc file
|
|
nvm_rc_version() {
|
|
export NVM_RC_VERSION=''
|
|
local NVMRC_PATH
|
|
NVMRC_PATH="$(nvm_find_nvmrc)"
|
|
if [ -e "$NVMRC_PATH" ]; then
|
|
read NVM_RC_VERSION < "$NVMRC_PATH"
|
|
echo "Found '$NVMRC_PATH' with version <$NVM_RC_VERSION>"
|
|
else
|
|
>&2 echo "No .nvmrc file found"
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
nvm_version_greater() {
|
|
local LHS
|
|
LHS=$(nvm_normalize_version "$1")
|
|
local RHS
|
|
RHS=$(nvm_normalize_version "$2")
|
|
[ $LHS -gt $RHS ];
|
|
}
|
|
|
|
nvm_version_greater_than_or_equal_to() {
|
|
local LHS
|
|
LHS=$(nvm_normalize_version "$1")
|
|
local RHS
|
|
RHS=$(nvm_normalize_version "$2")
|
|
[ $LHS -ge $RHS ];
|
|
}
|
|
|
|
nvm_version_dir() {
|
|
local NVM_USE_NEW_DIR
|
|
NVM_USE_NEW_DIR="$1"
|
|
if [ -z "$NVM_USE_NEW_DIR" ] || [ "$NVM_USE_NEW_DIR" = "new" ]; then
|
|
echo "$NVM_DIR/versions"
|
|
elif [ "$NVM_USE_NEW_DIR" = "old" ]; then
|
|
echo "$NVM_DIR"
|
|
else
|
|
echo "unknown version dir" >&2
|
|
return 3
|
|
fi
|
|
}
|
|
|
|
nvm_version_path() {
|
|
local VERSION
|
|
VERSION="$1"
|
|
if [ -z "$VERSION" ]; then
|
|
echo "version is required" >&2
|
|
return 3
|
|
elif nvm_version_greater 0.12.0 "$VERSION"; then
|
|
echo "$(nvm_version_dir old)/$VERSION"
|
|
else
|
|
echo "$(nvm_version_dir new)/$VERSION"
|
|
fi
|
|
}
|
|
|
|
# Expand a version using the version cache
|
|
nvm_version() {
|
|
local PATTERN
|
|
PATTERN=$1
|
|
local VERSION
|
|
# The default version is the current one
|
|
if [ -z "$PATTERN" ]; then
|
|
PATTERN='current'
|
|
fi
|
|
|
|
if [ "$PATTERN" = "current" ]; then
|
|
nvm_ls_current
|
|
return $?
|
|
fi
|
|
|
|
VERSION="$(nvm_ls "$PATTERN" | tail -n1)"
|
|
echo "$VERSION"
|
|
|
|
if [ "$VERSION" = 'N/A' ]; then
|
|
return 3
|
|
fi
|
|
}
|
|
|
|
nvm_remote_version() {
|
|
local PATTERN
|
|
PATTERN="$1"
|
|
local VERSION
|
|
VERSION="$(nvm_ls_remote "$PATTERN" | tail -n1)"
|
|
echo "$VERSION"
|
|
|
|
if [ "_$VERSION" = '_N/A' ]; then
|
|
return 3
|
|
fi
|
|
}
|
|
|
|
nvm_normalize_version() {
|
|
echo "$1" | sed -e 's/^v//' | \awk -F. '{ printf("%d%06d%06d\n", $1,$2,$3); }'
|
|
}
|
|
|
|
nvm_ensure_version_prefix() {
|
|
echo "$1" | sed -e 's/^\([0-9]\)/v\1/g'
|
|
}
|
|
|
|
nvm_format_version() {
|
|
local VERSION
|
|
VERSION="$(nvm_ensure_version_prefix "$1")"
|
|
if [ "_$(nvm_num_version_groups "$VERSION")" != "_3" ]; then
|
|
VERSION="$(echo "$VERSION" | sed -e 's/\.*$/.0/')"
|
|
nvm_format_version "$VERSION"
|
|
else
|
|
echo "$VERSION"
|
|
fi
|
|
}
|
|
|
|
nvm_num_version_groups() {
|
|
local VERSION
|
|
VERSION="$1"
|
|
if [ -z "$VERSION" ]; then
|
|
echo "0"
|
|
return
|
|
fi
|
|
local NVM_NUM_DOTS
|
|
NVM_NUM_DOTS=$(echo "$VERSION" | sed -e 's/^v//' | sed -e 's/\.$//' | sed -e 's/[^\.]//g')
|
|
local NVM_NUM_GROUPS
|
|
NVM_NUM_GROUPS=".$NVM_NUM_DOTS"
|
|
echo "${#NVM_NUM_GROUPS}"
|
|
}
|
|
|
|
nvm_strip_path() {
|
|
echo "$1" | sed -e "s#$NVM_DIR/[^/]*$2[^:]*:##g" -e "s#:$NVM_DIR/[^/]*$2[^:]*##g" -e "s#$NVM_DIR/[^/]*$2[^:]*##g"
|
|
}
|
|
|
|
nvm_prepend_path() {
|
|
if [ -z "$1" ]; then
|
|
echo "$2"
|
|
else
|
|
echo "$2:$1"
|
|
fi
|
|
}
|
|
|
|
nvm_binary_available() {
|
|
# binaries started with node 0.8.6
|
|
local FIRST_VERSION_WITH_BINARY
|
|
FIRST_VERSION_WITH_BINARY="0.8.6"
|
|
nvm_version_greater_than_or_equal_to "$1" "$FIRST_VERSION_WITH_BINARY"
|
|
}
|
|
|
|
nvm_alias() {
|
|
local ALIAS
|
|
ALIAS="$1"
|
|
if [ -z "$ALIAS" ]; then
|
|
echo >&2 'An alias is required.'
|
|
return 1
|
|
fi
|
|
|
|
local NVM_ALIAS_PATH
|
|
NVM_ALIAS_PATH="$NVM_DIR/alias/$ALIAS"
|
|
if [ ! -f "$NVM_ALIAS_PATH" ]; then
|
|
echo >&2 'Alias does not exist.'
|
|
return 2
|
|
fi
|
|
|
|
cat "$NVM_ALIAS_PATH"
|
|
}
|
|
|
|
nvm_ls_current() {
|
|
local NVM_LS_CURRENT_NODE_PATH
|
|
NVM_LS_CURRENT_NODE_PATH="$(which node 2> /dev/null)"
|
|
if [ $? -ne 0 ]; then
|
|
echo 'none'
|
|
elif nvm_tree_contains_path "$NVM_DIR" "$NVM_LS_CURRENT_NODE_PATH"; then
|
|
local VERSION
|
|
VERSION=`node -v 2>/dev/null`
|
|
if [ "$VERSION" = "v0.6.21-pre" ]; then
|
|
echo "v0.6.21"
|
|
else
|
|
echo "$VERSION"
|
|
fi
|
|
else
|
|
echo 'system'
|
|
fi
|
|
}
|
|
|
|
nvm_resolve_alias() {
|
|
if [ -z "$1" ]; then
|
|
return 1
|
|
fi
|
|
|
|
local PATTERN
|
|
PATTERN="$1"
|
|
|
|
local ALIAS
|
|
ALIAS="$PATTERN"
|
|
local ALIAS_TEMP
|
|
|
|
local SEEN_ALIASES
|
|
SEEN_ALIASES="$ALIAS"
|
|
while true; do
|
|
ALIAS_TEMP="$(nvm_alias "$ALIAS" 2> /dev/null)"
|
|
|
|
if [ -z "$ALIAS_TEMP" ]; then
|
|
break
|
|
fi
|
|
|
|
if [ -n "$ALIAS_TEMP" ] \
|
|
&& printf "$SEEN_ALIASES" | \grep -e "^$ALIAS_TEMP$" > /dev/null; then
|
|
ALIAS="∞"
|
|
break
|
|
fi
|
|
|
|
SEEN_ALIASES="$SEEN_ALIASES\n$ALIAS_TEMP"
|
|
ALIAS="$ALIAS_TEMP"
|
|
done
|
|
|
|
if [ -n "$ALIAS" ] && [ "_$ALIAS" != "_$PATTERN" ]; then
|
|
if [ "_$ALIAS" = "_∞" ]; then
|
|
echo "$ALIAS"
|
|
else
|
|
nvm_version "$ALIAS"
|
|
fi
|
|
return 0
|
|
fi
|
|
|
|
if nvm_validate_implicit_alias "$PATTERN" 2> /dev/null ; then
|
|
local IMPLICIT
|
|
IMPLICIT="$(nvm_print_implicit_alias local "$PATTERN" 2> /dev/null)"
|
|
if [ -n "$IMPLICIT" ]; then
|
|
nvm_version "$IMPLICIT"
|
|
return $?
|
|
fi
|
|
return 3
|
|
fi
|
|
|
|
return 2
|
|
}
|
|
|
|
nvm_ls() {
|
|
local PATTERN
|
|
PATTERN=$1
|
|
local VERSIONS
|
|
VERSIONS=''
|
|
if [ "$PATTERN" = 'current' ]; then
|
|
nvm_ls_current
|
|
return
|
|
fi
|
|
|
|
if nvm_resolve_alias "$PATTERN"; then
|
|
return
|
|
fi
|
|
|
|
# If it looks like an explicit version, don't do anything funny
|
|
PATTERN=$(nvm_ensure_version_prefix $PATTERN)
|
|
if [ "_$(echo "$PATTERN" | cut -c1-1)" = "_v" ] && [ "_$(nvm_num_version_groups "$PATTERN")" = "_3" ]; then
|
|
if [ -d "$(nvm_version_path "$PATTERN")" ]; then
|
|
VERSIONS="$PATTERN"
|
|
fi
|
|
else
|
|
if [ "_$PATTERN" != "_system" ]; then
|
|
local NUM_VERSION_GROUPS
|
|
NUM_VERSION_GROUPS="$(nvm_num_version_groups "$PATTERN")"
|
|
if [ "_$NUM_VERSION_GROUPS" = "_2" ] || [ "_$NUM_VERSION_GROUPS" = "_1" ]; then
|
|
PATTERN="$(echo "$PATTERN" | sed -e 's/\.*$//g')."
|
|
fi
|
|
fi
|
|
if [ -d "$(nvm_version_dir new)" ]; then
|
|
VERSIONS=`find "$(nvm_version_dir new)/" "$(nvm_version_dir old)/" -maxdepth 1 -type d -name "$PATTERN*" -exec basename '{}' ';' \
|
|
| sort -t. -u -k 1.2,1n -k 2,2n -k 3,3n | \grep -v '^ *\.' | \grep -e '^v' | \grep -v -e '^versions$'`
|
|
else
|
|
VERSIONS=`find "$(nvm_version_dir old)/" -maxdepth 1 -type d -name "$PATTERN*" -exec basename '{}' ';' \
|
|
| sort -t. -u -k 1.2,1n -k 2,2n -k 3,3n | \grep -v '^ *\.' | \grep -e '^v'`
|
|
fi
|
|
fi
|
|
|
|
if nvm_has_system_node; then
|
|
if [ -z "$PATTERN" ]; then
|
|
VERSIONS="$VERSIONS$(printf '\n%s' 'system')"
|
|
elif [ "$PATTERN" = 'system' ]; then
|
|
VERSIONS="$(printf '%s' 'system')"
|
|
fi
|
|
fi
|
|
|
|
if [ -z "$VERSIONS" ]; then
|
|
echo "N/A"
|
|
return 3
|
|
fi
|
|
|
|
echo "$VERSIONS"
|
|
return
|
|
}
|
|
|
|
nvm_ls_remote() {
|
|
local PATTERN
|
|
PATTERN="$1"
|
|
local VERSIONS
|
|
local GREP_OPTIONS
|
|
GREP_OPTIONS=''
|
|
if nvm_validate_implicit_alias "$PATTERN" 2> /dev/null ; then
|
|
PATTERN="$(nvm_remote_version "$(nvm_print_implicit_alias remote "$PATTERN")")"
|
|
elif [ -n "$PATTERN" ]; then
|
|
PATTERN="$(nvm_ensure_version_prefix "$PATTERN")"
|
|
else
|
|
PATTERN=".*"
|
|
fi
|
|
VERSIONS=`nvm_download -L -s $NVM_NODEJS_ORG_MIRROR/ -o - \
|
|
| \egrep -o 'v[0-9]+\.[0-9]+\.[0-9]+' \
|
|
| \grep -w "${PATTERN}" \
|
|
| sort -t. -u -k 1.2,1n -k 2,2n -k 3,3n`
|
|
if [ -z "$VERSIONS" ]; then
|
|
echo "N/A"
|
|
return 3
|
|
fi
|
|
echo "$VERSIONS"
|
|
return
|
|
}
|
|
|
|
nvm_checksum() {
|
|
if nvm_has "sha1sum"; then
|
|
checksum="$(sha1sum "$1" | \awk '{print $1}')"
|
|
elif nvm_has "sha1"; then
|
|
checksum="$(sha1 -q "$1")"
|
|
else
|
|
checksum="$(shasum "$1" | \awk '{print $1}')"
|
|
fi
|
|
|
|
if [ "_$checksum" = "_$2" ]; then
|
|
return
|
|
elif [ -z "$2" ]; then
|
|
echo 'Checksums empty' #missing in raspberry pi binary
|
|
return
|
|
else
|
|
echo 'Checksums do not match.' >&2
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
nvm_print_versions() {
|
|
local VERSION
|
|
local FORMAT
|
|
local NVM_CURRENT
|
|
NVM_CURRENT=$(nvm_ls_current)
|
|
echo "$1" | while read VERSION; do
|
|
if [ "$VERSION" = "$NVM_CURRENT" ]; then
|
|
FORMAT='\033[0;32m-> %9s\033[0m'
|
|
elif [ -d "$(nvm_version_path "$VERSION" 2> /dev/null)" ]; then
|
|
FORMAT='\033[0;34m%12s\033[0m'
|
|
elif [ "$VERSION" = "system" ]; then
|
|
FORMAT='\033[0;33m%12s\033[0m'
|
|
else
|
|
FORMAT='%12s'
|
|
fi
|
|
printf "$FORMAT\n" $VERSION
|
|
done
|
|
}
|
|
|
|
nvm_validate_implicit_alias() {
|
|
if [ "_$1" != "_stable" ] && [ "_$1" != "_unstable" ]; then
|
|
echo "Only implicit aliases 'stable' and 'unstable' are supported." >&2
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
nvm_print_implicit_alias() {
|
|
if [ "_$1" != "_local" ] && [ "_$1" != "_remote" ]; then
|
|
echo "nvm_print_implicit_alias must be specified with local or remote as the first argument." >&2
|
|
return 1
|
|
fi
|
|
|
|
if ! nvm_validate_implicit_alias "$2"; then
|
|
return 2
|
|
fi
|
|
|
|
local LAST_TWO
|
|
if [ "_$1" = "_local" ]; then
|
|
LAST_TWO=$(nvm_ls | \grep -e '^v' | cut -c2- | cut -d . -f 1,2 | uniq)
|
|
else
|
|
LAST_TWO=$(nvm_ls_remote | \grep -e '^v' | cut -c2- | cut -d . -f 1,2 | uniq)
|
|
fi
|
|
local MINOR
|
|
local STABLE
|
|
local UNSTABLE
|
|
local MOD
|
|
|
|
local ZHS_HAS_SHWORDSPLIT_UNSET
|
|
ZHS_HAS_SHWORDSPLIT_UNSET=1
|
|
if nvm_has "setopt"; then
|
|
ZHS_HAS_SHWORDSPLIT_UNSET=$(setopt | \grep shwordsplit > /dev/null ; echo $?)
|
|
setopt shwordsplit
|
|
fi
|
|
for MINOR in $LAST_TWO; do
|
|
MOD=$(expr "$(nvm_normalize_version "$MINOR")" \/ 1000000 \% 2)
|
|
if [ $MOD -eq 0 ]; then
|
|
STABLE="$MINOR"
|
|
elif [ $MOD -eq 1 ]; then
|
|
UNSTABLE="$MINOR"
|
|
fi
|
|
done
|
|
if [ $ZHS_HAS_SHWORDSPLIT_UNSET -eq 1 ] && nvm_has "unsetopt"; then
|
|
unsetopt shwordsplit
|
|
fi
|
|
|
|
if [ "_$2" = "_stable" ]; then
|
|
echo $STABLE
|
|
elif [ "_$2" = "_unstable" ]; then
|
|
echo $UNSTABLE
|
|
fi
|
|
}
|
|
|
|
nvm() {
|
|
if [ $# -lt 1 ]; then
|
|
nvm help
|
|
return
|
|
fi
|
|
|
|
# Try to figure out the os and arch for binary fetching
|
|
local uname
|
|
uname="$(uname -a)"
|
|
local os
|
|
local arch
|
|
arch="$(uname -m)"
|
|
local GREP_OPTIONS
|
|
GREP_OPTIONS=''
|
|
case "$uname" in
|
|
Linux\ *) os=linux ;;
|
|
Darwin\ *) os=darwin ;;
|
|
SunOS\ *) os=sunos ;;
|
|
FreeBSD\ *) os=freebsd ;;
|
|
esac
|
|
case "$uname" in
|
|
*x86_64*) arch=x64 ;;
|
|
*i*86*) arch=x86 ;;
|
|
*armv6l*) arch=arm-pi ;;
|
|
esac
|
|
|
|
# initialize local variables
|
|
local VERSION
|
|
local ADDITIONAL_PARAMETERS
|
|
local ALIAS
|
|
|
|
case $1 in
|
|
"help" )
|
|
echo
|
|
echo "Node Version Manager"
|
|
echo
|
|
echo "Usage:"
|
|
echo " nvm help Show this message"
|
|
echo " nvm --version Print out the latest released version of nvm"
|
|
echo " nvm install [-s] <version> Download and install a <version>, [-s] from source. Uses .nvmrc if available"
|
|
echo " nvm uninstall <version> Uninstall a version"
|
|
echo " nvm use <version> Modify PATH to use <version>. Uses .nvmrc if available"
|
|
echo " nvm run <version> [<args>] Run <version> with <args> as arguments. Uses .nvmrc if available for <version>"
|
|
echo " nvm current Display currently activated version"
|
|
echo " nvm ls List installed versions"
|
|
echo " nvm ls <version> List versions matching a given description"
|
|
echo " nvm ls-remote List remote versions available for install"
|
|
echo " nvm deactivate Undo effects of \`nvm\` on current shell"
|
|
echo " nvm alias [<pattern>] Show all aliases beginning with <pattern>"
|
|
echo " nvm alias <name> <version> Set an alias named <name> pointing to <version>"
|
|
echo " nvm unalias <name> Deletes the alias named <name>"
|
|
echo " nvm reinstall-packages <version> Reinstall global \`npm\` packages contained in <version> to current version"
|
|
echo " nvm unload Unload \`nvm\` from shell"
|
|
echo " nvm which [<version>] Display path to installed node version. Uses .nvmrc if available"
|
|
echo
|
|
echo "Example:"
|
|
echo " nvm install v0.10.32 Install a specific version number"
|
|
echo " nvm use 0.10 Use the latest available 0.10.x release"
|
|
echo " nvm run 0.10.32 app.js Run app.js using node v0.10.32"
|
|
echo " nvm exec 0.10.32 node app.js Run \`node app.js\` with the PATH pointing to node v0.10.32"
|
|
echo " nvm alias default 0.10.32 Set default node version on a shell"
|
|
echo
|
|
echo "Note:"
|
|
echo " to remove, delete, or uninstall nvm - just remove ~/.nvm, ~/.npm, and ~/.bower folders"
|
|
echo
|
|
;;
|
|
|
|
"install" | "i" )
|
|
# initialize local variables
|
|
local binavail
|
|
local t
|
|
local url
|
|
local sum
|
|
local tarball
|
|
local nobinary
|
|
local version_not_provided
|
|
version_not_provided=0
|
|
local provided_version
|
|
|
|
if ! nvm_has "curl" && ! nvm_has "wget"; then
|
|
echo 'nvm needs curl or wget to proceed.' >&2;
|
|
return 1
|
|
fi
|
|
|
|
if [ $# -lt 2 ]; then
|
|
version_not_provided=1
|
|
nvm_rc_version
|
|
if [ -z "$NVM_RC_VERSION" ]; then
|
|
nvm help
|
|
return
|
|
fi
|
|
fi
|
|
|
|
shift
|
|
|
|
nobinary=0
|
|
if [ "$1" = "-s" ]; then
|
|
nobinary=1
|
|
shift
|
|
fi
|
|
|
|
if [ "$os" = "freebsd" ]; then
|
|
nobinary=1
|
|
fi
|
|
|
|
provided_version="$1"
|
|
|
|
if [ -z "$provided_version" ]; then
|
|
if [ $version_not_provided -ne 1 ]; then
|
|
nvm_rc_version
|
|
fi
|
|
provided_version="$NVM_RC_VERSION"
|
|
else
|
|
shift
|
|
fi
|
|
|
|
VERSION="$(nvm_remote_version "$provided_version")"
|
|
ADDITIONAL_PARAMETERS=''
|
|
local PROVIDED_REINSTALL_PACKAGES_FROM
|
|
local REINSTALL_PACKAGES_FROM
|
|
|
|
while [ $# -ne 0 ]
|
|
do
|
|
if [ "_$(echo "$1" | cut -c 1-26)" = "_--reinstall-packages-from=" ]; then
|
|
PROVIDED_REINSTALL_PACKAGES_FROM="$(echo "$1" | cut -c 27-)"
|
|
REINSTALL_PACKAGES_FROM="$(nvm_version "$PROVIDED_REINSTALL_PACKAGES_FROM")"
|
|
elif [ "_$(echo "$1" | cut -c 1-21)" = "_--copy-packages-from=" ]; then
|
|
PROVIDED_REINSTALL_PACKAGES_FROM="$(echo "$1" | cut -c 22-)"
|
|
REINSTALL_PACKAGES_FROM="$(nvm_version "$PROVIDED_REINSTALL_PACKAGES_FROM")"
|
|
else
|
|
ADDITIONAL_PARAMETERS="$ADDITIONAL_PARAMETERS $1"
|
|
fi
|
|
shift
|
|
done
|
|
|
|
if [ "_$(nvm_ensure_version_prefix "$PROVIDED_REINSTALL_PACKAGES_FROM")" = "_$VERSION" ]; then
|
|
echo "You can't reinstall global packages from the same version of node you're installing." >&2
|
|
return 4
|
|
elif [ ! -z "$PROVIDED_REINSTALL_PACKAGES_FROM" ] && [ "_$REINSTALL_PACKAGES_FROM" = "_N/A" ]; then
|
|
echo "If --reinstall-packages-from is provided, it must point to an installed version of node." >&2
|
|
return 5
|
|
fi
|
|
|
|
if [ -d "$(nvm_version_path "$VERSION")" ]; then
|
|
echo "$VERSION is already installed." >&2
|
|
if nvm use "$VERSION" && [ ! -z "$REINSTALL_PACKAGES_FROM" ] && [ "_$REINSTALL_PACKAGES_FROM" != "_N/A" ]; then
|
|
nvm reinstall-packages "$REINSTALL_PACKAGES_FROM"
|
|
fi
|
|
return $?
|
|
fi
|
|
|
|
if [ "$VERSION" = "N/A" ]; then
|
|
echo "Version '$provided_version' not found - try \`nvm ls-remote\` to browse available versions." >&2
|
|
return 3
|
|
fi
|
|
|
|
# skip binary install if no binary option specified.
|
|
if [ $nobinary -ne 1 ]; then
|
|
# shortcut - try the binary if possible.
|
|
if [ -n "$os" ]; then
|
|
if nvm_binary_available "$VERSION"; then
|
|
t="$VERSION-$os-$arch"
|
|
url="$NVM_NODEJS_ORG_MIRROR/$VERSION/node-${t}.tar.gz"
|
|
sum=`nvm_download -L -s $NVM_NODEJS_ORG_MIRROR/$VERSION/SHASUMS.txt -o - | \grep node-${t}.tar.gz | \awk '{print $1}'`
|
|
local tmpdir
|
|
tmpdir="$NVM_DIR/bin/node-${t}"
|
|
local tmptarball
|
|
tmptarball="$tmpdir/node-${t}.tar.gz"
|
|
if (
|
|
mkdir -p "$tmpdir" && \
|
|
nvm_download -L -C - --progress-bar $url -o "$tmptarball" && \
|
|
nvm_checksum "$tmptarball" $sum && \
|
|
tar -xzf "$tmptarball" -C "$tmpdir" --strip-components 1 && \
|
|
rm -f "$tmptarball" && \
|
|
mv "$tmpdir" "$(nvm_version_path "$VERSION")"
|
|
)
|
|
then
|
|
if nvm use "$VERSION" && [ ! -z "$REINSTALL_PACKAGES_FROM" ] && [ "_$REINSTALL_PACKAGES_FROM" != "_N/A" ]; then
|
|
nvm reinstall-packages "$REINSTALL_PACKAGES_FROM"
|
|
fi
|
|
return $?
|
|
else
|
|
echo "Binary download failed, trying source." >&2
|
|
rm -rf "$tmptarball" "$tmpdir"
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if [ -n "$ADDITIONAL_PARAMETERS" ]; then
|
|
echo "Additional options while compiling: $ADDITIONAL_PARAMETERS"
|
|
fi
|
|
|
|
tarball=''
|
|
sum=''
|
|
make='make'
|
|
if [ "$os" = "freebsd" ]; then
|
|
make='gmake'
|
|
MAKE_CXX="CXX=c++"
|
|
fi
|
|
local tmpdir
|
|
tmpdir="$NVM_DIR/src"
|
|
local tmptarball
|
|
tmptarball="$tmpdir/node-$VERSION.tar.gz"
|
|
if [ "`nvm_download -L -s -I "$NVM_NODEJS_ORG_MIRROR/$VERSION/node-$VERSION.tar.gz" -o - 2>&1 | \grep '200 OK'`" != '' ]; then
|
|
tarball="$NVM_NODEJS_ORG_MIRROR/$VERSION/node-$VERSION.tar.gz"
|
|
sum=`nvm_download -L -s $NVM_NODEJS_ORG_MIRROR/$VERSION/SHASUMS.txt -o - | \grep node-$VERSION.tar.gz | \awk '{print $1}'`
|
|
elif [ "`nvm_download -L -s -I "$NVM_NODEJS_ORG_MIRROR/node-$VERSION.tar.gz" -o - | \grep '200 OK'`" != '' ]; then
|
|
tarball="$NVM_NODEJS_ORG_MIRROR/node-$VERSION.tar.gz"
|
|
fi
|
|
if (
|
|
[ -n "$tarball" ] && \
|
|
mkdir -p "$tmpdir" && \
|
|
nvm_download -L --progress-bar $tarball -o "$tmptarball" && \
|
|
nvm_checksum "$tmptarball" $sum && \
|
|
tar -xzf "$tmptarball" -C "$tmpdir" && \
|
|
cd "$tmpdir/node-$VERSION" && \
|
|
./configure --prefix="$(nvm_version_path "$VERSION")" $ADDITIONAL_PARAMETERS && \
|
|
$make $MAKE_CXX && \
|
|
rm -f "$(nvm_version_path "$VERSION")" 2>/dev/null && \
|
|
$make $MAKE_CXX install
|
|
)
|
|
then
|
|
if nvm use "$VERSION" && [ ! -z "$REINSTALL_PACKAGES_FROM" ] && [ "_$REINSTALL_PACKAGES_FROM" != "_N/A" ]; then
|
|
nvm reinstall-packages "$REINSTALL_PACKAGES_FROM"
|
|
fi
|
|
if ! nvm_has "npm" ; then
|
|
echo "Installing npm..."
|
|
if nvm_version_greater 0.2.0 "$VERSION"; then
|
|
echo "npm requires node v0.2.3 or higher" >&2
|
|
elif nvm_version_greater_than_or_equal_to "$VERSION" 0.2.0; then
|
|
if nvm_version_greater 0.2.3 "$VERSION"; then
|
|
echo "npm requires node v0.2.3 or higher" >&2
|
|
else
|
|
nvm_download -L https://npmjs.org/install.sh -o - | clean=yes npm_install=0.2.19 sh
|
|
fi
|
|
else
|
|
nvm_download -L https://npmjs.org/install.sh -o - | clean=yes sh
|
|
fi
|
|
fi
|
|
else
|
|
echo "nvm: install $VERSION failed!" >&2
|
|
return 1
|
|
fi
|
|
|
|
return $?
|
|
;;
|
|
"uninstall" )
|
|
[ $# -ne 2 ] && nvm help && return
|
|
PATTERN=`nvm_ensure_version_prefix $2`
|
|
if [ "$PATTERN" = `nvm_version` ]; then
|
|
echo "nvm: Cannot uninstall currently-active node version, $PATTERN." >&2
|
|
return 1
|
|
fi
|
|
VERSION=`nvm_version $PATTERN`
|
|
if [ ! -d "$(nvm_version_path "$VERSION")" ]; then
|
|
echo "$VERSION version is not installed..." >&2
|
|
return;
|
|
fi
|
|
|
|
t="$VERSION-$os-$arch"
|
|
|
|
# Delete all files related to target version.
|
|
rm -rf "$NVM_DIR/src/node-$VERSION" \
|
|
"$NVM_DIR/src/node-$VERSION.tar.gz" \
|
|
"$NVM_DIR/bin/node-${t}" \
|
|
"$NVM_DIR/bin/node-${t}.tar.gz" \
|
|
"$(nvm_version_path "$VERSION")" 2>/dev/null
|
|
echo "Uninstalled node $VERSION"
|
|
|
|
# Rm any aliases that point to uninstalled version.
|
|
for ALIAS in `\grep -l $VERSION $NVM_DIR/alias/* 2>/dev/null`
|
|
do
|
|
nvm unalias `basename $ALIAS`
|
|
done
|
|
|
|
;;
|
|
"deactivate" )
|
|
local NEWPATH
|
|
NEWPATH="$(nvm_strip_path "$PATH" "/bin")"
|
|
if [ "$PATH" = "$NEWPATH" ]; then
|
|
echo "Could not find $NVM_DIR/*/bin in \$PATH" >&2
|
|
else
|
|
export PATH="$NEWPATH"
|
|
hash -r
|
|
echo "$NVM_DIR/*/bin removed from \$PATH"
|
|
fi
|
|
|
|
NEWPATH="$(nvm_strip_path "$MANPATH" "/share/man")"
|
|
if [ "$MANPATH" = "$NEWPATH" ]; then
|
|
echo "Could not find $NVM_DIR/*/share/man in \$MANPATH" >&2
|
|
else
|
|
export MANPATH="$NEWPATH"
|
|
echo "$NVM_DIR/*/share/man removed from \$MANPATH"
|
|
fi
|
|
|
|
NEWPATH="$(nvm_strip_path "$NODE_PATH" "/lib/node_modules")"
|
|
if [ "$NODE_PATH" != "$NEWPATH" ]; then
|
|
export NODE_PATH="$NEWPATH"
|
|
echo "$NVM_DIR/*/lib/node_modules removed from \$NODE_PATH"
|
|
fi
|
|
;;
|
|
"use" )
|
|
if [ $# -eq 0 ]; then
|
|
nvm help
|
|
return 127
|
|
fi
|
|
if [ $# -eq 1 ]; then
|
|
nvm_rc_version
|
|
if [ -n "$NVM_RC_VERSION" ]; then
|
|
VERSION=`nvm_version $NVM_RC_VERSION`
|
|
fi
|
|
elif [ "_$2" != '_system' ]; then
|
|
VERSION="$(nvm_version "$2")"
|
|
else
|
|
VERSION="$2"
|
|
fi
|
|
if [ -z "$VERSION" ]; then
|
|
nvm help
|
|
return 127
|
|
fi
|
|
|
|
if [ "_$VERSION" = '_system' ]; then
|
|
if nvm_has_system_node && nvm deactivate >/dev/null 2>&1; then
|
|
echo "Now using system version of node: $(node -v 2>/dev/null)."
|
|
return
|
|
else
|
|
echo "System version of node not found." >&2
|
|
return 127
|
|
fi
|
|
elif [ "_$VERSION" = "_∞" ]; then
|
|
echo "The alias \"$2\" leads to an infinite loop. Aborting." >&2
|
|
return 8
|
|
fi
|
|
|
|
local NVM_VERSION_DIR
|
|
NVM_VERSION_DIR="$(nvm_version_path "$VERSION")"
|
|
if [ ! -d "$NVM_VERSION_DIR" ]; then
|
|
echo "$VERSION version is not installed yet" >&2
|
|
return 1
|
|
fi
|
|
# Strip other version from PATH
|
|
PATH=`nvm_strip_path "$PATH" "/bin"`
|
|
# Prepend current version
|
|
PATH=`nvm_prepend_path "$PATH" "$NVM_VERSION_DIR/bin"`
|
|
if nvm_has manpath; then
|
|
if [ -z "$MANPATH" ]; then
|
|
MANPATH=$(manpath)
|
|
fi
|
|
# Strip other version from MANPATH
|
|
MANPATH=`nvm_strip_path "$MANPATH" "/share/man"`
|
|
# Prepend current version
|
|
MANPATH=`nvm_prepend_path "$MANPATH" "$NVM_VERSION_DIR/share/man"`
|
|
export MANPATH
|
|
fi
|
|
export PATH
|
|
hash -r
|
|
export NVM_PATH="$NVM_VERSION_DIR/lib/node"
|
|
export NVM_BIN="$NVM_VERSION_DIR/bin"
|
|
if [ "$NVM_SYMLINK_CURRENT" = true ]; then
|
|
rm -f "$NVM_DIR/current" && ln -s "$NVM_VERSION_DIR" "$NVM_DIR/current"
|
|
fi
|
|
echo "Now using node $VERSION"
|
|
;;
|
|
"run" )
|
|
local provided_version
|
|
local has_checked_nvmrc
|
|
has_checked_nvmrc=0
|
|
# run given version of node
|
|
shift
|
|
if [ $# -lt 1 ]; then
|
|
nvm_rc_version && has_checked_nvmrc=1
|
|
if [ -n "$NVM_RC_VERSION" ]; then
|
|
VERSION=`nvm_version $NVM_RC_VERSION`
|
|
else
|
|
VERSION='N/A'
|
|
fi
|
|
if [ $VERSION = "N/A" ]; then
|
|
nvm help
|
|
return 127
|
|
fi
|
|
fi
|
|
|
|
provided_version=$1
|
|
if [ -n "$provided_version" ]; then
|
|
VERSION=`nvm_version $provided_version`
|
|
if [ "_$VERSION" = "_N/A" ]; then
|
|
provided_version=''
|
|
if [ $has_checked_nvmrc -ne 1 ]; then
|
|
nvm_rc_version && has_checked_nvmrc=1
|
|
fi
|
|
VERSION=`nvm_version $NVM_RC_VERSION`
|
|
else
|
|
shift
|
|
fi
|
|
fi
|
|
|
|
echo "Running node $VERSION"
|
|
local ARGS
|
|
ARGS="$@"
|
|
local OUTPUT
|
|
OUTPUT="$(nvm use "$VERSION" >/dev/null && node "$ARGS")"
|
|
local EXIT_CODE
|
|
EXIT_CODE="$?"
|
|
echo "$OUTPUT"
|
|
return $EXIT_CODE
|
|
;;
|
|
"exec" )
|
|
shift
|
|
|
|
local provided_version
|
|
provided_version="$1"
|
|
if [ -n "$provided_version" ]; then
|
|
VERSION=`nvm_version $provided_version`
|
|
if [ $VERSION = "N/A" ]; then
|
|
provided_version=''
|
|
nvm_rc_version
|
|
VERSION="$(nvm_version "$NVM_RC_VERSION")"
|
|
else
|
|
shift
|
|
fi
|
|
fi
|
|
|
|
local NVM_VERSION_DIR
|
|
NVM_VERSION_DIR=$(nvm_version_path "$VERSION")
|
|
if [ ! -d "$NVM_VERSION_DIR" ]; then
|
|
echo "$VERSION version is not installed yet" >&2
|
|
return 1
|
|
fi
|
|
echo "Running node $VERSION"
|
|
NODE_VERSION=$VERSION $NVM_DIR/nvm-exec "$@"
|
|
;;
|
|
"ls" | "list" )
|
|
local NVM_LS_OUTPUT
|
|
local NVM_LS_EXIT_CODE
|
|
NVM_LS_OUTPUT=$(nvm_ls "$2")
|
|
NVM_LS_EXIT_CODE=$?
|
|
nvm_print_versions "$NVM_LS_OUTPUT"
|
|
if [ $# -eq 1 ]; then
|
|
nvm alias
|
|
fi
|
|
return $NVM_LS_EXIT_CODE
|
|
;;
|
|
"ls-remote" | "list-remote" )
|
|
local NVM_LS_EXIT_CODE
|
|
NVM_LS_OUTPUT=$(nvm_ls_remote "$2")
|
|
NVM_LS_EXIT_CODE=$?
|
|
nvm_print_versions "$NVM_LS_OUTPUT"
|
|
return $NVM_LS_EXIT_CODE
|
|
;;
|
|
"current" )
|
|
nvm_version current
|
|
;;
|
|
"which" )
|
|
if [ $# -eq 1 ]; then
|
|
nvm_rc_version
|
|
if [ -n "$NVM_RC_VERSION" ]; then
|
|
VERSION=$(nvm_version $NVM_RC_VERSION)
|
|
fi
|
|
elif [ "_$2" != '_system' ]; then
|
|
VERSION="$(nvm_version "$2")"
|
|
else
|
|
VERSION="$2"
|
|
fi
|
|
if [ -z "$VERSION" ]; then
|
|
nvm help
|
|
return 127
|
|
fi
|
|
|
|
if [ "_$VERSION" = '_system' ]; then
|
|
if nvm_has_system_node >/dev/null 2>&1; then
|
|
local NVM_BIN
|
|
NVM_BIN="$(nvm use system >/dev/null 2>&1 && which node)"
|
|
if [ -n "$NVM_BIN" ]; then
|
|
echo "$NVM_BIN"
|
|
return
|
|
else
|
|
return 1
|
|
fi
|
|
else
|
|
echo "System version of node not found." >&2
|
|
return 127
|
|
fi
|
|
elif [ "_$VERSION" = "_∞" ]; then
|
|
echo "The alias \"$2\" leads to an infinite loop. Aborting." >&2
|
|
return 8
|
|
fi
|
|
|
|
local NVM_VERSION_DIR
|
|
NVM_VERSION_DIR="$(nvm_version_path "$VERSION")"
|
|
if [ ! -d "$NVM_VERSION_DIR" ]; then
|
|
echo "$VERSION version is not installed yet" >&2
|
|
return 1
|
|
fi
|
|
echo "$NVM_VERSION_DIR/bin/node"
|
|
;;
|
|
"alias" )
|
|
mkdir -p "$NVM_DIR/alias"
|
|
if [ $# -le 2 ]; then
|
|
local DEST
|
|
for ALIAS_PATH in "$NVM_DIR"/alias/"$2"*; do
|
|
ALIAS="$(basename "$ALIAS_PATH")"
|
|
DEST="$(nvm_alias "$ALIAS" 2> /dev/null)"
|
|
if [ -n "$DEST" ]; then
|
|
VERSION="$(nvm_version "$DEST")"
|
|
if [ "_$DEST" = "_$VERSION" ]; then
|
|
echo "$ALIAS -> $DEST"
|
|
else
|
|
echo "$ALIAS -> $DEST (-> $VERSION)"
|
|
fi
|
|
fi
|
|
done
|
|
|
|
for ALIAS in "stable" "unstable"; do
|
|
if [ ! -f "$NVM_DIR/alias/$ALIAS" ]; then
|
|
if [ $# -lt 2 ] || [ "~$ALIAS" = "~$2" ]; then
|
|
DEST="$(nvm_print_implicit_alias local "$ALIAS")"
|
|
if [ "_$DEST" != "_" ]; then
|
|
VERSION="$(nvm_version "$DEST")"
|
|
echo "$ALIAS -> $DEST (-> $VERSION) (default)"
|
|
fi
|
|
fi
|
|
fi
|
|
done
|
|
return
|
|
fi
|
|
if [ -z "$3" ]; then
|
|
rm -f "$NVM_DIR/alias/$2"
|
|
echo "$2 -> *poof*"
|
|
return
|
|
fi
|
|
VERSION="$(nvm_version "$3")"
|
|
if [ $? -ne 0 ]; then
|
|
echo "! WARNING: Version '$3' does not exist." >&2
|
|
fi
|
|
echo $3 > "$NVM_DIR/alias/$2"
|
|
if [ ! "_$3" = "_$VERSION" ]; then
|
|
echo "$2 -> $3 (-> $VERSION)"
|
|
else
|
|
echo "$2 -> $3"
|
|
fi
|
|
;;
|
|
"unalias" )
|
|
mkdir -p $NVM_DIR/alias
|
|
[ $# -ne 2 ] && nvm help && return 127
|
|
[ ! -f "$NVM_DIR/alias/$2" ] && echo "Alias $2 doesn't exist!" >&2 && return
|
|
rm -f $NVM_DIR/alias/$2
|
|
echo "Deleted alias $2"
|
|
;;
|
|
"reinstall-packages" | "copy-packages" )
|
|
if [ $# -ne 2 ]; then
|
|
nvm help
|
|
return 127
|
|
fi
|
|
|
|
local PROVIDED_VERSION
|
|
PROVIDED_VERSION="$2"
|
|
|
|
if [ "$PROVIDED_VERSION" = "$(nvm_ls_current)" ] || [ "$(nvm_version $PROVIDED_VERSION)" = "$(nvm_ls_current)" ]; then
|
|
echo 'Can not reinstall packages from the current version of node.' >&2
|
|
return 2
|
|
fi
|
|
|
|
local INSTALLS
|
|
if [ "$PROVIDED_VERSION" = "system" ]; then
|
|
if ! nvm_has_system_node; then
|
|
echo 'No system version of node detected.' >&2
|
|
return 3
|
|
fi
|
|
INSTALLS=$(nvm deactivate > /dev/null && npm list -g --depth=0 | tail -n +2 | \grep -o -e ' [^@]*' | cut -c 2- | \grep -v npm | xargs)
|
|
else
|
|
local VERSION
|
|
VERSION="$(nvm_version "$PROVIDED_VERSION")"
|
|
INSTALLS=$(nvm use "$VERSION" > /dev/null && npm list -g --depth=0 | tail -n +2 | \grep -o -e ' [^@]*' | cut -c 2- | \grep -v npm | xargs)
|
|
fi
|
|
|
|
echo "Copying global packages from $VERSION..."
|
|
echo "$INSTALLS" | xargs npm install -g --quiet
|
|
;;
|
|
"clear-cache" )
|
|
rm -f $NVM_DIR/v* "$(nvm_version_dir)" 2>/dev/null
|
|
echo "Cache cleared."
|
|
;;
|
|
"version" )
|
|
nvm_version $2
|
|
;;
|
|
"--version" )
|
|
echo "0.22.0"
|
|
;;
|
|
"unload" )
|
|
unset -f nvm nvm_print_versions nvm_checksum nvm_ls_remote nvm_ls nvm_remote_version nvm_version nvm_rc_version nvm_version_greater nvm_version_greater_than_or_equal_to nvm_supports_source_options > /dev/null 2>&1
|
|
unset RC_VERSION NVM_NODEJS_ORG_MIRROR NVM_DIR NVM_CD_FLAGS > /dev/null 2>&1
|
|
;;
|
|
* )
|
|
nvm help
|
|
;;
|
|
esac
|
|
}
|
|
|
|
nvm_supports_source_options() {
|
|
[ "_$(echo 'echo $1' | . /dev/stdin yes)" = "_yes" ]
|
|
}
|
|
|
|
if nvm_supports_source_options && [ "_$1" = "_--install" ]; then
|
|
VERSION="$(nvm_alias default 2>/dev/null)"
|
|
if [ -n "$VERSION" ]; then
|
|
nvm install "$VERSION" >/dev/null
|
|
elif nvm_rc_version >/dev/null 2>&1; then
|
|
nvm install >/dev/null
|
|
fi
|
|
elif nvm ls default >/dev/null; then
|
|
nvm use default >/dev/null
|
|
elif nvm_rc_version >/dev/null 2>&1; then
|
|
nvm use >/dev/null
|
|
fi
|
|
|