discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/@ember/engine/instance.js

@@ -1,228 +0,0 @@
-/**
-@module @ember/engine
-*/
-
-import { guidFor } from 'ember-utils';
-import {
-  Object as EmberObject,
-  ContainerProxyMixin,
-  RegistryProxyMixin,
-  RSVP,
-} from 'ember-runtime';
-import { assert } from '@ember/debug';
-import EmberError from '@ember/error';
-import { Registry, privatize as P } from 'container';
-import { getEngineParent, setEngineParent } from './lib/engine-parent';
-
-/**
-  The `EngineInstance` encapsulates all of the stateful aspects of a
-  running `Engine`.
-
-  @public
-  @class EngineInstance
-  @extends EmberObject
-  @uses RegistryProxyMixin
-  @uses ContainerProxyMixin
-*/
-
-const EngineInstance = EmberObject.extend(RegistryProxyMixin, ContainerProxyMixin, {
-  /**
-    The base `Engine` for which this is an instance.
-
-    @property {Engine} engine
-    @private
-  */
-  base: null,
-
-  init() {
-    this._super(...arguments);
-
-    guidFor(this);
-
-    let base = this.base;
-
-    if (!base) {
-      base = this.application;
-      this.base = base;
-    }
-
-    // Create a per-instance registry that will use the application's registry
-    // as a fallback for resolving registrations.
-    let registry = (this.__registry__ = new Registry({
-      fallback: base.__registry__,
-    }));
-
-    // Create a per-instance container from the instance's registry
-    this.__container__ = registry.container({ owner: this });
-
-    this._booted = false;
-  },
-
-  /**
-    Initialize the `EngineInstance` and return a promise that resolves
-    with the instance itself when the boot process is complete.
-
-    The primary task here is to run any registered instance initializers.
-
-    See the documentation on `BootOptions` for the options it takes.
-
-    @public
-    @method boot
-    @param options {Object}
-    @return {Promise<EngineInstance,Error>}
-  */
-  boot(options) {
-    if (this._bootPromise) {
-      return this._bootPromise;
-    }
-
-    this._bootPromise = new RSVP.Promise(resolve => resolve(this._bootSync(options)));
-
-    return this._bootPromise;
-  },
-
-  /**
-    Unfortunately, a lot of existing code assumes booting an instance is
-    synchronous – specifically, a lot of tests assume the last call to
-    `app.advanceReadiness()` or `app.reset()` will result in a new instance
-    being fully-booted when the current runloop completes.
-
-    We would like new code (like the `visit` API) to stop making this
-    assumption, so we created the asynchronous version above that returns a
-    promise. But until we have migrated all the code, we would have to expose
-    this method for use *internally* in places where we need to boot an instance
-    synchronously.
-
-    @private
-  */
-  _bootSync(options) {
-    if (this._booted) {
-      return this;
-    }
-
-    assert(
-      "An engine instance's parent must be set via `setEngineParent(engine, parent)` prior to calling `engine.boot()`.",
-      getEngineParent(this)
-    );
-
-    this.cloneParentDependencies();
-
-    this.setupRegistry(options);
-
-    this.base.runInstanceInitializers(this);
-
-    this._booted = true;
-
-    return this;
-  },
-
-  setupRegistry(options = this.__container__.lookup('-environment:main')) {
-    this.constructor.setupRegistry(this.__registry__, options);
-  },
-
-  /**
-   Unregister a factory.
-
-   Overrides `RegistryProxy#unregister` in order to clear any cached instances
-   of the unregistered factory.
-
-   @public
-   @method unregister
-   @param {String} fullName
-   */
-  unregister(fullName) {
-    this.__container__.reset(fullName);
-    this._super(...arguments);
-  },
-
-  /**
-    Build a new `EngineInstance` that's a child of this instance.
-
-    Engines must be registered by name with their parent engine
-    (or application).
-
-    @private
-    @method buildChildEngineInstance
-    @param name {String} the registered name of the engine.
-    @param options {Object} options provided to the engine instance.
-    @return {EngineInstance,Error}
-  */
-  buildChildEngineInstance(name, options = {}) {
-    let Engine = this.lookup(`engine:${name}`);
-
-    if (!Engine) {
-      throw new EmberError(
-        `You attempted to mount the engine '${name}', but it is not registered with its parent.`
-      );
-    }
-
-    let engineInstance = Engine.buildInstance(options);
-
-    setEngineParent(engineInstance, this);
-
-    return engineInstance;
-  },
-
-  /**
-    Clone dependencies shared between an engine instance and its parent.
-
-    @private
-    @method cloneParentDependencies
-  */
-  cloneParentDependencies() {
-    let parent = getEngineParent(this);
-
-    let registrations = ['route:basic', 'service:-routing', 'service:-glimmer-environment'];
-
-    registrations.forEach(key => this.register(key, parent.resolveRegistration(key)));
-
-    let env = parent.lookup('-environment:main');
-    this.register('-environment:main', env, { instantiate: false });
-
-    let singletons = [
-      'router:main',
-      P`-bucket-cache:main`,
-      '-view-registry:main',
-      `renderer:-${env.isInteractive ? 'dom' : 'inert'}`,
-      'service:-document',
-      P`template-compiler:main`,
-    ];
-
-    if (env.isInteractive) {
-      singletons.push('event_dispatcher:main');
-    }
-
-    singletons.forEach(key => this.register(key, parent.lookup(key), { instantiate: false }));
-
-    this.inject('view', '_environment', '-environment:main');
-    this.inject('route', '_environment', '-environment:main');
-  },
-});
-
-EngineInstance.reopenClass({
-  /**
-   @private
-   @method setupRegistry
-   @param {Registry} registry
-   @param {BootOptions} options
-   */
-  setupRegistry(registry, options) {
-    // when no options/environment is present, do nothing
-    if (!options) {
-      return;
-    }
-
-    registry.injection('view', '_environment', '-environment:main');
-    registry.injection('route', '_environment', '-environment:main');
-
-    if (options.isInteractive) {
-      registry.injection('view', 'renderer', 'renderer:-dom');
-      registry.injection('component', 'renderer', 'renderer:-dom');
-    } else {
-      registry.injection('view', 'renderer', 'renderer:-inert');
-      registry.injection('component', 'renderer', 'renderer:-inert');
-    }
-  },
-});
-
-export default EngineInstance;

