ember-cli 7.1.0 → 7.2.0-alpha.2

package/packages/blueprint-model/utilities/edit-file-diff.js

@@ -0,0 +1,64 @@
+'use strict';
+
+const fs = require('fs');
+const util = require('util');
+const { applyPatch, createPatch } = require('diff');
+const quickTemp = require('quick-temp');
+const path = require('path');
+const SilentError = require('silent-error');
+const openEditor = require('./open-editor');
+const hash = require('promise.hash.helper');
+
+const readFile = util.promisify(fs.readFile);
+const writeFile = util.promisify(fs.writeFile);
+
+class EditFileDiff {
+  constructor(options) {
+    this.info = options.info;
+
+    quickTemp.makeOrRemake(this, 'tmpDifferenceDir');
+  }
+
+  edit() {
+    return hash({
+      input: this.info.render(),
+      output: readFile(this.info.outputPath),
+    })
+      .then(this.invokeEditor.bind(this))
+      .then(this.applyPatch.bind(this))
+      .finally(this.cleanUp.bind(this));
+  }
+
+  cleanUp() {
+    quickTemp.remove(this, 'tmpDifferenceDir');
+  }
+
+  applyPatch(resultHash) {
+    return hash({
+      diffString: readFile(resultHash.diffPath),
+      currentString: readFile(resultHash.outputPath),
+    }).then((result) => {
+      let appliedDiff = applyPatch(result.currentString.toString(), result.diffString.toString());
+
+      if (!appliedDiff) {
+        let message = 'Patch was not cleanly applied.';
+        this.info.ui.writeLine(`${message} Please choose another action.`);
+        throw new SilentError(message);
+      }
+
+      return writeFile(resultHash.outputPath, appliedDiff);
+    });
+  }
+
+  invokeEditor(result) {
+    let info = this.info;
+    let diff = createPatch(info.outputPath, result.output.toString(), result.input);
+    let diffPath = path.join(this.tmpDifferenceDir, 'currentDiff.diff');
+
+    return writeFile(diffPath, diff)
+      .then(() => openEditor(diffPath))
+      .then(() => ({ outputPath: info.outputPath, diffPath }));
+  }
+}
+
+module.exports = EditFileDiff;

package/packages/blueprint-model/utilities/experiments.js

@@ -0,0 +1,63 @@
+'use strict';
+
+const { default: chalk } = require('chalk');
+
+/*
+  If you're here to remove the VITE experiment flag in favor of it being
+  permanently on, you can't do that until addressing
+  https://github.com/ember-cli/ember-cli/pull/10781#pullrequestreview-3230644293
+
+  A lot of test coverage would otherwise be lost, because valid tests are being
+  run only when the VITE experiment is off.
+*/
+const availableExperiments = Object.freeze(['EMBROIDER', 'CLASSIC', 'VITE']);
+
+const deprecatedExperiments = Object.freeze([]);
+const enabledExperiments = Object.freeze(['VITE']);
+const deprecatedExperimentsDeprecationsIssued = [];
+
+function isExperimentEnabled(experimentName) {
+  if (!availableExperiments.includes(experimentName)) {
+    return false;
+  }
+
+  if (process.env.EMBER_CLI_ENABLE_ALL_EXPERIMENTS && deprecatedExperiments.includes(experimentName)) {
+    return false;
+  }
+
+  if (process.env.EMBER_CLI_ENABLE_ALL_EXPERIMENTS) {
+    return true;
+  }
+
+  if (process.env.EMBER_CLI_CLASSIC && experimentName === 'EMBROIDER') {
+    return false;
+  }
+
+  let experimentEnvironmentVariable = `EMBER_CLI_${experimentName}`;
+  let experimentValue = process.env[experimentEnvironmentVariable];
+
+  if (deprecatedExperiments.includes(experimentName)) {
+    let deprecationPreviouslyIssued = deprecatedExperimentsDeprecationsIssued.includes(experimentName);
+    let isSpecifiedByUser = experimentValue !== undefined;
+
+    if (!deprecationPreviouslyIssued && isSpecifiedByUser) {
+      console.warn(
+        chalk.yellow(`The ${experimentName} experiment in ember-cli has been deprecated and will be removed.`)
+      );
+      deprecatedExperimentsDeprecationsIssued.push(experimentName);
+    }
+  }
+
+  if (enabledExperiments.includes(experimentName)) {
+    return experimentValue !== 'false';
+  } else {
+    return experimentValue !== undefined && experimentValue !== 'false';
+  }
+}
+
+module.exports = {
+  isExperimentEnabled,
+
+  // exported for testing purposes
+  _deprecatedExperimentsDeprecationsIssued: deprecatedExperimentsDeprecationsIssued,
+};

