discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/ember-metal/tests/accessors/set_path_test.js

@@ -1,97 +0,0 @@
-import { context } from 'ember-environment';
-import { set, trySet, get } from '../..';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-let originalLookup = context.lookup;
-let lookup;
-
-let obj;
-function commonSetup() {
-  context.lookup = lookup = {};
-  obj = {
-    foo: {
-      bar: {
-        baz: { biff: 'BIFF' },
-      },
-    },
-  };
-}
-
-function commonTeardown() {
-  context.lookup = originalLookup;
-  obj = null;
-}
-
-moduleFor(
-  'set with path',
-  class extends AbstractTestCase {
-    constructor() {
-      super();
-      commonSetup();
-    }
-
-    teardown() {
-      commonTeardown();
-    }
-
-    ['@test [Foo, bar] -> Foo.bar'](assert) {
-      lookup.Foo = {
-        toString() {
-          return 'Foo';
-        },
-      }; // Behave like an Ember.Namespace
-
-      set(lookup.Foo, 'bar', 'baz');
-      assert.equal(get(lookup.Foo, 'bar'), 'baz');
-    }
-
-    // ..........................................................
-    //
-    // LOCAL PATHS
-
-    ['@test [obj, foo] -> obj.foo'](assert) {
-      set(obj, 'foo', 'BAM');
-      assert.equal(get(obj, 'foo'), 'BAM');
-    }
-
-    ['@test [obj, foo.bar] -> obj.foo.bar'](assert) {
-      set(obj, 'foo.bar', 'BAM');
-      assert.equal(get(obj, 'foo.bar'), 'BAM');
-    }
-  }
-);
-
-moduleFor(
-  'set with path - deprecated',
-  class extends AbstractTestCase {
-    constructor() {
-      super();
-      commonSetup();
-    }
-
-    teardown() {
-      commonTeardown();
-    }
-
-    // ..........................................................
-    // DEPRECATED
-    //
-    ['@test [obj, bla.bla] gives a proper exception message'](assert) {
-      let exceptionMessage = 'Property set failed: object in path "bla" could not be found.';
-      try {
-        set(obj, 'bla.bla', 'BAM');
-      } catch (ex) {
-        assert.equal(ex.message, exceptionMessage);
-      }
-    }
-
-    ['@test [obj, foo.baz.bat] -> EXCEPTION'](assert) {
-      assert.throws(() => set(obj, 'foo.baz.bat', 'BAM'));
-    }
-
-    ['@test [obj, foo.baz.bat] -> EXCEPTION'](assert) {
-      trySet(obj, 'foo.baz.bat', 'BAM');
-      assert.ok(true, 'does not raise');
-    }
-  }
-);

data/dist/es/ember-metal/tests/accessors/set_test.js

@@ -1,128 +0,0 @@
-import { get, set, trySet, setHasViews } from '../..';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'set',
-  class extends AbstractTestCase {
-    teardown() {
-      setHasViews(() => false);
-    }
-
-    ['@test should set arbitrary properties on an object'](assert) {
-      let obj = {
-        string: 'string',
-        number: 23,
-        boolTrue: true,
-        boolFalse: false,
-        nullValue: null,
-        undefinedValue: undefined,
-      };
-
-      let newObj = {};
-
-      for (let key in obj) {
-        if (!obj.hasOwnProperty(key)) {
-          continue;
-        }
-
-        assert.equal(set(newObj, key, obj[key]), obj[key], 'should return value');
-        assert.ok(key in newObj, 'should have key');
-        assert.ok(newObj.hasOwnProperty(key), 'should have key');
-        assert.equal(get(newObj, key), obj[key], 'should set value');
-      }
-    }
-
-    ['@test should set a number key on an object'](assert) {
-      let obj = {};
-
-      set(obj, 1, 'first');
-      assert.equal(obj[1], 'first');
-    }
-
-    ['@test should set an array index'](assert) {
-      let arr = ['first', 'second'];
-
-      set(arr, 1, 'lol');
-      assert.deepEqual(arr, ['first', 'lol']);
-    }
-
-    ['@test should call setUnknownProperty if defined and value is undefined'](assert) {
-      let obj = {
-        count: 0,
-
-        unknownProperty() {
-          assert.ok(false, 'should not invoke unknownProperty if setUnknownProperty is defined');
-        },
-
-        setUnknownProperty(key, value) {
-          assert.equal(key, 'foo', 'should pass key');
-          assert.equal(value, 'BAR', 'should pass key');
-          this.count++;
-          return 'FOO';
-        },
-      };
-
-      assert.equal(set(obj, 'foo', 'BAR'), 'BAR', 'should return set value');
-      assert.equal(obj.count, 1, 'should have invoked');
-    }
-
-    ['@test warn on attempts to call set with undefined as object']() {
-      expectAssertion(
-        () => set(undefined, 'aProperty', 'BAM'),
-        /Cannot call set with 'aProperty' on an undefined object./
-      );
-    }
-
-    ['@test warn on attempts to call set with null as object']() {
-      expectAssertion(
-        () => set(null, 'aProperty', 'BAM'),
-        /Cannot call set with 'aProperty' on an undefined object./
-      );
-    }
-
-    ['@test warn on attempts to use set with an unsupported property path']() {
-      let obj = {};
-      expectAssertion(
-        () => set(obj, null, 42),
-        /The key provided to set must be a string or number, you passed null/
-      );
-      expectAssertion(
-        () => set(obj, NaN, 42),
-        /The key provided to set must be a string or number, you passed NaN/
-      );
-      expectAssertion(
-        () => set(obj, undefined, 42),
-        /The key provided to set must be a string or number, you passed undefined/
-      );
-      expectAssertion(
-        () => set(obj, false, 42),
-        /The key provided to set must be a string or number, you passed false/
-      );
-    }
-
-    ['@test warn on attempts of calling set on a destroyed object']() {
-      let obj = { isDestroyed: true };
-
-      expectAssertion(
-        () => set(obj, 'favoriteFood', 'hot dogs'),
-        'calling set on destroyed object: [object Object].favoriteFood = hot dogs'
-      );
-    }
-
-    ['@test does not trigger auto-run assertion for objects that have not been tagged'](assert) {
-      setHasViews(() => true);
-      let obj = {};
-
-      set(obj, 'foo', 'bar');
-
-      assert.equal(obj.foo, 'bar');
-    }
-
-    ['@test does not warn on attempts of calling set on a destroyed object with `trySet`'](assert) {
-      let obj = { isDestroyed: true };
-
-      trySet(obj, 'favoriteFood', 'hot dogs');
-      assert.equal(obj.favoriteFood, undefined, 'does not set and does not error');
-    }
-  }
-);

