ember-source 4.3.0-alpha.1 → 4.3.0-beta.1

package/dist/packages/@ember/-internals/routing/lib/system/router.js

@@ -11,6 +11,10 @@ import { calculateCacheKey, extractRouteArgs, getActiveTargetName, resemblesURL
 import DSL from './dsl';
 import { defaultSerialize, getFullQueryParams, hasDefaultSerialize, ROUTE_CONNECTIONS } from './route';
 import RouterState from './router_state';
+/**
+@module @ember/routing
+*/
+
 import Router, { logAbort, STATE_SYMBOL } from 'router_js';
 
 function defaultDidTransition(infos) {
@@ -80,7 +84,8 @@ class EmberRouter extends EmberObject.extend(Evented) {
     this.currentRouteName = null;
     this.currentPath = null;
     this.currentRoute = null;
-    this._qpCache = Object.create(null);
+    this._qpCache = Object.create(null); // Set of QueryParam['urlKey']
+
     this._qpUpdates = new Set();
     this._queuedQPChanges = {};
     this._toplevelView = null;
@@ -165,7 +170,9 @@ class EmberRouter extends EmberObject.extend(Evented) {
     let name, nameParts, oldNameParts;
 
     for (let i = 1; i < routeInfos.length; i++) {
-      name = routeInfos[i].name;
+      let routeInfo = routeInfos[i];
+      assert('has routeInfo', routeInfo);
+      name = routeInfo.name;
       nameParts = name.split('.');
       oldNameParts = slice.call(path);
 
@@ -186,7 +193,8 @@ class EmberRouter extends EmberObject.extend(Evented) {
   _initRouterJs() {
     let location = get(this, 'location');
     let router = this;
-    let owner = getOwner(this);
+    const owner = getOwner(this);
+    assert('Router is unexpectedly missing an owner', owner);
     let seen = Object.create(null);
 
     class PrivateRouter extends Router {
@@ -203,6 +211,7 @@ class EmberRouter extends EmberObject.extend(Evented) {
         }
 
         let fullRouteName = `route:${routeName}`;
+        assert('Route is unexpectedly missing an owner', routeOwner);
         let route = routeOwner.lookup(fullRouteName);
 
         if (seen[name]) {
@@ -367,7 +376,8 @@ class EmberRouter extends EmberObject.extend(Evented) {
     let enableLoadingSubstates = this._hasModuleBasedResolver();
 
     let router = this;
-    let owner = getOwner(this);
+    const owner = getOwner(this);
+    assert('Router is unexpectedly missing an owner', owner);
     let options = {
       enableLoadingSubstates,
 
@@ -397,6 +407,7 @@ class EmberRouter extends EmberObject.extend(Evented) {
 
   _hasModuleBasedResolver() {
     let owner = getOwner(this);
+    assert('Router is unexpectedly missing an owner', owner);
     let resolver = get(owner, 'application.__registry__.resolver.moduleBasedResolver');
     return Boolean(resolver);
   }
@@ -467,8 +478,8 @@ class EmberRouter extends EmberObject.extend(Evented) {
     let defaultParentState;
     let liveRoutes = null;
 
-    for (let i = 0; i < routeInfos.length; i++) {
-      let route = routeInfos[i].route;
+    for (let routeInfo of routeInfos) {
+      let route = routeInfo.route;
       let connections = ROUTE_CONNECTIONS.get(route);
       let ownState;
 
@@ -503,6 +514,7 @@ class EmberRouter extends EmberObject.extend(Evented) {
 
     if (!this._toplevelView) {
       let owner = getOwner(this);
+      assert('Router is unexpectedly missing an owner', owner);
       let OutletView = owner.factoryFor('view:-outlet');
       let application = owner.lookup('application:main');
       let environment = owner.lookup('-environment:main');
@@ -543,9 +555,8 @@ class EmberRouter extends EmberObject.extend(Evented) {
   /**
     Transition the application into another route. The route may
     be either a single route or route path:
-       See [transitionTo](/ember/release/classes/Route/methods/transitionTo?anchor=transitionTo) for more info.
        @method transitionTo
-    @param {String} name the name of the route or a URL
+    @param {String} [name] the name of the route or a URL
     @param {...Object} models the model(s) or identifier(s) to be used while
       transitioning to the route.
     @param {Object} [options] optional hash with a queryParams property
@@ -580,12 +591,29 @@ class EmberRouter extends EmberObject.extend(Evented) {
       let infos = this._routerMicrolib.currentRouteInfos;
 
       if (this.namespace.LOG_TRANSITIONS) {
-        // eslint-disable-next-line no-console
-        assert('expected infos to be set', infos);
+        assert('expected infos to be set', infos); // eslint-disable-next-line no-console
+
         console.log(`Intermediate-transitioned into '${EmberRouter._routePath(infos)}'`);
       }
     }
   }
+  /**
+    Similar to `transitionTo`, but instead of adding the destination to the browser's URL history,
+    it replaces the entry for the current route.
+    When the user clicks the "back" button in the browser, there will be fewer steps.
+    This is most commonly used to manage redirects in a way that does not cause confusing additions
+    to the user's browsing history.
+       @method replaceWith
+    @param {String} [name] the name of the route or a URL
+    @param {...Object} models the model(s) or identifier(s) to be used while
+      transitioning to the route.
+    @param {Object} [options] optional hash with a queryParams property
+      containing a mapping of query parameters
+    @return {Transition} the transition object associated with this
+      attempted transition
+    @public
+  */
+
 
   replaceWith(...args) {
     return this.transitionTo(...args).method('replace');
@@ -671,8 +699,11 @@ class EmberRouter extends EmberObject.extend(Evented) {
     let instances = this._engineInstances;
 
     for (let name in instances) {
-      for (let id in instances[name]) {
-        run(instances[name][id], 'destroy');
+      let instance = instances[name];
+      assert('has instance', instance);
+
+      for (let id in instance) {
+        run(instance[id], 'destroy');
       }
     }
   }
@@ -686,7 +717,8 @@ class EmberRouter extends EmberObject.extend(Evented) {
   _activeQPChanged(queryParameterName, newValue) {
     this._queuedQPChanges[queryParameterName] = newValue;
     once(this, this._fireQueryParamTransition);
-  }
+  } // The queryParameterName is QueryParam['urlKey']
+
 
   _updatingQPChanged(queryParameterName) {
     this._qpUpdates.add(queryParameterName);
@@ -718,6 +750,7 @@ class EmberRouter extends EmberObject.extend(Evented) {
     let location = this.location;
     let rootURL = this.rootURL;
     let owner = getOwner(this);
+    assert('Router is unexpectedly missing an owner', owner);
 
     if ('string' === typeof location) {
       let resolvedLocation = owner.lookup(`location:${location}`);
@@ -729,6 +762,7 @@ class EmberRouter extends EmberObject.extend(Evented) {
           url: 'https://emberjs.com/deprecations/v4.x#toc_deprecate-auto-location',
           for: 'ember-source',
           since: {
+            available: '4.1.0',
             enabled: '4.1.0'
           }
         });
@@ -761,6 +795,7 @@ class EmberRouter extends EmberObject.extend(Evented) {
             url: 'https://emberjs.com/deprecations/v4.x#toc_deprecate-auto-location',
             for: 'ember-source',
             since: {
+              available: '4.1.0',
               enabled: '4.1.0'
             }
           });
@@ -990,12 +1025,11 @@ class EmberRouter extends EmberObject.extend(Evented) {
     let qps = [];
     let qpsByUrlKey = DEBUG ? {} : null;
     let qpMeta;
-    let qp;
     let urlKey;
     let qpOther;
 
-    for (let i = 0; i < routeInfoLength; ++i) {
-      qpMeta = this._getQPMeta(routeInfos[i]);
+    for (let routeInfo of routeInfos) {
+      qpMeta = this._getQPMeta(routeInfo);
 
       if (!qpMeta) {
         shouldCache = false;
@@ -1003,9 +1037,7 @@ class EmberRouter extends EmberObject.extend(Evented) {
       } // Loop over each QP to make sure we don't have any collisions by urlKey
 
 
-      for (let i = 0; i < qpMeta.qps.length; i++) {
-        qp = qpMeta.qps[i];
-
+      for (let qp of qpMeta.qps) {
         if (DEBUG) {
           urlKey = qp.urlKey;
           qpOther = qpsByUrlKey[urlKey];
@@ -1051,19 +1083,15 @@ class EmberRouter extends EmberObject.extend(Evented) {
     let routeInfos = state.routeInfos;
     let qpMeta;
 
-    for (let i = 0, len = routeInfos.length; i < len; ++i) {
-      qpMeta = this._getQPMeta(routeInfos[i]);
+    for (let routeInfo of routeInfos) {
+      qpMeta = this._getQPMeta(routeInfo);
 
       if (!qpMeta) {
         continue;
       }
 
-      let qp;
-      let presentProp;
-
-      for (let j = 0, qpLen = qpMeta.qps.length; j < qpLen; ++j) {
-        qp = qpMeta.qps[j];
-        presentProp = qp.prop in queryParams && qp.prop || qp.scopedPropertyName in queryParams && qp.scopedPropertyName || qp.urlKey in queryParams && qp.urlKey;
+      for (let qp of qpMeta.qps) {
+        let presentProp = qp.prop in queryParams && qp.prop || qp.scopedPropertyName in queryParams && qp.scopedPropertyName || qp.urlKey in queryParams && qp.urlKey;
 
         if (presentProp) {
           if (presentProp !== qp.scopedPropertyName) {
@@ -1093,15 +1121,17 @@ class EmberRouter extends EmberObject.extend(Evented) {
     let qp;
     let presentProp;
 
-    for (let i = 0; i < routeInfos.length; ++i) {
-      qpMeta = this._getQPMeta(routeInfos[i]);
+    for (let routeInfo of routeInfos) {
+      qpMeta = this._getQPMeta(routeInfo);
 
       if (!qpMeta) {
         continue;
-      }
+      } // Needs to stay for index loop to avoid throwIfClosureRequired
+
 
       for (let j = 0, qpLen = qpMeta.qps.length; j < qpLen; ++j) {
         qp = qpMeta.qps[j];
+        assert('expected qp', qp);
         presentProp = qp.prop in queryParams && qp.prop || qp.scopedPropertyName in queryParams && qp.scopedPropertyName || qp.urlKey in queryParams && qp.urlKey;
         assert(`You passed the \`${presentProp}\` query parameter during a transition into ${qp.route.routeName}, please update to ${qp.urlKey}`, function () {
           if (qp.urlKey === presentProp || qp.scopedPropertyName === presentProp) {
@@ -1178,22 +1208,27 @@ class EmberRouter extends EmberObject.extend(Evented) {
     mountPoint
   }) {
     let engineInstances = this._engineInstances;
+    let namedInstances = engineInstances[name];
+
+    if (!namedInstances) {
+      namedInstances = Object.create(null);
+      engineInstances[name] = namedInstances;
+    } // We just set these!
 
-    if (!engineInstances[name]) {
-      engineInstances[name] = Object.create(null);
-    }
 
-    let engineInstance = engineInstances[name][instanceId];
+    assert('has namedInstances', namedInstances);
+    let engineInstance = namedInstances[instanceId];
 
     if (!engineInstance) {
       let owner = getOwner(this);
+      assert('Router is unexpectedly missing an owner', owner);
       assert(`You attempted to mount the engine '${name}' in your router map, but the engine can not be found.`, owner.hasRegistration(`engine:${name}`));
       engineInstance = owner.buildChildEngineInstance(name, {
         routable: true,
         mountPoint
       });
       engineInstance.boot();
-      engineInstances[name][instanceId] = engineInstance;
+      namedInstances[instanceId] = engineInstance;
     }
 
     return engineInstance;
@@ -1220,6 +1255,7 @@ class EmberRouter extends EmberObject.extend(Evented) {
 function forEachRouteAbove(routeInfos, callback) {
   for (let i = routeInfos.length - 1; i >= 0; --i) {
     let routeInfo = routeInfos[i];
+    assert('has routeInfo', routeInfo);
     let route = routeInfo.route; // routeInfo.handler being `undefined` generally means either:
     //
     // 1. an error occurred during creation of the route in question
@@ -1354,6 +1390,7 @@ function logError(_error, initialMessage) {
 
 function findRouteSubstateName(route, state) {
   let owner = getOwner(route);
+  assert('Route is unexpectedly missing an owner', owner);
   let {
     routeName,
     fullRouteName,
@@ -1377,6 +1414,7 @@ function findRouteSubstateName(route, state) {
 
 function findRouteStateName(route, state) {
   let owner = getOwner(route);
+  assert('Route is unexpectedly missing an owner', owner);
   let {
     routeName,
     fullRouteName,
@@ -1420,6 +1458,7 @@ export function triggerEvent(routeInfos, ignoreFailure, name, args) {
 
   for (let i = routeInfos.length - 1; i >= 0; i--) {
     routeInfo = routeInfos[i];
+    assert('has routeInfo', routeInfo);
     handler = routeInfo.route;
     actionHandler = handler && handler.actions && handler.actions[name];
 
@@ -1457,9 +1496,8 @@ function calculatePostTransitionState(emberRouter, leafRouteName, contexts) {
     params
   } = state;
 
-  for (let i = 0; i < routeInfos.length; ++i) {
-    let routeInfo = routeInfos[i]; // If the routeInfo is not resolved, we serialize the context into params
-
+  for (let routeInfo of routeInfos) {
+    // If the routeInfo is not resolved, we serialize the context into params
     if (!routeInfo.isResolved) {
       params[routeInfo.name] = routeInfo.serialize(routeInfo.context);
     } else {
@@ -1479,14 +1517,18 @@ function updatePaths(router) {
 
   let path = EmberRouter._routePath(infos);
 
-  let currentRouteName = infos[infos.length - 1].name;
+  let info = infos[infos.length - 1];
+  assert('expected info', info);
+  let currentRouteName = info.name;
   let location = router.location;
   assert('expected location to not be a string', typeof location !== 'string');
   let currentURL = location.getURL();
   set(router, 'currentPath', path);
   set(router, 'currentRouteName', currentRouteName);
   set(router, 'currentURL', currentURL);
-  let appController = getOwner(router).lookup('controller:application');
+  let owner = getOwner(router);
+  assert('Router is unexpectedly missing an owner', owner);
+  let appController = owner.lookup('controller:application');
 
   if (!appController) {
     // appController might not exist when top-level loading/error

package/dist/packages/@ember/-internals/routing/lib/utils.js

@@ -1,28 +1,32 @@
 import { get } from '@ember/-internals/metal';
 import { getOwner } from '@ember/-internals/owner';
-import { deprecate } from '@ember/debug';
+import { assert, deprecate } from '@ember/debug';
 import EmberError from '@ember/error';
 import { STATE_SYMBOL } from 'router_js';
 const ALL_PERIODS_REGEX = /\./g;
 export function extractRouteArgs(args) {
+  // SAFETY: This should just be the same thing
   args = args.slice();
-  let possibleQueryParams = args[args.length - 1];
+  let possibleOptions = args[args.length - 1];
   let queryParams;
 
-  if (possibleQueryParams && Object.prototype.hasOwnProperty.call(possibleQueryParams, 'queryParams')) {
-    // SAFETY: this cast is safe because we have just checked whether
-    // `possibleQueryParams` -- defined as the last item in args -- both exists
-    // and has the property `queryParams`. If either of these invariants change,
-    // ***this is unsafe and should be changed***.
-    queryParams = args.pop().queryParams;
+  if (isRouteOptions(possibleOptions)) {
+    args.pop(); // Remove options
+
+    queryParams = possibleOptions.queryParams;
   } else {
     queryParams = {};
-  } // UNSAFE: these are simply assumed as the existing behavior of the system.
-  // However, this could break if upstream refactors change it, and the types
-  // here would not be able to tell us; we would lie to everything downstream.
+  }
+
+  let routeName;
+
+  if (typeof args[0] === 'string') {
+    routeName = args.shift(); // We just checked this!
+
+    assert('routeName is a string', typeof routeName === 'string');
+  } // SAFTEY: We removed the name and options if they existed, only models left.
 
 
-  let routeName = args.shift();
   let models = args;
   return {
     routeName,
@@ -32,7 +36,9 @@ export function extractRouteArgs(args) {
 }
 export function getActiveTargetName(router) {
   let routeInfos = router.activeTransition ? router.activeTransition[STATE_SYMBOL].routeInfos : router.state.routeInfos;
-  return routeInfos[routeInfos.length - 1].name;
+  let lastRouteInfo = routeInfos[routeInfos.length - 1];
+  assert('has last route info', lastRouteInfo);
+  return lastRouteInfo.name;
 }
 export function stashParamNames(router, routeInfos) {
   if (routeInfos['_namesStashed']) {
@@ -43,7 +49,9 @@ export function stashParamNames(router, routeInfos) {
   // Hopefully we can remove this in the future.
 
 
-  let targetRouteName = routeInfos[routeInfos.length - 1].name;
+  let routeInfo = routeInfos[routeInfos.length - 1];
+  assert('has route info', routeInfo);
+  let targetRouteName = routeInfo.name;
 
   let recogHandlers = router._routerMicrolib.recognizer.handlersFor(targetRouteName);
 
@@ -51,6 +59,7 @@ export function stashParamNames(router, routeInfos) {
 
   for (let i = 0; i < routeInfos.length; ++i) {
     let routeInfo = routeInfos[i];
+    assert('has route info', routeInfo);
     let names = recogHandlers[i].names;
 
     if (names.length) {
@@ -58,7 +67,7 @@ export function stashParamNames(router, routeInfos) {
     }
 
     routeInfo['_names'] = names;
-    let route = routeInfo.route;
+    let route = routeInfo.route; // SAFETY: This cast should be idential. I don't understand why it is needed.
 
     route._stashNames(routeInfo, dynamicParent);
   }
@@ -96,9 +105,7 @@ function _calculateCacheValuePrefix(prefix, part) {
 export function calculateCacheKey(prefix, parts = [], values) {
   let suffixes = '';
 
-  for (let i = 0; i < parts.length; ++i) {
-    let part = parts[i];
-
+  for (let part of parts) {
     let cacheValuePrefix = _calculateCacheValuePrefix(prefix, part);
 
     let value;
@@ -153,8 +160,8 @@ export function calculateCacheKey(prefix, parts = [], values) {
 export function normalizeControllerQueryParams(queryParams) {
   let qpMap = {};
 
-  for (let i = 0; i < queryParams.length; ++i) {
-    accumulateQueryParamDescriptors(queryParams[i], qpMap);
+  for (let queryParam of queryParams) {
+    accumulateQueryParamDescriptors(queryParam, qpMap);
   }
 
   return qpMap;
@@ -185,12 +192,12 @@ function accumulateQueryParamDescriptors(_desc, accum) {
       };
     }
 
-    tmp = accum[key] || {
+    let val = accum[key] || {
       as: null,
       scope: 'model'
     };
-    Object.assign(tmp, singleDesc);
-    accum[key] = tmp;
+    Object.assign(val, singleDesc);
+    accum[key] = val;
   }
 }
 /*
@@ -210,11 +217,14 @@ export function resemblesURL(str) {
 */
 
 export function prefixRouteNameArg(route, args) {
-  let routeName = args[0];
+  let routeName;
   let owner = getOwner(route);
+  assert('Route is unexpectedly missing an owner', owner);
   let prefix = owner.mountPoint; // only alter the routeName if it's actually referencing a route.
 
-  if (owner.routable && typeof routeName === 'string') {
+  if (owner.routable && typeof args[0] === 'string') {
+    routeName = args[0];
+
     if (resemblesURL(routeName)) {
       throw new EmberError('Programmatic transitions by URL cannot be used within an Engine. Please use the route name instead.');
     } else {
@@ -253,9 +263,22 @@ export function deprecateTransitionMethods(frameworkClass, methodName) {
     id: 'routing.transition-methods',
     for: 'ember-source',
     since: {
+      available: '3.26.0',
       enabled: '3.26.0'
     },
     until: '5.0.0',
     url: 'https://deprecations.emberjs.com/v3.x/#toc_routing-transition-methods'
   });
+}
+
+function isRouteOptions(value) {
+  if (value && typeof value === 'object') {
+    let qps = value.queryParams;
+
+    if (qps && typeof qps === 'object') {
+      return Object.keys(qps).every(k => typeof k === 'string');
+    }
+  }
+
+  return false;
 }

package/dist/packages/@ember/-internals/runtime/lib/mixins/-proxy.js

@@ -53,7 +53,7 @@ function customTagForProxy(proxy, key, addMandatorySetter) {
 export default Mixin.create({
   /**
     The object whose properties will be forwarded.
-     @property content
+       @property content
     @type {unknown}
     @default null
     @public

package/dist/packages/@ember/-internals/runtime/lib/mixins/array.js

@@ -952,6 +952,7 @@ const ArrayMixin = Mixin.create(Enumerable, {
     @return {Object} The reduced value.
     @public
   */
+  // FIXME: When called without initialValue, behavior does not match native behavior
   reduce(callback, initialValue) {
     assert('`reduce` expects a function as first argument.', typeof callback === 'function');
     let ret = initialValue;

package/dist/packages/@ember/-internals/runtime/lib/mixins/comparable.js

@@ -18,13 +18,13 @@ import { Mixin } from '@ember/-internals/metal';
 export default Mixin.create({
   /**
     __Required.__ You must implement this method to apply this mixin.
-     Override to return the result of the comparison of the two parameters. The
+       Override to return the result of the comparison of the two parameters. The
     compare method should return:
-     - `-1` if `a < b`
+       - `-1` if `a < b`
     - `0` if `a == b`
     - `1` if `a > b`
-     Default implementation raises an exception.
-     @method compare
+       Default implementation raises an exception.
+       @method compare
     @param a {Object} the first object to compare
     @param b {Object} the second object to compare
     @return {Number} the result of the comparison

package/dist/packages/@ember/-internals/runtime/lib/mixins/container_proxy.js

@@ -15,7 +15,7 @@ import { Mixin } from '@ember/-internals/metal';
 let containerProxyMixin = {
   /**
    The container stores state.
-    @private
+      @private
    @property {Ember.Container} __container__
    */
   __container__: null,
@@ -23,16 +23,16 @@ let containerProxyMixin = {
   /**
    Returns an object that can be used to provide an owner to a
    manually created instance.
-    Example:
-    ```
+      Example:
+      ```
    import { getOwner } from '@ember/application';
-    let owner = getOwner(this);
-    User.create(
+      let owner = getOwner(this);
+      User.create(
      owner.ownerInjection(),
      { username: 'rwjblue' }
    )
    ```
-    @public
+      @public
    @method ownerInjection
    @since 2.3.0
    @return {Object}
@@ -43,30 +43,30 @@ let containerProxyMixin = {
 
   /**
    Given a fullName return a corresponding instance.
-    The default behavior is for lookup to return a singleton instance.
+      The default behavior is for lookup to return a singleton instance.
    The singleton is scoped to the container, allowing multiple containers
    to all have their own locally scoped singletons.
-    ```javascript
+      ```javascript
    let registry = new Registry();
    let container = registry.container();
-    registry.register('api:twitter', Twitter);
-    let twitter = container.lookup('api:twitter');
-    twitter instanceof Twitter; // => true
-    // by default the container will return singletons
+      registry.register('api:twitter', Twitter);
+      let twitter = container.lookup('api:twitter');
+      twitter instanceof Twitter; // => true
+      // by default the container will return singletons
    let twitter2 = container.lookup('api:twitter');
    twitter2 instanceof Twitter; // => true
-    twitter === twitter2; //=> true
+      twitter === twitter2; //=> true
    ```
-    If singletons are not wanted an optional flag can be provided at lookup.
-    ```javascript
+      If singletons are not wanted an optional flag can be provided at lookup.
+      ```javascript
    let registry = new Registry();
    let container = registry.container();
-    registry.register('api:twitter', Twitter);
-    let twitter = container.lookup('api:twitter', { singleton: false });
+      registry.register('api:twitter', Twitter);
+      let twitter = container.lookup('api:twitter', { singleton: false });
    let twitter2 = container.lookup('api:twitter', { singleton: false });
-    twitter === twitter2; //=> false
+      twitter === twitter2; //=> false
    ```
-    @public
+      @public
    @method lookup
    @param {String} fullName
    @param {Object} options
@@ -91,32 +91,32 @@ let containerProxyMixin = {
 
   /**
   Given a fullName return a factory manager.
-   This method returns a manager which can be used for introspection of the
+     This method returns a manager which can be used for introspection of the
   factory's class or for the creation of factory instances with initial
   properties. The manager is an object with the following properties:
-   * `class` - The registered or resolved class.
+     * `class` - The registered or resolved class.
   * `create` - A function that will create an instance of the class with
     any dependencies injected.
-   For example:
-   ```javascript
+     For example:
+     ```javascript
   import { getOwner } from '@ember/application';
-   let owner = getOwner(otherInstance);
+     let owner = getOwner(otherInstance);
   // the owner is commonly the `applicationInstance`, and can be accessed via
   // an instance initializer.
-   let factory = owner.factoryFor('service:bespoke');
-   factory.class;
+     let factory = owner.factoryFor('service:bespoke');
+     factory.class;
   // The registered or resolved class. For example when used with an Ember-CLI
   // app, this would be the default export from `app/services/bespoke.js`.
-   let instance = factory.create({
+     let instance = factory.create({
     someProperty: 'an initial property value'
   });
   // Create an instance with any injections and the passed options as
   // initial properties.
   ```
-   Any instances created via the factory's `.create()` method *must* be destroyed
+     Any instances created via the factory's `.create()` method *must* be destroyed
   manually by the caller of `.create()`. Typically, this is done during the creating
   objects own `destroy` or `willDestroy` methods.
-   @public
+     @public
   @method factoryFor
   @param {String} fullName
   @param {Object} options