// ========================================================================== // Project: SproutCore
Costello - Property Observing Library // Copyright: ©2006-2011 Strobe Inc. and contributors. // Portions ©2008-2011 Apple Inc. All rights reserved. // License: Licensed under MIT license (see license.js) // ==========================================================================
sc_require('system/function');
SC.mixin(Function.prototype, /** @lends Function.prototype */ {
/** Indicates that the function should be treated as a computed property. Computed properties are methods that you want to treat as if they were static properties. When you use get() or set() on a computed property, the object will call the property method and return its value instead of returning the method itself. This makes it easy to create "virtual properties" that are computed dynamically from other properties. Consider the following example: contact = SC.Object.create({ firstName: "Charles", lastName: "Jolley", // This is a computed property! fullName: function() { return this.getEach('firstName','lastName').compact().join(' ') ; }.property('firstName', 'lastName'), // this is not getFullName: function() { return this.getEach('firstName','lastName').compact().join(' ') ; } }); contact.get('firstName') ; --> "Charles" contact.get('fullName') ; --> "Charles Jolley" contact.get('getFullName') ; --> function() Note that when you get the fullName property, SproutCore will call the fullName() function and return its value whereas when you get() a property that contains a regular method (such as getFullName above), then the function itself will be returned instead. Using Dependent Keys ---- Computed properties are often computed dynamically from other member properties. Whenever those properties change, you need to notify any object that is observing the computed property that the computed property has changed also. We call these properties the computed property is based upon "dependent keys". For example, in the contact object above, the fullName property depends on the firstName and lastName property. If either property value changes, any observer watching the fullName property will need to be notified as well. You inform SproutCore of these dependent keys by passing the key names as parameters to the property() function. Whenever the value of any key you name here changes, the computed property will be marked as changed also. You should always register dependent keys for computed properties to ensure they update. Sometimes you may need to depend on keys that are several objects deep. In that case, you can provide a path to property(): capitalizedName: function() { return this.getPath('person.fullName').toUpper(); }.property('person.fullName') This will cause observers of +capitalizedName+ to be fired when either +fullName+ _or_ +person+ changes. Using Computed Properties as Setters --- Computed properties can be used to modify the state of an object as well as to return a value. Unlike many other key-value system, you use the same method to both get and set values on a computed property. To write a setter, simply declare two extra parameters: key and value. Whenever your property function is called as a setter, the value parameter will be set. Whenever your property is called as a getter the value parameter will be undefined. For example, the following object will split any full name that you set into a first name and last name components and save them. contact = SC.Object.create({ fullName: function(key, value) { if (value !== undefined) { var parts = value.split(' ') ; this.beginPropertyChanges() .set('firstName', parts[0]) .set('lastName', parts[1]) .endPropertyChanges() ; } return this.getEach('firstName', 'lastName').compact().join(' '); }.property('firstName','lastName') }) ; Why Use The Same Method for Getters and Setters? --- Most property-based frameworks expect you to write two methods for each property but SproutCore only uses one. We do this because most of the time when you write a setter is is basically a getter plus some extra work. There is little added benefit in writing both methods when you can conditionally exclude part of it. This helps to keep your code more compact and easier to maintain. @param {String...} dependentKeys optional set of dependent keys @returns {Function} the declared function instance */ property: function() { return SC.Function.property(this, arguments); }, /** You can call this method on a computed property to indicate that the property is cacheable (or not cacheable). By default all computed properties are not cached. Enabling this feature will allow SproutCore to cache the return value of your computed property and to use that value until one of your dependent properties changes or until you invoke propertyDidChange() and name the computed property itself. If you do not specify this option, computed properties are assumed to be not cacheable. @param {Boolean} aFlag optionally indicate cacheable or no, default YES @returns {Function} receiver, useful for chaining calls. */ cacheable: function(aFlag) { return SC.Function.cacheable(this, aFlag); }, /** Indicates that the computed property is volatile. Normally SproutCore assumes that your computed property is idempotent. That is, calling set() on your property more than once with the same value has the same effect as calling it only once. All non-computed properties are idempotent and normally you should make your computed properties behave the same way. However, if you need to make your property change its return value every time your method is called, you may chain this to your property to make it volatile. If you do not specify this option, properties are assumed to be non-volatile. @param {Boolean} aFlag optionally indicate state, default to YES @returns {Function} receiver, useful for chaining calls. */ idempotent: function(aFlag) { return SC.Function.idempotent(this, aFlag); }, enhance: function() { return SC.Function.enhance(this); }, /** Declare that a function should observe an object or property at the named path. Note that the path is used only to construct the observation one time. @param {String...} propertyPaths A list of strings which indicate the properties being observed @returns {Function} receiver, useful for chaining calls. */ observes: function(propertyPaths) { return SC.Function.observes(this, arguments); }
});