publishr/lib/dry-runner.js

A tool for harmonious publishing of git and npm packages.

"use strict";

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

var _es6Promise = require("es6-promise");

var _constants = require("./constants");

var _fileUtils = require("./file-utils");

var _fileUtils2 = _interopRequireDefault(_fileUtils);

var _git = require("./git");

var _git2 = _interopRequireDefault(_git);

var _logger = require("./logger");

var _logger2 = _interopRequireDefault(_logger);

var _postpublish2 = require("./postpublish");

var _postpublish3 = _interopRequireDefault(_postpublish2);

var _postversion2 = require("./postversion");

var _postversion3 = _interopRequireDefault(_postversion2);

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

var mockfs = void 0;

var dryRunner = {
  afterDryRun: function afterDryRun() {
    _logger2.default.disable();
    _git2.default.disableDry();
    dryRunner.restoreFileSystem();

    return _es6Promise.Promise.resolve();
  },
  beforeDryRun: function beforeDryRun() {
    _logger2.default.enable();
    _git2.default.enableDry();
    _logger2.default.info("Validating configuration...");

    return _fileUtils2.default.readPackage().then(dryRunner.validatePackage).then(dryRunner.validateFiles).then(function (result) {
      dryRunner.patchFileSystem(result.json, result.files);

      return _es6Promise.Promise.resolve();
    });
  },
  patchFileSystem: function patchFileSystem(packageJSON, files) {
    mockfs = require("mock-fs"); // eslint-disable-line global-require

    var fileSystem = files.reduce(function (result, file) {
      result[file.path] = mockfs.file({
        content: file.path + " contents",
        mode: file.stats.mode
      });

      return result;
    }, {
      "package.json": JSON.stringify(packageJSON, null, _constants.NUM_JSON_SPACES)
    });

    mockfs(fileSystem);
  },
  postpublish: function postpublish() {
    _logger2.default.info("Validating postpublish...");

    return _postpublish3.default.run();
  },
  postversion: function postversion() {
    _logger2.default.info("Validating postversion...");

    return _postversion3.default.run();
  },
  restoreFileSystem: function restoreFileSystem() {
    mockfs.restore();
  },
  run: function run() {
    return dryRunner.beforeDryRun().then(dryRunner.postversion).then(dryRunner.postpublish).then(dryRunner.afterDryRun);
  },
  validateFileOperation: function validateFileOperation(filePath) {
    return _fileUtils2.default.statFile(filePath).then(function (stats) {
      _logger2.default.pass("validate " + filePath);

      return _es6Promise.Promise.resolve({
        path: filePath,
        stats: stats
      });
    });
  },
  validateFileRead: function validateFileRead(filePath) {
    return dryRunner.validateFileOperation(filePath).catch(function (err) {
      _logger2.default.fail("validate " + filePath, err);

      return _es6Promise.Promise.reject(err);
    });
  },
  validateFiles: function validateFiles(packageJSON) {
    var files = packageJSON.publishr.files || {};
    var filePaths = Object.keys(files);
    var fileReads = filePaths.map(function (filePath) {
      return dryRunner.validateFileRead(files[filePath]);
    });
    var fileWrites = filePaths.map(function (filePath) {
      return dryRunner.validateFileWrite(filePath);
    });
    var fileOperations = [].concat(fileReads, fileWrites);

    return _es6Promise.Promise.all(fileOperations).then(function (validFiles) {
      return _es6Promise.Promise.resolve({
        files: validFiles.filter(function (file) {
          return file;
        }),
        json: packageJSON
      });
    });
  },
  validateFileWrite: function validateFileWrite(filePath) {
    return dryRunner.validateFileOperation(filePath).catch(function (err) {
      if (err.code !== "ENOENT") {
        _logger2.default.pass("validate " + filePath, err);

        return _es6Promise.Promise.reject(err);
      }

      _logger2.default.pass("validate " + filePath);

      return _es6Promise.Promise.resolve();
    });
  },
  validatePackage: function validatePackage(packageJSON) {
    var err = void 0;

    if (!packageJSON || !packageJSON.publishr) {
      err = new Error("No publishr configuration in 'package.json'");
    } else if (!packageJSON.publishr.dependencies && !packageJSON.publishr.files) {
      err = new Error("No files or dependencies in publishr configuration");
    }

    if (err) {
      _logger2.default.fail("validate 'package.json'", err);

      return _es6Promise.Promise.reject(err);
    }

    _logger2.default.pass("validate 'package.json'");

    return _es6Promise.Promise.resolve(packageJSON);
  }
};

exports.default = dryRunner;