data/dist/es/ember-metal/tests/alias_test.js

@@ -1,167 +0,0 @@
-import {
-  alias,
-  defineProperty,
-  get,
-  set,
-  isWatching,
-  addObserver,
-  removeObserver,
-  tagFor,
-} from '..';
-import { meta } from 'ember-meta';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-let obj, count;
-
-function incrementCount() {
-  count++;
-}
-
-moduleFor(
-  'ember-metal/alias',
-  class extends AbstractTestCase {
-    beforeEach() {
-      obj = { foo: { faz: 'FOO' } };
-      count = 0;
-    }
-
-    afterEach() {
-      obj = null;
-    }
-
-    ['@test should proxy get to alt key'](assert) {
-      defineProperty(obj, 'bar', alias('foo.faz'));
-      assert.equal(get(obj, 'bar'), 'FOO');
-    }
-
-    ['@test should proxy set to alt key'](assert) {
-      defineProperty(obj, 'bar', alias('foo.faz'));
-      set(obj, 'bar', 'BAR');
-      assert.equal(get(obj, 'foo.faz'), 'BAR');
-    }
-
-    ['@test old dependent keys should not trigger property changes'](assert) {
-      let obj1 = Object.create(null);
-      defineProperty(obj1, 'foo', null, null);
-      defineProperty(obj1, 'bar', alias('foo'));
-      defineProperty(obj1, 'baz', alias('foo'));
-      defineProperty(obj1, 'baz', alias('bar')); // redefine baz
-      addObserver(obj1, 'baz', incrementCount);
-
-      set(obj1, 'foo', 'FOO');
-      assert.equal(count, 1);
-
-      removeObserver(obj1, 'baz', incrementCount);
-
-      set(obj1, 'foo', 'OOF');
-      assert.equal(count, 1);
-    }
-
-    [`@test inheriting an observer of the alias from the prototype then
-    redefining the alias on the instance to another property dependent on same key
-    does not call the observer twice`](assert) {
-      let obj1 = Object.create(null);
-
-      meta(obj1).proto = obj1;
-
-      defineProperty(obj1, 'foo', null, null);
-      defineProperty(obj1, 'bar', alias('foo'));
-      defineProperty(obj1, 'baz', alias('foo'));
-      addObserver(obj1, 'baz', incrementCount);
-
-      let obj2 = Object.create(obj1);
-      defineProperty(obj2, 'baz', alias('bar')); // override baz
-
-      set(obj2, 'foo', 'FOO');
-      assert.equal(count, 1);
-
-      removeObserver(obj2, 'baz', incrementCount);
-
-      set(obj2, 'foo', 'OOF');
-      assert.equal(count, 1);
-    }
-
-    ['@test an observer of the alias works if added after defining the alias'](assert) {
-      defineProperty(obj, 'bar', alias('foo.faz'));
-      addObserver(obj, 'bar', incrementCount);
-      assert.ok(isWatching(obj, 'foo.faz'));
-      set(obj, 'foo.faz', 'BAR');
-      assert.equal(count, 1);
-    }
-
-    ['@test an observer of the alias works if added before defining the alias'](assert) {
-      addObserver(obj, 'bar', incrementCount);
-      defineProperty(obj, 'bar', alias('foo.faz'));
-      assert.ok(isWatching(obj, 'foo.faz'));
-      set(obj, 'foo.faz', 'BAR');
-      assert.equal(count, 1);
-    }
-
-    ['@test object with alias is dirtied if interior object of alias is set after consumption'](
-      assert
-    ) {
-      defineProperty(obj, 'bar', alias('foo.faz'));
-      get(obj, 'bar');
-
-      let tag = tagFor(obj);
-      let tagValue = tag.value();
-      set(obj, 'foo.faz', 'BAR');
-
-      assert.ok(!tag.validate(tagValue), 'setting the aliased key should dirty the object');
-    }
-
-    ['@test setting alias on self should fail assertion']() {
-      expectAssertion(
-        () => defineProperty(obj, 'bar', alias('bar')),
-        "Setting alias 'bar' on self"
-      );
-    }
-
-    ['@test destroyed alias does not disturb watch count'](assert) {
-      defineProperty(obj, 'bar', alias('foo.faz'));
-
-      assert.equal(get(obj, 'bar'), 'FOO');
-      assert.ok(isWatching(obj, 'foo.faz'));
-
-      defineProperty(obj, 'bar', null);
-
-      assert.notOk(isWatching(obj, 'foo.faz'));
-    }
-
-    ['@test setting on oneWay alias does not disturb watch count'](assert) {
-      defineProperty(obj, 'bar', alias('foo.faz').oneWay());
-
-      assert.equal(get(obj, 'bar'), 'FOO');
-      assert.ok(isWatching(obj, 'foo.faz'));
-
-      set(obj, 'bar', null);
-
-      assert.notOk(isWatching(obj, 'foo.faz'));
-    }
-
-    ['@test redefined alias with observer does not disturb watch count'](assert) {
-      defineProperty(obj, 'bar', alias('foo.faz').oneWay());
-
-      assert.equal(get(obj, 'bar'), 'FOO');
-      assert.ok(isWatching(obj, 'foo.faz'));
-
-      addObserver(obj, 'bar', incrementCount);
-
-      assert.equal(count, 0);
-
-      set(obj, 'bar', null);
-
-      assert.equal(count, 1);
-      assert.notOk(isWatching(obj, 'foo.faz'));
-
-      defineProperty(obj, 'bar', alias('foo.faz'));
-
-      assert.equal(count, 1);
-      assert.ok(isWatching(obj, 'foo.faz'));
-
-      set(obj, 'foo.faz', 'great');
-
-      assert.equal(count, 2);
-    }
-  }
-);

