discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/internal-test-helpers/lib/module-for.js

@@ -1,89 +0,0 @@
-import { isEnabled } from '@ember/canary-features';
-import applyMixins from './apply-mixins';
-import getAllPropertyNames from './get-all-property-names';
-import { all } from 'rsvp';
-
-export default function moduleFor(description, TestClass, ...mixins) {
-  QUnit.module(description, {
-    beforeEach: function(...args) {
-      let instance = new TestClass(...args);
-      this.instance = instance;
-      if (instance.beforeEach) {
-        return instance.beforeEach(...args);
-      }
-    },
-
-    afterEach: function() {
-      let promises = [];
-      let instance = this.instance;
-      this.instance = null;
-      if (instance.teardown) {
-        promises.push(instance.teardown());
-      }
-      if (instance.afterEach) {
-        promises.push(instance.afterEach());
-      }
-
-      // this seems odd, but actually saves significant time
-      // in the test suite
-      //
-      // returning a promise from a QUnit test always adds a 13ms
-      // delay to the test, this filtering prevents returning a
-      // promise when it is not needed
-      //
-      // Remove after we can update to QUnit that includes
-      // https://github.com/qunitjs/qunit/pull/1246
-      let filteredPromises = promises.filter(Boolean);
-      if (filteredPromises.length > 0) {
-        return all(filteredPromises);
-      }
-    },
-  });
-
-  if (mixins.length > 0) {
-    applyMixins(TestClass, ...mixins);
-  }
-
-  let properties = getAllPropertyNames(TestClass);
-  properties.forEach(generateTest);
-
-  function shouldTest(features) {
-    return features.every(feature => {
-      if (feature[0] === '!' && isEnabled(feature.slice(1))) {
-        return false;
-      } else if (!isEnabled(feature)) {
-        return false;
-      } else {
-        return true;
-      }
-    });
-  }
-
-  function generateTest(name) {
-    if (name.indexOf('@test ') === 0) {
-      QUnit.test(name.slice(5), function(assert) {
-        return this.instance[name](assert);
-      });
-    } else if (name.indexOf('@only ') === 0) {
-      QUnit.only(name.slice(5), function(assert) {
-        return this.instance[name](assert);
-      });
-    } else if (name.indexOf('@skip ') === 0) {
-      QUnit.skip(name.slice(5), function(assert) {
-        return this.instance[name](assert);
-      });
-    } else {
-      let match = /^@feature\(([A-Z_a-z-!]+)\) /.exec(name);
-
-      if (match) {
-        let features = match[1].replace(/ /g, '').split(',');
-
-        if (shouldTest(features)) {
-          QUnit.test(name.slice(match[0].length), function(assert) {
-            return this.instance[name](assert);
-          });
-        }
-      }
-    }
-  }
-}

data/dist/es/internal-test-helpers/lib/registry-check.js

@@ -1,28 +0,0 @@
-export function verifyRegistration(assert, owner, fullName) {
-  assert.ok(owner.resolveRegistration(fullName), `has registration: ${fullName}`);
-}
-
-export function verifyInjection(assert, owner, fullName, property, injectionName) {
-  let registry = owner.__registry__;
-  let injections;
-
-  if (fullName.indexOf(':') === -1) {
-    injections = registry.getTypeInjections(fullName);
-  } else {
-    injections = registry.getInjections(registry.normalize(fullName));
-  }
-
-  let normalizedName = registry.normalize(injectionName);
-  let hasInjection = false;
-  let injection;
-
-  for (let i = 0, l = injections.length; i < l; i++) {
-    injection = injections[i];
-    if (injection.property === property && injection.specifier === normalizedName) {
-      hasInjection = true;
-      break;
-    }
-  }
-
-  assert.ok(hasInjection, `has injection: ${fullName}.${property} = ${injectionName}`);
-}

data/dist/es/internal-test-helpers/lib/run.js

@@ -1,11 +0,0 @@
-import { run } from '@ember/runloop';
-
-export function runAppend(view) {
-  run(view, 'appendTo', document.getElementById('qunit-fixture'));
-}
-
-export function runDestroy(toDestroy) {
-  if (toDestroy) {
-    run(toDestroy, 'destroy');
-  }
-}

data/dist/es/internal-test-helpers/lib/strip.js

@@ -1,12 +0,0 @@
-export default function strip([...strings], ...values) {
-  let str = strings
-    .map((string, index) => {
-      let interpolated = values[index];
-      return string + (interpolated !== undefined ? interpolated : '');
-    })
-    .join('');
-  return str
-    .split('\n')
-    .map(s => s.trim())
-    .join('');
-}

