discourse-ember-source 3.5.1.1 → 3.5.1.2

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

@@ -1,368 +0,0 @@
-import { Object as EmberObject } from 'ember-runtime';
-import { Mixin, defineProperty, descriptor } from '..';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-let classes = [
-  class {
-    static module(title) {
-      return `${title}: using defineProperty on an object directly`;
-    }
-
-    constructor() {
-      this.object = {};
-    }
-
-    install(key, desc, assert) {
-      let { object } = this;
-
-      defineProperty(object, key, desc);
-
-      assert.ok(object.hasOwnProperty(key));
-    }
-
-    set(key, value) {
-      this.object[key] = value;
-    }
-
-    finalize() {
-      return this.object;
-    }
-
-    source() {
-      return this.object;
-    }
-  },
-
-  class {
-    static module(title) {
-      return `${title}: using defineProperty on a prototype`;
-    }
-
-    constructor() {
-      this.proto = {};
-    }
-
-    install(key, desc, assert) {
-      let { proto } = this;
-
-      defineProperty(proto, key, desc);
-
-      assert.ok(proto.hasOwnProperty(key));
-    }
-
-    set(key, value) {
-      this.proto[key] = value;
-    }
-
-    finalize() {
-      return Object.create(this.proto);
-    }
-
-    source() {
-      return this.proto;
-    }
-  },
-
-  class {
-    static module(title) {
-      return `${title}: in EmberObject.extend()`;
-    }
-
-    constructor() {
-      this.klass = null;
-      this.props = {};
-    }
-
-    install(key, desc) {
-      this.props[key] = desc;
-    }
-
-    set(key, value) {
-      this.props[key] = value;
-    }
-
-    finalize() {
-      this.klass = EmberObject.extend(this.props);
-      return this.klass.create();
-    }
-
-    source() {
-      return this.klass.prototype;
-    }
-  },
-
-  class {
-    static module(title) {
-      return `${title}: in EmberObject.extend() through a mixin`;
-    }
-
-    constructor() {
-      this.klass = null;
-      this.props = {};
-    }
-
-    install(key, desc) {
-      this.props[key] = desc;
-    }
-
-    set(key, value) {
-      this.props[key] = value;
-    }
-
-    finalize() {
-      this.klass = EmberObject.extend(Mixin.create(this.props));
-      return this.klass.create();
-    }
-
-    source() {
-      return this.klass.prototype;
-    }
-  },
-
-  class {
-    static module(title) {
-      return `${title}: inherited from another EmberObject super class`;
-    }
-
-    constructor() {
-      this.superklass = null;
-      this.props = {};
-    }
-
-    install(key, desc) {
-      this.props[key] = desc;
-    }
-
-    set(key, value) {
-      this.props[key] = value;
-    }
-
-    finalize() {
-      this.superklass = EmberObject.extend(this.props);
-      return this.superklass.extend().create();
-    }
-
-    source() {
-      return this.superklass.prototype;
-    }
-  },
-];
-
-classes.forEach(TestClass => {
-  moduleFor(
-    TestClass.module('ember-metal/descriptor'),
-    class extends AbstractTestCase {
-      ['@test defining a configurable property'](assert) {
-        let factory = new TestClass(assert);
-
-        factory.install('foo', descriptor({ configurable: true, value: 'bar' }), assert);
-
-        let obj = factory.finalize();
-
-        assert.equal(obj.foo, 'bar');
-
-        let source = factory.source();
-
-        delete source.foo;
-
-        assert.strictEqual(obj.foo, undefined);
-
-        Object.defineProperty(source, 'foo', { configurable: true, value: 'baz' });
-
-        assert.equal(obj.foo, 'baz');
-      }
-
-      ['@test defining a non-configurable property'](assert) {
-        let factory = new TestClass(assert);
-        factory.install('foo', descriptor({ configurable: false, value: 'bar' }), assert);
-
-        let obj = factory.finalize();
-
-        assert.equal(obj.foo, 'bar');
-
-        let source = factory.source();
-
-        assert.throws(() => delete source.foo, TypeError);
-
-        assert.throws(
-          () =>
-            Object.defineProperty(source, 'foo', {
-              configurable: true,
-              value: 'baz',
-            }),
-          TypeError
-        );
-
-        assert.equal(obj.foo, 'bar');
-      }
-
-      ['@test defining an enumerable property'](assert) {
-        let factory = new TestClass(assert);
-        factory.install('foo', descriptor({ enumerable: true, value: 'bar' }), assert);
-
-        let obj = factory.finalize();
-
-        assert.equal(obj.foo, 'bar');
-
-        let source = factory.source();
-
-        assert.ok(Object.keys(source).indexOf('foo') !== -1);
-      }
-
-      ['@test defining a non-enumerable property'](assert) {
-        let factory = new TestClass(assert);
-        factory.install('foo', descriptor({ enumerable: false, value: 'bar' }), assert);
-
-        let obj = factory.finalize();
-
-        assert.equal(obj.foo, 'bar');
-
-        let source = factory.source();
-
-        assert.ok(Object.keys(source).indexOf('foo') === -1);
-      }
-
-      ['@test defining a writable property'](assert) {
-        let factory = new TestClass(assert);
-        factory.install('foo', descriptor({ writable: true, value: 'bar' }), assert);
-
-        let obj = factory.finalize();
-
-        assert.equal(obj.foo, 'bar');
-
-        let source = factory.source();
-
-        source.foo = 'baz';
-
-        assert.equal(obj.foo, 'baz');
-
-        obj.foo = 'bat';
-
-        assert.equal(obj.foo, 'bat');
-      }
-
-      ['@test defining a non-writable property'](assert) {
-        let factory = new TestClass(assert);
-        factory.install('foo', descriptor({ writable: false, value: 'bar' }), assert);
-
-        let obj = factory.finalize();
-
-        assert.equal(obj.foo, 'bar');
-
-        let source = factory.source();
-
-        assert.throws(() => (source.foo = 'baz'), TypeError);
-        assert.throws(() => (obj.foo = 'baz'), TypeError);
-
-        assert.equal(obj.foo, 'bar');
-      }
-
-      ['@test defining a getter'](assert) {
-        let factory = new TestClass(assert);
-        factory.install(
-          'foo',
-          descriptor({
-            get: function() {
-              return this.__foo__;
-            },
-          }),
-          assert
-        );
-
-        factory.set('__foo__', 'bar');
-
-        let obj = factory.finalize();
-
-        assert.equal(obj.foo, 'bar');
-
-        obj.__foo__ = 'baz';
-
-        assert.equal(obj.foo, 'baz');
-      }
-
-      ['@test defining a setter'](assert) {
-        let factory = new TestClass(assert);
-        factory.install(
-          'foo',
-          descriptor({
-            set: function(value) {
-              this.__foo__ = value;
-            },
-          }),
-          assert
-        );
-
-        factory.set('__foo__', 'bar');
-
-        let obj = factory.finalize();
-
-        assert.equal(obj.__foo__, 'bar');
-
-        obj.foo = 'baz';
-
-        assert.equal(obj.__foo__, 'baz');
-      }
-
-      ['@test combining multiple setter and getters'](assert) {
-        let factory = new TestClass(assert);
-        factory.install(
-          'foo',
-          descriptor({
-            get: function() {
-              return this.__foo__;
-            },
-
-            set: function(value) {
-              this.__foo__ = value;
-            },
-          }),
-          assert
-        );
-
-        factory.set('__foo__', 'foo');
-
-        factory.install(
-          'bar',
-          descriptor({
-            get: function() {
-              return this.__bar__;
-            },
-
-            set: function(value) {
-              this.__bar__ = value;
-            },
-          }),
-          assert
-        );
-
-        factory.set('__bar__', 'bar');
-
-        factory.install(
-          'fooBar',
-          descriptor({
-            get: function() {
-              return this.foo + '-' + this.bar;
-            },
-          }),
-          assert
-        );
-
-        let obj = factory.finalize();
-
-        assert.equal(obj.fooBar, 'foo-bar');
-
-        obj.foo = 'FOO';
-
-        assert.equal(obj.fooBar, 'FOO-bar');
-
-        obj.__bar__ = 'BAR';
-
-        assert.equal(obj.fooBar, 'FOO-BAR');
-
-        assert.throws(() => (obj.fooBar = 'foobar'), TypeError);
-
-        assert.equal(obj.fooBar, 'FOO-BAR');
-      }
-    }
-  );
-});

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

