ember-introjs/.node_modules.ember-try/testem/lib/config.js

An Ember Component for intro.js

/*

config.js
=========

This object returns all config info for the app. It handles reading the `testem.yml`
or `testem.json` config file.

*/
'use strict';


var os = require('os');
var fs = require('fs');
var yaml = require('js-yaml');
var log = require('npmlog');
var path = require('path');
var glob = require('glob');
var url = require('url');
var querystring = require('querystring');
var Bluebird = require('bluebird');

var browser_launcher = require('./browser_launcher');
var LauncherFactory = require('./launcher-factory');
var Chars = require('./chars');
var pad = require('./strutils').pad;
var isa = require('./isa');
var fileExists = require('./fileutils').fileExists;
var uniqBy = require('lodash.uniqby');

var knownBrowsers = require('./utils/known-browsers');
var globAsync = Bluebird.promisify(glob);

function Config(appMode, progOptions, config) {
  this.appMode = appMode;
  this.progOptions = progOptions || {};
  this.fileOptions = {};
  this.config = config || {};
  this.getters = {
    test_page: 'getTestPage'
  };

  if (appMode === 'dev') {
    this.progOptions.reporter = 'dev';
    this.progOptions.parallel = -1;
  }

  if (this.progOptions.debug === true) {
    this.progOptions.debug = 'testem.log';
  }

  if (appMode === 'ci') {
    this.progOptions.disable_watching = true;
    this.progOptions.single_run = true;
  }
}

Config.prototype.read = function(callback) {
  var configFile = this.progOptions.file;

  if (configFile) {
    this.readConfigFile(configFile, callback);
  } else {
    log.info('Seeking for config file...');

    // Try all testem.json, testem.yml and testem.js
    // testem.json gets precedence
    var files = ['testem.json', '.testem.json', '.testem.yml', 'testem.yml', 'testem.js', '.testem.js'];
    return Bluebird.filter(files.map(this.resolveConfigPath.bind(this)), fileExists).then(function(matched) {
      var configFile = matched[0];
      if (matched.length > 1) {
        var baseNames = matched.map(function(fileName) {
          return path.basename(fileName);
        });
        console.warn('Found ' + matched.length + ' config files (' + baseNames + '), using ' + baseNames[0]);
      }
      if (configFile) {
        this.readConfigFile(configFile, callback);
      } else {
        if (callback) {
          callback.call(this);
        }
      }
    }.bind(this));
  }
};

Config.prototype.resolvePath = function(filepath) {
  if (filepath[0] === '/') {
    return filepath;
  }

  return path.resolve(this.cwd(), filepath);
};

Config.prototype.client = function() {
  return {
    decycle_depth: this.get('client_decycle_depth')
  };
};

Config.prototype.resolveConfigPath = function(filepath) {
  if (this.progOptions.config_dir) {
    return path.resolve(this.progOptions.config_dir, filepath);
  } else {
    return this.resolvePath(filepath);
  }
};

Config.prototype.reverseResolvePath = function(filepath) {
  return path.relative(this.cwd(), filepath);
};

Config.prototype.cwd = function() {
  return this.get('cwd') || process.cwd();
};

Config.prototype.readConfigFile = function(configFile, callback) {
  var self = this;
  if (!configFile) { // allow empty configFile for programmatic setups
    if (callback) {
      callback.call(self);
    }
  } else if (configFile.match(/\.js$/)) {
    this.readJS(configFile, callback);
  } else if (configFile.match(/\.json$/)) {
    this.readJSON(configFile, callback);
  } else if (configFile.match(/\.yml$/)) {
    this.readYAML(configFile, callback);
  } else {
    log.error('Unrecognized config file format for ' + configFile);
    if (callback) {
      callback.call(self);
    }
  }
};

Config.prototype.readJS = function(configFile, callback) {
  this.fileOptions = require(this.resolveConfigPath(configFile));
  if (callback) {
    callback.call(this);
  }
};

Config.prototype.readYAML = function(configFile, callback) {
  var self = this;
  fs.readFile(configFile, function(err, data) {
    if (!err) {
      var cfg = yaml.load(String(data));
      self.fileOptions = cfg;
    }
    if (callback) {
      callback.call(self);
    }
  });
};

Config.prototype.readJSON = function(configFile, callback) {
  var self = this;
  fs.readFile(configFile, function(err, data) {
    if (!err) {
      var cfg = JSON.parse(data.toString());
      self.fileOptions = cfg;
      self.progOptions.file = configFile;
    }
    if (callback) {
      callback.call(self);
    }
  });
};

Config.prototype.defaults = {
  host: 'localhost',
  port: 7357,
  url: function() {
    var scheme = 'http';
    if (this.get('key') || this.get('pfx')) {
      scheme = 'https';
    }
    return scheme + '://' + this.get('host') + ':' + this.get('port') + '/';
  },
  parallel: 1,
  reporter: 'tap',
  bail_on_uncaught_error: true,
  browser_start_timeout: 30,
  browser_disconnect_timeout: 10,
  client_decycle_depth: 5
};

