lifen-autotest/node_modules/cucumber/lib/cli/index.js

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _extends2 = require('babel-runtime/helpers/extends');

var _extends3 = _interopRequireDefault(_extends2);

var _bluebird = require('bluebird');

var _bluebird2 = _interopRequireDefault(_bluebird);

var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _createClass2 = require('babel-runtime/helpers/createClass');

var _createClass3 = _interopRequireDefault(_createClass2);

var _helpers = require('../formatter/helpers');

var _helpers2 = require('./helpers');

var _install_validator = require('./install_validator');

var _i18n = require('./i18n');

var I18n = _interopRequireWildcard(_i18n);

var _configuration_builder = require('./configuration_builder');

var _configuration_builder2 = _interopRequireDefault(_configuration_builder);

var _events = require('events');

var _events2 = _interopRequireDefault(_events);

var _builder = require('../formatter/builder');

var _builder2 = _interopRequireDefault(_builder);

var _fs = require('mz/fs');

var _fs2 = _interopRequireDefault(_fs);

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

var _pickle_filter = require('../pickle_filter');

var _pickle_filter2 = _interopRequireDefault(_pickle_filter);

var _master = require('../runtime/parallel/master');

var _master2 = _interopRequireDefault(_master);

var _runtime = require('../runtime');

var _runtime2 = _interopRequireDefault(_runtime);

var _support_code_library_builder = require('../support_code_library_builder');

