discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/ember-metal/tests/watching/watch_test.js

@@ -1,255 +0,0 @@
-import { context } from 'ember-environment';
-import { set, get, computed, defineProperty, addListener, watch, unwatch } from '../..';
-import { deleteMeta, meta } from 'ember-meta';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-let didCount, didKeys, originalLookup;
-
-function addListeners(obj, keyPath) {
-  addListener(obj, keyPath + ':change', function() {
-    didCount++;
-    didKeys.push(keyPath);
-  });
-}
-
-moduleFor(
-  'watch',
-  class extends AbstractTestCase {
-    beforeEach() {
-      didCount = 0;
-      didKeys = [];
-
-      originalLookup = context.lookup;
-      context.lookup = {};
-    }
-
-    afterEach() {
-      context.lookup = originalLookup;
-    }
-
-    ['@test watching a computed property'](assert) {
-      let obj = {};
-      defineProperty(
-        obj,
-        'foo',
-        computed({
-          get() {
-            return this.__foo;
-          },
-          set(keyName, value) {
-            if (value !== undefined) {
-              this.__foo = value;
-            }
-            return this.__foo;
-          },
-        })
-      );
-      addListeners(obj, 'foo');
-
-      watch(obj, 'foo');
-      set(obj, 'foo', 'bar');
-      assert.equal(didCount, 1, 'should have invoked didCount');
-    }
-
-    ['@test watching a regular defined property'](assert) {
-      let obj = { foo: 'baz' };
-      addListeners(obj, 'foo');
-
-      watch(obj, 'foo');
-      assert.equal(get(obj, 'foo'), 'baz', 'should have original prop');
-
-      set(obj, 'foo', 'bar');
-      assert.equal(didCount, 1, 'should have invoked didCount');
-
-      assert.equal(get(obj, 'foo'), 'bar', 'should get new value');
-      assert.equal(obj.foo, 'bar', 'property should be accessible on obj');
-    }
-
-    ['@test watching a regular undefined property'](assert) {
-      let obj = {};
-      addListeners(obj, 'foo');
-
-      watch(obj, 'foo');
-
-      assert.equal('foo' in obj, false, 'precond undefined');
-
-      set(obj, 'foo', 'bar');
-
-      assert.equal(didCount, 1, 'should have invoked didCount');
-
-      assert.equal(get(obj, 'foo'), 'bar', 'should get new value');
-      assert.equal(obj.foo, 'bar', 'property should be accessible on obj');
-    }
-
-    ['@test watches should inherit'](assert) {
-      let obj = { foo: 'baz' };
-      let objB = Object.create(obj);
-
-      addListeners(obj, 'foo');
-      watch(obj, 'foo');
-      assert.equal(get(obj, 'foo'), 'baz', 'should have original prop');
-
-      set(obj, 'foo', 'bar');
-      set(objB, 'foo', 'baz');
-      assert.equal(didCount, 2, 'should have invoked didCount once only');
-    }
-
-    ['@test watching an object THEN defining it should work also'](assert) {
-      let obj = {};
-      addListeners(obj, 'foo');
-
-      watch(obj, 'foo');
-
-      defineProperty(obj, 'foo');
-      set(obj, 'foo', 'bar');
-
-      assert.equal(get(obj, 'foo'), 'bar', 'should have set');
-      assert.equal(didCount, 1, 'should have invoked didChange once');
-    }
-
-    ['@test watching a chain then defining the property'](assert) {
-      let obj = {};
-      let foo = { bar: 'bar' };
-      addListeners(obj, 'foo.bar');
-      addListeners(foo, 'bar');
-
-      watch(obj, 'foo.bar');
-
-      defineProperty(obj, 'foo', undefined, foo);
-      set(foo, 'bar', 'baz');
-
-      assert.deepEqual(
-        didKeys,
-        ['foo.bar', 'bar'],
-        'should have invoked didChange with bar, foo.bar'
-      );
-      assert.equal(didCount, 2, 'should have invoked didChange twice');
-    }
-
-    ['@test watching a chain then defining the nested property'](assert) {
-      let bar = {};
-      let obj = { foo: bar };
-      let baz = { baz: 'baz' };
-      addListeners(obj, 'foo.bar.baz');
-      addListeners(baz, 'baz');
-
-      watch(obj, 'foo.bar.baz');
-
-      defineProperty(bar, 'bar', undefined, baz);
-      set(baz, 'baz', 'BOO');
-
-      assert.deepEqual(
-        didKeys,
-        ['foo.bar.baz', 'baz'],
-        'should have invoked didChange with bar, foo.bar'
-      );
-      assert.equal(didCount, 2, 'should have invoked didChange twice');
-    }
-
-    ['@test watching an object value then unwatching should restore old value'](assert) {
-      let obj = { foo: { bar: { baz: { biff: 'BIFF' } } } };
-      addListeners(obj, 'foo.bar.baz.biff');
-
-      watch(obj, 'foo.bar.baz.biff');
-
-      let foo = get(obj, 'foo');
-      assert.equal(get(get(get(foo, 'bar'), 'baz'), 'biff'), 'BIFF', 'biff should exist');
-
-      unwatch(obj, 'foo.bar.baz.biff');
-      assert.equal(get(get(get(foo, 'bar'), 'baz'), 'biff'), 'BIFF', 'biff should exist');
-    }
-
-    ['@test when watching another object, destroy should remove chain watchers from the other object'](
-      assert
-    ) {
-      let objA = {};
-      let objB = { foo: 'bar' };
-      objA.b = objB;
-      addListeners(objA, 'b.foo');
-
-      watch(objA, 'b.foo');
-
-      let meta_objB = meta(objB);
-      let chainNode = meta(objA).readableChains().chains.b.chains.foo;
-
-      assert.equal(meta_objB.peekWatching('foo'), 1, 'should be watching foo');
-      assert.equal(
-        meta_objB.readableChainWatchers().has('foo', chainNode),
-        true,
-        'should have chain watcher'
-      );
-
-      deleteMeta(objA);
-
-      assert.equal(meta_objB.peekWatching('foo'), 0, 'should not be watching foo');
-      assert.equal(
-        meta_objB.readableChainWatchers().has('foo', chainNode),
-        false,
-        'should not have chain watcher'
-      );
-    }
-
-    // TESTS for length property
-
-    ['@test watching "length" property on an object'](assert) {
-      let obj = { length: '26.2 miles' };
-      addListeners(obj, 'length');
-
-      watch(obj, 'length');
-      assert.equal(get(obj, 'length'), '26.2 miles', 'should have original prop');
-
-      set(obj, 'length', '10k');
-      assert.equal(didCount, 1, 'should have invoked didCount');
-
-      assert.equal(get(obj, 'length'), '10k', 'should get new value');
-      assert.equal(obj.length, '10k', 'property should be accessible on obj');
-    }
-
-    ['@test watching "length" property on an array'](assert) {
-      let arr = [];
-      addListeners(arr, 'length');
-
-      watch(arr, 'length');
-      assert.equal(get(arr, 'length'), 0, 'should have original prop');
-
-      set(arr, 'length', '10');
-      assert.equal(didCount, 1, 'should NOT have invoked didCount');
-
-      assert.equal(get(arr, 'length'), 10, 'should get new value');
-      assert.equal(arr.length, 10, 'property should be accessible on arr');
-    }
-
-    ['@test watch + ES5 getter'](assert) {
-      let parent = { b: 1 };
-      let child = {
-        get b() {
-          return parent.b;
-        },
-      };
-
-      assert.equal(parent.b, 1, 'parent.b should be 1');
-      assert.equal(child.b, 1, 'child.b should be 1');
-      assert.equal(get(child, 'b'), 1, 'get(child, "b") should be 1');
-
-      watch(child, 'b');
-
-      assert.equal(parent.b, 1, 'parent.b should be 1 (after watch)');
-      assert.equal(child.b, 1, 'child.b should be 1  (after watch)');
-
-      assert.equal(get(child, 'b'), 1, 'get(child, "b") should be 1 (after watch)');
-    }
-
-    ['@test watch + set + no-descriptor'](assert) {
-      let child = {};
-
-      assert.equal(child.b, undefined, 'child.b ');
-      assert.equal(get(child, 'b'), undefined, 'get(child, "b")');
-
-      watch(child, 'b');
-      set(child, 'b', 1);
-
-      assert.equal(child.b, 1, 'child.b (after watch)');
-      assert.equal(get(child, 'b'), 1, 'get(child, "b") (after watch)');
-    }
-  }
-);

