ember-cli 4.1.1 → 4.3.0-beta.1

package/lib/broccoli/default-packager.js

@@ -12,6 +12,7 @@ const ConfigReplace = require('broccoli-config-replace');
 const emberAppUtils = require('../utilities/ember-app-utils');
 const funnelReducer = require('broccoli-funnel-reducer');
 const addonProcessTree = require('../utilities/addon-process-tree');
+const { deprecate } = require('../debug');
 
 const preprocessCss = p.preprocessCss;
 const preprocessJs = p.preprocessJs;
@@ -628,9 +629,21 @@ module.exports = class DefaultPackager {
    * @param {String} bowerDirectory Custom path to bower components
    */
   packageBower(tree, bowerDirectory) {
+    let destDir = bowerDirectory || DEFAULT_BOWER_PATH;
+
+    deprecate(`Building Bower packages has been deprecated. You have Bower packages in \`${destDir}\`.`, false, {
+      for: 'ember-cli',
+      id: 'ember-cli.building-bower-packages',
+      since: {
+        available: '4.2.0',
+        enabled: '4.2.0',
+      },
+      until: '5.0.0',
+    });
+
     if (this._cachedBower === null) {
       this._cachedBower = new Funnel(tree, {
-        destDir: bowerDirectory || DEFAULT_BOWER_PATH,
+        destDir,
         annotation: 'Packaged Bower',
       });
     }

package/lib/broccoli/ember-app.js

@@ -20,9 +20,9 @@ const concat = require('broccoli-concat');
 const BroccoliDebug = require('broccoli-debug');
 const AmdFunnel = require('broccoli-amd-funnel');
 const mergeTrees = require('./merge-trees');
+const broccoliMergeTrees = require('broccoli-merge-trees');
 const WatchedDir = require('broccoli-source').WatchedDir;
 const UnwatchedDir = require('broccoli-source').UnwatchedDir;
-const BroccoliMergeTrees = require('broccoli-merge-trees');
 
 const merge = require('ember-cli-lodash-subset').merge;
 const defaultsDeep = require('ember-cli-lodash-subset').defaultsDeep;
@@ -108,7 +108,7 @@ class EmberApp {
 
     this.registry = options.registry || p.defaultRegistry(this);
 
-    this.bowerDirectory = this.project.bowerDirectory;
+    this.bowerDirectory = this.project._bowerDirectory;
 
     this._initTestsAndHinting(options);
     this._initOptions(options);
@@ -438,7 +438,7 @@ class EmberApp {
     @method _initVendorFiles
   */
   _initVendorFiles() {
-    let bowerDeps = this.project.bowerDependencies();
+    let bowerDeps = this.project._bowerDependencies();
     let ember = this.project.findAddonByName('ember-source');
     let addonEmberCliShims = this.project.findAddonByName('ember-cli-shims');
     let bowerEmberCliShims = bowerDeps['ember-cli-shims'];
@@ -1727,7 +1727,7 @@ class EmberApp {
     }
 
     let trees = [].concat(packagedTree, additionalTrees).filter(Boolean);
-    let combinedPackageTree = new BroccoliMergeTrees(trees);
+    let combinedPackageTree = broccoliMergeTrees(trees);
 
     return this.addonPostprocessTree('all', combinedPackageTree);
   }

package/lib/commands/destroy.js

@@ -26,6 +26,13 @@ module.exports = Command.extend({
       description:
         'Runs a blueprint against an in repo addon. ' + 'A path is expected, relative to the root of the project.',
     },
+    {
+      name: 'typescript',
+      type: Boolean,
+      aliases: ['ts'],
+      description:
+        'Specifically destroys the TypeScript output of the `generate` command. Run `--no-typescript` to instead target the JavaScript output.',
+    },
   ],
 
   anonymousOptions: ['<blueprint>'],

package/lib/commands/generate.js

@@ -9,6 +9,11 @@ const _ = require('ember-cli-lodash-subset');
 const EOL = require('os').EOL;
 const SilentError = require('silent-error');
 
+const UNKNOWN_BLUEPRINT_ERROR =
+  'The `ember generate` command requires a ' +
+  'blueprint name to be specified. ' +
+  'For more details, use `ember help`';
+
 module.exports = Command.extend({
   name: 'generate',
   description: 'Generates new code from blueprints.',
@@ -30,6 +35,12 @@ module.exports = Command.extend({
       description:
         'Runs a blueprint against an in repo addon. ' + 'A path is expected, relative to the root of the project.',
     },
+    {
+      name: 'typescript',
+      type: Boolean,
+      aliases: ['ts'],
+      description: 'Generates a version of the blueprint written in TypeScript (if available).',
+    },
   ],
 
   anonymousOptions: ['<blueprint>'],
@@ -40,13 +51,7 @@ module.exports = Command.extend({
     let blueprintName = rawArgs[0];
 
     if (!blueprintName) {
-      return Promise.reject(
-        new SilentError(
-          'The `ember generate` command requires a ' +
-            'blueprint name to be specified. ' +
-            'For more details, use `ember help`.'
-        )
-      );
+      return Promise.reject(new SilentError(UNKNOWN_BLUEPRINT_ERROR));
     }
 
     let taskArgs = {
@@ -166,3 +171,7 @@ module.exports = Command.extend({
     }
   },
 });
+
+module.exports.ERRORS = {
+  UNKNOWN_BLUEPRINT_ERROR,
+};

package/lib/debug/assert.js

@@ -0,0 +1,37 @@
+'use strict';
+
+/**
+ * Verify that a certain condition is met, or throw an error if otherwise.
+ *
+ * This is useful for communicating expectations in the code to other human
+ * readers as well as catching bugs that accidentally violate these expectations.
+ *
+ * ```js
+ * const { assert } = require('ember-cli/lib/debug');
+ *
+ * // Test for truthiness:
+ * assert('Must pass a string.', typeof str === 'string');
+ *
+ * // Fail unconditionally:
+ * assert('This code path should never run.');
+ * ```
+ *
+ * @method assert
+ * @param {String} description Describes the condition.
+ * This will become the message of the error thrown if the assertion fails.
+ * @param {Any} condition Must be truthy for the assertion to pass.
+ * If falsy, an error will be thrown.
+ */
+function assert(description, condition) {
+  if (!description) {
+    throw new Error('When calling `assert`, you must provide a description as the first argument.');
+  }
+
+  if (condition) {
+    return;
+  }
+
+  throw new Error(`ASSERTION FAILED: ${description}`);
+}
+
+module.exports = assert;

package/lib/debug/deprecate.js

@@ -0,0 +1,111 @@
+'use strict';
+
+const chalk = require('chalk');
+const semver = require('semver');
+const assert = require('./assert');
+
+/**
+ * Display a deprecation message.
+ *
+ * ```js
+ * const { deprecate } = require('ember-cli/lib/debug');
+ *
+ * deprecate('The `foo` method is deprecated.', false, {
+ *   for: 'ember-cli',
+ *   id: 'ember-cli.foo-method',
+ *   since: {
+ *     available: '4.1.0',
+ *     enabled: '4.2.0',
+ *   },
+ *   until: '5.0.0',
+ *   url: 'https://example.com',
+ * });
+ * ```
+ *
+ * @method deprecate
+ * @param {String} description Describes the deprecation.
+ * @param {Any} condition If falsy, the deprecation message will be displayed.
+ * @param {Object} options An object including the deprecation's details:
+ * - `for` The library that the deprecation is for
+ * - `id` The deprecation's unique id
+ * - `since.available` A SemVer version indicating when the deprecation was made available
+ * - `since.enabled` A SemVer version indicating when the deprecation was enabled
+ * - `until` A SemVer version indicating until when the deprecation will be active
+ * - `url` A URL that refers to additional information about the deprecation
+ */
+function deprecate(description, condition, options) {
+  assert('When calling `deprecate`, you must provide a description as the first argument.', description);
+  assert('When calling `deprecate`, you must provide a condition as the second argument.', arguments.length > 1);
+
+  assert(
+    'When calling `deprecate`, you must provide an options object as the third argument. The options object must include the `for`, `id`, `since` and `until` options (`url` is optional).',
+    options
+  );
+
+  assert('When calling `deprecate`, you must provide the `for` option.', options.for);
+  assert('When calling `deprecate`, you must provide the `id` option.', options.id);
+
+  assert(
+    'When calling `deprecate`, you must provide the `since` option. `since` must include the `available` and/or the `enabled` option.',
+    options.since
+  );
+
+  assert(
+    'When calling `deprecate`, you must provide the `since.available` and/or the `since.enabled` option.',
+    options.since.available || options.since.enabled
+  );
+
+  assert(
+    '`since.available` must be a valid SemVer version.',
+    !options.since.available || isSemVer(options.since.available)
+  );
+
+  assert('`since.enabled` must be a valid SemVer version.', !options.since.enabled || isSemVer(options.since.enabled));
+
+  assert(
+    'When calling `deprecate`, you must provide a valid SemVer version for the `until` option.',
+    isSemVer(options.until)
+  );
+
+  if (condition) {
+    return;
+  }
+
+  let message = formatMessage(description, options);
+
+  warn(message);
+  warn(getStackTrace());
+
+  // Return the message for testing purposes.
+  // This can be removed once we can register deprecation handlers.
+  return message;
+}
+
+function isSemVer(version) {
+  return semver.valid(version) !== null;
+}
+
+function formatMessage(description, options) {
+  let message = [`DEPRECATION: ${description}`, `[ID: ${options.id}]`];
+
+  if (options.url) {
+    message.push(`See ${options.url} for more details.`);
+  }
+
+  return message.join(' ');
+}
+
+function getStackTrace() {
+  let error = new Error();
+  let lines = error.stack.split('\n');
+
+  lines.shift(); // Remove the word `Error`.
+
+  return lines.map((line) => line.trim()).join('\n');
+}
+
+function warn(message) {
+  console.warn(chalk.yellow(message));
+}
+
+module.exports = deprecate;

package/lib/debug/index.js

@@ -0,0 +1,6 @@
+'use strict';
+
+module.exports = {
+  assert: require('./assert'),
+  deprecate: require('./deprecate'),
+};

package/lib/models/blueprint.js

@@ -23,7 +23,9 @@ const EOL = require('os').EOL;
 const bowEpParser = require('bower-endpoint-parser');
 const logger = require('heimdalljs-logger')('ember-cli:blueprint');
 const normalizeEntityName = require('ember-cli-normalize-entity-name');
+const { removeTypes } = require('remove-types');
 const isAddon = require('../utilities/is-addon');
+const { deprecate } = require('../debug');
 
 const initialIgnoredFiles = ['.DS_Store'];
 
@@ -195,6 +197,18 @@ let Blueprint = CoreObject.extend({
 
   _printableProperties: ['name', 'description', 'availableOptions', 'anonymousOptions', 'overridden'],
 
+  /**
+    Indicates whether or not a blueprint is a candidate for automatic transpilation from TS to JS.
+    This property could be false in the case that the blueprint is written in JS and is not intended
+    to work with TS at all, OR in the case that the blueprint is written in TS and the author does
+    not intend to support transpilation to JS.
+
+    @public
+    @property shouldTransformTypeScript
+    @type Boolean
+  */
+  shouldTransformTypeScript: false,
+
   init(blueprintPath) {
     this._super();
 
@@ -429,12 +443,85 @@ let Blueprint = CoreObject.extend({
     let fileInfos = await process.call(this, intoDir, locals);
 
     // commit changes for each FileInfo (with prompting as needed)
-    await Promise.all(fileInfos.map((fi) => this._commit(fi)));
+    await Promise.all(fileInfos.map((info) => this._commit(info)));
 
     // run afterInstall/afterUninstall userland hooks
     await afterHook.call(this, options);
   },
 
+  /**
+    @private
+    @method shouldConvertToJS
+    @param {Object} options
+    @param {FileInfo} fileInfo
+    @return {Boolean}
+  */
+  shouldConvertToJS(options, fileInfo) {
+    // If this isn't turned on, it doesn't matter what else was passed, we're not touching it.
+    if (!this.shouldTransformTypeScript) {
+      return false;
+    }
+
+    // If the blueprint isn't a TS file to begin with, there's nothing to convert.
+    if (!isTypeScriptFile(fileInfo.outputPath)) {
+      // If the user wants TypeScript output but there is no TypeScript blueprint available, we want
+      // to warn them that they're not going to get what they're expecting while still at least giving
+      // them the JS output. We check for this *after* checking `shouldTranformTypeScript` because
+      // it's possible for people to set `{typescript: true}` in their `.ember-cli` file, which would
+      // then erroneously trigger this message every time they generate a JS blueprint even though
+      // they didn't pass the flag.
+      if (options.typescript === true) {
+        this.ui.writeLine(
+          chalk.yellow(
+            "You passed the '--typescript' flag but there is no TypeScript blueprint available. " +
+              'A JavaScript blueprint will be generated instead.'
+          )
+        );
+      }
+
+      return false;
+    }
+
+    // Indicates when the user explicitly passed either `--typescript` or `--no-typescript` as opposed
+    // to not passing a flag at all and allowing for default behavior
+    const userExplicitlySelectedTypeScriptStatus = options.typescript !== undefined;
+
+    // Indicates when the user has asked for TypeScript either globally (by setting
+    // `isTypeScriptProject` to true) or locally (by passing the `--typescript` flag when they
+    // invoked the generator). Although ember-cli merges `.ember-cli` and all of the flag values into
+    // one object, we thought the DX would be improved by differentiating between what is intended
+    // to be global vs. local config.
+    const shouldUseTypeScript = userExplicitlySelectedTypeScriptStatus
+      ? options.typescript
+      : options.isTypeScriptProject;
+
+    // if the user wants TS output and we have a TS file available, we do *not* want to downlevel to JS
+    if (shouldUseTypeScript) {
+      return false;
+    }
+
+    return true;
+  },
+
+  /**
+    @private
+    @method convertToJS
+    @param {FileInfo} fileInfo
+    @return {Promise}
+  */
+  async convertToJS(fileInfo) {
+    let rendered = await fileInfo.render();
+
+    const transformed = await removeTypes(rendered);
+
+    fileInfo.rendered = transformed;
+
+    fileInfo.displayPath = replaceExtension(fileInfo.displayPath, '.js');
+    fileInfo.outputPath = replaceExtension(fileInfo.outputPath, '.js');
+
+    return fileInfo;
+  },
+
   /**
     @method install
     @param {Object} options
@@ -756,6 +843,17 @@ let Blueprint = CoreObject.extend({
 
     return Promise.all(fileInfos.filter(isValidFile).map(prepareConfirm))
       .then(finishProcessingForInstall)
+      .then((fileInfos) => {
+        return Promise.all(
+          fileInfos.map((info) => {
+            if (this.shouldConvertToJS(this.options, info)) {
+              return this.convertToJS(info);
+            }
+
+            return info;
+          })
+        );
+      })
       .then((fileInfos) => fileInfos.concat(fileInfosToRemove));
   },
 
@@ -769,7 +867,45 @@ let Blueprint = CoreObject.extend({
 
     this._ignoreUpdateFiles();
 
-    return finishProcessingForUninstall(fileInfos.filter(isValidFile));
+    fileInfos = fileInfos.filter(isValidFile).reduce((acc, info) => {
+      // if it's possible that this blueprint could have produced either typescript OR javascript, we have to do some
+      // work to figure out which files to delete.
+      if (this.shouldTransformTypeScript) {
+        if (this.options.typescript === true) {
+          // if the user explicitly passed `--typescript`, we only want to delete TS files, so we stick with the existing
+          // info object since it will contain a .ts outputPath (since we know this blueprint is authored in TS because
+          // of our check above)
+          acc.push(info);
+          return acc;
+        }
+
+        const jsInfo = new FileInfo({
+          ...info,
+          outputPath: replaceExtension(info.outputPath, '.js'),
+          displayPath: replaceExtension(info.displayPath, '.js'),
+        });
+
+        if (this.options.typescript === false) {
+          // if the user explicitly passed `--no-typescript`, we only want to delete JS file, so we return our newly
+          // created jsInfo object since it contains the javascript version of the output path.
+          acc.push(jsInfo);
+          return acc;
+        }
+
+        if (this.options.typescript === undefined) {
+          // if the user didn't specify one way or the other, then both the JS and TS paths are possibilities, so we add
+          // both of them to the list. `finishProcessingForUninstall` will actually look to see which of them exists and
+          // delete whatever it finds.
+          acc.push(info, jsInfo);
+          return acc;
+        }
+      }
+
+      acc.push(info);
+      return acc;
+    }, []);
+
+    return finishProcessingForUninstall(fileInfos);
   },
 
   /**
@@ -1017,10 +1153,29 @@ let Blueprint = CoreObject.extend({
     ```
   */
   addBowerPackageToProject(localPackageName, target, installOptions) {
+    deprecate(
+      [
+        `(Blueprint: \`${this.name}\`) \`addBowerPackageToProject\` has been deprecated.`,
+        'If the package is also available on the npm registry, please use `addPackageToProject` instead.',
+        'If not, please install the Bower package manually by running:',
+        `\`bower install ${localPackageName} --save\``,
+      ].join('\n'),
+      false,
+      {
+        for: 'ember-cli',
+        id: 'ember-cli.blueprint.add-bower-package-to-project',
+        since: {
+          available: '4.2.0',
+          enabled: '4.2.0',
+        },
+        until: '5.0.0',
+      }
+    );
+
     let lpn = localPackageName;
     let tar = target;
     let packageObject = bowEpParser.json2decomposed(lpn, tar);
-    return this.addBowerPackagesToProject([packageObject], installOptions);
+    return this.addBowerPackagesToProject([packageObject], installOptions, true);
   },
 
   /**
@@ -1039,7 +1194,7 @@ let Blueprint = CoreObject.extend({
     @param {Object} installOptions
     @return {Promise}
   */
-  addBowerPackagesToProject(packages, installOptions) {
+  addBowerPackagesToProject(packages, installOptions, _deprecationCondition = false) {
     let task = this.taskFor('bower-install');
     let installText = packages.length > 1 ? 'install bower packages' : 'install bower package';
     let packageNames = [];
@@ -1051,6 +1206,25 @@ let Blueprint = CoreObject.extend({
       })
       .map(bowEpParser.compose);
 
+    deprecate(
+      [
+        `(Blueprint: \`${this.name}\`) \`addBowerPackagesToProject\` has been deprecated.`,
+        'If the packages are also available on the npm registry, please use `addPackagesToProject` instead.',
+        'If not, please install the Bower packages manually by running:',
+        `\`bower install ${packageNames.join(' ')} --save\``,
+      ].join('\n'),
+      _deprecationCondition,
+      {
+        for: 'ember-cli',
+        id: 'ember-cli.blueprint.add-bower-packages-to-project',
+        since: {
+          available: '4.2.0',
+          enabled: '4.2.0',
+        },
+        until: '5.0.0',
+      }
+    );
+
     this._writeStatusToUI(chalk.green, installText, packageNames.join(', '));
 
     return task.run({
@@ -1279,6 +1453,23 @@ let Blueprint = CoreObject.extend({
 Blueprint.lookup = function (name, options) {
   options = options || {};
 
+  if (name.includes(path.sep)) {
+    let blueprintPath = path.resolve(name);
+    let isNameAPath = Boolean(blueprintPath);
+
+    if (isNameAPath) {
+      if (Blueprint._existsSync(blueprintPath)) {
+        return Blueprint.load(blueprintPath);
+      }
+
+      if (!options.ignoreMissing) {
+        throw new SilentError(`Unknown blueprint: ${name}`);
+      }
+
+      return;
+    }
+  }
+
   let lookupPaths = generateLookupPaths(options.paths);
 
   let lookupPath;
@@ -1581,4 +1772,18 @@ function finishProcessingForUninstall(infos) {
   return validInfos;
 }
 
+function replaceExtension(filePath, newExt) {
+  const { dir, name } = path.parse(filePath);
+
+  return path.format({
+    dir,
+    name,
+    ext: newExt,
+  });
+}
+
+function isTypeScriptFile(filePath) {
+  return path.extname(filePath) === '.ts';
+}
+
 module.exports = Blueprint;

package/lib/models/installation-checker.js

@@ -48,7 +48,7 @@ class InstallationChecker {
   }
 
   bowerDependenciesNotPresent() {
-    return !fs.existsSync(this.project.bowerDirectory);
+    return !fs.existsSync(this.project._bowerDirectory);
   }
 
   hasNpmDeps() {

package/lib/models/project.js

@@ -18,6 +18,7 @@ const PackageInfoCache = require('./package-info-cache');
 const PerBundleAddonCache = require('./per-bundle-addon-cache');
 const instantiateAddons = require('./instantiate-addons');
 const HostInfoCache = require('./host-info-cache');
+const { deprecate } = require('../debug');
 
 let processCwd = process.cwd();
 
@@ -117,15 +118,36 @@ class Project {
 
     if (fs.existsSync(bowerrcPath)) {
       try {
-        this.bowerDirectory = fs.readJsonSync(bowerrcPath).directory;
+        this._bowerDirectory = fs.readJsonSync(bowerrcPath).directory;
       } catch (exception) {
         logger.info('failed to parse bowerc: %s', exception);
-        this.bowerDirectory = null;
+        this._bowerDirectory = null;
       }
     }
 
-    this.bowerDirectory = this.bowerDirectory || 'bower_components';
-    logger.info('bowerDirectory: %s', this.bowerDirectory);
+    this._bowerDirectory = this._bowerDirectory || 'bower_components';
+    logger.info('bowerDirectory: %s', this._bowerDirectory);
+  }
+
+  get bowerDirectory() {
+    deprecate(
+      [
+        '`bowerDirectory` has been deprecated.',
+        "If you still need access to the project's Bower directory, you will have to manually resolve the project's `.bowerrc` file, and read the `directory` property instead.",
+      ].join('\n'),
+      false,
+      {
+        for: 'ember-cli',
+        id: 'ember-cli.project.bower-directory',
+        since: {
+          available: '4.2.0',
+          enabled: '4.2.0',
+        },
+        until: '5.0.0',
+      }
+    );
+
+    return this._bowerDirectory;
   }
 
   // Checks whether the project's npm dependencies are
@@ -387,6 +409,27 @@ class Project {
     @return {Object}       Bower dependencies
    */
   bowerDependencies(bower) {
+    deprecate(
+      [
+        '`bowerDependencies` has been deprecated.',
+        "If you still need access to the project's Bower dependencies, you will have to manually resolve the project's `bower.json` file instead.",
+      ].join('\n'),
+      false,
+      {
+        for: 'ember-cli',
+        id: 'ember-cli.project.bower-dependencies',
+        since: {
+          available: '4.2.0',
+          enabled: '4.2.0',
+        },
+        until: '5.0.0',
+      }
+    );
+
+    return this._bowerDependencies(bower);
+  }
+
+  _bowerDependencies(bower) {
     if (!bower) {
       let bowerPath = path.join(this.root, 'bower.json');
       bower = fs.existsSync(bowerPath) ? require(bowerPath) : {};