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

DEEP Package Manager

/**
 * Created by CCristi on 6/16/16.
 */

'use strict';

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

var _ModuleInstance = require('./ModuleInstance');

var _StandardStrategy = require('../GitHub/ExtractStrategy/StandardStrategy');

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

var _GitHubDriver = require('../Storage/Driver/GitHubDriver');

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

var _tarStream2 = _interopRequireDefault(_tarStream);

var _gunzipMaybe = require('gunzip-maybe');

var _gunzipMaybe2 = _interopRequireDefault(_gunzipMaybe);

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

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

var _createOutputStream2 = _interopRequireDefault(_createOutputStream);

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

class GitHubModuleInstance extends _ModuleInstance.ModuleInstance {
  /**
   * @param {Object} args
   */
  constructor(...args) {
    super(...args);
  }

  /**
   * @param {String} dumpPath
   * @param {Function} cb
   */
  extract(dumpPath, cb) {
    let moduleUri = this.storage.strategy.getModuleLocation(this.context);

    this._gitHubDriver.readObjStreamed(moduleUri, (error, streamResponse) => {
      if (error) {
        cb(error, null);
        return;
      }

      this._extractResponse(streamResponse, dumpPath, cb);
    });
  }

  /**
   * @param {stream.Stream|*} dataStream
   * @param {String} dumpPath
   * @param {Function} cb
   * @param {AbstractStrategy|StandardStrategy|null} extractStrategy
   * @private
   */
  _extractResponse(dataStream, dumpPath, cb, extractStrategy = null) {
    console.debug(`Dumping '${this.context}' dependency into '${dumpPath}'`);

    let unTarStream = _tarStream2.default.extract();
    let wait = new _WaitFor.WaitFor();
    let filesToExtract = 0;

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

    unTarStream.on('entry', (header, stream, next) => {
      if (header.type === 'directory') {
        stream.resume().on('end', next);
        return;
      }

      filesToExtract++;

      let filePath = header.name.replace(/^([^\/]+\/)/, '');

      if (this._haveToDump(filePath)) {
        let file = _path2.default.join(dumpPath, _StandardStrategy.StandardStrategy.normalizeFilePath(filePath));
        let output = (0, _createOutputStream2.default)(file);

        output.on('finish', () => {
          filesToExtract--;
          next();
        });

        stream.pipe(output);
        return;
      }

      filesToExtract--;
      stream.resume().on('end', next);
    });

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

    dataStream.setDefaultEncoding('binary');

    dataStream.pipe((0, _gunzipMaybe2.default)()).pipe(unTarStream);
  }

  /**
   * @param {String} filePath
   * @returns {Boolean}
   * @private
   */
  _haveToDump(filePath) {
    let depName = this.context.name;
    let regExp = new RegExp(`^\/?src\/${depName}\/`, 'i');

    return regExp.test(filePath);
  }

  /**
   * @returns {GitHubDriver}
   */
  get _gitHubDriver() {
    return this.storage.driver.find(_GitHubDriver.GitHubDriver);
  }
}
exports.GitHubModuleInstance = GitHubModuleInstance;