data/dist/es/internal-test-helpers/lib/system/synthetic-events.js

@@ -1,183 +0,0 @@
-import { run } from '@ember/runloop';
-/* globals Element */
-
-import { merge } from '@ember/polyfills';
-
-const DEFAULT_EVENT_OPTIONS = { canBubble: true, cancelable: true };
-const KEYBOARD_EVENT_TYPES = ['keydown', 'keypress', 'keyup'];
-const MOUSE_EVENT_TYPES = [
-  'click',
-  'mousedown',
-  'mouseup',
-  'dblclick',
-  'mouseenter',
-  'mouseleave',
-  'mousemove',
-  'mouseout',
-  'mouseover',
-];
-
-export const elMatches =
-  typeof Element !== 'undefined' &&
-  (Element.prototype.matches ||
-    Element.prototype.matchesSelector ||
-    Element.prototype.mozMatchesSelector ||
-    Element.prototype.msMatchesSelector ||
-    Element.prototype.oMatchesSelector ||
-    Element.prototype.webkitMatchesSelector);
-
-export function matches(el, selector) {
-  return elMatches.call(el, selector);
-}
-
-function isFocusable(el) {
-  let focusableTags = ['INPUT', 'BUTTON', 'LINK', 'SELECT', 'A', 'TEXTAREA'];
-  let { tagName, type } = el;
-
-  if (type === 'hidden') {
-    return false;
-  }
-
-  return focusableTags.indexOf(tagName) > -1 || el.contentEditable === 'true';
-}
-
-export function click(el, options = {}) {
-  run(() => fireEvent(el, 'mousedown', options));
-  focus(el);
-  run(() => fireEvent(el, 'mouseup', options));
-  run(() => fireEvent(el, 'click', options));
-}
-
-export function focus(el) {
-  if (!el) {
-    return;
-  }
-  if (isFocusable(el)) {
-    run(null, function() {
-      let browserIsNotFocused = document.hasFocus && !document.hasFocus();
-
-      // Firefox does not trigger the `focusin` event if the window
-      // does not have focus. If the document doesn't have focus just
-      // use trigger('focusin') instead.
-      if (browserIsNotFocused) {
-        fireEvent(el, 'focusin');
-      }
-
-      // makes `document.activeElement` be `el`. If the browser is focused, it also fires a focus event
-      el.focus();
-
-      // if the browser is not focused the previous `el.focus()` didn't fire an event, so we simulate it
-      if (browserIsNotFocused) {
-        fireEvent(el, 'focus');
-      }
-    });
-  }
-}
-
-export function blur(el) {
-  if (isFocusable(el)) {
-    run(null, function() {
-      let browserIsNotFocused = document.hasFocus && !document.hasFocus();
-
-      fireEvent(el, 'focusout');
-
-      // makes `document.activeElement` be `body`.
-      // If the browser is focused, it also fires a blur event
-      el.blur();
-
-      // Chrome/Firefox does not trigger the `blur` event if the window
-      // does not have focus. If the document does not have focus then
-      // fire `blur` event via native event.
-      if (browserIsNotFocused) {
-        fireEvent(el, 'blur');
-      }
-    });
-  }
-}
-
-export function fireEvent(element, type, options = {}) {
-  if (!element) {
-    return;
-  }
-  let event;
-  if (KEYBOARD_EVENT_TYPES.indexOf(type) > -1) {
-    event = buildKeyboardEvent(type, options);
-  } else if (MOUSE_EVENT_TYPES.indexOf(type) > -1) {
-    let rect = element.getBoundingClientRect();
-    let x = rect.left + 1;
-    let y = rect.top + 1;
-    let simulatedCoordinates = {
-      screenX: x + 5,
-      screenY: y + 95,
-      clientX: x,
-      clientY: y,
-    };
-    event = buildMouseEvent(type, merge(simulatedCoordinates, options));
-  } else {
-    event = buildBasicEvent(type, options);
-  }
-  element.dispatchEvent(event);
-
-  return event;
-}
-
-function buildBasicEvent(type, options = {}) {
-  let event = document.createEvent('Events');
-  event.initEvent(type, true, true);
-  merge(event, options);
-  return event;
-}
-
-function buildMouseEvent(type, options = {}) {
-  let event;
-  try {
-    event = document.createEvent('MouseEvents');
-    let eventOpts = merge({}, DEFAULT_EVENT_OPTIONS);
-    merge(eventOpts, options);
-
-    event.initMouseEvent(
-      type,
-      eventOpts.canBubble,
-      eventOpts.cancelable,
-      window,
-      eventOpts.detail,
-      eventOpts.screenX,
-      eventOpts.screenY,
-      eventOpts.clientX,
-      eventOpts.clientY,
-      eventOpts.ctrlKey,
-      eventOpts.altKey,
-      eventOpts.shiftKey,
-      eventOpts.metaKey,
-      eventOpts.button,
-      eventOpts.relatedTarget
-    );
-  } catch (e) {
-    event = buildBasicEvent(type, options);
-  }
-  return event;
-}
-
-function buildKeyboardEvent(type, options = {}) {
-  let event;
-  try {
-    event = document.createEvent('KeyEvents');
-    let eventOpts = merge({}, DEFAULT_EVENT_OPTIONS);
-    merge(eventOpts, options);
-    event.initKeyEvent(
-      type,
-      eventOpts.canBubble,
-      eventOpts.cancelable,
-      window,
-      eventOpts.ctrlKey,
-      eventOpts.altKey,
-      eventOpts.shiftKey,
-      eventOpts.metaKey,
-      eventOpts.keyCode,
-      eventOpts.charCode
-    );
-  } catch (e) {
-    event = buildBasicEvent(type, options);
-  }
-  return event;
-}

