ember-source 4.3.0-alpha.3 → 4.4.0-alpha.2

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

@@ -1,6 +1,7 @@
 import { privatize as P } from '@ember/-internals/container';
 import { computed, get, set } from '@ember/-internals/metal';
 import { getOwner } from '@ember/-internals/owner';
+import { BucketCache } from '@ember/-internals/routing';
 import { A as emberA, Evented, Object as EmberObject, typeOf } from '@ember/-internals/runtime';
 import { assert, deprecate, info } from '@ember/debug';
 import EmberError from '@ember/error';
@@ -11,7 +12,12 @@ 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';
+import EngineInstance from '@ember/engine/instance';
 
 function defaultDidTransition(infos) {
   updatePaths(this);
@@ -73,7 +79,7 @@ const {
 
 class EmberRouter extends EmberObject.extend(Evented) {
   constructor(owner) {
-    super(...arguments);
+    super(owner);
     this._didSetupRouter = false;
     this._initialTransitionStarted = false;
     this.currentURL = null;
@@ -95,7 +101,7 @@ class EmberRouter extends EmberObject.extend(Evented) {
 
     this.namespace = owner.lookup('application:main');
     let bucketCache = owner.lookup(P`-bucket-cache:main`);
-    assert('BUG: BucketCache should always be present', bucketCache !== undefined);
+    assert('BUG: BucketCache should always be present', bucketCache instanceof BucketCache);
     this._bucketCache = bucketCache;
     let routerService = owner.lookup('service:router');
     assert('BUG: RouterService should always be present', routerService !== undefined);
@@ -166,7 +172,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);
 
@@ -472,8 +480,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;
 
@@ -549,9 +557,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
@@ -592,6 +599,23 @@ class EmberRouter extends EmberObject.extend(Evented) {
       }
     }
   }
+  /**
+    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');
@@ -677,8 +701,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');
       }
     }
   }
@@ -1000,12 +1027,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;
@@ -1013,9 +1039,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];
@@ -1061,19 +1085,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) {
@@ -1103,15 +1123,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) {
@@ -1188,23 +1210,27 @@ class EmberRouter extends EmberObject.extend(Evented) {
     mountPoint
   }) {
     let engineInstances = this._engineInstances;
+    let namedInstances = engineInstances[name];
 
-    if (!engineInstances[name]) {
-      engineInstances[name] = Object.create(null);
-    }
+    if (!namedInstances) {
+      namedInstances = Object.create(null);
+      engineInstances[name] = namedInstances;
+    } // We just set these!
 
-    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('Expected router to have EngineInstance as owner', owner instanceof EngineInstance);
       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;
@@ -1231,6 +1257,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
@@ -1433,6 +1460,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];
 
@@ -1470,9 +1498,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 {
@@ -1492,23 +1519,15 @@ 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 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
-    // substates have been entered since ApplicationRoute hasn't
-    // actually been entered at that point.
-    return;
-  }
 }
 
 function didBeginTransition(transition, router) {

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

@@ -1,26 +1,33 @@
 import { get } from '@ember/-internals/metal';
 import { getOwner } from '@ember/-internals/owner';
 import { assert, deprecate } from '@ember/debug';
+import EngineInstance from '@ember/engine/instance';
 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.pop();
+  let possibleOptions = args[args.length - 1];
   let queryParams;
 
-  if (hasQueryParams(possibleQueryParams)) {
-    queryParams = possibleQueryParams.queryParams;
+  if (isRouteOptions(possibleOptions)) {
+    args.pop(); // Remove options
+
+    queryParams = possibleOptions.queryParams;
   } else {
-    // Not query params so return to the array
-    args.push(possibleQueryParams);
     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,
@@ -30,7 +37,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']) {
@@ -41,7 +50,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);
 
@@ -49,6 +60,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) {
@@ -56,7 +68,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);
   }
@@ -94,9 +106,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;
@@ -151,8 +161,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;
@@ -208,12 +218,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);
+  assert('Expected route to have EngineInstance as owner', owner instanceof EngineInstance);
   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 {
@@ -260,7 +272,7 @@ export function deprecateTransitionMethods(frameworkClass, methodName) {
   });
 }
 
-function hasQueryParams(value) {
+function isRouteOptions(value) {
   if (value && typeof value === 'object') {
     let qps = value.queryParams;
 

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

@@ -21,16 +21,16 @@ const ActionHandler = Mixin.create({
   /**
     The collection of functions, keyed by name, available on this
     `ActionHandler` as action targets.
-       These functions will be invoked when a matching `{{action}}` is triggered
+     These functions will be invoked when a matching `{{action}}` is triggered
     from within a template and the application's current route is this route.
-       Actions can also be invoked from other parts of your application
+     Actions can also be invoked from other parts of your application
     via `ActionHandler#send`.
-       The `actions` hash will inherit action handlers from
+     The `actions` hash will inherit action handlers from
     the `actions` hash defined on extended parent classes
     or mixins rather than just replace the entire hash, e.g.:
-       ```app/mixins/can-display-banner.js
+     ```app/mixins/can-display-banner.js
     import Mixin from '@ember/mixin';
-       export default Mixin.create({
+     export default Mixin.create({
       actions: {
         displayBanner(msg) {
           // ...
@@ -38,28 +38,28 @@ const ActionHandler = Mixin.create({
       }
     });
     ```
-       ```app/routes/welcome.js
+     ```app/routes/welcome.js
     import Route from '@ember/routing/route';
     import CanDisplayBanner from '../mixins/can-display-banner';
-       export default Route.extend(CanDisplayBanner, {
+     export default Route.extend(CanDisplayBanner, {
       actions: {
         playMusic() {
           // ...
         }
       }
     });
-       // `WelcomeRoute`, when active, will be able to respond
+     // `WelcomeRoute`, when active, will be able to respond
     // to both actions, since the actions hash is merged rather
     // then replaced when extending mixins / parent classes.
     this.send('displayBanner');
     this.send('playMusic');
     ```
-       Within a Controller, Route or Component's action handler,
+     Within a Controller, Route or Component's action handler,
     the value of the `this` context is the Controller, Route or
     Component object:
-       ```app/routes/song.js
+     ```app/routes/song.js
     import Route from '@ember/routing/route';
-       export default Route.extend({
+     export default Route.extend({
       actions: {
         myAction() {
           this.controllerFor("song");
@@ -69,13 +69,13 @@ const ActionHandler = Mixin.create({
       }
     });
     ```
-       It is also possible to call `this._super(...arguments)` from within an
+     It is also possible to call `this._super(...arguments)` from within an
     action handler if it overrides a handler defined on a parent
     class or mixin:
-       Take for example the following routes:
-       ```app/mixins/debug-route.js
+     Take for example the following routes:
+     ```app/mixins/debug-route.js
     import Mixin from '@ember/mixin';
-       export default Mixin.create({
+     export default Mixin.create({
       actions: {
         debugRouteInformation() {
           console.debug("It's a-me, console.debug!");
@@ -83,54 +83,54 @@ const ActionHandler = Mixin.create({
       }
     });
     ```
-       ```app/routes/annoying-debug.js
+     ```app/routes/annoying-debug.js
     import Route from '@ember/routing/route';
     import DebugRoute from '../mixins/debug-route';
-       export default Route.extend(DebugRoute, {
+     export default Route.extend(DebugRoute, {
       actions: {
         debugRouteInformation() {
           // also call the debugRouteInformation of mixed in DebugRoute
           this._super(...arguments);
-             // show additional annoyance
+           // show additional annoyance
           window.alert(...);
         }
       }
     });
     ```
-       ## Bubbling
-       By default, an action will stop bubbling once a handler defined
+     ## Bubbling
+     By default, an action will stop bubbling once a handler defined
     on the `actions` hash handles it. To continue bubbling the action,
     you must return `true` from the handler:
-       ```app/router.js
+     ```app/router.js
     Router.map(function() {
       this.route("album", function() {
         this.route("song");
       });
     });
     ```
-       ```app/routes/album.js
+     ```app/routes/album.js
     import Route from '@ember/routing/route';
-       export default Route.extend({
+     export default Route.extend({
       actions: {
         startPlaying: function() {
         }
       }
     });
     ```
-       ```app/routes/album-song.js
+     ```app/routes/album-song.js
     import Route from '@ember/routing/route';
-       export default Route.extend({
+     export default Route.extend({
       actions: {
         startPlaying() {
           // ...
-             if (actionShouldAlsoBeTriggeredOnParentRoute) {
+           if (actionShouldAlsoBeTriggeredOnParentRoute) {
             return true;
           }
         }
       }
     });
     ```
-       @property actions
+     @property actions
     @type Object
     @default null
     @public
@@ -140,14 +140,14 @@ const ActionHandler = Mixin.create({
     Triggers a named action on the `ActionHandler`. Any parameters
     supplied after the `actionName` string will be passed as arguments
     to the action target function.
-       If the `ActionHandler` has its `target` property set, actions may
+     If the `ActionHandler` has its `target` property set, actions may
     bubble to the `target`. Bubbling happens when an `actionName` can
     not be found in the `ActionHandler`'s `actions` hash or if the
     action target function returns `true`.
-       Example
-       ```app/routes/welcome.js
+     Example
+     ```app/routes/welcome.js
     import Route from '@ember/routing/route';
-       export default Route.extend({
+     export default Route.extend({
       actions: {
         playTheme() {
           this.send('playMusic', 'theme.mp3');
@@ -158,7 +158,7 @@ const ActionHandler = Mixin.create({
       }
     });
     ```
-       @method send
+     @method send
     @param {String} actionName The action to trigger
     @param {*} context a context to send with the action
     @public

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