text: var fs = require('fs');
  var sys = require('sys');
  var path = require('path');
  
  var filename = __dirname + '/jasmine-1.0.1.js';
  global.window = {
    setTimeout: setTimeout,
    clearTimeout: clearTimeout,
    setInterval: setInterval,
    clearInterval: clearInterval
  };
  
  var src = fs.readFileSync(filename);
  var jasmine;
  var minorVersion = process.version.match(/\d\.(\d)\.\d/)[1];
  switch (minorVersion) {
    case "1":
    case "2":
      jasmine = process.compile(src + '\njasmine;', filename);
      break;
    default:
      jasmine = require('vm').runInThisContext(src + "\njasmine;", filename);
  }
  
  delete global.window;
  
  function noop(){}
  
  jasmine.loadHelpersInFolder=function(folder, matcher)
  {
    var helpers = jasmine.getAllSpecFiles(folder, matcher);
  
    for (var i = 0, len = helpers.length; i < len; ++i)
    {
      var filename = helpers[i];
      var helper= require(filename.replace(/\.*$/, ""));
      for (var key in helper)
        global[key]= helper[key];
    }
  }
  
  jasmine.executeSpecsInFolder = function(folder, done, isVerbose, showColors, matcher){
    var log = [];
    var columnCounter = 0;
    var start = 0;
    var elapsed = 0;
    var verbose = isVerbose || false;
    var fileMatcher = matcher || new RegExp(".(js)$", "i");
    var colors = showColors || false;
    var specs = jasmine.getAllSpecFiles(folder, fileMatcher);
  
    var ansi = {
      green: '\033[32m',
      red: '\033[31m',
      yellow: '\033[33m',
      none: '\033[0m'
    };
  
    for (var i = 0, len = specs.length; i < len; ++i){
      var filename = specs[i];
      require(filename.replace(/\.\w+$/, ""));
    }
  
    var jasmineEnv = jasmine.getEnv();
    jasmineEnv.reporter = {
      log: function(str){
      },
  
      reportSpecStarting: function(runner) {
      },
  
      reportRunnerStarting: function(runner) {
        sys.puts('Started');
        start = Number(new Date);
      },
  
      reportSuiteResults: function(suite) {
        var specResults = suite.results();
        var path = [];
        while(suite) {
          path.unshift(suite.description);
          suite = suite.parentSuite;
        }
        var description = path.join(' ');
  
        if (verbose)
          log.push('Spec ' + description);
  
        specResults.items_.forEach(function(spec){
          if (spec.failedCount > 0 && spec.description) {
            if (!verbose)
                log.push(description);
            log.push('  it ' + spec.description);
            spec.items_.forEach(function(result){
              log.push('  ' + result.trace.stack + '\n');
            });
          } else {
            if (verbose)
                log.push('  it ' + spec.description);
          }
        });
      },
  
      reportSpecResults: function(spec) {
        var result = spec.results();
        var msg = '';
        if (result.passed())
        {
          msg = (colors) ? (ansi.green + '.' + ansi.none) : '.';
  //      } else if (result.skipped) {  TODO: Research why "result.skipped" returns false when "xit" is called on a spec?
  //        msg = (colors) ? (ansi.yellow + '*' + ansi.none) : '*';
        } else {
          msg = (colors) ? (ansi.red + 'F' + ansi.none) : 'F';
        }
        sys.print(msg);
        if (columnCounter++ < 50) return;
        columnCounter = 0;
        sys.print('\n');
      },
  
  
      reportRunnerResults: function(runner) {
        elapsed = (Number(new Date) - start) / 1000;
        sys.puts('\n');
        log.forEach(function(log){
          sys.puts(log);
        });
        sys.puts('Finished in ' + elapsed + ' seconds');
  
        var summary = jasmine.printRunnerResults(runner);
        if(colors)
        {
          if(runner.results().failedCount === 0 )
            sys.puts(ansi.green + summary + ansi.none);
          else
            sys.puts(ansi.red + summary + ansi.none);
        } else {
          sys.puts(summary);
        }
        (done||noop)(runner, log);
      }
    };
    jasmineEnv.execute();
  };
  
  jasmine.getAllSpecFiles = function(dir, matcher){
    var specs = [];
    if (fs.statSync(dir).isFile() && dir.match(matcher)) {
      specs.push(dir);
    } else {
      var files = fs.readdirSync(dir);
      for (var i = 0, len = files.length; i < len; ++i){
        var filename = dir + '/' + files[i];
          // fs.fstatSync will pass ENOENT from stat(2) up
          // the stack. That's not particularly useful right now,
          // so try and continue...
          try{
            isFile = fs.statSync(filename).isFile();
          }catch (err){
            if(err.code === 'ENOENT'){
              isFile = false;
            }else{
                throw err;
            }
          }
          if (filename.match(matcher) && isFile){
            specs.push(filename);
          }else{
            try{
              isDir = fs.statSync(filename).isDirectory();
            } catch (err) {
              if(err.code === 'ENOENT'){
                isDir = false;
              }else{
                throw err;
              }
            }
            if (isDir){
              var subfiles = this.getAllSpecFiles(filename, matcher);
              subfiles.forEach(function(result){
                  specs.push(result);
              });
            }
          }
  
      }
    }
    return specs;
  };
  
  jasmine.printRunnerResults = function(runner){
    var results = runner.results();
    var suites = runner.suites();
    var msg = '';
    msg += suites.length + ' test' + ((suites.length === 1) ? '' : 's') + ', ';
    msg += results.totalCount + ' assertion' + ((results.totalCount === 1) ? '' : 's') + ', ';
    msg += results.failedCount + ' failure' + ((results.failedCount === 1) ? '' : 's') + '\n';
    return msg;
  };
  
  function now(){
    return new Date().getTime();
  }
  
  jasmine.asyncSpecWait = function(){
    var wait = jasmine.asyncSpecWait;
    wait.start = now();
    wait.done = false;
    (function innerWait(){
      waits(10);
      runs(function() {
        if (wait.start + wait.timeout < now()) {
          expect('timeout waiting for spec').toBeNull();
        } else if (wait.done) {
          wait.done = false;
        } else {
          innerWait();
        }
      });
    })();
  };
  jasmine.asyncSpecWait.timeout = 4 * 1000;
  jasmine.asyncSpecDone = function(){
    jasmine.asyncSpecWait.done = true;
  };
  
  for ( var key in jasmine) {
    exports[key] = jasmine[key];
  }
  