var _support_code_library_builder2 = _interopRequireDefault(_support_code_library_builder);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var Cli = function () {
  function Cli(_ref) {
    var argv = _ref.argv,
        cwd = _ref.cwd,
        stdout = _ref.stdout;
    (0, _classCallCheck3.default)(this, Cli);

    this.argv = argv;
    this.cwd = cwd;
    this.stdout = stdout;
  }

  (0, _createClass3.default)(Cli, [{
    key: 'getConfiguration',
    value: function () {
      var _ref2 = (0, _bluebird.coroutine)(function* () {
        var fullArgv = yield (0, _helpers2.getExpandedArgv)({ argv: this.argv, cwd: this.cwd });
        return _configuration_builder2.default.build({ argv: fullArgv, cwd: this.cwd });
      });

      function getConfiguration() {
        return _ref2.apply(this, arguments);
      }

      return getConfiguration;
    }()
  }, {
    key: 'initializeFormatters',
    value: function () {
      var _ref4 = (0, _bluebird.coroutine)(function* (_ref3) {
        var _this = this;

        var eventBroadcaster = _ref3.eventBroadcaster,
            formatOptions = _ref3.formatOptions,
            formats = _ref3.formats,
            supportCodeLibrary = _ref3.supportCodeLibrary;

        var streamsToClose = [];
        var eventDataCollector = new _helpers.EventDataCollector(eventBroadcaster);
        yield _bluebird2.default.map(formats, function () {
          var _ref6 = (0, _bluebird.coroutine)(function* (_ref5) {
            var _context;

            var type = _ref5.type,
                outputTo = _ref5.outputTo;

            var stream = _this.stdout;
            if (outputTo) {
              var fd = yield _fs2.default.open(_path2.default.resolve(_this.cwd, outputTo), 'w');
              stream = _fs2.default.createWriteStream(null, { fd: fd });
              streamsToClose.push(stream);
            }
            var typeOptions = (0, _extends3.default)({
              eventBroadcaster: eventBroadcaster,
              eventDataCollector: eventDataCollector,
              log: (_context = stream).write.bind(_context),
              stream: stream,
              supportCodeLibrary: supportCodeLibrary
            }, formatOptions);
            return _builder2.default.build(type, typeOptions);
          });

          return function (_x2) {
            return _ref6.apply(this, arguments);
          };
        }());
        return function () {
          return _bluebird2.default.each(streamsToClose, function (stream) {
            return _bluebird2.default.promisify(stream.end.bind(stream))();
          });
        };
      });

      function initializeFormatters(_x) {
        return _ref4.apply(this, arguments);
      }

      return initializeFormatters;
    }()
  }, {
    key: 'getSupportCodeLibrary',
    value: function getSupportCodeLibrary(_ref7) {
      var supportCodeRequiredModules = _ref7.supportCodeRequiredModules,
          supportCodePaths = _ref7.supportCodePaths;

      supportCodeRequiredModules.map(function (module) {
        return require(module);
      });
      _support_code_library_builder2.default.reset(this.cwd);
      supportCodePaths.forEach(function (codePath) {
        return require(codePath);
      });
      return _support_code_library_builder2.default.finalize();
    }
  }, {
    key: 'run',
    value: function () {
      var _ref8 = (0, _bluebird.coroutine)(function* () {
        yield (0, _install_validator.validateInstall)(this.cwd);
        var configuration = yield this.getConfiguration();
        if (configuration.listI18nLanguages) {
          this.stdout.write(I18n.getLanguages());
          return { success: true };
        }
        if (configuration.listI18nKeywordsFor) {
          this.stdout.write(I18n.getKeywords(configuration.listI18nKeywordsFor));
          return { success: true };
        }
        var supportCodeLibrary = this.getSupportCodeLibrary(configuration);
        var eventBroadcaster = new _events2.default();
        var cleanup = yield this.initializeFormatters({
          eventBroadcaster: eventBroadcaster,
          formatOptions: configuration.formatOptions,
          formats: configuration.formats,
          supportCodeLibrary: supportCodeLibrary
        });
        var testCases = yield (0, _helpers2.getTestCasesFromFilesystem)({
          cwd: this.cwd,
          eventBroadcaster: eventBroadcaster,
          featureDefaultLanguage: configuration.featureDefaultLanguage,
          featurePaths: configuration.featurePaths,
          order: configuration.order,
          pickleFilter: new _pickle_filter2.default(configuration.pickleFilterOptions)
        });
        var success = void 0;
        if (configuration.parallel) {
          var parallelRuntimeMaster = new _master2.default({
            eventBroadcaster: eventBroadcaster,
            options: configuration.runtimeOptions,
            supportCodePaths: configuration.supportCodePaths,
            supportCodeRequiredModules: configuration.supportCodeRequiredModules,
            testCases: testCases
          });
          yield new _bluebird2.default(function (resolve) {
            parallelRuntimeMaster.run(configuration.parallel, function (s) {
              success = s;
              resolve();
            });
          });
        } else {
          var runtime = new _runtime2.default({
            eventBroadcaster: eventBroadcaster,
            options: configuration.runtimeOptions,
            supportCodeLibrary: supportCodeLibrary,
            testCases: testCases
          });
          success = yield runtime.start();
        }
        yield cleanup();
        return {
          shouldExitImmediately: configuration.shouldExitImmediately,
          success: success
        };
      });

      function run() {
        return _ref8.apply(this, arguments);
      }

      return run;
    }()
  }]);
  return Cli;
}();

