test('it works', function() {
var TextNgramsObject = Ember.Object.extend(TextNgramsMixin);
var subject = TextNgramsObject.create();
ok(subject);
});
setValidation: function() {
this.set('validation', Ember.Object.create({}));
}.on('init'),
/**
* Creates the validations class that will become `model.validations`.
* - Setup parent validation inheritance
* - Normalize nested keys (i.e. 'details.dob') into objects (i.e { details: { dob: validator() }})
* - Merge normalized validations with parent
* - Create global CPs (i.e. 'isValid', 'messages', etc...)
*
* @method createValidationsClass
* @private
* @param {Object} inheritedValidationsClass
* @param {Object} validations
* @param {Object} owner
* @return {Ember.Object}
*/
function createValidationsClass(inheritedValidationsClass, validations, owner) {
let validationRules = {};
let validatableAttributes = Object.keys(validations);
// Setup validation inheritance
if (inheritedValidationsClass && inheritedValidationsClass.__isCPValidationsClass__) {
const inheritedValidations = inheritedValidationsClass.create();
validationRules = merge(validationRules, inheritedValidations.get('_validationRules'));
validatableAttributes = emberArray(inheritedValidations.get('validatableAttributes').concat(validatableAttributes)).uniq();
}
// Normalize nested keys into actual objects and merge them with parent object
Object.keys(validations).reduce((obj, key) => {
assign(obj, key, validations[key]);
return obj;
}, validationRules);
// Create the mixin that holds all the top level validation props (isValid, messages, etc)
const TopLevelProps = createTopLevelPropsMixin(validatableAttributes);
// Create the `attrs` class which will add the current model reference once instantiated
const AttrsClass = createAttrsClass(validatableAttributes, validationRules, owner);
// Create `validations` class
const ValidationsClass = Ember.Object.extend(TopLevelProps, {
model: null,
attrs: null,
isValidations: true,
validatableAttributes: computed(function () {
return validatableAttributes;
}).readOnly(),
// Caches
_validators: null,
_debouncedValidations: null,
// Private
_validationRules: computed(function () {
return validationRules;
}).readOnly(),
validate,
validateSync,
init() {
this._super(...arguments);
this.setProperties({
attrs: AttrsClass.create({
_model: this.get('model')
}),
_validators: {},
_debouncedValidations: {}
});
},
destroy() {
this._super(...arguments);
const validatableAttrs = get(this, 'validatableAttributes');
const debouncedValidations = get(this, '_debouncedValidations');
// Initiate attrs destroy to cleanup any remaining model references
this.get('attrs').destroy();
// Cancel all debounced timers
validatableAttrs.forEach(attr => {
const attrCache = get(debouncedValidations, attr);
if (!isNone(attrCache)) {
// Itterate over each attribute and cancel all of its debounced validations
Object.keys(attrCache).forEach(v => run.cancel(attrCache[v]));
}
});
}
});
ValidationsClass.reopenClass({
__isCPValidationsClass__: true
});
return ValidationsClass;
}
return this.get('content').map((image) => {
return Ember.Object.create(image);
});
import Ember from 'ember';
import { test, moduleForComponent } from 'ember-qunit';
import sinon from 'sinon';
import componentMixin from 'sl-ember-behavior/mixins/component';
let behaviorService;
moduleForComponent( 'sl-able', 'Unit | Component | sl able', {
unit: true,
beforeEach() {
behaviorService = Ember.Object.create({
isAble: sinon.stub().returns( true )
});
}
});
test( 'Successfully mixed component', function( assert ) {
assert.ok(
componentMixin.detect( this.subject() )
);
});
/**
* Ensures that the template is wrapping the content in a span tag and not in
* any block-level tags. While it appears that core Ember functionality is being
* tested this test is ensuring that the implied contract about how this non-UI
* component is rendered into the DOM is adhered to.
*/
test( 'Renders as a span tag with no classes', function( assert ) {
this.subject({
return this.get('ajax').get("/repos/" + (repo.get('id')) + "/key", (data) => {
return Ember.Object.create({
fingerprint: data.fingerprint
});
});
test('it works', function() {
var EditPageControllerObject = Ember.Object.extend(EditPageControllerMixin);
var subject = EditPageControllerObject.create();
ok(subject);
});
Ember.run(function() {
component.set('errors', Ember.Object.create({attribute: 'email', message: 'invalid email'}));
});
import Ember from 'ember';
import Struct from 'mapp/models/struct';
import SurfaceVisualization from './surface';
import SymbolVisualization from './symbol';
let VisualizationFactory = Ember.Object.extend({});
VisualizationFactory.reopenClass({
classForType(type) {
switch (type) {
case "surface":
return SurfaceVisualization;
case "symbol":
return SymbolVisualization;
}
throw new Error(`Unknow mapping type ${type}`);
},
createInstance(type, props = {}) {
let o = this.classForType(type).create(props);
o.set('type', type);
return o;
},
restoreInstance(json, refs) {
if (json != null) {
let o = this.classForType(json.type).restore(json, refs);
return o;
} else {
return null;
}
import Ember from 'ember';
import Errors from '../mixins/errors';
import Serializable from '../mixins/serializable';
export default Ember.Object.extend(Errors, Serializable, {
_serializableProperties: ['declarationOption', 'signatoryType', 'visited'],
declarationOption: null,
signatoryType: null,
errors: Ember.computed('declarationOption', 'signatoryType', function() {
const errors = {};
if (Ember.isBlank(this.get('declarationOption'))) {
errors['declarationOption'] = 'Required';
}
if (Ember.isBlank(this.get('signatoryType'))) {
errors['signatoryType'] = 'Required';
}
return errors;
})
});
/**
* Define HashMap class
*
* Simple use of associative array as hash table allowing buckets w/
* chaining for duplicates.
*/
var RelationshipNode = Ember.Object.extend({
next: undefined,
prev: undefined,
item: undefined,
initialize: Ember.on('init', function() {
this.setProperties({
next: undefined,
prev: undefined,
item: undefined
});
})
});
var RelationshipHash = Ember.Object.extend({
buckets: {},
initialize: Ember.on('init', function() {
this.setProperties({
it('works', function() {
let UiAnimatableObject = Ember.Object.extend(AnimatableMixin);
let subject = UiAnimatableObject.create();
expect(subject).to.be.ok;
});
export default Ember.Object.extend({
connection: null,
cable: null,
init() {
this._super(...arguments);
this.pollInterval = { min: 3, max: 30 };
this.staleThreshold = 6;
this.reconnectAttempts = 0;
this.startedAt = null;
this.stoppedAt = null;
this.pingedAt = null;
this.pollTimeout = null;
},
start() {
if (!this.get('isRunning')) {
this.set('startedAt', this.now());
this.set('stoppedAt', null);
this.startPolling();
// TODO
// Use actions instead of event listeners!
// document.addEventListener(
// "visibilitychange", this.get('visibilityDidChange'));
this.get('cable').log(`ConnectionMonitor started. pollInterval = ${this.get('getPollInterval')} ms`);
}
},
stop() {
if (this.get('isRunning')) {
this.set('stoppedAt', this.now());
this.stopPolling();
// TODO
// Use actions instead of event listeners!
// document.removeEventListener(
// "visibilitychange", this.visibilityDidChange);
this.get('cable').log("ConnectionMonitor stopped");
}
},
isRunning: computed('startedAt', 'stoppedAt', function() {
return (this.get('startedAt') !== null) &&
(this.get('stoppedAt') === null);
}),
recordPing() {
this.set('pingedAt', this.now());
},
recordConnect() {
this.set('reconnectAttempts', 0);
this.recordPing();
this.set('disconnectAt', null);
this.get('cable').log("ConnectionMonitor recorded connect");
},
recordDisconnect() {
this.set('disconnectAt', this.now());
this.get('cable').log("ConnectionMonitor recorded disconnect");
},
startPolling() {
this.stopPolling();
this.poll();
},
stopPolling() {
Ember.run.cancel(this.get('pollTimeout'));
},
poll() {
let runLater = Ember.run.later(this, () => {
this.reconnectIfStale();
this.poll();
}, this.get('getPollInterval'));
this.set('pollTimeout', runLater);
},
getPollInterval: computed('reconnectAttempts', function() {
return Math.max(3, Math.min(30, 5 * Math.log(this.get('reconnectAttempts') + 1) )) * 1000;
}),
reconnectIfStale() {
if(this.connectionIsStale()) {
this.get('cable').log(`ConnectionMonitor detected stale connection.
reconnectAttempts = ${this.get('reconnectAttempts')},
pollInterval = ${this.get('getPollInterval')} ms,
time disconnected = ${this.secondsSince(this.get('disconnectedAt'))} s,
stale threshold = ${this.get('staleThreshold')} s`);
this.incrementProperty('reconnectAttempts');
if (!this.disconnectedRecently()) {
this.get('connection').reopen();
}
}
},
connectionIsStale() {
return this.secondsSince(this.get('pingedAt') ||
this.get('startedAt')) > this.get('staleThreshold');
},
disconnectedRecently() {
return this.get('disconnectedAt') &&
this.secondsSince(this.get('disconnectedAt') ) < this.get('staleThreshold');
},
visibilityDidChange() {
if (document.visibilityState === "visible") {
Ember.run.later(this, () => {
if (this.connectionIsStale() || !this.get('connection').isOpen()) {
this.get('cable').log(`ConnectionMonitor reopening stale connection on visibilitychange. visbilityState = ${document.visibilityState}`);
this.get('connection').reopen();
}
}, 200);
}
},
now() {
return new Date().getTime();
},
secondsSince(time) {
return (Date.now() - time) / 1000;
},
clamp(number, min, max) {
return Math.max(min, Math.min(max, number));
}
});
addValue: function() {
this.send('openModal', 'admin.lookup.edit', Ember.Object.create({
isNew: true
}));
},
test('generateBindingPath 3x2 simple', function(assert) {
var PathFactoryObject = Ember.Object.extend(PathFactoryMixin, {
svgenv: Ember.Object.create({
colW: 40,
rowH: 40,
paddingT: 0,
paddingR: 0,
paddingB: 0,
paddingL: 0
})
});
var subject = PathFactoryObject.create();
// #__
// ___
var a = Ember.Object.create({col: 0, row: 0, x: 0, y: 0});
var b = Ember.Object.create({col: 0, row: 0, x: 0, y: 0});
var result = subject.generateBindingPath(a, b);
var expected = null;
assert.equal(result, expected, 'same node');
// ##_
// ___
a = Ember.Object.create({col: 0, row: 0, x: 0, y: 0});
b = Ember.Object.create({col: 1, row: 0, x: 40, y: 0});
result = subject.generateBindingPath(a, b);
expected = null;
assert.equal(result, expected, 'contiguous a b (0,0) (1,0)');
result = subject.generateBindingPath(b, a);
assert.equal(result, expected, 'same row, contiguous b a');
// 3x2
// #_#
// ___
a = Ember.Object.create({col: 0, row: 0, x: 0, y: 0});
b = Ember.Object.create({col: 2, row: 0, x: 80, y: 0});
result = subject.generateBindingPath(a, b);
expected = 'M40 20 v20 h40 v-20';
assert.equal(result, expected, '(0,0) (2,0)');
result = subject.generateBindingPath(b, a);
assert.equal(result, expected, '(0,0) (2,0)');
// #__
// __#
a = Ember.Object.create({col: 0, row: 0, x: 0, y: 0});
b = Ember.Object.create({col: 2, row: 1, x: 0, y: 0});
result = subject.generateBindingPath(a, b);
expected = 'M40 20 v20 h40 v20';
assert.equal(result, expected, '(0,0) (2,1)');
result = subject.generateBindingPath(b, a);
assert.equal(result, expected);
// __#
// #__
a = Ember.Object.create({col: 0, row: 1, x: 0, y: 40});
b = Ember.Object.create({col: 2, row: 0, x: 80, y: 0});
result = subject.generateBindingPath(a, b);
expected = 'M40 60 v-20 h40 v-20';
assert.equal(result, expected, '(0,1) (2,0)');
result = subject.generateBindingPath(b, a);
assert.equal(result, expected, '(2,0) (0,1)');
// 2x3
// _#
// __
// _#
a = Ember.Object.create({col: 1, row: 0, x: 40, y: 0});
b = Ember.Object.create({col: 1, row: 2, x: 40, y: 80});
result = subject.generateBindingPath(a, b);
expected = 'M80 20 v20 v40 v20';
assert.equal(result, expected, '(1,0) (1,2)');
result = subject.generateBindingPath(b, a);
assert.equal(result, expected, '(1,2) (1,0)');
// #_
// __
// _#
a = Ember.Object.create({col: 0, row: 0, x: 0, y: 0});
b = Ember.Object.create({col: 1, row: 2, x: 40, y: 80});
result = subject.generateBindingPath(a, b);
expected = 'M40 20 v20 v40 v20';
assert.equal(result, expected, '(0,0) (1,2)');
result = subject.generateBindingPath(b, a);
assert.equal(result, expected, '(1,2) (0,0)');
});
return store.find('stack', params.stack_id).then((stack) => {
return Ember.Object.create({
stack: stack,
all: all,
});
});
test('it works', function(assert) {
var PathFactoryObject = Ember.Object.extend(PathFactoryMixin);
var subject = PathFactoryObject.create();
assert.ok(subject);
});
/**
* Created by stephenwhite on 20/01/15.
*/
import Ember from 'ember';
export default Ember.Object.extend({
username : ''
});
import Ember from 'ember';
//model is not defined ,so we create like this
var Band=Ember.Object.extend({
name: '',
});
var ledZeppelin = Band.create({ name : 'Led Zeppelin'});
var pearlJam = Band.create({ name : 'Pearl Jam'});
var fooFighters = Band.create({ name : 'Foo Fighters'});
var bands = [ledZeppelin,pearlJam,fooFighters];
export default Ember.Route.extend({
model(){
return bands;
}
});
let links = Ember.Object.create({
HOME: [
{
name: 'eosf.navbar.search',
href: serviceLinks.search,
type: 'search'
},
{
name: 'eosf.navbar.support',
href: serviceLinks.osfSupport
},
{
name: 'eosf.navbar.donate',
href: 'https://cos.io/donate',
type: 'donateToCOS'
},
],
PREPRINTS: [
{
name: 'eosf.navbar.addAPreprint',
href: Ember.isEmpty(baseServiceUrl) ? serviceLinks.preprintsSubmit : baseServiceUrl + 'submit',
type: 'addAPreprint'
},
{
name: 'eosf.navbar.search',
href: Ember.isEmpty(baseServiceUrl) ? serviceLinks.preprintsDiscover : baseServiceUrl + 'discover',
type: 'search'
},
{
name: 'eosf.navbar.support',
href: serviceLinks.preprintsSupport
},
{
name: 'eosf.navbar.donate',
href: 'https://cos.io/donate',
type: 'donateToCOS'
},
],
REGISTRIES: [
{
name: 'eosf.navbar.search',
href: serviceLinks.registriesDiscover,
type: 'search'
},
{
name: 'eosf.navbar.support',
href: serviceLinks.registriesSupport
},
{
name: 'eosf.navbar.donate',
href: 'https://cos.io/donate',
type: 'donateToCOS'
},
],
MEETINGS: [
{
name: 'eosf.navbar.search',
href: serviceLinks.meetingsHome,
type: 'search'
},
{
name: 'eosf.navbar.donate',
href: 'https://cos.io/donate',
type: 'donateToCOS'
},
]
});
import {denormalizeName} from 'ui/services/settings';
export default Ember.Route.extend({
settings: Ember.inject.service(),
beforeModel() {
var store = this.get('store');
return Ember.RSVP.all([
store.find('setting', denormalizeName(C.SETTING.API_HOST)),
store.find('setting', denormalizeName(C.SETTING.CATALOG_URL)),
store.find('setting', denormalizeName(C.SETTING.VM_ENABLED)),
]);
},
model() {
var settings = this.get('settings');
return Ember.Object.create({
host: settings.get(C.SETTING.API_HOST),
catalog: settings.get(C.SETTING.CATALOG_URL),
vm: settings.get(C.SETTING.VM_ENABLED) || false,
});
},
resetController(controller, isExiting /*, transition*/ ) {
if (isExiting) {
controller.set('backToAdd', false);
controller.set('error', null);
}
}
});
test('it works', function(assert) {
var HeritablePropertiesObject = Ember.Object.extend(HeritablePropertiesMixin);
var subject = HeritablePropertiesObject.create();
assert.ok(subject);
});
{
label: 'Save',
action: 'save',
},
{
label: 'Edit',
action: 'edit',
},
{
label: 'Delete',
action: 'delete',
}
]),
optionsNoLabel: Ember.A([
Ember.Object.create({ action: 'save' }),
Ember.Object.create({ label: 'Delete', action: 'delete' }),
Ember.Object.create({ label: 'Edit', action: 'edit' })
]),
optionsPrimary: Ember.A([
Ember.Object.create({ label: 'Save', action: 'save', primary: true }),
Ember.Object.create({ label: 'Delete', action: 'delete' }),
Ember.Object.create({ label: 'Edit', action: 'edit' })
]),
optionsContext: Ember.A([
Ember.Object.create({ label: 'Save', action: 'saveItem', primary: true }),
Ember.Object.create({ label: 'Delete', action: 'deleteItem' }),
Ember.Object.create({ label: 'Edit', action: 'editItem' })
]),
test('_genPathC2CR basic', function(assert) {
var PathFactoryObject = Ember.Object.extend(PathFactoryMixin, {
svgenv: Ember.Object.create({
colW: 40,
rowH: 40
})
});
var subject = PathFactoryObject.create();
/* 2x2 */
var result = subject._genPathC2CR(0, 0),
expected = null;
assert.equal(result, expected, 'same node');
result = subject._genPathC2CR(1, 0);
expected = null;
assert.equal(result, expected, 'node to the right');
result = subject._genPathC2CR(-1, 0);
expected = null;
assert.equal(result, expected, 'node to the left');
result = subject._genPathC2CR(0, 1);
expected = null;
assert.equal(result, expected, 'node below');
result = subject._genPathC2CR(1, 1);
expected = null;
assert.equal(result, expected, 'diagonal node');
/* 2x3 */
/* 0,0 */
result = subject._genPathC2CR(2, 0);
expected = 'h40';
assert.equal(result, expected, '(0,0) (2,0)');
result = subject._genPathC2CR(2, 1);
expected = 'h40';
assert.equal(result, expected, '(0,0) (2,1)');
/* 0,1 */
result = subject._genPathC2CR(2, -1);
expected = 'h40';
assert.equal(result, expected, '(0,1) (2,0)');
result = subject._genPathC2CR(2, 0);
expected = 'h40';
assert.equal(result, expected, '(0,1) (2,1)');
/* 3x2 */
/* 0,0 */
result = subject._genPathC2CR(0, 2);
expected = 'v40';
assert.equal(result, expected, '(0,0) (0,2)');
result = subject._genPathC2CR(1, 2);
expected = 'v40';
assert.equal(result, expected, '(0,0) (1,2)');
/* 1,0 */
result = subject._genPathC2CR(-1, 2);
expected = 'v40';
assert.equal(result, expected, '(1,0) (0,2)');
result = subject._genPathC2CR(0, 2);
expected = 'v40';
assert.equal(result, expected, '(1,0) (1,2)');
// non basic cases
result = subject._genPathC2CR(3, -7);
expected = 'h80 v-240';
assert.equal(result, expected, '(3,14) (6,7)');
});
query: function() {
return Ember.Object.create();
}.property(),
test('generatePathToChild', function(assert) {
var PathFactoryObject = Ember.Object.extend(PathFactoryMixin, {
svgenv: Ember.Object.create({
paddingT: 5,
paddingB: 5,
colW: 40,
rowH: 20
})
});
var subject = PathFactoryObject.create();
var a = Ember.Object.create({
col: 0,
row: 0
}),
b = Ember.Object.create({
col: 0,
row: 0
}),
result = subject.generatePathToChild(a, b),
expected = '';
assert.equal(result, expected, 'same node');
/*
__
|a |
|_b|
*/
a = Ember.Object.create({
col: 0,
row: 0,
x: 0,
y: 0,
width: 40,
height: 10,
cx: 20,
y_padded: 5,
});
b = Ember.Object.create({
col: 1,
row: 1
});
result = subject.generatePathToChild(a, b);
expected = 'M20 15 v5 h20 h20 h-2.5 l2.5 5 l2.5 -5 h-2.5';
assert.equal(result, expected, 'diagonal');
/*
__
|ab|
|__|
*/
a = Ember.Object.create({
col: 0,
row: 0,
x: 0,
y: 0,
width: 40,
height: 10,
cx: 20,
y_padded: 5,
});
b = Ember.Object.create({
col: 1,
row: 0,
});
result = subject.generatePathToChild(a, b);
expected = 'M20 15 v5 h20 v-20 h20 h-2.5 l2.5 5 l2.5 -5 h-2.5';
assert.equal(result, expected, 'node to the right (0,0) (1,0)');
/*
__
|a |
|b_|
*/
a = Ember.Object.create({
col: 0,
row: 0,
x: 0,
y: 0,
width: 40,
height: 10,
cx: 20,
y_padded: 5,
});
b = Ember.Object.create({
col: 0,
row: 1,
});
result = subject.generatePathToChild(a, b);
expected = 'M20 15 v5 h-2.5 l2.5 5 l2.5 -5 h-2.5';
assert.equal(result, expected, 'node to the right (0,0) (1,0)');
});
export default Ember.Object.extend({
/**
* Return a user from the store. If the user doesn't exist, create a new user
*
* @param {String} username
* @return {Promise}
*/
getUserByUsername: function(username) {
var store = this.get('store');
username = username.replace(/[^a-zA-Z0-9 -]/g, '');
return store.findRecord('user', username).then(function(user) {
return user;
}, function() {
// HACK: `findRecord()` creates an entry in internal models which prevents `createRecord()` from working
if (typeof store.typeMapFor === 'function') {
delete store.typeMapFor(store.modelFor('user')).idToRecord[username];
} else if (typeof store._internalModelsFor === 'function') {
store._internalModelsFor('user').remove('user', username);
}
// A user couldn't be found, so create a new user
var user = store.createRecord('user', {
id: username,
created: new Date().getTime()
});
// Save the user
user.save();
return user;
});
}
});
test('_orderNodes', function(assert) {
var PathFactoryObject = Ember.Object.extend(PathFactoryMixin, {
svgenv: Ember.Object.create({
colW: 10,
rowH: 10,
paddingT: 0,
paddingR: 0,
paddingB: 0,
paddingL: 0
})
});
var subject = PathFactoryObject.create();
// 3x3 node `a` at the center (1,1)
var a = Ember.Object.create({col: 1, row: 1});
var b = Ember.Object.create({col: 1, row: 1});
var result = subject._orderNodes(a, b);
var expected = null;
assert.equal(result, expected, 'same node');
// swap needed
a = Ember.Object.create({col: 1, row: 1});
b = Ember.Object.create({col: 0, row: 0});
result = subject._orderNodes(a, b);
expected = {a: b, b: a};
assert.deepEqual(result, expected, '1,1 0,0 swap');
a = Ember.Object.create({col: 1, row: 1});
b = Ember.Object.create({col: 0, row: 1});
result = subject._orderNodes(a, b);
expected = {a: b, b: a};
assert.deepEqual(result, expected, '1,1 0,1 swap');
a = Ember.Object.create({col: 1, row: 1});
b = Ember.Object.create({col: 0, row: 2});
result = subject._orderNodes(a, b);
expected = {a: b, b: a};
assert.deepEqual(result, expected, '1,1 0,2 swap');
a = Ember.Object.create({col: 1, row: 1});
b = Ember.Object.create({col: 1, row: 0});
result = subject._orderNodes(a, b);
expected = {a: b, b: a};
assert.deepEqual(result, expected, '1,1 1,0 swap');
// no swap
a = Ember.Object.create({col: 1, row: 1});
b = Ember.Object.create({col: 2, row: 0});
result = subject._orderNodes(a, b);
expected = {a: a, b: b};
assert.deepEqual(result, expected, '1,1 2,0');
a = Ember.Object.create({col: 1, row: 1});
b = Ember.Object.create({col: 2, row: 1});
result = subject._orderNodes(a, b);
expected = {a: a, b: b};
assert.deepEqual(result, expected, '1,1 2,1');
a = Ember.Object.create({col: 1, row: 1});
b = Ember.Object.create({col: 1, row: 2});
result = subject._orderNodes(a, b);
expected = {a: a, b: b};
assert.deepEqual(result, expected, '1,1 1,2');
a = Ember.Object.create({col: 1, row: 1});
b = Ember.Object.create({col: 2, row: 2});
result = subject._orderNodes(a, b);
expected = {a: a, b: b};
assert.deepEqual(result, expected, '1,1 2,2');
});
// Two states change could trigger new pages generation
// 1. When queryCount is changed
// 2. When pageSize is changed
// queryCount change is initiated from outside of component
// pageSize change could be initiated from inside (from the drop down) or from outside (query parameters)
_createPages() {
let self = this,
size = Math.floor(self.get('queryCount') / self.get('pageSize')) + 1,
range = Array(size),
pagesArray = self.get('pagesArray');
pagesArray.clear();
let i = 1;
for (i = 1; i <= range.length; i++) {
var obj = Ember.Object.create({text: i, className: self.get('pageNumber') === i ? "active": ""});
pagesArray.pushObject(obj);
}
},
// highlight the selected page number
_markPaginationActive: function(pageNumber) {
let self = this,
array = self.get('pagesArray');
array.forEach(function(item) {
if (item.text === pageNumber) {
item.set("className", "active");
} else {
item.set("className", "");
}
import Ember from 'ember';
import {
module,
test
} from 'qunit';
import startApp from 'contacts/tests/helpers/start-app';
import { testMixin as FactoryGuyTestMixin } from 'factory-guy';
import contactFactory from '../factories/contact';
import FactoryGuy from 'factory-guy';
var application;
var TestHelper = Ember.Object.createWithMixins(FactoryGuyTestMixin);
var testHelper;
module('Acceptance: Contacts', {
beforeEach: function() {
application = startApp();
testHelper = TestHelper.setup(application);
},
afterEach: function() {
Ember.run(function() { testHelper.teardown(); });
Ember.run(application, 'destroy');
}
});
test('visiting /contacts', function(assert) {
testHelper.handleFindAll('contact', 2);
visit('/contacts');
andThen(function() {