data/dist/es/ember-owner/index.js

@@ -1,66 +0,0 @@
-/**
-@module @ember/application
-*/
-import { symbol } from 'ember-utils';
-export const OWNER = symbol('OWNER');
-/**
-  Framework objects in an Ember application (components, services, routes, etc.)
-  are created via a factory and dependency injection system. Each of these
-  objects is the responsibility of an "owner", which handled its
-  instantiation and manages its lifetime.
-
-  `getOwner` fetches the owner object responsible for an instance. This can
-  be used to lookup or resolve other class instances, or register new factories
-  into the owner.
-
-  For example, this component dynamically looks up a service based on the
-  `audioType` passed as an attribute:
-
-  ```app/components/play-audio.js
-  import Component from '@ember/component';
-  import { computed } from '@ember/object';
-  import { getOwner } from '@ember/application';
-
-  // Usage:
-  //
-  //   {{play-audio audioType=model.audioType audioFile=model.file}}
-  //
-  export default Component.extend({
-    audioService: computed('audioType', function() {
-      let owner = getOwner(this);
-      return owner.lookup(`service:${this.get('audioType')}`);
-    }),
-
-    click() {
-      let player = this.get('audioService');
-      player.play(this.get('audioFile'));
-    }
-  });
-  ```
-
-  @method getOwner
-  @static
-  @for @ember/application
-  @param {Object} object An object with an owner.
-  @return {Object} An owner object.
-  @since 2.3.0
-  @public
-*/
-export function getOwner(object) {
-    return object[OWNER];
-}
-/**
-  `setOwner` forces a new owner on a given object instance. This is primarily
-  useful in some testing cases.
-
-  @method setOwner
-  @static
-  @for @ember/application
-  @param {Object} object An object instance.
-  @param {Object} object The new owner object of the object instance.
-  @since 2.3.0
-  @public
-*/
-export function setOwner(object, owner) {
-    object[OWNER] = owner;
-}

