test('creating an object with required properties', function() {
var ClassA = EmberObject.extend({
foo: required()
});
var obj = ClassA.createWithMixins({ foo: 'FOO' }); // should not throw
equal(get(obj,'foo'), 'FOO');
});
setup: function() {
PartialMixin = Mixin.create({
foo: required(),
bar: 'BAR'
});
FinalMixin = Mixin.create({
foo: 'FOO'
});
obj = {};
},
Generally iterators will continue to call `nextObject` until the index
reaches the your current length-1. If you run out of data before this
time for some reason, you should simply return undefined.
The default implementation of this method simply looks up the index.
This works great on any Array-like objects.
@method nextObject
@param {Number} index the current index of the iteration
@param {Object} previousObject the value returned by the last call to
`nextObject`.
@param {Object} context a context object you can use to maintain state.
@return {Object} the next object in the iteration or undefined
*/
nextObject: required(Function),
/**
Helper method returns the first object from a collection. This is usually
used by bindings and other parts of the framework to extract a single
object if the enumerable contains only one item.
If you override this method, you should implement it so that it will
always return the same value each time it is called. If your enumerable
contains only one object, this method should always return that object.
If your enumerable is empty, this method should return `undefined`.
```javascript
var arr = ["a", "b", "c"];
arr.get('firstObject'); // "a"
mixin. All `Ember.Array`-like objects are also enumerable.
@class Array
@namespace Ember
@uses Ember.Enumerable
@since Ember 0.9.0
*/
export default Mixin.create(Enumerable, {
/**
Your array must support the `length` property. Your replace methods should
set this property whenever it changes.
@property {Number} length
*/
length: required(),
/**
Returns the object at the given `index`. If the given `index` is negative
or is greater or equal than the array length, returns `undefined`.
This is one of the primitives you must implement to support `Ember.Array`.
If your object supports retrieving the value of an array item using `get()`
(i.e. `myArray.get(0)`), then you do not need to implement this method
yourself.
```javascript
var arr = ['a', 'b', 'c', 'd'];
arr.objectAt(0); // "a"
arr.objectAt(3); // "d"
arr.objectAt(-1); // undefined
/**
Implements some standard methods for comparing objects. Add this mixin to
any class you create that can compare its instances.
You should implement the `compare()` method.
@class Comparable
@namespace Ember
@since Ember 0.9
*/
export default Mixin.create({
/**
Override to return the result of the comparison of the two parameters. The
compare method should return:
- `-1` if `a < b`
- `0` if `a == b`
- `1` if `a > b`
Default implementation raises an exception.
@method compare
@param a {Object} the first object to compare
@param b {Object} the second object to compare
@return {Integer} the result of the comparison
*/
compare: required(Function)
});
To use a Suite to test your own objects, extend the suite subclass and
define any required methods. Then call run() on the new subclass. This
will create an instance of your class and then defining the unit tests.
@extends Ember.Object
@private
*/
var Suite = EmberObject.extend({
/**
Define a name for these tests - all modules are prefixed w/ it.
@type String
*/
name: required(String),
/**
Invoked to actually run the test - overridden by mixins
*/
run: function() {}
});
Suite.reopenClass({
plan: null,
run: function() {
var C = this;
return new C().run();
import { Suite } from 'ember-runtime/tests/suites/suite';
import {required} from "ember-metal/mixin";
var CopyableTests = Suite.extend({
/**
Must be able to create a new object for testing.
@returns {Object} object
*/
newObject: required(Function),
/**
Compares the two passed in objects. Returns true if the two objects
are logically equivalent.
@param {Object} a
First object
@param {Object} b
Second object
@returns {Boolean}
*/
isEqual: required(Function),
/**
Set this to true if you expect the objects you test to be freezable.
The suite will verify that your objects actually match this. (i.e. if
you say you can't test freezable it will verify that your objects really
aren't freezable.)
CoreObject.PrototypeMixin.ownerConstructor = CoreObject;
function makeToString(ret) {
return function() { return ret; };
}
if (Ember.config.overridePrototypeMixin) {
Ember.config.overridePrototypeMixin(CoreObject.PrototypeMixin);
}
CoreObject.__super__ = null;
var ClassMixin = Mixin.create({
ClassMixin: required(),
PrototypeMixin: required(),
isClass: true,
isMethod: false,
/**
Creates a new subclass.
```javascript
App.Person = Ember.Object.extend({
say: function(thing) {
alert(thing);
}
});
var EnumerableTests = Suite.extend({
/**
Implement to return a new enumerable object for testing. Should accept
either no parameters, a single number (indicating the desired length of
the collection) or an array of objects.
@param {Array} content
An array of items to include in the enumerable optionally.
@returns {Ember.Enumerable} a new enumerable
*/
newObject: required(Function),
/**
Implement to return a set of new fixture strings that can be applied to
the enumerable. This may be passed into the newObject method.
@param {Number} count
The number of items required.
@returns {Array} array of strings
*/
newFixture: function(cnt) {
var ret = [];
while(--cnt >= 0) ret.push(generateGuid());
return ret;
},
/**
__Required.__ You must implement this method to apply this mixin.
Attempts to add the passed object to the receiver if the object is not
already present in the collection. If the object is present, this method
has no effect.
If the passed object is of a type not supported by the receiver,
then this method should raise an exception.
@method addObject
@param {Object} object The object to add to the enumerable.
@return {Object} the passed object
*/
addObject: required(Function),
/**
Adds each object in the passed enumerable to the receiver.
@method addObjects
@param {Ember.Enumerable} objects the objects to add.
@return {Object} receiver
*/
addObjects: function(objects) {
beginPropertyChanges(this);
forEach(objects, function(obj) { this.addObject(obj); }, this);
endPropertyChanges(this);
return this;
},
@class Copyable
@namespace Ember
@since Ember 0.9
*/
var Copyable = Mixin.create({
/**
Override to return a copy of the receiver. Default implementation raises
an exception.
@method copy
@param {Boolean} deep if `true`, a deep copy of the object should be made
@return {Object} copy of receiver
*/
copy: required(Function),
/**
If the object implements `Ember.Freezable`, then this will return a new
copy if the object is not frozen and the receiver if the object is frozen.
Raises an exception if you try to call this method on a object that does
not support freezing.
You should use this method whenever you want a copy of a freezable object
since a freezable object can simply return itself without actually
consuming more memory.
@method frozenCopy
@return {Object} copy of receiver or receiver
*/
expectDeprecation(() => {
PartialMixin = Mixin.create({
foo: required(),
bar: 'BAR'
});
}, 'Ember.required is deprecated as its behavior is inconsistent and unreliable.');
/**
__Required.__ You must implement this method to apply this mixin.
This is one of the primitives you must implement to support `Ember.Array`.
You should replace amt objects started at idx with the objects in the
passed array. You should also call `this.enumerableContentDidChange()`
@method replace
@param {Number} idx Starting index in the array to replace. If
idx >= length, then append to the end of the array.
@param {Number} amt Number of elements that should be removed from
the array, starting at *idx*.
@param {Array} objects An array of zero or more objects that should be
inserted into the array at *idx*
*/
replace: required(),
/**
Remove all elements from the array. This is useful if you
want to reuse an existing array without having to recreate it.
```javascript
var colors = ["red", "green", "blue"];
color.length(); // 3
colors.clear(); // []
colors.length(); // 0
```
@method clear
@return {Ember.Array} An empty Array.
*/