exports.default = Cli;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/cli/index.js"],"names":["I18n","Cli","argv","cwd","stdout","fullArgv","build","eventBroadcaster","formatOptions","formats","supportCodeLibrary","streamsToClose","eventDataCollector","map","type","outputTo","stream","fd","open","resolve","createWriteStream","push","typeOptions","log","write","each","promisify","end","supportCodeRequiredModules","supportCodePaths","require","module","reset","forEach","codePath","finalize","configuration","getConfiguration","listI18nLanguages","getLanguages","success","listI18nKeywordsFor","getKeywords","getSupportCodeLibrary","cleanup","initializeFormatters","testCases","featureDefaultLanguage","featurePaths","order","pickleFilter","pickleFilterOptions","parallel","parallelRuntimeMaster","options","runtimeOptions","run","s","runtime","start","shouldExitImmediately"],"mappings":"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","file":"index.js","sourcesContent":["import { EventDataCollector } from '../formatter/helpers'\nimport { getExpandedArgv, getTestCasesFromFilesystem } from './helpers'\nimport { validateInstall } from './install_validator'\nimport * as I18n from './i18n'\nimport ConfigurationBuilder from './configuration_builder'\nimport EventEmitter from 'events'\nimport FormatterBuilder from '../formatter/builder'\nimport fs from 'mz/fs'\nimport path from 'path'\nimport PickleFilter from '../pickle_filter'\nimport Promise from 'bluebird'\nimport ParallelRuntimeMaster from '../runtime/parallel/master'\nimport Runtime from '../runtime'\nimport supportCodeLibraryBuilder from '../support_code_library_builder'\n\nexport default class Cli {\n  constructor({ argv, cwd, stdout }) {\n    this.argv = argv\n    this.cwd = cwd\n    this.stdout = stdout\n  }\n\n  async getConfiguration() {\n    const fullArgv = await getExpandedArgv({ argv: this.argv, cwd: this.cwd })\n    return ConfigurationBuilder.build({ argv: fullArgv, cwd: this.cwd })\n  }\n\n  async initializeFormatters({\n    eventBroadcaster,\n    formatOptions,\n    formats,\n    supportCodeLibrary,\n  }) {\n    const streamsToClose = []\n    const eventDataCollector = new EventDataCollector(eventBroadcaster)\n    await Promise.map(formats, async ({ type, outputTo }) => {\n      let stream = this.stdout\n      if (outputTo) {\n        const fd = await fs.open(path.resolve(this.cwd, outputTo), 'w')\n        stream = fs.createWriteStream(null, { fd })\n        streamsToClose.push(stream)\n      }\n      const typeOptions = {\n        eventBroadcaster,\n        eventDataCollector,\n        log: ::stream.write,\n        stream,\n        supportCodeLibrary,\n        ...formatOptions,\n      }\n      return FormatterBuilder.build(type, typeOptions)\n    })\n    return function() {\n      return Promise.each(streamsToClose, stream =>\n        Promise.promisify(::stream.end)()\n      )\n    }\n  }\n\n  getSupportCodeLibrary({ supportCodeRequiredModules, supportCodePaths }) {\n    supportCodeRequiredModules.map(module => require(module))\n    supportCodeLibraryBuilder.reset(this.cwd)\n    supportCodePaths.forEach(codePath => require(codePath))\n    return supportCodeLibraryBuilder.finalize()\n  }\n\n  async run() {\n    await validateInstall(this.cwd)\n    const configuration = await this.getConfiguration()\n    if (configuration.listI18nLanguages) {\n      this.stdout.write(I18n.getLanguages())\n      return { success: true }\n    }\n    if (configuration.listI18nKeywordsFor) {\n      this.stdout.write(I18n.getKeywords(configuration.listI18nKeywordsFor))\n      return { success: true }\n    }\n    const supportCodeLibrary = this.getSupportCodeLibrary(configuration)\n    const eventBroadcaster = new EventEmitter()\n    const cleanup = await this.initializeFormatters({\n      eventBroadcaster,\n      formatOptions: configuration.formatOptions,\n      formats: configuration.formats,\n      supportCodeLibrary,\n    })\n    const testCases = await getTestCasesFromFilesystem({\n      cwd: this.cwd,\n      eventBroadcaster,\n      featureDefaultLanguage: configuration.featureDefaultLanguage,\n      featurePaths: configuration.featurePaths,\n      order: configuration.order,\n      pickleFilter: new PickleFilter(configuration.pickleFilterOptions),\n    })\n    let success\n    if (configuration.parallel) {\n      const parallelRuntimeMaster = new ParallelRuntimeMaster({\n        eventBroadcaster,\n        options: configuration.runtimeOptions,\n        supportCodePaths: configuration.supportCodePaths,\n        supportCodeRequiredModules: configuration.supportCodeRequiredModules,\n        testCases,\n      })\n      await new Promise(resolve => {\n        parallelRuntimeMaster.run(configuration.parallel, s => {\n          success = s\n          resolve()\n        })\n      })\n    } else {\n      const runtime = new Runtime({\n        eventBroadcaster,\n        options: configuration.runtimeOptions,\n        supportCodeLibrary,\n        testCases,\n      })\n      success = await runtime.start()\n    }\n    await cleanup()\n    return {\n      shouldExitImmediately: configuration.shouldExitImmediately,\n      success,\n    }\n  }\n}\n"]}