Config.prototype.mergeUrlAndQueryParams = function(urlString, queryParamsObj) {
  if (!queryParamsObj) {
    return urlString;
  }

  if (typeof queryParamsObj === 'string') {
    if (queryParamsObj[0] === '?') {
      queryParamsObj = queryParamsObj.substr(1);
    }
    queryParamsObj = querystring.parse(queryParamsObj);
  }

  var urlObj = url.parse(urlString);
  var outputQueryParams = querystring.parse(urlObj.query) || {};
  Object.keys(queryParamsObj).forEach(function(param) {
    outputQueryParams[param] = queryParamsObj[param];
  });
  urlObj.query = outputQueryParams;
  urlObj.search = querystring.stringify(outputQueryParams)
    .replace(/=&/g, '&')
    .replace(/=$/, '');
  urlObj.path = urlObj.pathname + urlObj.search;
  return url.format(urlObj);
};

Config.prototype.getTestPage = function() {
  var testPage = this.getConfigProperty('test_page');
  var queryParams = this.getConfigProperty('query_params');
  var self = this;

  if (!Array.isArray(testPage)) {
    testPage = [testPage];
  }

  return testPage.map(function(page) {
    return self.mergeUrlAndQueryParams(page, queryParams);
  });
};

Config.prototype.getConfigProperty = function(key) {
  if (this.config && key in this.config) {
    return this.config[key];
  }
  if (key in this.progOptions && typeof this.progOptions[key] !== 'undefined') {
    return this.progOptions[key];
  }
  if (key in this.fileOptions && typeof this.fileOptions[key] !== 'undefined') {
    return this.fileOptions[key];
  }
  if (key in this.defaults) {
    var defaultVal = this.defaults[key];
    if (typeof defaultVal === 'function') {
      return defaultVal.call(this);
    } else {
      return defaultVal;
    }
  }
};

Config.prototype.get = function(key) {
  var getterKey = this.getters[key];
  var getter = getterKey && this[getterKey];
  if (getter) {
    return getter.call(this, key);
  } else {
    return this.getConfigProperty(key);
  }
};

Config.prototype.set = function(key, value) {
  if (!this.config) {
    this.config = {};
  }
  this.config[key] = value;
};

Config.prototype.isCwdMode = function() {
  return !this.get('src_files') && !this.get('test_page');
};

Config.prototype.getAvailableLaunchers = function(cb) {
  var self = this;

  var browsers = knownBrowsers(process.platform, self);
  browser_launcher.getAvailableBrowsers(self, browsers, function(err, availableBrowsers) {
    if (err) {
      return cb(err);
    }

    var availableLaunchers = {};
    availableBrowsers.forEach(function(browser) {
      var newLauncher = new LauncherFactory(browser.name, browser, self);
      availableLaunchers[browser.name.toLowerCase()] = newLauncher;
    });

    // add custom launchers
    var customLaunchers = self.get('launchers');
    if (customLaunchers) {
      for (var name in customLaunchers) {
        var newLauncher = new LauncherFactory(name, customLaunchers[name], self);
        availableLaunchers[name.toLowerCase()] = newLauncher;
      }
    }
    cb(null, availableLaunchers);
  });
};

Config.prototype.getLaunchers = function(cb) {
  var self = this;
  this.getAvailableLaunchers(function(err, availableLaunchers) {
    if (err) {
      return cb(err);
    }

    self.getWantedLaunchers(availableLaunchers, cb);
  });
};

Config.prototype.getWantedLauncherNames = function(available) {
  var launchers = this.get('launch');
  if (launchers) {
    launchers = launchers.toLowerCase().split(',');
  } else if (this.appMode === 'dev') {
    launchers = this.get('launch_in_dev') || [];
  } else {
    launchers = this.get('launch_in_ci') || Object.keys(available);
  }

  var skip = this.get('skip');
  if (skip) {
    skip = skip.toLowerCase().split(',');
    launchers = launchers.filter(function(name) {
      return skip.indexOf(name) === -1;
    });
  }
  return launchers;
};

Config.prototype.getWantedLaunchers = function(available, cb) {
  var launchers = [];
  var wanted = this.getWantedLauncherNames(available);
  var self = this;
  var err = null;

  wanted.forEach(function(name) {
    var launcher = available[name.toLowerCase()];
    if (!launcher) {
      if (self.appMode === 'dev' || self.get('ignore_missing_launchers')) {
        log.warn('Launcher "' + name + '" is not recognized.');
      } else {
        err = new Error('Launcher ' + name + ' not found. Not installed?');
      }
    } else {
      launchers.push(launcher);
    }
  });
  cb(err, launchers);
};

