Fix Merge Conflicts

README.md

@@ -15,10 +15,10 @@ consumers or providers of engines. The following functionality is supported:
 * Sharing of dependencies from parents (applications or other engines) to
   contained engines. Shared dependencies are currently limited to services
   and route paths.
+* Lazy loading of engines.
 
 The following functionality will soon be supported:
 
-* Lazy loading of engines.
 * Route serializer modules that isolate serialization logic from the rest of
   the route definition.
 

addon/-private/route-ext.js

@@ -11,7 +11,7 @@ const {
 function externalAlias(methodName) {
   return function _externalAliasMethod(routeName, ...args) {
     let externalRoute = getOwner(this)._getExternalRoute(routeName);
-    this.router[methodName](externalRoute, ...args);
+    return this.router[methodName](externalRoute, ...args);
   };
 }
 

blueprints/in-repo-engine/index.js

@@ -15,7 +15,6 @@ module.exports = Object.assign({}, InRepoAddon, {
     return {
       name: name,
       modulePrefix: name,
-      hasLazyFlag: typeof options.lazy !== 'undefined',
       isLazy: !!options.lazy
     };
   },

blueprints/in-repo-engine/routable-files/lib/__name__/addon/templates/application.hbs

@@ -1 +1 @@
-{{outlet}}
+{{outlet}}

blueprints/in-repo-engine/routable-files/lib/__name__/index.js

@@ -1,11 +1,16 @@
-/*jshint node:true*/
-var EngineAddon = require('ember-engines/lib/engine-addon');
+/* eslint-env node */
+'use strict';
+
+const EngineAddon = require('ember-engines/lib/engine-addon');
+
 module.exports = EngineAddon.extend({
-  name: '<%= dasherizedModuleName %>',<% if (hasLazyFlag) { %>
+  name: '<%= dasherizedModuleName %>',
 
-  lazyLoading: <%= isLazy %>,<% } %>
+  lazyLoading: {
+    enabled: <%= isLazy %>
+  },
 
-  isDevelopingAddon: function() {
+  isDevelopingAddon() {
     return true;
   }
 });

blueprints/in-repo-engine/routeless-files/lib/__name__/index.js

@@ -1,11 +1,16 @@
-/*jshint node:true*/
-var EngineAddon = require('ember-engines/lib/engine-addon');
+/* eslint-env node */
+'use strict';
+
+const EngineAddon = require('ember-engines/lib/engine-addon');
+
 module.exports = EngineAddon.extend({
-  name: '<%= dasherizedModuleName %>',<% if (hasLazyFlag) { %>
+  name: '<%= dasherizedModuleName %>',
 
-  lazyLoading: <%= isLazy %>,<% } %>
+  lazyLoading: {
+    enabled: <%= isLazy %>
+  },
 
-  isDevelopingAddon: function() {
+  isDevelopingAddon() {
     return true;
   }
 });

lib/engine-addon.js

@@ -64,7 +64,7 @@ function findHost() {
   // Keep iterating upward until we don't have a grandparent.
   // Has to do this grandparent check because at some point we hit the project.
   do {
-    if (current.lazyLoading === true) { return current; }
+    if (current.lazyLoading.enabled === true) { return current; }
     app = current.app || app;
   } while (current.parent.parent && (current = current.parent));
 
@@ -79,7 +79,7 @@ function findHostsHost() {
   // Keep iterating upward until we don't have a grandparent.
   // Has to do this grandparent check because at some point we hit the project.
   do {
-    if (current.lazyLoading === true) {
+    if (current.lazyLoading.enabled === true) {
       if (foundHost) {
         return current;
       }
@@ -185,6 +185,29 @@ var buildEngineJSTreeWithoutRoutes = memoize(function buildEngineJSTreeWithoutRo
   });
 });
 
+var buildEngineRoutesJSTree = memoize(function buildEngineRoutesJSTree() {
+  // Get complete engine JS tree
+  var engineAppTree = buildEngineJSTree.call(this);
+  // Separate routes
+  var engineRoutesTree = new DependencyFunnel(engineAppTree, {
+    include: true,
+    entry: this.name+'/routes.js',
+    external: ['ember-engines/routes']
+  });
+  // If babel options aren't defined, we need to transpile the modules.
+  if (!this.options || !this.options.babel) {
+    engineRoutesTree = processBabel(engineRoutesTree);
+  }
+  // Concatenate routes.js and its dependencies into a single file.
+  engineRoutesTree = concat(engineRoutesTree, {
+    allowNone: true,
+    inputFiles: ['**/*.js'],
+    outputFile: 'engines-dist/' + this.name + '/assets/routes.js'
+  });
+  // Return concatenated JS tree
+  return this.debugTree(engineRoutesTree, 'routes:output');
+});
+
 var buildVendorJSWithImports = memoize(function buildVendorJSWithImports(concatTranspiledVendorJSTree) {
   var externalTree = buildExternalTree.call(this);
   var combined = mergeTrees([externalTree, concatTranspiledVendorJSTree].filter(Boolean), { overwrite: true });
@@ -287,7 +310,7 @@ module.exports = {
 
     options.cacheKeyForTree = function(treeType) {
       // We do different things in the addon, public, and engine trees based on
-      // the value of `lazyLoading`, so we add it to the cache key
+      // the value of `lazyLoading.enabled`, so we add it to the cache key
       if (treeType === 'addon' || treeType === 'public' || treeType === 'engine') {
         return calculateCacheKeyForTree(treeType, this, [ this.lazyLoading ]);
       } else {
@@ -296,12 +319,14 @@ module.exports = {
     };
 
     /**
-     * Gets a list of all the addons by name that are used by all hosts above
+     * Gets a map of all the addons that are used by all hosts above
      * the current host.
+     *
+     * The key is the name of the addon and the value is first encountered instance of this addon.
      */
-    options.ancestorHostAddonNames = function() {
-      if (this._hostAddonNames) {
-        return this._hostAddonNames;
+    options.ancestorHostAddons = function() {
+      if (this._hostAddons) {
+        return this._hostAddons;
       }
 
       var host = findHostsHost.call(this);
@@ -310,43 +335,27 @@ module.exports = {
         return [];
       }
 
-      var hostIsEngine = !!host.ancestorHostAddonNames;
+      var hostIsEngine = !!host.ancestorHostAddons;
 
-      var addonNames = hostIsEngine ? host.ancestorHostAddonNames().slice() : [];
+      var hostAddons = hostIsEngine ? Object.assign({}, host.ancestorHostAddons()) : {};
       var queue = hostIsEngine ? host.addons.slice() : host.project.addons.slice();
 
       // Do a breadth-first walk of the addons in the host, ignoring those that
       // have a different host (e.g., lazy engine)
       while (queue.length) {
         var addon = queue.pop();
 
-        if (addon.lazyLoading) { continue; }
-        if (addonNames.indexOf(addon.name) !== -1) { continue; }
-
-        addonNames.push(addon.name);
-        queue.push.apply(queue, addon.addons);
-      }
-
-      this._hostAddonNames = addonNames;
+        if (addon.lazyLoading && addon.lazyLoading.enabled) { continue; }
 
-      return addonNames;
-    };
+        if (hostAddons[addon.name]) { continue; }
 
-    /**
-     * Gets a list of addons that are not included by an ancestor host based on
-     * the addon's name.
-     */
-    options.nonDuplicatedAddons = function() {
-      if (this._nonDuplicatedAddons) {
-        return this._nonDuplicatedAddons;
+        hostAddons[addon.name] = addon;
+        queue.push.apply(queue, addon.addons);
       }
 
-      var hostAddonNames = this.ancestorHostAddonNames();
-      this._nonDuplicatedAddons = this.addons.filter(function(addon) {
-        return hostAddonNames.indexOf(addon.name) === -1;
-      });
+      this._hostAddons = hostAddons;
 
-      return this._nonDuplicatedAddons;
+      return hostAddons;
     };
 
     /**
@@ -358,12 +367,31 @@ module.exports = {
       this.initializeAddons();
 
       var invokeArguments = args || [];
-      var addons = this.nonDuplicatedAddons();
+      var hostAddons = this.ancestorHostAddons();
 
-      return addons.map(function(addon) {
-        if (addon[methodName]) {
-          return addon[methodName].apply(addon, invokeArguments);
+      return this.addons.map(function(addon) {
+        if (!addon[methodName]) {
+          // no method to call
+          return;
+        }
+        var hostAddon = hostAddons[addon.name];
+        if (hostAddon) {
+          switch(methodName) {
+            case 'treeFor':
+              var treeName = invokeArguments[0];
+              var hostAddonCacheKey = hostAddon.cacheKeyForTree(treeName);
+              var addonCacheKey = addon.cacheKeyForTree(treeName);
+              if (addonCacheKey != null && addonCacheKey === hostAddonCacheKey) {
+                // the addon specifies cache key and it is the same as host instance of the addon, skip the tree
+                return;
+              }
+              break;
+            default:
+              // the same addon exist in the parent as well, skip the invocation
+              return;
+          }
         }
+        return addon[methodName].apply(addon, invokeArguments);
       }).filter(Boolean);
     };
 
@@ -372,6 +400,14 @@ module.exports = {
     options.init = function() {
       this.options = defaultsDeep(options, DEFAULT_CONFIG);
 
+      // Ensure lazyLoading is a hash, retain backwards compatibility with using
+      // a boolean value
+      if (typeof this.lazyLoading === "boolean") {
+        this.lazyLoading = {
+          enabled: this.lazyLoading
+        };
+      }
+
       // NOTE: This is a beautiful hack to deal with core object calling toString on the function.
       // It'll throw a deprecation warning if this isn't present because it doesn't see a `_super`
       // invocation. Do not remove the following line!
@@ -390,7 +426,7 @@ module.exports = {
 
       // Require that the user specify a lazyLoading property.
       if (!('lazyLoading' in this)) {
-        this.ui.writeDeprecateLine(this.pkg.name + ' engine must specify the `lazyLoading` property to `true` or `false` as to whether the engine should be lazily loaded.');
+        this.ui.writeDeprecateLine(this.pkg.name + ' engine must specify the `lazyLoading.enabled` property as to whether the engine should be lazily loaded.');
       }
 
       if (shouldCompactReexports(this)) {
@@ -427,13 +463,22 @@ module.exports = {
         var host = originalFindHost.call(this);
         var target = this._findHost();
 
+        target.env = host.env;
         target._import = host._import;
         target._getAssetPath = host._getAssetPath;
         target.otherAssets = host.otherAssets;
         target._mergeTrees = host._mergeTrees;
 
         // We're delegating to the upstream EmberApp behavior for eager engines.
-        if (this.lazyLoading !== true) {
+        if (this.lazyLoading.enabled !== true) {
+          // Asset can be an object with environment properties.
+          asset = target._getAssetPath(asset);
+
+          // The asset path can be undefined depending on `env`.
+          if (typeof asset !== 'string') {
+            return;
+          }
+
           // This is hard-coded in Ember CLI, not tied to treePaths.
           asset.replace(/^vendor/, '');
         }
@@ -442,7 +487,7 @@ module.exports = {
 
       var originalIncluded = this.included;
       this.included = function() {
-        if (this.lazyLoading === true) {
+        if (this.lazyLoading.enabled === true) {
           // Do this greedily so that it runs before the `included` hook.
           this.import('engines-dist/' + this.name + '/assets/engine-vendor.js');
           this.import('engines-dist/' + this.name + '/assets/engine-vendor.css');
@@ -467,7 +512,7 @@ module.exports = {
               var stack = (new Error()).stack;
               ui.writeWarnLine('`app.import` should be avoided and `this.import` should be used instead. ' +
                                'Using `app.import` forces the asset in question to be hoisted in all scenarios (' +
-                               'regardless of `lazyLoading` flag).\n\n  Import performed on `' + name + '`\'s `app` argument at:\n\n  ' +
+                               'regardless of `lazyLoading.enabled` flag).\n\n  Import performed on `' + name + '`\'s `app` argument at:\n\n  ' +
                                stack + '\n'
                               );
               return originalHostImport.apply(this, arguments);
@@ -479,9 +524,15 @@ module.exports = {
         this.nonDuplicatedAddonInvoke('included', [this]);
       };
 
+      // The treeForEngine method constructs and returns a tree that represents
+      // the engines routes.js file and its dependencies. This is used later to
+      // promote the engines routes.js to the host.
+      //
+      // If the lazyLoading.includeRoutesInApplication option is false, we don't
+      // want to promote the routes into the host.
       this.treeForEngine = function() {
-        // If this engine is lazy or any of its parents are lazy we need to promote its routes.
-        if (!this._hasLazyAncestor) { return; }
+        var extractRoutes = this._hasLazyAncestor && this.lazyLoading.includeRoutesInApplication !== false;
+        if (!extractRoutes) { return; }
 
         // The only thing that we want to promote from a lazy engine is the
         // routes.js file and all of its dependencies, which is why we build the
@@ -503,7 +554,7 @@ module.exports = {
       // Replace `treeForAddon` so that we control how this engine gets built.
       // We may or may not want it to be combined like a default addon.
       this.treeForAddon = function() {
-        if (this.lazyLoading === true) { return; }
+        if (this.lazyLoading.enabled === true) { return; }
 
         // NOT LAZY LOADING!
         // This is the scenario where we want to act like an addon.
@@ -530,7 +581,8 @@ module.exports = {
         // We only calculate our external tree for eager engines
         // if they're going to be consumed by a lazy engine.
         var externalTree;
-        if (this._findHost().lazyLoading === true) {
+        var hostLazyLoading = this._findHost().lazyLoading;
+        if (hostLazyLoading && hostLazyLoading.enabled === true) {
           externalTree = buildExternalTree.call(this);
         }
 
@@ -612,7 +664,7 @@ module.exports = {
       this.treeForPublic = function() {
         // NOT LAZY LOADING!
         // In this scenario we just want to do the default behavior and bail.
-        if (this.lazyLoading !== true) {
+        if (this.lazyLoading.enabled !== true) {
           return originalTreeForPublic.apply(this, arguments);
         }
 
@@ -822,7 +874,7 @@ module.exports = {
      * @override
      */
     options.updateFastBootManifest = function(manifest) {
-      if (this.lazyLoading) {
+      if (this.lazyLoading.enabled === true) {
         manifest.vendorFiles.push('engines-dist/' + options.name + '/assets/engine-vendor.js');
         manifest.vendorFiles.push('engines-dist/' + options.name + '/assets/engine.js');
         manifest.vendorFiles.push('engines-dist/' + options.name + '/config/environment.js');
@@ -885,8 +937,8 @@ module.exports = {
           // when using deprecated 0.4 style processing, we allow the styles tree to be
           // hoisted to the top level host
         (this.useDeprecatedIncorrectCSSProcessing !== true && name === 'styles') ||
-        (name === 'addon' && this.lazyLoading === true) ||
-        (name === 'public' && this.lazyLoading === true)
+        (name === 'addon' && this.lazyLoading.enabled === true) ||
+        (name === 'public' && this.lazyLoading.enabled === true)
       ) {
         trees = [];
       } else {