endl/lib/file.js

// Generated by CoffeeScript 1.9.3
var EventEmitter, File, Zip, _extend, basename, bhttp, createWriteStream, dirname, execFile, extname, join, mime, minimatch, mkdirp, normalize, parse, path, ref, sanitize, stat, url;

mime = require('mime');

url = require('url');

parse = url.parse;

path = require('path');

normalize = path.normalize, dirname = path.dirname, basename = path.basename, extname = path.extname, join = path.join;

_extend = require('util')._extend;

ref = require('fs'), createWriteStream = ref.createWriteStream, stat = ref.stat;

sanitize = require('sanitize-filename');

mkdirp = require('mkdirp');

execFile = require('child_process').execFile;

Zip = require('adm-zip');

minimatch = require('minimatch');

bhttp = require('bhttp');

EventEmitter = require('events').EventEmitter;

File = (function() {
  function File(_url, _pageUrl) {
    this._url = _url;
    this._pageUrl = _pageUrl;
    this._ee = new EventEmitter();
  }

  File.prototype._bindCallback = function(response, callback, data) {
    if (typeof callback === 'function') {
      return response.on('end', function() {
        return callback(data);
      });
    }
  };

  File.prototype._getDefaultDownloadOptions = function() {
    return {
      headers: {},
      pageUrlAsReferrer: false,
      filenameMode: {
        contentDisposition: false,
        urlBasename: false,
        contentType: false,
        predefined: false,
        redirect: false
      },
      directory: ''
    };
  };

  File.prototype._getExtension = function(contentType) {
    var extension;
    if (contentType != null) {
      extension = mime.extension(contentType);
      if (extension != null) {
        extension = "." + extension;
      }
    }
    return extension;
  };

  File.prototype._getFilename = function(initialUrl, options, response) {
    var filename;
    if (typeof options.filenameMode.predefined === 'string') {
      filename = sanitize(options.filenameMode.predefined);
    } else if (options.filenameMode.urlBasename === true) {
      if (options.filenameMode.redirect === true) {
        filename = basename(parse(response.request.url).pathname);
      } else {
        filename = basename(parse(initialUrl).pathname);
      }
      filename = decodeURIComponent(filename);
    }
    return filename;
  };

  File.prototype.download = function(options, callback) {
    var domain, downloadCallback, downloadUrl, requestOptions, thisClass, type;
    thisClass = this;
    downloadUrl = this._url;
    type = typeof options;
    if (type === 'string') {
      options = {
        filenameMode: {
          predefined: options
        }
      };
    } else if (type === 'object' && Object.keys(options).length === 0) {
      options = {
        filenameMode: {
          urlBasename: true
        }
      };
    }
    options = _extend(this._getDefaultDownloadOptions(), options);
    requestOptions = {
      headers: options.headers,
      stream: true,
      noDecode: true
    };
    if (downloadUrl[0] === '/' && this._pageUrl.length > 0) {
      domain = url.resolve(this._pageUrl, '/').replace(/\/$/, '');
      downloadUrl = domain + downloadUrl;
    }
    if (options.pageUrlAsReferrer === true) {
      requestOptions.headers.referer = this._pageUrl ? this._pageUrl : downloadUrl;
    }
    downloadCallback = function(err, response) {
      var callbackData, cdFilename, contentDisposition, contentType, extension, filename, startDownload;
      if (err) {
        throw err;
      }
      contentType = response.headers['content-type'];
      extension = thisClass._getExtension(contentType);
      filename = thisClass._getFilename(downloadUrl, options, response);
      if (options.filenameMode.urlBasename === true && options.filenameMode.contentType === true && (extension != null) && extension !== extname(filename)) {
        filename += extension;
      }
      contentDisposition = response.headers['content-disposition'];
      if (options.filenameMode.contentDisposition === true && (contentDisposition != null)) {
        cdFilename = contentDisposition.split('filename=')[1].replace(/"/g, '');
        if (cdFilename.length > 0) {
          filename = sanitize(cdFilename);
        }
      }
      if (filename == null) {
        throw new Error('File name is not defined');
      }
      options.directory = path.resolve(options.directory);
      thisClass._file = join(options.directory, filename);
      callbackData = {
        url: downloadUrl,
        file: thisClass._file
      };
      startDownload = function() {
        thisClass._stream = createWriteStream(thisClass._file);
        thisClass._ee.emit('create');
        File.prototype._bindCallback(response, callback, callbackData);
        return response.pipe(thisClass._stream);
      };
      return stat(options.directory, function(err, stats) {
        if (err && err.code === 'ENOENT') {
          return mkdirp(options.directory, function() {
            return startDownload();
          });
        } else if (!err) {
          return startDownload();
        } else {
          throw err;
        }
      });
    };
    this._req = bhttp.get(downloadUrl, requestOptions, downloadCallback);
    return this;
  };

  File.prototype._getDefaultExtractOptions = function() {
    return {
      to: '',
      cd: false,
      cdRegex: false,
      fileGlob: false,
      maintainEntryPath: true,
      overwrite: true
    };
  };

  File.prototype._extractOnFinish = function(options, callback) {
    var cdRegex, cdRegexSuffix, entries, extracted, zip;
    zip = new Zip(this._file);
    entries = zip.getEntries();
    options = _extend(this._getDefaultExtractOptions(), options);
    cdRegexSuffix = '([^\\\/\\\\]*(\\\/|\\\\))';
    cdRegex = null;
    if (typeof options.cd === 'string' || typeof options.cdRegex === 'string') {
      if (typeof options.cd === 'string') {
        cdRegex = new RegExp("^" + options.cd + cdRegexSuffix);
      } else if (typeof options.cdRegex === 'string') {
        cdRegex = new RegExp("" + options.cdRegex + cdRegexSuffix);
      }
      entries = entries.filter(function(entry) {
        if (cdRegex != null) {
          return cdRegex.test(entry.entryName);
        } else {
          return true;
        }
      });
    }
    if (typeof options.fileGlob === 'string') {
      entries = entries.filter(function(entry) {
        return minimatch(entry.name, options.fileGlob);
      });
    }
    extracted = [];
    entries.forEach(function(entry) {
      var fromPath, targetDirname, toPath;
      fromPath = entry.entryName;
      if (options.maintainEntryPath) {
        targetDirname = dirname(entry.entryName);
        if (cdRegex !== null) {
          targetDirname = targetDirname.replace(cdRegex, '');
        }
        toPath = join(options.to, targetDirname);
      } else {
        toPath = options.to;
      }
      extracted.push({
        from: fromPath,
        to: toPath
      });
      return zip.extractEntryTo(fromPath, toPath, false, options.overwrite);
    });
    if (typeof callback === 'function') {
      return callback(extracted);
    }
  };

  File.prototype.extract = function(options, callback) {
    var thisClass;
    thisClass = this;
    return thisClass._ee.on('create', function() {
      return thisClass._stream.on('finish', thisClass._extractOnFinish.bind(thisClass, options, callback));
    });
  };

  File.prototype._executeOnFinish = function(options) {
    var args;
    if (options instanceof Array) {
      args = options;
      options = {};
    } else if (typeof options === 'object') {
      if (options.hasOwnProperty('args')) {
        args = options.args;
      }
    } else {
      options = options != null ? options : {};
    }
    delete options.args;
    return execFile(this._file, args, options);
  };

  File.prototype.execute = function(options) {
    var thisClass;
    thisClass = this;
    return thisClass._ee.on('create', function() {
      return thisClass._stream.on('finish', thisClass._executeOnFinish.bind(thisClass, options));
    });
  };

  return File;

})();

module.exports = File;