discourse-ember-source 3.5.1.1 → 3.5.1.2

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

@@ -1,44 +0,0 @@
-import { get, set, setHasViews } from '../..';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-import { createTracked } from './support';
-
-import { EMBER_METAL_TRACKED_PROPERTIES } from '@ember/canary-features';
-
-if (EMBER_METAL_TRACKED_PROPERTIES) {
-  moduleFor(
-    'tracked set',
-    class extends AbstractTestCase {
-      teardown() {
-        setHasViews(() => false);
-      }
-
-      ['@test should set arbitrary properties on an object'](assert) {
-        let obj = createTracked({
-          string: 'string',
-          number: 23,
-          boolTrue: true,
-          boolFalse: false,
-          nullValue: null,
-          undefinedValue: undefined,
-        });
-
-        let newObj = createTracked({
-          undefinedValue: 'emberjs',
-        });
-
-        for (let key in obj) {
-          assert.equal(set(newObj, key, obj[key]), obj[key], 'should return value');
-          assert.equal(get(newObj, key), obj[key], 'should set value');
-        }
-      }
-
-      ['@test should set a number key on an object'](assert) {
-        let obj = createTracked({ 1: 'original' });
-
-        set(obj, 1, 'first');
-        assert.equal(obj[1], 'first');
-      }
-    }
-  );
-}

data/dist/es/ember-metal/tests/tracked/support.js

@@ -1,37 +0,0 @@
-import { tracked } from '../..';
-
-export function createTracked(values, proto = {}) {
-  function Class() {
-    for (let prop in values) {
-      this[prop] = values[prop];
-    }
-  }
-
-  for (let prop in values) {
-    Object.defineProperty(
-      proto,
-      prop,
-      tracked(proto, prop, {
-        enumerable: true,
-        configurable: true,
-        writable: true,
-        value: values[prop],
-      })
-    );
-  }
-
-  Class.prototype = proto;
-
-  return new Class();
-}
-
-export function createWithDescriptors(values) {
-  function Class() {}
-
-  for (let prop in values) {
-    let descriptor = Object.getOwnPropertyDescriptor(values, prop);
-    Object.defineProperty(Class.prototype, prop, tracked(Class.prototype, prop, descriptor));
-  }
-
-  return new Class();
-}

data/dist/es/ember-metal/tests/tracked/validation_test.js

