deep-package-manager/lib.compiled/Registry/Module/ModuleInstance.js

DEEP Package Manager

/**
 * Created by AlexanderC on 2/3/16.
 */

'use strict';

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

var _fsExtra = require('fs-extra');

var _fsExtra2 = _interopRequireDefault(_fsExtra);

var _createOutputStream = require('create-output-stream');

var _createOutputStream2 = _interopRequireDefault(_createOutputStream);

var _tarStream = require('tar-stream');

var _tarStream2 = _interopRequireDefault(_tarStream);

var _string2stream = require('string2stream');

var _string2stream2 = _interopRequireDefault(_string2stream);

var _FileWalker = require('../../Helpers/FileWalker');

var _WaitFor = require('../../Helpers/WaitFor');

var _GitHubContext = require('../Context/GitHubContext');

var _GitHubModuleInstance = require('./GitHubModuleInstance');

var _AbstractModuleInstance = require('./AbstractModuleInstance');

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

var _fs = require('fs');

var _fs2 = _interopRequireDefault(_fs);

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

class ModuleInstance extends _AbstractModuleInstance.AbstractModuleInstance {
  /**
   * @param {Context} moduleContext
   * @param {String} rawContent
   * @param {Storage|*} storage
   */
  constructor(moduleContext, rawContent, storage) {
    super();

    this._context = moduleContext;
    this._storage = storage;
    this._rawContent = rawContent;
  }

  /**
   * @param {String} modulePath
   * @param {Function} cb
   */
  load(modulePath, cb) {
    let tarStream = _tarStream2.default.pack();

    let walker = new _FileWalker.FileWalker(_FileWalker.FileWalker.RECURSIVE);
    let files = walker.walk(modulePath);

    _WaitFor.WaitFor.waterfall(file => {
      let entryReady = false;
      let entryName = _path2.default.relative(modulePath, file);

      _fs2.default.readFile(file, { encoding: 'ascii' }, (error, fileContent) => {
        if (error) {
          console.error(error);
        } else {
          let plainFileContent = fileContent.toString();

          tarStream.entry({ name: entryName, size: plainFileContent.length }, plainFileContent);
        }

        entryReady = true;
      });

      return () => {
        return entryReady;
      };
    }, () => {
      this._rawContent = '';

      tarStream.on('data', chunk => {
        this._rawContent += chunk.toString();
      });

      tarStream.on('end', cb);
      tarStream.finalize();
    }, ...files);
  }

  /**
   * @param {String} dumpPath
   * @param {Function} cb
   */
  extract(dumpPath, cb) {
    _fsExtra2.default.ensureDir(dumpPath, error => {
      if (error) {
        cb(error);
        return;
      }

      let contentStream = (0, _string2stream2.default)(this._rawContent);
      let unTarStream = _tarStream2.default.extract();

      let wait = new _WaitFor.WaitFor();
      let filesToExtract = 0;

      wait.push(() => {
        return filesToExtract <= 0;
      });

      unTarStream.on('entry', (header, stream, next) => {
        let file = _path2.default.join(dumpPath, header.name);

        filesToExtract++;

        stream.pipe((0, _createOutputStream2.default)(file));

        stream.on('end', () => {
          filesToExtract--;

          next();
        });
      });

      unTarStream.on('finish', () => {
        wait.ready(cb);
      });

      contentStream.pipe(unTarStream);
    });
  }

  /**
   * @returns {stream}
   */
  createExtractStream() {
    let contentStream = (0, _string2stream2.default)(this._rawContent);
    let unTarStream = _tarStream2.default.extract();

    return contentStream.pipe(unTarStream);
  }

  /**
   * @param {Function} cb
   */
  upload(cb) {
    this._storage.uploadModule(this, cb);
  }

  /**
   * @returns {String}
   */
  toString() {
    return this._rawContent;
  }

  /**
   * @returns {String}
   */
  get rawContent() {
    return this._rawContent;
  }

  /**
   * @returns {Storage|*}
   */
  get storage() {
    return this._storage;
  }

  /**
   * @returns {String}
   */
  get moduleName() {
    return this._context.name;
  }

  /**
   * @returns {String}
   */
  get moduleVersion() {
    return this._context.version;
  }

  /**
   * @returns {Context|GitHubContext}
   */
  get context() {
    return this._context;
  }

  /**
   * @param {Context} moduleContext
   * @param {String} rawContent
   * @param {Storage} storage
   * @returns {*}
   */
  static create(moduleContext, rawContent, storage) {
    let ModuleProto = moduleContext instanceof _GitHubContext.GitHubContext ? _GitHubModuleInstance.GitHubModuleInstance : ModuleInstance;

    return new ModuleProto(moduleContext, rawContent, storage);
  }

  /**
   * @returns {String}
   */
  static get ARCHIVE_EXTENSION() {
    return 'tar';
  }
}
exports.ModuleInstance = ModuleInstance;