data/dist/es/ember-metal/tests/chains_test.js

@@ -1,210 +0,0 @@
-import {
-  addObserver,
-  get,
-  set,
-  ChainNode,
-  finishChains,
-  defineProperty,
-  computed,
-  alias,
-  notifyPropertyChange,
-  watch,
-  unwatch,
-  watcherCount,
-} from '..';
-import { meta, peekMeta } from 'ember-meta';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'Chains',
-  class extends AbstractTestCase {
-    ['@test finishChains should properly copy chains from prototypes to instances'](assert) {
-      function didChange() {}
-
-      let obj = {};
-      addObserver(obj, 'foo.bar', null, didChange);
-
-      let childObj = Object.create(obj);
-
-      let parentMeta = meta(obj);
-      let childMeta = meta(childObj);
-
-      finishChains(childMeta);
-
-      assert.ok(
-        parentMeta.readableChains() !== childMeta.readableChains(),
-        'The chains object is copied'
-      );
-    }
-
-    ['@test does not observe primitive values'](assert) {
-      let obj = {
-        foo: { bar: 'STRING' },
-      };
-
-      addObserver(obj, 'foo.bar.baz', null, function() {});
-      let meta = peekMeta(obj);
-      assert.notOk(meta._object);
-    }
-
-    ['@test observer and CP chains'](assert) {
-      let obj = {};
-
-      defineProperty(obj, 'foo', computed('qux.[]', function() {}));
-      defineProperty(obj, 'qux', computed(function() {}));
-
-      // create DK chains
-      get(obj, 'foo');
-
-      // create observer chain
-      addObserver(obj, 'qux.length', function() {});
-
-      /*
-             +-----+
-             | qux |   root CP
-             +-----+
-                ^
-         +------+-----+
-         |            |
-     +--------+    +----+
-     | length |    | [] |  chainWatchers
-     +--------+    +----+
-      observer       CP(foo, 'qux.[]')
-    */
-
-      // invalidate qux
-      notifyPropertyChange(obj, 'qux');
-
-      // CP chain is blown away
-
-      /*
-             +-----+
-             | qux |   root CP
-             +-----+
-                ^
-         +------+xxxxxx
-         |            x
-     +--------+    xxxxxx
-     | length |    x [] x  chainWatchers
-     +--------+    xxxxxx
-      observer       CP(foo, 'qux.[]')
-    */
-
-      get(obj, 'qux'); // CP chain re-recreated
-      assert.ok(true, 'no crash');
-    }
-
-    ['@test checks cache correctly'](assert) {
-      let obj = {};
-      let parentChainNode = new ChainNode(null, null, obj);
-      let chainNode = new ChainNode(parentChainNode, 'foo');
-
-      defineProperty(
-        obj,
-        'foo',
-        computed(function() {
-          return undefined;
-        })
-      );
-      get(obj, 'foo');
-
-      assert.strictEqual(chainNode.value(), undefined);
-    }
-
-    ['@test chains are watched correctly'](assert) {
-      let obj = { foo: { bar: { baz: 1 } } };
-
-      watch(obj, 'foo.bar.baz');
-
-      assert.equal(watcherCount(obj, 'foo'), 1);
-      assert.equal(watcherCount(obj, 'foo.bar'), 0);
-      assert.equal(watcherCount(obj, 'foo.bar.baz'), 1);
-      assert.equal(watcherCount(obj.foo, 'bar'), 1);
-      assert.equal(watcherCount(obj.foo, 'bar.baz'), 0);
-      assert.equal(watcherCount(obj.foo.bar, 'baz'), 1);
-
-      unwatch(obj, 'foo.bar.baz');
-
-      assert.equal(watcherCount(obj, 'foo'), 0);
-      assert.equal(watcherCount(obj, 'foo.bar'), 0);
-      assert.equal(watcherCount(obj, 'foo.bar.baz'), 0);
-      assert.equal(watcherCount(obj.foo, 'bar'), 0);
-      assert.equal(watcherCount(obj.foo, 'bar.baz'), 0);
-      assert.equal(watcherCount(obj.foo.bar, 'baz'), 0);
-    }
-
-    ['@test chains with single character keys are watched correctly'](assert) {
-      let obj = { a: { b: { c: 1 } } };
-
-      watch(obj, 'a.b.c');
-
-      assert.equal(watcherCount(obj, 'a'), 1);
-      assert.equal(watcherCount(obj, 'a.b'), 0);
-      assert.equal(watcherCount(obj, 'a.b.c'), 1);
-      assert.equal(watcherCount(obj.a, 'b'), 1);
-      assert.equal(watcherCount(obj.a, 'b.c'), 0);
-      assert.equal(watcherCount(obj.a.b, 'c'), 1);
-
-      unwatch(obj, 'a.b.c');
-
-      assert.equal(watcherCount(obj, 'a'), 0);
-      assert.equal(watcherCount(obj, 'a.b'), 0);
-      assert.equal(watcherCount(obj, 'a.b.c'), 0);
-      assert.equal(watcherCount(obj.a, 'b'), 0);
-      assert.equal(watcherCount(obj.a, 'b.c'), 0);
-      assert.equal(watcherCount(obj.a.b, 'c'), 0);
-    }
-
-    ['@test writable chains is not defined more than once'](assert) {
-      assert.expect(0);
-
-      class Base {
-        constructor() {
-          finishChains(meta(this));
-        }
-
-        didChange() {}
-      }
-
-      Base.prototype.foo = {
-        bar: {
-          baz: {
-            value: 123,
-          },
-        },
-      };
-
-      // Define a standard computed property, which will eventually setup dependencies
-      defineProperty(
-        Base.prototype,
-        'bar',
-        computed('foo.bar', {
-          get() {
-            return this.foo.bar;
-          },
-        })
-      );
-
-      // Define some aliases, which will proxy chains along
-      defineProperty(Base.prototype, 'baz', alias('bar.baz'));
-      defineProperty(Base.prototype, 'value', alias('baz.value'));
-
-      // Define an observer, which will eagerly attempt to setup chains and watch
-      // their values. This follows the aliases eagerly, and forces the first
-      // computed to actually set up its values/dependencies for chains. If
-      // writableChains was not already defined, this results in multiple root
-      // chain nodes being defined on the same object meta.
-      addObserver(Base.prototype, 'value', null, 'didChange');
-
-      class Child extends Base {}
-
-      let childObj = new Child();
-
-      set(childObj, 'foo.bar', {
-        baz: {
-          value: 456,
-        },
-      });
-    }
-  }
-);