@@ -1,233 +0,0 @@
-import { computed, defineProperty, get, set, tracked } from '../..';
-
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-import { tagForProperty } from '../..';
-
-import { EMBER_METAL_TRACKED_PROPERTIES } from '@ember/canary-features';
-
-if (EMBER_METAL_TRACKED_PROPERTIES) {
-  moduleFor(
-    'tracked get validation',
-    class extends AbstractTestCase {
-      [`@test validators for tracked getters with dependencies should invalidate when the dependencies invalidate`](
-        assert
-      ) {
-        class Tracked {
-          constructor(first, last) {
-            this.first = first;
-            this.last = last;
-          }
-        }
-
-        track(Tracked, ['first', 'last'], {
-          get full() {
-            return `${this.first} ${this.last}`;
-          },
-        });
-
-        let obj = new Tracked('Tom', 'Dale');
-
-        let tag = tagForProperty(obj, 'full');
-        let snapshot = tag.value();
-
-        let full = obj.full;
-        assert.equal(full, 'Tom Dale', 'The full name starts correct');
-        assert.equal(tag.validate(snapshot), true);
-
-        snapshot = tag.value();
-        assert.equal(tag.validate(snapshot), true);
-
-        obj.first = 'Thomas';
-        assert.equal(tag.validate(snapshot), false);
-
-        assert.equal(obj.full, 'Thomas Dale');
-        snapshot = tag.value();
-
-        assert.equal(tag.validate(snapshot), true);
-      }
-
-      [`@test interaction with Ember object model (tracked property depending on Ember property)`](
-        assert
-      ) {
-        class Tracked {
-          constructor(name) {
-            this.name = name;
-          }
-        }
-
-        track(Tracked, ['name'], {
-          get full() {
-            return `${get(this.name, 'first')} ${get(this.name, 'last')}`;
-          },
-        });
-
-        let tom = { first: 'Tom', last: 'Dale' };
-
-        let obj = new Tracked(tom);
-
-        let tag = tagForProperty(obj, 'full');
-        let snapshot = tag.value();
-
-        let full = obj.full;
-        assert.equal(full, 'Tom Dale');
-        assert.equal(tag.validate(snapshot), true);
-
-        snapshot = tag.value();
-        assert.equal(tag.validate(snapshot), true);
-
-        set(tom, 'first', 'Thomas');
-        assert.equal(tag.validate(snapshot), false, 'invalid after setting with Ember set');
-
-        assert.equal(obj.full, 'Thomas Dale');
-        snapshot = tag.value();
-
-        assert.equal(tag.validate(snapshot), true);
-      }
-
-      [`@test interaction with Ember object model (Ember computed property depending on tracked property)`](
-        assert
-      ) {
-        class EmberObject {
-          constructor(name) {
-            this.name = name;
-          }
-        }
-
-        defineProperty(
-          EmberObject.prototype,
-          'full',
-          computed('name', function() {
-            let name = get(this, 'name');
-            return `${name.first} ${name.last}`;
-          })
-        );
-
-        class Name {
-          constructor(first, last) {
-            this.first = first;
-            this.last = last;
-          }
-        }
-
-        track(Name, ['first', 'last']);
-
-        let tom = new Name('Tom', 'Dale');
-        let obj = new EmberObject(tom);
-
-        let tag = tagForProperty(obj, 'full');
-        let snapshot = tag.value();
-
-        let full = get(obj, 'full');
-        assert.equal(full, 'Tom Dale');
-        assert.equal(tag.validate(snapshot), true);
-
-        snapshot = tag.value();
-        assert.equal(tag.validate(snapshot), true);
-
-        tom.first = 'Thomas';
-        assert.equal(
-          tag.validate(snapshot),
-          false,
-          'invalid after setting with tracked properties'
-        );
-
-        assert.equal(get(obj, 'full'), 'Thomas Dale');
-        snapshot = tag.value();
-
-        // assert.equal(tag.validate(snapshot), true);
-      }
-
-      ['@test interaction with the Ember object model (paths going through tracked properties)'](
-        assert
-      ) {
-        class EmberObject {
-          constructor(contact) {
-            this.contact = contact;
-          }
-        }
-
-        defineProperty(
-          EmberObject.prototype,
-          'full',
-          computed('contact.name.first', 'contact.name.last', function() {
-            let contact = get(this, 'contact');
-            return `${get(contact.name, 'first')} ${get(contact.name, 'last')}`;
-          })
-        );
-
-        class Contact {
-          constructor(name) {
-            this.name = name;
-          }
-        }
-
-        track(Contact, ['name']);
-
-        class EmberName {
-          constructor(first, last) {
-            this.first = first;
-            this.last = last;
-          }
-        }
-
-        let tom = new EmberName('Tom', 'Dale');
-        let contact = new Contact(tom);
-        let obj = new EmberObject(contact);
-
-        let tag = tagForProperty(obj, 'full');
-        let snapshot = tag.value();
-
-        let full = get(obj, 'full');
-        assert.equal(full, 'Tom Dale');
-        assert.equal(tag.validate(snapshot), true);
-
-        snapshot = tag.value();
-        assert.equal(tag.validate(snapshot), true);
-
-        set(tom, 'first', 'Thomas');
-        assert.equal(tag.validate(snapshot), false, 'invalid after setting with Ember.set');
-
-        assert.equal(get(obj, 'full'), 'Thomas Dale');
-        snapshot = tag.value();
-
-        tom = contact.name = new EmberName('T', 'Dale');
-        assert.equal(tag.validate(snapshot), false, 'invalid after setting with Ember.set');
-
-        assert.equal(get(obj, 'full'), 'T Dale');
-        snapshot = tag.value();
-
-        set(tom, 'first', 'Tizzle');
-        assert.equal(tag.validate(snapshot), false, 'invalid after setting with Ember.set');
-
-        assert.equal(get(obj, 'full'), 'Tizzle Dale');
-      }
-    }
-  );
-}
-
-function track(Class, properties, accessors = {}) {
-  let proto = Class.prototype;
-
-  properties.forEach(prop => defineData(proto, prop));
-
-  let keys = Object.getOwnPropertyNames(accessors);
-
-  keys.forEach(key => defineAccessor(proto, key, Object.getOwnPropertyDescriptor(accessors, key)));
-}
-
-function defineData(prototype, property) {
-  Object.defineProperty(
-    prototype,
-    property,
-    tracked(prototype, property, {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: undefined,
-    })
-  );
-}
-
-function defineAccessor(prototype, property, descriptor) {
-  Object.defineProperty(prototype, property, tracked(prototype, property, descriptor));
-}

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

