bps.js/lib/cli.js

BPS patching utility

#! /usr/bin/env node
'use strict';

var _crypto = require('crypto');

var _crypto2 = _interopRequireDefault(_crypto);

var _fs = require('fs');

var _fs2 = _interopRequireDefault(_fs);

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

var _crcHash = require('crc-hash');

var _crcHash2 = _interopRequireDefault(_crcHash);

var _commander = require('commander');

var _commander2 = _interopRequireDefault(_commander);

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

var _logger2 = _interopRequireDefault(_logger);

var _package = require('../package.json');

var pkg = _interopRequireWildcard(_package);

var _applyBpsPatch = require('./applyBpsPatch');

var _applyBpsPatch2 = _interopRequireDefault(_applyBpsPatch);

var _createBpsPatch = require('./createBpsPatch');

var _createBpsPatch2 = _interopRequireDefault(_createBpsPatch);

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 }; }

function applyBpsPatchFile(source, patch, target) {
  var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
  var _options$allowOverwri = options.allowOverwrite,
      allowOverwrite = _options$allowOverwri === undefined ? false : _options$allowOverwri,
      _options$dryRun = options.dryRun,
      dryRun = _options$dryRun === undefined ? false : _options$dryRun;


  if (!source) {
    _logger2.default.error('No source file specified');
    return 1;
  }

  if (!patch) {
    _logger2.default.error('No patch file specified');
    return 1;
  }

  if (source === target || patch === target) {
    _logger2.default.error('Not trying to overwrite original %s', target);
    return 1;
  }

  if (!_fs2.default.existsSync(source)) {
    _logger2.default.error('Cannot find source file %s', source);
    return 1;
  }

  if (!_fs2.default.existsSync(patch)) {
    _logger2.default.error('Cannot find patch file %s', patch);
    return 1;
  }

  if (!(allowOverwrite || dryRun) && _fs2.default.existsSync(target)) {
    _logger2.default.error('Destination file already exists: %s', target);
    return 1;
  }

  var sourceFile = _fs2.default.readFileSync(source);
  _logger2.default.info('Read source file: %s', source);

  var patchFile = _fs2.default.readFileSync(patch);
  _logger2.default.info('Read patch file: %s', patch);

  var sourceCrc32 = _crcHash2.default.createHash('crc32').update(sourceFile).digest('hex');
  var sourceMd5 = _crypto2.default.createHash('md5').update(sourceFile).digest('hex');
  var sourceSha256 = _crypto2.default.createHash('sha256').update(sourceFile).digest('hex');

  var patchCrc32 = _crcHash2.default.createHash('crc32').update(patchFile).digest('hex');
  var patchMd5 = _crypto2.default.createHash('md5').update(patchFile).digest('hex');
  var patchSha256 = _crypto2.default.createHash('sha256').update(patchFile).digest('hex');

  _logger2.default.info('Source CRC32: %s', sourceCrc32);
  _logger2.default.info('Source MD5: %s', sourceMd5);
  _logger2.default.info('Source SHA-256: %s', sourceSha256);

  _logger2.default.info('Patch CRC32: %s', patchCrc32);
  _logger2.default.info('Patch MD5: %s', patchMd5);
  _logger2.default.info('Patch SHA-256: %s', patchSha256);

  var targetFile = void 0;

  try {
    targetFile = (0, _applyBpsPatch2.default)(sourceFile, patchFile, {
      log: function log() {
        if (dryRun) {
          _logger2.default.info.apply(_logger2.default, arguments);
        } else {
          _logger2.default.debug.apply(_logger2.default, arguments);
        }
      }
    });
  } catch (e) {
    _logger2.default.error(e.toString());
    return 1;
  }

  if (dryRun) {
    _logger2.default.info('Dry run! Not writing file: %s', target);
  } else {
    try {
      _fs2.default.writeFileSync(target, targetFile);
      _logger2.default.info('Wrote patched file: %s', target);
    } catch (e) {
      _logger2.default.error('Error writing patched file %s', target);
      return 1;
    }
  }

  var targetCrc32 = _crcHash2.default.createHash('crc32').update(targetFile).digest('hex');
  var targetMd5 = _crypto2.default.createHash('md5').update(targetFile).digest('hex');
  var targetSha256 = _crypto2.default.createHash('sha256').update(targetFile).digest('hex');

  _logger2.default.info('Target CRC32: %s', targetCrc32);
  _logger2.default.info('Target MD5: %s', targetMd5);
  _logger2.default.info('Target SHA-256: %s', targetSha256);

  _logger2.default.info('OK!');

  return 0;
}
/* eslint-env: node */

