Merge remote-tracking branch 'origin/versions'

README.md

@@ -29,6 +29,24 @@ Example usage:
 
 The buildpack will detect your app as Node.js if it has the file `package.json` in the root.  It will use NPM to install your dependencies, and vendors a version of the Node.js runtime into your slug.  The `node_modules` directory will be cached between builds to allow for faster NPM install time.
 
+Node.js and npm versions
+------------------------
+
+You can specify the versions of Node.js and npm your application requires using `package.json`
+
+    {
+      "name": "myapp",
+      "engines": {
+        "node": ">=0.4.7 <0.7.0",
+        "npm": ">=1.0.0"
+      }
+    }
+
+To list the available versions of Node.js and npm, see these manifests:
+
+http://heroku-buildpack-nodejs.s3.amazonaws.com/manifest.nodejs
+http://heroku-buildpack-nodejs.s3.amazonaws.com/manifest.npm
+
 Hacking
 -------
 
@@ -36,20 +54,19 @@ To use this buildpack, fork it on Github.  Push up changes to your fork, then cr
 
 To change the vendored binaries for Node.js, NPM, and SCons, use the helper scripts in the `support/` subdirectory.  You'll need an S3-enabled AWS account and a bucket to store your binaries in.
 
-For example, you can change the vendored version of Node.js to v0.5.8.
+For example, you can change the default version of Node.js to v0.6.7.
 
 First you'll need to build a Heroku-compatible version of Node.js:
 
     $ export AWS_ID=xxx AWS_SECRET=yyy S3_BUCKET=zzz
     $ s3 create $S3_BUCKET
-    $ support/package_node 0.5.8
+    $ support/package_nodejs 0.6.7
 
 Open `bin/compile` in your editor, and change the following lines:
 
-    NODE_VERSION="0.5.8"
-
+    DEFAULT_NODE_VERSION="0.6.7"
     S3_BUCKET=zzz
 
 Commit and push the changes to your buildpack to your Github fork, then push your sample app to Heroku to test.  You should see:
 
-    -----> Vendoring node 0.5.8
+    -----> Vendoring node 0.6.7

bin/compile

 #!/usr/bin/env bash
 # bin/compile <build-dir> <cache-dir>
 
