configuration.js

const clone = require('clone');
const { EventEmitter } = require('events');

const logger = require('./logger');
const reporterOutputLogger = require('./reporters/reporterOutputLogger');


function coerceToArray(value) {
  if (Array.isArray(value)) {
    return value;
  } if (typeof value === 'string') {
    return [value];
  } if ((value == null)) {
    return [];
  }
  return value;
}


function applyLoggingOptions(options) {
  if (options.color === false) {
    logger.transports.console.colorize = false;
    reporterOutputLogger.transports.console.colorize = false;
  }

  // Handling the 'loglevel' value
  if (options.loglevel) {
    const loglevel = options.loglevel.toLowerCase();
    if (loglevel === 'silent') {
      logger.transports.console.silent = true;
    } else if (loglevel === 'warning') {
      logger.transports.console.level = 'warn';
    } else if (loglevel === 'debug') {
      logger.transports.console.level = 'debug';
      logger.transports.console.timestamp = true;
    } else if (['warn', 'error'].includes(loglevel)) {
      logger.transports.console.level = loglevel;
    } else {
      throw new Error(`Unsupported logging level: '${loglevel}'`);
    }
  } else {
    logger.transports.console.level = 'warn';
  }
}


function errorOnRemovedOptions(config = {}) {
  if (config.options) {
    if (config.options.c) {
      throw new Error('Dredd does not support '
        + '-c anymore, use --color/--no-color instead');
    }
    if (typeof config.options.color === 'string') {
      throw new Error('Dredd does not support '
        + `--color=${config.options.color} anymore, use --color/--no-color instead`);
    }
    if (config.options.level) {
      throw new Error('Dredd does not support '
        + '--level anymore, use --loglevel instead');
    }
    if (config.options.timestamp || config.options.t) {
      throw new Error('Dredd does not support '
        + '--timestamp anymore, use --loglevel=debug instead');
    }
    if (config.options.silent || config.options.q) {
      throw new Error('Dredd does not support '
        + '-q/--silent anymore, use --loglevel=silent instead');
    }
    if (config.options.sandbox || config.options.b) {
      throw new Error('Dredd does not support '
        + 'sandboxed JS hooks anymore, use standard JS hooks instead');
    }
  }
  if (config.hooksData) {
    throw new Error('Dredd does not support '
      + 'sandboxed JS hooks anymore, use standard JS hooks instead');
  }
  if (config.blueprintPath) {
    throw new Error('Dredd does not support '
      + "the 'blueprintPath' option anymore, use 'path' instead");
  }
}


function applyConfiguration(config) {
  const configuration = {
    server: null,
    emitter: new EventEmitter(),
    custom: { // Used for custom settings of various APIs or reporters
      // Keep commented-out, so these values are actually set by CLI
      // cwd: process.cwd()
    },
    options: {
      'dry-run': false,
      reporter: null,
      output: null,
      debug: false,
      header: null,
      user: null,
      'inline-errors': false,
      details: false,
      method: [],
      only: [],
      color: true,
      loglevel: 'warning',
      sorted: false,
      names: false,
      hookfiles: null,
      language: 'nodejs',
      'hooks-worker-timeout': 5000,
      'hooks-worker-connect-timeout': 1500,
      'hooks-worker-connect-retry': 500,
      'hooks-worker-after-connect-wait': 100,
      'hooks-worker-term-timeout': 5000,
      'hooks-worker-term-retry': 500,
      'hooks-worker-handler-host': '127.0.0.1',
      'hooks-worker-handler-port': 61321,
    },
  };

  // Normalize options and config
  for (const key of Object.keys(config || {})) {
    // Copy anything except "custom" hash
    const value = config[key];
    if (key !== 'custom') {
      configuration[key] = value;
    } else {
      if (!configuration.custom) { configuration.custom = {}; }
      const object = config.custom || {};
      for (const customKey of Object.keys(object || {})) {
        const customVal = object[customKey];
        configuration.custom[customKey] = clone(customVal, false);
      }
    }
  }

  // Coerce single/multiple options into an array
  configuration.options.reporter = coerceToArray(configuration.options.reporter);
  configuration.options.output = coerceToArray(configuration.options.output);
  configuration.options.header = coerceToArray(configuration.options.header);
  configuration.options.method = coerceToArray(configuration.options.method);
  configuration.options.only = coerceToArray(configuration.options.only);
  configuration.options.path = coerceToArray(configuration.options.path);

  configuration.options.method = configuration.options.method.map(method => method.toUpperCase());

  if (configuration.options.user) {
    const authHeader = `Authorization:Basic ${Buffer.from(configuration.options.user).toString('base64')}`;
    configuration.options.header.push(authHeader);
  }

  applyLoggingOptions(configuration.options);
  errorOnRemovedOptions(config);

  return configuration;
}


module.exports = {
  applyConfiguration,
  applyLoggingOptions,
};