package/packages/blueprint-model/utilities/file-info.js

@@ -0,0 +1,170 @@
+'use strict';
+
+const fs = require('fs');
+const util = require('util');
+const { default: chalk } = require('chalk');
+const EditFileDiff = require('./edit-file-diff');
+const EOL = require('os').EOL;
+const rxEOL = new RegExp(EOL, 'g');
+const isBinaryFile = require('isbinaryfile').isBinaryFileSync;
+const hash = require('promise.hash.helper');
+const canEdit = require('./open-editor').canEdit;
+const processTemplate = require('./process-template');
+
+const readFile = util.promisify(fs.readFile);
+const lstat = util.promisify(fs.stat);
+
+function diffHighlight(line) {
+  if (line[0] === '+') {
+    return chalk.green(line);
+  } else if (line[0] === '-') {
+    return chalk.red(line);
+  } else if (/^@@/.test(line)) {
+    return chalk.cyan(line);
+  } else {
+    return line;
+  }
+}
+
+const NOOP = (_) => _;
+class FileInfo {
+  constructor(options) {
+    this.action = options.action;
+    this.outputBasePath = options.outputBasePath;
+    this.outputPath = options.outputPath;
+    this.displayPath = options.displayPath;
+    this.inputPath = options.inputPath;
+    this.templateVariables = options.templateVariables;
+    this.replacer = options.replacer || NOOP;
+    this.ui = options.ui;
+  }
+
+  confirmOverwrite(path) {
+    let promptOptions = {
+      type: 'expand',
+      name: 'answer',
+      default: false,
+      message: `${chalk.red('Overwrite')} ${path}?`,
+      choices: [
+        { key: 'y', name: 'Yes, overwrite', value: 'overwrite' },
+        { key: 'n', name: 'No, skip', value: 'skip' },
+      ],
+    };
+
+    let outputPathIsFile = false;
+    try {
+      outputPathIsFile = fs.statSync(this.outputPath).isFile();
+    } catch (err) {
+      /* ignore */
+    }
+
+    let canDiff = !isBinaryFile(this.inputPath) && (!outputPathIsFile || !isBinaryFile(this.outputPath));
+
+    if (canDiff) {
+      promptOptions.choices.push({ key: 'd', name: 'Diff', value: 'diff' });
+
+      if (canEdit()) {
+        promptOptions.choices.push({ key: 'e', name: 'Edit', value: 'edit' });
+      }
+    }
+
+    return this.ui.prompt(promptOptions).then((response) => response.answer);
+  }
+
+  displayDiff() {
+    let info = this,
+      { createPatch } = require('diff');
+    return hash({
+      input: this.render(),
+      output: readFile(info.outputPath),
+    }).then((result) => {
+      let diff = createPatch(
+        info.outputPath,
+        result.output.toString().replace(rxEOL, '\n'),
+        result.input.replace(rxEOL, '\n')
+      );
+      let lines = diff.split('\n');
+
+      for (let i = 0; i < lines.length; i++) {
+        info.ui.write(diffHighlight(lines[i] + EOL));
+      }
+    });
+  }
+
+  async render() {
+    if (!this.rendered) {
+      let result = await this._render();
+      this.rendered = this.replacer(result, this);
+    }
+
+    return this.rendered;
+  }
+
+  _render() {
+    let path = this.inputPath;
+    let context = this.templateVariables;
+
+    return readFile(path).then((content) =>
+      lstat(path).then((fileStat) => {
+        if (isBinaryFile(content, fileStat.size)) {
+          return content;
+        } else {
+          try {
+            return processTemplate(content.toString(), context);
+          } catch (err) {
+            err.message += ` (Error in blueprint template: ${path})`;
+            throw err;
+          }
+        }
+      })
+    );
+  }
+
+  checkForConflict() {
+    return this.render().then((input) => {
+      input = input.toString().replace(rxEOL, '\n');
+
+      return readFile(this.outputPath)
+        .then((output) => {
+          output = output.toString().replace(rxEOL, '\n');
+
+          return input === output ? 'identical' : 'confirm';
+        })
+        .catch((e) => {
+          if (e.code === 'ENOENT') {
+            return 'none';
+          }
+
+          throw e;
+        });
+    });
+  }
+
+  confirmOverwriteTask() {
+    let info = this;
+
+    return function () {
+      function doConfirm() {
+        return info.confirmOverwrite(info.displayPath).then((action) => {
+          if (action === 'diff') {
+            return info.displayDiff().then(doConfirm);
+          } else if (action === 'edit') {
+            let editFileDiff = new EditFileDiff({ info });
+            return editFileDiff
+              .edit()
+              .then(() => (info.action = action))
+              .catch(() => doConfirm())
+              .then(() => info);
+          } else {
+            info.action = action;
+            return info;
+          }
+        });
+      }
+
+      return doConfirm();
+    };
+  }
+}
+
+module.exports = FileInfo;

