test

#!/usr/bin/env node

var spawn = require('child_process').spawn
var fs    = require('fs')
var path  = require('path')


var NVM_DIR        = path.join(process.env.HOME, '.nvm')
var PROJECT_PATH   = path.resolve(__dirname, '..')
var PACKAGE_PATH   = path.join(PROJECT_PATH, 'package.json')
var TESTS_PATH     = path.join(PROJECT_PATH, 'test')
var VOWS_PATH      = path.join(PROJECT_PATH, 'node_modules', '.bin', 'vows')
var NVM_PROXY_PATH = path.join(PROJECT_PATH, 'scripts', 'nvm-proxy')

try {
  if (!fs.statSync(NVM_DIR).isDirectory()) {
    throw false
  }
} catch(err) {
  throw 'This script expects that you have nvm installed to ' + NVM_DIR
}


function spawnWithNvm(commands) {
  // Ensure a clean environment so that we don't confuse nvm & npm.
  cleanEnv = {
    PATH: process.env.PATH,
    HOME: process.env.HOME,
    PWD:  process.env.PWD,
    LANG: process.env.LANG
  }

  commands = "source ~/.nvm/nvm.sh\n" + commands

  return spawn('bash', ['-c', commands], {env: cleanEnv})
}

function installedNodes() {
  nodes = []
  paths = fs.readdirSync(NVM_DIR)

  for (var i = 0; i < paths.length; i++) {
    if (paths[i].match(/v[\d\.]+/)) {
      nodes.push(paths[i])
    }
  }

  return nodes
}

function targetedNodes() {
  nodes = []

  packageInfo   = JSON.parse(fs.readFileSync(PACKAGE_PATH))
  versionRanges = packageInfo.testedEngines.node.split(' || ')

  // We assume that each version range is stable for X & Y.
  for (i = 0; i < versionRanges.length; i++) {
    versions = versionRanges[i].match(/>= (\d+)\.(\d+)\.(\d+) <= \d+\.\d+\.(\d+)/)

    if (versions) {
      base = 'v' + versions[1] + '.' + versions[2] + '.'

      for (z = parseInt(versions[3]); z <= parseInt(versions[4]); z++) {
        nodes.push(base + z)
      }
    } else {
      nodes.push(versionRanges[i])
    }
  }

  return nodes
}

function installMissingNodes(callback) {
  targeted  = targetedNodes()
  installed = installedNodes()
  missing   = []

  for (i = 0; i < targeted.length; i++) {
    var found = false
    for (j = 0; j < installed.length; j++) {
      if (installed[j] == targeted[i]) {
        found = true
      }
    }

    if (!found) {
      missing.push(targeted[i])
    }
  }

  function installNode(versions) {
    toInstall = versions.shift()
    process.stdout.write('Installing missing node ' + toInstall + '... ')

    installer = spawnWithNvm('nvm install ' + toInstall)
    installer.on('exit', function(code) {
      if (code !== 0) {
        process.stdout.write('failed!  Try installing manually.\n')
        process.exit(code)
      } else {
        process.stdout.write('done\n')
        if (versions.length == 0) {
          callback()
        } else {
          installNode(versions)
        }
      }
    })
  }

  if (missing.length == 0) {
    callback()
  } else {
    installNode(missing)
  }
}

function runTests(nodeVer, callback) {
  commands  = 'nvm use ' + nodeVer + "\n"
  commands += VOWS_PATH + ' ' + TESTS_PATH + '/*_test.coffee --isolate'

  // Need output for failure cases!
  output = ''

  runner = spawnWithNvm(commands)
  runner.stderr.on('data', function(data) {
    output += data
  })
  runner.stdout.on('data', function(data) {
    output += data
  })
  runner.on('exit', function(code) {
    callback(code !== 0, output)
  })
}

function summarize(statuses) {
  passed = []
  failed = []

  for (node in statuses) {
    if (statuses[node]) {
      passed.push(node)
    } else {
      failed.push(node)
    }
  }

  if (failed.length > 0) {
    console.log()
    console.log('The following nodes failed:')
    console.log('  ' + failed.join(', '))
    console.log()
  }

  process.exit(failed.length == 0 ? 0 : 1)
}


installMissingNodes(function() {
  targeted = targetedNodes()
  statuses = {}

  function handleNode(versions) {
    toRun = versions.shift()
    process.stdout.write('Testing node ' + toRun + '... ')

    runTests(toRun, function(err, output) {
      statuses[toRun] = !err

      if (err) {
        process.stdout.write('failed:\n')
        console.log(output)
      } else {
        process.stdout.write('passed\n')
      }

      if (versions.length == 0) {
        summarize(statuses)
      } else {
        handleNode(versions)
      }
    })
  }

  handleNode(targeted)
})