data/dist/es/ember-routing/index.js

@@ -1,21 +0,0 @@
-// ES6TODO: Cleanup modules with side-effects below
-import './lib/ext/controller';
-
-export { default as Location } from './lib/location/api';
-export { default as NoneLocation } from './lib/location/none_location';
-export { default as HashLocation } from './lib/location/hash_location';
-export { default as HistoryLocation } from './lib/location/history_location';
-export { default as AutoLocation } from './lib/location/auto_location';
-
-export {
-  default as generateController,
-  generateControllerFactory,
-} from './lib/system/generate_controller';
-export { default as controllerFor } from './lib/system/controller_for';
-export { default as RouterDSL } from './lib/system/dsl';
-export { default as Router } from './lib/system/router';
-export { default as Route } from './lib/system/route';
-export { default as QueryParams } from './lib/system/query_params';
-export { default as RoutingService } from './lib/services/routing';
-export { default as RouterService } from './lib/services/router';
-export { default as BucketCache } from './lib/system/cache';

data/dist/es/ember-routing/lib/ext/controller.js

@@ -1,222 +0,0 @@
-import { get } from 'ember-metal';
-import ControllerMixin from '@ember/controller/lib/controller_mixin';
-import { prefixRouteNameArg } from '../utils';
-
-/**
-@module ember
-*/
-
-ControllerMixin.reopen({
-  concatenatedProperties: ['queryParams'],
-
-  /**
-    Defines which query parameters the controller accepts.
-    If you give the names `['category','page']` it will bind
-    the values of these query parameters to the variables
-    `this.category` and `this.page`.
-    By default, Ember coerces query parameter values using `toggleProperty`.
-    This behavior may lead to unexpected results.
-    To explicitly configure a query parameter property so it coerces as expected, you must define a type property:
-    ```javascript
-      queryParams: [{
-        category: {
-          type: 'boolean'
-        }
-      }]
-    ```
-    @for Ember.ControllerMixin
-    @property queryParams
-    @public
-  */
-  queryParams: null,
-
-  /**
-   This property is updated to various different callback functions depending on
-   the current "state" of the backing route. It is used by
-   `Controller.prototype._qpChanged`.
-
-   The methods backing each state can be found in the `Route.prototype._qp` computed
-   property return value (the `.states` property). The current values are listed here for
-   the sanity of future travelers:
-
-   * `inactive` - This state is used when this controller instance is not part of the active
-     route hierarchy. Set in `Route.prototype._reset` (a `router.js` microlib hook) and
-     `Route.prototype.actions.finalizeQueryParamChange`.
-   * `active` - This state is used when this controller instance is part of the active
-     route hierarchy. Set in `Route.prototype.actions.finalizeQueryParamChange`.
-   * `allowOverrides` - This state is used in `Route.prototype.setup` (`route.js` microlib hook).
-
-    @method _qpDelegate
-    @private
-  */
-  _qpDelegate: null, // set by route
-
-  /**
-   During `Route#setup` observers are created to invoke this method
-   when any of the query params declared in `Controller#queryParams` property
-   are changed.
-
-
-   When invoked this method uses the currently active query param update delegate
-   (see `Controller.prototype._qpDelegate` for details) and invokes it with
-   the QP key/value being changed.
-
-    @method _qpChanged
-    @private
-  */
-  _qpChanged(controller, _prop) {
-    let prop = _prop.substr(0, _prop.length - 3);
-
-    let delegate = controller._qpDelegate;
-    let value = get(controller, prop);
-    delegate(prop, value);
-  },
-
-  /**
-    Transition the application into another route. The route may
-    be either a single route or route path:
-
-    ```javascript
-    aController.transitionToRoute('blogPosts');
-    aController.transitionToRoute('blogPosts.recentEntries');
-    ```
-
-    Optionally supply a model for the route in question. The model
-    will be serialized into the URL using the `serialize` hook of
-    the route:
-
-    ```javascript
-    aController.transitionToRoute('blogPost', aPost);
-    ```
-
-    If a literal is passed (such as a number or a string), it will
-    be treated as an identifier instead. In this case, the `model`
-    hook of the route will be triggered:
-
-    ```javascript
-    aController.transitionToRoute('blogPost', 1);
-    ```
-
-    Multiple models will be applied last to first recursively up the
-    route tree.
-
-    ```app/router.js
-    Router.map(function() {
-      this.route('blogPost', { path: ':blogPostId' }, function() {
-        this.route('blogComment', { path: ':blogCommentId', resetNamespace: true });
-      });
-    });
-    ```
-
-    ```javascript
-    aController.transitionToRoute('blogComment', aPost, aComment);
-    aController.transitionToRoute('blogComment', 1, 13);
-    ```
-
-    It is also possible to pass a URL (a string that starts with a
-    `/`). This is intended for testing and debugging purposes and
-    should rarely be used in production code.
-
-    ```javascript
-    aController.transitionToRoute('/');
-    aController.transitionToRoute('/blog/post/1/comment/13');
-    aController.transitionToRoute('/blog/posts?sort=title');
-    ```
-
-    An options hash with a `queryParams` property may be provided as
-    the final argument to add query parameters to the destination URL.
-
-    ```javascript
-    aController.transitionToRoute('blogPost', 1, {
-      queryParams: { showComments: 'true' }
-    });
-
-    // if you just want to transition the query parameters without changing the route
-    aController.transitionToRoute({ queryParams: { sort: 'date' } });
-    ```
-
-    See also [replaceRoute](/api/ember/release/classes/Ember.ControllerMixin/methods/replaceRoute?anchor=replaceRoute).
-
-    @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
-    @for Ember.ControllerMixin
-    @method transitionToRoute
-    @public
-  */
-  transitionToRoute(...args) {
-    // target may be either another controller or a router
-    let target = get(this, 'target');
-    let method = target.transitionToRoute || target.transitionTo;
-    return method.apply(target, prefixRouteNameArg(this, args));
-  },
-
-  /**
-    Transition into another route while replacing the current URL, if possible.
-    This will replace the current history entry instead of adding a new one.
-    Beside that, it is identical to `transitionToRoute` in all other respects.
-
-    ```javascript
-    aController.replaceRoute('blogPosts');
-    aController.replaceRoute('blogPosts.recentEntries');
-    ```
-
-    Optionally supply a model for the route in question. The model
-    will be serialized into the URL using the `serialize` hook of
-    the route:
-
-    ```javascript
-    aController.replaceRoute('blogPost', aPost);
-    ```
-
-    If a literal is passed (such as a number or a string), it will
-    be treated as an identifier instead. In this case, the `model`
-    hook of the route will be triggered:
-
-    ```javascript
-    aController.replaceRoute('blogPost', 1);
-    ```
-
-    Multiple models will be applied last to first recursively up the
-    route tree.
-
-    ```app/router.js
-    Router.map(function() {
-      this.route('blogPost', { path: ':blogPostId' }, function() {
-        this.route('blogComment', { path: ':blogCommentId', resetNamespace: true });
-      });
-    });
-    ```
-
-    ```
-    aController.replaceRoute('blogComment', aPost, aComment);
-    aController.replaceRoute('blogComment', 1, 13);
-    ```
-
-    It is also possible to pass a URL (a string that starts with a
-    `/`). This is intended for testing and debugging purposes and
-    should rarely be used in production code.
-
-    ```javascript
-    aController.replaceRoute('/');
-    aController.replaceRoute('/blog/post/1/comment/13');
-    ```
-
-    @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.
-    @for Ember.ControllerMixin
-    @method replaceRoute
-    @public
-  */
-  replaceRoute(...args) {
-    // target may be either another controller or a router
-    let target = get(this, 'target');
-    let method = target.replaceRoute || target.replaceWith;
-    return method.apply(target, prefixRouteNameArg(this, args));
-  },
-});
-
-export default ControllerMixin;