package/packages/blueprint-model/utilities/open-editor.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const spawn = require('child_process').spawn;
+
+function openEditor(file) {
+  if (!openEditor.canEdit()) {
+    throw new Error('EDITOR environment variable is not set');
+  }
+
+  if (!file) {
+    throw new Error('No `file` option provided');
+  }
+
+  let editorArgs = openEditor._env().EDITOR.split(' ');
+  let editor = editorArgs.shift();
+  const args = [file].concat(editorArgs);
+  let editProcess = openEditor._spawn(editor, args, { stdio: 'inherit' });
+
+  return new Promise((resolve, reject) => {
+    editProcess.on('close', (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(
+          new Error(`Spawn('${editor}', [${args.join(',')}]) exited with a non zero error status code: '${code}'`)
+        );
+      }
+    });
+  });
+}
+
+openEditor.canEdit = function () {
+  return openEditor._env().EDITOR !== undefined;
+};
+
+openEditor._env = function () {
+  return process.env;
+};
+
+openEditor._spawn = function () {
+  return spawn.apply(this, arguments);
+};
+
+module.exports = openEditor;

package/packages/blueprint-model/utilities/prepend-emoji.js

@@ -0,0 +1,12 @@
+'use strict';
+
+function supportEmoji() {
+  const hasEmojiTurnedOff = process.argv.indexOf('--no-emoji') > -1;
+  return process.stdout.isTTY && process.platform !== 'win32' && !hasEmojiTurnedOff;
+}
+
+const areEmojiSupported = supportEmoji();
+
+module.exports = function prependEmoji(emoji, msg) {
+  return areEmojiSupported ? `${emoji}  ${msg}` : msg;
+};

package/packages/blueprint-model/utilities/process-template.js

@@ -0,0 +1,10 @@
+'use strict';
+
+module.exports = function processTemplate(content, context) {
+  let options = {
+    evaluate: /<%([\s\S]+?)%>/g,
+    interpolate: /<%=([\s\S]+?)%>/g,
+    escape: /<%-([\s\S]+?)%>/g,
+  };
+  return require('lodash/template')(content, options)(context);
+};

