mem-fs-editor/lib/actions/copy.js

'use strict';

var assert = require('assert');
var fs = require('fs');
var path = require('path');
var globby = require('globby');
var multimatch = require('multimatch');
var ejs = require('ejs');
var util = require('../util');
var normalize = require('normalize-path');

function applyProcessingFunc(process, contents, filename) {
  var output = process(contents, filename);
  return output instanceof Buffer ? output : Buffer.from(output);
}

exports.copy = function (from, to, options, context, tplSettings) {
  to = path.resolve(to);
  options = options || {};
  var fromGlob = util.globify(from);

  var globOptions = {...options.globOptions, nodir: true};
  var diskFiles = globby.sync(fromGlob, globOptions).map(file => path.resolve(file));
  var storeFiles = [];
  this.store.each(file => {
    // The store may have a glob path and when we try to copy it will fail because not real file
    if (!globby.hasMagic(normalize(file.path)) && multimatch([file.path], fromGlob).length !== 0 && !diskFiles.includes(file.path)) {
      storeFiles.push(file.path);
    }
  });
  var files = diskFiles.concat(storeFiles);

  var generateDestination = () => to;
  if (Array.isArray(from) || !this.exists(from) || globby.hasMagic(normalize(from))) {
    assert(
      !this.exists(to) || fs.statSync(to).isDirectory(),
      'When copying multiple files, provide a directory as destination'
    );

    const processDestinationPath = options.processDestinationPath || (path => path);
    var root = util.getCommonPath(from);
    generateDestination = filepath => {
      var toFile = path.relative(root, filepath);
      return processDestinationPath(path.join(to, toFile));
    };
  }

  // Sanity checks: Makes sure we copy at least one file.
  assert(options.ignoreNoMatch || files.length > 0, 'Trying to copy from a source that does not exist: ' + from);

  files.forEach(file => {
    var toFile = generateDestination(file);
    if (context) {
      toFile = ejs.render(toFile, context, tplSettings);
    }

    this._copySingle(file, toFile, options, context, tplSettings);
  });
};

exports._copySingle = function (from, to, options = {}) {
  assert(this.exists(from), 'Trying to copy from a source that does not exist: ' + from);

  var file = this.store.get(from);

  var contents = file.contents;
  if (options.process) {
    contents = applyProcessingFunc(options.process, file.contents, file.path);
  }

  if (options.append) {
    if (!this.store.existsInMemory) {
      throw new Error('Current mem-fs is not compatible with append');
    }

    if (this.store.existsInMemory(to)) {
      this.append(to, contents, {create: true, ...options});
      return;
    }
  }

  this.write(to, contents, file.stat);
};