@@ -1,210 +0,0 @@
-import { Mixin, on, addListener, removeListener, sendEvent, hasListeners } from '..';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'system/props/events_test',
-  class extends AbstractTestCase {
-    ['@test listener should receive event - removing should remove'](assert) {
-      let obj = {};
-      let count = 0;
-
-      function F() {
-        count++;
-      }
-
-      addListener(obj, 'event!', F);
-      assert.equal(count, 0, 'nothing yet');
-
-      sendEvent(obj, 'event!');
-      assert.equal(count, 1, 'received event');
-
-      removeListener(obj, 'event!', F);
-
-      count = 0;
-      sendEvent(obj, 'event!');
-      assert.equal(count, 0, 'received event');
-    }
-
-    ['@test listeners should be inherited'](assert) {
-      let obj = {};
-      let count = 0;
-      let F = function() {
-        count++;
-      };
-
-      addListener(obj, 'event!', F);
-
-      let obj2 = Object.create(obj);
-
-      assert.equal(count, 0, 'nothing yet');
-
-      sendEvent(obj2, 'event!');
-      assert.equal(count, 1, 'received event');
-
-      removeListener(obj2, 'event!', F);
-
-      count = 0;
-      sendEvent(obj2, 'event!');
-      assert.equal(count, 0, 'did not receive event');
-
-      sendEvent(obj, 'event!');
-      assert.equal(count, 1, 'should still invoke on parent');
-    }
-
-    ['@test adding a listener more than once should only invoke once'](assert) {
-      let obj = {};
-      let count = 0;
-      function F() {
-        count++;
-      }
-      addListener(obj, 'event!', F);
-      addListener(obj, 'event!', F);
-
-      sendEvent(obj, 'event!');
-      assert.equal(count, 1, 'should only invoke once');
-    }
-
-    ['@test adding a listener with a target should invoke with target'](assert) {
-      let obj = {};
-      let target;
-
-      target = {
-        count: 0,
-        method() {
-          this.count++;
-        },
-      };
-
-      addListener(obj, 'event!', target, target.method);
-      sendEvent(obj, 'event!');
-      assert.equal(target.count, 1, 'should invoke');
-    }
-
-    ['@test adding a listener with string method should lookup method on event delivery'](assert) {
-      let obj = {};
-      let target;
-
-      target = {
-        count: 0,
-        method() {},
-      };
-
-      addListener(obj, 'event!', target, 'method');
-      sendEvent(obj, 'event!');
-      assert.equal(target.count, 0, 'should invoke but do nothing');
-
-      target.method = function() {
-        this.count++;
-      };
-      sendEvent(obj, 'event!');
-      assert.equal(target.count, 1, 'should invoke now');
-    }
-
-    ['@test calling sendEvent with extra params should be passed to listeners'](assert) {
-      let obj = {};
-      let params = null;
-      addListener(obj, 'event!', function() {
-        params = Array.prototype.slice.call(arguments);
-      });
-
-      sendEvent(obj, 'event!', ['foo', 'bar']);
-      assert.deepEqual(params, ['foo', 'bar'], 'params should be saved');
-    }
-
-    ['@test hasListeners tells you if there are listeners for a given event'](assert) {
-      let obj = {};
-
-      function F() {}
-      function F2() {}
-
-      assert.equal(hasListeners(obj, 'event!'), false, 'no listeners at first');
-
-      addListener(obj, 'event!', F);
-      addListener(obj, 'event!', F2);
-
-      assert.equal(hasListeners(obj, 'event!'), true, 'has listeners');
-
-      removeListener(obj, 'event!', F);
-      assert.equal(hasListeners(obj, 'event!'), true, 'has listeners');
-
-      removeListener(obj, 'event!', F2);
-      assert.equal(hasListeners(obj, 'event!'), false, 'has no more listeners');
-
-      addListener(obj, 'event!', F);
-      assert.equal(hasListeners(obj, 'event!'), true, 'has listeners');
-    }
-
-    ['@test calling removeListener without method should remove all listeners'](assert) {
-      let obj = {};
-      function F() {}
-      function F2() {}
-
-      assert.equal(hasListeners(obj, 'event!'), false, 'no listeners at first');
-
-      addListener(obj, 'event!', F);
-      addListener(obj, 'event!', F2);
-
-      assert.equal(hasListeners(obj, 'event!'), true, 'has listeners');
-      removeListener(obj, 'event!');
-
-      assert.equal(hasListeners(obj, 'event!'), false, 'has no more listeners');
-    }
-
-    ['@test a listener can be added as part of a mixin'](assert) {
-      let triggered = 0;
-      let MyMixin = Mixin.create({
-        foo1: on('bar', function() {
-          triggered++;
-        }),
-
-        foo2: on('bar', function() {
-          triggered++;
-        }),
-      });
-
-      let obj = {};
-      MyMixin.apply(obj);
-
-      sendEvent(obj, 'bar');
-      assert.equal(triggered, 2, 'should invoke listeners');
-    }
-
-    [`@test 'on' asserts for invalid arguments`]() {
-      expectAssertion(() => {
-        Mixin.create({
-          foo1: on('bar'),
-        });
-      }, 'on expects function as last argument');
-
-      expectAssertion(() => {
-        Mixin.create({
-          foo1: on(function() {}),
-        });
-      }, 'on called without valid event names');
-    }
-
-    ['@test a listener added as part of a mixin may be overridden'](assert) {
-      let triggered = 0;
-      let FirstMixin = Mixin.create({
-        foo: on('bar', function() {
-          triggered++;
-        }),
-      });
-      let SecondMixin = Mixin.create({
-        foo: on('baz', function() {
-          triggered++;
-        }),
-      });
-
-      let obj = {};
-      FirstMixin.apply(obj);
-      SecondMixin.apply(obj);
-
-      sendEvent(obj, 'bar');
-      assert.equal(triggered, 0, 'should not invoke from overridden property');
-
-      sendEvent(obj, 'baz');
-      assert.equal(triggered, 1, 'should invoke from subclass property');
-    }
-  }
-);