ember-cli 7.4.0-beta.1 → 7.5.0-alpha.1

package/packages/blueprint-model/node_modules/.bin/markdown-it

@@ -0,0 +1,21 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -z "$NODE_PATH" ]; then
+  export NODE_PATH="/home/runner/work/ember-cli/ember-cli/node_modules/.pnpm/markdown-it@14.3.2/node_modules/markdown-it/bin/node_modules:/home/runner/work/ember-cli/ember-cli/node_modules/.pnpm/markdown-it@14.3.2/node_modules/markdown-it/node_modules:/home/runner/work/ember-cli/ember-cli/node_modules/.pnpm/markdown-it@14.3.2/node_modules:/home/runner/work/ember-cli/ember-cli/node_modules/.pnpm/node_modules"
+else
+  export NODE_PATH="/home/runner/work/ember-cli/ember-cli/node_modules/.pnpm/markdown-it@14.3.2/node_modules/markdown-it/bin/node_modules:/home/runner/work/ember-cli/ember-cli/node_modules/.pnpm/markdown-it@14.3.2/node_modules/markdown-it/node_modules:/home/runner/work/ember-cli/ember-cli/node_modules/.pnpm/markdown-it@14.3.2/node_modules:/home/runner/work/ember-cli/ember-cli/node_modules/.pnpm/node_modules:$NODE_PATH"
+fi
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../markdown-it/bin/markdown-it.mjs" "$@"
+else
+  exec node  "$basedir/../markdown-it/bin/markdown-it.mjs" "$@"
+fi

package/packages/blueprint-model/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@ember-tooling/blueprint-model",
+  "version": "0.7.1",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ember-cli/ember-cli.git",
+    "directory": "packages/blueprint-model"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "babel-remove-types": "^2.0.0",
+    "chalk": "^5.6.2",
+    "content-tag": "^4.0.0",
+    "core-object": "^3.1.5",
+    "diff": "^8.0.4",
+    "ember-cli-normalize-entity-name": "^1.0.0",
+    "ember-cli-string-utils": "^1.1.0",
+    "fs-extra": "^11.3.4",
+    "heimdalljs-logger": "^0.1.10",
+    "inflection": "^3.0.2",
+    "isbinaryfile": "^5.0.7",
+    "lodash": "^4.17.23",
+    "markdown-it": "^14.1.0",
+    "markdown-it-terminal": "^0.4.0",
+    "minimatch": "^10.1.1",
+    "promise.hash.helper": "^1.0.8",
+    "quick-temp": "^0.1.9",
+    "silent-error": "^1.1.1",
+    "walk-sync": "^4.0.0"
+  }
+}

package/packages/blueprint-model/utilities/clean-remove.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs-extra');
+const walkUp = require('./walk-up-path');
+
+async function cleanRemove(fileInfo) {
+  try {
+    await fs.stat(fileInfo.outputPath);
+    await fs.remove(fileInfo.outputPath);
+    let paths = walkUp(fileInfo.displayPath).map((thePath) => path.join(fileInfo.outputBasePath, thePath));
+
+    for (let thePath of paths) {
+      let childPaths = await fs.readdir(thePath);
+      if (childPaths.length > 0) {
+        return;
+      }
+
+      await fs.remove(thePath);
+    }
+  } catch (err) {
+    // you tried to destroy a blueprint without first generating it
+    // instead of trying to read dirs that don't exist
+    // swallow error and carry on
+    if (err.code !== 'ENOENT') {
+      throw err;
+    }
+  }
+}
+
+module.exports = cleanRemove;

package/packages/blueprint-model/utilities/directory-for-package-name.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const path = require('path');
+
+/**
+ * Derive a directory name from a package name.
+ * Takes scoped packages into account.
+ *
+ * @method directoryForPackageName
+ * @param {String} packageName
+ * @return {String} Derived directory name.
+ */
+module.exports = function directoryForPackageName(packageName) {
+  let isScoped = packageName[0] === '@' && packageName.includes('/');
+
+  if (isScoped) {
+    let slashIndex = packageName.indexOf('/');
+    let scopeName = packageName.substring(1, slashIndex);
+    let packageNameWithoutScope = packageName.substring(slashIndex + 1);
+    let pathParts = process.cwd().split(path.sep);
+    let parentDirectoryContainsScopeName = pathParts.includes(scopeName);
+
+    if (parentDirectoryContainsScopeName) {
+      return packageNameWithoutScope;
+    } else {
+      return `${scopeName}-${packageNameWithoutScope}`;
+    }
+  } else {
+    return packageName;
+  }
+};

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/insert-into-file.js

