oop.js revision 3c803ac3b53ba983a143b03bf688bc67b1a9db2b
/**
* Supplies object inheritance and manipulation utilities. This adds
* additional functionaity to what is provided in yui-base, and the
* methods are applied directly to the YUI instance. This module
* is required for most YUI components.
* @module oop
*/
var L = Y.Lang,
A = Y.Array,
/**
* The following methods are added to the YUI instance
* @class YUI~oop
*/
/**
* Applies prototype properties from the supplier to the receiver.
* The receiver can be a constructor or an instance.
* @method augment
* @param {Function} r the object to receive the augmentation
* @param {Function} s the object that supplies the properties to augment
* @param ov {boolean} if true, properties already on the receiver
* will be overwritten if found on the supplier.
* @param wl {string[]} a whitelist. If supplied, only properties in
* this list will be applied to the receiver.
* @param args {Array | Any} arg or arguments to apply to the supplier
* constructor when initializing.
* @return {object} the augmented object
*
* @todo constructor optional?
* @todo understanding what an instance is augmented with
* @TODO best practices for overriding sequestered methods.
*/
// working on a class, so apply constructor infrastructure
var sequestered = {}, replacements = {};
newProto = {};
// sequester all of the functions in the supplier and replace with
// one that will restore all of them.
replacements[k] = function() {
// Y.log('sequestered function "' + k + '" executed. Initializing Event.Target');
// overwrite the prototype with all of the sequestered functions,
// but only if it hasn't been overridden
for (var i in sequestered) {
// Y.log('... restoring ' + k);
this[i] = sequestered[i];
}
}
// apply the constructor
// apply the original sequestered function
};
// Y.log('augment: ' + k);
if (L.isFunction(v)) {
// sequester the function
sequestered[k] = v;
// replace the sequestered function with a function that will
// restore all sequestered functions and exectue the constructor.
this[k] = replacements[k];
} else {
// Y.log('augment() applying non-function: ' + k);
this[k] = v;
}
}
}, newProto, true);
// augmenting an instance, so apply the constructor immediately
} else {
applyConstructor = true;
}
if (applyConstructor) {
}
return r;
};
/**
* Applies object properties from the supplier to the receiver. If
* the target has the property, and the property is an object, the target
* object will be augmented with the supplier's value. If the property
* is an array, the suppliers value will be appended to the target.
* @method aggregate
* @param {Function} r the object to receive the augmentation
* @param {Function} s the object that supplies the properties to augment
* @param ov {boolean} if true, properties already on the receiver
* will be overwritten if found on the supplier.
* @param wl {string[]} a whitelist. If supplied, only properties in
* this list will be applied to the receiver.
* @return {object} the extended object
*/
};
/**
* Utility to set up the prototype, constructor and superclass properties to
* support an inheritance strategy that can chain constructors and methods.
* Static members will not be inherited.
*
* @method extend
* @param {Function} r the object to modify
* @param {Function} s the object to inherit
* @return {YUI} the YUI instance
*/
if (!s||!r) {
// @TODO error symbols
Y.fail("extend failed, verify dependencies");
}
rp.constructor=r;
r.superclass=sp;
// assign constructor property
sp.constructor=s;
}
// add prototype overrides
if (px) {
}
// add object overrides
if (sx) {
}
return r;
};
/**
* Executes the supplied function for each item in
* a collection. Supports arrays, objects, and
* Y.NodeLists
* @method each
* @param o the object to iterate
* @param f the function to execute. This function
* receives the value, key, and object as parameters
* @param proto if true, prototype properties are
* iterated on objects
* @return {YUI} the YUI instance
*/
} else {
switch (A.test(o)) {
case 1:
return A.each(o, f, c);
case 2:
return A.each(Y.Array(o, 0, true), f, c);
default:
}
}
// return Y.Object.each(o, f, c);
};
/**
* Array-like objects are treated as arrays.
* primitives are returned untouched. Optionally a
* function can be provided to handle other data types,
* filter keys, validate values, etc.
*
* @method clone
* @param o what to clone
* @param safe {boolean} if true, objects will not have prototype
* items from the source. If false, it does. In this case, the
* original is initally protected, but the clone is not completely immune
* from changes to the source object prototype. Also, cloned prototype
* items that are deleted from the clone will result in the value
* of the source prototype to be exposed. If operating on a non-safe
* clone, items should be nulled out rather than deleted.
* @TODO review
* @param f optional function to apply to each item in a collection
* it will be executed prior to applying the value to
* the new object. Return false to prevent the copy.
* @param c optional execution context for f
* @param owner Owner object passed when clone is iterating an
* object. Used to set up context for cloned functions.
* @return {Array|Object} the cloned object
*/
if (!L.isObject(o)) {
return o;
}
var o2;
switch (L.type(o)) {
case 'date':
return new Date(o);
case 'regexp':
return new RegExp(o.source);
case 'function':
break;
case 'array':
o2 = [];
break;
default:
}
Y.each(o, function(v, k) {
if (!f || (f.call(c || this, v, k, this, o) !== false)) {
}
}, o2);
return o2;
};
/**
* Returns a function that will execute the supplied function in the
* supplied object's context, optionally adding any additional
* supplied parameters to the end of the arguments the function
* is executed with.
*
* In some cases it is preferable to have the additional arguments
* applied to the beginning of the function signature. For instance,
* FireFox setTimeout/setInterval supplies a parameter that other
* browsers do not.
* Note: YUI provides a later() function which wraps setTimeout/setInterval,
* providing context adjustment and parameter addition. This can be
* used instead of setTimeout/setInterval, avoiding the arguments
* collection issue when using bind() in FireFox.
*
* @method bind
* @param f {Function} the function to bind
* @param c the execution context
* @param args* 0..n arguments to append to the end of arguments collection
* supplied to the function
* @return {function} the wrapped function
*/
Y.bind = function(f, c) {
var a = Y.Array(arguments, 2, true);
return function () {
};
};
/*
* Returns a function that will execute the supplied function in the
* supplied object's context, optionally adding any additional
* supplied parameters to the beginning of the arguments collection the
* supplied to the function.
*
* @method bind
* @param f {Function} the function to bind
* @param c the execution context
* @param args* 0..n arguments to append to the arguments collection for the function
* @return {function} the wrapped function
*/
// Y.bind = function(f, c) {
// var a = Y.Array(arguments, 2, true);
// return function () {
// return f.apply(c || f, a.concat(Y.Array(arguments, 0, true)));
// };
// };