@@ -1,97 +0,0 @@
-import {
-  computed,
-  get,
-  defineProperty,
-  Mixin,
-  observer,
-  addObserver,
-  removeObserver,
-  isWatching,
-} from '../..';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-function testObserver(assert, setup, teardown, key = 'key') {
-  let obj = {};
-  function fn() {}
-
-  assert.equal(isWatching(obj, key), false, 'precond - isWatching is false by default');
-  setup(obj, key, fn);
-  assert.equal(isWatching(obj, key), true, 'isWatching is true when observers are added');
-  teardown(obj, key, fn);
-  assert.equal(isWatching(obj, key), false, 'isWatching is false after observers are removed');
-}
-
-moduleFor(
-  'isWatching',
-  class extends AbstractTestCase {
-    ['@test isWatching is true for regular local observers'](assert) {
-      testObserver(
-        assert,
-        (obj, key, fn) => {
-          Mixin.create({
-            didChange: observer(key, fn),
-          }).apply(obj);
-        },
-        (obj, key, fn) => removeObserver(obj, key, obj, fn)
-      );
-    }
-
-    ['@test isWatching is true for nonlocal observers'](assert) {
-      testObserver(
-        assert,
-        (obj, key, fn) => {
-          addObserver(obj, key, obj, fn);
-        },
-        (obj, key, fn) => removeObserver(obj, key, obj, fn)
-      );
-    }
-
-    ['@test isWatching is true for chained observers'](assert) {
-      testObserver(
-        assert,
-        function(obj, key, fn) {
-          addObserver(obj, key + '.bar', obj, fn);
-        },
-        function(obj, key, fn) {
-          removeObserver(obj, key + '.bar', obj, fn);
-        }
-      );
-    }
-
-    ['@test isWatching is true for computed properties'](assert) {
-      testObserver(
-        assert,
-        (obj, key, fn) => {
-          defineProperty(obj, 'computed', computed(fn).property(key));
-          get(obj, 'computed');
-        },
-        obj => defineProperty(obj, 'computed', null)
-      );
-    }
-
-    ['@test isWatching is true for chained computed properties'](assert) {
-      testObserver(
-        assert,
-        (obj, key, fn) => {
-          defineProperty(obj, 'computed', computed(fn).property(key + '.bar'));
-          get(obj, 'computed');
-        },
-        obj => defineProperty(obj, 'computed', null)
-      );
-    }
-
-    // can't watch length on Array - it is special...
-    // But you should be able to watch a length property of an object
-    ["@test isWatching is true for 'length' property on object"](assert) {
-      testObserver(
-        assert,
-        (obj, key, fn) => {
-          defineProperty(obj, 'length', null, '26.2 miles');
-          addObserver(obj, 'length', obj, fn);
-        },
-        (obj, key, fn) => removeObserver(obj, 'length', obj, fn),
-        'length'
-      );
-    }
-  }
-);

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

@@ -1,109 +0,0 @@
-import { watch, unwatch, defineProperty, addListener, computed, set } from '../..';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-let didCount;
-
-function addListeners(obj, keyPath) {
-  addListener(obj, keyPath + ':change', () => didCount++);
-}
-
-moduleFor(
-  'unwatch',
-  class extends AbstractTestCase {
-    beforeEach() {
-      didCount = 0;
-    }
-
-    ['@test unwatching a computed property - regular get/set'](assert) {
-      let obj = {};
-
-      defineProperty(
-        obj,
-        'foo',
-        computed({
-          get() {
-            return this.__foo;
-          },
-          set(keyName, value) {
-            this.__foo = value;
-            return this.__foo;
-          },
-        })
-      );
-      addListeners(obj, 'foo');
-
-      watch(obj, 'foo');
-      set(obj, 'foo', 'bar');
-      assert.equal(didCount, 1, 'should have invoked didCount');
-
-      unwatch(obj, 'foo');
-      didCount = 0;
-      set(obj, 'foo', 'BAZ');
-      assert.equal(didCount, 0, 'should NOT have invoked didCount');
-    }
-
-    ['@test unwatching a regular property - regular get/set'](assert) {
-      let obj = { foo: 'BIFF' };
-      addListeners(obj, 'foo');
-
-      watch(obj, 'foo');
-      set(obj, 'foo', 'bar');
-      assert.equal(didCount, 1, 'should have invoked didCount');
-
-      unwatch(obj, 'foo');
-      didCount = 0;
-      set(obj, 'foo', 'BAZ');
-      assert.equal(didCount, 0, 'should NOT have invoked didCount');
-    }
-
-    ['@test unwatching should be nested'](assert) {
-      let obj = { foo: 'BIFF' };
-      addListeners(obj, 'foo');
-
-      watch(obj, 'foo');
-      watch(obj, 'foo');
-      set(obj, 'foo', 'bar');
-      assert.equal(didCount, 1, 'should have invoked didCount');
-
-      unwatch(obj, 'foo');
-      didCount = 0;
-      set(obj, 'foo', 'BAZ');
-      assert.equal(didCount, 1, 'should NOT have invoked didCount');
-
-      unwatch(obj, 'foo');
-      didCount = 0;
-      set(obj, 'foo', 'BAZ');
-      assert.equal(didCount, 0, 'should NOT have invoked didCount');
-    }
-
-    ['@test unwatching "length" property on an object'](assert) {
-      let obj = { foo: 'RUN' };
-      addListeners(obj, 'length');
-
-      // Can watch length when it is undefined
-      watch(obj, 'length');
-      set(obj, 'length', '10k');
-      assert.equal(didCount, 1, 'should have invoked didCount');
-
-      // Should stop watching despite length now being defined (making object 'array-like')
-      unwatch(obj, 'length');
-      didCount = 0;
-      set(obj, 'length', '5k');
-      assert.equal(didCount, 0, 'should NOT have invoked didCount');
-    }
-
-    ['@test unwatching should not destroy non MANDATORY_SETTER descriptor'](assert) {
-      let obj = {
-        get foo() {
-          return 'RUN';
-        },
-      };
-
-      assert.equal(obj.foo, 'RUN', 'obj.foo');
-      watch(obj, 'foo');
-      assert.equal(obj.foo, 'RUN', 'obj.foo after watch');
-      unwatch(obj, 'foo');
-      assert.equal(obj.foo, 'RUN', 'obj.foo after unwatch');
-    }
-  }
-);