function createBpsPatchFile(source, target, patch) {
  var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
  var _options$allowOverwri2 = options.allowOverwrite,
      allowOverwrite = _options$allowOverwri2 === undefined ? false : _options$allowOverwri2,
      _options$dryRun2 = options.dryRun,
      dryRun = _options$dryRun2 === undefined ? false : _options$dryRun2;


  if (!source) {
    _logger2.default.error('No source file specified');
    return 1;
  }

  if (!target) {
    _logger2.default.error('No target file specified');
    return 1;
  }

  if (source === patch || target === patch) {
    _logger2.default.error('Not trying to overwrite original %s', patch);
    return 1;
  }

  if (!_fs2.default.existsSync(source)) {
    _logger2.default.error('Cannot find source file %s', source);
    return 1;
  }

  if (!_fs2.default.existsSync(target)) {
    _logger2.default.error('Cannot find target file %s', target);
    return 1;
  }

  if (!(allowOverwrite || dryRun) && _fs2.default.existsSync(patch)) {
    _logger2.default.error('Destination file already exists: %s', patch);
    return 1;
  }

  var sourceFile = _fs2.default.readFileSync(source);
  _logger2.default.info('Read source file: %s', source);

  var targetFile = _fs2.default.readFileSync(target);
  _logger2.default.info('Read target file: %s', target);

  var sourceMd5 = _crypto2.default.createHash('md5').update(sourceFile).digest('hex');
  var targetMd5 = _crypto2.default.createHash('md5').update(targetFile).digest('hex');

  _logger2.default.info('Source MD5: %s', sourceMd5);
  _logger2.default.info('Target MD5: %s', targetMd5);

  var sourceSha256 = _crypto2.default.createHash('sha256').update(sourceFile).digest('hex');
  _logger2.default.info('Source SHA-256: %s', sourceSha256);

  var patchFile = void 0;

  try {
    patchFile = (0, _createBpsPatch2.default)(sourceFile, targetFile, {
      log: function log() {
        if (dryRun) {
          _logger2.default.info.apply(_logger2.default, arguments);
        } else {
          _logger2.default.debug.apply(_logger2.default, arguments);
        }
      }
    });
  } catch (e) {
    _logger2.default.error(e.toString());
    return 1;
  }

  if (dryRun) {
    _logger2.default.info('Dry run! Not writing file: %s', patch);
  } else {
    try {
      _fs2.default.writeFileSync(patch, patchFile);
      _logger2.default.info('Wrote patch file: %s', patch);
    } catch (e) {
      _logger2.default.error('Error writing patch file %s', patch);
      return 1;
    }
  }

  var patchMd5 = _crypto2.default.createHash('md5').update(patchFile).digest('hex');
  var patchSha256 = _crypto2.default.createHash('sha256').update(patchFile).digest('hex');

  _logger2.default.info('Patch MD5: %s', patchMd5);
  _logger2.default.info('Patch SHA-256: %s', patchSha256);

  _logger2.default.info('OK!');

  return 0;
}

_commander2.default.version(pkg.version, '-v, --version').option('-d, --debug', 'enable debug logging').on('option:debug', function () {
  if (_commander2.default.debug) {
    _logger2.default.level = 'debug';
  }
});

_commander2.default.command('apply <source> <patch> [target]').option('--allow-overwrite', 'Allow overwriting of destination file').option('--dry-run', 'Stop before writing the destination file').description('apply a patch to the source file').action(function (source, patch, target, cmd) {
  if (!target) {
    var _path$parse = _path2.default.parse(source),
        ext = _path$parse.ext;

    var _path$parse2 = _path2.default.parse(patch),
        dir = _path$parse2.dir,
        name = _path$parse2.name;
    // eslint-disable-next-line


    target = _path2.default.join(dir, '' + name + ext);
  }
  var result = applyBpsPatchFile(source, patch, target, {
    allowOverwrite: cmd.allowOverwrite,
    dryRun: cmd.dryRun,
    checkSourceMd5: cmd.md5
  });
  _logger2.default.on('finish', function () {
    process.exit(result || 0);
  });
});

_commander2.default.command('create <source> <target> [patch]').option('--allow-overwrite', 'Allow overwriting of destination file').option('--dry-run', 'Stop before writing the destination file').description('create a patch from the source and target files').action(function (source, target, patch, cmd) {
  if (!patch) {
    var _path$parse3 = _path2.default.parse(target),
        dir = _path$parse3.dir,
        name = _path$parse3.name;
    // eslint-disable-next-line


    patch = _path2.default.join(dir, name + '.bps');
  }
  var result = createBpsPatchFile(source, target, patch, {
    allowOverwrite: cmd.allowOverwrite,
    dryRun: cmd.dryRun
  });
  _logger2.default.on('finish', function () {
    process.exit(result || 0);
  });
});

_commander2.default.command('*', { noHelp: true, isDefault: true }).on('command:*', function () {
  _commander2.default.help();
});

_commander2.default.parse(process.argv);

if (process.argv.length < 3) {
  _commander2.default.help();
}