data/dist/es/internal-test-helpers/lib/test-cases/abstract-application.js

@@ -1,70 +0,0 @@
-import { compile } from 'ember-template-compiler';
-import { ENV } from 'ember-environment';
-import AbstractTestCase from './abstract';
-import { runDestroy } from '../run';
-
-export default class AbstractApplicationTestCase extends AbstractTestCase {
-  _ensureInstance(bootOptions) {
-    if (this._applicationInstancePromise) {
-      return this._applicationInstancePromise;
-    }
-
-    return (this._applicationInstancePromise = this.runTask(() => this.application.boot()).then(
-      app => {
-        this.applicationInstance = app.buildInstance();
-
-        return this.applicationInstance.boot(bootOptions);
-      }
-    ));
-  }
-
-  visit(url, options) {
-    // TODO: THIS IS HORRIBLE
-    // the promise returned by `ApplicationInstance.protoype.visit` does **not**
-    // currently guarantee rendering is completed
-    return this.runTask(() => {
-      return this._ensureInstance(options).then(instance => instance.visit(url));
-    });
-  }
-
-  get element() {
-    if (this._element) {
-      return this._element;
-    } else if (ENV._APPLICATION_TEMPLATE_WRAPPER) {
-      return (this._element = document.querySelector('#qunit-fixture > div.ember-view'));
-    } else {
-      return (this._element = document.querySelector('#qunit-fixture'));
-    }
-  }
-
-  set element(element) {
-    this._element = element;
-  }
-
-  afterEach() {
-    runDestroy(this.applicationInstance);
-    runDestroy(this.application);
-
-    super.teardown();
-  }
-
-  get applicationOptions() {
-    return {
-      rootElement: '#qunit-fixture',
-    };
-  }
-
-  get routerOptions() {
-    return {
-      location: 'none',
-    };
-  }
-
-  get router() {
-    return this.application.resolveRegistration('router:main');
-  }
-
-  compile(/* string, options */) {
-    return compile(...arguments);
-  }
-}

data/dist/es/internal-test-helpers/lib/test-cases/abstract-rendering.js