Config.prototype.printLauncherInfo = function() {
  var self = this;
  this.getAvailableLaunchers(function(err, launchers) {
    var launch_in_dev = (self.get('launch_in_dev') || [])
      .map(function(s) {return s.toLowerCase();});
    var launch_in_ci = self.get('launch_in_ci');
    if (launch_in_ci) {
      launch_in_ci = launch_in_ci.map(function(s) {return s.toLowerCase();});
    }
    launchers = Object.keys(launchers).map(function(k) {return launchers[k];});
    console.log('Have ' + launchers.length + ' launchers available; auto-launch info displayed on the right.');
    console.log(); // newline
    console.log('Launcher      Type          CI  Dev');
    console.log('------------  ------------  --  ---');
    console.log(launchers.map(function(launcher) {
      var protocol = launcher.settings.protocol;
      var kind = protocol === 'browser' ?
        'browser' : (
          protocol === 'tap' ?
            'process(TAP)' : 'process');
      var dev = launch_in_dev.indexOf(launcher.name.toLowerCase()) !== -1 ?
        Chars.mark :
        ' ';
      var ci = !launch_in_ci || launch_in_ci.indexOf(launcher.name.toLowerCase()) !== -1 ?
        Chars.mark :
        ' ';
      return (pad(launcher.name, 14, ' ', 1) +
        pad(kind, 12, ' ', 1) +
        '  ' + ci + '    ' + dev + '      ');
    }).join('\n'));
  });
};

Config.prototype.getFileSet = function(want, dontWant, callback) {
  var self = this;
  if (isa(want, String)) {
    want = [want]; // want is an Array
  }
  if (isa(dontWant, String)) {
    dontWant = [dontWant]; // dontWant is an Array
  }

  // Filter glob < 6 negation patterns to still support them
  // See https://github.com/isaacs/node-glob/tree/3f883c43#comments-and-negation
  var positiveWants = [];
  want.forEach(function(patternEntry) {
    var pattern = isa(patternEntry, String) ? patternEntry : patternEntry.src;
    if (pattern.indexOf('!') === 0) {
      return dontWant.push(pattern.substring(1));
    }

    positiveWants.push(patternEntry);
  });

  dontWant = dontWant.map(function(p) {
    return p ? self.resolvePath(p) : p;
  });
  Bluebird.reduce(positiveWants, function(allThatIWant, patternEntry) {
    var pattern = isa(patternEntry, String) ? patternEntry : patternEntry.src;
    var attrs = patternEntry.attrs || [];
    var patternUrl = url.parse(pattern);

    if (patternUrl.protocol === 'file:') {
      pattern = patternUrl.hostname + patternUrl.path;
    } else if (patternUrl.protocol) {
      return allThatIWant.concat({src: pattern, attrs: attrs});
    }

    return globAsync(self.resolvePath(pattern), { ignore: dontWant }).then(function(files) {
      return allThatIWant.concat(files.map(function(f) {
        f = self.reverseResolvePath(f);
        return {src: f, attrs: attrs};
      }));
    });
  }, [])
    .then(function(result) {
      return uniqBy(result, 'src');
    })
    .asCallback(callback);
};

Config.prototype.getSrcFiles = function(callback) {
  var srcFiles = this.get('src_files') || '*.js';
  var srcFilesIgnore = this.get('src_files_ignore') || '';
  this.getFileSet(srcFiles, srcFilesIgnore, callback);
};

Config.prototype.getServeFiles = function(callback) {
  var want = this.get('serve_files') || this.get('src_files') || '*.js';
  var dontWant = this.get('serve_files_ignore') || this.get('src_files_ignore') || '';
  this.getFileSet(want, dontWant, callback);
};

Config.prototype.getUserDataDir = function() {
  if (this.get('user_data_dir')) {
    return path.resolve(this.cwd(), this.get('user_data_dir'));
  }

  return os.tmpdir();
};

Config.prototype.getHomeDir = function() {
  return process.env.HOME || process.env.USERPROFILE;
};

Config.prototype.getCSSFiles = function(callback) {
  var want = this.get('css_files') || '';
  this.getFileSet(want, '', callback);
};

Config.prototype.getAllOptions = function() {
  var options = [];
  function getOptions(o) {
    if (!o) {
      return;
    }
    if (o.options) {
      o.options.forEach(function(o) {
        options.push(o.name());
      });
    }
    getOptions(o.parent);
  }
  getOptions(this.progOptions);
  return options;
};

Config.prototype.getTemplateData = function(cb) {
  var ret = {};
  var options = this.getAllOptions();
  var key;
  for (key in this.progOptions) {
    if (options.indexOf(key) !== -1) {
      ret[key] = this.progOptions[key];
    }
  }
  for (key in this.fileOptions) {
    ret[key] = this.fileOptions[key];
  }
  for (key in this.config) {
    ret[key] = this.config[key];
  }
  this.getServeFiles(function(err, files) {
    var replaceSlashes = function(f) {
      return {src: f.src.replace(/\\/g, '/'), attrs: f.attrs};
    };

    ret.serve_files = files.map(replaceSlashes);

    this.getCSSFiles(function(err, files) {
      ret.css_files = files.map(replaceSlashes);
      if (cb) {
        cb(err, ret);
      }
    });
  }.bind(this));
};

module.exports = Config;