discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/ember-routing/tests/system/router_test.js

@@ -1,287 +0,0 @@
-import { setOwner } from 'ember-owner';
-import HashLocation from '../../lib/location/hash_location';
-import HistoryLocation from '../../lib/location/history_location';
-import AutoLocation from '../../lib/location/auto_location';
-import NoneLocation from '../../lib/location/none_location';
-import Router, { triggerEvent } from '../../lib/system/router';
-import { runDestroy, buildOwner, moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-let owner;
-
-function createRouter(settings, options = {}) {
-  let CustomRouter = Router.extend();
-  let router = CustomRouter.create(settings);
-
-  if (!options.skipOwner) {
-    setOwner(router, owner);
-  }
-
-  if (!options.disableSetup) {
-    router.setupRouter();
-  }
-
-  return router;
-}
-
-moduleFor(
-  'Ember Router',
-  class extends AbstractTestCase {
-    constructor() {
-      super();
-      owner = buildOwner();
-
-      //register the HashLocation (the default)
-      owner.register('location:hash', HashLocation);
-      owner.register('location:history', HistoryLocation);
-      owner.register('location:auto', AutoLocation);
-      owner.register('location:none', NoneLocation);
-    }
-
-    teardown() {
-      runDestroy(owner);
-      owner = null;
-    }
-
-    ['@test can create a router without an owner'](assert) {
-      createRouter(undefined, { disableSetup: true, skipOwner: true });
-
-      assert.ok(true, 'no errors were thrown when creating without a container');
-    }
-
-    ['@test [GH#15237] EmberError is imported correctly'](assert) {
-      // If we get the right message it means Error is being imported correctly.
-      assert.throws(function() {
-        triggerEvent(null, false, []);
-      }, /because your app hasn't finished transitioning/);
-    }
-
-    ['@test should not create a router.js instance upon init'](assert) {
-      let router = createRouter(undefined, { disableSetup: true });
-
-      assert.ok(!router._routerMicrolib);
-    }
-
-    ['@test should not reify location until setupRouter is called'](assert) {
-      let router = createRouter(undefined, { disableSetup: true });
-      assert.equal(typeof router.location, 'string', 'location is specified as a string');
-
-      router.setupRouter();
-
-      assert.equal(typeof router.location, 'object', 'location is reified into an object');
-    }
-
-    ['@test should destroy its location upon destroying the routers owner.'](assert) {
-      let router = createRouter();
-      let location = router.get('location');
-
-      runDestroy(owner);
-
-      assert.ok(location.isDestroyed, 'location should be destroyed');
-    }
-
-    ['@test should instantiate its location with its `rootURL`'](assert) {
-      let router = createRouter({
-        rootURL: '/rootdir/',
-      });
-      let location = router.get('location');
-
-      assert.equal(location.get('rootURL'), '/rootdir/');
-    }
-
-    ['@test replacePath should be called with the right path'](assert) {
-      assert.expect(1);
-
-      let location = owner.lookup('location:auto');
-
-      let browserLocation = {
-        href: 'http://test.com/rootdir/welcome',
-        origin: 'http://test.com',
-        pathname: '/rootdir/welcome',
-        hash: '',
-        search: '',
-        replace(url) {
-          assert.equal(url, 'http://test.com/rootdir/#/welcome');
-        },
-      };
-
-      location.location = browserLocation;
-      location.global = { onhashchange() {} };
-      location.history = null;
-
-      createRouter({
-        location: 'auto',
-        rootURL: '/rootdir/',
-      });
-    }
-
-    ['@test Router._routePath should consume identical prefixes'](assert) {
-      createRouter();
-
-      function routePath() {
-        let handlerInfos = Array.prototype.slice.call(arguments).map(function(s) {
-          return { name: s };
-        });
-        handlerInfos.unshift({ name: 'ignored' });
-
-        return Router._routePath(handlerInfos);
-      }
-
-      assert.equal(routePath('foo'), 'foo');
-      assert.equal(routePath('foo', 'bar', 'baz'), 'foo.bar.baz');
-      assert.equal(routePath('foo', 'foo.bar'), 'foo.bar');
-      assert.equal(routePath('foo', 'foo.bar', 'foo.bar.baz'), 'foo.bar.baz');
-      assert.equal(routePath('foo', 'foo.bar', 'foo.bar.baz.wow'), 'foo.bar.baz.wow');
-      assert.equal(routePath('foo', 'foo.bar.baz.wow'), 'foo.bar.baz.wow');
-      assert.equal(routePath('foo.bar', 'bar.baz.wow'), 'foo.bar.baz.wow');
-
-      // This makes no sense, not trying to handle it, just
-      // making sure it doesn't go boom.
-      assert.equal(routePath('foo.bar.baz', 'foo'), 'foo.bar.baz.foo');
-    }
-
-    ['@test Router should cancel routing setup when the Location class says so via cancelRouterSetup'](
-      assert
-    ) {
-      assert.expect(0);
-
-      let router;
-      let FakeLocation = {
-        cancelRouterSetup: true,
-        create() {
-          return this;
-        },
-      };
-
-      owner.register('location:fake', FakeLocation);
-
-      router = createRouter({
-        location: 'fake',
-
-        _setupRouter() {
-          assert.ok(false, '_setupRouter should not be called');
-        },
-      });
-
-      router.startRouting();
-    }
-
-    ["@test AutoLocation should replace the url when it's not in the preferred format"](assert) {
-      assert.expect(1);
-
-      let location = owner.lookup('location:auto');
-
-      location.location = {
-        href: 'http://test.com/rootdir/welcome',
-        origin: 'http://test.com',
-        pathname: '/rootdir/welcome',
-        hash: '',
-        search: '',
-        replace(url) {
-          assert.equal(url, 'http://test.com/rootdir/#/welcome');
-        },
-      };
-      location.history = null;
-      location.global = {
-        onhashchange() {},
-      };
-
-      createRouter({
-        location: 'auto',
-        rootURL: '/rootdir/',
-      });
-    }
-
-    ['@test Router#handleURL should remove any #hashes before doing URL transition'](assert) {
-      assert.expect(2);
-
-      let router = createRouter({
-        _doURLTransition(routerJsMethod, url) {
-          assert.equal(routerJsMethod, 'handleURL');
-          assert.equal(url, '/foo/bar?time=morphin');
-        },
-      });
-
-      router.handleURL('/foo/bar?time=morphin#pink-power-ranger');
-    }
-
-    ['@test Router#triggerEvent allows actions to bubble when returning true'](assert) {
-      assert.expect(2);
-
-      let handlerInfos = [
-        {
-          name: 'application',
-          handler: {
-            actions: {
-              loading() {
-                assert.ok(false, 'loading not handled by application route');
-              },
-            },
-          },
-        },
-        {
-          name: 'about',
-          handler: {
-            actions: {
-              loading() {
-                assert.ok(true, 'loading handled by about route');
-                return false;
-              },
-            },
-          },
-        },
-        {
-          name: 'about.me',
-          handler: {
-            actions: {
-              loading() {
-                assert.ok(true, 'loading handled by about.me route');
-                return true;
-              },
-            },
-          },
-        },
-      ];
-
-      triggerEvent(handlerInfos, false, ['loading']);
-    }
-
-    ['@test Router#triggerEvent ignores handlers that have not loaded yet'](assert) {
-      assert.expect(1);
-
-      let handlerInfos = [
-        {
-          name: 'about',
-          handler: {
-            actions: {
-              loading() {
-                assert.ok(true, 'loading handled by about route');
-              },
-            },
-          },
-        },
-        {
-          name: 'about.me',
-          handler: undefined,
-        },
-      ];
-
-      triggerEvent(handlerInfos, false, ['loading']);
-    }
-
-    ['@test transitionTo should throw an error when called after owner is destroyed']() {
-      let router = createRouter();
-
-      runDestroy(router);
-
-      router.currentRouteName = 'route-a';
-
-      expectAssertion(function() {
-        router.transitionTo('route-b');
-      }, "A transition was attempted from 'route-a' to 'route-b' but the application instance has already been destroyed.");
-
-      expectAssertion(function() {
-        router.transitionTo('./route-b/1');
-      }, "A transition was attempted from 'route-a' to './route-b/1' but the application instance has already been destroyed.");
-    }
-  }
-);

data/dist/es/ember-routing/tests/utils_test.js

@@ -1,37 +0,0 @@
-import { normalizeControllerQueryParams } from '../lib/utils';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'Routing query parameter utils - normalizeControllerQueryParams',
-  class extends AbstractTestCase {
-    ['@test converts array style into verbose object style'](assert) {
-      let paramName = 'foo';
-      let params = [paramName];
-      let normalized = normalizeControllerQueryParams(params);
-
-      assert.ok(normalized[paramName], 'turns the query param name into key');
-      assert.equal(normalized[paramName].as, null, "includes a blank alias in 'as' key");
-      assert.equal(normalized[paramName].scope, 'model', 'defaults scope to model');
-    }
-
-    ["@test converts object style [{foo: 'an_alias'}]"](assert) {
-      let paramName = 'foo';
-      let params = [{ foo: 'an_alias' }];
-      let normalized = normalizeControllerQueryParams(params);
-
-      assert.ok(normalized[paramName], 'retains the query param name as key');
-      assert.equal(normalized[paramName].as, 'an_alias', "includes the provided alias in 'as' key");
-      assert.equal(normalized[paramName].scope, 'model', 'defaults scope to model');
-    }
-
-    ["@test retains maximally verbose object style [{foo: {as: 'foo'}}]"](assert) {
-      let paramName = 'foo';
-      let params = [{ foo: { as: 'an_alias' } }];
-      let normalized = normalizeControllerQueryParams(params);
-
-      assert.ok(normalized[paramName], 'retains the query param name as key');
-      assert.equal(normalized[paramName].as, 'an_alias', "includes the provided alias in 'as' key");
-      assert.equal(normalized[paramName].scope, 'model', 'defaults scope to model');
-    }
-  }
-);

data/dist/es/ember-runtime/.gitignore

@@ -1 +0,0 @@
-.spade

data/dist/es/ember-runtime/README

@@ -1,12 +0,0 @@
-ember/runtime
-
-== About Ember Runtime
-
-The Ember Runtime is a library that adds property bindings and observers
-to JavaScript.  You can use the runtime in web pages, applications, and
-everything in between to easily manage the state of your page with less code.
-
-This library is a part of the Ember JavaScript Application Framework,
-which is a full-stack MVC framework for building desktop-like applications on
-the web.
-

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

@@ -1,35 +0,0 @@
-export { default as Object, FrameworkObject } from './lib/system/object';
-export { default as RegistryProxyMixin } from './lib/mixins/registry_proxy';
-export { default as ContainerProxyMixin } from './lib/mixins/container_proxy';
-export { default as copy } from './lib/copy';
-export { default as compare } from './lib/compare';
-export { default as isEqual } from './lib/is-equal';
-export {
-  default as Array,
-  isEmberArray,
-  NativeArray,
-  A,
-  MutableArray,
-  removeAt,
-  uniqBy,
-  isArray,
-} from './lib/mixins/array';
-export { default as Comparable } from './lib/mixins/comparable';
-export { default as Namespace } from './lib/system/namespace';
-export { default as ArrayProxy } from './lib/system/array_proxy';
-export { default as ObjectProxy } from './lib/system/object_proxy';
-export { default as CoreObject } from './lib/system/core_object';
-export { default as ActionHandler } from './lib/mixins/action_handler';
-export { default as Copyable } from './lib/mixins/copyable';
-export { default as Enumerable } from './lib/mixins/enumerable';
-export { default as _ProxyMixin, contentFor as _contentFor } from './lib/mixins/-proxy';
-export { default as Observable } from './lib/mixins/observable';
-export { default as MutableEnumerable } from './lib/mixins/mutable_enumerable';
-export { default as TargetActionSupport } from './lib/mixins/target_action_support';
-export { default as Evented } from './lib/mixins/evented';
-export { default as PromiseProxyMixin } from './lib/mixins/promise_proxy';
-
-export { default as RSVP, onerrorDefault } from './lib/ext/rsvp'; // just for side effect of extending Ember.RSVP
-export { typeOf } from './lib/type-of';
-
-import './lib/ext/function'; // just for side effect of extending Function.prototype

data/dist/es/ember-runtime/lib/compare.js

@@ -1,149 +0,0 @@
-import { typeOf } from './type-of';
-import Comparable from './mixins/comparable';
-
-const TYPE_ORDER = {
-  undefined: 0,
-  null: 1,
-  boolean: 2,
-  number: 3,
-  string: 4,
-  array: 5,
-  object: 6,
-  instance: 7,
-  function: 8,
-  class: 9,
-  date: 10,
-};
-
-//
-// the spaceship operator
-//
-//                      `. ___
-//                     __,' __`.                _..----....____
-//         __...--.'``;.   ,.   ;``--..__     .'    ,-._    _.-'
-//   _..-''-------'   `'   `'   `'     O ``-''._   (,;') _,'
-// ,'________________                          \`-._`-','
-//  `._              ```````````------...___   '-.._'-:
-//     ```--.._      ,.                     ````--...__\-.
-//             `.--. `-` "INFINITY IS LESS     ____    |  |`
-//               `. `.   THAN BEYOND"        ,'`````.  ;  ;`
-//                 `._`.        __________   `.      \'__/`
-//                    `-:._____/______/___/____`.     \  `
-//                                |       `._    `.    \
-//                                `._________`-.   `.   `.___
-//                                              SSt  `------'`
-function spaceship(a, b) {
-  let diff = a - b;
-  return (diff > 0) - (diff < 0);
-}
-
-/**
- @module @ember/utils
-*/
-
-/**
- Compares two javascript values and returns:
-
-  - -1 if the first is smaller than the second,
-  - 0 if both are equal,
-  - 1 if the first is greater than the second.
-
-  ```javascript
-  import { compare } from '@ember/utils';
-
-  compare('hello', 'hello');  // 0
-  compare('abc', 'dfg');      // -1
-  compare(2, 1);              // 1
-  ```
-
- If the types of the two objects are different precedence occurs in the
- following order, with types earlier in the list considered `<` types
- later in the list:
-
-  - undefined
-  - null
-  - boolean
-  - number
-  - string
-  - array
-  - object
-  - instance
-  - function
-  - class
-  - date
-
-  ```javascript
-  import { compare } from '@ember/utils';
-
-  compare('hello', 50);       // 1
-  compare(50, 'hello');       // -1
-  ```
-
- @method compare
- @for @ember/utils
- @static
- @param {Object} v First value to compare
- @param {Object} w Second value to compare
- @return {Number} -1 if v < w, 0 if v = w and 1 if v > w.
- @public
-*/
-export default function compare(v, w) {
-  if (v === w) {
-    return 0;
-  }
-
-  let type1 = typeOf(v);
-  let type2 = typeOf(w);
-
-  if (type1 === 'instance' && Comparable.detect(v) && v.constructor.compare) {
-    return v.constructor.compare(v, w);
-  }
-
-  if (type2 === 'instance' && Comparable.detect(w) && w.constructor.compare) {
-    return w.constructor.compare(w, v) * -1;
-  }
-
-  let res = spaceship(TYPE_ORDER[type1], TYPE_ORDER[type2]);
-
-  if (res !== 0) {
-    return res;
-  }
-
-  // types are equal - so we have to check values now
-  switch (type1) {
-    case 'boolean':
-    case 'number':
-      return spaceship(v, w);
-
-    case 'string':
-      return spaceship(v.localeCompare(w), 0);
-
-    case 'array': {
-      let vLen = v.length;
-      let wLen = w.length;
-      let len = Math.min(vLen, wLen);
-
-      for (let i = 0; i < len; i++) {
-        let r = compare(v[i], w[i]);
-        if (r !== 0) {
-          return r;
-        }
-      }
-
-      // all elements are equal now
-      // shorter array should be ordered first
-      return spaceship(vLen, wLen);
-    }
-    case 'instance':
-      if (Comparable.detect(v)) {
-        return v.compare(v, w);
-      }
-      return 0;
-
-    case 'date':
-      return spaceship(v.getTime(), w.getTime());
-
-    default:
-      return 0;
-  }
-}