data/dist/es/@ember/engine/lib/engine-parent.js

@@ -1,32 +0,0 @@
-/**
-@module @ember/engine
-*/
-import { symbol } from 'ember-utils';
-
-const ENGINE_PARENT = symbol('ENGINE_PARENT');
-
-/**
-  `getEngineParent` retrieves an engine instance's parent instance.
-
-  @method getEngineParent
-  @param {EngineInstance} engine An engine instance.
-  @return {EngineInstance} The parent engine instance.
-  @for @ember/engine
-  @static
-  @private
-*/
-export function getEngineParent(engine) {
-  return engine[ENGINE_PARENT];
-}
-
-/**
-  `setEngineParent` sets an engine instance's parent instance.
-
-  @method setEngineParent
-  @param {EngineInstance} engine An engine instance.
-  @param {EngineInstance} parent The parent engine instance.
-  @private
-*/
-export function setEngineParent(engine, parent) {
-  engine[ENGINE_PARENT] = parent;
-}

data/dist/es/@ember/engine/tests/engine_initializers_test.js

@@ -1,366 +0,0 @@
-import { run } from '@ember/runloop';
-import Engine from '@ember/engine';
-import { moduleFor, AbstractTestCase as TestCase } from 'internal-test-helpers';
-
-let MyEngine, myEngine, myEngineInstance;
-
-moduleFor(
-  'Engine initializers',
-  class extends TestCase {
-    teardown() {
-      run(() => {
-        if (myEngineInstance) {
-          myEngineInstance.destroy();
-          myEngineInstance = null;
-        }
-
-        if (myEngine) {
-          myEngine.destroy();
-          myEngine = null;
-        }
-      });
-    }
-
-    ["@test initializers require proper 'name' and 'initialize' properties"]() {
-      MyEngine = Engine.extend();
-
-      expectAssertion(() => {
-        run(() => {
-          MyEngine.initializer({ name: 'initializer' });
-        });
-      });
-
-      expectAssertion(() => {
-        run(() => {
-          MyEngine.initializer({ initialize() {} });
-        });
-      });
-    }
-
-    ['@test initializers are passed an Engine'](assert) {
-      MyEngine = Engine.extend();
-
-      MyEngine.initializer({
-        name: 'initializer',
-        initialize(engine) {
-          assert.ok(engine instanceof Engine, 'initialize is passed an Engine');
-        },
-      });
-
-      myEngine = MyEngine.create();
-      myEngineInstance = myEngine.buildInstance();
-    }
-
-    ['@test initializers can be registered in a specified order'](assert) {
-      let order = [];
-
-      MyEngine = Engine.extend();
-      MyEngine.initializer({
-        name: 'fourth',
-        after: 'third',
-        initialize() {
-          order.push('fourth');
-        },
-      });
-
-      MyEngine.initializer({
-        name: 'second',
-        after: 'first',
-        before: 'third',
-        initialize() {
-          order.push('second');
-        },
-      });
-
-      MyEngine.initializer({
-        name: 'fifth',
-        after: 'fourth',
-        before: 'sixth',
-        initialize() {
-          order.push('fifth');
-        },
-      });
-
-      MyEngine.initializer({
-        name: 'first',
-        before: 'second',
-        initialize() {
-          order.push('first');
-        },
-      });
-
-      MyEngine.initializer({
-        name: 'third',
-        initialize() {
-          order.push('third');
-        },
-      });
-
-      MyEngine.initializer({
-        name: 'sixth',
-        initialize() {
-          order.push('sixth');
-        },
-      });
-
-      myEngine = MyEngine.create();
-      myEngineInstance = myEngine.buildInstance();
-
-      assert.deepEqual(order, ['first', 'second', 'third', 'fourth', 'fifth', 'sixth']);
-    }
-
-    ['@test initializers can be registered in a specified order as an array'](assert) {
-      let order = [];
-
-      MyEngine = Engine.extend();
-
-      MyEngine.initializer({
-        name: 'third',
-        initialize() {
-          order.push('third');
-        },
-      });
-
-      MyEngine.initializer({
-        name: 'second',
-        after: 'first',
-        before: ['third', 'fourth'],
-        initialize() {
-          order.push('second');
-        },
-      });
-
-      MyEngine.initializer({
-        name: 'fourth',
-        after: ['second', 'third'],
-        initialize() {
-          order.push('fourth');
-        },
-      });
-
-      MyEngine.initializer({
-        name: 'fifth',
-        after: 'fourth',
-        before: 'sixth',
-        initialize() {
-          order.push('fifth');
-        },
-      });
-
-      MyEngine.initializer({
-        name: 'first',
-        before: ['second'],
-        initialize() {
-          order.push('first');
-        },
-      });
-
-      MyEngine.initializer({
-        name: 'sixth',
-        initialize() {
-          order.push('sixth');
-        },
-      });
-
-      myEngine = MyEngine.create();
-      myEngineInstance = myEngine.buildInstance();
-
-      assert.deepEqual(order, ['first', 'second', 'third', 'fourth', 'fifth', 'sixth']);
-    }
-
-    ['@test initializers can have multiple dependencies'](assert) {
-      let order = [];
-
-      MyEngine = Engine.extend();
-
-      let a = {
-        name: 'a',
-        before: 'b',
-        initialize() {
-          order.push('a');
-        },
-      };
-      let b = {
-        name: 'b',
-        initialize() {
-          order.push('b');
-        },
-      };
-      let c = {
-        name: 'c',
-        after: 'b',
-        initialize() {
-          order.push('c');
-        },
-      };
-      let afterB = {
-        name: 'after b',
-        after: 'b',
-        initialize() {
-          order.push('after b');
-        },
-      };
-      let afterC = {
-        name: 'after c',
-        after: 'c',
-        initialize() {
-          order.push('after c');
-        },
-      };
-
-      MyEngine.initializer(b);
-      MyEngine.initializer(a);
-      MyEngine.initializer(afterC);
-      MyEngine.initializer(afterB);
-      MyEngine.initializer(c);
-
-      myEngine = MyEngine.create();
-      myEngineInstance = myEngine.buildInstance();
-
-      assert.ok(order.indexOf(a.name) < order.indexOf(b.name), 'a < b');
-      assert.ok(order.indexOf(b.name) < order.indexOf(c.name), 'b < c');
-      assert.ok(order.indexOf(b.name) < order.indexOf(afterB.name), 'b < afterB');
-      assert.ok(order.indexOf(c.name) < order.indexOf(afterC.name), 'c < afterC');
-    }
-
-    ['@test initializers set on Engine subclasses are not shared between engines'](assert) {
-      let firstInitializerRunCount = 0;
-      let secondInitializerRunCount = 0;
-      let FirstEngine = Engine.extend();
-
-      FirstEngine.initializer({
-        name: 'first',
-        initialize() {
-          firstInitializerRunCount++;
-        },
-      });
-
-      let SecondEngine = Engine.extend();
-
-      SecondEngine.initializer({
-        name: 'second',
-        initialize() {
-          secondInitializerRunCount++;
-        },
-      });
-
-      let firstEngine = FirstEngine.create();
-      let firstEngineInstance = firstEngine.buildInstance();
-
-      assert.equal(firstInitializerRunCount, 1, 'first initializer only was run');
-      assert.equal(secondInitializerRunCount, 0, 'first initializer only was run');
-
-      let secondEngine = SecondEngine.create();
-      let secondEngineInstance = secondEngine.buildInstance();
-
-      assert.equal(firstInitializerRunCount, 1, 'second initializer only was run');
-      assert.equal(secondInitializerRunCount, 1, 'second initializer only was run');
-
-      run(function() {
-        firstEngineInstance.destroy();
-        secondEngineInstance.destroy();
-
-        firstEngine.destroy();
-        secondEngine.destroy();
-      });
-    }
-
-    ['@test initializers are concatenated'](assert) {
-      let firstInitializerRunCount = 0;
-      let secondInitializerRunCount = 0;
-      let FirstEngine = Engine.extend();
-
-      FirstEngine.initializer({
-        name: 'first',
-        initialize() {
-          firstInitializerRunCount++;
-        },
-      });
-
-      let SecondEngine = FirstEngine.extend();
-
-      SecondEngine.initializer({
-        name: 'second',
-        initialize() {
-          secondInitializerRunCount++;
-        },
-      });
-
-      let firstEngine = FirstEngine.create();
-      let firstEngineInstance = firstEngine.buildInstance();
-
-      assert.equal(
-        firstInitializerRunCount,
-        1,
-        'first initializer only was run when base class created'
-      );
-      assert.equal(
-        secondInitializerRunCount,
-        0,
-        'second initializer was not run when first base class created'
-      );
-      firstInitializerRunCount = 0;
-
-      let secondEngine = SecondEngine.create();
-      let secondEngineInstance = secondEngine.buildInstance();
-
-      assert.equal(firstInitializerRunCount, 1, 'first initializer was run when subclass created');
-      assert.equal(
-        secondInitializerRunCount,
-        1,
-        'second initializers was run when subclass created'
-      );
-
-      run(function() {
-        firstEngineInstance.destroy();
-        secondEngineInstance.destroy();
-
-        firstEngine.destroy();
-        secondEngine.destroy();
-      });
-    }
-
-    ['@test initializers are per-engine'](assert) {
-      assert.expect(2);
-
-      let FirstEngine = Engine.extend();
-
-      FirstEngine.initializer({
-        name: 'abc',
-        initialize() {},
-      });
-
-      expectAssertion(function() {
-        FirstEngine.initializer({
-          name: 'abc',
-          initialize() {},
-        });
-      });
-
-      let SecondEngine = Engine.extend();
-      SecondEngine.instanceInitializer({
-        name: 'abc',
-        initialize() {},
-      });
-
-      assert.ok(true, 'Two engines can have initializers named the same.');
-    }
-
-    ['@test initializers are executed in their own context'](assert) {
-      assert.expect(1);
-
-      MyEngine = Engine.extend();
-
-      MyEngine.initializer({
-        name: 'coolInitializer',
-        myProperty: 'cool',
-        initialize() {
-          assert.equal(this.myProperty, 'cool', 'should have access to its own context');
-        },
-      });
-
-      myEngine = MyEngine.create();
-      myEngineInstance = myEngine.buildInstance();
-    }
-  }
-);