package/patches/ember-cli-blueprint-test-helpers.patch

@@ -0,0 +1,15 @@
+diff --git a/lib/helpers/setup.js b/lib/helpers/setup.js
+index c337ec0020f46e0e9ed3f76b325c7d174168a900..29dfd7fb0acd5ae895d470b80be15bf1c8ff9a25 100644
+--- a/lib/helpers/setup.js
++++ b/lib/helpers/setup.js
+@@ -31,7 +31,9 @@ module.exports = function setupTestHooks(scope, options) {
+   }
+ 
+   if (disabledTasks.length) {
+-    let Blueprint = requireFromCLI('lib/models/blueprint');
++    let Blueprint = require('@ember-tooling/blueprint-model', {
++      paths: [options.cliPath]
++    });
+ 
+     before(() => {
+       MockBlueprintTaskFor.disableTasks(Blueprint, disabledTasks);

package/tests/helpers/acceptance.js

@@ -139,11 +139,7 @@ async function createAndInstallTestTargets(projectName, options) {
 
   let result = await applyCommand(command, projectName, '--skip-npm', `--directory=${outputDir.path}`);
 
-  await execa('pnpm', ['install', '--prefer-offline'], {
-    preferLocal: true,
-    cwd: outputDir.path,
-  });
-
+  // we need to link these packages before we try to run pnpm install so it always uses the current version of ember-cli and the sub-packages
   for (let pkg of [
     '.',
     'packages/blueprint-model',
@@ -157,6 +153,11 @@ async function createAndInstallTestTargets(projectName, options) {
     });
   }
 
+  await execa('pnpm', ['install', '--prefer-offline'], {
+    preferLocal: true,
+    cwd: outputDir.path,
+  });
+
   return {
     result,
     cleanup: outputDir.cleanup,

package/tests/helpers/fixturify-project.js

@@ -4,9 +4,10 @@ const path = require('path');
 const merge = require('lodash/merge');
 // this is a test-only dependency
 // eslint-disable-next-line n/no-unpublished-require
-const FixturifyProject = require('fixturify-project');
+const { Project: FixturifyProject } = require('fixturify-project');
 const Project = require('../../lib/models/project');
 const MockCLI = require('./mock-cli');
+const { readFile } = require('fs/promises');
 
 // used in these tests to ensure we are only
 // operating on the addons added here
@@ -45,22 +46,9 @@ function getOptionsObjectWithCallbackFunction(defaultOptions, optionsOrCallback)
   );
 }
 
-// Essentially a copy of the function in node-fixturify-project, converted from TS to JS.
-// We need this for use during toJSON().
-function parseScoped(name) {
-  let matched = name.match(/(@[^@/]+)\/(.*)/);
-  if (matched) {
-    return {
-      scope: matched[1],
-      name: matched[2],
-    };
-  }
-  return null;
-}
-
 module.exports = class EmberCLIFixturifyProject extends FixturifyProject {
-  writeSync() {
-    super.writeSync(...arguments);
+  async write() {
+    await super.write(...arguments);
     this._hasWritten = true;
   }
 
@@ -68,26 +56,24 @@ module.exports = class EmberCLIFixturifyProject extends FixturifyProject {
     merge(this.files, filesObj);
   }
 
-  buildProjectModel(ProjectClass = ProjectWithoutInternalAddons) {
+  async buildProjectModel(ProjectClass = ProjectWithoutInternalAddons) {
     if (!this._hasWritten) {
-      this.writeSync();
+      await this.write();
     }
 
-    let pkg = JSON.parse(this.toJSON('package.json'));
     let cli = new MockCLI();
-    let root = path.join(this.root, this.name);
 
-    return new ProjectClass(root, pkg, cli.ui, cli);
+    return new ProjectClass(this.baseDir, this.pkg, cli.ui, cli);
   }
 
-  buildProjectModelForInRepoAddon(addonName, ProjectClass = ProjectWithoutInternalAddons) {
+  async buildProjectModelForInRepoAddon(addonName, ProjectClass = ProjectWithoutInternalAddons) {
     if (!this._hasWritten) {
-      this.writeSync();
+      await this.write();
     }
 
-    let pkg = JSON.parse(this.files.lib[addonName]['package.json']);
+    let root = path.join(this.baseDir, 'lib', addonName);
+    let pkg = JSON.parse(await readFile(path.join(root, 'package.json'), 'utf8'));
     let cli = new MockCLI();
-    let root = path.join(this.root, this.name, 'lib', addonName);
 
     return new ProjectClass(root, pkg, cli.ui, cli);
   }
@@ -105,31 +91,7 @@ module.exports = class EmberCLIFixturifyProject extends FixturifyProject {
    */
   addDependency(name, version, optionsOrCallback) {
     const options = getOptionsObjectWithCallbackFunction(optionsOrCallback);
-    return super.addDependency(name, version, options.callback);
-  }
-
-  /**
-   * Add a 'reference' entry to this object's `dependencies` list. A 'reference' dependency is
-   * an entry in `dependencies` where the caller knows the dependency's source files are being
-   * created elsewhere in the project tree, so no source files should be created locally in
-   * `node_modules`, which is the standard FixturifyProject (and node-fixturify-project) behavior.
-   * We do this by adding the necessary reference to `dependencies` during `toJSON`.
-   *
-   * This is used when two addons wish to share a single definition on disk for a dependency (various parts of
-   * ember-cli optimize processing based on paths on disk.)
-   *
-   * Because there is no FixturifyProject being created, no callback is given as in other methods.
-   *
-   * @param {String} name name of the dependency
-   * @param {String} version version of the dependency, defaults to '*'. For our purposes, '*' means
-   * "whatever version was specified elsewhere."
-   */
-  addReferenceDependency(name, version = '*') {
-    if (!this._referenceDependencies) {
-      this._referenceDependencies = {};
-    }
-
-    this._referenceDependencies[name] = version;
+    return super.addDependency(new this.constructor(name, version), options.callback);
   }
 
   /**
@@ -148,30 +110,6 @@ module.exports = class EmberCLIFixturifyProject extends FixturifyProject {
     return super.addDevDependency(name, version, options.callback);
   }
 
-  /**
-   * Add a 'reference' entry to this object's `devDependencies` list. A 'reference' devDependency is
-   * an entry in `devDependencies` where the caller knows the dependency's source files are being
-   * created elsewhere in the project tree, so no source files should be created locally in
-   * `node_modules`, which is the standard FixturifyProject (and node-fixturify-project) behavior.
-   * We do this by adding the necessary reference to `devDependencies` during `toJSON`.
-   *
-   * This is used when two addons wish to share a single definition on disk for a devDependency
-   * (various parts of ember-cli optimize processing based on paths on disk.)
-   *
-   * Because there is no FixturifyProject being created, no callback is given as in other methods.
-   *
-   * @param {String} name name of the devDependency
-   * @param {String} version version of the devDependency, defaults to '*'. For our purposes, '*' means
-   * "whatever version was specified elsewhere."
-   */
-  addReferenceDevDependency(name, version = '*') {
-    if (!this._referenceDevDependencies) {
-      this._referenceDevDependencies = {};
-    }
-
-    this._referenceDevDependencies[name] = version;
-  }
-
   /**
    * Add an addon to this object's `dependencies` list. The addon files will be written in
    * this object's `node_modules/<addon_name>` directory when this object is written out.
@@ -274,15 +212,22 @@ module.exports = class EmberCLIFixturifyProject extends FixturifyProject {
    * a callback function while also specifying other properties.)
    * @returns {FixturifyProject} the newly-created addon
    */
-  addInRepoAddon(name, version = '0.0.0', optionsOrCallback) {
+  async addInRepoAddon(name, version = '0.0.0', optionsOrCallback) {
     const options = getOptionsObjectWithCallbackFunction({ allowCachingPerBundle: false }, optionsOrCallback);
 
-    const inRepoAddon = new EmberCLIFixturifyProject(name, version, (addon) => {
-      prepareAddon(addon, options);
+    let inRepoAddon;
 
-      if (typeof options.callback === 'function') {
-        options.callback(addon);
-      }
+    await new Promise((resolve) => {
+      inRepoAddon = new EmberCLIFixturifyProject(name, version, async (addon) => {
+        prepareAddon(addon, options);
+
+        if (typeof options.callback === 'function') {
+          await options.callback(addon);
+          resolve();
+        } else {
+          resolve();
+        }
+      });
     });
 
     // configure the current project to have an ember-addon configured at the
@@ -301,10 +246,9 @@ module.exports = class EmberCLIFixturifyProject extends FixturifyProject {
 
     addon.paths.push(addonPath);
 
-    this.files[addonRootDir] = this.files[addonRootDir] || {};
+    inRepoAddon.baseDir = path.join(this.baseDir, addonRootDir, inRepoAddon.pkg.name);
 
-    let addonJSON = inRepoAddon.toJSON();
-    Object.assign(this.files[addonRootDir], addonJSON);
+    await inRepoAddon.write();
     return inRepoAddon;
   }
 
@@ -322,12 +266,12 @@ module.exports = class EmberCLIFixturifyProject extends FixturifyProject {
    * @returns {FixturifyProject} the newly-created addon
    */
   addInRepoEngine(name, version = '0.0.0', options = { allowCachingPerBundle: false, enableLazyLoading: false }) {
-    const callback = (engine) => {
+    const callback = async (engine) => {
       engine.pkg.keywords.push('ember-engine');
 
       // call original callback if it exists
       if (typeof options.callback === 'function') {
-        options.callback(engine);
+        await options.callback(engine);
       }
     };
 
@@ -341,56 +285,4 @@ module.exports = class EmberCLIFixturifyProject extends FixturifyProject {
 
     return this.addInRepoAddon(name, version, { ...options, callback });
   }
-
-  /**
-   * Convert the object into a data structure suitable for passing to `fixturify`.
-   *
-   * @param {String} key optional key. If specified, the object will be run through toJSON, then the given
-   * property extracted and returned.
-   * @returns {Object} the `toJSON` value of the object (wrapped) or the toJSON value of the specified field
-   * (not wrapped.)
-   */
-  toJSON(key) {
-    if (key) {
-      return super.toJSON(key);
-    }
-
-    let jsonData = super.toJSON();
-
-    let scoped = parseScoped(this.name);
-
-    // Allowing for scoped names, get the object in the JSON structure that corresponds
-    // to this FixturifyProject.
-    let container = scoped ? jsonData[scoped.scope][scoped.name] : jsonData[this.name];
-
-    if (this._referenceDependencies || this._referenceDevDependencies) {
-      let pkg = JSON.parse(container['package.json']);
-
-      if (this._referenceDependencies) {
-        if (!pkg.dependencies) {
-          pkg.dependencies = {};
-        }
-
-        Object.assign(pkg.dependencies, this._referenceDependencies);
-      }
-
-      if (this._referenceDevDependencies) {
-        if (!pkg.devDependencies) {
-          pkg.devDependencies = {};
-        }
-
-        Object.assign(pkg.devDependencies, this._referenceDevDependencies);
-      }
-
-      container['package.json'] = JSON.stringify(pkg, undefined, 2);
-    }
-
-    // an optimization to remove any node_modules declaration that has nothing in it,
-    // to avoid creating extra directories for no reason.
-    if (container['node_modules'] && Object.keys(container['node_modules']).length === 0) {
-      delete container['node_modules'];
-    }
-
-    return jsonData;
-  }
 };