@@ -0,0 +1,125 @@
+'use strict';
+
+const fs = require('fs-extra');
+const EOL = require('os').EOL;
+
+/**
+  Inserts the given content into a file. If the `contentsToInsert` string is already
+  present in the current contents, the file will not be changed unless `force` option
+  is passed.
+
+  If `options.before` is specified, `contentsToInsert` will be inserted before
+  the first instance of that string.  If `options.after` is specified, the
+  contents will be inserted after the first instance of that string.
+  If the string specified by options.before or options.after is not in the file,
+  no change will be made. Both of these options support regular expressions.
+
+  If neither `options.before` nor `options.after` are present, `contentsToInsert`
+  will be inserted at the end of the file.
+
+  It will create a new file if one doesn't exist, unless you set the `options.create`
+  option to `false`.
+
+  Example:
+
+  ```
+  // app/router.js
+  Router.map(function () {
+  });
+  ```
+
+  ```
+  insertIntoFile('app/router.js', '  this.route("admin");', {
+    after: 'Router.map(function () {' + EOL
+  });
+  ```
+
+  ```
+  // app/router.js
+  Router.map(function () {
+    this.route("admin");
+  });
+  ```
+
+  @method insertIntoFile
+  @param {String} pathRelativeToProjectRoot
+  @param {String} contentsToInsert
+  @param {Object} providedOptions
+  @return {Promise}
+*/
+async function insertIntoFile(fullPath, contentsToInsert, providedOptions) {
+  let options = providedOptions || {};
+
+  let returnValue = {
+    path: fullPath,
+    originalContents: '',
+    contents: '',
+    inserted: false,
+  };
+
+  let exists = fs.existsSync(fullPath);
+
+  if (exists || (!exists && options.create !== false)) {
+    let originalContents = '';
+
+    if (exists) {
+      originalContents = fs.readFileSync(fullPath, { encoding: 'utf8' });
+    }
+
+    let contentsToWrite = originalContents;
+
+    let alreadyPresent = originalContents.indexOf(contentsToInsert) > -1;
+    let insert = !alreadyPresent;
+    let insertBehavior = 'end';
+
+    if (options.before) {
+      insertBehavior = 'before';
+    }
+    if (options.after) {
+      insertBehavior = 'after';
+    }
+
+    if (options.force) {
+      insert = true;
+    }
+
+    if (insert) {
+      if (insertBehavior === 'end') {
+        contentsToWrite += contentsToInsert;
+      } else {
+        let contentMarker = options[insertBehavior];
+        if (contentMarker instanceof RegExp) {
+          let matches = contentsToWrite.match(contentMarker);
+          if (matches) {
+            contentMarker = matches[0];
+          }
+        }
+        let contentMarkerIndex = contentsToWrite.indexOf(contentMarker);
+
+        if (contentMarkerIndex !== -1) {
+          let insertIndex = contentMarkerIndex;
+          if (insertBehavior === 'after') {
+            insertIndex += contentMarker.length;
+          }
+
+          contentsToWrite =
+            contentsToWrite.slice(0, insertIndex) + contentsToInsert + EOL + contentsToWrite.slice(insertIndex);
+        }
+      }
+    }
+
+    returnValue.originalContents = originalContents;
+    returnValue.contents = contentsToWrite;
+
+    if (contentsToWrite !== originalContents) {
+      returnValue.inserted = true;
+
+      await fs.outputFile(fullPath, contentsToWrite);
+      return returnValue;
+    }
+  }
+
+  return Promise.resolve(returnValue);
+}
+
+module.exports = insertIntoFile;

package/packages/blueprint-model/utilities/is-addon.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = function isAddon(keywords) {
+  return Array.isArray(keywords) && keywords.indexOf('ember-addon') >= 0;
+};