From 360b1d1a738df0b919de47071d80bce33c2a2dc8 Mon Sep 17 00:00:00 2001 From: Piotr Sarnacki Date: Tue, 19 Feb 2013 02:56:35 +0100 Subject: [PATCH] Update ember, ember-data and jquery --- assets/scripts/vendor/ember-data.js | 7471 +++++-- assets/scripts/vendor/ember.js | 29964 ++++++++++++++------------ assets/scripts/vendor/handlebars.js | 791 +- assets/scripts/vendor/jquery.min.js | 9601 ++++++++- 4 files changed, 32360 insertions(+), 15467 deletions(-) diff --git a/assets/scripts/vendor/ember-data.js b/assets/scripts/vendor/ember-data.js index 9a71e855..8c5311c0 100644 --- a/assets/scripts/vendor/ember-data.js +++ b/assets/scripts/vendor/ember-data.js @@ -1,15 +1,46 @@ +// Last commit: 8801f2e (2013-02-15 13:53:27 -0800) + + (function() { window.DS = Ember.Namespace.create({ - CURRENT_API_REVISION: 4 + // this one goes to 11 + CURRENT_API_REVISION: 11 }); })(); +(function() { +var DeferredMixin = Ember.DeferredMixin, // ember-runtime/mixins/deferred + Evented = Ember.Evented, // ember-runtime/mixins/evented + run = Ember.run, // ember-metal/run-loop + get = Ember.get; // ember-metal/accessors + +var LoadPromise = Ember.Mixin.create(Evented, DeferredMixin, { + init: function() { + this._super.apply(this, arguments); + this.one('didLoad', function() { + run(this, 'resolve', this); + }); + + if (get(this, 'isLoaded')) { + this.trigger('didLoad'); + } + } +}); + +DS.LoadPromise = LoadPromise; + +})(); + + + (function() { var get = Ember.get, set = Ember.set; +var LoadPromise = DS.LoadPromise; // system/mixins/load_promise + /** A record array is an array that contains records of a certain type. The record array materializes records as needed when they are retrieved for the first @@ -18,8 +49,7 @@ var get = Ember.get, set = Ember.set; in response to queries. */ -DS.RecordArray = Ember.ArrayProxy.extend({ - +DS.RecordArray = Ember.ArrayProxy.extend(Ember.Evented, LoadPromise, { /** The model type contained by this record array. @@ -33,17 +63,46 @@ DS.RecordArray = Ember.ArrayProxy.extend({ // necessary, by the store. content: null, + isLoaded: false, + isUpdating: false, + // The store that created this record array. store: null, objectAtContent: function(index) { var content = get(this, 'content'), - clientId = content.objectAt(index), + reference = content.objectAt(index), store = get(this, 'store'); - if (clientId !== undefined) { - return store.findByClientId(get(this, 'type'), clientId); + if (reference) { + return store.recordForReference(reference); } + }, + + materializedObjectAt: function(index) { + var reference = get(this, 'content').objectAt(index); + if (!reference) { return; } + + if (get(this, 'store').recordIsMaterialized(reference)) { + return this.objectAt(index); + } + }, + + update: function() { + if (get(this, 'isUpdating')) { return; } + + var store = get(this, 'store'), + type = get(this, 'type'); + + store.fetchAll(type, this); + }, + + addReference: function(reference) { + get(this, 'content').addObject(reference); + }, + + removeReference: function(reference) { + get(this, 'content').removeObject(reference); } }); @@ -56,6 +115,7 @@ var get = Ember.get; DS.FilteredRecordArray = DS.RecordArray.extend({ filterFunction: null, + isLoaded: true, replace: function() { var type = get(this, 'type').toString(); @@ -77,169 +137,25 @@ var get = Ember.get, set = Ember.set; DS.AdapterPopulatedRecordArray = DS.RecordArray.extend({ query: null, - isLoaded: false, replace: function() { var type = get(this, 'type').toString(); throw new Error("The result of a server query (on " + type + ") is immutable."); }, - load: function(array) { + load: function(references) { var store = get(this, 'store'), type = get(this, 'type'); - var clientIds = store.loadMany(type, array).clientIds; - this.beginPropertyChanges(); - set(this, 'content', Ember.A(clientIds)); + set(this, 'content', Ember.A(references)); set(this, 'isLoaded', true); this.endPropertyChanges(); - } -}); - -})(); - - - -(function() { -var get = Ember.get, set = Ember.set, guidFor = Ember.guidFor; - -var Set = function() { - this.hash = {}; - this.list = []; -}; - -Set.prototype = { - add: function(item) { - var hash = this.hash, - guid = guidFor(item); - - if (hash.hasOwnProperty(guid)) { return; } - - hash[guid] = true; - this.list.push(item); - }, - - remove: function(item) { - var hash = this.hash, - guid = guidFor(item); - - if (!hash.hasOwnProperty(guid)) { return; } - - delete hash[guid]; - var list = this.list, - index = Ember.EnumerableUtils.indexOf(this, item); - - list.splice(index, 1); - }, - - isEmpty: function() { - return this.list.length === 0; - } -}; - -var LoadedState = Ember.State.extend({ - recordWasAdded: function(manager, record) { - var dirty = manager.dirty, observer; - dirty.add(record); - - observer = function() { - if (!get(record, 'isDirty')) { - record.removeObserver('isDirty', observer); - manager.send('childWasSaved', record); - } - }; - - record.addObserver('isDirty', observer); - }, - - recordWasRemoved: function(manager, record) { - var dirty = manager.dirty, observer; - dirty.add(record); - - observer = function() { - record.removeObserver('isDirty', observer); - if (!get(record, 'isDirty')) { manager.send('childWasSaved', record); } - }; - - record.addObserver('isDirty', observer); - } -}); - -var states = { - loading: Ember.State.create({ - isLoaded: false, - isDirty: false, - - loadedRecords: function(manager, count) { - manager.decrement(count); - }, - - becameLoaded: function(manager) { - manager.transitionTo('clean'); - } - }), - - clean: LoadedState.create({ - isLoaded: true, - isDirty: false, - - recordWasAdded: function(manager, record) { - this._super(manager, record); - manager.goToState('dirty'); - }, - - update: function(manager, clientIds) { - var manyArray = manager.manyArray; - set(manyArray, 'content', clientIds); - } - }), - - dirty: LoadedState.create({ - isLoaded: true, - isDirty: true, - - childWasSaved: function(manager, child) { - var dirty = manager.dirty; - dirty.remove(child); - - if (dirty.isEmpty()) { manager.send('arrayBecameSaved'); } - }, - - arrayBecameSaved: function(manager) { - manager.goToState('clean'); - } - }) -}; - -DS.ManyArrayStateManager = Ember.StateManager.extend({ - manyArray: null, - initialState: 'loading', - states: states, - - /** - This number is used to keep track of the number of outstanding - records that must be loaded before the array is considered - loaded. As results stream in, this number is decremented until - it becomes zero, at which case the `isLoaded` flag will be set - to true - */ - counter: 0, - - init: function() { - this._super(); - this.dirty = new Set(); - this.counter = get(this, 'manyArray.length'); - }, - - decrement: function(count) { - var counter = this.counter = this.counter - count; - - Ember.assert("Somehow the ManyArray loaded counter went below 0. This is probably an ember-data bug. Please report it at https://github.com/emberjs/data/issues", counter >= 0); - - if (counter === 0) { - this.send('becameLoaded'); - } + var self = this; + // TODO: does triggering didLoad event should be the last action of the runLoop? + Ember.run.once(function() { + self.trigger('didLoad'); + }); } }); @@ -250,124 +166,176 @@ DS.ManyArrayStateManager = Ember.StateManager.extend({ (function() { var get = Ember.get, set = Ember.set; +/** + A ManyArray is a RecordArray that represents the contents of a has-many + relationship. + + The ManyArray is instantiated lazily the first time the relationship is + requested. + + ### Inverses + + Often, the relationships in Ember Data applications will have + an inverse. For example, imagine the following models are + defined: + + App.Post = DS.Model.extend({ + comments: DS.hasMany('App.Comment') + }); + + App.Comment = DS.Model.extend({ + post: DS.belongsTo('App.Post') + }); + + If you created a new instance of `App.Post` and added + a `App.Comment` record to its `comments` has-many + relationship, you would expect the comment's `post` + property to be set to the post that contained + the has-many. + + We call the record to which a relationship belongs the + relationship's _owner_. +*/ DS.ManyArray = DS.RecordArray.extend({ init: function() { - set(this, 'stateManager', DS.ManyArrayStateManager.create({ manyArray: this })); - - return this._super(); + this._super.apply(this, arguments); + this._changesToSync = Ember.OrderedSet.create(); }, - parentRecord: null, + /** + @private - isDirty: Ember.computed(function() { - return get(this, 'stateManager.currentState.isDirty'); - }).property('stateManager.currentState').cacheable(), + The record to which this relationship belongs. - isLoaded: Ember.computed(function() { - return get(this, 'stateManager.currentState.isLoaded'); - }).property('stateManager.currentState').cacheable(), + @property {DS.Model} + */ + owner: null, - send: function(event, context) { - this.get('stateManager').send(event, context); + // LOADING STATE + + isLoaded: false, + + loadingRecordsCount: function(count) { + this.loadingRecordsCount = count; + }, + + loadedRecord: function() { + this.loadingRecordsCount--; + if (this.loadingRecordsCount === 0) { + set(this, 'isLoaded', true); + this.trigger('didLoad'); + } }, fetch: function() { - var clientIds = get(this, 'content'), + var references = get(this, 'content'), store = get(this, 'store'), - type = get(this, 'type'); + type = get(this, 'type'), + owner = get(this, 'owner'); - store.fetchUnloadedClientIds(type, clientIds); + store.fetchUnloadedReferences(type, references, owner); }, // Overrides Ember.Array's replace method to implement replaceContent: function(index, removed, added) { - var parentRecord = get(this, 'parentRecord'); - var pendingParent = parentRecord && !get(parentRecord, 'id'); - var stateManager = get(this, 'stateManager'); - // Map the array of record objects into an array of client ids. added = added.map(function(record) { - Ember.assert("You can only add records of " + (get(this, 'type') && get(this, 'type').toString()) + " to this association.", !get(this, 'type') || (get(this, 'type') === record.constructor)); - - // If the record to which this many array belongs does not yet - // have an id, notify the newly-added record that it must wait - // for the parent to receive an id before the child can be - // saved. - if (pendingParent) { - record.send('waitingOn', parentRecord); - } - - var oldParent = this.assignInverse(record, parentRecord); - - record.get('transaction') - .relationshipBecameDirty(record, oldParent, parentRecord); - - stateManager.send('recordWasAdded', record); - - return record.get('clientId'); + Ember.assert("You can only add records of " + (get(this, 'type') && get(this, 'type').toString()) + " to this relationship.", !get(this, 'type') || (get(this, 'type') === record.constructor)); + return get(record, '_reference'); }, this); - var store = this.store; - - var len = index+removed, record; - for (var i = index; i < len; i++) { - // TODO: null out inverse FK - record = this.objectAt(i); - var oldParent = this.assignInverse(record, parentRecord, true); - - record.get('transaction') - .relationshipBecameDirty(record, parentRecord, null); - - // If we put the child record into a pending state because - // we were waiting on the parent record to get an id, we - // can tell the child it no longer needs to wait. - if (pendingParent) { - record.send('doneWaitingOn', parentRecord); - } - - stateManager.send('recordWasAdded', record); - } - this._super(index, removed, added); }, - assignInverse: function(record, parentRecord, remove) { - var associationMap = get(record.constructor, 'associations'), - possibleAssociations = associationMap.get(parentRecord.constructor), - possible, actual, oldParent; + arrangedContentDidChange: function() { + this.fetch(); + }, - if (!possibleAssociations) { return; } + arrayContentWillChange: function(index, removed, added) { + var owner = get(this, 'owner'), + name = get(this, 'name'); - for (var i = 0, l = possibleAssociations.length; i < l; i++) { - possible = possibleAssociations[i]; + if (!owner._suspendedRelationships) { + // This code is the first half of code that continues inside + // of arrayContentDidChange. It gets or creates a change from + // the child object, adds the current owner as the old + // parent if this is the first time the object was removed + // from a ManyArray, and sets `newParent` to null. + // + // Later, if the object is added to another ManyArray, + // the `arrayContentDidChange` will set `newParent` on + // the change. + for (var i=index; i B - // B -> C - // - // In this case, there is no need to remember the A->B - // change. We can collapse both changes into: - // - // A -> C - // - // Another possible case is: - // - // A -> B - // B -> A - // - // In this case, we don't need to do anything. We can - // simply remove the original A->B change and call it - // a day. - if (relationship.newParent === oldParent) { - oldParent = relationship.oldParent; - this.removeRelationship(relationship); - - // This is the case of A->B followed by B->A. - if (relationship.oldParent === newParent) { - needsNewEntries = false; - } - } - } - } - - relationship = { - child: child, - oldParent: oldParent, - newParent: newParent - }; - - // If we didn't go A->B and then B->A, add new dirty relationship - // entries. - if (needsNewEntries) { - this.addRelationshipTo('byChild', child, relationship); - this.addRelationshipTo('byOldParent', oldParent, relationship); - this.addRelationshipTo('byNewParent', newParent, relationship); - } - }, - - removeRelationship: function(relationship) { - var relationships = this.dirtyRelationships; - - removeObject(relationships.byOldParent.get(relationship.oldParent), relationship); - removeObject(relationships.byNewParent.get(relationship.newParent), relationship); - removeObject(relationships.byChild.get(relationship.child), relationship); - }, - - addRelationshipTo: function(type, record, description) { - var map = this.dirtyRelationships[type]; - - var relationships = map.get(record); - - if (!relationships) { - relationships = [ description ]; - map.set(record, relationships); - } else { - relationships.push(description); - } + this.bucketForType(bucketType).remove(record); }, /** @@ -857,6 +713,11 @@ DS.Transaction = Ember.Object.extend({ this.addToBucket('inflight', record); }, + recordIsMoving: function(kind, record) { + this.removeFromBucket(kind, record); + this.addToBucket('clean', record); + }, + /** @private @@ -868,7 +729,6 @@ DS.Transaction = Ember.Object.extend({ */ recordBecameClean: function(kind, record) { this.removeFromBucket(kind, record); - this.remove(record); } }); @@ -878,37 +738,181 @@ DS.Transaction = Ember.Object.extend({ (function() { -/*globals Ember*/ -var get = Ember.get, set = Ember.set, fmt = Ember.String.fmt; +var classify = Ember.String.classify, get = Ember.get; -var DATA_PROXY = { - get: function(name) { - return this.savedData[name]; - } +/** +@private + + The Mappable mixin is designed for classes that would like to + behave as a map for configuration purposes. + + For example, the DS.Adapter class can behave like a map, with + more semantic API, via the `map` API: + + DS.Adapter.map('App.Person', { firstName: { keyName: 'FIRST' } }); + + Class configuration via a map-like API has a few common requirements + that differentiate it from the standard Ember.Map implementation. + + First, values often are provided as strings that should be normalized + into classes the first time the configuration options are used. + + Second, the values configured on parent classes should also be taken + into account. + + Finally, setting the value of a key sometimes should merge with the + previous value, rather than replacing it. + + This mixin provides a instance method, `createInstanceMapFor`, that + will reify all of the configuration options set on an instance's + constructor and provide it for the instance to use. + + Classes can implement certain hooks that allow them to customize + the requirements listed above: + + * `resolveMapConflict` - called when a value is set for an existing + value + * `transformMapKey` - allows a key name (for example, a global path + to a class) to be normalized + * `transformMapValue` - allows a value (for example, a class that + should be instantiated) to be normalized + + Classes that implement this mixin should also implement a class + method built using the `generateMapFunctionFor` method: + + DS.Adapter.reopenClass({ + map: DS.Mappable.generateMapFunctionFor('attributes', function(key, newValue, map) { + var existingValue = map.get(key); + + for (var prop in newValue) { + if (!newValue.hasOwnProperty(prop)) { continue; } + existingValue[prop] = newValue[prop]; + } + }) + }); + + The function passed to `generateMapFunctionFor` is invoked every time a + new value is added to the map. +**/ + +var resolveMapConflict = function(oldValue, newValue, mappingsKey) { + return oldValue; }; +var transformMapKey = function(key, value) { + return key; +}; + +var transformMapValue = function(key, value) { + return value; +}; + +DS._Mappable = Ember.Mixin.create({ + createInstanceMapFor: function(mapName) { + var instanceMeta = Ember.metaPath(this, ['DS.Mappable'], true); + + instanceMeta.values = instanceMeta.values || {}; + + if (instanceMeta.values[mapName]) { return instanceMeta.values[mapName]; } + + var instanceMap = instanceMeta.values[mapName] = new Ember.Map(); + + var klass = this.constructor; + + while (klass && klass !== DS.Store) { + this._copyMap(mapName, klass, instanceMap); + klass = klass.superclass; + } + + instanceMeta.values[mapName] = instanceMap; + return instanceMap; + }, + + _copyMap: function(mapName, klass, instanceMap) { + var classMeta = Ember.metaPath(klass, ['DS.Mappable'], true); + + var classMap = classMeta[mapName]; + if (classMap) { + classMap.forEach(eachMap, this); + } + + function eachMap(key, value) { + var transformedKey = (klass.transformMapKey || transformMapKey)(key, value); + var transformedValue = (klass.transformMapValue || transformMapValue)(key, value); + + var oldValue = instanceMap.get(transformedKey); + var newValue = transformedValue; + + if (oldValue) { + newValue = (this.constructor.resolveMapConflict || resolveMapConflict)(oldValue, newValue, mapName); + } + + instanceMap.set(transformedKey, newValue); + } + }, + + +}); + +DS._Mappable.generateMapFunctionFor = function(mapName, transform) { + return function(key, value) { + var meta = Ember.metaPath(this, ['DS.Mappable'], true); + var map = meta[mapName] || Ember.MapWithDefault.create({ + defaultValue: function() { return {}; } + }); + + transform.call(this, key, value, map); + + meta[mapName] = map; + }; +}; + +})(); + + + +(function() { +/*globals Ember*/ +/*jshint eqnull:true*/ +var get = Ember.get, set = Ember.set, fmt = Ember.String.fmt, once = Ember.run.once; +var forEach = Ember.EnumerableUtils.forEach; // These values are used in the data cache when clientIds are // needed but the underlying data has not yet been loaded by // the server. var UNLOADED = 'unloaded'; var LOADING = 'loading'; +var MATERIALIZED = { materialized: true }; +var CREATED = { created: true }; // Implementors Note: // // The variables in this file are consistently named according to the following // scheme: // -// * +id+ means an identifier managed by an external source, provided inside the -// data hash provided by that source. +// * +id+ means an identifier managed by an external source, provided inside +// the data provided by that source. // * +clientId+ means a transient numerical identifier generated at runtime by // the data store. It is important primarily because newly created objects may // not yet have an externally generated id. // * +type+ means a subclass of DS.Model. +// Used by the store to normalize IDs entering the store. Despite the fact +// that developers may provide IDs as numbers (e.g., `store.find(Person, 1)`), +// it is important that internally we use strings, since IDs may be serialized +// and lose type information. For example, Ember's router may put a record's +// ID into the URL, and if we later try to deserialize that URL and find the +// corresponding record, we will not know if it is a string or a number. +var coerceId = function(id) { + return id == null ? null : id+''; +}; + +var map = Ember.EnumerableUtils.map; + /** - The store contains all of the hashes for records loaded from the server. - It is also responsible for creating instances of DS.Model when you request one - of these data hashes, so that they can be bound to in your Handlebars templates. + The store contains all of the data for records loaded from the server. + It is also responsible for creating instances of DS.Model that wraps + the individual data for a record, so that they can be bound to in your + Handlebars templates. Create a new store like this: @@ -929,7 +933,7 @@ var LOADING = 'loading'; You can learn more about writing a custom adapter by reading the `DS.Adapter` documentation. */ -DS.Store = Ember.Object.extend({ +DS.Store = Ember.Object.extend(DS._Mappable, { /** Many methods can be invoked without specifying which store should be used. @@ -955,22 +959,36 @@ DS.Store = Ember.Object.extend({ this.typeMaps = {}; this.recordCache = []; this.clientIdToId = {}; + this.clientIdToType = {}; + this.clientIdToData = {}; + this.clientIdToPrematerializedData = {}; this.recordArraysByClientId = {}; + this.relationshipChanges = {}; + this.recordReferences = {}; // Internally, we maintain a map of all unloaded IDs requested by - // a ManyArray. As the adapter loads hashes into the store, the + // a ManyArray. As the adapter loads data into the store, the // store notifies any interested ManyArrays. When the ManyArray's // total number of loading records drops to zero, it becomes // `isLoaded` and fires a `didLoad` event. this.loadingRecordArrays = {}; set(this, 'defaultTransaction', this.transaction()); - - return this._super(); }, /** - Returns a new transaction scoped to this store. + Returns a new transaction scoped to this store. This delegates + responsibility for invoking the adapter's commit mechanism to + a transaction. + + Transaction are responsible for tracking changes to records + added to them, and supporting `commit` and `rollback` + functionality. Committing a transaction invokes the store's + adapter, while rolling back a transaction reverses all + changes made to records added to the transaction. + + A store has an implicit (default) transaction, which tracks changes + made to records not explicitly added to a transaction. @see {DS.Transaction} @returns DS.Transaction @@ -979,17 +997,88 @@ DS.Store = Ember.Object.extend({ return DS.Transaction.create({ store: this }); }, + ensureSameTransaction: function(records){ + var transactions = Ember.A(); + forEach( records, function(record){ + if (record){ transactions.pushObject(get(record, 'transaction')); } + }); + + var transaction = transactions.reduce(function(prev, t) { + if (!get(t, 'isDefault')) { + if (prev === null) { return t; } + Ember.assert("All records in a changed relationship must be in the same transaction. You tried to change the relationship between records when one is in " + t + " and the other is in " + prev, t === prev); + } + + return prev; + }, null); + + if (transaction) { + forEach( records, function(record){ + if (record){ transaction.add(record); } + }); + } else { + transaction = transactions.objectAt(0); + } + return transaction; + + }, /** @private - This is used only by the record's DataProxy. Do not use this directly. - */ - dataForRecord: function(record) { - var type = record.constructor, - clientId = get(record, 'clientId'), - typeMap = this.typeMapFor(type); + Instructs the store to materialize the data for a given record. - return typeMap.cidToHash[clientId]; + To materialize a record, the store first retrieves the opaque data that was + passed to either `load()` or `loadMany()`. Then, the data and the record + are passed to the adapter's `materialize()` method, which allows the adapter + to translate arbitrary data structures from the adapter into the normalized + form the record expects. + + The adapter's `materialize()` method will invoke `materializeAttribute()`, + `materializeHasMany()` and `materializeBelongsTo()` on the record to + populate it with normalized values. + + @param {DS.Model} record + */ + materializeData: function(record) { + var clientId = get(record, 'clientId'), + cidToData = this.clientIdToData, + adapter = this.adapterForType(record.constructor), + data = cidToData[clientId]; + + cidToData[clientId] = MATERIALIZED; + + var prematerialized = this.clientIdToPrematerializedData[clientId]; + + // Ensures the record's data structures are setup + // before being populated by the adapter. + record.setupData(); + + if (data !== CREATED) { + // Instructs the adapter to extract information from the + // opaque data and materialize the record's attributes and + // relationships. + adapter.materialize(record, data, prematerialized); + } + }, + + /** + @private + + Returns true if there is already a record for this clientId. + + This is used to determine whether cleanup is required, so that + "changes" to unmaterialized records do not trigger mass + materialization. + + For example, if a parent record in a relationship with a large + number of children is deleted, we want to avoid materializing + those children. + + @param {Object} reference + @return {Boolean} + */ + recordIsMaterialized: function(reference) { + return !!this.recordCache[reference.clientId]; }, /** @@ -1000,25 +1089,66 @@ DS.Store = Ember.Object.extend({ @property {DS.Adapter|String} */ - adapter: null, + adapter: 'DS.RESTAdapter', /** @private - This property returns the adapter, after resolving a possible String. + Returns a JSON representation of the record using the adapter's + serialization strategy. This method exists primarily to enable + a record, which has access to its store (but not the store's + adapter) to provide a `serialize()` convenience. + + The available options are: + + * `includeId`: `true` if the record's ID should be included in + the JSON representation + + @param {DS.Model} record the record to serialize + @param {Object} options an options hash + */ + serialize: function(record, options) { + return this.adapterForType(record.constructor).serialize(record, options); + }, + + /** + @private + + This property returns the adapter, after resolving a possible + property path. + + If the supplied `adapter` was a class, or a String property + path resolved to a class, this property will instantiate the + class. + + This property is cacheable, so the same instance of a specified + adapter class should be used for the lifetime of the store. @returns DS.Adapter */ _adapter: Ember.computed(function() { var adapter = get(this, 'adapter'); if (typeof adapter === 'string') { - return get(this, adapter, false) || get(window, adapter); + adapter = get(this, adapter, false) || get(Ember.lookup, adapter); } - return adapter; - }).property('adapter').cacheable(), - // A monotonically increasing number to be used to uniquely identify - // data hashes and records. + if (DS.Adapter.detect(adapter)) { + adapter = adapter.create(); + } + + return adapter; + }).property('adapter'), + + /** + @private + + A monotonically increasing number to be used to uniquely identify + data and records. + + It starts at 1 so other parts of the code can test for truthiness + when provided a `clientId` instead of having to explicitly test + for undefined. + */ clientIdCounter: 1, // ..................... @@ -1029,6 +1159,10 @@ DS.Store = Ember.Object.extend({ Create a new record in the current store. The properties passed to this method are set on the newly created record. + Note: The third `transaction` property is for internal use only. + If you want to create a record inside of a given transaction, + use `transaction.createRecord()` instead of `store.createRecord()`. + @param {subclass of DS.Model} type @param {Object} properties a hash of properties to set on the newly created record. @@ -1040,54 +1174,67 @@ DS.Store = Ember.Object.extend({ // Create a new instance of the model `type` and put it // into the specified `transaction`. If no transaction is // specified, the default transaction will be used. - // - // NOTE: A `transaction` is specified when the - // `transaction.createRecord` API is used. var record = type._create({ store: this }); transaction = transaction || get(this, 'defaultTransaction'); + + // adoptRecord is an internal API that allows records to move + // into a transaction without assertions designed for app + // code. It is used here to ensure that regardless of new + // restrictions on the use of the public `transaction.add()` + // API, we will always be able to insert new records into + // their transaction. transaction.adoptRecord(record); - // Extract the primary key from the `properties` hash, - // based on the `primaryKey` for the model type. - var primaryKey = get(record, 'primaryKey'), - id = properties[primaryKey] || null; + // `id` is a special property that may not be a `DS.attr` + var id = properties.id; // If the passed properties do not include a primary key, - // give the adapter an opportunity to generate one. + // give the adapter an opportunity to generate one. Typically, + // client-side ID generators will use something like uuid.js + // to avoid conflicts. var adapter; - if (Ember.none(id)) { - adapter = get(this, 'adapter'); + if (Ember.isNone(id)) { + adapter = this.adapterForType(type); if (adapter && adapter.generateIdForRecord) { - id = adapter.generateIdForRecord(this, record); + id = coerceId(adapter.generateIdForRecord(this, record)); properties.id = id; } } - var hash = {}, clientId; + id = coerceId(id); - // Push the hash into the store. If present, associate the - // extracted `id` with the hash. - clientId = this.pushHash(hash, id, type); - - record.send('didChangeData'); - - var recordCache = get(this, 'recordCache'); + // Create a new `clientId` and associate it with the + // specified (or generated) `id`. Since we don't have + // any data for the server yet (by definition), store + // the sentinel value CREATED as the data for this + // clientId. If we see this value later, we will skip + // materialization. + var clientId = this.pushData(CREATED, id, type); // Now that we have a clientId, attach it to the record we // just created. set(record, 'clientId', clientId); + // Move the record out of its initial `empty` state into + // the `loaded` state. + record.loadedData(); + + // Make sure the data is set up so the record doesn't + // try to materialize its nonexistent data. + record.setupData(); + // Store the record we just created in the record cache for // this clientId. - recordCache[clientId] = record; + this.recordCache[clientId] = record; // Set the properties specified on the record. record.setProperties(properties); - this.updateRecordArrays(type, clientId, get(record, 'data')); + // Resolve record promise + Ember.run(record, 'resolve', record); return record; }, @@ -1102,7 +1249,16 @@ DS.Store = Ember.Object.extend({ @param {DS.Model} record */ deleteRecord: function(record) { - record.send('deleteRecord'); + record.deleteRecord(); + }, + + /** + For symmetry, a record can be unloaded via the store. + + @param {DS.Model} record + */ + unloadRecord: function(record) { + record.unloadRecord(); }, // ................ @@ -1110,13 +1266,12 @@ DS.Store = Ember.Object.extend({ // ................ /** - This is the main entry point into finding records. The first - parameter to this method is always a subclass of `DS.Model`. + This is the main entry point into finding records. The first parameter to + this method is always a subclass of `DS.Model`. - You can use the `find` method on a subclass of `DS.Model` - directly if your application only has one store. For - example, instead of `store.find(App.Person, 1)`, you could - say `App.Person.find(1)`. + You can use the `find` method on a subclass of `DS.Model` directly if your + application only has one store. For example, instead of + `store.find(App.Person, 1)`, you could say `App.Person.find(1)`. --- @@ -1125,101 +1280,144 @@ DS.Store = Ember.Object.extend({ store.find(App.Person, 1); App.Person.find(1); - If the record with that `id` had not previously been loaded, - the store will return an empty record immediately and ask - the adapter to find the data by calling the adapter's `find` - method. + If the record with that `id` had not previously been loaded, the store will + return an empty record immediately and ask the adapter to find the data by + calling the adapter's `find` method. - The `find` method will always return the same object for a - given type and `id`. To check whether the adapter has populated - a record, you can check its `isLoaded` property. + The `find` method will always return the same object for a given type and + `id`. To check whether the adapter has populated a record, you can check + its `isLoaded` property. --- - To find all records for a type, call `find` with no additional - parameters: + To find all records for a type, call `find` with no additional parameters: store.find(App.Person); App.Person.find(); - This will return a `RecordArray` representing all known records - for the given type and kick off a request to the adapter's - `findAll` method to load any additional records for the type. + This will return a `RecordArray` representing all known records for the + given type and kick off a request to the adapter's `findAll` method to load + any additional records for the type. - The `RecordArray` returned by `find()` is live. If any more - records for the type are added at a later time through any - mechanism, it will automatically update to reflect the change. + The `RecordArray` returned by `find()` is live. If any more records for the + type are added at a later time through any mechanism, it will automatically + update to reflect the change. --- - To find a record by a query, call `find` with a hash as the - second parameter: + To find a record by a query, call `find` with a hash as the second + parameter: store.find(App.Person, { page: 1 }); App.Person.find({ page: 1 }); - This will return a `RecordArray` immediately, but it will always - be an empty `RecordArray` at first. It will call the adapter's - `findQuery` method, which will populate the `RecordArray` once - the server has returned results. + This will return a `RecordArray` immediately, but it will always be an + empty `RecordArray` at first. It will call the adapter's `findQuery` + method, which will populate the `RecordArray` once the server has returned + results. - You can check whether a query results `RecordArray` has loaded - by checking its `isLoaded` property. + You can check whether a query results `RecordArray` has loaded by checking + its `isLoaded` property. */ - find: function(type, id, query) { + find: function(type, id) { if (id === undefined) { return this.findAll(type); } - if (query !== undefined) { - return this.findMany(type, id, query); - } else if (Ember.typeOf(id) === 'object') { + // We are passed a query instead of an id. + if (Ember.typeOf(id) === 'object') { return this.findQuery(type, id); } - if (Ember.isArray(id)) { - return this.findMany(type, id); - } - - var clientId = this.typeMapFor(type).idToCid[id]; - - return this.findByClientId(type, clientId, id); + return this.findById(type, coerceId(id)); }, - findByClientId: function(type, clientId, id) { - var recordCache = get(this, 'recordCache'), - dataCache, record; + /** + @private - // If there is already a clientId assigned for this - // type/id combination, try to find an existing - // record for that id and return. Otherwise, - // materialize a new record and set its data to the - // value we already have. - if (clientId !== undefined) { - record = recordCache[clientId]; + This method returns a record for a given type and id combination. - if (!record) { - // create a new instance of the model type in the - // 'isLoading' state - record = this.materializeRecord(type, clientId); + If the store has never seen this combination of type and id before, it + creates a new `clientId` with the LOADING sentinel and asks the adapter to + load the data. - dataCache = this.typeMapFor(type).cidToHash; + If the store has seen the combination, this method delegates to + `getByReference`. + */ + findById: function(type, id) { + var clientId = this.typeMapFor(type).idToCid[id]; - if (typeof dataCache[clientId] === 'object') { - record.send('didChangeData'); - } - } - } else { - clientId = this.pushHash(LOADING, id, type); + if (clientId) { + return this.findByClientId(type, clientId); + } + clientId = this.pushData(LOADING, id, type); + + // create a new instance of the model type in the + // 'isLoading' state + var record = this.materializeRecord(type, clientId, id); + + // let the adapter set the data, possibly async + var adapter = this.adapterForType(type); + if (adapter && adapter.find) { adapter.find(this, type, id); } + else { throw "Adapter is either null or does not implement `find` method"; } + + return record; + }, + + reloadRecord: function(record) { + var type = record.constructor, + adapter = this.adapterForType(type), + id = get(record, 'id'); + + Ember.assert("You cannot update a record without an ID", id); + Ember.assert("You tried to update a record but you have no adapter (for " + type + ")", adapter); + Ember.assert("You tried to update a record but your adapter does not implement `find`", adapter.find); + + adapter.find(this, type, id); + }, + + /** + @private + + This method returns a record for a given clientId. + + If there is no record object yet for the clientId, this method materializes + a new record object. This allows adapters to eagerly load large amounts of + data into the store, and avoid incurring the cost to create the objects + until they are requested. + + Several parts of Ember Data call this method: + + * findById, if a clientId already exists for a given type and + id combination + * OneToManyChange, which is backed by clientIds, when getChild, + getOldParent or getNewParent are called + * RecordArray, which is backed by clientIds, when an object at + a particular index is looked up + + In short, it's a convenient way to get a record for a known + clientId, materializing it if necessary. + + @param {Class} type + @param {Number|String} clientId + */ + findByClientId: function(type, clientId) { + var cidToData, record, id; + + record = this.recordCache[clientId]; + + if (!record) { // create a new instance of the model type in the // 'isLoading' state + id = this.clientIdToId[clientId]; record = this.materializeRecord(type, clientId, id); - // let the adapter set the data, possibly async - var adapter = get(this, '_adapter'); - if (adapter && adapter.find) { adapter.find(this, type, id); } - else { throw fmt("Adapter is either null or does not implement `find` method", this); } + cidToData = this.clientIdToData; + + if (typeof cidToData[clientId] === 'object') { + record.loadedData(); + } } return record; @@ -1234,36 +1432,36 @@ DS.Store = Ember.Object.extend({ In preparation for loading, this method also marks any unloaded `clientId`s as loading. */ - neededClientIds: function(type, clientIds) { - var neededClientIds = [], - typeMap = this.typeMapFor(type), - dataCache = typeMap.cidToHash, - clientId; + neededReferences: function(type, references) { + var neededReferences = [], + cidToData = this.clientIdToData, + reference; - for (var i=0, l=clientIds.length; i "created.uncommitted" + record.get('stateManager.currentPath'); + //=> "created.uncommitted" The `DS.Model` states are themselves stateless. What we mean is that, though each instance of a record also has a unique instance of a @@ -1921,7 +2811,7 @@ var get = Ember.get, set = Ember.set, guidFor = Ember.guidFor; which will be passed as the second parameter to the event handler. Events should transition to a different state if appropriate. This can be - done by calling the state manager's `goToState()` method with a path to the + done by calling the state manager's `transitionTo()` method with a path to the desired state. The state manager will attempt to resolve the state path relative to the current state. If no state is found at that path, it will attempt to resolve it relative to the current state's parent, and then its @@ -1935,12 +2825,12 @@ var get = Ember.get, set = Ember.set, guidFor = Ember.guidFor; * inFlight If we are currently in the `start` state, calling - `goToState('inFlight')` would transition to the `created.inFlight` state, - while calling `goToState('updated.inFlight')` would transition to + `transitionTo('inFlight')` would transition to the `created.inFlight` state, + while calling `transitionTo('updated.inFlight')` would transition to the `updated.inFlight` state. Remember that *only events* should ever cause a state transition. You should - never call `goToState()` from outside a state's event handler. If you are + never call `transitionTo()` from outside a state's event handler. If you are tempted to do so, create a new event and send that to the state manager. #### Flags @@ -1949,7 +2839,7 @@ var get = Ember.get, set = Ember.set, guidFor = Ember.guidFor; state in a more user-friendly way than examining its state path. For example, instead of doing this: - var statePath = record.get('stateManager.currentState.path'); + var statePath = record.get('stateManager.currentPath'); if (statePath === 'created.inFlight') { doSomething(); } @@ -2010,15 +2900,39 @@ var hasDefinedProperties = function(object) { return false; }; +var didChangeData = function(manager) { + var record = get(manager, 'record'); + record.materializeData(); +}; + +var willSetProperty = function(manager, context) { + context.oldValue = get(get(manager, 'record'), context.name); + + var change = DS.AttributeChange.createChange(context); + get(manager, 'record')._changesToSync[context.attributeName] = change; +}; + +var didSetProperty = function(manager, context) { + var change = get(manager, 'record')._changesToSync[context.attributeName]; + change.value = get(get(manager, 'record'), context.name); + change.sync(); +}; + +// Whenever a property is set, recompute all dependent filters +var updateRecordArrays = function(manager) { + var record = manager.get('record'); + record.updateRecordArraysLater(); +}; + DS.State = Ember.State.extend({ isLoaded: stateProperty, + isReloading: stateProperty, isDirty: stateProperty, isSaving: stateProperty, isDeleted: stateProperty, isError: stateProperty, isNew: stateProperty, isValid: stateProperty, - isPending: stateProperty, // For states that are substates of a // DirtyState (updated or created), it is @@ -2027,54 +2941,6 @@ DS.State = Ember.State.extend({ dirtyType: stateProperty }); -var setProperty = function(manager, context) { - var key = context.key, value = context.value; - - var record = get(manager, 'record'), - data = get(record, 'data'); - - set(data, key, value); -}; - -var setAssociation = function(manager, context) { - var key = context.key, value = context.value; - - var record = get(manager, 'record'), - data = get(record, 'data'); - - data.setAssociation(key, value); -}; - -var didChangeData = function(manager) { - var record = get(manager, 'record'), - data = get(record, 'data'); - - data._savedData = null; - record.notifyPropertyChange('data'); -}; - -// The waitingOn event shares common functionality -// between the different dirty states, but each is -// treated slightly differently. This method is exposed -// so that each implementation can invoke the common -// behavior, and then implement the behavior specific -// to the state. -var waitingOn = function(manager, object) { - var record = get(manager, 'record'), - pendingQueue = get(record, 'pendingQueue'), - objectGuid = guidFor(object); - - var observer = function() { - if (get(object, 'id')) { - manager.send('doneWaitingOn', object); - Ember.removeObserver(object, 'id', observer); - } - }; - - pendingQueue[objectGuid] = [object, observer]; - Ember.addObserver(object, 'id', observer); -}; - // Implementation notes: // // Each state has a boolean value for all of the following flags: @@ -2102,51 +2968,6 @@ var waitingOn = function(manager, object) { // did not yet report that it was successfully saved. // * isValid: No client-side validations have failed and the // adapter did not report any server-side validation failures. -// * isPending: A record `isPending` when it belongs to an -// association on another record and that record has not been -// saved. A record in this state cannot be saved because it -// lacks a "foreign key" that will be supplied by its parent -// association when the parent record has been created. When -// the adapter reports that the parent has saved, the -// `isPending` property on all children will become `false` -// and the transaction will try to commit the records. - -// This mixin is mixed into various uncommitted states. Make -// sure to mix it in *after* the class definition, so its -// super points to the class definition. -var Uncommitted = Ember.Mixin.create({ - setProperty: setProperty, - setAssociation: setAssociation -}); - -// These mixins are mixed into substates of the concrete -// subclasses of DirtyState. - -var CreatedUncommitted = Ember.Mixin.create({ - deleteRecord: function(manager) { - var record = get(manager, 'record'); - this._super(manager); - - record.withTransaction(function(t) { - t.recordBecameClean('created', record); - }); - manager.goToState('deleted.saved'); - } -}); - -var UpdatedUncommitted = Ember.Mixin.create({ - deleteRecord: function(manager) { - this._super(manager); - - var record = get(manager, 'record'); - - record.withTransaction(function(t) { - t.recordBecameClean('updated', record); - }); - - manager.goToState('deleted'); - } -}); // The dirty state is a abstract state whose functionality is // shared between the `created` and `updated` states. @@ -2154,6 +2975,15 @@ var UpdatedUncommitted = Ember.Mixin.create({ // The deleted state shares the `isDirty` flag with the // subclasses of `DirtyState`, but with a very different // implementation. +// +// Dirty states have three child states: +// +// `uncommitted`: the store has not yet handed off the record +// to be saved. +// `inFlight`: the store has handed off the record to be saved, +// but the adapter has not yet acknowledged success. +// `invalid`: the record has invalid information and cannot be +// send to the adapter yet. var DirtyState = DS.State.extend({ initialState: 'uncommitted', @@ -2163,8 +2993,8 @@ var DirtyState = DS.State.extend({ // SUBSTATES // When a record first becomes dirty, it is `uncommitted`. - // This means that there are local pending changes, - // but they have not yet begun to be saved. + // This means that there are local pending changes, but they + // have not yet begun to be saved, and are not invalid. uncommitted: DS.State.extend({ // TRANSITIONS enter: function(manager) { @@ -2177,15 +3007,24 @@ var DirtyState = DS.State.extend({ }, // EVENTS - deleteRecord: Ember.K, + willSetProperty: willSetProperty, + didSetProperty: didSetProperty, - waitingOn: function(manager, object) { - waitingOn(manager, object); - manager.goToState('pending'); - }, + becomeDirty: Ember.K, willCommit: function(manager) { - manager.goToState('inFlight'); + manager.transitionTo('inFlight'); + }, + + becameClean: function(manager) { + var record = get(manager, 'record'), + dirtyType = get(this, 'dirtyType'); + + record.withTransaction(function(t) { + t.recordBecameClean(dirtyType, record); + }); + + manager.transitionTo('loaded.materializing'); }, becameInvalid: function(manager) { @@ -2196,23 +3035,13 @@ var DirtyState = DS.State.extend({ t.recordBecameInFlight(dirtyType, record); }); - manager.goToState('invalid'); + manager.transitionTo('invalid'); }, rollback: function(manager) { - var record = get(manager, 'record'), - dirtyType = get(this, 'dirtyType'), - data = get(record, 'data'); - - data.rollback(); - - record.withTransaction(function(t) { - t.recordBecameClean(dirtyType, record); - }); - - manager.goToState('saved'); + get(manager, 'record').rollback(); } - }, Uncommitted), + }), // Once a record has been handed off to the adapter to be // saved, it is in the 'in flight' state. Changes to the @@ -2226,6 +3055,8 @@ var DirtyState = DS.State.extend({ var dirtyType = get(this, 'dirtyType'), record = get(manager, 'record'); + record.becameInFlight(); + record.withTransaction(function (t) { t.recordBecameInFlight(dirtyType, record); }); @@ -2240,7 +3071,7 @@ var DirtyState = DS.State.extend({ t.recordBecameClean('inflight', record); }); - manager.goToState('saved'); + manager.transitionTo('saved'); manager.send('invokeLifecycleCallbacks', dirtyType); }, @@ -2249,117 +3080,14 @@ var DirtyState = DS.State.extend({ set(record, 'errors', errors); - manager.goToState('invalid'); + manager.transitionTo('invalid'); manager.send('invokeLifecycleCallbacks'); }, becameError: function(manager) { - manager.goToState('error'); + manager.transitionTo('error'); manager.send('invokeLifecycleCallbacks'); - }, - - didChangeData: didChangeData - }), - - // If a record becomes associated with a newly created - // parent record, it will be `pending` until the parent - // record has successfully persisted. Once this happens, - // this record can use the parent's primary key as its - // foreign key. - // - // If the record's transaction had already started to - // commit, the record will transition to the `inFlight` - // state. If it had not, the record will transition to - // the `uncommitted` state. - pending: DS.State.extend({ - initialState: 'uncommitted', - - // FLAGS - isPending: true, - - // SUBSTATES - - // A pending record whose transaction has not yet - // started to commit is in this state. - uncommitted: DS.State.extend({ - // EVENTS - deleteRecord: function(manager) { - var record = get(manager, 'record'), - pendingQueue = get(record, 'pendingQueue'), - tuple; - - // since we are leaving the pending state, remove any - // observers we have registered on other records. - for (var prop in pendingQueue) { - if (!pendingQueue.hasOwnProperty(prop)) { continue; } - - tuple = pendingQueue[prop]; - Ember.removeObserver(tuple[0], 'id', tuple[1]); - } - }, - - willCommit: function(manager) { - manager.goToState('committing'); - }, - - doneWaitingOn: function(manager, object) { - var record = get(manager, 'record'), - pendingQueue = get(record, 'pendingQueue'), - objectGuid = guidFor(object); - - delete pendingQueue[objectGuid]; - - if (isEmptyObject(pendingQueue)) { - manager.send('doneWaiting'); - } - }, - - doneWaiting: function(manager) { - var dirtyType = get(this, 'dirtyType'); - manager.goToState(dirtyType + '.uncommitted'); - } - }, Uncommitted), - - // A pending record whose transaction has started - // to commit is in this state. Since it has not yet - // been sent to the adapter, it is not `inFlight` - // until all of its dependencies have been committed. - committing: DS.State.extend({ - // FLAGS - isSaving: true, - - // EVENTS - doneWaitingOn: function(manager, object) { - var record = get(manager, 'record'), - pendingQueue = get(record, 'pendingQueue'), - objectGuid = guidFor(object); - - delete pendingQueue[objectGuid]; - - if (isEmptyObject(pendingQueue)) { - manager.send('doneWaiting'); - } - }, - - doneWaiting: function(manager) { - var record = get(manager, 'record'), - transaction = get(record, 'transaction'); - - // Now that the record is no longer pending, schedule - // the transaction to commit. - Ember.run.once(transaction, transaction.commit); - }, - - willCommit: function(manager) { - var record = get(manager, 'record'), - pendingQueue = get(record, 'pendingQueue'); - - if (isEmptyObject(pendingQueue)) { - var dirtyType = get(this, 'dirtyType'); - manager.goToState(dirtyType + '.inFlight'); - } - } - }) + } }), // A record is in the `invalid` state when its client-side @@ -2379,32 +3107,35 @@ var DirtyState = DS.State.extend({ // EVENTS deleteRecord: function(manager) { - manager.goToState('deleted'); + manager.transitionTo('deleted'); + get(manager, 'record').clearRelationships(); }, - setAssociation: setAssociation, - - setProperty: function(manager, context) { - setProperty(manager, context); + willSetProperty: willSetProperty, + didSetProperty: function(manager, context) { var record = get(manager, 'record'), errors = get(record, 'errors'), - key = context.key; + key = context.name; set(errors, key, null); if (!hasDefinedProperties(errors)) { manager.send('becameValid'); } + + didSetProperty(manager, context); }, + becomeDirty: Ember.K, + rollback: function(manager) { manager.send('becameValid'); manager.send('rollback'); }, becameValid: function(manager) { - manager.goToState('uncommitted'); + manager.transitionTo('uncommitted'); }, invokeLifecycleCallbacks: function(manager) { @@ -2429,31 +3160,36 @@ var updatedState = DirtyState.create({ dirtyType: 'updated' }); -// The created.uncommitted state and created.pending.uncommitted share -// some logic defined in CreatedUncommitted. -createdState.states.uncommitted.reopen(CreatedUncommitted); -createdState.states.pending.states.uncommitted.reopen(CreatedUncommitted); - -// The created.uncommitted state needs to immediately transition to the -// deleted state if it is rolled back. createdState.states.uncommitted.reopen({ - rollback: function(manager) { - this._super(manager); - manager.goToState('deleted.saved'); + deleteRecord: function(manager) { + var record = get(manager, 'record'); + + record.withTransaction(function(t) { + t.recordIsMoving('created', record); + }); + + record.clearRelationships(); + manager.transitionTo('deleted.saved'); } }); -// The updated.uncommitted state and updated.pending.uncommitted share -// some logic defined in UpdatedUncommitted. -updatedState.states.uncommitted.reopen(UpdatedUncommitted); -updatedState.states.pending.states.uncommitted.reopen(UpdatedUncommitted); -updatedState.states.inFlight.reopen({ - didSaveData: function(manager) { - var record = get(manager, 'record'), - data = get(record, 'data'); +createdState.states.uncommitted.reopen({ + rollback: function(manager) { + this._super(manager); + manager.transitionTo('deleted.saved'); + } +}); - data.saveData(); - data.adapterDidUpdate(); +updatedState.states.uncommitted.reopen({ + deleteRecord: function(manager) { + var record = get(manager, 'record'); + + record.withTransaction(function(t) { + t.recordIsMoving('updated', record); + }); + + manager.transitionTo('deleted'); + get(manager, 'record').clearRelationships(); } }); @@ -2461,13 +3197,13 @@ var states = { rootState: Ember.State.create({ // FLAGS isLoaded: false, + isReloading: false, isDirty: false, isSaving: false, isDeleted: false, isError: false, isNew: false, isValid: true, - isPending: false, // SUBSTATES @@ -2479,13 +3215,11 @@ var states = { empty: DS.State.create({ // EVENTS loadingData: function(manager) { - manager.goToState('loading'); + manager.transitionTo('loading'); }, - didChangeData: function(manager) { - didChangeData(manager); - - manager.goToState('loaded.created'); + loadedData: function(manager) { + manager.transitionTo('loaded.created'); } }), @@ -2496,20 +3230,11 @@ var states = { // Usually, this process is asynchronous, using an // XHR to retrieve the data. loading: DS.State.create({ - // TRANSITIONS - exit: function(manager) { - var record = get(manager, 'record'); - record.trigger('didLoad'); - }, - // EVENTS - didChangeData: function(manager, data) { - didChangeData(manager); - manager.send('loadedData'); - }, + loadedData: didChangeData, - loadedData: function(manager) { - manager.goToState('loaded'); + materializingData: function(manager) { + manager.transitionTo('loaded.materializing.firstTime'); } }), @@ -2524,30 +3249,88 @@ var states = { // SUBSTATES - // If there are no local changes to a record, it remains - // in the `saved` state. - saved: DS.State.create({ + materializing: DS.State.create({ + // FLAGS + isLoaded: false, // EVENTS - setProperty: function(manager, context) { - setProperty(manager, context); - manager.goToState('updated'); - }, - - setAssociation: function(manager, context) { - setAssociation(manager, context); - manager.goToState('updated'); - }, + willSetProperty: Ember.K, + didSetProperty: Ember.K, didChangeData: didChangeData, - deleteRecord: function(manager) { - manager.goToState('deleted'); + finishedMaterializing: function(manager) { + manager.transitionTo('loaded.saved'); }, - waitingOn: function(manager, object) { - waitingOn(manager, object); - manager.goToState('updated.pending'); + // SUBSTATES + firstTime: DS.State.create({ + exit: function(manager) { + var record = get(manager, 'record'); + + Ember.run.once(function() { + record.trigger('didLoad'); + }); + } + }) + }), + + reloading: DS.State.create({ + // FLAGS + isReloading: true, + + // TRANSITIONS + enter: function(manager) { + var record = get(manager, 'record'), + store = get(record, 'store'); + + store.reloadRecord(record); + }, + + exit: function(manager) { + var record = get(manager, 'record'); + + once(record, 'trigger', 'didReload'); + }, + + // EVENTS + loadedData: didChangeData, + + materializingData: function(manager) { + manager.transitionTo('loaded.materializing'); + } + }), + + // If there are no local changes to a record, it remains + // in the `saved` state. + saved: DS.State.create({ + // EVENTS + willSetProperty: willSetProperty, + didSetProperty: didSetProperty, + + didChangeData: didChangeData, + loadedData: didChangeData, + + reloadRecord: function(manager) { + manager.transitionTo('loaded.reloading'); + }, + + materializingData: function(manager) { + manager.transitionTo('loaded.materializing'); + }, + + becomeDirty: function(manager) { + manager.transitionTo('updated'); + }, + + deleteRecord: function(manager) { + manager.transitionTo('deleted'); + get(manager, 'record').clearRelationships(); + }, + + unloadRecord: function(manager) { + manager.transitionTo('deleted.saved'); + get(manager, 'record').clearRelationships(); }, invokeLifecycleCallbacks: function(manager, dirtyType) { @@ -2573,13 +3356,16 @@ var states = { // A record is in this state if it was deleted from the store. deleted: DS.State.create({ + initialState: 'uncommitted', + dirtyType: 'deleted', + // FLAGS isDeleted: true, isLoaded: true, isDirty: true, // TRANSITIONS - enter: function(manager) { + setup: function(manager) { var record = get(manager, 'record'), store = get(record, 'store'); @@ -2591,7 +3377,7 @@ var states = { // When a record is deleted, it enters the `start` // state. It will exit this state when the record's // transaction starts to commit. - start: DS.State.create({ + uncommitted: DS.State.create({ // TRANSITIONS enter: function(manager) { var record = get(manager, 'record'); @@ -2603,18 +3389,23 @@ var states = { // EVENTS willCommit: function(manager) { - manager.goToState('inFlight'); + manager.transitionTo('inFlight'); }, rollback: function(manager) { - var record = get(manager, 'record'), - data = get(record, 'data'); + get(manager, 'record').rollback(); + }, + + becomeDirty: Ember.K, + + becameClean: function(manager) { + var record = get(manager, 'record'); - data.rollback(); record.withTransaction(function(t) { t.recordBecameClean('deleted', record); }); - manager.goToState('loaded'); + + manager.transitionTo('loaded.materializing'); } }), @@ -2630,6 +3421,8 @@ var states = { enter: function(manager) { var record = get(manager, 'record'); + record.becameInFlight(); + record.withTransaction(function (t) { t.recordBecameInFlight('deleted', record); }); @@ -2643,7 +3436,7 @@ var states = { t.recordBecameClean('inflight', record); }); - manager.goToState('saved'); + manager.transitionTo('saved'); manager.send('invokeLifecycleCallbacks'); } @@ -2656,6 +3449,13 @@ var states = { // FLAGS isDirty: false, + setup: function(manager) { + var record = get(manager, 'record'), + store = get(record, 'store'); + + store.dematerializeRecord(record); + }, + invokeLifecycleCallbacks: function(manager) { var record = get(manager, 'record'); record.trigger('didDelete', record); @@ -2682,7 +3482,19 @@ var states = { DS.StateManager = Ember.StateManager.extend({ record: null, initialState: 'rootState', - states: states + states: states, + unhandledEvent: function(manager, originalEvent) { + var record = manager.get('record'), + contexts = [].slice.call(arguments, 2), + errorMessage; + errorMessage = "Attempted to handle event `" + originalEvent + "` "; + errorMessage += "on " + record.toString() + " while in state "; + errorMessage += get(manager, 'currentState.path') + ". Called with "; + errorMessage += arrayMap.call(contexts, function(context){ + return Ember.inspect(context); + }).join(', '); + throw new Ember.Error(errorMessage); + } }); })(); @@ -2690,368 +3502,89 @@ DS.StateManager = Ember.StateManager.extend({ (function() { -var get = Ember.get, set = Ember.set; +var LoadPromise = DS.LoadPromise; // system/mixins/load_promise -// When a record is changed on the client, it is considered "dirty"--there are -// pending changes that need to be saved to a persistence layer, such as a -// server. -// -// If the record is rolled back, it re-enters a clean state, any changes are -// discarded, and its attributes are reset back to the last known good copy -// of the data that came from the server. -// -// If the record is committed, the changes are sent to the server to be saved, -// and once the server confirms that they are valid, the record's "canonical" -// data becomes the original canonical data plus the changes merged in. -// -// A DataProxy is an object that encapsulates this change tracking. It -// contains three buckets: -// -// * `savedData` - the last-known copy of the data from the server -// * `unsavedData` - a hash that contains any changes that have not yet -// been committed -// * `associations` - this is similar to `savedData`, but holds the client -// ids of associated records -// -// When setting a property on the object, the value is placed into the -// `unsavedData` bucket: -// -// proxy.set('key', 'value'); -// -// // unsavedData: -// { -// key: "value" -// } -// -// When retrieving a property from the object, it first looks to see -// if that value exists in the `unsavedData` bucket, and returns it if so. -// Otherwise, it returns the value from the `savedData` bucket. -// -// When the adapter notifies a record that it has been saved, it merges the -// `unsavedData` bucket into the `savedData` bucket. If the record's -// transaction is rolled back, the `unsavedData` hash is simply discarded. -// -// This object is a regular JS object for performance. It is only -// used internally for bookkeeping purposes. - -var DataProxy = DS._DataProxy = function(record) { - this.record = record; - - this.unsavedData = {}; - - this.associations = {}; -}; - -DataProxy.prototype = { - get: function(key) { return Ember.get(this, key); }, - set: function(key, value) { return Ember.set(this, key, value); }, - - setAssociation: function(key, value) { - this.associations[key] = value; - }, - - savedData: function() { - var savedData = this._savedData; - if (savedData) { return savedData; } - - var record = this.record, - clientId = get(record, 'clientId'), - store = get(record, 'store'); - - if (store) { - savedData = store.dataForRecord(record); - this._savedData = savedData; - return savedData; - } - }, - - unknownProperty: function(key) { - var unsavedData = this.unsavedData, - associations = this.associations, - savedData = this.savedData(), - store; - - var value = unsavedData[key], association; - - // if this is a belongsTo association, this will - // be a clientId. - association = associations[key]; - - if (association !== undefined) { - store = get(this.record, 'store'); - return store.clientIdToId[association]; - } - - if (savedData && value === undefined) { - value = savedData[key]; - } - - return value; - }, - - setUnknownProperty: function(key, value) { - var record = this.record, - unsavedData = this.unsavedData; - - unsavedData[key] = value; - - record.hashWasUpdated(); - - return value; - }, - - commit: function() { - this.saveData(); - - this.record.notifyPropertyChange('data'); - }, - - rollback: function() { - this.unsavedData = {}; - - this.record.notifyPropertyChange('data'); - }, - - saveData: function() { - var record = this.record; - - var unsavedData = this.unsavedData; - var savedData = this.savedData(); - - for (var prop in unsavedData) { - if (unsavedData.hasOwnProperty(prop)) { - savedData[prop] = unsavedData[prop]; - delete unsavedData[prop]; - } - } - }, - - adapterDidUpdate: function() { - this.unsavedData = {}; - } -}; - -})(); - - - -(function() { -var get = Ember.get, set = Ember.set, none = Ember.none; +var get = Ember.get, set = Ember.set, none = Ember.isNone, map = Ember.EnumerableUtils.map; var retrieveFromCurrentState = Ember.computed(function(key) { return get(get(this, 'stateManager.currentState'), key); -}).property('stateManager.currentState').cacheable(); +}).property('stateManager.currentState'); -DS.Model = Ember.Object.extend(Ember.Evented, { +DS.Model = Ember.Object.extend(Ember.Evented, LoadPromise, { isLoaded: retrieveFromCurrentState, + isReloading: retrieveFromCurrentState, isDirty: retrieveFromCurrentState, isSaving: retrieveFromCurrentState, isDeleted: retrieveFromCurrentState, isError: retrieveFromCurrentState, isNew: retrieveFromCurrentState, - isPending: retrieveFromCurrentState, isValid: retrieveFromCurrentState, clientId: null, + id: null, transaction: null, stateManager: null, - pendingQueue: null, errors: null, - // because unknownProperty is used, any internal property - // must be initialized here. - primaryKey: 'id', - id: Ember.computed(function(key, value) { - var primaryKey = get(this, 'primaryKey'), - data = get(this, 'data'); - - if (arguments.length === 2) { - set(data, primaryKey, value); - return value; - } - - var id = get(data, primaryKey); - return id ? id : this._id; - }).property('primaryKey', 'data'), - - // The following methods are callbacks invoked by `toJSON`. You - // can override one of the callbacks to override specific behavior, - // or toJSON itself. - // - // If you override toJSON, you can invoke these callbacks manually - // to get the default behavior. - /** - Add the record's primary key to the JSON hash. + Create a JSON representation of the record, using the serialization + strategy of the store's adapter. - The default implementation uses the record's specified `primaryKey` - and the `id` computed property, which are passed in as parameters. + Available options: - @param {Object} json the JSON hash being built - @param {Number|String} id the record's id - @param {String} key the primaryKey for the record + * `includeId`: `true` if the record's ID should be included in the + JSON representation. + + @param {Object} options + @returns {Object} an object whose values are primitive JSON values only */ - addIdToJSON: function(json, id, key) { - if (id) { json[key] = id; } + serialize: function(options) { + var store = get(this, 'store'); + return store.serialize(this, options); }, - /** - Add the attributes' current values to the JSON hash. - - The default implementation gets the current value of each - attribute from the `data`, and uses a `defaultValue` if - specified in the `DS.attr` definition. - - @param {Object} json the JSON hash being build - @param {Ember.Map} attributes a Map of attributes - @param {DataProxy} data the record's data, accessed with `get` and `set`. - */ - addAttributesToJSON: function(json, attributes, data) { - attributes.forEach(function(name, meta) { - var key = meta.key(this.constructor), - value = get(data, key); - - if (value === undefined) { - value = meta.options.defaultValue; - } - - json[key] = value; - }, this); - }, - - /** - Add the value of a `hasMany` association to the JSON hash. - - The default implementation honors the `embedded` option - passed to `DS.hasMany`. If embedded, `toJSON` is recursively - called on the child records. If not, the `id` of each - record is added. - - Note that if a record is not embedded and does not - yet have an `id` (usually provided by the server), it - will not be included in the output. - - @param {Object} json the JSON hash being built - @param {DataProxy} data the record's data, accessed with `get` and `set`. - @param {Object} meta information about the association - @param {Object} options options passed to `toJSON` - */ - addHasManyToJSON: function(json, data, meta, options) { - var key = meta.key, - manyArray = get(this, key), - records = [], i, l, - clientId, id; - - if (meta.options.embedded) { - // TODO: Avoid materializing embedded hashes if possible - manyArray.forEach(function(record) { - records.push(record.toJSON(options)); - }); - } else { - var clientIds = get(manyArray, 'content'); - - for (i=0, l=clientIds.length; i')` from " + this.toString(), name !== 'id'); + + meta.name = name; + map.set(name, meta); + } }); return map; - }).cacheable(), + }) +}); - processAttributeKeys: function() { - if (this.processedAttributeKeys) { return; } +var AttributeChange = DS.AttributeChange = function(options) { + this.reference = options.reference; + this.store = options.store; + this.name = options.name; + this.oldValue = options.oldValue; +}; - var namingConvention = this.proto().namingConvention; +AttributeChange.createChange = function(options) { + return new AttributeChange(options); +}; - this.eachComputedProperty(function(name, meta) { - if (meta.isAttribute && !meta.options.key) { - meta.options.key = namingConvention.keyToJSONKey(name, this); - } - }, this); +AttributeChange.prototype = { + sync: function() { + this.store.recordAttributeDidChange(this.reference, this.name, this.value, this.oldValue); + + // TODO: Use this object in the commit process + this.destroy(); + }, + + destroy: function() { + delete this.store.recordForReference(this.reference)._changesToSync[this.name]; } +}; + +DS.Model.reopen({ + eachAttribute: function(callback, binding) { + get(this.constructor, 'attributes').forEach(function(name, meta) { + callback.call(binding, name, meta); + }, binding); + }, + + attributeWillChange: Ember.beforeObserver(function(record, key) { + var reference = get(record, '_reference'), + store = get(record, 'store'); + + record.send('willSetProperty', { reference: reference, store: store, name: key }); + }), + + attributeDidChange: Ember.observer(function(record, key) { + record.send('didSetProperty', { name: key }); + }) }); function getAttr(record, options, key) { - var data = get(record, 'data'); - var value = get(data, key); + var attributes = get(record, 'data').attributes; + var value = attributes[key]; if (value === undefined) { value = options.defaultValue; @@ -3231,92 +3933,2293 @@ function getAttr(record, options, key) { } DS.attr = function(type, options) { - var transform = DS.attr.transforms[type]; - Ember.assert("Could not find model attribute of type " + type, !!transform); - - var transformFrom = transform.from; - var transformTo = transform.to; - options = options || {}; var meta = { type: type, isAttribute: true, - options: options, - - // this will ensure that the key always takes naming - // conventions into consideration. - key: function(recordType) { - recordType.processAttributeKeys(); - return options.key; - } + options: options }; - return Ember.computed(function(key, value) { + return Ember.computed(function(key, value, oldValue) { var data; - if(arguments.length === 1 && key && this.constructor.isAttribute(key) && get(this, 'incomplete') && !this.isAttributeLoaded(key)) { - if(this.loadTheRest) { - this.loadTheRest(key); - } - } - - key = meta.key(this.constructor); - - if (arguments.length === 2) { - value = transformTo(value); - - if (value !== getAttr(this, options, key)) { - this.setProperty(key, value); - } + if (arguments.length > 1) { + Ember.assert("You may not set `id` as an attribute on your model. Please remove any lines that look like: `id: DS.attr('')` from " + this.constructor.toString(), key !== 'id'); } else { value = getAttr(this, options, key); } - return transformFrom(value); + return value; // `data` is never set directly. However, it may be // invalidated from the state manager's setData // event. - }).property('data').cacheable().meta(meta); + }).property('data').meta(meta); }; -DS.attr.transforms = { + +})(); + + + +(function() { + +})(); + + + +(function() { +var get = Ember.get, set = Ember.set, + none = Ember.isNone; + +DS.belongsTo = function(type, options) { + Ember.assert("The first argument DS.belongsTo must be a model type or string, like DS.belongsTo(App.Person)", !!type && (typeof type === 'string' || DS.Model.detect(type))); + + options = options || {}; + + var meta = { type: type, isRelationship: true, options: options, kind: 'belongsTo' }; + + return Ember.computed(function(key, value) { + if (arguments.length === 2) { + return value === undefined ? null : value; + } + + var data = get(this, 'data').belongsTo, + store = get(this, 'store'), id; + + if (typeof type === 'string') { + type = get(this, type, false) || get(Ember.lookup, type); + } + + id = data[key]; + + if(!id) { + return null; + } else if (typeof id === 'object') { + return store.recordForReference(id); + } else { + return store.find(type, id); + } + }).property('data').meta(meta); +}; + +/** + These observers observe all `belongsTo` relationships on the record. See + `relationships/ext` to see how these observers get their dependencies. + +*/ + +DS.Model.reopen({ + /** @private */ + belongsToWillChange: Ember.beforeObserver(function(record, key) { + if (get(record, 'isLoaded')) { + var oldParent = get(record, key); + + var childReference = get(record, '_reference'), + store = get(record, 'store'); + if (oldParent){ + var change = DS.RelationshipChange.createChange(childReference, get(oldParent, '_reference'), store, { key: key, kind:"belongsTo", changeType: "remove" }); + change.sync(); + this._changesToSync[key] = change; + } + } + }), + + /** @private */ + belongsToDidChange: Ember.immediateObserver(function(record, key) { + if (get(record, 'isLoaded')) { + var newParent = get(record, key); + if(newParent){ + var childReference = get(record, '_reference'), + store = get(record, 'store'); + var change = DS.RelationshipChange.createChange(childReference, get(newParent, '_reference'), store, { key: key, kind:"belongsTo", changeType: "add" }); + change.sync(); + if(this._changesToSync[key]){ + DS.OneToManyChange.ensureSameTransaction([change, this._changesToSync[key]], store); + } + } + } + delete this._changesToSync[key]; + }) +}); + +})(); + + + +(function() { +var get = Ember.get, set = Ember.set; +var hasRelationship = function(type, options) { + options = options || {}; + + var meta = { type: type, isRelationship: true, options: options, kind: 'hasMany' }; + + return Ember.computed(function(key, value) { + var data = get(this, 'data').hasMany, + store = get(this, 'store'), + ids, relationship; + + if (typeof type === 'string') { + type = get(this, type, false) || get(Ember.lookup, type); + } + + ids = data[key]; + relationship = store.findMany(type, ids || [], this, meta); + set(relationship, 'owner', this); + set(relationship, 'name', key); + + return relationship; + }).property().meta(meta); +}; + +DS.hasMany = function(type, options) { + Ember.assert("The type passed to DS.hasMany must be defined", !!type); + return hasRelationship(type, options); +}; + +})(); + + + +(function() { +var get = Ember.get, set = Ember.set; + +/** + @private + + This file defines several extensions to the base `DS.Model` class that + add support for one-to-many relationships. +*/ + +DS.Model.reopen({ + // This Ember.js hook allows an object to be notified when a property + // is defined. + // + // In this case, we use it to be notified when an Ember Data user defines a + // belongs-to relationship. In that case, we need to set up observers for + // each one, allowing us to track relationship changes and automatically + // reflect changes in the inverse has-many array. + // + // This hook passes the class being set up, as well as the key and value + // being defined. So, for example, when the user does this: + // + // DS.Model.extend({ + // parent: DS.belongsTo(App.User) + // }); + // + // This hook would be called with "parent" as the key and the computed + // property returned by `DS.belongsTo` as the value. + didDefineProperty: function(proto, key, value) { + // Check if the value being set is a computed property. + if (value instanceof Ember.Descriptor) { + + // If it is, get the metadata for the relationship. This is + // populated by the `DS.belongsTo` helper when it is creating + // the computed property. + var meta = value.meta(); + + if (meta.isRelationship && meta.kind === 'belongsTo') { + Ember.addObserver(proto, key, null, 'belongsToDidChange'); + Ember.addBeforeObserver(proto, key, null, 'belongsToWillChange'); + } + + if (meta.isAttribute) { + Ember.addObserver(proto, key, null, 'attributeDidChange'); + Ember.addBeforeObserver(proto, key, null, 'attributeWillChange'); + } + + meta.parentType = proto.constructor; + } + } +}); + +/** + These DS.Model extensions add class methods that provide relationship + introspection abilities about relationships. + + A note about the computed properties contained here: + + **These properties are effectively sealed once called for the first time.** + To avoid repeatedly doing expensive iteration over a model's fields, these + values are computed once and then cached for the remainder of the runtime of + your application. + + If your application needs to modify a class after its initial definition + (for example, using `reopen()` to add additional attributes), make sure you + do it before using your model with the store, which uses these properties + extensively. +*/ + +DS.Model.reopenClass({ + /** + For a given relationship name, returns the model type of the relationship. + + For example, if you define a model like this: + + App.Post = DS.Model.extend({ + comments: DS.hasMany(App.Comment) + }); + + Calling `App.Post.typeForRelationship('comments')` will return `App.Comment`. + + @param {String} name the name of the relationship + @return {subclass of DS.Model} the type of the relationship, or undefined + */ + typeForRelationship: function(name) { + var relationship = get(this, 'relationshipsByName').get(name); + return relationship && relationship.type; + }, + + /** + The model's relationships as a map, keyed on the type of the + relationship. The value of each entry is an array containing a descriptor + for each relationship with that type, describing the name of the relationship + as well as the type. + + For example, given the following model definition: + + App.Blog = DS.Model.extend({ + users: DS.hasMany(App.User), + owner: DS.belongsTo(App.User), + + posts: DS.hasMany(App.Post) + }); + + This computed property would return a map describing these + relationships, like this: + + var relationships = Ember.get(App.Blog, 'relationships'); + associatons.get(App.User); + //=> [ { name: 'users', kind: 'hasMany' }, + // { name: 'owner', kind: 'belongsTo' } ] + relationships.get(App.Post); + //=> [ { name: 'posts', kind: 'hasMany' } ] + + @type Ember.Map + @readOnly + */ + relationships: Ember.computed(function() { + var map = new Ember.MapWithDefault({ + defaultValue: function() { return []; } + }); + + // Loop through each computed property on the class + this.eachComputedProperty(function(name, meta) { + + // If the computed property is a relationship, add + // it to the map. + if (meta.isRelationship) { + if (typeof meta.type === 'string') { + meta.type = Ember.get(Ember.lookup, meta.type); + } + + var relationshipsForType = map.get(meta.type); + + relationshipsForType.push({ name: name, kind: meta.kind }); + } + }); + + return map; + }), + + /** + A hash containing lists of the model's relationships, grouped + by the relationship kind. For example, given a model with this + definition: + + App.Blog = DS.Model.extend({ + users: DS.hasMany(App.User), + owner: DS.belongsTo(App.User), + + posts: DS.hasMany(App.Post) + }); + + This property would contain the following: + + var relationshipNames = Ember.get(App.Blog, 'relationshipNames'); + relationshipNames.hasMany; + //=> ['users', 'posts'] + relationshipNames.belongsTo; + //=> ['owner'] + + @type Object + @readOnly + */ + relationshipNames: Ember.computed(function() { + var names = { hasMany: [], belongsTo: [] }; + + this.eachComputedProperty(function(name, meta) { + if (meta.isRelationship) { + names[meta.kind].push(name); + } + }); + + return names; + }), + + /** + A map whose keys are the relationships of a model and whose values are + relationship descriptors. + + For example, given a model with this + definition: + + App.Blog = DS.Model.extend({ + users: DS.hasMany(App.User), + owner: DS.belongsTo(App.User), + + posts: DS.hasMany(App.Post) + }); + + This property would contain the following: + + var relationshipsByName = Ember.get(App.Blog, 'relationshipsByName'); + relationshipsByName.get('users'); + //=> { key: 'users', kind: 'hasMany', type: App.User } + relationshipsByName.get('owner'); + //=> { key: 'owner', kind: 'belongsTo', type: App.User } + + @type Ember.Map + @readOnly + */ + relationshipsByName: Ember.computed(function() { + var map = Ember.Map.create(), type; + + this.eachComputedProperty(function(name, meta) { + if (meta.isRelationship) { + meta.key = name; + type = meta.type; + + if (typeof type === 'string') { + type = get(this, type, false) || get(Ember.lookup, type); + meta.type = type; + } + + map.set(name, meta); + } + }); + + return map; + }), + + /** + A map whose keys are the fields of the model and whose values are strings + describing the kind of the field. A model's fields are the union of all of its + attributes and relationships. + + For example: + + App.Blog = DS.Model.extend({ + users: DS.hasMany(App.User), + owner: DS.belongsTo(App.User), + + posts: DS.hasMany(App.Post), + + title: DS.attr('string') + }); + + var fields = Ember.get(App.Blog, 'fields'); + fields.forEach(function(field, kind) { + console.log(field, kind); + }); + + // prints: + // users, hasMany + // owner, belongsTo + // posts, hasMany + // title, attribute + + @type Ember.Map + @readOnly + */ + fields: Ember.computed(function() { + var map = Ember.Map.create(), type; + + this.eachComputedProperty(function(name, meta) { + if (meta.isRelationship) { + map.set(name, meta.kind); + } else if (meta.isAttribute) { + map.set(name, 'attribute'); + } + }); + + return map; + }), + + /** + Given a callback, iterates over each of the relationships in the model, + invoking the callback with the name of each relationship and its relationship + descriptor. + + @param {Function} callback the callback to invoke + @param {any} binding the value to which the callback's `this` should be bound + */ + eachRelationship: function(callback, binding) { + get(this, 'relationshipsByName').forEach(function(name, relationship) { + callback.call(binding, name, relationship); + }); + } +}); + +DS.Model.reopen({ + /** + Given a callback, iterates over each of the relationships in the model, + invoking the callback with the name of each relationship and its relationship + descriptor. + + @param {Function} callback the callback to invoke + @param {any} binding the value to which the callback's `this` should be bound + */ + eachRelationship: function(callback, binding) { + this.constructor.eachRelationship(callback, binding); + } +}); + +/** + @private + + Helper method to look up the name of the inverse of a relationship. + + In a has-many relationship, there are always two sides: the `belongsTo` side + and the `hasMany` side. When one side changes, the other side should be updated + automatically. + + Given a model, the model of the inverse, and the kind of the relationship, this + helper returns the name of the relationship on the inverse. + + For example, imagine the following two associated models: + + App.Post = DS.Model.extend({ + comments: DS.hasMany('App.Comment') + }); + + App.Comment = DS.Model.extend({ + post: DS.belongsTo('App.Post') + }); + + If the `post` property of a `Comment` was modified, Ember Data would invoke + this helper like this: + + DS._inverseNameFor(App.Comment, App.Post, 'hasMany'); + //=> 'comments' + + Ember Data uses the name of the relationship returned to reflect the changed + relationship on the other side. +*/ +DS._inverseRelationshipFor = function(modelType, inverseModelType) { + var relationshipMap = get(modelType, 'relationships'), + possibleRelationships = relationshipMap.get(inverseModelType), + possible, actual, oldValue; + + if (!possibleRelationships) { return; } + if (possibleRelationships.length > 1) { return; } + return possibleRelationships[0]; +}; + +/** + @private + + Given a model and a relationship name, returns the model type of + the named relationship. + + App.Post = DS.Model.extend({ + comments: DS.hasMany('App.Comment') + }); + + DS._inverseTypeFor(App.Post, 'comments'); + //=> App.Comment + @param {DS.Model class} modelType + @param {String} relationshipName + @return {DS.Model class} +*/ +DS._inverseTypeFor = function(modelType, relationshipName) { + var relationships = get(modelType, 'relationshipsByName'), + relationship = relationships.get(relationshipName); + + if (relationship) { return relationship.type; } +}; + +})(); + + + +(function() { +var get = Ember.get, set = Ember.set; +var forEach = Ember.EnumerableUtils.forEach; + +DS.RelationshipChange = function(options) { + this.parentReference = options.parentReference; + this.childReference = options.childReference; + this.firstRecordReference = options.firstRecordReference; + this.firstRecordKind = options.firstRecordKind; + this.firstRecordName = options.firstRecordName; + this.secondRecordReference = options.secondRecordReference; + this.secondRecordKind = options.secondRecordKind; + this.secondRecordName = options.secondRecordName; + this.store = options.store; + this.committed = {}; + this.changeType = options.changeType; +}; + +DS.RelationshipChangeAdd = function(options){ + DS.RelationshipChange.call(this, options); +}; + +DS.RelationshipChangeRemove = function(options){ + DS.RelationshipChange.call(this, options); +}; + +/** @private */ +DS.RelationshipChange.create = function(options) { + return new DS.RelationshipChange(options); +}; + +/** @private */ +DS.RelationshipChangeAdd.create = function(options) { + return new DS.RelationshipChangeAdd(options); +}; + +/** @private */ +DS.RelationshipChangeRemove.create = function(options) { + return new DS.RelationshipChangeRemove(options); +}; + +DS.OneToManyChange = {}; +DS.OneToNoneChange = {}; +DS.ManyToNoneChange = {}; +DS.OneToOneChange = {}; +DS.ManyToManyChange = {}; + +DS.RelationshipChange._createChange = function(options){ + if(options.changeType === "add"){ + return DS.RelationshipChangeAdd.create(options); + } + if(options.changeType === "remove"){ + return DS.RelationshipChangeRemove.create(options); + } +}; + + +DS.RelationshipChange.determineRelationshipType = function(recordType, knownSide){ + var knownKey = knownSide.key, key, type, otherContainerType,assoc; + var knownContainerType = knownSide.kind; + var options = recordType.metaForProperty(knownKey).options; + var otherType = DS._inverseTypeFor(recordType, knownKey); + + if(options.inverse){ + key = options.inverse; + otherContainerType = get(otherType, 'relationshipsByName').get(key).kind; + } + else if(assoc = DS._inverseRelationshipFor(otherType, recordType)){ + key = assoc.name; + otherContainerType = assoc.kind; + } + if(!key){ + return knownContainerType === "belongsTo" ? "oneToNone" : "manyToNone"; + } + else{ + if(otherContainerType === "belongsTo"){ + return knownContainerType === "belongsTo" ? "oneToOne" : "manyToOne"; + } + else{ + return knownContainerType === "belongsTo" ? "oneToMany" : "manyToMany"; + } + } + +}; + +DS.RelationshipChange.createChange = function(firstRecordReference, secondRecordReference, store, options){ + // Get the type of the child based on the child's client ID + var firstRecordType = firstRecordReference.type, key, changeType; + changeType = DS.RelationshipChange.determineRelationshipType(firstRecordType, options); + if (changeType === "oneToMany"){ + return DS.OneToManyChange.createChange(firstRecordReference, secondRecordReference, store, options); + } + else if (changeType === "manyToOne"){ + return DS.OneToManyChange.createChange(secondRecordReference, firstRecordReference, store, options); + } + else if (changeType === "oneToNone"){ + return DS.OneToNoneChange.createChange(firstRecordReference, secondRecordReference, store, options); + } + else if (changeType === "manyToNone"){ + return DS.ManyToNoneChange.createChange(firstRecordReference, secondRecordReference, store, options); + } + else if (changeType === "oneToOne"){ + return DS.OneToOneChange.createChange(firstRecordReference, secondRecordReference, store, options); + } + else if (changeType === "manyToMany"){ + return DS.ManyToManyChange.createChange(firstRecordReference, secondRecordReference, store, options); + } +}; + +/** @private */ +DS.OneToNoneChange.createChange = function(childReference, parentReference, store, options) { + var key = options.key; + var change = DS.RelationshipChange._createChange({ + parentReference: parentReference, + childReference: childReference, + firstRecordReference: childReference, + store: store, + changeType: options.changeType, + firstRecordName: key, + firstRecordKind: "belongsTo" + }); + + store.addRelationshipChangeFor(childReference, key, parentReference, null, change); + + return change; +}; + +/** @private */ +DS.ManyToNoneChange.createChange = function(childReference, parentReference, store, options) { + var key = options.key; + var change = DS.RelationshipChange._createChange({ + parentReference: childReference, + childReference: parentReference, + secondRecordReference: childReference, + store: store, + changeType: options.changeType, + secondRecordName: options.key, + secondRecordKind: "hasMany" + }); + + store.addRelationshipChangeFor(childReference, key, parentReference, null, change); + return change; +}; + + +/** @private */ +DS.ManyToManyChange.createChange = function(childReference, parentReference, store, options) { + // Get the type of the child based on the child's client ID + var childType = childReference.type, key; + + // If the name of the belongsTo side of the relationship is specified, + // use that + // If the type of the parent is specified, look it up on the child's type + // definition. + key = options.key; + + var change = DS.RelationshipChange._createChange({ + parentReference: parentReference, + childReference: childReference, + firstRecordReference: childReference, + secondRecordReference: parentReference, + firstRecordKind: "hasMany", + secondRecordKind: "hasMany", + store: store, + changeType: options.changeType, + firstRecordName: key + }); + + store.addRelationshipChangeFor(childReference, key, parentReference, null, change); + + + return change; +}; + +/** @private */ +DS.OneToOneChange.createChange = function(childReference, parentReference, store, options) { + // Get the type of the child based on the child's client ID + var childType = childReference.type, key; + + // If the name of the belongsTo side of the relationship is specified, + // use that + // If the type of the parent is specified, look it up on the child's type + // definition. + if (options.parentType) { + key = inverseBelongsToName(options.parentType, childType, options.key); + //DS.OneToOneChange.maintainInvariant( options, store, childReference, key ); + } else if (options.key) { + key = options.key; + } else { + Ember.assert("You must pass either a parentType or belongsToName option to OneToManyChange.forChildAndParent", false); + } + + var change = DS.RelationshipChange._createChange({ + parentReference: parentReference, + childReference: childReference, + firstRecordReference: childReference, + secondRecordReference: parentReference, + firstRecordKind: "belongsTo", + secondRecordKind: "belongsTo", + store: store, + changeType: options.changeType, + firstRecordName: key + }); + + store.addRelationshipChangeFor(childReference, key, parentReference, null, change); + + + return change; +}; + +DS.OneToOneChange.maintainInvariant = function(options, store, childReference, key){ + if (options.changeType === "add" && store.recordIsMaterialized(childReference)) { + var child = store.recordForReference(childReference); + var oldParent = get(child, key); + if (oldParent){ + var correspondingChange = DS.OneToOneChange.createChange(childReference, oldParent.get('_reference'), store, { + parentType: options.parentType, + hasManyName: options.hasManyName, + changeType: "remove", + key: options.key + }); + store.addRelationshipChangeFor(childReference, key, options.parentReference , null, correspondingChange); + correspondingChange.sync(); + } + } +}; + +/** @private */ +DS.OneToManyChange.createChange = function(childReference, parentReference, store, options) { + // Get the type of the child based on the child's client ID + var childType = childReference.type, key; + + // If the name of the belongsTo side of the relationship is specified, + // use that + // If the type of the parent is specified, look it up on the child's type + // definition. + if (options.parentType) { + key = inverseBelongsToName(options.parentType, childType, options.key); + DS.OneToManyChange.maintainInvariant( options, store, childReference, key ); + } else if (options.key) { + key = options.key; + } else { + Ember.assert("You must pass either a parentType or belongsToName option to OneToManyChange.forChildAndParent", false); + } + + var change = DS.RelationshipChange._createChange({ + parentReference: parentReference, + childReference: childReference, + firstRecordReference: childReference, + secondRecordReference: parentReference, + firstRecordKind: "belongsTo", + secondRecordKind: "hasMany", + store: store, + changeType: options.changeType, + firstRecordName: key + }); + + store.addRelationshipChangeFor(childReference, key, parentReference, null, change); + + + return change; +}; + + +DS.OneToManyChange.maintainInvariant = function(options, store, childReference, key){ + if (options.changeType === "add" && store.recordIsMaterialized(childReference)) { + var child = store.recordForReference(childReference); + var oldParent = get(child, key); + if (oldParent){ + var correspondingChange = DS.OneToManyChange.createChange(childReference, oldParent.get('_reference'), store, { + parentType: options.parentType, + hasManyName: options.hasManyName, + changeType: "remove", + key: options.key + }); + store.addRelationshipChangeFor(childReference, key, options.parentReference , null, correspondingChange); + correspondingChange.sync(); + } + } +}; + +DS.OneToManyChange.ensureSameTransaction = function(changes, store){ + var records = Ember.A(); + forEach(changes, function(change){ + records.addObject(change.getSecondRecord()); + records.addObject(change.getFirstRecord()); + }); + var transaction = store.ensureSameTransaction(records); + forEach(changes, function(change){ + change.transaction = transaction; + }); +}; + +DS.RelationshipChange.prototype = { + + getSecondRecordName: function() { + var name = this.secondRecordName, store = this.store, parent; + + if (!name) { + parent = this.secondRecordReference; + if (!parent) { return; } + + var childType = this.firstRecordReference.type; + var inverseType = DS._inverseTypeFor(childType, this.firstRecordName); + name = inverseHasManyName(inverseType, childType, this.firstRecordName); + this.secondRecordName = name; + } + + return name; + }, + + /** + Get the name of the relationship on the belongsTo side. + + @returns {String} + */ + getFirstRecordName: function() { + var name = this.firstRecordName, store = this.store, parent, child; + + if (!name) { + parent = this.secondRecordReference; + child = this.firstRecordReference; + if (!(child && parent)) { return; } + + name = DS._inverseRelationshipFor(child.type, parent.type).name; + + this.firstRecordName = name; + } + + return name; + }, + + /** @private */ + destroy: function() { + var childReference = this.childReference, + belongsToName = this.getFirstRecordName(), + hasManyName = this.getSecondRecordName(), + store = this.store, + child, oldParent, newParent, lastParent, transaction; + + store.removeRelationshipChangeFor(childReference, belongsToName, this.parentReference, hasManyName, this.changeType); + + if (transaction = this.transaction) { + transaction.relationshipBecameClean(this); + } + }, + + /** @private */ + getByReference: function(reference) { + var store = this.store; + + // return null or undefined if the original reference was null or undefined + if (!reference) { return reference; } + + if (store.recordIsMaterialized(reference)) { + return store.recordForReference(reference); + } + }, + + getSecondRecord: function(){ + return this.getByReference(this.secondRecordReference); + }, + + /** @private */ + getFirstRecord: function() { + return this.getByReference(this.firstRecordReference); + }, + + /** + @private + + Make sure that all three parts of the relationship change are part of + the same transaction. If any of the three records is clean and in the + default transaction, and the rest are in a different transaction, move + them all into that transaction. + */ + ensureSameTransaction: function() { + var child = this.getFirstRecord(), + parentRecord = this.getSecondRecord(); + + var transaction = this.store.ensureSameTransaction([child, parentRecord]); + + this.transaction = transaction; + return transaction; + }, + + callChangeEvents: function(){ + var hasManyName = this.getSecondRecordName(), + belongsToName = this.getFirstRecordName(), + child = this.getFirstRecord(), + parentRecord = this.getSecondRecord(); + + var dirtySet = new Ember.OrderedSet(); + + // TODO: This implementation causes a race condition in key-value + // stores. The fix involves buffering changes that happen while + // a record is loading. A similar fix is required for other parts + // of ember-data, and should be done as new infrastructure, not + // a one-off hack. [tomhuda] + if (parentRecord && get(parentRecord, 'isLoaded')) { + this.store.recordHasManyDidChange(dirtySet, parentRecord, this); + } + + if (child) { + this.store.recordBelongsToDidChange(dirtySet, child, this); + } + + dirtySet.forEach(function(record) { + record.adapterDidDirty(); + }); + }, + + coalesce: function(){ + var relationshipPairs = this.store.relationshipChangePairsFor(this.firstRecordReference); + forEach(relationshipPairs, function(pair){ + var addedChange = pair["add"]; + var removedChange = pair["remove"]; + if(addedChange && removedChange) { + addedChange.destroy(); + removedChange.destroy(); + } + }); + } +}; + +DS.RelationshipChangeAdd.prototype = Ember.create(DS.RelationshipChange.create({})); +DS.RelationshipChangeRemove.prototype = Ember.create(DS.RelationshipChange.create({})); + +DS.RelationshipChangeAdd.prototype.changeType = "add"; +DS.RelationshipChangeAdd.prototype.sync = function() { + var secondRecordName = this.getSecondRecordName(), + firstRecordName = this.getFirstRecordName(), + firstRecord = this.getFirstRecord(), + secondRecord = this.getSecondRecord(); + + //Ember.assert("You specified a hasMany (" + hasManyName + ") on " + (!belongsToName && (newParent || oldParent || this.lastParent).constructor) + " but did not specify an inverse belongsTo on " + child.constructor, belongsToName); + //Ember.assert("You specified a belongsTo (" + belongsToName + ") on " + child.constructor + " but did not specify an inverse hasMany on " + (!hasManyName && (newParent || oldParent || this.lastParentRecord).constructor), hasManyName); + + var transaction = this.ensureSameTransaction(); + transaction.relationshipBecameDirty(this); + + this.callChangeEvents(); + + if (secondRecord && firstRecord) { + if(this.secondRecordKind === "belongsTo"){ + secondRecord.suspendRelationshipObservers(function(){ + set(secondRecord, secondRecordName, firstRecord); + }); + + } + else if(this.secondRecordKind === "hasMany"){ + secondRecord.suspendRelationshipObservers(function(){ + get(secondRecord, secondRecordName).addObject(firstRecord); + }); + } + } + + if (firstRecord && secondRecord && get(firstRecord, firstRecordName) !== secondRecord) { + if(this.firstRecordKind === "belongsTo"){ + firstRecord.suspendRelationshipObservers(function(){ + set(firstRecord, firstRecordName, secondRecord); + }); + } + else if(this.firstdRecordKind === "hasMany"){ + firstRecord.suspendRelationshipObservers(function(){ + get(firstRecord, firstRecordName).addObject(secondRecord); + }); + } + } + + this.coalesce(); +}; + +DS.RelationshipChangeRemove.prototype.changeType = "remove"; +DS.RelationshipChangeRemove.prototype.sync = function() { + var secondRecordName = this.getSecondRecordName(), + firstRecordName = this.getFirstRecordName(), + firstRecord = this.getFirstRecord(), + secondRecord = this.getSecondRecord(); + + //Ember.assert("You specified a hasMany (" + hasManyName + ") on " + (!belongsToName && (newParent || oldParent || this.lastParent).constructor) + " but did not specify an inverse belongsTo on " + child.constructor, belongsToName); + //Ember.assert("You specified a belongsTo (" + belongsToName + ") on " + child.constructor + " but did not specify an inverse hasMany on " + (!hasManyName && (newParent || oldParent || this.lastParentRecord).constructor), hasManyName); + + var transaction = this.ensureSameTransaction(firstRecord, secondRecord, secondRecordName, firstRecordName); + transaction.relationshipBecameDirty(this); + + this.callChangeEvents(); + + if (secondRecord && firstRecord) { + if(this.secondRecordKind === "belongsTo"){ + set(secondRecord, secondRecordName, null); + } + else if(this.secondRecordKind === "hasMany"){ + secondRecord.suspendRelationshipObservers(function(){ + get(secondRecord, secondRecordName).removeObject(firstRecord); + }); + } + } + + if (firstRecord && get(firstRecord, firstRecordName)) { + if(this.firstRecordKind === "belongsTo"){ + firstRecord.suspendRelationshipObservers(function(){ + set(firstRecord, firstRecordName, null); + }); + } + else if(this.firstdRecordKind === "hasMany"){ + firstRecord.suspendRelationshipObservers(function(){ + get(firstRecord, firstRecordName).removeObject(secondRecord); + }); + } + } + + this.coalesce(); +}; + +function inverseBelongsToName(parentType, childType, hasManyName) { + // Get the options passed to the parent's DS.hasMany() + var options = parentType.metaForProperty(hasManyName).options; + var belongsToName; + + if (belongsToName = options.inverse) { + return belongsToName; + } + + return DS._inverseRelationshipFor(childType, parentType).name; +} + +function inverseHasManyName(parentType, childType, belongsToName) { + var options = childType.metaForProperty(belongsToName).options; + var hasManyName; + + if (hasManyName = options.inverse) { + return hasManyName; + } + + return DS._inverseRelationshipFor(parentType, childType).name; +} + +})(); + + + +(function() { + +})(); + + + +(function() { +var set = Ember.set; + +/** + This code registers an injection for Ember.Application. + + If an Ember.js developer defines a subclass of DS.Store on their application, + this code will automatically instantiate it and make it available on the + router. + + Additionally, after an application's controllers have been injected, they will + each have the store made available to them. + + For example, imagine an Ember.js application with the following classes: + + App.Store = DS.Store.extend({ + adapter: 'App.MyCustomAdapter' + }); + + App.PostsController = Ember.ArrayController.extend({ + // ... + }); + + When the application is initialized, `App.Store` will automatically be + instantiated, and the instance of `App.PostsController` will have its `store` + property set to that instance. + + Note that this code will only be run if the `ember-application` package is + loaded. If Ember Data is being used in an environment other than a + typical application (e.g., node.js where only `ember-runtime` is available), + this code will be ignored. +*/ + +Ember.onLoad('Ember.Application', function(Application) { + if (Application.registerInjection) { + Application.registerInjection({ + name: "store", + before: "controllers", + + // If a store subclass is defined, like App.Store, + // instantiate it and inject it into the router. + injection: function(app, stateManager, property) { + if (!stateManager) { return; } + if (property === 'Store') { + set(stateManager, 'store', app[property].create()); + } + } + }); + + Application.registerInjection({ + name: "giveStoreToControllers", + after: ['store','controllers'], + + // For each controller, set its `store` property + // to the DS.Store instance we created above. + injection: function(app, stateManager, property) { + if (!stateManager) { return; } + if (/^[A-Z].*Controller$/.test(property)) { + var controllerName = property.charAt(0).toLowerCase() + property.substr(1); + var store = stateManager.get('store'); + var controller = stateManager.get(controllerName); + if(!controller) { return; } + + controller.set('store', store); + } + } + }); + } else if (Application.initializer) { + Application.initializer({ + name: "store", + + initialize: function(container, application) { + container.register('store', 'main', application.Store); + + // Eagerly generate the store so defaultStore is populated. + // TODO: Do this in a finisher hook + container.lookup('store:main'); + } + }); + + Application.initializer({ + name: "injectStore", + + initialize: function(container) { + container.typeInjection('controller', 'store', 'store:main'); + container.typeInjection('route', 'store', 'store:main'); + } + }); + } +}); + +})(); + + + +(function() { +var get = Ember.get, set = Ember.set, map = Ember.ArrayPolyfills.map, isNone = Ember.isNone; + +function mustImplement(name) { + return function() { + throw new Ember.Error("Your serializer " + this.toString() + " does not implement the required method " + name); + }; +} + +/** + A serializer is responsible for serializing and deserializing a group of + records. + + `DS.Serializer` is an abstract base class designed to help you build a + serializer that can read to and write from any serialized form. While most + applications will use `DS.JSONSerializer`, which reads and writes JSON, the + serializer architecture allows your adapter to transmit things like XML, + strings, or custom binary data. + + Typically, your application's `DS.Adapter` is responsible for both creating a + serializer as well as calling the appropriate methods when it needs to + materialize data or serialize a record. + + The serializer API is designed as a series of layered hooks that you can + override to customize any of the individual steps of serialization and + deserialization. + + The hooks are organized by the three responsibilities of the serializer: + + 1. Determining naming conventions + 2. Serializing records into a serialized form + 3. Deserializing records from a serialized form + + Because Ember Data lazily materializes records, the deserialization + step, and therefore the hooks you implement, are split into two phases: + + 1. Extraction, where the serialized forms for multiple records are + extracted from a single payload. The IDs of each record are also + extracted for indexing. + 2. Materialization, where a newly-created record has its attributes + and relationships initialized based on the serialized form loaded + by the adapter. + + Additionally, a serializer can convert values from their JavaScript + versions into their serialized versions via a declarative API. + + ## Naming Conventions + + One of the most common uses of the serializer is to map attribute names + from the serialized form to your `DS.Model`. For example, in your model, + you may have an attribute called `firstName`: + + ```javascript + App.Person = DS.Model.extend({ + firstName: DS.attr('string') + }); + ``` + + However, because the web API your adapter is communicating with is + legacy, it calls this attribute `FIRST_NAME`. + + You can determine the attribute name used in the serialized form + by implementing `keyForAttributeName`: + + ```javascript + keyForAttributeName: function(type, name) { + return name.underscore.toUpperCase(); + } + ``` + + If your attribute names are not predictable, you can re-map them + one-by-one using the `map` API: + + ```javascript + App.Person.map('App.Person', { + firstName: { key: '*API_USER_FIRST_NAME*' } + }); + ``` + + ## Serialization + + During the serialization process, a record or records are converted + from Ember.js objects into their serialized form. + + These methods are designed in layers, like a delicious 7-layer + cake (but with fewer layers). + + The main entry point for serialization is the `serialize` + method, which takes the record and options. + + The `serialize` method is responsible for: + + * turning the record's attributes (`DS.attr`) into + attributes on the JSON object. + * optionally adding the record's ID onto the hash + * adding relationships (`DS.hasMany` and `DS.belongsTo`) + to the JSON object. + + Depending on the backend, the serializer can choose + whether to include the `hasMany` or `belongsTo` + relationships on the JSON hash. + + For very custom serialization, you can implement your + own `serialize` method. In general, however, you will want + to override the hooks described below. + + ### Adding the ID + + The default `serialize` will optionally call your serializer's + `addId` method with the JSON hash it is creating, the + record's type, and the record's ID. The `serialize` method + will not call `addId` if the record's ID is undefined. + + Your adapter must specifically request ID inclusion by + passing `{ includeId: true }` as an option to `serialize`. + + NOTE: You may not want to include the ID when updating an + existing record, because your server will likely disallow + changing an ID after it is created, and the PUT request + itself will include the record's identification. + + By default, `addId` will: + + 1. Get the primary key name for the record by calling + the serializer's `primaryKey` with the record's type. + Unless you override the `primaryKey` method, this + will be `'id'`. + 2. Assign the record's ID to the primary key in the + JSON hash being built. + + If your backend expects a JSON object with the primary + key at the root, you can just override the `primaryKey` + method on your serializer subclass. + + Otherwise, you can override the `addId` method for + more specialized handling. + + ### Adding Attributes + + By default, the serializer's `serialize` method will call + `addAttributes` with the JSON object it is creating + and the record to serialize. + + The `addAttributes` method will then call `addAttribute` + in turn, with the JSON object, the record to serialize, + the attribute's name and its type. + + Finally, the `addAttribute` method will serialize the + attribute: + + 1. It will call `keyForAttributeName` to determine + the key to use in the JSON hash. + 2. It will get the value from the record. + 3. It will call `serializeValue` with the attribute's + value and attribute type to convert it into a + JSON-compatible value. For example, it will convert a + Date into a String. + + If your backend expects a JSON object with attributes as + keys at the root, you can just override the `serializeValue` + and `keyForAttributeName` methods in your serializer + subclass and let the base class do the heavy lifting. + + If you need something more specialized, you can probably + override `addAttribute` and let the default `addAttributes` + handle the nitty gritty. + + ### Adding Relationships + + By default, `serialize` will call your serializer's + `addRelationships` method with the JSON object that is + being built and the record being serialized. The default + implementation of this method is to loop over all of the + relationships defined on your record type and: + + * If the relationship is a `DS.hasMany` relationship, + call `addHasMany` with the JSON object, the record + and a description of the relationship. + * If the relationship is a `DS.belongsTo` relationship, + call `addBelongsTo` with the JSON object, the record + and a description of the relationship. + + The relationship description has the following keys: + + * `type`: the class of the associated information (the + first parameter to `DS.hasMany` or `DS.belongsTo`) + * `kind`: either `hasMany` or `belongsTo` + + The relationship description may get additional + information in the future if more capabilities or + relationship types are added. However, it will + remain backwards-compatible, so the mere existence + of new features should not break existing adapters. +*/ +DS.Serializer = Ember.Object.extend({ + init: function() { + this.mappings = Ember.Map.create(); + this.configurations = Ember.Map.create(); + this.globalConfigurations = {}; + }, + + extract: mustImplement('extract'), + extractMany: mustImplement('extractMany'), + + extractRecordRepresentation: function(loader, type, json, shouldSideload) { + var mapping = this.mappingForType(type); + var embeddedData, prematerialized = {}, reference; + + if (shouldSideload) { + reference = loader.sideload(type, json); + } else { + reference = loader.load(type, json); + } + + this.eachEmbeddedHasMany(type, function(name, relationship) { + var embeddedData = json[this.keyFor(relationship)]; + if (!isNone(embeddedData)) { + this.extractEmbeddedHasMany(loader, relationship, embeddedData, reference, prematerialized); + } + }, this); + + this.eachEmbeddedBelongsTo(type, function(name, relationship) { + var embeddedData = json[this.keyFor(relationship)]; + if (!isNone(embeddedData)) { + this.extractEmbeddedBelongsTo(loader, relationship, embeddedData, reference, prematerialized); + } + }, this); + + loader.prematerialize(reference, prematerialized); + + return reference; + }, + + extractEmbeddedHasMany: function(loader, relationship, array, parent, prematerialized) { + var references = map.call(array, function(item) { + if (!item) { return; } + + var reference = this.extractRecordRepresentation(loader, relationship.type, item, true); + + // If the embedded record should also be saved back when serializing the parent, + // make sure we set its parent since it will not have an ID. + var embeddedType = this.embeddedType(parent.type, relationship.key); + if (embeddedType === 'always') { + reference.parent = parent; + } + + return reference; + }, this); + + prematerialized[relationship.key] = references; + }, + + extractEmbeddedBelongsTo: function(loader, relationship, data, parent, prematerialized) { + var reference = this.extractRecordRepresentation(loader, relationship.type, data, true); + prematerialized[relationship.key] = reference; + + // If the embedded record should also be saved back when serializing the parent, + // make sure we set its parent since it will not have an ID. + var embeddedType = this.embeddedType(parent.type, relationship.key); + if (embeddedType === 'always') { + reference.parent = parent; + } + }, + + //....................... + //. SERIALIZATION HOOKS + //....................... + + /** + The main entry point for serializing a record. While you can consider this + a hook that can be overridden in your serializer, you will have to manually + handle serialization. For most cases, there are more granular hooks that you + can override. + + If overriding this method, these are the responsibilities that you will need + to implement yourself: + + * If the option hash contains `includeId`, add the record's ID to the serialized form. + By default, `serialize` calls `addId` if appropriate. + * Add the record's attributes to the serialized form. By default, `serialize` calls + `addAttributes`. + * Add the record's relationships to the serialized form. By default, `serialize` calls + `addRelationships`. + + @param {DS.Model} record the record to serialize + @param {Object} [options] a hash of options + @returns {any} the serialized form of the record + */ + serialize: function(record, options) { + options = options || {}; + + var serialized = this.createSerializedForm(), id; + + if (options.includeId) { + if (id = get(record, 'id')) { + this._addId(serialized, record.constructor, id); + } + } + + this.addAttributes(serialized, record); + this.addRelationships(serialized, record); + + return serialized; + }, + + /** + @private + + Given an attribute type and value, convert the value into the + serialized form using the transform registered for that type. + + @param {any} value the value to convert to the serialized form + @param {String} attributeType the registered type (e.g. `string` + or `boolean`) + @returns {any} the serialized form of the value + */ + serializeValue: function(value, attributeType) { + var transform = this.transforms ? this.transforms[attributeType] : null; + + Ember.assert("You tried to use an attribute type (" + attributeType + ") that has not been registered", transform); + return transform.serialize(value); + }, + + /** + A hook you can use to normalize IDs before adding them to the + serialized representation. + + Because the store coerces all IDs to strings for consistency, + this is the opportunity for the serializer to, for example, + convert numerical IDs back into number form. + + @param {String} id the id from the record + @returns {any} the serialized representation of the id + */ + serializeId: function(id) { + if (isNaN(id)) { return id; } + return +id; + }, + + /** + A hook you can use to change how attributes are added to the serialized + representation of a record. + + By default, `addAttributes` simply loops over all of the attributes of the + passed record, maps the attribute name to the key for the serialized form, + and invokes any registered transforms on the value. It then invokes the + more granular `addAttribute` with the key and transformed value. + + Since you can override `keyForAttributeName`, `addAttribute`, and register + custom tranforms, you should rarely need to override this hook. + + @param {any} data the serialized representation that is being built + @param {DS.Model} record the record to serialize + */ + addAttributes: function(data, record) { + record.eachAttribute(function(name, attribute) { + this._addAttribute(data, record, name, attribute.type); + }, this); + }, + + /** + A hook you can use to customize how the key/value pair is added to + the serialized data. + + @param {any} serialized the serialized form being built + @param {String} key the key to add to the serialized data + @param {any} value the value to add to the serialized data + */ + addAttribute: Ember.K, + + /** + A hook you can use to customize how the record's id is added to + the serialized data. + + The `addId` hook is called with: + + * the serialized representation being built + * the resolved primary key (taking configurations and the + `primaryKey` hook into consideration) + * the serialized id (after calling the `serializeId` hook) + + @param {any} data the serialized representation that is being built + @param {String} key the resolved primary key + @param {id} id the serialized id + */ + addId: Ember.K, + + /** + A hook you can use to change how relationships are added to the serialized + representation of a record. + + By default, `addAttributes` loops over all of the relationships of the + passed record, maps the relationship names to the key for the serialized form, + and then invokes the public `addBelongsTo` and `addHasMany` hooks. + + Since you can override `keyForBelongsTo`, `keyForHasMany`, `addBelongsTo`, + `addHasMany`, and register mappings, you should rarely need to override this + hook. + + @param {any} data the serialized representation that is being built + @param {DS.Model} record the record to serialize + */ + addRelationships: function(data, record) { + record.eachRelationship(function(name, relationship) { + if (relationship.kind === 'belongsTo') { + this._addBelongsTo(data, record, name, relationship); + } else if (relationship.kind === 'hasMany') { + this._addHasMany(data, record, name, relationship); + } + }, this); + }, + + /** + A hook you can use to add a `belongsTo` relationship to the + serialized representation. + + The specifics of this hook are very adapter-specific, so there + is no default implementation. You can see `DS.JSONSerializer` + for an example of an implementation of the `addBelongsTo` hook. + + The `belongsTo` relationship object has the following properties: + + * **type** a subclass of DS.Model that is the type of the + relationship. This is the first parameter to DS.belongsTo + * **options** the options passed to the call to DS.belongsTo + * **kind** always `belongsTo` + + Additional properties may be added in the future. + + @param {any} data the serialized representation that is being built + @param {DS.Model} record the record to serialize + @param {String} key the key for the serialized object + @param {Object} relationship an object representing the relationship + */ + addBelongsTo: Ember.K, + + /** + A hook you can use to add a `hasMany` relationship to the + serialized representation. + + The specifics of this hook are very adapter-specific, so there + is no default implementation. You may not need to implement this, + for example, if your backend only expects relationships on the + child of a one to many relationship. + + The `hasMany` relationship object has the following properties: + + * **type** a subclass of DS.Model that is the type of the + relationship. This is the first parameter to DS.hasMany + * **options** the options passed to the call to DS.hasMany + * **kind** always `hasMany` + + Additional properties may be added in the future. + + @param {any} data the serialized representation that is being built + @param {DS.Model} record the record to serialize + @param {String} key the key for the serialized object + @param {Object} relationship an object representing the relationship + */ + addHasMany: Ember.K, + + /** + NAMING CONVENTIONS + + The most commonly overridden APIs of the serializer are + the naming convention methods: + + * `keyForAttributeName`: converts a camelized attribute name + into a key in the adapter-provided data hash. For example, + if the model's attribute name was `firstName`, and the + server used underscored names, you would return `first_name`. + * `primaryKey`: returns the key that should be used to + extract the id from the adapter-provided data hash. It is + also used when serializing a record. + */ + + /** + A hook you can use in your serializer subclass to customize + how an unmapped attribute name is converted into a key. + + By default, this method returns the `name` parameter. + + For example, if the attribute names in your JSON are underscored, + you will want to convert them into JavaScript conventional + camelcase: + + ```javascript + App.MySerializer = DS.Serializer.extend({ + // ... + + keyForAttributeName: function(type, name) { + return name.camelize(); + } + }); + ``` + + @param {DS.Model subclass} type the type of the record with + the attribute name `name` + @param {String} name the attribute name to convert into a key + + @returns {String} the key + */ + keyForAttributeName: function(type, name) { + return name; + }, + + /** + A hook you can use in your serializer to specify a conventional + primary key. + + By default, this method will return the string `id`. + + In general, you should not override this hook to specify a special + primary key for an individual type; use `configure` instead. + + For example, if your primary key is always `__id__`: + + ```javascript + App.MySerializer = DS.Serializer.extend({ + // ... + primaryKey: function(type) { + return '__id__'; + } + }); + ``` + + In another example, if the primary key always includes the + underscored version of the type before the string `id`: + + ```javascript + App.MySerializer = DS.Serializer.extend({ + // ... + primaryKey: function(type) { + // If the type is `BlogPost`, this will return + // `blog_post_id`. + var typeString = type.toString.split(".")[1].underscore(); + return typeString + "_id"; + } + }); + ``` + + @param {DS.Model subclass} type + @returns {String} the primary key for the type + */ + primaryKey: function(type) { + return "id"; + }, + + /** + A hook you can use in your serializer subclass to customize + how an unmapped `belongsTo` relationship is converted into + a key. + + By default, this method calls `keyForAttributeName`, so if + your naming convention is uniform across attributes and + relationships, you can use the default here and override + just `keyForAttributeName` as needed. + + For example, if the `belongsTo` names in your JSON always + begin with `BT_` (e.g. `BT_posts`), you can strip out the + `BT_` prefix:" + + ```javascript + App.MySerializer = DS.Serializer.extend({ + // ... + keyForBelongsTo: function(type, name) { + return name.match(/^BT_(.*)$/)[1].camelize(); + } + }); + ``` + + @param {DS.Model subclass} type the type of the record with + the `belongsTo` relationship. + @param {String} name the relationship name to convert into a key + + @returns {String} the key + */ + keyForBelongsTo: function(type, name) { + return this.keyForAttributeName(type, name); + }, + + /** + A hook you can use in your serializer subclass to customize + how an unmapped `hasMany` relationship is converted into + a key. + + By default, this method calls `keyForAttributeName`, so if + your naming convention is uniform across attributes and + relationships, you can use the default here and override + just `keyForAttributeName` as needed. + + For example, if the `hasMany` names in your JSON always + begin with the "table name" for the current type (e.g. + `post_comments`), you can strip out the prefix:" + + ```javascript + App.MySerializer = DS.Serializer.extend({ + // ... + keyForHasMany: function(type, name) { + // if your App.BlogPost has many App.BlogComment, the key from + // the server would look like: `blog_post_blog_comments` + // + // 1. Convert the type into a string and underscore the + // second part (App.BlogPost -> blog_post) + // 2. Extract the part after `blog_post_` (`blog_comments`) + // 3. Underscore it, to become `blogComments` + var typeString = type.toString().split(".")[1].underscore(); + return name.match(new RegExp("^" + typeString + "_(.*)$"))[1].camelize(); + } + }); + ``` + + @param {DS.Model subclass} type the type of the record with + the `belongsTo` relationship. + @param {String} name the relationship name to convert into a key + + @returns {String} the key + */ + keyForHasMany: function(type, name) { + return this.keyForAttributeName(type, name); + }, + + //......................... + //. MATERIALIZATION HOOKS + //......................... + + materialize: function(record, serialized, prematerialized) { + var id; + if (Ember.isNone(get(record, 'id'))) { + if (prematerialized && prematerialized.hasOwnProperty('id')) { + id = prematerialized.id; + } else { + id = this.extractId(record.constructor, serialized); + } + record.materializeId(id); + } + + this.materializeAttributes(record, serialized, prematerialized); + this.materializeRelationships(record, serialized, prematerialized); + }, + + deserializeValue: function(value, attributeType) { + var transform = this.transforms ? this.transforms[attributeType] : null; + + Ember.assert("You tried to use a attribute type (" + attributeType + ") that has not been registered", transform); + return transform.deserialize(value); + }, + + materializeAttributes: function(record, serialized, prematerialized) { + record.eachAttribute(function(name, attribute) { + if (prematerialized && prematerialized.hasOwnProperty(name)) { + record.materializeAttribute(name, prematerialized[name]); + } else { + this.materializeAttribute(record, serialized, name, attribute.type); + } + }, this); + }, + + materializeAttribute: function(record, serialized, attributeName, attributeType) { + var value = this.extractAttribute(record.constructor, serialized, attributeName); + value = this.deserializeValue(value, attributeType); + + record.materializeAttribute(attributeName, value); + }, + + materializeRelationships: function(record, hash, prematerialized) { + record.eachRelationship(function(name, relationship) { + if (relationship.kind === 'hasMany') { + if (prematerialized && prematerialized.hasOwnProperty(name)) { + record.materializeHasMany(name, prematerialized[name]); + } else { + this.materializeHasMany(name, record, hash, relationship, prematerialized); + } + } else if (relationship.kind === 'belongsTo') { + if (prematerialized && prematerialized.hasOwnProperty(name)) { + record.materializeBelongsTo(name, prematerialized[name]); + } else { + this.materializeBelongsTo(name, record, hash, relationship, prematerialized); + } + } + }, this); + }, + + materializeHasMany: function(name, record, hash, relationship) { + var key = this._keyForHasMany(record.constructor, relationship.key); + record.materializeHasMany(name, this.extractHasMany(record.constructor, hash, key)); + }, + + materializeBelongsTo: function(name, record, hash, relationship) { + var key = this._keyForBelongsTo(record.constructor, relationship.key); + record.materializeBelongsTo(name, this.extractBelongsTo(record.constructor, hash, key)); + }, + + _extractEmbeddedRelationship: function(type, hash, name, relationshipType) { + var key = this['_keyFor' + relationshipType](type, name); + + if (this.embeddedType(type, name)) { + return this['extractEmbedded' + relationshipType](type, hash, key); + } + }, + + _extractEmbeddedBelongsTo: function(type, hash, name) { + return this._extractEmbeddedRelationship(type, hash, name, 'BelongsTo'); + }, + + _extractEmbeddedHasMany: function(type, hash, name) { + return this._extractEmbeddedRelationship(type, hash, name, 'HasMany'); + }, + + /** + @private + + This method is called to get the primary key for a given + type. + + If a primary key configuration exists for this type, this + method will return the configured value. Otherwise, it will + call the public `primaryKey` hook. + + @param {DS.Model subclass} type + @returns {String} the primary key for the type + */ + _primaryKey: function(type) { + var config = this.configurationForType(type), + primaryKey = config && config.primaryKey; + + if (primaryKey) { + return primaryKey; + } else { + return this.primaryKey(type); + } + }, + + /** + @private + + This method looks up the key for the attribute name and transforms the + attribute's value using registered transforms. + + Specifically: + + 1. Look up the key for the attribute name. If available, this will use + any registered mappings. Otherwise, it will invoke the public + `keyForAttributeName` hook. + 2. Get the value from the record using the `attributeName`. + 3. Transform the value using registered transforms for the `attributeType`. + 4. Invoke the public `addAttribute` hook with the hash, key, and + transformed value. + + @param {any} data the serialized representation being built + @param {DS.Model} record the record to serialize + @param {String} attributeName the name of the attribute on the record + @param {String} attributeType the type of the attribute (e.g. `string` + or `boolean`) + */ + _addAttribute: function(data, record, attributeName, attributeType) { + var key = this._keyForAttributeName(record.constructor, attributeName); + var value = get(record, attributeName); + + this.addAttribute(data, key, this.serializeValue(value, attributeType)); + }, + + /** + @private + + This method looks up the primary key for the `type` and invokes + `serializeId` on the `id`. + + It then invokes the public `addId` hook with the primary key and + the serialized id. + + @param {any} data the serialized representation that is being built + @param {Ember.Model subclass} type + @param {any} id the materialized id from the record + */ + _addId: function(hash, type, id) { + var primaryKey = this._primaryKey(type); + + this.addId(hash, primaryKey, this.serializeId(id)); + }, + + /** + @private + + This method is called to get a key used in the data from + an attribute name. It first checks for any mappings before + calling the public hook `keyForAttributeName`. + + @param {DS.Model subclass} type the type of the record with + the attribute name `name` + @param {String} name the attribute name to convert into a key + + @returns {String} the key + */ + _keyForAttributeName: function(type, name) { + return this._keyFromMappingOrHook('keyForAttributeName', type, name); + }, + + /** + @private + + This method is called to get a key used in the data from + a belongsTo relationship. It first checks for any mappings before + calling the public hook `keyForBelongsTo`. + + @param {DS.Model subclass} type the type of the record with + the `belongsTo` relationship. + @param {String} name the relationship name to convert into a key + + @returns {String} the key + */ + _keyForBelongsTo: function(type, name) { + return this._keyFromMappingOrHook('keyForBelongsTo', type, name); + }, + + keyFor: function(description) { + var type = description.parentType, + name = description.key; + + switch (description.kind) { + case 'belongsTo': + return this._keyForBelongsTo(type, name); + case 'hasMany': + return this._keyForHasMany(type, name); + } + }, + + /** + @private + + This method is called to get a key used in the data from + a hasMany relationship. It first checks for any mappings before + calling the public hook `keyForHasMany`. + + @param {DS.Model subclass} type the type of the record with + the `hasMany` relationship. + @param {String} name the relationship name to convert into a key + + @returns {String} the key + */ + _keyForHasMany: function(type, name) { + return this._keyFromMappingOrHook('keyForHasMany', type, name); + }, + /** + @private + + This method converts the relationship name to a key for serialization, + and then invokes the public `addBelongsTo` hook. + + @param {any} data the serialized representation that is being built + @param {DS.Model} record the record to serialize + @param {String} name the relationship name + @param {Object} relationship an object representing the relationship + */ + _addBelongsTo: function(data, record, name, relationship) { + var key = this._keyForBelongsTo(record.constructor, name); + this.addBelongsTo(data, record, key, relationship); + }, + + /** + @private + + This method converts the relationship name to a key for serialization, + and then invokes the public `addHasMany` hook. + + @param {any} data the serialized representation that is being built + @param {DS.Model} record the record to serialize + @param {String} name the relationship name + @param {Object} relationship an object representing the relationship + */ + _addHasMany: function(data, record, name, relationship) { + var key = this._keyForHasMany(record.constructor, name); + this.addHasMany(data, record, key, relationship); + }, + + /** + @private + + An internal method that handles checking whether a mapping + exists for a particular attribute or relationship name before + calling the public hooks. + + If a mapping is found, and the mapping has a key defined, + use that instead of invoking the hook. + + @param {String} publicMethod the public hook to invoke if + a mapping is not found (e.g. `keyForAttributeName`) + @param {DS.Model subclass} type the type of the record with + the attribute or relationship name. + @param {String} name the attribute or relationship name to + convert into a key + */ + _keyFromMappingOrHook: function(publicMethod, type, name) { + var key = this.mappingOption(type, name, 'key'); + + if (key) { + return key; + } else { + return this[publicMethod](type, name); + } + }, + + /** + TRANSFORMS + */ + + registerTransform: function(type, transform) { + this.transforms[type] = transform; + }, + + registerEnumTransform: function(type, objects) { + var transform = { + deserialize: function(deserialized) { + return Ember.A(objects).objectAt(deserialized); + }, + serialize: function(serialized) { + return Ember.EnumerableUtils.indexOf(objects, serialized); + }, + values: objects + }; + this.registerTransform(type, transform); + }, + + /** + MAPPING CONVENIENCE + */ + + map: function(type, mappings) { + this.mappings.set(type, mappings); + }, + + configure: function(type, configuration) { + if (type && !configuration) { + Ember.merge(this.globalConfigurations, type); + return; + } + + var config = Ember.create(this.globalConfigurations); + Ember.merge(config, configuration); + + this.configurations.set(type, config); + }, + + mappingForType: function(type) { + this._reifyMappings(); + return this.mappings.get(type) || {}; + }, + + configurationForType: function(type) { + this._reifyConfigurations(); + return this.configurations.get(type) || this.globalConfigurations; + }, + + _reifyMappings: function() { + if (this._didReifyMappings) { return; } + + var mappings = this.mappings, + reifiedMappings = Ember.Map.create(); + + mappings.forEach(function(key, mapping) { + if (typeof key === 'string') { + var type = Ember.get(Ember.lookup, key); + Ember.assert("Could not find model at path " + key, type); + + reifiedMappings.set(type, mapping); + } else { + reifiedMappings.set(key, mapping); + } + }); + + this.mappings = reifiedMappings; + + this._didReifyMappings = true; + }, + + _reifyConfigurations: function() { + if (this._didReifyConfigurations) { return; } + + var configurations = this.configurations, + reifiedConfigurations = Ember.Map.create(); + + configurations.forEach(function(key, mapping) { + if (typeof key === 'string' && key !== 'plurals') { + var type = Ember.get(Ember.lookup, key); + Ember.assert("Could not find model at path " + key, type); + + reifiedConfigurations.set(type, mapping); + } else { + reifiedConfigurations.set(key, mapping); + } + }); + + this.configurations = reifiedConfigurations; + + this._didReifyConfigurations = true; + }, + + mappingOption: function(type, name, option) { + var mapping = this.mappingForType(type)[name]; + + return mapping && mapping[option]; + }, + + configOption: function(type, option) { + var config = this.configurationForType(type); + + return config[option]; + }, + + // EMBEDDED HELPERS + + embeddedType: function(type, name) { + return this.mappingOption(type, name, 'embedded'); + }, + + eachEmbeddedRecord: function(record, callback, binding) { + this.eachEmbeddedBelongsToRecord(record, callback, binding); + this.eachEmbeddedHasManyRecord(record, callback, binding); + }, + + eachEmbeddedBelongsToRecord: function(record, callback, binding) { + var type = record.constructor; + + this.eachEmbeddedBelongsTo(record.constructor, function(name, relationship, embeddedType) { + var embeddedRecord = get(record, name); + if (embeddedRecord) { callback.call(binding, embeddedRecord, embeddedType); } + }); + }, + + eachEmbeddedHasManyRecord: function(record, callback, binding) { + var type = record.constructor; + + this.eachEmbeddedHasMany(record.constructor, function(name, relationship, embeddedType) { + var array = get(record, name); + for (var i=0, l=get(array, 'length'); i 'low' + Server Response / Load: { myTask: {priority: 0} } + + @param {String} type of the transform + @param {Array} array of String objects to use for the enumerated values. + This is an ordered list and the index values will be used for the transform. + */ + registerEnumTransform: function(attributeType, objects) { + get(this, 'serializer').registerEnumTransform(attributeType, objects); + }, + /** If the globally unique IDs for your records should be generated on the client, implement the `generateIdForRecord()` method. This method will be invoked @@ -3644,20 +7145,64 @@ DS.Adapter = Ember.Object.extend({ */ generateIdForRecord: null, + materialize: function(record, data, prematerialized) { + get(this, 'serializer').materialize(record, data, prematerialized); + }, + + serialize: function(record, options) { + return get(this, 'serializer').serialize(record, options); + }, + + extractId: function(type, data) { + return get(this, 'serializer').extractId(type, data); + }, + + groupByType: function(enumerable) { + var map = Ember.MapWithDefault.create({ + defaultValue: function() { return Ember.OrderedSet.create(); } + }); + + enumerable.forEach(function(item) { + map.get(item.constructor).add(item); + }); + + return map; + }, + commit: function(store, commitDetails) { - commitDetails.updated.eachType(function(type, array) { - this.updateRecords(store, type, array.slice()); + this.save(store, commitDetails); + }, + + save: function(store, commitDetails) { + var adapter = this; + + function filter(records) { + var filteredSet = Ember.OrderedSet.create(); + + records.forEach(function(record) { + if (adapter.shouldSave(record)) { + filteredSet.add(record); + } + }); + + return filteredSet; + } + + this.groupByType(commitDetails.created).forEach(function(type, set) { + this.createRecords(store, type, filter(set)); }, this); - commitDetails.created.eachType(function(type, array) { - this.createRecords(store, type, array.slice()); + this.groupByType(commitDetails.updated).forEach(function(type, set) { + this.updateRecords(store, type, filter(set)); }, this); - commitDetails.deleted.eachType(function(type, array) { - this.deleteRecords(store, type, array.slice()); + this.groupByType(commitDetails.deleted).forEach(function(type, set) { + this.deleteRecords(store, type, filter(set)); }, this); }, + shouldSave: Ember.K, + createRecords: function(store, type, records) { records.forEach(function(record) { this.createRecord(store, type, record); @@ -3683,38 +7228,114 @@ DS.Adapter = Ember.Object.extend({ } }); +DS.Adapter.reopenClass({ + registerTransform: function(attributeType, transform) { + var registeredTransforms = this._registeredTransforms || {}; + + registeredTransforms[attributeType] = transform; + + this._registeredTransforms = registeredTransforms; + }, + + map: DS._Mappable.generateMapFunctionFor('attributes', function(key, newValue, map) { + var existingValue = map.get(key); + + merge(existingValue, newValue); + }), + + configure: DS._Mappable.generateMapFunctionFor('configurations', function(key, newValue, map) { + var existingValue = map.get(key); + + // If a mapping configuration is provided, peel it off and apply it + // using the DS.Adapter.map API. + var mappings = newValue && newValue.mappings; + if (mappings) { + this.map(key, mappings); + delete newValue.mappings; + } + + merge(existingValue, newValue); + }), + + resolveMapConflict: function(oldValue, newValue, mappingsKey) { + merge(newValue, oldValue); + + return newValue; + } +}); + })(); (function() { -var set = Ember.set; +var get = Ember.get, set = Ember.set; -Ember.onLoad('Ember.Application', function(Application) { - Application.registerInjection({ - name: "store", - before: "controllers", +DS.FixtureSerializer = DS.Serializer.extend({ + deserializeValue: function(value, attributeType) { + return value; + }, - injection: function(app, stateManager, property) { - if (property === 'Store') { - set(stateManager, 'store', app[property].create()); - } + serializeValue: function(value, attributeType) { + return value; + }, + + /** + @private + + Creates an empty hash that will be filled in by the hooks called from the + `serialize()` method. + + @return {Object} + */ + createSerializedForm: function() { + return {}; + }, + + extract: function(loader, fixture, type, record) { + if (record) { loader.updateId(record, fixture); } + this.extractRecordRepresentation(loader, type, fixture); + }, + + extractMany: function(loader, fixtures, type, records) { + var objects = fixtures, references = []; + if (records) { records = records.toArray(); } + + for (var i = 0; i < objects.length; i++) { + if (records) { loader.updateId(records[i], objects[i]); } + var reference = this.extractRecordRepresentation(loader, type, objects[i]); + references.push(reference); } - }); - Application.registerInjection({ - name: "giveStoreToControllers", + loader.populateArray(references); + }, - injection: function(app, stateManager, property) { - if (/^[A-Z].*Controller$/.test(property)) { - var controllerName = property.charAt(0).toLowerCase() + property.substr(1); - var store = stateManager.get('store'); - var controller = stateManager.get(controllerName); + extractId: function(type, hash) { + var primaryKey = this._primaryKey(type); - controller.set('store', store); - } + if (hash.hasOwnProperty(primaryKey)) { + // Ensure that we coerce IDs to strings so that record + // IDs remain consistent between application runs; especially + // if the ID is serialized and later deserialized from the URL, + // when type information will have been lost. + return hash[primaryKey]+''; + } else { + return null; } - }); + }, + + extractAttribute: function(type, hash, attributeName) { + var key = this._keyForAttributeName(type, attributeName); + return hash[key]; + }, + + extractHasMany: function(type, hash, key) { + return hash[key]; + }, + + extractBelongsTo: function(type, hash, key) { + return hash[key]; + } }); })(); @@ -3724,23 +7345,45 @@ Ember.onLoad('Ember.Application', function(Application) { (function() { var get = Ember.get; +/** + `DS.FixtureAdapter` is an adapter that loads records from memory. + Its primarily used for development and testing. You can also use + `DS.FixtureAdapter` while working on the API but are not ready to + integrate yet. It is a fully functioning adapter. All CRUD methods + are implemented. You can also implement query logic that a remote + system would do. Its possible to do develop your entire application + with `DS.FixtureAdapter`. + +*/ DS.FixtureAdapter = DS.Adapter.extend({ simulateRemoteResponse: true, latency: 50, + serializer: DS.FixtureSerializer, + /* Implement this method in order to provide data associated with a type */ fixturesForType: function(type) { - return type.FIXTURES ? Ember.A(type.FIXTURES) : null; + if (type.FIXTURES) { + var fixtures = Ember.A(type.FIXTURES); + return fixtures.map(function(fixture){ + if(!fixture.id){ + throw new Error('the id property must be defined for fixture %@'.fmt(fixture)); + } + fixture.id = fixture.id + ''; + return fixture; + }); + } + return null; }, /* Implement this method in order to query fixtures data */ - queryFixtures: function(fixtures, query) { + queryFixtures: function(fixtures, query, type) { return fixtures; }, @@ -3748,7 +7391,7 @@ DS.FixtureAdapter = DS.Adapter.extend({ Implement this method in order to provide provide json for CRUD methods */ mockJSON: function(type, record) { - return record.toJSON({associations: true}); + return this.serialize(record, { includeId: true }); }, /* @@ -3759,18 +7402,19 @@ DS.FixtureAdapter = DS.Adapter.extend({ }, find: function(store, type, id) { - var fixtures = this.fixturesForType(type); + var fixtures = this.fixturesForType(type), + fixture; Ember.assert("Unable to find fixtures for model type "+type.toString(), !!fixtures); if (fixtures) { - fixtures = fixtures.findProperty('id', id); + fixture = Ember.A(fixtures).findProperty('id', id); } - if (fixtures) { + if (fixture) { this.simulateRemoteCall(function() { - store.load(type, fixtures); - }, store, type); + this.didFindRecord(store, type, fixture, id); + }, this); } }, @@ -3787,8 +7431,8 @@ DS.FixtureAdapter = DS.Adapter.extend({ if (fixtures) { this.simulateRemoteCall(function() { - store.loadMany(type, fixtures); - }, store, type); + this.didFindMany(store, type, fixtures); + }, this); } }, @@ -3798,8 +7442,8 @@ DS.FixtureAdapter = DS.Adapter.extend({ Ember.assert("Unable to find fixtures for model type "+type.toString(), !!fixtures); this.simulateRemoteCall(function() { - store.loadMany(type, fixtures); - }, store, type); + this.didFindAll(store, type, fixtures); + }, this); }, findQuery: function(store, type, query, array) { @@ -3807,12 +7451,12 @@ DS.FixtureAdapter = DS.Adapter.extend({ Ember.assert("Unable to find fixtures for model type "+type.toString(), !!fixtures); - fixtures = this.queryFixtures(fixtures, query); + fixtures = this.queryFixtures(fixtures, query, type); if (fixtures) { this.simulateRemoteCall(function() { - array.load(fixtures); - }, store, type); + this.didFindQuery(store, type, fixtures, array); + }, this); } }, @@ -3822,37 +7466,70 @@ DS.FixtureAdapter = DS.Adapter.extend({ fixture.id = this.generateIdForRecord(store, record); this.simulateRemoteCall(function() { - store.didCreateRecord(record, fixture); - }, store, type, record); + this.didCreateRecord(store, type, record, fixture); + }, this); }, updateRecord: function(store, type, record) { var fixture = this.mockJSON(type, record); this.simulateRemoteCall(function() { - store.didUpdateRecord(record, fixture); - }, store, type, record); + this.didUpdateRecord(store, type, record, fixture); + }, this); }, deleteRecord: function(store, type, record) { this.simulateRemoteCall(function() { - store.didDeleteRecord(record); - }, store, type, record); + this.didDeleteRecord(store, type, record); + }, this); }, /* @private */ - simulateRemoteCall: function(callback, store, type, record) { + simulateRemoteCall: function(callback, context) { + function response() { + Ember.run(context, callback); + } + if (get(this, 'simulateRemoteResponse')) { - setTimeout(callback, get(this, 'latency')); + setTimeout(response, get(this, 'latency')); } else { - callback(); + response(); } } }); -DS.fixtureAdapter = DS.FixtureAdapter.create(); +})(); + + + +(function() { +DS.RESTSerializer = DS.JSONSerializer.extend({ + keyForAttributeName: function(type, name) { + return Ember.String.decamelize(name); + }, + + keyForBelongsTo: function(type, name) { + var key = this.keyForAttributeName(type, name); + + if (this.embeddedType(type, name)) { + return key; + } + + return key + "_id"; + }, + + keyForHasMany: function(type, name) { + var key = this.keyForAttributeName(type, name); + + if (this.embeddedType(type, name)) { + return key; + } + + return this.singularize(key) + "_ids"; + } +}); })(); @@ -3861,31 +7538,128 @@ DS.fixtureAdapter = DS.FixtureAdapter.create(); (function() { /*global jQuery*/ -var get = Ember.get, set = Ember.set; +var get = Ember.get, set = Ember.set, merge = Ember.merge; +/** + The REST adapter allows your store to communicate with an HTTP server by + transmitting JSON via XHR. Most Ember.js apps that consume a JSON API + should use the REST adapter. + + This adapter is designed around the idea that the JSON exchanged with + the server should be conventional. + + ## JSON Structure + + The REST adapter expects the JSON returned from your server to follow + these conventions. + + ### Object Root + + The JSON payload should be an object that contains the record inside a + root property. For example, in response to a `GET` request for + `/posts/1`, the JSON should look like this: + + ```js + { + "post": { + title: "I'm Running to Reform the W3C's Tag", + author: "Yehuda Katz" + } + } + ``` + + ### Conventional Names + + Attribute names in your JSON payload should be the underscored versions of + the attributes in your Ember.js models. + + For example, if you have a `Person` model: + + ```js + App.Person = DS.Model.extend({ + firstName: DS.attr('string'), + lastName: DS.attr('string'), + occupation: DS.attr('string') + }); + ``` + + The JSON returned should look like this: + + ```js + { + "person": { + "first_name": "Barack", + "last_name": "Obama", + "occupation": "President" + } + } + ``` +*/ DS.RESTAdapter = DS.Adapter.extend({ bulkCommit: false, + since: 'since', + + serializer: DS.RESTSerializer, + + init: function() { + this._super.apply(this, arguments); + }, + + shouldSave: function(record) { + var reference = get(record, '_reference'); + + return !reference.parent; + }, createRecord: function(store, type, record) { var root = this.rootForType(type); var data = {}; - data[root] = record.toJSON(); + data[root] = this.serialize(record, { includeId: true }); this.ajax(this.buildURL(root), "POST", { data: data, context: this, success: function(json) { - this.didCreateRecord(store, type, record, json); + Ember.run(this, function(){ + this.didCreateRecord(store, type, record, json); + }); + }, + error: function(xhr) { + this.didError(store, type, record, xhr); } }); }, - didCreateRecord: function(store, type, record, json) { - var root = this.rootForType(type); + dirtyRecordsForRecordChange: function(dirtySet, record) { + this._dirtyTree(dirtySet, record); + }, - this.sideload(store, type, json, root); - store.didCreateRecord(record, json[root]); + dirtyRecordsForHasManyChange: function(dirtySet, record, relationship) { + var embeddedType = get(this, 'serializer').embeddedType(record.constructor, relationship.secondRecordName); + + if (embeddedType === 'always') { + relationship.childReference.parent = relationship.parentReference; + this._dirtyTree(dirtySet, record); + } + }, + + _dirtyTree: function(dirtySet, record) { + dirtySet.add(record); + + get(this, 'serializer').eachEmbeddedRecord(record, function(embeddedRecord, embeddedType) { + if (embeddedType !== 'always') { return; } + if (dirtySet.has(embeddedRecord)) { return; } + this._dirtyTree(dirtySet, embeddedRecord); + }, this); + + var reference = record.get('_reference'); + + if (reference.parent) { + var store = get(record, 'store'); + var parent = store.recordForReference(reference.parent); + this._dirtyTree(dirtySet, parent); + } }, createRecords: function(store, type, records) { @@ -3897,49 +7671,43 @@ DS.RESTAdapter = DS.Adapter.extend({ plural = this.pluralize(root); var data = {}; - data[plural] = records.map(function(record) { - return record.toJSON(); - }); + data[plural] = []; + records.forEach(function(record) { + data[plural].push(this.serialize(record, { includeId: true })); + }, this); this.ajax(this.buildURL(root), "POST", { data: data, context: this, success: function(json) { - this.didCreateRecords(store, type, records, json); + Ember.run(this, function(){ + this.didCreateRecords(store, type, records, json); + }); } }); }, - didCreateRecords: function(store, type, records, json) { - var root = this.pluralize(this.rootForType(type)); - - this.sideload(store, type, json, root); - store.didCreateRecords(type, records, json[root]); - }, - updateRecord: function(store, type, record) { var id = get(record, 'id'); var root = this.rootForType(type); var data = {}; - data[root] = record.toJSON(); + data[root] = this.serialize(record); this.ajax(this.buildURL(root, id), "PUT", { data: data, context: this, success: function(json) { - this.didUpdateRecord(store, type, record, json); + Ember.run(this, function(){ + this.didSaveRecord(store, type, record, json); + }); + }, + error: function(xhr) { + this.didError(store, type, record, xhr); } }); }, - didUpdateRecord: function(store, type, record, json) { - var root = this.rootForType(type); - - this.sideload(store, type, json, root); - store.didUpdateRecord(record, json && json[root]); - }, - updateRecords: function(store, type, records) { if (get(this, 'bulkCommit') === false) { return this._super(store, type, records); @@ -3949,26 +7717,22 @@ DS.RESTAdapter = DS.Adapter.extend({ plural = this.pluralize(root); var data = {}; - data[plural] = records.map(function(record) { - return record.toJSON(); - }); + data[plural] = []; + records.forEach(function(record) { + data[plural].push(this.serialize(record, { includeId: true })); + }, this); this.ajax(this.buildURL(root, "bulk"), "PUT", { data: data, context: this, success: function(json) { - this.didUpdateRecords(store, type, records, json); + Ember.run(this, function(){ + this.didSaveRecords(store, type, records, json); + }); } }); }, - didUpdateRecords: function(store, type, records, json) { - var root = this.pluralize(this.rootForType(type)); - - this.sideload(store, type, json, root); - store.didUpdateRecords(records, json[root]); - }, - deleteRecord: function(store, type, record) { var id = get(record, 'id'); var root = this.rootForType(type); @@ -3976,106 +7740,113 @@ DS.RESTAdapter = DS.Adapter.extend({ this.ajax(this.buildURL(root, id), "DELETE", { context: this, success: function(json) { - this.didDeleteRecord(store, type, record, json); + Ember.run(this, function(){ + this.didSaveRecord(store, type, record, json); + }); } }); }, - didDeleteRecord: function(store, type, record, json) { - if (json) { this.sideload(store, type, json); } - store.didDeleteRecord(record); - }, - deleteRecords: function(store, type, records) { if (get(this, 'bulkCommit') === false) { return this._super(store, type, records); } var root = this.rootForType(type), - plural = this.pluralize(root); + plural = this.pluralize(root), + serializer = get(this, 'serializer'); var data = {}; - data[plural] = records.map(function(record) { - return get(record, 'id'); + data[plural] = []; + records.forEach(function(record) { + data[plural].push(serializer.serializeId( get(record, 'id') )); }); this.ajax(this.buildURL(root, 'bulk'), "DELETE", { data: data, context: this, success: function(json) { - this.didDeleteRecords(store, type, records, json); + Ember.run(this, function(){ + this.didSaveRecords(store, type, records, json); + }); } }); }, - didDeleteRecords: function(store, type, records, json) { - if (json) { this.sideload(store, type, json); } - store.didDeleteRecords(records); - }, - find: function(store, type, id) { var root = this.rootForType(type); this.ajax(this.buildURL(root, id), "GET", { success: function(json) { - this.sideload(store, type, json, root); - store.load(type, json[root]); + Ember.run(this, function(){ + this.didFindRecord(store, type, json, id); + }); } }); }, - findMany: function(store, type, ids) { - var root = this.rootForType(type), plural = this.pluralize(root); + findAll: function(store, type, since) { + var root = this.rootForType(type); this.ajax(this.buildURL(root), "GET", { - data: { ids: ids }, + data: this.sinceQuery(since), success: function(json) { - this.sideload(store, type, json, plural); - store.loadMany(type, json[plural]); - } - }); - }, - - findAll: function(store, type) { - var root = this.rootForType(type), plural = this.pluralize(root); - - this.ajax(this.buildURL(root), "GET", { - success: function(json) { - this.sideload(store, type, json, plural); - store.loadMany(type, json[plural]); + Ember.run(this, function(){ + this.didFindAll(store, type, json); + }); } }); }, findQuery: function(store, type, query, recordArray) { - var root = this.rootForType(type), plural = this.pluralize(root); + var root = this.rootForType(type); this.ajax(this.buildURL(root), "GET", { data: query, success: function(json) { - this.sideload(store, type, json, plural); - recordArray.load(json[plural]); + Ember.run(this, function(){ + this.didFindQuery(store, type, json, recordArray); + }); } }); }, - // HELPERS + findMany: function(store, type, ids, owner) { + var root = this.rootForType(type); + ids = this.serializeIds(ids); - plurals: {}, - - // define a plurals hash in your subclass to define - // special-case pluralization - pluralize: function(name) { - return this.plurals[name] || name + "s"; + this.ajax(this.buildURL(root), "GET", { + data: {ids: ids}, + success: function(json) { + Ember.run(this, function(){ + this.didFindMany(store, type, json); + }); + } + }); }, - rootForType: function(type) { - if (type.url) { return type.url; } + /** + @private - // use the last part of the name as the URL - var parts = type.toString().split("."); - var name = parts[parts.length - 1]; - return name.replace(/([A-Z])/g, '_$1').toLowerCase().slice(1); + This method serializes a list of IDs using `serializeId` + + @returns {Array} an array of serialized IDs + */ + serializeIds: function(ids) { + var serializer = get(this, 'serializer'); + + return Ember.EnumerableUtils.map(ids, function(id) { + return serializer.serializeId(id); + }); + }, + + didError: function(store, type, record, xhr) { + if (xhr.status === 422) { + var data = JSON.parse(xhr.responseText); + store.recordWasInvalid(record, data['errors']); + } else { + this._super.apply(this, arguments); + } }, ajax: function(url, type, hash) { @@ -4092,60 +7863,20 @@ DS.RESTAdapter = DS.Adapter.extend({ jQuery.ajax(hash); }, - sideload: function(store, type, json, root) { - var sideloadedType, mappings, loaded = {}; + url: "", - loaded[root] = true; - - for (var prop in json) { - if (!json.hasOwnProperty(prop)) { continue; } - if (prop === root) { continue; } - - sideloadedType = type.typeForAssociation(prop); - - if (!sideloadedType) { - mappings = get(this, 'mappings'); - Ember.assert("Your server returned a hash with the key " + prop + " but you have no mappings", !!mappings); - - sideloadedType = get(mappings, prop); - - if (typeof sideloadedType === 'string') { - sideloadedType = get(window, sideloadedType); - } - - Ember.assert("Your server returned a hash with the key " + prop + " but you have no mapping for it", !!sideloadedType); - } - - this.sideloadAssociations(store, sideloadedType, json, prop, loaded); - } + rootForType: function(type) { + var serializer = get(this, 'serializer'); + return serializer.rootForType(type); }, - sideloadAssociations: function(store, type, json, prop, loaded) { - loaded[prop] = true; - - get(type, 'associationsByName').forEach(function(key, meta) { - key = meta.key || key; - if (meta.kind === 'belongsTo') { - key = this.pluralize(key); - } - if (json[key] && !loaded[key]) { - this.sideloadAssociations(store, meta.type, json, key, loaded); - } - }, this); - - this.loadValue(store, type, json[prop]); - }, - - loadValue: function(store, type, value) { - if (value instanceof Array) { - store.loadMany(type, value); - } else { - store.load(type, value); - } + pluralize: function(string) { + var serializer = get(this, 'serializer'); + return serializer.pluralize(string); }, buildURL: function(record, suffix) { - var url = [""]; + var url = [this.url]; Ember.assert("Namespace URL (" + this.namespace + ") must not start with slash", !this.namespace || this.namespace.toString().charAt(0) !== "/"); Ember.assert("Record URL (" + record + ") must not start with slash", !record || record.toString().charAt(0) !== "/"); @@ -4161,6 +7892,12 @@ DS.RESTAdapter = DS.Adapter.extend({ } return url.join("/"); + }, + + sinceQuery: function(since) { + var query = {}; + query[get(this, 'since')] = since; + return since ? query : null; } }); @@ -4169,6 +7906,12 @@ DS.RESTAdapter = DS.Adapter.extend({ +(function() { + +})(); + + + (function() { //Copyright (C) 2011 by Living Social, Inc. diff --git a/assets/scripts/vendor/ember.js b/assets/scripts/vendor/ember.js index f0fd6977..35a9c6a5 100644 --- a/assets/scripts/vendor/ember.js +++ b/assets/scripts/vendor/ember.js @@ -1,5 +1,5 @@ -// Version: v1.0.pre-243-g2578a65 -// Last commit: 2578a65 (2012-10-21 18:51:25 +0200) +// Version: v1.0.0-pre.4-209-g455440d +// Last commit: 455440d (2013-02-13 12:03:37 -0800) (function() { @@ -32,18 +32,19 @@ if (!('MANDATORY_SETTER' in Ember.ENV)) { /** Define an assertion that will throw an exception if the condition is not - met. Ember build tools will remove any calls to Ember.assert() when + met. Ember build tools will remove any calls to `Ember.assert()` when doing a production build. Example: - // Test for truthiness - Ember.assert('Must pass a valid object', obj); - // Fail unconditionally - Ember.assert('This code path should never be run') + ```javascript + // Test for truthiness + Ember.assert('Must pass a valid object', obj); + // Fail unconditionally + Ember.assert('This code path should never be run') + ``` @method assert - @param {String} desc A description of the assertion. This will become + @param {String} desc A description of the assertion. This will become the text of the Error thrown if the assertion fails. - @param {Boolean} test Must be truthy for the assertion to pass. If falsy, an exception will be thrown. */ @@ -54,7 +55,7 @@ Ember.assert = function(desc, test) { /** Display a warning with the provided message. Ember build tools will - remove any calls to Ember.warn() when doing a production build. + remove any calls to `Ember.warn()` when doing a production build. @method warn @param {String} message A warning to display. @@ -68,10 +69,25 @@ Ember.warn = function(message, test) { } }; +/** + Display a debug notice. Ember build tools will remove any calls to + `Ember.debug()` when doing a production build. + + ```javascript + Ember.debug("I'm a debug notice!"); + ``` + + @method debug + @param {String} message A debug message to display. +*/ +Ember.debug = function(message) { + Ember.Logger.debug("DEBUG: "+message); +}; + /** Display a deprecation warning with the provided message and a stack trace (Chrome and Firefox only). Ember build tools will remove any calls to - Ember.deprecate() when doing a production build. + `Ember.deprecate()` when doing a production build. @method deprecate @param {String} message A description of the deprecation. @@ -118,7 +134,7 @@ Ember.deprecate = function(message, test) { Display a deprecation warning with the provided message and a stack trace (Chrome and Firefox only) when the wrapped method is called. - Ember build tools will not remove calls to Ember.deprecateFunc(), though + Ember build tools will not remove calls to `Ember.deprecateFunc()`, though no warnings will be shown in production. @method deprecateFunc @@ -132,18 +148,44 @@ Ember.deprecateFunc = function(message, func) { }; }; - -window.ember_assert = Ember.deprecateFunc("ember_assert is deprecated. Please use Ember.assert instead.", Ember.assert); -window.ember_warn = Ember.deprecateFunc("ember_warn is deprecated. Please use Ember.warn instead.", Ember.warn); -window.ember_deprecate = Ember.deprecateFunc("ember_deprecate is deprecated. Please use Ember.deprecate instead.", Ember.deprecate); -window.ember_deprecateFunc = Ember.deprecateFunc("ember_deprecateFunc is deprecated. Please use Ember.deprecateFunc instead.", Ember.deprecateFunc); - })(); -// Version: v1.0.pre-243-g2578a65 -// Last commit: 2578a65 (2012-10-21 18:51:25 +0200) +// Version: v1.0.0-pre.4-209-g455440d +// Last commit: 455440d (2013-02-13 12:03:37 -0800) +(function() { +var define, requireModule; + +(function() { + var registry = {}, seen = {}; + + define = function(name, deps, callback) { + registry[name] = { deps: deps, callback: callback }; + }; + + requireModule = function(name) { + if (seen[name]) { return seen[name]; } + seen[name] = {}; + + var mod = registry[name], + deps = mod.deps, + callback = mod.callback, + reified = [], + exports; + + for (var i=0, l=deps.length; i -1; -}; - -// From: https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/array/map -var arrayMap = isNativeFunc(Array.prototype.map) ? Array.prototype.map : function(fun /*, thisp */) { - //"use strict"; - - if (this === void 0 || this === null) { - throw new TypeError(); - } - - var t = Object(this); - var len = t.length >>> 0; - if (typeof fun !== "function") { - throw new TypeError(); - } - - var res = new Array(len); - var thisp = arguments[1]; - for (var i = 0; i < len; i++) { - if (i in t) { - res[i] = fun.call(thisp, t[i], i, t); - } - } - - return res; -}; - -// From: https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/array/foreach -var arrayForEach = isNativeFunc(Array.prototype.forEach) ? Array.prototype.forEach : function(fun /*, thisp */) { - //"use strict"; - - if (this === void 0 || this === null) { - throw new TypeError(); - } - - var t = Object(this); - var len = t.length >>> 0; - if (typeof fun !== "function") { - throw new TypeError(); - } - - var thisp = arguments[1]; - for (var i = 0; i < len; i++) { - if (i in t) { - fun.call(thisp, t[i], i, t); - } +Ember.merge = function(original, updates) { + for (var prop in updates) { + if (!updates.hasOwnProperty(prop)) { continue; } + original[prop] = updates[prop]; } }; -var arrayIndexOf = isNativeFunc(Array.prototype.indexOf) ? Array.prototype.indexOf : function (obj, fromIndex) { - if (fromIndex === null || fromIndex === undefined) { fromIndex = 0; } - else if (fromIndex < 0) { fromIndex = Math.max(0, this.length + fromIndex); } - for (var i = fromIndex, j = this.length; i < j; i++) { - if (this[i] === obj) { return i; } - } - return -1; -}; - -Ember.ArrayPolyfills = { - map: arrayMap, - forEach: arrayForEach, - indexOf: arrayIndexOf -}; - -var utils = Ember.EnumerableUtils = { - map: function(obj, callback, thisArg) { - return obj.map ? obj.map.call(obj, callback, thisArg) : arrayMap.call(obj, callback, thisArg); - }, - - forEach: function(obj, callback, thisArg) { - return obj.forEach ? obj.forEach.call(obj, callback, thisArg) : arrayForEach.call(obj, callback, thisArg); - }, - - indexOf: function(obj, element, index) { - return obj.indexOf ? obj.indexOf.call(obj, element, index) : arrayIndexOf.call(obj, element, index); - }, - - indexesOf: function(obj, elements) { - return elements === undefined ? [] : utils.map(elements, function(item) { - return utils.indexOf(obj, item); - }); - }, - - removeObject: function(array, item) { - var index = utils.indexOf(array, item); - if (index !== -1) { array.splice(index, 1); } - }, - - replace: function(array, idx, amt, objects) { - if (array.replace) { - return array.replace(idx, amt, objects); - } else { - var args = Array.prototype.concat.apply([idx, amt], objects); - return array.splice.apply(array, args); - } - } -}; - - -if (Ember.SHIM_ES5) { - if (!Array.prototype.map) { - Array.prototype.map = arrayMap; - } - - if (!Array.prototype.forEach) { - Array.prototype.forEach = arrayForEach; - } - - if (!Array.prototype.indexOf) { - Array.prototype.indexOf = arrayIndexOf; - } -} - })(); @@ -643,13 +430,16 @@ var platform = Ember.platform = {}; /** - Identical to Object.create(). Implements if not available natively. + Identical to `Object.create()`. Implements if not available natively. + @method create @for Ember */ Ember.create = Object.create; -if (!Ember.create) { +// STUB_OBJECT_CREATE allows us to override other libraries that stub +// Object.create different than we would prefer +if (!Ember.create || Ember.ENV.STUB_OBJECT_CREATE) { var K = function() {}; Ember.create = function(obj, props) { @@ -744,7 +534,7 @@ if (defineProperty) { */ /** - Identical to Object.defineProperty(). Implements as much functionality + Identical to `Object.defineProperty()`. Implements as much functionality as possible if not available natively. @method defineProperty @@ -786,6 +576,7 @@ if (Ember.ENV.MANDATORY_SETTER && !platform.hasPropertyAccessors) { @module ember-metal */ + var o_defineProperty = Ember.platform.defineProperty, o_create = Ember.create, // Used for guid generation... @@ -824,20 +615,18 @@ var GUID_DESC = { @private Generates a new guid, optionally saving the guid to the object that you - pass in. You will rarely need to use this method. Instead you should - call Ember.guidFor(obj), which return an existing guid if available. + pass in. You will rarely need to use this method. Instead you should + call `Ember.guidFor(obj)`, which return an existing guid if available. @method generateGuid @for Ember - @param {Object} [obj] Object the guid will be used for. If passed in, the guid will + @param {Object} [obj] Object the guid will be used for. If passed in, the guid will be saved on the object and reused whenever you pass the same object again. If no object is passed, just generate a new guid. - - @param {String} [prefix] Prefix to place in front of the guid. Useful when you want to + @param {String} [prefix] Prefix to place in front of the guid. Useful when you want to separate the guid into separate namespaces. - @return {String} the guid */ Ember.generateGuid = function generateGuid(obj, prefix) { @@ -853,9 +642,10 @@ Ember.generateGuid = function generateGuid(obj, prefix) { /** @private - Returns a unique id for the object. If the object does not yet have - a guid, one will be assigned to it. You can call this on any object, - Ember.Object-based or not, but be aware that it will add a _guid property. + Returns a unique id for the object. If the object does not yet have a guid, + one will be assigned to it. You can call this on any object, + `Ember.Object`-based or not, but be aware that it will add a `_guid` + property. You can also use this method on DOM Element objects. @@ -950,14 +740,18 @@ if (isDefinePropertySimulated) { // jQuery.extend() by having a property that fails // hasOwnProperty check. Meta.prototype.__preventPlainObject__ = true; + + // Without non-enumerable properties, meta objects will be output in JSON + // unless explicitly suppressed + Meta.prototype.toJSON = function () { }; } /** - Retrieves the meta hash for an object. If 'writable' is true ensures the + Retrieves the meta hash for an object. If `writable` is true ensures the hash is writable for this object as well. The meta object contains information about computed property descriptors as - well as any watched properties and other information. You generally will + well as any watched properties and other information. You generally will not access this information directly but instead work with higher level methods that manipulate this hash indirectly. @@ -966,10 +760,8 @@ if (isDefinePropertySimulated) { @private @param {Object} obj The object to retrieve meta for - - @param {Boolean} [writable=true] Pass false if you do not intend to modify + @param {Boolean} [writable=true] Pass `false` if you do not intend to modify the meta hash, allowing the method to avoid making an unnecessary copy. - @return {Hash} */ Ember.meta = function meta(obj, writable) { @@ -1029,7 +821,7 @@ Ember.setMeta = function setMeta(obj, property, value) { This method allows extensions to deeply clone a series of nested hashes or other complex objects. For instance, the event system might pass - ['listeners', 'foo:change', 'ember157'] to `prepareMetaPath`, which will + `['listeners', 'foo:change', 'ember157']` to `prepareMetaPath`, which will walk down the keys provided. For each key, if the key does not exist, it is created. If it already @@ -1074,7 +866,7 @@ Ember.metaPath = function metaPath(obj, path, writable) { @private Wraps the passed function so that `this._super` will point to the superFunc - when the function is invoked. This is the primitive we use to implement + when the function is invoked. This is the primitive we use to implement calls to super. @method wrap @@ -1084,19 +876,21 @@ Ember.metaPath = function metaPath(obj, path, writable) { @return {Function} wrapped function. */ Ember.wrap = function(func, superFunc) { - function K() {} - var newFunc = function() { + function superWrapper() { var ret, sup = this._super; this._super = superFunc || K; ret = func.apply(this, arguments); this._super = sup; return ret; - }; + } - newFunc.base = func; - return newFunc; + superWrapper.wrappedFunction = func; + superWrapper.__ember_observes__ = func.__ember_observes__; + superWrapper.__ember_observesBefore__ = func.__ember_observesBefore__; + + return superWrapper; }; /** @@ -1108,12 +902,14 @@ Ember.wrap = function(func, superFunc) { - the object is a native Array - the object is an Object, and has a length property - Unlike Ember.typeOf this method returns true even if the passed object is - not formally array but appears to be array-like (i.e. implements Ember.Array) + Unlike `Ember.typeOf` this method returns true even if the passed object is + not formally array but appears to be array-like (i.e. implements `Ember.Array`) - Ember.isArray(); // false - Ember.isArray([]); // true - Ember.isArray( Ember.ArrayProxy.create({ content: [] }) ); // true + ```javascript + Ember.isArray(); // false + Ember.isArray([]); // true + Ember.isArray( Ember.ArrayProxy.create({ content: [] }) ); // true + ``` @method isArray @for Ember @@ -1129,18 +925,20 @@ Ember.isArray = function(obj) { }; /** - Forces the passed object to be part of an array. If the object is already - an array or array-like, returns the object. Otherwise adds the object to - an array. If obj is null or undefined, returns an empty array. + Forces the passed object to be part of an array. If the object is already + an array or array-like, returns the object. Otherwise adds the object to + an array. If obj is `null` or `undefined`, returns an empty array. - Ember.makeArray(); => [] - Ember.makeArray(null); => [] - Ember.makeArray(undefined); => [] - Ember.makeArray('lindsay'); => ['lindsay'] - Ember.makeArray([1,2,42]); => [1,2,42] + ```javascript + Ember.makeArray(); // [] + Ember.makeArray(null); // [] + Ember.makeArray(undefined); // [] + Ember.makeArray('lindsay'); // ['lindsay'] + Ember.makeArray([1,2,42]); // [1,2,42] - var controller = Ember.ArrayProxy.create({ content: [] }); - Ember.makeArray(controller) === controller; => true + var controller = Ember.ArrayProxy.create({ content: [] }); + Ember.makeArray(controller) === controller; // true + ``` @method makeArray @for Ember @@ -1183,6 +981,452 @@ Ember.tryInvoke = function(obj, methodName, args) { } }; +// https://github.com/emberjs/ember.js/pull/1617 +var needsFinallyFix = (function() { + var count = 0; + try{ + try { } + finally { + count++; + throw new Error('needsFinallyFixTest'); + } + } catch (e) {} + + return count !== 1; +})(); + +/** + Provides try { } finally { } functionality, while working + around Safari's double finally bug. + + @method tryFinally + @for Ember + @param {Function} function The function to run the try callback + @param {Function} function The function to run the finally callback + @param [binding] + @return {anything} The return value is the that of the finalizer, + unless that valueis undefined, in which case it is the return value + of the tryable +*/ + +if (needsFinallyFix) { + Ember.tryFinally = function(tryable, finalizer, binding) { + var result, finalResult, finalError; + + binding = binding || this; + + try { + result = tryable.call(binding); + } finally { + try { + finalResult = finalizer.call(binding); + } catch (e){ + finalError = e; + } + } + + if (finalError) { throw finalError; } + + return (finalResult === undefined) ? result : finalResult; + }; +} else { + Ember.tryFinally = function(tryable, finalizer, binding) { + var result, finalResult; + + binding = binding || this; + + try { + result = tryable.call(binding); + } finally { + finalResult = finalizer.call(binding); + } + + return (finalResult === undefined) ? result : finalResult; + }; +} + +/** + Provides try { } catch finally { } functionality, while working + around Safari's double finally bug. + + @method tryCatchFinally + @for Ember + @param {Function} function The function to run the try callback + @param {Function} function The function to run the catchable callback + @param {Function} function The function to run the finally callback + @param [binding] + @return {anything} The return value is the that of the finalizer, + unless that value is undefined, in which case it is the return value + of the tryable. +*/ +if (needsFinallyFix) { + Ember.tryCatchFinally = function(tryable, catchable, finalizer, binding) { + var result, finalResult, finalError, finalReturn; + + binding = binding || this; + + try { + result = tryable.call(binding); + } catch(error) { + result = catchable.call(binding, error); + } finally { + try { + finalResult = finalizer.call(binding); + } catch (e){ + finalError = e; + } + } + + if (finalError) { throw finalError; } + + return (finalResult === undefined) ? result : finalResult; + }; +} else { + Ember.tryCatchFinally = function(tryable, catchable, finalizer, binding) { + var result, finalResult; + + binding = binding || this; + + try { + result = tryable.call(binding); + } catch(error) { + result = catchable.call(binding, error); + } finally { + finalResult = finalizer.call(binding); + } + + return (finalResult === undefined) ? result : finalResult; + }; +} + +})(); + + + +(function() { +// Ember.tryCatchFinally + +/** + The purpose of the Ember Instrumentation module is + to provide efficient, general-purpose instrumentation + for Ember. + + Subscribe to a listener by using `Ember.subscribe`: + + ```javascript + Ember.subscribe("render", { + before: function(name, timestamp, payload) { + + }, + + after: function(name, timestamp, payload) { + + } + }); + ``` + + If you return a value from the `before` callback, that same + value will be passed as a fourth parameter to the `after` + callback. + + Instrument a block of code by using `Ember.instrument`: + + ```javascript + Ember.instrument("render.handlebars", payload, function() { + // rendering logic + }, binding); + ``` + + Event names passed to `Ember.instrument` are namespaced + by periods, from more general to more specific. Subscribers + can listen for events by whatever level of granularity they + are interested in. + + In the above example, the event is `render.handlebars`, + and the subscriber listened for all events beginning with + `render`. It would receive callbacks for events named + `render`, `render.handlebars`, `render.container`, or + even `render.handlebars.layout`. + + @class Instrumentation + @namespace Ember + @static +*/ +Ember.Instrumentation = {}; + +var subscribers = [], cache = {}; + +var populateListeners = function(name) { + var listeners = [], subscriber; + + for (var i=0, l=subscribers.length; i= 0) { + intersection.push(element); + } + }); + + return intersection; + } +}; + +})(); + + + +(function() { +/*jshint newcap:false*/ +/** +@module ember-metal +*/ + +// NOTE: There is a bug in jshint that doesn't recognize `Object()` without `new` +// as being ok unless both `newcap:false` and not `use strict`. +// https://github.com/jshint/jshint/issues/392 + +// Testing this is not ideal, but we want to use native functions +// if available, but not to use versions created by libraries like Prototype +var isNativeFunc = function(func) { + // This should probably work in all browsers likely to have ES5 array methods + return func && Function.prototype.toString.call(func).indexOf('[native code]') > -1; +}; + +// From: https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/array/map +var arrayMap = isNativeFunc(Array.prototype.map) ? Array.prototype.map : function(fun /*, thisp */) { + //"use strict"; + + if (this === void 0 || this === null) { + throw new TypeError(); + } + + var t = Object(this); + var len = t.length >>> 0; + if (typeof fun !== "function") { + throw new TypeError(); + } + + var res = new Array(len); + var thisp = arguments[1]; + for (var i = 0; i < len; i++) { + if (i in t) { + res[i] = fun.call(thisp, t[i], i, t); + } + } + + return res; +}; + +// From: https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/array/foreach +var arrayForEach = isNativeFunc(Array.prototype.forEach) ? Array.prototype.forEach : function(fun /*, thisp */) { + //"use strict"; + + if (this === void 0 || this === null) { + throw new TypeError(); + } + + var t = Object(this); + var len = t.length >>> 0; + if (typeof fun !== "function") { + throw new TypeError(); + } + + var thisp = arguments[1]; + for (var i = 0; i < len; i++) { + if (i in t) { + fun.call(thisp, t[i], i, t); + } + } +}; + +var arrayIndexOf = isNativeFunc(Array.prototype.indexOf) ? Array.prototype.indexOf : function (obj, fromIndex) { + if (fromIndex === null || fromIndex === undefined) { fromIndex = 0; } + else if (fromIndex < 0) { fromIndex = Math.max(0, this.length + fromIndex); } + for (var i = fromIndex, j = this.length; i < j; i++) { + if (this[i] === obj) { return i; } + } + return -1; +}; + +Ember.ArrayPolyfills = { + map: arrayMap, + forEach: arrayForEach, + indexOf: arrayIndexOf +}; + +if (Ember.SHIM_ES5) { + if (!Array.prototype.map) { + Array.prototype.map = arrayMap; + } + + if (!Array.prototype.forEach) { + Array.prototype.forEach = arrayForEach; + } + + if (!Array.prototype.indexOf) { + Array.prototype.indexOf = arrayIndexOf; + } +} + })(); @@ -1201,12 +1445,12 @@ Ember.tryInvoke = function(obj, methodName, args) { keys. Because it is commonly used in low-level bookkeeping, Map is implemented as a pure JavaScript object for performance. - This implementation follows the current iteration of the ES6 proposal - for maps (http://wiki.ecmascript.org/doku.php?id=harmony:simple_maps_and_sets), - with two exceptions. First, because we need our implementation to be - pleasant on older browsers, we do not use the `delete` name (using - `remove` instead). Second, as we do not have the luxury of in-VM - iteration, we implement a forEach method for iteration. + This implementation follows the current iteration of the ES6 proposal for + maps (http://wiki.ecmascript.org/doku.php?id=harmony:simple_maps_and_sets), + with two exceptions. First, because we need our implementation to be pleasant + on older browsers, we do not use the `delete` name (using `remove` instead). + Second, as we do not have the luxury of in-VM iteration, we implement a + forEach method for iteration. Map is mocked out to look like an Ember object, so you can do `Ember.Map.create()` for symmetry with other Ember classes. @@ -1235,7 +1479,7 @@ var copyMap = function(original, newObject) { }; /** - This class is used internally by Ember.js and Ember Data. + This class is used internally by Ember and Ember Data. Please do not use it at this time. We plan to clean it up and add many tests soon. @@ -1362,9 +1606,8 @@ OrderedSet.prototype = { Internally, a Map has two data structures: - `keys`: an OrderedSet of all of the existing keys - `values`: a JavaScript Object indexed by the - Ember.guidFor(key) + 1. `keys`: an OrderedSet of all of the existing keys + 2. `values`: a JavaScript Object indexed by the `Ember.guidFor(key)` When a key/value pair is added for the first time, we add the key to the `keys` OrderedSet, and create or @@ -1395,7 +1638,7 @@ Map.prototype = { @method get @param {anything} key - @return {anything} the value associated with the key, or undefined + @return {anything} the value associated with the key, or `undefined` */ get: function(key) { var values = this.values, @@ -1509,7 +1752,8 @@ var MapWithDefault = Ember.MapWithDefault = function(options) { @static @param [options] @param {anything} [options.defaultValue] - @return {Ember.MapWithDefault|Ember.Map} If options are passed, returns Ember.MapWithDefault otherwise returns Ember.Map + @return {Ember.MapWithDefault|Ember.Map} If options are passed, returns + `Ember.MapWithDefault` otherwise returns `Ember.Map` */ MapWithDefault.create = function(options) { if (options) { @@ -1576,28 +1820,28 @@ var FIRST_KEY = /^([^\.\*]+)/; // object. /** - Gets the value of a property on an object. If the property is computed, - the function will be invoked. If the property is not defined but the - object implements the unknownProperty() method then that will be invoked. + Gets the value of a property on an object. If the property is computed, + the function will be invoked. If the property is not defined but the + object implements the `unknownProperty` method then that will be invoked. If you plan to run on IE8 and older browsers then you should use this method anytime you want to retrieve a property on an object that you don't - know for sure is private. (My convention only properties beginning with - an underscore '_' are considered private.) + know for sure is private. (Properties beginning with an underscore '_' + are considered private.) On all newer browsers, you only need to use this method to retrieve properties if the property might not be defined on the object and you want - to respect the unknownProperty() handler. Otherwise you can ignore this + to respect the `unknownProperty` handler. Otherwise you can ignore this method. - Note that if the obj itself is null, this method will simply return - undefined. + Note that if the object itself is `undefined`, this method will throw + an error. @method get @for Ember @param {Object} obj The object to retrieve from. @param {String} keyName The property key to retrieve - @return {Object} the property value or null. + @return {Object} the property value or `null`. */ get = function get(obj, keyName) { // Helpers that operate with 'this' within an #each @@ -1611,6 +1855,7 @@ get = function get(obj, keyName) { } if (!obj || keyName.indexOf('.') !== -1) { + Ember.assert("Cannot call get with '"+ keyName +"' on an undefined object.", obj !== undefined); return getPath(obj, keyName); } @@ -1637,18 +1882,18 @@ get = function get(obj, keyName) { /** Sets the value of a property on an object, respecting computed properties - and notifying observers and other listeners of the change. If the - property is not defined but the object implements the unknownProperty() + and notifying observers and other listeners of the change. If the + property is not defined but the object implements the `unknownProperty` method then that will be invoked as well. If you plan to run on IE8 and older browsers then you should use this method anytime you want to set a property on an object that you don't - know for sure is private. (My convention only properties beginning with - an underscore '_' are considered private.) + know for sure is private. (Properties beginning with an underscore '_' + are considered private.) On all newer browsers, you only need to use this method to set properties if the property might not be defined on the object and you want - to respect the unknownProperty() handler. Otherwise you can ignore this + to respect the `unknownProperty` handler. Otherwise you can ignore this method. @method set @@ -1677,8 +1922,7 @@ set = function set(obj, keyName, value, tolerant) { isUnknown, currentValue; if (desc) { desc.set(obj, keyName, value); - } - else { + } else { isUnknown = 'object' === typeof obj && !(keyName in obj); // setUnknownProperty is called if `obj` is an object, @@ -1805,13 +2049,13 @@ function setPath(root, path, value, tolerant) { @private Normalizes a target/path pair to reflect that actual target/path that should - be observed, etc. This takes into account passing in global property + be observed, etc. This takes into account passing in global property paths (i.e. a path beginning with a captial letter not defined on the target) and * separators. @method normalizeTuple @for Ember - @param {Object} target The current target. May be null. + @param {Object} target The current target. May be `null`. @param {String} path A path on the target or a global property path. @return {Array} a temporary array with the normalized target/path pair. */ @@ -1834,8 +2078,8 @@ Ember.set = set; Ember.setPath = Ember.deprecateFunc('setPath is deprecated since set now supports paths', Ember.set); /** - Error-tolerant form of Ember.set. Will not blow up if any part of the - chain is undefined, null, or destroyed. + Error-tolerant form of `Ember.set`. Will not blow up if any part of the + chain is `undefined`, `null`, or destroyed. This is primarily used when syncing bindings, which may try to update after an object has been destroyed. @@ -1852,8 +2096,8 @@ Ember.trySet = function(root, path, value) { Ember.trySetPath = Ember.deprecateFunc('trySetPath has been renamed to trySet', Ember.trySet); /** - Returns true if the provided path is global (e.g., "MyApp.fooController.bar") - instead of local ("foo.bar.baz"). + Returns true if the provided path is global (e.g., `MyApp.fooController.bar`) + instead of local (`foo.bar.baz`). @method isGlobalPath @for Ember @@ -1890,7 +2134,7 @@ var MANDATORY_SETTER = Ember.ENV.MANDATORY_SETTER; /** Objects of this type can implement an interface to responds requests to - get and set. The default implementation handles simple properties. + get and set. The default implementation handles simple properties. You generally won't need to create or subclass this directly. @@ -1905,45 +2149,58 @@ var Descriptor = Ember.Descriptor = function() {}; // DEFINING PROPERTIES API // +var MANDATORY_SETTER_FUNCTION = Ember.MANDATORY_SETTER_FUNCTION = function(value) { + Ember.assert("You must use Ember.set() to access this property (of " + this + ")", false); +}; + +var DEFAULT_GETTER_FUNCTION = Ember.DEFAULT_GETTER_FUNCTION = function(name) { + return function() { + var meta = this[META_KEY]; + return meta && meta.values[name]; + }; +}; + /** @private - NOTE: This is a low-level method used by other parts of the API. You almost - never want to call this method directly. Instead you should use Ember.mixin() - to define new properties. + NOTE: This is a low-level method used by other parts of the API. You almost + never want to call this method directly. Instead you should use + `Ember.mixin()` to define new properties. - Defines a property on an object. This method works much like the ES5 - Object.defineProperty() method except that it can also accept computed + Defines a property on an object. This method works much like the ES5 + `Object.defineProperty()` method except that it can also accept computed properties and other special descriptors. - Normally this method takes only three parameters. However if you pass an - instance of Ember.Descriptor as the third param then you can pass an optional - value as the fourth parameter. This is often more efficient than creating - new descriptor hashes for each property. + Normally this method takes only three parameters. However if you pass an + instance of `Ember.Descriptor` as the third param then you can pass an + optional value as the fourth parameter. This is often more efficient than + creating new descriptor hashes for each property. ## Examples - // ES5 compatible mode - Ember.defineProperty(contact, 'firstName', { - writable: true, - configurable: false, - enumerable: true, - value: 'Charles' - }); + ```javascript + // ES5 compatible mode + Ember.defineProperty(contact, 'firstName', { + writable: true, + configurable: false, + enumerable: true, + value: 'Charles' + }); - // define a simple property - Ember.defineProperty(contact, 'lastName', undefined, 'Jolley'); + // define a simple property + Ember.defineProperty(contact, 'lastName', undefined, 'Jolley'); - // define a computed property - Ember.defineProperty(contact, 'fullName', Ember.computed(function() { - return this.firstName+' '+this.lastName; - }).property('firstName', 'lastName')); + // define a computed property + Ember.defineProperty(contact, 'fullName', Ember.computed(function() { + return this.firstName+' '+this.lastName; + }).property('firstName', 'lastName')); + ``` @method defineProperty @for Ember @param {Object} obj the object to define this property on. This may be a prototype. @param {String} keyName the name of the property - @param {Ember.Descriptor} [desc] an instance of Ember.Descriptor (typically a + @param {Ember.Descriptor} [desc] an instance of `Ember.Descriptor` (typically a computed property) or an ES5 descriptor. You must provide this or `data` but not both. @param {anything} [data] something other than a descriptor, that will @@ -1975,7 +2232,6 @@ Ember.defineProperty = function(obj, keyName, desc, data, meta) { } else { obj[keyName] = undefined; // make enumerable } - desc.setup(obj, keyName); } else { descs[keyName] = undefined; // shadow descriptor in proto if (desc == null) { @@ -1986,13 +2242,8 @@ Ember.defineProperty = function(obj, keyName, desc, data, meta) { objectDefineProperty(obj, keyName, { configurable: true, enumerable: true, - set: function() { - Ember.assert('Must use Ember.set() to access this property', false); - }, - get: function() { - var meta = this[META_KEY]; - return meta && meta.values[keyName]; - } + set: MANDATORY_SETTER_FUNCTION, + get: DEFAULT_GETTER_FUNCTION(keyName) }); } else { obj[keyName] = data; @@ -2022,84 +2273,80 @@ Ember.defineProperty = function(obj, keyName, desc, data, meta) { (function() { +// Ember.tryFinally /** @module ember-metal */ var AFTER_OBSERVERS = ':change'; var BEFORE_OBSERVERS = ':before'; + var guidFor = Ember.guidFor; var deferred = 0; -var array_Slice = [].slice; -var ObserverSet = function () { - this.targetSet = {}; -}; -ObserverSet.prototype.add = function (target, path) { - var targetSet = this.targetSet, - targetGuid = Ember.guidFor(target), - pathSet = targetSet[targetGuid]; - if (!pathSet) { - targetSet[targetGuid] = pathSet = {}; +/* + this.observerSet = { + [senderGuid]: { // variable name: `keySet` + [keyName]: listIndex + } + }, + this.observers = [ + { + sender: obj, + keyName: keyName, + eventName: eventName, + listeners: [ + [target, method, onceFlag, suspendedFlag] + ] + }, + ... + ] +*/ +function ObserverSet() { + this.clear(); +} + +ObserverSet.prototype.add = function(sender, keyName, eventName) { + var observerSet = this.observerSet, + observers = this.observers, + senderGuid = Ember.guidFor(sender), + keySet = observerSet[senderGuid], + index; + + if (!keySet) { + observerSet[senderGuid] = keySet = {}; } - if (pathSet[path]) { - return false; - } else { - return pathSet[path] = true; - } -}; -ObserverSet.prototype.clear = function () { - this.targetSet = {}; -}; - -var DeferredEventQueue = function() { - this.targetSet = {}; - this.queue = []; -}; - -DeferredEventQueue.prototype.push = function(target, eventName, keyName) { - var targetSet = this.targetSet, - queue = this.queue, - targetGuid = Ember.guidFor(target), - eventNameSet = targetSet[targetGuid], - index; - - if (!eventNameSet) { - targetSet[targetGuid] = eventNameSet = {}; - } - index = eventNameSet[eventName]; + index = keySet[keyName]; if (index === undefined) { - eventNameSet[eventName] = queue.push(Ember.deferEvent(target, eventName, [target, keyName])) - 1; - } else { - queue[index] = Ember.deferEvent(target, eventName, [target, keyName]); + index = observers.push({ + sender: sender, + keyName: keyName, + eventName: eventName, + listeners: [] + }) - 1; + keySet[keyName] = index; + } + return observers[index].listeners; +}; + +ObserverSet.prototype.flush = function() { + var observers = this.observers, i, len, observer, sender; + this.clear(); + for (i=0, len=observers.length; i < len; ++i) { + observer = observers[i]; + sender = observer.sender; + if (sender.isDestroying || sender.isDestroyed) { continue; } + Ember.sendEvent(sender, observer.eventName, [sender, observer.keyName], observer.listeners); } }; -DeferredEventQueue.prototype.flush = function() { - var queue = this.queue; - this.queue = []; - this.targetSet = {}; - for (var i=0, len=queue.length; i < len; ++i) { - queue[i](); - } +ObserverSet.prototype.clear = function() { + this.observerSet = {}; + this.observers = []; }; -var queue = new DeferredEventQueue(), beforeObserverSet = new ObserverSet(); - -function notifyObservers(obj, eventName, keyName, forceNotification) { - if (deferred && !forceNotification) { - queue.push(obj, eventName, keyName); - } else { - Ember.sendEvent(obj, eventName, [obj, keyName]); - } -} - -function flushObserverQueue() { - beforeObserverSet.clear(); - - queue.flush(); -} +var beforeObserverSet = new ObserverSet(), observerSet = new ObserverSet(); /** @method beginPropertyChanges @@ -2107,7 +2354,6 @@ function flushObserverQueue() { */ Ember.beginPropertyChanges = function() { deferred++; - return this; }; /** @@ -2115,17 +2361,22 @@ Ember.beginPropertyChanges = function() { */ Ember.endPropertyChanges = function() { deferred--; - if (deferred<=0) flushObserverQueue(); + if (deferred<=0) { + beforeObserverSet.clear(); + observerSet.flush(); + } }; /** Make a series of property changes together in an exception-safe way. - Ember.changeProperties(function() { - obj1.set('foo', mayBlowUpWhenSet); - obj2.set('bar', baz); - }); + ```javascript + Ember.changeProperties(function() { + obj1.set('foo', mayBlowUpWhenSet); + obj2.set('bar', baz); + }); + ``` @method changeProperties @param {Function} callback @@ -2133,11 +2384,7 @@ Ember.endPropertyChanges = function() { */ Ember.changeProperties = function(cb, binding){ Ember.beginPropertyChanges(); - try { - cb.call(binding); - } finally { - Ember.endPropertyChanges(); - } + Ember.tryFinally(cb, Ember.endPropertyChanges, binding); }; /** @@ -2252,28 +2499,30 @@ Ember.removeBeforeObserver = function(obj, path, target, method) { return this; }; -Ember.notifyObservers = function(obj, keyName) { - if (obj.isDestroying) { return; } - - notifyObservers(obj, changeEvent(keyName), keyName); -}; - Ember.notifyBeforeObservers = function(obj, keyName) { if (obj.isDestroying) { return; } - var guid, set, forceNotification = false; - + var eventName = beforeEvent(keyName), listeners, listenersDiff; if (deferred) { - if (beforeObserverSet.add(obj, keyName)) { - forceNotification = true; - } else { - return; - } + listeners = beforeObserverSet.add(obj, keyName, eventName); + listenersDiff = Ember.listenersDiff(obj, eventName, listeners); + Ember.sendEvent(obj, eventName, [obj, keyName], listenersDiff); + } else { + Ember.sendEvent(obj, eventName, [obj, keyName]); } - - notifyObservers(obj, beforeEvent(keyName), keyName, forceNotification); }; +Ember.notifyObservers = function(obj, keyName) { + if (obj.isDestroying) { return; } + + var eventName = changeEvent(keyName), listeners; + if (deferred) { + listeners = observerSet.add(obj, keyName, eventName); + Ember.listenersUnion(obj, eventName, listeners); + } else { + Ember.sendEvent(obj, eventName, [obj, keyName]); + } +}; })(); @@ -2314,8 +2563,6 @@ function isKeyName(path) { // DEPENDENT KEYS // -var DEP_SKIP = { __emberproto__: true }; // skip some keys and toString - function iterDeps(method, obj, depKey, seen, meta) { var guid = guidFor(obj); @@ -2327,7 +2574,6 @@ function iterDeps(method, obj, depKey, seen, meta) { deps = deps && deps[depKey]; if (deps) { for(var key in deps) { - if (DEP_SKIP[key]) continue; var desc = meta.descs[key]; if (desc && desc._suspended === obj) continue; method(obj, key); @@ -2363,30 +2609,39 @@ function dependentKeysDidChange(obj, depKey, meta) { // function addChainWatcher(obj, keyName, node) { - if (!obj || ('object' !== typeof obj)) return; // nothing to do - var m = metaFor(obj); - var nodes = m.chainWatchers; - if (!nodes || nodes.__emberproto__ !== obj) { - nodes = m.chainWatchers = { __emberproto__: obj }; + if (!obj || ('object' !== typeof obj)) { return; } // nothing to do + + var m = metaFor(obj), nodes = m.chainWatchers; + + if (!m.hasOwnProperty('chainWatchers')) { + nodes = m.chainWatchers = {}; } - if (!nodes[keyName]) { nodes[keyName] = {}; } - nodes[keyName][guidFor(node)] = node; + if (!nodes[keyName]) { nodes[keyName] = []; } + nodes[keyName].push(node); Ember.watch(obj, keyName); } function removeChainWatcher(obj, keyName, node) { if (!obj || 'object' !== typeof obj) { return; } // nothing to do - var m = metaFor(obj, false), - nodes = m.chainWatchers; - if (!nodes || nodes.__emberproto__ !== obj) { return; } //nothing to do - if (nodes[keyName]) { delete nodes[keyName][guidFor(node)]; } + + var m = metaFor(obj, false); + if (!m.hasOwnProperty('chainWatchers')) { return; } // nothing to do + + var nodes = m.chainWatchers; + + if (nodes[keyName]) { + nodes = nodes[keyName]; + for (var i = 0, l = nodes.length; i < l; i++) { + if (nodes[i] === node) { nodes.splice(i, 1); } + } + } Ember.unwatch(obj, keyName); } var pendingQueue = []; -// attempts to add the pendingQueue chains again. If some of them end up +// attempts to add the pendingQueue chains again. If some of them end up // back in the queue and reschedule is true, schedules a timeout to try // again. function flushPendingChains() { @@ -2404,10 +2659,10 @@ function isProto(pvalue) { return metaFor(pvalue, false).proto === pvalue; } -// A ChainNode watches a single key on an object. If you provide a starting -// value for the key then the node won't actually watch it. For a root node +// A ChainNode watches a single key on an object. If you provide a starting +// value for the key then the node won't actually watch it. For a root node // pass null for parent and key and object for value. -var ChainNode = function(parent, key, value, separator) { +var ChainNode = function(parent, key, value) { var obj; this._parent = parent; this._key = key; @@ -2421,7 +2676,6 @@ var ChainNode = function(parent, key, value, separator) { this._watching = value===undefined; this._value = value; - this._separator = separator || '.'; this._paths = {}; if (this._watching) { this._object = parent.value(); @@ -2458,7 +2712,7 @@ ChainNodePrototype.destroy = function() { // copies a top level object only ChainNodePrototype.copy = function(obj) { - var ret = new ChainNode(null, null, obj, this._separator), + var ret = new ChainNode(null, null, obj), paths = this._paths, path; for (path in paths) { if (paths[path] <= 0) { continue; } // this check will also catch non-number vals. @@ -2470,7 +2724,7 @@ ChainNodePrototype.copy = function(obj) { // called on the root node of a chain to setup watchers on the specified // path. ChainNodePrototype.add = function(path) { - var obj, tuple, key, src, separator, paths; + var obj, tuple, key, src, paths; paths = this._paths; paths[path] = (paths[path] || 0) + 1; @@ -2495,12 +2749,11 @@ ChainNodePrototype.add = function(path) { } else { src = tuple[0]; key = path.slice(0, 0-(tuple[1].length+1)); - separator = path.slice(key.length, key.length+1); path = tuple[1]; } tuple.length = 0; - this.chain(key, path, src, separator); + this.chain(key, path, src); }; // called on the root node of a chain to teardown watcher on the specified @@ -2529,12 +2782,12 @@ ChainNodePrototype.remove = function(path) { ChainNodePrototype.count = 0; -ChainNodePrototype.chain = function(key, path, src, separator) { +ChainNodePrototype.chain = function(key, path, src) { var chains = this._chains, node; if (!chains) { chains = this._chains = {}; } node = chains[key]; - if (!node) { node = chains[key] = new ChainNode(this, key, src, separator); } + if (!node) { node = chains[key] = new ChainNode(this, key, src); } node.count++; // count chains... // chain rest of path if there is one @@ -2577,7 +2830,7 @@ ChainNodePrototype.willChange = function() { }; ChainNodePrototype.chainWillChange = function(chain, path, depth) { - if (this._key) { path = this._key + this._separator + path; } + if (this._key) { path = this._key + '.' + path; } if (this._parent) { this._parent.chainWillChange(this, path, depth+1); @@ -2589,7 +2842,7 @@ ChainNodePrototype.chainWillChange = function(chain, path, depth) { }; ChainNodePrototype.chainDidChange = function(chain, path, depth) { - if (this._key) { path = this._key + this._separator + path; } + if (this._key) { path = this._key + '.' + path; } if (this._parent) { this._parent.chainDidChange(this, path, depth+1); } else { @@ -2631,7 +2884,7 @@ ChainNodePrototype.didChange = function(suppressEvent) { if (this._parent) { this._parent.chainDidChange(this, this._key, 1); } }; -// get the chains for the current object. If the current object has +// get the chains for the current object. If the current object has // chains inherited from the proto they will be cloned and reconfigured for // the current object. function chainsFor(obj) { @@ -2644,30 +2897,35 @@ function chainsFor(obj) { return ret; } -function notifyChains(obj, m, keyName, methodName, arg) { - var nodes = m.chainWatchers; +Ember.overrideChains = function(obj, keyName, m) { + chainsDidChange(obj, keyName, m, true); +}; - if (!nodes || nodes.__emberproto__ !== obj) { return; } // nothing to do +function chainsWillChange(obj, keyName, m, arg) { + if (!m.hasOwnProperty('chainWatchers')) { return; } // nothing to do + + var nodes = m.chainWatchers; nodes = nodes[keyName]; if (!nodes) { return; } - for(var key in nodes) { - if (!nodes.hasOwnProperty(key)) { continue; } - nodes[key][methodName](arg); + for(var i = 0, l = nodes.length; i < l; i++) { + nodes[i].willChange(arg); } } -Ember.overrideChains = function(obj, keyName, m) { - notifyChains(obj, m, keyName, 'didChange', true); -}; +function chainsDidChange(obj, keyName, m, arg) { + if (!m.hasOwnProperty('chainWatchers')) { return; } // nothing to do -function chainsWillChange(obj, keyName, m) { - notifyChains(obj, m, keyName, 'willChange'); -} + var nodes = m.chainWatchers; -function chainsDidChange(obj, keyName, m) { - notifyChains(obj, m, keyName, 'didChange'); + nodes = nodes[keyName]; + if (!nodes) { return; } + + // looping in reverse because the chainWatchers array can be modified inside didChange + for (var i = nodes.length - 1; i >= 0; i--) { + nodes[i].didChange(arg); + } } // .......................................................... @@ -2677,11 +2935,11 @@ function chainsDidChange(obj, keyName, m) { /** @private - Starts watching a property on an object. Whenever the property changes, - invokes Ember.propertyWillChange and Ember.propertyDidChange. This is the + Starts watching a property on an object. Whenever the property changes, + invokes `Ember.propertyWillChange` and `Ember.propertyDidChange`. This is the primitive used by observers and dependent keys; usually you will never call this method directly but instead use higher level methods like - Ember.addObserver(). + `Ember.addObserver()` @method watch @for Ember @@ -2692,15 +2950,12 @@ Ember.watch = function(obj, keyName) { // can't watch length on Array - it is special... if (keyName === 'length' && Ember.typeOf(obj) === 'array') { return this; } - var m = metaFor(obj), watching = m.watching, desc; + var m = metaFor(obj), watching = m.watching; // activate watching first time if (!watching[keyName]) { watching[keyName] = 1; if (isKeyName(keyName)) { - desc = m.descs[keyName]; - if (desc && desc.willWatch) { desc.willWatch(obj, keyName); } - if ('function' === typeof obj.willWatchProperty) { obj.willWatchProperty(keyName); } @@ -2710,13 +2965,8 @@ Ember.watch = function(obj, keyName) { o_defineProperty(obj, keyName, { configurable: true, enumerable: true, - set: function() { - Ember.assert('Must use Ember.set() to access this property', false); - }, - get: function() { - var meta = this[META_KEY]; - return meta && meta.values[keyName]; - } + set: Ember.MANDATORY_SETTER_FUNCTION, + get: Ember.DEFAULT_GETTER_FUNCTION(keyName) }); } } else { @@ -2740,15 +2990,12 @@ Ember.unwatch = function(obj, keyName) { // can't watch length on Array - it is special... if (keyName === 'length' && Ember.typeOf(obj) === 'array') { return this; } - var m = metaFor(obj), watching = m.watching, desc; + var m = metaFor(obj), watching = m.watching; if (watching[keyName] === 1) { watching[keyName] = 0; if (isKeyName(keyName)) { - desc = m.descs[keyName]; - if (desc && desc.didUnwatch) { desc.didUnwatch(obj, keyName); } - if ('function' === typeof obj.didUnwatchProperty) { obj.didUnwatchProperty(keyName); } @@ -2776,8 +3023,8 @@ Ember.unwatch = function(obj, keyName) { /** @private - Call on an object when you first beget it from another object. This will - setup any chained watchers on the object instance as needed. This method is + Call on an object when you first beget it from another object. This will + setup any chained watchers on the object instance as needed. This method is safe to call multiple times. @method rewatch @@ -2935,6 +3182,7 @@ Ember.warn("The CP_DEFAULT_CACHEABLE flag has been removed and computed properti var get = Ember.get, + set = Ember.set, metaFor = Ember.meta, guidFor = Ember.guidFor, a_slice = [].slice, @@ -2951,9 +3199,7 @@ var get = Ember.get, // meta.deps = { // 'depKey': { // 'keyName': count, -// __emberproto__: SRC_OBJ [to detect clones] -// }, -// __emberproto__: SRC_OBJ +// } // } /* @@ -2965,12 +3211,11 @@ function keysForDep(obj, depsMeta, depKey) { if (!keys) { // if there are no dependencies yet for a the given key // create a new empty list of dependencies for the key - keys = depsMeta[depKey] = { __emberproto__: obj }; - } else if (keys.__emberproto__ !== obj) { + keys = depsMeta[depKey] = {}; + } else if (!depsMeta.hasOwnProperty(depKey)) { // otherwise if the dependency list is inherited from // a superclass, clone the hash keys = depsMeta[depKey] = o_create(keys); - keys.__emberproto__ = obj; } return keys; } @@ -2982,12 +3227,11 @@ function metaForDeps(obj, meta) { if (!deps) { // initialize the dependencies with a pointer back to // the current object - deps = meta.deps = { __emberproto__: obj }; - } else if (deps.__emberproto__ !== obj) { + deps = meta.deps = {}; + } else if (!meta.hasOwnProperty('deps')) { // otherwise if the dependencies are inherited from the // object's superclass, clone the deps deps = meta.deps = o_create(deps); - deps.__emberproto__ = obj; } return deps; } @@ -3052,24 +3296,26 @@ ComputedProperty.prototype = new Ember.Descriptor(); var ComputedPropertyPrototype = ComputedProperty.prototype; /** - Call on a computed property to set it into cacheable mode. When in this + Call on a computed property to set it into cacheable mode. When in this mode the computed property will automatically cache the return value of your function until one of the dependent keys changes. - MyApp.president = Ember.Object.create({ - fullName: function() { - return this.get('firstName') + ' ' + this.get('lastName'); + ```javascript + MyApp.president = Ember.Object.create({ + fullName: function() { + return this.get('firstName') + ' ' + this.get('lastName'); - // After calculating the value of this function, Ember.js will - // return that value without re-executing this function until - // one of the dependent properties change. - }.property('firstName', 'lastName') - }); + // After calculating the value of this function, Ember will + // return that value without re-executing this function until + // one of the dependent properties change. + }.property('firstName', 'lastName') + }); + ``` Properties are cacheable by default. @method cacheable - @param {Boolean} aFlag optional set to false to disable caching + @param {Boolean} aFlag optional set to `false` to disable caching @chainable */ ComputedPropertyPrototype.cacheable = function(aFlag) { @@ -3078,14 +3324,16 @@ ComputedPropertyPrototype.cacheable = function(aFlag) { }; /** - Call on a computed property to set it into non-cached mode. When in this + Call on a computed property to set it into non-cached mode. When in this mode the computed property will not automatically cache the return value. - MyApp.outsideService = Ember.Object.create({ - value: function() { - return OutsideService.getValue(); - }.property().volatile() - }); + ```javascript + MyApp.outsideService = Ember.Object.create({ + value: function() { + return OutsideService.getValue(); + }.property().volatile() + }); + ``` @method volatile @chainable @@ -3095,17 +3343,19 @@ ComputedPropertyPrototype.volatile = function() { }; /** - Sets the dependent keys on this computed property. Pass any number of + Sets the dependent keys on this computed property. Pass any number of arguments containing key paths that this computed property depends on. - MyApp.president = Ember.Object.create({ - fullName: Ember.computed(function() { - return this.get('firstName') + ' ' + this.get('lastName'); + ```javascript + MyApp.president = Ember.Object.create({ + fullName: Ember.computed(function() { + return this.get('firstName') + ' ' + this.get('lastName'); - // Tell Ember.js that this computed property depends on firstName - // and lastName - }).property('firstName', 'lastName') - }); + // Tell Ember that this computed property depends on firstName + // and lastName + }).property('firstName', 'lastName') + }); + ``` @method property @param {String} path* zero or more property paths @@ -3128,10 +3378,12 @@ ComputedPropertyPrototype.property = function() { You can pass a hash of these values to a computed property like this: - person: function() { - var personId = this.get('personId'); - return App.Person.create({ id: personId }); - }.property().meta({ type: App.Person }) + ``` + person: function() { + var personId = this.get('personId'); + return App.Person.create({ id: personId }); + }.property().meta({ type: App.Person }) + ``` The hash that you pass to the `meta()` function will be saved on the computed property descriptor under the `_meta` key. Ember runtime @@ -3152,25 +3404,6 @@ ComputedPropertyPrototype.meta = function(meta) { } }; -/* impl descriptor API */ -ComputedPropertyPrototype.willWatch = function(obj, keyName) { - // watch already creates meta for this instance - var meta = obj[META_KEY]; - Ember.assert('watch should have setup meta to be writable', meta.source === obj); - if (!(keyName in meta.cache)) { - addDependentKeys(this, obj, keyName, meta); - } -}; - -ComputedPropertyPrototype.didUnwatch = function(obj, keyName) { - var meta = obj[META_KEY]; - Ember.assert('unwatch should have setup meta to be writable', meta.source === obj); - if (!(keyName in meta.cache)) { - // unwatch already creates meta for this instance - removeDependentKeys(this, obj, keyName, meta); - } -}; - /* impl descriptor API */ ComputedPropertyPrototype.didChange = function(obj, keyName) { // _suspended is set via a CP.set to ensure we don't clear @@ -3179,9 +3412,7 @@ ComputedPropertyPrototype.didChange = function(obj, keyName) { var meta = metaFor(obj); if (keyName in meta.cache) { delete meta.cache[keyName]; - if (!meta.watching[keyName]) { - removeDependentKeys(this, obj, keyName, meta); - } + removeDependentKeys(this, obj, keyName, meta); } } }; @@ -3194,9 +3425,7 @@ ComputedPropertyPrototype.get = function(obj, keyName) { cache = meta.cache; if (keyName in cache) { return cache[keyName]; } ret = cache[keyName] = this.func.call(obj, keyName); - if (!meta.watching[keyName]) { - addDependentKeys(this, obj, keyName, meta); - } + addDependentKeys(this, obj, keyName, meta); } else { ret = this.func.call(obj, keyName); } @@ -3206,33 +3435,53 @@ ComputedPropertyPrototype.get = function(obj, keyName) { /* impl descriptor API */ ComputedPropertyPrototype.set = function(obj, keyName, value) { var cacheable = this._cacheable, + func = this.func, meta = metaFor(obj, cacheable), watched = meta.watching[keyName], oldSuspended = this._suspended, hadCachedValue = false, - ret; - this._suspended = obj; - try { - ret = this.func.call(obj, keyName, value); + cache = meta.cache, + cachedValue, ret; - if (cacheable && keyName in meta.cache) { - if (meta.cache[keyName] === ret) { - return; - } + this._suspended = obj; + + try { + if (cacheable && cache.hasOwnProperty(keyName)) { + cachedValue = cache[keyName]; hadCachedValue = true; } + // Check if the CP has been wrapped + if (func.wrappedFunction) { func = func.wrappedFunction; } + + // For backwards-compatibility with computed properties + // that check for arguments.length === 2 to determine if + // they are being get or set, only pass the old cached + // value if the computed property opts into a third + // argument. + if (func.length === 3) { + ret = func.call(obj, keyName, value, cachedValue); + } else if (func.length === 2) { + ret = func.call(obj, keyName, value); + } else { + Ember.defineProperty(obj, keyName, null, cachedValue); + Ember.set(obj, keyName, value); + return; + } + + if (hadCachedValue && cachedValue === ret) { return; } + if (watched) { Ember.propertyWillChange(obj, keyName); } - if (cacheable && hadCachedValue) { - delete meta.cache[keyName]; + if (hadCachedValue) { + delete cache[keyName]; } if (cacheable) { - if (!watched && !hadCachedValue) { + if (!hadCachedValue) { addDependentKeys(this, obj, keyName, meta); } - meta.cache[keyName] = ret; + cache[keyName] = ret; } if (watched) { Ember.propertyDidChange(obj, keyName); } @@ -3242,19 +3491,11 @@ ComputedPropertyPrototype.set = function(obj, keyName, value) { return ret; }; -/* called when property is defined */ -ComputedPropertyPrototype.setup = function(obj, keyName) { - var meta = obj[META_KEY]; - if (meta && meta.watching[keyName]) { - addDependentKeys(this, obj, keyName, metaFor(obj)); - } -}; - /* called before property is overridden */ ComputedPropertyPrototype.teardown = function(obj, keyName) { var meta = metaFor(obj); - if (meta.watching[keyName] || keyName in meta.cache) { + if (keyName in meta.cache) { removeDependentKeys(this, obj, keyName, meta); } @@ -3266,12 +3507,12 @@ ComputedPropertyPrototype.teardown = function(obj, keyName) { /** This helper returns a new property descriptor that wraps the passed - computed property function. You can use this helper to define properties - with mixins or via Ember.defineProperty(). + computed property function. You can use this helper to define properties + with mixins or via `Ember.defineProperty()`. The function you pass will be used to both get and set property values. - The function should accept two parameters, key and value. If value is not - undefined you should set the value first. In either case return the + The function should accept two parameters, key and value. If value is not + undefined you should set the value first. In either case return the current value of the property. @method computed @@ -3306,7 +3547,7 @@ Ember.computed = function(func) { @for Ember @param {Object} obj the object whose property you want to check @param {String} key the name of the property whose cached value you want - to return + to return */ Ember.cacheFor = function cacheFor(obj, key) { var cache = metaFor(obj, false).cache; @@ -3350,6 +3591,22 @@ Ember.computed.bool = function(dependentKey) { }); }; +/** + @method computed.alias + @for Ember + @param {String} dependentKey +*/ +Ember.computed.alias = function(dependentKey) { + return Ember.computed(dependentKey, function(key, value){ + if (arguments.length === 1) { + return get(this, dependentKey); + } else { + set(this, dependentKey, value); + return value; + } + }); +}; + })(); @@ -3360,10 +3617,9 @@ Ember.computed.bool = function(dependentKey) { */ var o_create = Ember.create, - meta = Ember.meta, + metaFor = Ember.meta, metaPath = Ember.metaPath, - guidFor = Ember.guidFor, - a_slice = [].slice; + META_KEY = Ember.META_KEY; /* The event system uses a series of nested hashes to store listeners on an @@ -3374,75 +3630,84 @@ var o_create = Ember.create, // Object's meta hash { - listeners: { // variable name: `listenerSet` - "foo:changed": { // variable name: `targetSet` - [targetGuid]: { // variable name: `actionSet` - [methodGuid]: { // variable name: `action` - target: [Object object], - method: [Function function] - } - } - } + listeners: { // variable name: `listenerSet` + "foo:changed": [ // variable name: `actions` + [target, method, onceFlag, suspendedFlag] + ] } } */ -// Gets the set of all actions, keyed on the guid of each action's -// method property. -function actionSetFor(obj, eventName, target, writable) { - return metaPath(obj, ['listeners', eventName, guidFor(target)], writable); +function indexOf(array, target, method) { + var index = -1; + for (var i = 0, l = array.length; i < l; i++) { + if (target === array[i][0] && method === array[i][1]) { index = i; break; } + } + return index; } -// Gets the set of all targets, keyed on the guid of each action's -// target property. -function targetSetFor(obj, eventName) { - var listenerSet = meta(obj, false).listeners; - if (!listenerSet) { return false; } +function actionsFor(obj, eventName) { + var meta = metaFor(obj, true), + actions; - return listenerSet[eventName] || false; + if (!meta.listeners) { meta.listeners = {}; } + + if (!meta.hasOwnProperty('listeners')) { + // setup inherited copy of the listeners object + meta.listeners = o_create(meta.listeners); + } + + actions = meta.listeners[eventName]; + + // if there are actions, but the eventName doesn't exist in our listeners, then copy them from the prototype + if (actions && !meta.listeners.hasOwnProperty(eventName)) { + actions = meta.listeners[eventName] = meta.listeners[eventName].slice(); + } else if (!actions) { + actions = meta.listeners[eventName] = []; + } + + return actions; } -// TODO: This knowledge should really be a part of the -// meta system. -var SKIP_PROPERTIES = { __ember_source__: true }; +function actionsUnion(obj, eventName, otherActions) { + var meta = obj[META_KEY], + actions = meta && meta.listeners && meta.listeners[eventName]; -function iterateSet(obj, eventName, callback, params) { - var targetSet = targetSetFor(obj, eventName); - if (!targetSet) { return false; } - // Iterate through all elements of the target set - for(var targetGuid in targetSet) { - if (SKIP_PROPERTIES[targetGuid]) { continue; } + if (!actions) { return; } + for (var i = actions.length - 1; i >= 0; i--) { + var target = actions[i][0], + method = actions[i][1], + once = actions[i][2], + suspended = actions[i][3], + actionIndex = indexOf(otherActions, target, method); - var actionSet = targetSet[targetGuid]; - if (actionSet) { - // Iterate through the elements of the action set - for(var methodGuid in actionSet) { - if (SKIP_PROPERTIES[methodGuid]) { continue; } - - var action = actionSet[methodGuid]; - if (action) { - if (callback(action, params, obj) === true) { - return true; - } - } - } + if (actionIndex === -1) { + otherActions.push([target, method, once, suspended]); } } - return false; } -function invokeAction(action, params, sender) { - var method = action.method, target = action.target; - // If there is no target, the target is the object - // on which the event was fired. - if (!target) { target = sender; } - if ('string' === typeof method) { method = target[method]; } - if (params) { - method.apply(target, params); - } else { - method.apply(target); +function actionsDiff(obj, eventName, otherActions) { + var meta = obj[META_KEY], + actions = meta && meta.listeners && meta.listeners[eventName], + diffActions = []; + + if (!actions) { return; } + for (var i = actions.length - 1; i >= 0; i--) { + var target = actions[i][0], + method = actions[i][1], + once = actions[i][2], + suspended = actions[i][3], + actionIndex = indexOf(otherActions, target, method); + + if (actionIndex !== -1) { continue; } + + otherActions.push([target, method, once, suspended]); + diffActions.push([target, method, once, suspended]); } + + return diffActions; } /** @@ -3455,7 +3720,7 @@ function invokeAction(action, params, sender) { @param {Object|Function} targetOrMethod A target object or a function @param {Function|String} method A function or the name of a function to be called on `target` */ -function addListener(obj, eventName, target, method, guid) { +function addListener(obj, eventName, target, method, once) { Ember.assert("You must pass at least an object and event name to Ember.addListener", !!obj && !!eventName); if (!method && 'function' === typeof target) { @@ -3463,14 +3728,12 @@ function addListener(obj, eventName, target, method, guid) { target = null; } - var actionSet = actionSetFor(obj, eventName, target, true), - // guid is used in case we wrapp given method to register - // listener with method guid instead of the wrapper guid - methodGuid = guid || guidFor(method); + var actions = actionsFor(obj, eventName), + actionIndex = indexOf(actions, target, method); - if (!actionSet[methodGuid]) { - actionSet[methodGuid] = { target: target, method: method }; - } + if (actionIndex !== -1) { return; } + + actions.push([target, method, once, undefined]); if ('function' === typeof obj.didAddListener) { obj.didAddListener(eventName, target, method); @@ -3497,13 +3760,14 @@ function removeListener(obj, eventName, target, method) { target = null; } - function _removeListener(target, method) { - var actionSet = actionSetFor(obj, eventName, target, true), - methodGuid = guidFor(method); + function _removeListener(target, method, once) { + var actions = actionsFor(obj, eventName), + actionIndex = indexOf(actions, target, method); - // we can't simply delete this parameter, because if we do, we might - // re-expose the property from the prototype chain. - if (actionSet && actionSet[methodGuid]) { actionSet[methodGuid] = null; } + // action doesn't exist, give up silently + if (actionIndex === -1) { return; } + + actions.splice(actionIndex, 1); if ('function' === typeof obj.didRemoveListener) { obj.didRemoveListener(eventName, target, method); @@ -3513,9 +3777,13 @@ function removeListener(obj, eventName, target, method) { if (method) { _removeListener(target, method); } else { - iterateSet(obj, eventName, function(action) { - _removeListener(action.target, action.method); - }); + var meta = obj[META_KEY], + actions = meta && meta.listeners && meta.listeners[eventName]; + + if (!actions) { return; } + for (var i = actions.length - 1; i >= 0; i--) { + _removeListener(actions[i][0], actions[i][1]); + } } } @@ -3543,16 +3811,20 @@ function suspendListener(obj, eventName, target, method, callback) { target = null; } - var actionSet = actionSetFor(obj, eventName, target, true), - methodGuid = guidFor(method), - action = actionSet && actionSet[methodGuid]; + var actions = actionsFor(obj, eventName), + actionIndex = indexOf(actions, target, method), + action; - actionSet[methodGuid] = null; - try { - return callback.call(target); - } finally { - actionSet[methodGuid] = action; + if (actionIndex !== -1) { + action = actions[actionIndex].slice(); // copy it, otherwise we're modifying a shared object + action[3] = true; // mark the action as suspended + actions[actionIndex] = action; // replace the shared object with our copy } + + function tryable() { return callback.call(target); } + function finalizer() { if (action) { action[3] = undefined; } } + + return Ember.tryFinally(tryable, finalizer); } /** @@ -3579,29 +3851,31 @@ function suspendListeners(obj, eventNames, target, method, callback) { target = null; } - var oldActions = [], - actionSets = [], - eventName, actionSet, methodGuid, action, i, l; + var suspendedActions = [], + eventName, actions, action, i, l; for (i=0, l=eventNames.length; i= 0; i--) { // looping in reverse for once listeners + if (!actions[i] || actions[i][3] === true) { continue; } + + var target = actions[i][0], + method = actions[i][1], + once = actions[i][2]; + + if (once) { removeListener(obj, eventName, target, method); } + if (!target) { target = obj; } + if ('string' === typeof method) { method = target[method]; } + if (params) { + method.apply(target, params); + } else { + method.apply(target); + } + } return true; } -/** - @private - @method deferEvent - @for Ember - @param obj - @param {String} eventName - @param {Array} params -*/ -function deferEvent(obj, eventName, params) { - var actions = []; - iterateSet(obj, eventName, function (action) { - actions.push(action); - }); - - return function() { - if (obj.isDestroyed) { return; } - - if (obj !== Ember && 'function' === typeof obj.sendEvent) { - obj.sendEvent(eventName, params); - } - - for (var i=0, len=actions.length; i < len; ++i) { - invokeAction(actions[i], params, obj); - } - }; -} - /** @private @method hasListeners @@ -3679,15 +3946,10 @@ function deferEvent(obj, eventName, params) { @param {String} eventName */ function hasListeners(obj, eventName) { - if (iterateSet(obj, eventName, function() { return true; })) { - return true; - } + var meta = obj[META_KEY], + actions = meta && meta.listeners && meta.listeners[eventName]; - // no listeners! might as well clean this up so it is faster later. - var set = metaPath(obj, ['listeners'], true); - set[eventName] = null; - - return false; + return !!(actions && actions.length); } /** @@ -3699,9 +3961,17 @@ function hasListeners(obj, eventName) { */ function listenersFor(obj, eventName) { var ret = []; - iterateSet(obj, eventName, function (action) { - ret.push([action.target, action.method]); - }); + var meta = obj[META_KEY], + actions = meta && meta.listeners && meta.listeners[eventName]; + + if (!actions) { return ret; } + + for (var i = 0, l = actions.length; i < l; i++) { + var target = actions[i][0], + method = actions[i][1]; + ret.push([target, method]); + } + return ret; } @@ -3713,7 +3983,8 @@ Ember.sendEvent = sendEvent; Ember.hasListeners = hasListeners; Ember.watchedEvents = watchedEvents; Ember.listenersFor = listenersFor; -Ember.deferEvent = deferEvent; +Ember.listenersDiff = actionsDiff; +Ember.listenersUnion = actionsUnion; })(); @@ -3723,7 +3994,7 @@ Ember.deferEvent = deferEvent; // Ember.Logger // Ember.watch.flushPending // Ember.beginPropertyChanges, Ember.endPropertyChanges -// Ember.guidFor +// Ember.guidFor, Ember.tryFinally /** @module ember-metal @@ -3825,24 +4096,25 @@ RunLoop.prototype = { invoke(item.target, item.method, item.args); } + function tryable() { + forEach.call(queue, iter); + } + Ember.watch.flushPending(); // make sure all chained watchers are setup if (queueName) { while (this._queues && (queue = this._queues[queueName])) { this._queues[queueName] = null; - // the sync phase is to allow property changes to propagate. don't + // the sync phase is to allow property changes to propagate. don't // invoke observers until that is finished. if (queueName === 'sync') { log = Ember.LOG_BINDINGS; if (log) { Ember.Logger.log('Begin: Flush Sync Queue'); } Ember.beginPropertyChanges(); - try { - forEach.call(queue, iter); - } finally { - Ember.endPropertyChanges(); - } + + Ember.tryFinally(tryable, Ember.endPropertyChanges); if (log) { Ember.Logger.log('End: Flush Sync Queue'); } @@ -3863,18 +4135,15 @@ RunLoop.prototype = { delete this._queues[queueName]; if (queue) { - // the sync phase is to allow property changes to propagate. don't + // the sync phase is to allow property changes to propagate. don't // invoke observers until that is finished. if (queueName === 'sync') { log = Ember.LOG_BINDINGS; if (log) { Ember.Logger.log('Begin: Flush Sync Queue'); } Ember.beginPropertyChanges(); - try { - forEach.call(queue, iter); - } finally { - Ember.endPropertyChanges(); - } + + Ember.tryFinally(tryable, Ember.endPropertyChanges); if (log) { Ember.Logger.log('End: Flush Sync Queue'); } } else { @@ -3913,14 +4182,16 @@ Ember.RunLoop = RunLoop; deferred actions including bindings and views updates are flushed at the end. - Normally you should not need to invoke this method yourself. However if + Normally you should not need to invoke this method yourself. However if you are implementing raw event handlers when interfacing with other libraries or plugins, you should probably wrap all of your code inside this call. - Ember.run(function(){ - // code to be execute within a RunLoop - }); + ```javascript + Ember.run(function(){ + // code to be execute within a RunLoop + }); + ``` @class run @namespace Ember @@ -3928,33 +4199,38 @@ Ember.RunLoop = RunLoop; @constructor @param {Object} [target] target of method to call @param {Function|String} method Method to invoke. - May be a function or a string. If you pass a string + May be a function or a string. If you pass a string then it will be looked up on the passed target. @param {Object} [args*] Any additional arguments you wish to pass to the method. @return {Object} return value from invoking the passed function. */ Ember.run = function(target, method) { - var ret, loop; + var loop, + args = arguments; run.begin(); - try { - if (target || method) { ret = invoke(target, method, arguments, 2); } - } finally { - run.end(); + + function tryable() { + if (target || method) { + return invoke(target, method, args, 2); + } } - return ret; + + return Ember.tryFinally(tryable, run.end); }; var run = Ember.run; /** - Begins a new RunLoop. Any deferred actions invoked after the begin will - be buffered until you invoke a matching call to Ember.run.end(). This is - an lower-level way to use a RunLoop instead of using Ember.run(). + Begins a new RunLoop. Any deferred actions invoked after the begin will + be buffered until you invoke a matching call to `Ember.run.end()`. This is + an lower-level way to use a RunLoop instead of using `Ember.run()`. - Ember.run.begin(); - // code to be execute within a RunLoop - Ember.run.end(); + ```javascript + Ember.run.begin(); + // code to be execute within a RunLoop + Ember.run.end(); + ``` @method begin @return {void} @@ -3964,31 +4240,32 @@ Ember.run.begin = function() { }; /** - Ends a RunLoop. This must be called sometime after you call Ember.run.begin() - to flush any deferred actions. This is a lower-level way to use a RunLoop - instead of using Ember.run(). + Ends a RunLoop. This must be called sometime after you call + `Ember.run.begin()` to flush any deferred actions. This is a lower-level way + to use a RunLoop instead of using `Ember.run()`. - Ember.run.begin(); - // code to be execute within a RunLoop - Ember.run.end(); + ```javascript + Ember.run.begin(); + // code to be execute within a RunLoop + Ember.run.end(); + ``` @method end @return {void} */ Ember.run.end = function() { Ember.assert('must have a current run loop', run.currentRunLoop); - try { - run.currentRunLoop.end(); - } - finally { - run.currentRunLoop = run.currentRunLoop.prev(); - } + + function tryable() { run.currentRunLoop.end(); } + function finalizer() { run.currentRunLoop = run.currentRunLoop.prev(); } + + Ember.tryFinally(tryable, finalizer); }; /** - Array of named queues. This array determines the order in which queues - are flushed at the end of the RunLoop. You can define your own queues by - simply adding the queue name to this array. Normally you should not need + Array of named queues. This array determines the order in which queues + are flushed at the end of the RunLoop. You can define your own queues by + simply adding the queue name to this array. Normally you should not need to inspect or modify this property. @property queues @@ -3999,38 +4276,38 @@ Ember.run.queues = ['sync', 'actions', 'destroy', 'timers']; /** Adds the passed target/method and any optional arguments to the named - queue to be executed at the end of the RunLoop. If you have not already + queue to be executed at the end of the RunLoop. If you have not already started a RunLoop when calling this method one will be started for you automatically. At the end of a RunLoop, any methods scheduled in this way will be invoked. Methods will be invoked in an order matching the named queues defined in - the run.queues property. + the `run.queues` property. - Ember.run.schedule('timers', this, function(){ - // this will be executed at the end of the RunLoop, when timers are run - console.log("scheduled on timers queue"); - }); - Ember.run.schedule('sync', this, function(){ - // this will be executed at the end of the RunLoop, when bindings are synced - console.log("scheduled on sync queue"); - }); - // Note the functions will be run in order based on the run queues order. Output would be: - // scheduled on sync queue - // scheduled on timers queue + ```javascript + Ember.run.schedule('timers', this, function(){ + // this will be executed at the end of the RunLoop, when timers are run + console.log("scheduled on timers queue"); + }); + + Ember.run.schedule('sync', this, function(){ + // this will be executed at the end of the RunLoop, when bindings are synced + console.log("scheduled on sync queue"); + }); + + // Note the functions will be run in order based on the run queues order. Output would be: + // scheduled on sync queue + // scheduled on timers queue + ``` @method schedule @param {String} queue The name of the queue to schedule against. Default queues are 'sync' and 'actions' - @param {Object} [target] target object to use as the context when invoking a method. - - @param {String|Function} method The method to invoke. If you pass a string it + @param {String|Function} method The method to invoke. If you pass a string it will be resolved on the target object at the time the scheduled item is invoked allowing you to change the target function. - @param {Object} [arguments*] Optional arguments to be passed to the queued method. - @return {void} */ Ember.run.schedule = function(queue, target, method) { @@ -4068,10 +4345,9 @@ Ember.run.cancelTimers = function () { /** Begins a new RunLoop if necessary and schedules a timer to flush the - RunLoop at a later time. This method is used by parts of Ember to - ensure the RunLoop always finishes. You normally do not need to call this - method directly. Instead use Ember.run(). - + RunLoop at a later time. This method is used by parts of Ember to + ensure the RunLoop always finishes. You normally do not need to call this + method directly. Instead use `Ember.run()` @method autorun @example @@ -4093,14 +4369,16 @@ Ember.run.autorun = function() { }; /** - Immediately flushes any events scheduled in the 'sync' queue. Bindings + Immediately flushes any events scheduled in the 'sync' queue. Bindings use this queue so this method is a useful way to immediately force all bindings in the application to sync. You should call this method anytime you need any changed state to propagate throughout the app immediately without repainting the UI. - Ember.run.sync(); + ```javascript + Ember.run.sync(); + ``` @method sync @return {void} @@ -4139,30 +4417,28 @@ function invokeLaterTimers() { /** Invokes the passed target/method and optional arguments after a specified - period if time. The last parameter of this method must always be a number + period if time. The last parameter of this method must always be a number of milliseconds. You should use this method whenever you need to run some action after a - period of time instead of using setTimeout(). This method will ensure that + period of time instead of using `setTimeout()`. This method will ensure that items that expire during the same script execution cycle all execute together, which is often more efficient than using a real setTimeout. - Ember.run.later(myContext, function(){ - // code here will execute within a RunLoop in about 500ms with this == myContext - }, 500); + ```javascript + Ember.run.later(myContext, function(){ + // code here will execute within a RunLoop in about 500ms with this == myContext + }, 500); + ``` @method later @param {Object} [target] target of method to invoke - @param {Function|String} method The method to invoke. If you pass a string it will be resolved on the target at the time the method is invoked. - @param {Object} [args*] Optional arguments to pass to the timeout. - @param {Number} wait Number of milliseconds to wait. - @return {String} a string you can use to cancel the timer in {{#crossLink "Ember/run.cancel"}}{{/crossLink}} later. */ @@ -4224,30 +4500,28 @@ function scheduleOnce(queue, target, method, args) { } /** - Schedules an item to run one time during the current RunLoop. Calling + Schedules an item to run one time during the current RunLoop. Calling this method with the same target/method combination will have no effect. Note that although you can pass optional arguments these will not be - considered when looking for duplicates. New arguments will replace previous + considered when looking for duplicates. New arguments will replace previous calls. - Ember.run(function(){ - var doFoo = function() { foo(); } - Ember.run.once(myContext, doFoo); - Ember.run.once(myContext, doFoo); - // doFoo will only be executed once at the end of the RunLoop - }); + ```javascript + Ember.run(function(){ + var doFoo = function() { foo(); } + Ember.run.once(myContext, doFoo); + Ember.run.once(myContext, doFoo); + // doFoo will only be executed once at the end of the RunLoop + }); + ``` @method once @param {Object} [target] target of method to invoke - @param {Function|String} method The method to invoke. If you pass a string it will be resolved on the target at the time the method is invoked. - @param {Object} [args*] Optional arguments to pass to the timeout. - - @return {Object} timer */ Ember.run.once = function(target, method) { @@ -4273,21 +4547,20 @@ function invokeNextTimers() { /** Schedules an item to run after control has been returned to the system. - This is often equivalent to calling setTimeout(function...,1). + This is often equivalent to calling `setTimeout(function() {}, 1)`. - Ember.run.next(myContext, function(){ - // code to be executed in the next RunLoop, which will be scheduled after the current one - }); + ```javascript + Ember.run.next(myContext, function(){ + // code to be executed in the next RunLoop, which will be scheduled after the current one + }); + ``` @method next @param {Object} [target] target of method to invoke - @param {Function|String} method The method to invoke. If you pass a string it will be resolved on the target at the time the method is invoked. - @param {Object} [args*] Optional arguments to pass to the timeout. - @return {Object} timer */ Ember.run.next = function(target, method) { @@ -4307,23 +4580,25 @@ Ember.run.next = function(target, method) { }; /** - Cancels a scheduled item. Must be a value returned by `Ember.run.later()`, + Cancels a scheduled item. Must be a value returned by `Ember.run.later()`, `Ember.run.once()`, or `Ember.run.next()`. - var runNext = Ember.run.next(myContext, function(){ - // will not be executed - }); - Ember.run.cancel(runNext); + ```javascript + var runNext = Ember.run.next(myContext, function(){ + // will not be executed + }); + Ember.run.cancel(runNext); - var runLater = Ember.run.later(myContext, function(){ - // will not be executed - }, 500); - Ember.run.cancel(runLater); + var runLater = Ember.run.later(myContext, function(){ + // will not be executed + }, 500); + Ember.run.cancel(runLater); - var runOnce = Ember.run.once(myContext, function(){ - // will not be executed - }); - Ember.run.cancel(runOnce); + var runOnce = Ember.run.once(myContext, function(){ + // will not be executed + }); + Ember.run.cancel(runOnce); + ``` @method cancel @param {Object} timer Timer object to cancel @@ -4407,17 +4682,17 @@ Binding.prototype = { // /** - This will set "from" property path to the specified value. It will not + This will set `from` property path to the specified value. It will not attempt to resolve this property path to an actual object until you connect the binding. The binding will search for the property path starting at the root object - you pass when you connect() the binding. It follows the same rules as + you pass when you `connect()` the binding. It follows the same rules as `get()` - see that method for more information. @method from @param {String} propertyPath the property path to connect to - @return {Ember.Binding} receiver + @return {Ember.Binding} `this` */ from: function(path) { this._from = path; @@ -4425,17 +4700,17 @@ Binding.prototype = { }, /** - This will set the "to" property path to the specified value. It will not + This will set the `to` property path to the specified value. It will not attempt to resolve this property path to an actual object until you connect the binding. The binding will search for the property path starting at the root object - you pass when you connect() the binding. It follows the same rules as + you pass when you `connect()` the binding. It follows the same rules as `get()` - see that method for more information. @method to @param {String|Tuple} propertyPath A property path or tuple - @return {Ember.Binding} this + @return {Ember.Binding} `this` */ to: function(path) { this._to = path; @@ -4444,12 +4719,12 @@ Binding.prototype = { /** Configures the binding as one way. A one-way binding will relay changes - on the "from" side to the "to" side, but not the other way around. This - means that if you change the "to" side directly, the "from" side may have + on the `from` side to the `to` side, but not the other way around. This + means that if you change the `to` side directly, the `from` side may have a different value. @method oneWay - @return {Ember.Binding} receiver + @return {Ember.Binding} `this` */ oneWay: function() { this._oneWay = true; @@ -4472,7 +4747,7 @@ Binding.prototype = { @method connect @param {Object} obj The root object for this binding. - @return {Ember.Binding} this + @return {Ember.Binding} `this` */ connect: function(obj) { Ember.assert('Must pass a valid object to Ember.Binding.connect()', !!obj); @@ -4497,7 +4772,7 @@ Binding.prototype = { @method disconnect @param {Object} obj The root object you passed when connecting the binding. - @return {Ember.Binding} this + @return {Ember.Binding} `this` */ disconnect: function(obj) { Ember.assert('Must pass a valid object to Ember.Binding.disconnect()', !!obj); @@ -4622,8 +4897,8 @@ mixinProperties(Binding, { /** Creates a new Binding instance and makes it apply in a single direction. - A one-way binding will relay changes on the "from" side object (supplied - as the `from` argument) the "to" side, but not the other way around. + A one-way binding will relay changes on the `from` side object (supplied + as the `from` argument) the `to` side, but not the other way around. This means that if you change the "to" side directly, the "from" side may have a different value. @@ -4631,8 +4906,9 @@ mixinProperties(Binding, { @method oneWay @param {String} from from path. - @param {Boolean} [flag] (Optional) passing nothing here will make the binding oneWay. You can - instead pass false to disable oneWay, making the binding two way again. + @param {Boolean} [flag] (Optional) passing nothing here will make the + binding `oneWay`. You can instead pass `false` to disable `oneWay`, making the + binding two way again. */ oneWay: function(from, flag) { var C = this, binding = new C(null, from); @@ -4642,18 +4918,23 @@ mixinProperties(Binding, { }); /** - An Ember.Binding connects the properties of two objects so that whenever the - value of one property changes, the other property will be changed also. + An `Ember.Binding` connects the properties of two objects so that whenever + the value of one property changes, the other property will be changed also. ## Automatic Creation of Bindings with `/^*Binding/`-named Properties + You do not usually create Binding objects directly but instead describe - bindings in your class or object definition using automatic binding detection. + bindings in your class or object definition using automatic binding + detection. - Properties ending in a `Binding` suffix will be converted to Ember.Binding instances. - The value of this property should be a string representing a path to another object or - a custom binding instanced created using Binding helpers (see "Customizing Your Bindings"): + Properties ending in a `Binding` suffix will be converted to `Ember.Binding` + instances. The value of this property should be a string representing a path + to another object or a custom binding instanced created using Binding helpers + (see "Customizing Your Bindings"): - valueBinding: "MyApp.someController.title" + ``` + valueBinding: "MyApp.someController.title" + ``` This will create a binding from `MyApp.someController.title` to the `value` property of your object instance automatically. Now the two values will be @@ -4668,12 +4949,14 @@ mixinProperties(Binding, { has changed, but your object will not be changing the preference itself, you could do: - bigTitlesBinding: Ember.Binding.oneWay("MyApp.preferencesController.bigTitles") + ``` + bigTitlesBinding: Ember.Binding.oneWay("MyApp.preferencesController.bigTitles") + ``` - This way if the value of MyApp.preferencesController.bigTitles changes the - "bigTitles" property of your object will change also. However, if you - change the value of your "bigTitles" property, it will not update the - preferencesController. + This way if the value of `MyApp.preferencesController.bigTitles` changes the + `bigTitles` property of your object will change also. However, if you + change the value of your `bigTitles` property, it will not update the + `preferencesController`. One way bindings are almost twice as fast to setup and twice as fast to execute because the binding only has to worry about changes to one side. @@ -4684,35 +4967,39 @@ mixinProperties(Binding, { ## Adding Bindings Manually - All of the examples above show you how to configure a custom binding, but - the result of these customizations will be a binding template, not a fully - active Binding instance. The binding will actually become active only when you + All of the examples above show you how to configure a custom binding, but the + result of these customizations will be a binding template, not a fully active + Binding instance. The binding will actually become active only when you instantiate the object the binding belongs to. It is useful however, to understand what actually happens when the binding is activated. - For a binding to function it must have at least a "from" property and a "to" - property. The from property path points to the object/key that you want to - bind from while the to path points to the object/key you want to bind to. + For a binding to function it must have at least a `from` property and a `to` + property. The `from` property path points to the object/key that you want to + bind from while the `to` path points to the object/key you want to bind to. When you define a custom binding, you are usually describing the property - you want to bind from (such as "MyApp.someController.value" in the examples + you want to bind from (such as `MyApp.someController.value` in the examples above). When your object is created, it will automatically assign the value - you want to bind "to" based on the name of your binding key. In the + you want to bind `to` based on the name of your binding key. In the examples above, during init, Ember objects will effectively call something like this on your binding: - binding = Ember.Binding.from(this.valueBinding).to("value"); + ```javascript + binding = Ember.Binding.from(this.valueBinding).to("value"); + ``` This creates a new binding instance based on the template you provide, and - sets the to path to the "value" property of the new object. Now that the - binding is fully configured with a "from" and a "to", it simply needs to be - connected to become active. This is done through the connect() method: + sets the to path to the `value` property of the new object. Now that the + binding is fully configured with a `from` and a `to`, it simply needs to be + connected to become active. This is done through the `connect()` method: - binding.connect(this); + ```javascript + binding.connect(this); + ``` Note that when you connect a binding you pass the object you want it to be - connected to. This object will be used as the root for both the from and - to side of the binding when inspecting relative paths. This allows the + connected to. This object will be used as the root for both the from and + to side of the binding when inspecting relative paths. This allows the binding to be automatically inherited by subclassed objects as well. Now that the binding is connected, it will observe both the from and to side @@ -4720,20 +5007,23 @@ mixinProperties(Binding, { If you ever needed to do so (you almost never will, but it is useful to understand this anyway), you could manually create an active binding by - using the Ember.bind() helper method. (This is the same method used by + using the `Ember.bind()` helper method. (This is the same method used by to setup your bindings on objects): - Ember.bind(MyApp.anotherObject, "value", "MyApp.someController.value"); + ```javascript + Ember.bind(MyApp.anotherObject, "value", "MyApp.someController.value"); + ``` Both of these code fragments have the same effect as doing the most friendly form of binding creation like so: - MyApp.anotherObject = Ember.Object.create({ - valueBinding: "MyApp.someController.value", + ```javascript + MyApp.anotherObject = Ember.Object.create({ + valueBinding: "MyApp.someController.value", - // OTHER CODE FOR THIS OBJECT... - - }); + // OTHER CODE FOR THIS OBJECT... + }); + ``` Ember's built in binding creation method makes it easy to automatically create bindings for you. You should always use the highest-level APIs @@ -4747,19 +5037,16 @@ Ember.Binding = Binding; /** - Global helper method to create a new binding. Just pass the root object - along with a to and from path to create and connect the binding. + Global helper method to create a new binding. Just pass the root object + along with a `to` and `from` path to create and connect the binding. @method bind @for Ember @param {Object} obj The root object of the transform. - @param {String} to The path to the 'to' side of the binding. Must be relative to obj. - @param {String} from The path to the 'from' side of the binding. Must be relative to obj or a global path. - @return {Ember.Binding} binding instance */ Ember.bind = function(obj, to, from) { @@ -4770,13 +5057,10 @@ Ember.bind = function(obj, to, from) { @method oneWay @for Ember @param {Object} obj The root object of the transform. - @param {String} to The path to the 'to' side of the binding. Must be relative to obj. - @param {String} from The path to the 'from' side of the binding. Must be relative to obj or a global path. - @return {Ember.Binding} binding instance */ Ember.oneWay = function(obj, to, from) { @@ -4793,13 +5077,11 @@ Ember.oneWay = function(obj, to, from) { */ var Mixin, REQUIRED, Alias, - classToString, superClassString, a_map = Ember.ArrayPolyfills.map, a_indexOf = Ember.ArrayPolyfills.indexOf, a_forEach = Ember.ArrayPolyfills.forEach, a_slice = [].slice, EMPTY_META = {}, // dummy for non-writable meta - META_SKIP = { __emberproto__: true, __ember_count__: true }, o_create = Ember.create, defineProperty = Ember.defineProperty, guidFor = Ember.guidFor; @@ -4807,10 +5089,9 @@ var Mixin, REQUIRED, Alias, function mixinsMeta(obj) { var m = Ember.meta(obj, true), ret = m.mixins; if (!ret) { - ret = m.mixins = { __emberproto__: obj }; - } else if (ret.__emberproto__ !== obj) { + ret = m.mixins = {}; + } else if (!m.hasOwnProperty('mixins')) { ret = m.mixins = o_create(ret); - ret.__emberproto__ = obj; } return ret; } @@ -4820,8 +5101,8 @@ function initMixin(mixin, args) { mixin.mixins = a_map.call(args, function(x) { if (x instanceof Mixin) { return x; } - // Note: Manually setup a primitive mixin here. This is the only - // way to actually get a primitive mixin. This way normal creation + // Note: Manually setup a primitive mixin here. This is the only + // way to actually get a primitive mixin. This way normal creation // of mixins will give you combined mixins... var mixin = new Mixin(); mixin.properties = x; @@ -4837,77 +5118,145 @@ function isMethod(obj) { obj !== Boolean && obj !== Object && obj !== Number && obj !== Array && obj !== Date && obj !== String; } +var CONTINUE = {}; + +function mixinProperties(mixinsMeta, mixin) { + var guid; + + if (mixin instanceof Mixin) { + guid = guidFor(mixin); + if (mixinsMeta[guid]) { return CONTINUE; } + mixinsMeta[guid] = mixin; + return mixin.properties; + } else { + return mixin; // apply anonymous mixin properties + } +} + +function concatenatedProperties(props, values, base) { + var concats; + + // reset before adding each new mixin to pickup concats from previous + concats = values.concatenatedProperties || base.concatenatedProperties; + if (props.concatenatedProperties) { + concats = concats ? concats.concat(props.concatenatedProperties) : props.concatenatedProperties; + } + + return concats; +} + +function giveDescriptorSuper(meta, key, property, values, descs) { + var superProperty; + + // Computed properties override methods, and do not call super to them + if (values[key] === undefined) { + // Find the original descriptor in a parent mixin + superProperty = descs[key]; + } + + // If we didn't find the original descriptor in a parent mixin, find + // it on the original object. + superProperty = superProperty || meta.descs[key]; + + if (!superProperty || !(superProperty instanceof Ember.ComputedProperty)) { + return property; + } + + // Since multiple mixins may inherit from the same parent, we need + // to clone the computed property so that other mixins do not receive + // the wrapped version. + property = o_create(property); + property.func = Ember.wrap(property.func, superProperty.func); + + return property; +} + +function giveMethodSuper(obj, key, method, values, descs) { + var superMethod; + + // Methods overwrite computed properties, and do not call super to them. + if (descs[key] === undefined) { + // Find the original method in a parent mixin + superMethod = values[key]; + } + + // If we didn't find the original value in a parent mixin, find it in + // the original object + superMethod = superMethod || obj[key]; + + // Only wrap the new method if the original method was a function + if ('function' !== typeof superMethod) { + return method; + } + + return Ember.wrap(method, superMethod); +} + +function applyConcatenatedProperties(obj, key, value, values) { + var baseValue = values[key] || obj[key]; + + if (baseValue) { + if ('function' === typeof baseValue.concat) { + return baseValue.concat(value); + } else { + return Ember.makeArray(baseValue).concat(value); + } + } else { + return Ember.makeArray(value); + } +} + +function addNormalizedProperty(base, key, value, meta, descs, values, concats) { + if (value instanceof Ember.Descriptor) { + if (value === REQUIRED && descs[key]) { return CONTINUE; } + + // Wrap descriptor function to implement + // _super() if needed + if (value.func) { + value = giveDescriptorSuper(meta, key, value, values, descs); + } + + descs[key] = value; + values[key] = undefined; + } else { + // impl super if needed... + if (isMethod(value)) { + value = giveMethodSuper(base, key, value, values, descs); + } else if ((concats && a_indexOf.call(concats, key) >= 0) || key === 'concatenatedProperties') { + value = applyConcatenatedProperties(base, key, value, values); + } + + descs[key] = undefined; + values[key] = value; + } +} + function mergeMixins(mixins, m, descs, values, base) { - var len = mixins.length, idx, mixin, guid, props, value, key, ovalue, concats; + var mixin, props, key, concats, meta; function removeKeys(keyName) { delete descs[keyName]; delete values[keyName]; } - for(idx=0; idx < len; idx++) { - mixin = mixins[idx]; + for(var i=0, l=mixins.length; i= 0) || key === 'concatenatedProperties') { - var baseValue = values[key] || base[key]; - if (baseValue) { - if ('function' === typeof baseValue.concat) { - value = baseValue.concat(value); - } else { - value = Ember.makeArray(baseValue).concat(value); - } - } else { - value = Ember.makeArray(value); - } - } - - descs[key] = undefined; - values[key] = value; - } + addNormalizedProperty(base, key, props[key], meta, descs, values, concats); } // manually copy toString() because some JS engines do not enumerate it - if (props.hasOwnProperty('toString')) { - base.toString = props.toString; - } - + if (props.hasOwnProperty('toString')) { base.toString = props.toString; } } else if (mixin.mixins) { mergeMixins(mixin.mixins, m, descs, values, base); if (mixin._without) { a_forEach.call(mixin._without, removeKeys); } @@ -4917,9 +5266,8 @@ function mergeMixins(mixins, m, descs, values, base) { function writableReq(obj) { var m = Ember.meta(obj), req = m.required; - if (!req || req.__emberproto__ !== obj) { - req = m.required = req ? o_create(req) : { __ember_count__: 0 }; - req.__emberproto__ = obj; + if (!req || !m.hasOwnProperty('required')) { + req = m.required = req ? o_create(req) : {}; } return req; } @@ -4930,10 +5278,9 @@ function detectBinding(obj, key, value, m) { if (IS_BINDING.test(key)) { var bindings = m.bindings; if (!bindings) { - bindings = m.bindings = { __emberproto__: obj }; - } else if (bindings.__emberproto__ !== obj) { + bindings = m.bindings = {}; + } else if (!m.hasOwnProperty('bindings')) { bindings = m.bindings = o_create(m.bindings); - bindings.__emberproto__ = obj; } bindings[key] = value; } @@ -4944,7 +5291,7 @@ function connectBindings(obj, m) { var bindings = m.bindings, key, binding, to; if (bindings) { for (key in bindings) { - binding = key !== '__emberproto__' && bindings[key]; + binding = bindings[key]; if (binding) { to = key.slice(0, -7); // strip Binding off end if (binding instanceof Ember.Binding) { @@ -4958,7 +5305,7 @@ function connectBindings(obj, m) { } } // mark as applied - m.bindings = { __emberproto__: obj }; + m.bindings = {}; } } @@ -4967,9 +5314,47 @@ function finishPartial(obj, m) { return obj; } +function followAlias(obj, desc, m, descs, values) { + var altKey = desc.methodName, value; + if (descs[altKey] || values[altKey]) { + value = values[altKey]; + desc = descs[altKey]; + } else if (m.descs[altKey]) { + desc = m.descs[altKey]; + value = undefined; + } else { + desc = undefined; + value = obj[altKey]; + } + + return { desc: desc, value: value }; +} + +function updateObservers(obj, key, observer, observerKey, method) { + if ('function' !== typeof observer) { return; } + + var paths = observer[observerKey]; + + if (paths) { + for (var i=0, l=paths.length; i0) { - var keys = []; - for (key in req) { - if (META_SKIP[key]) { continue; } - keys.push(key); - } - // TODO: Remove surrounding if clause from production build - Ember.assert('Required properties not defined: '+keys.join(',')); - } return obj; } @@ -5088,22 +5409,24 @@ Ember.mixin = function(obj) { The `Ember.Mixin` class allows you to create mixins, whose properties can be added to other classes. For instance, - App.Editable = Ember.Mixin.create({ - edit: function() { - console.log('starting to edit'); - this.set('isEditing', true); - }, - isEditing: false - }); + ```javascript + App.Editable = Ember.Mixin.create({ + edit: function() { + console.log('starting to edit'); + this.set('isEditing', true); + }, + isEditing: false + }); - // Mix mixins into classes by passing them as the first arguments to - // .extend or .create. - App.CommentView = Ember.View.extend(App.Editable, { - template: Ember.Handlebars.compile('{{#if isEditing}}...{{else}}...{{/if}}') - }); + // Mix mixins into classes by passing them as the first arguments to + // .extend or .create. + App.CommentView = Ember.View.extend(App.Editable, { + template: Ember.Handlebars.compile('{{#if isEditing}}...{{else}}...{{/if}}') + }); - commentView = App.CommentView.create(); - commentView.edit(); // => outputs 'starting to edit' + commentView = App.CommentView.create(); + commentView.edit(); // outputs 'starting to edit' + ``` Note that Mixins are created with `Ember.Mixin.create`, not `Ember.Mixin.extend`. @@ -5124,13 +5447,15 @@ Mixin.applyPartial = function(obj) { Mixin.finishPartial = finishPartial; +Ember.anyUnprocessedMixins = false; + /** @method create @static @param arguments* */ Mixin.create = function() { - classToString.processed = false; + Ember.anyUnprocessedMixins = true; var M = this; return initMixin(new M(), arguments); }; @@ -5242,122 +5567,20 @@ MixinPrototype.keys = function() { return ret; }; -/* make Mixins have nice displayNames */ - -var NAME_KEY = Ember.GUID_KEY+'_name'; -var get = Ember.get; - -function processNames(paths, root, seen) { - var idx = paths.length; - for(var key in root) { - if (!root.hasOwnProperty || !root.hasOwnProperty(key)) { continue; } - var obj = root[key]; - paths[idx] = key; - - if (obj && obj.toString === classToString) { - obj[NAME_KEY] = paths.join('.'); - } else if (obj && get(obj, 'isNamespace')) { - if (seen[guidFor(obj)]) { continue; } - seen[guidFor(obj)] = true; - processNames(paths, obj, seen); - } - } - paths.length = idx; // cut out last item -} - -function findNamespaces() { - var Namespace = Ember.Namespace, lookup = Ember.lookup, obj, isNamespace; - - if (Namespace.PROCESSED) { return; } - - for (var prop in lookup) { - // get(window.globalStorage, 'isNamespace') would try to read the storage for domain isNamespace and cause exception in Firefox. - // globalStorage is a storage obsoleted by the WhatWG storage specification. See https://developer.mozilla.org/en/DOM/Storage#globalStorage - if (prop === "globalStorage" && lookup.StorageList && lookup.globalStorage instanceof lookup.StorageList) { continue; } - // Unfortunately, some versions of IE don't support window.hasOwnProperty - if (lookup.hasOwnProperty && !lookup.hasOwnProperty(prop)) { continue; } - - // At times we are not allowed to access certain properties for security reasons. - // There are also times where even if we can access them, we are not allowed to access their properties. - try { - obj = Ember.lookup[prop]; - isNamespace = obj && get(obj, 'isNamespace'); - } catch (e) { - continue; - } - - if (isNamespace) { - Ember.deprecate("Namespaces should not begin with lowercase.", /^[A-Z]/.test(prop)); - obj[NAME_KEY] = prop; - } - } -} - -/** - @private - @method identifyNamespaces - @for Ember -*/ -Ember.identifyNamespaces = findNamespaces; - -superClassString = function(mixin) { - var superclass = mixin.superclass; - if (superclass) { - if (superclass[NAME_KEY]) { return superclass[NAME_KEY]; } - else { return superClassString(superclass); } - } else { - return; - } -}; - -classToString = function() { - var Namespace = Ember.Namespace, namespace; - - // TODO: Namespace should really be in Metal - if (Namespace) { - if (!this[NAME_KEY] && !classToString.processed) { - if (!Namespace.PROCESSED) { - findNamespaces(); - Namespace.PROCESSED = true; - } - - classToString.processed = true; - - var namespaces = Namespace.NAMESPACES; - for (var i=0, l=namespaces.length; i 'red' - paintSample.moniker(); //=> 'Zed' + ```javascript + App.PaintSample = Ember.Object.extend({ + color: 'red', + colour: Ember.alias('color'), + name: function(){ + return "Zed"; + }, + moniker: Ember.alias("name") + }); + + var paintSample = App.PaintSample.create() + paintSample.get('colour'); // 'red' + paintSample.moniker(); // 'Zed' + ``` @method alias @for Ember @param {String} methodName name of the method or property to alias @return {Ember.Descriptor} + @deprecated Use `Ember.aliasMethod` or `Ember.computed.alias` instead */ Ember.alias = function(methodName) { return new Alias(methodName); }; +Ember.deprecateFunc("Ember.alias is deprecated. Please use Ember.aliasMethod or Ember.computed.alias instead.", Ember.alias); + +/** + Makes a method available via an additional name. + + ```javascript + App.Person = Ember.Object.extend({ + name: function(){ + return 'Tomhuda Katzdale'; + }, + moniker: Ember.aliasMethod('name') + }); + + var goodGuy = App.Person.create() + ``` + + @method aliasMethod + @for Ember + @param {String} methodName name of the method to alias + @return {Ember.Descriptor} +*/ +Ember.aliasMethod = function(methodName) { + return new Alias(methodName); +}; + // .......................................................... // OBSERVER HELPER // @@ -5466,214 +5718,535 @@ Ember Metal })(); (function() { -(function(exports) { "use strict"; +define("rsvp", + [], + function() { + "use strict"; + var browserGlobal = (typeof window !== 'undefined') ? window : {}; -var browserGlobal = (typeof window !== 'undefined') ? window : {}; + var MutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver; + var RSVP, async; -var MutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver; -var async; + if (typeof process !== 'undefined' && + {}.toString.call(process) === '[object process]') { + async = function(callback, binding) { + process.nextTick(function() { + callback.call(binding); + }); + }; + } else if (MutationObserver) { + var queue = []; -if (typeof process !== 'undefined') { - async = function(callback, binding) { - process.nextTick(function() { - callback.call(binding); - }); - }; -} else if (MutationObserver) { - var queue = []; + var observer = new MutationObserver(function() { + var toProcess = queue.slice(); + queue = []; - var observer = new MutationObserver(function() { - var toProcess = queue.slice(); - queue = []; + toProcess.forEach(function(tuple) { + var callback = tuple[0], binding = tuple[1]; + callback.call(binding); + }); + }); - toProcess.forEach(function(tuple) { - var callback = tuple[0], binding = tuple[1]; - callback.call(binding); - }); - }); + var element = document.createElement('div'); + observer.observe(element, { attributes: true }); - var element = document.createElement('div'); - observer.observe(element, { attributes: true }); + // Chrome Memory Leak: https://bugs.webkit.org/show_bug.cgi?id=93661 + window.addEventListener('unload', function(){ + observer.disconnect(); + observer = null; + }); - async = function(callback, binding) { - queue.push([callback, binding]); - element.setAttribute('drainQueue', 'drainQueue'); - }; -} else { - async = function(callback, binding) { - setTimeout(function() { - callback.call(binding); - }, 1); - }; -} - -exports.async = async; - -var Event = exports.Event = function(type, options) { - this.type = type; - - for (var option in options) { - if (!options.hasOwnProperty(option)) { continue; } - - this[option] = options[option]; - } -}; - -var indexOf = function(callbacks, callback) { - for (var i=0, l=callbacks.length; i 'undefined' - Ember.typeOf(null); => 'null' - Ember.typeOf(undefined); => 'undefined' - Ember.typeOf('michael'); => 'string' - Ember.typeOf(101); => 'number' - Ember.typeOf(true); => 'boolean' - Ember.typeOf(Ember.makeArray); => 'function' - Ember.typeOf([1,2,90]); => 'array' - Ember.typeOf(Ember.Object.extend()); => 'class' - Ember.typeOf(Ember.Object.create()); => 'instance' - Ember.typeOf(new Error('teamocil')); => 'error' + ```javascript + Ember.typeOf(); // 'undefined' + Ember.typeOf(null); // 'null' + Ember.typeOf(undefined); // 'undefined' + Ember.typeOf('michael'); // 'string' + Ember.typeOf(101); // 'number' + Ember.typeOf(true); // 'boolean' + Ember.typeOf(Ember.makeArray); // 'function' + Ember.typeOf([1,2,90]); // 'array' + Ember.typeOf(Ember.Object.extend()); // 'class' + Ember.typeOf(Ember.Object.create()); // 'instance' + Ember.typeOf(new Error('teamocil')); // 'error' - // "normal" JavaScript object - Ember.typeOf({a: 'b'}); => 'object' + // "normal" JavaScript object + Ember.typeOf({a: 'b'}); // 'object' + ``` @method typeOf @for Ember @@ -5758,48 +6333,55 @@ Ember.typeOf = function(item) { }; /** - Returns true if the passed value is null or undefined. This avoids errors + Returns true if the passed value is null or undefined. This avoids errors from JSLint complaining about use of ==, which can be technically confusing. - Ember.none(); => true - Ember.none(null); => true - Ember.none(undefined); => true - Ember.none(''); => false - Ember.none([]); => false - Ember.none(function(){}); => false + ```javascript + Ember.isNone(); // true + Ember.isNone(null); // true + Ember.isNone(undefined); // true + Ember.isNone(''); // false + Ember.isNone([]); // false + Ember.isNone(function(){}); // false + ``` - @method none + @method isNone @for Ember @param {Object} obj Value to test @return {Boolean} */ -Ember.none = function(obj) { +Ember.isNone = function(obj) { return obj === null || obj === undefined; }; +Ember.none = Ember.deprecateFunc("Ember.none is deprecated. Please use Ember.isNone instead.", Ember.isNone); /** - Verifies that a value is null or an empty string | array | function. + Verifies that a value is `null` or an empty string, empty array, + or empty function. - Constrains the rules on `Ember.none` by returning false for empty + Constrains the rules on `Ember.isNone` by returning false for empty string and empty arrays. - Ember.empty(); => true - Ember.empty(null); => true - Ember.empty(undefined); => true - Ember.empty(''); => true - Ember.empty([]); => true - Ember.empty('tobias fünke'); => false - Ember.empty([0,1,2]); => false + ```javascript + Ember.isEmpty(); // true + Ember.isEmpty(null); // true + Ember.isEmpty(undefined); // true + Ember.isEmpty(''); // true + Ember.isEmpty([]); // true + Ember.isEmpty('Adam Hawkins'); // false + Ember.isEmpty([0,1,2]); // false + ``` - @method empty + @method isEmpty @for Ember @param {Object} obj Value to test @return {Boolean} */ -Ember.empty = function(obj) { +Ember.isEmpty = function(obj) { return obj === null || obj === undefined || (obj.length === 0 && typeof obj !== 'function') || (typeof obj === 'object' && Ember.get(obj, 'length') === 0); }; +Ember.empty = Ember.deprecateFunc("Ember.empty is deprecated. Please use Ember.isEmpty instead.", Ember.isEmpty) ; /** This will compare two javascript values of possibly different types. @@ -5809,12 +6391,14 @@ Ember.empty = function(obj) { - 0 if both are equal, - 1 if the first is greater than the second. - The order is calculated based on Ember.ORDER_DEFINITION, if types are different. + The order is calculated based on `Ember.ORDER_DEFINITION`, if types are different. In case they have the same type an appropriate comparison for this type is made. - Ember.compare('hello', 'hello'); => 0 - Ember.compare('abc', 'dfg'); => -1 - Ember.compare(2, 1); => 1 + ```javascript + Ember.compare('hello', 'hello'); // 0 + Ember.compare('abc', 'dfg'); // -1 + Ember.compare(2, 1); // 1 + ``` @method compare @for Ember @@ -5922,7 +6506,7 @@ function _copy(obj, deep, seen, copies) { Ember.assert('Cannot clone an Ember.Object that does not implement Ember.Copyable', !(obj instanceof Ember.Object) || (Ember.Copyable && Ember.Copyable.detect(obj))); - // IMPORTANT: this specific test will detect a native array only. Any other + // IMPORTANT: this specific test will detect a native array only. Any other // object will need to implement Copyable. if (Ember.typeOf(obj) === 'array') { ret = obj.slice(); @@ -5936,6 +6520,11 @@ function _copy(obj, deep, seen, copies) { ret = {}; for(key in obj) { if (!obj.hasOwnProperty(key)) continue; + + // Prevents browsers that don't respect non-enumerability from + // copying internal Ember properties + if (key.substring(0,2) === '__') continue; + ret[key] = deep ? _copy(obj[key], deep, seen, copies) : obj[key]; } } @@ -5953,7 +6542,7 @@ function _copy(obj, deep, seen, copies) { any type of object and create a clone of it, including primitive values (which are not actually cloned because they are immutable). - If the passed object implements the clone() method, then this function + If the passed object implements the `clone()` method, then this function will simply call that method and return the result. @method copy @@ -5973,12 +6562,19 @@ Ember.copy = function(obj, deep) { Convenience method to inspect an object. This method will attempt to convert the object into a useful string description. + It is a pretty simple implementation. If you want something more robust, + use something like JSDump: https://github.com/NV/jsDump + @method inspect @for Ember @param {Object} obj The object you want to inspect. @return {String} A description of the object */ Ember.inspect = function(obj) { + if (typeof obj !== 'object' || obj === null) { + return obj + ''; + } + var v, ret = []; for(var key in obj) { if (obj.hasOwnProperty(key)) { @@ -5988,18 +6584,20 @@ Ember.inspect = function(obj) { ret.push(key + ": " + v); } } - return "{" + ret.join(" , ") + "}"; + return "{" + ret.join(", ") + "}"; }; /** - Compares two objects, returning true if they are logically equal. This is + Compares two objects, returning true if they are logically equal. This is a deeper comparison than a simple triple equal. For sets it will compare the - internal objects. For any other object that implements `isEqual()` it will + internal objects. For any other object that implements `isEqual()` it will respect that method. - Ember.isEqual('hello', 'hello'); => true - Ember.isEqual(1, 2); => false - Ember.isEqual([4,2], [4,2]); => false + ```javascript + Ember.isEqual('hello', 'hello'); // true + Ember.isEqual(1, 2); // false + Ember.isEqual([4,2], [4,2]); // false + ``` @method isEqual @for Ember @@ -6029,8 +6627,8 @@ Ember.ORDER_DEFINITION = Ember.ENV.ORDER_DEFINITION || [ /** Returns all of the keys defined on an object or hash. This is useful - when inspecting objects for debugging. On browsers that support it, this - uses the native Object.keys implementation. + when inspecting objects for debugging. On browsers that support it, this + uses the native `Object.keys` implementation. @method keys @for Ember @@ -6087,13 +6685,13 @@ Ember.Error.prototype = Ember.create(Error.prototype); var STRING_DASHERIZE_REGEXP = (/[ _]/g); var STRING_DASHERIZE_CACHE = {}; var STRING_DECAMELIZE_REGEXP = (/([a-z])([A-Z])/g); -var STRING_CAMELIZE_REGEXP = (/(\-|_|\s)+(.)?/g); +var STRING_CAMELIZE_REGEXP = (/(\-|_|\.|\s)+(.)?/g); var STRING_UNDERSCORE_REGEXP_1 = (/([a-z\d])([A-Z]+)/g); var STRING_UNDERSCORE_REGEXP_2 = (/\-|\s+/g); /** - Defines the hash of localized strings for the current language. Used by - the `Ember.String.loc()` helper. To localize, add string values to this + Defines the hash of localized strings for the current language. Used by + the `Ember.String.loc()` helper. To localize, add string values to this hash. @property STRINGS @@ -6104,8 +6702,8 @@ Ember.STRINGS = {}; /** Defines string helper methods including string formatting and localization. - Unless Ember.EXTEND_PROTOTYPES.String is false these methods will also be added - to the String.prototype as well. + Unless `Ember.EXTEND_PROTOTYPES.String` is `false` these methods will also be + added to the `String.prototype` as well. @class String @namespace Ember @@ -6114,17 +6712,19 @@ Ember.STRINGS = {}; Ember.String = { /** - Apply formatting options to the string. This will look for occurrences - of %@ in your string and substitute them with the arguments you pass into - this method. If you want to control the specific order of replacement, + Apply formatting options to the string. This will look for occurrences + of "%@" in your string and substitute them with the arguments you pass into + this method. If you want to control the specific order of replacement, you can add a number after the key as well to indicate which argument you want to insert. Ordered insertions are most useful when building loc strings where values you need to insert may appear in different orders. - "Hello %@ %@".fmt('John', 'Doe') => "Hello John Doe" - "Hello %@2, %@1".fmt('John', 'Doe') => "Hello Doe, John" + ```javascript + "Hello %@ %@".fmt('John', 'Doe'); // "Hello John Doe" + "Hello %@2, %@1".fmt('John', 'Doe'); // "Hello Doe, John" + ``` @method fmt @param {Object...} [args] @@ -6142,23 +6742,22 @@ Ember.String = { /** Formats the passed string, but first looks up the string in the localized - strings hash. This is a convenient way to localize text. See + strings hash. This is a convenient way to localize text. See `Ember.String.fmt()` for more information on formatting. Note that it is traditional but not required to prefix localized string keys with an underscore or other character so you can easily identify localized strings. - Ember.STRINGS = { - '_Hello World': 'Bonjour le monde', - '_Hello %@ %@': 'Bonjour %@ %@' - }; + ```javascript + Ember.STRINGS = { + '_Hello World': 'Bonjour le monde', + '_Hello %@ %@': 'Bonjour %@ %@' + }; - Ember.String.loc("_Hello World"); - => 'Bonjour le monde'; - - Ember.String.loc("_Hello %@ %@", ["John", "Smith"]); - => "Bonjour John Smith"; + Ember.String.loc("_Hello World"); // 'Bonjour le monde'; + Ember.String.loc("_Hello %@ %@", ["John", "Smith"]); // "Bonjour John Smith"; + ``` @method loc @param {String} str The string to format @@ -6172,15 +6771,18 @@ Ember.String = { /** Splits a string into separate units separated by spaces, eliminating any - empty strings in the process. This is a convenience method for split that - is mostly useful when applied to the String.prototype. + empty strings in the process. This is a convenience method for split that + is mostly useful when applied to the `String.prototype`. - Ember.String.w("alpha beta gamma").forEach(function(key) { - console.log(key); - }); - > alpha - > beta - > gamma + ```javascript + Ember.String.w("alpha beta gamma").forEach(function(key) { + console.log(key); + }); + + // > alpha + // > beta + // > gamma + ``` @method w @param {String} str The string to split @@ -6191,10 +6793,12 @@ Ember.String = { /** Converts a camelized string into all lower case separated by underscores. - 'innerHTML'.decamelize() => 'inner_html' - 'action_name'.decamelize() => 'action_name' - 'css-class-name'.decamelize() => 'css-class-name' - 'my favorite items'.decamelize() => 'my favorite items' + ```javascript + 'innerHTML'.decamelize(); // 'inner_html' + 'action_name'.decamelize(); // 'action_name' + 'css-class-name'.decamelize(); // 'css-class-name' + 'my favorite items'.decamelize(); // 'my favorite items' + ``` @method decamelize @param {String} str The string to decamelize. @@ -6207,10 +6811,12 @@ Ember.String = { /** Replaces underscores or spaces with dashes. - 'innerHTML'.dasherize() => 'inner-html' - 'action_name'.dasherize() => 'action-name' - 'css-class-name'.dasherize() => 'css-class-name' - 'my favorite items'.dasherize() => 'my-favorite-items' + ```javascript + 'innerHTML'.dasherize(); // 'inner-html' + 'action_name'.dasherize(); // 'action-name' + 'css-class-name'.dasherize(); // 'css-class-name' + 'my favorite items'.dasherize(); // 'my-favorite-items' + ``` @method dasherize @param {String} str The string to dasherize. @@ -6233,10 +6839,12 @@ Ember.String = { /** Returns the lowerCaseCamel form of a string. - 'innerHTML'.camelize() => 'innerHTML' - 'action_name'.camelize() => 'actionName' - 'css-class-name'.camelize() => 'cssClassName' - 'my favorite items'.camelize() => 'myFavoriteItems' + ```javascript + 'innerHTML'.camelize(); // 'innerHTML' + 'action_name'.camelize(); // 'actionName' + 'css-class-name'.camelize(); // 'cssClassName' + 'my favorite items'.camelize(); // 'myFavoriteItems' + ``` @method camelize @param {String} str The string to camelize. @@ -6251,37 +6859,65 @@ Ember.String = { /** Returns the UpperCamelCase form of a string. - 'innerHTML'.classify() => 'InnerHTML' - 'action_name'.classify() => 'ActionName' - 'css-class-name'.classify() => 'CssClassName' - 'my favorite items'.classify() => 'MyFavoriteItems' + ```javascript + 'innerHTML'.classify(); // 'InnerHTML' + 'action_name'.classify(); // 'ActionName' + 'css-class-name'.classify(); // 'CssClassName' + 'my favorite items'.classify(); // 'MyFavoriteItems' + ``` @method classify @param {String} str the string to classify @return {String} the classified string */ classify: function(str) { - var camelized = Ember.String.camelize(str); - return camelized.charAt(0).toUpperCase() + camelized.substr(1); + var parts = str.split("."), + out = []; + + for (var i=0, l=parts.length; i 'inner_html' - 'action_name'.underscore() => 'action_name' - 'css-class-name'.underscore() => 'css_class_name' - 'my favorite items'.underscore() => 'my_favorite_items' + ```javascript + 'innerHTML'.underscore(); // 'inner_html' + 'action_name'.underscore(); // 'action_name' + 'css-class-name'.underscore(); // 'css_class_name' + 'my favorite items'.underscore(); // 'my_favorite_items' + ``` - @property underscore + @method underscore @param {String} str The string to underscore. @return {String} the underscored string. */ underscore: function(str) { return str.replace(STRING_UNDERSCORE_REGEXP_1, '$1_$2'). replace(STRING_UNDERSCORE_REGEXP_2, '_').toLowerCase(); + }, + + /** + Returns the Capitalized form of a string + + 'innerHTML'.capitalize() => 'InnerHTML' + 'action_name'.capitalize() => 'Action_name' + 'css-class-name'.capitalize() => 'Css-class-name' + 'my favorite items'.capitalize() => 'My favorite items' + + @method capitalize + @param {String} str + @return {String} + */ + capitalize: function(str) { + return str.charAt(0).toUpperCase() + str.substr(1); } + }; })(); @@ -6303,6 +6939,7 @@ var fmt = Ember.String.fmt, decamelize = Ember.String.decamelize, dasherize = Ember.String.dasherize, underscore = Ember.String.underscore, + capitalize = Ember.String.capitalize, classify = Ember.String.classify; if (Ember.EXTEND_PROTOTYPES === true || Ember.EXTEND_PROTOTYPES.String) { @@ -6386,6 +7023,17 @@ if (Ember.EXTEND_PROTOTYPES === true || Ember.EXTEND_PROTOTYPES.String) { String.prototype.classify = function() { return classify(this); }; + + /** + See {{#crossLink "Ember.String/capitalize"}}{{/crossLink}} + + @method capitalize + @for String + */ + String.prototype.capitalize = function() { + return capitalize(this); + }; + } @@ -6405,45 +7053,49 @@ if (Ember.EXTEND_PROTOTYPES === true || Ember.EXTEND_PROTOTYPES.Function) { /** The `property` extension of Javascript's Function prototype is available - when Ember.EXTEND_PROTOTYPES or Ember.EXTEND_PROTOTYPES.Function is true, - which is the default. + when `Ember.EXTEND_PROTOTYPES` or `Ember.EXTEND_PROTOTYPES.Function` is + `true`, which is the default. Computed properties allow you to treat a function like a property: - MyApp.president = Ember.Object.create({ - firstName: "Barack", - lastName: "Obama", + ```javascript + MyApp.president = Ember.Object.create({ + firstName: "Barack", + lastName: "Obama", - fullName: function() { - return this.get('firstName') + ' ' + this.get('lastName'); + fullName: function() { + return this.get('firstName') + ' ' + this.get('lastName'); - // Call this flag to mark the function as a property - }.property() - }); + // Call this flag to mark the function as a property + }.property() + }); - MyApp.president.get('fullName'); => "Barack Obama" + MyApp.president.get('fullName'); // "Barack Obama" + ``` Treating a function like a property is useful because they can work with bindings, just like any other property. Many computed properties have dependencies on other properties. For example, in the above example, the `fullName` property depends on - `firstName` and `lastName` to determine its value. You can tell Ember.js + `firstName` and `lastName` to determine its value. You can tell Ember about these dependencies like this: - MyApp.president = Ember.Object.create({ - firstName: "Barack", - lastName: "Obama", + ```javascript + MyApp.president = Ember.Object.create({ + firstName: "Barack", + lastName: "Obama", - fullName: function() { - return this.get('firstName') + ' ' + this.get('lastName'); + fullName: function() { + return this.get('firstName') + ' ' + this.get('lastName'); - // Tell Ember.js that this computed property depends on firstName - // and lastName - }.property('firstName', 'lastName') - }); + // Tell Ember.js that this computed property depends on firstName + // and lastName + }.property('firstName', 'lastName') + }); + ``` - Make sure you list these dependencies so Ember.js knows when to update + Make sure you list these dependencies so Ember knows when to update bindings that connect to a computed property. Changing a dependency will not immediately trigger an update of the computed property, but will instead clear the cache so that it is updated when the next `get` @@ -6462,18 +7114,20 @@ if (Ember.EXTEND_PROTOTYPES === true || Ember.EXTEND_PROTOTYPES.Function) { /** The `observes` extension of Javascript's Function prototype is available - when Ember.EXTEND_PROTOTYPES or Ember.EXTEND_PROTOTYPES.Function is true, - which is the default. + when `Ember.EXTEND_PROTOTYPES` or `Ember.EXTEND_PROTOTYPES.Function` is + true, which is the default. You can observe property changes simply by adding the `observes` call to the end of your method declarations in classes that you write. For example: - Ember.Object.create({ - valueObserver: function() { - // Executes whenever the "value" property changes - }.observes('value') - }); + ```javascript + Ember.Object.create({ + valueObserver: function() { + // Executes whenever the "value" property changes + }.observes('value') + }); + ``` See {{#crossLink "Ember.Observable/observes"}}{{/crossLink}} @@ -6486,19 +7140,21 @@ if (Ember.EXTEND_PROTOTYPES === true || Ember.EXTEND_PROTOTYPES.Function) { }; /** - The `observesBefore` extension of Javascript's Function prototype is available - when Ember.EXTEND_PROTOTYPES or Ember.EXTEND_PROTOTYPES.Function is true, - which is the default. + The `observesBefore` extension of Javascript's Function prototype is + available when `Ember.EXTEND_PROTOTYPES` or + `Ember.EXTEND_PROTOTYPES.Function` is true, which is the default. You can get notified when a property changes is about to happen by by adding the `observesBefore` call to the end of your method declarations in classes that you write. For example: - Ember.Object.create({ - valueObserver: function() { - // Executes whenever the "value" property is about to change - }.observesBefore('value') - }); + ```javascript + Ember.Object.create({ + valueObserver: function() { + // Executes whenever the "value" property is about to change + }.observesBefore('value') + }); + ``` See {{#crossLink "Ember.Observable/observesBefore"}}{{/crossLink}} @@ -6560,33 +7216,33 @@ function iter(key, value) { /** This mixin defines the common interface implemented by enumerable objects - in Ember. Most of these methods follow the standard Array iteration + in Ember. Most of these methods follow the standard Array iteration API defined up to JavaScript 1.8 (excluding language-specific features that cannot be emulated in older versions of JavaScript). This mixin is applied automatically to the Array class on page load, so you - can use any of these methods on simple arrays. If Array already implements + can use any of these methods on simple arrays. If Array already implements one of these methods, the mixin will not override them. - h3. Writing Your Own Enumerable + ## Writing Your Own Enumerable To make your own custom class enumerable, you need two items: - 1. You must have a length property. This property should change whenever - the number of items in your enumerable object changes. If you using this - with an Ember.Object subclass, you should be sure to change the length - property using set(). + 1. You must have a length property. This property should change whenever + the number of items in your enumerable object changes. If you using this + with an `Ember.Object` subclass, you should be sure to change the length + property using `set().` - 2. If you must implement nextObject(). See documentation. + 2. If you must implement `nextObject().` See documentation. - Once you have these two methods implement, apply the Ember.Enumerable mixin + Once you have these two methods implement, apply the `Ember.Enumerable` mixin to your class and you will be able to enumerate the contents of your object like any other collection. - h3. Using Ember Enumeration with Other Libraries + ## Using Ember Enumeration with Other Libraries Many other libraries provide some kind of iterator or enumeration like - facility. This is often where the most common API conflicts occur. + facility. This is often where the most common API conflicts occur. Ember's API is designed to be as friendly as possible with other libraries by implementing only methods that mostly correspond to the JavaScript 1.8 API. @@ -6605,24 +7261,24 @@ Ember.Enumerable = Ember.Mixin.create( /** Implement this method to make your class enumerable. - This method will be call repeatedly during enumeration. The index value - will always begin with 0 and increment monotonically. You don't have to + This method will be call repeatedly during enumeration. The index value + will always begin with 0 and increment monotonically. You don't have to rely on the index value to determine what object to return, but you should always check the value and start from the beginning when you see the requested index is 0. - The previousObject is the object that was returned from the last call - to nextObject for the current iteration. This is a useful way to + The `previousObject` is the object that was returned from the last call + to `nextObject` for the current iteration. This is a useful way to manage iteration if you are tracing a linked list, for example. Finally the context parameter will always contain a hash you can use as a "scratchpad" to maintain any other state you need in order to iterate - properly. The context object is reused and is not reset between + properly. The context object is reused and is not reset between iterations so make sure you setup the context with a fresh state whenever the index parameter is 0. - Generally iterators will continue to call nextObject until the index - reaches the your current length-1. If you run out of data before this + 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. @@ -6630,27 +7286,30 @@ Ember.Enumerable = Ember.Mixin.create( @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} 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: Ember.required(Function), /** - Helper method returns the first object from a collection. This is usually + 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 + 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. + If your enumerable is empty, this method should return `undefined`. - var arr = ["a", "b", "c"]; - arr.firstObject(); => "a" + ```javascript + var arr = ["a", "b", "c"]; + arr.firstObject(); // "a" - var arr = []; - arr.firstObject(); => undefined + var arr = []; + arr.firstObject(); // undefined + ``` @property firstObject @return {Object} the object or undefined @@ -6668,13 +7327,15 @@ Ember.Enumerable = Ember.Mixin.create( /** Helper method returns the last object from a collection. If your enumerable contains only one object, this method should always return that object. - If your enumerable is empty, this method should return undefined. + If your enumerable is empty, this method should return `undefined`. - var arr = ["a", "b", "c"]; - arr.lastObject(); => "c" + ```javascript + var arr = ["a", "b", "c"]; + arr.lastObject(); // "c" - var arr = []; - arr.lastObject(); => undefined + var arr = []; + arr.lastObject(); // undefined + ``` @property lastObject @return {Object} the last object or undefined @@ -6692,17 +7353,19 @@ Ember.Enumerable = Ember.Mixin.create( }).property('[]'), /** - Returns true if the passed object can be found in the receiver. The + Returns `true` if the passed object can be found in the receiver. The default version will iterate through the enumerable until the object - is found. You may want to override this with a more efficient version. + is found. You may want to override this with a more efficient version. - var arr = ["a", "b", "c"]; - arr.contains("a"); => true - arr.contains("z"); => false + ```javascript + var arr = ["a", "b", "c"]; + arr.contains("a"); // true + arr.contains("z"); // false + ``` @method contains @param {Object} obj The object to search for. - @return {Boolean} true if object is found in enumerable. + @return {Boolean} `true` if object is found in enumerable. */ contains: function(obj) { return this.find(function(item) { return item===obj; }) !== undefined; @@ -6710,20 +7373,22 @@ Ember.Enumerable = Ember.Mixin.create( /** Iterates through the enumerable, calling the passed function on each - item. This method corresponds to the forEach() method defined in + item. This method corresponds to the `forEach()` method defined in JavaScript 1.6. The callback method you provide should have the following signature (all parameters are optional): - function(item, index, enumerable); + ```javascript + function(item, index, enumerable); + ``` - - *item* is the current item in the iteration. - - *index* is the current index in the iteration - - *enumerable* is the enumerable object itself. + - `item` is the current item in the iteration. + - `index` is the current index in the iteration. + - `enumerable` is the enumerable object itself. Note that in addition to a callback, you can also pass an optional target - object that will be set as "this" on the context. This is a good way + object that will be set as `this` on the context. This is a good way to give your iterator function access to the current object. @method forEach @@ -6748,7 +7413,7 @@ Ember.Enumerable = Ember.Mixin.create( }, /** - Alias for mapProperty + Alias for `mapProperty` @method getEach @param {String} key name of the property @@ -6761,8 +7426,8 @@ Ember.Enumerable = Ember.Mixin.create( /** Sets the value on the named property for each member. This is more efficient than using other methods defined on this helper. If the object - implements Ember.Observable, the value will be changed to set(), otherwise - it will be set directly. null objects are skipped. + implements Ember.Observable, the value will be changed to `set(),` otherwise + it will be set directly. `null` objects are skipped. @method setEach @param {String} key The key to set @@ -6777,21 +7442,23 @@ Ember.Enumerable = Ember.Mixin.create( /** Maps all of the items in the enumeration to another value, returning - a new array. This method corresponds to map() defined in JavaScript 1.6. + a new array. This method corresponds to `map()` defined in JavaScript 1.6. The callback method you provide should have the following signature (all parameters are optional): - function(item, index, enumerable); + ```javascript + function(item, index, enumerable); + ``` - - *item* is the current item in the iteration. - - *index* is the current index in the iteration - - *enumerable* is the enumerable object itself. + - `item` is the current item in the iteration. + - `index` is the current index in the iteration. + - `enumerable` is the enumerable object itself. It should return the mapped value. Note that in addition to a callback, you can also pass an optional target - object that will be set as "this" on the context. This is a good way + object that will be set as `this` on the context. This is a good way to give your iterator function access to the current object. @method map @@ -6823,22 +7490,25 @@ Ember.Enumerable = Ember.Mixin.create( /** Returns an array with all of the items in the enumeration that the passed - function returns true for. This method corresponds to filter() defined in + function returns true for. This method corresponds to `filter()` defined in JavaScript 1.6. The callback method you provide should have the following signature (all parameters are optional): - function(item, index, enumerable); + ```javascript + function(item, index, enumerable); + ``` - - *item* is the current item in the iteration. - - *index* is the current index in the iteration - - *enumerable* is the enumerable object itself. + - `item` is the current item in the iteration. + - `index` is the current index in the iteration. + - `enumerable` is the enumerable object itself. - It should return the true to include the item in the results, false otherwise. + It should return the `true` to include the item in the results, `false` + otherwise. Note that in addition to a callback, you can also pass an optional target - object that will be set as "this" on the context. This is a good way + object that will be set as `this` on the context. This is a good way to give your iterator function access to the current object. @method filter @@ -6855,9 +7525,39 @@ Ember.Enumerable = Ember.Mixin.create( }, /** - Returns an array with just the items with the matched property. You - can pass an optional second argument with the target value. Otherwise - this will match any property that evaluates to true. + Returns an array with all of the items in the enumeration where the passed + function returns false for. This method is the inverse of filter(). + + The callback method you provide should have the following signature (all + parameters are optional): + + function(item, index, enumerable); + + - *item* is the current item in the iteration. + - *index* is the current index in the iteration + - *enumerable* is the enumerable object itself. + + It should return the a falsey value to include the item in the results. + + Note that in addition to a callback, you can also pass an optional target + object that will be set as "this" on the context. This is a good way + to give your iterator function access to the current object. + + @method reject + @param {Function} callback The callback to execute + @param {Object} [target] The target object to use + @return {Array} A rejected array. + */ + reject: function(callback, target) { + return this.filter(function() { + return !(callback.apply(target, arguments)); + }); + }, + + /** + Returns an array with just the items with the matched property. You + can pass an optional second argument with the target value. Otherwise + this will match any property that evaluates to `true`. @method filterProperty @param {String} key the property to test @@ -6868,30 +7568,51 @@ Ember.Enumerable = Ember.Mixin.create( return this.filter(iter.apply(this, arguments)); }, + /** + Returns an array with the items that do not have truthy values for + key. You can pass an optional second argument with the target value. Otherwise + this will match any property that evaluates to false. + + @method rejectProperty + @param {String} key the property to test + @param {String} [value] optional value to test against. + @return {Array} rejected array + */ + rejectProperty: function(key, value) { + var exactValue = function(item) { return get(item, key) === value; }, + hasValue = function(item) { return !!get(item, key); }, + use = (arguments.length === 2 ? exactValue : hasValue); + + return this.reject(use); + }, + /** Returns the first item in the array for which the callback returns true. - This method works similar to the filter() method defined in JavaScript 1.6 + This method works similar to the `filter()` method defined in JavaScript 1.6 except that it will stop working on the array once a match is found. The callback method you provide should have the following signature (all parameters are optional): - function(item, index, enumerable); + ```javascript + function(item, index, enumerable); + ``` - - *item* is the current item in the iteration. - - *index* is the current index in the iteration - - *enumerable* is the enumerable object itself. + - `item` is the current item in the iteration. + - `index` is the current index in the iteration. + - `enumerable` is the enumerable object itself. - It should return the true to include the item in the results, false otherwise. + It should return the `true` to include the item in the results, `false` + otherwise. Note that in addition to a callback, you can also pass an optional target - object that will be set as "this" on the context. This is a good way + object that will be set as `this` on the context. This is a good way to give your iterator function access to the current object. @method find @param {Function} callback The callback to execute @param {Object} [target] The target object to use - @return {Object} Found item or null. + @return {Object} Found item or `undefined`. */ find: function(callback, target) { var len = get(this, 'length') ; @@ -6910,43 +7631,47 @@ Ember.Enumerable = Ember.Mixin.create( }, /** - Returns the first item with a property matching the passed value. You - can pass an optional second argument with the target value. Otherwise - this will match any property that evaluates to true. + Returns the first item with a property matching the passed value. You + can pass an optional second argument with the target value. Otherwise + this will match any property that evaluates to `true`. - This method works much like the more generic find() method. + This method works much like the more generic `find()` method. @method findProperty @param {String} key the property to test @param {String} [value] optional value to test against. - @return {Object} found item or null + @return {Object} found item or `undefined` */ findProperty: function(key, value) { return this.find(iter.apply(this, arguments)); }, /** - Returns true if the passed function returns true for every item in the - enumeration. This corresponds with the every() method in JavaScript 1.6. + Returns `true` if the passed function returns true for every item in the + enumeration. This corresponds with the `every()` method in JavaScript 1.6. The callback method you provide should have the following signature (all parameters are optional): - function(item, index, enumerable); + ```javascript + function(item, index, enumerable); + ``` - - *item* is the current item in the iteration. - - *index* is the current index in the iteration - - *enumerable* is the enumerable object itself. + - `item` is the current item in the iteration. + - `index` is the current index in the iteration. + - `enumerable` is the enumerable object itself. - It should return the true or false. + It should return the `true` or `false`. Note that in addition to a callback, you can also pass an optional target - object that will be set as "this" on the context. This is a good way + object that will be set as `this` on the context. This is a good way to give your iterator function access to the current object. Example Usage: - if (people.every(isEngineer)) { Paychecks.addBigBonus(); } + ```javascript + if (people.every(isEngineer)) { Paychecks.addBigBonus(); } + ``` @method every @param {Function} callback The callback to execute @@ -6960,13 +7685,13 @@ Ember.Enumerable = Ember.Mixin.create( }, /** - Returns true if the passed property resolves to true for all items in the - enumerable. This method is often simpler/faster than using a callback. + Returns `true` if the passed property resolves to `true` for all items in + the enumerable. This method is often simpler/faster than using a callback. @method everyProperty @param {String} key the property to test @param {String} [value] optional value to test against. - @return {Array} filtered array + @return {Boolean} */ everyProperty: function(key, value) { return this.every(iter.apply(this, arguments)); @@ -6974,27 +7699,32 @@ Ember.Enumerable = Ember.Mixin.create( /** - Returns true if the passed function returns true for any item in the - enumeration. This corresponds with the every() method in JavaScript 1.6. + Returns `true` if the passed function returns true for any item in the + enumeration. This corresponds with the `some()` method in JavaScript 1.6. The callback method you provide should have the following signature (all parameters are optional): - function(item, index, enumerable); + ```javascript + function(item, index, enumerable); + ``` - - *item* is the current item in the iteration. - - *index* is the current index in the iteration - - *enumerable* is the enumerable object itself. + - `item` is the current item in the iteration. + - `index` is the current index in the iteration. + - `enumerable` is the enumerable object itself. - It should return the true to include the item in the results, false otherwise. + It should return the `true` to include the item in the results, `false` + otherwise. Note that in addition to a callback, you can also pass an optional target - object that will be set as "this" on the context. This is a good way + object that will be set as `this` on the context. This is a good way to give your iterator function access to the current object. Usage Example: - if (people.some(isManager)) { Paychecks.addBiggerBonus(); } + ```javascript + if (people.some(isManager)) { Paychecks.addBiggerBonus(); } + ``` @method some @param {Function} callback The callback to execute @@ -7008,13 +7738,13 @@ Ember.Enumerable = Ember.Mixin.create( }, /** - Returns true if the passed property resolves to true for any item in the - enumerable. This method is often simpler/faster than using a callback. + Returns `true` if the passed property resolves to `true` for any item in + the enumerable. This method is often simpler/faster than using a callback. @method someProperty @param {String} key the property to test @param {String} [value] optional value to test against. - @return {Boolean} true + @return {Boolean} `true` */ someProperty: function(key, value) { return this.some(iter.apply(this, arguments)); @@ -7023,21 +7753,23 @@ Ember.Enumerable = Ember.Mixin.create( /** This will combine the values of the enumerator into a single value. It is a useful way to collect a summary value from an enumeration. This - corresponds to the reduce() method defined in JavaScript 1.8. + corresponds to the `reduce()` method defined in JavaScript 1.8. The callback method you provide should have the following signature (all parameters are optional): - function(previousValue, item, index, enumerable); + ```javascript + function(previousValue, item, index, enumerable); + ``` - - *previousValue* is the value returned by the last call to the iterator. - - *item* is the current item in the iteration. - - *index* is the current index in the iteration - - *enumerable* is the enumerable object itself. + - `previousValue` is the value returned by the last call to the iterator. + - `item` is the current item in the iteration. + - `index` is the current index in the iteration. + - `enumerable` is the enumerable object itself. Return the new cumulative value. - In addition to the callback you can also pass an initialValue. An error + In addition to the callback you can also pass an `initialValue`. An error will be raised if you do not pass an initial value and the enumerator is empty. @@ -7065,7 +7797,7 @@ Ember.Enumerable = Ember.Mixin.create( /** Invokes the named method on every object in the receiver that - implements it. This method corresponds to the implementation in + implements it. This method corresponds to the implementation in Prototype 1.6. @method invoke @@ -7088,8 +7820,8 @@ Ember.Enumerable = Ember.Mixin.create( }, /** - Simply converts the enumerable into a genuine array. The order is not - guaranteed. Corresponds to the method implemented by Prototype. + Simply converts the enumerable into a genuine array. The order is not + guaranteed. Corresponds to the method implemented by Prototype. @method toArray @return {Array} the enumerable as an array. @@ -7103,8 +7835,10 @@ Ember.Enumerable = Ember.Mixin.create( /** Returns a copy of the array with all null elements removed. - var arr = ["a", null, "c", null]; - arr.compact(); => ["a", "c"] + ```javascript + var arr = ["a", null, "c", null]; + arr.compact(); // ["a", "c"] + ``` @method compact @return {Array} the array without null elements. @@ -7112,12 +7846,14 @@ Ember.Enumerable = Ember.Mixin.create( compact: function() { return this.without(null); }, /** - Returns a new enumerable that excludes the passed value. The default + Returns a new enumerable that excludes the passed value. The default implementation returns an array regardless of the receiver type unless the receiver does not contain the value. - var arr = ["a", "b", "a", "c"]; - arr.without("a"); => ["b", "c"] + ```javascript + var arr = ["a", "b", "a", "c"]; + arr.without("a"); // ["b", "c"] + ``` @method without @param {Object} value @@ -7133,11 +7869,13 @@ Ember.Enumerable = Ember.Mixin.create( }, /** - Returns a new enumerable that contains only unique values. The default + Returns a new enumerable that contains only unique values. The default implementation returns an array regardless of the receiver type. - var arr = ["a", "a", "b", "b"]; - arr.uniq(); => ["a", "b"] + ```javascript + var arr = ["a", "a", "b", "b"]; + arr.uniq(); // ["a", "b"] + ``` @method uniq @return {Ember.Enumerable} @@ -7155,7 +7893,7 @@ Ember.Enumerable = Ember.Mixin.create( You can observe this property to be notified of changes to the enumerables content. - For plain enumerables, this property is read only. Ember.Array overrides + For plain enumerables, this property is read only. `Ember.Array` overrides this method. @property [] @@ -7163,14 +7901,14 @@ Ember.Enumerable = Ember.Mixin.create( */ '[]': Ember.computed(function(key, value) { return this; - }).property(), + }), // .......................................................... // ENUMERABLE OBSERVERS // /** - Registers an enumerable observer. Must implement Ember.EnumerableObserver + Registers an enumerable observer. Must implement `Ember.EnumerableObserver` mixin. @method addEnumerableObserver @@ -7217,12 +7955,12 @@ Ember.Enumerable = Ember.Mixin.create( */ hasEnumerableObservers: Ember.computed(function() { return Ember.hasListeners(this, '@enumerable:change') || Ember.hasListeners(this, '@enumerable:before'); - }).property(), + }), /** Invoke this method just before the contents of your enumerable will - change. You can either omit the parameters completely or pass the objects + change. You can either omit the parameters completely or pass the objects to be removed or added if available or just a count. @method enumerableContentWillChange @@ -7258,7 +7996,7 @@ Ember.Enumerable = Ember.Mixin.create( /** Invoke this method when the contents of your enumerable has changed. - This will notify any observers watching for content changes. If your are + This will notify any observers watching for content changes. If your are implementing an ordered enumerable (such as an array), also pass the start and end values where the content changed so that it can be used to notify range observers. @@ -7297,9 +8035,6 @@ Ember.Enumerable = Ember.Mixin.create( }) ; - - - })(); @@ -7322,12 +8057,12 @@ function none(obj) { return obj===null || obj===undefined; } // ARRAY // /** - This module implements Observer-friendly Array-like behavior. This mixin is + This module implements Observer-friendly Array-like behavior. This mixin is picked up by the Array class as well as other controllers, etc. that want to appear to be arrays. - Unlike Ember.Enumerable, this mixin defines methods specifically for - collections that provide index-ordered access to their contents. When you + Unlike `Ember.Enumerable,` this mixin defines methods specifically for + collections that provide index-ordered access to their contents. When you are designing code that needs to accept any kind of Array-like object, you should use these methods instead of Array primitives because these will properly notify observers of changes to the array. @@ -7338,15 +8073,15 @@ function none(obj) { return obj===null || obj===undefined; } as controllers and collections. You can use the methods defined in this module to access and modify array - contents in a KVO-friendly way. You can also be notified whenever the + contents in a KVO-friendly way. You can also be notified whenever the membership if an array changes by changing the syntax of the property to - .observes('*myProperty.[]') . + `.observes('*myProperty.[]')`. - To support Ember.Array in your own class, you must override two - primitives to use it: replace() and objectAt(). + To support `Ember.Array` in your own class, you must override two + primitives to use it: `replace()` and `objectAt()`. - Note that the Ember.Array mixin also incorporates the Ember.Enumerable mixin. All - Ember.Array-like objects are also enumerable. + Note that the Ember.Array mixin also incorporates the `Ember.Enumerable` + mixin. All `Ember.Array`-like objects are also enumerable. @class Array @namespace Ember @@ -7360,7 +8095,7 @@ Ember.Array = Ember.Mixin.create(Ember.Enumerable, /** @scope Ember.Array.protot isSCArray: true, /** - Your array must support the length property. Your replace methods should + Your array must support the `length` property. Your replace methods should set this property whenever it changes. @property {Number} length @@ -7368,24 +8103,25 @@ Ember.Array = Ember.Mixin.create(Ember.Enumerable, /** @scope Ember.Array.protot length: Ember.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`. + 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. - var arr = ['a', 'b', 'c', 'd']; - arr.objectAt(0); => "a" - arr.objectAt(3); => "d" - arr.objectAt(-1); => undefined - arr.objectAt(4); => undefined - arr.objectAt(5); => undefined + ```javascript + var arr = ['a', 'b', 'c', 'd']; + arr.objectAt(0); // "a" + arr.objectAt(3); // "d" + arr.objectAt(-1); // undefined + arr.objectAt(4); // undefined + arr.objectAt(5); // undefined + ``` @method objectAt - @param {Number} idx - The index of the item to return. + @param {Number} idx The index of the item to return. */ objectAt: function(idx) { if ((idx < 0) || (idx>=get(this, 'length'))) return undefined ; @@ -7395,13 +8131,14 @@ Ember.Array = Ember.Mixin.create(Ember.Enumerable, /** @scope Ember.Array.protot /** This returns the objects at the specified indexes, using `objectAt`. - var arr = ['a', 'b', 'c', 'd']; - arr.objectsAt([0, 1, 2]) => ["a", "b", "c"] - arr.objectsAt([2, 3, 4]) => ["c", "d", undefined] + ```javascript + var arr = ['a', 'b', 'c', 'd']; + arr.objectsAt([0, 1, 2]); // ["a", "b", "c"] + arr.objectsAt([2, 3, 4]); // ["c", "d", undefined] + ``` @method objectsAt - @param {Array} indexes - An array of indexes of items to return. + @param {Array} indexes An array of indexes of items to return. */ objectsAt: function(indexes) { var self = this; @@ -7414,26 +8151,26 @@ Ember.Array = Ember.Mixin.create(Ember.Enumerable, /** @scope Ember.Array.protot }, /** - This is the handler for the special array content property. If you get - this property, it will return this. If you set this property it a new + This is the handler for the special array content property. If you get + this property, it will return this. If you set this property it a new array, it will replace the current content. - This property overrides the default property defined in Ember.Enumerable. + This property overrides the default property defined in `Ember.Enumerable`. @property [] */ '[]': Ember.computed(function(key, value) { if (value !== undefined) this.replace(0, get(this, 'length'), value) ; return this ; - }).property(), + }), firstObject: Ember.computed(function() { return this.objectAt(0); - }).property(), + }), lastObject: Ember.computed(function() { return this.objectAt(get(this, 'length')-1); - }).property(), + }), // optimized version from Enumerable contains: function(obj){ @@ -7446,10 +8183,12 @@ Ember.Array = Ember.Mixin.create(Ember.Enumerable, /** @scope Ember.Array.protot uses the observable array methods to retrieve the objects for the new slice. - var arr = ['red', 'green', 'blue']; - arr.slice(0); => ['red', 'green', 'blue'] - arr.slice(0, 2); => ['red', 'green'] - arr.slice(1, 100); => ['green', 'blue'] + ```javascript + var arr = ['red', 'green', 'blue']; + arr.slice(0); // ['red', 'green', 'blue'] + arr.slice(0, 2); // ['red', 'green'] + arr.slice(1, 100); // ['green', 'blue'] + ``` @method slice @param beginIndex {Integer} (Optional) index to begin slicing from. @@ -7469,17 +8208,19 @@ Ember.Array = Ember.Mixin.create(Ember.Enumerable, /** @scope Ember.Array.protot /** Returns the index of the given object's first occurrence. - If no startAt argument is given, the starting location to + If no `startAt` argument is given, the starting location to search is 0. If it's negative, will count backward from the end of the array. Returns -1 if no match is found. - var arr = ["a", "b", "c", "d", "a"]; - arr.indexOf("a"); => 0 - arr.indexOf("z"); => -1 - arr.indexOf("a", 2); => 4 - arr.indexOf("a", -1); => 4 - arr.indexOf("b", 3); => -1 - arr.indexOf("a", 100); => -1 + ```javascript + var arr = ["a", "b", "c", "d", "a"]; + arr.indexOf("a"); // 0 + arr.indexOf("z"); // -1 + arr.indexOf("a", 2); // 4 + arr.indexOf("a", -1); // 4 + arr.indexOf("b", 3); // -1 + arr.indexOf("a", 100); // -1 + ``` @method indexOf @param {Object} object the item to search for @@ -7500,17 +8241,19 @@ Ember.Array = Ember.Mixin.create(Ember.Enumerable, /** @scope Ember.Array.protot /** Returns the index of the given object's last occurrence. - If no startAt argument is given, the search starts from + If no `startAt` argument is given, the search starts from the last position. If it's negative, will count backward from the end of the array. Returns -1 if no match is found. - var arr = ["a", "b", "c", "d", "a"]; - arr.lastIndexOf("a"); => 4 - arr.lastIndexOf("z"); => -1 - arr.lastIndexOf("a", 2); => 0 - arr.lastIndexOf("a", -1); => 4 - arr.lastIndexOf("b", 3); => 1 - arr.lastIndexOf("a", 100); => 4 + ```javascript + var arr = ["a", "b", "c", "d", "a"]; + arr.lastIndexOf("a"); // 4 + arr.lastIndexOf("z"); // -1 + arr.lastIndexOf("a", 2); // 0 + arr.lastIndexOf("a", -1); // 4 + arr.lastIndexOf("b", 3); // 1 + arr.lastIndexOf("a", 100); // 4 + ``` @method lastIndexOf @param {Object} object the item to search for @@ -7534,7 +8277,7 @@ Ember.Array = Ember.Mixin.create(Ember.Enumerable, /** @scope Ember.Array.protot // /** - Adds an array observer to the receiving array. The array observer object + Adds an array observer to the receiving array. The array observer object normally must implement two methods: * `arrayWillChange(start, removeCount, addCount)` - This method will be @@ -7543,7 +8286,7 @@ Ember.Array = Ember.Mixin.create(Ember.Enumerable, /** @scope Ember.Array.protot called just after the array is modified. Both callbacks will be passed the starting index of the change as well a - a count of the items to be removed and added. You can use these callbacks + a count of the items to be removed and added. You can use these callbacks to optionally inspect the array during the change, clear caches, or do any other bookkeeping necessary. @@ -7554,7 +8297,7 @@ Ember.Array = Ember.Mixin.create(Ember.Enumerable, /** @scope Ember.Array.protot @method addArrayObserver @param {Object} target The observer object. @param {Hash} opts Optional hash of configuration options including - willChange, didChange, and a context option. + `willChange`, `didChange`, and a `context` option. @return {Ember.Array} receiver */ addArrayObserver: function(target, opts) { @@ -7571,7 +8314,7 @@ Ember.Array = Ember.Mixin.create(Ember.Enumerable, /** @scope Ember.Array.protot /** Removes an array observer from the object if the observer is current - registered. Calling this method multiple times with the same object will + registered. Calling this method multiple times with the same object will have no effect. @method removeArrayObserver @@ -7598,18 +8341,20 @@ Ember.Array = Ember.Mixin.create(Ember.Enumerable, /** @scope Ember.Array.protot */ hasArrayObservers: Ember.computed(function() { return Ember.hasListeners(this, '@array:change') || Ember.hasListeners(this, '@array:before'); - }).property(), + }), /** - If you are implementing an object that supports Ember.Array, call this + If you are implementing an object that supports `Ember.Array`, call this method just before the array content changes to notify any observers and - invalidate any related properties. Pass the starting index of the change + invalidate any related properties. Pass the starting index of the change as well as a delta of the amounts to change. @method arrayContentWillChange @param {Number} startIdx The starting index in the array that will change. - @param {Number} removeAmt The number of items that will be removed. If you pass null assumes 0 - @param {Number} addAmt The number of items that will be added. If you pass null assumes 0. + @param {Number} removeAmt The number of items that will be removed. If you + pass `null` assumes 0 + @param {Number} addAmt The number of items that will be added If you + pass `null` assumes 0. @return {Ember.Array} receiver */ arrayContentWillChange: function(startIdx, removeAmt, addAmt) { @@ -7686,7 +8431,7 @@ Ember.Array = Ember.Mixin.create(Ember.Enumerable, /** @scope Ember.Array.protot /** Returns a special object that can be used to observe individual properties - on the array. Just get an equivalent property on this object and it will + on the array. Just get an equivalent property on this object and it will return an enumerable that maps automatically to the named key on the member objects. @@ -7695,7 +8440,7 @@ Ember.Array = Ember.Mixin.create(Ember.Enumerable, /** @scope Ember.Array.protot '@each': Ember.computed(function() { if (!this.__each) this.__each = new Ember.EachProxy(this); return this.__each; - }).property() + }) }) ; @@ -7714,7 +8459,7 @@ Ember.Array = Ember.Mixin.create(Ember.Enumerable, /** @scope Ember.Array.protot 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. + You should implement the `compare()` method. @class Comparable @namespace Ember @@ -7736,9 +8481,9 @@ Ember.Comparable = Ember.Mixin.create( /** @scope Ember.Comparable.prototype */{ 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` + - `-1` if `a < b` + - `0` if `a == b` + - `1` if `a > b` Default implementation raises an exception. @@ -7767,14 +8512,15 @@ Ember.Comparable = Ember.Mixin.create( /** @scope Ember.Comparable.prototype */{ var get = Ember.get, set = Ember.set; /** - Implements some standard methods for copying an object. Add this mixin to - any object you create that can create a copy of itself. This mixin is + Implements some standard methods for copying an object. Add this mixin to + any object you create that can create a copy of itself. This mixin is added automatically to the built-in array. - You should generally implement the copy() method to return a copy of the + You should generally implement the `copy()` method to return a copy of the receiver. - Note that frozenCopy() will only work if you also implement Ember.Freezable. + Note that `frozenCopy()` will only work if you also implement + `Ember.Freezable`. @class Copyable @namespace Ember @@ -7785,18 +8531,18 @@ Ember.Copyable = Ember.Mixin.create( /** @scope Ember.Copyable.prototype */ { /** - Override to return a copy of the receiver. Default implementation raises + Override to return a copy of the receiver. Default implementation raises an exception. @method copy - @param deep {Boolean} if true, a deep copy of the object should be made + @param deep {Boolean} if `true`, a deep copy of the object should be made @return {Object} copy of receiver */ copy: Ember.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. + 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. @@ -7817,9 +8563,6 @@ Ember.Copyable = Ember.Mixin.create( } }); - - - })(); @@ -7834,8 +8577,8 @@ Ember.Copyable = Ember.Mixin.create( var get = Ember.get, set = Ember.set; /** - The Ember.Freezable mixin implements some basic methods for marking an object - as frozen. Once an object is frozen it should be read only. No changes + The `Ember.Freezable` mixin implements some basic methods for marking an + object as frozen. Once an object is frozen it should be read only. No changes may be made the internal state of the object. ## Enforcement @@ -7843,47 +8586,47 @@ var get = Ember.get, set = Ember.set; To fully support freezing in your subclass, you must include this mixin and override any method that might alter any property on the object to instead raise an exception. You can check the state of an object by checking the - isFrozen property. + `isFrozen` property. Although future versions of JavaScript may support language-level freezing object objects, that is not the case today. Even if an object is freezable, it is still technically possible to modify the object, even though it could break other parts of your application that do not expect a frozen object to change. It is, therefore, very important that you always respect the - isFrozen property on all freezable objects. + `isFrozen` property on all freezable objects. ## Example Usage - The example below shows a simple object that implement the Ember.Freezable + The example below shows a simple object that implement the `Ember.Freezable` protocol. - Contact = Ember.Object.extend(Ember.Freezable, { + ```javascript + Contact = Ember.Object.extend(Ember.Freezable, { + firstName: null, + lastName: null, - firstName: null, + // swaps the names + swapNames: function() { + if (this.get('isFrozen')) throw Ember.FROZEN_ERROR; + var tmp = this.get('firstName'); + this.set('firstName', this.get('lastName')); + this.set('lastName', tmp); + return this; + } - lastName: null, + }); - // swaps the names - swapNames: function() { - if (this.get('isFrozen')) throw Ember.FROZEN_ERROR; - var tmp = this.get('firstName'); - this.set('firstName', this.get('lastName')); - this.set('lastName', tmp); - return this; - } - - }); - - c = Context.create({ firstName: "John", lastName: "Doe" }); - c.swapNames(); => returns c - c.freeze(); - c.swapNames(); => EXCEPTION + c = Context.create({ firstName: "John", lastName: "Doe" }); + c.swapNames(); // returns c + c.freeze(); + c.swapNames(); // EXCEPTION + ``` ## Copying - Usually the Ember.Freezable protocol is implemented in cooperation with the - Ember.Copyable protocol, which defines a frozenCopy() method that will return - a frozen object, if the object implements this method as well. + Usually the `Ember.Freezable` protocol is implemented in cooperation with the + `Ember.Copyable` protocol, which defines a `frozenCopy()` method that will + return a frozen object, if the object implements this method as well. @class Freezable @namespace Ember @@ -7894,8 +8637,8 @@ Ember.Freezable = Ember.Mixin.create( /** @scope Ember.Freezable.prototype */ { /** - Set to true when the object is frozen. Use this property to detect whether - your object is frozen or not. + Set to `true` when the object is frozen. Use this property to detect + whether your object is frozen or not. @property isFrozen @type Boolean @@ -7903,7 +8646,7 @@ Ember.Freezable = Ember.Mixin.create( isFrozen: false, /** - Freezes the object. Once this method has been called the object should + Freezes the object. Once this method has been called the object should no longer allow any properties to be edited. @method freeze @@ -7932,7 +8675,7 @@ Ember.FROZEN_ERROR = "Frozen object cannot be modified."; var forEach = Ember.EnumerableUtils.forEach; /** - This mixin defines the API for modifying generic enumerables. These methods + This mixin defines the API for modifying generic enumerables. These methods can be applied to an object regardless of whether it is ordered or unordered. @@ -7942,24 +8685,28 @@ var forEach = Ember.EnumerableUtils.forEach; ## Adding Objects - To add an object to an enumerable, use the addObject() method. This + To add an object to an enumerable, use the `addObject()` method. This method will only add the object to the enumerable if the object is not already present and the object if of a type supported by the enumerable. - set.addObject(contact); + ```javascript + set.addObject(contact); + ``` ## Removing Objects - To remove an object form an enumerable, use the removeObject() method. This + To remove an object form an enumerable, use the `removeObject()` method. This will only remove the object if it is already in the enumerable, otherwise this method has no effect. - set.removeObject(contact); + ```javascript + set.removeObject(contact); + ``` ## Implementing In Your Own Code If you are implementing an object and want to support this API, just include - this mixin in your class and implement the required methods. In your unit + this mixin in your class and implement the required methods. In your unit tests, be sure to apply the Ember.MutableEnumerableTests to your object. @class MutableEnumerable @@ -8004,7 +8751,7 @@ Ember.MutableEnumerable = Ember.Mixin.create(Ember.Enumerable, __Required.__ You must implement this method to apply this mixin. Attempts to remove the passed object from the receiver collection if the - object is in present in the collection. If the object is not present, + object is in present in the collection. If the object is not present, this method has no effect. If the passed object is of a type not supported by the receiver @@ -8056,7 +8803,7 @@ var EMPTY = []; var get = Ember.get, set = Ember.set, forEach = Ember.EnumerableUtils.forEach; /** - This mixin defines the API for modifying array-like objects. These methods + This mixin defines the API for modifying array-like objects. These methods can be applied only to a collection that keeps its items in an ordered set. Note that an Array can change even if it does not implement this mixin. @@ -8075,17 +8822,17 @@ Ember.MutableArray = Ember.Mixin.create(Ember.Array, Ember.MutableEnumerable, /** __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() ; + 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* + @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: Ember.required(), @@ -8093,10 +8840,12 @@ Ember.MutableArray = Ember.Mixin.create(Ember.Array, Ember.MutableEnumerable, Remove all elements from self. This is useful if you want to reuse an existing array without having to recreate it. - var colors = ["red", "green", "blue"]; - color.length(); => 3 - colors.clear(); => [] - colors.length(); => 0 + ```javascript + var colors = ["red", "green", "blue"]; + color.length(); // 3 + colors.clear(); // [] + colors.length(); // 0 + ``` @method clear @return {Ember.Array} An empty Array. @@ -8109,12 +8858,14 @@ Ember.MutableArray = Ember.Mixin.create(Ember.Array, Ember.MutableEnumerable, }, /** - This will use the primitive replace() method to insert an object at the + This will use the primitive `replace()` method to insert an object at the specified index. - var colors = ["red", "green", "blue"]; - colors.insertAt(2, "yellow"); => ["red", "green", "yellow", "blue"] - colors.insertAt(5, "orange"); => Error: Index out of range + ```javascript + var colors = ["red", "green", "blue"]; + colors.insertAt(2, "yellow"); // ["red", "green", "yellow", "blue"] + colors.insertAt(5, "orange"); // Error: Index out of range + ``` @method insertAt @param {Number} idx index of insert the object at. @@ -8127,16 +8878,18 @@ Ember.MutableArray = Ember.Mixin.create(Ember.Array, Ember.MutableEnumerable, }, /** - Remove an object at the specified index using the replace() primitive - method. You can pass either a single index, or a start and a length. + Remove an object at the specified index using the `replace()` primitive + method. You can pass either a single index, or a start and a length. If you pass a start and length that is beyond the - length this method will throw an Ember.OUT_OF_RANGE_EXCEPTION + length this method will throw an `Ember.OUT_OF_RANGE_EXCEPTION` - var colors = ["red", "green", "blue", "yellow", "orange"]; - colors.removeAt(0); => ["green", "blue", "yellow", "orange"] - colors.removeAt(2, 2); => ["green", "blue"] - colors.removeAt(4, 2); => Error: Index out of range + ```javascript + var colors = ["red", "green", "blue", "yellow", "orange"]; + colors.removeAt(0); // ["green", "blue", "yellow", "orange"] + colors.removeAt(2, 2); // ["green", "blue"] + colors.removeAt(4, 2); // Error: Index out of range + ``` @method removeAt @param {Number} start index, start of range @@ -8159,12 +8912,14 @@ Ember.MutableArray = Ember.Mixin.create(Ember.Array, Ember.MutableEnumerable, }, /** - Push the object onto the end of the array. Works just like push() but it + Push the object onto the end of the array. Works just like `push()` but it is KVO-compliant. - var colors = ["red", "green", "blue"]; - colors.pushObject("black"); => ["red", "green", "blue", "black"] - colors.pushObject(["yellow", "orange"]); => ["red", "green", "blue", "black", ["yellow", "orange"]] + ```javascript + var colors = ["red", "green", "blue"]; + colors.pushObject("black"); // ["red", "green", "blue", "black"] + colors.pushObject(["yellow", "orange"]); // ["red", "green", "blue", "black", ["yellow", "orange"]] + ``` @method pushObject @param {anything} obj object to push @@ -8175,12 +8930,14 @@ Ember.MutableArray = Ember.Mixin.create(Ember.Array, Ember.MutableEnumerable, }, /** - Add the objects in the passed numerable to the end of the array. Defers + Add the objects in the passed numerable to the end of the array. Defers notifying observers of the change until all objects are added. - var colors = ["red", "green", "blue"]; - colors.pushObjects("black"); => ["red", "green", "blue", "black"] - colors.pushObjects(["yellow", "orange"]); => ["red", "green", "blue", "black", "yellow", "orange"] + ```javascript + var colors = ["red", "green", "blue"]; + colors.pushObjects("black"); // ["red", "green", "blue", "black"] + colors.pushObjects(["yellow", "orange"]); // ["red", "green", "blue", "black", "yellow", "orange"] + ``` @method pushObjects @param {Ember.Enumerable} objects the objects to add @@ -8192,12 +8949,14 @@ Ember.MutableArray = Ember.Mixin.create(Ember.Array, Ember.MutableEnumerable, }, /** - Pop object from array or nil if none are left. Works just like pop() but + Pop object from array or nil if none are left. Works just like `pop()` but it is KVO-compliant. - var colors = ["red", "green", "blue"]; - colors.popObject(); => "blue" - console.log(colors); => ["red", "green"] + ```javascript + var colors = ["red", "green", "blue"]; + colors.popObject(); // "blue" + console.log(colors); // ["red", "green"] + ``` @method popObject @return object @@ -8212,12 +8971,14 @@ Ember.MutableArray = Ember.Mixin.create(Ember.Array, Ember.MutableEnumerable, }, /** - Shift an object from start of array or nil if none are left. Works just - like shift() but it is KVO-compliant. + Shift an object from start of array or nil if none are left. Works just + like `shift()` but it is KVO-compliant. - var colors = ["red", "green", "blue"]; - colors.shiftObject(); => "red" - console.log(colors); => ["green", "blue"] + ```javascript + var colors = ["red", "green", "blue"]; + colors.shiftObject(); // "red" + console.log(colors); // ["green", "blue"] + ``` @method shiftObject @return object @@ -8230,12 +8991,14 @@ Ember.MutableArray = Ember.Mixin.create(Ember.Array, Ember.MutableEnumerable, }, /** - Unshift an object to start of array. Works just like unshift() but it is + Unshift an object to start of array. Works just like `unshift()` but it is KVO-compliant. - var colors = ["red", "green", "blue"]; - colors.unshiftObject("yellow"); => ["yellow", "red", "green", "blue"] - colors.unshiftObject(["black", "white"]); => [["black", "white"], "yellow", "red", "green", "blue"] + ```javascript + var colors = ["red", "green", "blue"]; + colors.unshiftObject("yellow"); // ["yellow", "red", "green", "blue"] + colors.unshiftObject(["black", "white"]); // [["black", "white"], "yellow", "red", "green", "blue"] + ``` @method unshiftObject @param {anything} obj object to unshift @@ -8246,12 +9009,14 @@ Ember.MutableArray = Ember.Mixin.create(Ember.Array, Ember.MutableEnumerable, }, /** - Adds the named objects to the beginning of the array. Defers notifying + Adds the named objects to the beginning of the array. Defers notifying observers until all objects have been added. - var colors = ["red", "green", "blue"]; - colors.unshiftObjects(["black", "white"]); => ["black", "white", "red", "green", "blue"] - colors.unshiftObjects("yellow"); => Type Error: 'undefined' is not a function + ```javascript + var colors = ["red", "green", "blue"]; + colors.unshiftObjects(["black", "white"]); // ["black", "white", "red", "green", "blue"] + colors.unshiftObjects("yellow"); // Type Error: 'undefined' is not a function + ``` @method unshiftObjects @param {Ember.Enumerable} objects the objects to add @@ -8263,7 +9028,7 @@ Ember.MutableArray = Ember.Mixin.create(Ember.Array, Ember.MutableEnumerable, }, /** - Reverse objects in the array. Works just like reverse() but it is + Reverse objects in the array. Works just like `reverse()` but it is KVO-compliant. @method reverseObjects @@ -8281,9 +9046,11 @@ Ember.MutableArray = Ember.Mixin.create(Ember.Array, Ember.MutableEnumerable, Replace all the the receiver's content with content of the argument. If argument is an empty array receiver will be cleared. - var colors = ["red", "green", "blue"]; - colors.setObjects(["black", "white"]); => ["black", "white"] - colors.setObjects([]); => [] + ```javascript + var colors = ["red", "green", "blue"]; + colors.setObjects(["black", "white"]); // ["black", "white"] + colors.setObjects([]); // [] + ``` @method setObjects @param {Ember.Array} objects array whose content will be used for replacing @@ -8343,14 +9110,14 @@ var get = Ember.get, set = Ember.set, defineProperty = Ember.defineProperty; application. Any object that has this mixin applied can be used in observer - operations. That includes Ember.Object and most objects you will + operations. That includes `Ember.Object` and most objects you will interact with as you write your Ember application. Note that you will not generally apply this mixin to classes yourself, but you will use the features provided by this module frequently, so it is important to understand how to use it. - ## Using get() and set() + ## Using `get()` and `set()` Because of Ember's support for bindings and observers, you will always access properties using the get method, and set properties using the @@ -8365,21 +9132,25 @@ var get = Ember.get, set = Ember.set, defineProperty = Ember.defineProperty; call to the end of your method declarations in classes that you write. For example: - Ember.Object.create({ - valueObserver: function() { - // Executes whenever the "value" property changes - }.observes('value') - }); + ```javascript + Ember.Object.create({ + valueObserver: function() { + // Executes whenever the "value" property changes + }.observes('value') + }); + ``` Although this is the most common way to add an observer, this capability - is actually built into the Ember.Object class on top of two methods + is actually built into the `Ember.Object` class on top of two methods defined in this mixin: `addObserver` and `removeObserver`. You can use these two methods to add and remove observers yourself if you need to do so at runtime. To add an observer for a property, call: - object.addObserver('propertyKey', targetObject, targetAction) + ```javascript + object.addObserver('propertyKey', targetObject, targetAction) + ``` This will call the `targetAction` method on the `targetObject` to be called whenever the value of the `propertyKey` changes. @@ -8395,13 +9166,10 @@ var get = Ember.get, set = Ember.set, defineProperty = Ember.defineProperty; */ Ember.Observable = Ember.Mixin.create(/** @scope Ember.Observable.prototype */ { - // compatibility - isObserverable: true, - /** Retrieves the value of a property from the object. - This method is usually similar to using object[keyName] or object.keyName, + This method is usually similar to using `object[keyName]` or `object.keyName`, however it supports both computed properties and the unknownProperty handler. @@ -8414,9 +9182,11 @@ Ember.Observable = Ember.Mixin.create(/** @scope Ember.Observable.prototype */ { Computed properties are methods defined with the `property` modifier declared at the end, such as: - fullName: function() { - return this.getEach('firstName', 'lastName').compact().join(' '); - }.property('firstName', 'lastName') + ```javascript + fullName: function() { + return this.getEach('firstName', 'lastName').compact().join(' '); + }.property('firstName', 'lastName') + ``` When you call `get` on a computed property, the function will be called and the return value will be returned instead of the function @@ -8425,8 +9195,8 @@ Ember.Observable = Ember.Mixin.create(/** @scope Ember.Observable.prototype */ { ### Unknown Properties Likewise, if you try to call `get` on a property whose value is - undefined, the unknownProperty() method will be called on the object. - If this method returns any value other than undefined, it will be returned + `undefined`, the `unknownProperty()` method will be called on the object. + If this method returns any value other than `undefined`, it will be returned instead. This allows you to implement "virtual" properties that are not defined upfront. @@ -8439,14 +9209,18 @@ Ember.Observable = Ember.Mixin.create(/** @scope Ember.Observable.prototype */ { }, /** - To get multiple properties at once, call getProperties + To get multiple properties at once, call `getProperties` with a list of strings or an array: - record.getProperties('firstName', 'lastName', 'zipCode'); // => { firstName: 'John', lastName: 'Doe', zipCode: '10011' } + ```javascript + record.getProperties('firstName', 'lastName', 'zipCode'); // { firstName: 'John', lastName: 'Doe', zipCode: '10011' } + ``` - is equivalent to: + is equivalent to: - record.getProperties(['firstName', 'lastName', 'zipCode']); // => { firstName: 'John', lastName: 'Doe', zipCode: '10011' } + ```javascript + record.getProperties(['firstName', 'lastName', 'zipCode']); // { firstName: 'John', lastName: 'Doe', zipCode: '10011' } + ``` @method getProperties @param {String...|Array} list of keys to get @@ -8467,14 +9241,14 @@ Ember.Observable = Ember.Mixin.create(/** @scope Ember.Observable.prototype */ { /** Sets the provided key or path to the value. - This method is generally very similar to calling object[key] = value or - object.key = value, except that it provides support for computed - properties, the unknownProperty() method and property observers. + This method is generally very similar to calling `object[key] = value` or + `object.key = value`, except that it provides support for computed + properties, the `unknownProperty()` method and property observers. ### Computed Properties If you try to set a value on a key that has a computed property handler - defined (see the get() method for an example), then set() will call + defined (see the `get()` method for an example), then `set()` will call that method, passing both the value and key instead of simply changing the value itself. This is useful for those times when you need to implement a property that is composed of one or more member @@ -8483,31 +9257,33 @@ Ember.Observable = Ember.Mixin.create(/** @scope Ember.Observable.prototype */ { ### Unknown Properties If you try to set a value on a key that is undefined in the target - object, then the unknownProperty() handler will be called instead. This + object, then the `unknownProperty()` handler will be called instead. This gives you an opportunity to implement complex "virtual" properties that - are not predefined on the object. If unknownProperty() returns - undefined, then set() will simply set the value on the object. + are not predefined on the object. If `unknownProperty()` returns + undefined, then `set()` will simply set the value on the object. ### Property Observers - In addition to changing the property, set() will also register a - property change with the object. Unless you have placed this call - inside of a beginPropertyChanges() and endPropertyChanges(), any "local" - observers (i.e. observer methods declared on the same object), will be - called immediately. Any "remote" observers (i.e. observer methods - declared on another object) will be placed in a queue and called at a - later time in a coalesced manner. + In addition to changing the property, `set()` will also register a property + change with the object. Unless you have placed this call inside of a + `beginPropertyChanges()` and `endPropertyChanges(),` any "local" observers + (i.e. observer methods declared on the same object), will be called + immediately. Any "remote" observers (i.e. observer methods declared on + another object) will be placed in a queue and called at a later time in a + coalesced manner. ### Chaining - In addition to property changes, set() returns the value of the object + In addition to property changes, `set()` returns the value of the object itself so you can do chaining like this: - record.set('firstName', 'Charles').set('lastName', 'Jolley'); + ```javascript + record.set('firstName', 'Charles').set('lastName', 'Jolley'); + ``` @method set @param {String} key The property to set - @param {Object} value The value to set or null. + @param {Object} value The value to set or `null`. @return {Ember.Observable} */ set: function(keyName, value) { @@ -8516,10 +9292,12 @@ Ember.Observable = Ember.Mixin.create(/** @scope Ember.Observable.prototype */ { }, /** - To set multiple properties at once, call setProperties + To set multiple properties at once, call `setProperties` with a Hash: - record.setProperties({ firstName: 'Charles', lastName: 'Jolley' }); + ```javascript + record.setProperties({ firstName: 'Charles', lastName: 'Jolley' }); + ``` @method setProperties @param {Hash} hash the hash of keys and values to set @@ -8536,8 +9314,9 @@ Ember.Observable = Ember.Mixin.create(/** @scope Ember.Observable.prototype */ { will not be sent until the changes are finished. If you plan to make a large number of changes to an object at one time, you should call this method at the beginning of the changes to begin deferring change - notifications. When you are done making changes, call endPropertyChanges() - to deliver the deferred change notifications and end deferring. + notifications. When you are done making changes, call + `endPropertyChanges()` to deliver the deferred change notifications and end + deferring. @method beginPropertyChanges @return {Ember.Observable} @@ -8553,7 +9332,7 @@ Ember.Observable = Ember.Mixin.create(/** @scope Ember.Observable.prototype */ { You can use this method to group property changes so that notifications will not be sent until the changes are finished. If you plan to make a large number of changes to an object at one time, you should call - beginPropertyChanges() at the beginning of the changes to defer change + `beginPropertyChanges()` at the beginning of the changes to defer change notifications. When you are done making changes, call this method to deliver the deferred change notifications and end deferring. @@ -8569,14 +9348,15 @@ Ember.Observable = Ember.Mixin.create(/** @scope Ember.Observable.prototype */ { Notify the observer system that a property is about to change. Sometimes you need to change a value directly or indirectly without - actually calling get() or set() on it. In this case, you can use this - method and propertyDidChange() instead. Calling these two methods + actually calling `get()` or `set()` on it. In this case, you can use this + method and `propertyDidChange()` instead. Calling these two methods together will notify all observers that the property has potentially changed value. - Note that you must always call propertyWillChange and propertyDidChange as - a pair. If you do not, it may get the property change groups out of order - and cause notifications to be delivered more often than you would like. + Note that you must always call `propertyWillChange` and `propertyDidChange` + as a pair. If you do not, it may get the property change groups out of + order and cause notifications to be delivered more often than you would + like. @method propertyWillChange @param {String} key The property key that is about to change. @@ -8591,14 +9371,15 @@ Ember.Observable = Ember.Mixin.create(/** @scope Ember.Observable.prototype */ { Notify the observer system that a property has just changed. Sometimes you need to change a value directly or indirectly without - actually calling get() or set() on it. In this case, you can use this - method and propertyWillChange() instead. Calling these two methods + actually calling `get()` or `set()` on it. In this case, you can use this + method and `propertyWillChange()` instead. Calling these two methods together will notify all observers that the property has potentially changed value. - Note that you must always call propertyWillChange and propertyDidChange as - a pair. If you do not, it may get the property change groups out of order - and cause notifications to be delivered more often than you would like. + Note that you must always call `propertyWillChange` and `propertyDidChange` + as a pair. If you do not, it may get the property change groups out of + order and cause notifications to be delivered more often than you would + like. @method propertyDidChange @param {String} keyName The property key that has just changed. @@ -8646,19 +9427,23 @@ Ember.Observable = Ember.Mixin.create(/** @scope Ember.Observable.prototype */ { ### Observer Methods Observer methods you pass should generally have the following signature if - you do not pass a "context" parameter: + you do not pass a `context` parameter: - fooDidChange: function(sender, key, value, rev); + ```javascript + fooDidChange: function(sender, key, value, rev) { }; + ``` The sender is the object that changed. The key is the property that changes. The value property is currently reserved and unused. The rev is the last property revision of the object when it changed, which you can use to detect if the key value has really changed or not. - If you pass a "context" parameter, the context will be passed before the + If you pass a `context` parameter, the context will be passed before the revision like so: - fooDidChange: function(sender, key, value, context, rev); + ```javascript + fooDidChange: function(sender, key, value, context, rev) { }; + ``` Usually you will not need the value, context or revision parameters at the end. In this case, it is common to write observer methods that take @@ -8677,7 +9462,7 @@ Ember.Observable = Ember.Mixin.create(/** @scope Ember.Observable.prototype */ { /** Remove an observer you have previously registered on this object. Pass - the same key, target, and method you passed to addObserver() and your + the same key, target, and method you passed to `addObserver()` and your target will no longer receive notifications. @method removeObserver @@ -8691,7 +9476,7 @@ Ember.Observable = Ember.Mixin.create(/** @scope Ember.Observable.prototype */ { }, /** - Returns true if the object currently has observers registered for a + Returns `true` if the object currently has observers registered for a particular key. You can use this method to potentially defer performing an expensive action until someone begins observing a particular property on the object. @@ -8704,33 +9489,6 @@ Ember.Observable = Ember.Mixin.create(/** @scope Ember.Observable.prototype */ { return Ember.hasListeners(this, key+':change'); }, - /** - This method will be called when a client attempts to get the value of a - property that has not been defined in one of the typical ways. Override - this method to create "virtual" properties. - - @method unknownProperty - @param {String} key The name of the unknown property that was requested. - @return {Object} The property value or undefined. Default is undefined. - */ - unknownProperty: function(key) { - return undefined; - }, - - /** - This method will be called when a client attempts to set the value of a - property that has not been defined in one of the typical ways. Override - this method to create "virtual" properties. - - @method setUnknownProperty - @param {String} key The name of the unknown property to be set. - @param {Object} value The value the unknown property is to be set to. - */ - setUnknownProperty: function(key, value) { - defineProperty(this, key); - set(this, key, value); - }, - /** @deprecated @method getPath @@ -8746,7 +9504,7 @@ Ember.Observable = Ember.Mixin.create(/** @scope Ember.Observable.prototype */ { @deprecated @method setPath @param {String} path The path to the property that will be set - @param {Object} value The value to set or null. + @param {Object} value The value to set or `null`. @return {Ember.Observable} */ setPath: function(path, value) { @@ -8755,10 +9513,12 @@ Ember.Observable = Ember.Mixin.create(/** @scope Ember.Observable.prototype */ { }, /** - Retrieves the value of a property, or a default value in the case that the property - returns undefined. + Retrieves the value of a property, or a default value in the case that the + property returns `undefined`. - person.getWithDefault('lastName', 'Doe'); + ```javascript + person.getWithDefault('lastName', 'Doe'); + ``` @method getWithDefault @param {String} keyName The name of the property to retrieve @@ -8772,8 +9532,10 @@ Ember.Observable = Ember.Mixin.create(/** @scope Ember.Observable.prototype */ { /** Set the value of a property to the current value plus some amount. - person.incrementProperty('age'); - team.incrementProperty('score', 2); + ```javascript + person.incrementProperty('age'); + team.incrementProperty('score', 2); + ``` @method incrementProperty @param {String} keyName The name of the property to increment @@ -8789,8 +9551,10 @@ Ember.Observable = Ember.Mixin.create(/** @scope Ember.Observable.prototype */ { /** Set the value of a property to the current value minus some amount. - player.decrementProperty('lives'); - orc.decrementProperty('health', 5); + ```javascript + player.decrementProperty('lives'); + orc.decrementProperty('health', 5); + ``` @method decrementProperty @param {String} keyName The name of the property to decrement @@ -8807,7 +9571,9 @@ Ember.Observable = Ember.Mixin.create(/** @scope Ember.Observable.prototype */ { Set the value of a boolean property to the opposite of it's current value. - starship.toggleProperty('warpDriveEnaged'); + ```javascript + starship.toggleProperty('warpDriveEnaged'); + ``` @method toggleProperty @param {String} keyName The name of the property to toggle @@ -8907,37 +9673,97 @@ Ember.TargetActionSupport = Ember.Mixin.create({ */ /** + This mixin allows for Ember objects to subscribe to and emit events. + + ```javascript + App.Person = Ember.Object.extend(Ember.Evented, { + greet: function() { + // ... + this.trigger('greet'); + } + }); + + var person = App.Person.create(); + + person.on('greet', function() { + console.log('Our person has greeted'); + }); + + person.greet(); + + // outputs: 'Our person has greeted' + ``` + @class Evented @namespace Ember @extends Ember.Mixin */ Ember.Evented = Ember.Mixin.create({ + + /** + Subscribes to a named event with given function. + + ```javascript + person.on('didLoad', function() { + // fired once the person has loaded + }); + ``` + + An optional target can be passed in as the 2nd argument that will + be set as the "this" for the callback. This is a good way to give your + function access to the object triggering the event. When the target + parameter is used the callback becomes the third argument. + + @method on + @param {String} name The name of the event + @param {Object} [target] The "this" binding for the callback + @param {Function} method The callback to execute + */ on: function(name, target, method) { Ember.addListener(this, name, target, method); }, + /** + Subscribes a function to a named event and then cancels the subscription + after the first time the event is triggered. It is good to use ``one`` when + you only care about the first time an event has taken place. + + This function takes an optional 2nd argument that will become the "this" + value for the callback. If this argument is passed then the 3rd argument + becomes the function. + + @method one + @param {String} name The name of the event + @param {Object} [target] The "this" binding for the callback + @param {Function} method The callback to execute + */ one: function(name, target, method) { if (!method) { method = target; target = null; } - var self = this; - var wrapped = function() { - Ember.removeListener(self, name, target, method); - - if ('string' === typeof method) { method = this[method]; } - - // Internally, a `null` target means that the target is - // the first parameter to addListener. That means that - // the `this` passed into this function is the target - // determined by the event system. - method.apply(this, arguments); - }; - - Ember.addListener(this, name, target, wrapped, Ember.guidFor(method)); + Ember.addListener(this, name, target, method, true); }, + /** + Triggers a named event for the object. Any additional arguments + will be passed as parameters to the functions that are subscribed to the + event. + + ```javascript + person.on('didEat', function(food) { + console.log('person ate some ' + food); + }); + + person.trigger('didEat', 'broccoli'); + + // outputs: person ate some broccoli + ``` + @method trigger + @param {String} name The name of the event + @param {Object...} args Optional arguments to pass on + */ trigger: function(name) { var args = [], i, l; for (i = 1, l = arguments.length; i < l; i++) { @@ -8951,10 +9777,25 @@ Ember.Evented = Ember.Mixin.create({ this.trigger.apply(this, arguments); }, + /** + Cancels subscription for give name, target, and method. + + @method off + @param {String} name The name of the event + @param {Object} target The target of the subscription + @param {Function} method The function of the subscription + */ off: function(name, target, method) { Ember.removeListener(this, name, target, method); }, + /** + Checks to see if object has any subscriptions for named event. + + @method has + @param {String} name The name of the event + @return {Boolean} does the object have a subscription for event + */ has: function(name) { return Ember.hasListeners(this, name); } @@ -8965,6 +9806,12 @@ Ember.Evented = Ember.Mixin.create({ (function() { +var RSVP = requireModule("rsvp"); + +RSVP.async = function(callback, binding) { + Ember.run.schedule('actions', binding, callback); +}; + /** @module ember @submodule ember-runtime @@ -8978,8 +9825,7 @@ var get = Ember.get, @namespace Ember @extends Ember.Mixin */ -Ember.Deferred = Ember.Mixin.create({ - +Ember.DeferredMixin = Ember.Mixin.create({ /** Add handlers to be called when the Deferred object is resolved or rejected. @@ -8988,11 +9834,12 @@ Ember.Deferred = Ember.Mixin.create({ @param {Function} failCallback a callback function to be called when failed */ then: function(doneCallback, failCallback) { - return get(this, 'promise').then(doneCallback, failCallback); + var promise = get(this, 'promise'); + return promise.then.apply(promise, arguments); }, /** - Resolve a Deferred object and call any doneCallbacks with the given args. + Resolve a Deferred object and call any `doneCallbacks` with the given args. @method resolve */ @@ -9001,7 +9848,7 @@ Ember.Deferred = Ember.Mixin.create({ }, /** - Reject a Deferred object and call any failCallbacks with the given args. + Reject a Deferred object and call any `failCallbacks` with the given args. @method reject */ @@ -9014,6 +9861,7 @@ Ember.Deferred = Ember.Mixin.create({ }) }); + })(); @@ -9024,6 +9872,14 @@ Ember.Deferred = Ember.Mixin.create({ +(function() { +Ember.Container = requireModule('container'); +Ember.Container.set = Ember.set; + +})(); + + + (function() { /** @module ember @@ -9031,8 +9887,8 @@ Ember.Deferred = Ember.Mixin.create({ */ -// NOTE: this object should never be included directly. Instead use Ember. -// Ember.Object. We only define this separately so that Ember.Set can depend on it +// NOTE: this object should never be included directly. Instead use Ember. +// Ember.Object. We only define this separately so that Ember.Set can depend on it var set = Ember.set, get = Ember.get, @@ -9051,7 +9907,8 @@ var set = Ember.set, get = Ember.get, applyMixin = Mixin._apply, finishPartial = Mixin.finishPartial, reopen = Mixin.prototype.reopen, - classToString = Mixin.prototype.toString; + MANDATORY_SETTER = Ember.ENV.MANDATORY_SETTER, + indexOf = Ember.EnumerableUtils.indexOf; var undefinedDescriptor = { configurable: true, @@ -9063,10 +9920,10 @@ var undefinedDescriptor = { function makeCtor() { // Note: avoid accessing any properties on the object since it makes the - // method a lot faster. This is glue code so we want it to be as fast as + // method a lot faster. This is glue code so we want it to be as fast as // possible. - var wasApplied = false, initMixins; + var wasApplied = false, initMixins, initProperties; var Class = function() { if (!wasApplied) { @@ -9077,8 +9934,68 @@ function makeCtor() { var m = meta(this); m.proto = this; if (initMixins) { - this.reopen.apply(this, initMixins); + // capture locally so we can clear the closed over variable + var mixins = initMixins; initMixins = null; + this.reopen.apply(this, mixins); + } + if (initProperties) { + // capture locally so we can clear the closed over variable + var props = initProperties; + initProperties = null; + + var concatenatedProperties = this.concatenatedProperties; + + for (var i = 0, l = props.length; i < l; i++) { + var properties = props[i]; + for (var keyName in properties) { + if (!properties.hasOwnProperty(keyName)) { continue; } + + var value = properties[keyName], + IS_BINDING = Ember.IS_BINDING; + + if (IS_BINDING.test(keyName)) { + var bindings = m.bindings; + if (!bindings) { + bindings = m.bindings = {}; + } else if (!m.hasOwnProperty('bindings')) { + bindings = m.bindings = o_create(m.bindings); + } + bindings[keyName] = value; + } + + var desc = m.descs[keyName]; + + Ember.assert("Ember.Object.create no longer supports defining computed properties.", !(value instanceof Ember.ComputedProperty)); + Ember.assert("Ember.Object.create no longer supports defining methods that call _super.", !(typeof value === 'function' && value.toString().indexOf('._super') !== -1)); + + if (concatenatedProperties && indexOf(concatenatedProperties, keyName) >= 0) { + var baseValue = this[keyName]; + + if (baseValue) { + if ('function' === typeof baseValue.concat) { + value = baseValue.concat(value); + } else { + value = Ember.makeArray(baseValue).concat(value); + } + } else { + value = Ember.makeArray(value); + } + } + + if (desc) { + desc.set(this, keyName, value); + } else { + if (typeof this.setUnknownProperty === 'function' && !(keyName in this)) { + this.setUnknownProperty(keyName, value); + } else if (MANDATORY_SETTER) { + Ember.defineProperty(this, keyName, null, value); // setup mandatory setter + } else { + this[keyName] = value; + } + } + } + } } finishPartial(this, m); delete m.proto; @@ -9086,7 +10003,7 @@ function makeCtor() { this.init.apply(this, arguments); }; - Class.toString = classToString; + Class.toString = Mixin.prototype.toString; Class.willReopen = function() { if (wasApplied) { Class.PrototypeMixin = Mixin.create(Class.PrototypeMixin); @@ -9095,6 +10012,7 @@ function makeCtor() { wasApplied = false; }; Class._initMixins = function(args) { initMixins = args; }; + Class._initProperties = function(args) { initProperties = args; }; Class.proto = function() { var superclass = Class.superclass; @@ -9114,9 +10032,9 @@ function makeCtor() { } var CoreObject = makeCtor(); +CoreObject.toString = function() { return "Ember.CoreObject"; }; CoreObject.PrototypeMixin = Mixin.create({ - reopen: function() { applyMixin(this, arguments, true); return this; @@ -9126,6 +10044,71 @@ CoreObject.PrototypeMixin = Mixin.create({ init: function() {}, + /** + Defines the properties that will be concatenated from the superclass + (instead of overridden). + + By default, when you extend an Ember class a property defined in + the subclass overrides a property with the same name that is defined + in the superclass. However, there are some cases where it is preferable + to build up a property's value by combining the superclass' property + value with the subclass' value. An example of this in use within Ember + is the `classNames` property of `Ember.View`. + + Here is some sample code showing the difference between a concatenated + property and a normal one: + + ```javascript + App.BarView = Ember.View.extend({ + someNonConcatenatedProperty: ['bar'], + classNames: ['bar'] + }); + + App.FooBarView = App.BarView.extend({ + someNonConcatenatedProperty: ['foo'], + classNames: ['foo'], + }); + + var fooBarView = App.FooBarView.create(); + fooBarView.get('someNonConcatenatedProperty'); // ['foo'] + fooBarView.get('classNames'); // ['ember-view', 'bar', 'foo'] + ``` + + This behavior extends to object creation as well. Continuing the + above example: + + ```javascript + var view = App.FooBarView.create({ + someNonConcatenatedProperty: ['baz'], + classNames: ['baz'] + }) + view.get('someNonConcatenatedProperty'); // ['baz'] + view.get('classNames'); // ['ember-view', 'bar', 'foo', 'baz'] + ``` + Adding a single property that is not an array will just add it in the array: + + ```javascript + var view = App.FooBarView.create({ + classNames: 'baz' + }) + view.get('classNames'); // ['ember-view', 'bar', 'foo', 'baz'] + ``` + + Using the `concatenatedProperties` property, we can tell to Ember that mix + the content of the properties. + + In `Ember.View` the `classNameBindings` and `attributeBindings` properties + are also concatenated, in addition to `classNames`. + + This feature is available for you to use throughout the Ember object model, + although typical app developers are likely to use it infrequently. + + @property concatenatedProperties + @type Array + @default null + */ + concatenatedProperties: null, + /** @property isDestroyed @default false @@ -9139,7 +10122,7 @@ CoreObject.PrototypeMixin = Mixin.create({ isDestroying: false, /** - Destroys an object by setting the isDestroyed flag and removing its + Destroys an object by setting the `isDestroyed` flag and removing its metadata, which effectively destroys observers and bindings. If you try to set a property on a destroyed object, an exception will be @@ -9152,13 +10135,13 @@ CoreObject.PrototypeMixin = Mixin.create({ @return {Ember.Object} receiver */ destroy: function() { - if (this.isDestroying) { return; } + if (this._didCallDestroy) { return; } this.isDestroying = true; + this._didCallDestroy = true; if (this.willDestroy) { this.willDestroy(); } - set(this, 'isDestroyed', true); schedule('destroy', this, this._scheduledDestroy); return this; }, @@ -9173,6 +10156,8 @@ CoreObject.PrototypeMixin = Mixin.create({ */ _scheduledDestroy: function() { destroy(this); + set(this, 'isDestroyed', true); + if (this.didDestroy) { this.didDestroy(); } }, @@ -9182,11 +10167,51 @@ CoreObject.PrototypeMixin = Mixin.create({ return from; }, - toString: function() { - return '<'+this.constructor.toString()+':'+guidFor(this)+'>'; + /** + Returns a string representation which attempts to provide more information + than Javascript's `toString` typically does, in a generic way for all Ember + objects. + + App.Person = Em.Object.extend() + person = App.Person.create() + person.toString() //=> "" + + If the object's class is not defined on an Ember namespace, it will + indicate it is a subclass of the registered superclass: + + Student = App.Person.extend() + student = Student.create() + student.toString() //=> "<(subclass of App.Person):ember1025>" + + If the method `toStringExtension` is defined, its return value will be + included in the output. + + App.Teacher = App.Person.extend({ + toStringExtension: function(){ + return this.get('fullName'); + } + }); + teacher = App.Teacher.create() + teacher.toString(); // #=> "" + + @method toString + @return {String} string representation + */ + toString: function toString() { + var hasToStringExtension = typeof this.toStringExtension === 'function', + extension = hasToStringExtension ? ":" + this.toStringExtension() : ''; + var ret = '<'+this.constructor.toString()+':'+guidFor(this)+extension+'>'; + this.toString = makeToString(ret); + return ret; } }); +CoreObject.PrototypeMixin.ownerConstructor = CoreObject; + +function makeToString(ret) { + return function() { return ret; }; +} + if (Ember.config.overridePrototypeMixin) { Ember.config.overridePrototypeMixin(CoreObject.PrototypeMixin); } @@ -9225,12 +10250,18 @@ var ClassMixin = Mixin.create({ return Class; }, - create: function() { + createWithMixins: function() { var C = this; if (arguments.length>0) { this._initMixins(arguments); } return new C(); }, + create: function() { + var C = this; + if (arguments.length>0) { this._initProperties(arguments); } + return new C(); + }, + reopen: function() { this.willReopen(); reopen.apply(this.PrototypeMixin, arguments); @@ -9258,21 +10289,25 @@ var ClassMixin = Mixin.create({ /** In some cases, you may want to annotate computed properties with additional - metadata about how they function or what values they operate on. For example, - computed property functions may close over variables that are then no longer - available for introspection. + metadata about how they function or what values they operate on. For + example, computed property functions may close over variables that are then + no longer available for introspection. You can pass a hash of these values to a computed property like this: - person: function() { - var personId = this.get('personId'); - return App.Person.create({ id: personId }); - }.property().meta({ type: App.Person }) + ```javascript + person: function() { + var personId = this.get('personId'); + return App.Person.create({ id: personId }); + }.property().meta({ type: App.Person }) + ``` Once you've done this, you can retrieve the values saved to the computed property from your class like this: - MyClass.metaForProperty('person'); + ```javascript + MyClass.metaForProperty('person'); + ``` This will return the original hash that was passed to `meta()`. @@ -9311,6 +10346,8 @@ var ClassMixin = Mixin.create({ }); +ClassMixin.ownerConstructor = CoreObject; + if (Ember.config.overrideClassMixin) { Ember.config.overrideClassMixin(ClassMixin); } @@ -9324,9 +10361,6 @@ ClassMixin.apply(CoreObject); */ Ember.CoreObject = CoreObject; - - - })(); @@ -9337,15 +10371,15 @@ Ember.CoreObject = CoreObject; @submodule ember-runtime */ -var get = Ember.get, set = Ember.set, guidFor = Ember.guidFor, none = Ember.none; +var get = Ember.get, set = Ember.set, guidFor = Ember.guidFor, none = Ember.isNone; /** An unordered collection of objects. - A Set works a bit like an array except that its items are not ordered. - You can create a set to efficiently test for membership for an object. You - can also iterate through a set just like an array, even accessing objects - by index, however there is no guarantee as to their order. + A Set works a bit like an array except that its items are not ordered. You + can create a set to efficiently test for membership for an object. You can + also iterate through a set just like an array, even accessing objects by + index, however there is no guarantee as to their order. All Sets are observable via the Enumerable Observer API - which works on any enumerable object including both Sets and Arrays. @@ -9353,25 +10387,26 @@ var get = Ember.get, set = Ember.set, guidFor = Ember.guidFor, none = Ember.none ## Creating a Set You can create a set like you would most objects using - `new Ember.Set()`. Most new sets you create will be empty, but you can + `new Ember.Set()`. Most new sets you create will be empty, but you can also initialize the set with some content by passing an array or other enumerable of objects to the constructor. Finally, you can pass in an existing set and the set will be copied. You can also create a copy of a set by calling `Ember.Set#copy()`. - #js - // creates a new empty set - var foundNames = new Ember.Set(); + ```javascript + // creates a new empty set + var foundNames = new Ember.Set(); - // creates a set with four names in it. - var names = new Ember.Set(["Charles", "Tom", "Juan", "Alex"]); // :P + // creates a set with four names in it. + var names = new Ember.Set(["Charles", "Tom", "Juan", "Alex"]); // :P - // creates a copy of the names set. - var namesCopy = new Ember.Set(names); + // creates a copy of the names set. + var namesCopy = new Ember.Set(names); - // same as above. - var anotherNamesCopy = names.copy(); + // same as above. + var anotherNamesCopy = names.copy(); + ``` ## Adding/Removing Objects @@ -9385,8 +10420,8 @@ var get = Ember.get, set = Ember.set, guidFor = Ember.guidFor, none = Ember.none remove the object the first time and have no effect on future calls until you add the object to the set again. - NOTE: You cannot add/remove null or undefined to a set. Any attempt to do so - will be ignored. + NOTE: You cannot add/remove `null` or `undefined` to a set. Any attempt to do + so will be ignored. In addition to add/remove you can also call `push()`/`pop()`. Push behaves just like `add()` but `pop()`, unlike `remove()` will pick an arbitrary @@ -9401,9 +10436,9 @@ var get = Ember.get, set = Ember.set, guidFor = Ember.guidFor, none = Ember.none ## Observing changes When using `Ember.Set`, you can observe the `"[]"` property to be - alerted whenever the content changes. You can also add an enumerable + alerted whenever the content changes. You can also add an enumerable observer to the set to be notified of specific objects that are added and - removed from the set. See `Ember.Enumerable` for more information on + removed from the set. See `Ember.Enumerable` for more information on enumerables. This is often unhelpful. If you are filtering sets of objects, for instance, @@ -9414,16 +10449,16 @@ var get = Ember.get, set = Ember.set, guidFor = Ember.guidFor, none = Ember.none ## Other Methods - `Ember.Set` primary implements other mixin APIs. For a complete reference + `Ember.Set` primary implements other mixin APIs. For a complete reference on the methods you will use with `Ember.Set`, please consult these mixins. The most useful ones will be `Ember.Enumerable` and `Ember.MutableEnumerable` which implement most of the common iterator methods you are used to on Array. Note that you can also use the `Ember.Copyable` and `Ember.Freezable` - APIs on `Ember.Set` as well. Once a set is frozen it can no longer be - modified. The benefit of this is that when you call frozenCopy() on it, - Ember will avoid making copies of the set. This allows you to write + APIs on `Ember.Set` as well. Once a set is frozen it can no longer be + modified. The benefit of this is that when you call `frozenCopy()` on it, + Ember will avoid making copies of the set. This allows you to write code that can know with certainty when the underlying set data will or will not be modified. @@ -9455,10 +10490,12 @@ Ember.Set = Ember.CoreObject.extend(Ember.MutableEnumerable, Ember.Copyable, Emb Clears the set. This is useful if you want to reuse an existing set without having to recreate it. - var colors = new Ember.Set(["red", "green", "blue"]); - colors.length; => 3 - colors.clear(); - colors.length; => 0 + ```javascript + var colors = new Ember.Set(["red", "green", "blue"]); + colors.length; // 3 + colors.clear(); + colors.length; // 0 + ``` @method clear @return {Ember.Set} An empty Set @@ -9494,10 +10531,13 @@ Ember.Set = Ember.CoreObject.extend(Ember.MutableEnumerable, Ember.Copyable, Emb Returns true if the passed object is also an enumerable that contains the same objects as the receiver. - var colors = ["red", "green", "blue"], - same_colors = new Ember.Set(colors); - same_colors.isEqual(colors); => true - same_colors.isEqual(["purple", "brown"]); => false + ```javascript + var colors = ["red", "green", "blue"], + same_colors = new Ember.Set(colors); + + same_colors.isEqual(colors); // true + same_colors.isEqual(["purple", "brown"]); // false + ``` @method isEqual @param {Ember.Set} obj the other object. @@ -9518,48 +10558,54 @@ Ember.Set = Ember.CoreObject.extend(Ember.MutableEnumerable, Ember.Copyable, Emb }, /** - Adds an object to the set. Only non-null objects can be added to a set + Adds an object to the set. Only non-`null` objects can be added to a set and those can only be added once. If the object is already in the set or the passed value is null this method will have no effect. This is an alias for `Ember.MutableEnumerable.addObject()`. - var colors = new Ember.Set(); - colors.add("blue"); => ["blue"] - colors.add("blue"); => ["blue"] - colors.add("red"); => ["blue", "red"] - colors.add(null); => ["blue", "red"] - colors.add(undefined); => ["blue", "red"] + ```javascript + var colors = new Ember.Set(); + colors.add("blue"); // ["blue"] + colors.add("blue"); // ["blue"] + colors.add("red"); // ["blue", "red"] + colors.add(null); // ["blue", "red"] + colors.add(undefined); // ["blue", "red"] + ``` @method add @param {Object} obj The object to add. @return {Ember.Set} The set itself. */ - add: Ember.alias('addObject'), + add: Ember.aliasMethod('addObject'), /** - Removes the object from the set if it is found. If you pass a null value + Removes the object from the set if it is found. If you pass a `null` value or an object that is already not in the set, this method will have no effect. This is an alias for `Ember.MutableEnumerable.removeObject()`. - var colors = new Ember.Set(["red", "green", "blue"]); - colors.remove("red"); => ["blue", "green"] - colors.remove("purple"); => ["blue", "green"] - colors.remove(null); => ["blue", "green"] + ```javascript + var colors = new Ember.Set(["red", "green", "blue"]); + colors.remove("red"); // ["blue", "green"] + colors.remove("purple"); // ["blue", "green"] + colors.remove(null); // ["blue", "green"] + ``` @method remove @param {Object} obj The object to remove @return {Ember.Set} The set itself. */ - remove: Ember.alias('removeObject'), + remove: Ember.aliasMethod('removeObject'), /** - Removes the last element from the set and returns it, or null if it's empty. + Removes the last element from the set and returns it, or `null` if it's empty. - var colors = new Ember.Set(["green", "blue"]); - colors.pop(); => "blue" - colors.pop(); => "green" - colors.pop(); => null + ```javascript + var colors = new Ember.Set(["green", "blue"]); + colors.pop(); // "blue" + colors.pop(); // "green" + colors.pop(); // null + ``` @method pop @return {Object} The removed object from the set or null. @@ -9577,30 +10623,34 @@ Ember.Set = Ember.CoreObject.extend(Ember.MutableEnumerable, Ember.Copyable, Emb This is an alias for `Ember.MutableEnumerable.addObject()`. - var colors = new Ember.Set(); - colors.push("red"); => ["red"] - colors.push("green"); => ["red", "green"] - colors.push("blue"); => ["red", "green", "blue"] + ```javascript + var colors = new Ember.Set(); + colors.push("red"); // ["red"] + colors.push("green"); // ["red", "green"] + colors.push("blue"); // ["red", "green", "blue"] + ``` @method push @return {Ember.Set} The set itself. */ - push: Ember.alias('addObject'), + push: Ember.aliasMethod('addObject'), /** - Removes the last element from the set and returns it, or null if it's empty. + Removes the last element from the set and returns it, or `null` if it's empty. This is an alias for `Ember.Set.pop()`. - var colors = new Ember.Set(["green", "blue"]); - colors.shift(); => "blue" - colors.shift(); => "green" - colors.shift(); => null + ```javascript + var colors = new Ember.Set(["green", "blue"]); + colors.shift(); // "blue" + colors.shift(); // "green" + colors.shift(); // null + ``` @method shift @return {Object} The removed object from the set or null. */ - shift: Ember.alias('pop'), + shift: Ember.aliasMethod('pop'), /** Inserts the given object on to the end of the set. It returns @@ -9608,43 +10658,49 @@ Ember.Set = Ember.CoreObject.extend(Ember.MutableEnumerable, Ember.Copyable, Emb This is an alias of `Ember.Set.push()` - var colors = new Ember.Set(); - colors.unshift("red"); => ["red"] - colors.unshift("green"); => ["red", "green"] - colors.unshift("blue"); => ["red", "green", "blue"] + ```javascript + var colors = new Ember.Set(); + colors.unshift("red"); // ["red"] + colors.unshift("green"); // ["red", "green"] + colors.unshift("blue"); // ["red", "green", "blue"] + ``` @method unshift @return {Ember.Set} The set itself. */ - unshift: Ember.alias('push'), + unshift: Ember.aliasMethod('push'), /** Adds each object in the passed enumerable to the set. This is an alias of `Ember.MutableEnumerable.addObjects()` - var colors = new Ember.Set(); - colors.addEach(["red", "green", "blue"]); => ["red", "green", "blue"] + ```javascript + var colors = new Ember.Set(); + colors.addEach(["red", "green", "blue"]); // ["red", "green", "blue"] + ``` @method addEach @param {Ember.Enumerable} objects the objects to add. @return {Ember.Set} The set itself. */ - addEach: Ember.alias('addObjects'), + addEach: Ember.aliasMethod('addObjects'), /** Removes each object in the passed enumerable to the set. This is an alias of `Ember.MutableEnumerable.removeObjects()` - var colors = new Ember.Set(["red", "green", "blue"]); - colors.removeEach(["red", "blue"]); => ["green"] + ```javascript + var colors = new Ember.Set(["red", "green", "blue"]); + colors.removeEach(["red", "blue"]); // ["green"] + ``` @method removeEach @param {Ember.Enumerable} objects the objects to remove. @return {Ember.Set} The set itself. */ - removeEach: Ember.alias('removeObjects'), + removeEach: Ember.aliasMethod('removeObjects'), // .......................................................... // PRIVATE ENUMERABLE SUPPORT @@ -9663,12 +10719,12 @@ Ember.Set = Ember.CoreObject.extend(Ember.MutableEnumerable, Ember.Copyable, Emb // more optimized version firstObject: Ember.computed(function() { return this.length > 0 ? this[0] : undefined; - }).property(), + }), // more optimized version lastObject: Ember.computed(function() { return this.length > 0 ? this[this.length-1] : undefined; - }).property(), + }), // implements Ember.MutableEnumerable addObject: function(obj) { @@ -9783,6 +10839,7 @@ Ember.Set = Ember.CoreObject.extend(Ember.MutableEnumerable, Ember.Copyable, Emb @uses Ember.Observable */ Ember.Object = Ember.CoreObject.extend(Ember.Observable); +Ember.Object.toString = function() { return "Ember.Object"; }; })(); @@ -9794,24 +10851,26 @@ Ember.Object = Ember.CoreObject.extend(Ember.Observable); @submodule ember-runtime */ -var indexOf = Ember.ArrayPolyfills.indexOf; +var get = Ember.get, indexOf = Ember.ArrayPolyfills.indexOf; /** A Namespace is an object usually used to contain other objects or methods - such as an application or framework. Create a namespace anytime you want + such as an application or framework. Create a namespace anytime you want to define one of these new containers. # Example Usage - MyFramework = Ember.Namespace.create({ - VERSION: '1.0.0' - }); + ```javascript + MyFramework = Ember.Namespace.create({ + VERSION: '1.0.0' + }); + ``` @class Namespace @namespace Ember @extends Ember.Object */ -Ember.Namespace = Ember.Object.extend({ +var Namespace = Ember.Namespace = Ember.Object.extend({ isNamespace: true, init: function() { @@ -9820,10 +10879,17 @@ Ember.Namespace = Ember.Object.extend({ }, toString: function() { - Ember.identifyNamespaces(); + var name = get(this, 'name'); + if (name) { return name; } + + findNamespaces(); return this[Ember.GUID_KEY+'_name']; }, + nameClasses: function() { + processNamespace([this.toString()], this, {}); + }, + destroy: function() { var namespaces = Ember.Namespace.NAMESPACES; Ember.lookup[this.toString()] = undefined; @@ -9832,8 +10898,138 @@ Ember.Namespace = Ember.Object.extend({ } }); -Ember.Namespace.NAMESPACES = [Ember]; -Ember.Namespace.PROCESSED = false; +Namespace.reopenClass({ + NAMESPACES: [Ember], + PROCESSED: false, + processAll: processAllNamespaces +}); + +var hasOwnProp = ({}).hasOwnProperty, + guidFor = Ember.guidFor; + +function processNamespace(paths, root, seen) { + var idx = paths.length; + + // Loop over all of the keys in the namespace, looking for classes + for(var key in root) { + if (!hasOwnProp.call(root, key)) { continue; } + var obj = root[key]; + + // If we are processing the `Ember` namespace, for example, the + // `paths` will start with `["Ember"]`. Every iteration through + // the loop will update the **second** element of this list with + // the key, so processing `Ember.View` will make the Array + // `['Ember', 'View']`. + paths[idx] = key; + + // If we have found an unprocessed class + if (obj && obj.toString === classToString) { + // Replace the class' `toString` with the dot-separated path + // and set its `NAME_KEY` + obj.toString = makeToString(paths.join('.')); + obj[NAME_KEY] = paths.join('.'); + + // Support nested namespaces + } else if (obj && obj.isNamespace) { + // Skip aliased namespaces + if (seen[guidFor(obj)]) { continue; } + seen[guidFor(obj)] = true; + + // Process the child namespace + processNamespace(paths, obj, seen); + } + } + + paths.length = idx; // cut out last item +} + +function findNamespaces() { + var Namespace = Ember.Namespace, lookup = Ember.lookup, obj, isNamespace; + + if (Namespace.PROCESSED) { return; } + + for (var prop in lookup) { + // These don't raise exceptions but can cause warnings + if (prop === "parent" || prop === "top" || prop === "frameElement") { continue; } + + // get(window.globalStorage, 'isNamespace') would try to read the storage for domain isNamespace and cause exception in Firefox. + // globalStorage is a storage obsoleted by the WhatWG storage specification. See https://developer.mozilla.org/en/DOM/Storage#globalStorage + if (prop === "globalStorage" && lookup.StorageList && lookup.globalStorage instanceof lookup.StorageList) { continue; } + // Unfortunately, some versions of IE don't support window.hasOwnProperty + if (lookup.hasOwnProperty && !lookup.hasOwnProperty(prop)) { continue; } + + // At times we are not allowed to access certain properties for security reasons. + // There are also times where even if we can access them, we are not allowed to access their properties. + try { + obj = Ember.lookup[prop]; + isNamespace = obj && obj.isNamespace; + } catch (e) { + continue; + } + + if (isNamespace) { + Ember.deprecate("Namespaces should not begin with lowercase.", /^[A-Z]/.test(prop)); + obj[NAME_KEY] = prop; + } + } +} + +var NAME_KEY = Ember.NAME_KEY = Ember.GUID_KEY + '_name'; + +function superClassString(mixin) { + var superclass = mixin.superclass; + if (superclass) { + if (superclass[NAME_KEY]) { return superclass[NAME_KEY]; } + else { return superClassString(superclass); } + } else { + return; + } +} + +function classToString() { + if (!Ember.BOOTED && !this[NAME_KEY]) { + processAllNamespaces(); + } + + var ret; + + if (this[NAME_KEY]) { + ret = this[NAME_KEY]; + } else { + var str = superClassString(this); + if (str) { + ret = "(subclass of " + str + ")"; + } else { + ret = "(unknown mixin)"; + } + this.toString = makeToString(ret); + } + + return ret; +} + +function processAllNamespaces() { + if (!Namespace.PROCESSED) { + findNamespaces(); + Namespace.PROCESSED = true; + } + + if (Ember.anyUnprocessedMixins) { + var namespaces = Namespace.NAMESPACES, namespace; + for (var i=0, l=namespaces.length; i 'dog' - ap.set('content', ['amoeba', 'paramecium']); - ap.get('firstObject'); // => 'amoeba' + ```javascript + var pets = ['dog', 'cat', 'fish']; + var ap = Ember.ArrayProxy.create({ content: Ember.A(pets) }); + + ap.get('firstObject'); // 'dog' + ap.set('content', ['amoeba', 'paramecium']); + ap.get('firstObject'); // 'amoeba' + ``` This class can also be useful as a layer to transform the contents of an array, as they are accessed. This can be done by overriding `objectAtContent`: - var pets = ['dog', 'cat', 'fish']; - var ap = Ember.ArrayProxy.create({ - content: Ember.A(pets), - objectAtContent: function(idx) { - return this.get('content').objectAt(idx).toUpperCase(); - } - }); - ap.get('firstObject'); // => 'DOG' + ```javascript + var pets = ['dog', 'cat', 'fish']; + var ap = Ember.ArrayProxy.create({ + content: Ember.A(pets), + objectAtContent: function(idx) { + return this.get('content').objectAt(idx).toUpperCase(); + } + }); + ap.get('firstObject'); // . 'DOG' + ``` @class ArrayProxy @namespace Ember @@ -9922,8 +11125,8 @@ Ember.ArrayProxy = Ember.Object.extend(Ember.MutableArray, /** @scope Ember.ArrayProxy.prototype */ { /** - The content array. Must be an object that implements Ember.Array and/or - Ember.MutableArray. + The content array. Must be an object that implements `Ember.Array` and/or + `Ember.MutableArray.` @property content @type Ember.Array @@ -9937,16 +11140,14 @@ Ember.ArrayProxy = Ember.Object.extend(Ember.MutableArray, @property arrangedContent */ - arrangedContent: Ember.computed('content', function() { - return get(this, 'content'); - }), + arrangedContent: Ember.computed.alias('content'), /** Should actually retrieve the object at the specified index from the content. You can override this method in subclasses to transform the content item to something new. - This method will only be called if content is non-null. + This method will only be called if content is non-`null`. @method objectAtContent @param {Number} idx The index to retrieve. @@ -9961,16 +11162,17 @@ Ember.ArrayProxy = Ember.Object.extend(Ember.MutableArray, You can override this method in subclasses to transform the content item into something new. - This method will only be called if content is non-null. + This method will only be called if content is non-`null`. @method replaceContent @param {Number} idx The starting index @param {Number} amt The number of items to remove from the content. - @param {Array} objects Optional array of objects to insert or null if no objects. + @param {Array} objects Optional array of objects to insert or null if no + objects. @return {void} */ replaceContent: function(idx, amt, objects) { - get(this, 'arrangedContent').replace(idx, amt, objects); + get(this, 'content').replace(idx, amt, objects); }, /** @@ -10002,7 +11204,7 @@ Ember.ArrayProxy = Ember.Object.extend(Ember.MutableArray, /** @private - Invoked when the content property changes. Notifies observers that the + Invoked when the content property changes. Notifies observers that the entire array content has changed. @method _contentDidChange @@ -10081,7 +11283,7 @@ Ember.ArrayProxy = Ember.Object.extend(Ember.MutableArray, var arrangedContent = get(this, 'arrangedContent'); return arrangedContent ? get(arrangedContent, 'length') : 0; // No dependencies since Enumerable notifies length of change - }).property(), + }), replace: function(idx, amt, objects) { Ember.assert('The content property of '+ this.constructor + ' should be set before modifying it', this.get('content')); @@ -10146,53 +11348,64 @@ function contentPropertyDidChange(content, contentKey) { `Ember.ObjectProxy` forwards all properties not defined by the proxy itself to a proxied `content` object. - object = Ember.Object.create({ - name: 'Foo' - }); - proxy = Ember.ObjectProxy.create({ - content: object - }); + ```javascript + object = Ember.Object.create({ + name: 'Foo' + }); - // Access and change existing properties - proxy.get('name') // => 'Foo' - proxy.set('name', 'Bar'); - object.get('name') // => 'Bar' + proxy = Ember.ObjectProxy.create({ + content: object + }); - // Create new 'description' property on `object` - proxy.set('description', 'Foo is a whizboo baz'); - object.get('description') // => 'Foo is a whizboo baz' + // Access and change existing properties + proxy.get('name') // 'Foo' + proxy.set('name', 'Bar'); + object.get('name') // 'Bar' - While `content` is unset, setting a property to be delegated will throw an Error. + // Create new 'description' property on `object` + proxy.set('description', 'Foo is a whizboo baz'); + object.get('description') // 'Foo is a whizboo baz' + ``` - proxy = Ember.ObjectProxy.create({ - content: null, - flag: null - }); - proxy.set('flag', true); - proxy.get('flag'); // => true - proxy.get('foo'); // => undefined - proxy.set('foo', 'data'); // throws Error + While `content` is unset, setting a property to be delegated will throw an + Error. + + ```javascript + proxy = Ember.ObjectProxy.create({ + content: null, + flag: null + }); + proxy.set('flag', true); + proxy.get('flag'); // true + proxy.get('foo'); // undefined + proxy.set('foo', 'data'); // throws Error + ``` Delegated properties can be bound to and will change when content is updated. Computed properties on the proxy itself can depend on delegated properties. - ProxyWithComputedProperty = Ember.ObjectProxy.extend({ - fullName: function () { - var firstName = this.get('firstName'), - lastName = this.get('lastName'); - if (firstName && lastName) { - return firstName + ' ' + lastName; - } - return firstName || lastName; - }.property('firstName', 'lastName') - }); - proxy = ProxyWithComputedProperty.create(); - proxy.get('fullName'); => undefined - proxy.set('content', { - firstName: 'Tom', lastName: 'Dale' - }); // triggers property change for fullName on proxy - proxy.get('fullName'); => 'Tom Dale' + ```javascript + ProxyWithComputedProperty = Ember.ObjectProxy.extend({ + fullName: function () { + var firstName = this.get('firstName'), + lastName = this.get('lastName'); + if (firstName && lastName) { + return firstName + ' ' + lastName; + } + return firstName || lastName; + }.property('firstName', 'lastName') + }); + + proxy = ProxyWithComputedProperty.create(); + + proxy.get('fullName'); // undefined + proxy.set('content', { + firstName: 'Tom', lastName: 'Dale' + }); // triggers property change for fullName on proxy + + proxy.get('fullName'); // 'Tom Dale' + ``` @class ObjectProxy @namespace Ember @@ -10212,6 +11425,10 @@ Ember.ObjectProxy = Ember.Object.extend( Ember.assert("Can't set ObjectProxy's content to itself", this.get('content') !== this); }, 'content'), + isTruthy: Ember.computed.bool('content'), + + _debugContainerKey: null, + willWatchProperty: function (key) { var contentKey = 'content.' + key; addBeforeObserver(this, contentKey, null, contentPropertyWillChange); @@ -10269,7 +11486,7 @@ var EachArray = Ember.Object.extend(Ember.Array, { length: Ember.computed(function() { var content = this._content; return content ? get(content, 'length') : 0; - }).property() + }) }); @@ -10313,8 +11530,8 @@ function removeObserverForContentKey(content, keyName, proxy, idx, loc) { } /** - This is the object instance returned when you get the @each property on an - array. It uses the unknownProperty handler to automatically create + This is the object instance returned when you get the `@each` property on an + array. It uses the unknownProperty handler to automatically create EachArray instances for property names. @private @@ -10338,7 +11555,7 @@ Ember.EachProxy = Ember.Object.extend({ /** You can directly access mapped properties by simply requesting them. - The unknownProperty handler will generate an EachArray of each item. + The `unknownProperty` handler will generate an EachArray of each item. @method unknownProperty @param keyName {String} @@ -10459,7 +11676,7 @@ Ember.EachProxy = Ember.Object.extend({ var get = Ember.get, set = Ember.set; -// Add Ember.Array to Array.prototype. Remove methods with native +// Add Ember.Array to Array.prototype. Remove methods with native // implementations and supply some more optimized versions of generic methods // because they are so common. var NativeArray = Ember.Mixin.create(Ember.MutableArray, Ember.Observable, Ember.Copyable, { @@ -10482,7 +11699,7 @@ var NativeArray = Ember.Mixin.create(Ember.MutableArray, Ember.Observable, Ember if (this.isFrozen) throw Ember.FROZEN_ERROR ; // if we replaced exactly the same number of items, then pass only the - // replaced range. Otherwise, pass the full remaining array length + // replaced range. Otherwise, pass the full remaining array length // since everything has shifted var len = objects ? get(objects, 'length') : 0; this.arrayContentWillChange(idx, amt, len); @@ -10536,7 +11753,11 @@ var NativeArray = Ember.Mixin.create(Ember.MutableArray, Ember.Observable, Ember return -1; }, - copy: function() { + copy: function(deep) { + if (deep) { + return this.map(function(item){ return Ember.copy(item, true); }); + } + return this.slice(); } }); @@ -10553,10 +11774,10 @@ if (ignore.length>0) { /** The NativeArray mixin contains the properties needed to to make the native - Array support Ember.MutableArray and all of its dependent APIs. Unless you - have Ember.EXTEND_PROTOTYPES or Ember.EXTEND_PROTOTYPES.Array set to false, this - will be applied automatically. Otherwise you can apply the mixin at anytime by - calling `Ember.NativeArray.activate`. + Array support Ember.MutableArray and all of its dependent APIs. Unless you + have `Ember.EXTEND_PROTOTYPES or `Ember.EXTEND_PROTOTYPES.Array` set to + false, this will be applied automatically. Otherwise you can apply the mixin + at anytime by calling `Ember.NativeArray.activate`. @class NativeArray @namespace Ember @@ -10569,7 +11790,7 @@ if (ignore.length>0) { Ember.NativeArray = NativeArray; /** - Creates an Ember.NativeArray from an Array like object. + Creates an `Ember.NativeArray` from an Array like object. Does not modify the original object. @method A @@ -10578,11 +11799,11 @@ Ember.NativeArray = NativeArray; */ Ember.A = function(arr){ if (arr === undefined) { arr = []; } - return Ember.NativeArray.apply(arr); + return Ember.Array.detect(arr) ? arr : Ember.NativeArray.apply(arr); }; /** - Activates the mixin on the Array.prototype if not already applied. Calling + Activates the mixin on the Array.prototype if not already applied. Calling this method more than once is safe. @method activate @@ -10606,59 +11827,21 @@ if (Ember.EXTEND_PROTOTYPES === true || Ember.EXTEND_PROTOTYPES.Array) { (function() { -/** -@module ember -@submodule ember-runtime -*/ +var DeferredMixin = Ember.DeferredMixin, // mixins/deferred + EmberObject = Ember.Object, // system/object + get = Ember.get; -var get = Ember.get, set = Ember.set; +var Deferred = Ember.Object.extend(DeferredMixin); -Ember._PromiseChain = Ember.Object.extend({ - promises: null, - failureCallback: Ember.K, - successCallback: Ember.K, - abortCallback: Ember.K, - promiseSuccessCallback: Ember.K, - - runNextPromise: function() { - if (get(this, 'isDestroyed')) { return; } - - var item = get(this, 'promises').shiftObject(); - if (item) { - var promise = get(item, 'promise') || item; - Ember.assert("Cannot find promise to invoke", Ember.canInvoke(promise, 'then')); - - var self = this; - - var successCallback = function() { - self.promiseSuccessCallback.call(this, item, arguments); - self.runNextPromise(); - }; - - var failureCallback = get(self, 'failureCallback'); - - promise.then(successCallback, failureCallback); - } else { - this.successCallback(); - } - }, - - start: function() { - this.runNextPromise(); - return this; - }, - - abort: function() { - this.abortCallback(); - this.destroy(); - }, - - init: function() { - set(this, 'promises', Ember.A(get(this, 'promises'))); - this._super(); +Deferred.reopenClass({ + promise: function(callback, binding) { + var deferred = Deferred.create(); + callback.call(binding, deferred); + return get(deferred, 'promise'); } }); +Ember.Deferred = Deferred; })(); @@ -10670,7 +11853,7 @@ Ember._PromiseChain = Ember.Object.extend({ @submodule ember-runtime */ -var loadHooks = {}; +var loadHooks = Ember.ENV.EMBER_LOAD_HOOKS || {}; var loaded = {}; /** @@ -10681,6 +11864,7 @@ var loaded = {}; */ Ember.onLoad = function(name, callback) { var object; + loadHooks[name] = loadHooks[name] || Ember.A(); loadHooks[name].pushObject(callback); @@ -10718,39 +11902,47 @@ Ember.runLoadHooks = function(name, object) { (function() { +var get = Ember.get; + /** @module ember @submodule ember-runtime */ /** - Ember.ControllerMixin provides a standard interface for all classes - that compose Ember's controller layer: Ember.Controller, Ember.ArrayController, - and Ember.ObjectController. + `Ember.ControllerMixin` provides a standard interface for all classes that + compose Ember's controller layer: `Ember.Controller`, + `Ember.ArrayController`, and `Ember.ObjectController`. - Within an Ember.Router-managed application single shared instaces of every + Within an `Ember.Router`-managed application single shared instaces of every Controller object in your application's namespace will be added to the - application's Ember.Router instance. See `Ember.Application#initialize` + application's `Ember.Router` instance. See `Ember.Application#initialize` for additional information. ## Views + By default a controller instance will be the rendering context - for its associated Ember.View. This connection is made during calls to + for its associated `Ember.View.` This connection is made during calls to `Ember.ControllerMixin#connectOutlet`. - Within the view's template, the Ember.View instance can be accessed + Within the view's template, the `Ember.View` instance can be accessed through the controller with `{{view}}`. ## Target Forwarding - By default a controller will target your application's Ember.Router instance. - Calls to `{{action}}` within the template of a controller's view are forwarded - to the router. See `Ember.Handlebars.helpers.action` for additional information. + + By default a controller will target your application's `Ember.Router` + instance. Calls to `{{action}}` within the template of a controller's view + are forwarded to the router. See `Ember.Handlebars.helpers.action` for + additional information. @class ControllerMixin @namespace Ember @extends Ember.Mixin */ Ember.ControllerMixin = Ember.Mixin.create({ + /* ducktype as a controller */ + isController: true, + /** The object to which events from the view should be sent. @@ -10765,7 +11957,23 @@ Ember.ControllerMixin = Ember.Mixin.create({ */ target: null, - store: null + container: null, + + store: null, + + model: Ember.computed.alias('content'), + + send: function(actionName) { + var args = [].slice.call(arguments, 1), target; + + if (this[actionName]) { + Ember.assert("The controller " + this + " does not have the action " + actionName, typeof this[actionName] === 'function'); + this[actionName].apply(this, args); + } else if(target = get(this, 'target')) { + Ember.assert("The target for controller " + this + " (" + target + ") did not define a `send` method", typeof target.send === 'function'); + target.send.apply(target, arguments); + } + } }); /** @@ -10789,27 +11997,29 @@ Ember.Controller = Ember.Object.extend(Ember.ControllerMixin); var get = Ember.get, set = Ember.set, forEach = Ember.EnumerableUtils.forEach; /** - Ember.SortableMixin provides a standard interface for array proxies + `Ember.SortableMixin` provides a standard interface for array proxies to specify a sort order and maintain this sorting when objects are added, removed, or updated without changing the implicit order of their underlying content array: - songs = [ - {trackNumber: 4, title: 'Ob-La-Di, Ob-La-Da'}, - {trackNumber: 2, title: 'Back in the U.S.S.R.'}, - {trackNumber: 3, title: 'Glass Onion'}, - ]; + ```javascript + songs = [ + {trackNumber: 4, title: 'Ob-La-Di, Ob-La-Da'}, + {trackNumber: 2, title: 'Back in the U.S.S.R.'}, + {trackNumber: 3, title: 'Glass Onion'}, + ]; - songsController = Ember.ArrayController.create({ - content: songs, - sortProperties: ['trackNumber'] - }); + songsController = Ember.ArrayController.create({ + content: songs, + sortProperties: ['trackNumber'], + sortAscending: true + }); - songsController.get('firstObject'); // {trackNumber: 2, title: 'Back in the U.S.S.R.'} - - songsController.addObject({trackNumber: 1, title: 'Dear Prudence'}); - songsController.get('firstObject'); // {trackNumber: 1, title: 'Dear Prudence'} + songsController.get('firstObject'); // {trackNumber: 2, title: 'Back in the U.S.S.R.'} + songsController.addObject({trackNumber: 1, title: 'Dear Prudence'}); + songsController.get('firstObject'); // {trackNumber: 1, title: 'Dear Prudence'} + ``` @class SortableMixin @namespace Ember @@ -10817,19 +12027,21 @@ var get = Ember.get, set = Ember.set, forEach = Ember.EnumerableUtils.forEach; @uses Ember.MutableEnumerable */ Ember.SortableMixin = Ember.Mixin.create(Ember.MutableEnumerable, { + + /** + Specifies which properties dictate the arrangedContent's sort order. + + @property {Array} sortProperties + */ sortProperties: null, + + /** + Specifies the arrangedContent's sort direction + + @property {Boolean} sortAscending + */ sortAscending: true, - addObject: function(obj) { - var content = get(this, 'content'); - content.pushObject(obj); - }, - - removeObject: function(obj) { - var content = get(this, 'content'); - content.removeObject(obj); - }, - orderBy: function(item1, item2) { var result = 0, sortProperties = get(this, 'sortProperties'), @@ -10864,9 +12076,7 @@ Ember.SortableMixin = Ember.Mixin.create(Ember.MutableEnumerable, { return this._super(); }, - isSorted: Ember.computed('sortProperties', function() { - return !!get(this, 'sortProperties'); - }), + isSorted: Ember.computed.bool('sortProperties'), arrangedContent: Ember.computed('content', 'sortProperties.@each', function(key, value) { var content = get(this, 'content'), @@ -10930,7 +12140,7 @@ Ember.SortableMixin = Ember.Mixin.create(Ember.MutableEnumerable, { forEach(sortProperties, function(sortProperty) { Ember.removeObserver(item, sortProperty, this, 'contentItemSortPropertyDidChange'); }, this); - }); + }, this); } return this._super(array, idx, removedCount, addedCount); @@ -10967,9 +12177,12 @@ Ember.SortableMixin = Ember.Mixin.create(Ember.MutableEnumerable, { contentItemSortPropertyDidChange: function(item) { var arrangedContent = get(this, 'arrangedContent'), oldIndex = arrangedContent.indexOf(item), - newIndex = this._binarySearch(item, 0, get(arrangedContent, 'length')); + leftItem = arrangedContent.objectAt(oldIndex - 1), + rightItem = arrangedContent.objectAt(oldIndex + 1), + leftResult = leftItem && this.orderBy(item, leftItem), + rightResult = rightItem && this.orderBy(item, rightItem); - if (newIndex !== oldIndex) { + if (leftResult < 0 || rightResult > 0) { arrangedContent.removeObject(item); this.insertItemSorted(item); } @@ -11009,21 +12222,22 @@ Ember.SortableMixin = Ember.Mixin.create(Ember.MutableEnumerable, { @submodule ember-runtime */ -var get = Ember.get, set = Ember.set; +var get = Ember.get, set = Ember.set, isGlobalPath = Ember.isGlobalPath, + forEach = Ember.EnumerableUtils.forEach, replace = Ember.EnumerableUtils.replace; /** - Ember.ArrayController provides a way for you to publish a collection of objects - so that you can easily bind to the collection from a Handlebars #each helper, - an Ember.CollectionView, or other controllers. + `Ember.ArrayController` provides a way for you to publish a collection of + objects so that you can easily bind to the collection from a Handlebars + `#each` helper, an `Ember.CollectionView`, or other controllers. - The advantage of using an ArrayController is that you only have to set up + The advantage of using an `ArrayController` is that you only have to set up your view bindings once; to change what's displayed, simply swap out the `content` property on the controller. For example, imagine you wanted to display a list of items fetched via an XHR - request. Create an Ember.ArrayController and set its `content` property: + request. Create an `Ember.ArrayController` and set its `content` property: - ``` javascript + ```javascript MyApp.listController = Ember.ArrayController.create(); $.get('people.json', function(data) { @@ -11033,7 +12247,7 @@ var get = Ember.get, set = Ember.set; Then, create a view that binds to your new controller: - ``` handlebars + ```handlebars {{#each MyApp.listController}} {{firstName}} {{lastName}} {{/each}} @@ -11043,11 +12257,50 @@ var get = Ember.get, set = Ember.set; is to pass through any methods or properties to the underlying array. This capability comes from `Ember.ArrayProxy`, which this class inherits from. - Note: As of this writing, `ArrayController` does not add any functionality - to its superclass, `ArrayProxy`. The Ember team plans to add additional - controller-specific functionality in the future, e.g. single or multiple - selection support. If you are creating something that is conceptually a - controller, use this class. + Sometimes you want to display computed properties within the body of an + `#each` helper that depend on the underlying items in `content`, but are not + present on those items. To do this, set `itemController` to the name of a + controller (probably an `ObjectController`) that will wrap each individual item. + + For example: + + ```handlebars + {{#each post in controller}} +
  • {{title}} ({{titleLength}} characters)
    • + {{/each}} + ``` + + ```javascript + App.PostsController = Ember.ArrayController.extend({ + itemController: 'post' + }); + + App.PostController = Ember.ObjectController.extend({ + // the `title` property will be proxied to the underlying post. + + titleLength: function() { + return this.get('title').length; + }.property('title') + }); + ``` + + In some cases it is helpful to return a different `itemController` depending + on the particular item. Subclasses can do this by overriding + `lookupItemController`. + + For example: + + ```javascript + App.MyArrayController = Ember.ArrayController.extend({ + lookupItemController: function( object ) { + if (object.get('isSpecial')) { + return "special"; // use App.SpecialController + } else { + return "regular"; // use App.RegularController + } + } + }); + ``` @class ArrayController @namespace Ember @@ -11057,7 +12310,126 @@ var get = Ember.get, set = Ember.set; */ Ember.ArrayController = Ember.ArrayProxy.extend(Ember.ControllerMixin, - Ember.SortableMixin); + Ember.SortableMixin, { + + /** + The controller used to wrap items, if any. + + @property itemController + @type String + @default null + */ + itemController: null, + + /** + Return the name of the controller to wrap items, or `null` if items should + be returned directly. The default implementation simply returns the + `itemController` property, but subclasses can override this method to return + different controllers for different objects. + + For example: + + ```javascript + App.MyArrayController = Ember.ArrayController.extend({ + lookupItemController: function( object ) { + if (object.get('isSpecial')) { + return "special"; // use App.SpecialController + } else { + return "regular"; // use App.RegularController + } + } + }); + ``` + + @method + @type String + @default null + */ + lookupItemController: function(object) { + return get(this, 'itemController'); + }, + + objectAtContent: function(idx) { + var length = get(this, 'length'), + object = get(this,'arrangedContent').objectAt(idx); + + if (idx >= 0 && idx < length) { + var controllerClass = this.lookupItemController(object); + if (controllerClass) { + return this.controllerAt(idx, object, controllerClass); + } + } + + // When `controllerClass` is falsy, we have not opted in to using item + // controllers, so return the object directly. + + // When the index is out of range, we want to return the "out of range" + // value, whatever that might be. Rather than make assumptions + // (e.g. guessing `null` or `undefined`) we defer this to `arrangedContent`. + return object; + }, + + arrangedContentDidChange: function() { + this._super(); + this._resetSubContainers(); + }, + + arrayContentDidChange: function(idx, removedCnt, addedCnt) { + var subContainers = get(this, 'subContainers'), + subContainersToRemove = subContainers.slice(idx, idx+removedCnt); + + forEach(subContainersToRemove, function(subContainer) { + if (subContainer) { subContainer.destroy(); } + }); + + replace(subContainers, idx, removedCnt, new Array(addedCnt)); + + // The shadow array of subcontainers must be updated before we trigger + // observers, otherwise observers will get the wrong subcontainer when + // calling `objectAt` + this._super(idx, removedCnt, addedCnt); + }, + + init: function() { + this._super(); + this._resetSubContainers(); + }, + + controllerAt: function(idx, object, controllerClass) { + var container = get(this, 'container'), + subContainers = get(this, 'subContainers'), + subContainer = subContainers[idx], + controller; + + if (!subContainer) { + subContainer = subContainers[idx] = container.child(); + } + + controller = subContainer.lookup("controller:" + controllerClass); + if (!controller) { + throw new Error('Could not resolve itemController: "' + controllerClass + '"'); + } + + controller.set('target', this); + controller.set('content', object); + + return controller; + }, + + subContainers: null, + + _resetSubContainers: function() { + var subContainers = get(this, 'subContainers'); + + if (subContainers) { + forEach(subContainers, function(subContainer) { + if (subContainer) { subContainer.destroy(); } + }); + } + + this.set('subContainers', Ember.A()); + } +}); })(); @@ -11070,13 +12442,13 @@ Ember.ArrayController = Ember.ArrayProxy.extend(Ember.ControllerMixin, */ /** - Ember.ObjectController is part of Ember's Controller layer. A single - shared instance of each Ember.ObjectController subclass in your application's + `Ember.ObjectController` is part of Ember's Controller layer. A single shared + instance of each `Ember.ObjectController` subclass in your application's namespace will be created at application initialization and be stored on your - application's Ember.Router instance. + application's `Ember.Router` instance. - Ember.ObjectController derives its functionality from its superclass - Ember.ObjectProxy and the Ember.ControllerMixin mixin. + `Ember.ObjectController` derives its functionality from its superclass + `Ember.ObjectProxy` and the `Ember.ControllerMixin` mixin. @class ObjectController @namespace Ember @@ -11106,6 +12478,12103 @@ Ember Runtime })(); +(function() { +/** +@module ember +@submodule ember-views +*/ + +var jQuery = Ember.imports.jQuery; +Ember.assert("Ember Views require jQuery 1.8 or 1.9", jQuery && (jQuery().jquery.match(/^1\.(8|9)(\.\d+)?(pre|rc\d?)?/) || Ember.ENV.FORCE_JQUERY)); + +/** + Alias for jQuery + + @method $ + @for Ember +*/ +Ember.$ = jQuery; + +})(); + + + +(function() { +/** +@module ember +@submodule ember-views +*/ + +// http://www.whatwg.org/specs/web-apps/current-work/multipage/dnd.html#dndevents +var dragEvents = Ember.String.w('dragstart drag dragenter dragleave dragover drop dragend'); + +// Copies the `dataTransfer` property from a browser event object onto the +// jQuery event object for the specified events +Ember.EnumerableUtils.forEach(dragEvents, function(eventName) { + Ember.$.event.fixHooks[eventName] = { props: ['dataTransfer'] }; +}); + +})(); + + + +(function() { +/** +@module ember +@submodule ember-views +*/ + +/*** BEGIN METAMORPH HELPERS ***/ + +// Internet Explorer prior to 9 does not allow setting innerHTML if the first element +// is a "zero-scope" element. This problem can be worked around by making +// the first node an invisible text node. We, like Modernizr, use ­ +var needsShy = (function(){ + var testEl = document.createElement('div'); + testEl.innerHTML = "
    "; + testEl.firstChild.innerHTML = ""; + return testEl.firstChild.innerHTML === ''; +})(); + +// IE 8 (and likely earlier) likes to move whitespace preceeding +// a script tag to appear after it. This means that we can +// accidentally remove whitespace when updating a morph. +var movesWhitespace = (function() { + var testEl = document.createElement('div'); + testEl.innerHTML = "Test: Value"; + return testEl.childNodes[0].nodeValue === 'Test:' && + testEl.childNodes[2].nodeValue === ' Value'; +})(); + +// Use this to find children by ID instead of using jQuery +var findChildById = function(element, id) { + if (element.getAttribute('id') === id) { return element; } + + var len = element.childNodes.length, idx, node, found; + for (idx=0; idx 0) { + var len = matches.length, idx; + for (idx=0; idxTest'); + canSet = el.options.length === 1; + } + + innerHTMLTags[tagName] = canSet; + + return canSet; +}; + +var setInnerHTML = function(element, html) { + var tagName = element.tagName; + + if (canSetInnerHTML(tagName)) { + setInnerHTMLWithoutFix(element, html); + } else { + Ember.assert("Can't set innerHTML on "+element.tagName+" in this browser", element.outerHTML); + + var startTag = element.outerHTML.match(new RegExp("<"+tagName+"([^>]*)>", 'i'))[0], + endTag = ''; + + var wrapper = document.createElement('div'); + setInnerHTMLWithoutFix(wrapper, startTag + html + endTag); + element = wrapper.firstChild; + while (element.tagName !== tagName) { + element = element.nextSibling; + } + } + + return element; +}; + +function isSimpleClick(event) { + var modifier = event.shiftKey || event.metaKey || event.altKey || event.ctrlKey, + secondaryClick = event.which > 1; // IE9 may return undefined + + return !modifier && !secondaryClick; +} + +Ember.ViewUtils = { + setInnerHTML: setInnerHTML, + isSimpleClick: isSimpleClick +}; + +})(); + + + +(function() { +/** +@module ember +@submodule ember-views +*/ + +var get = Ember.get, set = Ember.set; +var indexOf = Ember.ArrayPolyfills.indexOf; + + + + + +var ClassSet = function() { + this.seen = {}; + this.list = []; +}; + +ClassSet.prototype = { + add: function(string) { + if (string in this.seen) { return; } + this.seen[string] = true; + + this.list.push(string); + }, + + toDOM: function() { + return this.list.join(" "); + } +}; + +/** + `Ember.RenderBuffer` gathers information regarding the a view and generates the + final representation. `Ember.RenderBuffer` will generate HTML which can be pushed + to the DOM. + + @class RenderBuffer + @namespace Ember + @constructor +*/ +Ember.RenderBuffer = function(tagName) { + return new Ember._RenderBuffer(tagName); +}; + +Ember._RenderBuffer = function(tagName) { + this.tagNames = [tagName || null]; + this.buffer = []; +}; + +Ember._RenderBuffer.prototype = +/** @scope Ember.RenderBuffer.prototype */ { + + // The root view's element + _element: null, + + /** + @private + + An internal set used to de-dupe class names when `addClass()` is + used. After each call to `addClass()`, the `classes` property + will be updated. + + @property elementClasses + @type Array + @default [] + */ + elementClasses: null, + + /** + Array of class names which will be applied in the class attribute. + + You can use `setClasses()` to set this property directly. If you + use `addClass()`, it will be maintained for you. + + @property classes + @type Array + @default [] + */ + classes: null, + + /** + The id in of the element, to be applied in the id attribute. + + You should not set this property yourself, rather, you should use + the `id()` method of `Ember.RenderBuffer`. + + @property elementId + @type String + @default null + */ + elementId: null, + + /** + A hash keyed on the name of the attribute and whose value will be + applied to that attribute. For example, if you wanted to apply a + `data-view="Foo.bar"` property to an element, you would set the + elementAttributes hash to `{'data-view':'Foo.bar'}`. + + You should not maintain this hash yourself, rather, you should use + the `attr()` method of `Ember.RenderBuffer`. + + @property elementAttributes + @type Hash + @default {} + */ + elementAttributes: null, + + /** + A hash keyed on the name of the properties and whose value will be + applied to that property. For example, if you wanted to apply a + `checked=true` property to an element, you would set the + elementProperties hash to `{'checked':true}`. + + You should not maintain this hash yourself, rather, you should use + the `prop()` method of `Ember.RenderBuffer`. + + @property elementProperties + @type Hash + @default {} + */ + elementProperties: null, + + /** + The tagname of the element an instance of `Ember.RenderBuffer` represents. + + Usually, this gets set as the first parameter to `Ember.RenderBuffer`. For + example, if you wanted to create a `p` tag, then you would call + + ```javascript + Ember.RenderBuffer('p') + ``` + + @property elementTag + @type String + @default null + */ + elementTag: null, + + /** + A hash keyed on the name of the style attribute and whose value will + be applied to that attribute. For example, if you wanted to apply a + `background-color:black;` style to an element, you would set the + elementStyle hash to `{'background-color':'black'}`. + + You should not maintain this hash yourself, rather, you should use + the `style()` method of `Ember.RenderBuffer`. + + @property elementStyle + @type Hash + @default {} + */ + elementStyle: null, + + /** + Nested `RenderBuffers` will set this to their parent `RenderBuffer` + instance. + + @property parentBuffer + @type Ember._RenderBuffer + */ + parentBuffer: null, + + /** + Adds a string of HTML to the `RenderBuffer`. + + @method push + @param {String} string HTML to push into the buffer + @chainable + */ + push: function(string) { + this.buffer.push(string); + return this; + }, + + /** + Adds a class to the buffer, which will be rendered to the class attribute. + + @method addClass + @param {String} className Class name to add to the buffer + @chainable + */ + addClass: function(className) { + // lazily create elementClasses + var elementClasses = this.elementClasses = (this.elementClasses || new ClassSet()); + this.elementClasses.add(className); + this.classes = this.elementClasses.list; + + return this; + }, + + setClasses: function(classNames) { + this.classes = classNames; + }, + + /** + Sets the elementID to be used for the element. + + @method id + @param {String} id + @chainable + */ + id: function(id) { + this.elementId = id; + return this; + }, + + // duck type attribute functionality like jQuery so a render buffer + // can be used like a jQuery object in attribute binding scenarios. + + /** + Adds an attribute which will be rendered to the element. + + @method attr + @param {String} name The name of the attribute + @param {String} value The value to add to the attribute + @chainable + @return {Ember.RenderBuffer|String} this or the current attribute value + */ + attr: function(name, value) { + var attributes = this.elementAttributes = (this.elementAttributes || {}); + + if (arguments.length === 1) { + return attributes[name]; + } else { + attributes[name] = value; + } + + return this; + }, + + /** + Remove an attribute from the list of attributes to render. + + @method removeAttr + @param {String} name The name of the attribute + @chainable + */ + removeAttr: function(name) { + var attributes = this.elementAttributes; + if (attributes) { delete attributes[name]; } + + return this; + }, + + /** + Adds an property which will be rendered to the element. + + @method prop + @param {String} name The name of the property + @param {String} value The value to add to the property + @chainable + @return {Ember.RenderBuffer|String} this or the current property value + */ + prop: function(name, value) { + var properties = this.elementProperties = (this.elementProperties || {}); + + if (arguments.length === 1) { + return properties[name]; + } else { + properties[name] = value; + } + + return this; + }, + + /** + Remove an property from the list of properties to render. + + @method removeProp + @param {String} name The name of the property + @chainable + */ + removeProp: function(name) { + var properties = this.elementProperties; + if (properties) { delete properties[name]; } + + return this; + }, + + /** + Adds a style to the style attribute which will be rendered to the element. + + @method style + @param {String} name Name of the style + @param {String} value + @chainable + */ + style: function(name, value) { + var style = this.elementStyle = (this.elementStyle || {}); + + this.elementStyle[name] = value; + return this; + }, + + begin: function(tagName) { + this.tagNames.push(tagName || null); + return this; + }, + + pushOpeningTag: function() { + var tagName = this.currentTagName(); + if (!tagName) { return; } + + if (!this._element && this.buffer.length === 0) { + this._element = this.generateElement(); + return; + } + + var buffer = this.buffer, + id = this.elementId, + classes = this.classes, + attrs = this.elementAttributes, + props = this.elementProperties, + style = this.elementStyle, + attr, prop; + + buffer.push('<' + tagName); + + if (id) { + buffer.push(' id="' + this._escapeAttribute(id) + '"'); + this.elementId = null; + } + if (classes) { + buffer.push(' class="' + this._escapeAttribute(classes.join(' ')) + '"'); + this.classes = null; + } + + if (style) { + buffer.push(' style="'); + + for (prop in style) { + if (style.hasOwnProperty(prop)) { + buffer.push(prop + ':' + this._escapeAttribute(style[prop]) + ';'); + } + } + + buffer.push('"'); + + this.elementStyle = null; + } + + if (attrs) { + for (attr in attrs) { + if (attrs.hasOwnProperty(attr)) { + buffer.push(' ' + attr + '="' + this._escapeAttribute(attrs[attr]) + '"'); + } + } + + this.elementAttributes = null; + } + + if (props) { + for (prop in props) { + if (props.hasOwnProperty(prop)) { + var value = props[prop]; + if (value) { + if (value === true) { + buffer.push(' ' + prop + '="' + prop + '"'); + } else { + buffer.push(' ' + prop + '="' + this._escapeAttribute(props[prop]) + '"'); + } + } + } + } + + this.elementProperties = null; + } + + buffer.push('>'); + }, + + pushClosingTag: function() { + var tagName = this.tagNames.pop(); + if (tagName) { this.buffer.push(''); } + }, + + currentTagName: function() { + return this.tagNames[this.tagNames.length-1]; + }, + + generateElement: function() { + var tagName = this.tagNames.pop(), // pop since we don't need to close + element = document.createElement(tagName), + $element = Ember.$(element), + id = this.elementId, + classes = this.classes, + attrs = this.elementAttributes, + props = this.elementProperties, + style = this.elementStyle, + styleBuffer = '', attr, prop; + + if (id) { + $element.attr('id', id); + this.elementId = null; + } + if (classes) { + $element.attr('class', classes.join(' ')); + this.classes = null; + } + + if (style) { + for (prop in style) { + if (style.hasOwnProperty(prop)) { + styleBuffer += (prop + ':' + style[prop] + ';'); + } + } + + $element.attr('style', styleBuffer); + + this.elementStyle = null; + } + + if (attrs) { + for (attr in attrs) { + if (attrs.hasOwnProperty(attr)) { + $element.attr(attr, attrs[attr]); + } + } + + this.elementAttributes = null; + } + + if (props) { + for (prop in props) { + if (props.hasOwnProperty(prop)) { + $element.prop(prop, props[prop]); + } + } + + this.elementProperties = null; + } + + return element; + }, + + /** + @method element + @return {DOMElement} The element corresponding to the generated HTML + of this buffer + */ + element: function() { + var html = this.innerString(); + + if (html) { + this._element = Ember.ViewUtils.setInnerHTML(this._element, html); + } + + return this._element; + }, + + /** + Generates the HTML content for this buffer. + + @method string + @return {String} The generated HTML + */ + string: function() { + if (this._element) { + return this.element().outerHTML; + } else { + return this.innerString(); + } + }, + + innerString: function() { + return this.buffer.join(''); + }, + + _escapeAttribute: function(value) { + // Stolen shamelessly from Handlebars + + var escape = { + "<": "<", + ">": ">", + '"': """, + "'": "'", + "`": "`" + }; + + var badChars = /&(?!\w+;)|[<>"'`]/g; + var possible = /[&<>"'`]/; + + var escapeChar = function(chr) { + return escape[chr] || "&"; + }; + + var string = value.toString(); + + if(!possible.test(string)) { return string; } + return string.replace(badChars, escapeChar); + } + +}; + +})(); + + + +(function() { +/** +@module ember +@submodule ember-views +*/ + +var get = Ember.get, set = Ember.set, fmt = Ember.String.fmt; + +/** + `Ember.EventDispatcher` handles delegating browser events to their + corresponding `Ember.Views.` For example, when you click on a view, + `Ember.EventDispatcher` ensures that that view's `mouseDown` method gets + called. + + @class EventDispatcher + @namespace Ember + @private + @extends Ember.Object +*/ +Ember.EventDispatcher = Ember.Object.extend( +/** @scope Ember.EventDispatcher.prototype */{ + + /** + @private + + The root DOM element to which event listeners should be attached. Event + listeners will be attached to the document unless this is overridden. + + Can be specified as a DOMElement or a selector string. + + The default body is a string since this may be evaluated before document.body + exists in the DOM. + + @property rootElement + @type DOMElement + @default 'body' + */ + rootElement: 'body', + + /** + @private + + Sets up event listeners for standard browser events. + + This will be called after the browser sends a `DOMContentReady` event. By + default, it will set up all of the listeners on the document body. If you + would like to register the listeners on a different element, set the event + dispatcher's `root` property. + + @method setup + @param addedEvents {Hash} + */ + setup: function(addedEvents) { + var event, events = { + touchstart : 'touchStart', + touchmove : 'touchMove', + touchend : 'touchEnd', + touchcancel : 'touchCancel', + keydown : 'keyDown', + keyup : 'keyUp', + keypress : 'keyPress', + mousedown : 'mouseDown', + mouseup : 'mouseUp', + contextmenu : 'contextMenu', + click : 'click', + dblclick : 'doubleClick', + mousemove : 'mouseMove', + focusin : 'focusIn', + focusout : 'focusOut', + mouseenter : 'mouseEnter', + mouseleave : 'mouseLeave', + submit : 'submit', + input : 'input', + change : 'change', + dragstart : 'dragStart', + drag : 'drag', + dragenter : 'dragEnter', + dragleave : 'dragLeave', + dragover : 'dragOver', + drop : 'drop', + dragend : 'dragEnd' + }; + + Ember.$.extend(events, addedEvents || {}); + + var rootElement = Ember.$(get(this, 'rootElement')); + + Ember.assert(fmt('You cannot use the same root element (%@) multiple times in an Ember.Application', [rootElement.selector || rootElement[0].tagName]), !rootElement.is('.ember-application')); + Ember.assert('You cannot make a new Ember.Application using a root element that is a descendent of an existing Ember.Application', !rootElement.closest('.ember-application').length); + Ember.assert('You cannot make a new Ember.Application using a root element that is an ancestor of an existing Ember.Application', !rootElement.find('.ember-application').length); + + rootElement.addClass('ember-application'); + + Ember.assert('Unable to add "ember-application" class to rootElement. Make sure you set rootElement to the body or an element in the body.', rootElement.is('.ember-application')); + + for (event in events) { + if (events.hasOwnProperty(event)) { + this.setupHandler(rootElement, event, events[event]); + } + } + }, + + /** + @private + + Registers an event listener on the document. If the given event is + triggered, the provided event handler will be triggered on the target view. + + If the target view does not implement the event handler, or if the handler + returns `false`, the parent view will be called. The event will continue to + bubble to each successive parent view until it reaches the top. + + For example, to have the `mouseDown` method called on the target view when + a `mousedown` event is received from the browser, do the following: + + ```javascript + setupHandler('mousedown', 'mouseDown'); + ``` + + @method setupHandler + @param {Element} rootElement + @param {String} event the browser-originated event to listen to + @param {String} eventName the name of the method to call on the view + */ + setupHandler: function(rootElement, event, eventName) { + var self = this; + + rootElement.delegate('.ember-view', event + '.ember', function(evt, triggeringManager) { + return Ember.handleErrors(function() { + var view = Ember.View.views[this.id], + result = true, manager = null; + + manager = self._findNearestEventManager(view,eventName); + + if (manager && manager !== triggeringManager) { + result = self._dispatchEvent(manager, evt, eventName, view); + } else if (view) { + result = self._bubbleEvent(view,evt,eventName); + } else { + evt.stopPropagation(); + } + + return result; + }, this); + }); + + rootElement.delegate('[data-ember-action]', event + '.ember', function(evt) { + return Ember.handleErrors(function() { + var actionId = Ember.$(evt.currentTarget).attr('data-ember-action'), + action = Ember.Handlebars.ActionHelper.registeredActions[actionId]; + + // We have to check for action here since in some cases, jQuery will trigger + // an event on `removeChild` (i.e. focusout) after we've already torn down the + // action handlers for the view. + if (action && action.eventName === eventName) { + return action.handler(evt); + } + }, this); + }); + }, + + _findNearestEventManager: function(view, eventName) { + var manager = null; + + while (view) { + manager = get(view, 'eventManager'); + if (manager && manager[eventName]) { break; } + + view = get(view, 'parentView'); + } + + return manager; + }, + + _dispatchEvent: function(object, evt, eventName, view) { + var result = true; + + var handler = object[eventName]; + if (Ember.typeOf(handler) === 'function') { + result = handler.call(object, evt, view); + // Do not preventDefault in eventManagers. + evt.stopPropagation(); + } + else { + result = this._bubbleEvent(view, evt, eventName); + } + + return result; + }, + + _bubbleEvent: function(view, evt, eventName) { + return Ember.run(function() { + return view.handleEvent(eventName, evt); + }); + }, + + destroy: function() { + var rootElement = get(this, 'rootElement'); + Ember.$(rootElement).undelegate('.ember').removeClass('ember-application'); + return this._super(); + } +}); + +})(); + + + +(function() { +/** +@module ember +@submodule ember-views +*/ + +// Add a new named queue for rendering views that happens +// after bindings have synced, and a queue for scheduling actions +// that that should occur after view rendering. +var queues = Ember.run.queues; +queues.splice(Ember.$.inArray('actions', queues)+1, 0, 'render', 'afterRender'); + +})(); + + + +(function() { +/** +@module ember +@submodule ember-views +*/ + +var get = Ember.get, set = Ember.set; + +// Original class declaration and documentation in runtime/lib/controllers/controller.js +// NOTE: It may be possible with YUIDoc to combine docs in two locations + +/** +Additional methods for the ControllerMixin + +@class ControllerMixin +@namespace Ember +*/ +Ember.ControllerMixin.reopen({ + target: null, + namespace: null, + view: null, + container: null, + _childContainers: null, + + init: function() { + this._super(); + set(this, '_childContainers', {}); + }, + + _modelDidChange: Ember.observer(function() { + var containers = get(this, '_childContainers'), + container; + + for (var prop in containers) { + if (!containers.hasOwnProperty(prop)) { continue; } + containers[prop].destroy(); + } + + set(this, '_childContainers', {}); + }, 'model') +}); + +})(); + + + +(function() { + +})(); + + + +(function() { +var states = {}; + +/** +@module ember +@submodule ember-views +*/ + +var get = Ember.get, set = Ember.set, addObserver = Ember.addObserver, removeObserver = Ember.removeObserver; +var meta = Ember.meta, guidFor = Ember.guidFor, fmt = Ember.String.fmt; +var a_slice = [].slice; +var a_forEach = Ember.EnumerableUtils.forEach; +var a_addObject = Ember.EnumerableUtils.addObject; + +var childViewsProperty = Ember.computed(function() { + var childViews = this._childViews, ret = Ember.A(), view = this; + + a_forEach(childViews, function(view) { + if (view.isVirtual) { + ret.pushObjects(get(view, 'childViews')); + } else { + ret.push(view); + } + }); + + ret.replace = function (idx, removedCount, addedViews) { + if (view instanceof Ember.ContainerView) { + Ember.deprecate("Manipulating a Ember.ContainerView through its childViews property is deprecated. Please use the ContainerView instance itself as an Ember.MutableArray."); + return view.replace(idx, removedCount, addedViews); + } + throw new Error("childViews is immutable"); + }; + + return ret; +}); + +Ember.warn("The VIEW_PRESERVES_CONTEXT flag has been removed and the functionality can no longer be disabled.", Ember.ENV.VIEW_PRESERVES_CONTEXT !== false); + +/** + Global hash of shared templates. This will automatically be populated + by the build tools so that you can store your Handlebars templates in + separate files that get loaded into JavaScript at buildtime. + + @property TEMPLATES + @for Ember + @type Hash +*/ +Ember.TEMPLATES = {}; + +Ember.CoreView = Ember.Object.extend(Ember.Evented, { + isView: true, + + states: states, + + init: function() { + this._super(); + + // Register the view for event handling. This hash is used by + // Ember.EventDispatcher to dispatch incoming events. + if (!this.isVirtual) { + Ember.assert("Attempted to register a view with an id already in use: "+this.elementId, !Ember.View.views[this.elementId]); + Ember.View.views[this.elementId] = this; + } + + this.addBeforeObserver('elementId', function() { + throw new Error("Changing a view's elementId after creation is not allowed"); + }); + + this.transitionTo('preRender'); + }, + + /** + If the view is currently inserted into the DOM of a parent view, this + property will point to the parent of the view. + + @property parentView + @type Ember.View + @default null + */ + parentView: Ember.computed(function() { + var parent = this._parentView; + + if (parent && parent.isVirtual) { + return get(parent, 'parentView'); + } else { + return parent; + } + }).property('_parentView'), + + state: null, + + _parentView: null, + + // return the current view, not including virtual views + concreteView: Ember.computed(function() { + if (!this.isVirtual) { return this; } + else { return get(this, 'parentView'); } + }).property('parentView').volatile(), + + instrumentName: 'core_view', + + instrumentDetails: function(hash) { + hash.object = this.toString(); + }, + + /** + @private + + Invoked by the view system when this view needs to produce an HTML + representation. This method will create a new render buffer, if needed, + then apply any default attributes, such as class names and visibility. + Finally, the `render()` method is invoked, which is responsible for + doing the bulk of the rendering. + + You should not need to override this method; instead, implement the + `template` property, or if you need more control, override the `render` + method. + + @method renderToBuffer + @param {Ember.RenderBuffer} buffer the render buffer. If no buffer is + passed, a default buffer, using the current view's `tagName`, will + be used. + */ + renderToBuffer: function(parentBuffer, bufferOperation) { + var name = 'render.' + this.instrumentName, + details = {}; + + this.instrumentDetails(details); + + return Ember.instrument(name, details, function() { + return this._renderToBuffer(parentBuffer, bufferOperation); + }, this); + }, + + _renderToBuffer: function(parentBuffer, bufferOperation) { + Ember.run.sync(); + + // If this is the top-most view, start a new buffer. Otherwise, + // create a new buffer relative to the original using the + // provided buffer operation (for example, `insertAfter` will + // insert a new buffer after the "parent buffer"). + var tagName = this.tagName; + + if (tagName === null || tagName === undefined) { + tagName = 'div'; + } + + var buffer = this.buffer = parentBuffer && parentBuffer.begin(tagName) || Ember.RenderBuffer(tagName); + this.transitionTo('inBuffer', false); + + this.beforeRender(buffer); + this.render(buffer); + this.afterRender(buffer); + + return buffer; + }, + + /** + @private + + Override the default event firing from `Ember.Evented` to + also call methods with the given name. + + @method trigger + @param name {String} + */ + trigger: function(name) { + this._super.apply(this, arguments); + var method = this[name]; + if (method) { + var args = [], i, l; + for (i = 1, l = arguments.length; i < l; i++) { + args.push(arguments[i]); + } + return method.apply(this, args); + } + }, + + has: function(name) { + return Ember.typeOf(this[name]) === 'function' || this._super(name); + }, + + willDestroy: function() { + var parent = this._parentView; + + // destroy the element -- this will avoid each child view destroying + // the element over and over again... + if (!this.removedFromDOM) { this.destroyElement(); } + + // remove from parent if found. Don't call removeFromParent, + // as removeFromParent will try to remove the element from + // the DOM again. + if (parent) { parent.removeChild(this); } + + this.transitionTo('destroyed'); + + // next remove view from global hash + if (!this.isVirtual) delete Ember.View.views[this.elementId]; + }, + + clearRenderedChildren: Ember.K, + triggerRecursively: Ember.K, + invokeRecursively: Ember.K, + transitionTo: Ember.K, + destroyElement: Ember.K +}); + +/** + `Ember.View` is the class in Ember responsible for encapsulating templates of + HTML content, combining templates with data to render as sections of a page's + DOM, and registering and responding to user-initiated events. + + ## HTML Tag + + The default HTML tag name used for a view's DOM representation is `div`. This + can be customized by setting the `tagName` property. The following view +class: + + ```javascript + ParagraphView = Ember.View.extend({ + tagName: 'em' + }); + ``` + + Would result in instances with the following HTML: + + ```html + + ``` + + ## HTML `class` Attribute + + The HTML `class` attribute of a view's tag can be set by providing a + `classNames` property that is set to an array of strings: + + ```javascript + MyView = Ember.View.extend({ + classNames: ['my-class', 'my-other-class'] + }); + ``` + + Will result in view instances with an HTML representation of: + + ```html +
    + ``` + + `class` attribute values can also be set by providing a `classNameBindings` + property set to an array of properties names for the view. The return value + of these properties will be added as part of the value for the view's `class` + attribute. These properties can be computed properties: + + ```javascript + MyView = Ember.View.extend({ + classNameBindings: ['propertyA', 'propertyB'], + propertyA: 'from-a', + propertyB: function(){ + if(someLogic){ return 'from-b'; } + }.property() + }); + ``` + + Will result in view instances with an HTML representation of: + + ```html +
    + ``` + + If the value of a class name binding returns a boolean the property name + itself will be used as the class name if the property is true. The class name + will not be added if the value is `false` or `undefined`. + + ```javascript + MyView = Ember.View.extend({ + classNameBindings: ['hovered'], + hovered: true + }); + ``` + + Will result in view instances with an HTML representation of: + + ```html +
    + ``` + + When using boolean class name bindings you can supply a string value other + than the property name for use as the `class` HTML attribute by appending the + preferred value after a ":" character when defining the binding: + + ```javascript + MyView = Ember.View.extend({ + classNameBindings: ['awesome:so-very-cool'], + awesome: true + }); + ``` + + Will result in view instances with an HTML representation of: + + ```html +
    + ``` + + Boolean value class name bindings whose property names are in a + camelCase-style format will be converted to a dasherized format: + + ```javascript + MyView = Ember.View.extend({ + classNameBindings: ['isUrgent'], + isUrgent: true + }); + ``` + + Will result in view instances with an HTML representation of: + + ```html +
    + ``` + + Class name bindings can also refer to object values that are found by + traversing a path relative to the view itself: + + ```javascript + MyView = Ember.View.extend({ + classNameBindings: ['messages.empty'] + messages: Ember.Object.create({ + empty: true + }) + }); + ``` + + Will result in view instances with an HTML representation of: + + ```html +
    + ``` + + If you want to add a class name for a property which evaluates to true and + and a different class name if it evaluates to false, you can pass a binding + like this: + + ```javascript + // Applies 'enabled' class when isEnabled is true and 'disabled' when isEnabled is false + Ember.View.create({ + classNameBindings: ['isEnabled:enabled:disabled'] + isEnabled: true + }); + ``` + + Will result in view instances with an HTML representation of: + + ```html +
    + ``` + + When isEnabled is `false`, the resulting HTML reprensentation looks like + this: + + ```html +
    + ``` + + This syntax offers the convenience to add a class if a property is `false`: + + ```javascript + // Applies no class when isEnabled is true and class 'disabled' when isEnabled is false + Ember.View.create({ + classNameBindings: ['isEnabled::disabled'] + isEnabled: true + }); + ``` + + Will result in view instances with an HTML representation of: + + ```html +
    + ``` + + When the `isEnabled` property on the view is set to `false`, it will result + in view instances with an HTML representation of: + + ```html +
    + ``` + + Updates to the the value of a class name binding will result in automatic + update of the HTML `class` attribute in the view's rendered HTML + representation. If the value becomes `false` or `undefined` the class name + will be removed. + + Both `classNames` and `classNameBindings` are concatenated properties. See + `Ember.Object` documentation for more information about concatenated + properties. + + ## HTML Attributes + + The HTML attribute section of a view's tag can be set by providing an + `attributeBindings` property set to an array of property names on the view. + The return value of these properties will be used as the value of the view's + HTML associated attribute: + + ```javascript + AnchorView = Ember.View.extend({ + tagName: 'a', + attributeBindings: ['href'], + href: 'http://google.com' + }); + ``` + + Will result in view instances with an HTML representation of: + + ```html + + ``` + + If the return value of an `attributeBindings` monitored property is a boolean + the property will follow HTML's pattern of repeating the attribute's name as + its value: + + ```javascript + MyTextInput = Ember.View.extend({ + tagName: 'input', + attributeBindings: ['disabled'], + disabled: true + }); + ``` + + Will result in view instances with an HTML representation of: + + ```html + + ``` + + `attributeBindings` can refer to computed properties: + + ```javascript + MyTextInput = Ember.View.extend({ + tagName: 'input', + attributeBindings: ['disabled'], + disabled: function(){ + if (someLogic) { + return true; + } else { + return false; + } + }.property() + }); + ``` + + Updates to the the property of an attribute binding will result in automatic + update of the HTML attribute in the view's rendered HTML representation. + + `attributeBindings` is a concatenated property. See `Ember.Object` + documentation for more information about concatenated properties. + + ## Templates + + The HTML contents of a view's rendered representation are determined by its + template. Templates can be any function that accepts an optional context + parameter and returns a string of HTML that will be inserted within the + view's tag. Most typically in Ember this function will be a compiled + `Ember.Handlebars` template. + + ```javascript + AView = Ember.View.extend({ + template: Ember.Handlebars.compile('I am the template') + }); + ``` + + Will result in view instances with an HTML representation of: + + ```html +
    I am the template
    + ``` + + Within an Ember application is more common to define a Handlebars templates as + part of a page: + + ```html + + ``` + + And associate it by name using a view's `templateName` property: + + ```javascript + AView = Ember.View.extend({ + templateName: 'some-template' + }); + ``` + + Using a value for `templateName` that does not have a Handlebars template + with a matching `data-template-name` attribute will throw an error. + + Assigning a value to both `template` and `templateName` properties will throw + an error. + + For views classes that may have a template later defined (e.g. as the block + portion of a `{{view}}` Handlebars helper call in another template or in + a subclass), you can provide a `defaultTemplate` property set to compiled + template function. If a template is not later provided for the view instance + the `defaultTemplate` value will be used: + + ```javascript + AView = Ember.View.extend({ + defaultTemplate: Ember.Handlebars.compile('I was the default'), + template: null, + templateName: null + }); + ``` + + Will result in instances with an HTML representation of: + + ```html +
    I was the default
    + ``` + + If a `template` or `templateName` is provided it will take precedence over + `defaultTemplate`: + + ```javascript + AView = Ember.View.extend({ + defaultTemplate: Ember.Handlebars.compile('I was the default') + }); + + aView = AView.create({ + template: Ember.Handlebars.compile('I was the template, not default') + }); + ``` + + Will result in the following HTML representation when rendered: + + ```html +
    I was the template, not default
    + ``` + + ## View Context + + The default context of the compiled template is the view's controller: + + ```javascript + AView = Ember.View.extend({ + template: Ember.Handlebars.compile('Hello {{excitedGreeting}}') + }); + + aController = Ember.Object.create({ + firstName: 'Barry', + excitedGreeting: function(){ + return this.get("content.firstName") + "!!!" + }.property() + }); + + aView = AView.create({ + controller: aController, + }); + ``` + + Will result in an HTML representation of: + + ```html +
    Hello Barry!!!
    + ``` + + A context can also be explicitly supplied through the view's `context` + property. If the view has neither `context` nor `controller` properties, the + `parentView`'s context will be used. + + ## Layouts + + Views can have a secondary template that wraps their main template. Like + primary templates, layouts can be any function that accepts an optional + context parameter and returns a string of HTML that will be inserted inside + view's tag. Views whose HTML element is self closing (e.g. ``) + cannot have a layout and this property will be ignored. + + Most typically in Ember a layout will be a compiled `Ember.Handlebars` + template. + + A view's layout can be set directly with the `layout` property or reference + an existing Handlebars template by name with the `layoutName` property. + + A template used as a layout must contain a single use of the Handlebars + `{{yield}}` helper. The HTML contents of a view's rendered `template` will be + inserted at this location: + + ```javascript + AViewWithLayout = Ember.View.extend({ + layout: Ember.Handlebars.compile("
    {{yield}}
    ") + template: Ember.Handlebars.compile("I got wrapped"), + }); + ``` + + Will result in view instances with an HTML representation of: + + ```html +
    +
    + I got wrapped +
    +
    + ``` + + See `Handlebars.helpers.yield` for more information. + + ## Responding to Browser Events + + Views can respond to user-initiated events in one of three ways: method + implementation, through an event manager, and through `{{action}}` helper use + in their template or layout. + + ### Method Implementation + + Views can respond to user-initiated events by implementing a method that + matches the event name. A `jQuery.Event` object will be passed as the + argument to this method. + + ```javascript + AView = Ember.View.extend({ + click: function(event){ + // will be called when when an instance's + // rendered element is clicked + } + }); + ``` + + ### Event Managers + + Views can define an object as their `eventManager` property. This object can + then implement methods that match the desired event names. Matching events + that occur on the view's rendered HTML or the rendered HTML of any of its DOM + descendants will trigger this method. A `jQuery.Event` object will be passed + as the first argument to the method and an `Ember.View` object as the + second. The `Ember.View` will be the view whose rendered HTML was interacted + with. This may be the view with the `eventManager` property or one of its + descendent views. + + ```javascript + AView = Ember.View.extend({ + eventManager: Ember.Object.create({ + doubleClick: function(event, view){ + // will be called when when an instance's + // rendered element or any rendering + // of this views's descendent + // elements is clicked + } + }) + }); + ``` + + An event defined for an event manager takes precedence over events of the + same name handled through methods on the view. + + ```javascript + AView = Ember.View.extend({ + mouseEnter: function(event){ + // will never trigger. + }, + eventManager: Ember.Object.create({ + mouseEnter: function(event, view){ + // takes presedence over AView#mouseEnter + } + }) + }); + ``` + + Similarly a view's event manager will take precedence for events of any views + rendered as a descendent. A method name that matches an event name will not + be called if the view instance was rendered inside the HTML representation of + a view that has an `eventManager` property defined that handles events of the + name. Events not handled by the event manager will still trigger method calls + on the descendent. + + ```javascript + OuterView = Ember.View.extend({ + template: Ember.Handlebars.compile("outer {{#view InnerView}}inner{{/view}} outer"), + eventManager: Ember.Object.create({ + mouseEnter: function(event, view){ + // view might be instance of either + // OutsideView or InnerView depending on + // where on the page the user interaction occured + } + }) + }); + + InnerView = Ember.View.extend({ + click: function(event){ + // will be called if rendered inside + // an OuterView because OuterView's + // eventManager doesn't handle click events + }, + mouseEnter: function(event){ + // will never be called if rendered inside + // an OuterView. + } + }); + ``` + + ### Handlebars `{{action}}` Helper + + See `Handlebars.helpers.action`. + + ### Event Names + + Possible events names for any of the responding approaches described above + are: + + Touch events: + + * `touchStart` + * `touchMove` + * `touchEnd` + * `touchCancel` + + Keyboard events + + * `keyDown` + * `keyUp` + * `keyPress` + + Mouse events + + * `mouseDown` + * `mouseUp` + * `contextMenu` + * `click` + * `doubleClick` + * `mouseMove` + * `focusIn` + * `focusOut` + * `mouseEnter` + * `mouseLeave` + + Form events: + + * `submit` + * `change` + * `focusIn` + * `focusOut` + * `input` + + HTML5 drag and drop events: + + * `dragStart` + * `drag` + * `dragEnter` + * `dragLeave` + * `drop` + * `dragEnd` + + ## Handlebars `{{view}}` Helper + + Other `Ember.View` instances can be included as part of a view's template by + using the `{{view}}` Handlebars helper. See `Handlebars.helpers.view` for + additional information. + + @class View + @namespace Ember + @extends Ember.Object + @uses Ember.Evented +*/ +Ember.View = Ember.CoreView.extend( +/** @scope Ember.View.prototype */ { + + concatenatedProperties: ['classNames', 'classNameBindings', 'attributeBindings'], + + /** + @property isView + @type Boolean + @default true + @final + */ + isView: true, + + // .......................................................... + // TEMPLATE SUPPORT + // + + /** + The name of the template to lookup if no template is provided. + + `Ember.View` will look for a template with this name in this view's + `templates` object. By default, this will be a global object + shared in `Ember.TEMPLATES`. + + @property templateName + @type String + @default null + */ + templateName: null, + + /** + The name of the layout to lookup if no layout is provided. + + `Ember.View` will look for a template with this name in this view's + `templates` object. By default, this will be a global object + shared in `Ember.TEMPLATES`. + + @property layoutName + @type String + @default null + */ + layoutName: null, + + /** + The hash in which to look for `templateName`. + + @property templates + @type Ember.Object + @default Ember.TEMPLATES + */ + templates: Ember.TEMPLATES, + + /** + The template used to render the view. This should be a function that + accepts an optional context parameter and returns a string of HTML that + will be inserted into the DOM relative to its parent view. + + In general, you should set the `templateName` property instead of setting + the template yourself. + + @property template + @type Function + */ + template: Ember.computed(function(key, value) { + if (value !== undefined) { return value; } + + var templateName = get(this, 'templateName'), + template = this.templateForName(templateName, 'template'); + + Ember.assert("You specified the templateName " + templateName + " for " + this + ", but it did not exist.", !templateName || template); + + return template || get(this, 'defaultTemplate'); + }).property('templateName'), + + container: Ember.computed(function() { + var parentView = get(this, '_parentView'); + + if (parentView) { return get(parentView, 'container'); } + + return Ember.Container && Ember.Container.defaultContainer; + }), + + /** + The controller managing this view. If this property is set, it will be + made available for use by the template. + + @property controller + @type Object + */ + controller: Ember.computed(function(key) { + var parentView = get(this, '_parentView'); + return parentView ? get(parentView, 'controller') : null; + }).property('_parentView'), + + /** + A view may contain a layout. A layout is a regular template but + supersedes the `template` property during rendering. It is the + responsibility of the layout template to retrieve the `template` + property from the view (or alternatively, call `Handlebars.helpers.yield`, + `{{yield}}`) to render it in the correct location. + + This is useful for a view that has a shared wrapper, but which delegates + the rendering of the contents of the wrapper to the `template` property + on a subclass. + + @property layout + @type Function + */ + layout: Ember.computed(function(key) { + var layoutName = get(this, 'layoutName'), + layout = this.templateForName(layoutName, 'layout'); + + Ember.assert("You specified the layoutName " + layoutName + " for " + this + ", but it did not exist.", !layoutName || layout); + + return layout || get(this, 'defaultLayout'); + }).property('layoutName'), + + templateForName: function(name, type) { + if (!name) { return; } + + Ember.assert("templateNames are not allowed to contain periods: "+name, name.indexOf('.') === -1); + + var container = get(this, 'container'); + + if (container) { + return container.lookup('template:' + name); + } + }, + + /** + The object from which templates should access properties. + + This object will be passed to the template function each time the render + method is called, but it is up to the individual function to decide what + to do with it. + + By default, this will be the view's controller. + + @property context + @type Object + */ + context: Ember.computed(function(key, value) { + if (arguments.length === 2) { + set(this, '_context', value); + return value; + } else { + return get(this, '_context'); + } + }).volatile(), + + /** + @private + + Private copy of the view's template context. This can be set directly + by Handlebars without triggering the observer that causes the view + to be re-rendered. + + The context of a view is looked up as follows: + + 1. Supplied context (usually by Handlebars) + 2. Specified controller + 3. `parentView`'s context (for a child of a ContainerView) + + The code in Handlebars that overrides the `_context` property first + checks to see whether the view has a specified controller. This is + something of a hack and should be revisited. + + @property _context + */ + _context: Ember.computed(function(key) { + var parentView, controller; + + if (controller = get(this, 'controller')) { + return controller; + } + + parentView = this._parentView; + if (parentView) { + return get(parentView, '_context'); + } + + return null; + }), + + /** + @private + + If a value that affects template rendering changes, the view should be + re-rendered to reflect the new value. + + @method _displayPropertyDidChange + */ + _contextDidChange: Ember.observer(function() { + this.rerender(); + }, 'context'), + + /** + If `false`, the view will appear hidden in DOM. + + @property isVisible + @type Boolean + @default null + */ + isVisible: true, + + /** + @private + + Array of child views. You should never edit this array directly. + Instead, use `appendChild` and `removeFromParent`. + + @property childViews + @type Array + @default [] + */ + childViews: childViewsProperty, + + _childViews: [], + + // When it's a virtual view, we need to notify the parent that their + // childViews will change. + _childViewsWillChange: Ember.beforeObserver(function() { + if (this.isVirtual) { + var parentView = get(this, 'parentView'); + if (parentView) { Ember.propertyWillChange(parentView, 'childViews'); } + } + }, 'childViews'), + + // When it's a virtual view, we need to notify the parent that their + // childViews did change. + _childViewsDidChange: Ember.observer(function() { + if (this.isVirtual) { + var parentView = get(this, 'parentView'); + if (parentView) { Ember.propertyDidChange(parentView, 'childViews'); } + } + }, 'childViews'), + + /** + Return the nearest ancestor that is an instance of the provided + class. + + @property nearestInstanceOf + @param {Class} klass Subclass of Ember.View (or Ember.View itself) + @return Ember.View + @deprecated + */ + nearestInstanceOf: function(klass) { + Ember.deprecate("nearestInstanceOf is deprecated and will be removed from future releases. Use nearestOfType."); + var view = get(this, 'parentView'); + + while (view) { + if(view instanceof klass) { return view; } + view = get(view, 'parentView'); + } + }, + + /** + Return the nearest ancestor that is an instance of the provided + class or mixin. + + @property nearestOfType + @param {Class,Mixin} klass Subclass of Ember.View (or Ember.View itself), + or an instance of Ember.Mixin. + @return Ember.View + */ + nearestOfType: function(klass) { + var view = get(this, 'parentView'), + isOfType = klass instanceof Ember.Mixin ? + function(view) { return klass.detect(view); } : + function(view) { return klass.detect(view.constructor); }; + + while (view) { + if( isOfType(view) ) { return view; } + view = get(view, 'parentView'); + } + }, + + /** + Return the nearest ancestor that has a given property. + + @property nearestWithProperty + @param {String} property A property name + @return Ember.View + */ + nearestWithProperty: function(property) { + var view = get(this, 'parentView'); + + while (view) { + if (property in view) { return view; } + view = get(view, 'parentView'); + } + }, + + /** + Return the nearest ancestor whose parent is an instance of + `klass`. + + @property nearestChildOf + @param {Class} klass Subclass of Ember.View (or Ember.View itself) + @return Ember.View + */ + nearestChildOf: function(klass) { + var view = get(this, 'parentView'); + + while (view) { + if(get(view, 'parentView') instanceof klass) { return view; } + view = get(view, 'parentView'); + } + }, + + /** + @private + + When the parent view changes, recursively invalidate `controller` + + @method _parentViewDidChange + */ + _parentViewDidChange: Ember.observer(function() { + if (this.isDestroying) { return; } + + if (get(this, 'parentView.controller') && !get(this, 'controller')) { + this.notifyPropertyChange('controller'); + } + }, '_parentView'), + + _controllerDidChange: Ember.observer(function() { + if (this.isDestroying) { return; } + + this.rerender(); + + this.forEachChildView(function(view) { + view.propertyDidChange('controller'); + }); + }, 'controller'), + + cloneKeywords: function() { + var templateData = get(this, 'templateData'); + + var keywords = templateData ? Ember.copy(templateData.keywords) : {}; + set(keywords, 'view', get(this, 'concreteView')); + set(keywords, '_view', this); + set(keywords, 'controller', get(this, 'controller')); + + return keywords; + }, + + /** + Called on your view when it should push strings of HTML into a + `Ember.RenderBuffer`. Most users will want to override the `template` + or `templateName` properties instead of this method. + + By default, `Ember.View` will look for a function in the `template` + property and invoke it with the value of `context`. The value of + `context` will be the view's controller unless you override it. + + @method render + @param {Ember.RenderBuffer} buffer The render buffer + */ + render: function(buffer) { + // If this view has a layout, it is the responsibility of the + // the layout to render the view's template. Otherwise, render the template + // directly. + var template = get(this, 'layout') || get(this, 'template'); + + if (template) { + var context = get(this, 'context'); + var keywords = this.cloneKeywords(); + var output; + + var data = { + view: this, + buffer: buffer, + isRenderData: true, + keywords: keywords, + insideGroup: get(this, 'templateData.insideGroup') + }; + + // Invoke the template with the provided template context, which + // is the view's controller by default. A hash of data is also passed that provides + // the template with access to the view and render buffer. + + Ember.assert('template must be a function. Did you mean to call Ember.Handlebars.compile("...") or specify templateName instead?', typeof template === 'function'); + // The template should write directly to the render buffer instead + // of returning a string. + output = template(context, { data: data }); + + // If the template returned a string instead of writing to the buffer, + // push the string onto the buffer. + if (output !== undefined) { buffer.push(output); } + } + }, + + /** + Renders the view again. This will work regardless of whether the + view is already in the DOM or not. If the view is in the DOM, the + rendering process will be deferred to give bindings a chance + to synchronize. + + If children were added during the rendering process using `appendChild`, + `rerender` will remove them, because they will be added again + if needed by the next `render`. + + In general, if the display of your view changes, you should modify + the DOM element directly instead of manually calling `rerender`, which can + be slow. + + @method rerender + */ + rerender: function() { + return this.currentState.rerender(this); + }, + + clearRenderedChildren: function() { + var lengthBefore = this.lengthBeforeRender, + lengthAfter = this.lengthAfterRender; + + // If there were child views created during the last call to render(), + // remove them under the assumption that they will be re-created when + // we re-render. + + // VIEW-TODO: Unit test this path. + var childViews = this._childViews; + for (var i=lengthAfter-1; i>=lengthBefore; i--) { + if (childViews[i]) { childViews[i].destroy(); } + } + }, + + /** + @private + + Iterates over the view's `classNameBindings` array, inserts the value + of the specified property into the `classNames` array, then creates an + observer to update the view's element if the bound property ever changes + in the future. + + @method _applyClassNameBindings + */ + _applyClassNameBindings: function(classBindings) { + var classNames = this.classNames, + elem, newClass, dasherizedClass; + + // Loop through all of the configured bindings. These will be either + // property names ('isUrgent') or property paths relative to the view + // ('content.isUrgent') + a_forEach(classBindings, function(binding) { + + // Variable in which the old class value is saved. The observer function + // closes over this variable, so it knows which string to remove when + // the property changes. + var oldClass; + // Extract just the property name from bindings like 'foo:bar' + var parsedPath = Ember.View._parsePropertyPath(binding); + + // Set up an observer on the context. If the property changes, toggle the + // class name. + var observer = function() { + // Get the current value of the property + newClass = this._classStringForProperty(binding); + elem = this.$(); + + // If we had previously added a class to the element, remove it. + if (oldClass) { + elem.removeClass(oldClass); + // Also remove from classNames so that if the view gets rerendered, + // the class doesn't get added back to the DOM. + classNames.removeObject(oldClass); + } + + // If necessary, add a new class. Make sure we keep track of it so + // it can be removed in the future. + if (newClass) { + elem.addClass(newClass); + oldClass = newClass; + } else { + oldClass = null; + } + }; + + // Get the class name for the property at its current value + dasherizedClass = this._classStringForProperty(binding); + + if (dasherizedClass) { + // Ensure that it gets into the classNames array + // so it is displayed when we render. + a_addObject(classNames, dasherizedClass); + + // Save a reference to the class name so we can remove it + // if the observer fires. Remember that this variable has + // been closed over by the observer. + oldClass = dasherizedClass; + } + + this.registerObserver(this, parsedPath.path, observer); + // Remove className so when the view is rerendered, + // the className is added based on binding reevaluation + this.one('willClearRender', function() { + if (oldClass) { + classNames.removeObject(oldClass); + oldClass = null; + } + }); + + }, this); + }, + + /** + @private + + Iterates through the view's attribute bindings, sets up observers for each, + then applies the current value of the attributes to the passed render buffer. + + @method _applyAttributeBindings + @param {Ember.RenderBuffer} buffer + */ + _applyAttributeBindings: function(buffer, attributeBindings) { + var attributeValue, elem, type; + + a_forEach(attributeBindings, function(binding) { + var split = binding.split(':'), + property = split[0], + attributeName = split[1] || property; + + // Create an observer to add/remove/change the attribute if the + // JavaScript property changes. + var observer = function() { + elem = this.$(); + if (!elem) { return; } + + attributeValue = get(this, property); + + Ember.View.applyAttributeBindings(elem, attributeName, attributeValue); + }; + + this.registerObserver(this, property, observer); + + // Determine the current value and add it to the render buffer + // if necessary. + attributeValue = get(this, property); + Ember.View.applyAttributeBindings(buffer, attributeName, attributeValue); + }, this); + }, + + /** + @private + + Given a property name, returns a dasherized version of that + property name if the property evaluates to a non-falsy value. + + For example, if the view has property `isUrgent` that evaluates to true, + passing `isUrgent` to this method will return `"is-urgent"`. + + @method _classStringForProperty + @param property + */ + _classStringForProperty: function(property) { + var parsedPath = Ember.View._parsePropertyPath(property); + var path = parsedPath.path; + + var val = get(this, path); + if (val === undefined && Ember.isGlobalPath(path)) { + val = get(Ember.lookup, path); + } + + return Ember.View._classStringForValue(path, val, parsedPath.className, parsedPath.falsyClassName); + }, + + // .......................................................... + // ELEMENT SUPPORT + // + + /** + Returns the current DOM element for the view. + + @property element + @type DOMElement + */ + element: Ember.computed(function(key, value) { + if (value !== undefined) { + return this.currentState.setElement(this, value); + } else { + return this.currentState.getElement(this); + } + }).property('_parentView'), + + /** + Returns a jQuery object for this view's element. If you pass in a selector + string, this method will return a jQuery object, using the current element + as its buffer. + + For example, calling `view.$('li')` will return a jQuery object containing + all of the `li` elements inside the DOM element of this view. + + @property $ + @param {String} [selector] a jQuery-compatible selector string + @return {jQuery} the CoreQuery object for the DOM node + */ + $: function(sel) { + return this.currentState.$(this, sel); + }, + + mutateChildViews: function(callback) { + var childViews = this._childViews, + idx = childViews.length, + view; + + while(--idx >= 0) { + view = childViews[idx]; + callback.call(this, view, idx); + } + + return this; + }, + + forEachChildView: function(callback) { + var childViews = this._childViews; + + if (!childViews) { return this; } + + var len = childViews.length, + view, idx; + + for(idx = 0; idx < len; idx++) { + view = childViews[idx]; + callback.call(this, view); + } + + return this; + }, + + /** + Appends the view's element to the specified parent element. + + If the view does not have an HTML representation yet, `createElement()` + will be called automatically. + + Note that this method just schedules the view to be appended; the DOM + element will not be appended to the given element until all bindings have + finished synchronizing. + + This is not typically a function that you will need to call directly when + building your application. You might consider using `Ember.ContainerView` + instead. If you do need to use `appendTo`, be sure that the target element + you are providing is associated with an `Ember.Application` and does not + have an ancestor element that is associated with an Ember view. + + @method appendTo + @param {String|DOMElement|jQuery} A selector, element, HTML string, or jQuery object + @return {Ember.View} receiver + */ + appendTo: function(target) { + // Schedule the DOM element to be created and appended to the given + // element after bindings have synchronized. + this._insertElementLater(function() { + Ember.assert("You cannot append to an existing Ember.View. Consider using Ember.ContainerView instead.", !Ember.$(target).is('.ember-view') && !Ember.$(target).parents().is('.ember-view')); + this.$().appendTo(target); + }); + + return this; + }, + + /** + Replaces the content of the specified parent element with this view's + element. If the view does not have an HTML representation yet, + `createElement()` will be called automatically. + + Note that this method just schedules the view to be appended; the DOM + element will not be appended to the given element until all bindings have + finished synchronizing + + @method replaceIn + @param {String|DOMElement|jQuery} A selector, element, HTML string, or jQuery object + @return {Ember.View} received + */ + replaceIn: function(target) { + Ember.assert("You cannot replace an existing Ember.View. Consider using Ember.ContainerView instead.", !Ember.$(target).is('.ember-view') && !Ember.$(target).parents().is('.ember-view')); + + this._insertElementLater(function() { + Ember.$(target).empty(); + this.$().appendTo(target); + }); + + return this; + }, + + /** + @private + + Schedules a DOM operation to occur during the next render phase. This + ensures that all bindings have finished synchronizing before the view is + rendered. + + To use, pass a function that performs a DOM operation. + + Before your function is called, this view and all child views will receive + the `willInsertElement` event. After your function is invoked, this view + and all of its child views will receive the `didInsertElement` event. + + ```javascript + view._insertElementLater(function() { + this.createElement(); + this.$().appendTo('body'); + }); + ``` + + @method _insertElementLater + @param {Function} fn the function that inserts the element into the DOM + */ + _insertElementLater: function(fn) { + this._scheduledInsert = Ember.run.scheduleOnce('render', this, '_insertElement', fn); + }, + + _insertElement: function (fn) { + this._scheduledInsert = null; + this.currentState.insertElement(this, fn); + }, + + /** + Appends the view's element to the document body. If the view does + not have an HTML representation yet, `createElement()` will be called + automatically. + + Note that this method just schedules the view to be appended; the DOM + element will not be appended to the document body until all bindings have + finished synchronizing. + + @method append + @return {Ember.View} receiver + */ + append: function() { + return this.appendTo(document.body); + }, + + /** + Removes the view's element from the element to which it is attached. + + @method remove + @return {Ember.View} receiver + */ + remove: function() { + // What we should really do here is wait until the end of the run loop + // to determine if the element has been re-appended to a different + // element. + // In the interim, we will just re-render if that happens. It is more + // important than elements get garbage collected. + if (!this.removedFromDOM) { this.destroyElement(); } + this.invokeRecursively(function(view) { + if (view.clearRenderedChildren) { view.clearRenderedChildren(); } + }); + }, + + elementId: null, + + /** + Attempts to discover the element in the parent element. The default + implementation looks for an element with an ID of `elementId` (or the + view's guid if `elementId` is null). You can override this method to + provide your own form of lookup. For example, if you want to discover your + element using a CSS class name instead of an ID. + + @method findElementInParentElement + @param {DOMElement} parentElement The parent's DOM element + @return {DOMElement} The discovered element + */ + findElementInParentElement: function(parentElem) { + var id = "#" + this.elementId; + return Ember.$(id)[0] || Ember.$(id, parentElem)[0]; + }, + + /** + Creates a DOM representation of the view and all of its + child views by recursively calling the `render()` method. + + After the element has been created, `didInsertElement` will + be called on this view and all of its child views. + + @method createElement + @return {Ember.View} receiver + */ + createElement: function() { + if (get(this, 'element')) { return this; } + + var buffer = this.renderToBuffer(); + set(this, 'element', buffer.element()); + + return this; + }, + + /** + Called when a view is going to insert an element into the DOM. + + @event willInsertElement + */ + willInsertElement: Ember.K, + + /** + Called when the element of the view has been inserted into the DOM. + Override this function to do any set up that requires an element in the + document body. + + @event didInsertElement + */ + didInsertElement: Ember.K, + + /** + Called when the view is about to rerender, but before anything has + been torn down. This is a good opportunity to tear down any manual + observers you have installed based on the DOM state + + @event willClearRender + */ + willClearRender: Ember.K, + + /** + @private + + Run this callback on the current view and recursively on child views. + + @method invokeRecursively + @param fn {Function} + */ + invokeRecursively: function(fn) { + var childViews = [this], currentViews, view; + + while (childViews.length) { + currentViews = childViews.slice(); + childViews = []; + + for (var i=0, l=currentViews.length; i` tag for views. + + @property tagName + @type String + @default null + */ + + // We leave this null by default so we can tell the difference between + // the default case and a user-specified tag. + tagName: null, + + /** + The WAI-ARIA role of the control represented by this view. For example, a + button may have a role of type 'button', or a pane may have a role of + type 'alertdialog'. This property is used by assistive software to help + visually challenged users navigate rich web applications. + + The full list of valid WAI-ARIA roles is available at: + http://www.w3.org/TR/wai-aria/roles#roles_categorization + + @property ariaRole + @type String + @default null + */ + ariaRole: null, + + /** + Standard CSS class names to apply to the view's outer element. This + property automatically inherits any class names defined by the view's + superclasses as well. + + @property classNames + @type Array + @default ['ember-view'] + */ + classNames: ['ember-view'], + + /** + A list of properties of the view to apply as class names. If the property + is a string value, the value of that string will be applied as a class + name. + + ```javascript + // Applies the 'high' class to the view element + Ember.View.create({ + classNameBindings: ['priority'] + priority: 'high' + }); + ``` + + If the value of the property is a Boolean, the name of that property is + added as a dasherized class name. + + ```javascript + // Applies the 'is-urgent' class to the view element + Ember.View.create({ + classNameBindings: ['isUrgent'] + isUrgent: true + }); + ``` + + If you would prefer to use a custom value instead of the dasherized + property name, you can pass a binding like this: + + ```javascript + // Applies the 'urgent' class to the view element + Ember.View.create({ + classNameBindings: ['isUrgent:urgent'] + isUrgent: true + }); + ``` + + This list of properties is inherited from the view's superclasses as well. + + @property classNameBindings + @type Array + @default [] + */ + classNameBindings: [], + + /** + A list of properties of the view to apply as attributes. If the property is + a string value, the value of that string will be applied as the attribute. + + ```javascript + // Applies the type attribute to the element + // with the value "button", like
    + Ember.View.create({ + attributeBindings: ['type'], + type: 'button' + }); + ``` + + If the value of the property is a Boolean, the name of that property is + added as an attribute. + + ```javascript + // Renders something like
    + Ember.View.create({ + attributeBindings: ['enabled'], + enabled: true + }); + ``` + + @property attributeBindings + */ + attributeBindings: [], + + // ....................................................... + // CORE DISPLAY METHODS + // + + /** + @private + + Setup a view, but do not finish waking it up. + - configure `childViews` + - register the view with the global views hash, which is used for event + dispatch + + @method init + */ + init: function() { + this.elementId = this.elementId || guidFor(this); + + this._super(); + + // setup child views. be sure to clone the child views array first + this._childViews = this._childViews.slice(); + + Ember.assert("Only arrays are allowed for 'classNameBindings'", Ember.typeOf(this.classNameBindings) === 'array'); + this.classNameBindings = Ember.A(this.classNameBindings.slice()); + + Ember.assert("Only arrays are allowed for 'classNames'", Ember.typeOf(this.classNames) === 'array'); + this.classNames = Ember.A(this.classNames.slice()); + + var viewController = get(this, 'viewController'); + if (viewController) { + viewController = get(viewController); + if (viewController) { + set(viewController, 'view', this); + } + } + }, + + appendChild: function(view, options) { + return this.currentState.appendChild(this, view, options); + }, + + /** + Removes the child view from the parent view. + + @method removeChild + @param {Ember.View} view + @return {Ember.View} receiver + */ + removeChild: function(view) { + // If we're destroying, the entire subtree will be + // freed, and the DOM will be handled separately, + // so no need to mess with childViews. + if (this.isDestroying) { return; } + + // update parent node + set(view, '_parentView', null); + + // remove view from childViews array. + var childViews = this._childViews; + + Ember.EnumerableUtils.removeObject(childViews, view); + + this.propertyDidChange('childViews'); // HUH?! what happened to will change? + + return this; + }, + + /** + Removes all children from the `parentView`. + + @method removeAllChildren + @return {Ember.View} receiver + */ + removeAllChildren: function() { + return this.mutateChildViews(function(view) { + this.removeChild(view); + }); + }, + + destroyAllChildren: function() { + return this.mutateChildViews(function(view) { + view.destroy(); + }); + }, + + /** + Removes the view from its `parentView`, if one is found. Otherwise + does nothing. + + @method removeFromParent + @return {Ember.View} receiver + */ + removeFromParent: function() { + var parent = this._parentView; + + // Remove DOM element from parent + this.remove(); + + if (parent) { parent.removeChild(this); } + return this; + }, + + /** + You must call `destroy` on a view to destroy the view (and all of its + child views). This will remove the view from any parent node, then make + sure that the DOM element managed by the view can be released by the + memory manager. + + @method willDestroy + */ + willDestroy: function() { + // calling this._super() will nuke computed properties and observers, + // so collect any information we need before calling super. + var childViews = this._childViews, + parent = this._parentView, + childLen, i; + + // destroy the element -- this will avoid each child view destroying + // the element over and over again... + if (!this.removedFromDOM) { this.destroyElement(); } + + childLen = childViews.length; + for (i=childLen-1; i>=0; i--) { + childViews[i].removedFromDOM = true; + } + + // remove from non-virtual parent view if viewName was specified + if (this.viewName) { + var nonVirtualParentView = get(this, 'parentView'); + if (nonVirtualParentView) { + set(nonVirtualParentView, this.viewName, null); + } + } + + // remove from parent if found. Don't call removeFromParent, + // as removeFromParent will try to remove the element from + // the DOM again. + if (parent) { parent.removeChild(this); } + + this.transitionTo('destroyed'); + + childLen = childViews.length; + for (i=childLen-1; i>=0; i--) { + childViews[i].destroy(); + } + + // next remove view from global hash + if (!this.isVirtual) delete Ember.View.views[get(this, 'elementId')]; + }, + + /** + Instantiates a view to be added to the childViews array during view + initialization. You generally will not call this method directly unless + you are overriding `createChildViews()`. Note that this method will + automatically configure the correct settings on the new view instance to + act as a child of the parent. + + @method createChildView + @param {Class} viewClass + @param {Hash} [attrs] Attributes to add + @return {Ember.View} new instance + */ + createChildView: function(view, attrs) { + if (view.isView && view._parentView === this) { return view; } + + if (Ember.CoreView.detect(view)) { + attrs = attrs || {}; + attrs._parentView = this; + attrs.templateData = attrs.templateData || get(this, 'templateData'); + + view = view.create(attrs); + + // don't set the property on a virtual view, as they are invisible to + // consumers of the view API + if (view.viewName) { set(get(this, 'concreteView'), view.viewName, view); } + } else { + Ember.assert('You must pass instance or subclass of View', view.isView); + + if (attrs) { + view.setProperties(attrs); + } + + if (!get(view, 'templateData')) { + set(view, 'templateData', get(this, 'templateData')); + } + + set(view, '_parentView', this); + } + + return view; + }, + + becameVisible: Ember.K, + becameHidden: Ember.K, + + /** + @private + + When the view's `isVisible` property changes, toggle the visibility + element of the actual DOM element. + + @method _isVisibleDidChange + */ + _isVisibleDidChange: Ember.observer(function() { + var $el = this.$(); + if (!$el) { return; } + + var isVisible = get(this, 'isVisible'); + + $el.toggle(isVisible); + + if (this._isAncestorHidden()) { return; } + + if (isVisible) { + this._notifyBecameVisible(); + } else { + this._notifyBecameHidden(); + } + }, 'isVisible'), + + _notifyBecameVisible: function() { + this.trigger('becameVisible'); + + this.forEachChildView(function(view) { + var isVisible = get(view, 'isVisible'); + + if (isVisible || isVisible === null) { + view._notifyBecameVisible(); + } + }); + }, + + _notifyBecameHidden: function() { + this.trigger('becameHidden'); + this.forEachChildView(function(view) { + var isVisible = get(view, 'isVisible'); + + if (isVisible || isVisible === null) { + view._notifyBecameHidden(); + } + }); + }, + + _isAncestorHidden: function() { + var parent = get(this, 'parentView'); + + while (parent) { + if (get(parent, 'isVisible') === false) { return true; } + + parent = get(parent, 'parentView'); + } + + return false; + }, + + clearBuffer: function() { + this.invokeRecursively(function(view) { + view.buffer = null; + }); + }, + + transitionTo: function(state, children) { + this.currentState = this.states[state]; + this.state = state; + + if (children !== false) { + this.forEachChildView(function(view) { + view.transitionTo(state); + }); + } + }, + + // ....................................................... + // EVENT HANDLING + // + + /** + @private + + Handle events from `Ember.EventDispatcher` + + @method handleEvent + @param eventName {String} + @param evt {Event} + */ + handleEvent: function(eventName, evt) { + return this.currentState.handleEvent(this, eventName, evt); + }, + + registerObserver: function(root, path, target, observer) { + Ember.addObserver(root, path, target, observer); + + this.one('willClearRender', function() { + Ember.removeObserver(root, path, target, observer); + }); + } + +}); + +/* + Describe how the specified actions should behave in the various + states that a view can exist in. Possible states: + + * preRender: when a view is first instantiated, and after its + element was destroyed, it is in the preRender state + * inBuffer: once a view has been rendered, but before it has + been inserted into the DOM, it is in the inBuffer state + * inDOM: once a view has been inserted into the DOM it is in + the inDOM state. A view spends the vast majority of its + existence in this state. + * destroyed: once a view has been destroyed (using the destroy + method), it is in this state. No further actions can be invoked + on a destroyed view. +*/ + + // in the destroyed state, everything is illegal + + // before rendering has begun, all legal manipulations are noops. + + // inside the buffer, legal manipulations are done on the buffer + + // once the view has been inserted into the DOM, legal manipulations + // are done on the DOM element. + +var DOMManager = { + prepend: function(view, html) { + view.$().prepend(html); + }, + + after: function(view, html) { + view.$().after(html); + }, + + html: function(view, html) { + view.$().html(html); + }, + + replace: function(view) { + var element = get(view, 'element'); + + set(view, 'element', null); + + view._insertElementLater(function() { + Ember.$(element).replaceWith(get(view, 'element')); + }); + }, + + remove: function(view) { + view.$().remove(); + }, + + empty: function(view) { + view.$().empty(); + } +}; + +Ember.View.reopen({ + domManager: DOMManager +}); + +Ember.View.reopenClass({ + + /** + @private + + Parse a path and return an object which holds the parsed properties. + + For example a path like "content.isEnabled:enabled:disabled" wil return the + following object: + + ```javascript + { + path: "content.isEnabled", + className: "enabled", + falsyClassName: "disabled", + classNames: ":enabled:disabled" + } + ``` + + @method _parsePropertyPath + @static + */ + _parsePropertyPath: function(path) { + var split = path.split(':'), + propertyPath = split[0], + classNames = "", + className, + falsyClassName; + + // check if the property is defined as prop:class or prop:trueClass:falseClass + if (split.length > 1) { + className = split[1]; + if (split.length === 3) { falsyClassName = split[2]; } + + classNames = ':' + className; + if (falsyClassName) { classNames += ":" + falsyClassName; } + } + + return { + path: propertyPath, + classNames: classNames, + className: (className === '') ? undefined : className, + falsyClassName: falsyClassName + }; + }, + + /** + @private + + Get the class name for a given value, based on the path, optional + `className` and optional `falsyClassName`. + + - if a `className` or `falsyClassName` has been specified: + - if the value is truthy and `className` has been specified, + `className` is returned + - if the value is falsy and `falsyClassName` has been specified, + `falsyClassName` is returned + - otherwise `null` is returned + - if the value is `true`, the dasherized last part of the supplied path + is returned + - if the value is not `false`, `undefined` or `null`, the `value` + is returned + - if none of the above rules apply, `null` is returned + + @method _classStringForValue + @param path + @param val + @param className + @param falsyClassName + @static + */ + _classStringForValue: function(path, val, className, falsyClassName) { + // When using the colon syntax, evaluate the truthiness or falsiness + // of the value to determine which className to return + if (className || falsyClassName) { + if (className && !!val) { + return className; + + } else if (falsyClassName && !val) { + return falsyClassName; + + } else { + return null; + } + + // If value is a Boolean and true, return the dasherized property + // name. + } else if (val === true) { + // Normalize property path to be suitable for use + // as a class name. For exaple, content.foo.barBaz + // becomes bar-baz. + var parts = path.split('.'); + return Ember.String.dasherize(parts[parts.length-1]); + + // If the value is not false, undefined, or null, return the current + // value of the property. + } else if (val !== false && val !== undefined && val !== null) { + return val; + + // Nothing to display. Return null so that the old class is removed + // but no new class is added. + } else { + return null; + } + } +}); + +/** + Global views hash + + @property views + @static + @type Hash +*/ +Ember.View.views = {}; + +// If someone overrides the child views computed property when +// defining their class, we want to be able to process the user's +// supplied childViews and then restore the original computed property +// at view initialization time. This happens in Ember.ContainerView's init +// method. +Ember.View.childViewsProperty = childViewsProperty; + +Ember.View.applyAttributeBindings = function(elem, name, value) { + var type = Ember.typeOf(value); + + // if this changes, also change the logic in ember-handlebars/lib/helpers/binding.js + if (name !== 'value' && (type === 'string' || (type === 'number' && !isNaN(value)))) { + if (value !== elem.attr(name)) { + elem.attr(name, value); + } + } else if (name === 'value' || type === 'boolean') { + if (value !== elem.prop(name)) { + // value and booleans should always be properties + elem.prop(name, value); + } + } else if (!value) { + elem.removeAttr(name); + } +}; + +Ember.View.states = states; + +})(); + + + +(function() { +/** +@module ember +@submodule ember-views +*/ + +var get = Ember.get, set = Ember.set; + +Ember.View.states._default = { + // appendChild is only legal while rendering the buffer. + appendChild: function() { + throw "You can't use appendChild outside of the rendering process"; + }, + + $: function() { + return undefined; + }, + + getElement: function() { + return null; + }, + + // Handle events from `Ember.EventDispatcher` + handleEvent: function() { + return true; // continue event propagation + }, + + destroyElement: function(view) { + set(view, 'element', null); + if (view._scheduledInsert) { + Ember.run.cancel(view._scheduledInsert); + view._scheduledInsert = null; + } + return view; + }, + + renderToBufferIfNeeded: function () { + return false; + }, + + rerender: Ember.K +}; + +})(); + + + +(function() { +/** +@module ember +@submodule ember-views +*/ + +var preRender = Ember.View.states.preRender = Ember.create(Ember.View.states._default); + +Ember.merge(preRender, { + // a view leaves the preRender state once its element has been + // created (createElement). + insertElement: function(view, fn) { + view.createElement(); + view.triggerRecursively('willInsertElement'); + // after createElement, the view will be in the hasElement state. + fn.call(view); + view.transitionTo('inDOM'); + view.triggerRecursively('didInsertElement'); + }, + + renderToBufferIfNeeded: function(view) { + return view.renderToBuffer(); + }, + + empty: Ember.K, + + setElement: function(view, value) { + if (value !== null) { + view.transitionTo('hasElement'); + } + return value; + } +}); + +})(); + + + +(function() { +/** +@module ember +@submodule ember-views +*/ + +var get = Ember.get, set = Ember.set, meta = Ember.meta; + +var inBuffer = Ember.View.states.inBuffer = Ember.create(Ember.View.states._default); + +Ember.merge(inBuffer, { + $: function(view, sel) { + // if we don't have an element yet, someone calling this.$() is + // trying to update an element that isn't in the DOM. Instead, + // rerender the view to allow the render method to reflect the + // changes. + view.rerender(); + return Ember.$(); + }, + + // when a view is rendered in a buffer, rerendering it simply + // replaces the existing buffer with a new one + rerender: function(view) { + throw new Ember.Error("Something you did caused a view to re-render after it rendered but before it was inserted into the DOM."); + }, + + // when a view is rendered in a buffer, appending a child + // view will render that view and append the resulting + // buffer into its buffer. + appendChild: function(view, childView, options) { + var buffer = view.buffer; + + childView = view.createChildView(childView, options); + view._childViews.push(childView); + + childView.renderToBuffer(buffer); + + view.propertyDidChange('childViews'); + + return childView; + }, + + // when a view is rendered in a buffer, destroying the + // element will simply destroy the buffer and put the + // state back into the preRender state. + destroyElement: function(view) { + view.clearBuffer(); + view._notifyWillDestroyElement(); + view.transitionTo('preRender'); + + return view; + }, + + empty: function() { + Ember.assert("Emptying a view in the inBuffer state is not allowed and should not happen under normal circumstances. Most likely there is a bug in your application. This may be due to excessive property change notifications."); + }, + + renderToBufferIfNeeded: function (view) { + return view.buffer; + }, + + // It should be impossible for a rendered view to be scheduled for + // insertion. + insertElement: function() { + throw "You can't insert an element that has already been rendered"; + }, + + setElement: function(view, value) { + if (value === null) { + view.transitionTo('preRender'); + } else { + view.clearBuffer(); + view.transitionTo('hasElement'); + } + + return value; + } +}); + + +})(); + + + +(function() { +/** +@module ember +@submodule ember-views +*/ + +var get = Ember.get, set = Ember.set, meta = Ember.meta; + +var hasElement = Ember.View.states.hasElement = Ember.create(Ember.View.states._default); + +Ember.merge(hasElement, { + $: function(view, sel) { + var elem = get(view, 'element'); + return sel ? Ember.$(sel, elem) : Ember.$(elem); + }, + + getElement: function(view) { + var parent = get(view, 'parentView'); + if (parent) { parent = get(parent, 'element'); } + if (parent) { return view.findElementInParentElement(parent); } + return Ember.$("#" + get(view, 'elementId'))[0]; + }, + + setElement: function(view, value) { + if (value === null) { + view.transitionTo('preRender'); + } else { + throw "You cannot set an element to a non-null value when the element is already in the DOM."; + } + + return value; + }, + + // once the view has been inserted into the DOM, rerendering is + // deferred to allow bindings to synchronize. + rerender: function(view) { + view.triggerRecursively('willClearRender'); + + view.clearRenderedChildren(); + + view.domManager.replace(view); + return view; + }, + + // once the view is already in the DOM, destroying it removes it + // from the DOM, nukes its element, and puts it back into the + // preRender state if inDOM. + + destroyElement: function(view) { + view._notifyWillDestroyElement(); + view.domManager.remove(view); + set(view, 'element', null); + if (view._scheduledInsert) { + Ember.run.cancel(view._scheduledInsert); + view._scheduledInsert = null; + } + return view; + }, + + empty: function(view) { + var _childViews = view._childViews, len, idx; + if (_childViews) { + len = _childViews.length; + for (idx = 0; idx < len; idx++) { + _childViews[idx]._notifyWillDestroyElement(); + } + } + view.domManager.empty(view); + }, + + // Handle events from `Ember.EventDispatcher` + handleEvent: function(view, eventName, evt) { + if (view.has(eventName)) { + // Handler should be able to re-dispatch events, so we don't + // preventDefault or stopPropagation. + return view.trigger(eventName, evt); + } else { + return true; // continue event propagation + } + } +}); + +var inDOM = Ember.View.states.inDOM = Ember.create(hasElement); + +Ember.merge(inDOM, { + insertElement: function(view, fn) { + throw "You can't insert an element into the DOM that has already been inserted"; + } +}); + +})(); + + + +(function() { +/** +@module ember +@submodule ember-views +*/ + +var destroyedError = "You can't call %@ on a destroyed view", fmt = Ember.String.fmt; + +var destroyed = Ember.View.states.destroyed = Ember.create(Ember.View.states._default); + +Ember.merge(destroyed, { + appendChild: function() { + throw fmt(destroyedError, ['appendChild']); + }, + rerender: function() { + throw fmt(destroyedError, ['rerender']); + }, + destroyElement: function() { + throw fmt(destroyedError, ['destroyElement']); + }, + empty: function() { + throw fmt(destroyedError, ['empty']); + }, + + setElement: function() { + throw fmt(destroyedError, ["set('element', ...)"]); + }, + + renderToBufferIfNeeded: function() { + throw fmt(destroyedError, ["renderToBufferIfNeeded"]); + }, + + // Since element insertion is scheduled, don't do anything if + // the view has been destroyed between scheduling and execution + insertElement: Ember.K +}); + + +})(); + + + +(function() { +Ember.View.cloneStates = function(from) { + var into = {}; + + into._default = {}; + into.preRender = Ember.create(into._default); + into.destroyed = Ember.create(into._default); + into.inBuffer = Ember.create(into._default); + into.hasElement = Ember.create(into._default); + into.inDOM = Ember.create(into.hasElement); + + var viewState; + + for (var stateName in from) { + if (!from.hasOwnProperty(stateName)) { continue; } + Ember.merge(into[stateName], from[stateName]); + } + + return into; +}; + +})(); + + + +(function() { +var states = Ember.View.cloneStates(Ember.View.states); + +/** +@module ember +@submodule ember-views +*/ + +var get = Ember.get, set = Ember.set, meta = Ember.meta; +var forEach = Ember.EnumerableUtils.forEach; + +/** + A `ContainerView` is an `Ember.View` subclass that implements `Ember.MutableArray` + allowing programatic management of its child views. + + ## Setting Initial Child Views + + The initial array of child views can be set in one of two ways. You can + provide a `childViews` property at creation time that contains instance of + `Ember.View`: + + ```javascript + aContainer = Ember.ContainerView.create({ + childViews: [Ember.View.create(), Ember.View.create()] + }); + ``` + + You can also provide a list of property names whose values are instances of + `Ember.View`: + + ```javascript + aContainer = Ember.ContainerView.create({ + childViews: ['aView', 'bView', 'cView'], + aView: Ember.View.create(), + bView: Ember.View.create(), + cView: Ember.View.create() + }); + ``` + + The two strategies can be combined: + + ```javascript + aContainer = Ember.ContainerView.create({ + childViews: ['aView', Ember.View.create()], + aView: Ember.View.create() + }); + ``` + + Each child view's rendering will be inserted into the container's rendered + HTML in the same order as its position in the `childViews` property. + + ## Adding and Removing Child Views + + The container view implements `Ember.MutableArray` allowing programatic management of its child views. + + To remove a view, pass that view into a `removeObject` call on the container view. + + Given an empty `` the following code + + ```javascript + aContainer = Ember.ContainerView.create({ + classNames: ['the-container'], + childViews: ['aView', 'bView'], + aView: Ember.View.create({ + template: Ember.Handlebars.compile("A") + }), + bView: Ember.View.create({ + template: Ember.Handlebars.compile("B") + }) + }); + + aContainer.appendTo('body'); + ``` + + Results in the HTML + + ```html +
    +
    A
    +
    B
    +
    + ``` + + Removing a view + + ```javascript + aContainer.toArray(); // [aContainer.aView, aContainer.bView] + aContainer.removeObject(aContainer.get('bView')); + aContainer.toArray(); // [aContainer.aView] + ``` + + Will result in the following HTML + + ```html +
    +
    A
    +
    + ``` + + Similarly, adding a child view is accomplished by adding `Ember.View` instances to the + container view. + + Given an empty `` the following code + + ```javascript + aContainer = Ember.ContainerView.create({ + classNames: ['the-container'], + childViews: ['aView', 'bView'], + aView: Ember.View.create({ + template: Ember.Handlebars.compile("A") + }), + bView: Ember.View.create({ + template: Ember.Handlebars.compile("B") + }) + }); + + aContainer.appendTo('body'); + ``` + + Results in the HTML + + ```html +
    +
    A
    +
    B
    +
    + ``` + + Adding a view + + ```javascript + AnotherViewClass = Ember.View.extend({ + template: Ember.Handlebars.compile("Another view") + }); + + aContainer.toArray(); // [aContainer.aView, aContainer.bView] + aContainer.pushObject(AnotherViewClass.create()); + aContainer.toArray(); // [aContainer.aView, aContainer.bView, ] + ``` + + Will result in the following HTML + + ```html +
    +
    A
    +
    B
    +
    Another view
    +
    + ``` + + ## Templates and Layout + + A `template`, `templateName`, `defaultTemplate`, `layout`, `layoutName` or + `defaultLayout` property on a container view will not result in the template + or layout being rendered. The HTML contents of a `Ember.ContainerView`'s DOM + representation will only be the rendered HTML of its child views. + + ## Binding a View to Display + + If you would like to display a single view in your ContainerView, you can set + its `currentView` property. When the `currentView` property is set to a view + instance, it will be added to the ContainerView. If the `currentView` property + is later changed to a different view, the new view will replace the old view. + If `currentView` is set to `null`, the last `currentView` will be removed. + + This functionality is useful for cases where you want to bind the display of + a ContainerView to a controller or state manager. For example, you can bind + the `currentView` of a container to a controller like this: + + ```javascript + App.appController = Ember.Object.create({ + view: Ember.View.create({ + templateName: 'person_template' + }) + }); + ``` + + ```handlebars + {{view Ember.ContainerView currentViewBinding="App.appController.view"}} + ``` + + @class ContainerView + @namespace Ember + @extends Ember.View +*/ +Ember.ContainerView = Ember.View.extend(Ember.MutableArray, { + states: states, + + init: function() { + this._super(); + + var childViews = get(this, 'childViews'); + + // redefine view's childViews property that was obliterated + Ember.defineProperty(this, 'childViews', Ember.View.childViewsProperty); + + var _childViews = this._childViews; + + forEach(childViews, function(viewName, idx) { + var view; + + if ('string' === typeof viewName) { + view = get(this, viewName); + view = this.createChildView(view); + set(this, viewName, view); + } else { + view = this.createChildView(viewName); + } + + _childViews[idx] = view; + }, this); + + var currentView = get(this, 'currentView'); + if (currentView) { + _childViews.push(this.createChildView(currentView)); + } + }, + + replace: function(idx, removedCount, addedViews) { + var addedCount = addedViews ? get(addedViews, 'length') : 0; + + this.arrayContentWillChange(idx, removedCount, addedCount); + this.childViewsWillChange(this._childViews, idx, removedCount); + + if (addedCount === 0) { + this._childViews.splice(idx, removedCount) ; + } else { + var args = [idx, removedCount].concat(addedViews); + this._childViews.splice.apply(this._childViews, args); + } + + this.arrayContentDidChange(idx, removedCount, addedCount); + this.childViewsDidChange(this._childViews, idx, removedCount, addedCount); + + return this; + }, + + objectAt: function(idx) { + return this._childViews[idx]; + }, + + length: Ember.computed(function () { + return this._childViews.length; + }), + + /** + @private + + Instructs each child view to render to the passed render buffer. + + @method render + @param {Ember.RenderBuffer} buffer the buffer to render to + */ + render: function(buffer) { + this.forEachChildView(function(view) { + view.renderToBuffer(buffer); + }); + }, + + instrumentName: 'render.container', + + /** + @private + + When a child view is removed, destroy its element so that + it is removed from the DOM. + + The array observer that triggers this action is set up in the + `renderToBuffer` method. + + @method childViewsWillChange + @param {Ember.Array} views the child views array before mutation + @param {Number} start the start position of the mutation + @param {Number} removed the number of child views removed + **/ + childViewsWillChange: function(views, start, removed) { + this.propertyWillChange('childViews'); + + if (removed > 0) { + var changedViews = views.slice(start, start+removed); + // transition to preRender before clearing parentView + this.currentState.childViewsWillChange(this, views, start, removed); + this.initializeViews(changedViews, null, null); + } + }, + + removeChild: function(child) { + this.removeObject(child); + return this; + }, + + /** + @private + + When a child view is added, make sure the DOM gets updated appropriately. + + If the view has already rendered an element, we tell the child view to + create an element and insert it into the DOM. If the enclosing container + view has already written to a buffer, but not yet converted that buffer + into an element, we insert the string representation of the child into the + appropriate place in the buffer. + + @method childViewsDidChange + @param {Ember.Array} views the array of child views afte the mutation has occurred + @param {Number} start the start position of the mutation + @param {Number} removed the number of child views removed + @param {Number} the number of child views added + */ + childViewsDidChange: function(views, start, removed, added) { + if (added > 0) { + var changedViews = views.slice(start, start+added); + this.initializeViews(changedViews, this, get(this, 'templateData')); + this.currentState.childViewsDidChange(this, views, start, added); + } + this.propertyDidChange('childViews'); + }, + + initializeViews: function(views, parentView, templateData) { + forEach(views, function(view) { + set(view, '_parentView', parentView); + + if (!get(view, 'templateData')) { + set(view, 'templateData', templateData); + } + }); + }, + + currentView: null, + + _currentViewWillChange: Ember.beforeObserver(function() { + var currentView = get(this, 'currentView'); + if (currentView) { + currentView.destroy(); + } + }, 'currentView'), + + _currentViewDidChange: Ember.observer(function() { + var currentView = get(this, 'currentView'); + if (currentView) { + this.pushObject(currentView); + } + }, 'currentView'), + + _ensureChildrenAreInDOM: function () { + this.currentState.ensureChildrenAreInDOM(this); + } +}); + +Ember.merge(states._default, { + childViewsWillChange: Ember.K, + childViewsDidChange: Ember.K, + ensureChildrenAreInDOM: Ember.K +}); + +Ember.merge(states.inBuffer, { + childViewsDidChange: function(parentView, views, start, added) { + throw new Error('You cannot modify child views while in the inBuffer state'); + } +}); + +Ember.merge(states.hasElement, { + childViewsWillChange: function(view, views, start, removed) { + for (var i=start; i` and the following code: + + ```javascript + someItemsView = Ember.CollectionView.create({ + classNames: ['a-collection'], + content: ['A','B','C'], + itemViewClass: Ember.View.extend({ + template: Ember.Handlebars.compile("the letter: {{view.content}}") + }) + }); + + someItemsView.appendTo('body'); + ``` + + Will result in the following HTML structure + + ```html +
    +
    the letter: A
    +
    the letter: B
    +
    the letter: C
    +
    + ``` + + ## Automatic matching of parent/child tagNames + + Setting the `tagName` property of a `CollectionView` to any of + "ul", "ol", "table", "thead", "tbody", "tfoot", "tr", or "select" will result + in the item views receiving an appropriately matched `tagName` property. + + Given an empty `` and the following code: + + ```javascript + anUndorderedListView = Ember.CollectionView.create({ + tagName: 'ul', + content: ['A','B','C'], + itemViewClass: Ember.View.extend({ + template: Ember.Handlebars.compile("the letter: {{view.content}}") + }) + }); + + anUndorderedListView.appendTo('body'); + ``` + + Will result in the following HTML structure + + ```html +
      +
    • the letter: A
      • +
    • the letter: B
      • +
    • the letter: C
      • +
    + ``` + + Additional `tagName` pairs can be provided by adding to + `Ember.CollectionView.CONTAINER_MAP ` + + ```javascript + Ember.CollectionView.CONTAINER_MAP['article'] = 'section' + ``` + + ## Programatic creation of child views + + For cases where additional customization beyond the use of a single + `itemViewClass` or `tagName` matching is required CollectionView's + `createChildView` method can be overidden: + + ```javascript + CustomCollectionView = Ember.CollectionView.extend({ + createChildView: function(viewClass, attrs) { + if (attrs.content.kind == 'album') { + viewClass = App.AlbumView; + } else { + viewClass = App.SongView; + } + this._super(viewClass, attrs); + } + }); + ``` + + ## Empty View + + You can provide an `Ember.View` subclass to the `Ember.CollectionView` + instance as its `emptyView` property. If the `content` property of a + `CollectionView` is set to `null` or an empty array, an instance of this view + will be the `CollectionView`s only child. + + ```javascript + aListWithNothing = Ember.CollectionView.create({ + classNames: ['nothing'] + content: null, + emptyView: Ember.View.extend({ + template: Ember.Handlebars.compile("The collection is empty") + }) + }); + + aListWithNothing.appendTo('body'); + ``` + + Will result in the following HTML structure + + ```html +
    +
    + The collection is empty +
    +
    + ``` + + ## Adding and Removing items + + The `childViews` property of a `CollectionView` should not be directly + manipulated. Instead, add, remove, replace items from its `content` property. + This will trigger appropriate changes to its rendered HTML. + + ## Use in templates via the `{{collection}}` `Ember.Handlebars` helper + + `Ember.Handlebars` provides a helper specifically for adding + `CollectionView`s to templates. See `Ember.Handlebars.collection` for more + details + + @class CollectionView + @namespace Ember + @extends Ember.ContainerView + @since Ember 0.9 +*/ +Ember.CollectionView = Ember.ContainerView.extend( +/** @scope Ember.CollectionView.prototype */ { + + /** + A list of items to be displayed by the `Ember.CollectionView`. + + @property content + @type Ember.Array + @default null + */ + content: null, + + /** + @private + + This provides metadata about what kind of empty view class this + collection would like if it is being instantiated from another + system (like Handlebars) + + @property emptyViewClass + */ + emptyViewClass: Ember.View, + + /** + An optional view to display if content is set to an empty array. + + @property emptyView + @type Ember.View + @default null + */ + emptyView: null, + + /** + @property itemViewClass + @type Ember.View + @default Ember.View + */ + itemViewClass: Ember.View, + + init: function() { + var ret = this._super(); + this._contentDidChange(); + return ret; + }, + + _contentWillChange: Ember.beforeObserver(function() { + var content = this.get('content'); + + if (content) { content.removeArrayObserver(this); } + var len = content ? get(content, 'length') : 0; + this.arrayWillChange(content, 0, len); + }, 'content'), + + /** + @private + + Check to make sure that the content has changed, and if so, + update the children directly. This is always scheduled + asynchronously, to allow the element to be created before + bindings have synchronized and vice versa. + + @method _contentDidChange + */ + _contentDidChange: Ember.observer(function() { + var content = get(this, 'content'); + + if (content) { + Ember.assert(fmt("an Ember.CollectionView's content must implement Ember.Array. You passed %@", [content]), Ember.Array.detect(content)); + content.addArrayObserver(this); + } + + var len = content ? get(content, 'length') : 0; + this.arrayDidChange(content, 0, null, len); + }, 'content'), + + willDestroy: function() { + var content = get(this, 'content'); + if (content) { content.removeArrayObserver(this); } + + this._super(); + + if (this._createdEmptyView) { + this._createdEmptyView.destroy(); + } + }, + + arrayWillChange: function(content, start, removedCount) { + // If the contents were empty before and this template collection has an + // empty view remove it now. + var emptyView = get(this, 'emptyView'); + if (emptyView && emptyView instanceof Ember.View) { + emptyView.removeFromParent(); + } + + // Loop through child views that correspond with the removed items. + // Note that we loop from the end of the array to the beginning because + // we are mutating it as we go. + var childViews = this._childViews, childView, idx, len; + + len = this._childViews.length; + + var removingAll = removedCount === len; + + if (removingAll) { + this.currentState.empty(this); + } + + for (idx = start + removedCount - 1; idx >= start; idx--) { + childView = childViews[idx]; + if (removingAll) { childView.removedFromDOM = true; } + childView.destroy(); + } + }, + + /** + Called when a mutation to the underlying content array occurs. + + This method will replay that mutation against the views that compose the + `Ember.CollectionView`, ensuring that the view reflects the model. + + This array observer is added in `contentDidChange`. + + @method arrayDidChange + @param {Array} addedObjects the objects that were added to the content + @param {Array} removedObjects the objects that were removed from the content + @param {Number} changeIndex the index at which the changes occurred + */ + arrayDidChange: function(content, start, removed, added) { + var itemViewClass = get(this, 'itemViewClass'), + addedViews = [], view, item, idx, len, itemTagName; + + if ('string' === typeof itemViewClass) { + itemViewClass = get(itemViewClass); + } + + Ember.assert(fmt("itemViewClass must be a subclass of Ember.View, not %@", [itemViewClass]), Ember.View.detect(itemViewClass)); + + len = content ? get(content, 'length') : 0; + if (len) { + for (idx = start; idx < start+added; idx++) { + item = content.objectAt(idx); + + view = this.createChildView(itemViewClass, { + content: item, + contentIndex: idx + }); + + addedViews.push(view); + } + } else { + var emptyView = get(this, 'emptyView'); + if (!emptyView) { return; } + + var isClass = Ember.CoreView.detect(emptyView); + + emptyView = this.createChildView(emptyView); + addedViews.push(emptyView); + set(this, 'emptyView', emptyView); + + if (isClass) { this._createdEmptyView = emptyView; } + } + this.replace(start, 0, addedViews); + }, + + createChildView: function(view, attrs) { + view = this._super(view, attrs); + + var itemTagName = get(view, 'tagName'); + var tagName = (itemTagName === null || itemTagName === undefined) ? Ember.CollectionView.CONTAINER_MAP[get(this, 'tagName')] : itemTagName; + + set(view, 'tagName', tagName); + + return view; + } +}); + +/** + A map of parent tags to their default child tags. You can add + additional parent tags if you want collection views that use + a particular parent tag to default to a child tag. + + @property CONTAINER_MAP + @type Hash + @static + @final +*/ +Ember.CollectionView.CONTAINER_MAP = { + ul: 'li', + ol: 'li', + table: 'tr', + thead: 'tr', + tbody: 'tr', + tfoot: 'tr', + tr: 'td', + select: 'option' +}; + +})(); + + + +(function() { + +})(); + + + +(function() { +/*globals jQuery*/ +/** +Ember Views + +@module ember +@submodule ember-views +@requires ember-runtime +@main ember-views +*/ + +})(); + +(function() { +define("metamorph", + [], + function() { + "use strict"; + // ========================================================================== + // Project: metamorph + // Copyright: ©2011 My Company Inc. All rights reserved. + // ========================================================================== + + var K = function(){}, + guid = 0, + document = window.document, + + // Feature-detect the W3C range API, the extended check is for IE9 which only partially supports ranges + supportsRange = ('createRange' in document) && (typeof Range !== 'undefined') && Range.prototype.createContextualFragment, + + // Internet Explorer prior to 9 does not allow setting innerHTML if the first element + // is a "zero-scope" element. This problem can be worked around by making + // the first node an invisible text node. We, like Modernizr, use ­ + needsShy = (function(){ + var testEl = document.createElement('div'); + testEl.innerHTML = "
    "; + testEl.firstChild.innerHTML = ""; + return testEl.firstChild.innerHTML === ''; + })(), + + + // IE 8 (and likely earlier) likes to move whitespace preceeding + // a script tag to appear after it. This means that we can + // accidentally remove whitespace when updating a morph. + movesWhitespace = (function() { + var testEl = document.createElement('div'); + testEl.innerHTML = "Test: Value"; + return testEl.childNodes[0].nodeValue === 'Test:' && + testEl.childNodes[2].nodeValue === ' Value'; + })(); + + // Constructor that supports either Metamorph('foo') or new + // Metamorph('foo'); + // + // Takes a string of HTML as the argument. + + var Metamorph = function(html) { + var self; + + if (this instanceof Metamorph) { + self = this; + } else { + self = new K(); + } + + self.innerHTML = html; + var myGuid = 'metamorph-'+(guid++); + self.start = myGuid + '-start'; + self.end = myGuid + '-end'; + + return self; + }; + + K.prototype = Metamorph.prototype; + + var rangeFor, htmlFunc, removeFunc, outerHTMLFunc, appendToFunc, afterFunc, prependFunc, startTagFunc, endTagFunc; + + outerHTMLFunc = function() { + return this.startTag() + this.innerHTML + this.endTag(); + }; + + startTagFunc = function() { + /* + * We replace chevron by its hex code in order to prevent escaping problems. + * Check this thread for more explaination: + * http://stackoverflow.com/questions/8231048/why-use-x3c-instead-of-when-generating-html-from-javascript + */ + return "hi"; + * div.firstChild.firstChild.tagName //=> "" + * + * If our script markers are inside such a node, we need to find that + * node and use *it* as the marker. + **/ + var realNode = function(start) { + while (start.parentNode.tagName === "") { + start = start.parentNode; + } + + return start; + }; + + /** + * When automatically adding a tbody, Internet Explorer inserts the + * tbody immediately before the first . Other browsers create it + * before the first node, no matter what. + * + * This means the the following code: + * + * div = document.createElement("div"); + * div.innerHTML = "
    hi
    + * + * Generates the following DOM in IE: + * + * + div + * + table + * - script id='first' + * + tbody + * + tr + * + td + * - "hi" + * - script id='last' + * + * Which means that the two script tags, even though they were + * inserted at the same point in the hierarchy in the original + * HTML, now have different parents. + * + * This code reparents the first script tag by making it the tbody's + * first child. + **/ + var fixParentage = function(start, end) { + if (start.parentNode !== end.parentNode) { + end.parentNode.insertBefore(start, end.parentNode.firstChild); + } + }; + + htmlFunc = function(html, outerToo) { + // get the real starting node. see realNode for details. + var start = realNode(document.getElementById(this.start)); + var end = document.getElementById(this.end); + var parentNode = end.parentNode; + var node, nextSibling, last; + + // make sure that the start and end nodes share the same + // parent. If not, fix it. + fixParentage(start, end); + + // remove all of the nodes after the starting placeholder and + // before the ending placeholder. + node = start.nextSibling; + while (node) { + nextSibling = node.nextSibling; + last = node === end; + + // if this is the last node, and we want to remove it as well, + // set the `end` node to the next sibling. This is because + // for the rest of the function, we insert the new nodes + // before the end (note that insertBefore(node, null) is + // the same as appendChild(node)). + // + // if we do not want to remove it, just break. + if (last) { + if (outerToo) { end = node.nextSibling; } else { break; } + } + + node.parentNode.removeChild(node); + + // if this is the last node and we didn't break before + // (because we wanted to remove the outer nodes), break + // now. + if (last) { break; } + + node = nextSibling; + } + + // get the first node for the HTML string, even in cases like + // tables and lists where a simple innerHTML on a div would + // swallow some of the content. + node = firstNodeFor(start.parentNode, html); + + // copy the nodes for the HTML between the starting and ending + // placeholder. + while (node) { + nextSibling = node.nextSibling; + parentNode.insertBefore(node, end); + node = nextSibling; + } + }; + + // remove the nodes in the DOM representing this metamorph. + // + // this includes the starting and ending placeholders. + removeFunc = function() { + var start = realNode(document.getElementById(this.start)); + var end = document.getElementById(this.end); + + this.html(''); + start.parentNode.removeChild(start); + end.parentNode.removeChild(end); + }; + + appendToFunc = function(parentNode) { + var node = firstNodeFor(parentNode, this.outerHTML()); + var nextSibling; + + while (node) { + nextSibling = node.nextSibling; + parentNode.appendChild(node); + node = nextSibling; + } + }; + + afterFunc = function(html) { + // get the real starting node. see realNode for details. + var end = document.getElementById(this.end); + var insertBefore = end.nextSibling; + var parentNode = end.parentNode; + var nextSibling; + var node; + + // get the first node for the HTML string, even in cases like + // tables and lists where a simple innerHTML on a div would + // swallow some of the content. + node = firstNodeFor(parentNode, html); + + // copy the nodes for the HTML between the starting and ending + // placeholder. + while (node) { + nextSibling = node.nextSibling; + parentNode.insertBefore(node, insertBefore); + node = nextSibling; + } + }; + + prependFunc = function(html) { + var start = document.getElementById(this.start); + var parentNode = start.parentNode; + var nextSibling; + var node; + + node = firstNodeFor(parentNode, html); + var insertBefore = start.nextSibling; + + while (node) { + nextSibling = node.nextSibling; + parentNode.insertBefore(node, insertBefore); + node = nextSibling; + } + }; + } + + Metamorph.prototype.html = function(html) { + this.checkRemoved(); + if (html === undefined) { return this.innerHTML; } + + htmlFunc.call(this, html); + + this.innerHTML = html; + }; + + Metamorph.prototype.replaceWith = function(html) { + this.checkRemoved(); + htmlFunc.call(this, html, true); + }; + + Metamorph.prototype.remove = removeFunc; + Metamorph.prototype.outerHTML = outerHTMLFunc; + Metamorph.prototype.appendTo = appendToFunc; + Metamorph.prototype.after = afterFunc; + Metamorph.prototype.prepend = prependFunc; + Metamorph.prototype.startTag = startTagFunc; + Metamorph.prototype.endTag = endTagFunc; + + Metamorph.prototype.isRemoved = function() { + var before = document.getElementById(this.start); + var after = document.getElementById(this.end); + + return !before || !after; + }; + + Metamorph.prototype.checkRemoved = function() { + if (this.isRemoved()) { + throw new Error("Cannot perform operations on a Metamorph that is not in the DOM."); + } + }; + + return Metamorph; + }); + +})(); + +(function() { +/** +@module ember +@submodule ember-handlebars +*/ + +// Eliminate dependency on any Ember to simplify precompilation workflow +var objectCreate = Object.create || function(parent) { + function F() {} + F.prototype = parent; + return new F(); +}; + +var Handlebars = this.Handlebars || Ember.imports.Handlebars; +Ember.assert("Ember Handlebars requires Handlebars 1.0.rc.2 or greater", Handlebars && Handlebars.VERSION.match(/^1\.0\.rc\.[23456789]+/)); + +/** + Prepares the Handlebars templating library for use inside Ember's view + system. + + The `Ember.Handlebars` object is the standard Handlebars library, extended to + use Ember's `get()` method instead of direct property access, which allows + computed properties to be used inside templates. + + To create an `Ember.Handlebars` template, call `Ember.Handlebars.compile()`. + This will return a function that can be used by `Ember.View` for rendering. + + @class Handlebars + @namespace Ember +*/ +Ember.Handlebars = objectCreate(Handlebars); + +/** +@class helpers +@namespace Ember.Handlebars +*/ +Ember.Handlebars.helpers = objectCreate(Handlebars.helpers); + +/** + Override the the opcode compiler and JavaScript compiler for Handlebars. + + @class Compiler + @namespace Ember.Handlebars + @private + @constructor +*/ +Ember.Handlebars.Compiler = function() {}; + +// Handlebars.Compiler doesn't exist in runtime-only +if (Handlebars.Compiler) { + Ember.Handlebars.Compiler.prototype = objectCreate(Handlebars.Compiler.prototype); +} + +Ember.Handlebars.Compiler.prototype.compiler = Ember.Handlebars.Compiler; + +/** + @class JavaScriptCompiler + @namespace Ember.Handlebars + @private + @constructor +*/ +Ember.Handlebars.JavaScriptCompiler = function() {}; + +// Handlebars.JavaScriptCompiler doesn't exist in runtime-only +if (Handlebars.JavaScriptCompiler) { + Ember.Handlebars.JavaScriptCompiler.prototype = objectCreate(Handlebars.JavaScriptCompiler.prototype); + Ember.Handlebars.JavaScriptCompiler.prototype.compiler = Ember.Handlebars.JavaScriptCompiler; +} + + +Ember.Handlebars.JavaScriptCompiler.prototype.namespace = "Ember.Handlebars"; + + +Ember.Handlebars.JavaScriptCompiler.prototype.initializeBuffer = function() { + return "''"; +}; + +/** + @private + + Override the default buffer for Ember Handlebars. By default, Handlebars + creates an empty String at the beginning of each invocation and appends to + it. Ember's Handlebars overrides this to append to a single shared buffer. + + @method appendToBuffer + @param string {String} +*/ +Ember.Handlebars.JavaScriptCompiler.prototype.appendToBuffer = function(string) { + return "data.buffer.push("+string+");"; +}; + +var prefix = "ember" + (+new Date()), incr = 1; + +/** + @private + + Rewrite simple mustaches from `{{foo}}` to `{{bind "foo"}}`. This means that + all simple mustaches in Ember's Handlebars will also set up an observer to + keep the DOM up to date when the underlying property changes. + + @method mustache + @for Ember.Handlebars.Compiler + @param mustache +*/ +Ember.Handlebars.Compiler.prototype.mustache = function(mustache) { + if (mustache.isHelper && mustache.id.string === 'control') { + mustache.hash = mustache.hash || new Handlebars.AST.HashNode([]); + mustache.hash.pairs.push(["controlID", new Handlebars.AST.StringNode(prefix + incr++)]); + } else if (mustache.params.length || mustache.hash) { + // no changes required + } else { + var id = new Handlebars.AST.IdNode(['_triageMustache']); + + // Update the mustache node to include a hash value indicating whether the original node + // was escaped. This will allow us to properly escape values when the underlying value + // changes and we need to re-render the value. + if(!mustache.escaped) { + mustache.hash = mustache.hash || new Handlebars.AST.HashNode([]); + mustache.hash.pairs.push(["unescaped", new Handlebars.AST.StringNode("true")]); + } + mustache = new Handlebars.AST.MustacheNode([id].concat([mustache.id]), mustache.hash, !mustache.escaped); + } + + return Handlebars.Compiler.prototype.mustache.call(this, mustache); +}; + +/** + Used for precompilation of Ember Handlebars templates. This will not be used + during normal app execution. + + @method precompile + @for Ember.Handlebars + @static + @param {String} string The template to precompile +*/ +Ember.Handlebars.precompile = function(string) { + var ast = Handlebars.parse(string); + + var options = { + knownHelpers: { + action: true, + unbound: true, + bindAttr: true, + template: true, + view: true, + _triageMustache: true + }, + data: true, + stringParams: true + }; + + var environment = new Ember.Handlebars.Compiler().compile(ast, options); + return new Ember.Handlebars.JavaScriptCompiler().compile(environment, options, undefined, true); +}; + +// We don't support this for Handlebars runtime-only +if (Handlebars.compile) { + /** + The entry point for Ember Handlebars. This replaces the default + `Handlebars.compile` and turns on template-local data and String + parameters. + + @method compile + @for Ember.Handlebars + @static + @param {String} string The template to compile + @return {Function} + */ + Ember.Handlebars.compile = function(string) { + var ast = Handlebars.parse(string); + var options = { data: true, stringParams: true }; + var environment = new Ember.Handlebars.Compiler().compile(ast, options); + var templateSpec = new Ember.Handlebars.JavaScriptCompiler().compile(environment, options, undefined, true); + + return Ember.Handlebars.template(templateSpec); + }; +} + + +})(); + +(function() { +var slice = Array.prototype.slice; + +/** + @private + + If a path starts with a reserved keyword, returns the root + that should be used. + + @method normalizePath + @for Ember + @param root {Object} + @param path {String} + @param data {Hash} +*/ +var normalizePath = Ember.Handlebars.normalizePath = function(root, path, data) { + var keywords = (data && data.keywords) || {}, + keyword, isKeyword; + + // Get the first segment of the path. For example, if the + // path is "foo.bar.baz", returns "foo". + keyword = path.split('.', 1)[0]; + + // Test to see if the first path is a keyword that has been + // passed along in the view's data hash. If so, we will treat + // that object as the new root. + if (keywords.hasOwnProperty(keyword)) { + // Look up the value in the template's data hash. + root = keywords[keyword]; + isKeyword = true; + + // Handle cases where the entire path is the reserved + // word. In that case, return the object itself. + if (path === keyword) { + path = ''; + } else { + // Strip the keyword from the path and look up + // the remainder from the newly found root. + path = path.substr(keyword.length+1); + } + } + + return { root: root, path: path, isKeyword: isKeyword }; +}; + + +/** + Lookup both on root and on window. If the path starts with + a keyword, the corresponding object will be looked up in the + template's data hash and used to resolve the path. + + @method get + @for Ember.Handlebars + @param {Object} root The object to look up the property on + @param {String} path The path to be lookedup + @param {Object} options The template's option hash +*/ +var handlebarsGet = Ember.Handlebars.get = function(root, path, options) { + var data = options && options.data, + normalizedPath = normalizePath(root, path, data), + value; + + // In cases where the path begins with a keyword, change the + // root to the value represented by that keyword, and ensure + // the path is relative to it. + root = normalizedPath.root; + path = normalizedPath.path; + + value = Ember.get(root, path); + + // If the path starts with a capital letter, look it up on Ember.lookup, + // which defaults to the `window` object in browsers. + if (value === undefined && root !== Ember.lookup && Ember.isGlobalPath(path)) { + value = Ember.get(Ember.lookup, path); + } + return value; +}; +Ember.Handlebars.getPath = Ember.deprecateFunc('`Ember.Handlebars.getPath` has been changed to `Ember.Handlebars.get` for consistency.', Ember.Handlebars.get); + +Ember.Handlebars.resolveParams = function(context, params, options) { + var resolvedParams = [], types = options.types, param, type; + + for (var i=0, l=params.length; i + ``` + + The above handlebars template will fill the ``'s `src` attribute will + the value of the property referenced with `"imageUrl"` and its `alt` + attribute with the value of the property referenced with `"imageTitle"`. + + If the rendering context of this template is the following object: + + ```javascript + { + imageUrl: 'http://lolcats.info/haz-a-funny', + imageTitle: 'A humorous image of a cat' + } + ``` + + The resulting HTML output will be: + + ```html + A humorous image of a cat + ``` + + `bindAttr` cannot redeclare existing DOM element attributes. The use of `src` + in the following `bindAttr` example will be ignored and the hard coded value + of `src="/failwhale.gif"` will take precedence: + + ```handlebars + imageTitle + ``` + + ### `bindAttr` and the `class` attribute + + `bindAttr` supports a special syntax for handling a number of cases unique + to the `class` DOM element attribute. The `class` attribute combines + multiple discreet values into a single attribute as a space-delimited + list of strings. Each string can be: + + * a string return value of an object's property. + * a boolean return value of an object's property + * a hard-coded value + + A string return value works identically to other uses of `bindAttr`. The + return value of the property will become the value of the attribute. For + example, the following view and template: + + ```javascript + AView = Ember.View.extend({ + someProperty: function(){ + return "aValue"; + }.property() + }) + ``` + + ```handlebars + + ``` + + A boolean return value will insert a specified class name if the property + returns `true` and remove the class name if the property returns `false`. + + A class name is provided via the syntax + `somePropertyName:class-name-if-true`. + + ```javascript + AView = Ember.View.extend({ + someBool: true + }) + ``` + + ```handlebars + + ``` + + Result in the following rendered output: + + ```html + + ``` + + An additional section of the binding can be provided if you want to + replace the existing class instead of removing it when the boolean + value changes: + + ```handlebars + + ``` + + A hard-coded value can be used by prepending `:` to the desired + class name: `:class-name-to-always-apply`. + + ```handlebars + + ``` + + Results in the following rendered output: + + ```html + + ``` + + All three strategies - string return value, boolean return value, and + hard-coded value – can be combined in a single declaration: + + ```handlebars + + ``` + + @method bindAttr + @for Ember.Handlebars.helpers + @param {Hash} options + @return {String} HTML string +*/ +EmberHandlebars.registerHelper('bindAttr', function(options) { + + var attrs = options.hash; + + Ember.assert("You must specify at least one hash argument to bindAttr", !!Ember.keys(attrs).length); + + var view = options.data.view; + var ret = []; + var ctx = this; + + // Generate a unique id for this element. This will be added as a + // data attribute to the element so it can be looked up when + // the bound property changes. + var dataId = ++Ember.uuid; + + // Handle classes differently, as we can bind multiple classes + var classBindings = attrs['class']; + if (classBindings !== null && classBindings !== undefined) { + var classResults = EmberHandlebars.bindClasses(this, classBindings, view, dataId, options); + + ret.push('class="' + Handlebars.Utils.escapeExpression(classResults.join(' ')) + '"'); + delete attrs['class']; + } + + var attrKeys = Ember.keys(attrs); + + // For each attribute passed, create an observer and emit the + // current value of the property as an attribute. + forEach.call(attrKeys, function(attr) { + var path = attrs[attr], + normalized; + + Ember.assert(fmt("You must provide a String for a bound attribute, not %@", [path]), typeof path === 'string'); + + normalized = normalizePath(ctx, path, options.data); + + var value = (path === 'this') ? normalized.root : handlebarsGet(ctx, path, options), + type = Ember.typeOf(value); + + Ember.assert(fmt("Attributes must be numbers, strings or booleans, not %@", [value]), value === null || value === undefined || type === 'number' || type === 'string' || type === 'boolean'); + + var observer, invoker; + + observer = function observer() { + var result = handlebarsGet(ctx, path, options); + + Ember.assert(fmt("Attributes must be numbers, strings or booleans, not %@", [result]), result === null || result === undefined || typeof result === 'number' || typeof result === 'string' || typeof result === 'boolean'); + + var elem = view.$("[data-bindattr-" + dataId + "='" + dataId + "']"); + + // If we aren't able to find the element, it means the element + // to which we were bound has been removed from the view. + // In that case, we can assume the template has been re-rendered + // and we need to clean up the observer. + if (!elem || elem.length === 0) { + Ember.removeObserver(normalized.root, normalized.path, invoker); + return; + } + + Ember.View.applyAttributeBindings(elem, attr, result); + }; + + invoker = function() { + Ember.run.scheduleOnce('render', observer); + }; + + // Add an observer to the view for when the property changes. + // When the observer fires, find the element using the + // unique data id and update the attribute to the new value. + if (path !== 'this') { + view.registerObserver(normalized.root, normalized.path, invoker); + } + + // if this changes, also change the logic in ember-views/lib/views/view.js + if ((type === 'string' || (type === 'number' && !isNaN(value)))) { + ret.push(attr + '="' + Handlebars.Utils.escapeExpression(value) + '"'); + } else if (value && type === 'boolean') { + // The developer controls the attr name, so it should always be safe + ret.push(attr + '="' + attr + '"'); + } + }, this); + + // Add the unique identifier + // NOTE: We use all lower-case since Firefox has problems with mixed case in SVG + ret.push('data-bindattr-' + dataId + '="' + dataId + '"'); + return new EmberHandlebars.SafeString(ret.join(' ')); +}); + +/** + @private + + Helper that, given a space-separated string of property paths and a context, + returns an array of class names. Calling this method also has the side + effect of setting up observers at those property paths, such that if they + change, the correct class name will be reapplied to the DOM element. + + For example, if you pass the string "fooBar", it will first look up the + "fooBar" value of the context. If that value is true, it will add the + "foo-bar" class to the current element (i.e., the dasherized form of + "fooBar"). If the value is a string, it will add that string as the class. + Otherwise, it will not add any new class name. + + @method bindClasses + @for Ember.Handlebars + @param {Ember.Object} context The context from which to lookup properties + @param {String} classBindings A string, space-separated, of class bindings + to use + @param {Ember.View} view The view in which observers should look for the + element to update + @param {Srting} bindAttrId Optional bindAttr id used to lookup elements + @return {Array} An array of class names to add +*/ +EmberHandlebars.bindClasses = function(context, classBindings, view, bindAttrId, options) { + var ret = [], newClass, value, elem; + + // Helper method to retrieve the property from the context and + // determine which class string to return, based on whether it is + // a Boolean or not. + var classStringForPath = function(root, parsedPath, options) { + var val, + path = parsedPath.path; + + if (path === 'this') { + val = root; + } else if (path === '') { + val = true; + } else { + val = handlebarsGet(root, path, options); + } + + return Ember.View._classStringForValue(path, val, parsedPath.className, parsedPath.falsyClassName); + }; + + // For each property passed, loop through and setup + // an observer. + forEach.call(classBindings.split(' '), function(binding) { + + // Variable in which the old class value is saved. The observer function + // closes over this variable, so it knows which string to remove when + // the property changes. + var oldClass; + + var observer, invoker; + + var parsedPath = Ember.View._parsePropertyPath(binding), + path = parsedPath.path, + pathRoot = context, + normalized; + + if (path !== '' && path !== 'this') { + normalized = normalizePath(context, path, options.data); + + pathRoot = normalized.root; + path = normalized.path; + } + + // Set up an observer on the context. If the property changes, toggle the + // class name. + observer = function() { + // Get the current value of the property + newClass = classStringForPath(context, parsedPath, options); + elem = bindAttrId ? view.$("[data-bindattr-" + bindAttrId + "='" + bindAttrId + "']") : view.$(); + + // If we can't find the element anymore, a parent template has been + // re-rendered and we've been nuked. Remove the observer. + if (!elem || elem.length === 0) { + Ember.removeObserver(pathRoot, path, invoker); + } else { + // If we had previously added a class to the element, remove it. + if (oldClass) { + elem.removeClass(oldClass); + } + + // If necessary, add a new class. Make sure we keep track of it so + // it can be removed in the future. + if (newClass) { + elem.addClass(newClass); + oldClass = newClass; + } else { + oldClass = null; + } + } + }; + + invoker = function() { + Ember.run.scheduleOnce('render', observer); + }; + + if (path !== '' && path !== 'this') { + view.registerObserver(pathRoot, path, invoker); + } + + // We've already setup the observer; now we just need to figure out the + // correct behavior right now on the first pass through. + value = classStringForPath(context, parsedPath, options); + + if (value) { + ret.push(value); + + // Make sure we save the current value so that it can be removed if the + // observer fires. + oldClass = value; + } + }); + + return ret; +}; + + +})(); + + + +(function() { +/*globals Handlebars */ + +// TODO: Don't require the entire module +/** +@module ember +@submodule ember-handlebars +*/ + +var get = Ember.get, set = Ember.set; +var PARENT_VIEW_PATH = /^parentView\./; +var EmberHandlebars = Ember.Handlebars; + +EmberHandlebars.ViewHelper = Ember.Object.create({ + + propertiesFromHTMLOptions: function(options, thisContext) { + var hash = options.hash, data = options.data; + var extensions = {}, + classes = hash['class'], + dup = false; + + if (hash.id) { + extensions.elementId = hash.id; + dup = true; + } + + if (classes) { + classes = classes.split(' '); + extensions.classNames = classes; + dup = true; + } + + if (hash.classBinding) { + extensions.classNameBindings = hash.classBinding.split(' '); + dup = true; + } + + if (hash.classNameBindings) { + if (extensions.classNameBindings === undefined) extensions.classNameBindings = []; + extensions.classNameBindings = extensions.classNameBindings.concat(hash.classNameBindings.split(' ')); + dup = true; + } + + if (hash.attributeBindings) { + Ember.assert("Setting 'attributeBindings' via Handlebars is not allowed. Please subclass Ember.View and set it there instead."); + extensions.attributeBindings = null; + dup = true; + } + + if (dup) { + hash = Ember.$.extend({}, hash); + delete hash.id; + delete hash['class']; + delete hash.classBinding; + } + + // Set the proper context for all bindings passed to the helper. This applies to regular attribute bindings + // as well as class name bindings. If the bindings are local, make them relative to the current context + // instead of the view. + var path; + + // Evaluate the context of regular attribute bindings: + for (var prop in hash) { + if (!hash.hasOwnProperty(prop)) { continue; } + + // Test if the property ends in "Binding" + if (Ember.IS_BINDING.test(prop) && typeof hash[prop] === 'string') { + path = this.contextualizeBindingPath(hash[prop], data); + if (path) { hash[prop] = path; } + } + } + + // Evaluate the context of class name bindings: + if (extensions.classNameBindings) { + for (var b in extensions.classNameBindings) { + var full = extensions.classNameBindings[b]; + if (typeof full === 'string') { + // Contextualize the path of classNameBinding so this: + // + // classNameBinding="isGreen:green" + // + // is converted to this: + // + // classNameBinding="_parentView.context.isGreen:green" + var parsedPath = Ember.View._parsePropertyPath(full); + path = this.contextualizeBindingPath(parsedPath.path, data); + if (path) { extensions.classNameBindings[b] = path + parsedPath.classNames; } + } + } + } + + return Ember.$.extend(hash, extensions); + }, + + // Transform bindings from the current context to a context that can be evaluated within the view. + // Returns null if the path shouldn't be changed. + // + // TODO: consider the addition of a prefix that would allow this method to return `path`. + contextualizeBindingPath: function(path, data) { + var normalized = Ember.Handlebars.normalizePath(null, path, data); + if (normalized.isKeyword) { + return 'templateData.keywords.' + path; + } else if (Ember.isGlobalPath(path)) { + return null; + } else if (path === 'this') { + return '_parentView.context'; + } else { + return '_parentView.context.' + path; + } + }, + + helper: function(thisContext, path, options) { + var inverse = options.inverse, + data = options.data, + view = data.view, + fn = options.fn, + hash = options.hash, + newView; + + if ('string' === typeof path) { + newView = EmberHandlebars.get(thisContext, path, options); + Ember.assert("Unable to find view at path '" + path + "'", !!newView); + } else { + newView = path; + } + + Ember.assert(Ember.String.fmt('You must pass a view to the #view helper, not %@ (%@)', [path, newView]), Ember.View.detect(newView) || Ember.View.detectInstance(newView)); + + var viewOptions = this.propertiesFromHTMLOptions(options, thisContext); + var currentView = data.view; + viewOptions.templateData = options.data; + var newViewProto = newView.proto ? newView.proto() : newView; + + if (fn) { + Ember.assert("You cannot provide a template block if you also specified a templateName", !get(viewOptions, 'templateName') && !get(newViewProto, 'templateName')); + viewOptions.template = fn; + } + + // We only want to override the `_context` computed property if there is + // no specified controller. See View#_context for more information. + if (!newViewProto.controller && !newViewProto.controllerBinding && !viewOptions.controller && !viewOptions.controllerBinding) { + viewOptions._context = thisContext; + } + + currentView.appendChild(newView, viewOptions); + } +}); + +/** + `{{view}}` inserts a new instance of `Ember.View` into a template passing its + options to the `Ember.View`'s `create` method and using the supplied block as + the view's own template. + + An empty `` and the following template: + + ```handlebars + A span: + {{#view tagName="span"}} + hello. + {{/view}} + ``` + + Will result in HTML structure: + + ```html + + + +
    + A span: + + Hello. + +
    + + ``` + + ### `parentView` setting + + The `parentView` property of the new `Ember.View` instance created through + `{{view}}` will be set to the `Ember.View` instance of the template where + `{{view}}` was called. + + ```javascript + aView = Ember.View.create({ + template: Ember.Handlebars.compile("{{#view}} my parent: {{parentView.elementId}} {{/view}}") + }); + + aView.appendTo('body'); + ``` + + Will result in HTML structure: + + ```html +
    +
    + my parent: ember1 +
    +
    + ``` + + ### Setting CSS id and class attributes + + The HTML `id` attribute can be set on the `{{view}}`'s resulting element with + the `id` option. This option will _not_ be passed to `Ember.View.create`. + + ```handlebars + {{#view tagName="span" id="a-custom-id"}} + hello. + {{/view}} + ``` + + Results in the following HTML structure: + + ```html +
    + + hello. + +
    + ``` + + The HTML `class` attribute can be set on the `{{view}}`'s resulting element + with the `class` or `classNameBindings` options. The `class` option will + directly set the CSS `class` attribute and will not be passed to + `Ember.View.create`. `classNameBindings` will be passed to `create` and use + `Ember.View`'s class name binding functionality: + + ```handlebars + {{#view tagName="span" class="a-custom-class"}} + hello. + {{/view}} + ``` + + Results in the following HTML structure: + + ```html +
    + + hello. + +
    + ``` + + ### Supplying a different view class + + `{{view}}` can take an optional first argument before its supplied options to + specify a path to a custom view class. + + ```handlebars + {{#view "MyApp.CustomView"}} + hello. + {{/view}} + ``` + + The first argument can also be a relative path. Ember will search for the + view class starting at the `Ember.View` of the template where `{{view}}` was + used as the root object: + + ```javascript + MyApp = Ember.Application.create({}); + MyApp.OuterView = Ember.View.extend({ + innerViewClass: Ember.View.extend({ + classNames: ['a-custom-view-class-as-property'] + }), + template: Ember.Handlebars.compile('{{#view "innerViewClass"}} hi {{/view}}') + }); + + MyApp.OuterView.create().appendTo('body'); + ``` + + Will result in the following HTML: + + ```html +
    +
    + hi +
    +
    + ``` + + ### Blockless use + + If you supply a custom `Ember.View` subclass that specifies its own template + or provide a `templateName` option to `{{view}}` it can be used without + supplying a block. Attempts to use both a `templateName` option and supply a + block will throw an error. + + ```handlebars + {{view "MyApp.ViewWithATemplateDefined"}} + ``` + + ### `viewName` property + + You can supply a `viewName` option to `{{view}}`. The `Ember.View` instance + will be referenced as a property of its parent view by this name. + + ```javascript + aView = Ember.View.create({ + template: Ember.Handlebars.compile('{{#view viewName="aChildByName"}} hi {{/view}}') + }); + + aView.appendTo('body'); + aView.get('aChildByName') // the instance of Ember.View created by {{view}} helper + ``` + + @method view + @for Ember.Handlebars.helpers + @param {String} path + @param {Hash} options + @return {String} HTML string +*/ +EmberHandlebars.registerHelper('view', function(path, options) { + Ember.assert("The view helper only takes a single argument", arguments.length <= 2); + + // If no path is provided, treat path param as options. + if (path && path.data && path.data.isRenderData) { + options = path; + path = "Ember.View"; + } + + return EmberHandlebars.ViewHelper.helper(this, path, options); +}); + + +})(); + + + +(function() { +/*globals Handlebars */ + +// TODO: Don't require all of this module +/** +@module ember +@submodule ember-handlebars +*/ + +var get = Ember.get, handlebarsGet = Ember.Handlebars.get, fmt = Ember.String.fmt; + +/** + `{{collection}}` is a `Ember.Handlebars` helper for adding instances of + `Ember.CollectionView` to a template. See `Ember.CollectionView` for + additional information on how a `CollectionView` functions. + + `{{collection}}`'s primary use is as a block helper with a `contentBinding` + option pointing towards an `Ember.Array`-compatible object. An `Ember.View` + instance will be created for each item in its `content` property. Each view + will have its own `content` property set to the appropriate item in the + collection. + + The provided block will be applied as the template for each item's view. + + Given an empty `` the following template: + + ```handlebars + {{#collection contentBinding="App.items"}} + Hi {{view.content.name}} + {{/collection}} + ``` + + And the following application code + + ```javascript + App = Ember.Application.create() + App.items = [ + Ember.Object.create({name: 'Dave'}), + Ember.Object.create({name: 'Mary'}), + Ember.Object.create({name: 'Sara'}) + ] + ``` + + Will result in the HTML structure below + + ```html +
    +
    Hi Dave
    +
    Hi Mary
    +
    Hi Sara
    +
    + ``` + + ### Blockless Use + + If you provide an `itemViewClass` option that has its own `template` you can + omit the block. + + The following template: + + ```handlebars + {{collection contentBinding="App.items" itemViewClass="App.AnItemView"}} + ``` + + And application code + + ```javascript + App = Ember.Application.create(); + App.items = [ + Ember.Object.create({name: 'Dave'}), + Ember.Object.create({name: 'Mary'}), + Ember.Object.create({name: 'Sara'}) + ]; + + App.AnItemView = Ember.View.extend({ + template: Ember.Handlebars.compile("Greetings {{view.content.name}}") + }); + ``` + + Will result in the HTML structure below + + ```html +
    +
    Greetings Dave
    +
    Greetings Mary
    +
    Greetings Sara
    +
    + ``` + + ### Specifying a CollectionView subclass + + By default the `{{collection}}` helper will create an instance of + `Ember.CollectionView`. You can supply a `Ember.CollectionView` subclass to + the helper by passing it as the first argument: + + ```handlebars + {{#collection App.MyCustomCollectionClass contentBinding="App.items"}} + Hi {{view.content.name}} + {{/collection}} + ``` + + ### Forwarded `item.*`-named Options + + As with the `{{view}}`, helper options passed to the `{{collection}}` will be + set on the resulting `Ember.CollectionView` as properties. Additionally, + options prefixed with `item` will be applied to the views rendered for each + item (note the camelcasing): + + ```handlebars + {{#collection contentBinding="App.items" + itemTagName="p" + itemClassNames="greeting"}} + Howdy {{view.content.name}} + {{/collection}} + ``` + + Will result in the following HTML structure: + + ```html +
    +

    Howdy Dave

    +

    Howdy Mary

    +

    Howdy Sara

    +
    + ``` + + @method collection + @for Ember.Handlebars.helpers + @param {String} path + @param {Hash} options + @return {String} HTML string + @deprecated Use `{{each}}` helper instead. +*/ +Ember.Handlebars.registerHelper('collection', function(path, options) { + Ember.deprecate("Using the {{collection}} helper without specifying a class has been deprecated as the {{each}} helper now supports the same functionality.", path !== 'collection'); + + // If no path is provided, treat path param as options. + if (path && path.data && path.data.isRenderData) { + options = path; + path = undefined; + Ember.assert("You cannot pass more than one argument to the collection helper", arguments.length === 1); + } else { + Ember.assert("You cannot pass more than one argument to the collection helper", arguments.length === 2); + } + + var fn = options.fn; + var data = options.data; + var inverse = options.inverse; + var view = options.data.view; + + // If passed a path string, convert that into an object. + // Otherwise, just default to the standard class. + var collectionClass; + collectionClass = path ? handlebarsGet(this, path, options) : Ember.CollectionView; + Ember.assert(fmt("%@ #collection: Could not find collection class %@", [data.view, path]), !!collectionClass); + + var hash = options.hash, itemHash = {}, match; + + // Extract item view class if provided else default to the standard class + var itemViewClass, itemViewPath = hash.itemViewClass; + var collectionPrototype = collectionClass.proto(); + delete hash.itemViewClass; + itemViewClass = itemViewPath ? handlebarsGet(collectionPrototype, itemViewPath, options) : collectionPrototype.itemViewClass; + Ember.assert(fmt("%@ #collection: Could not find itemViewClass %@", [data.view, itemViewPath]), !!itemViewClass); + + // Go through options passed to the {{collection}} helper and extract options + // that configure item views instead of the collection itself. + for (var prop in hash) { + if (hash.hasOwnProperty(prop)) { + match = prop.match(/^item(.)(.*)$/); + + if(match && prop !== 'itemController') { + // Convert itemShouldFoo -> shouldFoo + itemHash[match[1].toLowerCase() + match[2]] = hash[prop]; + // Delete from hash as this will end up getting passed to the + // {{view}} helper method. + delete hash[prop]; + } + } + } + + var tagName = hash.tagName || collectionPrototype.tagName; + + if (fn) { + itemHash.template = fn; + delete options.fn; + } + + var emptyViewClass; + if (inverse && inverse !== Handlebars.VM.noop) { + emptyViewClass = get(collectionPrototype, 'emptyViewClass'); + emptyViewClass = emptyViewClass.extend({ + template: inverse, + tagName: itemHash.tagName + }); + } else if (hash.emptyViewClass) { + emptyViewClass = handlebarsGet(this, hash.emptyViewClass, options); + } + if (emptyViewClass) { hash.emptyView = emptyViewClass; } + + if(!hash.keyword){ + itemHash._context = Ember.computed.alias('content'); + } + + var viewString = view.toString(); + + var viewOptions = Ember.Handlebars.ViewHelper.propertiesFromHTMLOptions({ data: data, hash: itemHash }, this); + hash.itemViewClass = itemViewClass.extend(viewOptions); + + return Ember.Handlebars.helpers.view.call(this, collectionClass, options); +}); + + +})(); + + + +(function() { +/*globals Handlebars */ +/** +@module ember +@submodule ember-handlebars +*/ + +var handlebarsGet = Ember.Handlebars.get; + +/** + `unbound` allows you to output a property without binding. *Important:* The + output will not be updated if the property changes. Use with caution. + + ```handlebars +
    {{unbound somePropertyThatDoesntChange}}
    + ``` + + `unbound` can also be used in conjunction with a bound helper to + render it in its unbound form: + + ```handlebars +
    {{unbound helperName somePropertyThatDoesntChange}}
    + ``` + + @method unbound + @for Ember.Handlebars.helpers + @param {String} property + @return {String} HTML string +*/ +Ember.Handlebars.registerHelper('unbound', function(property, fn) { + var options = arguments[arguments.length - 1], helper, context, out; + + if(arguments.length > 2) { + // Unbound helper call. + options.data.isUnbound = true; + helper = Ember.Handlebars.helpers[arguments[0]] || Ember.Handlebars.helperMissing; + out = helper.apply(this, Array.prototype.slice.call(arguments, 1)); + delete options.data.isUnbound; + return out; + } + + context = (fn.contexts && fn.contexts[0]) || this; + return handlebarsGet(context, property, fn); +}); + +})(); + + + +(function() { +/*jshint debug:true*/ +/** +@module ember +@submodule ember-handlebars +*/ + +var handlebarsGet = Ember.Handlebars.get, normalizePath = Ember.Handlebars.normalizePath; + +/** + `log` allows you to output the value of a value in the current rendering + context. + + ```handlebars + {{log myVariable}} + ``` + + @method log + @for Ember.Handlebars.helpers + @param {String} property +*/ +Ember.Handlebars.registerHelper('log', function(property, options) { + var context = (options.contexts && options.contexts[0]) || this, + normalized = normalizePath(context, property, options.data), + pathRoot = normalized.root, + path = normalized.path, + value = (path === 'this') ? pathRoot : handlebarsGet(pathRoot, path, options); + Ember.Logger.log(value); +}); + +/** + Execute the `debugger` statement in the current context. + + ```handlebars + {{debugger}} + ``` + + @method debugger + @for Ember.Handlebars.helpers + @param {String} property +*/ +Ember.Handlebars.registerHelper('debugger', function() { + debugger; +}); + +})(); + + + +(function() { +/** +@module ember +@submodule ember-handlebars +*/ + +var get = Ember.get, set = Ember.set; + +Ember.Handlebars.EachView = Ember.CollectionView.extend(Ember._Metamorph, { + init: function() { + var itemController = get(this, 'itemController'); + var binding; + + if (itemController) { + var controller = Ember.ArrayController.create(); + set(controller, 'itemController', itemController); + set(controller, 'container', get(this, 'controller.container')); + set(controller, '_eachView', this); + set(controller, 'target', get(this, 'controller')); + + this.disableContentObservers(function() { + set(this, 'content', controller); + binding = new Ember.Binding('content', '_eachView.dataSource').oneWay(); + binding.connect(controller); + }); + + set(this, '_arrayController', controller); + } else { + this.disableContentObservers(function() { + binding = new Ember.Binding('content', 'dataSource').oneWay(); + binding.connect(this); + }); + } + + return this._super(); + }, + + disableContentObservers: function(callback) { + Ember.removeBeforeObserver(this, 'content', null, '_contentWillChange'); + Ember.removeObserver(this, 'content', null, '_contentDidChange'); + + callback.apply(this); + + Ember.addBeforeObserver(this, 'content', null, '_contentWillChange'); + Ember.addObserver(this, 'content', null, '_contentDidChange'); + }, + + itemViewClass: Ember._MetamorphView, + emptyViewClass: Ember._MetamorphView, + + createChildView: function(view, attrs) { + view = this._super(view, attrs); + + // At the moment, if a container view subclass wants + // to insert keywords, it is responsible for cloning + // the keywords hash. This will be fixed momentarily. + var keyword = get(this, 'keyword'); + var content = get(view, 'content'); + + if (keyword) { + var data = get(view, 'templateData'); + + data = Ember.copy(data); + data.keywords = view.cloneKeywords(); + set(view, 'templateData', data); + + // In this case, we do not bind, because the `content` of + // a #each item cannot change. + data.keywords[keyword] = content; + } + + // If {{#each}} is looping over an array of controllers, + // point each child view at their respective controller. + if (content && get(content, 'isController')) { + set(view, 'controller', content); + } + + return view; + }, + + willDestroy: function() { + var arrayController = get(this, '_arrayController'); + + if (arrayController) { + arrayController.destroy(); + } + + return this._super(); + } +}); + +var GroupedEach = Ember.Handlebars.GroupedEach = function(context, path, options) { + var self = this, + normalized = Ember.Handlebars.normalizePath(context, path, options.data); + + this.context = context; + this.path = path; + this.options = options; + this.template = options.fn; + this.containingView = options.data.view; + this.normalizedRoot = normalized.root; + this.normalizedPath = normalized.path; + this.content = this.lookupContent(); + + this.addContentObservers(); + this.addArrayObservers(); + + this.containingView.on('willClearRender', function() { + self.destroy(); + }); +}; + +GroupedEach.prototype = { + contentWillChange: function() { + this.removeArrayObservers(); + }, + + contentDidChange: function() { + this.content = this.lookupContent(); + this.addArrayObservers(); + this.rerenderContainingView(); + }, + + contentArrayWillChange: Ember.K, + + contentArrayDidChange: function() { + this.rerenderContainingView(); + }, + + lookupContent: function() { + return Ember.Handlebars.get(this.normalizedRoot, this.normalizedPath, this.options); + }, + + addArrayObservers: function() { + this.content.addArrayObserver(this, { + willChange: 'contentArrayWillChange', + didChange: 'contentArrayDidChange' + }); + }, + + removeArrayObservers: function() { + this.content.removeArrayObserver(this, { + willChange: 'contentArrayWillChange', + didChange: 'contentArrayDidChange' + }); + }, + + addContentObservers: function() { + Ember.addBeforeObserver(this.normalizedRoot, this.normalizedPath, this, this.contentWillChange); + Ember.addObserver(this.normalizedRoot, this.normalizedPath, this, this.contentDidChange); + }, + + removeContentObservers: function() { + Ember.removeBeforeObserver(this.normalizedRoot, this.normalizedPath, this.contentWillChange); + Ember.removeObserver(this.normalizedRoot, this.normalizedPath, this.contentDidChange); + }, + + render: function() { + var content = this.content, + contentLength = get(content, 'length'), + data = this.options.data, + template = this.template; + + data.insideEach = true; + for (var i = 0; i < contentLength; i++) { + template(content.objectAt(i), { data: data }); + } + }, + + rerenderContainingView: function() { + Ember.run.scheduleOnce('render', this.containingView, 'rerender'); + }, + + destroy: function() { + this.removeContentObservers(); + this.removeArrayObservers(); + } +}; + +/** + The `{{#each}}` helper loops over elements in a collection, rendering its + block once for each item. It is an extension of the base Handlebars `{{#each}}` + helper: + + ```javascript + Developers = [{name: 'Yehuda'},{name: 'Tom'}, {name: 'Paul'}]; + ``` + + ```handlebars + {{#each Developers}} + {{name}} + {{/each}} + ``` + + `{{each}}` supports an alternative syntax with element naming: + + ```handlebars + {{#each person in Developers}} + {{person.name}} + {{/each}} + ``` + + When looping over objects that do not have properties, `{{this}}` can be used + to render the object: + + ```javascript + DeveloperNames = ['Yehuda', 'Tom', 'Paul'] + ``` + + ```handlebars + {{#each DeveloperNames}} + {{this}} + {{/each}} + ``` + ### {{else}} condition + `{{#each}}` can have a matching `{{else}}`. The contents of this block will render + if the collection is empty. + + ``` + {{#each person in Developers}} + {{person.name}} + {{else}} +

    Sorry, nobody is available for this task.

    + {{/each}} + ``` + ### Specifying a View class for items + If you provide an `itemViewClass` option that references a view class + with its own `template` you can omit the block. + + The following template: + + ```handlebars + {{#view App.MyView }} + {{each view.items itemViewClass="App.AnItemView"}} + {{/view}} + ``` + + And application code + + ```javascript + App = Ember.Application.create({ + MyView: Ember.View.extend({ + items: [ + Ember.Object.create({name: 'Dave'}), + Ember.Object.create({name: 'Mary'}), + Ember.Object.create({name: 'Sara'}) + ] + }) + }); + + App.AnItemView = Ember.View.extend({ + template: Ember.Handlebars.compile("Greetings {{name}}") + }); + ``` + + Will result in the HTML structure below + + ```html +
    +
    Greetings Dave
    +
    Greetings Mary
    +
    Greetings Sara
    +
    + ``` + + ### Representing each item with a Controller. + By default the controller lookup within an `{{#each}}` block will be + the controller of the template where the `{{#each}}` was used. If each + item needs to be presented by a custom controller you can provide a + `itemController` option which references a controller by lookup name. + Each item in the loop will be wrapped in an instance of this controller + and the item itself will be set to the `content` property of that controller. + + This is useful in cases where properties of model objects need transformation + or synthesis for display: + + ```javascript + App.DeveloperController = Ember.ObjectController.extend({ + isAvailableForHire: function(){ + return !this.get('content.isEmployed') && this.get('content.isSeekingWork'); + }.property('isEmployed', 'isSeekingWork') + }) + ``` + + ```handlebars + {{#each person in Developers itemController="developer"}} + {{person.name}} {{#if person.isAvailableForHire}}Hire me!{{/if}} + {{/each}} + ``` + + @method each + @for Ember.Handlebars.helpers + @param [name] {String} name for item (used with `in`) + @param path {String} path + @param [options] {Object} Handlebars key/value pairs of options + @param [options.itemViewClass] {String} a path to a view class used for each item + @param [options.itemController] {String} name of a controller to be created for each item +*/ +Ember.Handlebars.registerHelper('each', function(path, options) { + if (arguments.length === 4) { + Ember.assert("If you pass more than one argument to the each helper, it must be in the form #each foo in bar", arguments[1] === "in"); + + var keywordName = arguments[0]; + + options = arguments[3]; + path = arguments[2]; + if (path === '') { path = "this"; } + + options.hash.keyword = keywordName; + } + + options.hash.dataSourceBinding = path; + // Set up emptyView as a metamorph with no tag + //options.hash.emptyViewClass = Ember._MetamorphView; + + if (options.data.insideGroup && !options.hash.groupedRows && !options.hash.itemViewClass) { + new Ember.Handlebars.GroupedEach(this, path, options).render(); + } else { + return Ember.Handlebars.helpers.collection.call(this, 'Ember.Handlebars.EachView', options); + } +}); + +})(); + + + +(function() { +/** +@module ember +@submodule ember-handlebars +*/ + +/** + `template` allows you to render a template from inside another template. + This allows you to re-use the same template in multiple places. For example: + + ```html + + ``` + + ```html + + ``` + + This helper looks for templates in the global `Ember.TEMPLATES` hash. If you + add ` + ``` + + And application code + + ```javascript + AController = Ember.Controller.extend({ + anActionName: function() {} + }); + + AView = Ember.View.extend({ + controller: AController.create(), + templateName: 'a-template' + }); + + aView = AView.create(); + aView.appendTo('body'); + ``` + + Will results in the following rendered HTML + + ```html +
    +
    + click me +
    +
    + ``` + + Clicking "click me" will trigger the `anActionName` method of the + `AController`. In this case, no additional parameters will be passed. + + If you provide additional parameters to the helper: + + ```handlebars + + ``` + + Those parameters will be passed along as arguments to the JavaScript + function implementing the action. + + ### Event Propagation + + Events triggered through the action helper will automatically have + `.preventDefault()` called on them. You do not need to do so in your event + handlers. + + To also disable bubbling, pass `bubbles=false` to the helper: + + ```handlebars + + ``` + + If you need the default handler to trigger you should either register your + own event handler, or use event methods on your view class. See `Ember.View` + 'Responding to Browser Events' for more information. + + ### Specifying DOM event type + + By default the `{{action}}` helper registers for DOM `click` events. You can + supply an `on` option to the helper to specify a different DOM event name: + + ```handlebars + + ``` + + See `Ember.View` 'Responding to Browser Events' for a list of + acceptable DOM event names. + + NOTE: Because `{{action}}` depends on Ember's event dispatch system it will + only function if an `Ember.EventDispatcher` instance is available. An + `Ember.EventDispatcher` instance will be created when a new `Ember.Application` + is created. Having an instance of `Ember.Application` will satisfy this + requirement. + + ### Specifying a Target + + There are several possible target objects for `{{action}}` helpers: + + In a typical Ember application, where views are managed through use of the + `{{outlet}}` helper, actions will bubble to the current controller, then + to the current route, and then up the route hierarchy. + + Alternatively, a `target` option can be provided to the helper to change + which object will receive the method call. This option must be a path + path to an object, accessible in the current context: + + ```handlebars + + ``` + + Clicking "click me" in the rendered HTML of the above template will trigger + the `anActionName` method of the object at `MyApplication.someObject`. + + If an action's target does not implement a method that matches the supplied + action name an error will be thrown. + + ```handlebars + + ``` + + With the following application code + + ```javascript + AView = Ember.View.extend({ + templateName; 'a-template', + // note: no method 'aMethodNameThatIsMissing' + anActionName: function(event) {} + }); + + aView = AView.create(); + aView.appendTo('body'); + ``` + + Will throw `Uncaught TypeError: Cannot call method 'call' of undefined` when + "click me" is clicked. + + ### Additional Parameters + + You may specify additional parameters to the `{{action}}` helper. These + parameters are passed along as the arguments to the JavaScript function + implementing the action. + + ```handlebars + + ``` + + Clicking "click me" will trigger the `edit` method on the current view's + controller with the current person as a parameter. + + @method action + @for Ember.Handlebars.helpers + @param {String} actionName + @param {Object} [context]* + @param {Hash} options + */ + EmberHandlebars.registerHelper('action', function(actionName) { + var options = arguments[arguments.length - 1], + contexts = a_slice.call(arguments, 1, -1); + + var hash = options.hash, + view = options.data.view, + controller, link; + + // create a hash to pass along to registerAction + var action = { + eventName: hash.on || "click" + }; + + action.parameters = { + context: this, + options: options, + params: contexts + }; + + action.view = view = get(view, 'concreteView'); + + var root, target; + + if (hash.target) { + root = this; + target = hash.target; + } else if (controller = options.data.keywords.controller) { + root = controller; + } + + action.target = { root: root, target: target, options: options }; + action.bubbles = hash.bubbles; + + var actionId = ActionHelper.registerAction(actionName, action); + return new SafeString('data-ember-action="' + actionId + '"'); + }); + +}); + +})(); + + + +(function() { +/** +@module ember +@submodule ember-routing +*/ + + +var get = Ember.get, set = Ember.set; + +/** + @method control + @for Ember.Handlebars.helpers + @param {String} path + @param {String} modelPath + @param {Hash} options + @return {String} HTML string +*/ +Ember.Handlebars.registerHelper('control', function(path, modelPath, options) { + if (arguments.length === 2) { + options = modelPath; + modelPath = undefined; + } + + var model; + + if (modelPath) { + model = Ember.Handlebars.get(this, modelPath, options); + } + + var controller = options.data.keywords.controller, + view = options.data.keywords.view, + children = get(controller, '_childContainers'), + controlID = options.hash.controlID, + container, subContainer; + + if (children.hasOwnProperty(controlID)) { + subContainer = children[controlID]; + } else { + container = get(controller, 'container'), + subContainer = container.child(); + children[controlID] = subContainer; + } + + var normalizedPath = path.replace(/\//g, '.'); + + var childView = subContainer.lookup('view:' + normalizedPath) || subContainer.lookup('view:default'), + childController = subContainer.lookup('controller:' + normalizedPath), + childTemplate = subContainer.lookup('template:' + path); + + Ember.assert("Could not find controller for path: " + normalizedPath, childController); + Ember.assert("Could not find view for path: " + normalizedPath, childView); + + set(childController, 'target', controller); + set(childController, 'model', model); + + options.hash.template = childTemplate; + options.hash.controller = childController; + + function observer() { + var model = Ember.Handlebars.get(this, modelPath, options); + set(childController, 'model', model); + childView.rerender(); + } + + Ember.addObserver(this, modelPath, observer); + childView.one('willDestroyElement', this, function() { + Ember.removeObserver(this, modelPath, observer); + }); + + Ember.Handlebars.helpers.view.call(this, childView, options); +}); + +})(); + + + +(function() { + +})(); + + + +(function() { +/** +@module ember +@submodule ember-routing +*/ + +var get = Ember.get, set = Ember.set; + +Ember.ControllerMixin.reopen({ + transitionToRoute: function() { + // target may be either another controller or a router + var target = get(this, 'target'), + method = target.transitionToRoute || target.transitionTo; + return method.apply(target, arguments); + }, + + transitionTo: function() { + Ember.deprecate("transitionTo is deprecated. Please use transitionToRoute."); + return this.transitionToRoute.apply(this, arguments); + }, + + replaceRoute: function() { + // target may be either another controller or a router + var target = get(this, 'target'), + method = target.replaceRoute || target.replaceWith; + return method.apply(target, arguments); + }, + + replaceWith: function() { + Ember.deprecate("replaceWith is deprecated. Please use replaceRoute."); + return this.replaceRoute.apply(this, arguments); + } +}); + +})(); + + + +(function() { +/** +@module ember +@submodule ember-routing +*/ + +var get = Ember.get, set = Ember.set; + +Ember.View.reopen({ + init: function() { + set(this, '_outlets', {}); + this._super(); + }, + + connectOutlet: function(outletName, view) { + var outlets = get(this, '_outlets'), + container = get(this, 'container'), + router = container && container.lookup('router:main'), + renderedName = get(view, 'renderedName'); + + set(outlets, outletName, view); + + if (router && renderedName) { + router._connectActiveView(renderedName, view); + } + }, + + disconnectOutlet: function(outletName) { + var outlets = get(this, '_outlets'); + + set(outlets, outletName, null); + } +}); + +})(); + + + +(function() { + +})(); + + + +(function() { +/** +@module ember +@submodule ember-routing +*/ + +var get = Ember.get, set = Ember.set; + +/* + This file implements the `location` API used by Ember's router. + + That API is: + + getURL: returns the current URL + setURL(path): sets the current URL + replaceURL(path): replace the current URL (optional) + onUpdateURL(callback): triggers the callback when the URL changes + formatURL(url): formats `url` to be placed into `href` attribute + + Calling setURL or replaceURL will not trigger onUpdateURL callbacks. + + TODO: This should perhaps be moved so that it's visible in the doc output. +*/ + +/** + Ember.Location returns an instance of the correct implementation of + the `location` API. + + You can pass it a `implementation` ('hash', 'history', 'none') to force a + particular implementation. + + @class Location + @namespace Ember + @static +*/ +Ember.Location = { + create: function(options) { + var implementation = options && options.implementation; + Ember.assert("Ember.Location.create: you must specify a 'implementation' option", !!implementation); + + var implementationClass = this.implementations[implementation]; + Ember.assert("Ember.Location.create: " + implementation + " is not a valid implementation", !!implementationClass); + + return implementationClass.create.apply(implementationClass, arguments); + }, + + registerImplementation: function(name, implementation) { + this.implementations[name] = implementation; + }, + + implementations: {} +}; + +})(); + + + +(function() { +/** +@module ember +@submodule ember-routing +*/ + +var get = Ember.get, set = Ember.set; + +/** + Ember.NoneLocation does not interact with the browser. It is useful for + testing, or when you need to manage state with your Router, but temporarily + don't want it to muck with the URL (for example when you embed your + application in a larger page). + + @class NoneLocation + @namespace Ember + @extends Ember.Object +*/ +Ember.NoneLocation = Ember.Object.extend({ + path: '', + + getURL: function() { + return get(this, 'path'); + }, + + setURL: function(path) { + set(this, 'path', path); + }, + + onUpdateURL: function(callback) { + this.updateCallback = callback; + }, + + handleURL: function(url) { + set(this, 'path', url); + this.updateCallback(url); + }, + + formatURL: function(url) { + // The return value is not overly meaningful, but we do not want to throw + // errors when test code renders templates containing {{action href=true}} + // helpers. + return url; + } +}); + +Ember.Location.registerImplementation('none', Ember.NoneLocation); + +})(); + + + +(function() { +/** +@module ember +@submodule ember-routing +*/ + +var get = Ember.get, set = Ember.set; + +/** + Ember.HashLocation implements the location API using the browser's + hash. At present, it relies on a hashchange event existing in the + browser. + + @class HashLocation + @namespace Ember + @extends Ember.Object +*/ +Ember.HashLocation = Ember.Object.extend({ + + init: function() { + set(this, 'location', get(this, 'location') || window.location); + }, + + /** + @private + + Returns the current `location.hash`, minus the '#' at the front. + + @method getURL + */ + getURL: function() { + return get(this, 'location').hash.substr(1); + }, + + /** + @private + + Set the `location.hash` and remembers what was set. This prevents + `onUpdateURL` callbacks from triggering when the hash was set by + `HashLocation`. + + @method setURL + @param path {String} + */ + setURL: function(path) { + get(this, 'location').hash = path; + set(this, 'lastSetURL', path); + }, + + /** + @private + + Register a callback to be invoked when the hash changes. These + callbacks will execute when the user presses the back or forward + button, but not after `setURL` is invoked. + + @method onUpdateURL + @param callback {Function} + */ + onUpdateURL: function(callback) { + var self = this; + var guid = Ember.guidFor(this); + + Ember.$(window).bind('hashchange.ember-location-'+guid, function() { + Ember.run(function() { + var path = location.hash.substr(1); + if (get(self, 'lastSetURL') === path) { return; } + + set(self, 'lastSetURL', null); + + callback(location.hash.substr(1)); + }); + }); + }, + + /** + @private + + Given a URL, formats it to be placed into the page as part + of an element's `href` attribute. + + This is used, for example, when using the {{action}} helper + to generate a URL based on an event. + + @method formatURL + @param url {String} + */ + formatURL: function(url) { + return '#'+url; + }, + + willDestroy: function() { + var guid = Ember.guidFor(this); + + Ember.$(window).unbind('hashchange.ember-location-'+guid); + } +}); + +Ember.Location.registerImplementation('hash', Ember.HashLocation); + +})(); + + + +(function() { +/** +@module ember +@submodule ember-routing +*/ + +var get = Ember.get, set = Ember.set; +var popstateReady = false; + +/** + Ember.HistoryLocation implements the location API using the browser's + history.pushState API. + + @class HistoryLocation + @namespace Ember + @extends Ember.Object +*/ +Ember.HistoryLocation = Ember.Object.extend({ + + init: function() { + set(this, 'location', get(this, 'location') || window.location); + this.initState(); + }, + + /** + @private + + Used to set state on first call to setURL + + @method initState + */ + initState: function() { + this.replaceState(this.formatURL(this.getURL())); + set(this, 'history', window.history); + }, + + /** + Will be pre-pended to path upon state change + + @property rootURL + @default '/' + */ + rootURL: '/', + + /** + @private + + Returns the current `location.pathname` without rootURL + + @method getURL + */ + getURL: function() { + var rootURL = get(this, 'rootURL'), + url = get(this, 'location').pathname; + + rootURL = rootURL.replace(/\/$/, ''); + url = url.replace(rootURL, ''); + + return url; + }, + + /** + @private + + Uses `history.pushState` to update the url without a page reload. + + @method setURL + @param path {String} + */ + setURL: function(path) { + path = this.formatURL(path); + + if (this.getState() && this.getState().path !== path) { + popstateReady = true; + this.pushState(path); + } + }, + + /** + @private + + Uses `history.replaceState` to update the url without a page reload + or history modification. + + @method replaceURL + @param path {String} + */ + replaceURL: function(path) { + path = this.formatURL(path); + + if (this.getState() && this.getState().path !== path) { + popstateReady = true; + this.replaceState(path); + } + }, + + /** + @private + + Get the current `history.state` + + @method getState + */ + getState: function() { + return get(this, 'history').state; + }, + + /** + @private + + Pushes a new state + + @method pushState + @param path {String} + */ + pushState: function(path) { + window.history.pushState({ path: path }, null, path); + }, + + /** + @private + + Replaces the current state + + @method replaceState + @param path {String} + */ + replaceState: function(path) { + window.history.replaceState({ path: path }, null, path); + }, + + /** + @private + + Register a callback to be invoked whenever the browser + history changes, including using forward and back buttons. + + @method onUpdateURL + @param callback {Function} + */ + onUpdateURL: function(callback) { + var guid = Ember.guidFor(this), + self = this; + + Ember.$(window).bind('popstate.ember-location-'+guid, function(e) { + if(!popstateReady) { + return; + } + callback(self.getURL()); + }); + }, + + /** + @private + + Used when using `{{action}}` helper. The url is always appended to the rootURL. + + @method formatURL + @param url {String} + */ + formatURL: function(url) { + var rootURL = get(this, 'rootURL'); + + if (url !== '') { + rootURL = rootURL.replace(/\/$/, ''); + } + + return rootURL + url; + }, + + willDestroy: function() { + var guid = Ember.guidFor(this); + + Ember.$(window).unbind('popstate.ember-location-'+guid); + } +}); + +Ember.Location.registerImplementation('history', Ember.HistoryLocation); + +})(); + + + +(function() { + +})(); + + + +(function() { +/** +Ember Routing + +@module ember +@submodule ember-routing +@requires ember-states +@requires ember-views +*/ + +})(); + (function() { function visit(vertex, fn, visited, path) { var name = vertex.name, @@ -11221,15 +24690,17 @@ Ember.DAG = DAG; @submodule ember-application */ -var get = Ember.get, set = Ember.set; +var get = Ember.get, set = Ember.set, + classify = Ember.String.classify, + decamelize = Ember.String.decamelize; /** - An instance of `Ember.Application` is the starting point for every Ember.js + An instance of `Ember.Application` is the starting point for every Ember application. It helps to instantiate, initialize and coordinate the many objects that make up your app. - Each Ember.js app has one and only one `Ember.Application` object. In fact, the very - first thing you should do in your application is create the instance: + Each Ember app has one and only one `Ember.Application` object. In fact, the + very first thing you should do in your application is create the instance: ```javascript window.App = Ember.Application.create(); @@ -11245,12 +24716,15 @@ var get = Ember.get, set = Ember.set; App.MyView = Ember.View.extend(); ``` - After all of your classes are defined, call `App.initialize()` to start the - application. + By default, calling `Ember.Application.create()` will automatically initialize + your application by calling the `Ember.Application.initialize()` method. If + you need to delay initialization, you can call your app's `deferReadiness()` + method. When you are ready for your app to be initialized, call its + `advanceReadiness()` method. Because `Ember.Application` inherits from `Ember.Namespace`, any classes - you create will have useful string representations when calling `toString()`; - see the `Ember.Namespace` documentation for more information. + you create will have useful string representations when calling `toString()`. + See the `Ember.Namespace` documentation for more information. While you can think of your `Ember.Application` as a container that holds the other classes in your application, there are several other responsibilities @@ -11258,24 +24732,24 @@ var get = Ember.get, set = Ember.set; ### Event Delegation - Ember.js uses a technique called _event delegation_. This allows the framework - to set up a global, shared event listener instead of requiring each view to do - it manually. For example, instead of each view registering its own `mousedown` - listener on its associated element, Ember.js sets up a `mousedown` listener on - the `body`. + Ember uses a technique called _event delegation_. This allows the framework + to set up a global, shared event listener instead of requiring each view to + do it manually. For example, instead of each view registering its own + `mousedown` listener on its associated element, Ember sets up a `mousedown` + listener on the `body`. - If a `mousedown` event occurs, Ember.js will look at the target of the event and - start walking up the DOM node tree, finding corresponding views and invoking their - `mouseDown` method as it goes. + If a `mousedown` event occurs, Ember will look at the target of the event and + start walking up the DOM node tree, finding corresponding views and invoking + their `mouseDown` method as it goes. - `Ember.Application` has a number of default events that it listens for, as well - as a mapping from lowercase events to camel-cased view method names. For + `Ember.Application` has a number of default events that it listens for, as + well as a mapping from lowercase events to camel-cased view method names. For example, the `keypress` event causes the `keyPress` method on the view to be called, the `dblclick` event causes `doubleClick` to be called, and so on. - If there is a browser event that Ember.js does not listen for by default, you - can specify custom events and their corresponding view method names by setting - the application's `customEvents` property: + If there is a browser event that Ember does not listen for by default, you + can specify custom events and their corresponding view method names by + setting the application's `customEvents` property: ```javascript App = Ember.Application.create({ @@ -11287,13 +24761,13 @@ var get = Ember.get, set = Ember.set; }); ``` - By default, the application sets up these event listeners on the document body. - However, in cases where you are embedding an Ember.js application inside an - existing page, you may want it to set up the listeners on an element inside - the body. + By default, the application sets up these event listeners on the document + body. However, in cases where you are embedding an Ember application inside + an existing page, you may want it to set up the listeners on an element + inside the body. - For example, if only events inside a DOM element with the ID of `ember-app` should - be delegated, set your application's `rootElement` property: + For example, if only events inside a DOM element with the ID of `ember-app` + should be delegated, set your application's `rootElement` property: ```javascript window.App = Ember.Application.create({ @@ -11302,89 +24776,48 @@ var get = Ember.get, set = Ember.set; ``` The `rootElement` can be either a DOM element or a jQuery-compatible selector - string. Note that *views appended to the DOM outside the root element will not - receive events.* If you specify a custom root element, make sure you only append - views inside it! + string. Note that *views appended to the DOM outside the root element will + not receive events.* If you specify a custom root element, make sure you only + append views inside it! - To learn more about the advantages of event delegation and the Ember.js view layer, - and a list of the event listeners that are setup by default, visit the - [Ember.js View Layer guide](http://emberjs.com/guides/view_layer#toc_event-delegation). + To learn more about the advantages of event delegation and the Ember view + layer, and a list of the event listeners that are setup by default, visit the + [Ember View Layer guide](http://emberjs.com/guides/view_layer#toc_event-delegation). - ### Dependency Injection + ### Initializers - One thing you may have noticed while using Ember.js is that you define *classes*, not - *instances*. When your application loads, all of the instances are created for you. - Creating these instances is the responsibility of `Ember.Application`. - - When the `Ember.Application` initializes, it will look for an `Ember.Router` class - defined on the applications's `Router` property, like this: + Libraries on top of Ember can register additional initializers, like so: ```javascript - App.Router = Ember.Router.extend({ - // ... - }); - ``` + Ember.Application.initializer({ + name: "store", - If found, the router is instantiated and saved on the application's `router` - property (note the lowercase 'r'). While you should *not* reference this router - instance directly from your application code, having access to `App.router` - from the console can be useful during debugging. - - After the router is created, the application loops through all of the - registered _injections_ and invokes them once for each property on the - `Ember.Application` object. - - An injection is a function that is responsible for instantiating objects from - classes defined on the application. By default, the only injection registered - instantiates controllers and makes them available on the router. - - For example, if you define a controller class: - - ```javascript - App.MyController = Ember.Controller.extend({ - // ... - }); - ``` - - Your router will receive an instance of `App.MyController` saved on its - `myController` property. - - Libraries on top of Ember.js can register additional injections. For example, - if your application is using Ember Data, it registers an injection that - instantiates `DS.Store`: - - ```javascript - Ember.Application.registerInjection({ - name: 'store', - before: 'controllers', - - injection: function(app, router, property) { - if (property === 'Store') { - set(router, 'store', app[property].create()); - } + initialize: function(container, application) { + container.register('store', 'main', application.Store); } }); ``` ### Routing - In addition to creating your application's router, `Ember.Application` is also - responsible for telling the router when to start routing. - - By default, the router will begin trying to translate the current URL into - application state once the browser emits the `DOMContentReady` event. If you - need to defer routing, you can call the application's `deferReadiness()` method. - Once routing can begin, call the `advanceReadiness()` method. - - If there is any setup required before routing begins, you can implement a `ready()` - method on your app that will be invoked immediately before routing begins: + In addition to creating your application's router, `Ember.Application` is + also responsible for telling the router when to start routing. Transitions + between routes can be logged with the LOG_TRANSITIONS flag: ```javascript window.App = Ember.Application.create({ - ready: function() { - this.set('router.enableLogging', true); - } + LOG_TRANSITIONS: true }); + ``` + + By default, the router will begin trying to translate the current URL into + application state once the browser emits the `DOMContentReady` event. If you + need to defer routing, you can call the application's `deferReadiness()` + method. Once routing can begin, call the `advanceReadiness()` method. + + If there is any setup required before routing begins, you can implement a + `ready()` method on your app that will be invoked immediately before routing + begins. To begin routing, you must have at a minimum a top-level controller and view. You define these as `App.ApplicationController` and `App.ApplicationView`, @@ -11402,8 +24835,7 @@ var get = Ember.get, set = Ember.set; @namespace Ember @extends Ember.Namespace */ -Ember.Application = Ember.Namespace.extend( -/** @scope Ember.Application.prototype */{ +var Application = Ember.Application = Ember.Namespace.extend({ /** The root DOM element of the Application. This can be specified as an @@ -11449,13 +24881,15 @@ Ember.Application = Ember.Namespace.extend( to a hash containing the DOM event name as the key and the corresponding view method name as the value. For example: - App = Ember.Application.create({ - customEvents: { - // add support for the loadedmetadata media - // player event - 'loadedmetadata': "loadedMetadata" - } - }); + ```javascript + App = Ember.Application.create({ + customEvents: { + // add support for the loadedmetadata media + // player event + 'loadedmetadata': "loadedMetadata" + } + }); + ``` @property customEvents @type Object @@ -11463,43 +24897,87 @@ Ember.Application = Ember.Namespace.extend( */ customEvents: null, - autoinit: !Ember.testing, - isInitialized: false, + // Start off the number of deferrals at 1. This will be + // decremented by the Application's own `initialize` method. + _readinessDeferrals: 1, + init: function() { if (!this.$) { this.$ = Ember.$; } + this.__container__ = this.buildContainer(); + + this.Router = this.Router || this.defaultRouter(); + if (this.Router) { this.Router.namespace = this; } this._super(); - this.createEventDispatcher(); + this.deferUntilDOMReady(); + this.scheduleInitialize(); - // Start off the number of deferrals at 1. This will be - // decremented by the Application's own `initialize` method. - this._readinessDeferrals = 1; + Ember.debug('-------------------------------'); + Ember.debug('Ember.VERSION : ' + Ember.VERSION); + Ember.debug('Handlebars.VERSION : ' + Ember.Handlebars.VERSION); + Ember.debug('jQuery.VERSION : ' + Ember.$().jquery); + Ember.debug('-------------------------------'); + }, - this.waitForDOMContentLoaded(); + /** + @private - if (this.autoinit) { - var self = this; - this.$().ready(function() { - if (self.isDestroyed || self.isInitialized) return; - self.initialize(); - }); + Build the container for the current application. + + Also register a default application view in case the application + itself does not. + + @method buildContainer + @return {Ember.Container} the configured container + */ + buildContainer: function() { + var container = this.__container__ = Application.buildContainer(this); + + return container; + }, + + /** + @private + + If the application has not opted out of routing and has not explicitly + defined a router, supply a default router for the application author + to configure. + + This allows application developers to do: + + ```javascript + App = Ember.Application.create(); + + App.Router.map(function(match) { + match("/").to("index"); + }); + ``` + + @method defaultRouter + @return {Ember.Router} the default router + */ + defaultRouter: function() { + // Create a default App.Router if one was not supplied to make + // it possible to do App.Router.map(...) without explicitly + // creating a router first. + if (this.router === undefined) { + return Ember.Router.extend(); } }, - /** @private */ - createEventDispatcher: function() { - var rootElement = get(this, 'rootElement'), - eventDispatcher = Ember.EventDispatcher.create({ - rootElement: rootElement - }); + /** + @private - set(this, 'eventDispatcher', eventDispatcher); - }, + Defer Ember readiness until DOM readiness. By default, Ember + will wait for both DOM readiness and application initialization, + as well as any deferrals registered by initializers. - waitForDOMContentLoaded: function() { + @method deferUntilDOMReady + */ + deferUntilDOMReady: function() { this.deferReadiness(); var self = this; @@ -11508,11 +24986,63 @@ Ember.Application = Ember.Namespace.extend( }); }, + /** + @private + + Automatically initialize the application once the DOM has + become ready. + + The initialization itself is deferred using Ember.run.once, + which ensures that application loading finishes before + booting. + + If you are asynchronously loading code, you should call + `deferReadiness()` to defer booting, and then call + `advanceReadiness()` once all of your code has finished + loading. + + @method scheduleInitialize + */ + scheduleInitialize: function() { + var self = this; + this.$().ready(function() { + if (self.isDestroyed || self.isInitialized) return; + Ember.run.once(self, 'initialize'); + }); + }, + + /** + Use this to defer readiness until some condition is true. + + Example: + + ```javascript + App = Ember.Application.create(); + App.deferReadiness(); + + jQuery.getJSON("/auth-token", function(token) { + App.token = token; + App.advanceReadiness(); + }); + ``` + + This allows you to perform asynchronous setup logic and defer + booting your application until the setup has finished. + + However, if the setup requires a loading UI, it might be better + to use the router for this purpose. + + @method deferReadiness + */ deferReadiness: function() { Ember.assert("You cannot defer readiness since the `ready()` hook has already been called.", this._readinessDeferrals > 0); this._readinessDeferrals++; }, + /** + @method advanceReadiness + @see {Ember.Application#deferReadiness} + */ advanceReadiness: function() { this._readinessDeferrals--; @@ -11522,142 +25052,161 @@ Ember.Application = Ember.Namespace.extend( }, /** - Instantiate all controllers currently available on the namespace - and inject them onto a router. + registers a factory for later injection Example: - App.PostsController = Ember.ArrayController.extend(); - App.CommentsController = Ember.ArrayController.extend(); + ```javascript + App = Ember.Application.create(); - var router = Ember.Router.create({ - ... - }); + App.Person = Ember.Object.extend({}); + App.Orange = Ember.Object.extend({}); + App.Email = Ember.Object.extend({}); - App.initialize(router); + App.register('model:user', App.Person, {singleton: false }); + App.register('fruit:favorite', App.Orange); + App.register('communication:main', App.Email, {singleton: false}); + ``` - router.get('postsController') // - router.get('commentsController') // + @method register + @param type {String} + @param name {String} + @param factory {String} + @param options {String} (optional) + **/ + register: function() { + var container = this.__container__; + container.register.apply(container, arguments); + }, + /** + defines an injection or typeInjection + + Example: + + ```javascript + App.inject(, , ) + App.inject('model:user', 'email', 'model:email') + App.inject('model', 'source', 'source:main') + ``` + + @method inject + @param factoryNameOrType {String} + @param property {String} + @param injectionName {String} + **/ + inject: function(){ + var container = this.__container__; + container.injection.apply(container, arguments); + }, + + /** + @private + + Initialize the application. This happens automatically. + + Run any initializers and run the application load hook. These hooks may + choose to defer readiness. For example, an authentication hook might want + to defer readiness until the auth token has been retrieved. @method initialize - @param router {Ember.Router} */ - initialize: function(router) { - Ember.assert("Application initialize may only be call once", !this.isInitialized); - Ember.assert("Application not destroyed", !this.isDestroyed); - - router = this.setupRouter(router); - - this.runInjections(router); - - Ember.runLoadHooks('application', this); - + initialize: function() { + Ember.assert("Application initialize may only be called once", !this.isInitialized); + Ember.assert("Cannot initialize a destroyed application", !this.isDestroyed); this.isInitialized = true; - // At this point, any injections or load hooks that would have wanted - // to defer readiness have fired. + // At this point, the App.Router must already be assigned + this.__container__.register('router', 'main', this.Router); + + this.runInitializers(); + Ember.runLoadHooks('application', this); + + // At this point, any initializers or load hooks that would have wanted + // to defer readiness have fired. In general, advancing readiness here + // will proceed to didBecomeReady. this.advanceReadiness(); return this; }, - /** @private */ - runInjections: function(router) { - var injections = get(this.constructor, 'injections'), + reset: function() { + get(this, '__container__').destroy(); + this.buildContainer(); + + this.isInitialized = false; + this.initialize(); + this.startRouting(); + }, + + /** + @private + @method runInitializers + */ + runInitializers: function() { + var initializers = get(this.constructor, 'initializers'), + container = this.__container__, graph = new Ember.DAG(), namespace = this, - properties, i, injection; + properties, i, initializer; - for (i=0; i'; - } - - var childBuffers = this.childBuffers; - - Ember.ArrayPolyfills.forEach.call(childBuffers, function(buffer) { - var stringy = typeof buffer === 'string'; - content += (stringy ? buffer : buffer.string()); - }); - - if (tag) { - return openTag + content + ""; - } else { - return content; - } - }, - - _escapeAttribute: function(value) { - // Stolen shamelessly from Handlebars - - var escape = { - "<": "<", - ">": ">", - '"': """, - "'": "'", - "`": "`" - }; - - var badChars = /&(?!\w+;)|[<>"'`]/g; - var possible = /[&<>"'`]/; - - var escapeChar = function(chr) { - return escape[chr] || "&"; - }; - - var string = value.toString(); - - if(!possible.test(string)) { return string; } - return string.replace(badChars, escapeChar); - } - -}; - -})(); - - - -(function() { -/** -@module ember -@submodule ember-views -*/ - -var get = Ember.get, set = Ember.set, fmt = Ember.String.fmt; - -/** - Ember.EventDispatcher handles delegating browser events to their corresponding - Ember.Views. For example, when you click on a view, Ember.EventDispatcher ensures - that that view's `mouseDown` method gets called. - - @class EventDispatcher - @namespace Ember - @private - @extends Ember.Object -*/ -Ember.EventDispatcher = Ember.Object.extend( -/** @scope Ember.EventDispatcher.prototype */{ - - /** - @private - - The root DOM element to which event listeners should be attached. Event - listeners will be attached to the document unless this is overridden. - - Can be specified as a DOMElement or a selector string. - - The default body is a string since this may be evaluated before document.body - exists in the DOM. - - @property rootElement - @type DOMElement - @default 'body' - */ - rootElement: 'body', - - /** - @private - - Sets up event listeners for standard browser events. - - This will be called after the browser sends a DOMContentReady event. By - default, it will set up all of the listeners on the document body. If you - would like to register the listeners on a different element, set the event - dispatcher's `root` property. - - @method setup - @param addedEvents {Hash} - */ - setup: function(addedEvents) { - var event, events = { - touchstart : 'touchStart', - touchmove : 'touchMove', - touchend : 'touchEnd', - touchcancel : 'touchCancel', - keydown : 'keyDown', - keyup : 'keyUp', - keypress : 'keyPress', - mousedown : 'mouseDown', - mouseup : 'mouseUp', - contextmenu : 'contextMenu', - click : 'click', - dblclick : 'doubleClick', - mousemove : 'mouseMove', - focusin : 'focusIn', - focusout : 'focusOut', - mouseenter : 'mouseEnter', - mouseleave : 'mouseLeave', - submit : 'submit', - input : 'input', - change : 'change', - dragstart : 'dragStart', - drag : 'drag', - dragenter : 'dragEnter', - dragleave : 'dragLeave', - dragover : 'dragOver', - drop : 'drop', - dragend : 'dragEnd' - }; - - Ember.$.extend(events, addedEvents || {}); - - var rootElement = Ember.$(get(this, 'rootElement')); - - Ember.assert(fmt('You cannot use the same root element (%@) multiple times in an Ember.Application', [rootElement.selector || rootElement[0].tagName]), !rootElement.is('.ember-application')); - Ember.assert('You cannot make a new Ember.Application using a root element that is a descendent of an existing Ember.Application', !rootElement.closest('.ember-application').length); - Ember.assert('You cannot make a new Ember.Application using a root element that is an ancestor of an existing Ember.Application', !rootElement.find('.ember-application').length); - - rootElement.addClass('ember-application'); - - Ember.assert('Unable to add "ember-application" class to rootElement. Make sure you set rootElement to the body or an element in the body.', rootElement.is('.ember-application')); - - for (event in events) { - if (events.hasOwnProperty(event)) { - this.setupHandler(rootElement, event, events[event]); - } - } - }, - - /** - @private - - Registers an event listener on the document. If the given event is - triggered, the provided event handler will be triggered on the target - view. - - If the target view does not implement the event handler, or if the handler - returns false, the parent view will be called. The event will continue to - bubble to each successive parent view until it reaches the top. - - For example, to have the `mouseDown` method called on the target view when - a `mousedown` event is received from the browser, do the following: - - setupHandler('mousedown', 'mouseDown'); - - @method setupHandler - @param {Element} rootElement - @param {String} event the browser-originated event to listen to - @param {String} eventName the name of the method to call on the view - */ - setupHandler: function(rootElement, event, eventName) { - var self = this; - - rootElement.delegate('.ember-view', event + '.ember', function(evt, triggeringManager) { - return Ember.handleErrors(function() { - var view = Ember.View.views[this.id], - result = true, manager = null; - - manager = self._findNearestEventManager(view,eventName); - - if (manager && manager !== triggeringManager) { - result = self._dispatchEvent(manager, evt, eventName, view); - } else if (view) { - result = self._bubbleEvent(view,evt,eventName); - } else { - evt.stopPropagation(); - } - - return result; - }, this); - }); - - rootElement.delegate('[data-ember-action]', event + '.ember', function(evt) { - return Ember.handleErrors(function() { - var actionId = Ember.$(evt.currentTarget).attr('data-ember-action'), - action = Ember.Handlebars.ActionHelper.registeredActions[actionId], - handler = action.handler; - - if (action.eventName === eventName) { - return handler(evt); - } - }, this); - }); - }, - - _findNearestEventManager: function(view, eventName) { - var manager = null; - - while (view) { - manager = get(view, 'eventManager'); - if (manager && manager[eventName]) { break; } - - view = get(view, 'parentView'); - } - - return manager; - }, - - _dispatchEvent: function(object, evt, eventName, view) { - var result = true; - - var handler = object[eventName]; - if (Ember.typeOf(handler) === 'function') { - result = handler.call(object, evt, view); - // Do not preventDefault in eventManagers. - evt.stopPropagation(); - } - else { - result = this._bubbleEvent(view, evt, eventName); - } - - return result; - }, - - _bubbleEvent: function(view, evt, eventName) { - return Ember.run(function() { - return view.handleEvent(eventName, evt); - }); - }, - - destroy: function() { - var rootElement = get(this, 'rootElement'); - Ember.$(rootElement).undelegate('.ember').removeClass('ember-application'); - return this._super(); - } -}); - -})(); - - - -(function() { -/** -@module ember -@submodule ember-views -*/ - -// Add a new named queue for rendering views that happens -// after bindings have synced. -var queues = Ember.run.queues; -queues.splice(Ember.$.inArray('actions', queues)+1, 0, 'render'); - -})(); - - - -(function() { -/** -@module ember -@submodule ember-views -*/ - -var get = Ember.get, set = Ember.set; - -// Original class declaration and documentation in runtime/lib/controllers/controller.js -// NOTE: It may be possible with YUIDoc to combine docs in two locations - -/** -Additional methods for the ControllerMixin - -@class ControllerMixin -@namespace Ember -*/ -Ember.ControllerMixin.reopen({ - - target: null, - controllers: null, - namespace: null, - view: null, - - /** - `connectOutlet` creates a new instance of a provided view - class, wires it up to its associated controller, and - assigns the new view to a property on the current controller. - - The purpose of this method is to enable views that use - outlets to quickly assign new views for a given outlet. - - For example, an application view's template may look like - this: - - ``` handlebars -

    My Blog

    - {{outlet}} - ``` - - The view for this outlet is specified by assigning a - `view` property to the application's controller. The - following code will assign a new `App.PostsView` to - that outlet: - - ``` javascript - applicationController.connectOutlet('posts'); - ``` - - In general, you will also want to assign a controller - to the newly created view. By convention, a controller - named `postsController` will be assigned as the view's - controller. - - In an application initialized using `app.initialize(router)`, - `connectOutlet` will look for `postsController` on the - router. The initialization process will automatically - create an instance of `App.PostsController` called - `postsController`, so you don't need to do anything - beyond `connectOutlet` to assign your view and wire it - up to its associated controller. - - You can supply a `content` for the controller by supplying - a final argument after the view class: - - ``` javascript - applicationController.connectOutlet('posts', App.Post.find()); - ``` - - You can specify a particular outlet to use. For example, if your main - template looks like: - - ``` handlebars -

    My Blog

    - {{outlet masterView}} - {{outlet detailView}} - ``` - - You can assign an `App.PostsView` to the masterView outlet: - - ``` javascript - applicationController.connectOutlet({ - outletName: 'masterView', - name: 'posts', - context: App.Post.find() - }); - ``` - - You can write this as: - - ``` javascript - applicationController.connectOutlet('masterView', 'posts', App.Post.find()); - ``` - - - @method connectOutlet - @param {String} outletName a name for the outlet to set - @param {String} name a view/controller pair name - @param {Object} context a context object to assign to the - controller's `content` property, if a controller can be - found (optional) - */ - connectOutlet: function(name, context) { - // Normalize arguments. Supported arguments: - // - // name - // name, context - // outletName, name - // outletName, name, context - // options - // - // The options hash has the following keys: - // - // name: the name of the controller and view - // to use. If this is passed, the name - // determines the view and controller. - // outletName: the name of the outlet to - // fill in. default: 'view' - // viewClass: the class of the view to instantiate - // controller: the controller instance to pass - // to the view - // context: an object that should become the - // controller's `content` and thus the - // template's context. - - var outletName, viewClass, view, controller, options; - - if (Ember.typeOf(context) === 'string') { - outletName = name; - name = context; - context = arguments[2]; - } - - if (arguments.length === 1) { - if (Ember.typeOf(name) === 'object') { - options = name; - outletName = options.outletName; - name = options.name; - viewClass = options.viewClass; - controller = options.controller; - context = options.context; - } - } else { - options = {}; - } - - outletName = outletName || 'view'; - - Ember.assert("The viewClass is either missing or the one provided did not resolve to a view", !!name || (!name && !!viewClass)); - - Ember.assert("You must supply a name or a viewClass to connectOutlet, but not both", (!!name && !viewClass && !controller) || (!name && !!viewClass)); - - if (name) { - var namespace = get(this, 'namespace'), - controllers = get(this, 'controllers'); - - var viewClassName = name.charAt(0).toUpperCase() + name.substr(1) + "View"; - viewClass = get(namespace, viewClassName); - controller = get(controllers, name + 'Controller'); - - Ember.assert("The name you supplied " + name + " did not resolve to a view " + viewClassName, !!viewClass); - Ember.assert("The name you supplied " + name + " did not resolve to a controller " + name + 'Controller', (!!controller && !!context) || !context); - } - - if (controller && context) { set(controller, 'content', context); } - - view = this.createOutletView(outletName, viewClass); - - if (controller) { set(view, 'controller', controller); } - set(this, outletName, view); - - return view; - }, - - /** - Convenience method to connect controllers. This method makes other controllers - available on the controller the method was invoked on. - - For example, to make the `personController` and the `postController` available - on the `overviewController`, you would call: - - overviewController.connectControllers('person', 'post'); - - @method connectControllers - @param {String...} controllerNames the controllers to make available - */ - connectControllers: function() { - var controllers = get(this, 'controllers'), - controllerNames = Array.prototype.slice.apply(arguments), - controllerName; - - for (var i=0, l=controllerNames.length; i - ``` - - ## HTML `class` Attribute - The HTML `class` attribute of a view's tag can be set by providing a `classNames` property - that is set to an array of strings: - - ``` javascript - MyView = Ember.View.extend({ - classNames: ['my-class', 'my-other-class'] - }); - ``` - - Will result in view instances with an HTML representation of: - - ``` html -
    - ``` - - `class` attribute values can also be set by providing a `classNameBindings` property - set to an array of properties names for the view. The return value of these properties - will be added as part of the value for the view's `class` attribute. These properties - can be computed properties: - - ``` javascript - MyView = Ember.View.extend({ - classNameBindings: ['propertyA', 'propertyB'], - propertyA: 'from-a', - propertyB: function(){ - if(someLogic){ return 'from-b'; } - }.property() - }); - ``` - - Will result in view instances with an HTML representation of: - - ``` html -
    - ``` - - If the value of a class name binding returns a boolean the property name itself - will be used as the class name if the property is true. The class name will - not be added if the value is `false` or `undefined`. - - ``` javascript - MyView = Ember.View.extend({ - classNameBindings: ['hovered'], - hovered: true - }); - ``` - - Will result in view instances with an HTML representation of: - - ``` html -
    - ``` - - When using boolean class name bindings you can supply a string value other than the - property name for use as the `class` HTML attribute by appending the preferred value after - a ":" character when defining the binding: - - ``` javascript - MyView = Ember.View.extend({ - classNameBindings: ['awesome:so-very-cool'], - awesome: true - }); - ``` - - Will result in view instances with an HTML representation of: - - ``` html -
    - ``` - - - Boolean value class name bindings whose property names are in a camelCase-style - format will be converted to a dasherized format: - - ``` javascript - MyView = Ember.View.extend({ - classNameBindings: ['isUrgent'], - isUrgent: true - }); - ``` - - Will result in view instances with an HTML representation of: - - ``` html -
    - ``` - - - Class name bindings can also refer to object values that are found by - traversing a path relative to the view itself: - - ``` javascript - MyView = Ember.View.extend({ - classNameBindings: ['messages.empty'] - messages: Ember.Object.create({ - empty: true - }) - }); - ``` - - Will result in view instances with an HTML representation of: - - ``` html -
    - ``` - - - If you want to add a class name for a property which evaluates to true and - and a different class name if it evaluates to false, you can pass a binding - like this: - - ``` - // Applies 'enabled' class when isEnabled is true and 'disabled' when isEnabled is false - Ember.View.create({ - classNameBindings: ['isEnabled:enabled:disabled'] - isEnabled: true - }); - ``` - - Will result in view instances with an HTML representation of: - - ``` html -
    - ``` - - When isEnabled is `false`, the resulting HTML reprensentation looks like this: - - ``` html -
    - ``` - - This syntax offers the convenience to add a class if a property is `false`: - - ``` javascript - // Applies no class when isEnabled is true and class 'disabled' when isEnabled is false - Ember.View.create({ - classNameBindings: ['isEnabled::disabled'] - isEnabled: true - }); - ``` - - Will result in view instances with an HTML representation of: - - ``` html -
    - ``` - - When the `isEnabled` property on the view is set to `false`, it will result - in view instances with an HTML representation of: - - ``` html -
    - ``` - - Updates to the the value of a class name binding will result in automatic update - of the HTML `class` attribute in the view's rendered HTML representation. - If the value becomes `false` or `undefined` the class name will be removed. - - Both `classNames` and `classNameBindings` are concatenated properties. - See `Ember.Object` documentation for more information about concatenated properties. - - ## HTML Attributes - - The HTML attribute section of a view's tag can be set by providing an `attributeBindings` - property set to an array of property names on the view. The return value of these properties - will be used as the value of the view's HTML associated attribute: - - ``` javascript - AnchorView = Ember.View.extend({ - tagName: 'a', - attributeBindings: ['href'], - href: 'http://google.com' - }); - ``` - - Will result in view instances with an HTML representation of: - - ``` html - - ``` - - If the return value of an `attributeBindings` monitored property is a boolean - the property will follow HTML's pattern of repeating the attribute's name as - its value: - - ``` javascript - MyTextInput = Ember.View.extend({ - tagName: 'input', - attributeBindings: ['disabled'], - disabled: true - }); - ``` - - Will result in view instances with an HTML representation of: - - ``` html - - ``` - - `attributeBindings` can refer to computed properties: - - ``` javascript - MyTextInput = Ember.View.extend({ - tagName: 'input', - attributeBindings: ['disabled'], - disabled: function(){ - if (someLogic) { - return true; - } else { - return false; - } - }.property() - }); - ``` - - Updates to the the property of an attribute binding will result in automatic update - of the HTML attribute in the view's rendered HTML representation. - - `attributeBindings` is a concatenated property. See `Ember.Object` documentation - for more information about concatenated properties. - - ## Templates - The HTML contents of a view's rendered representation are determined by its template. - Templates can be any function that accepts an optional context parameter and returns - a string of HTML that will be inserted within the view's tag. Most - typically in Ember this function will be a compiled Ember.Handlebars template. - - ``` javascript - AView = Ember.View.extend({ - template: Ember.Handlebars.compile('I am the template') - }); - ``` - - Will result in view instances with an HTML representation of: - - ``` html -
    I am the template
    - ``` - - The default context of the compiled template will be the view instance itself: - - ``` javascript - AView = Ember.View.extend({ - template: Ember.Handlebars.compile('Hello {{excitedGreeting}}') - }); - - aView = AView.create({ - content: Ember.Object.create({ - firstName: 'Barry' - }) - excitedGreeting: function(){ - return this.get("content.firstName") + "!!!" - } - }); - ``` - - Will result in an HTML representation of: - - ``` html -
    Hello Barry!!!
    - ``` - - Within an Ember application is more common to define a Handlebars templates as - part of a page: - - ``` handlebars - - ``` - - And associate it by name using a view's `templateName` property: - - ``` javascript - AView = Ember.View.extend({ - templateName: 'some-template' - }); - ``` - - Using a value for `templateName` that does not have a Handlebars template with a - matching `data-template-name` attribute will throw an error. - - Assigning a value to both `template` and `templateName` properties will throw an error. - - For views classes that may have a template later defined (e.g. as the block portion of a `{{view}}` - Handlebars helper call in another template or in a subclass), you can provide a `defaultTemplate` - property set to compiled template function. If a template is not later provided for the view - instance the `defaultTemplate` value will be used: - - ``` javascript - AView = Ember.View.extend({ - defaultTemplate: Ember.Handlebars.compile('I was the default'), - template: null, - templateName: null - }); - ``` - - Will result in instances with an HTML representation of: - - ``` html -
    I was the default
    - ``` - - If a `template` or `templateName` is provided it will take precedence over `defaultTemplate`: - - ``` javascript - AView = Ember.View.extend({ - defaultTemplate: Ember.Handlebars.compile('I was the default') - }); - - aView = AView.create({ - template: Ember.Handlebars.compile('I was the template, not default') - }); - ``` - - Will result in the following HTML representation when rendered: - - ``` html -
    I was the template, not default
    - ``` - - ## Layouts - - Views can have a secondary template that wraps their main template. Like - primary templates, layouts can be any function that accepts an optional context - parameter and returns a string of HTML that will be inserted inside view's tag. Views whose HTML - element is self closing (e.g. ``) cannot have a layout and this property will be ignored. - - Most typically in Ember a layout will be a compiled Ember.Handlebars template. - - A view's layout can be set directly with the `layout` property or reference an - existing Handlebars template by name with the `layoutName` property. - - A template used as a layout must contain a single use of the Handlebars `{{yield}}` - helper. The HTML contents of a view's rendered `template` will be inserted at this location: - - ``` javascript - AViewWithLayout = Ember.View.extend({ - layout: Ember.Handlebars.compile("
    {{yield}}
    ") - template: Ember.Handlebars.compile("I got wrapped"), - }); - ``` - - Will result in view instances with an HTML representation of: - - ``` html -
    -
    - I got wrapped -
    -
    - ``` - - See `Handlebars.helpers.yield` for more information. - - ## Responding to Browser Events - - Views can respond to user-initiated events in one of three ways: method implementation, - through an event manager, and through `{{action}}` helper use in their template or layout. - - ### Method Implementation - - Views can respond to user-initiated events by implementing a method that matches the - event name. A `jQuery.Event` object will be passed as the argument to this method. - - ``` javascript - AView = Ember.View.extend({ - click: function(event){ - // will be called when when an instance's - // rendered element is clicked - } - }); - ``` - - ### Event Managers - - Views can define an object as their `eventManager` property. This object can then - implement methods that match the desired event names. Matching events that occur - on the view's rendered HTML or the rendered HTML of any of its DOM descendants - will trigger this method. A `jQuery.Event` object will be passed as the first - argument to the method and an `Ember.View` object as the second. The `Ember.View` - will be the view whose rendered HTML was interacted with. This may be the view with - the `eventManager` property or one of its descendent views. - - ``` javascript - AView = Ember.View.extend({ - eventManager: Ember.Object.create({ - doubleClick: function(event, view){ - // will be called when when an instance's - // rendered element or any rendering - // of this views's descendent - // elements is clicked - } - }) - }); - ``` - - - An event defined for an event manager takes precedence over events of the same - name handled through methods on the view. - - ``` javascript - AView = Ember.View.extend({ - mouseEnter: function(event){ - // will never trigger. - }, - eventManager: Ember.Object.create({ - mouseEnter: function(event, view){ - // takes presedence over AView#mouseEnter - } - }) - }); - ``` - - Similarly a view's event manager will take precedence for events of any views - rendered as a descendent. A method name that matches an event name will not be called - if the view instance was rendered inside the HTML representation of a view that has - an `eventManager` property defined that handles events of the name. Events not handled - by the event manager will still trigger method calls on the descendent. - - ``` javascript - OuterView = Ember.View.extend({ - template: Ember.Handlebars.compile("outer {{#view InnerView}}inner{{/view}} outer"), - eventManager: Ember.Object.create({ - mouseEnter: function(event, view){ - // view might be instance of either - // OutsideView or InnerView depending on - // where on the page the user interaction occured - } - }) - }); - - InnerView = Ember.View.extend({ - click: function(event){ - // will be called if rendered inside - // an OuterView because OuterView's - // eventManager doesn't handle click events - }, - mouseEnter: function(event){ - // will never be called if rendered inside - // an OuterView. - } - }); - ``` - - ### Handlebars `{{action}}` Helper - - See `Handlebars.helpers.action`. - - ### Event Names - - Possible events names for any of the responding approaches described above are: - - Touch events: 'touchStart', 'touchMove', 'touchEnd', 'touchCancel' - - Keyboard events: 'keyDown', 'keyUp', 'keyPress' - - Mouse events: 'mouseDown', 'mouseUp', 'contextMenu', 'click', 'doubleClick', 'mouseMove', - 'focusIn', 'focusOut', 'mouseEnter', 'mouseLeave' - - Form events: 'submit', 'change', 'focusIn', 'focusOut', 'input' - - HTML5 drag and drop events: 'dragStart', 'drag', 'dragEnter', 'dragLeave', 'drop', 'dragEnd' - - ## Handlebars `{{view}}` Helper - - Other `Ember.View` instances can be included as part of a view's template by using the `{{view}}` - Handlebars helper. See `Handlebars.helpers.view` for additional information. - - @class View - @namespace Ember - @extends Ember.Object - @uses Ember.Evented -*/ -Ember.View = Ember.CoreView.extend( -/** @scope Ember.View.prototype */ { - - concatenatedProperties: ['classNames', 'classNameBindings', 'attributeBindings'], - - /** - @property isView - @type Boolean - @default true - @final - */ - isView: true, - - // .......................................................... - // TEMPLATE SUPPORT - // - - /** - The name of the template to lookup if no template is provided. - - Ember.View will look for a template with this name in this view's - `templates` object. By default, this will be a global object - shared in `Ember.TEMPLATES`. - - @property templateName - @type String - @default null - */ - templateName: null, - - /** - The name of the layout to lookup if no layout is provided. - - Ember.View will look for a template with this name in this view's - `templates` object. By default, this will be a global object - shared in `Ember.TEMPLATES`. - - @property layoutName - @type String - @default null - */ - layoutName: null, - - /** - The hash in which to look for `templateName`. - - @property templates - @type Ember.Object - @default Ember.TEMPLATES - */ - templates: Ember.TEMPLATES, - - /** - The template used to render the view. This should be a function that - accepts an optional context parameter and returns a string of HTML that - will be inserted into the DOM relative to its parent view. - - In general, you should set the `templateName` property instead of setting - the template yourself. - - @property template - @type Function - */ - template: Ember.computed(function(key, value) { - if (value !== undefined) { return value; } - - var templateName = get(this, 'templateName'), - template = this.templateForName(templateName, 'template'); - - return template || get(this, 'defaultTemplate'); - }).property('templateName'), - - /** - The controller managing this view. If this property is set, it will be - made available for use by the template. - - @property controller - @type Object - */ - controller: Ember.computed(function(key, value) { - var parentView; - - if (arguments.length === 2) { - return value; - } else { - parentView = get(this, 'parentView'); - return parentView ? get(parentView, 'controller') : null; - } - }).property(), - - /** - A view may contain a layout. A layout is a regular template but - supersedes the `template` property during rendering. It is the - responsibility of the layout template to retrieve the `template` - property from the view (or alternatively, call `Handlebars.helpers.yield`, - `{{yield}}`) to render it in the correct location. - - This is useful for a view that has a shared wrapper, but which delegates - the rendering of the contents of the wrapper to the `template` property - on a subclass. - - @property layout - @type Function - */ - layout: Ember.computed(function(key, value) { - if (arguments.length === 2) { return value; } - - var layoutName = get(this, 'layoutName'), - layout = this.templateForName(layoutName, 'layout'); - - return layout || get(this, 'defaultLayout'); - }).property('layoutName'), - - templateForName: function(name, type) { - if (!name) { return; } - - var templates = get(this, 'templates'), - template = get(templates, name); - - if (!template) { - throw new Ember.Error(fmt('%@ - Unable to find %@ "%@".', [this, type, name])); - } - - return template; - }, - - /** - The object from which templates should access properties. - - This object will be passed to the template function each time the render - method is called, but it is up to the individual function to decide what - to do with it. - - By default, this will be the view itself. - - @property context - @type Object - */ - context: Ember.computed(function(key, value) { - if (arguments.length === 2) { - set(this, '_context', value); - return value; - } else { - return get(this, '_context'); - } - }).volatile(), - - /** - @private - - Private copy of the view's template context. This can be set directly - by Handlebars without triggering the observer that causes the view - to be re-rendered. - - The context of a view is looked up as follows: - - 1. Supplied context (usually by Handlebars) - 2. Specified controller - 3. `parentView`'s context (for a child of a ContainerView) - - The code in Handlebars that overrides the `_context` property first - checks to see whether the view has a specified controller. This is - something of a hack and should be revisited. - - @property _context - */ - _context: Ember.computed(function(key, value) { - var parentView, controller; - - if (arguments.length === 2) { - return value; - } - - if (controller = get(this, 'controller')) { - return controller; - } - - parentView = get(this, '_parentView'); - if (parentView) { - return get(parentView, '_context'); - } - - return this; - }), - - /** - @private - - If a value that affects template rendering changes, the view should be - re-rendered to reflect the new value. - - @method _displayPropertyDidChange - */ - _displayPropertyDidChange: Ember.observer(function() { - this.rerender(); - }, 'context', 'controller'), - - /** - If false, the view will appear hidden in DOM. - - @property isVisible - @type Boolean - @default null - */ - isVisible: true, - - /** - @private - - Array of child views. You should never edit this array directly. - Instead, use appendChild and removeFromParent. - - @property childViews - @type Array - @default [] - */ - childViews: childViewsProperty, - - _childViews: [], - - // When it's a virtual view, we need to notify the parent that their - // childViews will change. - _childViewsWillChange: Ember.beforeObserver(function() { - if (this.isVirtual) { - var parentView = get(this, 'parentView'); - if (parentView) { Ember.propertyWillChange(parentView, 'childViews'); } - } - }, 'childViews'), - - // When it's a virtual view, we need to notify the parent that their - // childViews did change. - _childViewsDidChange: Ember.observer(function() { - if (this.isVirtual) { - var parentView = get(this, 'parentView'); - if (parentView) { Ember.propertyDidChange(parentView, 'childViews'); } - } - }, 'childViews'), - - /** - Return the nearest ancestor that is an instance of the provided - class. - - @property nearestInstanceOf - @param {Class} klass Subclass of Ember.View (or Ember.View itself) - @return Ember.View - @deprecated - */ - nearestInstanceOf: function(klass) { - Ember.deprecate("nearestInstanceOf is deprecated and will be removed from future releases. Use nearestOfType."); - var view = get(this, 'parentView'); - - while (view) { - if(view instanceof klass) { return view; } - view = get(view, 'parentView'); - } - }, - - /** - Return the nearest ancestor that is an instance of the provided - class or mixin. - - @proprty nearestOfType - @param {Class,Mixin} klass Subclass of Ember.View (or Ember.View itself), - or an instance of Ember.Mixin. - @return Ember.View - */ - nearestOfType: function(klass) { - var view = get(this, 'parentView'), - isOfType = klass instanceof Ember.Mixin ? - function(view) { return klass.detect(view); } : - function(view) { return klass.detect(view.constructor); }; - - while (view) { - if( isOfType(view) ) { return view; } - view = get(view, 'parentView'); - } - }, - - /** - Return the nearest ancestor that has a given property. - - @property nearestWithProperty - @param {String} property A property name - @return Ember.View - */ - nearestWithProperty: function(property) { - var view = get(this, 'parentView'); - - while (view) { - if (property in view) { return view; } - view = get(view, 'parentView'); - } - }, - - /** - Return the nearest ancestor whose parent is an instance of - `klass`. - - @property nearestChildOf - @param {Class} klass Subclass of Ember.View (or Ember.View itself) - @return Ember.View - */ - nearestChildOf: function(klass) { - var view = get(this, 'parentView'); - - while (view) { - if(get(view, 'parentView') instanceof klass) { return view; } - view = get(view, 'parentView'); - } - }, - - /** - Return the nearest ancestor that is an Ember.CollectionView - - @property collectionView - @return Ember.CollectionView - */ - collectionView: Ember.computed(function() { - return this.nearestOfType(Ember.CollectionView); - }), - - /** - Return the nearest ancestor that is a direct child of - an Ember.CollectionView - - @property itemView - @return Ember.View - */ - itemView: Ember.computed(function() { - return this.nearestChildOf(Ember.CollectionView); - }), - - /** - Return the nearest ancestor that has the property - `content`. - - @property contentView - @return Ember.View - */ - contentView: Ember.computed(function() { - return this.nearestWithProperty('content'); - }), - - /** - @private - - When the parent view changes, recursively invalidate - collectionView, itemView, and contentView - - @method _parentViewDidChange - */ - _parentViewDidChange: Ember.observer(function() { - if (this.isDestroying) { return; } - - this.invokeRecursively(function(view) { - view.propertyDidChange('collectionView'); - view.propertyDidChange('itemView'); - view.propertyDidChange('contentView'); - }); - - if (get(this, 'parentView.controller') && !get(this, 'controller')) { - this.notifyPropertyChange('controller'); - } - }, '_parentView'), - - _controllerDidChange: Ember.observer(function() { - if (this.isDestroying) { return; } - - this.forEachChildView(function(view) { - view.propertyDidChange('controller'); - }); - }, 'controller'), - - cloneKeywords: function() { - var templateData = get(this, 'templateData'); - - var keywords = templateData ? Ember.copy(templateData.keywords) : {}; - set(keywords, 'view', get(this, 'concreteView')); - set(keywords, 'controller', get(this, 'controller')); - - return keywords; - }, - - /** - Called on your view when it should push strings of HTML into a - Ember.RenderBuffer. Most users will want to override the `template` - or `templateName` properties instead of this method. - - By default, Ember.View will look for a function in the `template` - property and invoke it with the value of `context`. The value of - `context` will be the view's controller unless you override it. - - @method render - @param {Ember.RenderBuffer} buffer The render buffer - */ - render: function(buffer) { - // If this view has a layout, it is the responsibility of the - // the layout to render the view's template. Otherwise, render the template - // directly. - var template = get(this, 'layout') || get(this, 'template'); - - if (template) { - var context = get(this, 'context'); - var keywords = this.cloneKeywords(); - - var data = { - view: this, - buffer: buffer, - isRenderData: true, - keywords: keywords - }; - - // Invoke the template with the provided template context, which - // is the view by default. A hash of data is also passed that provides - // the template with access to the view and render buffer. - - Ember.assert('template must be a function. Did you mean to call Ember.Handlebars.compile("...") or specify templateName instead?', typeof template === 'function'); - // The template should write directly to the render buffer instead - // of returning a string. - var output = template(context, { data: data }); - - // If the template returned a string instead of writing to the buffer, - // push the string onto the buffer. - if (output !== undefined) { buffer.push(output); } - } - }, - - invokeForState: function(name) { - var stateName = this.state, args, fn; - - // try to find the function for the state in the cache - if (fn = invokeForState[stateName][name]) { - args = a_slice.call(arguments); - args[0] = this; - - return fn.apply(this, args); - } - - // otherwise, find and cache the function for this state - var parent = this, states = parent.states, state; - - while (states) { - state = states[stateName]; - - while (state) { - fn = state[name]; - - if (fn) { - invokeForState[stateName][name] = fn; - - args = a_slice.call(arguments, 1); - args.unshift(this); - - return fn.apply(this, args); - } - - state = state.parentState; - } - - states = states.parent; - } - }, - - /** - Renders the view again. This will work regardless of whether the - view is already in the DOM or not. If the view is in the DOM, the - rendering process will be deferred to give bindings a chance - to synchronize. - - If children were added during the rendering process using `appendChild`, - `rerender` will remove them, because they will be added again - if needed by the next `render`. - - In general, if the display of your view changes, you should modify - the DOM element directly instead of manually calling `rerender`, which can - be slow. - - @method rerender - */ - rerender: function() { - return this.invokeForState('rerender'); - }, - - clearRenderedChildren: function() { - var lengthBefore = this.lengthBeforeRender, - lengthAfter = this.lengthAfterRender; - - // If there were child views created during the last call to render(), - // remove them under the assumption that they will be re-created when - // we re-render. - - // VIEW-TODO: Unit test this path. - var childViews = this._childViews; - for (var i=lengthAfter-1; i>=lengthBefore; i--) { - if (childViews[i]) { childViews[i].destroy(); } - } - }, - - /** - @private - - Iterates over the view's `classNameBindings` array, inserts the value - of the specified property into the `classNames` array, then creates an - observer to update the view's element if the bound property ever changes - in the future. - - @method _applyClassNameBindings - */ - _applyClassNameBindings: function() { - var classBindings = get(this, 'classNameBindings'), - classNames = get(this, 'classNames'), - elem, newClass, dasherizedClass; - - if (!classBindings) { return; } - - // Loop through all of the configured bindings. These will be either - // property names ('isUrgent') or property paths relative to the view - // ('content.isUrgent') - a_forEach(classBindings, function(binding) { - - // Variable in which the old class value is saved. The observer function - // closes over this variable, so it knows which string to remove when - // the property changes. - var oldClass; - // Extract just the property name from bindings like 'foo:bar' - var parsedPath = Ember.View._parsePropertyPath(binding); - - // Set up an observer on the context. If the property changes, toggle the - // class name. - var observer = function() { - // Get the current value of the property - newClass = this._classStringForProperty(binding); - elem = this.$(); - if (!elem) { - removeObserver(this, parsedPath.path, observer); - return; - } - - // If we had previously added a class to the element, remove it. - if (oldClass) { - elem.removeClass(oldClass); - // Also remove from classNames so that if the view gets rerendered, - // the class doesn't get added back to the DOM. - classNames.removeObject(oldClass); - } - - // If necessary, add a new class. Make sure we keep track of it so - // it can be removed in the future. - if (newClass) { - elem.addClass(newClass); - oldClass = newClass; - } else { - oldClass = null; - } - }; - - // Get the class name for the property at its current value - dasherizedClass = this._classStringForProperty(binding); - - if (dasherizedClass) { - // Ensure that it gets into the classNames array - // so it is displayed when we render. - classNames.push(dasherizedClass); - - // Save a reference to the class name so we can remove it - // if the observer fires. Remember that this variable has - // been closed over by the observer. - oldClass = dasherizedClass; - } - - addObserver(this, parsedPath.path, observer); - - this.one('willClearRender', function() { - removeObserver(this, parsedPath.path, observer); - }); - }, this); - }, - - /** - @private - - Iterates through the view's attribute bindings, sets up observers for each, - then applies the current value of the attributes to the passed render buffer. - - @method _applyAttributeBindings - @param {Ember.RenderBuffer} buffer - */ - _applyAttributeBindings: function(buffer) { - var attributeBindings = get(this, 'attributeBindings'), - attributeValue, elem, type; - - if (!attributeBindings) { return; } - - a_forEach(attributeBindings, function(binding) { - var split = binding.split(':'), - property = split[0], - attributeName = split[1] || property; - - // Create an observer to add/remove/change the attribute if the - // JavaScript property changes. - var observer = function() { - elem = this.$(); - if (!elem) { return; } - - attributeValue = get(this, property); - - Ember.View.applyAttributeBindings(elem, attributeName, attributeValue); - }; - - addObserver(this, property, observer); - - this.one('willClearRender', function() { - removeObserver(this, property, observer); - }); - - // Determine the current value and add it to the render buffer - // if necessary. - attributeValue = get(this, property); - Ember.View.applyAttributeBindings(buffer, attributeName, attributeValue); - }, this); - }, - - /** - @private - - Given a property name, returns a dasherized version of that - property name if the property evaluates to a non-falsy value. - - For example, if the view has property `isUrgent` that evaluates to true, - passing `isUrgent` to this method will return `"is-urgent"`. - - @method _classStringForProperty - @param property - */ - _classStringForProperty: function(property) { - var parsedPath = Ember.View._parsePropertyPath(property); - var path = parsedPath.path; - - var val = get(this, path); - if (val === undefined && Ember.isGlobalPath(path)) { - val = get(Ember.lookup, path); - } - - return Ember.View._classStringForValue(path, val, parsedPath.className, parsedPath.falsyClassName); - }, - - // .......................................................... - // ELEMENT SUPPORT - // - - /** - Returns the current DOM element for the view. - - @property element - @type DOMElement - */ - element: Ember.computed(function(key, value) { - if (value !== undefined) { - return this.invokeForState('setElement', value); - } else { - return this.invokeForState('getElement'); - } - }).property('_parentView'), - - /** - Returns a jQuery object for this view's element. If you pass in a selector - string, this method will return a jQuery object, using the current element - as its buffer. - - For example, calling `view.$('li')` will return a jQuery object containing - all of the `li` elements inside the DOM element of this view. - - @property $ - @param {String} [selector] a jQuery-compatible selector string - @return {jQuery} the CoreQuery object for the DOM node - */ - $: function(sel) { - return this.invokeForState('$', sel); - }, - - mutateChildViews: function(callback) { - var childViews = this._childViews, - idx = childViews.length, - view; - - while(--idx >= 0) { - view = childViews[idx]; - callback.call(this, view, idx); - } - - return this; - }, - - forEachChildView: function(callback) { - var childViews = this._childViews; - - if (!childViews) { return this; } - - var len = childViews.length, - view, idx; - - for(idx = 0; idx < len; idx++) { - view = childViews[idx]; - callback.call(this, view); - } - - return this; - }, - - /** - Appends the view's element to the specified parent element. - - If the view does not have an HTML representation yet, `createElement()` - will be called automatically. - - Note that this method just schedules the view to be appended; the DOM - element will not be appended to the given element until all bindings have - finished synchronizing. - - This is not typically a function that you will need to call directly - when building your application. You might consider using Ember.ContainerView - instead. If you do need to use appendTo, be sure that the target element you - are providing is associated with an Ember.Application and does not have an - ancestor element that is associated with an Ember view. - - @method appendTo - @param {String|DOMElement|jQuery} A selector, element, HTML string, or jQuery object - @return {Ember.View} receiver - */ - appendTo: function(target) { - // Schedule the DOM element to be created and appended to the given - // element after bindings have synchronized. - this._insertElementLater(function() { - Ember.assert("You cannot append to an existing Ember.View. Consider using Ember.ContainerView instead.", !Ember.$(target).is('.ember-view') && !Ember.$(target).parents().is('.ember-view')); - this.$().appendTo(target); - }); - - return this; - }, - - /** - Replaces the content of the specified parent element with this view's element. - If the view does not have an HTML representation yet, `createElement()` - will be called automatically. - - Note that this method just schedules the view to be appended; the DOM - element will not be appended to the given element until all bindings have - finished synchronizing - - @method replaceIn - @param {String|DOMElement|jQuery} A selector, element, HTML string, or jQuery object - @return {Ember.View} received - */ - replaceIn: function(target) { - Ember.assert("You cannot replace an existing Ember.View. Consider using Ember.ContainerView instead.", !Ember.$(target).is('.ember-view') && !Ember.$(target).parents().is('.ember-view')); - - this._insertElementLater(function() { - Ember.$(target).empty(); - this.$().appendTo(target); - }); - - return this; - }, - - /** - @private - - Schedules a DOM operation to occur during the next render phase. This - ensures that all bindings have finished synchronizing before the view is - rendered. - - To use, pass a function that performs a DOM operation.. - - Before your function is called, this view and all child views will receive - the `willInsertElement` event. After your function is invoked, this view - and all of its child views will receive the `didInsertElement` event. - - view._insertElementLater(function() { - this.createElement(); - this.$().appendTo('body'); - }); - - @method _insertElementLater - @param {Function} fn the function that inserts the element into the DOM - */ - _insertElementLater: function(fn) { - this._scheduledInsert = Ember.run.scheduleOnce('render', this, '_insertElement', fn); - }, - - /** - @private - */ - _insertElement: function (fn) { - this._scheduledInsert = null; - this.invokeForState('insertElement', fn); - }, - - /** - Appends the view's element to the document body. If the view does - not have an HTML representation yet, `createElement()` will be called - automatically. - - Note that this method just schedules the view to be appended; the DOM - element will not be appended to the document body until all bindings have - finished synchronizing. - - @method append - @return {Ember.View} receiver - */ - append: function() { - return this.appendTo(document.body); - }, - - /** - Removes the view's element from the element to which it is attached. - - @method remove - @return {Ember.View} receiver - */ - remove: function() { - // What we should really do here is wait until the end of the run loop - // to determine if the element has been re-appended to a different - // element. - // In the interim, we will just re-render if that happens. It is more - // important than elements get garbage collected. - this.destroyElement(); - this.invokeRecursively(function(view) { - view.clearRenderedChildren(); - }); - }, - - /** - The ID to use when trying to locate the element in the DOM. If you do not - set the elementId explicitly, then the view's GUID will be used instead. - This ID must be set at the time the view is created. - - @property elementId - @type String - */ - elementId: Ember.computed(function(key, value) { - return value !== undefined ? value : Ember.guidFor(this); - }), - - // TODO: Perhaps this should be removed from the production build somehow. - _elementIdDidChange: Ember.beforeObserver(function() { - throw "Changing a view's elementId after creation is not allowed."; - }, 'elementId'), - - /** - Attempts to discover the element in the parent element. The default - implementation looks for an element with an ID of elementId (or the view's - guid if elementId is null). You can override this method to provide your - own form of lookup. For example, if you want to discover your element - using a CSS class name instead of an ID. - - @method findElementInParentElement - @param {DOMElement} parentElement The parent's DOM element - @return {DOMElement} The discovered element - */ - findElementInParentElement: function(parentElem) { - var id = "#" + get(this, 'elementId'); - return Ember.$(id)[0] || Ember.$(id, parentElem)[0]; - }, - - /** - Creates a DOM representation of the view and all of its - child views by recursively calling the `render()` method. - - After the element has been created, `didInsertElement` will - be called on this view and all of its child views. - - @method createElement - @return {Ember.View} receiver - */ - createElement: function() { - if (get(this, 'element')) { return this; } - - var buffer = this.renderToBuffer(); - set(this, 'element', buffer.element()); - - return this; - }, - - /** - Called when a view is going to insert an element into the DOM. - - @event willInsertElement - */ - willInsertElement: Ember.K, - - /** - Called when the element of the view has been inserted into the DOM. - Override this function to do any set up that requires an element in the - document body. - - @event didInsertElement - */ - didInsertElement: Ember.K, - - /** - Called when the view is about to rerender, but before anything has - been torn down. This is a good opportunity to tear down any manual - observers you have installed based on the DOM state - - @event willClearRender - */ - willClearRender: Ember.K, - - /** - @private - - Run this callback on the current view and recursively on child views. - - @method invokeRecursively - @param fn {Function} - */ - invokeRecursively: function(fn) { - fn.call(this, this); - - this.forEachChildView(function(view) { - view.invokeRecursively(fn); - }); - }, - - /** - Invalidates the cache for a property on all child views. - - @method invalidateRecursively - */ - invalidateRecursively: function(key) { - this.forEachChildView(function(view) { - view.propertyDidChange(key); - }); - }, - - /** - @private - - Invokes the receiver's willInsertElement() method if it exists and then - invokes the same on all child views. - - NOTE: In some cases this was called when the element existed. This no longer - works so we let people know. We can remove this warning code later. - - @method _notifyWillInsertElement - */ - _notifyWillInsertElement: function() { - this.invokeRecursively(function(view) { - view.trigger('willInsertElement'); - }); - }, - - /** - @private - - Invokes the receiver's didInsertElement() method if it exists and then - invokes the same on all child views. - - @method _notifyDidInsertElement - */ - _notifyDidInsertElement: function() { - this.invokeRecursively(function(view) { - view.trigger('didInsertElement'); - }); - }, - - /** - @private - - Triggers the `willClearRender` event (which invokes the `willClearRender()` - method if it exists) on this view and all child views. - - @method _notifyWillClearRender - */ - _notifyWillClearRender: function() { - this.invokeRecursively(function(view) { - view.trigger('willClearRender'); - }); - }, - - /** - Destroys any existing element along with the element for any child views - as well. If the view does not currently have a element, then this method - will do nothing. - - If you implement willDestroyElement() on your view, then this method will - be invoked on your view before your element is destroyed to give you a - chance to clean up any event handlers, etc. - - If you write a willDestroyElement() handler, you can assume that your - didInsertElement() handler was called earlier for the same element. - - Normally you will not call or override this method yourself, but you may - want to implement the above callbacks when it is run. - - @method destroyElement - @return {Ember.View} receiver - */ - destroyElement: function() { - return this.invokeForState('destroyElement'); - }, - - /** - Called when the element of the view is going to be destroyed. Override - this function to do any teardown that requires an element, like removing - event listeners. - - @event willDestroyElement - */ - willDestroyElement: function() {}, - - /** - @private - - Triggers the `willDestroyElement` event (which invokes the `willDestroyElement()` - method if it exists) on this view and all child views. - - Before triggering `willDestroyElement`, it first triggers the `willClearRender` - event recursively. - - @method _notifyWillDestroyElement - */ - _notifyWillDestroyElement: function() { - this._notifyWillClearRender(); - - this.invokeRecursively(function(view) { - view.trigger('willDestroyElement'); - }); - }, - - _elementWillChange: Ember.beforeObserver(function() { - this.forEachChildView(function(view) { - Ember.propertyWillChange(view, 'element'); - }); - }, 'element'), - - /** - @private - - If this view's element changes, we need to invalidate the caches of our - child views so that we do not retain references to DOM elements that are - no longer needed. - - @method _elementDidChange - */ - _elementDidChange: Ember.observer(function() { - this.forEachChildView(function(view) { - Ember.propertyDidChange(view, 'element'); - }); - }, 'element'), - - /** - Called when the parentView property has changed. - - @event parentViewDidChange - */ - parentViewDidChange: Ember.K, - - instrumentName: 'render.view', - - instrumentDetails: function(hash) { - hash.template = get(this, 'templateName'); - this._super(hash); - }, - - _renderToBuffer: function(parentBuffer, bufferOperation) { - this.lengthBeforeRender = this._childViews.length; - var buffer = this._super(parentBuffer, bufferOperation); - this.lengthAfterRender = this._childViews.length; - - return buffer; - }, - - renderToBufferIfNeeded: function () { - return this.invokeForState('renderToBufferIfNeeded', this); - }, - - beforeRender: function(buffer) { - this.applyAttributesToBuffer(buffer); - }, - - afterRender: Ember.K, - - applyAttributesToBuffer: function(buffer) { - // Creates observers for all registered class name and attribute bindings, - // then adds them to the element. - this._applyClassNameBindings(); - - // Pass the render buffer so the method can apply attributes directly. - // This isn't needed for class name bindings because they use the - // existing classNames infrastructure. - this._applyAttributeBindings(buffer); - - - a_forEach(get(this, 'classNames'), function(name){ buffer.addClass(name); }); - buffer.id(get(this, 'elementId')); - - var role = get(this, 'ariaRole'); - if (role) { - buffer.attr('role', role); - } - - if (get(this, 'isVisible') === false) { - buffer.style('display', 'none'); - } - }, - - // .......................................................... - // STANDARD RENDER PROPERTIES - // - - /** - Tag name for the view's outer element. The tag name is only used when - an element is first created. If you change the tagName for an element, you - must destroy and recreate the view element. - - By default, the render buffer will use a `
    ` tag for views. - - @property tagName - @type String - @default null - */ - - // We leave this null by default so we can tell the difference between - // the default case and a user-specified tag. - tagName: null, - - /** - The WAI-ARIA role of the control represented by this view. For example, a - button may have a role of type 'button', or a pane may have a role of - type 'alertdialog'. This property is used by assistive software to help - visually challenged users navigate rich web applications. - - The full list of valid WAI-ARIA roles is available at: - http://www.w3.org/TR/wai-aria/roles#roles_categorization - - @property ariaRole - @type String - @default null - */ - ariaRole: null, - - /** - Standard CSS class names to apply to the view's outer element. This - property automatically inherits any class names defined by the view's - superclasses as well. - - @property classNames - @type Array - @default ['ember-view'] - */ - classNames: ['ember-view'], - - /** - A list of properties of the view to apply as class names. If the property - is a string value, the value of that string will be applied as a class - name. - - // Applies the 'high' class to the view element - Ember.View.create({ - classNameBindings: ['priority'] - priority: 'high' - }); - - If the value of the property is a Boolean, the name of that property is - added as a dasherized class name. - - // Applies the 'is-urgent' class to the view element - Ember.View.create({ - classNameBindings: ['isUrgent'] - isUrgent: true - }); - - If you would prefer to use a custom value instead of the dasherized - property name, you can pass a binding like this: - - // Applies the 'urgent' class to the view element - Ember.View.create({ - classNameBindings: ['isUrgent:urgent'] - isUrgent: true - }); - - This list of properties is inherited from the view's superclasses as well. - - @property classNameBindings - @type Array - @default [] - */ - classNameBindings: [], - - /** - A list of properties of the view to apply as attributes. If the property is - a string value, the value of that string will be applied as the attribute. - - // Applies the type attribute to the element - // with the value "button", like
    - Ember.View.create({ - attributeBindings: ['type'], - type: 'button' - }); - - If the value of the property is a Boolean, the name of that property is - added as an attribute. - - // Renders something like
    - Ember.View.create({ - attributeBindings: ['enabled'], - enabled: true - }); - - @property attributeBindings - */ - attributeBindings: [], - - // ....................................................... - // CORE DISPLAY METHODS - // - - /** - @private - - Setup a view, but do not finish waking it up. - - configure childViews - - register the view with the global views hash, which is used for event - dispatch - - @method init - */ - init: function() { - this._super(); - - // setup child views. be sure to clone the child views array first - this._childViews = this._childViews.slice(); - - Ember.assert("Only arrays are allowed for 'classNameBindings'", Ember.typeOf(this.classNameBindings) === 'array'); - this.classNameBindings = Ember.A(this.classNameBindings.slice()); - - Ember.assert("Only arrays are allowed for 'classNames'", Ember.typeOf(this.classNames) === 'array'); - this.classNames = Ember.A(this.classNames.slice()); - - var viewController = get(this, 'viewController'); - if (viewController) { - viewController = get(viewController); - if (viewController) { - set(viewController, 'view', this); - } - } - }, - - appendChild: function(view, options) { - return this.invokeForState('appendChild', view, options); - }, - - /** - Removes the child view from the parent view. - - @method removeChild - @param {Ember.View} view - @return {Ember.View} receiver - */ - removeChild: function(view) { - // If we're destroying, the entire subtree will be - // freed, and the DOM will be handled separately, - // so no need to mess with childViews. - if (this.isDestroying) { return; } - - // update parent node - set(view, '_parentView', null); - - // remove view from childViews array. - var childViews = this._childViews; - - Ember.EnumerableUtils.removeObject(childViews, view); - - this.propertyDidChange('childViews'); // HUH?! what happened to will change? - - return this; - }, - - /** - Removes all children from the parentView. - - @method removeAllChildren - @return {Ember.View} receiver - */ - removeAllChildren: function() { - return this.mutateChildViews(function(view) { - this.removeChild(view); - }); - }, - - destroyAllChildren: function() { - return this.mutateChildViews(function(view) { - view.destroy(); - }); - }, - - /** - Removes the view from its parentView, if one is found. Otherwise - does nothing. - - @method removeFromParent - @return {Ember.View} receiver - */ - removeFromParent: function() { - var parent = get(this, '_parentView'); - - // Remove DOM element from parent - this.remove(); - - if (parent) { parent.removeChild(this); } - return this; - }, - - /** - You must call `destroy` on a view to destroy the view (and all of its - child views). This will remove the view from any parent node, then make - sure that the DOM element managed by the view can be released by the - memory manager. - - @method willDestroy - */ - willDestroy: function() { - // calling this._super() will nuke computed properties and observers, - // so collect any information we need before calling super. - var childViews = this._childViews, - parent = get(this, '_parentView'), - childLen; - - // destroy the element -- this will avoid each child view destroying - // the element over and over again... - if (!this.removedFromDOM) { this.destroyElement(); } - - // remove from non-virtual parent view if viewName was specified - if (this.viewName) { - var nonVirtualParentView = get(this, 'parentView'); - if (nonVirtualParentView) { - set(nonVirtualParentView, this.viewName, null); - } - } - - // remove from parent if found. Don't call removeFromParent, - // as removeFromParent will try to remove the element from - // the DOM again. - if (parent) { parent.removeChild(this); } - - this.state = 'destroyed'; - - childLen = childViews.length; - for (var i=childLen-1; i>=0; i--) { - childViews[i].removedFromDOM = true; - childViews[i].destroy(); - } - - // next remove view from global hash - if (!this.isVirtual) delete Ember.View.views[get(this, 'elementId')]; - }, - - /** - Instantiates a view to be added to the childViews array during view - initialization. You generally will not call this method directly unless - you are overriding createChildViews(). Note that this method will - automatically configure the correct settings on the new view instance to - act as a child of the parent. - - @method createChildView - @param {Class} viewClass - @param {Hash} [attrs] Attributes to add - @return {Ember.View} new instance - */ - createChildView: function(view, attrs) { - if (Ember.CoreView.detect(view)) { - attrs = attrs || {}; - attrs._parentView = this; - attrs.templateData = attrs.templateData || get(this, 'templateData'); - - view = view.create(attrs); - - // don't set the property on a virtual view, as they are invisible to - // consumers of the view API - if (view.viewName) { set(get(this, 'concreteView'), view.viewName, view); } - } else { - Ember.assert('You must pass instance or subclass of View', view instanceof Ember.CoreView); - Ember.assert("You can only pass attributes when a class is provided", !attrs); - - if (!get(view, 'templateData')) { - set(view, 'templateData', get(this, 'templateData')); - } - - set(view, '_parentView', this); - } - - return view; - }, - - becameVisible: Ember.K, - becameHidden: Ember.K, - - /** - @private - - When the view's `isVisible` property changes, toggle the visibility - element of the actual DOM element. - - @method _isVisibleDidChange - */ - _isVisibleDidChange: Ember.observer(function() { - var $el = this.$(); - if (!$el) { return; } - - var isVisible = get(this, 'isVisible'); - - $el.toggle(isVisible); - - if (this._isAncestorHidden()) { return; } - - if (isVisible) { - this._notifyBecameVisible(); - } else { - this._notifyBecameHidden(); - } - }, 'isVisible'), - - _notifyBecameVisible: function() { - this.trigger('becameVisible'); - - this.forEachChildView(function(view) { - var isVisible = get(view, 'isVisible'); - - if (isVisible || isVisible === null) { - view._notifyBecameVisible(); - } - }); - }, - - _notifyBecameHidden: function() { - this.trigger('becameHidden'); - this.forEachChildView(function(view) { - var isVisible = get(view, 'isVisible'); - - if (isVisible || isVisible === null) { - view._notifyBecameHidden(); - } - }); - }, - - _isAncestorHidden: function() { - var parent = get(this, 'parentView'); - - while (parent) { - if (get(parent, 'isVisible') === false) { return true; } - - parent = get(parent, 'parentView'); - } - - return false; - }, - - clearBuffer: function() { - this.invokeRecursively(function(view) { - this.buffer = null; - }); - }, - - transitionTo: function(state, children) { - this.state = state; - - if (children !== false) { - this.forEachChildView(function(view) { - view.transitionTo(state); - }); - } - }, - - // ....................................................... - // EVENT HANDLING - // - - /** - @private - - Handle events from `Ember.EventDispatcher` - - @method handleEvent - @param eventName {String} - @param evt {Event} - */ - handleEvent: function(eventName, evt) { - return this.invokeForState('handleEvent', eventName, evt); - } - -}); - -/* - Describe how the specified actions should behave in the various - states that a view can exist in. Possible states: - - * preRender: when a view is first instantiated, and after its - element was destroyed, it is in the preRender state - * inBuffer: once a view has been rendered, but before it has - been inserted into the DOM, it is in the inBuffer state - * inDOM: once a view has been inserted into the DOM it is in - the inDOM state. A view spends the vast majority of its - existence in this state. - * destroyed: once a view has been destroyed (using the destroy - method), it is in this state. No further actions can be invoked - on a destroyed view. -*/ - - // in the destroyed state, everything is illegal - - // before rendering has begun, all legal manipulations are noops. - - // inside the buffer, legal manipulations are done on the buffer - - // once the view has been inserted into the DOM, legal manipulations - // are done on the DOM element. - -var DOMManager = { - prepend: function(view, html) { - view.$().prepend(html); - }, - - after: function(view, html) { - view.$().after(html); - }, - - html: function(view, html) { - view.$().html(html); - }, - - replace: function(view) { - var element = get(view, 'element'); - - set(view, 'element', null); - - view._insertElementLater(function() { - Ember.$(element).replaceWith(get(view, 'element')); - }); - }, - - remove: function(view) { - view.$().remove(); - }, - - empty: function(view) { - view.$().empty(); - } -}; - -Ember.View.reopen({ - states: Ember.View.states, - domManager: DOMManager -}); - -Ember.View.reopenClass({ - - /** - @private - - Parse a path and return an object which holds the parsed properties. - - For example a path like "content.isEnabled:enabled:disabled" wil return the - following object: - - { - path: "content.isEnabled", - className: "enabled", - falsyClassName: "disabled", - classNames: ":enabled:disabled" - } - - @method _parsePropertyPath - @static - */ - _parsePropertyPath: function(path) { - var split = path.split(':'), - propertyPath = split[0], - classNames = "", - className, - falsyClassName; - - // check if the property is defined as prop:class or prop:trueClass:falseClass - if (split.length > 1) { - className = split[1]; - if (split.length === 3) { falsyClassName = split[2]; } - - classNames = ':' + className; - if (falsyClassName) { classNames += ":" + falsyClassName; } - } - - return { - path: propertyPath, - classNames: classNames, - className: (className === '') ? undefined : className, - falsyClassName: falsyClassName - }; - }, - - /** - @private - - Get the class name for a given value, based on the path, optional className - and optional falsyClassName. - - - if a className or falsyClassName has been specified: - - if the value is truthy and className has been specified, className is returned - - if the value is falsy and falsyClassName has been specified, falsyClassName is returned - - otherwise null is returned - - if the value is true, the dasherized last part of the supplied path is returned - - if the value is not false, undefined or null, the value is returned - - if none of the above rules apply, null is returned - - @method _classStringForValue - @param path - @param val - @param className - @param falsyClassName - @static - */ - _classStringForValue: function(path, val, className, falsyClassName) { - // When using the colon syntax, evaluate the truthiness or falsiness - // of the value to determine which className to return - if (className || falsyClassName) { - if (className && !!val) { - return className; - - } else if (falsyClassName && !val) { - return falsyClassName; - - } else { - return null; - } - - // If value is a Boolean and true, return the dasherized property - // name. - } else if (val === true) { - // Normalize property path to be suitable for use - // as a class name. For exaple, content.foo.barBaz - // becomes bar-baz. - var parts = path.split('.'); - return Ember.String.dasherize(parts[parts.length-1]); - - // If the value is not false, undefined, or null, return the current - // value of the property. - } else if (val !== false && val !== undefined && val !== null) { - return val; - - // Nothing to display. Return null so that the old class is removed - // but no new class is added. - } else { - return null; - } - } -}); - -/** - Global views hash - - @property views - @static - @type Hash -*/ -Ember.View.views = {}; - -// If someone overrides the child views computed property when -// defining their class, we want to be able to process the user's -// supplied childViews and then restore the original computed property -// at view initialization time. This happens in Ember.ContainerView's init -// method. -Ember.View.childViewsProperty = childViewsProperty; - -Ember.View.applyAttributeBindings = function(elem, name, value) { - var type = Ember.typeOf(value); - var currentValue = elem.attr(name); - - // if this changes, also change the logic in ember-handlebars/lib/helpers/binding.js - if ((type === 'string' || (type === 'number' && !isNaN(value))) && value !== currentValue) { - elem.attr(name, value); - } else if (value && type === 'boolean') { - elem.attr(name, name); - } else if (!value) { - elem.removeAttr(name); - } -}; - -})(); - - - -(function() { -/** -@module ember -@submodule ember-views -*/ - -var get = Ember.get, set = Ember.set; - -Ember.View.states = { - _default: { - // appendChild is only legal while rendering the buffer. - appendChild: function() { - throw "You can't use appendChild outside of the rendering process"; - }, - - $: function() { - return undefined; - }, - - getElement: function() { - return null; - }, - - // Handle events from `Ember.EventDispatcher` - handleEvent: function() { - return true; // continue event propagation - }, - - destroyElement: function(view) { - set(view, 'element', null); - if (view._scheduledInsert) { - Ember.run.cancel(view._scheduledInsert); - view._scheduledInsert = null; - } - return view; - }, - - renderToBufferIfNeeded: function () { - return false; - } - } -}; - -Ember.View.reopen({ - states: Ember.View.states -}); - -})(); - - - -(function() { -/** -@module ember -@submodule ember-views -*/ - -Ember.View.states.preRender = { - parentState: Ember.View.states._default, - - // a view leaves the preRender state once its element has been - // created (createElement). - insertElement: function(view, fn) { - view.createElement(); - view._notifyWillInsertElement(); - // after createElement, the view will be in the hasElement state. - fn.call(view); - view.transitionTo('inDOM'); - view._notifyDidInsertElement(); - }, - - renderToBufferIfNeeded: function(view) { - return view.renderToBuffer(); - }, - - empty: Ember.K, - - setElement: function(view, value) { - if (value !== null) { - view.transitionTo('hasElement'); - } - return value; - } -}; - -})(); - - - -(function() { -/** -@module ember -@submodule ember-views -*/ - -var get = Ember.get, set = Ember.set, meta = Ember.meta; - -Ember.View.states.inBuffer = { - parentState: Ember.View.states._default, - - $: function(view, sel) { - // if we don't have an element yet, someone calling this.$() is - // trying to update an element that isn't in the DOM. Instead, - // rerender the view to allow the render method to reflect the - // changes. - view.rerender(); - return Ember.$(); - }, - - // when a view is rendered in a buffer, rerendering it simply - // replaces the existing buffer with a new one - rerender: function(view) { - Ember.deprecate("Something you did caused a view to re-render after it rendered but before it was inserted into the DOM. Because this is avoidable and the cause of significant performance issues in applications, this behavior is deprecated. If you want to use the debugger to find out what caused this, you can set ENV.RAISE_ON_DEPRECATION to true."); - - view._notifyWillClearRender(); - - view.clearRenderedChildren(); - view.renderToBuffer(view.buffer, 'replaceWith'); - }, - - // when a view is rendered in a buffer, appending a child - // view will render that view and append the resulting - // buffer into its buffer. - appendChild: function(view, childView, options) { - var buffer = view.buffer; - - childView = this.createChildView(childView, options); - view._childViews.push(childView); - - childView.renderToBuffer(buffer); - - view.propertyDidChange('childViews'); - - return childView; - }, - - // when a view is rendered in a buffer, destroying the - // element will simply destroy the buffer and put the - // state back into the preRender state. - destroyElement: function(view) { - view.clearBuffer(); - view._notifyWillDestroyElement(); - view.transitionTo('preRender'); - - return view; - }, - - empty: function() { - Ember.assert("Emptying a view in the inBuffer state is not allowed and should not happen under normal circumstances. Most likely there is a bug in your application. This may be due to excessive property change notifications."); - }, - - renderToBufferIfNeeded: function (view) { - return view.buffer; - }, - - // It should be impossible for a rendered view to be scheduled for - // insertion. - insertElement: function() { - throw "You can't insert an element that has already been rendered"; - }, - - setElement: function(view, value) { - if (value === null) { - view.transitionTo('preRender'); - } else { - view.clearBuffer(); - view.transitionTo('hasElement'); - } - - return value; - } -}; - - -})(); - - - -(function() { -/** -@module ember -@submodule ember-views -*/ - -var get = Ember.get, set = Ember.set, meta = Ember.meta; - -Ember.View.states.hasElement = { - parentState: Ember.View.states._default, - - $: function(view, sel) { - var elem = get(view, 'element'); - return sel ? Ember.$(sel, elem) : Ember.$(elem); - }, - - getElement: function(view) { - var parent = get(view, 'parentView'); - if (parent) { parent = get(parent, 'element'); } - if (parent) { return view.findElementInParentElement(parent); } - return Ember.$("#" + get(view, 'elementId'))[0]; - }, - - setElement: function(view, value) { - if (value === null) { - view.transitionTo('preRender'); - } else { - throw "You cannot set an element to a non-null value when the element is already in the DOM."; - } - - return value; - }, - - // once the view has been inserted into the DOM, rerendering is - // deferred to allow bindings to synchronize. - rerender: function(view) { - view._notifyWillClearRender(); - - view.clearRenderedChildren(); - - view.domManager.replace(view); - return view; - }, - - // once the view is already in the DOM, destroying it removes it - // from the DOM, nukes its element, and puts it back into the - // preRender state if inDOM. - - destroyElement: function(view) { - view._notifyWillDestroyElement(); - view.domManager.remove(view); - set(view, 'element', null); - if (view._scheduledInsert) { - Ember.run.cancel(view._scheduledInsert); - view._scheduledInsert = null; - } - return view; - }, - - empty: function(view) { - var _childViews = view._childViews, len, idx; - if (_childViews) { - len = _childViews.length; - for (idx = 0; idx < len; idx++) { - _childViews[idx]._notifyWillDestroyElement(); - } - } - view.domManager.empty(view); - }, - - // Handle events from `Ember.EventDispatcher` - handleEvent: function(view, eventName, evt) { - if (view.has(eventName)) { - // Handler should be able to re-dispatch events, so we don't - // preventDefault or stopPropagation. - return view.trigger(eventName, evt); - } else { - return true; // continue event propagation - } - } -}; - -Ember.View.states.inDOM = { - parentState: Ember.View.states.hasElement, - - insertElement: function(view, fn) { - throw "You can't insert an element into the DOM that has already been inserted"; - } -}; - -})(); - - - -(function() { -/** -@module ember -@submodule ember-views -*/ - -var destroyedError = "You can't call %@ on a destroyed view", fmt = Ember.String.fmt; - -Ember.View.states.destroyed = { - parentState: Ember.View.states._default, - - appendChild: function() { - throw fmt(destroyedError, ['appendChild']); - }, - rerender: function() { - throw fmt(destroyedError, ['rerender']); - }, - destroyElement: function() { - throw fmt(destroyedError, ['destroyElement']); - }, - empty: function() { - throw fmt(destroyedError, ['empty']); - }, - - setElement: function() { - throw fmt(destroyedError, ["set('element', ...)"]); - }, - - renderToBufferIfNeeded: function() { - throw fmt(destroyedError, ["renderToBufferIfNeeded"]); - }, - - // Since element insertion is scheduled, don't do anything if - // the view has been destroyed between scheduling and execution - insertElement: Ember.K -}; - - -})(); - - - -(function() { - -})(); - - - -(function() { -/** -@module ember -@submodule ember-views -*/ - -var get = Ember.get, set = Ember.set, meta = Ember.meta; -var forEach = Ember.EnumerableUtils.forEach; - -var childViewsProperty = Ember.computed(function() { - return get(this, '_childViews'); -}).property('_childViews'); - -/** - A `ContainerView` is an `Ember.View` subclass that allows for manual or programatic - management of a view's `childViews` array that will correctly update the `ContainerView` - instance's rendered DOM representation. - - ## Setting Initial Child Views - The initial array of child views can be set in one of two ways. You can provide - a `childViews` property at creation time that contains instance of `Ember.View`: - - ``` javascript - aContainer = Ember.ContainerView.create({ - childViews: [Ember.View.create(), Ember.View.create()] - }); - ``` - - You can also provide a list of property names whose values are instances of `Ember.View`: - - ``` javascript - aContainer = Ember.ContainerView.create({ - childViews: ['aView', 'bView', 'cView'], - aView: Ember.View.create(), - bView: Ember.View.create() - cView: Ember.View.create() - }); - ``` - - The two strategies can be combined: - - ``` javascript - aContainer = Ember.ContainerView.create({ - childViews: ['aView', Ember.View.create()], - aView: Ember.View.create() - }); - ``` - - Each child view's rendering will be inserted into the container's rendered HTML in the same - order as its position in the `childViews` property. - - ## Adding and Removing Child Views - The views in a container's `childViews` array should be added and removed by manipulating - the `childViews` property directly. - - To remove a view pass that view into a `removeObject` call on the container's `childViews` property. - - Given an empty `` the following code - - ``` javascript - aContainer = Ember.ContainerView.create({ - classNames: ['the-container'], - childViews: ['aView', 'bView'], - aView: Ember.View.create({ - template: Ember.Handlebars.compile("A") - }), - bView: Ember.View.create({ - template: Ember.Handlebars.compile("B") - }) - }); - - aContainer.appendTo('body'); - ``` - - Results in the HTML - - ``` html -
    -
    A
    -
    B
    -
    - ``` - - Removing a view - - ``` javascript - aContainer.get('childViews'); // [aContainer.aView, aContainer.bView] - aContainer.get('childViews').removeObject(aContainer.get('bView')); - aContainer.get('childViews'); // [aContainer.aView] - ``` - - Will result in the following HTML - - ``` html -
    -
    A
    -
    - ``` - - - Similarly, adding a child view is accomplished by adding `Ember.View` instances to the - container's `childViews` property. - - Given an empty `` the following code - - ``` javascript - aContainer = Ember.ContainerView.create({ - classNames: ['the-container'], - childViews: ['aView', 'bView'], - aView: Ember.View.create({ - template: Ember.Handlebars.compile("A") - }), - bView: Ember.View.create({ - template: Ember.Handlebars.compile("B") - }) - }); - - aContainer.appendTo('body'); - ``` - - Results in the HTML - - ``` html -
    -
    A
    -
    B
    -
    - ``` - - Adding a view - - ``` javascript - AnotherViewClass = Ember.View.extend({ - template: Ember.Handlebars.compile("Another view") - }); - - aContainer.get('childViews'); // [aContainer.aView, aContainer.bView] - aContainer.get('childViews').pushObject(AnotherViewClass.create()); - aContainer.get('childViews'); // [aContainer.aView, aContainer.bView, ] - ``` - - Will result in the following HTML - - ``` html -
    -
    A
    -
    B
    -
    Another view
    -
    - ``` - - - Direct manipulation of childViews presence or absence in the DOM via calls to - `remove` or `removeFromParent` or calls to a container's `removeChild` may not behave - correctly. - - Calling `remove()` on a child view will remove the view's HTML, but it will remain as part of its - container's `childView`s property. - - Calling `removeChild()` on the container will remove the passed view instance from the container's - `childView`s but keep its HTML within the container's rendered view. - - Calling `removeFromParent()` behaves as expected but should be avoided in favor of direct - manipulation of a container's `childViews` property. - - ``` javascript - aContainer = Ember.ContainerView.create({ - classNames: ['the-container'], - childViews: ['aView', 'bView'], - aView: Ember.View.create({ - template: Ember.Handlebars.compile("A") - }), - bView: Ember.View.create({ - template: Ember.Handlebars.compile("B") - }) - }); - - aContainer.appendTo('body'); - ``` - - Results in the HTML - - ``` html -
    -
    A
    -
    B
    -
    - ``` - - Calling `aContainer.get('aView').removeFromParent()` will result in the following HTML - - ``` html -
    -
    B
    -
    - ``` - - And the `Ember.View` instance stored in `aContainer.aView` will be removed from `aContainer`'s - `childViews` array. - - ## Templates and Layout - - A `template`, `templateName`, `defaultTemplate`, `layout`, `layoutName` or `defaultLayout` - property on a container view will not result in the template or layout being rendered. - The HTML contents of a `Ember.ContainerView`'s DOM representation will only be the rendered HTML - of its child views. - - ## Binding a View to Display - - If you would like to display a single view in your ContainerView, you can set its `currentView` - property. When the `currentView` property is set to a view instance, it will be added to the - ContainerView's `childViews` array. If the `currentView` property is later changed to a - different view, the new view will replace the old view. If `currentView` is set to `null`, the - last `currentView` will be removed. - - This functionality is useful for cases where you want to bind the display of a ContainerView to - a controller or state manager. For example, you can bind the `currentView` of a container to - a controller like this: - - ``` javascript - App.appController = Ember.Object.create({ - view: Ember.View.create({ - templateName: 'person_template' - }) - }); - ``` - - ``` handlebars - {{view Ember.ContainerView currentViewBinding="App.appController.view"}} - ``` - - ## Use lifecycle hooks - - This is an example of how you could implement reusable currentView view. - - ``` javascript - App.ContainerView = Ember.ContainerView.extend({ - appendCurrentView: function(currentView, callback) { - currentView.set('isVisible', true); - - if (!this.get('childViews').contains(currentView)) { - this._super(currentView, callback); - } else { - callback(); - } - }, - removeCurrentView: function(currentView, callback) { - if (currentView.get('isShared')) { - currentView.set('isVisible', false); - callback(); - } else { - this._super(currentView, callback); - } - } - }); - ```` - - This is an example of how you could implement animations. - - ```` javascript - App.ContainerView = Ember.ContainerView.extend({ - presentCurrentView: function(currentView, callback) { - currentView.$().animate({top: '0px'}, callback); - }, - dismissCurrentView: function(currentView, callback) { - currentView.$().animate({top: '-100px'}, callback); - } - }); - ```` - - @class ContainerView - @namespace Ember - @extends Ember.View -*/ - -Ember.ContainerView = Ember.View.extend({ - - init: function() { - this._super(); - - var childViews = get(this, 'childViews'); - Ember.defineProperty(this, 'childViews', childViewsProperty); - - var _childViews = this._childViews; - - forEach(childViews, function(viewName, idx) { - var view; - - if ('string' === typeof viewName) { - view = get(this, viewName); - view = this.createChildView(view); - set(this, viewName, view); - } else { - view = this.createChildView(viewName); - } - - _childViews[idx] = view; - }, this); - - // Make the _childViews array observable - Ember.A(_childViews); - - // Sets up an array observer on the child views array. This - // observer will detect when child views are added or removed - // and update the DOM to reflect the mutation. - get(this, 'childViews').addArrayObserver(this, { - willChange: 'childViewsWillChange', - didChange: 'childViewsDidChange' - }); - - // Make sure we initialize with currentView if it is present - var currentView = get(this, 'currentView'); - if (currentView) { this._currentViewDidChange(); } - }, - - /** - @private - - Instructs each child view to render to the passed render buffer. - - @method render - @param {Ember.RenderBuffer} buffer the buffer to render to - */ - render: function(buffer) { - this.forEachChildView(function(view) { - view.renderToBuffer(buffer); - }); - }, - - instrumentName: 'render.container', - - /** - @private - - When the container view is destroyed, tear down the child views - array observer. - - @method willDestroy - */ - willDestroy: function() { - get(this, 'childViews').removeArrayObserver(this, { - willChange: 'childViewsWillChange', - didChange: 'childViewsDidChange' - }); - - this._super(); - }, - - /** - @private - - When a child view is removed, destroy its element so that - it is removed from the DOM. - - The array observer that triggers this action is set up in the - `renderToBuffer` method. - - @method childViewsWillChange - @param {Ember.Array} views the child views array before mutation - @param {Number} start the start position of the mutation - @param {Number} removed the number of child views removed - **/ - childViewsWillChange: function(views, start, removed) { - if (removed === 0) { return; } - - var changedViews = views.slice(start, start+removed); - this.initializeViews(changedViews, null, null); - - this.invokeForState('childViewsWillChange', views, start, removed); - }, - - /** - @private - - When a child view is added, make sure the DOM gets updated appropriately. - - If the view has already rendered an element, we tell the child view to - create an element and insert it into the DOM. If the enclosing container view - has already written to a buffer, but not yet converted that buffer into an - element, we insert the string representation of the child into the appropriate - place in the buffer. - - @method childViewsDidChange - @param {Ember.Array} views the array of child views afte the mutation has occurred - @param {Number} start the start position of the mutation - @param {Number} removed the number of child views removed - @param {Number} the number of child views added - */ - childViewsDidChange: function(views, start, removed, added) { - var len = get(views, 'length'); - - // No new child views were added; bail out. - if (added === 0) return; - - var changedViews = views.slice(start, start+added); - this.initializeViews(changedViews, this, get(this, 'templateData')); - - // Let the current state handle the changes - this.invokeForState('childViewsDidChange', views, start, added); - }, - - initializeViews: function(views, parentView, templateData) { - forEach(views, function(view) { - set(view, '_parentView', parentView); - - if (!get(view, 'templateData')) { - set(view, 'templateData', templateData); - } - }); - }, - - currentView: null, - - /** - This method is responsible for presenting a new view. - Default implementation will simply call the callback. - You can override this method if you want to add an animation for example. - - @method presentCurrentView - @param {Ember.View} currentView a view to present - @param {Function} callback the callback called once operation is terminated - */ - presentCurrentView: function(currentView, callback) { - callback(); - }, - - /** - This method is responsible for adding view to containerView - - @method appendCurrentView - @param {Ember.View} currentView a view to present - @param {Function} callback the callback called once view is appended - */ - appendCurrentView: function(currentView, callback) { - var childViews = get(this, 'childViews'); - - currentView.one('didInsertElement', callback); - - childViews.pushObject(currentView); - }, - - /** - This method is responsible for dismissing a view. - Default implementation will simply call the callback. - You can override this method if you want to add an animation for example. - - @method dismissCurrentView - @param {Ember.View} currentView a view to dismiss - @param {Function} callback the callback called once operation is terminated - */ - dismissCurrentView: function(currentView, callback) { - callback(); - }, - - /** - This method is responsible for removing a view from the containerView - You may want to override it in case you implementing views sharing for example - - @method removeCurrentView - @param {Ember.View} currentView a view to present - @param {Function} callback the callback called once view is removed - */ - removeCurrentView: function(currentView, callback) { - var childViews = get(this, 'childViews'); - - currentView.one('didDisappear', function() { - currentView.destroy(); - }); - - childViews.removeObject(currentView); - - callback(); - }, - - _currentViewWillChange: Ember.beforeObserver(function() { - var currentView = get(this, 'currentView'), - containerView = this; - - if (currentView) { - set(currentView, 'isBeingDismissed', true); - currentView.trigger('willDisappear', currentView); - - this.dismissCurrentView(currentView, function() { - containerView.removeCurrentView(currentView, function() { - set(currentView, 'isBeingDismissed', false); - currentView.trigger('didDisappear', currentView); - }); - }); - } - }, 'currentView'), - - _currentViewDidChange: Ember.observer(function() { - var currentView = get(this, 'currentView'), - containerView = this; - - if (currentView) { - set(currentView, 'isBeingPresented', true); - currentView.trigger('willAppear', currentView); - - this.appendCurrentView(currentView, function() { - containerView.presentCurrentView(currentView, function() { - set(currentView, 'isBeingPresented', false); - currentView.trigger('didAppear', currentView); - }); - }); - } - }, 'currentView'), - - _ensureChildrenAreInDOM: function () { - this.invokeForState('ensureChildrenAreInDOM', this); - } -}); - -// Ember.ContainerView extends the default view states to provide different -// behavior for childViewsWillChange and childViewsDidChange. -Ember.ContainerView.states = { - parent: Ember.View.states, - - inBuffer: { - childViewsDidChange: function(parentView, views, start, added) { - var buffer = parentView.buffer, - startWith, prev, prevBuffer, view; - - // Determine where to begin inserting the child view(s) in the - // render buffer. - if (start === 0) { - // If views were inserted at the beginning, prepend the first - // view to the render buffer, then begin inserting any - // additional views at the beginning. - view = views[start]; - startWith = start + 1; - view.renderToBuffer(buffer, 'prepend'); - } else { - // Otherwise, just insert them at the same place as the child - // views mutation. - view = views[start - 1]; - startWith = start; - } - - for (var i=startWith; i` and the following code: - - ``` javascript - someItemsView = Ember.CollectionView.create({ - classNames: ['a-collection'], - content: ['A','B','C'], - itemViewClass: Ember.View.extend({ - template: Ember.Handlebars.compile("the letter: {{view.content}}") - }) - }); - - someItemsView.appendTo('body'); - ``` - - Will result in the following HTML structure - - ``` html -
    -
    the letter: A
    -
    the letter: B
    -
    the letter: C
    -
    - ``` - - ## Automatic matching of parent/child tagNames - - Setting the `tagName` property of a `CollectionView` to any of - "ul", "ol", "table", "thead", "tbody", "tfoot", "tr", or "select" will result - in the item views receiving an appropriately matched `tagName` property. - - - Given an empty `` and the following code: - - ``` javascript - anUndorderedListView = Ember.CollectionView.create({ - tagName: 'ul', - content: ['A','B','C'], - itemViewClass: Ember.View.extend({ - template: Ember.Handlebars.compile("the letter: {{view.content}}") - }) - }); - - anUndorderedListView.appendTo('body'); - ``` - - Will result in the following HTML structure - - ``` html -
      -
    • the letter: A
      • -
    • the letter: B
      • -
    • the letter: C
      • -
    - ``` - - Additional tagName pairs can be provided by adding to `Ember.CollectionView.CONTAINER_MAP ` - - ``` javascript - Ember.CollectionView.CONTAINER_MAP['article'] = 'section' - ``` - - - ## Empty View - You can provide an `Ember.View` subclass to the `Ember.CollectionView` instance as its - `emptyView` property. If the `content` property of a `CollectionView` is set to `null` - or an empty array, an instance of this view will be the `CollectionView`s only child. - - ``` javascript - aListWithNothing = Ember.CollectionView.create({ - classNames: ['nothing'] - content: null, - emptyView: Ember.View.extend({ - template: Ember.Handlebars.compile("The collection is empty") - }) - }); - - aListWithNothing.appendTo('body'); - ``` - - Will result in the following HTML structure - - ``` html -
    -
    - The collection is empty -
    -
    - ``` - - ## Adding and Removing items - The `childViews` property of a `CollectionView` should not be directly manipulated. Instead, - add, remove, replace items from its `content` property. This will trigger - appropriate changes to its rendered HTML. - - ## Use in templates via the `{{collection}}` Ember.Handlebars helper - Ember.Handlebars provides a helper specifically for adding `CollectionView`s to templates. - See `Ember.Handlebars.collection` for more details - - @class CollectionView - @namespace Ember - @extends Ember.ContainerView - @since Ember 0.9 -*/ -Ember.CollectionView = Ember.ContainerView.extend( -/** @scope Ember.CollectionView.prototype */ { - - /** - A list of items to be displayed by the Ember.CollectionView. - - @property content - @type Ember.Array - @default null - */ - content: null, - - /** - @private - - This provides metadata about what kind of empty view class this - collection would like if it is being instantiated from another - system (like Handlebars) - - @property emptyViewClass - */ - emptyViewClass: Ember.View, - - /** - An optional view to display if content is set to an empty array. - - @property emptyView - @type Ember.View - @default null - */ - emptyView: null, - - /** - @property itemViewClass - @type Ember.View - @default Ember.View - */ - itemViewClass: Ember.View, - - init: function() { - var ret = this._super(); - this._contentDidChange(); - return ret; - }, - - _contentWillChange: Ember.beforeObserver(function() { - var content = this.get('content'); - - if (content) { content.removeArrayObserver(this); } - var len = content ? get(content, 'length') : 0; - this.arrayWillChange(content, 0, len); - }, 'content'), - - /** - @private - - Check to make sure that the content has changed, and if so, - update the children directly. This is always scheduled - asynchronously, to allow the element to be created before - bindings have synchronized and vice versa. - - @method _contentDidChange - */ - _contentDidChange: Ember.observer(function() { - var content = get(this, 'content'); - - if (content) { - Ember.assert(fmt("an Ember.CollectionView's content must implement Ember.Array. You passed %@", [content]), Ember.Array.detect(content)); - content.addArrayObserver(this); - } - - var len = content ? get(content, 'length') : 0; - this.arrayDidChange(content, 0, null, len); - }, 'content'), - - willDestroy: function() { - var content = get(this, 'content'); - if (content) { content.removeArrayObserver(this); } - - this._super(); - }, - - arrayWillChange: function(content, start, removedCount) { - // If the contents were empty before and this template collection has an - // empty view remove it now. - var emptyView = get(this, 'emptyView'); - if (emptyView && emptyView instanceof Ember.View) { - emptyView.removeFromParent(); - } - - // Loop through child views that correspond with the removed items. - // Note that we loop from the end of the array to the beginning because - // we are mutating it as we go. - var childViews = get(this, 'childViews'), childView, idx, len; - - len = get(childViews, 'length'); - - var removingAll = removedCount === len; - - if (removingAll) { - this.invokeForState('empty'); - } - - for (idx = start + removedCount - 1; idx >= start; idx--) { - childView = childViews[idx]; - if (removingAll) { childView.removedFromDOM = true; } - childView.destroy(); - } - }, - - /** - Called when a mutation to the underlying content array occurs. - - This method will replay that mutation against the views that compose the - Ember.CollectionView, ensuring that the view reflects the model. - - This array observer is added in contentDidChange. - - @method arrayDidChange - @param {Array} addedObjects the objects that were added to the content - @param {Array} removedObjects the objects that were removed from the content - @param {Number} changeIndex the index at which the changes occurred - */ - arrayDidChange: function(content, start, removed, added) { - var itemViewClass = get(this, 'itemViewClass'), - childViews = get(this, 'childViews'), - addedViews = [], view, item, idx, len, itemTagName; - - if ('string' === typeof itemViewClass) { - itemViewClass = get(itemViewClass); - } - - Ember.assert(fmt("itemViewClass must be a subclass of Ember.View, not %@", [itemViewClass]), Ember.View.detect(itemViewClass)); - - len = content ? get(content, 'length') : 0; - if (len) { - for (idx = start; idx < start+added; idx++) { - item = content.objectAt(idx); - - view = this.createChildView(itemViewClass, { - content: item, - contentIndex: idx - }); - - addedViews.push(view); - } - } else { - var emptyView = get(this, 'emptyView'); - if (!emptyView) { return; } - - emptyView = this.createChildView(emptyView); - addedViews.push(emptyView); - set(this, 'emptyView', emptyView); - } - childViews.replace(start, 0, addedViews); - }, - - createChildView: function(view, attrs) { - view = this._super(view, attrs); - - var itemTagName = get(view, 'tagName'); - var tagName = (itemTagName === null || itemTagName === undefined) ? Ember.CollectionView.CONTAINER_MAP[get(this, 'tagName')] : itemTagName; - - set(view, 'tagName', tagName); - - return view; - } -}); - -/** - A map of parent tags to their default child tags. You can add - additional parent tags if you want collection views that use - a particular parent tag to default to a child tag. - - @property CONTAINER_MAP - @type Hash - @static - @final -*/ -Ember.CollectionView.CONTAINER_MAP = { - ul: 'li', - ol: 'li', - table: 'tr', - thead: 'tr', - tbody: 'tr', - tfoot: 'tr', - tr: 'td', - select: 'option' -}; - -})(); - - - -(function() { - -})(); - - - -(function() { -/*globals jQuery*/ -/** -Ember Views - -@module ember -@submodule ember-views -@require ember-runtime -@main ember-views -*/ - -})(); - (function() { var get = Ember.get, set = Ember.set; @@ -16416,12 +25509,12 @@ Ember.State = Ember.Object.extend(Ember.Evented, } return path; - }).property(), + }), /** @private - Override the default event firing from Ember.Evented to + Override the default event firing from `Ember.Evented` to also call methods with the given name. @method trigger @@ -16505,7 +25598,7 @@ Ember.State = Ember.Object.extend(Ember.Evented, /** A Boolean value indicating whether the state is a leaf state - in the state hierarchy. This is false if the state has child + in the state hierarchy. This is `false` if the state has child states; otherwise it is true. @property isLeaf @@ -16554,25 +25647,28 @@ Ember.State = Ember.Object.extend(Ember.Evented, Ember.State.reopenClass({ /** - Creates an action function for transitioning to the named state while preserving context. + Creates an action function for transitioning to the named state while + preserving context. The following example StateManagers are equivalent: - aManager = Ember.StateManager.create({ - stateOne: Ember.State.create({ - changeToStateTwo: Ember.State.transitionTo('stateTwo') - }), - stateTwo: Ember.State.create({}) - }) + ```javascript + aManager = Ember.StateManager.create({ + stateOne: Ember.State.create({ + changeToStateTwo: Ember.State.transitionTo('stateTwo') + }), + stateTwo: Ember.State.create({}) + }) - bManager = Ember.StateManager.create({ - stateOne: Ember.State.create({ - changeToStateTwo: function(manager, context){ - manager.transitionTo('stateTwo', context) - } - }), - stateTwo: Ember.State.create({}) - }) + bManager = Ember.StateManager.create({ + stateOne: Ember.State.create({ + changeToStateTwo: function(manager, context){ + manager.transitionTo('stateTwo', context) + } + }), + stateTwo: Ember.State.create({}) + }) + ``` @method transitionTo @static @@ -16776,370 +25872,482 @@ Transition.prototype = { } }; +var sendRecursively = function(event, currentState, isUnhandledPass) { + var log = this.enableLogging, + eventName = isUnhandledPass ? 'unhandledEvent' : event, + action = currentState[eventName], + contexts, sendRecursiveArguments, actionArguments; + + contexts = [].slice.call(arguments, 3); + + // Test to see if the action is a method that + // can be invoked. Don't blindly check just for + // existence, because it is possible the state + // manager has a child state of the given name, + // and we should still raise an exception in that + // case. + if (typeof action === 'function') { + if (log) { + if (isUnhandledPass) { + Ember.Logger.log(fmt("STATEMANAGER: Unhandled event '%@' being sent to state %@.", [event, get(currentState, 'path')])); + } else { + Ember.Logger.log(fmt("STATEMANAGER: Sending event '%@' to state %@.", [event, get(currentState, 'path')])); + } + } + + actionArguments = contexts; + if (isUnhandledPass) { + actionArguments.unshift(event); + } + actionArguments.unshift(this); + + return action.apply(currentState, actionArguments); + } else { + var parentState = get(currentState, 'parentState'); + if (parentState) { + + sendRecursiveArguments = contexts; + sendRecursiveArguments.unshift(event, parentState, isUnhandledPass); + + return sendRecursively.apply(this, sendRecursiveArguments); + } else if (!isUnhandledPass) { + return sendEvent.call(this, event, contexts, true); + } + } +}; + +var sendEvent = function(eventName, sendRecursiveArguments, isUnhandledPass) { + sendRecursiveArguments.unshift(eventName, get(this, 'currentState'), isUnhandledPass); + return sendRecursively.apply(this, sendRecursiveArguments); +}; + /** - StateManager is part of Ember's implementation of a finite state machine. A StateManager - instance manages a number of properties that are instances of `Ember.State`, + StateManager is part of Ember's implementation of a finite state machine. A + StateManager instance manages a number of properties that are instances of + `Ember.State`, tracks the current active state, and triggers callbacks when states have changed. ## Defining States - The states of StateManager can be declared in one of two ways. First, you can define - a `states` property that contains all the states: + The states of StateManager can be declared in one of two ways. First, you can + define a `states` property that contains all the states: - managerA = Ember.StateManager.create({ - states: { - stateOne: Ember.State.create(), - stateTwo: Ember.State.create() - } - }) + ```javascript + managerA = Ember.StateManager.create({ + states: { + stateOne: Ember.State.create(), + stateTwo: Ember.State.create() + } + }) - managerA.get('states') - // { - // stateOne: Ember.State.create(), - // stateTwo: Ember.State.create() - // } + managerA.get('states') + // { + // stateOne: Ember.State.create(), + // stateTwo: Ember.State.create() + // } + ``` - You can also add instances of `Ember.State` (or an `Ember.State` subclass) directly as properties - of a StateManager. These states will be collected into the `states` property for you. + You can also add instances of `Ember.State` (or an `Ember.State` subclass) + directly as properties of a StateManager. These states will be collected into + the `states` property for you. - managerA = Ember.StateManager.create({ - stateOne: Ember.State.create(), - stateTwo: Ember.State.create() - }) + ```javascript + managerA = Ember.StateManager.create({ + stateOne: Ember.State.create(), + stateTwo: Ember.State.create() + }) - managerA.get('states') - // { - // stateOne: Ember.State.create(), - // stateTwo: Ember.State.create() - // } + managerA.get('states') + // { + // stateOne: Ember.State.create(), + // stateTwo: Ember.State.create() + // } + ``` ## The Initial State + When created a StateManager instance will immediately enter into the state defined as its `start` property or the state referenced by name in its `initialState` property: - managerA = Ember.StateManager.create({ - start: Ember.State.create({}) - }) + ```javascript + managerA = Ember.StateManager.create({ + start: Ember.State.create({}) + }) - managerA.get('currentState.name') // 'start' + managerA.get('currentState.name') // 'start' - managerB = Ember.StateManager.create({ - initialState: 'beginHere', - beginHere: Ember.State.create({}) - }) + managerB = Ember.StateManager.create({ + initialState: 'beginHere', + beginHere: Ember.State.create({}) + }) - managerB.get('currentState.name') // 'beginHere' + managerB.get('currentState.name') // 'beginHere' + ``` - Because it is a property you may also provide a computed function if you wish to derive - an `initialState` programmatically: + Because it is a property you may also provide a computed function if you wish + to derive an `initialState` programmatically: - managerC = Ember.StateManager.create({ - initialState: function(){ - if (someLogic) { - return 'active'; - } else { - return 'passive'; - } - }.property(), - active: Ember.State.create({}), - passive: Ember.State.create({}) - }) + ```javascript + managerC = Ember.StateManager.create({ + initialState: function(){ + if (someLogic) { + return 'active'; + } else { + return 'passive'; + } + }.property(), + active: Ember.State.create({}), + passive: Ember.State.create({}) + }) + ``` ## Moving Between States - A StateManager can have any number of Ember.State objects as properties + + A StateManager can have any number of `Ember.State` objects as properties and can have a single one of these states as its current state. Calling `transitionTo` transitions between states: - robotManager = Ember.StateManager.create({ - initialState: 'poweredDown', - poweredDown: Ember.State.create({}), - poweredUp: Ember.State.create({}) - }) + ```javascript + robotManager = Ember.StateManager.create({ + initialState: 'poweredDown', + poweredDown: Ember.State.create({}), + poweredUp: Ember.State.create({}) + }) - robotManager.get('currentState.name') // 'poweredDown' - robotManager.transitionTo('poweredUp') - robotManager.get('currentState.name') // 'poweredUp' + robotManager.get('currentState.name') // 'poweredDown' + robotManager.transitionTo('poweredUp') + robotManager.get('currentState.name') // 'poweredUp' + ``` - Before transitioning into a new state the existing `currentState` will have its - `exit` method called with the StateManager instance as its first argument and - an object representing the transition as its second argument. + Before transitioning into a new state the existing `currentState` will have + its `exit` method called with the StateManager instance as its first argument + and an object representing the transition as its second argument. After transitioning into a new state the new `currentState` will have its - `enter` method called with the StateManager instance as its first argument and - an object representing the transition as its second argument. + `enter` method called with the StateManager instance as its first argument + and an object representing the transition as its second argument. - robotManager = Ember.StateManager.create({ - initialState: 'poweredDown', - poweredDown: Ember.State.create({ - exit: function(stateManager){ - console.log("exiting the poweredDown state") - } - }), - poweredUp: Ember.State.create({ - enter: function(stateManager){ - console.log("entering the poweredUp state. Destroy all humans.") - } - }) + ```javascript + robotManager = Ember.StateManager.create({ + initialState: 'poweredDown', + poweredDown: Ember.State.create({ + exit: function(stateManager){ + console.log("exiting the poweredDown state") + } + }), + poweredUp: Ember.State.create({ + enter: function(stateManager){ + console.log("entering the poweredUp state. Destroy all humans.") + } + }) + }) + + robotManager.get('currentState.name') // 'poweredDown' + robotManager.transitionTo('poweredUp') + + // will log + // 'exiting the poweredDown state' + // 'entering the poweredUp state. Destroy all humans.' + ``` + + Once a StateManager is already in a state, subsequent attempts to enter that + state will not trigger enter or exit method calls. Attempts to transition + into a state that the manager does not have will result in no changes in the + StateManager's current state: + + ```javascript + robotManager = Ember.StateManager.create({ + initialState: 'poweredDown', + poweredDown: Ember.State.create({ + exit: function(stateManager){ + console.log("exiting the poweredDown state") + } + }), + poweredUp: Ember.State.create({ + enter: function(stateManager){ + console.log("entering the poweredUp state. Destroy all humans.") + } + }) + }) + + robotManager.get('currentState.name') // 'poweredDown' + robotManager.transitionTo('poweredUp') + // will log + // 'exiting the poweredDown state' + // 'entering the poweredUp state. Destroy all humans.' + robotManager.transitionTo('poweredUp') // no logging, no state change + + robotManager.transitionTo('someUnknownState') // silently fails + robotManager.get('currentState.name') // 'poweredUp' + ``` + + Each state property may itself contain properties that are instances of + `Ember.State`. The StateManager can transition to specific sub-states in a + series of transitionTo method calls or via a single transitionTo with the + full path to the specific state. The StateManager will also keep track of the + full path to its currentState + + ```javascript + robotManager = Ember.StateManager.create({ + initialState: 'poweredDown', + poweredDown: Ember.State.create({ + charging: Ember.State.create(), + charged: Ember.State.create() + }), + poweredUp: Ember.State.create({ + mobile: Ember.State.create(), + stationary: Ember.State.create() + }) + }) + + robotManager.get('currentState.name') // 'poweredDown' + + robotManager.transitionTo('poweredUp') + robotManager.get('currentState.name') // 'poweredUp' + + robotManager.transitionTo('mobile') + robotManager.get('currentState.name') // 'mobile' + + // transition via a state path + robotManager.transitionTo('poweredDown.charging') + robotManager.get('currentState.name') // 'charging' + + robotManager.get('currentState.path') // 'poweredDown.charging' + ``` + + Enter transition methods will be called for each state and nested child state + in their hierarchical order. Exit methods will be called for each state and + its nested states in reverse hierarchical order. + + Exit transitions for a parent state are not called when entering into one of + its child states, only when transitioning to a new section of possible states + in the hierarchy. + + ```javascript + robotManager = Ember.StateManager.create({ + initialState: 'poweredDown', + poweredDown: Ember.State.create({ + enter: function(){}, + exit: function(){ + console.log("exited poweredDown state") + }, + charging: Ember.State.create({ + enter: function(){}, + exit: function(){} + }), + charged: Ember.State.create({ + enter: function(){ + console.log("entered charged state") + }, + exit: function(){ + console.log("exited charged state") + } }) - - robotManager.get('currentState.name') // 'poweredDown' - robotManager.transitionTo('poweredUp') - // will log - // 'exiting the poweredDown state' - // 'entering the poweredUp state. Destroy all humans.' - - - Once a StateManager is already in a state, subsequent attempts to enter that state will - not trigger enter or exit method calls. Attempts to transition into a state that the - manager does not have will result in no changes in the StateManager's current state: - - robotManager = Ember.StateManager.create({ - initialState: 'poweredDown', - poweredDown: Ember.State.create({ - exit: function(stateManager){ - console.log("exiting the poweredDown state") - } - }), - poweredUp: Ember.State.create({ - enter: function(stateManager){ - console.log("entering the poweredUp state. Destroy all humans.") - } - }) + }), + poweredUp: Ember.State.create({ + enter: function(){ + console.log("entered poweredUp state") + }, + exit: function(){}, + mobile: Ember.State.create({ + enter: function(){ + console.log("entered mobile state") + }, + exit: function(){} + }), + stationary: Ember.State.create({ + enter: function(){}, + exit: function(){} }) - - robotManager.get('currentState.name') // 'poweredDown' - robotManager.transitionTo('poweredUp') - // will log - // 'exiting the poweredDown state' - // 'entering the poweredUp state. Destroy all humans.' - robotManager.transitionTo('poweredUp') // no logging, no state change - - robotManager.transitionTo('someUnknownState') // silently fails - robotManager.get('currentState.name') // 'poweredUp' + }) + }) - Each state property may itself contain properties that are instances of Ember.State. - The StateManager can transition to specific sub-states in a series of transitionTo method calls or - via a single transitionTo with the full path to the specific state. The StateManager will also - keep track of the full path to its currentState + robotManager.get('currentState.path') // 'poweredDown' + robotManager.transitionTo('charged') + // logs 'entered charged state' + // but does *not* log 'exited poweredDown state' + robotManager.get('currentState.name') // 'charged - robotManager = Ember.StateManager.create({ - initialState: 'poweredDown', - poweredDown: Ember.State.create({ - charging: Ember.State.create(), - charged: Ember.State.create() - }), - poweredUp: Ember.State.create({ - mobile: Ember.State.create(), - stationary: Ember.State.create() - }) - }) + robotManager.transitionTo('poweredUp.mobile') + // logs + // 'exited charged state' + // 'exited poweredDown state' + // 'entered poweredUp state' + // 'entered mobile state' + ``` - robotManager.get('currentState.name') // 'poweredDown' + During development you can set a StateManager's `enableLogging` property to + `true` to receive console messages of state transitions. - robotManager.transitionTo('poweredUp') - robotManager.get('currentState.name') // 'poweredUp' - - robotManager.transitionTo('mobile') - robotManager.get('currentState.name') // 'mobile' - - // transition via a state path - robotManager.transitionTo('poweredDown.charging') - robotManager.get('currentState.name') // 'charging' - - robotManager.get('currentState.path') // 'poweredDown.charging' - - Enter transition methods will be called for each state and nested child state in their - hierarchical order. Exit methods will be called for each state and its nested states in - reverse hierarchical order. - - Exit transitions for a parent state are not called when entering into one of its child states, - only when transitioning to a new section of possible states in the hierarchy. - - robotManager = Ember.StateManager.create({ - initialState: 'poweredDown', - poweredDown: Ember.State.create({ - enter: function(){}, - exit: function(){ - console.log("exited poweredDown state") - }, - charging: Ember.State.create({ - enter: function(){}, - exit: function(){} - }), - charged: Ember.State.create({ - enter: function(){ - console.log("entered charged state") - }, - exit: function(){ - console.log("exited charged state") - } - }) - }), - poweredUp: Ember.State.create({ - enter: function(){ - console.log("entered poweredUp state") - }, - exit: function(){}, - mobile: Ember.State.create({ - enter: function(){ - console.log("entered mobile state") - }, - exit: function(){} - }), - stationary: Ember.State.create({ - enter: function(){}, - exit: function(){} - }) - }) - }) - - - robotManager.get('currentState.path') // 'poweredDown' - robotManager.transitionTo('charged') - // logs 'entered charged state' - // but does *not* log 'exited poweredDown state' - robotManager.get('currentState.name') // 'charged - - robotManager.transitionTo('poweredUp.mobile') - // logs - // 'exited charged state' - // 'exited poweredDown state' - // 'entered poweredUp state' - // 'entered mobile state' - - During development you can set a StateManager's `enableLogging` property to `true` to - receive console messages of state transitions. - - robotManager = Ember.StateManager.create({ - enableLogging: true - }) + ```javascript + robotManager = Ember.StateManager.create({ + enableLogging: true + }) + ``` ## Managing currentState with Actions - To control which transitions between states are possible for a given state, StateManager - can receive and route action messages to its states via the `send` method. Calling to `send` with - an action name will begin searching for a method with the same name starting at the current state - and moving up through the parent states in a state hierarchy until an appropriate method is found - or the StateManager instance itself is reached. - If an appropriately named method is found it will be called with the state manager as the first - argument and an optional `context` object as the second argument. + To control which transitions are possible for a given state, and + appropriately handle external events, the StateManager can receive and + route action messages to its states via the `send` method. Calling to + `send` with an action name will begin searching for a method with the same + name starting at the current state and moving up through the parent states + in a state hierarchy until an appropriate method is found or the StateManager + instance itself is reached. - managerA = Ember.StateManager.create({ - initialState: 'stateOne.substateOne.subsubstateOne', - stateOne: Ember.State.create({ - substateOne: Ember.State.create({ - anAction: function(manager, context){ - console.log("an action was called") - }, - subsubstateOne: Ember.State.create({}) - }) - }) + If an appropriately named method is found it will be called with the state + manager as the first argument and an optional `context` object as the second + argument. + + ```javascript + managerA = Ember.StateManager.create({ + initialState: 'stateOne.substateOne.subsubstateOne', + stateOne: Ember.State.create({ + substateOne: Ember.State.create({ + anAction: function(manager, context){ + console.log("an action was called") + }, + subsubstateOne: Ember.State.create({}) }) + }) + }) - managerA.get('currentState.name') // 'subsubstateOne' - managerA.send('anAction') - // 'stateOne.substateOne.subsubstateOne' has no anAction method - // so the 'anAction' method of 'stateOne.substateOne' is called - // and logs "an action was called" - // with managerA as the first argument - // and no second argument - - someObject = {} - managerA.send('anAction', someObject) - // the 'anAction' method of 'stateOne.substateOne' is called again - // with managerA as the first argument and - // someObject as the second argument. + managerA.get('currentState.name') // 'subsubstateOne' + managerA.send('anAction') + // 'stateOne.substateOne.subsubstateOne' has no anAction method + // so the 'anAction' method of 'stateOne.substateOne' is called + // and logs "an action was called" + // with managerA as the first argument + // and no second argument + someObject = {} + managerA.send('anAction', someObject) + // the 'anAction' method of 'stateOne.substateOne' is called again + // with managerA as the first argument and + // someObject as the second argument. + ``` If the StateManager attempts to send an action but does not find an appropriately named - method in the current state or while moving upwards through the state hierarchy - it will throw a new Ember.Error. Action detection only moves upwards through the state hierarchy - from the current state. It does not search in other portions of the hierarchy. + method in the current state or while moving upwards through the state hierarchy, it will + repeat the process looking for a `unhandledEvent` method. If an `unhandledEvent` method is + found, it will be called with the original event name as the second argument. If an + `unhandledEvent` method is not found, the StateManager will throw a new Ember.Error. - managerB = Ember.StateManager.create({ - initialState: 'stateOne.substateOne.subsubstateOne', - stateOne: Ember.State.create({ - substateOne: Ember.State.create({ - subsubstateOne: Ember.State.create({}) - }) - }), - stateTwo: Ember.State.create({ - anAction: function(manager, context){ - // will not be called below because it is - // not a parent of the current state - } - }) + ```javascript + managerB = Ember.StateManager.create({ + initialState: 'stateOne.substateOne.subsubstateOne', + stateOne: Ember.State.create({ + substateOne: Ember.State.create({ + subsubstateOne: Ember.State.create({}), + unhandledEvent: function(manager, eventName, context) { + console.log("got an unhandledEvent with name " + eventName); + } }) + }) + }) - managerB.get('currentState.name') // 'subsubstateOne' - managerB.send('anAction') - // Error: could not - // respond to event anAction in state stateOne.substateOne.subsubstateOne. + managerB.get('currentState.name') // 'subsubstateOne' + managerB.send('anAction') + // neither `stateOne.substateOne.subsubstateOne` nor any of it's + // parent states have a handler for `anAction`. `subsubstateOne` + // also does not have a `unhandledEvent` method, but its parent + // state, `substateOne`, does, and it gets fired. It will log + // "got an unhandledEvent with name anAction" + ``` + + Action detection only moves upwards through the state hierarchy from the current state. + It does not search in other portions of the hierarchy. + + ```javascript + managerC = Ember.StateManager.create({ + initialState: 'stateOne.substateOne.subsubstateOne', + stateOne: Ember.State.create({ + substateOne: Ember.State.create({ + subsubstateOne: Ember.State.create({}) + }) + }), + stateTwo: Ember.State.create({ + anAction: function(manager, context){ + // will not be called below because it is + // not a parent of the current state + } + }) + }) + + managerC.get('currentState.name') // 'subsubstateOne' + managerC.send('anAction') + // Error: could not + // respond to event anAction in state stateOne.substateOne.subsubstateOne. + ``` Inside of an action method the given state should delegate `transitionTo` calls on its StateManager. - robotManager = Ember.StateManager.create({ - initialState: 'poweredDown.charging', - poweredDown: Ember.State.create({ - charging: Ember.State.create({ - chargeComplete: function(manager, context){ - manager.transitionTo('charged') - } - }), - charged: Ember.State.create({ - boot: function(manager, context){ - manager.transitionTo('poweredUp') - } - }) - }), - poweredUp: Ember.State.create({ - beginExtermination: function(manager, context){ - manager.transitionTo('rampaging') - }, - rampaging: Ember.State.create() - }) + ```javascript + robotManager = Ember.StateManager.create({ + initialState: 'poweredDown.charging', + poweredDown: Ember.State.create({ + charging: Ember.State.create({ + chargeComplete: function(manager, context){ + manager.transitionTo('charged') + } + }), + charged: Ember.State.create({ + boot: function(manager, context){ + manager.transitionTo('poweredUp') + } }) + }), + poweredUp: Ember.State.create({ + beginExtermination: function(manager, context){ + manager.transitionTo('rampaging') + }, + rampaging: Ember.State.create() + }) + }) - robotManager.get('currentState.name') // 'charging' - robotManager.send('boot') // throws error, no boot action - // in current hierarchy - robotManager.get('currentState.name') // remains 'charging' + robotManager.get('currentState.name') // 'charging' + robotManager.send('boot') // throws error, no boot action + // in current hierarchy + robotManager.get('currentState.name') // remains 'charging' - robotManager.send('beginExtermination') // throws error, no beginExtermination - // action in current hierarchy - robotManager.get('currentState.name') // remains 'charging' + robotManager.send('beginExtermination') // throws error, no beginExtermination + // action in current hierarchy + robotManager.get('currentState.name') // remains 'charging' - robotManager.send('chargeComplete') - robotManager.get('currentState.name') // 'charged' + robotManager.send('chargeComplete') + robotManager.get('currentState.name') // 'charged' - robotManager.send('boot') - robotManager.get('currentState.name') // 'poweredUp' + robotManager.send('boot') + robotManager.get('currentState.name') // 'poweredUp' - robotManager.send('beginExtermination', allHumans) - robotManager.get('currentState.name') // 'rampaging' + robotManager.send('beginExtermination', allHumans) + robotManager.get('currentState.name') // 'rampaging' + ``` - Transition actions can also be created using the `transitionTo` method of the Ember.State class. The + Transition actions can also be created using the `transitionTo` method of the `Ember.State` class. The following example StateManagers are equivalent: - aManager = Ember.StateManager.create({ - stateOne: Ember.State.create({ - changeToStateTwo: Ember.State.transitionTo('stateTwo') - }), - stateTwo: Ember.State.create({}) - }) + ```javascript + aManager = Ember.StateManager.create({ + stateOne: Ember.State.create({ + changeToStateTwo: Ember.State.transitionTo('stateTwo') + }), + stateTwo: Ember.State.create({}) + }) - bManager = Ember.StateManager.create({ - stateOne: Ember.State.create({ - changeToStateTwo: function(manager, context){ - manager.transitionTo('stateTwo', context) - } - }), - stateTwo: Ember.State.create({}) - }) + bManager = Ember.StateManager.create({ + stateOne: Ember.State.create({ + changeToStateTwo: function(manager, context){ + manager.transitionTo('stateTwo', context) + } + }), + stateTwo: Ember.State.create({}) + }) + ``` @class StateManager @namespace Ember @@ -17194,7 +26402,7 @@ Ember.StateManager = Ember.State.extend({ /** The current state from among the manager's possible states. This property should - not be set directly. Use `transitionTo` to move between states by name. + not be set directly. Use `transitionTo` to move between states by name. @property currentState @type Ember.State @@ -17208,9 +26416,7 @@ Ember.StateManager = Ember.State.extend({ @property currentPath @type String */ - currentPath: Ember.computed('currentState', function() { - return get(this, 'currentState.path'); - }), + currentPath: Ember.computed.alias('currentState.path'), /** The name of transitionEvent that this stateManager will dispatch @@ -17233,48 +26439,13 @@ Ember.StateManager = Ember.State.extend({ errorOnUnhandledEvent: true, send: function(event) { - var contexts, sendRecursiveArguments; - + var contexts = [].slice.call(arguments, 1); Ember.assert('Cannot send event "' + event + '" while currentState is ' + get(this, 'currentState'), get(this, 'currentState')); - - contexts = [].slice.call(arguments, 1); - sendRecursiveArguments = contexts; - sendRecursiveArguments.unshift(event, get(this, 'currentState')); - - return this.sendRecursively.apply(this, sendRecursiveArguments); + return sendEvent.call(this, event, contexts, false); }, - - sendRecursively: function(event, currentState) { - var log = this.enableLogging, - action = currentState[event], - contexts, sendRecursiveArguments, actionArguments; - - contexts = [].slice.call(arguments, 2); - - // Test to see if the action is a method that - // can be invoked. Don't blindly check just for - // existence, because it is possible the state - // manager has a child state of the given name, - // and we should still raise an exception in that - // case. - if (typeof action === 'function') { - if (log) { Ember.Logger.log(fmt("STATEMANAGER: Sending event '%@' to state %@.", [event, get(currentState, 'path')])); } - - actionArguments = contexts; - actionArguments.unshift(this); - - return action.apply(currentState, actionArguments); - } else { - var parentState = get(currentState, 'parentState'); - if (parentState) { - - sendRecursiveArguments = contexts; - sendRecursiveArguments.unshift(event, parentState); - - return this.sendRecursively.apply(this, sendRecursiveArguments); - } else if (get(this, 'errorOnUnhandledEvent')) { - throw new Ember.Error(this.toString() + " could not respond to event " + event + " in state " + get(this, 'currentState.path') + "."); - } + unhandledEvent: function(manager, event) { + if (get(this, 'errorOnUnhandledEvent')) { + throw new Ember.Error(this.toString() + " could not respond to event " + event + " in state " + get(this, 'currentState.path') + "."); } }, @@ -17283,15 +26454,17 @@ Ember.StateManager = Ember.State.extend({ Example: - manager = Ember.StateManager.create({ - root: Ember.State.create({ - dashboard: Ember.State.create() - }) - }); + ```javascript + manager = Ember.StateManager.create({ + root: Ember.State.create({ + dashboard: Ember.State.create() + }) + }); - manager.getStateByPath(manager, "root.dashboard") + manager.getStateByPath(manager, "root.dashboard") - // returns the dashboard state + // returns the dashboard state + ``` @method getStateByPath @param {Ember.State} root the state to start searching from @@ -17360,7 +26533,7 @@ Ember.StateManager = Ember.State.extend({ transitionTo: function(path, context) { // XXX When is transitionTo called with no path - if (Ember.empty(path)) { return; } + if (Ember.isEmpty(path)) { return; } // The ES6 signature of this function is `path, ...contexts` var contexts = context ? Array.prototype.slice.call(arguments, 1) : [], @@ -17529,5723 +26702,10 @@ Ember States })(); -(function() { -var get = Ember.get; - -Ember._ResolvedState = Ember.Object.extend({ - manager: null, - state: null, - match: null, - - object: Ember.computed(function(key, value) { - if (arguments.length === 2) { - this._object = value; - return value; - } else { - if (this._object) { - return this._object; - } else { - var state = get(this, 'state'), - match = get(this, 'match'), - manager = get(this, 'manager'); - return state.deserialize(manager, match.hash); - } - } - }).property(), - - hasPromise: Ember.computed(function() { - return Ember.canInvoke(get(this, 'object'), 'then'); - }).property('object'), - - promise: Ember.computed(function() { - var object = get(this, 'object'); - if (Ember.canInvoke(object, 'then')) { - return object; - } else { - return { - then: function(success) { success(object); } - }; - } - }).property('object'), - - transition: function() { - var manager = get(this, 'manager'), - path = get(this, 'state.path'), - object = get(this, 'object'); - manager.transitionTo(path, object); - } -}); })(); - - - -(function() { -/** -@module ember -@submodule ember-routing -*/ - -var get = Ember.get; - -// The Ember Routable mixin assumes the existance of a simple -// routing shim that supports the following three behaviors: -// -// * .getURL() - this is called when the page loads -// * .setURL(newURL) - this is called from within the state -// manager when the state changes to a routable state -// * .onURLChange(callback) - this happens when the user presses -// the back or forward button - -var paramForClass = function(classObject) { - var className = classObject.toString(), - parts = className.split("."), - last = parts[parts.length - 1]; - - return Ember.String.underscore(last) + "_id"; -}; - -var merge = function(original, hash) { - for (var prop in hash) { - if (!hash.hasOwnProperty(prop)) { continue; } - if (original.hasOwnProperty(prop)) { continue; } - - original[prop] = hash[prop]; - } -}; - -/** - @class Routable - @namespace Ember - @extends Ember.Mixin -*/ -Ember.Routable = Ember.Mixin.create({ - init: function() { - var redirection; - this.on('setup', this, this.stashContext); - - if (redirection = get(this, 'redirectsTo')) { - Ember.assert("You cannot use `redirectsTo` if you already have a `connectOutlets` method", this.connectOutlets === Ember.K); - - this.connectOutlets = function(router) { - router.transitionTo(redirection); - }; - } - - // normalize empty route to '/' - var route = get(this, 'route'); - if (route === '') { - route = '/'; - } - - this._super(); - - Ember.assert("You cannot use `redirectsTo` on a state that has child states", !redirection || (!!redirection && !!get(this, 'isLeaf'))); - }, - - setup: function() { - return this.connectOutlets.apply(this, arguments); - }, - - /** - @private - - Whenever a routable state is entered, the context it was entered with - is stashed so that we can regenerate the state's `absoluteURL` on - demand. - - @method stashContext - @param manager {Ember.StateManager} - @param context - */ - stashContext: function(manager, context) { - this.router = manager; - - var serialized = this.serialize(manager, context); - Ember.assert('serialize must return a hash', !serialized || typeof serialized === 'object'); - - manager.setStateMeta(this, 'context', context); - manager.setStateMeta(this, 'serialized', serialized); - - if (get(this, 'isRoutable') && !get(manager, 'isRouting')) { - this.updateRoute(manager, get(manager, 'location')); - } - }, - - /** - @private - - Whenever a routable state is entered, the router's location object - is notified to set the URL to the current absolute path. - - In general, this will update the browser's URL. - - @method updateRoute - @param manager {Ember.StateManager} - @param location {Ember.Location} - */ - updateRoute: function(manager, location) { - if (get(this, 'isLeafRoute')) { - var path = this.absoluteRoute(manager); - location.setURL(path); - } - }, - - /** - @private - - Get the absolute route for the current state and a given - hash. - - This method is private, as it expects a serialized hash, - not the original context object. - - @method absoluteRoute - @param manager {Ember.StateManager} - @param hash {Hash} - */ - absoluteRoute: function(manager, hash) { - var parentState = get(this, 'parentState'); - var path = '', generated; - - // If the parent state is routable, use its current path - // as this route's prefix. - if (get(parentState, 'isRoutable')) { - path = parentState.absoluteRoute(manager, hash); - } - - var matcher = get(this, 'routeMatcher'), - serialized = manager.getStateMeta(this, 'serialized'); - - // merge the existing serialized object in with the passed - // in hash. - hash = hash || {}; - merge(hash, serialized); - - generated = matcher && matcher.generate(hash); - - if (generated) { - path = path + '/' + generated; - } - - return path; - }, - - /** - @private - - At the moment, a state is routable if it has a string `route` - property. This heuristic may change. - - @property isRoutable - @type Boolean - */ - isRoutable: Ember.computed(function() { - return typeof get(this, 'route') === 'string'; - }), - - /** - @private - - Determine if this is the last routeable state - - @property isLeafRoute - @type Boolean - */ - isLeafRoute: Ember.computed(function() { - if (get(this, 'isLeaf')) { return true; } - return !get(this, 'childStates').findProperty('isRoutable'); - }), - - /** - @private - - A _RouteMatcher object generated from the current route's `route` - string property. - - @property routeMatcher - @type Ember._RouteMatcher - */ - routeMatcher: Ember.computed(function() { - var route = get(this, 'route'); - if (route) { - return Ember._RouteMatcher.create({ - route: route, - dynamicSegmentPattern: get(this, 'dynamicSegmentPattern'), - dynamicSegmentTerminators: get(this, 'dynamicSegmentTerminators'), - customRegexp: get(this, 'customRegexp') - }); - } - }), - - /** - @private - - Check whether the route has dynamic segments and therefore takes - a context. - - @property hasContext - @type Boolean - */ - hasContext: Ember.computed(function() { - var routeMatcher = get(this, 'routeMatcher'); - if (routeMatcher) { - return routeMatcher.identifiers.length > 0; - } - }), - - /** - @private - - The model class associated with the current state. This property - uses the `modelType` property, in order to allow it to be - specified as a String. - - @property modelClass - @type Ember.Object - */ - modelClass: Ember.computed(function() { - var modelType = get(this, 'modelType'); - - if (typeof modelType === 'string') { - return Ember.get(Ember.lookup, modelType); - } else { - return modelType; - } - }), - - /** - @private - - Get the model class for the state. The heuristic is: - - * The state must have a single dynamic segment - * The dynamic segment must end in `_id` - * A dynamic segment like `blog_post_id` is converted into `BlogPost` - * The name is then looked up on the passed in namespace - - The process of initializing an application with a router will - pass the application's namespace into the router, which will be - used here. - - @method modelClassFor - @param namespace {Ember.Namespace} - */ - modelClassFor: function(namespace) { - var modelClass, routeMatcher, identifiers, match, className; - - // if an explicit modelType was specified, use that - if (modelClass = get(this, 'modelClass')) { return modelClass; } - - // if the router has no lookup namespace, we won't be able to guess - // the modelType - if (!namespace) { return; } - - // make sure this state is actually a routable state - routeMatcher = get(this, 'routeMatcher'); - if (!routeMatcher) { return; } - - // only guess modelType for states with a single dynamic segment - // (no more, no fewer) - identifiers = routeMatcher.identifiers; - if (identifiers.length !== 2) { return; } - - // extract the `_id` from the end of the dynamic segment; if the - // dynamic segment does not end in `_id`, we can't guess the - // modelType - match = identifiers[1].match(/^(.*)_id$/); - if (!match) { return; } - - // convert the underscored type into a class form and look it up - // on the router's namespace - className = Ember.String.classify(match[1]); - return get(namespace, className); - }, - - /** - The default method that takes a `params` object and converts - it into an object. - - By default, a params hash that looks like `{ post_id: 1 }` - will be looked up as `namespace.Post.find(1)`. This is - designed to work seamlessly with Ember Data, but will work - fine with any class that has a `find` method. - - @method deserialize - @param manager {Ember.StateManager} - @param params {Hash} - */ - deserialize: function(manager, params) { - var modelClass, routeMatcher, param; - - if (modelClass = this.modelClassFor(get(manager, 'namespace'))) { - Ember.assert("Expected "+modelClass.toString()+" to implement `find` for use in '"+this.get('path')+"' `deserialize`. Please implement the `find` method or overwrite `deserialize`.", modelClass.find); - return modelClass.find(params[paramForClass(modelClass)]); - } - - return params; - }, - - /** - The default method that takes an object and converts it into - a params hash. - - By default, if there is a single dynamic segment named - `blog_post_id` and the object is a `BlogPost` with an - `id` of `12`, the serialize method will produce: - - { blog_post_id: 12 } - - @method serialize - @param manager {Ember.StateManager} - @param context - */ - serialize: function(manager, context) { - var modelClass, routeMatcher, namespace, param, id; - - if (Ember.empty(context)) { return ''; } - - if (modelClass = this.modelClassFor(get(manager, 'namespace'))) { - param = paramForClass(modelClass); - id = get(context, 'id'); - context = {}; - context[param] = id; - } - - return context; - }, - - /** - @private - @method resolvePath - @param manager {Ember.StateManager} - @param path {String} - */ - resolvePath: function(manager, path) { - if (get(this, 'isLeafRoute')) { return Ember.A(); } - - var childStates = get(this, 'childStates'), match; - - childStates = Ember.A(childStates.filterProperty('isRoutable')); - - childStates = childStates.sort(function(a, b) { - var aDynamicSegments = get(a, 'routeMatcher.identifiers.length'), - bDynamicSegments = get(b, 'routeMatcher.identifiers.length'), - aRoute = get(a, 'route'), - bRoute = get(b, 'route'), - aIndex = a.get('index'), - bIndex = b.get('index'); - - if( (aIndex || aIndex == 0) && (bIndex || bIndex == 0) ) { - return aIndex - bIndex - } - - - if (aRoute.indexOf(bRoute) === 0) { - return -1; - } else if (bRoute.indexOf(aRoute) === 0) { - return 1; - } - - if (aDynamicSegments !== bDynamicSegments) { - return aDynamicSegments - bDynamicSegments; - } - - return get(b, 'route.length') - get(a, 'route.length'); - }); - - var state = childStates.find(function(state) { - var matcher = get(state, 'routeMatcher'); - if (match = matcher.match(path)) { return true; } - }); - - Ember.assert("Could not find state for path " + path, !!state); - - var resolvedState = Ember._ResolvedState.create({ - manager: manager, - state: state, - match: match - }); - - var states = state.resolvePath(manager, match.remaining); - - return Ember.A([resolvedState]).pushObjects(states); - }, - - /** - @private - - Once `unroute` has finished unwinding, `routePath` will be called - with the remainder of the route. - - For example, if you were in the /posts/1/comments state, and you - moved into the /posts/2/comments state, `routePath` will be called - on the state whose path is `/posts` with the path `/2/comments`. - - @method routePath - @param manager {Ember.StateManager} - @param path {String} - */ - routePath: function(manager, path) { - if (get(this, 'isLeafRoute')) { return; } - - var resolvedStates = this.resolvePath(manager, path), - hasPromises = resolvedStates.some(function(s) { return get(s, 'hasPromise'); }); - - function runTransition() { - resolvedStates.forEach(function(rs) { rs.transition(); }); - } - - if (hasPromises) { - manager.transitionTo('loading'); - - Ember.assert('Loading state should be the child of a route', Ember.Routable.detect(get(manager, 'currentState.parentState'))); - Ember.assert('Loading state should not be a route', !Ember.Routable.detect(get(manager, 'currentState'))); - - manager.handleStatePromises(resolvedStates, runTransition); - } else { - runTransition(); - } - }, - - /** - @private - - When you move to a new route by pressing the back - or forward button, this method is called first. - - Its job is to move the state manager into a parent - state of the state it will eventually move into. - - @method unroutePath - @param router {Ember.Router} - @param path {String} - */ - unroutePath: function(router, path) { - var parentState = get(this, 'parentState'); - - // If we're at the root state, we're done - if (parentState === router) { - return; - } - - path = path.replace(/^(?=[^\/])/, "/"); - var absolutePath = this.absoluteRoute(router); - - var route = get(this, 'route'); - - // If the current path is empty, move up one state, - // because the index ('/') state must be a leaf node. - if (route !== '/') { - // If the current path is a prefix of the path we're trying - // to go to, we're done. - var index = path.indexOf(absolutePath), - next = path.charAt(absolutePath.length); - - if (index === 0 && (next === "/" || next === "")) { - return; - } - } - - // Transition to the parent and call unroute again. - router.enterState({ - exitStates: [this], - enterStates: [], - finalState: parentState - }); - - router.send('unroutePath', path); - }, - - parentTemplate: Ember.computed(function() { - var state = this, parentState, template; - - while (state = get(state, 'parentState')) { - if (template = get(state, 'template')) { - return template; - } - } - - return 'application'; - }), - - _template: Ember.computed(function(key, value) { - if (arguments.length > 1) { return value; } - - if (value = get(this, 'template')) { - return value; - } - - // If no template was explicitly supplied convert - // the class name into a template name. For example, - // App.PostRoute will return `post`. - var className = this.constructor.toString(), baseName; - if (/^[^\[].*Route$/.test(className)) { - baseName = className.match(/([^\.]+\.)*([^\.]+)/)[2]; - baseName = baseName.replace(/Route$/, ''); - return baseName.charAt(0).toLowerCase() + baseName.substr(1); - } - }), - - render: function(options) { - options = options || {}; - - var template = options.template || get(this, '_template'), - parentTemplate = options.into || get(this, 'parentTemplate'), - controller = get(this.router, parentTemplate + "Controller"); - - var viewName = Ember.String.classify(template) + "View", - viewClass = get(get(this.router, 'namespace'), viewName); - - viewClass = (viewClass || Ember.View).extend({ - templateName: template - }); - - controller.set('view', viewClass.create()); - }, - - /** - The `connectOutlets` event will be triggered once a - state has been entered. It will be called with the - route's context. - - @event connectOutlets - @param router {Ember.Router} - @param [context*] - */ - connectOutlets: Ember.K, - - /** - The `navigateAway` event will be triggered when the - URL changes due to the back/forward button - - @event navigateAway - */ - navigateAway: Ember.K -}); - -})(); - - - -(function() { -/** -@module ember -@submodule ember-routing -*/ - -/** - @class Route - @namespace Ember - @extends Ember.State - @uses Ember.Routable -*/ -Ember.Route = Ember.State.extend(Ember.Routable); - -})(); - - - -(function() { -var escapeForRegex = function(text) { - return text.replace(/[\-\[\]{}()*+?.,\\\^\$|#\s]/g, "\\$&"); -}; - -/** - @class _RouteMatcher - @namespace Ember - @private - @extends Ember.Object -*/ -Ember._RouteMatcher = Ember.Object.extend({ - state: null, - - init: function() { - var route = this.route; - - // Strip off leading slash if present - if (route.charAt(0) === '/') { - route = this.route = route.substr(1); - } - - if(this.customRegexp) { - this.identifiers = []; - this.regex = this.customRegexp; - } else { - var dynamicSegmentPattern = this.dynamicSegmentPattern || "([^/]+)", - terminators = this.dynamicSegmentTerminators || [], - identifiers = [], - count = 1, - escaped, - segmentRegexp; - - - escaped = escapeForRegex(route); - - terminators.push('$|/'); - str = ':([a-z_]+)(?=' + terminators.join('|') + ')' - segmentRegexp = new RegExp(str, 'gi'); - var regex = escaped.replace(segmentRegexp, function(match, id) { - identifiers[count++] = id; - return dynamicSegmentPattern; - }); - - this.identifiers = identifiers; - this.regex = new RegExp("^/?" + regex); - } - }, - - match: function(path) { - var match = path.match(this.regex); - - if (match) { - var identifiers = this.identifiers, - hash = {}; - - for (var i=1, l=identifiers.length; i 0 ? hash : null - }; - } - }, - - generate: function(hash) { - var identifiers = this.identifiers, route = this.route, id; - for (var i=1, l=identifiers.length; i -

    {{title}}

    - - ``` - - Will delegate `click` events on the rendered `h1` to the application's router instance. In this case the - `anActionOnTheRouter` method of the state at 'root.aRoute' will be called with the view's controller - as the context argument. This context will be passed to the `connectOutlets` as its second argument. - - Different `context` can be supplied from within the `{{action}}` helper, allowing specific context passing - between application states: - - ``` handlebars - - ``` - - See `Handlebars.helpers.action` for additional usage examples. - - - ## Changing View Hierarchy in Response To State Change - - Changes in application state that change the URL should be accompanied by associated changes in view - hierarchy. This can be accomplished by calling 'connectOutlet' on the injected controller singletons from - within the 'connectOutlets' event of an Ember.Route: - - ``` javascript - App = Ember.Application.create({ - OneController: Ember.ObjectController.extend(), - OneView: Ember.View.extend(), - - AnotherController: Ember.ObjectController.extend(), - AnotherView: Ember.View.extend(), - - Router: Ember.Router.extend({ - root: Ember.Route.extend({ - aRoute: Ember.Route.extend({ - route: '/', - connectOutlets: function(router, context) { - router.get('oneController').connectOutlet('another'); - }, - }) - }) - }) - }); - App.initialize(); - ``` - - - This will detect the '{{outlet}}' portion of `oneController`'s view (an instance of `App.OneView`) and - fill it with a rendered instance of `App.AnotherView` whose `context` will be the single instance of - `App.AnotherController` stored on the router in the `anotherController` property. - - For more information about Outlets, see `Ember.Handlebars.helpers.outlet`. For additional information on - the `connectOutlet` method, see `Ember.Controller.connectOutlet`. For more information on - controller injections, see `Ember.Application#initialize()`. For additional information about view context, - see `Ember.View`. - - @class Router - @namespace Ember - @extends Ember.StateManager -*/ -Ember.Router = Ember.StateManager.extend( -/** @scope Ember.Router.prototype */ { - - /** - @property initialState - @type String - @default 'root' - */ - initialState: 'root', - - /** - The `Ember.Location` implementation to be used to manage the application - URL state. The following values are supported: - - * 'hash': Uses URL fragment identifiers (like #/blog/1) for routing. - * 'history': Uses the browser's history.pushstate API for routing. Only works in - modern browsers with pushstate support. - * 'none': Does not read or set the browser URL, but still allows for - routing to happen. Useful for testing. - - @property location - @type String - @default 'hash' - */ - location: 'hash', - - /** - This is only used when a history location is used so that applications that - don't live at the root of the domain can append paths to their root. - - @property rootURL - @type String - @default '/' - */ - - rootURL: '/', - - transitionTo: function() { - this.abortRoutingPromises(); - this._super.apply(this, arguments); - }, - - route: function(path) { - this.abortRoutingPromises(); - - set(this, 'isRouting', true); - - var routableState; - - try { - path = path.replace(get(this, 'rootURL'), ''); - path = path.replace(/^(?=[^\/])/, "/"); - - this.send('navigateAway'); - this.send('unroutePath', path); - - routableState = get(this, 'currentState'); - while (routableState && !routableState.get('isRoutable')) { - routableState = get(routableState, 'parentState'); - } - var currentURL = routableState ? routableState.absoluteRoute(this) : ''; - var rest = path.substr(currentURL.length); - - this.send('routePath', rest); - } finally { - set(this, 'isRouting', false); - } - - routableState = get(this, 'currentState'); - while (routableState && !routableState.get('isRoutable')) { - routableState = get(routableState, 'parentState'); - } - - if (routableState) { - routableState.updateRoute(this, get(this, 'location')); - } - }, - - urlFor: function(path, hash) { - var currentState = get(this, 'currentState') || this, - state = this.findStateByPath(currentState, path); - - Ember.assert(Ember.String.fmt("Could not find route with path '%@'", [path]), state); - Ember.assert(Ember.String.fmt("To get a URL for the state '%@', it must have a `route` property.", [path]), get(state, 'routeMatcher')); - - var location = get(this, 'location'), - absoluteRoute = state.absoluteRoute(this, hash); - - return location.formatURL(absoluteRoute); - }, - - urlForEvent: function(eventName) { - var contexts = Array.prototype.slice.call(arguments, 1); - var currentState = get(this, 'currentState'); - var targetStateName = currentState.lookupEventTransition(eventName); - - Ember.assert(Ember.String.fmt("You must specify a target state for event '%@' in order to link to it in the current state '%@'.", [eventName, get(currentState, 'path')]), targetStateName); - - var targetState = this.findStateByPath(currentState, targetStateName); - - Ember.assert("Your target state name " + targetStateName + " for event " + eventName + " did not resolve to a state", targetState); - - var hash = this.serializeRecursively(targetState, contexts, {}); - - return this.urlFor(targetStateName, hash); - }, - - serializeRecursively: function(state, contexts, hash) { - var parentState, - context = get(state, 'hasContext') ? contexts.pop() : null; - merge(hash, state.serialize(this, context)); - parentState = state.get("parentState"); - if (parentState && parentState instanceof Ember.Route) { - return this.serializeRecursively(parentState, contexts, hash); - } else { - return hash; - } - }, - - abortRoutingPromises: function() { - if (this._routingPromises) { - this._routingPromises.abort(); - this._routingPromises = null; - } - }, - - handleStatePromises: function(states, complete) { - this.abortRoutingPromises(); - - this.set('isLocked', true); - - var manager = this; - - this._routingPromises = Ember._PromiseChain.create({ - promises: states.slice(), - - successCallback: function() { - manager.set('isLocked', false); - complete(); - }, - - failureCallback: function() { - throw "Unable to load object"; - }, - - promiseSuccessCallback: function(item, args) { - set(item, 'object', args[0]); - }, - - abortCallback: function() { - manager.set('isLocked', false); - } - }).start(); - }, - - moveStatesIntoRoot: function() { - this.root = Ember.Route.extend(); - - for (var name in this) { - if (name === "constructor") { continue; } - - var state = this[name]; - - if (state instanceof Ember.Route || Ember.Route.detect(state)) { - this.root[name] = state; - delete this[name]; - } - } - }, - - init: function() { - if (!this.root) { - this.moveStatesIntoRoot(); - } - - this._super(); - - var location = get(this, 'location'), - rootURL = get(this, 'rootURL'); - - if ('string' === typeof location) { - set(this, 'location', Ember.Location.create({ - implementation: location, - rootURL: rootURL - })); - } - - this.assignRouter(this, this); - }, - - assignRouter: function(state, router) { - state.router = router; - - var childStates = state.states; - - if (childStates) { - for (var stateName in childStates) { - if (!childStates.hasOwnProperty(stateName)) { continue; } - this.assignRouter(childStates[stateName], router); - } - } - }, - - willDestroy: function() { - get(this, 'location').destroy(); - } -}); - -})(); - - - -(function() { -/** -Ember Routing - -@module ember -@submodule ember-routing -@requires ember-states -*/ - -})(); - -(function() { -// ========================================================================== -// Project: metamorph -// Copyright: ©2011 My Company Inc. All rights reserved. -// ========================================================================== - -(function(window) { - - var K = function(){}, - guid = 0, - document = window.document, - - // Feature-detect the W3C range API, the extended check is for IE9 which only partially supports ranges - supportsRange = ('createRange' in document) && (typeof Range !== 'undefined') && Range.prototype.createContextualFragment, - - // Internet Explorer prior to 9 does not allow setting innerHTML if the first element - // is a "zero-scope" element. This problem can be worked around by making - // the first node an invisible text node. We, like Modernizr, use ­ - needsShy = (function(){ - var testEl = document.createElement('div'); - testEl.innerHTML = "
    "; - testEl.firstChild.innerHTML = ""; - return testEl.firstChild.innerHTML === ''; - })(); - - // Constructor that supports either Metamorph('foo') or new - // Metamorph('foo'); - // - // Takes a string of HTML as the argument. - - var Metamorph = function(html) { - var self; - - if (this instanceof Metamorph) { - self = this; - } else { - self = new K(); - } - - self.innerHTML = html; - var myGuid = 'metamorph-'+(guid++); - self.start = myGuid + '-start'; - self.end = myGuid + '-end'; - - return self; - }; - - K.prototype = Metamorph.prototype; - - var rangeFor, htmlFunc, removeFunc, outerHTMLFunc, appendToFunc, afterFunc, prependFunc, startTagFunc, endTagFunc; - - outerHTMLFunc = function() { - return this.startTag() + this.innerHTML + this.endTag(); - }; - - startTagFunc = function() { - return ""; - }; - - endTagFunc = function() { - return ""; - }; - - // If we have the W3C range API, this process is relatively straight forward. - if (supportsRange) { - - // Get a range for the current morph. Optionally include the starting and - // ending placeholders. - rangeFor = function(morph, outerToo) { - var range = document.createRange(); - var before = document.getElementById(morph.start); - var after = document.getElementById(morph.end); - - if (outerToo) { - range.setStartBefore(before); - range.setEndAfter(after); - } else { - range.setStartAfter(before); - range.setEndBefore(after); - } - - return range; - }; - - htmlFunc = function(html, outerToo) { - // get a range for the current metamorph object - var range = rangeFor(this, outerToo); - - // delete the contents of the range, which will be the - // nodes between the starting and ending placeholder. - range.deleteContents(); - - // create a new document fragment for the HTML - var fragment = range.createContextualFragment(html); - - // insert the fragment into the range - range.insertNode(fragment); - }; - - removeFunc = function() { - // get a range for the current metamorph object including - // the starting and ending placeholders. - var range = rangeFor(this, true); - - // delete the entire range. - range.deleteContents(); - }; - - appendToFunc = function(node) { - var range = document.createRange(); - range.setStart(node); - range.collapse(false); - var frag = range.createContextualFragment(this.outerHTML()); - node.appendChild(frag); - }; - - afterFunc = function(html) { - var range = document.createRange(); - var after = document.getElementById(this.end); - - range.setStartAfter(after); - range.setEndAfter(after); - - var fragment = range.createContextualFragment(html); - range.insertNode(fragment); - }; - - prependFunc = function(html) { - var range = document.createRange(); - var start = document.getElementById(this.start); - - range.setStartAfter(start); - range.setEndAfter(start); - - var fragment = range.createContextualFragment(html); - range.insertNode(fragment); - }; - - } else { - /** - * This code is mostly taken from jQuery, with one exception. In jQuery's case, we - * have some HTML and we need to figure out how to convert it into some nodes. - * - * In this case, jQuery needs to scan the HTML looking for an opening tag and use - * that as the key for the wrap map. In our case, we know the parent node, and - * can use its type as the key for the wrap map. - **/ - var wrapMap = { - select: [ 1, "" ], - fieldset: [ 1, "
    ", "
    " ], - table: [ 1, "", "
    " ], - tbody: [ 2, "", "
    " ], - tr: [ 3, "", "
    " ], - colgroup: [ 2, "", "
    " ], - map: [ 1, "", "" ], - _default: [ 0, "", "" ] - }; - - /** - * Given a parent node and some HTML, generate a set of nodes. Return the first - * node, which will allow us to traverse the rest using nextSibling. - * - * We need to do this because innerHTML in IE does not really parse the nodes. - **/ - var firstNodeFor = function(parentNode, html) { - var arr = wrapMap[parentNode.tagName.toLowerCase()] || wrapMap._default; - var depth = arr[0], start = arr[1], end = arr[2]; - - if (needsShy) { html = '­'+html; } - - var element = document.createElement('div'); - element.innerHTML = start + html + end; - - for (var i=0; i<=depth; i++) { - element = element.firstChild; - } - - // Look for ­ to remove it. - if (needsShy) { - var shyElement = element; - - // Sometimes we get nameless elements with the shy inside - while (shyElement.nodeType === 1 && !shyElement.nodeName) { - shyElement = shyElement.firstChild; - } - - // At this point it's the actual unicode character. - if (shyElement.nodeType === 3 && shyElement.nodeValue.charAt(0) === "\u00AD") { - shyElement.nodeValue = shyElement.nodeValue.slice(1); - } - } - - return element; - }; - - /** - * In some cases, Internet Explorer can create an anonymous node in - * the hierarchy with no tagName. You can create this scenario via: - * - * div = document.createElement("div"); - * div.innerHTML = "­
    hi
    "; - * div.firstChild.firstChild.tagName //=> "" - * - * If our script markers are inside such a node, we need to find that - * node and use *it* as the marker. - **/ - var realNode = function(start) { - while (start.parentNode.tagName === "") { - start = start.parentNode; - } - - return start; - }; - - /** - * When automatically adding a tbody, Internet Explorer inserts the - * tbody immediately before the first . Other browsers create it - * before the first node, no matter what. - * - * This means the the following code: - * - * div = document.createElement("div"); - * div.innerHTML = "
    hi
    - * - * Generates the following DOM in IE: - * - * + div - * + table - * - script id='first' - * + tbody - * + tr - * + td - * - "hi" - * - script id='last' - * - * Which means that the two script tags, even though they were - * inserted at the same point in the hierarchy in the original - * HTML, now have different parents. - * - * This code reparents the first script tag by making it the tbody's - * first child. - **/ - var fixParentage = function(start, end) { - if (start.parentNode !== end.parentNode) { - end.parentNode.insertBefore(start, end.parentNode.firstChild); - } - }; - - htmlFunc = function(html, outerToo) { - // get the real starting node. see realNode for details. - var start = realNode(document.getElementById(this.start)); - var end = document.getElementById(this.end); - var parentNode = end.parentNode; - var node, nextSibling, last; - - // make sure that the start and end nodes share the same - // parent. If not, fix it. - fixParentage(start, end); - - // remove all of the nodes after the starting placeholder and - // before the ending placeholder. - node = start.nextSibling; - while (node) { - nextSibling = node.nextSibling; - last = node === end; - - // if this is the last node, and we want to remove it as well, - // set the `end` node to the next sibling. This is because - // for the rest of the function, we insert the new nodes - // before the end (note that insertBefore(node, null) is - // the same as appendChild(node)). - // - // if we do not want to remove it, just break. - if (last) { - if (outerToo) { end = node.nextSibling; } else { break; } - } - - node.parentNode.removeChild(node); - - // if this is the last node and we didn't break before - // (because we wanted to remove the outer nodes), break - // now. - if (last) { break; } - - node = nextSibling; - } - - // get the first node for the HTML string, even in cases like - // tables and lists where a simple innerHTML on a div would - // swallow some of the content. - node = firstNodeFor(start.parentNode, html); - - // copy the nodes for the HTML between the starting and ending - // placeholder. - while (node) { - nextSibling = node.nextSibling; - parentNode.insertBefore(node, end); - node = nextSibling; - } - }; - - // remove the nodes in the DOM representing this metamorph. - // - // this includes the starting and ending placeholders. - removeFunc = function() { - var start = realNode(document.getElementById(this.start)); - var end = document.getElementById(this.end); - - this.html(''); - start.parentNode.removeChild(start); - end.parentNode.removeChild(end); - }; - - appendToFunc = function(parentNode) { - var node = firstNodeFor(parentNode, this.outerHTML()); - - while (node) { - nextSibling = node.nextSibling; - parentNode.appendChild(node); - node = nextSibling; - } - }; - - afterFunc = function(html) { - // get the real starting node. see realNode for details. - var end = document.getElementById(this.end); - var insertBefore = end.nextSibling; - var parentNode = end.parentNode; - var nextSibling; - var node; - - // get the first node for the HTML string, even in cases like - // tables and lists where a simple innerHTML on a div would - // swallow some of the content. - node = firstNodeFor(parentNode, html); - - // copy the nodes for the HTML between the starting and ending - // placeholder. - while (node) { - nextSibling = node.nextSibling; - parentNode.insertBefore(node, insertBefore); - node = nextSibling; - } - }; - - prependFunc = function(html) { - var start = document.getElementById(this.start); - var parentNode = start.parentNode; - var nextSibling; - var node; - - node = firstNodeFor(parentNode, html); - var insertBefore = start.nextSibling; - - while (node) { - nextSibling = node.nextSibling; - parentNode.insertBefore(node, insertBefore); - node = nextSibling; - } - } - } - - Metamorph.prototype.html = function(html) { - this.checkRemoved(); - if (html === undefined) { return this.innerHTML; } - - htmlFunc.call(this, html); - - this.innerHTML = html; - }; - - Metamorph.prototype.replaceWith = function(html) { - this.checkRemoved(); - htmlFunc.call(this, html, true); - }; - - Metamorph.prototype.remove = removeFunc; - Metamorph.prototype.outerHTML = outerHTMLFunc; - Metamorph.prototype.appendTo = appendToFunc; - Metamorph.prototype.after = afterFunc; - Metamorph.prototype.prepend = prependFunc; - Metamorph.prototype.startTag = startTagFunc; - Metamorph.prototype.endTag = endTagFunc; - - Metamorph.prototype.isRemoved = function() { - var before = document.getElementById(this.start); - var after = document.getElementById(this.end); - - return !before || !after; - }; - - Metamorph.prototype.checkRemoved = function() { - if (this.isRemoved()) { - throw new Error("Cannot perform operations on a Metamorph that is not in the DOM."); - } - }; - - window.Metamorph = Metamorph; -})(this); - - -})(); - -(function() { -/** -@module ember -@submodule ember-handlebars -*/ - -var objectCreate = Ember.create; - -var Handlebars = Ember.imports.Handlebars; -Ember.assert("Ember Handlebars requires Handlebars 1.0.beta.5 or greater", Handlebars && Handlebars.VERSION.match(/^1\.0\.beta\.[56789]$|^1\.0\.rc\.[123456789]+/)); - -/** - Prepares the Handlebars templating library for use inside Ember's view - system. - - The Ember.Handlebars object is the standard Handlebars library, extended to use - Ember's get() method instead of direct property access, which allows - computed properties to be used inside templates. - - To create an Ember.Handlebars template, call Ember.Handlebars.compile(). This will - return a function that can be used by Ember.View for rendering. - - @class Handlebars - @namespace Ember -*/ -Ember.Handlebars = objectCreate(Handlebars); - -/** -@class helpers -@namespace Ember.Handlebars -*/ -Ember.Handlebars.helpers = objectCreate(Handlebars.helpers); - -/** - Override the the opcode compiler and JavaScript compiler for Handlebars. - - @class Compiler - @namespace Ember.Handlebars - @private - @constructor -*/ -Ember.Handlebars.Compiler = function() {}; - -// Handlebars.Compiler doesn't exist in runtime-only -if (Handlebars.Compiler) { - Ember.Handlebars.Compiler.prototype = objectCreate(Handlebars.Compiler.prototype); -} - -Ember.Handlebars.Compiler.prototype.compiler = Ember.Handlebars.Compiler; - -/** - @class JavaScriptCompiler - @namespace Ember.Handlebars - @private - @constructor -*/ -Ember.Handlebars.JavaScriptCompiler = function() {}; - -// Handlebars.JavaScriptCompiler doesn't exist in runtime-only -if (Handlebars.JavaScriptCompiler) { - Ember.Handlebars.JavaScriptCompiler.prototype = objectCreate(Handlebars.JavaScriptCompiler.prototype); - Ember.Handlebars.JavaScriptCompiler.prototype.compiler = Ember.Handlebars.JavaScriptCompiler; -} - - -Ember.Handlebars.JavaScriptCompiler.prototype.namespace = "Ember.Handlebars"; - - -Ember.Handlebars.JavaScriptCompiler.prototype.initializeBuffer = function() { - return "''"; -}; - -/** - @private - - Override the default buffer for Ember Handlebars. By default, Handlebars creates - an empty String at the beginning of each invocation and appends to it. Ember's - Handlebars overrides this to append to a single shared buffer. - - @method appendToBuffer - @param string {String} -*/ -Ember.Handlebars.JavaScriptCompiler.prototype.appendToBuffer = function(string) { - return "data.buffer.push("+string+");"; -}; - -/** - @private - - Rewrite simple mustaches from `{{foo}}` to `{{bind "foo"}}`. This means that all simple - mustaches in Ember's Handlebars will also set up an observer to keep the DOM - up to date when the underlying property changes. - - @method mustache - @for Ember.Handlebars.Compiler - @param mustache -*/ -Ember.Handlebars.Compiler.prototype.mustache = function(mustache) { - if (mustache.params.length || mustache.hash) { - return Handlebars.Compiler.prototype.mustache.call(this, mustache); - } else { - var id = new Handlebars.AST.IdNode(['_triageMustache']); - - // Update the mustache node to include a hash value indicating whether the original node - // was escaped. This will allow us to properly escape values when the underlying value - // changes and we need to re-render the value. - if(!mustache.escaped) { - mustache.hash = mustache.hash || new Handlebars.AST.HashNode([]); - mustache.hash.pairs.push(["unescaped", new Handlebars.AST.StringNode("true")]); - } - mustache = new Handlebars.AST.MustacheNode([id].concat([mustache.id]), mustache.hash, !mustache.escaped); - return Handlebars.Compiler.prototype.mustache.call(this, mustache); - } -}; - -/** - Used for precompilation of Ember Handlebars templates. This will not be used during normal - app execution. - - @method precompile - @for Ember.Handlebars - @static - @param {String} string The template to precompile -*/ -Ember.Handlebars.precompile = function(string) { - var ast = Handlebars.parse(string); - - var options = { - knownHelpers: { - action: true, - unbound: true, - bindAttr: true, - template: true, - view: true, - _triageMustache: true - }, - data: true, - stringParams: true - }; - - var environment = new Ember.Handlebars.Compiler().compile(ast, options); - return new Ember.Handlebars.JavaScriptCompiler().compile(environment, options, undefined, true); -}; - -// We don't support this for Handlebars runtime-only -if (Handlebars.compile) { - /** - The entry point for Ember Handlebars. This replaces the default Handlebars.compile and turns on - template-local data and String parameters. - - @method compile - @for Ember.Handlebars - @static - @param {String} string The template to compile - @return {Function} - */ - Ember.Handlebars.compile = function(string) { - var ast = Handlebars.parse(string); - var options = { data: true, stringParams: true }; - var environment = new Ember.Handlebars.Compiler().compile(ast, options); - var templateSpec = new Ember.Handlebars.JavaScriptCompiler().compile(environment, options, undefined, true); - - return Handlebars.template(templateSpec); - }; -} - -/** - @private - - If a path starts with a reserved keyword, returns the root - that should be used. - - @method normalizePath - @for Ember - @param root {Object} - @param path {String} - @param data {Hash} -*/ -var normalizePath = Ember.Handlebars.normalizePath = function(root, path, data) { - var keywords = (data && data.keywords) || {}, - keyword, isKeyword; - - // Get the first segment of the path. For example, if the - // path is "foo.bar.baz", returns "foo". - keyword = path.split('.', 1)[0]; - - // Test to see if the first path is a keyword that has been - // passed along in the view's data hash. If so, we will treat - // that object as the new root. - if (keywords.hasOwnProperty(keyword)) { - // Look up the value in the template's data hash. - root = keywords[keyword]; - isKeyword = true; - - // Handle cases where the entire path is the reserved - // word. In that case, return the object itself. - if (path === keyword) { - path = ''; - } else { - // Strip the keyword from the path and look up - // the remainder from the newly found root. - path = path.substr(keyword.length+1); - } - } - - return { root: root, path: path, isKeyword: isKeyword }; -}; - - -/** - Lookup both on root and on window. If the path starts with - a keyword, the corresponding object will be looked up in the - template's data hash and used to resolve the path. - - @method getPath - @for Ember.Handlebars - @param {Object} root The object to look up the property on - @param {String} path The path to be lookedup - @param {Object} options The template's option hash -*/ -Ember.Handlebars.getPath = function(root, path, options) { - var data = options && options.data, - normalizedPath = normalizePath(root, path, data), - value; - - // In cases where the path begins with a keyword, change the - // root to the value represented by that keyword, and ensure - // the path is relative to it. - root = normalizedPath.root; - path = normalizedPath.path; - - value = Ember.get(root, path); - - // If the path starts with a capital letter, look it up on Ember.lookup, - // which defaults to the `window` object in browsers. - if (value === undefined && root !== Ember.lookup && Ember.isGlobalPath(path)) { - value = Ember.get(Ember.lookup, path); - } - return value; -}; - -/** - @private - - Registers a helper in Handlebars that will be called if no property with the - given name can be found on the current context object, and no helper with - that name is registered. - - This throws an exception with a more helpful error message so the user can - track down where the problem is happening. - - @method helperMissing - @for Ember.Handlebars.helpers - @param {String} path - @param {Hash} options -*/ -Ember.Handlebars.registerHelper('helperMissing', function(path, options) { - var error, view = ""; - - error = "%@ Handlebars error: Could not find property '%@' on object %@."; - if (options.data){ - view = options.data.view; - } - throw new Ember.Error(Ember.String.fmt(error, [view, path, this])); -}); - - -})(); - - - -(function() { -/** - @method htmlSafe - @for Ember.String - @static -*/ -Ember.String.htmlSafe = function(str) { - return new Handlebars.SafeString(str); -}; - -var htmlSafe = Ember.String.htmlSafe; - -if (Ember.EXTEND_PROTOTYPES === true || Ember.EXTEND_PROTOTYPES.String) { - - /** - See {{#crossLink "Ember.String/htmlSafe"}}{{/crossLink}} - - @method htmlSafe - @for String - */ - String.prototype.htmlSafe = function() { - return htmlSafe(this); - }; -} - -})(); - - - -(function() { -/*jshint newcap:false*/ -/** -@module ember -@submodule ember-handlebars -*/ - -var set = Ember.set, get = Ember.get; - -// DOMManager should just abstract dom manipulation between jquery and metamorph -var DOMManager = { - remove: function(view) { - view.morph.remove(); - }, - - prepend: function(view, html) { - view.morph.prepend(html); - }, - - after: function(view, html) { - view.morph.after(html); - }, - - html: function(view, html) { - view.morph.html(html); - }, - - // This is messed up. - replace: function(view) { - var morph = view.morph; - - view.transitionTo('preRender'); - view.clearRenderedChildren(); - var buffer = view.renderToBuffer(); - - Ember.run.schedule('render', this, function() { - if (get(view, 'isDestroyed')) { return; } - view.invalidateRecursively('element'); - view._notifyWillInsertElement(); - morph.replaceWith(buffer.string()); - view.transitionTo('inDOM'); - view._notifyDidInsertElement(); - }); - }, - - empty: function(view) { - view.morph.html(""); - } -}; - -// The `morph` and `outerHTML` properties are internal only -// and not observable. - -/** - @class _Metamorph - @namespace Ember - @extends Ember.Mixin - @private -*/ -Ember._Metamorph = Ember.Mixin.create({ - isVirtual: true, - tagName: '', - - instrumentName: 'render.metamorph', - - init: function() { - this._super(); - this.morph = Metamorph(); - }, - - beforeRender: function(buffer) { - buffer.push(this.morph.startTag()); - }, - - afterRender: function(buffer) { - buffer.push(this.morph.endTag()); - }, - - createElement: function() { - var buffer = this.renderToBuffer(); - this.outerHTML = buffer.string(); - this.clearBuffer(); - }, - - domManager: DOMManager -}); - -/** - @class _MetamorphView - @namespace Ember - @extends Ember.View - @uses Ember._Metamorph - @private -*/ -Ember._MetamorphView = Ember.View.extend(Ember._Metamorph); - -/** - @class _SimpleMetamorphView - @namespace Ember - @extends Ember.View - @uses Ember._Metamorph - @private -*/ -Ember._SimpleMetamorphView = Ember.CoreView.extend(Ember._Metamorph); - - -})(); - - - -(function() { -/*globals Handlebars */ - -/** -@module ember -@submodule ember-handlebars -*/ - -var get = Ember.get, set = Ember.set, getPath = Ember.Handlebars.getPath; -Ember._SimpleHandlebarsView = Ember._SimpleMetamorphView.extend({ - instrumentName: 'render.simpleHandlebars', - - normalizedValue: Ember.computed(function() { - var path = get(this, 'path'), - pathRoot = get(this, 'pathRoot'), - result, templateData; - - // Use the pathRoot as the result if no path is provided. This - // happens if the path is `this`, which gets normalized into - // a `pathRoot` of the current Handlebars context and a path - // of `''`. - if (path === '') { - result = pathRoot; - } else { - templateData = get(this, 'templateData'); - result = getPath(pathRoot, path, { data: templateData }); - } - - return result; - }).property('path', 'pathRoot').volatile(), - - render: function(buffer) { - // If not invoked via a triple-mustache ({{{foo}}}), escape - // the content of the template. - var escape = get(this, 'isEscaped'); - var result = get(this, 'normalizedValue'); - - if (result === null || result === undefined) { - result = ""; - } else if (!(result instanceof Handlebars.SafeString)) { - result = String(result); - } - - if (escape) { result = Handlebars.Utils.escapeExpression(result); } - buffer.push(result); - return; - }, - - rerender: function() { - switch(this.state) { - case 'preRender': - case 'destroyed': - break; - case 'inBuffer': - throw new Error("Something you did tried to replace an {{expression}} before it was inserted into the DOM."); - case 'hasElement': - case 'inDOM': - this.domManager.replace(this); - break; - } - - return this; - }, - - transitionTo: function(state) { - this.state = state; - } -}); - -/** - Ember._HandlebarsBoundView is a private view created by the Handlebars `{{bind}}` - helpers that is used to keep track of bound properties. - - Every time a property is bound using a `{{mustache}}`, an anonymous subclass - of Ember._HandlebarsBoundView is created with the appropriate sub-template and - context set up. When the associated property changes, just the template for - this view will re-render. - - @class _HandlebarsBoundView - @namespace Ember - @extends Ember._MetamorphView - @private -*/ -Ember._HandlebarsBoundView = Ember._MetamorphView.extend({ - instrumentName: 'render.boundHandlebars', - - /** - The function used to determine if the `displayTemplate` or - `inverseTemplate` should be rendered. This should be a function that takes - a value and returns a Boolean. - - @property shouldDisplayFunc - @type Function - @default null - */ - shouldDisplayFunc: null, - - /** - Whether the template rendered by this view gets passed the context object - of its parent template, or gets passed the value of retrieving `path` - from the `pathRoot`. - - For example, this is true when using the `{{#if}}` helper, because the - template inside the helper should look up properties relative to the same - object as outside the block. This would be false when used with `{{#with - foo}}` because the template should receive the object found by evaluating - `foo`. - - @property preserveContext - @type Boolean - @default false - */ - preserveContext: false, - - /** - If `preserveContext` is true, this is the object that will be used - to render the template. - - @property previousContext - @type Object - */ - previousContext: null, - - /** - The template to render when `shouldDisplayFunc` evaluates to true. - - @property displayTemplate - @type Function - @default null - */ - displayTemplate: null, - - /** - The template to render when `shouldDisplayFunc` evaluates to false. - - @property inverseTemplate - @type Function - @default null - */ - inverseTemplate: null, - - - /** - The path to look up on `pathRoot` that is passed to - `shouldDisplayFunc` to determine which template to render. - - In addition, if `preserveContext` is false, the object at this path will - be passed to the template when rendering. - - @property path - @type String - @default null - */ - path: null, - - /** - The object from which the `path` will be looked up. Sometimes this is the - same as the `previousContext`, but in cases where this view has been generated - for paths that start with a keyword such as `view` or `controller`, the - path root will be that resolved object. - - @property pathRoot - @type Object - */ - pathRoot: null, - - normalizedValue: Ember.computed(function() { - var path = get(this, 'path'), - pathRoot = get(this, 'pathRoot'), - valueNormalizer = get(this, 'valueNormalizerFunc'), - result, templateData; - - // Use the pathRoot as the result if no path is provided. This - // happens if the path is `this`, which gets normalized into - // a `pathRoot` of the current Handlebars context and a path - // of `''`. - if (path === '') { - result = pathRoot; - } else { - templateData = get(this, 'templateData'); - result = getPath(pathRoot, path, { data: templateData }); - } - - return valueNormalizer ? valueNormalizer(result) : result; - }).property('path', 'pathRoot', 'valueNormalizerFunc').volatile(), - - rerenderIfNeeded: function() { - if (!get(this, 'isDestroyed') && get(this, 'normalizedValue') !== this._lastNormalizedValue) { - this.rerender(); - } - }, - - /** - Determines which template to invoke, sets up the correct state based on - that logic, then invokes the default Ember.View `render` implementation. - - This method will first look up the `path` key on `pathRoot`, - then pass that value to the `shouldDisplayFunc` function. If that returns - true, the `displayTemplate` function will be rendered to DOM. Otherwise, - `inverseTemplate`, if specified, will be rendered. - - For example, if this Ember._HandlebarsBoundView represented the `{{#with foo}}` - helper, it would look up the `foo` property of its context, and - `shouldDisplayFunc` would always return true. The object found by looking - up `foo` would be passed to `displayTemplate`. - - @method render - @param {Ember.RenderBuffer} buffer - */ - render: function(buffer) { - // If not invoked via a triple-mustache ({{{foo}}}), escape - // the content of the template. - var escape = get(this, 'isEscaped'); - - var shouldDisplay = get(this, 'shouldDisplayFunc'), - preserveContext = get(this, 'preserveContext'), - context = get(this, 'previousContext'); - - var inverseTemplate = get(this, 'inverseTemplate'), - displayTemplate = get(this, 'displayTemplate'); - - var result = get(this, 'normalizedValue'); - this._lastNormalizedValue = result; - - // First, test the conditional to see if we should - // render the template or not. - if (shouldDisplay(result)) { - set(this, 'template', displayTemplate); - - // If we are preserving the context (for example, if this - // is an #if block, call the template with the same object. - if (preserveContext) { - set(this, '_context', context); - } else { - // Otherwise, determine if this is a block bind or not. - // If so, pass the specified object to the template - if (displayTemplate) { - set(this, '_context', result); - } else { - // This is not a bind block, just push the result of the - // expression to the render context and return. - if (result === null || result === undefined) { - result = ""; - } else if (!(result instanceof Handlebars.SafeString)) { - result = String(result); - } - - if (escape) { result = Handlebars.Utils.escapeExpression(result); } - buffer.push(result); - return; - } - } - } else if (inverseTemplate) { - set(this, 'template', inverseTemplate); - - if (preserveContext) { - set(this, '_context', context); - } else { - set(this, '_context', result); - } - } else { - set(this, 'template', function() { return ''; }); - } - - return this._super(buffer); - } -}); - -})(); - - - -(function() { -/** -@module ember -@submodule ember-handlebars -*/ - -var get = Ember.get, set = Ember.set, fmt = Ember.String.fmt; -var getPath = Ember.Handlebars.getPath, normalizePath = Ember.Handlebars.normalizePath; -var forEach = Ember.ArrayPolyfills.forEach; - -var EmberHandlebars = Ember.Handlebars, helpers = EmberHandlebars.helpers; - -// Binds a property into the DOM. This will create a hook in DOM that the -// KVO system will look for and update if the property changes. -function bind(property, options, preserveContext, shouldDisplay, valueNormalizer) { - var data = options.data, - fn = options.fn, - inverse = options.inverse, - view = data.view, - currentContext = this, - pathRoot, path, normalized; - - normalized = normalizePath(currentContext, property, data); - - pathRoot = normalized.root; - path = normalized.path; - - // Set up observers for observable objects - if ('object' === typeof this) { - // Create the view that will wrap the output of this template/property - // and add it to the nearest view's childViews array. - // See the documentation of Ember._HandlebarsBoundView for more. - var bindView = view.createChildView(Ember._HandlebarsBoundView, { - preserveContext: preserveContext, - shouldDisplayFunc: shouldDisplay, - valueNormalizerFunc: valueNormalizer, - displayTemplate: fn, - inverseTemplate: inverse, - path: path, - pathRoot: pathRoot, - previousContext: currentContext, - isEscaped: !options.hash.unescaped, - templateData: options.data - }); - - view.appendChild(bindView); - - var observer = function() { - Ember.run.scheduleOnce('render', bindView, 'rerenderIfNeeded'); - }; - - // Observes the given property on the context and - // tells the Ember._HandlebarsBoundView to re-render. If property - // is an empty string, we are printing the current context - // object ({{this}}) so updating it is not our responsibility. - if (path !== '') { - Ember.addObserver(pathRoot, path, observer); - - view.one('willClearRender', function() { - Ember.removeObserver(pathRoot, path, observer); - }); - } - } else { - // The object is not observable, so just render it out and - // be done with it. - data.buffer.push(getPath(pathRoot, path, options)); - } -} - -function simpleBind(property, options) { - var data = options.data, - view = data.view, - currentContext = this, - pathRoot, path, normalized; - - normalized = normalizePath(currentContext, property, data); - - pathRoot = normalized.root; - path = normalized.path; - - // Set up observers for observable objects - if ('object' === typeof this) { - var bindView = Ember._SimpleHandlebarsView.create().setProperties({ - path: path, - pathRoot: pathRoot, - isEscaped: !options.hash.unescaped, - previousContext: currentContext, - templateData: options.data - }); - - view.createChildView(bindView); - view.appendChild(bindView); - - var observer = function() { - Ember.run.scheduleOnce('render', bindView, 'rerender'); - }; - - // Observes the given property on the context and - // tells the Ember._HandlebarsBoundView to re-render. If property - // is an empty string, we are printing the current context - // object ({{this}}) so updating it is not our responsibility. - if (path !== '') { - Ember.addObserver(pathRoot, path, observer); - - view.one('willClearRender', function() { - Ember.removeObserver(pathRoot, path, observer); - }); - } - } else { - // The object is not observable, so just render it out and - // be done with it. - data.buffer.push(getPath(pathRoot, path, options)); - } -} - -/** - @private - - '_triageMustache' is used internally select between a binding and helper for - the given context. Until this point, it would be hard to determine if the - mustache is a property reference or a regular helper reference. This triage - helper resolves that. - - This would not be typically invoked by directly. - - @method _triageMustache - @for Ember.Handlebars.helpers - @param {String} property Property/helperID to triage - @param {Function} fn Context to provide for rendering - @return {String} HTML string -*/ -EmberHandlebars.registerHelper('_triageMustache', function(property, fn) { - Ember.assert("You cannot pass more than one argument to the _triageMustache helper", arguments.length <= 2); - if (helpers[property]) { - return helpers[property].call(this, fn); - } - else { - return helpers.bind.apply(this, arguments); - } -}); - -/** - @private - - `bind` can be used to display a value, then update that value if it - changes. For example, if you wanted to print the `title` property of - `content`: - - ``` handlebars - {{bind "content.title"}} - ``` - - This will return the `title` property as a string, then create a new - observer at the specified path. If it changes, it will update the value in - DOM. Note that if you need to support IE7 and IE8 you must modify the - model objects properties using Ember.get() and Ember.set() for this to work as - it relies on Ember's KVO system. For all other browsers this will be handled - for you automatically. - - @method bind - @for Ember.Handlebars.helpers - @param {String} property Property to bind - @param {Function} fn Context to provide for rendering - @return {String} HTML string -*/ -EmberHandlebars.registerHelper('bind', function(property, options) { - Ember.assert("You cannot pass more than one argument to the bind helper", arguments.length <= 2); - - var context = (options.contexts && options.contexts[0]) || this; - - if (!options.fn) { - return simpleBind.call(context, property, options); - } - - return bind.call(context, property, options, false, function(result) { - return !Ember.none(result); - }); -}); - -/** - @private - - Use the `boundIf` helper to create a conditional that re-evaluates - whenever the bound value changes. - - ``` handlebars - {{#boundIf "content.shouldDisplayTitle"}} - {{content.title}} - {{/boundIf}} - ``` - - @method boundIf - @for Ember.Handlebars.helpers - @param {String} property Property to bind - @param {Function} fn Context to provide for rendering - @return {String} HTML string -*/ -EmberHandlebars.registerHelper('boundIf', function(property, fn) { - var context = (fn.contexts && fn.contexts[0]) || this; - var func = function(result) { - if (Ember.typeOf(result) === 'array') { - return get(result, 'length') !== 0; - } else { - return !!result; - } - }; - - return bind.call(context, property, fn, true, func, func); -}); - -/** - @method with - @for Ember.Handlebars.helpers - @param {Function} context - @param {Hash} options - @return {String} HTML string -*/ -EmberHandlebars.registerHelper('with', function(context, options) { - if (arguments.length === 4) { - var keywordName, path, rootPath, normalized; - - Ember.assert("If you pass more than one argument to the with helper, it must be in the form #with foo as bar", arguments[1] === "as"); - options = arguments[3]; - keywordName = arguments[2]; - path = arguments[0]; - - Ember.assert("You must pass a block to the with helper", options.fn && options.fn !== Handlebars.VM.noop); - - if (Ember.isGlobalPath(path)) { - Ember.bind(options.data.keywords, keywordName, path); - } else { - normalized = normalizePath(this, path, options.data); - path = normalized.path; - rootPath = normalized.root; - - // This is a workaround for the fact that you cannot bind separate objects - // together. When we implement that functionality, we should use it here. - var contextKey = Ember.$.expando + Ember.guidFor(rootPath); - options.data.keywords[contextKey] = rootPath; - - // if the path is '' ("this"), just bind directly to the current context - var contextPath = path ? contextKey + '.' + path : contextKey; - Ember.bind(options.data.keywords, keywordName, contextPath); - } - - return bind.call(this, path, options, true, function(result) { - return !Ember.none(result); - }); - } else { - Ember.assert("You must pass exactly one argument to the with helper", arguments.length === 2); - Ember.assert("You must pass a block to the with helper", options.fn && options.fn !== Handlebars.VM.noop); - return helpers.bind.call(options.contexts[0], context, options); - } -}); - - -/** - @method if - @for Ember.Handlebars.helpers - @param {Function} context - @param {Hash} options - @return {String} HTML string -*/ -EmberHandlebars.registerHelper('if', function(context, options) { - Ember.assert("You must pass exactly one argument to the if helper", arguments.length === 2); - Ember.assert("You must pass a block to the if helper", options.fn && options.fn !== Handlebars.VM.noop); - - return helpers.boundIf.call(options.contexts[0], context, options); -}); - -/** - @method unless - @for Ember.Handlebars.helpers - @param {Function} context - @param {Hash} options - @return {String} HTML string -*/ -EmberHandlebars.registerHelper('unless', function(context, options) { - Ember.assert("You must pass exactly one argument to the unless helper", arguments.length === 2); - Ember.assert("You must pass a block to the unless helper", options.fn && options.fn !== Handlebars.VM.noop); - - var fn = options.fn, inverse = options.inverse; - - options.fn = inverse; - options.inverse = fn; - - return helpers.boundIf.call(options.contexts[0], context, options); -}); - -/** - `bindAttr` allows you to create a binding between DOM element attributes and - Ember objects. For example: - - ``` handlebars - imageTitle - ``` - - @method bindAttr - @for Ember.Handlebars.helpers - @param {Hash} options - @return {String} HTML string -*/ -EmberHandlebars.registerHelper('bindAttr', function(options) { - - var attrs = options.hash; - - Ember.assert("You must specify at least one hash argument to bindAttr", !!Ember.keys(attrs).length); - - var view = options.data.view; - var ret = []; - var ctx = this; - - // Generate a unique id for this element. This will be added as a - // data attribute to the element so it can be looked up when - // the bound property changes. - var dataId = ++Ember.$.uuid; - - // Handle classes differently, as we can bind multiple classes - var classBindings = attrs['class']; - if (classBindings !== null && classBindings !== undefined) { - var classResults = EmberHandlebars.bindClasses(this, classBindings, view, dataId, options); - ret.push('class="' + Handlebars.Utils.escapeExpression(classResults.join(' ')) + '"'); - delete attrs['class']; - } - - var attrKeys = Ember.keys(attrs); - - // For each attribute passed, create an observer and emit the - // current value of the property as an attribute. - forEach.call(attrKeys, function(attr) { - var path = attrs[attr], - pathRoot, normalized; - - Ember.assert(fmt("You must provide a String for a bound attribute, not %@", [path]), typeof path === 'string'); - - normalized = normalizePath(ctx, path, options.data); - - pathRoot = normalized.root; - path = normalized.path; - - var value = (path === 'this') ? pathRoot : getPath(pathRoot, path, options), - type = Ember.typeOf(value); - - Ember.assert(fmt("Attributes must be numbers, strings or booleans, not %@", [value]), value === null || value === undefined || type === 'number' || type === 'string' || type === 'boolean'); - - var observer, invoker; - - observer = function observer() { - var result = getPath(pathRoot, path, options); - - Ember.assert(fmt("Attributes must be numbers, strings or booleans, not %@", [result]), result === null || result === undefined || typeof result === 'number' || typeof result === 'string' || typeof result === 'boolean'); - - var elem = view.$("[data-bindattr-" + dataId + "='" + dataId + "']"); - - // If we aren't able to find the element, it means the element - // to which we were bound has been removed from the view. - // In that case, we can assume the template has been re-rendered - // and we need to clean up the observer. - if (!elem || elem.length === 0) { - Ember.removeObserver(pathRoot, path, invoker); - return; - } - - Ember.View.applyAttributeBindings(elem, attr, result); - }; - - invoker = function() { - Ember.run.scheduleOnce('render', observer); - }; - - // Add an observer to the view for when the property changes. - // When the observer fires, find the element using the - // unique data id and update the attribute to the new value. - if (path !== 'this') { - Ember.addObserver(pathRoot, path, invoker); - - view.one('willClearRender', function() { - Ember.removeObserver(pathRoot, path, invoker); - }); - } - - // if this changes, also change the logic in ember-views/lib/views/view.js - if ((type === 'string' || (type === 'number' && !isNaN(value)))) { - ret.push(attr + '="' + Handlebars.Utils.escapeExpression(value) + '"'); - } else if (value && type === 'boolean') { - // The developer controls the attr name, so it should always be safe - ret.push(attr + '="' + attr + '"'); - } - }, this); - - // Add the unique identifier - // NOTE: We use all lower-case since Firefox has problems with mixed case in SVG - ret.push('data-bindattr-' + dataId + '="' + dataId + '"'); - return new EmberHandlebars.SafeString(ret.join(' ')); -}); - -/** - @private - - Helper that, given a space-separated string of property paths and a context, - returns an array of class names. Calling this method also has the side - effect of setting up observers at those property paths, such that if they - change, the correct class name will be reapplied to the DOM element. - - For example, if you pass the string "fooBar", it will first look up the - "fooBar" value of the context. If that value is true, it will add the - "foo-bar" class to the current element (i.e., the dasherized form of - "fooBar"). If the value is a string, it will add that string as the class. - Otherwise, it will not add any new class name. - - @method bindClasses - @for Ember.Handlebars - @param {Ember.Object} context The context from which to lookup properties - @param {String} classBindings A string, space-separated, of class bindings to use - @param {Ember.View} view The view in which observers should look for the element to update - @param {Srting} bindAttrId Optional bindAttr id used to lookup elements - @return {Array} An array of class names to add -*/ -EmberHandlebars.bindClasses = function(context, classBindings, view, bindAttrId, options) { - var ret = [], newClass, value, elem; - - // Helper method to retrieve the property from the context and - // determine which class string to return, based on whether it is - // a Boolean or not. - var classStringForPath = function(root, parsedPath, options) { - var val, - path = parsedPath.path; - - if (path === 'this') { - val = root; - } else if (path === '') { - val = true; - } else { - val = getPath(root, path, options); - } - - return Ember.View._classStringForValue(path, val, parsedPath.className, parsedPath.falsyClassName); - }; - - // For each property passed, loop through and setup - // an observer. - forEach.call(classBindings.split(' '), function(binding) { - - // Variable in which the old class value is saved. The observer function - // closes over this variable, so it knows which string to remove when - // the property changes. - var oldClass; - - var observer, invoker; - - var parsedPath = Ember.View._parsePropertyPath(binding), - path = parsedPath.path, - pathRoot = context, - normalized; - - if (path !== '' && path !== 'this') { - normalized = normalizePath(context, path, options.data); - - pathRoot = normalized.root; - path = normalized.path; - } - - // Set up an observer on the context. If the property changes, toggle the - // class name. - observer = function() { - // Get the current value of the property - newClass = classStringForPath(pathRoot, parsedPath, options); - elem = bindAttrId ? view.$("[data-bindattr-" + bindAttrId + "='" + bindAttrId + "']") : view.$(); - - // If we can't find the element anymore, a parent template has been - // re-rendered and we've been nuked. Remove the observer. - if (!elem || elem.length === 0) { - Ember.removeObserver(pathRoot, path, invoker); - } else { - // If we had previously added a class to the element, remove it. - if (oldClass) { - elem.removeClass(oldClass); - } - - // If necessary, add a new class. Make sure we keep track of it so - // it can be removed in the future. - if (newClass) { - elem.addClass(newClass); - oldClass = newClass; - } else { - oldClass = null; - } - } - }; - - invoker = function() { - Ember.run.scheduleOnce('render', observer); - }; - - if (path !== '' && path !== 'this') { - Ember.addObserver(pathRoot, path, invoker); - - view.one('willClearRender', function() { - Ember.removeObserver(pathRoot, path, invoker); - }); - } - - // We've already setup the observer; now we just need to figure out the - // correct behavior right now on the first pass through. - value = classStringForPath(pathRoot, parsedPath, options); - - if (value) { - ret.push(value); - - // Make sure we save the current value so that it can be removed if the - // observer fires. - oldClass = value; - } - }); - - return ret; -}; - - -})(); - - - -(function() { -/*globals Handlebars */ - -// TODO: Don't require the entire module -/** -@module ember -@submodule ember-handlebars -*/ - -var get = Ember.get, set = Ember.set; -var PARENT_VIEW_PATH = /^parentView\./; -var EmberHandlebars = Ember.Handlebars; - -EmberHandlebars.ViewHelper = Ember.Object.create({ - - propertiesFromHTMLOptions: function(options, thisContext) { - var hash = options.hash, data = options.data; - var extensions = {}, - classes = hash['class'], - dup = false; - - if (hash.id) { - extensions.elementId = hash.id; - dup = true; - } - - if (classes) { - classes = classes.split(' '); - extensions.classNames = classes; - dup = true; - } - - if (hash.classBinding) { - extensions.classNameBindings = hash.classBinding.split(' '); - dup = true; - } - - if (hash.classNameBindings) { - if (extensions.classNameBindings === undefined) extensions.classNameBindings = []; - extensions.classNameBindings = extensions.classNameBindings.concat(hash.classNameBindings.split(' ')); - dup = true; - } - - if (hash.attributeBindings) { - Ember.assert("Setting 'attributeBindings' via Handlebars is not allowed. Please subclass Ember.View and set it there instead."); - extensions.attributeBindings = null; - dup = true; - } - - if (dup) { - hash = Ember.$.extend({}, hash); - delete hash.id; - delete hash['class']; - delete hash.classBinding; - } - - // Set the proper context for all bindings passed to the helper. This applies to regular attribute bindings - // as well as class name bindings. If the bindings are local, make them relative to the current context - // instead of the view. - var path; - - // Evaluate the context of regular attribute bindings: - for (var prop in hash) { - if (!hash.hasOwnProperty(prop)) { continue; } - - // Test if the property ends in "Binding" - if (Ember.IS_BINDING.test(prop) && typeof hash[prop] === 'string') { - path = this.contextualizeBindingPath(hash[prop], data); - if (path) { hash[prop] = path; } - } - } - - // Evaluate the context of class name bindings: - if (extensions.classNameBindings) { - for (var b in extensions.classNameBindings) { - var full = extensions.classNameBindings[b]; - if (typeof full === 'string') { - // Contextualize the path of classNameBinding so this: - // - // classNameBinding="isGreen:green" - // - // is converted to this: - // - // classNameBinding="bindingContext.isGreen:green" - var parsedPath = Ember.View._parsePropertyPath(full); - path = this.contextualizeBindingPath(parsedPath.path, data); - if (path) { extensions.classNameBindings[b] = path + parsedPath.classNames; } - } - } - } - - // Make the current template context available to the view - // for the bindings set up above. - extensions.bindingContext = thisContext; - - return Ember.$.extend(hash, extensions); - }, - - // Transform bindings from the current context to a context that can be evaluated within the view. - // Returns null if the path shouldn't be changed. - // - // TODO: consider the addition of a prefix that would allow this method to return `path`. - contextualizeBindingPath: function(path, data) { - var normalized = Ember.Handlebars.normalizePath(null, path, data); - if (normalized.isKeyword) { - return 'templateData.keywords.' + path; - } else if (Ember.isGlobalPath(path)) { - return null; - } else if (path === 'this') { - return 'bindingContext'; - } else { - return 'bindingContext.' + path; - } - }, - - helper: function(thisContext, path, options) { - var inverse = options.inverse, - data = options.data, - view = data.view, - fn = options.fn, - hash = options.hash, - newView; - - if ('string' === typeof path) { - newView = EmberHandlebars.getPath(thisContext, path, options); - Ember.assert("Unable to find view at path '" + path + "'", !!newView); - } else { - newView = path; - } - - Ember.assert(Ember.String.fmt('You must pass a view class to the #view helper, not %@ (%@)', [path, newView]), Ember.View.detect(newView)); - - var viewOptions = this.propertiesFromHTMLOptions(options, thisContext); - var currentView = data.view; - viewOptions.templateData = options.data; - - if (fn) { - Ember.assert("You cannot provide a template block if you also specified a templateName", !get(viewOptions, 'templateName') && !get(newView.proto(), 'templateName')); - viewOptions.template = fn; - } - - // We only want to override the `_context` computed property if there is - // no specified controller. See View#_context for more information. - if (!newView.proto().controller && !newView.proto().controllerBinding && !viewOptions.controller && !viewOptions.controllerBinding) { - viewOptions._context = thisContext; - } - - currentView.appendChild(newView, viewOptions); - } -}); - -/** - `{{view}}` inserts a new instance of `Ember.View` into a template passing its options - to the `Ember.View`'s `create` method and using the supplied block as the view's own template. - - An empty `` and the following template: - - ``` handlebars - - ``` - - Will result in HTML structure: - - ``` html - - - -
    - A span: - - Hello. - -
    - - ``` - - ### parentView setting - - The `parentView` property of the new `Ember.View` instance created through `{{view}}` - will be set to the `Ember.View` instance of the template where `{{view}}` was called. - - ``` javascript - aView = Ember.View.create({ - template: Ember.Handlebars.compile("{{#view}} my parent: {{parentView.elementId}} {{/view}}") - }); - - aView.appendTo('body'); - ``` - - Will result in HTML structure: - - ``` html -
    -
    - my parent: ember1 -
    -
    - ``` - - ### Setting CSS id and class attributes - - The HTML `id` attribute can be set on the `{{view}}`'s resulting element with the `id` option. - This option will _not_ be passed to `Ember.View.create`. - - ``` handlebars - - ``` - - Results in the following HTML structure: - - ``` html -
    - - hello. - -
    - ``` - - The HTML `class` attribute can be set on the `{{view}}`'s resulting element with - the `class` or `classNameBindings` options. The `class` option - will directly set the CSS `class` attribute and will not be passed to - `Ember.View.create`. `classNameBindings` will be passed to `create` and use - `Ember.View`'s class name binding functionality: - - ``` handlebars - - ``` - - Results in the following HTML structure: - - ``` html -
    - - hello. - -
    - ``` - - ### Supplying a different view class - - `{{view}}` can take an optional first argument before its supplied options to specify a - path to a custom view class. - - ``` handlebars - - ``` - - The first argument can also be a relative path. Ember will search for the view class - starting at the `Ember.View` of the template where `{{view}}` was used as the root object: - - ``` javascript - MyApp = Ember.Application.create({}); - MyApp.OuterView = Ember.View.extend({ - innerViewClass: Ember.View.extend({ - classNames: ['a-custom-view-class-as-property'] - }), - template: Ember.Handlebars.compile('{{#view "innerViewClass"}} hi {{/view}}') - }); - - MyApp.OuterView.create().appendTo('body'); - ``` - - Will result in the following HTML: - - ``` html -
    -
    - hi -
    -
    - ``` - - ### Blockless use - - If you supply a custom `Ember.View` subclass that specifies its own template - or provide a `templateName` option to `{{view}}` it can be used without supplying a block. - Attempts to use both a `templateName` option and supply a block will throw an error. - - ``` handlebars - - ``` - - ### viewName property - - You can supply a `viewName` option to `{{view}}`. The `Ember.View` instance will - be referenced as a property of its parent view by this name. - - ``` javascript - aView = Ember.View.create({ - template: Ember.Handlebars.compile('{{#view viewName="aChildByName"}} hi {{/view}}') - }); - - aView.appendTo('body'); - aView.get('aChildByName') // the instance of Ember.View created by {{view}} helper - ``` - - @method view - @for Ember.Handlebars.helpers - @param {String} path - @param {Hash} options - @return {String} HTML string -*/ -EmberHandlebars.registerHelper('view', function(path, options) { - Ember.assert("The view helper only takes a single argument", arguments.length <= 2); - - // If no path is provided, treat path param as options. - if (path && path.data && path.data.isRenderData) { - options = path; - path = "Ember.View"; - } - - return EmberHandlebars.ViewHelper.helper(this, path, options); -}); - - -})(); - - - -(function() { -/*globals Handlebars */ - -// TODO: Don't require all of this module -/** -@module ember -@submodule ember-handlebars -*/ - -var get = Ember.get, getPath = Ember.Handlebars.getPath, fmt = Ember.String.fmt; - -/** - `{{collection}}` is a `Ember.Handlebars` helper for adding instances of - `Ember.CollectionView` to a template. See `Ember.CollectionView` for additional - information on how a `CollectionView` functions. - - `{{collection}}`'s primary use is as a block helper with a `contentBinding` option - pointing towards an `Ember.Array`-compatible object. An `Ember.View` instance will - be created for each item in its `content` property. Each view will have its own - `content` property set to the appropriate item in the collection. - - The provided block will be applied as the template for each item's view. - - Given an empty `` the following template: - - ``` handlebars - - ``` - - And the following application code - - ``` javascript - App = Ember.Application.create() - App.items = [ - Ember.Object.create({name: 'Dave'}), - Ember.Object.create({name: 'Mary'}), - Ember.Object.create({name: 'Sara'}) - ] - ``` - - Will result in the HTML structure below - - ``` html -
    -
    Hi Dave
    -
    Hi Mary
    -
    Hi Sara
    -
    - ``` - - ### Blockless Use - If you provide an `itemViewClass` option that has its own `template` you can omit - the block. - - The following template: - - ``` handlebars - - ``` - - And application code - - ``` javascript - App = Ember.Application.create(); - App.items = [ - Ember.Object.create({name: 'Dave'}), - Ember.Object.create({name: 'Mary'}), - Ember.Object.create({name: 'Sara'}) - ]; - - App.AnItemView = Ember.View.extend({ - template: Ember.Handlebars.compile("Greetings {{view.content.name}}") - }); - ``` - - Will result in the HTML structure below - - ``` html -
    -
    Greetings Dave
    -
    Greetings Mary
    -
    Greetings Sara
    -
    - ``` - - ### Specifying a CollectionView subclass - - By default the `{{collection}}` helper will create an instance of `Ember.CollectionView`. - You can supply a `Ember.CollectionView` subclass to the helper by passing it - as the first argument: - - ``` handlebars - - ``` - - - ### Forwarded `item.*`-named Options - - As with the `{{view}}`, helper options passed to the `{{collection}}` will be set on - the resulting `Ember.CollectionView` as properties. Additionally, options prefixed with - `item` will be applied to the views rendered for each item (note the camelcasing): - - ``` handlebars - - ``` - - Will result in the following HTML structure: - - ``` html -
    -

    Howdy Dave

    -

    Howdy Mary

    -

    Howdy Sara

    -
    - ``` - - @method collection - @for Ember.Handlebars.helpers - @param {String} path - @param {Hash} options - @return {String} HTML string -*/ -Ember.Handlebars.registerHelper('collection', function(path, options) { - // If no path is provided, treat path param as options. - if (path && path.data && path.data.isRenderData) { - options = path; - path = undefined; - Ember.assert("You cannot pass more than one argument to the collection helper", arguments.length === 1); - } else { - Ember.assert("You cannot pass more than one argument to the collection helper", arguments.length === 2); - } - - var fn = options.fn; - var data = options.data; - var inverse = options.inverse; - - // If passed a path string, convert that into an object. - // Otherwise, just default to the standard class. - var collectionClass; - collectionClass = path ? getPath(this, path, options) : Ember.CollectionView; - Ember.assert(fmt("%@ #collection: Could not find collection class %@", [data.view, path]), !!collectionClass); - - var hash = options.hash, itemHash = {}, match; - - // Extract item view class if provided else default to the standard class - var itemViewClass, itemViewPath = hash.itemViewClass; - var collectionPrototype = collectionClass.proto(); - delete hash.itemViewClass; - itemViewClass = itemViewPath ? getPath(collectionPrototype, itemViewPath, options) : collectionPrototype.itemViewClass; - Ember.assert(fmt("%@ #collection: Could not find itemViewClass %@", [data.view, itemViewPath]), !!itemViewClass); - - // Go through options passed to the {{collection}} helper and extract options - // that configure item views instead of the collection itself. - for (var prop in hash) { - if (hash.hasOwnProperty(prop)) { - match = prop.match(/^item(.)(.*)$/); - - if(match) { - // Convert itemShouldFoo -> shouldFoo - itemHash[match[1].toLowerCase() + match[2]] = hash[prop]; - // Delete from hash as this will end up getting passed to the - // {{view}} helper method. - delete hash[prop]; - } - } - } - - var tagName = hash.tagName || collectionPrototype.tagName; - - if (fn) { - itemHash.template = fn; - delete options.fn; - } - - var emptyViewClass; - if (inverse && inverse !== Handlebars.VM.noop) { - emptyViewClass = get(collectionPrototype, 'emptyViewClass'); - emptyViewClass = emptyViewClass.extend({ - template: inverse, - tagName: itemHash.tagName - }); - } else if (hash.emptyViewClass) { - emptyViewClass = getPath(this, hash.emptyViewClass, options); - } - hash.emptyView = emptyViewClass; - - if (hash.eachHelper === 'each') { - itemHash._context = Ember.computed(function() { - return get(this, 'content'); - }).property('content'); - delete hash.eachHelper; - } - - var viewOptions = Ember.Handlebars.ViewHelper.propertiesFromHTMLOptions({ data: data, hash: itemHash }, this); - hash.itemViewClass = itemViewClass.extend(viewOptions); - - return Ember.Handlebars.helpers.view.call(this, collectionClass, options); -}); - - -})(); - - - -(function() { -/*globals Handlebars */ -/** -@module ember -@submodule ember-handlebars -*/ - -var getPath = Ember.Handlebars.getPath; - -/** - `unbound` allows you to output a property without binding. *Important:* The - output will not be updated if the property changes. Use with caution. - - ``` handlebars -
    {{unbound somePropertyThatDoesntChange}}
    - ``` - - @method unbound - @for Ember.Handlebars.helpers - @param {String} property - @return {String} HTML string -*/ -Ember.Handlebars.registerHelper('unbound', function(property, fn) { - var context = (fn.contexts && fn.contexts[0]) || this; - return getPath(context, property, fn); -}); - -})(); - - - -(function() { -/*jshint debug:true*/ -/** -@module ember -@submodule ember-handlebars -*/ - -var getPath = Ember.Handlebars.getPath, normalizePath = Ember.Handlebars.normalizePath; - -/** - `log` allows you to output the value of a value in the current rendering - context. - - ``` handlebars - {{log myVariable}} - ``` - - @method log - @for Ember.Handlebars.helpers - @param {String} property -*/ -Ember.Handlebars.registerHelper('log', function(property, options) { - var context = (options.contexts && options.contexts[0]) || this, - normalized = normalizePath(context, property, options.data), - pathRoot = normalized.root, - path = normalized.path, - value = (path === 'this') ? pathRoot : getPath(pathRoot, path, options); - Ember.Logger.log(value); -}); - -/** - The `debugger` helper executes the `debugger` statement in the current - context. - - ``` handlebars - {{debugger}} - ``` - - @method debugger - @for Ember.Handlebars.helpers - @param {String} property -*/ -Ember.Handlebars.registerHelper('debugger', function() { - debugger; -}); - -})(); - - - -(function() { -/** -@module ember -@submodule ember-handlebars -*/ - -var get = Ember.get, set = Ember.set; - -Ember.Handlebars.EachView = Ember.CollectionView.extend(Ember._Metamorph, { - itemViewClass: Ember._MetamorphView, - emptyViewClass: Ember._MetamorphView, - - createChildView: function(view, attrs) { - view = this._super(view, attrs); - - // At the moment, if a container view subclass wants - // to insert keywords, it is responsible for cloning - // the keywords hash. This will be fixed momentarily. - var keyword = get(this, 'keyword'); - - if (keyword) { - var data = get(view, 'templateData'); - - data = Ember.copy(data); - data.keywords = view.cloneKeywords(); - set(view, 'templateData', data); - - var content = get(view, 'content'); - - // In this case, we do not bind, because the `content` of - // a #each item cannot change. - data.keywords[keyword] = content; - } - - return view; - } -}); - -/** - The `{{#each}}` helper loops over elements in a collection, rendering its block once for each item: - - ``` javascript - Developers = [{name: 'Yehuda'},{name: 'Tom'}, {name: 'Paul'}]; - ``` - - ``` handlebars - {{#each Developers}} - {{name}} - {{/each}} - ``` - - `{{each}}` supports an alternative syntax with element naming: - - ``` handlebars - {{#each person in Developers}} - {{person.name}} - {{/each}} - ``` - - When looping over objects that do not have properties, `{{this}}` can be used to render the object: - - ``` javascript - DeveloperNames = ['Yehuda', 'Tom', 'Paul'] - ``` - - ``` handlebars - {{#each DeveloperNames}} - {{this}} - {{/each}} - ``` - - ### Blockless Use - - If you provide an `itemViewClass` option that has its own `template` you can omit - the block in a similar way to how it can be done with the collection helper. - - The following template: - - ``` handlebars - - ``` - - And application code - - ``` javascript - App = Ember.Application.create({ - MyView: Ember.View.extend({ - items: [ - Ember.Object.create({name: 'Dave'}), - Ember.Object.create({name: 'Mary'}), - Ember.Object.create({name: 'Sara'}) - ] - }) - }); - - App.AnItemView = Ember.View.extend({ - template: Ember.Handlebars.compile("Greetings {{name}}") - }); - - App.initialize(); - ``` - - Will result in the HTML structure below - - ``` html -
    -
    Greetings Dave
    -
    Greetings Mary
    -
    Greetings Sara
    -
    - ``` - - - @method each - @for Ember.Handlebars.helpers - @param [name] {String} name for item (used with `in`) - @param path {String} path -*/ -Ember.Handlebars.registerHelper('each', function(path, options) { - if (arguments.length === 4) { - Ember.assert("If you pass more than one argument to the each helper, it must be in the form #each foo in bar", arguments[1] === "in"); - - var keywordName = arguments[0]; - - options = arguments[3]; - path = arguments[2]; - if (path === '') { path = "this"; } - - options.hash.keyword = keywordName; - } else { - options.hash.eachHelper = 'each'; - } - - options.hash.contentBinding = path; - // Set up emptyView as a metamorph with no tag - //options.hash.emptyViewClass = Ember._MetamorphView; - - return Ember.Handlebars.helpers.collection.call(this, 'Ember.Handlebars.EachView', options); -}); - -})(); - - - -(function() { -/** -@module ember -@submodule ember-handlebars -*/ - -/** - `template` allows you to render a template from inside another template. - This allows you to re-use the same template in multiple places. For example: - - ``` handlebars - - - - ``` - - This helper looks for templates in the global Ember.TEMPLATES hash. If you - add <script> tags to your page with the `data-template-name` attribute set, - they will be compiled and placed in this hash automatically. - - You can also manually register templates by adding them to the hash: - - ``` javascript - Ember.TEMPLATES["my_cool_template"] = Ember.Handlebars.compile('{{user}}'); - ``` - - @method template - @for Ember.Handlebars.helpers - @param {String} templateName the template to render -*/ - -Ember.Handlebars.registerHelper('template', function(name, options) { - var template = Ember.TEMPLATES[name]; - - Ember.assert("Unable to find template with name '"+name+"'.", !!template); - - Ember.TEMPLATES[name](this, { data: options.data }); -}); - -})(); - - - -(function() { -/** -@module ember -@submodule ember-handlebars -*/ - -var EmberHandlebars = Ember.Handlebars, - getPath = EmberHandlebars.getPath, - get = Ember.get, - a_slice = Array.prototype.slice; - -var ActionHelper = EmberHandlebars.ActionHelper = { - registeredActions: {} -}; - -ActionHelper.registerAction = function(actionName, options) { - var actionId = (++Ember.$.uuid).toString(); - - ActionHelper.registeredActions[actionId] = { - eventName: options.eventName, - handler: function(event) { - var modifier = event.shiftKey || event.metaKey || event.altKey || event.ctrlKey, - secondaryClick = event.which > 1, // IE9 may return undefined - nonStandard = modifier || secondaryClick; - - if (options.link && nonStandard) { - // Allow the browser to handle special link clicks normally - return; - } - - event.preventDefault(); - - event.view = options.view; - - if (options.hasOwnProperty('context')) { - event.context = options.context; - } - - if (options.hasOwnProperty('contexts')) { - event.contexts = options.contexts; - } - - var target = options.target; - - // Check for StateManager (or compatible object) - if (target.isState && typeof target.send === 'function') { - return target.send(actionName, event); - } else { - Ember.assert(Ember.String.fmt('Target %@ does not have action %@', [target, actionName]), target[actionName]); - return target[actionName].call(target, event); - } - } - }; - - options.view.on('willClearRender', function() { - delete ActionHelper.registeredActions[actionId]; - }); - - return actionId; -}; - -/** - The `{{action}}` helper registers an HTML element within a template for - DOM event handling and forwards that interaction to the Application's router, - the template's `Ember.View` instance, or supplied `target` option (see 'Specifying a Target'). - - User interaction with that element will invoke the supplied action name on - the appropriate target. - - Given the following Handlebars template on the page - - ``` handlebars - - ``` - - And application code - - ``` javascript - AView = Ember.View.extend({ - templateName; 'a-template', - anActionName: function(event){} - }); - - aView = AView.create(); - aView.appendTo('body'); - ``` - - Will results in the following rendered HTML - - ``` html -
    -
    - click me -
    -
    - ``` - - Clicking "click me" will trigger the `anActionName` method of the `aView` - object with a `jQuery.Event` object as its argument. The `jQuery.Event` - object will be extended to include a `view` property that is set to the - original view interacted with (in this case the `aView` object). - - ### Event Propagation - - Events triggered through the action helper will automatically have - `.preventDefault()` called on them. You do not need to do so in your event - handlers. To stop propagation of the event, simply return `false` from your - handler. - - If you need the default handler to trigger you should either register your - own event handler, or use event methods on your view class. See Ember.View - 'Responding to Browser Events' for more information. - - ### Specifying DOM event type - - By default the `{{action}}` helper registers for DOM `click` events. You can - supply an `on` option to the helper to specify a different DOM event name: - - ``` handlebars - - ``` - - See Ember.View 'Responding to Browser Events' for a list of - acceptable DOM event names. - - Because `{{action}}` depends on Ember's event dispatch system it will only - function if an `Ember.EventDispatcher` instance is available. An - `Ember.EventDispatcher` instance will be created when a new - `Ember.Application` is created. Having an instance of `Ember.Application` - will satisfy this requirement. - - - ### Specifying a Target - There are several possible target objects for `{{action}}` helpers: - - In a typical `Ember.Router`-backed Application where views are managed - through use of the `{{outlet}}` helper, actions will be forwarded to the - current state of the Applications's Router. See Ember.Router 'Responding - to User-initiated Events' for more information. - - If you manually set the `target` property on the controller of a template's - `Ember.View` instance, the specifed `controller.target` will become the target - for any actions. Likely custom values for a controller's `target` are the - controller itself or a StateManager other than the Application's Router. - - If the templates's view lacks a controller property the view itself is the target. - - Finally, a `target` option can be provided to the helper to change which object - will receive the method call. This option must be a string representing a - path to an object: - - ``` handlebars - - ``` - - Clicking "click me" in the rendered HTML of the above template will trigger - the `anActionName` method of the object at `MyApplication.someObject`. - The first argument to this method will be a `jQuery.Event` extended to - include a `view` property that is set to the original view interacted with. - - A path relative to the template's `Ember.View` instance can also be used as - a target: - - ``` handlebars - - ``` - - Clicking "click me" in the rendered HTML of the above template will trigger - the `anActionName` method of the view's parent view. - - The `{{action}}` helper is `Ember.StateManager` aware. If the target of the - action is an `Ember.StateManager` instance `{{action}}` will use the `send` - functionality of StateManagers. The documentation for `Ember.StateManager` - has additional information about this use. - - If an action's target does not implement a method that matches the supplied - action name an error will be thrown. - - ``` handlebars - - ``` - - With the following application code - - ``` javascript - AView = Ember.View.extend({ - templateName; 'a-template', - // note: no method 'aMethodNameThatIsMissing' - anActionName: function(event){} - }); - - aView = AView.create(); - aView.appendTo('body'); - ``` - - Will throw `Uncaught TypeError: Cannot call method 'call' of undefined` when - "click me" is clicked. - - ### Specifying a context - - By default the `{{action}}` helper passes the current Handlebars context - along in the `jQuery.Event` object. You may specify an alternate object to - pass as the context by providing a property path: - - ``` handlebars - - ``` - - @method action - @for Ember.Handlebars.helpers - @param {String} actionName - @param {Object...} contexts - @param {Hash} options -*/ -EmberHandlebars.registerHelper('action', function(actionName) { - var options = arguments[arguments.length - 1], - contexts = a_slice.call(arguments, 1, -1); - - var hash = options.hash, - view = options.data.view, - target, controller, link; - - // create a hash to pass along to registerAction - var action = { - eventName: hash.on || "click" - }; - - action.view = view = get(view, 'concreteView'); - - if (hash.target) { - target = getPath(this, hash.target, options); - } else if (controller = options.data.keywords.controller) { - target = get(controller, 'target'); - } - - action.target = target = target || view; - - if (contexts.length) { - action.contexts = contexts = Ember.EnumerableUtils.map(contexts, function(context) { - return getPath(this, context, options); - }, this); - action.context = contexts[0]; - } - - var output = [], url; - - if (hash.href && target.urlForEvent) { - url = target.urlForEvent.apply(target, [actionName].concat(contexts)); - output.push('href="' + url + '"'); - action.link = true; - } - - var actionId = ActionHelper.registerAction(actionName, action); - output.push('data-ember-action="' + actionId + '"'); - - return new EmberHandlebars.SafeString(output.join(" ")); -}); - -})(); - - - -(function() { -/** -@module ember -@submodule ember-handlebars -*/ - -var get = Ember.get, set = Ember.set; - -/** - - When used in a Handlebars template that is assigned to an `Ember.View` instance's - `layout` property Ember will render the layout template first, inserting the view's - own rendered output at the `{{ yield }}` location. - - An empty `` and the following application code: - - ``` javascript - AView = Ember.View.extend({ - classNames: ['a-view-with-layout'], - layout: Ember.Handlebars.compile('
    {{ yield }}
    '), - template: Ember.Handlebars.compile('I am wrapped') - }); - - aView = AView.create(); - aView.appendTo('body'); - ``` - - Will result in the following HTML output: - - ``` html - -
    -
    - I am wrapped -
    -
    - - ``` - - The yield helper cannot be used outside of a template assigned to an `Ember.View`'s `layout` property - and will throw an error if attempted. - - ``` javascript - BView = Ember.View.extend({ - classNames: ['a-view-with-layout'], - template: Ember.Handlebars.compile('{{yield}}') - }); - - bView = BView.create(); - bView.appendTo('body'); - - // throws - // Uncaught Error: assertion failed: You called yield in a template that was not a layout - ``` - - @method yield - @for Ember.Handlebars.helpers - @param {Hash} options - @return {String} HTML string -*/ -Ember.Handlebars.registerHelper('yield', function(options) { - var view = options.data.view, template; - - while (view && !get(view, 'layout')) { - view = get(view, 'parentView'); - } - - Ember.assert("You called yield in a template that was not a layout", !!view); - - template = get(view, 'template'); - - if (template) { template(this, options); } -}); - -})(); - - - -(function() { -/** -@module ember -@submodule ember-handlebars -*/ - -Ember.Handlebars.OutletView = Ember.ContainerView.extend(Ember._Metamorph); - -/** - The `outlet` helper allows you to specify that the current - view's controller will fill in the view for a given area. - - ``` handlebars - {{outlet}} - ``` - - By default, when the the current controller's `view` property changes, the - outlet will replace its current view with the new view. You can set the - `view` property directly, but it's normally best to use `connectOutlet`. - - ``` javascript - # Instantiate App.PostsView and assign to `view`, so as to render into outlet. - controller.connectOutlet('posts'); - ``` - - You can also specify a particular name other than `view`: - - ``` handlebars - {{outlet masterView}} - {{outlet detailView}} - ``` - - Then, you can control several outlets from a single controller. - - ``` javascript - # Instantiate App.PostsView and assign to controller.masterView. - controller.connectOutlet('masterView', 'posts'); - # Also, instantiate App.PostInfoView and assign to controller.detailView. - controller.connectOutlet('detailView', 'postInfo'); - ``` - - @method outlet - @for Ember.Handlebars.helpers - @param {String} property the property on the controller - that holds the view for this outlet -*/ -Ember.Handlebars.registerHelper('outlet', function(property, options) { - if (property && property.data && property.data.isRenderData) { - options = property; - property = 'view'; - } - - options.hash.currentViewBinding = "view.context." + property; - - return Ember.Handlebars.helpers.view.call(this, Ember.Handlebars.OutletView, options); -}); - -})(); - - - -(function() { - -})(); - - - -(function() { - -})(); - - - -(function() { -/** -@module ember -@submodule ember-handlebars -*/ - -var set = Ember.set, get = Ember.get; - -/** - The `Ember.Checkbox` view class renders a checkbox [input](https://developer.mozilla.org/en/HTML/Element/Input) - element. It allows for binding an Ember property (`checked`) to the status of the checkbox. - - Example: - - ``` handlebars - {{view Ember.Checkbox checkedBinding="receiveEmail"}} - ``` - - You can add a `label` tag yourself in the template where the Ember.Checkbox is being used. - - ``` html - - ``` - - - The `checked` attribute of an Ember.Checkbox object should always be set - through the Ember object or by interacting with its rendered element representation - via the mouse, keyboard, or touch. Updating the value of the checkbox via jQuery will - result in the checked value of the object and its element losing synchronization. - - ## Layout and LayoutName properties - Because HTML `input` elements are self closing `layout` and `layoutName` properties will - not be applied. See `Ember.View`'s layout section for more information. - - @class Checkbox - @namespace Ember - @extends Ember.View -*/ -Ember.Checkbox = Ember.View.extend({ - classNames: ['ember-checkbox'], - - tagName: 'input', - - attributeBindings: ['type', 'checked', 'disabled', 'tabindex'], - - type: "checkbox", - checked: false, - disabled: false, - - init: function() { - this._super(); - this.on("change", this, this._updateElementValue); - }, - - _updateElementValue: function() { - set(this, 'checked', this.$().prop('checked')); - } -}); - -})(); - - - -(function() { -/** -@module ember -@submodule ember-handlebars -*/ - -var get = Ember.get, set = Ember.set; - -/** - Shared mixin used by Ember.TextField and Ember.TextArea. - - @class TextSupport - @namespace Ember - @extends Ember.Mixin - @private -*/ -Ember.TextSupport = Ember.Mixin.create({ - value: "", - - attributeBindings: ['placeholder', 'disabled', 'maxlength', 'tabindex'], - placeholder: null, - disabled: false, - maxlength: null, - - insertNewline: Ember.K, - cancel: Ember.K, - - init: function() { - this._super(); - this.on("focusOut", this, this._elementValueDidChange); - this.on("change", this, this._elementValueDidChange); - this.on("keyUp", this, this.interpretKeyEvents); - }, - - interpretKeyEvents: function(event) { - var map = Ember.TextSupport.KEY_EVENTS; - var method = map[event.keyCode]; - - this._elementValueDidChange(); - if (method) { return this[method](event); } - }, - - _elementValueDidChange: function() { - set(this, 'value', this.$().val()); - } - -}); - -Ember.TextSupport.KEY_EVENTS = { - 13: 'insertNewline', - 27: 'cancel' -}; - -})(); - - - -(function() { -/** -@module ember -@submodule ember-handlebars -*/ - -var get = Ember.get, set = Ember.set; - -/** - The `Ember.TextField` view class renders a text - [input](https://developer.mozilla.org/en/HTML/Element/Input) element. It - allows for binding Ember properties to the text field contents (`value`), - live-updating as the user inputs text. - - Example: - - ``` handlebars - {{view Ember.TextField valueBinding="firstName"}} - ``` - - ## Layout and LayoutName properties - Because HTML `input` elements are self closing `layout` and `layoutName` properties will - not be applied. See `Ember.View`'s layout section for more information. - - ## HTML Attributes - - By default `Ember.TextField` provides support for `type`, `value`, `size`, `placeholder`, - `disabled`, `maxlength` and `tabindex` attributes on a textarea. If you need to support - more attributes have a look at the `attributeBindings` property in `Ember.View`'s - HTML Attributes section. - - To globally add support for additional attributes you can reopen `Ember.TextField` or - `Ember.TextSupport`. - - ``` javascript - Ember.TextSupport.reopen({ - attributeBindings: ["required"] - }) - ``` - - @class TextField - @namespace Ember - @extends Ember.View - @uses Ember.TextSupport -*/ -Ember.TextField = Ember.View.extend(Ember.TextSupport, - /** @scope Ember.TextField.prototype */ { - - classNames: ['ember-text-field'], - tagName: "input", - attributeBindings: ['type', 'value', 'size'], - - /** - The value attribute of the input element. As the user inputs text, this - property is updated live. - - @property value - @type String - @default "" - */ - value: "", - - /** - The type attribute of the input element. - - @property type - @type String - @default "text" - */ - type: "text", - - /** - The size of the text field in characters. - - @property size - @type String - @default null - */ - size: null -}); - -})(); - - - -(function() { -/** -@module ember -@submodule ember-handlebars -*/ - -var get = Ember.get, set = Ember.set; - -/** - @class Button - @namespace Ember - @extends Ember.View - @uses Ember.TargetActionSupport - @deprecated -*/ -Ember.Button = Ember.View.extend(Ember.TargetActionSupport, { - classNames: ['ember-button'], - classNameBindings: ['isActive'], - - tagName: 'button', - - propagateEvents: false, - - attributeBindings: ['type', 'disabled', 'href', 'tabindex'], - - /** - @private - - Overrides TargetActionSupport's targetObject computed - property to use Handlebars-specific path resolution. - - @property targetObject - */ - targetObject: Ember.computed(function() { - var target = get(this, 'target'), - root = get(this, 'context'), - data = get(this, 'templateData'); - - if (typeof target !== 'string') { return target; } - - return Ember.Handlebars.getPath(root, target, { data: data }); - }).property('target'), - - // Defaults to 'button' if tagName is 'input' or 'button' - type: Ember.computed(function(key, value) { - var tagName = this.get('tagName'); - if (value !== undefined) { this._type = value; } - if (this._type !== undefined) { return this._type; } - if (tagName === 'input' || tagName === 'button') { return 'button'; } - }).property('tagName'), - - disabled: false, - - // Allow 'a' tags to act like buttons - href: Ember.computed(function() { - return this.get('tagName') === 'a' ? '#' : null; - }).property('tagName'), - - mouseDown: function() { - if (!get(this, 'disabled')) { - set(this, 'isActive', true); - this._mouseDown = true; - this._mouseEntered = true; - } - return get(this, 'propagateEvents'); - }, - - mouseLeave: function() { - if (this._mouseDown) { - set(this, 'isActive', false); - this._mouseEntered = false; - } - }, - - mouseEnter: function() { - if (this._mouseDown) { - set(this, 'isActive', true); - this._mouseEntered = true; - } - }, - - mouseUp: function(event) { - if (get(this, 'isActive')) { - // Actually invoke the button's target and action. - // This method comes from the Ember.TargetActionSupport mixin. - this.triggerAction(); - set(this, 'isActive', false); - } - - this._mouseDown = false; - this._mouseEntered = false; - return get(this, 'propagateEvents'); - }, - - keyDown: function(event) { - // Handle space or enter - if (event.keyCode === 13 || event.keyCode === 32) { - this.mouseDown(); - } - }, - - keyUp: function(event) { - // Handle space or enter - if (event.keyCode === 13 || event.keyCode === 32) { - this.mouseUp(); - } - }, - - // TODO: Handle proper touch behavior. Including should make inactive when - // finger moves more than 20x outside of the edge of the button (vs mouse - // which goes inactive as soon as mouse goes out of edges.) - - touchStart: function(touch) { - return this.mouseDown(touch); - }, - - touchEnd: function(touch) { - return this.mouseUp(touch); - }, - - init: function() { - Ember.deprecate("Ember.Button is deprecated and will be removed from future releases. Consider using the `{{action}}` helper."); - this._super(); - } -}); - -})(); - - - -(function() { -/** -@module ember -@submodule ember-handlebars -*/ - -var get = Ember.get, set = Ember.set; - -/** - The `Ember.TextArea` view class renders a - [textarea](https://developer.mozilla.org/en/HTML/Element/textarea) element. - It allows for binding Ember properties to the text area contents (`value`), - live-updating as the user inputs text. - - ## Layout and LayoutName properties - - Because HTML `textarea` elements do not contain inner HTML the `layout` and `layoutName` - properties will not be applied. See `Ember.View`'s layout section for more information. - - ## HTML Attributes - - By default `Ember.TextArea` provides support for `rows`, `cols`, `placeholder`, `disabled`, - `maxlength` and `tabindex` attributes on a textarea. If you need to support more - attributes have a look at the `attributeBindings` property in `Ember.View`'s HTML Attributes section. - - To globally add support for additional attributes you can reopen `Ember.TextArea` or `Ember.TextSupport`. - - ``` javascript - Ember.TextSupport.reopen({ - attributeBindings: ["required"] - }) - ``` - - @class TextArea - @namespace Ember - @extends Ember.View - @uses Ember.TextSupport -*/ -Ember.TextArea = Ember.View.extend(Ember.TextSupport, { - classNames: ['ember-text-area'], - - tagName: "textarea", - attributeBindings: ['rows', 'cols'], - rows: null, - cols: null, - - _updateElementValue: Ember.observer(function() { - // We do this check so cursor position doesn't get affected in IE - var value = get(this, 'value'), - $el = this.$(); - if ($el && value !== $el.val()) { - $el.val(value); - } - }, 'value'), - - init: function() { - this._super(); - this.on("didInsertElement", this, this._updateElementValue); - } - -}); - -})(); - - - -(function() { -/** -@module ember -@submodule ember-handlebars -*/ - -/** -@class TabContainerView -@namespace Ember -@deprecated -@extends Ember.View -*/ -Ember.TabContainerView = Ember.View.extend({ - init: function() { - Ember.deprecate("Ember.TabContainerView is deprecated and will be removed from future releases."); - this._super(); - } -}); - -})(); - - - -(function() { -/** -@module ember -@submodule ember-handlebars -*/ - -var get = Ember.get; - -/** - @class TabPaneView - @namespace Ember - @extends Ember.View - @deprecated -*/ -Ember.TabPaneView = Ember.View.extend({ - tabsContainer: Ember.computed(function() { - return this.nearestOfType(Ember.TabContainerView); - }).property().volatile(), - - isVisible: Ember.computed(function() { - return get(this, 'viewName') === get(this, 'tabsContainer.currentView'); - }).property('tabsContainer.currentView').volatile(), - - init: function() { - Ember.deprecate("Ember.TabPaneView is deprecated and will be removed from future releases."); - this._super(); - } -}); - -})(); - - - -(function() { -/** -@module ember -@submodule ember-handlebars -*/ - -var get = Ember.get, setPath = Ember.setPath; - -/** -@class TabView -@namespace Ember -@extends Ember.View -@deprecated -*/ -Ember.TabView = Ember.View.extend({ - tabsContainer: Ember.computed(function() { - return this.nearestInstanceOf(Ember.TabContainerView); - }).property().volatile(), - - mouseUp: function() { - setPath(this, 'tabsContainer.currentView', get(this, 'value')); - }, - - init: function() { - Ember.deprecate("Ember.TabView is deprecated and will be removed from future releases."); - this._super(); - } -}); - -})(); - - - -(function() { - -})(); - - - -(function() { -/*jshint eqeqeq:false */ - -/** -@module ember -@submodule ember-handlebars -*/ - -var set = Ember.set, - get = Ember.get, - indexOf = Ember.EnumerableUtils.indexOf, - indexesOf = Ember.EnumerableUtils.indexesOf, - replace = Ember.EnumerableUtils.replace, - isArray = Ember.isArray; - -/** - The Ember.Select view class renders a - [select](https://developer.mozilla.org/en/HTML/Element/select) HTML element, - allowing the user to choose from a list of options. - - The text and `value` property of each ` - - - - ``` - - - The `value` attribute of the selected `{{/if}}{{#each view.content}}{{view Ember.SelectOption contentBinding="this"}}{{/each}}'), - attributeBindings: ['multiple', 'tabindex'], - - /** - The `multiple` attribute of the select element. Indicates whether multiple - options can be selected. - - @property multiple - @type Boolean - @default false - */ - multiple: false, - - /** - The list of options. - - If `optionLabelPath` and `optionValuePath` are not overridden, this should - be a list of strings, which will serve simultaneously as labels and values. - - Otherwise, this should be a list of objects. For instance: - - content: Ember.A([ - { id: 1, firstName: 'Yehuda' }, - { id: 2, firstName: 'Tom' } - ]), - optionLabelPath: 'content.firstName', - optionValuePath: 'content.id' - - @property content - @type Array - @default null - */ - content: null, - - /** - When `multiple` is false, the element of `content` that is currently - selected, if any. - - When `multiple` is true, an array of such elements. - - @property selection - @type Object or Array - @default null - */ - selection: null, - - /** - In single selection mode (when `multiple` is false), value can be used to get - the current selection's value or set the selection by it's value. - - It is not currently supported in multiple selection mode. - - @property value - @type String - @default null - */ - value: Ember.computed(function(key, value) { - if (arguments.length === 2) { return value; } - - var valuePath = get(this, 'optionValuePath').replace(/^content\.?/, ''); - return valuePath ? get(this, 'selection.' + valuePath) : get(this, 'selection'); - }).property('selection'), - - /** - If given, a top-most dummy option will be rendered to serve as a user - prompt. - - @property prompt - @type String - @default null - */ - prompt: null, - - /** - The path of the option labels. See `content`. - - @property optionLabelPath - @type String - @default 'content' - */ - optionLabelPath: 'content', - - /** - The path of the option values. See `content`. - - @property optionValuePath - @type String - @default 'content' - */ - optionValuePath: 'content', - - _change: function() { - if (get(this, 'multiple')) { - this._changeMultiple(); - } else { - this._changeSingle(); - } - }, - - selectionDidChange: Ember.observer(function() { - var selection = get(this, 'selection'); - if (get(this, 'multiple')) { - if (!isArray(selection)) { - set(this, 'selection', Ember.A([selection])); - return; - } - this._selectionDidChangeMultiple(); - } else { - this._selectionDidChangeSingle(); - } - }, 'selection.@each'), - - valueDidChange: Ember.observer(function() { - var content = get(this, 'content'), - value = get(this, 'value'), - valuePath = get(this, 'optionValuePath').replace(/^content\.?/, ''), - selectedValue = (valuePath ? get(this, 'selection.' + valuePath) : get(this, 'selection')), - selection; - - if (value !== selectedValue) { - selection = content.find(function(obj) { - return value === (valuePath ? get(obj, valuePath) : obj); - }); - - this.set('selection', selection); - } - }, 'value'), - - - _triggerChange: function() { - var selection = get(this, 'selection'); - var value = get(this, 'value'); - - if (selection) { this.selectionDidChange(); } - if (value) { this.valueDidChange(); } - - this._change(); - }, - - _changeSingle: function() { - var selectedIndex = this.$()[0].selectedIndex, - content = get(this, 'content'), - prompt = get(this, 'prompt'); - - if (!content) { return; } - if (prompt && selectedIndex === 0) { set(this, 'selection', null); return; } - - if (prompt) { selectedIndex -= 1; } - set(this, 'selection', content.objectAt(selectedIndex)); - }, - - - _changeMultiple: function() { - var options = this.$('option:selected'), - prompt = get(this, 'prompt'), - offset = prompt ? 1 : 0, - content = get(this, 'content'), - selection = get(this, 'selection'); - - if (!content){ return; } - if (options) { - var selectedIndexes = options.map(function(){ - return this.index - offset; - }).toArray(); - var newSelection = content.objectsAt(selectedIndexes); - - if (isArray(selection)) { - replace(selection, 0, get(selection, 'length'), newSelection); - } else { - set(this, 'selection', newSelection); - } - } - }, - - _selectionDidChangeSingle: function() { - var el = this.get('element'); - if (!el) { return; } - - var content = get(this, 'content'), - selection = get(this, 'selection'), - selectionIndex = content ? indexOf(content, selection) : -1, - prompt = get(this, 'prompt'); - - if (prompt) { selectionIndex += 1; } - if (el) { el.selectedIndex = selectionIndex; } - }, - - _selectionDidChangeMultiple: function() { - var content = get(this, 'content'), - selection = get(this, 'selection'), - selectedIndexes = content ? indexesOf(content, selection) : [-1], - prompt = get(this, 'prompt'), - offset = prompt ? 1 : 0, - options = this.$('option'), - adjusted; - - if (options) { - options.each(function() { - adjusted = this.index > -1 ? this.index - offset : -1; - this.selected = indexOf(selectedIndexes, adjusted) > -1; - }); - } - }, - - init: function() { - this._super(); - this.on("didInsertElement", this, this._triggerChange); - this.on("change", this, this._change); - } -}); - -Ember.SelectOption = Ember.View.extend({ - tagName: 'option', - attributeBindings: ['value', 'selected'], - - defaultTemplate: function(context, options) { - options = { data: options.data, hash: {} }; - Ember.Handlebars.helpers.bind.call(context, "view.label", options); - }, - - init: function() { - this.labelPathDidChange(); - this.valuePathDidChange(); - - this._super(); - }, - - selected: Ember.computed(function() { - var content = get(this, 'content'), - selection = get(this, 'parentView.selection'); - if (get(this, 'parentView.multiple')) { - return selection && indexOf(selection, content.valueOf()) > -1; - } else { - // Primitives get passed through bindings as objects... since - // `new Number(4) !== 4`, we use `==` below - return content == selection; - } - }).property('content', 'parentView.selection').volatile(), - - labelPathDidChange: Ember.observer(function() { - var labelPath = get(this, 'parentView.optionLabelPath'); - - if (!labelPath) { return; } - - Ember.defineProperty(this, 'label', Ember.computed(function() { - return get(this, labelPath); - }).property(labelPath)); - }, 'parentView.optionLabelPath'), - - valuePathDidChange: Ember.observer(function() { - var valuePath = get(this, 'parentView.optionValuePath'); - - if (!valuePath) { return; } - - Ember.defineProperty(this, 'value', Ember.computed(function() { - return get(this, valuePath); - }).property(valuePath)); - }, 'parentView.optionValuePath') -}); - -})(); - - - -(function() { - -})(); - - - -(function() { -/*globals Handlebars */ -/** -@module ember -@submodule ember-handlebars -*/ - -/** - @private - - Find templates stored in the head tag as script tags and make them available - to Ember.CoreView in the global Ember.TEMPLATES object. This will be run as as - jQuery DOM-ready callback. - - Script tags with "text/x-handlebars" will be compiled - with Ember's Handlebars and are suitable for use as a view's template. - Those with type="text/x-raw-handlebars" will be compiled with regular - Handlebars and are suitable for use in views' computed properties. - - @method bootstrap - @for Ember.Handlebars - @static - @param ctx -*/ -Ember.Handlebars.bootstrap = function(ctx) { - var selectors = 'script[type="text/x-handlebars"], script[type="text/x-raw-handlebars"]'; - - Ember.$(selectors, ctx) - .each(function() { - // Get a reference to the script tag - var script = Ember.$(this), - type = script.attr('type'); - - var compile = (script.attr('type') === 'text/x-raw-handlebars') ? - Ember.$.proxy(Handlebars.compile, Handlebars) : - Ember.$.proxy(Ember.Handlebars.compile, Ember.Handlebars), - // Get the name of the script, used by Ember.View's templateName property. - // First look for data-template-name attribute, then fall back to its - // id if no name is found. - templateName = script.attr('data-template-name') || script.attr('id') || 'application', - template = compile(script.html()); - - // For templates which have a name, we save them and then remove them from the DOM - Ember.TEMPLATES[templateName] = template; - - // Remove script tag from DOM - script.remove(); - }); -}; - -function bootstrap() { - Ember.Handlebars.bootstrap( Ember.$(document) ); -} - -/* - We tie this to application.load to ensure that we've at least - attempted to bootstrap at the point that the application is loaded. - - We also tie this to document ready since we're guaranteed that all - the inline templates are present at this point. - - There's no harm to running this twice, since we remove the templates - from the DOM after processing. -*/ - -Ember.onLoad('application', bootstrap); - -})(); - - - -(function() { -/** -Ember Handlebars - -@module ember -@submodule ember-handlebars -@requires ember-views -*/ - -})(); - -// Version: v1.0.pre-243-g2578a65 -// Last commit: 2578a65 (2012-10-21 18:51:25 +0200) +// Version: v1.0.0-pre.4-209-g455440d +// Last commit: 455440d (2013-02-13 12:03:37 -0800) (function() { diff --git a/assets/scripts/vendor/handlebars.js b/assets/scripts/vendor/handlebars.js index 1cbc8a27..247a3fdf 100644 --- a/assets/scripts/vendor/handlebars.js +++ b/assets/scripts/vendor/handlebars.js @@ -3,9 +3,9 @@ /*jshint eqnull:true*/ this.Handlebars = {}; -(function() { +(function(Handlebars) { -Handlebars.VERSION = "1.0.rc.1"; +Handlebars.VERSION = "1.0.rc.2"; Handlebars.helpers = {}; Handlebars.partials = {}; @@ -44,29 +44,71 @@ Handlebars.registerHelper('blockHelperMissing', function(context, options) { return inverse(this); } else if(type === "[object Array]") { if(context.length > 0) { - for(var i=0, j=context.length; i 0) { - for(var i=0, j=context.length; i 2) { - expected.push("'"+this.terminals_[p]+"'"); - } - var errStr = ''; + for (p in table[state]) + if (this.terminals_[p] && p > 2) { + expected.push("'" + this.terminals_[p] + "'"); + } if (this.lexer.showPosition) { - errStr = 'Parse error on line '+(yylineno+1)+":\n"+this.lexer.showPosition()+"\nExpecting "+expected.join(', ') + ", got '" + this.terminals_[symbol]+ "'"; + errStr = "Parse error on line " + (yylineno + 1) + ":\n" + this.lexer.showPosition() + "\nExpecting " + expected.join(", ") + ", got '" + (this.terminals_[symbol] || symbol) + "'"; } else { - errStr = 'Parse error on line '+(yylineno+1)+": Unexpected " + - (symbol == 1 /*EOF*/ ? "end of input" : - ("'"+(this.terminals_[symbol] || symbol)+"'")); + errStr = "Parse error on line " + (yylineno + 1) + ": Unexpected " + (symbol == 1?"end of input":"'" + (this.terminals_[symbol] || symbol) + "'"); } - this.parseError(errStr, - {text: this.lexer.match, token: this.terminals_[symbol] || symbol, line: this.lexer.yylineno, loc: yyloc, expected: expected}); + this.parseError(errStr, {text: this.lexer.match, token: this.terminals_[symbol] || symbol, line: this.lexer.yylineno, loc: yyloc, expected: expected}); } - - // just recovered from another error - if (recovering == 3) { - if (symbol == EOF) { - throw new Error(errStr || 'Parsing halted.'); - } - - // discard current lookahead and grab another + } + if (action[0] instanceof Array && action.length > 1) { + throw new Error("Parse Error: multiple actions possible at state: " + state + ", token: " + symbol); + } + switch (action[0]) { + case 1: + stack.push(symbol); + vstack.push(this.lexer.yytext); + lstack.push(this.lexer.yylloc); + stack.push(action[1]); + symbol = null; + if (!preErrorSymbol) { yyleng = this.lexer.yyleng; yytext = this.lexer.yytext; yylineno = this.lexer.yylineno; yyloc = this.lexer.yylloc; - symbol = lex(); + if (recovering > 0) + recovering--; + } else { + symbol = preErrorSymbol; + preErrorSymbol = null; } - - // try to recover from error - while (1) { - // check for error recovery rule in this state - if ((TERROR.toString()) in table[state]) { - break; - } - if (state == 0) { - throw new Error(errStr || 'Parsing halted.'); - } - popStack(1); - state = stack[stack.length-1]; + break; + case 2: + len = this.productions_[action[1]][1]; + yyval.$ = vstack[vstack.length - len]; + yyval._$ = {first_line: lstack[lstack.length - (len || 1)].first_line, last_line: lstack[lstack.length - 1].last_line, first_column: lstack[lstack.length - (len || 1)].first_column, last_column: lstack[lstack.length - 1].last_column}; + if (ranges) { + yyval._$.range = [lstack[lstack.length - (len || 1)].range[0], lstack[lstack.length - 1].range[1]]; } - - preErrorSymbol = symbol; // save the lookahead token - symbol = TERROR; // insert generic error symbol as new lookahead - state = stack[stack.length-1]; - action = table[state] && table[state][TERROR]; - recovering = 3; // allow 3 real symbols to be shifted before reporting a new error + r = this.performAction.call(yyval, yytext, yyleng, yylineno, this.yy, action[1], vstack, lstack); + if (typeof r !== "undefined") { + return r; + } + if (len) { + stack = stack.slice(0, -1 * len * 2); + vstack = vstack.slice(0, -1 * len); + lstack = lstack.slice(0, -1 * len); + } + stack.push(this.productions_[action[1]][0]); + vstack.push(yyval.$); + lstack.push(yyval._$); + newState = table[stack[stack.length - 2]][stack[stack.length - 1]]; + stack.push(newState); + break; + case 3: + return true; } - - // this shouldn't happen, unless resolve defaults are off - if (action[0] instanceof Array && action.length > 1) { - throw new Error('Parse Error: multiple actions possible at state: '+state+', token: '+symbol); - } - - switch (action[0]) { - - case 1: // shift - //this.shiftCount++; - - stack.push(symbol); - vstack.push(this.lexer.yytext); - lstack.push(this.lexer.yylloc); - stack.push(action[1]); // push state - symbol = null; - if (!preErrorSymbol) { // normal execution/no error - yyleng = this.lexer.yyleng; - yytext = this.lexer.yytext; - yylineno = this.lexer.yylineno; - yyloc = this.lexer.yylloc; - if (recovering > 0) - recovering--; - } else { // error just occurred, resume old lookahead f/ before error - symbol = preErrorSymbol; - preErrorSymbol = null; - } - break; - - case 2: // reduce - //this.reductionCount++; - - len = this.productions_[action[1]][1]; - - // perform semantic action - yyval.$ = vstack[vstack.length-len]; // default to $$ = $1 - // default location, uses first token for firsts, last for lasts - yyval._$ = { - first_line: lstack[lstack.length-(len||1)].first_line, - last_line: lstack[lstack.length-1].last_line, - first_column: lstack[lstack.length-(len||1)].first_column, - last_column: lstack[lstack.length-1].last_column - }; - r = this.performAction.call(yyval, yytext, yyleng, yylineno, this.yy, action[1], vstack, lstack); - - if (typeof r !== 'undefined') { - return r; - } - - // pop off stack - if (len) { - stack = stack.slice(0,-1*len*2); - vstack = vstack.slice(0, -1*len); - lstack = lstack.slice(0, -1*len); - } - - stack.push(this.productions_[action[1]][0]); // push nonterminal (reduce) - vstack.push(yyval.$); - lstack.push(yyval._$); - // goto new state = table[STATE][NONTERMINAL] - newState = table[stack[stack.length-2]][stack[stack.length-1]]; - stack.push(newState); - break; - - case 3: // accept - return true; - } - } - return true; -}};/* Jison generated lexer */ +} +}; +/* Jison generated lexer */ var lexer = (function(){ - var lexer = ({EOF:1, parseError:function parseError(str, hash) { - if (this.yy.parseError) { - this.yy.parseError(str, hash); + if (this.yy.parser) { + this.yy.parser.parseError(str, hash); } else { throw new Error(str); } @@ -400,27 +376,64 @@ setInput:function (input) { this.yytext = this.matched = this.match = ''; this.conditionStack = ['INITIAL']; this.yylloc = {first_line:1,first_column:0,last_line:1,last_column:0}; + if (this.options.ranges) this.yylloc.range = [0,0]; + this.offset = 0; return this; }, input:function () { var ch = this._input[0]; - this.yytext+=ch; + this.yytext += ch; this.yyleng++; - this.match+=ch; - this.matched+=ch; - var lines = ch.match(/\n/); - if (lines) this.yylineno++; + this.offset++; + this.match += ch; + this.matched += ch; + var lines = ch.match(/(?:\r\n?|\n).*/g); + if (lines) { + this.yylineno++; + this.yylloc.last_line++; + } else { + this.yylloc.last_column++; + } + if (this.options.ranges) this.yylloc.range[1]++; + this._input = this._input.slice(1); return ch; }, unput:function (ch) { + var len = ch.length; + var lines = ch.split(/(?:\r\n?|\n)/g); + this._input = ch + this._input; + this.yytext = this.yytext.substr(0, this.yytext.length-len-1); + //this.yyleng -= len; + this.offset -= len; + var oldLines = this.match.split(/(?:\r\n?|\n)/g); + this.match = this.match.substr(0, this.match.length-1); + this.matched = this.matched.substr(0, this.matched.length-1); + + if (lines.length-1) this.yylineno -= lines.length-1; + var r = this.yylloc.range; + + this.yylloc = {first_line: this.yylloc.first_line, + last_line: this.yylineno+1, + first_column: this.yylloc.first_column, + last_column: lines ? + (lines.length === oldLines.length ? this.yylloc.first_column : 0) + oldLines[oldLines.length - lines.length].length - lines[0].length: + this.yylloc.first_column - len + }; + + if (this.options.ranges) { + this.yylloc.range = [r[0], r[0] + this.yyleng - len]; + } return this; }, more:function () { this._more = true; return this; }, +less:function (n) { + this.unput(this.match.slice(n)); + }, pastInput:function () { var past = this.matched.substr(0, this.matched.length - this.match.length); return (past.length > 20 ? '...':'') + past.substr(-20).replace(/\n/g, ""); @@ -445,6 +458,8 @@ next:function () { var token, match, + tempMatch, + index, col, lines; if (!this._more) { @@ -453,30 +468,39 @@ next:function () { } var rules = this._currentRules(); for (var i=0;i < rules.length; i++) { - match = this._input.match(this.rules[rules[i]]); - if (match) { - lines = match[0].match(/\n.*/g); - if (lines) this.yylineno += lines.length; - this.yylloc = {first_line: this.yylloc.last_line, - last_line: this.yylineno+1, - first_column: this.yylloc.last_column, - last_column: lines ? lines[lines.length-1].length-1 : this.yylloc.last_column + match[0].length} - this.yytext += match[0]; - this.match += match[0]; - this.matches = match; - this.yyleng = this.yytext.length; - this._more = false; - this._input = this._input.slice(match[0].length); - this.matched += match[0]; - token = this.performAction.call(this, this.yy, this, rules[i],this.conditionStack[this.conditionStack.length-1]); - if (token) return token; - else return; + tempMatch = this._input.match(this.rules[rules[i]]); + if (tempMatch && (!match || tempMatch[0].length > match[0].length)) { + match = tempMatch; + index = i; + if (!this.options.flex) break; } } + if (match) { + lines = match[0].match(/(?:\r\n?|\n).*/g); + if (lines) this.yylineno += lines.length; + this.yylloc = {first_line: this.yylloc.last_line, + last_line: this.yylineno+1, + first_column: this.yylloc.last_column, + last_column: lines ? lines[lines.length-1].length-lines[lines.length-1].match(/\r?\n?/)[0].length : this.yylloc.last_column + match[0].length}; + this.yytext += match[0]; + this.match += match[0]; + this.matches = match; + this.yyleng = this.yytext.length; + if (this.options.ranges) { + this.yylloc.range = [this.offset, this.offset += this.yyleng]; + } + this._more = false; + this._input = this._input.slice(match[0].length); + this.matched += match[0]; + token = this.performAction.call(this, this.yy, this, rules[index],this.conditionStack[this.conditionStack.length-1]); + if (this.done && this._input) this.done = false; + if (token) return token; + else return; + } if (this._input === "") { return this.EOF; } else { - this.parseError('Lexical error on line '+(this.yylineno+1)+'. Unrecognized text.\n'+this.showPosition(), + return this.parseError('Lexical error on line '+(this.yylineno+1)+'. Unrecognized text.\n'+this.showPosition(), {text: "", token: null, line: this.yylineno}); } }, @@ -503,6 +527,7 @@ topState:function () { pushState:function begin(condition) { this.begin(condition); }}); +lexer.options = {}; lexer.performAction = function anonymous(yy,yy_,$avoiding_name_collisions,YY_START) { var YYSTATE=YY_START @@ -511,86 +536,85 @@ case 0: if(yy_.yytext.slice(-1) !== "\\") this.begin("mu"); if(yy_.yytext.slice(-1) === "\\") yy_.yytext = yy_.yytext.substr(0,yy_.yyleng-1), this.begin("emu"); if(yy_.yytext) return 14; - + break; -case 1: return 14; +case 1: return 14; break; -case 2: this.popState(); return 14; +case 2: + if(yy_.yytext.slice(-1) !== "\\") this.popState(); + if(yy_.yytext.slice(-1) === "\\") yy_.yytext = yy_.yytext.substr(0,yy_.yyleng-1); + return 14; + break; -case 3: return 24; +case 3: yy_.yytext = yy_.yytext.substr(0, yy_.yyleng-4); this.popState(); return 15; break; -case 4: return 16; +case 4: this.begin("par"); return 24; break; -case 5: return 20; +case 5: return 16; break; -case 6: return 19; +case 6: return 20; break; -case 7: return 19; +case 7: return 19; break; -case 8: return 23; +case 8: return 19; break; -case 9: return 23; +case 9: return 23; break; -case 10: yy_.yytext = yy_.yytext.substr(3,yy_.yyleng-5); this.popState(); return 15; +case 10: return 23; break; -case 11: return 22; +case 11: this.popState(); this.begin('com'); break; -case 12: return 34; +case 12: yy_.yytext = yy_.yytext.substr(3,yy_.yyleng-5); this.popState(); return 15; break; -case 13: return 33; +case 13: return 22; break; -case 14: return 33; +case 14: return 36; break; -case 15: return 36; +case 15: return 35; break; -case 16: /*ignore whitespace*/ +case 16: return 35; break; -case 17: this.popState(); return 18; +case 17: return 39; break; -case 18: this.popState(); return 18; +case 18: /*ignore whitespace*/ break; -case 19: yy_.yytext = yy_.yytext.substr(1,yy_.yyleng-2).replace(/\\"/g,'"'); return 28; +case 19: this.popState(); return 18; break; -case 20: return 30; +case 20: this.popState(); return 18; break; -case 21: return 30; +case 21: yy_.yytext = yy_.yytext.substr(1,yy_.yyleng-2).replace(/\\"/g,'"'); return 30; break; -case 22: return 29; +case 22: yy_.yytext = yy_.yytext.substr(1,yy_.yyleng-2).replace(/\\'/g,"'"); return 30; break; -case 23: return 33; +case 23: yy_.yytext = yy_.yytext.substr(1); return 28; break; -case 24: yy_.yytext = yy_.yytext.substr(1, yy_.yyleng-2); return 33; +case 24: return 32; break; -case 25: return 'INVALID'; +case 25: return 32; break; -case 26: return 5; +case 26: return 31; +break; +case 27: return 35; +break; +case 28: yy_.yytext = yy_.yytext.substr(1, yy_.yyleng-2); return 35; +break; +case 29: return 'INVALID'; +break; +case 30: /*ignore whitespace*/ +break; +case 31: this.popState(); return 37; +break; +case 32: return 5; break; } }; -lexer.rules = [/^[^\x00]*?(?=(\{\{))/,/^[^\x00]+/,/^[^\x00]{2,}?(?=(\{\{))/,/^\{\{>/,/^\{\{#/,/^\{\{\//,/^\{\{\^/,/^\{\{\s*else\b/,/^\{\{\{/,/^\{\{&/,/^\{\{![\s\S]*?\}\}/,/^\{\{/,/^=/,/^\.(?=[} ])/,/^\.\./,/^[\/.]/,/^\s+/,/^\}\}\}/,/^\}\}/,/^"(\\["]|[^"])*"/,/^true(?=[}\s])/,/^false(?=[}\s])/,/^[0-9]+(?=[}\s])/,/^[a-zA-Z0-9_$-]+(?=[=}\s\/.])/,/^\[[^\]]*\]/,/^./,/^$/]; -lexer.conditions = {"mu":{"rules":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26],"inclusive":false},"emu":{"rules":[2],"inclusive":false},"INITIAL":{"rules":[0,1,26],"inclusive":true}};return lexer;})() +lexer.rules = [/^(?:[^\x00]*?(?=(\{\{)))/,/^(?:[^\x00]+)/,/^(?:[^\x00]{2,}?(?=(\{\{|$)))/,/^(?:[\s\S]*?--\}\})/,/^(?:\{\{>)/,/^(?:\{\{#)/,/^(?:\{\{\/)/,/^(?:\{\{\^)/,/^(?:\{\{\s*else\b)/,/^(?:\{\{\{)/,/^(?:\{\{&)/,/^(?:\{\{!--)/,/^(?:\{\{![\s\S]*?\}\})/,/^(?:\{\{)/,/^(?:=)/,/^(?:\.(?=[} ]))/,/^(?:\.\.)/,/^(?:[\/.])/,/^(?:\s+)/,/^(?:\}\}\})/,/^(?:\}\})/,/^(?:"(\\["]|[^"])*")/,/^(?:'(\\[']|[^'])*')/,/^(?:@[a-zA-Z]+)/,/^(?:true(?=[}\s]))/,/^(?:false(?=[}\s]))/,/^(?:[0-9]+(?=[}\s]))/,/^(?:[a-zA-Z0-9_$-]+(?=[=}\s\/.]))/,/^(?:\[[^\]]*\])/,/^(?:.)/,/^(?:\s+)/,/^(?:[a-zA-Z0-9_$-/]+)/,/^(?:$)/]; +lexer.conditions = {"mu":{"rules":[4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,32],"inclusive":false},"emu":{"rules":[2],"inclusive":false},"com":{"rules":[3],"inclusive":false},"par":{"rules":[30,31],"inclusive":false},"INITIAL":{"rules":[0,1,32],"inclusive":true}}; +return lexer;})() parser.lexer = lexer; -return parser; -})(); -if (typeof require !== 'undefined' && typeof exports !== 'undefined') { -exports.parser = handlebars; -exports.parse = function () { return handlebars.parse.apply(handlebars, arguments); } -exports.main = function commonjsMain(args) { - if (!args[1]) - throw new Error('Usage: '+args[0]+' FILE'); - if (typeof process !== 'undefined') { - var source = require('fs').readFileSync(require('path').join(process.cwd(), args[1]), "utf8"); - } else { - var cwd = require("file").path(require("file").cwd()); - var source = cwd.join(args[1]).read({charset: "utf-8"}); - } - return exports.parser.parse(source); -} -if (typeof module !== 'undefined' && require.main === module) { - exports.main(typeof process !== 'undefined' ? process.argv.slice(1) : require("system").args); -} -}; -; +function Parser () { this.yy = {}; }Parser.prototype = parser;parser.Parser = Parser; +return new Parser; +})();; // lib/handlebars/compiler/base.js Handlebars.Parser = handlebars; @@ -601,17 +625,7 @@ Handlebars.parse = function(string) { Handlebars.print = function(ast) { return new Handlebars.PrintVisitor().accept(ast); -}; - -Handlebars.logger = { - DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3, level: 3, - - // override in the host environment - log: function(level, str) {} -}; - -Handlebars.log = function(level, str) { Handlebars.logger.log(level, str); }; -; +};; // lib/handlebars/compiler/ast.js (function() { @@ -645,13 +659,10 @@ Handlebars.log = function(level, str) { Handlebars.logger.log(level, str); }; // pass or at runtime. }; - Handlebars.AST.PartialNode = function(id, context) { - this.type = "partial"; - - // TODO: disallow complex IDs - - this.id = id; - this.context = context; + Handlebars.AST.PartialNode = function(partialName, context) { + this.type = "partial"; + this.partialName = partialName; + this.context = context; }; var verifyMatch = function(open, close) { @@ -703,21 +714,36 @@ Handlebars.log = function(level, str) { Handlebars.logger.log(level, str); }; // an ID is simple if it only has one part, and that part is not // `..` or `this`. this.isSimple = parts.length === 1 && !this.isScoped && depth === 0; + + this.stringModeValue = this.string; + }; + + Handlebars.AST.PartialNameNode = function(name) { + this.type = "PARTIAL_NAME"; + this.name = name; + }; + + Handlebars.AST.DataNode = function(id) { + this.type = "DATA"; + this.id = id; }; Handlebars.AST.StringNode = function(string) { this.type = "STRING"; this.string = string; + this.stringModeValue = string; }; Handlebars.AST.IntegerNode = function(integer) { this.type = "INTEGER"; this.integer = integer; + this.stringModeValue = Number(integer); }; Handlebars.AST.BooleanNode = function(bool) { this.type = "BOOLEAN"; this.bool = bool; + this.stringModeValue = bool === "true"; }; Handlebars.AST.CommentNode = function(comment) { @@ -727,14 +753,16 @@ Handlebars.log = function(level, str) { Handlebars.logger.log(level, str); }; })();; // lib/handlebars/utils.js + +var errorProps = ['description', 'fileName', 'lineNumber', 'message', 'name', 'number', 'stack']; + Handlebars.Exception = function(message) { var tmp = Error.prototype.constructor.apply(this, arguments); - for (var p in tmp) { - if (tmp.hasOwnProperty(p)) { this[p] = tmp[p]; } + // Unfortunately errors are not enumerable in Chrome (at least), so `for prop in tmp` doesn't work. + for (var idx = 0; idx < errorProps.length; idx++) { + this[errorProps[idx]] = tmp[errorProps[idx]]; } - - this.message = tmp.message; }; Handlebars.Exception.prototype = new Error(); @@ -748,6 +776,7 @@ Handlebars.SafeString.prototype.toString = function() { (function() { var escape = { + "&": "&", "<": "<", ">": ">", '"': """, @@ -755,7 +784,7 @@ Handlebars.SafeString.prototype.toString = function() { "`": "`" }; - var badChars = /&(?!\w+;)|[<>"'`]/g; + var badChars = /[&<>"'`]/g; var possible = /[&<>"'`]/; var escapeChar = function(chr) { @@ -776,11 +805,7 @@ Handlebars.SafeString.prototype.toString = function() { }, isEmpty: function(value) { - if (typeof value === "undefined") { - return true; - } else if (value === null) { - return true; - } else if (value === false) { + if (!value && value !== 0) { return true; } else if(Object.prototype.toString.call(value) === "[object Array]" && value.length === 0) { return true; @@ -919,7 +944,7 @@ Handlebars.JavaScriptCompiler = function() {}; // evaluate it by executing `blockHelperMissing` this.opcode('pushProgram', program); this.opcode('pushProgram', inverse); - this.opcode('pushLiteral', '{}'); + this.opcode('pushHash'); this.opcode('blockValue'); } else { this.ambiguousMustache(mustache, program, inverse); @@ -928,7 +953,7 @@ Handlebars.JavaScriptCompiler = function() {}; // evaluate it by executing `blockHelperMissing` this.opcode('pushProgram', program); this.opcode('pushProgram', inverse); - this.opcode('pushLiteral', '{}'); + this.opcode('pushHash'); this.opcode('ambiguousBlockValue'); } @@ -938,19 +963,24 @@ Handlebars.JavaScriptCompiler = function() {}; hash: function(hash) { var pairs = hash.pairs, pair, val; - this.opcode('push', '{}'); + this.opcode('pushHash'); for(var i=0, l=pairs.length; i").appendTo(b),e=d.css("display");d.remove();if(e==="none"||e===""){ck||(ck=c.createElement("iframe"),ck.frameBorder=ck.width=ck.height=0),b.appendChild(ck);if(!cl||!ck.createElement)cl=(ck.contentWindow||ck.contentDocument).document,cl.write((f.support.boxModel?"":"")+""),cl.close();d=cl.createElement(a),cl.body.appendChild(d),e=f.css(d,"display"),b.removeChild(ck)}cj[a]=e}return cj[a]}function ct(a,b){var c={};f.each(cp.concat.apply([],cp.slice(0,b)),function(){c[this]=a});return c}function cs(){cq=b}function cr(){setTimeout(cs,0);return cq=f.now()}function ci(){try{return new a.ActiveXObject("Microsoft.XMLHTTP")}catch(b){}}function ch(){try{return new a.XMLHttpRequest}catch(b){}}function cb(a,c){a.dataFilter&&(c=a.dataFilter(c,a.dataType));var d=a.dataTypes,e={},g,h,i=d.length,j,k=d[0],l,m,n,o,p;for(g=1;g0){if(c!=="border")for(;e=0===c})}function S(a){return!a||!a.parentNode||a.parentNode.nodeType===11}function K(){return!0}function J(){return!1}function n(a,b,c){var d=b+"defer",e=b+"queue",g=b+"mark",h=f._data(a,d);h&&(c==="queue"||!f._data(a,e))&&(c==="mark"||!f._data(a,g))&&setTimeout(function(){!f._data(a,e)&&!f._data(a,g)&&(f.removeData(a,d,!0),h.fire())},0)}function m(a){for(var b in a){if(b==="data"&&f.isEmptyObject(a[b]))continue;if(b!=="toJSON")return!1}return!0}function l(a,c,d){if(d===b&&a.nodeType===1){var e="data-"+c.replace(k,"-$1").toLowerCase();d=a.getAttribute(e);if(typeof d=="string"){try{d=d==="true"?!0:d==="false"?!1:d==="null"?null:f.isNumeric(d)?+d:j.test(d)?f.parseJSON(d):d}catch(g){}f.data(a,c,d)}else d=b}return d}function h(a){var b=g[a]={},c,d;a=a.split(/\s+/);for(c=0,d=a.length;c)[^>]*$|#([\w\-]*)$)/,j=/\S/,k=/^\s+/,l=/\s+$/,m=/^<(\w+)\s*\/?>(?:<\/\1>)?$/,n=/^[\],:{}\s]*$/,o=/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,p=/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,q=/(?:^|:|,)(?:\s*\[)+/g,r=/(webkit)[ \/]([\w.]+)/,s=/(opera)(?:.*version)?[ \/]([\w.]+)/,t=/(msie) ([\w.]+)/,u=/(mozilla)(?:.*? rv:([\w.]+))?/,v=/-([a-z]|[0-9])/ig,w=/^-ms-/,x=function(a,b){return(b+"").toUpperCase()},y=d.userAgent,z,A,B,C=Object.prototype.toString,D=Object.prototype.hasOwnProperty,E=Array.prototype.push,F=Array.prototype.slice,G=String.prototype.trim,H=Array.prototype.indexOf,I={};e.fn=e.prototype={constructor:e,init:function(a,d,f){var g,h,j,k;if(!a)return this;if(a.nodeType){this.context=this[0]=a,this.length=1;return this}if(a==="body"&&!d&&c.body){this.context=c,this[0]=c.body,this.selector=a,this.length=1;return this}if(typeof a=="string"){a.charAt(0)!=="<"||a.charAt(a.length-1)!==">"||a.length<3?g=i.exec(a):g=[null,a,null];if(g&&(g[1]||!d)){if(g[1]){d=d instanceof e?d[0]:d,k=d?d.ownerDocument||d:c,j=m.exec(a),j?e.isPlainObject(d)?(a=[c.createElement(j[1])],e.fn.attr.call(a,d,!0)):a=[k.createElement(j[1])]:(j=e.buildFragment([g[1]],[k]),a=(j.cacheable?e.clone(j.fragment):j.fragment).childNodes);return e.merge(this,a)}h=c.getElementById(g[2]);if(h&&h.parentNode){if(h.id!==g[2])return f.find(a);this.length=1,this[0]=h}this.context=c,this.selector=a;return this}return!d||d.jquery?(d||f).find(a):this.constructor(d).find(a)}if(e.isFunction(a))return f.ready(a);a.selector!==b&&(this.selector=a.selector,this.context=a.context);return e.makeArray(a,this)},selector:"",jquery:"1.7.2",length:0,size:function(){return this.length},toArray:function(){return F.call(this,0)},get:function(a){return a==null?this.toArray():a<0?this[this.length+a]:this[a]},pushStack:function(a,b,c){var d=this.constructor();e.isArray(a)?E.apply(d,a):e.merge(d,a),d.prevObject=this,d.context=this.context,b==="find"?d.selector=this.selector+(this.selector?" ":"")+c:b&&(d.selector=this.selector+"."+b+"("+c+")");return d},each:function(a,b){return e.each(this,a,b)},ready:function(a){e.bindReady(),A.add(a);return this},eq:function(a){a=+a;return a===-1?this.slice(a):this.slice(a,a+1)},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},slice:function(){return this.pushStack(F.apply(this,arguments),"slice",F.call(arguments).join(","))},map:function(a){return this.pushStack(e.map(this,function(b,c){return a.call(b,c,b)}))},end:function(){return this.prevObject||this.constructor(null)},push:E,sort:[].sort,splice:[].splice},e.fn.init.prototype=e.fn,e.extend=e.fn.extend=function(){var a,c,d,f,g,h,i=arguments[0]||{},j=1,k=arguments.length,l=!1;typeof i=="boolean"&&(l=i,i=arguments[1]||{},j=2),typeof i!="object"&&!e.isFunction(i)&&(i={}),k===j&&(i=this,--j);for(;j0)return;A.fireWith(c,[e]),e.fn.trigger&&e(c).trigger("ready").off("ready")}},bindReady:function(){if(!A){A=e.Callbacks("once memory");if(c.readyState==="complete")return setTimeout(e.ready,1);if(c.addEventListener)c.addEventListener("DOMContentLoaded",B,!1),a.addEventListener("load",e.ready,!1);else if(c.attachEvent){c.attachEvent("onreadystatechange",B),a.attachEvent("onload",e.ready);var b=!1;try{b=a.frameElement==null}catch(d){}c.documentElement.doScroll&&b&&J()}}},isFunction:function(a){return e.type(a)==="function"},isArray:Array.isArray||function(a){return e.type(a)==="array"},isWindow:function(a){return a!=null&&a==a.window},isNumeric:function(a){return!isNaN(parseFloat(a))&&isFinite(a)},type:function(a){return a==null?String(a):I[C.call(a)]||"object"},isPlainObject:function(a){if(!a||e.type(a)!=="object"||a.nodeType||e.isWindow(a))return!1;try{if(a.constructor&&!D.call(a,"constructor")&&!D.call(a.constructor.prototype,"isPrototypeOf"))return!1}catch(c){return!1}var d;for(d in a);return d===b||D.call(a,d)},isEmptyObject:function(a){for(var b in a)return!1;return!0},error:function(a){throw new Error(a)},parseJSON:function(b){if(typeof b!="string"||!b)return null;b=e.trim(b);if(a.JSON&&a.JSON.parse)return a.JSON.parse(b);if(n.test(b.replace(o,"@").replace(p,"]").replace(q,"")))return(new Function("return "+b))();e.error("Invalid JSON: "+b)},parseXML:function(c){if(typeof c!="string"||!c)return null;var d,f;try{a.DOMParser?(f=new DOMParser,d=f.parseFromString(c,"text/xml")):(d=new ActiveXObject("Microsoft.XMLDOM"),d.async="false",d.loadXML(c))}catch(g){d=b}(!d||!d.documentElement||d.getElementsByTagName("parsererror").length)&&e.error("Invalid XML: "+c);return d},noop:function(){},globalEval:function(b){b&&j.test(b)&&(a.execScript||function(b){a.eval.call(a,b)})(b)},camelCase:function(a){return a.replace(w,"ms-").replace(v,x)},nodeName:function(a,b){return a.nodeName&&a.nodeName.toUpperCase()===b.toUpperCase()},each:function(a,c,d){var f,g=0,h=a.length,i=h===b||e.isFunction(a);if(d){if(i){for(f in a)if(c.apply(a[f],d)===!1)break}else for(;g0&&a[0]&&a[j-1]||j===0||e.isArray(a));if(k)for(;i1?i.call(arguments,0):b,j.notifyWith(k,e)}}function l(a){return function(c){b[a]=arguments.length>1?i.call(arguments,0):c,--g||j.resolveWith(j,b)}}var b=i.call(arguments,0),c=0,d=b.length,e=Array(d),g=d,h=d,j=d<=1&&a&&f.isFunction(a.promise)?a:f.Deferred(),k=j.promise();if(d>1){for(;c
    a",d=p.getElementsByTagName("*"),e=p.getElementsByTagName("a")[0];if(!d||!d.length||!e)return{};g=c.createElement("select"),h=g.appendChild(c.createElement("option")),i=p.getElementsByTagName("input")[0],b={leadingWhitespace:p.firstChild.nodeType===3,tbody:!p.getElementsByTagName("tbody").length,htmlSerialize:!!p.getElementsByTagName("link").length,style:/top/.test(e.getAttribute("style")),hrefNormalized:e.getAttribute("href")==="/a",opacity:/^0.55/.test(e.style.opacity),cssFloat:!!e.style.cssFloat,checkOn:i.value==="on",optSelected:h.selected,getSetAttribute:p.className!=="t",enctype:!!c.createElement("form").enctype,html5Clone:c.createElement("nav").cloneNode(!0).outerHTML!=="<:nav>",submitBubbles:!0,changeBubbles:!0,focusinBubbles:!1,deleteExpando:!0,noCloneEvent:!0,inlineBlockNeedsLayout:!1,shrinkWrapBlocks:!1,reliableMarginRight:!0,pixelMargin:!0},f.boxModel=b.boxModel=c.compatMode==="CSS1Compat",i.checked=!0,b.noCloneChecked=i.cloneNode(!0).checked,g.disabled=!0,b.optDisabled=!h.disabled;try{delete p.test}catch(r){b.deleteExpando=!1}!p.addEventListener&&p.attachEvent&&p.fireEvent&&(p.attachEvent("onclick",function(){b.noCloneEvent=!1}),p.cloneNode(!0).fireEvent("onclick")),i=c.createElement("input"),i.value="t",i.setAttribute("type","radio"),b.radioValue=i.value==="t",i.setAttribute("checked","checked"),i.setAttribute("name","t"),p.appendChild(i),j=c.createDocumentFragment(),j.appendChild(p.lastChild),b.checkClone=j.cloneNode(!0).cloneNode(!0).lastChild.checked,b.appendChecked=i.checked,j.removeChild(i),j.appendChild(p);if(p.attachEvent)for(n in{submit:1,change:1,focusin:1})m="on"+n,o=m in p,o||(p.setAttribute(m,"return;"),o=typeof p[m]=="function"),b[n+"Bubbles"]=o;j.removeChild(p),j=g=h=p=i=null,f(function(){var d,e,g,h,i,j,l,m,n,q,r,s,t,u=c.getElementsByTagName("body")[0];!u||(m=1,t="padding:0;margin:0;border:",r="position:absolute;top:0;left:0;width:1px;height:1px;",s=t+"0;visibility:hidden;",n="style='"+r+t+"5px solid #000;",q="
    "+""+"
    ",d=c.createElement("div"),d.style.cssText=s+"width:0;height:0;position:static;top:0;margin-top:"+m+"px",u.insertBefore(d,u.firstChild),p=c.createElement("div"),d.appendChild(p),p.innerHTML="
    t
    ",k=p.getElementsByTagName("td"),o=k[0].offsetHeight===0,k[0].style.display="",k[1].style.display="none",b.reliableHiddenOffsets=o&&k[0].offsetHeight===0,a.getComputedStyle&&(p.innerHTML="",l=c.createElement("div"),l.style.width="0",l.style.marginRight="0",p.style.width="2px",p.appendChild(l),b.reliableMarginRight=(parseInt((a.getComputedStyle(l,null)||{marginRight:0}).marginRight,10)||0)===0),typeof p.style.zoom!="undefined"&&(p.innerHTML="",p.style.width=p.style.padding="1px",p.style.border=0,p.style.overflow="hidden",p.style.display="inline",p.style.zoom=1,b.inlineBlockNeedsLayout=p.offsetWidth===3,p.style.display="block",p.style.overflow="visible",p.innerHTML="
    ",b.shrinkWrapBlocks=p.offsetWidth!==3),p.style.cssText=r+s,p.innerHTML=q,e=p.firstChild,g=e.firstChild,i=e.nextSibling.firstChild.firstChild,j={doesNotAddBorder:g.offsetTop!==5,doesAddBorderForTableAndCells:i.offsetTop===5},g.style.position="fixed",g.style.top="20px",j.fixedPosition=g.offsetTop===20||g.offsetTop===15,g.style.position=g.style.top="",e.style.overflow="hidden",e.style.position="relative",j.subtractsBorderForOverflowNotVisible=g.offsetTop===-5,j.doesNotIncludeMarginInBodyOffset=u.offsetTop!==m,a.getComputedStyle&&(p.style.marginTop="1%",b.pixelMargin=(a.getComputedStyle(p,null)||{marginTop:0}).marginTop!=="1%"),typeof d.style.zoom!="undefined"&&(d.style.zoom=1),u.removeChild(d),l=p=d=null,f.extend(b,j))});return b}();var j=/^(?:\{.*\}|\[.*\])$/,k=/([A-Z])/g;f.extend({cache:{},uuid:0,expando:"jQuery"+(f.fn.jquery+Math.random()).replace(/\D/g,""),noData:{embed:!0,object:"clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",applet:!0},hasData:function(a){a=a.nodeType?f.cache[a[f.expando]]:a[f.expando];return!!a&&!m(a)},data:function(a,c,d,e){if(!!f.acceptData(a)){var g,h,i,j=f.expando,k=typeof c=="string",l=a.nodeType,m=l?f.cache:a,n=l?a[j]:a[j]&&j,o=c==="events";if((!n||!m[n]||!o&&!e&&!m[n].data)&&k&&d===b)return;n||(l?a[j]=n=++f.uuid:n=j),m[n]||(m[n]={},l||(m[n].toJSON=f.noop));if(typeof c=="object"||typeof c=="function")e?m[n]=f.extend(m[n],c):m[n].data=f.extend(m[n].data,c);g=h=m[n],e||(h.data||(h.data={}),h=h.data),d!==b&&(h[f.camelCase(c)]=d);if(o&&!h[c])return g.events;k?(i=h[c],i==null&&(i=h[f.camelCase(c)])):i=h;return i}},removeData:function(a,b,c){if(!!f.acceptData(a)){var d,e,g,h=f.expando,i=a.nodeType,j=i?f.cache:a,k=i?a[h]:h;if(!j[k])return;if(b){d=c?j[k]:j[k].data;if(d){f.isArray(b)||(b in d?b=[b]:(b=f.camelCase(b),b in d?b=[b]:b=b.split(" ")));for(e=0,g=b.length;e1,null,!1)},removeData:function(a){return this.each(function(){f.removeData(this,a)})}}),f.extend({_mark:function(a,b){a&&(b=(b||"fx")+"mark",f._data(a,b,(f._data(a,b)||0)+1))},_unmark:function(a,b,c){a!==!0&&(c=b,b=a,a=!1);if(b){c=c||"fx";var d=c+"mark",e=a?0:(f._data(b,d)||1)-1;e?f._data(b,d,e):(f.removeData(b,d,!0),n(b,c,"mark"))}},queue:function(a,b,c){var d;if(a){b=(b||"fx")+"queue",d=f._data(a,b),c&&(!d||f.isArray(c)?d=f._data(a,b,f.makeArray(c)):d.push(c));return d||[]}},dequeue:function(a,b){b=b||"fx";var c=f.queue(a,b),d=c.shift(),e={};d==="inprogress"&&(d=c.shift()),d&&(b==="fx"&&c.unshift("inprogress"),f._data(a,b+".run",e),d.call(a,function(){f.dequeue(a,b)},e)),c.length||(f.removeData(a,b+"queue "+b+".run",!0),n(a,b,"queue"))}}),f.fn.extend({queue:function(a,c){var d=2;typeof a!="string"&&(c=a,a="fx",d--);if(arguments.length1)},removeAttr:function(a){return this.each(function(){f.removeAttr(this,a)})},prop:function(a,b){return f.access(this,f.prop,a,b,arguments.length>1)},removeProp:function(a){a=f.propFix[a]||a;return this.each(function(){try{this[a]=b,delete this[a]}catch(c){}})},addClass:function(a){var b,c,d,e,g,h,i;if(f.isFunction(a))return this.each(function(b){f(this).addClass(a.call(this,b,this.className))});if(a&&typeof a=="string"){b=a.split(p);for(c=0,d=this.length;c-1)return!0;return!1},val:function(a){var c,d,e,g=this[0];{if(!!arguments.length){e=f.isFunction(a);return this.each(function(d){var g=f(this),h;if(this.nodeType===1){e?h=a.call(this,d,g.val()):h=a,h==null?h="":typeof h=="number"?h+="":f.isArray(h)&&(h=f.map(h,function(a){return a==null?"":a+""})),c=f.valHooks[this.type]||f.valHooks[this.nodeName.toLowerCase()];if(!c||!("set"in c)||c.set(this,h,"value")===b)this.value=h}})}if(g){c=f.valHooks[g.type]||f.valHooks[g.nodeName.toLowerCase()];if(c&&"get"in c&&(d=c.get(g,"value"))!==b)return d;d=g.value;return typeof d=="string"?d.replace(q,""):d==null?"":d}}}}),f.extend({valHooks:{option:{get:function(a){var b=a.attributes.value;return!b||b.specified?a.value:a.text}},select:{get:function(a){var b,c,d,e,g=a.selectedIndex,h=[],i=a.options,j=a.type==="select-one";if(g<0)return null;c=j?g:0,d=j?g+1:i.length;for(;c=0}),c.length||(a.selectedIndex=-1);return c}}},attrFn:{val:!0,css:!0,html:!0,text:!0,data:!0,width:!0,height:!0,offset:!0},attr:function(a,c,d,e){var g,h,i,j=a.nodeType;if(!!a&&j!==3&&j!==8&&j!==2){if(e&&c in f.attrFn)return f(a)[c](d);if(typeof a.getAttribute=="undefined")return f.prop(a,c,d);i=j!==1||!f.isXMLDoc(a),i&&(c=c.toLowerCase(),h=f.attrHooks[c]||(u.test(c)?x:w));if(d!==b){if(d===null){f.removeAttr(a,c);return}if(h&&"set"in h&&i&&(g=h.set(a,d,c))!==b)return g;a.setAttribute(c,""+d);return d}if(h&&"get"in h&&i&&(g=h.get(a,c))!==null)return g;g=a.getAttribute(c);return g===null?b:g}},removeAttr:function(a,b){var c,d,e,g,h,i=0;if(b&&a.nodeType===1){d=b.toLowerCase().split(p),g=d.length;for(;i=0}})});var z=/^(?:textarea|input|select)$/i,A=/^([^\.]*)?(?:\.(.+))?$/,B=/(?:^|\s)hover(\.\S+)?\b/,C=/^key/,D=/^(?:mouse|contextmenu)|click/,E=/^(?:focusinfocus|focusoutblur)$/,F=/^(\w*)(?:#([\w\-]+))?(?:\.([\w\-]+))?$/,G=function( -a){var b=F.exec(a);b&&(b[1]=(b[1]||"").toLowerCase(),b[3]=b[3]&&new RegExp("(?:^|\\s)"+b[3]+"(?:\\s|$)"));return b},H=function(a,b){var c=a.attributes||{};return(!b[1]||a.nodeName.toLowerCase()===b[1])&&(!b[2]||(c.id||{}).value===b[2])&&(!b[3]||b[3].test((c["class"]||{}).value))},I=function(a){return f.event.special.hover?a:a.replace(B,"mouseenter$1 mouseleave$1")};f.event={add:function(a,c,d,e,g){var h,i,j,k,l,m,n,o,p,q,r,s;if(!(a.nodeType===3||a.nodeType===8||!c||!d||!(h=f._data(a)))){d.handler&&(p=d,d=p.handler,g=p.selector),d.guid||(d.guid=f.guid++),j=h.events,j||(h.events=j={}),i=h.handle,i||(h.handle=i=function(a){return typeof f!="undefined"&&(!a||f.event.triggered!==a.type)?f.event.dispatch.apply(i.elem,arguments):b},i.elem=a),c=f.trim(I(c)).split(" ");for(k=0;k=0&&(h=h.slice(0,-1),k=!0),h.indexOf(".")>=0&&(i=h.split("."),h=i.shift(),i.sort());if((!e||f.event.customEvent[h])&&!f.event.global[h])return;c=typeof c=="object"?c[f.expando]?c:new f.Event(h,c):new f.Event(h),c.type=h,c.isTrigger=!0,c.exclusive=k,c.namespace=i.join("."),c.namespace_re=c.namespace?new RegExp("(^|\\.)"+i.join("\\.(?:.*\\.)?")+"(\\.|$)"):null,o=h.indexOf(":")<0?"on"+h:"";if(!e){j=f.cache;for(l in j)j[l].events&&j[l].events[h]&&f.event.trigger(c,d,j[l].handle.elem,!0);return}c.result=b,c.target||(c.target=e),d=d!=null?f.makeArray(d):[],d.unshift(c),p=f.event.special[h]||{};if(p.trigger&&p.trigger.apply(e,d)===!1)return;r=[[e,p.bindType||h]];if(!g&&!p.noBubble&&!f.isWindow(e)){s=p.delegateType||h,m=E.test(s+h)?e:e.parentNode,n=null;for(;m;m=m.parentNode)r.push([m,s]),n=m;n&&n===e.ownerDocument&&r.push([n.defaultView||n.parentWindow||a,s])}for(l=0;le&&j.push({elem:this,matches:d.slice(e)});for(k=0;k0?this.on(b,null,a,c):this.trigger(b)},f.attrFn&&(f.attrFn[b]=!0),C.test(b)&&(f.event.fixHooks[b]=f.event.keyHooks),D.test(b)&&(f.event.fixHooks[b]=f.event.mouseHooks)}),function(){function x(a,b,c,e,f,g){for(var h=0,i=e.length;h0){k=j;break}}j=j[a]}e[h]=k}}}function w(a,b,c,e,f,g){for(var h=0,i=e.length;h+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,d="sizcache"+(Math.random()+"").replace(".",""),e=0,g=Object.prototype.toString,h=!1,i=!0,j=/\\/g,k=/\r\n/g,l=/\W/;[0,0].sort(function(){i=!1;return 0});var m=function(b,d,e,f){e=e||[],d=d||c;var h=d;if(d.nodeType!==1&&d.nodeType!==9)return[];if(!b||typeof b!="string")return e;var i,j,k,l,n,q,r,t,u=!0,v=m.isXML(d),w=[],x=b;do{a.exec(""),i=a.exec(x);if(i){x=i[3],w.push(i[1]);if(i[2]){l=i[3];break}}}while(i);if(w.length>1&&p.exec(b))if(w.length===2&&o.relative[w[0]])j=y(w[0]+w[1],d,f);else{j=o.relative[w[0]]?[d]:m(w.shift(),d);while(w.length)b=w.shift(),o.relative[b]&&(b+=w.shift()),j=y(b,j,f)}else{!f&&w.length>1&&d.nodeType===9&&!v&&o.match.ID.test(w[0])&&!o.match.ID.test(w[w.length-1])&&(n=m.find(w.shift(),d,v),d=n.expr?m.filter(n.expr,n.set)[0]:n.set[0]);if(d){n=f?{expr:w.pop(),set:s(f)}:m.find(w.pop(),w.length===1&&(w[0]==="~"||w[0]==="+")&&d.parentNode?d.parentNode:d,v),j=n.expr?m.filter(n.expr,n.set):n.set,w.length>0?k=s(j):u=!1;while(w.length)q=w.pop(),r=q,o.relative[q]?r=w.pop():q="",r==null&&(r=d),o.relative[q](k,r,v)}else k=w=[]}k||(k=j),k||m.error(q||b);if(g.call(k)==="[object Array]")if(!u)e.push.apply(e,k);else if(d&&d.nodeType===1)for(t=0;k[t]!=null;t++)k[t]&&(k[t]===!0||k[t].nodeType===1&&m.contains(d,k[t]))&&e.push(j[t]);else for(t=0;k[t]!=null;t++)k[t]&&k[t].nodeType===1&&e.push(j[t]);else s(k,e);l&&(m(l,h,e,f),m.uniqueSort(e));return e};m.uniqueSort=function(a){if(u){h=i,a.sort(u);if(h)for(var b=1;b0},m.find=function(a,b,c){var d,e,f,g,h,i;if(!a)return[];for(e=0,f=o.order.length;e":function(a,b){var c,d=typeof b=="string",e=0,f=a.length;if(d&&!l.test(b)){b=b.toLowerCase();for(;e=0)?c||d.push(h):c&&(b[g]=!1));return!1},ID:function(a){return a[1].replace(j,"")},TAG:function(a,b){return a[1].replace(j,"").toLowerCase()},CHILD:function(a){if(a[1]==="nth"){a[2]||m.error(a[0]),a[2]=a[2].replace(/^\+|\s*/g,"");var b=/(-?)(\d*)(?:n([+\-]?\d*))?/.exec(a[2]==="even"&&"2n"||a[2]==="odd"&&"2n+1"||!/\D/.test(a[2])&&"0n+"+a[2]||a[2]);a[2]=b[1]+(b[2]||1)-0,a[3]=b[3]-0}else a[2]&&m.error(a[0]);a[0]=e++;return a},ATTR:function(a,b,c,d,e,f){var g=a[1]=a[1].replace(j,"");!f&&o.attrMap[g]&&(a[1]=o.attrMap[g]),a[4]=(a[4]||a[5]||"").replace(j,""),a[2]==="~="&&(a[4]=" "+a[4]+" ");return a},PSEUDO:function(b,c,d,e,f){if(b[1]==="not")if((a.exec(b[3])||"").length>1||/^\w/.test(b[3]))b[3]=m(b[3],null,null,c);else{var g=m.filter(b[3],c,d,!0^f);d||e.push.apply(e,g);return!1}else if(o.match.POS.test(b[0])||o.match.CHILD.test(b[0]))return!0;return b},POS:function(a){a.unshift(!0);return a}},filters:{enabled:function(a){return a.disabled===!1&&a.type!=="hidden"},disabled:function(a){return a.disabled===!0},checked:function(a){return a.checked===!0},selected:function(a){a.parentNode&&a.parentNode.selectedIndex;return a.selected===!0},parent:function(a){return!!a.firstChild},empty:function(a){return!a.firstChild},has:function(a,b,c){return!!m(c[3],a).length},header:function(a){return/h\d/i.test(a.nodeName)},text:function(a){var b=a.getAttribute("type"),c=a.type;return a.nodeName.toLowerCase()==="input"&&"text"===c&&(b===c||b===null)},radio:function(a){return a.nodeName.toLowerCase()==="input"&&"radio"===a.type},checkbox:function(a){return a.nodeName.toLowerCase()==="input"&&"checkbox"===a.type},file:function(a){return a.nodeName.toLowerCase()==="input"&&"file"===a.type},password:function(a){return a.nodeName.toLowerCase()==="input"&&"password"===a.type},submit:function(a){var b=a.nodeName.toLowerCase();return(b==="input"||b==="button")&&"submit"===a.type},image:function(a){return a.nodeName.toLowerCase()==="input"&&"image"===a.type},reset:function(a){var b=a.nodeName.toLowerCase();return(b==="input"||b==="button")&&"reset"===a.type},button:function(a){var b=a.nodeName.toLowerCase();return b==="input"&&"button"===a.type||b==="button"},input:function(a){return/input|select|textarea|button/i.test(a.nodeName)},focus:function(a){return a===a.ownerDocument.activeElement}},setFilters:{first:function(a,b){return b===0},last:function(a,b,c,d){return b===d.length-1},even:function(a,b){return b%2===0},odd:function(a,b){return b%2===1},lt:function(a,b,c){return bc[3]-0},nth:function(a,b,c){return c[3]-0===b},eq:function(a,b,c){return c[3]-0===b}},filter:{PSEUDO:function(a,b,c,d){var e=b[1],f=o.filters[e];if(f)return f(a,c,b,d);if(e==="contains")return(a.textContent||a.innerText||n([a])||"").indexOf(b[3])>=0;if(e==="not"){var g=b[3];for(var h=0,i=g.length;h=0}},ID:function(a,b){return a.nodeType===1&&a.getAttribute("id")===b},TAG:function(a,b){return b==="*"&&a.nodeType===1||!!a.nodeName&&a.nodeName.toLowerCase()===b},CLASS:function(a,b){return(" "+(a.className||a.getAttribute("class"))+" ").indexOf(b)>-1},ATTR:function(a,b){var c=b[1],d=m.attr?m.attr(a,c):o.attrHandle[c]?o.attrHandle[c](a):a[c]!=null?a[c]:a.getAttribute(c),e=d+"",f=b[2],g=b[4];return d==null?f==="!=":!f&&m.attr?d!=null:f==="="?e===g:f==="*="?e.indexOf(g)>=0:f==="~="?(" "+e+" ").indexOf(g)>=0:g?f==="!="?e!==g:f==="^="?e.indexOf(g)===0:f==="$="?e.substr(e.length-g.length)===g:f==="|="?e===g||e.substr(0,g.length+1)===g+"-":!1:e&&d!==!1},POS:function(a,b,c,d){var e=b[2],f=o.setFilters[e];if(f)return f(a,c,b,d)}}},p=o.match.POS,q=function(a,b){return"\\"+(b-0+1)};for(var r in o.match)o.match[r]=new RegExp(o.match[r].source+/(?![^\[]*\])(?![^\(]*\))/.source),o.leftMatch[r]=new RegExp(/(^(?:.|\r|\n)*?)/.source+o.match[r].source.replace(/\\(\d+)/g,q));o.match.globalPOS=p;var s=function(a,b){a=Array.prototype.slice.call(a,0);if(b){b.push.apply(b,a);return b}return a};try{Array.prototype.slice.call(c.documentElement.childNodes,0)[0].nodeType}catch(t){s=function(a,b){var c=0,d=b||[];if(g.call(a)==="[object Array]")Array.prototype.push.apply(d,a);else if(typeof a.length=="number")for(var e=a.length;c",e.insertBefore(a,e.firstChild),c.getElementById(d)&&(o.find.ID=function(a,c,d){if(typeof c.getElementById!="undefined"&&!d){var e=c.getElementById(a[1]);return e?e.id===a[1]||typeof e.getAttributeNode!="undefined"&&e.getAttributeNode("id").nodeValue===a[1]?[e]:b:[]}},o.filter.ID=function(a,b){var c=typeof a.getAttributeNode!="undefined"&&a.getAttributeNode("id");return a.nodeType===1&&c&&c.nodeValue===b}),e.removeChild(a),e=a=null}(),function(){var a=c.createElement("div");a.appendChild(c.createComment("")),a.getElementsByTagName("*").length>0&&(o.find.TAG=function(a,b){var c=b.getElementsByTagName(a[1]);if(a[1]==="*"){var d=[];for(var e=0;c[e];e++)c[e].nodeType===1&&d.push(c[e]);c=d}return c}),a.innerHTML="",a.firstChild&&typeof a.firstChild.getAttribute!="undefined"&&a.firstChild.getAttribute("href")!=="#"&&(o.attrHandle.href=function(a){return a.getAttribute("href",2)}),a=null}(),c.querySelectorAll&&function(){var a=m,b=c.createElement("div"),d="__sizzle__";b.innerHTML="

    ";if(!b.querySelectorAll||b.querySelectorAll(".TEST").length!==0){m=function(b,e,f,g){e=e||c;if(!g&&!m.isXML(e)){var h=/^(\w+$)|^\.([\w\-]+$)|^#([\w\-]+$)/.exec(b);if(h&&(e.nodeType===1||e.nodeType===9)){if(h[1])return s(e.getElementsByTagName(b),f);if(h[2]&&o.find.CLASS&&e.getElementsByClassName)return s(e.getElementsByClassName(h[2]),f)}if(e.nodeType===9){if(b==="body"&&e.body)return s([e.body],f);if(h&&h[3]){var i=e.getElementById(h[3]);if(!i||!i.parentNode)return s([],f);if(i.id===h[3])return s([i],f)}try{return s(e.querySelectorAll(b),f)}catch(j){}}else if(e.nodeType===1&&e.nodeName.toLowerCase()!=="object"){var k=e,l=e.getAttribute("id"),n=l||d,p=e.parentNode,q=/^\s*[+~]/.test(b);l?n=n.replace(/'/g,"\\$&"):e.setAttribute("id",n),q&&p&&(e=e.parentNode);try{if(!q||p)return s(e.querySelectorAll("[id='"+n+"'] "+b),f)}catch(r){}finally{l||k.removeAttribute("id")}}}return a(b,e,f,g)};for(var e in a)m[e]=a[e];b=null}}(),function(){var a=c.documentElement,b=a.matchesSelector||a.mozMatchesSelector||a.webkitMatchesSelector||a.msMatchesSelector;if(b){var d=!b.call(c.createElement("div"),"div"),e=!1;try{b.call(c.documentElement,"[test!='']:sizzle")}catch(f){e=!0}m.matchesSelector=function(a,c){c=c.replace(/\=\s*([^'"\]]*)\s*\]/g,"='$1']");if(!m.isXML(a))try{if(e||!o.match.PSEUDO.test(c)&&!/!=/.test(c)){var f=b.call(a,c);if(f||!d||a.document&&a.document.nodeType!==11)return f}}catch(g){}return m(c,null,null,[a]).length>0}}}(),function(){var a=c.createElement("div");a.innerHTML="
    ";if(!!a.getElementsByClassName&&a.getElementsByClassName("e").length!==0){a.lastChild.className="e";if(a.getElementsByClassName("e").length===1)return;o.order.splice(1,0,"CLASS"),o.find.CLASS=function(a,b,c){if(typeof b.getElementsByClassName!="undefined"&&!c)return b.getElementsByClassName(a[1])},a=null}}(),c.documentElement.contains?m.contains=function(a,b){return a!==b&&(a.contains?a.contains(b):!0)}:c.documentElement.compareDocumentPosition?m.contains=function(a,b){return!!(a.compareDocumentPosition(b)&16)}:m.contains=function(){return!1},m.isXML=function(a){var b=(a?a.ownerDocument||a:0).documentElement;return b?b.nodeName!=="HTML":!1};var y=function(a,b,c){var d,e=[],f="",g=b.nodeType?[b]:b;while(d=o.match.PSEUDO.exec(a))f+=d[0],a=a.replace(o.match.PSEUDO,"");a=o.relative[a]?a+"*":a;for(var h=0,i=g.length;h0)for(h=g;h=0:f.filter(a,this).length>0:this.filter(a).length>0)},closest:function(a,b){var c=[],d,e,g=this[0];if(f.isArray(a)){var h=1;while(g&&g.ownerDocument&&g!==b){for(d=0;d-1:f.find.matchesSelector(g,a)){c.push(g);break}g=g.parentNode;if(!g||!g.ownerDocument||g===b||g.nodeType===11)break}}c=c.length>1?f.unique(c):c;return this.pushStack(c,"closest",a)},index:function(a){if(!a)return this[0]&&this[0].parentNode?this.prevAll().length:-1;if(typeof a=="string")return f.inArray(this[0],f(a));return f.inArray(a.jquery?a[0]:a,this)},add:function(a,b){var c=typeof a=="string"?f(a,b):f.makeArray(a&&a.nodeType?[a]:a),d=f.merge(this.get(),c);return this.pushStack(S(c[0])||S(d[0])?d:f.unique(d))},andSelf:function(){return this.add(this.prevObject)}}),f.each({parent:function(a){var b=a.parentNode;return b&&b.nodeType!==11?b:null},parents:function(a){return f.dir(a,"parentNode")},parentsUntil:function(a,b,c){return f.dir(a,"parentNode",c)},next:function(a){return f.nth(a,2,"nextSibling")},prev:function(a){return f.nth(a,2,"previousSibling")},nextAll:function(a){return f.dir(a,"nextSibling")},prevAll:function(a){return f.dir(a,"previousSibling")},nextUntil:function(a,b,c){return f.dir(a,"nextSibling",c)},prevUntil:function(a,b,c){return f.dir(a,"previousSibling",c)},siblings:function(a){return f.sibling((a.parentNode||{}).firstChild,a)},children:function(a){return f.sibling(a.firstChild)},contents:function(a){return f.nodeName(a,"iframe")?a.contentDocument||a.contentWindow.document:f.makeArray(a.childNodes)}},function(a,b){f.fn[a]=function(c,d){var e=f.map(this,b,c);L.test(a)||(d=c),d&&typeof d=="string"&&(e=f.filter(d,e)),e=this.length>1&&!R[a]?f.unique(e):e,(this.length>1||N.test(d))&&M.test(a)&&(e=e.reverse());return this.pushStack(e,a,P.call(arguments).join(","))}}),f.extend({filter:function(a,b,c){c&&(a=":not("+a+")");return b.length===1?f.find.matchesSelector(b[0],a)?[b[0]]:[]:f.find.matches(a,b)},dir:function(a,c,d){var e=[],g=a[c];while(g&&g.nodeType!==9&&(d===b||g.nodeType!==1||!f(g).is(d)))g.nodeType===1&&e.push(g),g=g[c];return e},nth:function(a,b,c,d){b=b||1;var e=0;for(;a;a=a[c])if(a.nodeType===1&&++e===b)break;return a},sibling:function(a,b){var c=[];for(;a;a=a.nextSibling)a.nodeType===1&&a!==b&&c.push(a);return c}});var V="abbr|article|aside|audio|bdi|canvas|data|datalist|details|figcaption|figure|footer|header|hgroup|mark|meter|nav|output|progress|section|summary|time|video",W=/ jQuery\d+="(?:\d+|null)"/g,X=/^\s+/,Y=/<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig,Z=/<([\w:]+)/,$=/]","i"),bd=/checked\s*(?:[^=]|=\s*.checked.)/i,be=/\/(java|ecma)script/i,bf=/^\s*",""],legend:[1,"
    ","
    "],thead:[1,"","
    "],tr:[2,"","
    "],td:[3,"","
    "],col:[2,"","
    "],area:[1,"",""],_default:[0,"",""]},bh=U(c);bg.optgroup=bg.option,bg.tbody=bg.tfoot=bg.colgroup=bg.caption=bg.thead,bg.th=bg.td,f.support.htmlSerialize||(bg._default=[1,"div
    ","
    "]),f.fn.extend({text:function(a){return f.access(this,function(a){return a===b?f.text(this):this.empty().append((this[0]&&this[0].ownerDocument||c).createTextNode(a))},null,a,arguments.length)},wrapAll:function(a){if(f.isFunction(a))return this.each(function(b){f(this).wrapAll(a.call(this,b))});if(this[0]){var b=f(a,this[0].ownerDocument).eq(0).clone(!0);this[0].parentNode&&b.insertBefore(this[0]),b.map(function(){var a=this;while(a.firstChild&&a.firstChild.nodeType===1)a=a.firstChild;return a}).append(this)}return this},wrapInner:function(a){if(f.isFunction(a))return this.each(function(b){f(this).wrapInner(a.call(this,b))});return this.each(function(){var b=f(this),c=b.contents();c.length?c.wrapAll(a):b.append(a)})},wrap:function(a){var b=f.isFunction(a);return this.each(function(c){f(this).wrapAll(b?a.call(this,c):a)})},unwrap:function(){return this.parent().each(function(){f.nodeName(this,"body")||f(this).replaceWith(this.childNodes)}).end()},append:function(){return this.domManip(arguments,!0,function(a){this.nodeType===1&&this.appendChild(a)})},prepend:function(){return this.domManip(arguments,!0,function(a){this.nodeType===1&&this.insertBefore(a,this.firstChild)})},before:function(){if(this[0]&&this[0].parentNode)return this.domManip(arguments,!1,function(a){this.parentNode.insertBefore(a,this)});if(arguments.length){var a=f -.clean(arguments);a.push.apply(a,this.toArray());return this.pushStack(a,"before",arguments)}},after:function(){if(this[0]&&this[0].parentNode)return this.domManip(arguments,!1,function(a){this.parentNode.insertBefore(a,this.nextSibling)});if(arguments.length){var a=this.pushStack(this,"after",arguments);a.push.apply(a,f.clean(arguments));return a}},remove:function(a,b){for(var c=0,d;(d=this[c])!=null;c++)if(!a||f.filter(a,[d]).length)!b&&d.nodeType===1&&(f.cleanData(d.getElementsByTagName("*")),f.cleanData([d])),d.parentNode&&d.parentNode.removeChild(d);return this},empty:function(){for(var a=0,b;(b=this[a])!=null;a++){b.nodeType===1&&f.cleanData(b.getElementsByTagName("*"));while(b.firstChild)b.removeChild(b.firstChild)}return this},clone:function(a,b){a=a==null?!1:a,b=b==null?a:b;return this.map(function(){return f.clone(this,a,b)})},html:function(a){return f.access(this,function(a){var c=this[0]||{},d=0,e=this.length;if(a===b)return c.nodeType===1?c.innerHTML.replace(W,""):null;if(typeof a=="string"&&!ba.test(a)&&(f.support.leadingWhitespace||!X.test(a))&&!bg[(Z.exec(a)||["",""])[1].toLowerCase()]){a=a.replace(Y,"<$1>");try{for(;d1&&l0?this.clone(!0):this).get();f(e[h])[b](j),d=d.concat(j)}return this.pushStack(d,a,e.selector)}}),f.extend({clone:function(a,b,c){var d,e,g,h=f.support.html5Clone||f.isXMLDoc(a)||!bc.test("<"+a.nodeName+">")?a.cloneNode(!0):bo(a);if((!f.support.noCloneEvent||!f.support.noCloneChecked)&&(a.nodeType===1||a.nodeType===11)&&!f.isXMLDoc(a)){bk(a,h),d=bl(a),e=bl(h);for(g=0;d[g];++g)e[g]&&bk(d[g],e[g])}if(b){bj(a,h);if(c){d=bl(a),e=bl(h);for(g=0;d[g];++g)bj(d[g],e[g])}}d=e=null;return h},clean:function(a,b,d,e){var g,h,i,j=[];b=b||c,typeof b.createElement=="undefined"&&(b=b.ownerDocument||b[0]&&b[0].ownerDocument||c);for(var k=0,l;(l=a[k])!=null;k++){typeof l=="number"&&(l+="");if(!l)continue;if(typeof l=="string")if(!_.test(l))l=b.createTextNode(l);else{l=l.replace(Y,"<$1>");var m=(Z.exec(l)||["",""])[1].toLowerCase(),n=bg[m]||bg._default,o=n[0],p=b.createElement("div"),q=bh.childNodes,r;b===c?bh.appendChild(p):U(b).appendChild(p),p.innerHTML=n[1]+l+n[2];while(o--)p=p.lastChild;if(!f.support.tbody){var s=$.test(l),t=m==="table"&&!s?p.firstChild&&p.firstChild.childNodes:n[1]===""&&!s?p.childNodes:[];for(i=t.length-1;i>=0;--i)f.nodeName(t[i],"tbody")&&!t[i].childNodes.length&&t[i].parentNode.removeChild(t[i])}!f.support.leadingWhitespace&&X.test(l)&&p.insertBefore(b.createTextNode(X.exec(l)[0]),p.firstChild),l=p.childNodes,p&&(p.parentNode.removeChild(p),q.length>0&&(r=q[q.length-1],r&&r.parentNode&&r.parentNode.removeChild(r)))}var u;if(!f.support.appendChecked)if(l[0]&&typeof (u=l.length)=="number")for(i=0;i1)},f.extend({cssHooks:{opacity:{get:function(a,b){if(b){var c=by(a,"opacity");return c===""?"1":c}return a.style.opacity}}},cssNumber:{fillOpacity:!0,fontWeight:!0,lineHeight:!0,opacity:!0,orphans:!0,widows:!0,zIndex:!0,zoom:!0},cssProps:{"float":f.support.cssFloat?"cssFloat":"styleFloat"},style:function(a,c,d,e){if(!!a&&a.nodeType!==3&&a.nodeType!==8&&!!a.style){var g,h,i=f.camelCase(c),j=a.style,k=f.cssHooks[i];c=f.cssProps[i]||i;if(d===b){if(k&&"get"in k&&(g=k.get(a,!1,e))!==b)return g;return j[c]}h=typeof d,h==="string"&&(g=bu.exec(d))&&(d=+(g[1]+1)*+g[2]+parseFloat(f.css(a,c)),h="number");if(d==null||h==="number"&&isNaN(d))return;h==="number"&&!f.cssNumber[i]&&(d+="px");if(!k||!("set"in k)||(d=k.set(a,d))!==b)try{j[c]=d}catch(l){}}},css:function(a,c,d){var e,g;c=f.camelCase(c),g=f.cssHooks[c],c=f.cssProps[c]||c,c==="cssFloat"&&(c="float");if(g&&"get"in g&&(e=g.get(a,!0,d))!==b)return e;if(by)return by(a,c)},swap:function(a,b,c){var d={},e,f;for(f in b)d[f]=a.style[f],a.style[f]=b[f];e=c.call(a);for(f in b)a.style[f]=d[f];return e}}),f.curCSS=f.css,c.defaultView&&c.defaultView.getComputedStyle&&(bz=function(a,b){var c,d,e,g,h=a.style;b=b.replace(br,"-$1").toLowerCase(),(d=a.ownerDocument.defaultView)&&(e=d.getComputedStyle(a,null))&&(c=e.getPropertyValue(b),c===""&&!f.contains(a.ownerDocument.documentElement,a)&&(c=f.style(a,b))),!f.support.pixelMargin&&e&&bv.test(b)&&bt.test(c)&&(g=h.width,h.width=c,c=e.width,h.width=g);return c}),c.documentElement.currentStyle&&(bA=function(a,b){var c,d,e,f=a.currentStyle&&a.currentStyle[b],g=a.style;f==null&&g&&(e=g[b])&&(f=e),bt.test(f)&&(c=g.left,d=a.runtimeStyle&&a.runtimeStyle.left,d&&(a.runtimeStyle.left=a.currentStyle.left),g.left=b==="fontSize"?"1em":f,f=g.pixelLeft+"px",g.left=c,d&&(a.runtimeStyle.left=d));return f===""?"auto":f}),by=bz||bA,f.each(["height","width"],function(a,b){f.cssHooks[b]={get:function(a,c,d){if(c)return a.offsetWidth!==0?bB(a,b,d):f.swap(a,bw,function(){return bB(a,b,d)})},set:function(a,b){return bs.test(b)?b+"px":b}}}),f.support.opacity||(f.cssHooks.opacity={get:function(a,b){return bq.test((b&&a.currentStyle?a.currentStyle.filter:a.style.filter)||"")?parseFloat(RegExp.$1)/100+"":b?"1":""},set:function(a,b){var c=a.style,d=a.currentStyle,e=f.isNumeric(b)?"alpha(opacity="+b*100+")":"",g=d&&d.filter||c.filter||"";c.zoom=1;if(b>=1&&f.trim(g.replace(bp,""))===""){c.removeAttribute("filter");if(d&&!d.filter)return}c.filter=bp.test(g)?g.replace(bp,e):g+" "+e}}),f(function(){f.support.reliableMarginRight||(f.cssHooks.marginRight={get:function(a,b){return f.swap(a,{display:"inline-block"},function(){return b?by(a,"margin-right"):a.style.marginRight})}})}),f.expr&&f.expr.filters&&(f.expr.filters.hidden=function(a){var b=a.offsetWidth,c=a.offsetHeight;return b===0&&c===0||!f.support.reliableHiddenOffsets&&(a.style&&a.style.display||f.css(a,"display"))==="none"},f.expr.filters.visible=function(a){return!f.expr.filters.hidden(a)}),f.each({margin:"",padding:"",border:"Width"},function(a,b){f.cssHooks[a+b]={expand:function(c){var d,e=typeof c=="string"?c.split(" "):[c],f={};for(d=0;d<4;d++)f[a+bx[d]+b]=e[d]||e[d-2]||e[0];return f}}});var bC=/%20/g,bD=/\[\]$/,bE=/\r?\n/g,bF=/#.*$/,bG=/^(.*?):[ \t]*([^\r\n]*)\r?$/mg,bH=/^(?:color|date|datetime|datetime-local|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i,bI=/^(?:about|app|app\-storage|.+\-extension|file|res|widget):$/,bJ=/^(?:GET|HEAD)$/,bK=/^\/\//,bL=/\?/,bM=/)<[^<]*)*<\/script>/gi,bN=/^(?:select|textarea)/i,bO=/\s+/,bP=/([?&])_=[^&]*/,bQ=/^([\w\+\.\-]+:)(?:\/\/([^\/?#:]*)(?::(\d+))?)?/,bR=f.fn.load,bS={},bT={},bU,bV,bW=["*/"]+["*"];try{bU=e.href}catch(bX){bU=c.createElement("a"),bU.href="",bU=bU.href}bV=bQ.exec(bU.toLowerCase())||[],f.fn.extend({load:function(a,c,d){if(typeof a!="string"&&bR)return bR.apply(this,arguments);if(!this.length)return this;var e=a.indexOf(" ");if(e>=0){var g=a.slice(e,a.length);a=a.slice(0,e)}var h="GET";c&&(f.isFunction(c)?(d=c,c=b):typeof c=="object"&&(c=f.param(c,f.ajaxSettings.traditional),h="POST"));var i=this;f.ajax({url:a,type:h,dataType:"html",data:c,complete:function(a,b,c){c=a.responseText,a.isResolved()&&(a.done(function(a){c=a}),i.html(g?f("
    ").append(c.replace(bM,"")).find(g):c)),d&&i.each(d,[c,b,a])}});return this},serialize:function(){return f.param(this.serializeArray())},serializeArray:function(){return this.map(function(){return this.elements?f.makeArray(this.elements):this}).filter(function(){return this.name&&!this.disabled&&(this.checked||bN.test(this.nodeName)||bH.test(this.type))}).map(function(a,b){var c=f(this).val();return c==null?null:f.isArray(c)?f.map(c,function(a,c){return{name:b.name,value:a.replace(bE,"\r\n")}}):{name:b.name,value:c.replace(bE,"\r\n")}}).get()}}),f.each("ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split(" "),function(a,b){f.fn[b]=function(a){return this.on(b,a)}}),f.each(["get","post"],function(a,c){f[c]=function(a,d,e,g){f.isFunction(d)&&(g=g||e,e=d,d=b);return f.ajax({type:c,url:a,data:d,success:e,dataType:g})}}),f.extend({getScript:function(a,c){return f.get(a,b,c,"script")},getJSON:function(a,b,c){return f.get(a,b,c,"json")},ajaxSetup:function(a,b){b?b$(a,f.ajaxSettings):(b=a,a=f.ajaxSettings),b$(a,b);return a},ajaxSettings:{url:bU,isLocal:bI.test(bV[1]),global:!0,type:"GET",contentType:"application/x-www-form-urlencoded; charset=UTF-8",processData:!0,async:!0,accepts:{xml:"application/xml, text/xml",html:"text/html",text:"text/plain",json:"application/json, text/javascript","*":bW},contents:{xml:/xml/,html:/html/,json:/json/},responseFields:{xml:"responseXML",text:"responseText"},converters:{"* text":a.String,"text html":!0,"text json":f.parseJSON,"text xml":f.parseXML},flatOptions:{context:!0,url:!0}},ajaxPrefilter:bY(bS),ajaxTransport:bY(bT),ajax:function(a,c){function w(a,c,l,m){if(s!==2){s=2,q&&clearTimeout(q),p=b,n=m||"",v.readyState=a>0?4:0;var o,r,u,w=c,x=l?ca(d,v,l):b,y,z;if(a>=200&&a<300||a===304){if(d.ifModified){if(y=v.getResponseHeader("Last-Modified"))f.lastModified[k]=y;if(z=v.getResponseHeader("Etag"))f.etag[k]=z}if(a===304)w="notmodified",o=!0;else try{r=cb(d,x),w="success",o=!0}catch(A){w="parsererror",u=A}}else{u=w;if(!w||a)w="error",a<0&&(a=0)}v.status=a,v.statusText=""+(c||w),o?h.resolveWith(e,[r,w,v]):h.rejectWith(e,[v,w,u]),v.statusCode(j),j=b,t&&g.trigger("ajax"+(o?"Success":"Error"),[v,d,o?r:u]),i.fireWith(e,[v,w]),t&&(g.trigger("ajaxComplete",[v,d]),--f.active||f.event.trigger("ajaxStop"))}}typeof a=="object"&&(c=a,a=b),c=c||{};var d=f.ajaxSetup({},c),e=d.context||d,g=e!==d&&(e.nodeType||e instanceof f)?f(e):f.event,h=f.Deferred(),i=f.Callbacks("once memory"),j=d.statusCode||{},k,l={},m={},n,o,p,q,r,s=0,t,u,v={readyState:0,setRequestHeader:function(a,b){if(!s){var c=a.toLowerCase();a=m[c]=m[c]||a,l[a]=b}return this},getAllResponseHeaders:function(){return s===2?n:null},getResponseHeader:function(a){var c;if(s===2){if(!o){o={};while(c=bG.exec(n))o[c[1].toLowerCase()]=c[2]}c=o[a.toLowerCase()]}return c===b?null:c},overrideMimeType:function(a){s||(d.mimeType=a);return this},abort:function(a){a=a||"abort",p&&p.abort(a),w(0,a);return this}};h.promise(v),v.success=v.done,v.error=v.fail,v.complete=i.add,v.statusCode=function(a){if(a){var b;if(s<2)for(b in a)j[b]=[j[b],a[b]];else b=a[v.status],v.then(b,b)}return this},d.url=((a||d.url)+"").replace(bF,"").replace(bK,bV[1]+"//"),d.dataTypes=f.trim(d.dataType||"*").toLowerCase().split(bO),d.crossDomain==null&&(r=bQ.exec(d.url.toLowerCase()),d.crossDomain=!(!r||r[1]==bV[1]&&r[2]==bV[2]&&(r[3]||(r[1]==="http:"?80:443))==(bV[3]||(bV[1]==="http:"?80:443)))),d.data&&d.processData&&typeof d.data!="string"&&(d.data=f.param(d.data,d.traditional)),bZ(bS,d,c,v);if(s===2)return!1;t=d.global,d.type=d.type.toUpperCase(),d.hasContent=!bJ.test(d.type),t&&f.active++===0&&f.event.trigger("ajaxStart");if(!d.hasContent){d.data&&(d.url+=(bL.test(d.url)?"&":"?")+d.data,delete d.data),k=d.url;if(d.cache===!1){var x=f.now(),y=d.url.replace(bP,"$1_="+x);d.url=y+(y===d.url?(bL.test(d.url)?"&":"?")+"_="+x:"")}}(d.data&&d.hasContent&&d.contentType!==!1||c.contentType)&&v.setRequestHeader("Content-Type",d.contentType),d.ifModified&&(k=k||d.url,f.lastModified[k]&&v.setRequestHeader("If-Modified-Since",f.lastModified[k]),f.etag[k]&&v.setRequestHeader("If-None-Match",f.etag[k])),v.setRequestHeader("Accept",d.dataTypes[0]&&d.accepts[d.dataTypes[0]]?d.accepts[d.dataTypes[0]]+(d.dataTypes[0]!=="*"?", "+bW+"; q=0.01":""):d.accepts["*"]);for(u in d.headers)v.setRequestHeader(u,d.headers[u]);if(d.beforeSend&&(d.beforeSend.call(e,v,d)===!1||s===2)){v.abort();return!1}for(u in{success:1,error:1,complete:1})v[u](d[u]);p=bZ(bT,d,c,v);if(!p)w(-1,"No Transport");else{v.readyState=1,t&&g.trigger("ajaxSend",[v,d]),d.async&&d.timeout>0&&(q=setTimeout(function(){v.abort("timeout")},d.timeout));try{s=1,p.send(l,w)}catch(z){if(s<2)w(-1,z);else throw z}}return v},param:function(a,c){var d=[],e=function(a,b){b=f.isFunction(b)?b():b,d[d.length]=encodeURIComponent(a)+"="+encodeURIComponent(b)};c===b&&(c=f.ajaxSettings.traditional);if(f.isArray(a)||a.jquery&&!f.isPlainObject(a))f.each(a,function(){e(this.name,this.value)});else for(var g in a)b_(g,a[g],c,e);return d.join("&").replace(bC,"+")}}),f.extend({active:0,lastModified:{},etag:{}});var cc=f.now(),cd=/(\=)\?(&|$)|\?\?/i;f.ajaxSetup({jsonp:"callback",jsonpCallback:function(){return f.expando+"_"+cc++}}),f.ajaxPrefilter("json jsonp",function(b,c,d){var e=typeof b.data=="string"&&/^application\/x\-www\-form\-urlencoded/.test(b.contentType);if(b.dataTypes[0]==="jsonp"||b.jsonp!==!1&&(cd.test(b.url)||e&&cd.test(b.data))){var g,h=b.jsonpCallback=f.isFunction(b.jsonpCallback)?b.jsonpCallback():b.jsonpCallback,i=a[h],j=b.url,k=b.data,l="$1"+h+"$2";b.jsonp!==!1&&(j=j.replace(cd,l),b.url===j&&(e&&(k=k.replace(cd,l)),b.data===k&&(j+=(/\?/.test(j)?"&":"?")+b.jsonp+"="+h))),b.url=j,b.data=k,a[h]=function(a){g=[a]},d.always(function(){a[h]=i,g&&f.isFunction(i)&&a[h](g[0])}),b.converters["script json"]=function(){g||f.error(h+" was not called");return g[0]},b.dataTypes[0]="json";return"script"}}),f.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/javascript|ecmascript/},converters:{"text script":function(a){f.globalEval(a);return a}}}),f.ajaxPrefilter("script",function(a){a.cache===b&&(a.cache=!1),a.crossDomain&&(a.type="GET",a.global=!1)}),f.ajaxTransport("script",function(a){if(a.crossDomain){var d,e=c.head||c.getElementsByTagName("head")[0]||c.documentElement;return{send:function(f,g){d=c.createElement("script"),d.async="async",a.scriptCharset&&(d.charset=a.scriptCharset),d.src=a.url,d.onload=d.onreadystatechange=function(a,c){if(c||!d.readyState||/loaded|complete/.test(d.readyState))d.onload=d.onreadystatechange=null,e&&d.parentNode&&e.removeChild(d),d=b,c||g(200,"success")},e.insertBefore(d,e.firstChild)},abort:function(){d&&d.onload(0,1)}}}});var ce=a.ActiveXObject?function(){for(var a in cg)cg[a](0,1)}:!1,cf=0,cg;f.ajaxSettings.xhr=a.ActiveXObject?function(){return!this.isLocal&&ch()||ci()}:ch,function(a){f.extend(f.support,{ajax:!!a,cors:!!a&&"withCredentials"in a})}(f.ajaxSettings.xhr()),f.support.ajax&&f.ajaxTransport(function(c){if(!c.crossDomain||f.support.cors){var d;return{send:function(e,g){var h=c.xhr(),i,j;c.username?h.open(c.type,c.url,c.async,c.username,c.password):h.open(c.type,c.url,c.async);if(c.xhrFields)for(j in c.xhrFields)h[j]=c.xhrFields[j];c.mimeType&&h.overrideMimeType&&h.overrideMimeType(c.mimeType),!c.crossDomain&&!e["X-Requested-With"]&&(e["X-Requested-With"]="XMLHttpRequest");try{for(j in e)h.setRequestHeader(j,e[j])}catch(k){}h.send(c.hasContent&&c.data||null),d=function(a,e){var j,k,l,m,n;try{if(d&&(e||h.readyState===4)){d=b,i&&(h.onreadystatechange=f.noop,ce&&delete cg[i]);if(e)h.readyState!==4&&h.abort();else{j=h.status,l=h.getAllResponseHeaders(),m={},n=h.responseXML,n&&n.documentElement&&(m.xml=n);try{m.text=h.responseText}catch(a){}try{k=h.statusText}catch(o){k=""}!j&&c.isLocal&&!c.crossDomain?j=m.text?200:404:j===1223&&(j=204)}}}catch(p){e||g(-1,p)}m&&g(j,k,m,l)},!c.async||h.readyState===4?d():(i=++cf,ce&&(cg||(cg={},f(a).unload(ce)),cg[i]=d),h.onreadystatechange=d)},abort:function(){d&&d(0,1)}}}});var cj={},ck,cl,cm=/^(?:toggle|show|hide)$/,cn=/^([+\-]=)?([\d+.\-]+)([a-z%]*)$/i,co,cp=[["height","marginTop","marginBottom","paddingTop","paddingBottom"],["width","marginLeft","marginRight","paddingLeft","paddingRight"],["opacity"]],cq;f.fn.extend({show:function(a,b,c){var d,e;if(a||a===0)return this.animate(ct("show",3),a,b,c);for(var g=0,h=this.length;g=i.duration+this.startTime){this.now=this.end,this.pos=this.state=1,this.update(),i.animatedProperties[this.prop]=!0;for(b in i.animatedProperties)i.animatedProperties[b]!==!0&&(g=!1);if(g){i.overflow!=null&&!f.support.shrinkWrapBlocks&&f.each(["","X","Y"],function(a,b){h.style["overflow"+b]=i.overflow[a]}),i.hide&&f(h).hide();if(i.hide||i.show)for(b in i.animatedProperties)f.style(h,b,i.orig[b]),f.removeData(h,"fxshow"+b,!0),f.removeData(h,"toggle"+b,!0);d=i.complete,d&&(i.complete=!1,d.call(h))}return!1}i.duration==Infinity?this.now=e:(c=e-this.startTime,this.state=c/i.duration,this.pos=f.easing[i.animatedProperties[this.prop]](this.state,c,0,1,i.duration),this.now=this.start+(this.end-this.start)*this.pos),this.update();return!0}},f.extend(f.fx,{tick:function(){var a,b=f.timers,c=0;for(;c-1,k={},l={},m,n;j?(l=e.position(),m=l.top,n=l.left):(m=parseFloat(h)||0,n=parseFloat(i)||0),f.isFunction(b)&&(b=b.call(a,c,g)),b.top!=null&&(k.top=b.top-g.top+m),b.left!=null&&(k.left=b.left-g.left+n),"using"in b?b.using.call(a,k):e.css(k)}},f.fn.extend({position:function(){if(!this[0])return null;var a=this[0],b=this.offsetParent(),c=this.offset(),d=cx.test(b[0].nodeName)?{top:0,left:0}:b.offset();c.top-=parseFloat(f.css(a,"marginTop"))||0,c.left-=parseFloat(f.css(a,"marginLeft"))||0,d.top+=parseFloat(f.css(b[0],"borderTopWidth"))||0,d.left+=parseFloat(f.css(b[0],"borderLeftWidth"))||0;return{top:c.top-d.top,left:c.left-d.left}},offsetParent:function(){return this.map(function(){var a=this.offsetParent||c.body;while(a&&!cx.test(a.nodeName)&&f.css(a,"position")==="static")a=a.offsetParent;return a})}}),f.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(a,c){var d=/Y/.test(c);f.fn[a]=function(e){return f.access(this,function(a,e,g){var h=cy(a);if(g===b)return h?c in h?h[c]:f.support.boxModel&&h.document.documentElement[e]||h.document.body[e]:a[e];h?h.scrollTo(d?f(h).scrollLeft():g,d?g:f(h).scrollTop()):a[e]=g},a,e,arguments.length,null)}}),f.each({Height:"height",Width:"width"},function(a,c){var d="client"+a,e="scroll"+a,g="offset"+a;f.fn["inner"+a]=function(){var a=this[0];return a?a.style?parseFloat(f.css(a,c,"padding")):this[c]():null},f.fn["outer"+a]=function(a){var b=this[0];return b?b.style?parseFloat(f.css(b,c,a?"margin":"border")):this[c]():null},f.fn[c]=function(a){return f.access(this,function(a,c,h){var i,j,k,l;if(f.isWindow(a)){i=a.document,j=i.documentElement[d];return f.support.boxModel&&j||i.body&&i.body[d]||j}if(a.nodeType===9){i=a.documentElement;if(i[d]>=i[e])return i[d];return Math.max(a.body[e],i[e],a.body[g],i[g])}if(h===b){k=f.css(a,c),l=parseFloat(k);return f.isNumeric(l)?l:k}f(a).css(c,h)},c,a,arguments.length,null)}}),a.jQuery=a.$=f,typeof define=="function"&&define.amd&&define.amd.jQuery&&define("jquery",[],function(){return f})})(window); +/*! + * jQuery JavaScript Library v1.9.1 + * http://jquery.com/ + * + * Includes Sizzle.js + * http://sizzlejs.com/ + * + * Copyright 2005, 2012 jQuery Foundation, Inc. and other contributors + * Released under the MIT license + * http://jquery.org/license + * + * Date: 2013-2-4 + */ +(function( window, undefined ) { + +// Can't do this because several apps including ASP.NET trace +// the stack via arguments.caller.callee and Firefox dies if +// you try to trace through "use strict" call chains. (#13335) +// Support: Firefox 18+ +//"use strict"; +var + // The deferred used on DOM ready + readyList, + + // A central reference to the root jQuery(document) + rootjQuery, + + // Support: IE<9 + // For `typeof node.method` instead of `node.method !== undefined` + core_strundefined = typeof undefined, + + // Use the correct document accordingly with window argument (sandbox) + document = window.document, + location = window.location, + + // Map over jQuery in case of overwrite + _jQuery = window.jQuery, + + // Map over the $ in case of overwrite + _$ = window.$, + + // [[Class]] -> type pairs + class2type = {}, + + // List of deleted data cache ids, so we can reuse them + core_deletedIds = [], + + core_version = "1.9.1", + + // Save a reference to some core methods + core_concat = core_deletedIds.concat, + core_push = core_deletedIds.push, + core_slice = core_deletedIds.slice, + core_indexOf = core_deletedIds.indexOf, + core_toString = class2type.toString, + core_hasOwn = class2type.hasOwnProperty, + core_trim = core_version.trim, + + // Define a local copy of jQuery + jQuery = function( selector, context ) { + // The jQuery object is actually just the init constructor 'enhanced' + return new jQuery.fn.init( selector, context, rootjQuery ); + }, + + // Used for matching numbers + core_pnum = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source, + + // Used for splitting on whitespace + core_rnotwhite = /\S+/g, + + // Make sure we trim BOM and NBSP (here's looking at you, Safari 5.0 and IE) + rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, + + // A simple way to check for HTML strings + // Prioritize #id over to avoid XSS via location.hash (#9521) + // Strict HTML recognition (#11290: must start with <) + rquickExpr = /^(?:(<[\w\W]+>)[^>]*|#([\w-]*))$/, + + // Match a standalone tag + rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>|)$/, + + // JSON RegExp + rvalidchars = /^[\],:{}\s]*$/, + rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g, + rvalidescape = /\\(?:["\\\/bfnrt]|u[\da-fA-F]{4})/g, + rvalidtokens = /"[^"\\\r\n]*"|true|false|null|-?(?:\d+\.|)\d+(?:[eE][+-]?\d+|)/g, + + // Matches dashed string for camelizing + rmsPrefix = /^-ms-/, + rdashAlpha = /-([\da-z])/gi, + + // Used by jQuery.camelCase as callback to replace() + fcamelCase = function( all, letter ) { + return letter.toUpperCase(); + }, + + // The ready event handler + completed = function( event ) { + + // readyState === "complete" is good enough for us to call the dom ready in oldIE + if ( document.addEventListener || event.type === "load" || document.readyState === "complete" ) { + detach(); + jQuery.ready(); + } + }, + // Clean-up method for dom ready events + detach = function() { + if ( document.addEventListener ) { + document.removeEventListener( "DOMContentLoaded", completed, false ); + window.removeEventListener( "load", completed, false ); + + } else { + document.detachEvent( "onreadystatechange", completed ); + window.detachEvent( "onload", completed ); + } + }; + +jQuery.fn = jQuery.prototype = { + // The current version of jQuery being used + jquery: core_version, + + constructor: jQuery, + init: function( selector, context, rootjQuery ) { + var match, elem; + + // HANDLE: $(""), $(null), $(undefined), $(false) + if ( !selector ) { + return this; + } + + // Handle HTML strings + if ( typeof selector === "string" ) { + if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) { + // Assume that strings that start and end with <> are HTML and skip the regex check + match = [ null, selector, null ]; + + } else { + match = rquickExpr.exec( selector ); + } + + // Match html or make sure no context is specified for #id + if ( match && (match[1] || !context) ) { + + // HANDLE: $(html) -> $(array) + if ( match[1] ) { + context = context instanceof jQuery ? context[0] : context; + + // scripts is true for back-compat + jQuery.merge( this, jQuery.parseHTML( + match[1], + context && context.nodeType ? context.ownerDocument || context : document, + true + ) ); + + // HANDLE: $(html, props) + if ( rsingleTag.test( match[1] ) && jQuery.isPlainObject( context ) ) { + for ( match in context ) { + // Properties of context are called as methods if possible + if ( jQuery.isFunction( this[ match ] ) ) { + this[ match ]( context[ match ] ); + + // ...and otherwise set as attributes + } else { + this.attr( match, context[ match ] ); + } + } + } + + return this; + + // HANDLE: $(#id) + } else { + elem = document.getElementById( match[2] ); + + // Check parentNode to catch when Blackberry 4.6 returns + // nodes that are no longer in the document #6963 + if ( elem && elem.parentNode ) { + // Handle the case where IE and Opera return items + // by name instead of ID + if ( elem.id !== match[2] ) { + return rootjQuery.find( selector ); + } + + // Otherwise, we inject the element directly into the jQuery object + this.length = 1; + this[0] = elem; + } + + this.context = document; + this.selector = selector; + return this; + } + + // HANDLE: $(expr, $(...)) + } else if ( !context || context.jquery ) { + return ( context || rootjQuery ).find( selector ); + + // HANDLE: $(expr, context) + // (which is just equivalent to: $(context).find(expr) + } else { + return this.constructor( context ).find( selector ); + } + + // HANDLE: $(DOMElement) + } else if ( selector.nodeType ) { + this.context = this[0] = selector; + this.length = 1; + return this; + + // HANDLE: $(function) + // Shortcut for document ready + } else if ( jQuery.isFunction( selector ) ) { + return rootjQuery.ready( selector ); + } + + if ( selector.selector !== undefined ) { + this.selector = selector.selector; + this.context = selector.context; + } + + return jQuery.makeArray( selector, this ); + }, + + // Start with an empty selector + selector: "", + + // The default length of a jQuery object is 0 + length: 0, + + // The number of elements contained in the matched element set + size: function() { + return this.length; + }, + + toArray: function() { + return core_slice.call( this ); + }, + + // Get the Nth element in the matched element set OR + // Get the whole matched element set as a clean array + get: function( num ) { + return num == null ? + + // Return a 'clean' array + this.toArray() : + + // Return just the object + ( num < 0 ? this[ this.length + num ] : this[ num ] ); + }, + + // Take an array of elements and push it onto the stack + // (returning the new matched element set) + pushStack: function( elems ) { + + // Build a new jQuery matched element set + var ret = jQuery.merge( this.constructor(), elems ); + + // Add the old object onto the stack (as a reference) + ret.prevObject = this; + ret.context = this.context; + + // Return the newly-formed element set + return ret; + }, + + // Execute a callback for every element in the matched set. + // (You can seed the arguments with an array of args, but this is + // only used internally.) + each: function( callback, args ) { + return jQuery.each( this, callback, args ); + }, + + ready: function( fn ) { + // Add the callback + jQuery.ready.promise().done( fn ); + + return this; + }, + + slice: function() { + return this.pushStack( core_slice.apply( this, arguments ) ); + }, + + first: function() { + return this.eq( 0 ); + }, + + last: function() { + return this.eq( -1 ); + }, + + eq: function( i ) { + var len = this.length, + j = +i + ( i < 0 ? len : 0 ); + return this.pushStack( j >= 0 && j < len ? [ this[j] ] : [] ); + }, + + map: function( callback ) { + return this.pushStack( jQuery.map(this, function( elem, i ) { + return callback.call( elem, i, elem ); + })); + }, + + end: function() { + return this.prevObject || this.constructor(null); + }, + + // For internal use only. + // Behaves like an Array's method, not like a jQuery method. + push: core_push, + sort: [].sort, + splice: [].splice +}; + +// Give the init function the jQuery prototype for later instantiation +jQuery.fn.init.prototype = jQuery.fn; + +jQuery.extend = jQuery.fn.extend = function() { + var src, copyIsArray, copy, name, options, clone, + target = arguments[0] || {}, + i = 1, + length = arguments.length, + deep = false; + + // Handle a deep copy situation + if ( typeof target === "boolean" ) { + deep = target; + target = arguments[1] || {}; + // skip the boolean and the target + i = 2; + } + + // Handle case when target is a string or something (possible in deep copy) + if ( typeof target !== "object" && !jQuery.isFunction(target) ) { + target = {}; + } + + // extend jQuery itself if only one argument is passed + if ( length === i ) { + target = this; + --i; + } + + for ( ; i < length; i++ ) { + // Only deal with non-null/undefined values + if ( (options = arguments[ i ]) != null ) { + // Extend the base object + for ( name in options ) { + src = target[ name ]; + copy = options[ name ]; + + // Prevent never-ending loop + if ( target === copy ) { + continue; + } + + // Recurse if we're merging plain objects or arrays + if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) { + if ( copyIsArray ) { + copyIsArray = false; + clone = src && jQuery.isArray(src) ? src : []; + + } else { + clone = src && jQuery.isPlainObject(src) ? src : {}; + } + + // Never move original objects, clone them + target[ name ] = jQuery.extend( deep, clone, copy ); + + // Don't bring in undefined values + } else if ( copy !== undefined ) { + target[ name ] = copy; + } + } + } + } + + // Return the modified object + return target; +}; + +jQuery.extend({ + noConflict: function( deep ) { + if ( window.$ === jQuery ) { + window.$ = _$; + } + + if ( deep && window.jQuery === jQuery ) { + window.jQuery = _jQuery; + } + + return jQuery; + }, + + // Is the DOM ready to be used? Set to true once it occurs. + isReady: false, + + // A counter to track how many items to wait for before + // the ready event fires. See #6781 + readyWait: 1, + + // Hold (or release) the ready event + holdReady: function( hold ) { + if ( hold ) { + jQuery.readyWait++; + } else { + jQuery.ready( true ); + } + }, + + // Handle when the DOM is ready + ready: function( wait ) { + + // Abort if there are pending holds or we're already ready + if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) { + return; + } + + // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443). + if ( !document.body ) { + return setTimeout( jQuery.ready ); + } + + // Remember that the DOM is ready + jQuery.isReady = true; + + // If a normal DOM Ready event fired, decrement, and wait if need be + if ( wait !== true && --jQuery.readyWait > 0 ) { + return; + } + + // If there are functions bound, to execute + readyList.resolveWith( document, [ jQuery ] ); + + // Trigger any bound ready events + if ( jQuery.fn.trigger ) { + jQuery( document ).trigger("ready").off("ready"); + } + }, + + // See test/unit/core.js for details concerning isFunction. + // Since version 1.3, DOM methods and functions like alert + // aren't supported. They return false on IE (#2968). + isFunction: function( obj ) { + return jQuery.type(obj) === "function"; + }, + + isArray: Array.isArray || function( obj ) { + return jQuery.type(obj) === "array"; + }, + + isWindow: function( obj ) { + return obj != null && obj == obj.window; + }, + + isNumeric: function( obj ) { + return !isNaN( parseFloat(obj) ) && isFinite( obj ); + }, + + type: function( obj ) { + if ( obj == null ) { + return String( obj ); + } + return typeof obj === "object" || typeof obj === "function" ? + class2type[ core_toString.call(obj) ] || "object" : + typeof obj; + }, + + isPlainObject: function( obj ) { + // Must be an Object. + // Because of IE, we also have to check the presence of the constructor property. + // Make sure that DOM nodes and window objects don't pass through, as well + if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) { + return false; + } + + try { + // Not own constructor property must be Object + if ( obj.constructor && + !core_hasOwn.call(obj, "constructor") && + !core_hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) { + return false; + } + } catch ( e ) { + // IE8,9 Will throw exceptions on certain host objects #9897 + return false; + } + + // Own properties are enumerated firstly, so to speed up, + // if last one is own, then all properties are own. + + var key; + for ( key in obj ) {} + + return key === undefined || core_hasOwn.call( obj, key ); + }, + + isEmptyObject: function( obj ) { + var name; + for ( name in obj ) { + return false; + } + return true; + }, + + error: function( msg ) { + throw new Error( msg ); + }, + + // data: string of html + // context (optional): If specified, the fragment will be created in this context, defaults to document + // keepScripts (optional): If true, will include scripts passed in the html string + parseHTML: function( data, context, keepScripts ) { + if ( !data || typeof data !== "string" ) { + return null; + } + if ( typeof context === "boolean" ) { + keepScripts = context; + context = false; + } + context = context || document; + + var parsed = rsingleTag.exec( data ), + scripts = !keepScripts && []; + + // Single tag + if ( parsed ) { + return [ context.createElement( parsed[1] ) ]; + } + + parsed = jQuery.buildFragment( [ data ], context, scripts ); + if ( scripts ) { + jQuery( scripts ).remove(); + } + return jQuery.merge( [], parsed.childNodes ); + }, + + parseJSON: function( data ) { + // Attempt to parse using the native JSON parser first + if ( window.JSON && window.JSON.parse ) { + return window.JSON.parse( data ); + } + + if ( data === null ) { + return data; + } + + if ( typeof data === "string" ) { + + // Make sure leading/trailing whitespace is removed (IE can't handle it) + data = jQuery.trim( data ); + + if ( data ) { + // Make sure the incoming data is actual JSON + // Logic borrowed from http://json.org/json2.js + if ( rvalidchars.test( data.replace( rvalidescape, "@" ) + .replace( rvalidtokens, "]" ) + .replace( rvalidbraces, "")) ) { + + return ( new Function( "return " + data ) )(); + } + } + } + + jQuery.error( "Invalid JSON: " + data ); + }, + + // Cross-browser xml parsing + parseXML: function( data ) { + var xml, tmp; + if ( !data || typeof data !== "string" ) { + return null; + } + try { + if ( window.DOMParser ) { // Standard + tmp = new DOMParser(); + xml = tmp.parseFromString( data , "text/xml" ); + } else { // IE + xml = new ActiveXObject( "Microsoft.XMLDOM" ); + xml.async = "false"; + xml.loadXML( data ); + } + } catch( e ) { + xml = undefined; + } + if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) { + jQuery.error( "Invalid XML: " + data ); + } + return xml; + }, + + noop: function() {}, + + // Evaluates a script in a global context + // Workarounds based on findings by Jim Driscoll + // http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context + globalEval: function( data ) { + if ( data && jQuery.trim( data ) ) { + // We use execScript on Internet Explorer + // We use an anonymous function so that context is window + // rather than jQuery in Firefox + ( window.execScript || function( data ) { + window[ "eval" ].call( window, data ); + } )( data ); + } + }, + + // Convert dashed to camelCase; used by the css and data modules + // Microsoft forgot to hump their vendor prefix (#9572) + camelCase: function( string ) { + return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase ); + }, + + nodeName: function( elem, name ) { + return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase(); + }, + + // args is for internal usage only + each: function( obj, callback, args ) { + var value, + i = 0, + length = obj.length, + isArray = isArraylike( obj ); + + if ( args ) { + if ( isArray ) { + for ( ; i < length; i++ ) { + value = callback.apply( obj[ i ], args ); + + if ( value === false ) { + break; + } + } + } else { + for ( i in obj ) { + value = callback.apply( obj[ i ], args ); + + if ( value === false ) { + break; + } + } + } + + // A special, fast, case for the most common use of each + } else { + if ( isArray ) { + for ( ; i < length; i++ ) { + value = callback.call( obj[ i ], i, obj[ i ] ); + + if ( value === false ) { + break; + } + } + } else { + for ( i in obj ) { + value = callback.call( obj[ i ], i, obj[ i ] ); + + if ( value === false ) { + break; + } + } + } + } + + return obj; + }, + + // Use native String.trim function wherever possible + trim: core_trim && !core_trim.call("\uFEFF\xA0") ? + function( text ) { + return text == null ? + "" : + core_trim.call( text ); + } : + + // Otherwise use our own trimming functionality + function( text ) { + return text == null ? + "" : + ( text + "" ).replace( rtrim, "" ); + }, + + // results is for internal usage only + makeArray: function( arr, results ) { + var ret = results || []; + + if ( arr != null ) { + if ( isArraylike( Object(arr) ) ) { + jQuery.merge( ret, + typeof arr === "string" ? + [ arr ] : arr + ); + } else { + core_push.call( ret, arr ); + } + } + + return ret; + }, + + inArray: function( elem, arr, i ) { + var len; + + if ( arr ) { + if ( core_indexOf ) { + return core_indexOf.call( arr, elem, i ); + } + + len = arr.length; + i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0; + + for ( ; i < len; i++ ) { + // Skip accessing in sparse arrays + if ( i in arr && arr[ i ] === elem ) { + return i; + } + } + } + + return -1; + }, + + merge: function( first, second ) { + var l = second.length, + i = first.length, + j = 0; + + if ( typeof l === "number" ) { + for ( ; j < l; j++ ) { + first[ i++ ] = second[ j ]; + } + } else { + while ( second[j] !== undefined ) { + first[ i++ ] = second[ j++ ]; + } + } + + first.length = i; + + return first; + }, + + grep: function( elems, callback, inv ) { + var retVal, + ret = [], + i = 0, + length = elems.length; + inv = !!inv; + + // Go through the array, only saving the items + // that pass the validator function + for ( ; i < length; i++ ) { + retVal = !!callback( elems[ i ], i ); + if ( inv !== retVal ) { + ret.push( elems[ i ] ); + } + } + + return ret; + }, + + // arg is for internal usage only + map: function( elems, callback, arg ) { + var value, + i = 0, + length = elems.length, + isArray = isArraylike( elems ), + ret = []; + + // Go through the array, translating each of the items to their + if ( isArray ) { + for ( ; i < length; i++ ) { + value = callback( elems[ i ], i, arg ); + + if ( value != null ) { + ret[ ret.length ] = value; + } + } + + // Go through every key on the object, + } else { + for ( i in elems ) { + value = callback( elems[ i ], i, arg ); + + if ( value != null ) { + ret[ ret.length ] = value; + } + } + } + + // Flatten any nested arrays + return core_concat.apply( [], ret ); + }, + + // A global GUID counter for objects + guid: 1, + + // Bind a function to a context, optionally partially applying any + // arguments. + proxy: function( fn, context ) { + var args, proxy, tmp; + + if ( typeof context === "string" ) { + tmp = fn[ context ]; + context = fn; + fn = tmp; + } + + // Quick check to determine if target is callable, in the spec + // this throws a TypeError, but we will just return undefined. + if ( !jQuery.isFunction( fn ) ) { + return undefined; + } + + // Simulated bind + args = core_slice.call( arguments, 2 ); + proxy = function() { + return fn.apply( context || this, args.concat( core_slice.call( arguments ) ) ); + }; + + // Set the guid of unique handler to the same of original handler, so it can be removed + proxy.guid = fn.guid = fn.guid || jQuery.guid++; + + return proxy; + }, + + // Multifunctional method to get and set values of a collection + // The value/s can optionally be executed if it's a function + access: function( elems, fn, key, value, chainable, emptyGet, raw ) { + var i = 0, + length = elems.length, + bulk = key == null; + + // Sets many values + if ( jQuery.type( key ) === "object" ) { + chainable = true; + for ( i in key ) { + jQuery.access( elems, fn, i, key[i], true, emptyGet, raw ); + } + + // Sets one value + } else if ( value !== undefined ) { + chainable = true; + + if ( !jQuery.isFunction( value ) ) { + raw = true; + } + + if ( bulk ) { + // Bulk operations run against the entire set + if ( raw ) { + fn.call( elems, value ); + fn = null; + + // ...except when executing function values + } else { + bulk = fn; + fn = function( elem, key, value ) { + return bulk.call( jQuery( elem ), value ); + }; + } + } + + if ( fn ) { + for ( ; i < length; i++ ) { + fn( elems[i], key, raw ? value : value.call( elems[i], i, fn( elems[i], key ) ) ); + } + } + } + + return chainable ? + elems : + + // Gets + bulk ? + fn.call( elems ) : + length ? fn( elems[0], key ) : emptyGet; + }, + + now: function() { + return ( new Date() ).getTime(); + } +}); + +jQuery.ready.promise = function( obj ) { + if ( !readyList ) { + + readyList = jQuery.Deferred(); + + // Catch cases where $(document).ready() is called after the browser event has already occurred. + // we once tried to use readyState "interactive" here, but it caused issues like the one + // discovered by ChrisS here: http://bugs.jquery.com/ticket/12282#comment:15 + if ( document.readyState === "complete" ) { + // Handle it asynchronously to allow scripts the opportunity to delay ready + setTimeout( jQuery.ready ); + + // Standards-based browsers support DOMContentLoaded + } else if ( document.addEventListener ) { + // Use the handy event callback + document.addEventListener( "DOMContentLoaded", completed, false ); + + // A fallback to window.onload, that will always work + window.addEventListener( "load", completed, false ); + + // If IE event model is used + } else { + // Ensure firing before onload, maybe late but safe also for iframes + document.attachEvent( "onreadystatechange", completed ); + + // A fallback to window.onload, that will always work + window.attachEvent( "onload", completed ); + + // If IE and not a frame + // continually check to see if the document is ready + var top = false; + + try { + top = window.frameElement == null && document.documentElement; + } catch(e) {} + + if ( top && top.doScroll ) { + (function doScrollCheck() { + if ( !jQuery.isReady ) { + + try { + // Use the trick by Diego Perini + // http://javascript.nwbox.com/IEContentLoaded/ + top.doScroll("left"); + } catch(e) { + return setTimeout( doScrollCheck, 50 ); + } + + // detach all dom ready events + detach(); + + // and execute any waiting functions + jQuery.ready(); + } + })(); + } + } + } + return readyList.promise( obj ); +}; + +// Populate the class2type map +jQuery.each("Boolean Number String Function Array Date RegExp Object Error".split(" "), function(i, name) { + class2type[ "[object " + name + "]" ] = name.toLowerCase(); +}); + +function isArraylike( obj ) { + var length = obj.length, + type = jQuery.type( obj ); + + if ( jQuery.isWindow( obj ) ) { + return false; + } + + if ( obj.nodeType === 1 && length ) { + return true; + } + + return type === "array" || type !== "function" && + ( length === 0 || + typeof length === "number" && length > 0 && ( length - 1 ) in obj ); +} + +// All jQuery objects should point back to these +rootjQuery = jQuery(document); +// String to Object options format cache +var optionsCache = {}; + +// Convert String-formatted options into Object-formatted ones and store in cache +function createOptions( options ) { + var object = optionsCache[ options ] = {}; + jQuery.each( options.match( core_rnotwhite ) || [], function( _, flag ) { + object[ flag ] = true; + }); + return object; +} + +/* + * Create a callback list using the following parameters: + * + * options: an optional list of space-separated options that will change how + * the callback list behaves or a more traditional option object + * + * By default a callback list will act like an event callback list and can be + * "fired" multiple times. + * + * Possible options: + * + * once: will ensure the callback list can only be fired once (like a Deferred) + * + * memory: will keep track of previous values and will call any callback added + * after the list has been fired right away with the latest "memorized" + * values (like a Deferred) + * + * unique: will ensure a callback can only be added once (no duplicate in the list) + * + * stopOnFalse: interrupt callings when a callback returns false + * + */ +jQuery.Callbacks = function( options ) { + + // Convert options from String-formatted to Object-formatted if needed + // (we check in cache first) + options = typeof options === "string" ? + ( optionsCache[ options ] || createOptions( options ) ) : + jQuery.extend( {}, options ); + + var // Flag to know if list is currently firing + firing, + // Last fire value (for non-forgettable lists) + memory, + // Flag to know if list was already fired + fired, + // End of the loop when firing + firingLength, + // Index of currently firing callback (modified by remove if needed) + firingIndex, + // First callback to fire (used internally by add and fireWith) + firingStart, + // Actual callback list + list = [], + // Stack of fire calls for repeatable lists + stack = !options.once && [], + // Fire callbacks + fire = function( data ) { + memory = options.memory && data; + fired = true; + firingIndex = firingStart || 0; + firingStart = 0; + firingLength = list.length; + firing = true; + for ( ; list && firingIndex < firingLength; firingIndex++ ) { + if ( list[ firingIndex ].apply( data[ 0 ], data[ 1 ] ) === false && options.stopOnFalse ) { + memory = false; // To prevent further calls using add + break; + } + } + firing = false; + if ( list ) { + if ( stack ) { + if ( stack.length ) { + fire( stack.shift() ); + } + } else if ( memory ) { + list = []; + } else { + self.disable(); + } + } + }, + // Actual Callbacks object + self = { + // Add a callback or a collection of callbacks to the list + add: function() { + if ( list ) { + // First, we save the current length + var start = list.length; + (function add( args ) { + jQuery.each( args, function( _, arg ) { + var type = jQuery.type( arg ); + if ( type === "function" ) { + if ( !options.unique || !self.has( arg ) ) { + list.push( arg ); + } + } else if ( arg && arg.length && type !== "string" ) { + // Inspect recursively + add( arg ); + } + }); + })( arguments ); + // Do we need to add the callbacks to the + // current firing batch? + if ( firing ) { + firingLength = list.length; + // With memory, if we're not firing then + // we should call right away + } else if ( memory ) { + firingStart = start; + fire( memory ); + } + } + return this; + }, + // Remove a callback from the list + remove: function() { + if ( list ) { + jQuery.each( arguments, function( _, arg ) { + var index; + while( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) { + list.splice( index, 1 ); + // Handle firing indexes + if ( firing ) { + if ( index <= firingLength ) { + firingLength--; + } + if ( index <= firingIndex ) { + firingIndex--; + } + } + } + }); + } + return this; + }, + // Check if a given callback is in the list. + // If no argument is given, return whether or not list has callbacks attached. + has: function( fn ) { + return fn ? jQuery.inArray( fn, list ) > -1 : !!( list && list.length ); + }, + // Remove all callbacks from the list + empty: function() { + list = []; + return this; + }, + // Have the list do nothing anymore + disable: function() { + list = stack = memory = undefined; + return this; + }, + // Is it disabled? + disabled: function() { + return !list; + }, + // Lock the list in its current state + lock: function() { + stack = undefined; + if ( !memory ) { + self.disable(); + } + return this; + }, + // Is it locked? + locked: function() { + return !stack; + }, + // Call all callbacks with the given context and arguments + fireWith: function( context, args ) { + args = args || []; + args = [ context, args.slice ? args.slice() : args ]; + if ( list && ( !fired || stack ) ) { + if ( firing ) { + stack.push( args ); + } else { + fire( args ); + } + } + return this; + }, + // Call all the callbacks with the given arguments + fire: function() { + self.fireWith( this, arguments ); + return this; + }, + // To know if the callbacks have already been called at least once + fired: function() { + return !!fired; + } + }; + + return self; +}; +jQuery.extend({ + + Deferred: function( func ) { + var tuples = [ + // action, add listener, listener list, final state + [ "resolve", "done", jQuery.Callbacks("once memory"), "resolved" ], + [ "reject", "fail", jQuery.Callbacks("once memory"), "rejected" ], + [ "notify", "progress", jQuery.Callbacks("memory") ] + ], + state = "pending", + promise = { + state: function() { + return state; + }, + always: function() { + deferred.done( arguments ).fail( arguments ); + return this; + }, + then: function( /* fnDone, fnFail, fnProgress */ ) { + var fns = arguments; + return jQuery.Deferred(function( newDefer ) { + jQuery.each( tuples, function( i, tuple ) { + var action = tuple[ 0 ], + fn = jQuery.isFunction( fns[ i ] ) && fns[ i ]; + // deferred[ done | fail | progress ] for forwarding actions to newDefer + deferred[ tuple[1] ](function() { + var returned = fn && fn.apply( this, arguments ); + if ( returned && jQuery.isFunction( returned.promise ) ) { + returned.promise() + .done( newDefer.resolve ) + .fail( newDefer.reject ) + .progress( newDefer.notify ); + } else { + newDefer[ action + "With" ]( this === promise ? newDefer.promise() : this, fn ? [ returned ] : arguments ); + } + }); + }); + fns = null; + }).promise(); + }, + // Get a promise for this deferred + // If obj is provided, the promise aspect is added to the object + promise: function( obj ) { + return obj != null ? jQuery.extend( obj, promise ) : promise; + } + }, + deferred = {}; + + // Keep pipe for back-compat + promise.pipe = promise.then; + + // Add list-specific methods + jQuery.each( tuples, function( i, tuple ) { + var list = tuple[ 2 ], + stateString = tuple[ 3 ]; + + // promise[ done | fail | progress ] = list.add + promise[ tuple[1] ] = list.add; + + // Handle state + if ( stateString ) { + list.add(function() { + // state = [ resolved | rejected ] + state = stateString; + + // [ reject_list | resolve_list ].disable; progress_list.lock + }, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock ); + } + + // deferred[ resolve | reject | notify ] + deferred[ tuple[0] ] = function() { + deferred[ tuple[0] + "With" ]( this === deferred ? promise : this, arguments ); + return this; + }; + deferred[ tuple[0] + "With" ] = list.fireWith; + }); + + // Make the deferred a promise + promise.promise( deferred ); + + // Call given func if any + if ( func ) { + func.call( deferred, deferred ); + } + + // All done! + return deferred; + }, + + // Deferred helper + when: function( subordinate /* , ..., subordinateN */ ) { + var i = 0, + resolveValues = core_slice.call( arguments ), + length = resolveValues.length, + + // the count of uncompleted subordinates + remaining = length !== 1 || ( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0, + + // the master Deferred. If resolveValues consist of only a single Deferred, just use that. + deferred = remaining === 1 ? subordinate : jQuery.Deferred(), + + // Update function for both resolve and progress values + updateFunc = function( i, contexts, values ) { + return function( value ) { + contexts[ i ] = this; + values[ i ] = arguments.length > 1 ? core_slice.call( arguments ) : value; + if( values === progressValues ) { + deferred.notifyWith( contexts, values ); + } else if ( !( --remaining ) ) { + deferred.resolveWith( contexts, values ); + } + }; + }, + + progressValues, progressContexts, resolveContexts; + + // add listeners to Deferred subordinates; treat others as resolved + if ( length > 1 ) { + progressValues = new Array( length ); + progressContexts = new Array( length ); + resolveContexts = new Array( length ); + for ( ; i < length; i++ ) { + if ( resolveValues[ i ] && jQuery.isFunction( resolveValues[ i ].promise ) ) { + resolveValues[ i ].promise() + .done( updateFunc( i, resolveContexts, resolveValues ) ) + .fail( deferred.reject ) + .progress( updateFunc( i, progressContexts, progressValues ) ); + } else { + --remaining; + } + } + } + + // if we're not waiting on anything, resolve the master + if ( !remaining ) { + deferred.resolveWith( resolveContexts, resolveValues ); + } + + return deferred.promise(); + } +}); +jQuery.support = (function() { + + var support, all, a, + input, select, fragment, + opt, eventName, isSupported, i, + div = document.createElement("div"); + + // Setup + div.setAttribute( "className", "t" ); + div.innerHTML = "
    a"; + + // Support tests won't run in some limited or non-browser environments + all = div.getElementsByTagName("*"); + a = div.getElementsByTagName("a")[ 0 ]; + if ( !all || !a || !all.length ) { + return {}; + } + + // First batch of tests + select = document.createElement("select"); + opt = select.appendChild( document.createElement("option") ); + input = div.getElementsByTagName("input")[ 0 ]; + + a.style.cssText = "top:1px;float:left;opacity:.5"; + support = { + // Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7) + getSetAttribute: div.className !== "t", + + // IE strips leading whitespace when .innerHTML is used + leadingWhitespace: div.firstChild.nodeType === 3, + + // Make sure that tbody elements aren't automatically inserted + // IE will insert them into empty tables + tbody: !div.getElementsByTagName("tbody").length, + + // Make sure that link elements get serialized correctly by innerHTML + // This requires a wrapper element in IE + htmlSerialize: !!div.getElementsByTagName("link").length, + + // Get the style information from getAttribute + // (IE uses .cssText instead) + style: /top/.test( a.getAttribute("style") ), + + // Make sure that URLs aren't manipulated + // (IE normalizes it by default) + hrefNormalized: a.getAttribute("href") === "/a", + + // Make sure that element opacity exists + // (IE uses filter instead) + // Use a regex to work around a WebKit issue. See #5145 + opacity: /^0.5/.test( a.style.opacity ), + + // Verify style float existence + // (IE uses styleFloat instead of cssFloat) + cssFloat: !!a.style.cssFloat, + + // Check the default checkbox/radio value ("" on WebKit; "on" elsewhere) + checkOn: !!input.value, + + // Make sure that a selected-by-default option has a working selected property. + // (WebKit defaults to false instead of true, IE too, if it's in an optgroup) + optSelected: opt.selected, + + // Tests for enctype support on a form (#6743) + enctype: !!document.createElement("form").enctype, + + // Makes sure cloning an html5 element does not cause problems + // Where outerHTML is undefined, this still works + html5Clone: document.createElement("nav").cloneNode( true ).outerHTML !== "<:nav>", + + // jQuery.support.boxModel DEPRECATED in 1.8 since we don't support Quirks Mode + boxModel: document.compatMode === "CSS1Compat", + + // Will be defined later + deleteExpando: true, + noCloneEvent: true, + inlineBlockNeedsLayout: false, + shrinkWrapBlocks: false, + reliableMarginRight: true, + boxSizingReliable: true, + pixelPosition: false + }; + + // Make sure checked status is properly cloned + input.checked = true; + support.noCloneChecked = input.cloneNode( true ).checked; + + // Make sure that the options inside disabled selects aren't marked as disabled + // (WebKit marks them as disabled) + select.disabled = true; + support.optDisabled = !opt.disabled; + + // Support: IE<9 + try { + delete div.test; + } catch( e ) { + support.deleteExpando = false; + } + + // Check if we can trust getAttribute("value") + input = document.createElement("input"); + input.setAttribute( "value", "" ); + support.input = input.getAttribute( "value" ) === ""; + + // Check if an input maintains its value after becoming a radio + input.value = "t"; + input.setAttribute( "type", "radio" ); + support.radioValue = input.value === "t"; + + // #11217 - WebKit loses check when the name is after the checked attribute + input.setAttribute( "checked", "t" ); + input.setAttribute( "name", "t" ); + + fragment = document.createDocumentFragment(); + fragment.appendChild( input ); + + // Check if a disconnected checkbox will retain its checked + // value of true after appended to the DOM (IE6/7) + support.appendChecked = input.checked; + + // WebKit doesn't clone checked state correctly in fragments + support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked; + + // Support: IE<9 + // Opera does not clone events (and typeof div.attachEvent === undefined). + // IE9-10 clones events bound via attachEvent, but they don't trigger with .click() + if ( div.attachEvent ) { + div.attachEvent( "onclick", function() { + support.noCloneEvent = false; + }); + + div.cloneNode( true ).click(); + } + + // Support: IE<9 (lack submit/change bubble), Firefox 17+ (lack focusin event) + // Beware of CSP restrictions (https://developer.mozilla.org/en/Security/CSP), test/csp.php + for ( i in { submit: true, change: true, focusin: true }) { + div.setAttribute( eventName = "on" + i, "t" ); + + support[ i + "Bubbles" ] = eventName in window || div.attributes[ eventName ].expando === false; + } + + div.style.backgroundClip = "content-box"; + div.cloneNode( true ).style.backgroundClip = ""; + support.clearCloneStyle = div.style.backgroundClip === "content-box"; + + // Run tests that need a body at doc ready + jQuery(function() { + var container, marginDiv, tds, + divReset = "padding:0;margin:0;border:0;display:block;box-sizing:content-box;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;", + body = document.getElementsByTagName("body")[0]; + + if ( !body ) { + // Return for frameset docs that don't have a body + return; + } + + container = document.createElement("div"); + container.style.cssText = "border:0;width:0;height:0;position:absolute;top:0;left:-9999px;margin-top:1px"; + + body.appendChild( container ).appendChild( div ); + + // Support: IE8 + // Check if table cells still have offsetWidth/Height when they are set + // to display:none and there are still other visible table cells in a + // table row; if so, offsetWidth/Height are not reliable for use when + // determining if an element has been hidden directly using + // display:none (it is still safe to use offsets if a parent element is + // hidden; don safety goggles and see bug #4512 for more information). + div.innerHTML = "
    t
    "; + tds = div.getElementsByTagName("td"); + tds[ 0 ].style.cssText = "padding:0;margin:0;border:0;display:none"; + isSupported = ( tds[ 0 ].offsetHeight === 0 ); + + tds[ 0 ].style.display = ""; + tds[ 1 ].style.display = "none"; + + // Support: IE8 + // Check if empty table cells still have offsetWidth/Height + support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 ); + + // Check box-sizing and margin behavior + div.innerHTML = ""; + div.style.cssText = "box-sizing:border-box;-moz-box-sizing:border-box;-webkit-box-sizing:border-box;padding:1px;border:1px;display:block;width:4px;margin-top:1%;position:absolute;top:1%;"; + support.boxSizing = ( div.offsetWidth === 4 ); + support.doesNotIncludeMarginInBodyOffset = ( body.offsetTop !== 1 ); + + // Use window.getComputedStyle because jsdom on node.js will break without it. + if ( window.getComputedStyle ) { + support.pixelPosition = ( window.getComputedStyle( div, null ) || {} ).top !== "1%"; + support.boxSizingReliable = ( window.getComputedStyle( div, null ) || { width: "4px" } ).width === "4px"; + + // Check if div with explicit width and no margin-right incorrectly + // gets computed margin-right based on width of container. (#3333) + // Fails in WebKit before Feb 2011 nightlies + // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right + marginDiv = div.appendChild( document.createElement("div") ); + marginDiv.style.cssText = div.style.cssText = divReset; + marginDiv.style.marginRight = marginDiv.style.width = "0"; + div.style.width = "1px"; + + support.reliableMarginRight = + !parseFloat( ( window.getComputedStyle( marginDiv, null ) || {} ).marginRight ); + } + + if ( typeof div.style.zoom !== core_strundefined ) { + // Support: IE<8 + // Check if natively block-level elements act like inline-block + // elements when setting their display to 'inline' and giving + // them layout + div.innerHTML = ""; + div.style.cssText = divReset + "width:1px;padding:1px;display:inline;zoom:1"; + support.inlineBlockNeedsLayout = ( div.offsetWidth === 3 ); + + // Support: IE6 + // Check if elements with layout shrink-wrap their children + div.style.display = "block"; + div.innerHTML = "
    "; + div.firstChild.style.width = "5px"; + support.shrinkWrapBlocks = ( div.offsetWidth !== 3 ); + + if ( support.inlineBlockNeedsLayout ) { + // Prevent IE 6 from affecting layout for positioned elements #11048 + // Prevent IE from shrinking the body in IE 7 mode #12869 + // Support: IE<8 + body.style.zoom = 1; + } + } + + body.removeChild( container ); + + // Null elements to avoid leaks in IE + container = div = tds = marginDiv = null; + }); + + // Null elements to avoid leaks in IE + all = select = fragment = opt = a = input = null; + + return support; +})(); + +var rbrace = /(?:\{[\s\S]*\}|\[[\s\S]*\])$/, + rmultiDash = /([A-Z])/g; + +function internalData( elem, name, data, pvt /* Internal Use Only */ ){ + if ( !jQuery.acceptData( elem ) ) { + return; + } + + var thisCache, ret, + internalKey = jQuery.expando, + getByName = typeof name === "string", + + // We have to handle DOM nodes and JS objects differently because IE6-7 + // can't GC object references properly across the DOM-JS boundary + isNode = elem.nodeType, + + // Only DOM nodes need the global jQuery cache; JS object data is + // attached directly to the object so GC can occur automatically + cache = isNode ? jQuery.cache : elem, + + // Only defining an ID for JS objects if its cache already exists allows + // the code to shortcut on the same path as a DOM node with no cache + id = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey; + + // Avoid doing any more work than we need to when trying to get data on an + // object that has no data at all + if ( (!id || !cache[id] || (!pvt && !cache[id].data)) && getByName && data === undefined ) { + return; + } + + if ( !id ) { + // Only DOM nodes need a new unique ID for each element since their data + // ends up in the global cache + if ( isNode ) { + elem[ internalKey ] = id = core_deletedIds.pop() || jQuery.guid++; + } else { + id = internalKey; + } + } + + if ( !cache[ id ] ) { + cache[ id ] = {}; + + // Avoids exposing jQuery metadata on plain JS objects when the object + // is serialized using JSON.stringify + if ( !isNode ) { + cache[ id ].toJSON = jQuery.noop; + } + } + + // An object can be passed to jQuery.data instead of a key/value pair; this gets + // shallow copied over onto the existing cache + if ( typeof name === "object" || typeof name === "function" ) { + if ( pvt ) { + cache[ id ] = jQuery.extend( cache[ id ], name ); + } else { + cache[ id ].data = jQuery.extend( cache[ id ].data, name ); + } + } + + thisCache = cache[ id ]; + + // jQuery data() is stored in a separate object inside the object's internal data + // cache in order to avoid key collisions between internal data and user-defined + // data. + if ( !pvt ) { + if ( !thisCache.data ) { + thisCache.data = {}; + } + + thisCache = thisCache.data; + } + + if ( data !== undefined ) { + thisCache[ jQuery.camelCase( name ) ] = data; + } + + // Check for both converted-to-camel and non-converted data property names + // If a data property was specified + if ( getByName ) { + + // First Try to find as-is property data + ret = thisCache[ name ]; + + // Test for null|undefined property data + if ( ret == null ) { + + // Try to find the camelCased property + ret = thisCache[ jQuery.camelCase( name ) ]; + } + } else { + ret = thisCache; + } + + return ret; +} + +function internalRemoveData( elem, name, pvt ) { + if ( !jQuery.acceptData( elem ) ) { + return; + } + + var i, l, thisCache, + isNode = elem.nodeType, + + // See jQuery.data for more information + cache = isNode ? jQuery.cache : elem, + id = isNode ? elem[ jQuery.expando ] : jQuery.expando; + + // If there is already no cache entry for this object, there is no + // purpose in continuing + if ( !cache[ id ] ) { + return; + } + + if ( name ) { + + thisCache = pvt ? cache[ id ] : cache[ id ].data; + + if ( thisCache ) { + + // Support array or space separated string names for data keys + if ( !jQuery.isArray( name ) ) { + + // try the string as a key before any manipulation + if ( name in thisCache ) { + name = [ name ]; + } else { + + // split the camel cased version by spaces unless a key with the spaces exists + name = jQuery.camelCase( name ); + if ( name in thisCache ) { + name = [ name ]; + } else { + name = name.split(" "); + } + } + } else { + // If "name" is an array of keys... + // When data is initially created, via ("key", "val") signature, + // keys will be converted to camelCase. + // Since there is no way to tell _how_ a key was added, remove + // both plain key and camelCase key. #12786 + // This will only penalize the array argument path. + name = name.concat( jQuery.map( name, jQuery.camelCase ) ); + } + + for ( i = 0, l = name.length; i < l; i++ ) { + delete thisCache[ name[i] ]; + } + + // If there is no data left in the cache, we want to continue + // and let the cache object itself get destroyed + if ( !( pvt ? isEmptyDataObject : jQuery.isEmptyObject )( thisCache ) ) { + return; + } + } + } + + // See jQuery.data for more information + if ( !pvt ) { + delete cache[ id ].data; + + // Don't destroy the parent cache unless the internal data object + // had been the only thing left in it + if ( !isEmptyDataObject( cache[ id ] ) ) { + return; + } + } + + // Destroy the cache + if ( isNode ) { + jQuery.cleanData( [ elem ], true ); + + // Use delete when supported for expandos or `cache` is not a window per isWindow (#10080) + } else if ( jQuery.support.deleteExpando || cache != cache.window ) { + delete cache[ id ]; + + // When all else fails, null + } else { + cache[ id ] = null; + } +} + +jQuery.extend({ + cache: {}, + + // Unique for each copy of jQuery on the page + // Non-digits removed to match rinlinejQuery + expando: "jQuery" + ( core_version + Math.random() ).replace( /\D/g, "" ), + + // The following elements throw uncatchable exceptions if you + // attempt to add expando properties to them. + noData: { + "embed": true, + // Ban all objects except for Flash (which handle expandos) + "object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000", + "applet": true + }, + + hasData: function( elem ) { + elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ]; + return !!elem && !isEmptyDataObject( elem ); + }, + + data: function( elem, name, data ) { + return internalData( elem, name, data ); + }, + + removeData: function( elem, name ) { + return internalRemoveData( elem, name ); + }, + + // For internal use only. + _data: function( elem, name, data ) { + return internalData( elem, name, data, true ); + }, + + _removeData: function( elem, name ) { + return internalRemoveData( elem, name, true ); + }, + + // A method for determining if a DOM node can handle the data expando + acceptData: function( elem ) { + // Do not set data on non-element because it will not be cleared (#8335). + if ( elem.nodeType && elem.nodeType !== 1 && elem.nodeType !== 9 ) { + return false; + } + + var noData = elem.nodeName && jQuery.noData[ elem.nodeName.toLowerCase() ]; + + // nodes accept data unless otherwise specified; rejection can be conditional + return !noData || noData !== true && elem.getAttribute("classid") === noData; + } +}); + +jQuery.fn.extend({ + data: function( key, value ) { + var attrs, name, + elem = this[0], + i = 0, + data = null; + + // Gets all values + if ( key === undefined ) { + if ( this.length ) { + data = jQuery.data( elem ); + + if ( elem.nodeType === 1 && !jQuery._data( elem, "parsedAttrs" ) ) { + attrs = elem.attributes; + for ( ; i < attrs.length; i++ ) { + name = attrs[i].name; + + if ( !name.indexOf( "data-" ) ) { + name = jQuery.camelCase( name.slice(5) ); + + dataAttr( elem, name, data[ name ] ); + } + } + jQuery._data( elem, "parsedAttrs", true ); + } + } + + return data; + } + + // Sets multiple values + if ( typeof key === "object" ) { + return this.each(function() { + jQuery.data( this, key ); + }); + } + + return jQuery.access( this, function( value ) { + + if ( value === undefined ) { + // Try to fetch any internally stored data first + return elem ? dataAttr( elem, key, jQuery.data( elem, key ) ) : null; + } + + this.each(function() { + jQuery.data( this, key, value ); + }); + }, null, value, arguments.length > 1, null, true ); + }, + + removeData: function( key ) { + return this.each(function() { + jQuery.removeData( this, key ); + }); + } +}); + +function dataAttr( elem, key, data ) { + // If nothing was found internally, try to fetch any + // data from the HTML5 data-* attribute + if ( data === undefined && elem.nodeType === 1 ) { + + var name = "data-" + key.replace( rmultiDash, "-$1" ).toLowerCase(); + + data = elem.getAttribute( name ); + + if ( typeof data === "string" ) { + try { + data = data === "true" ? true : + data === "false" ? false : + data === "null" ? null : + // Only convert to a number if it doesn't change the string + +data + "" === data ? +data : + rbrace.test( data ) ? jQuery.parseJSON( data ) : + data; + } catch( e ) {} + + // Make sure we set the data so it isn't changed later + jQuery.data( elem, key, data ); + + } else { + data = undefined; + } + } + + return data; +} + +// checks a cache object for emptiness +function isEmptyDataObject( obj ) { + var name; + for ( name in obj ) { + + // if the public data object is empty, the private is still empty + if ( name === "data" && jQuery.isEmptyObject( obj[name] ) ) { + continue; + } + if ( name !== "toJSON" ) { + return false; + } + } + + return true; +} +jQuery.extend({ + queue: function( elem, type, data ) { + var queue; + + if ( elem ) { + type = ( type || "fx" ) + "queue"; + queue = jQuery._data( elem, type ); + + // Speed up dequeue by getting out quickly if this is just a lookup + if ( data ) { + if ( !queue || jQuery.isArray(data) ) { + queue = jQuery._data( elem, type, jQuery.makeArray(data) ); + } else { + queue.push( data ); + } + } + return queue || []; + } + }, + + dequeue: function( elem, type ) { + type = type || "fx"; + + var queue = jQuery.queue( elem, type ), + startLength = queue.length, + fn = queue.shift(), + hooks = jQuery._queueHooks( elem, type ), + next = function() { + jQuery.dequeue( elem, type ); + }; + + // If the fx queue is dequeued, always remove the progress sentinel + if ( fn === "inprogress" ) { + fn = queue.shift(); + startLength--; + } + + hooks.cur = fn; + if ( fn ) { + + // Add a progress sentinel to prevent the fx queue from being + // automatically dequeued + if ( type === "fx" ) { + queue.unshift( "inprogress" ); + } + + // clear up the last queue stop function + delete hooks.stop; + fn.call( elem, next, hooks ); + } + + if ( !startLength && hooks ) { + hooks.empty.fire(); + } + }, + + // not intended for public consumption - generates a queueHooks object, or returns the current one + _queueHooks: function( elem, type ) { + var key = type + "queueHooks"; + return jQuery._data( elem, key ) || jQuery._data( elem, key, { + empty: jQuery.Callbacks("once memory").add(function() { + jQuery._removeData( elem, type + "queue" ); + jQuery._removeData( elem, key ); + }) + }); + } +}); + +jQuery.fn.extend({ + queue: function( type, data ) { + var setter = 2; + + if ( typeof type !== "string" ) { + data = type; + type = "fx"; + setter--; + } + + if ( arguments.length < setter ) { + return jQuery.queue( this[0], type ); + } + + return data === undefined ? + this : + this.each(function() { + var queue = jQuery.queue( this, type, data ); + + // ensure a hooks for this queue + jQuery._queueHooks( this, type ); + + if ( type === "fx" && queue[0] !== "inprogress" ) { + jQuery.dequeue( this, type ); + } + }); + }, + dequeue: function( type ) { + return this.each(function() { + jQuery.dequeue( this, type ); + }); + }, + // Based off of the plugin by Clint Helfers, with permission. + // http://blindsignals.com/index.php/2009/07/jquery-delay/ + delay: function( time, type ) { + time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time; + type = type || "fx"; + + return this.queue( type, function( next, hooks ) { + var timeout = setTimeout( next, time ); + hooks.stop = function() { + clearTimeout( timeout ); + }; + }); + }, + clearQueue: function( type ) { + return this.queue( type || "fx", [] ); + }, + // Get a promise resolved when queues of a certain type + // are emptied (fx is the type by default) + promise: function( type, obj ) { + var tmp, + count = 1, + defer = jQuery.Deferred(), + elements = this, + i = this.length, + resolve = function() { + if ( !( --count ) ) { + defer.resolveWith( elements, [ elements ] ); + } + }; + + if ( typeof type !== "string" ) { + obj = type; + type = undefined; + } + type = type || "fx"; + + while( i-- ) { + tmp = jQuery._data( elements[ i ], type + "queueHooks" ); + if ( tmp && tmp.empty ) { + count++; + tmp.empty.add( resolve ); + } + } + resolve(); + return defer.promise( obj ); + } +}); +var nodeHook, boolHook, + rclass = /[\t\r\n]/g, + rreturn = /\r/g, + rfocusable = /^(?:input|select|textarea|button|object)$/i, + rclickable = /^(?:a|area)$/i, + rboolean = /^(?:checked|selected|autofocus|autoplay|async|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped)$/i, + ruseDefault = /^(?:checked|selected)$/i, + getSetAttribute = jQuery.support.getSetAttribute, + getSetInput = jQuery.support.input; + +jQuery.fn.extend({ + attr: function( name, value ) { + return jQuery.access( this, jQuery.attr, name, value, arguments.length > 1 ); + }, + + removeAttr: function( name ) { + return this.each(function() { + jQuery.removeAttr( this, name ); + }); + }, + + prop: function( name, value ) { + return jQuery.access( this, jQuery.prop, name, value, arguments.length > 1 ); + }, + + removeProp: function( name ) { + name = jQuery.propFix[ name ] || name; + return this.each(function() { + // try/catch handles cases where IE balks (such as removing a property on window) + try { + this[ name ] = undefined; + delete this[ name ]; + } catch( e ) {} + }); + }, + + addClass: function( value ) { + var classes, elem, cur, clazz, j, + i = 0, + len = this.length, + proceed = typeof value === "string" && value; + + if ( jQuery.isFunction( value ) ) { + return this.each(function( j ) { + jQuery( this ).addClass( value.call( this, j, this.className ) ); + }); + } + + if ( proceed ) { + // The disjunction here is for better compressibility (see removeClass) + classes = ( value || "" ).match( core_rnotwhite ) || []; + + for ( ; i < len; i++ ) { + elem = this[ i ]; + cur = elem.nodeType === 1 && ( elem.className ? + ( " " + elem.className + " " ).replace( rclass, " " ) : + " " + ); + + if ( cur ) { + j = 0; + while ( (clazz = classes[j++]) ) { + if ( cur.indexOf( " " + clazz + " " ) < 0 ) { + cur += clazz + " "; + } + } + elem.className = jQuery.trim( cur ); + + } + } + } + + return this; + }, + + removeClass: function( value ) { + var classes, elem, cur, clazz, j, + i = 0, + len = this.length, + proceed = arguments.length === 0 || typeof value === "string" && value; + + if ( jQuery.isFunction( value ) ) { + return this.each(function( j ) { + jQuery( this ).removeClass( value.call( this, j, this.className ) ); + }); + } + if ( proceed ) { + classes = ( value || "" ).match( core_rnotwhite ) || []; + + for ( ; i < len; i++ ) { + elem = this[ i ]; + // This expression is here for better compressibility (see addClass) + cur = elem.nodeType === 1 && ( elem.className ? + ( " " + elem.className + " " ).replace( rclass, " " ) : + "" + ); + + if ( cur ) { + j = 0; + while ( (clazz = classes[j++]) ) { + // Remove *all* instances + while ( cur.indexOf( " " + clazz + " " ) >= 0 ) { + cur = cur.replace( " " + clazz + " ", " " ); + } + } + elem.className = value ? jQuery.trim( cur ) : ""; + } + } + } + + return this; + }, + + toggleClass: function( value, stateVal ) { + var type = typeof value, + isBool = typeof stateVal === "boolean"; + + if ( jQuery.isFunction( value ) ) { + return this.each(function( i ) { + jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal ); + }); + } + + return this.each(function() { + if ( type === "string" ) { + // toggle individual class names + var className, + i = 0, + self = jQuery( this ), + state = stateVal, + classNames = value.match( core_rnotwhite ) || []; + + while ( (className = classNames[ i++ ]) ) { + // check each className given, space separated list + state = isBool ? state : !self.hasClass( className ); + self[ state ? "addClass" : "removeClass" ]( className ); + } + + // Toggle whole class name + } else if ( type === core_strundefined || type === "boolean" ) { + if ( this.className ) { + // store className if set + jQuery._data( this, "__className__", this.className ); + } + + // If the element has a class name or if we're passed "false", + // then remove the whole classname (if there was one, the above saved it). + // Otherwise bring back whatever was previously saved (if anything), + // falling back to the empty string if nothing was stored. + this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || ""; + } + }); + }, + + hasClass: function( selector ) { + var className = " " + selector + " ", + i = 0, + l = this.length; + for ( ; i < l; i++ ) { + if ( this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) >= 0 ) { + return true; + } + } + + return false; + }, + + val: function( value ) { + var ret, hooks, isFunction, + elem = this[0]; + + if ( !arguments.length ) { + if ( elem ) { + hooks = jQuery.valHooks[ elem.type ] || jQuery.valHooks[ elem.nodeName.toLowerCase() ]; + + if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) { + return ret; + } + + ret = elem.value; + + return typeof ret === "string" ? + // handle most common string cases + ret.replace(rreturn, "") : + // handle cases where value is null/undef or number + ret == null ? "" : ret; + } + + return; + } + + isFunction = jQuery.isFunction( value ); + + return this.each(function( i ) { + var val, + self = jQuery(this); + + if ( this.nodeType !== 1 ) { + return; + } + + if ( isFunction ) { + val = value.call( this, i, self.val() ); + } else { + val = value; + } + + // Treat null/undefined as ""; convert numbers to string + if ( val == null ) { + val = ""; + } else if ( typeof val === "number" ) { + val += ""; + } else if ( jQuery.isArray( val ) ) { + val = jQuery.map(val, function ( value ) { + return value == null ? "" : value + ""; + }); + } + + hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ]; + + // If set returns undefined, fall back to normal setting + if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) { + this.value = val; + } + }); + } +}); + +jQuery.extend({ + valHooks: { + option: { + get: function( elem ) { + // attributes.value is undefined in Blackberry 4.7 but + // uses .value. See #6932 + var val = elem.attributes.value; + return !val || val.specified ? elem.value : elem.text; + } + }, + select: { + get: function( elem ) { + var value, option, + options = elem.options, + index = elem.selectedIndex, + one = elem.type === "select-one" || index < 0, + values = one ? null : [], + max = one ? index + 1 : options.length, + i = index < 0 ? + max : + one ? index : 0; + + // Loop through all the selected options + for ( ; i < max; i++ ) { + option = options[ i ]; + + // oldIE doesn't update selected after form reset (#2551) + if ( ( option.selected || i === index ) && + // Don't return options that are disabled or in a disabled optgroup + ( jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null ) && + ( !option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" ) ) ) { + + // Get the specific value for the option + value = jQuery( option ).val(); + + // We don't need an array for one selects + if ( one ) { + return value; + } + + // Multi-Selects return an array + values.push( value ); + } + } + + return values; + }, + + set: function( elem, value ) { + var values = jQuery.makeArray( value ); + + jQuery(elem).find("option").each(function() { + this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0; + }); + + if ( !values.length ) { + elem.selectedIndex = -1; + } + return values; + } + } + }, + + attr: function( elem, name, value ) { + var hooks, notxml, ret, + nType = elem.nodeType; + + // don't get/set attributes on text, comment and attribute nodes + if ( !elem || nType === 3 || nType === 8 || nType === 2 ) { + return; + } + + // Fallback to prop when attributes are not supported + if ( typeof elem.getAttribute === core_strundefined ) { + return jQuery.prop( elem, name, value ); + } + + notxml = nType !== 1 || !jQuery.isXMLDoc( elem ); + + // All attributes are lowercase + // Grab necessary hook if one is defined + if ( notxml ) { + name = name.toLowerCase(); + hooks = jQuery.attrHooks[ name ] || ( rboolean.test( name ) ? boolHook : nodeHook ); + } + + if ( value !== undefined ) { + + if ( value === null ) { + jQuery.removeAttr( elem, name ); + + } else if ( hooks && notxml && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) { + return ret; + + } else { + elem.setAttribute( name, value + "" ); + return value; + } + + } else if ( hooks && notxml && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) { + return ret; + + } else { + + // In IE9+, Flash objects don't have .getAttribute (#12945) + // Support: IE9+ + if ( typeof elem.getAttribute !== core_strundefined ) { + ret = elem.getAttribute( name ); + } + + // Non-existent attributes return null, we normalize to undefined + return ret == null ? + undefined : + ret; + } + }, + + removeAttr: function( elem, value ) { + var name, propName, + i = 0, + attrNames = value && value.match( core_rnotwhite ); + + if ( attrNames && elem.nodeType === 1 ) { + while ( (name = attrNames[i++]) ) { + propName = jQuery.propFix[ name ] || name; + + // Boolean attributes get special treatment (#10870) + if ( rboolean.test( name ) ) { + // Set corresponding property to false for boolean attributes + // Also clear defaultChecked/defaultSelected (if appropriate) for IE<8 + if ( !getSetAttribute && ruseDefault.test( name ) ) { + elem[ jQuery.camelCase( "default-" + name ) ] = + elem[ propName ] = false; + } else { + elem[ propName ] = false; + } + + // See #9699 for explanation of this approach (setting first, then removal) + } else { + jQuery.attr( elem, name, "" ); + } + + elem.removeAttribute( getSetAttribute ? name : propName ); + } + } + }, + + attrHooks: { + type: { + set: function( elem, value ) { + if ( !jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) { + // Setting the type on a radio button after the value resets the value in IE6-9 + // Reset value to default in case type is set after value during creation + var val = elem.value; + elem.setAttribute( "type", value ); + if ( val ) { + elem.value = val; + } + return value; + } + } + } + }, + + propFix: { + tabindex: "tabIndex", + readonly: "readOnly", + "for": "htmlFor", + "class": "className", + maxlength: "maxLength", + cellspacing: "cellSpacing", + cellpadding: "cellPadding", + rowspan: "rowSpan", + colspan: "colSpan", + usemap: "useMap", + frameborder: "frameBorder", + contenteditable: "contentEditable" + }, + + prop: function( elem, name, value ) { + var ret, hooks, notxml, + nType = elem.nodeType; + + // don't get/set properties on text, comment and attribute nodes + if ( !elem || nType === 3 || nType === 8 || nType === 2 ) { + return; + } + + notxml = nType !== 1 || !jQuery.isXMLDoc( elem ); + + if ( notxml ) { + // Fix name and attach hooks + name = jQuery.propFix[ name ] || name; + hooks = jQuery.propHooks[ name ]; + } + + if ( value !== undefined ) { + if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) { + return ret; + + } else { + return ( elem[ name ] = value ); + } + + } else { + if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) { + return ret; + + } else { + return elem[ name ]; + } + } + }, + + propHooks: { + tabIndex: { + get: function( elem ) { + // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set + // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/ + var attributeNode = elem.getAttributeNode("tabindex"); + + return attributeNode && attributeNode.specified ? + parseInt( attributeNode.value, 10 ) : + rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ? + 0 : + undefined; + } + } + } +}); + +// Hook for boolean attributes +boolHook = { + get: function( elem, name ) { + var + // Use .prop to determine if this attribute is understood as boolean + prop = jQuery.prop( elem, name ), + + // Fetch it accordingly + attr = typeof prop === "boolean" && elem.getAttribute( name ), + detail = typeof prop === "boolean" ? + + getSetInput && getSetAttribute ? + attr != null : + // oldIE fabricates an empty string for missing boolean attributes + // and conflates checked/selected into attroperties + ruseDefault.test( name ) ? + elem[ jQuery.camelCase( "default-" + name ) ] : + !!attr : + + // fetch an attribute node for properties not recognized as boolean + elem.getAttributeNode( name ); + + return detail && detail.value !== false ? + name.toLowerCase() : + undefined; + }, + set: function( elem, value, name ) { + if ( value === false ) { + // Remove boolean attributes when set to false + jQuery.removeAttr( elem, name ); + } else if ( getSetInput && getSetAttribute || !ruseDefault.test( name ) ) { + // IE<8 needs the *property* name + elem.setAttribute( !getSetAttribute && jQuery.propFix[ name ] || name, name ); + + // Use defaultChecked and defaultSelected for oldIE + } else { + elem[ jQuery.camelCase( "default-" + name ) ] = elem[ name ] = true; + } + + return name; + } +}; + +// fix oldIE value attroperty +if ( !getSetInput || !getSetAttribute ) { + jQuery.attrHooks.value = { + get: function( elem, name ) { + var ret = elem.getAttributeNode( name ); + return jQuery.nodeName( elem, "input" ) ? + + // Ignore the value *property* by using defaultValue + elem.defaultValue : + + ret && ret.specified ? ret.value : undefined; + }, + set: function( elem, value, name ) { + if ( jQuery.nodeName( elem, "input" ) ) { + // Does not return so that setAttribute is also used + elem.defaultValue = value; + } else { + // Use nodeHook if defined (#1954); otherwise setAttribute is fine + return nodeHook && nodeHook.set( elem, value, name ); + } + } + }; +} + +// IE6/7 do not support getting/setting some attributes with get/setAttribute +if ( !getSetAttribute ) { + + // Use this for any attribute in IE6/7 + // This fixes almost every IE6/7 issue + nodeHook = jQuery.valHooks.button = { + get: function( elem, name ) { + var ret = elem.getAttributeNode( name ); + return ret && ( name === "id" || name === "name" || name === "coords" ? ret.value !== "" : ret.specified ) ? + ret.value : + undefined; + }, + set: function( elem, value, name ) { + // Set the existing or create a new attribute node + var ret = elem.getAttributeNode( name ); + if ( !ret ) { + elem.setAttributeNode( + (ret = elem.ownerDocument.createAttribute( name )) + ); + } + + ret.value = value += ""; + + // Break association with cloned elements by also using setAttribute (#9646) + return name === "value" || value === elem.getAttribute( name ) ? + value : + undefined; + } + }; + + // Set contenteditable to false on removals(#10429) + // Setting to empty string throws an error as an invalid value + jQuery.attrHooks.contenteditable = { + get: nodeHook.get, + set: function( elem, value, name ) { + nodeHook.set( elem, value === "" ? false : value, name ); + } + }; + + // Set width and height to auto instead of 0 on empty string( Bug #8150 ) + // This is for removals + jQuery.each([ "width", "height" ], function( i, name ) { + jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], { + set: function( elem, value ) { + if ( value === "" ) { + elem.setAttribute( name, "auto" ); + return value; + } + } + }); + }); +} + + +// Some attributes require a special call on IE +// http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx +if ( !jQuery.support.hrefNormalized ) { + jQuery.each([ "href", "src", "width", "height" ], function( i, name ) { + jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], { + get: function( elem ) { + var ret = elem.getAttribute( name, 2 ); + return ret == null ? undefined : ret; + } + }); + }); + + // href/src property should get the full normalized URL (#10299/#12915) + jQuery.each([ "href", "src" ], function( i, name ) { + jQuery.propHooks[ name ] = { + get: function( elem ) { + return elem.getAttribute( name, 4 ); + } + }; + }); +} + +if ( !jQuery.support.style ) { + jQuery.attrHooks.style = { + get: function( elem ) { + // Return undefined in the case of empty string + // Note: IE uppercases css property names, but if we were to .toLowerCase() + // .cssText, that would destroy case senstitivity in URL's, like in "background" + return elem.style.cssText || undefined; + }, + set: function( elem, value ) { + return ( elem.style.cssText = value + "" ); + } + }; +} + +// Safari mis-reports the default selected property of an option +// Accessing the parent's selectedIndex property fixes it +if ( !jQuery.support.optSelected ) { + jQuery.propHooks.selected = jQuery.extend( jQuery.propHooks.selected, { + get: function( elem ) { + var parent = elem.parentNode; + + if ( parent ) { + parent.selectedIndex; + + // Make sure that it also works with optgroups, see #5701 + if ( parent.parentNode ) { + parent.parentNode.selectedIndex; + } + } + return null; + } + }); +} + +// IE6/7 call enctype encoding +if ( !jQuery.support.enctype ) { + jQuery.propFix.enctype = "encoding"; +} + +// Radios and checkboxes getter/setter +if ( !jQuery.support.checkOn ) { + jQuery.each([ "radio", "checkbox" ], function() { + jQuery.valHooks[ this ] = { + get: function( elem ) { + // Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified + return elem.getAttribute("value") === null ? "on" : elem.value; + } + }; + }); +} +jQuery.each([ "radio", "checkbox" ], function() { + jQuery.valHooks[ this ] = jQuery.extend( jQuery.valHooks[ this ], { + set: function( elem, value ) { + if ( jQuery.isArray( value ) ) { + return ( elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0 ); + } + } + }); +}); +var rformElems = /^(?:input|select|textarea)$/i, + rkeyEvent = /^key/, + rmouseEvent = /^(?:mouse|contextmenu)|click/, + rfocusMorph = /^(?:focusinfocus|focusoutblur)$/, + rtypenamespace = /^([^.]*)(?:\.(.+)|)$/; + +function returnTrue() { + return true; +} + +function returnFalse() { + return false; +} + +/* + * Helper functions for managing events -- not part of the public interface. + * Props to Dean Edwards' addEvent library for many of the ideas. + */ +jQuery.event = { + + global: {}, + + add: function( elem, types, handler, data, selector ) { + var tmp, events, t, handleObjIn, + special, eventHandle, handleObj, + handlers, type, namespaces, origType, + elemData = jQuery._data( elem ); + + // Don't attach events to noData or text/comment nodes (but allow plain objects) + if ( !elemData ) { + return; + } + + // Caller can pass in an object of custom data in lieu of the handler + if ( handler.handler ) { + handleObjIn = handler; + handler = handleObjIn.handler; + selector = handleObjIn.selector; + } + + // Make sure that the handler has a unique ID, used to find/remove it later + if ( !handler.guid ) { + handler.guid = jQuery.guid++; + } + + // Init the element's event structure and main handler, if this is the first + if ( !(events = elemData.events) ) { + events = elemData.events = {}; + } + if ( !(eventHandle = elemData.handle) ) { + eventHandle = elemData.handle = function( e ) { + // Discard the second event of a jQuery.event.trigger() and + // when an event is called after a page has unloaded + return typeof jQuery !== core_strundefined && (!e || jQuery.event.triggered !== e.type) ? + jQuery.event.dispatch.apply( eventHandle.elem, arguments ) : + undefined; + }; + // Add elem as a property of the handle fn to prevent a memory leak with IE non-native events + eventHandle.elem = elem; + } + + // Handle multiple events separated by a space + // jQuery(...).bind("mouseover mouseout", fn); + types = ( types || "" ).match( core_rnotwhite ) || [""]; + t = types.length; + while ( t-- ) { + tmp = rtypenamespace.exec( types[t] ) || []; + type = origType = tmp[1]; + namespaces = ( tmp[2] || "" ).split( "." ).sort(); + + // If event changes its type, use the special event handlers for the changed type + special = jQuery.event.special[ type ] || {}; + + // If selector defined, determine special event api type, otherwise given type + type = ( selector ? special.delegateType : special.bindType ) || type; + + // Update special based on newly reset type + special = jQuery.event.special[ type ] || {}; + + // handleObj is passed to all event handlers + handleObj = jQuery.extend({ + type: type, + origType: origType, + data: data, + handler: handler, + guid: handler.guid, + selector: selector, + needsContext: selector && jQuery.expr.match.needsContext.test( selector ), + namespace: namespaces.join(".") + }, handleObjIn ); + + // Init the event handler queue if we're the first + if ( !(handlers = events[ type ]) ) { + handlers = events[ type ] = []; + handlers.delegateCount = 0; + + // Only use addEventListener/attachEvent if the special events handler returns false + if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) { + // Bind the global event handler to the element + if ( elem.addEventListener ) { + elem.addEventListener( type, eventHandle, false ); + + } else if ( elem.attachEvent ) { + elem.attachEvent( "on" + type, eventHandle ); + } + } + } + + if ( special.add ) { + special.add.call( elem, handleObj ); + + if ( !handleObj.handler.guid ) { + handleObj.handler.guid = handler.guid; + } + } + + // Add to the element's handler list, delegates in front + if ( selector ) { + handlers.splice( handlers.delegateCount++, 0, handleObj ); + } else { + handlers.push( handleObj ); + } + + // Keep track of which events have ever been used, for event optimization + jQuery.event.global[ type ] = true; + } + + // Nullify elem to prevent memory leaks in IE + elem = null; + }, + + // Detach an event or set of events from an element + remove: function( elem, types, handler, selector, mappedTypes ) { + var j, handleObj, tmp, + origCount, t, events, + special, handlers, type, + namespaces, origType, + elemData = jQuery.hasData( elem ) && jQuery._data( elem ); + + if ( !elemData || !(events = elemData.events) ) { + return; + } + + // Once for each type.namespace in types; type may be omitted + types = ( types || "" ).match( core_rnotwhite ) || [""]; + t = types.length; + while ( t-- ) { + tmp = rtypenamespace.exec( types[t] ) || []; + type = origType = tmp[1]; + namespaces = ( tmp[2] || "" ).split( "." ).sort(); + + // Unbind all events (on this namespace, if provided) for the element + if ( !type ) { + for ( type in events ) { + jQuery.event.remove( elem, type + types[ t ], handler, selector, true ); + } + continue; + } + + special = jQuery.event.special[ type ] || {}; + type = ( selector ? special.delegateType : special.bindType ) || type; + handlers = events[ type ] || []; + tmp = tmp[2] && new RegExp( "(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)" ); + + // Remove matching events + origCount = j = handlers.length; + while ( j-- ) { + handleObj = handlers[ j ]; + + if ( ( mappedTypes || origType === handleObj.origType ) && + ( !handler || handler.guid === handleObj.guid ) && + ( !tmp || tmp.test( handleObj.namespace ) ) && + ( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector ) ) { + handlers.splice( j, 1 ); + + if ( handleObj.selector ) { + handlers.delegateCount--; + } + if ( special.remove ) { + special.remove.call( elem, handleObj ); + } + } + } + + // Remove generic event handler if we removed something and no more handlers exist + // (avoids potential for endless recursion during removal of special event handlers) + if ( origCount && !handlers.length ) { + if ( !special.teardown || special.teardown.call( elem, namespaces, elemData.handle ) === false ) { + jQuery.removeEvent( elem, type, elemData.handle ); + } + + delete events[ type ]; + } + } + + // Remove the expando if it's no longer used + if ( jQuery.isEmptyObject( events ) ) { + delete elemData.handle; + + // removeData also checks for emptiness and clears the expando if empty + // so use it instead of delete + jQuery._removeData( elem, "events" ); + } + }, + + trigger: function( event, data, elem, onlyHandlers ) { + var handle, ontype, cur, + bubbleType, special, tmp, i, + eventPath = [ elem || document ], + type = core_hasOwn.call( event, "type" ) ? event.type : event, + namespaces = core_hasOwn.call( event, "namespace" ) ? event.namespace.split(".") : []; + + cur = tmp = elem = elem || document; + + // Don't do events on text and comment nodes + if ( elem.nodeType === 3 || elem.nodeType === 8 ) { + return; + } + + // focus/blur morphs to focusin/out; ensure we're not firing them right now + if ( rfocusMorph.test( type + jQuery.event.triggered ) ) { + return; + } + + if ( type.indexOf(".") >= 0 ) { + // Namespaced trigger; create a regexp to match event type in handle() + namespaces = type.split("."); + type = namespaces.shift(); + namespaces.sort(); + } + ontype = type.indexOf(":") < 0 && "on" + type; + + // Caller can pass in a jQuery.Event object, Object, or just an event type string + event = event[ jQuery.expando ] ? + event : + new jQuery.Event( type, typeof event === "object" && event ); + + event.isTrigger = true; + event.namespace = namespaces.join("."); + event.namespace_re = event.namespace ? + new RegExp( "(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)" ) : + null; + + // Clean up the event in case it is being reused + event.result = undefined; + if ( !event.target ) { + event.target = elem; + } + + // Clone any incoming data and prepend the event, creating the handler arg list + data = data == null ? + [ event ] : + jQuery.makeArray( data, [ event ] ); + + // Allow special events to draw outside the lines + special = jQuery.event.special[ type ] || {}; + if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) { + return; + } + + // Determine event propagation path in advance, per W3C events spec (#9951) + // Bubble up to document, then to window; watch for a global ownerDocument var (#9724) + if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) { + + bubbleType = special.delegateType || type; + if ( !rfocusMorph.test( bubbleType + type ) ) { + cur = cur.parentNode; + } + for ( ; cur; cur = cur.parentNode ) { + eventPath.push( cur ); + tmp = cur; + } + + // Only add window if we got to document (e.g., not plain obj or detached DOM) + if ( tmp === (elem.ownerDocument || document) ) { + eventPath.push( tmp.defaultView || tmp.parentWindow || window ); + } + } + + // Fire handlers on the event path + i = 0; + while ( (cur = eventPath[i++]) && !event.isPropagationStopped() ) { + + event.type = i > 1 ? + bubbleType : + special.bindType || type; + + // jQuery handler + handle = ( jQuery._data( cur, "events" ) || {} )[ event.type ] && jQuery._data( cur, "handle" ); + if ( handle ) { + handle.apply( cur, data ); + } + + // Native handler + handle = ontype && cur[ ontype ]; + if ( handle && jQuery.acceptData( cur ) && handle.apply && handle.apply( cur, data ) === false ) { + event.preventDefault(); + } + } + event.type = type; + + // If nobody prevented the default action, do it now + if ( !onlyHandlers && !event.isDefaultPrevented() ) { + + if ( (!special._default || special._default.apply( elem.ownerDocument, data ) === false) && + !(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) { + + // Call a native DOM method on the target with the same name name as the event. + // Can't use an .isFunction() check here because IE6/7 fails that test. + // Don't do default actions on window, that's where global variables be (#6170) + if ( ontype && elem[ type ] && !jQuery.isWindow( elem ) ) { + + // Don't re-trigger an onFOO event when we call its FOO() method + tmp = elem[ ontype ]; + + if ( tmp ) { + elem[ ontype ] = null; + } + + // Prevent re-triggering of the same event, since we already bubbled it above + jQuery.event.triggered = type; + try { + elem[ type ](); + } catch ( e ) { + // IE<9 dies on focus/blur to hidden element (#1486,#12518) + // only reproducible on winXP IE8 native, not IE9 in IE8 mode + } + jQuery.event.triggered = undefined; + + if ( tmp ) { + elem[ ontype ] = tmp; + } + } + } + } + + return event.result; + }, + + dispatch: function( event ) { + + // Make a writable jQuery.Event from the native event object + event = jQuery.event.fix( event ); + + var i, ret, handleObj, matched, j, + handlerQueue = [], + args = core_slice.call( arguments ), + handlers = ( jQuery._data( this, "events" ) || {} )[ event.type ] || [], + special = jQuery.event.special[ event.type ] || {}; + + // Use the fix-ed jQuery.Event rather than the (read-only) native event + args[0] = event; + event.delegateTarget = this; + + // Call the preDispatch hook for the mapped type, and let it bail if desired + if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) { + return; + } + + // Determine handlers + handlerQueue = jQuery.event.handlers.call( this, event, handlers ); + + // Run delegates first; they may want to stop propagation beneath us + i = 0; + while ( (matched = handlerQueue[ i++ ]) && !event.isPropagationStopped() ) { + event.currentTarget = matched.elem; + + j = 0; + while ( (handleObj = matched.handlers[ j++ ]) && !event.isImmediatePropagationStopped() ) { + + // Triggered event must either 1) have no namespace, or + // 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace). + if ( !event.namespace_re || event.namespace_re.test( handleObj.namespace ) ) { + + event.handleObj = handleObj; + event.data = handleObj.data; + + ret = ( (jQuery.event.special[ handleObj.origType ] || {}).handle || handleObj.handler ) + .apply( matched.elem, args ); + + if ( ret !== undefined ) { + if ( (event.result = ret) === false ) { + event.preventDefault(); + event.stopPropagation(); + } + } + } + } + } + + // Call the postDispatch hook for the mapped type + if ( special.postDispatch ) { + special.postDispatch.call( this, event ); + } + + return event.result; + }, + + handlers: function( event, handlers ) { + var sel, handleObj, matches, i, + handlerQueue = [], + delegateCount = handlers.delegateCount, + cur = event.target; + + // Find delegate handlers + // Black-hole SVG instance trees (#13180) + // Avoid non-left-click bubbling in Firefox (#3861) + if ( delegateCount && cur.nodeType && (!event.button || event.type !== "click") ) { + + for ( ; cur != this; cur = cur.parentNode || this ) { + + // Don't check non-elements (#13208) + // Don't process clicks on disabled elements (#6911, #8165, #11382, #11764) + if ( cur.nodeType === 1 && (cur.disabled !== true || event.type !== "click") ) { + matches = []; + for ( i = 0; i < delegateCount; i++ ) { + handleObj = handlers[ i ]; + + // Don't conflict with Object.prototype properties (#13203) + sel = handleObj.selector + " "; + + if ( matches[ sel ] === undefined ) { + matches[ sel ] = handleObj.needsContext ? + jQuery( sel, this ).index( cur ) >= 0 : + jQuery.find( sel, this, null, [ cur ] ).length; + } + if ( matches[ sel ] ) { + matches.push( handleObj ); + } + } + if ( matches.length ) { + handlerQueue.push({ elem: cur, handlers: matches }); + } + } + } + } + + // Add the remaining (directly-bound) handlers + if ( delegateCount < handlers.length ) { + handlerQueue.push({ elem: this, handlers: handlers.slice( delegateCount ) }); + } + + return handlerQueue; + }, + + fix: function( event ) { + if ( event[ jQuery.expando ] ) { + return event; + } + + // Create a writable copy of the event object and normalize some properties + var i, prop, copy, + type = event.type, + originalEvent = event, + fixHook = this.fixHooks[ type ]; + + if ( !fixHook ) { + this.fixHooks[ type ] = fixHook = + rmouseEvent.test( type ) ? this.mouseHooks : + rkeyEvent.test( type ) ? this.keyHooks : + {}; + } + copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props; + + event = new jQuery.Event( originalEvent ); + + i = copy.length; + while ( i-- ) { + prop = copy[ i ]; + event[ prop ] = originalEvent[ prop ]; + } + + // Support: IE<9 + // Fix target property (#1925) + if ( !event.target ) { + event.target = originalEvent.srcElement || document; + } + + // Support: Chrome 23+, Safari? + // Target should not be a text node (#504, #13143) + if ( event.target.nodeType === 3 ) { + event.target = event.target.parentNode; + } + + // Support: IE<9 + // For mouse/key events, metaKey==false if it's undefined (#3368, #11328) + event.metaKey = !!event.metaKey; + + return fixHook.filter ? fixHook.filter( event, originalEvent ) : event; + }, + + // Includes some event props shared by KeyEvent and MouseEvent + props: "altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "), + + fixHooks: {}, + + keyHooks: { + props: "char charCode key keyCode".split(" "), + filter: function( event, original ) { + + // Add which for key events + if ( event.which == null ) { + event.which = original.charCode != null ? original.charCode : original.keyCode; + } + + return event; + } + }, + + mouseHooks: { + props: "button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "), + filter: function( event, original ) { + var body, eventDoc, doc, + button = original.button, + fromElement = original.fromElement; + + // Calculate pageX/Y if missing and clientX/Y available + if ( event.pageX == null && original.clientX != null ) { + eventDoc = event.target.ownerDocument || document; + doc = eventDoc.documentElement; + body = eventDoc.body; + + event.pageX = original.clientX + ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) - ( doc && doc.clientLeft || body && body.clientLeft || 0 ); + event.pageY = original.clientY + ( doc && doc.scrollTop || body && body.scrollTop || 0 ) - ( doc && doc.clientTop || body && body.clientTop || 0 ); + } + + // Add relatedTarget, if necessary + if ( !event.relatedTarget && fromElement ) { + event.relatedTarget = fromElement === event.target ? original.toElement : fromElement; + } + + // Add which for click: 1 === left; 2 === middle; 3 === right + // Note: button is not normalized, so don't use it + if ( !event.which && button !== undefined ) { + event.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) ); + } + + return event; + } + }, + + special: { + load: { + // Prevent triggered image.load events from bubbling to window.load + noBubble: true + }, + click: { + // For checkbox, fire native event so checked state will be right + trigger: function() { + if ( jQuery.nodeName( this, "input" ) && this.type === "checkbox" && this.click ) { + this.click(); + return false; + } + } + }, + focus: { + // Fire native event if possible so blur/focus sequence is correct + trigger: function() { + if ( this !== document.activeElement && this.focus ) { + try { + this.focus(); + return false; + } catch ( e ) { + // Support: IE<9 + // If we error on focus to hidden element (#1486, #12518), + // let .trigger() run the handlers + } + } + }, + delegateType: "focusin" + }, + blur: { + trigger: function() { + if ( this === document.activeElement && this.blur ) { + this.blur(); + return false; + } + }, + delegateType: "focusout" + }, + + beforeunload: { + postDispatch: function( event ) { + + // Even when returnValue equals to undefined Firefox will still show alert + if ( event.result !== undefined ) { + event.originalEvent.returnValue = event.result; + } + } + } + }, + + simulate: function( type, elem, event, bubble ) { + // Piggyback on a donor event to simulate a different one. + // Fake originalEvent to avoid donor's stopPropagation, but if the + // simulated event prevents default then we do the same on the donor. + var e = jQuery.extend( + new jQuery.Event(), + event, + { type: type, + isSimulated: true, + originalEvent: {} + } + ); + if ( bubble ) { + jQuery.event.trigger( e, null, elem ); + } else { + jQuery.event.dispatch.call( elem, e ); + } + if ( e.isDefaultPrevented() ) { + event.preventDefault(); + } + } +}; + +jQuery.removeEvent = document.removeEventListener ? + function( elem, type, handle ) { + if ( elem.removeEventListener ) { + elem.removeEventListener( type, handle, false ); + } + } : + function( elem, type, handle ) { + var name = "on" + type; + + if ( elem.detachEvent ) { + + // #8545, #7054, preventing memory leaks for custom events in IE6-8 + // detachEvent needed property on element, by name of that event, to properly expose it to GC + if ( typeof elem[ name ] === core_strundefined ) { + elem[ name ] = null; + } + + elem.detachEvent( name, handle ); + } + }; + +jQuery.Event = function( src, props ) { + // Allow instantiation without the 'new' keyword + if ( !(this instanceof jQuery.Event) ) { + return new jQuery.Event( src, props ); + } + + // Event object + if ( src && src.type ) { + this.originalEvent = src; + this.type = src.type; + + // Events bubbling up the document may have been marked as prevented + // by a handler lower down the tree; reflect the correct value. + this.isDefaultPrevented = ( src.defaultPrevented || src.returnValue === false || + src.getPreventDefault && src.getPreventDefault() ) ? returnTrue : returnFalse; + + // Event type + } else { + this.type = src; + } + + // Put explicitly provided properties onto the event object + if ( props ) { + jQuery.extend( this, props ); + } + + // Create a timestamp if incoming event doesn't have one + this.timeStamp = src && src.timeStamp || jQuery.now(); + + // Mark it as fixed + this[ jQuery.expando ] = true; +}; + +// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding +// http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html +jQuery.Event.prototype = { + isDefaultPrevented: returnFalse, + isPropagationStopped: returnFalse, + isImmediatePropagationStopped: returnFalse, + + preventDefault: function() { + var e = this.originalEvent; + + this.isDefaultPrevented = returnTrue; + if ( !e ) { + return; + } + + // If preventDefault exists, run it on the original event + if ( e.preventDefault ) { + e.preventDefault(); + + // Support: IE + // Otherwise set the returnValue property of the original event to false + } else { + e.returnValue = false; + } + }, + stopPropagation: function() { + var e = this.originalEvent; + + this.isPropagationStopped = returnTrue; + if ( !e ) { + return; + } + // If stopPropagation exists, run it on the original event + if ( e.stopPropagation ) { + e.stopPropagation(); + } + + // Support: IE + // Set the cancelBubble property of the original event to true + e.cancelBubble = true; + }, + stopImmediatePropagation: function() { + this.isImmediatePropagationStopped = returnTrue; + this.stopPropagation(); + } +}; + +// Create mouseenter/leave events using mouseover/out and event-time checks +jQuery.each({ + mouseenter: "mouseover", + mouseleave: "mouseout" +}, function( orig, fix ) { + jQuery.event.special[ orig ] = { + delegateType: fix, + bindType: fix, + + handle: function( event ) { + var ret, + target = this, + related = event.relatedTarget, + handleObj = event.handleObj; + + // For mousenter/leave call the handler if related is outside the target. + // NB: No relatedTarget if the mouse left/entered the browser window + if ( !related || (related !== target && !jQuery.contains( target, related )) ) { + event.type = handleObj.origType; + ret = handleObj.handler.apply( this, arguments ); + event.type = fix; + } + return ret; + } + }; +}); + +// IE submit delegation +if ( !jQuery.support.submitBubbles ) { + + jQuery.event.special.submit = { + setup: function() { + // Only need this for delegated form submit events + if ( jQuery.nodeName( this, "form" ) ) { + return false; + } + + // Lazy-add a submit handler when a descendant form may potentially be submitted + jQuery.event.add( this, "click._submit keypress._submit", function( e ) { + // Node name check avoids a VML-related crash in IE (#9807) + var elem = e.target, + form = jQuery.nodeName( elem, "input" ) || jQuery.nodeName( elem, "button" ) ? elem.form : undefined; + if ( form && !jQuery._data( form, "submitBubbles" ) ) { + jQuery.event.add( form, "submit._submit", function( event ) { + event._submit_bubble = true; + }); + jQuery._data( form, "submitBubbles", true ); + } + }); + // return undefined since we don't need an event listener + }, + + postDispatch: function( event ) { + // If form was submitted by the user, bubble the event up the tree + if ( event._submit_bubble ) { + delete event._submit_bubble; + if ( this.parentNode && !event.isTrigger ) { + jQuery.event.simulate( "submit", this.parentNode, event, true ); + } + } + }, + + teardown: function() { + // Only need this for delegated form submit events + if ( jQuery.nodeName( this, "form" ) ) { + return false; + } + + // Remove delegated handlers; cleanData eventually reaps submit handlers attached above + jQuery.event.remove( this, "._submit" ); + } + }; +} + +// IE change delegation and checkbox/radio fix +if ( !jQuery.support.changeBubbles ) { + + jQuery.event.special.change = { + + setup: function() { + + if ( rformElems.test( this.nodeName ) ) { + // IE doesn't fire change on a check/radio until blur; trigger it on click + // after a propertychange. Eat the blur-change in special.change.handle. + // This still fires onchange a second time for check/radio after blur. + if ( this.type === "checkbox" || this.type === "radio" ) { + jQuery.event.add( this, "propertychange._change", function( event ) { + if ( event.originalEvent.propertyName === "checked" ) { + this._just_changed = true; + } + }); + jQuery.event.add( this, "click._change", function( event ) { + if ( this._just_changed && !event.isTrigger ) { + this._just_changed = false; + } + // Allow triggered, simulated change events (#11500) + jQuery.event.simulate( "change", this, event, true ); + }); + } + return false; + } + // Delegated event; lazy-add a change handler on descendant inputs + jQuery.event.add( this, "beforeactivate._change", function( e ) { + var elem = e.target; + + if ( rformElems.test( elem.nodeName ) && !jQuery._data( elem, "changeBubbles" ) ) { + jQuery.event.add( elem, "change._change", function( event ) { + if ( this.parentNode && !event.isSimulated && !event.isTrigger ) { + jQuery.event.simulate( "change", this.parentNode, event, true ); + } + }); + jQuery._data( elem, "changeBubbles", true ); + } + }); + }, + + handle: function( event ) { + var elem = event.target; + + // Swallow native change events from checkbox/radio, we already triggered them above + if ( this !== elem || event.isSimulated || event.isTrigger || (elem.type !== "radio" && elem.type !== "checkbox") ) { + return event.handleObj.handler.apply( this, arguments ); + } + }, + + teardown: function() { + jQuery.event.remove( this, "._change" ); + + return !rformElems.test( this.nodeName ); + } + }; +} + +// Create "bubbling" focus and blur events +if ( !jQuery.support.focusinBubbles ) { + jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) { + + // Attach a single capturing handler while someone wants focusin/focusout + var attaches = 0, + handler = function( event ) { + jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ), true ); + }; + + jQuery.event.special[ fix ] = { + setup: function() { + if ( attaches++ === 0 ) { + document.addEventListener( orig, handler, true ); + } + }, + teardown: function() { + if ( --attaches === 0 ) { + document.removeEventListener( orig, handler, true ); + } + } + }; + }); +} + +jQuery.fn.extend({ + + on: function( types, selector, data, fn, /*INTERNAL*/ one ) { + var type, origFn; + + // Types can be a map of types/handlers + if ( typeof types === "object" ) { + // ( types-Object, selector, data ) + if ( typeof selector !== "string" ) { + // ( types-Object, data ) + data = data || selector; + selector = undefined; + } + for ( type in types ) { + this.on( type, selector, data, types[ type ], one ); + } + return this; + } + + if ( data == null && fn == null ) { + // ( types, fn ) + fn = selector; + data = selector = undefined; + } else if ( fn == null ) { + if ( typeof selector === "string" ) { + // ( types, selector, fn ) + fn = data; + data = undefined; + } else { + // ( types, data, fn ) + fn = data; + data = selector; + selector = undefined; + } + } + if ( fn === false ) { + fn = returnFalse; + } else if ( !fn ) { + return this; + } + + if ( one === 1 ) { + origFn = fn; + fn = function( event ) { + // Can use an empty set, since event contains the info + jQuery().off( event ); + return origFn.apply( this, arguments ); + }; + // Use same guid so caller can remove using origFn + fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ ); + } + return this.each( function() { + jQuery.event.add( this, types, fn, data, selector ); + }); + }, + one: function( types, selector, data, fn ) { + return this.on( types, selector, data, fn, 1 ); + }, + off: function( types, selector, fn ) { + var handleObj, type; + if ( types && types.preventDefault && types.handleObj ) { + // ( event ) dispatched jQuery.Event + handleObj = types.handleObj; + jQuery( types.delegateTarget ).off( + handleObj.namespace ? handleObj.origType + "." + handleObj.namespace : handleObj.origType, + handleObj.selector, + handleObj.handler + ); + return this; + } + if ( typeof types === "object" ) { + // ( types-object [, selector] ) + for ( type in types ) { + this.off( type, selector, types[ type ] ); + } + return this; + } + if ( selector === false || typeof selector === "function" ) { + // ( types [, fn] ) + fn = selector; + selector = undefined; + } + if ( fn === false ) { + fn = returnFalse; + } + return this.each(function() { + jQuery.event.remove( this, types, fn, selector ); + }); + }, + + bind: function( types, data, fn ) { + return this.on( types, null, data, fn ); + }, + unbind: function( types, fn ) { + return this.off( types, null, fn ); + }, + + delegate: function( selector, types, data, fn ) { + return this.on( types, selector, data, fn ); + }, + undelegate: function( selector, types, fn ) { + // ( namespace ) or ( selector, types [, fn] ) + return arguments.length === 1 ? this.off( selector, "**" ) : this.off( types, selector || "**", fn ); + }, + + trigger: function( type, data ) { + return this.each(function() { + jQuery.event.trigger( type, data, this ); + }); + }, + triggerHandler: function( type, data ) { + var elem = this[0]; + if ( elem ) { + return jQuery.event.trigger( type, data, elem, true ); + } + } +}); +/*! + * Sizzle CSS Selector Engine + * Copyright 2012 jQuery Foundation and other contributors + * Released under the MIT license + * http://sizzlejs.com/ + */ +(function( window, undefined ) { + +var i, + cachedruns, + Expr, + getText, + isXML, + compile, + hasDuplicate, + outermostContext, + + // Local document vars + setDocument, + document, + docElem, + documentIsXML, + rbuggyQSA, + rbuggyMatches, + matches, + contains, + sortOrder, + + // Instance-specific data + expando = "sizzle" + -(new Date()), + preferredDoc = window.document, + support = {}, + dirruns = 0, + done = 0, + classCache = createCache(), + tokenCache = createCache(), + compilerCache = createCache(), + + // General-purpose constants + strundefined = typeof undefined, + MAX_NEGATIVE = 1 << 31, + + // Array methods + arr = [], + pop = arr.pop, + push = arr.push, + slice = arr.slice, + // Use a stripped-down indexOf if we can't use a native one + indexOf = arr.indexOf || function( elem ) { + var i = 0, + len = this.length; + for ( ; i < len; i++ ) { + if ( this[i] === elem ) { + return i; + } + } + return -1; + }, + + + // Regular expressions + + // Whitespace characters http://www.w3.org/TR/css3-selectors/#whitespace + whitespace = "[\\x20\\t\\r\\n\\f]", + // http://www.w3.org/TR/css3-syntax/#characters + characterEncoding = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+", + + // Loosely modeled on CSS identifier characters + // An unquoted value should be a CSS identifier http://www.w3.org/TR/css3-selectors/#attribute-selectors + // Proper syntax: http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier + identifier = characterEncoding.replace( "w", "w#" ), + + // Acceptable operators http://www.w3.org/TR/selectors/#attribute-selectors + operators = "([*^$|!~]?=)", + attributes = "\\[" + whitespace + "*(" + characterEncoding + ")" + whitespace + + "*(?:" + operators + whitespace + "*(?:(['\"])((?:\\\\.|[^\\\\])*?)\\3|(" + identifier + ")|)|)" + whitespace + "*\\]", + + // Prefer arguments quoted, + // then not containing pseudos/brackets, + // then attribute selectors/non-parenthetical expressions, + // then anything else + // These preferences are here to reduce the number of selectors + // needing tokenize in the PSEUDO preFilter + pseudos = ":(" + characterEncoding + ")(?:\\(((['\"])((?:\\\\.|[^\\\\])*?)\\3|((?:\\\\.|[^\\\\()[\\]]|" + attributes.replace( 3, 8 ) + ")*)|.*)\\)|)", + + // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter + rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ), + + rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ), + rcombinators = new RegExp( "^" + whitespace + "*([\\x20\\t\\r\\n\\f>+~])" + whitespace + "*" ), + rpseudo = new RegExp( pseudos ), + ridentifier = new RegExp( "^" + identifier + "$" ), + + matchExpr = { + "ID": new RegExp( "^#(" + characterEncoding + ")" ), + "CLASS": new RegExp( "^\\.(" + characterEncoding + ")" ), + "NAME": new RegExp( "^\\[name=['\"]?(" + characterEncoding + ")['\"]?\\]" ), + "TAG": new RegExp( "^(" + characterEncoding.replace( "w", "w*" ) + ")" ), + "ATTR": new RegExp( "^" + attributes ), + "PSEUDO": new RegExp( "^" + pseudos ), + "CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace + + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace + + "*(\\d+)|))" + whitespace + "*\\)|)", "i" ), + // For use in libraries implementing .is() + // We use this for POS matching in `select` + "needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + + whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" ) + }, + + rsibling = /[\x20\t\r\n\f]*[+~]/, + + rnative = /^[^{]+\{\s*\[native code/, + + // Easily-parseable/retrievable ID or TAG or CLASS selectors + rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/, + + rinputs = /^(?:input|select|textarea|button)$/i, + rheader = /^h\d$/i, + + rescape = /'|\\/g, + rattributeQuotes = /\=[\x20\t\r\n\f]*([^'"\]]*)[\x20\t\r\n\f]*\]/g, + + // CSS escapes http://www.w3.org/TR/CSS21/syndata.html#escaped-characters + runescape = /\\([\da-fA-F]{1,6}[\x20\t\r\n\f]?|.)/g, + funescape = function( _, escaped ) { + var high = "0x" + escaped - 0x10000; + // NaN means non-codepoint + return high !== high ? + escaped : + // BMP codepoint + high < 0 ? + String.fromCharCode( high + 0x10000 ) : + // Supplemental Plane codepoint (surrogate pair) + String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 ); + }; + +// Use a stripped-down slice if we can't use a native one +try { + slice.call( preferredDoc.documentElement.childNodes, 0 )[0].nodeType; +} catch ( e ) { + slice = function( i ) { + var elem, + results = []; + while ( (elem = this[i++]) ) { + results.push( elem ); + } + return results; + }; +} + +/** + * For feature detection + * @param {Function} fn The function to test for native support + */ +function isNative( fn ) { + return rnative.test( fn + "" ); +} + +/** + * Create key-value caches of limited size + * @returns {Function(string, Object)} Returns the Object data after storing it on itself with + * property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength) + * deleting the oldest entry + */ +function createCache() { + var cache, + keys = []; + + return (cache = function( key, value ) { + // Use (key + " ") to avoid collision with native prototype properties (see Issue #157) + if ( keys.push( key += " " ) > Expr.cacheLength ) { + // Only keep the most recent entries + delete cache[ keys.shift() ]; + } + return (cache[ key ] = value); + }); +} + +/** + * Mark a function for special use by Sizzle + * @param {Function} fn The function to mark + */ +function markFunction( fn ) { + fn[ expando ] = true; + return fn; +} + +/** + * Support testing using an element + * @param {Function} fn Passed the created div and expects a boolean result + */ +function assert( fn ) { + var div = document.createElement("div"); + + try { + return fn( div ); + } catch (e) { + return false; + } finally { + // release memory in IE + div = null; + } +} + +function Sizzle( selector, context, results, seed ) { + var match, elem, m, nodeType, + // QSA vars + i, groups, old, nid, newContext, newSelector; + + if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) { + setDocument( context ); + } + + context = context || document; + results = results || []; + + if ( !selector || typeof selector !== "string" ) { + return results; + } + + if ( (nodeType = context.nodeType) !== 1 && nodeType !== 9 ) { + return []; + } + + if ( !documentIsXML && !seed ) { + + // Shortcuts + if ( (match = rquickExpr.exec( selector )) ) { + // Speed-up: Sizzle("#ID") + if ( (m = match[1]) ) { + if ( nodeType === 9 ) { + elem = context.getElementById( m ); + // Check parentNode to catch when Blackberry 4.6 returns + // nodes that are no longer in the document #6963 + if ( elem && elem.parentNode ) { + // Handle the case where IE, Opera, and Webkit return items + // by name instead of ID + if ( elem.id === m ) { + results.push( elem ); + return results; + } + } else { + return results; + } + } else { + // Context is not a document + if ( context.ownerDocument && (elem = context.ownerDocument.getElementById( m )) && + contains( context, elem ) && elem.id === m ) { + results.push( elem ); + return results; + } + } + + // Speed-up: Sizzle("TAG") + } else if ( match[2] ) { + push.apply( results, slice.call(context.getElementsByTagName( selector ), 0) ); + return results; + + // Speed-up: Sizzle(".CLASS") + } else if ( (m = match[3]) && support.getByClassName && context.getElementsByClassName ) { + push.apply( results, slice.call(context.getElementsByClassName( m ), 0) ); + return results; + } + } + + // QSA path + if ( support.qsa && !rbuggyQSA.test(selector) ) { + old = true; + nid = expando; + newContext = context; + newSelector = nodeType === 9 && selector; + + // qSA works strangely on Element-rooted queries + // We can work around this by specifying an extra ID on the root + // and working up from there (Thanks to Andrew Dupont for the technique) + // IE 8 doesn't work on object elements + if ( nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) { + groups = tokenize( selector ); + + if ( (old = context.getAttribute("id")) ) { + nid = old.replace( rescape, "\\$&" ); + } else { + context.setAttribute( "id", nid ); + } + nid = "[id='" + nid + "'] "; + + i = groups.length; + while ( i-- ) { + groups[i] = nid + toSelector( groups[i] ); + } + newContext = rsibling.test( selector ) && context.parentNode || context; + newSelector = groups.join(","); + } + + if ( newSelector ) { + try { + push.apply( results, slice.call( newContext.querySelectorAll( + newSelector + ), 0 ) ); + return results; + } catch(qsaError) { + } finally { + if ( !old ) { + context.removeAttribute("id"); + } + } + } + } + } + + // All others + return select( selector.replace( rtrim, "$1" ), context, results, seed ); +} + +/** + * Detect xml + * @param {Element|Object} elem An element or a document + */ +isXML = Sizzle.isXML = function( elem ) { + // documentElement is verified for cases where it doesn't yet exist + // (such as loading iframes in IE - #4833) + var documentElement = elem && (elem.ownerDocument || elem).documentElement; + return documentElement ? documentElement.nodeName !== "HTML" : false; +}; + +/** + * Sets document-related variables once based on the current document + * @param {Element|Object} [doc] An element or document object to use to set the document + * @returns {Object} Returns the current document + */ +setDocument = Sizzle.setDocument = function( node ) { + var doc = node ? node.ownerDocument || node : preferredDoc; + + // If no document and documentElement is available, return + if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) { + return document; + } + + // Set our document + document = doc; + docElem = doc.documentElement; + + // Support tests + documentIsXML = isXML( doc ); + + // Check if getElementsByTagName("*") returns only elements + support.tagNameNoComments = assert(function( div ) { + div.appendChild( doc.createComment("") ); + return !div.getElementsByTagName("*").length; + }); + + // Check if attributes should be retrieved by attribute nodes + support.attributes = assert(function( div ) { + div.innerHTML = ""; + var type = typeof div.lastChild.getAttribute("multiple"); + // IE8 returns a string for some attributes even when not present + return type !== "boolean" && type !== "string"; + }); + + // Check if getElementsByClassName can be trusted + support.getByClassName = assert(function( div ) { + // Opera can't find a second classname (in 9.6) + div.innerHTML = ""; + if ( !div.getElementsByClassName || !div.getElementsByClassName("e").length ) { + return false; + } + + // Safari 3.2 caches class attributes and doesn't catch changes + div.lastChild.className = "e"; + return div.getElementsByClassName("e").length === 2; + }); + + // Check if getElementById returns elements by name + // Check if getElementsByName privileges form controls or returns elements by ID + support.getByName = assert(function( div ) { + // Inject content + div.id = expando + 0; + div.innerHTML = "
    "; + docElem.insertBefore( div, docElem.firstChild ); + + // Test + var pass = doc.getElementsByName && + // buggy browsers will return fewer than the correct 2 + doc.getElementsByName( expando ).length === 2 + + // buggy browsers will return more than the correct 0 + doc.getElementsByName( expando + 0 ).length; + support.getIdNotName = !doc.getElementById( expando ); + + // Cleanup + docElem.removeChild( div ); + + return pass; + }); + + // IE6/7 return modified attributes + Expr.attrHandle = assert(function( div ) { + div.innerHTML = ""; + return div.firstChild && typeof div.firstChild.getAttribute !== strundefined && + div.firstChild.getAttribute("href") === "#"; + }) ? + {} : + { + "href": function( elem ) { + return elem.getAttribute( "href", 2 ); + }, + "type": function( elem ) { + return elem.getAttribute("type"); + } + }; + + // ID find and filter + if ( support.getIdNotName ) { + Expr.find["ID"] = function( id, context ) { + if ( typeof context.getElementById !== strundefined && !documentIsXML ) { + var m = context.getElementById( id ); + // Check parentNode to catch when Blackberry 4.6 returns + // nodes that are no longer in the document #6963 + return m && m.parentNode ? [m] : []; + } + }; + Expr.filter["ID"] = function( id ) { + var attrId = id.replace( runescape, funescape ); + return function( elem ) { + return elem.getAttribute("id") === attrId; + }; + }; + } else { + Expr.find["ID"] = function( id, context ) { + if ( typeof context.getElementById !== strundefined && !documentIsXML ) { + var m = context.getElementById( id ); + + return m ? + m.id === id || typeof m.getAttributeNode !== strundefined && m.getAttributeNode("id").value === id ? + [m] : + undefined : + []; + } + }; + Expr.filter["ID"] = function( id ) { + var attrId = id.replace( runescape, funescape ); + return function( elem ) { + var node = typeof elem.getAttributeNode !== strundefined && elem.getAttributeNode("id"); + return node && node.value === attrId; + }; + }; + } + + // Tag + Expr.find["TAG"] = support.tagNameNoComments ? + function( tag, context ) { + if ( typeof context.getElementsByTagName !== strundefined ) { + return context.getElementsByTagName( tag ); + } + } : + function( tag, context ) { + var elem, + tmp = [], + i = 0, + results = context.getElementsByTagName( tag ); + + // Filter out possible comments + if ( tag === "*" ) { + while ( (elem = results[i++]) ) { + if ( elem.nodeType === 1 ) { + tmp.push( elem ); + } + } + + return tmp; + } + return results; + }; + + // Name + Expr.find["NAME"] = support.getByName && function( tag, context ) { + if ( typeof context.getElementsByName !== strundefined ) { + return context.getElementsByName( name ); + } + }; + + // Class + Expr.find["CLASS"] = support.getByClassName && function( className, context ) { + if ( typeof context.getElementsByClassName !== strundefined && !documentIsXML ) { + return context.getElementsByClassName( className ); + } + }; + + // QSA and matchesSelector support + + // matchesSelector(:active) reports false when true (IE9/Opera 11.5) + rbuggyMatches = []; + + // qSa(:focus) reports false when true (Chrome 21), + // no need to also add to buggyMatches since matches checks buggyQSA + // A support test would require too much code (would include document ready) + rbuggyQSA = [ ":focus" ]; + + if ( (support.qsa = isNative(doc.querySelectorAll)) ) { + // Build QSA regex + // Regex strategy adopted from Diego Perini + assert(function( div ) { + // Select is set to empty string on purpose + // This is to test IE's treatment of not explictly + // setting a boolean content attribute, + // since its presence should be enough + // http://bugs.jquery.com/ticket/12359 + div.innerHTML = ""; + + // IE8 - Some boolean attributes are not treated correctly + if ( !div.querySelectorAll("[selected]").length ) { + rbuggyQSA.push( "\\[" + whitespace + "*(?:checked|disabled|ismap|multiple|readonly|selected|value)" ); + } + + // Webkit/Opera - :checked should return selected option elements + // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked + // IE8 throws error here and will not see later tests + if ( !div.querySelectorAll(":checked").length ) { + rbuggyQSA.push(":checked"); + } + }); + + assert(function( div ) { + + // Opera 10-12/IE8 - ^= $= *= and empty values + // Should not select anything + div.innerHTML = ""; + if ( div.querySelectorAll("[i^='']").length ) { + rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:\"\"|'')" ); + } + + // FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled) + // IE8 throws error here and will not see later tests + if ( !div.querySelectorAll(":enabled").length ) { + rbuggyQSA.push( ":enabled", ":disabled" ); + } + + // Opera 10-11 does not throw on post-comma invalid pseudos + div.querySelectorAll("*,:x"); + rbuggyQSA.push(",.*:"); + }); + } + + if ( (support.matchesSelector = isNative( (matches = docElem.matchesSelector || + docElem.mozMatchesSelector || + docElem.webkitMatchesSelector || + docElem.oMatchesSelector || + docElem.msMatchesSelector) )) ) { + + assert(function( div ) { + // Check to see if it's possible to do matchesSelector + // on a disconnected node (IE 9) + support.disconnectedMatch = matches.call( div, "div" ); + + // This should fail with an exception + // Gecko does not error, returns false instead + matches.call( div, "[s!='']:x" ); + rbuggyMatches.push( "!=", pseudos ); + }); + } + + rbuggyQSA = new RegExp( rbuggyQSA.join("|") ); + rbuggyMatches = new RegExp( rbuggyMatches.join("|") ); + + // Element contains another + // Purposefully does not implement inclusive descendent + // As in, an element does not contain itself + contains = isNative(docElem.contains) || docElem.compareDocumentPosition ? + function( a, b ) { + var adown = a.nodeType === 9 ? a.documentElement : a, + bup = b && b.parentNode; + return a === bup || !!( bup && bup.nodeType === 1 && ( + adown.contains ? + adown.contains( bup ) : + a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16 + )); + } : + function( a, b ) { + if ( b ) { + while ( (b = b.parentNode) ) { + if ( b === a ) { + return true; + } + } + } + return false; + }; + + // Document order sorting + sortOrder = docElem.compareDocumentPosition ? + function( a, b ) { + var compare; + + if ( a === b ) { + hasDuplicate = true; + return 0; + } + + if ( (compare = b.compareDocumentPosition && a.compareDocumentPosition && a.compareDocumentPosition( b )) ) { + if ( compare & 1 || a.parentNode && a.parentNode.nodeType === 11 ) { + if ( a === doc || contains( preferredDoc, a ) ) { + return -1; + } + if ( b === doc || contains( preferredDoc, b ) ) { + return 1; + } + return 0; + } + return compare & 4 ? -1 : 1; + } + + return a.compareDocumentPosition ? -1 : 1; + } : + function( a, b ) { + var cur, + i = 0, + aup = a.parentNode, + bup = b.parentNode, + ap = [ a ], + bp = [ b ]; + + // Exit early if the nodes are identical + if ( a === b ) { + hasDuplicate = true; + return 0; + + // Parentless nodes are either documents or disconnected + } else if ( !aup || !bup ) { + return a === doc ? -1 : + b === doc ? 1 : + aup ? -1 : + bup ? 1 : + 0; + + // If the nodes are siblings, we can do a quick check + } else if ( aup === bup ) { + return siblingCheck( a, b ); + } + + // Otherwise we need full lists of their ancestors for comparison + cur = a; + while ( (cur = cur.parentNode) ) { + ap.unshift( cur ); + } + cur = b; + while ( (cur = cur.parentNode) ) { + bp.unshift( cur ); + } + + // Walk down the tree looking for a discrepancy + while ( ap[i] === bp[i] ) { + i++; + } + + return i ? + // Do a sibling check if the nodes have a common ancestor + siblingCheck( ap[i], bp[i] ) : + + // Otherwise nodes in our document sort first + ap[i] === preferredDoc ? -1 : + bp[i] === preferredDoc ? 1 : + 0; + }; + + // Always assume the presence of duplicates if sort doesn't + // pass them to our comparison function (as in Google Chrome). + hasDuplicate = false; + [0, 0].sort( sortOrder ); + support.detectDuplicates = hasDuplicate; + + return document; +}; + +Sizzle.matches = function( expr, elements ) { + return Sizzle( expr, null, null, elements ); +}; + +Sizzle.matchesSelector = function( elem, expr ) { + // Set document vars if needed + if ( ( elem.ownerDocument || elem ) !== document ) { + setDocument( elem ); + } + + // Make sure that attribute selectors are quoted + expr = expr.replace( rattributeQuotes, "='$1']" ); + + // rbuggyQSA always contains :focus, so no need for an existence check + if ( support.matchesSelector && !documentIsXML && (!rbuggyMatches || !rbuggyMatches.test(expr)) && !rbuggyQSA.test(expr) ) { + try { + var ret = matches.call( elem, expr ); + + // IE 9's matchesSelector returns false on disconnected nodes + if ( ret || support.disconnectedMatch || + // As well, disconnected nodes are said to be in a document + // fragment in IE 9 + elem.document && elem.document.nodeType !== 11 ) { + return ret; + } + } catch(e) {} + } + + return Sizzle( expr, document, null, [elem] ).length > 0; +}; + +Sizzle.contains = function( context, elem ) { + // Set document vars if needed + if ( ( context.ownerDocument || context ) !== document ) { + setDocument( context ); + } + return contains( context, elem ); +}; + +Sizzle.attr = function( elem, name ) { + var val; + + // Set document vars if needed + if ( ( elem.ownerDocument || elem ) !== document ) { + setDocument( elem ); + } + + if ( !documentIsXML ) { + name = name.toLowerCase(); + } + if ( (val = Expr.attrHandle[ name ]) ) { + return val( elem ); + } + if ( documentIsXML || support.attributes ) { + return elem.getAttribute( name ); + } + return ( (val = elem.getAttributeNode( name )) || elem.getAttribute( name ) ) && elem[ name ] === true ? + name : + val && val.specified ? val.value : null; +}; + +Sizzle.error = function( msg ) { + throw new Error( "Syntax error, unrecognized expression: " + msg ); +}; + +// Document sorting and removing duplicates +Sizzle.uniqueSort = function( results ) { + var elem, + duplicates = [], + i = 1, + j = 0; + + // Unless we *know* we can detect duplicates, assume their presence + hasDuplicate = !support.detectDuplicates; + results.sort( sortOrder ); + + if ( hasDuplicate ) { + for ( ; (elem = results[i]); i++ ) { + if ( elem === results[ i - 1 ] ) { + j = duplicates.push( i ); + } + } + while ( j-- ) { + results.splice( duplicates[ j ], 1 ); + } + } + + return results; +}; + +function siblingCheck( a, b ) { + var cur = b && a, + diff = cur && ( ~b.sourceIndex || MAX_NEGATIVE ) - ( ~a.sourceIndex || MAX_NEGATIVE ); + + // Use IE sourceIndex if available on both nodes + if ( diff ) { + return diff; + } + + // Check if b follows a + if ( cur ) { + while ( (cur = cur.nextSibling) ) { + if ( cur === b ) { + return -1; + } + } + } + + return a ? 1 : -1; +} + +// Returns a function to use in pseudos for input types +function createInputPseudo( type ) { + return function( elem ) { + var name = elem.nodeName.toLowerCase(); + return name === "input" && elem.type === type; + }; +} + +// Returns a function to use in pseudos for buttons +function createButtonPseudo( type ) { + return function( elem ) { + var name = elem.nodeName.toLowerCase(); + return (name === "input" || name === "button") && elem.type === type; + }; +} + +// Returns a function to use in pseudos for positionals +function createPositionalPseudo( fn ) { + return markFunction(function( argument ) { + argument = +argument; + return markFunction(function( seed, matches ) { + var j, + matchIndexes = fn( [], seed.length, argument ), + i = matchIndexes.length; + + // Match elements found at the specified indexes + while ( i-- ) { + if ( seed[ (j = matchIndexes[i]) ] ) { + seed[j] = !(matches[j] = seed[j]); + } + } + }); + }); +} + +/** + * Utility function for retrieving the text value of an array of DOM nodes + * @param {Array|Element} elem + */ +getText = Sizzle.getText = function( elem ) { + var node, + ret = "", + i = 0, + nodeType = elem.nodeType; + + if ( !nodeType ) { + // If no nodeType, this is expected to be an array + for ( ; (node = elem[i]); i++ ) { + // Do not traverse comment nodes + ret += getText( node ); + } + } else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) { + // Use textContent for elements + // innerText usage removed for consistency of new lines (see #11153) + if ( typeof elem.textContent === "string" ) { + return elem.textContent; + } else { + // Traverse its children + for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { + ret += getText( elem ); + } + } + } else if ( nodeType === 3 || nodeType === 4 ) { + return elem.nodeValue; + } + // Do not include comment or processing instruction nodes + + return ret; +}; + +Expr = Sizzle.selectors = { + + // Can be adjusted by the user + cacheLength: 50, + + createPseudo: markFunction, + + match: matchExpr, + + find: {}, + + relative: { + ">": { dir: "parentNode", first: true }, + " ": { dir: "parentNode" }, + "+": { dir: "previousSibling", first: true }, + "~": { dir: "previousSibling" } + }, + + preFilter: { + "ATTR": function( match ) { + match[1] = match[1].replace( runescape, funescape ); + + // Move the given value to match[3] whether quoted or unquoted + match[3] = ( match[4] || match[5] || "" ).replace( runescape, funescape ); + + if ( match[2] === "~=" ) { + match[3] = " " + match[3] + " "; + } + + return match.slice( 0, 4 ); + }, + + "CHILD": function( match ) { + /* matches from matchExpr["CHILD"] + 1 type (only|nth|...) + 2 what (child|of-type) + 3 argument (even|odd|\d*|\d*n([+-]\d+)?|...) + 4 xn-component of xn+y argument ([+-]?\d*n|) + 5 sign of xn-component + 6 x of xn-component + 7 sign of y-component + 8 y of y-component + */ + match[1] = match[1].toLowerCase(); + + if ( match[1].slice( 0, 3 ) === "nth" ) { + // nth-* requires argument + if ( !match[3] ) { + Sizzle.error( match[0] ); + } + + // numeric x and y parameters for Expr.filter.CHILD + // remember that false/true cast respectively to 0/1 + match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) ); + match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" ); + + // other types prohibit arguments + } else if ( match[3] ) { + Sizzle.error( match[0] ); + } + + return match; + }, + + "PSEUDO": function( match ) { + var excess, + unquoted = !match[5] && match[2]; + + if ( matchExpr["CHILD"].test( match[0] ) ) { + return null; + } + + // Accept quoted arguments as-is + if ( match[4] ) { + match[2] = match[4]; + + // Strip excess characters from unquoted arguments + } else if ( unquoted && rpseudo.test( unquoted ) && + // Get excess from tokenize (recursively) + (excess = tokenize( unquoted, true )) && + // advance to the next closing parenthesis + (excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) { + + // excess is a negative index + match[0] = match[0].slice( 0, excess ); + match[2] = unquoted.slice( 0, excess ); + } + + // Return only captures needed by the pseudo filter method (type and argument) + return match.slice( 0, 3 ); + } + }, + + filter: { + + "TAG": function( nodeName ) { + if ( nodeName === "*" ) { + return function() { return true; }; + } + + nodeName = nodeName.replace( runescape, funescape ).toLowerCase(); + return function( elem ) { + return elem.nodeName && elem.nodeName.toLowerCase() === nodeName; + }; + }, + + "CLASS": function( className ) { + var pattern = classCache[ className + " " ]; + + return pattern || + (pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) && + classCache( className, function( elem ) { + return pattern.test( elem.className || (typeof elem.getAttribute !== strundefined && elem.getAttribute("class")) || "" ); + }); + }, + + "ATTR": function( name, operator, check ) { + return function( elem ) { + var result = Sizzle.attr( elem, name ); + + if ( result == null ) { + return operator === "!="; + } + if ( !operator ) { + return true; + } + + result += ""; + + return operator === "=" ? result === check : + operator === "!=" ? result !== check : + operator === "^=" ? check && result.indexOf( check ) === 0 : + operator === "*=" ? check && result.indexOf( check ) > -1 : + operator === "$=" ? check && result.slice( -check.length ) === check : + operator === "~=" ? ( " " + result + " " ).indexOf( check ) > -1 : + operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" : + false; + }; + }, + + "CHILD": function( type, what, argument, first, last ) { + var simple = type.slice( 0, 3 ) !== "nth", + forward = type.slice( -4 ) !== "last", + ofType = what === "of-type"; + + return first === 1 && last === 0 ? + + // Shortcut for :nth-*(n) + function( elem ) { + return !!elem.parentNode; + } : + + function( elem, context, xml ) { + var cache, outerCache, node, diff, nodeIndex, start, + dir = simple !== forward ? "nextSibling" : "previousSibling", + parent = elem.parentNode, + name = ofType && elem.nodeName.toLowerCase(), + useCache = !xml && !ofType; + + if ( parent ) { + + // :(first|last|only)-(child|of-type) + if ( simple ) { + while ( dir ) { + node = elem; + while ( (node = node[ dir ]) ) { + if ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) { + return false; + } + } + // Reverse direction for :only-* (if we haven't yet done so) + start = dir = type === "only" && !start && "nextSibling"; + } + return true; + } + + start = [ forward ? parent.firstChild : parent.lastChild ]; + + // non-xml :nth-child(...) stores cache data on `parent` + if ( forward && useCache ) { + // Seek `elem` from a previously-cached index + outerCache = parent[ expando ] || (parent[ expando ] = {}); + cache = outerCache[ type ] || []; + nodeIndex = cache[0] === dirruns && cache[1]; + diff = cache[0] === dirruns && cache[2]; + node = nodeIndex && parent.childNodes[ nodeIndex ]; + + while ( (node = ++nodeIndex && node && node[ dir ] || + + // Fallback to seeking `elem` from the start + (diff = nodeIndex = 0) || start.pop()) ) { + + // When found, cache indexes on `parent` and break + if ( node.nodeType === 1 && ++diff && node === elem ) { + outerCache[ type ] = [ dirruns, nodeIndex, diff ]; + break; + } + } + + // Use previously-cached element index if available + } else if ( useCache && (cache = (elem[ expando ] || (elem[ expando ] = {}))[ type ]) && cache[0] === dirruns ) { + diff = cache[1]; + + // xml :nth-child(...) or :nth-last-child(...) or :nth(-last)?-of-type(...) + } else { + // Use the same loop as above to seek `elem` from the start + while ( (node = ++nodeIndex && node && node[ dir ] || + (diff = nodeIndex = 0) || start.pop()) ) { + + if ( ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) && ++diff ) { + // Cache the index of each encountered element + if ( useCache ) { + (node[ expando ] || (node[ expando ] = {}))[ type ] = [ dirruns, diff ]; + } + + if ( node === elem ) { + break; + } + } + } + } + + // Incorporate the offset, then check against cycle size + diff -= last; + return diff === first || ( diff % first === 0 && diff / first >= 0 ); + } + }; + }, + + "PSEUDO": function( pseudo, argument ) { + // pseudo-class names are case-insensitive + // http://www.w3.org/TR/selectors/#pseudo-classes + // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters + // Remember that setFilters inherits from pseudos + var args, + fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] || + Sizzle.error( "unsupported pseudo: " + pseudo ); + + // The user may use createPseudo to indicate that + // arguments are needed to create the filter function + // just as Sizzle does + if ( fn[ expando ] ) { + return fn( argument ); + } + + // But maintain support for old signatures + if ( fn.length > 1 ) { + args = [ pseudo, pseudo, "", argument ]; + return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ? + markFunction(function( seed, matches ) { + var idx, + matched = fn( seed, argument ), + i = matched.length; + while ( i-- ) { + idx = indexOf.call( seed, matched[i] ); + seed[ idx ] = !( matches[ idx ] = matched[i] ); + } + }) : + function( elem ) { + return fn( elem, 0, args ); + }; + } + + return fn; + } + }, + + pseudos: { + // Potentially complex pseudos + "not": markFunction(function( selector ) { + // Trim the selector passed to compile + // to avoid treating leading and trailing + // spaces as combinators + var input = [], + results = [], + matcher = compile( selector.replace( rtrim, "$1" ) ); + + return matcher[ expando ] ? + markFunction(function( seed, matches, context, xml ) { + var elem, + unmatched = matcher( seed, null, xml, [] ), + i = seed.length; + + // Match elements unmatched by `matcher` + while ( i-- ) { + if ( (elem = unmatched[i]) ) { + seed[i] = !(matches[i] = elem); + } + } + }) : + function( elem, context, xml ) { + input[0] = elem; + matcher( input, null, xml, results ); + return !results.pop(); + }; + }), + + "has": markFunction(function( selector ) { + return function( elem ) { + return Sizzle( selector, elem ).length > 0; + }; + }), + + "contains": markFunction(function( text ) { + return function( elem ) { + return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1; + }; + }), + + // "Whether an element is represented by a :lang() selector + // is based solely on the element's language value + // being equal to the identifier C, + // or beginning with the identifier C immediately followed by "-". + // The matching of C against the element's language value is performed case-insensitively. + // The identifier C does not have to be a valid language name." + // http://www.w3.org/TR/selectors/#lang-pseudo + "lang": markFunction( function( lang ) { + // lang value must be a valid identifider + if ( !ridentifier.test(lang || "") ) { + Sizzle.error( "unsupported lang: " + lang ); + } + lang = lang.replace( runescape, funescape ).toLowerCase(); + return function( elem ) { + var elemLang; + do { + if ( (elemLang = documentIsXML ? + elem.getAttribute("xml:lang") || elem.getAttribute("lang") : + elem.lang) ) { + + elemLang = elemLang.toLowerCase(); + return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0; + } + } while ( (elem = elem.parentNode) && elem.nodeType === 1 ); + return false; + }; + }), + + // Miscellaneous + "target": function( elem ) { + var hash = window.location && window.location.hash; + return hash && hash.slice( 1 ) === elem.id; + }, + + "root": function( elem ) { + return elem === docElem; + }, + + "focus": function( elem ) { + return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex); + }, + + // Boolean properties + "enabled": function( elem ) { + return elem.disabled === false; + }, + + "disabled": function( elem ) { + return elem.disabled === true; + }, + + "checked": function( elem ) { + // In CSS3, :checked should return both checked and selected elements + // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked + var nodeName = elem.nodeName.toLowerCase(); + return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected); + }, + + "selected": function( elem ) { + // Accessing this property makes selected-by-default + // options in Safari work properly + if ( elem.parentNode ) { + elem.parentNode.selectedIndex; + } + + return elem.selected === true; + }, + + // Contents + "empty": function( elem ) { + // http://www.w3.org/TR/selectors/#empty-pseudo + // :empty is only affected by element nodes and content nodes(including text(3), cdata(4)), + // not comment, processing instructions, or others + // Thanks to Diego Perini for the nodeName shortcut + // Greater than "@" means alpha characters (specifically not starting with "#" or "?") + for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { + if ( elem.nodeName > "@" || elem.nodeType === 3 || elem.nodeType === 4 ) { + return false; + } + } + return true; + }, + + "parent": function( elem ) { + return !Expr.pseudos["empty"]( elem ); + }, + + // Element/input types + "header": function( elem ) { + return rheader.test( elem.nodeName ); + }, + + "input": function( elem ) { + return rinputs.test( elem.nodeName ); + }, + + "button": function( elem ) { + var name = elem.nodeName.toLowerCase(); + return name === "input" && elem.type === "button" || name === "button"; + }, + + "text": function( elem ) { + var attr; + // IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc) + // use getAttribute instead to test this case + return elem.nodeName.toLowerCase() === "input" && + elem.type === "text" && + ( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === elem.type ); + }, + + // Position-in-collection + "first": createPositionalPseudo(function() { + return [ 0 ]; + }), + + "last": createPositionalPseudo(function( matchIndexes, length ) { + return [ length - 1 ]; + }), + + "eq": createPositionalPseudo(function( matchIndexes, length, argument ) { + return [ argument < 0 ? argument + length : argument ]; + }), + + "even": createPositionalPseudo(function( matchIndexes, length ) { + var i = 0; + for ( ; i < length; i += 2 ) { + matchIndexes.push( i ); + } + return matchIndexes; + }), + + "odd": createPositionalPseudo(function( matchIndexes, length ) { + var i = 1; + for ( ; i < length; i += 2 ) { + matchIndexes.push( i ); + } + return matchIndexes; + }), + + "lt": createPositionalPseudo(function( matchIndexes, length, argument ) { + var i = argument < 0 ? argument + length : argument; + for ( ; --i >= 0; ) { + matchIndexes.push( i ); + } + return matchIndexes; + }), + + "gt": createPositionalPseudo(function( matchIndexes, length, argument ) { + var i = argument < 0 ? argument + length : argument; + for ( ; ++i < length; ) { + matchIndexes.push( i ); + } + return matchIndexes; + }) + } +}; + +// Add button/input type pseudos +for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) { + Expr.pseudos[ i ] = createInputPseudo( i ); +} +for ( i in { submit: true, reset: true } ) { + Expr.pseudos[ i ] = createButtonPseudo( i ); +} + +function tokenize( selector, parseOnly ) { + var matched, match, tokens, type, + soFar, groups, preFilters, + cached = tokenCache[ selector + " " ]; + + if ( cached ) { + return parseOnly ? 0 : cached.slice( 0 ); + } + + soFar = selector; + groups = []; + preFilters = Expr.preFilter; + + while ( soFar ) { + + // Comma and first run + if ( !matched || (match = rcomma.exec( soFar )) ) { + if ( match ) { + // Don't consume trailing commas as valid + soFar = soFar.slice( match[0].length ) || soFar; + } + groups.push( tokens = [] ); + } + + matched = false; + + // Combinators + if ( (match = rcombinators.exec( soFar )) ) { + matched = match.shift(); + tokens.push( { + value: matched, + // Cast descendant combinators to space + type: match[0].replace( rtrim, " " ) + } ); + soFar = soFar.slice( matched.length ); + } + + // Filters + for ( type in Expr.filter ) { + if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] || + (match = preFilters[ type ]( match ))) ) { + matched = match.shift(); + tokens.push( { + value: matched, + type: type, + matches: match + } ); + soFar = soFar.slice( matched.length ); + } + } + + if ( !matched ) { + break; + } + } + + // Return the length of the invalid excess + // if we're just parsing + // Otherwise, throw an error or return tokens + return parseOnly ? + soFar.length : + soFar ? + Sizzle.error( selector ) : + // Cache the tokens + tokenCache( selector, groups ).slice( 0 ); +} + +function toSelector( tokens ) { + var i = 0, + len = tokens.length, + selector = ""; + for ( ; i < len; i++ ) { + selector += tokens[i].value; + } + return selector; +} + +function addCombinator( matcher, combinator, base ) { + var dir = combinator.dir, + checkNonElements = base && dir === "parentNode", + doneName = done++; + + return combinator.first ? + // Check against closest ancestor/preceding element + function( elem, context, xml ) { + while ( (elem = elem[ dir ]) ) { + if ( elem.nodeType === 1 || checkNonElements ) { + return matcher( elem, context, xml ); + } + } + } : + + // Check against all ancestor/preceding elements + function( elem, context, xml ) { + var data, cache, outerCache, + dirkey = dirruns + " " + doneName; + + // We can't set arbitrary data on XML nodes, so they don't benefit from dir caching + if ( xml ) { + while ( (elem = elem[ dir ]) ) { + if ( elem.nodeType === 1 || checkNonElements ) { + if ( matcher( elem, context, xml ) ) { + return true; + } + } + } + } else { + while ( (elem = elem[ dir ]) ) { + if ( elem.nodeType === 1 || checkNonElements ) { + outerCache = elem[ expando ] || (elem[ expando ] = {}); + if ( (cache = outerCache[ dir ]) && cache[0] === dirkey ) { + if ( (data = cache[1]) === true || data === cachedruns ) { + return data === true; + } + } else { + cache = outerCache[ dir ] = [ dirkey ]; + cache[1] = matcher( elem, context, xml ) || cachedruns; + if ( cache[1] === true ) { + return true; + } + } + } + } + } + }; +} + +function elementMatcher( matchers ) { + return matchers.length > 1 ? + function( elem, context, xml ) { + var i = matchers.length; + while ( i-- ) { + if ( !matchers[i]( elem, context, xml ) ) { + return false; + } + } + return true; + } : + matchers[0]; +} + +function condense( unmatched, map, filter, context, xml ) { + var elem, + newUnmatched = [], + i = 0, + len = unmatched.length, + mapped = map != null; + + for ( ; i < len; i++ ) { + if ( (elem = unmatched[i]) ) { + if ( !filter || filter( elem, context, xml ) ) { + newUnmatched.push( elem ); + if ( mapped ) { + map.push( i ); + } + } + } + } + + return newUnmatched; +} + +function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) { + if ( postFilter && !postFilter[ expando ] ) { + postFilter = setMatcher( postFilter ); + } + if ( postFinder && !postFinder[ expando ] ) { + postFinder = setMatcher( postFinder, postSelector ); + } + return markFunction(function( seed, results, context, xml ) { + var temp, i, elem, + preMap = [], + postMap = [], + preexisting = results.length, + + // Get initial elements from seed or context + elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ), + + // Prefilter to get matcher input, preserving a map for seed-results synchronization + matcherIn = preFilter && ( seed || !selector ) ? + condense( elems, preMap, preFilter, context, xml ) : + elems, + + matcherOut = matcher ? + // If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results, + postFinder || ( seed ? preFilter : preexisting || postFilter ) ? + + // ...intermediate processing is necessary + [] : + + // ...otherwise use results directly + results : + matcherIn; + + // Find primary matches + if ( matcher ) { + matcher( matcherIn, matcherOut, context, xml ); + } + + // Apply postFilter + if ( postFilter ) { + temp = condense( matcherOut, postMap ); + postFilter( temp, [], context, xml ); + + // Un-match failing elements by moving them back to matcherIn + i = temp.length; + while ( i-- ) { + if ( (elem = temp[i]) ) { + matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem); + } + } + } + + if ( seed ) { + if ( postFinder || preFilter ) { + if ( postFinder ) { + // Get the final matcherOut by condensing this intermediate into postFinder contexts + temp = []; + i = matcherOut.length; + while ( i-- ) { + if ( (elem = matcherOut[i]) ) { + // Restore matcherIn since elem is not yet a final match + temp.push( (matcherIn[i] = elem) ); + } + } + postFinder( null, (matcherOut = []), temp, xml ); + } + + // Move matched elements from seed to results to keep them synchronized + i = matcherOut.length; + while ( i-- ) { + if ( (elem = matcherOut[i]) && + (temp = postFinder ? indexOf.call( seed, elem ) : preMap[i]) > -1 ) { + + seed[temp] = !(results[temp] = elem); + } + } + } + + // Add elements to results, through postFinder if defined + } else { + matcherOut = condense( + matcherOut === results ? + matcherOut.splice( preexisting, matcherOut.length ) : + matcherOut + ); + if ( postFinder ) { + postFinder( null, results, matcherOut, xml ); + } else { + push.apply( results, matcherOut ); + } + } + }); +} + +function matcherFromTokens( tokens ) { + var checkContext, matcher, j, + len = tokens.length, + leadingRelative = Expr.relative[ tokens[0].type ], + implicitRelative = leadingRelative || Expr.relative[" "], + i = leadingRelative ? 1 : 0, + + // The foundational matcher ensures that elements are reachable from top-level context(s) + matchContext = addCombinator( function( elem ) { + return elem === checkContext; + }, implicitRelative, true ), + matchAnyContext = addCombinator( function( elem ) { + return indexOf.call( checkContext, elem ) > -1; + }, implicitRelative, true ), + matchers = [ function( elem, context, xml ) { + return ( !leadingRelative && ( xml || context !== outermostContext ) ) || ( + (checkContext = context).nodeType ? + matchContext( elem, context, xml ) : + matchAnyContext( elem, context, xml ) ); + } ]; + + for ( ; i < len; i++ ) { + if ( (matcher = Expr.relative[ tokens[i].type ]) ) { + matchers = [ addCombinator(elementMatcher( matchers ), matcher) ]; + } else { + matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches ); + + // Return special upon seeing a positional matcher + if ( matcher[ expando ] ) { + // Find the next relative operator (if any) for proper handling + j = ++i; + for ( ; j < len; j++ ) { + if ( Expr.relative[ tokens[j].type ] ) { + break; + } + } + return setMatcher( + i > 1 && elementMatcher( matchers ), + i > 1 && toSelector( tokens.slice( 0, i - 1 ) ).replace( rtrim, "$1" ), + matcher, + i < j && matcherFromTokens( tokens.slice( i, j ) ), + j < len && matcherFromTokens( (tokens = tokens.slice( j )) ), + j < len && toSelector( tokens ) + ); + } + matchers.push( matcher ); + } + } + + return elementMatcher( matchers ); +} + +function matcherFromGroupMatchers( elementMatchers, setMatchers ) { + // A counter to specify which element is currently being matched + var matcherCachedRuns = 0, + bySet = setMatchers.length > 0, + byElement = elementMatchers.length > 0, + superMatcher = function( seed, context, xml, results, expandContext ) { + var elem, j, matcher, + setMatched = [], + matchedCount = 0, + i = "0", + unmatched = seed && [], + outermost = expandContext != null, + contextBackup = outermostContext, + // We must always have either seed elements or context + elems = seed || byElement && Expr.find["TAG"]( "*", expandContext && context.parentNode || context ), + // Use integer dirruns iff this is the outermost matcher + dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1); + + if ( outermost ) { + outermostContext = context !== document && context; + cachedruns = matcherCachedRuns; + } + + // Add elements passing elementMatchers directly to results + // Keep `i` a string if there are no elements so `matchedCount` will be "00" below + for ( ; (elem = elems[i]) != null; i++ ) { + if ( byElement && elem ) { + j = 0; + while ( (matcher = elementMatchers[j++]) ) { + if ( matcher( elem, context, xml ) ) { + results.push( elem ); + break; + } + } + if ( outermost ) { + dirruns = dirrunsUnique; + cachedruns = ++matcherCachedRuns; + } + } + + // Track unmatched elements for set filters + if ( bySet ) { + // They will have gone through all possible matchers + if ( (elem = !matcher && elem) ) { + matchedCount--; + } + + // Lengthen the array for every element, matched or not + if ( seed ) { + unmatched.push( elem ); + } + } + } + + // Apply set filters to unmatched elements + matchedCount += i; + if ( bySet && i !== matchedCount ) { + j = 0; + while ( (matcher = setMatchers[j++]) ) { + matcher( unmatched, setMatched, context, xml ); + } + + if ( seed ) { + // Reintegrate element matches to eliminate the need for sorting + if ( matchedCount > 0 ) { + while ( i-- ) { + if ( !(unmatched[i] || setMatched[i]) ) { + setMatched[i] = pop.call( results ); + } + } + } + + // Discard index placeholder values to get only actual matches + setMatched = condense( setMatched ); + } + + // Add matches to results + push.apply( results, setMatched ); + + // Seedless set matches succeeding multiple successful matchers stipulate sorting + if ( outermost && !seed && setMatched.length > 0 && + ( matchedCount + setMatchers.length ) > 1 ) { + + Sizzle.uniqueSort( results ); + } + } + + // Override manipulation of globals by nested matchers + if ( outermost ) { + dirruns = dirrunsUnique; + outermostContext = contextBackup; + } + + return unmatched; + }; + + return bySet ? + markFunction( superMatcher ) : + superMatcher; +} + +compile = Sizzle.compile = function( selector, group /* Internal Use Only */ ) { + var i, + setMatchers = [], + elementMatchers = [], + cached = compilerCache[ selector + " " ]; + + if ( !cached ) { + // Generate a function of recursive functions that can be used to check each element + if ( !group ) { + group = tokenize( selector ); + } + i = group.length; + while ( i-- ) { + cached = matcherFromTokens( group[i] ); + if ( cached[ expando ] ) { + setMatchers.push( cached ); + } else { + elementMatchers.push( cached ); + } + } + + // Cache the compiled function + cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) ); + } + return cached; +}; + +function multipleContexts( selector, contexts, results ) { + var i = 0, + len = contexts.length; + for ( ; i < len; i++ ) { + Sizzle( selector, contexts[i], results ); + } + return results; +} + +function select( selector, context, results, seed ) { + var i, tokens, token, type, find, + match = tokenize( selector ); + + if ( !seed ) { + // Try to minimize operations if there is only one group + if ( match.length === 1 ) { + + // Take a shortcut and set the context if the root selector is an ID + tokens = match[0] = match[0].slice( 0 ); + if ( tokens.length > 2 && (token = tokens[0]).type === "ID" && + context.nodeType === 9 && !documentIsXML && + Expr.relative[ tokens[1].type ] ) { + + context = Expr.find["ID"]( token.matches[0].replace( runescape, funescape ), context )[0]; + if ( !context ) { + return results; + } + + selector = selector.slice( tokens.shift().value.length ); + } + + // Fetch a seed set for right-to-left matching + i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length; + while ( i-- ) { + token = tokens[i]; + + // Abort if we hit a combinator + if ( Expr.relative[ (type = token.type) ] ) { + break; + } + if ( (find = Expr.find[ type ]) ) { + // Search, expanding context for leading sibling combinators + if ( (seed = find( + token.matches[0].replace( runescape, funescape ), + rsibling.test( tokens[0].type ) && context.parentNode || context + )) ) { + + // If seed is empty or no tokens remain, we can return early + tokens.splice( i, 1 ); + selector = seed.length && toSelector( tokens ); + if ( !selector ) { + push.apply( results, slice.call( seed, 0 ) ); + return results; + } + + break; + } + } + } + } + } + + // Compile and execute a filtering function + // Provide `match` to avoid retokenization if we modified the selector above + compile( selector, match )( + seed, + context, + documentIsXML, + results, + rsibling.test( selector ) + ); + return results; +} + +// Deprecated +Expr.pseudos["nth"] = Expr.pseudos["eq"]; + +// Easy API for creating new setFilters +function setFilters() {} +Expr.filters = setFilters.prototype = Expr.pseudos; +Expr.setFilters = new setFilters(); + +// Initialize with the default document +setDocument(); + +// Override sizzle attribute retrieval +Sizzle.attr = jQuery.attr; +jQuery.find = Sizzle; +jQuery.expr = Sizzle.selectors; +jQuery.expr[":"] = jQuery.expr.pseudos; +jQuery.unique = Sizzle.uniqueSort; +jQuery.text = Sizzle.getText; +jQuery.isXMLDoc = Sizzle.isXML; +jQuery.contains = Sizzle.contains; + + +})( window ); +var runtil = /Until$/, + rparentsprev = /^(?:parents|prev(?:Until|All))/, + isSimple = /^.[^:#\[\.,]*$/, + rneedsContext = jQuery.expr.match.needsContext, + // methods guaranteed to produce a unique set when starting from a unique set + guaranteedUnique = { + children: true, + contents: true, + next: true, + prev: true + }; + +jQuery.fn.extend({ + find: function( selector ) { + var i, ret, self, + len = this.length; + + if ( typeof selector !== "string" ) { + self = this; + return this.pushStack( jQuery( selector ).filter(function() { + for ( i = 0; i < len; i++ ) { + if ( jQuery.contains( self[ i ], this ) ) { + return true; + } + } + }) ); + } + + ret = []; + for ( i = 0; i < len; i++ ) { + jQuery.find( selector, this[ i ], ret ); + } + + // Needed because $( selector, context ) becomes $( context ).find( selector ) + ret = this.pushStack( len > 1 ? jQuery.unique( ret ) : ret ); + ret.selector = ( this.selector ? this.selector + " " : "" ) + selector; + return ret; + }, + + has: function( target ) { + var i, + targets = jQuery( target, this ), + len = targets.length; + + return this.filter(function() { + for ( i = 0; i < len; i++ ) { + if ( jQuery.contains( this, targets[i] ) ) { + return true; + } + } + }); + }, + + not: function( selector ) { + return this.pushStack( winnow(this, selector, false) ); + }, + + filter: function( selector ) { + return this.pushStack( winnow(this, selector, true) ); + }, + + is: function( selector ) { + return !!selector && ( + typeof selector === "string" ? + // If this is a positional/relative selector, check membership in the returned set + // so $("p:first").is("p:last") won't return true for a doc with two "p". + rneedsContext.test( selector ) ? + jQuery( selector, this.context ).index( this[0] ) >= 0 : + jQuery.filter( selector, this ).length > 0 : + this.filter( selector ).length > 0 ); + }, + + closest: function( selectors, context ) { + var cur, + i = 0, + l = this.length, + ret = [], + pos = rneedsContext.test( selectors ) || typeof selectors !== "string" ? + jQuery( selectors, context || this.context ) : + 0; + + for ( ; i < l; i++ ) { + cur = this[i]; + + while ( cur && cur.ownerDocument && cur !== context && cur.nodeType !== 11 ) { + if ( pos ? pos.index(cur) > -1 : jQuery.find.matchesSelector(cur, selectors) ) { + ret.push( cur ); + break; + } + cur = cur.parentNode; + } + } + + return this.pushStack( ret.length > 1 ? jQuery.unique( ret ) : ret ); + }, + + // Determine the position of an element within + // the matched set of elements + index: function( elem ) { + + // No argument, return index in parent + if ( !elem ) { + return ( this[0] && this[0].parentNode ) ? this.first().prevAll().length : -1; + } + + // index in selector + if ( typeof elem === "string" ) { + return jQuery.inArray( this[0], jQuery( elem ) ); + } + + // Locate the position of the desired element + return jQuery.inArray( + // If it receives a jQuery object, the first element is used + elem.jquery ? elem[0] : elem, this ); + }, + + add: function( selector, context ) { + var set = typeof selector === "string" ? + jQuery( selector, context ) : + jQuery.makeArray( selector && selector.nodeType ? [ selector ] : selector ), + all = jQuery.merge( this.get(), set ); + + return this.pushStack( jQuery.unique(all) ); + }, + + addBack: function( selector ) { + return this.add( selector == null ? + this.prevObject : this.prevObject.filter(selector) + ); + } +}); + +jQuery.fn.andSelf = jQuery.fn.addBack; + +function sibling( cur, dir ) { + do { + cur = cur[ dir ]; + } while ( cur && cur.nodeType !== 1 ); + + return cur; +} + +jQuery.each({ + parent: function( elem ) { + var parent = elem.parentNode; + return parent && parent.nodeType !== 11 ? parent : null; + }, + parents: function( elem ) { + return jQuery.dir( elem, "parentNode" ); + }, + parentsUntil: function( elem, i, until ) { + return jQuery.dir( elem, "parentNode", until ); + }, + next: function( elem ) { + return sibling( elem, "nextSibling" ); + }, + prev: function( elem ) { + return sibling( elem, "previousSibling" ); + }, + nextAll: function( elem ) { + return jQuery.dir( elem, "nextSibling" ); + }, + prevAll: function( elem ) { + return jQuery.dir( elem, "previousSibling" ); + }, + nextUntil: function( elem, i, until ) { + return jQuery.dir( elem, "nextSibling", until ); + }, + prevUntil: function( elem, i, until ) { + return jQuery.dir( elem, "previousSibling", until ); + }, + siblings: function( elem ) { + return jQuery.sibling( ( elem.parentNode || {} ).firstChild, elem ); + }, + children: function( elem ) { + return jQuery.sibling( elem.firstChild ); + }, + contents: function( elem ) { + return jQuery.nodeName( elem, "iframe" ) ? + elem.contentDocument || elem.contentWindow.document : + jQuery.merge( [], elem.childNodes ); + } +}, function( name, fn ) { + jQuery.fn[ name ] = function( until, selector ) { + var ret = jQuery.map( this, fn, until ); + + if ( !runtil.test( name ) ) { + selector = until; + } + + if ( selector && typeof selector === "string" ) { + ret = jQuery.filter( selector, ret ); + } + + ret = this.length > 1 && !guaranteedUnique[ name ] ? jQuery.unique( ret ) : ret; + + if ( this.length > 1 && rparentsprev.test( name ) ) { + ret = ret.reverse(); + } + + return this.pushStack( ret ); + }; +}); + +jQuery.extend({ + filter: function( expr, elems, not ) { + if ( not ) { + expr = ":not(" + expr + ")"; + } + + return elems.length === 1 ? + jQuery.find.matchesSelector(elems[0], expr) ? [ elems[0] ] : [] : + jQuery.find.matches(expr, elems); + }, + + dir: function( elem, dir, until ) { + var matched = [], + cur = elem[ dir ]; + + while ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery( cur ).is( until )) ) { + if ( cur.nodeType === 1 ) { + matched.push( cur ); + } + cur = cur[dir]; + } + return matched; + }, + + sibling: function( n, elem ) { + var r = []; + + for ( ; n; n = n.nextSibling ) { + if ( n.nodeType === 1 && n !== elem ) { + r.push( n ); + } + } + + return r; + } +}); + +// Implement the identical functionality for filter and not +function winnow( elements, qualifier, keep ) { + + // Can't pass null or undefined to indexOf in Firefox 4 + // Set to 0 to skip string check + qualifier = qualifier || 0; + + if ( jQuery.isFunction( qualifier ) ) { + return jQuery.grep(elements, function( elem, i ) { + var retVal = !!qualifier.call( elem, i, elem ); + return retVal === keep; + }); + + } else if ( qualifier.nodeType ) { + return jQuery.grep(elements, function( elem ) { + return ( elem === qualifier ) === keep; + }); + + } else if ( typeof qualifier === "string" ) { + var filtered = jQuery.grep(elements, function( elem ) { + return elem.nodeType === 1; + }); + + if ( isSimple.test( qualifier ) ) { + return jQuery.filter(qualifier, filtered, !keep); + } else { + qualifier = jQuery.filter( qualifier, filtered ); + } + } + + return jQuery.grep(elements, function( elem ) { + return ( jQuery.inArray( elem, qualifier ) >= 0 ) === keep; + }); +} +function createSafeFragment( document ) { + var list = nodeNames.split( "|" ), + safeFrag = document.createDocumentFragment(); + + if ( safeFrag.createElement ) { + while ( list.length ) { + safeFrag.createElement( + list.pop() + ); + } + } + return safeFrag; +} + +var nodeNames = "abbr|article|aside|audio|bdi|canvas|data|datalist|details|figcaption|figure|footer|" + + "header|hgroup|mark|meter|nav|output|progress|section|summary|time|video", + rinlinejQuery = / jQuery\d+="(?:null|\d+)"/g, + rnoshimcache = new RegExp("<(?:" + nodeNames + ")[\\s/>]", "i"), + rleadingWhitespace = /^\s+/, + rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi, + rtagName = /<([\w:]+)/, + rtbody = /\s*$/g, + + // We have to close these tags to support XHTML (#13200) + wrapMap = { + option: [ 1, "" ], + legend: [ 1, "
    ", "
    " ], + area: [ 1, "", "" ], + param: [ 1, "", "" ], + thead: [ 1, "", "
    " ], + tr: [ 2, "", "
    " ], + col: [ 2, "", "
    " ], + td: [ 3, "", "
    " ], + + // IE6-8 can't serialize link, script, style, or any html5 (NoScope) tags, + // unless wrapped in a div with non-breaking characters in front of it. + _default: jQuery.support.htmlSerialize ? [ 0, "", "" ] : [ 1, "X
    ", "
    " ] + }, + safeFragment = createSafeFragment( document ), + fragmentDiv = safeFragment.appendChild( document.createElement("div") ); + +wrapMap.optgroup = wrapMap.option; +wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead; +wrapMap.th = wrapMap.td; + +jQuery.fn.extend({ + text: function( value ) { + return jQuery.access( this, function( value ) { + return value === undefined ? + jQuery.text( this ) : + this.empty().append( ( this[0] && this[0].ownerDocument || document ).createTextNode( value ) ); + }, null, value, arguments.length ); + }, + + wrapAll: function( html ) { + if ( jQuery.isFunction( html ) ) { + return this.each(function(i) { + jQuery(this).wrapAll( html.call(this, i) ); + }); + } + + if ( this[0] ) { + // The elements to wrap the target around + var wrap = jQuery( html, this[0].ownerDocument ).eq(0).clone(true); + + if ( this[0].parentNode ) { + wrap.insertBefore( this[0] ); + } + + wrap.map(function() { + var elem = this; + + while ( elem.firstChild && elem.firstChild.nodeType === 1 ) { + elem = elem.firstChild; + } + + return elem; + }).append( this ); + } + + return this; + }, + + wrapInner: function( html ) { + if ( jQuery.isFunction( html ) ) { + return this.each(function(i) { + jQuery(this).wrapInner( html.call(this, i) ); + }); + } + + return this.each(function() { + var self = jQuery( this ), + contents = self.contents(); + + if ( contents.length ) { + contents.wrapAll( html ); + + } else { + self.append( html ); + } + }); + }, + + wrap: function( html ) { + var isFunction = jQuery.isFunction( html ); + + return this.each(function(i) { + jQuery( this ).wrapAll( isFunction ? html.call(this, i) : html ); + }); + }, + + unwrap: function() { + return this.parent().each(function() { + if ( !jQuery.nodeName( this, "body" ) ) { + jQuery( this ).replaceWith( this.childNodes ); + } + }).end(); + }, + + append: function() { + return this.domManip(arguments, true, function( elem ) { + if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { + this.appendChild( elem ); + } + }); + }, + + prepend: function() { + return this.domManip(arguments, true, function( elem ) { + if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { + this.insertBefore( elem, this.firstChild ); + } + }); + }, + + before: function() { + return this.domManip( arguments, false, function( elem ) { + if ( this.parentNode ) { + this.parentNode.insertBefore( elem, this ); + } + }); + }, + + after: function() { + return this.domManip( arguments, false, function( elem ) { + if ( this.parentNode ) { + this.parentNode.insertBefore( elem, this.nextSibling ); + } + }); + }, + + // keepData is for internal use only--do not document + remove: function( selector, keepData ) { + var elem, + i = 0; + + for ( ; (elem = this[i]) != null; i++ ) { + if ( !selector || jQuery.filter( selector, [ elem ] ).length > 0 ) { + if ( !keepData && elem.nodeType === 1 ) { + jQuery.cleanData( getAll( elem ) ); + } + + if ( elem.parentNode ) { + if ( keepData && jQuery.contains( elem.ownerDocument, elem ) ) { + setGlobalEval( getAll( elem, "script" ) ); + } + elem.parentNode.removeChild( elem ); + } + } + } + + return this; + }, + + empty: function() { + var elem, + i = 0; + + for ( ; (elem = this[i]) != null; i++ ) { + // Remove element nodes and prevent memory leaks + if ( elem.nodeType === 1 ) { + jQuery.cleanData( getAll( elem, false ) ); + } + + // Remove any remaining nodes + while ( elem.firstChild ) { + elem.removeChild( elem.firstChild ); + } + + // If this is a select, ensure that it displays empty (#12336) + // Support: IE<9 + if ( elem.options && jQuery.nodeName( elem, "select" ) ) { + elem.options.length = 0; + } + } + + return this; + }, + + clone: function( dataAndEvents, deepDataAndEvents ) { + dataAndEvents = dataAndEvents == null ? false : dataAndEvents; + deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents; + + return this.map( function () { + return jQuery.clone( this, dataAndEvents, deepDataAndEvents ); + }); + }, + + html: function( value ) { + return jQuery.access( this, function( value ) { + var elem = this[0] || {}, + i = 0, + l = this.length; + + if ( value === undefined ) { + return elem.nodeType === 1 ? + elem.innerHTML.replace( rinlinejQuery, "" ) : + undefined; + } + + // See if we can take a shortcut and just use innerHTML + if ( typeof value === "string" && !rnoInnerhtml.test( value ) && + ( jQuery.support.htmlSerialize || !rnoshimcache.test( value ) ) && + ( jQuery.support.leadingWhitespace || !rleadingWhitespace.test( value ) ) && + !wrapMap[ ( rtagName.exec( value ) || ["", ""] )[1].toLowerCase() ] ) { + + value = value.replace( rxhtmlTag, "<$1>" ); + + try { + for (; i < l; i++ ) { + // Remove element nodes and prevent memory leaks + elem = this[i] || {}; + if ( elem.nodeType === 1 ) { + jQuery.cleanData( getAll( elem, false ) ); + elem.innerHTML = value; + } + } + + elem = 0; + + // If using innerHTML throws an exception, use the fallback method + } catch(e) {} + } + + if ( elem ) { + this.empty().append( value ); + } + }, null, value, arguments.length ); + }, + + replaceWith: function( value ) { + var isFunc = jQuery.isFunction( value ); + + // Make sure that the elements are removed from the DOM before they are inserted + // this can help fix replacing a parent with child elements + if ( !isFunc && typeof value !== "string" ) { + value = jQuery( value ).not( this ).detach(); + } + + return this.domManip( [ value ], true, function( elem ) { + var next = this.nextSibling, + parent = this.parentNode; + + if ( parent ) { + jQuery( this ).remove(); + parent.insertBefore( elem, next ); + } + }); + }, + + detach: function( selector ) { + return this.remove( selector, true ); + }, + + domManip: function( args, table, callback ) { + + // Flatten any nested arrays + args = core_concat.apply( [], args ); + + var first, node, hasScripts, + scripts, doc, fragment, + i = 0, + l = this.length, + set = this, + iNoClone = l - 1, + value = args[0], + isFunction = jQuery.isFunction( value ); + + // We can't cloneNode fragments that contain checked, in WebKit + if ( isFunction || !( l <= 1 || typeof value !== "string" || jQuery.support.checkClone || !rchecked.test( value ) ) ) { + return this.each(function( index ) { + var self = set.eq( index ); + if ( isFunction ) { + args[0] = value.call( this, index, table ? self.html() : undefined ); + } + self.domManip( args, table, callback ); + }); + } + + if ( l ) { + fragment = jQuery.buildFragment( args, this[ 0 ].ownerDocument, false, this ); + first = fragment.firstChild; + + if ( fragment.childNodes.length === 1 ) { + fragment = first; + } + + if ( first ) { + table = table && jQuery.nodeName( first, "tr" ); + scripts = jQuery.map( getAll( fragment, "script" ), disableScript ); + hasScripts = scripts.length; + + // Use the original fragment for the last item instead of the first because it can end up + // being emptied incorrectly in certain situations (#8070). + for ( ; i < l; i++ ) { + node = fragment; + + if ( i !== iNoClone ) { + node = jQuery.clone( node, true, true ); + + // Keep references to cloned scripts for later restoration + if ( hasScripts ) { + jQuery.merge( scripts, getAll( node, "script" ) ); + } + } + + callback.call( + table && jQuery.nodeName( this[i], "table" ) ? + findOrAppend( this[i], "tbody" ) : + this[i], + node, + i + ); + } + + if ( hasScripts ) { + doc = scripts[ scripts.length - 1 ].ownerDocument; + + // Reenable scripts + jQuery.map( scripts, restoreScript ); + + // Evaluate executable scripts on first document insertion + for ( i = 0; i < hasScripts; i++ ) { + node = scripts[ i ]; + if ( rscriptType.test( node.type || "" ) && + !jQuery._data( node, "globalEval" ) && jQuery.contains( doc, node ) ) { + + if ( node.src ) { + // Hope ajax is available... + jQuery.ajax({ + url: node.src, + type: "GET", + dataType: "script", + async: false, + global: false, + "throws": true + }); + } else { + jQuery.globalEval( ( node.text || node.textContent || node.innerHTML || "" ).replace( rcleanScript, "" ) ); + } + } + } + } + + // Fix #11809: Avoid leaking memory + fragment = first = null; + } + } + + return this; + } +}); + +function findOrAppend( elem, tag ) { + return elem.getElementsByTagName( tag )[0] || elem.appendChild( elem.ownerDocument.createElement( tag ) ); +} + +// Replace/restore the type attribute of script elements for safe DOM manipulation +function disableScript( elem ) { + var attr = elem.getAttributeNode("type"); + elem.type = ( attr && attr.specified ) + "/" + elem.type; + return elem; +} +function restoreScript( elem ) { + var match = rscriptTypeMasked.exec( elem.type ); + if ( match ) { + elem.type = match[1]; + } else { + elem.removeAttribute("type"); + } + return elem; +} + +// Mark scripts as having already been evaluated +function setGlobalEval( elems, refElements ) { + var elem, + i = 0; + for ( ; (elem = elems[i]) != null; i++ ) { + jQuery._data( elem, "globalEval", !refElements || jQuery._data( refElements[i], "globalEval" ) ); + } +} + +function cloneCopyEvent( src, dest ) { + + if ( dest.nodeType !== 1 || !jQuery.hasData( src ) ) { + return; + } + + var type, i, l, + oldData = jQuery._data( src ), + curData = jQuery._data( dest, oldData ), + events = oldData.events; + + if ( events ) { + delete curData.handle; + curData.events = {}; + + for ( type in events ) { + for ( i = 0, l = events[ type ].length; i < l; i++ ) { + jQuery.event.add( dest, type, events[ type ][ i ] ); + } + } + } + + // make the cloned public data object a copy from the original + if ( curData.data ) { + curData.data = jQuery.extend( {}, curData.data ); + } +} + +function fixCloneNodeIssues( src, dest ) { + var nodeName, e, data; + + // We do not need to do anything for non-Elements + if ( dest.nodeType !== 1 ) { + return; + } + + nodeName = dest.nodeName.toLowerCase(); + + // IE6-8 copies events bound via attachEvent when using cloneNode. + if ( !jQuery.support.noCloneEvent && dest[ jQuery.expando ] ) { + data = jQuery._data( dest ); + + for ( e in data.events ) { + jQuery.removeEvent( dest, e, data.handle ); + } + + // Event data gets referenced instead of copied if the expando gets copied too + dest.removeAttribute( jQuery.expando ); + } + + // IE blanks contents when cloning scripts, and tries to evaluate newly-set text + if ( nodeName === "script" && dest.text !== src.text ) { + disableScript( dest ).text = src.text; + restoreScript( dest ); + + // IE6-10 improperly clones children of object elements using classid. + // IE10 throws NoModificationAllowedError if parent is null, #12132. + } else if ( nodeName === "object" ) { + if ( dest.parentNode ) { + dest.outerHTML = src.outerHTML; + } + + // This path appears unavoidable for IE9. When cloning an object + // element in IE9, the outerHTML strategy above is not sufficient. + // If the src has innerHTML and the destination does not, + // copy the src.innerHTML into the dest.innerHTML. #10324 + if ( jQuery.support.html5Clone && ( src.innerHTML && !jQuery.trim(dest.innerHTML) ) ) { + dest.innerHTML = src.innerHTML; + } + + } else if ( nodeName === "input" && manipulation_rcheckableType.test( src.type ) ) { + // IE6-8 fails to persist the checked state of a cloned checkbox + // or radio button. Worse, IE6-7 fail to give the cloned element + // a checked appearance if the defaultChecked value isn't also set + + dest.defaultChecked = dest.checked = src.checked; + + // IE6-7 get confused and end up setting the value of a cloned + // checkbox/radio button to an empty string instead of "on" + if ( dest.value !== src.value ) { + dest.value = src.value; + } + + // IE6-8 fails to return the selected option to the default selected + // state when cloning options + } else if ( nodeName === "option" ) { + dest.defaultSelected = dest.selected = src.defaultSelected; + + // IE6-8 fails to set the defaultValue to the correct value when + // cloning other types of input fields + } else if ( nodeName === "input" || nodeName === "textarea" ) { + dest.defaultValue = src.defaultValue; + } +} + +jQuery.each({ + appendTo: "append", + prependTo: "prepend", + insertBefore: "before", + insertAfter: "after", + replaceAll: "replaceWith" +}, function( name, original ) { + jQuery.fn[ name ] = function( selector ) { + var elems, + i = 0, + ret = [], + insert = jQuery( selector ), + last = insert.length - 1; + + for ( ; i <= last; i++ ) { + elems = i === last ? this : this.clone(true); + jQuery( insert[i] )[ original ]( elems ); + + // Modern browsers can apply jQuery collections as arrays, but oldIE needs a .get() + core_push.apply( ret, elems.get() ); + } + + return this.pushStack( ret ); + }; +}); + +function getAll( context, tag ) { + var elems, elem, + i = 0, + found = typeof context.getElementsByTagName !== core_strundefined ? context.getElementsByTagName( tag || "*" ) : + typeof context.querySelectorAll !== core_strundefined ? context.querySelectorAll( tag || "*" ) : + undefined; + + if ( !found ) { + for ( found = [], elems = context.childNodes || context; (elem = elems[i]) != null; i++ ) { + if ( !tag || jQuery.nodeName( elem, tag ) ) { + found.push( elem ); + } else { + jQuery.merge( found, getAll( elem, tag ) ); + } + } + } + + return tag === undefined || tag && jQuery.nodeName( context, tag ) ? + jQuery.merge( [ context ], found ) : + found; +} + +// Used in buildFragment, fixes the defaultChecked property +function fixDefaultChecked( elem ) { + if ( manipulation_rcheckableType.test( elem.type ) ) { + elem.defaultChecked = elem.checked; + } +} + +jQuery.extend({ + clone: function( elem, dataAndEvents, deepDataAndEvents ) { + var destElements, node, clone, i, srcElements, + inPage = jQuery.contains( elem.ownerDocument, elem ); + + if ( jQuery.support.html5Clone || jQuery.isXMLDoc(elem) || !rnoshimcache.test( "<" + elem.nodeName + ">" ) ) { + clone = elem.cloneNode( true ); + + // IE<=8 does not properly clone detached, unknown element nodes + } else { + fragmentDiv.innerHTML = elem.outerHTML; + fragmentDiv.removeChild( clone = fragmentDiv.firstChild ); + } + + if ( (!jQuery.support.noCloneEvent || !jQuery.support.noCloneChecked) && + (elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem) ) { + + // We eschew Sizzle here for performance reasons: http://jsperf.com/getall-vs-sizzle/2 + destElements = getAll( clone ); + srcElements = getAll( elem ); + + // Fix all IE cloning issues + for ( i = 0; (node = srcElements[i]) != null; ++i ) { + // Ensure that the destination node is not null; Fixes #9587 + if ( destElements[i] ) { + fixCloneNodeIssues( node, destElements[i] ); + } + } + } + + // Copy the events from the original to the clone + if ( dataAndEvents ) { + if ( deepDataAndEvents ) { + srcElements = srcElements || getAll( elem ); + destElements = destElements || getAll( clone ); + + for ( i = 0; (node = srcElements[i]) != null; i++ ) { + cloneCopyEvent( node, destElements[i] ); + } + } else { + cloneCopyEvent( elem, clone ); + } + } + + // Preserve script evaluation history + destElements = getAll( clone, "script" ); + if ( destElements.length > 0 ) { + setGlobalEval( destElements, !inPage && getAll( elem, "script" ) ); + } + + destElements = srcElements = node = null; + + // Return the cloned set + return clone; + }, + + buildFragment: function( elems, context, scripts, selection ) { + var j, elem, contains, + tmp, tag, tbody, wrap, + l = elems.length, + + // Ensure a safe fragment + safe = createSafeFragment( context ), + + nodes = [], + i = 0; + + for ( ; i < l; i++ ) { + elem = elems[ i ]; + + if ( elem || elem === 0 ) { + + // Add nodes directly + if ( jQuery.type( elem ) === "object" ) { + jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem ); + + // Convert non-html into a text node + } else if ( !rhtml.test( elem ) ) { + nodes.push( context.createTextNode( elem ) ); + + // Convert html into DOM nodes + } else { + tmp = tmp || safe.appendChild( context.createElement("div") ); + + // Deserialize a standard representation + tag = ( rtagName.exec( elem ) || ["", ""] )[1].toLowerCase(); + wrap = wrapMap[ tag ] || wrapMap._default; + + tmp.innerHTML = wrap[1] + elem.replace( rxhtmlTag, "<$1>" ) + wrap[2]; + + // Descend through wrappers to the right content + j = wrap[0]; + while ( j-- ) { + tmp = tmp.lastChild; + } + + // Manually add leading whitespace removed by IE + if ( !jQuery.support.leadingWhitespace && rleadingWhitespace.test( elem ) ) { + nodes.push( context.createTextNode( rleadingWhitespace.exec( elem )[0] ) ); + } + + // Remove IE's autoinserted from table fragments + if ( !jQuery.support.tbody ) { + + // String was a , *may* have spurious + elem = tag === "table" && !rtbody.test( elem ) ? + tmp.firstChild : + + // String was a bare or + wrap[1] === "
    " && !rtbody.test( elem ) ? + tmp : + 0; + + j = elem && elem.childNodes.length; + while ( j-- ) { + if ( jQuery.nodeName( (tbody = elem.childNodes[j]), "tbody" ) && !tbody.childNodes.length ) { + elem.removeChild( tbody ); + } + } + } + + jQuery.merge( nodes, tmp.childNodes ); + + // Fix #12392 for WebKit and IE > 9 + tmp.textContent = ""; + + // Fix #12392 for oldIE + while ( tmp.firstChild ) { + tmp.removeChild( tmp.firstChild ); + } + + // Remember the top-level container for proper cleanup + tmp = safe.lastChild; + } + } + } + + // Fix #11356: Clear elements from fragment + if ( tmp ) { + safe.removeChild( tmp ); + } + + // Reset defaultChecked for any radios and checkboxes + // about to be appended to the DOM in IE 6/7 (#8060) + if ( !jQuery.support.appendChecked ) { + jQuery.grep( getAll( nodes, "input" ), fixDefaultChecked ); + } + + i = 0; + while ( (elem = nodes[ i++ ]) ) { + + // #4087 - If origin and destination elements are the same, and this is + // that element, do not do anything + if ( selection && jQuery.inArray( elem, selection ) !== -1 ) { + continue; + } + + contains = jQuery.contains( elem.ownerDocument, elem ); + + // Append to fragment + tmp = getAll( safe.appendChild( elem ), "script" ); + + // Preserve script evaluation history + if ( contains ) { + setGlobalEval( tmp ); + } + + // Capture executables + if ( scripts ) { + j = 0; + while ( (elem = tmp[ j++ ]) ) { + if ( rscriptType.test( elem.type || "" ) ) { + scripts.push( elem ); + } + } + } + } + + tmp = null; + + return safe; + }, + + cleanData: function( elems, /* internal */ acceptData ) { + var elem, type, id, data, + i = 0, + internalKey = jQuery.expando, + cache = jQuery.cache, + deleteExpando = jQuery.support.deleteExpando, + special = jQuery.event.special; + + for ( ; (elem = elems[i]) != null; i++ ) { + + if ( acceptData || jQuery.acceptData( elem ) ) { + + id = elem[ internalKey ]; + data = id && cache[ id ]; + + if ( data ) { + if ( data.events ) { + for ( type in data.events ) { + if ( special[ type ] ) { + jQuery.event.remove( elem, type ); + + // This is a shortcut to avoid jQuery.event.remove's overhead + } else { + jQuery.removeEvent( elem, type, data.handle ); + } + } + } + + // Remove cache only if it was not already removed by jQuery.event.remove + if ( cache[ id ] ) { + + delete cache[ id ]; + + // IE does not allow us to delete expando properties from nodes, + // nor does it have a removeAttribute function on Document nodes; + // we must handle all of these cases + if ( deleteExpando ) { + delete elem[ internalKey ]; + + } else if ( typeof elem.removeAttribute !== core_strundefined ) { + elem.removeAttribute( internalKey ); + + } else { + elem[ internalKey ] = null; + } + + core_deletedIds.push( id ); + } + } + } + } + } +}); +var iframe, getStyles, curCSS, + ralpha = /alpha\([^)]*\)/i, + ropacity = /opacity\s*=\s*([^)]*)/, + rposition = /^(top|right|bottom|left)$/, + // swappable if display is none or starts with table except "table", "table-cell", or "table-caption" + // see here for display values: https://developer.mozilla.org/en-US/docs/CSS/display + rdisplayswap = /^(none|table(?!-c[ea]).+)/, + rmargin = /^margin/, + rnumsplit = new RegExp( "^(" + core_pnum + ")(.*)$", "i" ), + rnumnonpx = new RegExp( "^(" + core_pnum + ")(?!px)[a-z%]+$", "i" ), + rrelNum = new RegExp( "^([+-])=(" + core_pnum + ")", "i" ), + elemdisplay = { BODY: "block" }, + + cssShow = { position: "absolute", visibility: "hidden", display: "block" }, + cssNormalTransform = { + letterSpacing: 0, + fontWeight: 400 + }, + + cssExpand = [ "Top", "Right", "Bottom", "Left" ], + cssPrefixes = [ "Webkit", "O", "Moz", "ms" ]; + +// return a css property mapped to a potentially vendor prefixed property +function vendorPropName( style, name ) { + + // shortcut for names that are not vendor prefixed + if ( name in style ) { + return name; + } + + // check for vendor prefixed names + var capName = name.charAt(0).toUpperCase() + name.slice(1), + origName = name, + i = cssPrefixes.length; + + while ( i-- ) { + name = cssPrefixes[ i ] + capName; + if ( name in style ) { + return name; + } + } + + return origName; +} + +function isHidden( elem, el ) { + // isHidden might be called from jQuery#filter function; + // in that case, element will be second argument + elem = el || elem; + return jQuery.css( elem, "display" ) === "none" || !jQuery.contains( elem.ownerDocument, elem ); +} + +function showHide( elements, show ) { + var display, elem, hidden, + values = [], + index = 0, + length = elements.length; + + for ( ; index < length; index++ ) { + elem = elements[ index ]; + if ( !elem.style ) { + continue; + } + + values[ index ] = jQuery._data( elem, "olddisplay" ); + display = elem.style.display; + if ( show ) { + // Reset the inline display of this element to learn if it is + // being hidden by cascaded rules or not + if ( !values[ index ] && display === "none" ) { + elem.style.display = ""; + } + + // Set elements which have been overridden with display: none + // in a stylesheet to whatever the default browser style is + // for such an element + if ( elem.style.display === "" && isHidden( elem ) ) { + values[ index ] = jQuery._data( elem, "olddisplay", css_defaultDisplay(elem.nodeName) ); + } + } else { + + if ( !values[ index ] ) { + hidden = isHidden( elem ); + + if ( display && display !== "none" || !hidden ) { + jQuery._data( elem, "olddisplay", hidden ? display : jQuery.css( elem, "display" ) ); + } + } + } + } + + // Set the display of most of the elements in a second loop + // to avoid the constant reflow + for ( index = 0; index < length; index++ ) { + elem = elements[ index ]; + if ( !elem.style ) { + continue; + } + if ( !show || elem.style.display === "none" || elem.style.display === "" ) { + elem.style.display = show ? values[ index ] || "" : "none"; + } + } + + return elements; +} + +jQuery.fn.extend({ + css: function( name, value ) { + return jQuery.access( this, function( elem, name, value ) { + var len, styles, + map = {}, + i = 0; + + if ( jQuery.isArray( name ) ) { + styles = getStyles( elem ); + len = name.length; + + for ( ; i < len; i++ ) { + map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles ); + } + + return map; + } + + return value !== undefined ? + jQuery.style( elem, name, value ) : + jQuery.css( elem, name ); + }, name, value, arguments.length > 1 ); + }, + show: function() { + return showHide( this, true ); + }, + hide: function() { + return showHide( this ); + }, + toggle: function( state ) { + var bool = typeof state === "boolean"; + + return this.each(function() { + if ( bool ? state : isHidden( this ) ) { + jQuery( this ).show(); + } else { + jQuery( this ).hide(); + } + }); + } +}); + +jQuery.extend({ + // Add in style property hooks for overriding the default + // behavior of getting and setting a style property + cssHooks: { + opacity: { + get: function( elem, computed ) { + if ( computed ) { + // We should always get a number back from opacity + var ret = curCSS( elem, "opacity" ); + return ret === "" ? "1" : ret; + } + } + } + }, + + // Exclude the following css properties to add px + cssNumber: { + "columnCount": true, + "fillOpacity": true, + "fontWeight": true, + "lineHeight": true, + "opacity": true, + "orphans": true, + "widows": true, + "zIndex": true, + "zoom": true + }, + + // Add in properties whose names you wish to fix before + // setting or getting the value + cssProps: { + // normalize float css property + "float": jQuery.support.cssFloat ? "cssFloat" : "styleFloat" + }, + + // Get and set the style property on a DOM Node + style: function( elem, name, value, extra ) { + // Don't set styles on text and comment nodes + if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) { + return; + } + + // Make sure that we're working with the right name + var ret, type, hooks, + origName = jQuery.camelCase( name ), + style = elem.style; + + name = jQuery.cssProps[ origName ] || ( jQuery.cssProps[ origName ] = vendorPropName( style, origName ) ); + + // gets hook for the prefixed version + // followed by the unprefixed version + hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ]; + + // Check if we're setting a value + if ( value !== undefined ) { + type = typeof value; + + // convert relative number strings (+= or -=) to relative numbers. #7345 + if ( type === "string" && (ret = rrelNum.exec( value )) ) { + value = ( ret[1] + 1 ) * ret[2] + parseFloat( jQuery.css( elem, name ) ); + // Fixes bug #9237 + type = "number"; + } + + // Make sure that NaN and null values aren't set. See: #7116 + if ( value == null || type === "number" && isNaN( value ) ) { + return; + } + + // If a number was passed in, add 'px' to the (except for certain CSS properties) + if ( type === "number" && !jQuery.cssNumber[ origName ] ) { + value += "px"; + } + + // Fixes #8908, it can be done more correctly by specifing setters in cssHooks, + // but it would mean to define eight (for every problematic property) identical functions + if ( !jQuery.support.clearCloneStyle && value === "" && name.indexOf("background") === 0 ) { + style[ name ] = "inherit"; + } + + // If a hook was provided, use that value, otherwise just set the specified value + if ( !hooks || !("set" in hooks) || (value = hooks.set( elem, value, extra )) !== undefined ) { + + // Wrapped to prevent IE from throwing errors when 'invalid' values are provided + // Fixes bug #5509 + try { + style[ name ] = value; + } catch(e) {} + } + + } else { + // If a hook was provided get the non-computed value from there + if ( hooks && "get" in hooks && (ret = hooks.get( elem, false, extra )) !== undefined ) { + return ret; + } + + // Otherwise just get the value from the style object + return style[ name ]; + } + }, + + css: function( elem, name, extra, styles ) { + var num, val, hooks, + origName = jQuery.camelCase( name ); + + // Make sure that we're working with the right name + name = jQuery.cssProps[ origName ] || ( jQuery.cssProps[ origName ] = vendorPropName( elem.style, origName ) ); + + // gets hook for the prefixed version + // followed by the unprefixed version + hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ]; + + // If a hook was provided get the computed value from there + if ( hooks && "get" in hooks ) { + val = hooks.get( elem, true, extra ); + } + + // Otherwise, if a way to get the computed value exists, use that + if ( val === undefined ) { + val = curCSS( elem, name, styles ); + } + + //convert "normal" to computed value + if ( val === "normal" && name in cssNormalTransform ) { + val = cssNormalTransform[ name ]; + } + + // Return, converting to number if forced or a qualifier was provided and val looks numeric + if ( extra === "" || extra ) { + num = parseFloat( val ); + return extra === true || jQuery.isNumeric( num ) ? num || 0 : val; + } + return val; + }, + + // A method for quickly swapping in/out CSS properties to get correct calculations + swap: function( elem, options, callback, args ) { + var ret, name, + old = {}; + + // Remember the old values, and insert the new ones + for ( name in options ) { + old[ name ] = elem.style[ name ]; + elem.style[ name ] = options[ name ]; + } + + ret = callback.apply( elem, args || [] ); + + // Revert the old values + for ( name in options ) { + elem.style[ name ] = old[ name ]; + } + + return ret; + } +}); + +// NOTE: we've included the "window" in window.getComputedStyle +// because jsdom on node.js will break without it. +if ( window.getComputedStyle ) { + getStyles = function( elem ) { + return window.getComputedStyle( elem, null ); + }; + + curCSS = function( elem, name, _computed ) { + var width, minWidth, maxWidth, + computed = _computed || getStyles( elem ), + + // getPropertyValue is only needed for .css('filter') in IE9, see #12537 + ret = computed ? computed.getPropertyValue( name ) || computed[ name ] : undefined, + style = elem.style; + + if ( computed ) { + + if ( ret === "" && !jQuery.contains( elem.ownerDocument, elem ) ) { + ret = jQuery.style( elem, name ); + } + + // A tribute to the "awesome hack by Dean Edwards" + // Chrome < 17 and Safari 5.0 uses "computed value" instead of "used value" for margin-right + // Safari 5.1.7 (at least) returns percentage for a larger set of values, but width seems to be reliably pixels + // this is against the CSSOM draft spec: http://dev.w3.org/csswg/cssom/#resolved-values + if ( rnumnonpx.test( ret ) && rmargin.test( name ) ) { + + // Remember the original values + width = style.width; + minWidth = style.minWidth; + maxWidth = style.maxWidth; + + // Put in the new values to get a computed value out + style.minWidth = style.maxWidth = style.width = ret; + ret = computed.width; + + // Revert the changed values + style.width = width; + style.minWidth = minWidth; + style.maxWidth = maxWidth; + } + } + + return ret; + }; +} else if ( document.documentElement.currentStyle ) { + getStyles = function( elem ) { + return elem.currentStyle; + }; + + curCSS = function( elem, name, _computed ) { + var left, rs, rsLeft, + computed = _computed || getStyles( elem ), + ret = computed ? computed[ name ] : undefined, + style = elem.style; + + // Avoid setting ret to empty string here + // so we don't default to auto + if ( ret == null && style && style[ name ] ) { + ret = style[ name ]; + } + + // From the awesome hack by Dean Edwards + // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291 + + // If we're not dealing with a regular pixel number + // but a number that has a weird ending, we need to convert it to pixels + // but not position css attributes, as those are proportional to the parent element instead + // and we can't measure the parent instead because it might trigger a "stacking dolls" problem + if ( rnumnonpx.test( ret ) && !rposition.test( name ) ) { + + // Remember the original values + left = style.left; + rs = elem.runtimeStyle; + rsLeft = rs && rs.left; + + // Put in the new values to get a computed value out + if ( rsLeft ) { + rs.left = elem.currentStyle.left; + } + style.left = name === "fontSize" ? "1em" : ret; + ret = style.pixelLeft + "px"; + + // Revert the changed values + style.left = left; + if ( rsLeft ) { + rs.left = rsLeft; + } + } + + return ret === "" ? "auto" : ret; + }; +} + +function setPositiveNumber( elem, value, subtract ) { + var matches = rnumsplit.exec( value ); + return matches ? + // Guard against undefined "subtract", e.g., when used as in cssHooks + Math.max( 0, matches[ 1 ] - ( subtract || 0 ) ) + ( matches[ 2 ] || "px" ) : + value; +} + +function augmentWidthOrHeight( elem, name, extra, isBorderBox, styles ) { + var i = extra === ( isBorderBox ? "border" : "content" ) ? + // If we already have the right measurement, avoid augmentation + 4 : + // Otherwise initialize for horizontal or vertical properties + name === "width" ? 1 : 0, + + val = 0; + + for ( ; i < 4; i += 2 ) { + // both box models exclude margin, so add it if we want it + if ( extra === "margin" ) { + val += jQuery.css( elem, extra + cssExpand[ i ], true, styles ); + } + + if ( isBorderBox ) { + // border-box includes padding, so remove it if we want content + if ( extra === "content" ) { + val -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles ); + } + + // at this point, extra isn't border nor margin, so remove border + if ( extra !== "margin" ) { + val -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); + } + } else { + // at this point, extra isn't content, so add padding + val += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles ); + + // at this point, extra isn't content nor padding, so add border + if ( extra !== "padding" ) { + val += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); + } + } + } + + return val; +} + +function getWidthOrHeight( elem, name, extra ) { + + // Start with offset property, which is equivalent to the border-box value + var valueIsBorderBox = true, + val = name === "width" ? elem.offsetWidth : elem.offsetHeight, + styles = getStyles( elem ), + isBorderBox = jQuery.support.boxSizing && jQuery.css( elem, "boxSizing", false, styles ) === "border-box"; + + // some non-html elements return undefined for offsetWidth, so check for null/undefined + // svg - https://bugzilla.mozilla.org/show_bug.cgi?id=649285 + // MathML - https://bugzilla.mozilla.org/show_bug.cgi?id=491668 + if ( val <= 0 || val == null ) { + // Fall back to computed then uncomputed css if necessary + val = curCSS( elem, name, styles ); + if ( val < 0 || val == null ) { + val = elem.style[ name ]; + } + + // Computed unit is not pixels. Stop here and return. + if ( rnumnonpx.test(val) ) { + return val; + } + + // we need the check for style in case a browser which returns unreliable values + // for getComputedStyle silently falls back to the reliable elem.style + valueIsBorderBox = isBorderBox && ( jQuery.support.boxSizingReliable || val === elem.style[ name ] ); + + // Normalize "", auto, and prepare for extra + val = parseFloat( val ) || 0; + } + + // use the active box-sizing model to add/subtract irrelevant styles + return ( val + + augmentWidthOrHeight( + elem, + name, + extra || ( isBorderBox ? "border" : "content" ), + valueIsBorderBox, + styles + ) + ) + "px"; +} + +// Try to determine the default display value of an element +function css_defaultDisplay( nodeName ) { + var doc = document, + display = elemdisplay[ nodeName ]; + + if ( !display ) { + display = actualDisplay( nodeName, doc ); + + // If the simple way fails, read from inside an iframe + if ( display === "none" || !display ) { + // Use the already-created iframe if possible + iframe = ( iframe || + jQuery("