-mktmpdir() {
+# fail fast
+set -e
+
+# debug
+# set -x
+
+# clean up leaking environment
+unset GIT_DIR
+
+# config
+SCONS_VERSION="1.2.0"
+S3_BUCKET="heroku-buildpack-nodejs"
+
+# parse and derive params
+BUILD_DIR=$1
+CACHE_DIR=$2
+LP_DIR=`cd $(dirname $0); cd ..; pwd`
+CACHE_STORE_DIR="$CACHE_DIR/node_modules/$NPM_VERSION"
+CACHE_TARGET_DIR="$BUILD_DIR/node_modules"
+
+function error() {
+  echo " !     $*"
+  exit 1
+}
+
+function mktmpdir() {
   dir=$(mktemp -t node-$1-XXXX)
   rm -rf $dir
   mkdir -p $dir
@@ -16,8 +41,10 @@ function indent() {
   esac
 }
 
-run_npm() {
+function run_npm() {
   command="$1"
+
+  cd $BUILD_DIR
   HOME="$BUILD_DIR" $VENDORED_NODE/bin/node $VENDORED_NPM/cli.js $command 2>&1 | indent
 
   if [ "${PIPESTATUS[*]}" != "0 0" ]; then
@@ -26,21 +53,76 @@ run_npm() {
   fi
 }
 
-# clean up leaking environment
-unset GIT_DIR
+function manifest_versions() {
+  curl "http://${S3_BUCKET}.s3.amazonaws.com/manifest.${1}" -s -o - | tr -s '\n' ' '
+}
 
-# config
-NODE_VERSION="0.4.7"
-NPM_VERSION="1.0.94"
-SCONS_VERSION="1.2.0"
-S3_BUCKET="heroku-buildpack-nodejs"
+function resolve_version() {
+  available_versions="$1"
+  requested_version="$2"
+  default_version="$3"
+
+  if [ "$2" == "" ]; then
+    echo $3
+  else
+    args=""
+    for version in $available_versions; do args="${args} -v \"${version}\""; done
+    for version in $requested_version; do args="${args} -r \"${version}\""; done
+    eval $bootstrap_node/bin/node $LP_DIR/vendor/node-semver/bin/semver ${args} | tail -n1
+  fi
+}
 
-# parse and derive params
-BUILD_DIR=$1
-CACHE_DIR=$2
-LP_DIR=`cd $(dirname $0); cd ..; pwd`
-CACHE_STORE_DIR="$CACHE_DIR/node_modules/$NPM_VERSION"
-CACHE_TARGET_DIR="$BUILD_DIR/node_modules"
+function package_engine_version() {
+  version=$(cat $BUILD_DIR/package.json | $bootstrap_node/bin/node $LP_DIR/vendor/json/json engines.$1 2>/dev/null)
+  if [ $? == 0 ]; then
+    echo $version
+  fi
+}
+
+function package_resolve_version() {
+  engine="$1"
+  resolved_version=$(resolve_version "${engine_versions[$engine]}" "${engine_requests[$engine]}" "${engine_defaults[$engine]}")
+
+  if [ "${resolved_version}" == "" ]; then
+    error "Requested engine $engine version ${engine_requests[$engine]} does not match available versions: ${engine_versions[$engine]}"
+  else
+    echo $resolved_version
+  fi
+}
+
+function package_download() {
+  engine="$1"
+  version="$2"
+  location="$3"
+
+  mkdir -p $location
+  package="http://${S3_BUCKET}.s3.amazonaws.com/$engine-$version.tgz"
+  curl $package -s -o - | tar xzf - -C $location
+}
+
+bootstrap_node=$(mktmpdir bootstrap_node)
+package_download "nodejs" "0.4.7" $bootstrap_node
+
+# make some associative arrays
+declare -A engine_versions
+declare -A engine_defaults
+declare -A engine_requests
+
+engine_defaults["node"]="0.4.7"
+engine_defaults["npm"]="1.0.94"
+
+engine_versions["node"]=$(manifest_versions "nodejs")
+engine_requests["node"]=$(package_engine_version "node")
+
+engine_versions["npm"]=$(manifest_versions "npm")
+engine_requests["npm"]=$(package_engine_version "npm")
+
+echo "-----> Resolving engine versions"
+NODE_VERSION=$(package_resolve_version "node")
+echo "Using Node.js version: ${NODE_VERSION}" | indent
+
+NPM_VERSION=$(package_resolve_version "npm")
+echo "Using npm version: ${NPM_VERSION}" | indent
 
 # s3 packages
 NODE_PACKAGE="http://${S3_BUCKET}.s3.amazonaws.com/nodejs-${NODE_VERSION}.tgz"
@@ -54,13 +136,13 @@ VENDORED_SCONS="$(mktmpdir scons)"
 
 # download and unpack packages
 echo "-----> Fetching Node.js binaries"
-mkdir -p $VENDORED_NODE  && curl $NODE_PACKAGE -s -o -  | tar xzf - -C $VENDORED_NODE
-mkdir -p $VENDORED_NPM   && curl $NPM_PACKAGE -s -o -   | tar xzf - -C $VENDORED_NPM
-mkdir -p $VENDORED_SCONS && curl $SCONS_PACKAGE -s -o - | tar xzf - -C $VENDORED_SCONS
+package_download "nodejs" "${NODE_VERSION}" "${VENDORED_NODE}"
+package_download "npm" "${NPM_VERSION}" "${VENDORED_NPM}"
+package_download "scons" "${SCONS_VERSION}" "${VENDORED_SCONS}"
 
 # vendor node into the slug
 PATH="$BUILD_DIR/bin:$PATH"
-echo "-----> Vendoring node $NODE_VERSION"
+echo "-----> Vendoring node into slug"
 mkdir -p "$BUILD_DIR/bin"
 cp "$VENDORED_NODE/bin/node" "$BUILD_DIR/bin/node"
 
@@ -93,12 +175,9 @@ if [ -d $CACHE_STORE_DIR ]; then
 fi
 
 # install dependencies with npm
-echo "-----> Installing dependencies with npm $NPM_VERSION"
-
-cd $BUILD_DIR
-run_npm install
-run_npm rebuild
-
+echo "-----> Installing dependencies with npm"
+run_npm "install"
+run_npm "rebuild"
 echo "Dependencies installed" | indent
 
 # repack cache with new assets

support/aws/s3

@@ -117,14 +117,17 @@ s3_curl() {
   # $2 = remote bucket.
   # $3 = remote name
   # $4 = local name.
+  # $5 = mime type
   local bucket remote date sig md5 arg inout headers
   # header handling is kinda fugly, but it works.
   bucket="${2:+/${2}}/" # slashify the bucket
   remote="$(urlenc "${3}")" # if you don't, strange things may happen.
   stdopts="--connect-timeout 10 --fail --silent"
+	mime="${5}"
   [[ $CURL_S3_DEBUG == true ]] && stdopts="${stdopts} --show-error --fail"
   case "${1}" in
    GET) arg="-o" inout="${4:--}" # stdout if no $4
+	  headers[${#headers[@]}]="x-amz-acl: public-read"
 	;;
    PUT) [[ ${2} ]] || die "PUT can has bucket?"
         if [[ ! ${3} ]]; then
@@ -135,6 +138,9 @@ s3_curl() {
 	  arg="-T" inout="${4}"
 	  headers[${#headers[@]}]="x-amz-acl: public-read"
 	  headers[${#headers[@]}]="Expect: 100-continue"
+		if [ "$mime" != "" ]; then
+		  headers[${#headers[@]}]="Content-Type: $mime"
+		fi
 	else
 	  die "Cannot write non-existing file ${4}"
         fi
@@ -145,7 +151,7 @@ s3_curl() {
    *) die "Unknown verb ${1}.  It probably would not have worked anyways." ;;
   esac
   date="$(TZ=UTC date '+%a, %e %b %Y %H:%M:%S %z')"
-  sig=$(s3_signature_string ${1} "${date}" "${bucket}" "${remote}" "${md5}" "" "x-amz-acl:public-read")
+  sig=$(s3_signature_string ${1} "${date}" "${bucket}" "${remote}" "${md5}" "${mime}" "x-amz-acl:public-read")
 
   headers[${#headers[@]}]="Authorization: AWS ${AWS_ID}:${sig}"
   headers[${#headers[@]}]="Date: ${date}"
@@ -159,7 +165,8 @@ s3_put() {
   # $1 = remote bucket to put it into
   # $2 = remote name to put
   # $3 = file to put.  This must be present if $2 is.
-  s3_curl PUT "${1}" "${2}" "${3:-${2}}"
+  # $4 = mime type
+  s3_curl PUT "${1}" "${2}" "${3:-${2}}" "${4}"
   return $?
 }
 

support/manifest

+#!/bin/sh
+
+set -e
+
+manifest_type="$1"
+
+if [ "$manifest_type" == "" ]; then
+  echo "usage: $0 <nodejs|npm>"
+  exit 1
+fi
+
+if [ "$AWS_ID" == "" ]; then
+  echo "must set AWS_ID"
+  exit 1
+fi
+
+if [ "$AWS_SECRET" == "" ]; then
+  echo "must set AWS_SECRET"
+  exit 1
+fi
+
+if [ "$S3_BUCKET" == "" ]; then
+  echo "must set S3_BUCKET"
+  exit 1
+fi
+
+basedir="$( cd -P "$( dirname "$0" )" && pwd )"
+
+# make a temp directory
+tempdir="$( mktemp -t node_XXXX )"
+rm -rf $tempdir
+mkdir -p $tempdir
+pushd $tempdir
+
+# generate manifest
+$basedir/aws/s3 ls $S3_BUCKET \
+  | grep "^${manifest_type}"  \
+  | sed -e "s/${manifest_type}-\([0-9.]*\)\\.tgz/\\1/" \
+  | awk 'BEGIN {FS="."} {printf("%03d.%03d.%03d %s\n",$1,$2,$3,$0)}' | sort -r | cut -d" " -f2 \
+  > manifest.${manifest_type}
+
+# upload manifest to s3
+$basedir/aws/s3 put $S3_BUCKET \
+  manifest.${manifest_type} "" "text/plain"

support/package_node → support/package_nodejs

@@ -30,14 +30,14 @@ basedir="$( cd -P "$( dirname "$0" )" && pwd )"
 tempdir="$( mktemp -t node_XXXX )"
 rm -rf $tempdir
 mkdir -p $tempdir
-pushd $tempdir
+cd $tempdir
 
 # download and extract node
-curl http://nodejs.org/dist/node-v${node_version}.tar.gz -o node.tgz
+curl http://nodejs.org/dist/v${node_version}/node-v${node_version}.tar.gz -o node.tgz
 tar xzvf node.tgz
 
 # go into node dir
-pushd node-v${node_version}
+cd node-v${node_version}
 
 # build and package nodejs for heroku
 vulcan build -v -o $tempdir/node-${node_version}.tgz
@@ -47,7 +47,7 @@ $basedir/aws/s3 put $S3_BUCKET \
   nodejs-${node_version}.tgz $tempdir/node-${node_version}.tgz
 
 # go into scons
-pushd tools/scons
+cd tools/scons
 
 # package scons
 scons_version=$(ls | grep "scons-local" | cut -d- -f3)
@@ -56,3 +56,6 @@ tar czvf $tempdir/scons-${scons_version}.tgz *
 # upload scons to s3
 $basedir/aws/s3 put $S3_BUCKET \
   scons-${scons_version}.tgz $tempdir/scons-${scons_version}.tgz
+
+# generate manifest
+$basedir/manifest nodejs

support/package_npm

@@ -48,3 +48,6 @@ tar czvf $tempdir/npm-${npm_version}.tgz *
 # upload npm to s3
 $basedir/aws/s3 put $S3_BUCKET \
   npm-${npm_version}.tgz $tempdir/npm-${npm_version}.tgz
+
+# generate manifest
+$basedir/manifest npm

vendor/README

+json: https://github.com/trentm/json
+node-semver: http://github.com/isaacs/node-semver

vendor/node-semver/LICENSE

+Copyright 2009, 2010, 2011 Isaac Z. Schlueter.
+All rights reserved.
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

vendor/node-semver/README.md

+semver(1) -- The semantic versioner for npm
+===========================================
+
+## Usage
+
+    $ npm install semver
+
+    semver.valid('1.2.3') // true
+    semver.valid('a.b.c') // false
+    semver.clean('  =v1.2.3   ') // '1.2.3'
+    semver.satisfies('1.2.3', '1.x || >=2.5.0 || 5.0.0 - 7.2.3') // true
+    semver.gt('1.2.3', '9.8.7') // false
+    semver.lt('1.2.3', '9.8.7') // true
+
+As a command-line utility:
+
+    $ semver -h
+
+    Usage: semver -v <version> [-r <range>]
+    Test if version(s) satisfy the supplied range(s),
+    and sort them.
+
+    Multiple versions or ranges may be supplied.
+
+    Program exits successfully if any valid version satisfies
+    all supplied ranges, and prints all satisfying versions.
+
+    If no versions are valid, or ranges are not satisfied,
+    then exits failure.
+
+    Versions are printed in ascending order, so supplying
+    multiple versions to the utility will just sort them.
+
+## Versions
+
+A version is the following things, in this order:
+
+* a number (Major)
+* a period
+* a number (minor)
+* a period
+* a number (patch)
+* OPTIONAL: a hyphen, followed by a number (build)
+* OPTIONAL: a collection of pretty much any non-whitespace characters
+  (tag)
+
+A leading `"="` or `"v"` character is stripped off and ignored.
+
+## Comparisons
+
+The ordering of versions is done using the following algorithm, given
+two versions and asked to find the greater of the two:
+
+* If the majors are numerically different, then take the one
+  with a bigger major number. `2.3.4 > 1.3.4`
+* If the minors are numerically different, then take the one
+  with the bigger minor number. `2.3.4 > 2.2.4`
+* If the patches are numerically different, then take the one with the
+  bigger patch number. `2.3.4 > 2.3.3`
+* If only one of them has a build number, then take the one with the
+  build number.  `2.3.4-0 > 2.3.4`
+* If they both have build numbers, and the build numbers are numerically
+  different, then take the one with the bigger build number.
+  `2.3.4-10 > 2.3.4-9`
+* If only one of them has a tag, then take the one without the tag.
+  `2.3.4 > 2.3.4-beta`
+* If they both have tags, then take the one with the lexicographically
+  larger tag.  `2.3.4-beta > 2.3.4-alpha`
+* At this point, they're equal.
+
+## Ranges
+
+The following range styles are supported:
+
+* `>1.2.3` Greater than a specific version.
+* `<1.2.3` Less than
+* `1.2.3 - 2.3.4` := `>=1.2.3 <=2.3.4`
+* `~1.2.3` := `>=1.2.3 <1.3.0`
+* `~1.2` := `>=1.2.0 <2.0.0`
+* `~1` := `>=1.0.0 <2.0.0`
+* `1.2.x` := `>=1.2.0 <1.3.0`
+* `1.x` := `>=1.0.0 <2.0.0`
+
+Ranges can be joined with either a space (which implies "and") or a
+`||` (which implies "or").
+
+## Functions
+
+* valid(v): Return the parsed version, or null if it's not valid.
+* inc(v, release): Return the version incremented by the release type
+  (major, minor, patch, or build), or null if it's not valid.
+
+### Comparison
+
+* gt(v1, v2): `v1 > v2`
+* gte(v1, v2): `v1 >= v2`
+* lt(v1, v2): `v1 < v2`
+* lte(v1, v2): `v1 <= v2`
+* eq(v1, v2): `v1 == v2` This is true if they're logically equivalent,
+  even if they're not the exact same string.  You already know how to
+  compare strings.
+* neq(v1, v2): `v1 != v2` The opposite of eq.
+* cmp(v1, comparator, v2): Pass in a comparison string, and it'll call
+  the corresponding function above.  `"==="` and `"!=="` do simple
+  string comparison, but are included for completeness.  Throws if an
+  invalid comparison string is provided.
+* compare(v1, v2): Return 0 if v1 == v2, or 1 if v1 is greater, or -1 if
+  v2 is greater.  Sorts in ascending order if passed to Array.sort().
+* rcompare(v1, v2): The reverse of compare.  Sorts an array of versions
+  in descending order when passed to Array.sort().
+
+
+### Ranges
+
+* validRange(range): Return the valid range or null if it's not valid
+* satisfies(version, range): Return true if the version satisfies the
+  range.
+* maxSatisfying(versions, range): Return the highest version in the list
+  that satisfies the range, or null if none of them do.

vendor/node-semver/bin/semver

+#!/usr/bin/env node
+// Standalone semver comparison program.
+// Exits successfully and prints matching version(s) if
+// any supplied version is valid and passes all tests.
+
+var argv = process.argv.slice(2)
+  , versions = []
+  , range = []
+  , gt = []
+  , lt = []
+  , eq = []
+  , semver = require("../semver")
+
+main()
+
+function main () {
+  if (!argv.length) return help()
+  while (argv.length) {
+    var a
+    switch (a = argv.shift()) {
+      case "-v": case "--version":
+        versions.push(argv.shift())
+        break
+      case "-r": case "--range":
+        range.push(argv.shift())
+        break
+      case "-h": case "--help": case "-?":
+        return help()
+      default:
+        versions.push(a)
+        break
+    }
+  }
+
+  versions = versions.filter(semver.valid)
+  for (var i = 0, l = range.length; i < l ; i ++) {
+    versions = versions.filter(function (v) {
+      return semver.satisfies(v, range[i])
+    })
+    if (!versions.length) return fail()
+  }
+  return success(versions)
+}
+
+function fail () { process.exit(1) }
+
+function success () {
+  versions.sort(semver.compare)
+    .map(semver.clean)
+    .forEach(function (v,i,_) { console.log(v) })
+}
+
+function help () {
+  console.log(["Usage: semver -v <version> [-r <range>]"
+              ,"Test if version(s) satisfy the supplied range(s),"
+              ,"and sort them."
+              ,""
+              ,"Multiple versions or ranges may be supplied."
+              ,""
+              ,"Program exits successfully if any valid version satisfies"
+              ,"all supplied ranges, and prints all satisfying versions."
+              ,""
+              ,"If no versions are valid, or ranges are not satisfied,"
+              ,"then exits failure."
+              ,""
+              ,"Versions are printed in ascending order, so supplying"
+              ,"multiple versions to the utility will just sort them."
+              ].join("\n"))
+}
+
+

vendor/node-semver/package.json

+{ "name" : "semver"
+, "version" : "1.0.12"
+, "description" : "The semantic version parser used by npm."
+, "main" : "semver.js"
+, "scripts" : { "test" : "tap test.js" }
+, "devDependencies": { "tap" : "0.x >=0.0.4" }
+, "license" :
+  { "type" : "MIT"
+  , "url" : "https://github.com/isaacs/semver/raw/master/LICENSE" }
+, "repository" : "git://github.com/isaacs/node-semver.git"
+, "bin" : { "semver" : "./bin/semver" } }

vendor/node-semver/semver.js

+;(function (exports) { // nothing in here is node-specific.
+
+// See http://semver.org/
+// This implementation is a *hair* less strict in that it allows
+// v1.2.3 things, and also tags that don't begin with a char.
+
+var semver = "\\s*[v=]*\\s*([0-9]+)"                // major
+           + "\\.([0-9]+)"                  // minor
+           + "\\.([0-9]+)"                  // patch
+           + "(-[0-9]+-?)?"                 // build
+           + "([a-zA-Z-][a-zA-Z0-9-\.:]*)?" // tag
+  , exprComparator = "^((<|>)?=?)\s*("+semver+")$|^$"
+  , xRangePlain = "[v=]*([0-9]+|x|X|\\*)"
+                + "(?:\\.([0-9]+|x|X|\\*)"
+                + "(?:\\.([0-9]+|x|X|\\*)"
+                + "([a-zA-Z-][a-zA-Z0-9-\.:]*)?)?)?"
+  , xRange = "((?:<|>)?=?)?\\s*" + xRangePlain
+  , exprSpermy = "(?:~>?)"+xRange
+  , expressions = exports.expressions =
+    { parse : new RegExp("^\\s*"+semver+"\\s*$")
+    , parsePackage : new RegExp("^\\s*([^\/]+)[-@](" +semver+")\\s*$")
+    , parseRange : new RegExp(
+        "^\\s*(" + semver + ")\\s+-\\s+(" + semver + ")\\s*$")
+    , validComparator : new RegExp("^"+exprComparator+"$")
+    , parseXRange : new RegExp("^"+xRange+"$")
+    , parseSpermy : new RegExp("^"+exprSpermy+"$")
+    }
+
+
+Object.getOwnPropertyNames(expressions).forEach(function (i) {
+  exports[i] = function (str) {
+    return ("" + (str || "")).match(expressions[i])
+  }
+})
+
+exports.rangeReplace = ">=$1 <=$7"
+exports.clean = clean
+exports.compare = compare
+exports.satisfies = satisfies
+exports.gt = gt
+exports.gte = gte
+exports.lt = lt
+exports.lte = lte
+exports.eq = eq
+exports.neq = neq
+exports.cmp = cmp
+exports.inc = inc
+
+exports.valid = valid
+exports.validPackage = validPackage
+exports.validRange = validRange
+exports.maxSatisfying = maxSatisfying
+
+exports.replaceStars = replaceStars
+exports.toComparators = toComparators
+
+function stringify (version) {
+  var v = version
+  return [v[1]||'', v[2]||'', v[3]||''].join(".") + (v[4]||'') + (v[5]||'')
+}
+
+function clean (version) {
+  version = exports.parse(version)
+  if (!version) return version
+  return stringify(version)
+}
+
+function valid (version) {
+  if (typeof version !== "string") return null
+  return exports.parse(version) && version.trim().replace(/^[v=]+/, '')
+}
+
+function validPackage (version) {
+  if (typeof version !== "string") return null
+  return version.match(expressions.parsePackage) && version.trim()
+}
+
+// range can be one of:
+// "1.0.3 - 2.0.0" range, inclusive, like ">=1.0.3 <=2.0.0"
+// ">1.0.2" like 1.0.3 - 9999.9999.9999
+// ">=1.0.2" like 1.0.2 - 9999.9999.9999
+// "<2.0.0" like 0.0.0 - 1.9999.9999
+// ">1.0.2 <2.0.0" like 1.0.3 - 1.9999.9999
+var starExpression = /(<|>)?=?\s*\*/g
+  , starReplace = ""
+  , compTrimExpression = new RegExp("((<|>)?=?)\\s*("
+                                    +semver+"|"+xRangePlain+")", "g")
+  , compTrimReplace = "$1$3"
+
+function toComparators (range) {
+  var ret = (range || "").trim()
+    .replace(expressions.parseRange, exports.rangeReplace)
+    .replace(compTrimExpression, compTrimReplace)
+    .split(/\s+/)
+    .join(" ")
+    .split("||")
+    .map(function (orchunk) {
+      return orchunk
+        .split(" ")
+        .map(replaceXRanges)
+        .map(replaceSpermies)
+        .map(replaceStars)
+        .join(" ").trim()
+    })
+    .map(function (orchunk) {
+      return orchunk
+        .trim()
+        .split(/\s+/)
+        .filter(function (c) { return c.match(expressions.validComparator) })
+    })
+    .filter(function (c) { return c.length })
+  return ret
+}
+
+function replaceStars (stars) {
+  return stars.trim().replace(starExpression, starReplace)
+}
+
+// "2.x","2.x.x" --> ">=2.0.0- <2.1.0-"
+// "2.3.x" --> ">=2.3.0- <2.4.0-"
+function replaceXRanges (ranges) {
+  return ranges.split(/\s+/)
+               .map(replaceXRange)
+               .join(" ")
+}
+
+function replaceXRange (version) {
+  return version.trim().replace(expressions.parseXRange,
+                                function (v, gtlt, M, m, p, t) {
+    var anyX = !M || M.toLowerCase() === "x" || M === "*"
+               || !m || m.toLowerCase() === "x" || m === "*"
+               || !p || p.toLowerCase() === "x" || p === "*"
+      , ret = v
+
+    if (gtlt && anyX) {
+      // just replace x'es with zeroes
+      ;(!M || M === "*" || M.toLowerCase() === "x") && (M = 0)
+      ;(!m || m === "*" || m.toLowerCase() === "x") && (m = 0)
+      ;(!p || p === "*" || p.toLowerCase() === "x") && (p = 0)
+      ret = gtlt + M+"."+m+"."+p+"-"
+    } else if (!M || M === "*" || M.toLowerCase() === "x") {
+      ret = "*" // allow any
+    } else if (!m || m === "*" || m.toLowerCase() === "x") {
+      // append "-" onto the version, otherwise
+      // "1.x.x" matches "2.0.0beta", since the tag
+      // *lowers* the version value
+      ret = ">="+M+".0.0- <"+(+M+1)+".0.0-"
+    } else if (!p || p === "*" || p.toLowerCase() === "x") {
+      ret = ">="+M+"."+m+".0- <"+M+"."+(+m+1)+".0-"
+    }
+    //console.error("parseXRange", [].slice.call(arguments), ret)
+    return ret
+  })
+}
+
+// ~, ~> --> * (any, kinda silly)
+// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0
+// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0
+// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0
+// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0
+// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0
+function replaceSpermies (version) {
+  return version.trim().replace(expressions.parseSpermy,
+                                function (v, gtlt, M, m, p, t) {
+    if (gtlt) throw new Error(
+      "Using '"+gtlt+"' with ~ makes no sense. Don't do it.")
+
+    if (!M || M.toLowerCase() === "x") {
+      return ""
+    }
+    // ~1 == >=1.0.0- <2.0.0-
+    if (!m || m.toLowerCase() === "x") {
+      return ">="+M+".0.0- <"+(+M+1)+".0.0-"
+    }
+    // ~1.2 == >=1.2.0- <1.3.0-
+    if (!p || p.toLowerCase() === "x") {
+      return ">="+M+"."+m+".0- <"+M+"."+(+m+1)+".0-"
+    }
+    // ~1.2.3 == >=1.2.3- <1.3.0-
+    t = t || "-"
+    return ">="+M+"."+m+"."+p+t+" <"+M+"."+(+m+1)+".0-"
+  })
+}
+
+function validRange (range) {
+  range = replaceStars(range)
+  var c = toComparators(range)
+  return (c.length === 0)
+       ? null
+       : c.map(function (c) { return c.join(" ") }).join("||")
+}
+
+// returns the highest satisfying version in the list, or undefined
+function maxSatisfying (versions, range) {
+  return versions
+    .filter(function (v) { return satisfies(v, range) })
+    .sort(compare)
+    .pop()
+}
+function satisfies (version, range) {
+  version = valid(version)
+  if (!version) return false
+  range = toComparators(range)
+  for (var i = 0, l = range.length ; i < l ; i ++) {
+    var ok = false
+    for (var j = 0, ll = range[i].length ; j < ll ; j ++) {
+      var r = range[i][j]
+        , gtlt = r.charAt(0) === ">" ? gt
+               : r.charAt(0) === "<" ? lt
+               : false
+        , eq = r.charAt(!!gtlt) === "="
+        , sub = (!!eq) + (!!gtlt)
+      if (!gtlt) eq = true
+      r = r.substr(sub)
+      r = (r === "") ? r : valid(r)
+      ok = (r === "") || (eq && r === version) || (gtlt && gtlt(version, r))
+      if (!ok) break
+    }
+    if (ok) return true
+  }
+  return false
+}
+
+// return v1 > v2 ? 1 : -1
+function compare (v1, v2) {
+  var g = gt(v1, v2)
+  return g === null ? 0 : g ? 1 : -1
+}
+
+function rcompare (v1, v2) {
+  return compare(v2, v1)
+}
+
+function lt (v1, v2) { return gt(v2, v1) }
+function gte (v1, v2) { return !lt(v1, v2) }
+function lte (v1, v2) { return !gt(v1, v2) }
+function eq (v1, v2) { return gt(v1, v2) === null }
+function neq (v1, v2) { return gt(v1, v2) !== null }
+function cmp (v1, c, v2) {
+  switch (c) {
+    case ">": return gt(v1, v2)
+    case "<": return lt(v1, v2)
+    case ">=": return gte(v1, v2)
+    case "<=": return lte(v1, v2)
+    case "==": return eq(v1, v2)
+    case "!=": return neq(v1, v2)
+    case "===": return v1 === v2
+    case "!==": return v1 !== v2
+    default: throw new Error("Y U NO USE VALID COMPARATOR!? "+c)
+  }
+}
+
+// return v1 > v2
+function num (v) {
+  return v === undefined ? -1 : parseInt((v||"0").replace(/[^0-9]+/g, ''), 10)
+}
+function gt (v1, v2) {
+  v1 = exports.parse(v1)
+  v2 = exports.parse(v2)
+  if (!v1 || !v2) return false
+
+  for (var i = 1; i < 5; i ++) {
+    v1[i] = num(v1[i])
+    v2[i] = num(v2[i])
+    if (v1[i] > v2[i]) return true
+    else if (v1[i] !== v2[i]) return false
+  }
+  // no tag is > than any tag, or use lexicographical order.
+  var tag1 = v1[5] || ""
+    , tag2 = v2[5] || ""
+
+  // kludge: null means they were equal.  falsey, and detectable.
+  // embarrassingly overclever, though, I know.
+  return tag1 === tag2 ? null
+         : !tag1 ? true
+         : !tag2 ? false
+         : tag1 > tag2
+}
+
+function inc (version, release) {
+  version = exports.parse(version)
+  if (!version) return null
+
+  var parsedIndexLookup =
+    { 'major': 1
+    , 'minor': 2
+    , 'patch': 3
+    , 'build': 4 }
+  var incIndex = parsedIndexLookup[release]
+  if (incIndex === undefined) return null
+
+  var current = num(version[incIndex])
+  version[incIndex] = current === -1 ? 1 : current + 1
+
+  for (var i = incIndex + 1; i < 5; i ++) {
+    if (num(version[i]) !== -1) version[i] = "0"
+  }
+
+  if (version[4]) version[4] = "-" + version[4]
+  version[5] = ""
+
+  return stringify(version)
+}
+})(typeof exports === "object" ? exports : semver = {})