@@ -1,203 +0,0 @@
-import { assign } from '@ember/polyfills';
-import { compile } from 'ember-template-compiler';
-import { EventDispatcher } from 'ember-views';
-import { helper, Helper, Component, _resetRenderers } from 'ember-glimmer';
-import { ModuleBasedResolver } from '../test-resolver';
-
-import AbstractTestCase from './abstract';
-import buildOwner from '../build-owner';
-import { runAppend, runDestroy } from '../run';
-
-const TextNode = window.Text;
-
-export default class AbstractRenderingTestCase extends AbstractTestCase {
-  constructor() {
-    super(...arguments);
-    let bootOptions = this.getBootOptions();
-
-    let owner = (this.owner = buildOwner({
-      ownerOptions: this.getOwnerOptions(),
-      resolver: this.getResolver(),
-      bootOptions,
-    }));
-
-    this.renderer = this.owner.lookup('renderer:-dom');
-    this.element = document.querySelector('#qunit-fixture');
-    this.component = null;
-
-    owner.register('event_dispatcher:main', EventDispatcher);
-    owner.inject('event_dispatcher:main', '_viewRegistry', '-view-registry:main');
-    if (!bootOptions || bootOptions.isInteractive !== false) {
-      owner.lookup('event_dispatcher:main').setup(this.getCustomDispatcherEvents(), this.element);
-    }
-  }
-
-  compile() {
-    return compile(...arguments);
-  }
-
-  getCustomDispatcherEvents() {
-    return {};
-  }
-
-  getOwnerOptions() {}
-  getBootOptions() {}
-
-  get resolver() {
-    return this.owner.__registry__.fallback.resolver;
-  }
-
-  getResolver() {
-    return new ModuleBasedResolver();
-  }
-
-  add(specifier, factory) {
-    this.resolver.add(specifier, factory);
-  }
-
-  addTemplate(templateName, templateString) {
-    if (typeof templateName === 'string') {
-      this.resolver.add(
-        `template:${templateName}`,
-        this.compile(templateString, {
-          moduleName: templateName,
-        })
-      );
-    } else {
-      this.resolver.add(
-        templateName,
-        this.compile(templateString, {
-          moduleName: templateName.moduleName,
-        })
-      );
-    }
-  }
-
-  addComponent(name, { ComponentClass = null, template = null }) {
-    if (ComponentClass) {
-      this.resolver.add(`component:${name}`, ComponentClass);
-    }
-
-    if (typeof template === 'string') {
-      this.resolver.add(
-        `template:components/${name}`,
-        this.compile(template, {
-          moduleName: `components/${name}`,
-        })
-      );
-    }
-  }
-
-  afterEach() {
-    try {
-      if (this.component) {
-        runDestroy(this.component);
-      }
-      if (this.owner) {
-        runDestroy(this.owner);
-      }
-    } finally {
-      _resetRenderers();
-    }
-  }
-
-  get context() {
-    return this.component;
-  }
-
-  render(templateStr, context = {}) {
-    let { owner } = this;
-
-    owner.register(
-      'template:-top-level',
-      this.compile(templateStr, {
-        moduleName: '-top-level',
-      })
-    );
-
-    let attrs = assign({}, context, {
-      tagName: '',
-      layoutName: '-top-level',
-    });
-
-    owner.register('component:-top-level', Component.extend(attrs));
-
-    this.component = owner.lookup('component:-top-level');
-
-    runAppend(this.component);
-  }
-
-  rerender() {
-    this.component.rerender();
-  }
-
-  registerHelper(name, funcOrClassBody) {
-    let type = typeof funcOrClassBody;
-
-    if (type === 'function') {
-      this.owner.register(`helper:${name}`, helper(funcOrClassBody));
-    } else if (type === 'object' && type !== null) {
-      this.owner.register(`helper:${name}`, Helper.extend(funcOrClassBody));
-    } else {
-      throw new Error(`Cannot register ${funcOrClassBody} as a helper`);
-    }
-  }
-
-  registerPartial(name, template) {
-    let owner = this.env.owner || this.owner;
-    if (typeof template === 'string') {
-      owner.register(
-        `template:${name}`,
-        this.compile(template, { moduleName: `my-app/templates/-${name}.hbs` })
-      );
-    }
-  }
-
-  registerComponent(name, { ComponentClass = Component, template = null }) {
-    let { owner } = this;
-
-    if (ComponentClass) {
-      owner.register(`component:${name}`, ComponentClass);
-    }
-
-    if (typeof template === 'string') {
-      owner.register(
-        `template:components/${name}`,
-        this.compile(template, {
-          moduleName: `my-app/templates/components/${name}.hbs`,
-        })
-      );
-    }
-  }
-
-  registerComponentManager(name, manager) {
-    let owner = this.env.owner || this.owner;
-    owner.register(`component-manager:${name}`, manager);
-  }
-
-  registerTemplate(name, template) {
-    let { owner } = this;
-    if (typeof template === 'string') {
-      owner.register(
-        `template:${name}`,
-        this.compile(template, {
-          moduleName: `my-app/templates/${name}.hbs`,
-        })
-      );
-    } else {
-      throw new Error(`Registered template "${name}" must be a string`);
-    }
-  }
-
-  registerService(name, klass) {
-    this.owner.register(`service:${name}`, klass);
-  }
-
-  assertTextNode(node, text) {
-    if (!(node instanceof TextNode)) {
-      throw new Error(`Expecting a text node, but got ${node}`);
-    }
-
-    this.assert.strictEqual(node.textContent, text, 'node.textContent');
-  }
-}