--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cm/media/js/lib/yui/yui_3.0.0b1/build/oop/oop-debug.js Mon Nov 23 15:14:29 2009 +0100
@@ -0,0 +1,311 @@
+/*
+Copyright (c) 2009, Yahoo! Inc. All rights reserved.
+Code licensed under the BSD License:
+http://developer.yahoo.net/yui/license.txt
+version: 3.0.0b1
+build: 1163
+*/
+YUI.add('oop', function(Y) {
+
+/**
+ * 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,
+ OP = Object.prototype;
+
+ /**
+ * 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.
+ */
+ Y.augment = function(r, s, ov, wl, args) {
+ var sProto = s.prototype,
+ newProto = null,
+ construct = s,
+ a = (args) ? Y.Array(args) : [],
+ rProto = r.prototype,
+ target = rProto || r,
+ applyConstructor = false,
+ sequestered, replacements, i;
+
+ // working on a class, so apply constructor infrastructure
+ if (rProto && construct) {
+ sequestered = {};
+ replacements = {};
+ newProto = {};
+
+ // sequester all of the functions in the supplier and replace with
+ // one that will restore all of them.
+ Y.each(sProto, function(v, k) {
+ replacements[k] = function() {
+
+// Y.log('sequestered function "' + k + '" executed. Initializing EventTarget');
+// overwrite the prototype with all of the sequestered functions,
+// but only if it hasn't been overridden
+ for (i in sequestered) {
+ if (sequestered.hasOwnProperty(i) && (this[i] === replacements[i])) {
+ // Y.log('... restoring ' + k);
+ this[i] = sequestered[i];
+ }
+ }
+
+ // apply the constructor
+ construct.apply(this, a);
+
+ // apply the original sequestered function
+ return sequestered[k].apply(this, arguments);
+ };
+
+ if ((!wl || (k in wl)) && (ov || !(k in this))) {
+ // 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;
+ }
+
+ Y.mix(target, newProto || sProto, ov, wl);
+
+ if (applyConstructor) {
+ s.apply(target, a);
+ }
+
+ 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
+ */
+ Y.aggregate = function(r, s, ov, wl) {
+ return Y.mix(r, s, ov, wl, 0, true);
+ };
+
+ /**
+ * 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
+ * @param {Object} px prototype properties to add/override
+ * @param {Object} sx static properties to add/override
+ * @return {YUI} the YUI instance
+ */
+ Y.extend = function(r, s, px, sx) {
+ if (!s||!r) {
+ // @TODO error symbols
+ Y.error("extend failed, verify dependencies");
+ }
+
+ var sp = s.prototype, rp=Y.Object(sp);
+ r.prototype=rp;
+
+ rp.constructor=r;
+ r.superclass=sp;
+
+ // assign constructor property
+ if (s != Object && sp.constructor == OP.constructor) {
+ sp.constructor=s;
+ }
+
+ // add prototype overrides
+ if (px) {
+ Y.mix(rp, px, true);
+ }
+
+ // add object overrides
+ if (sx) {
+ Y.mix(r, sx, true);
+ }
+
+ 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
+ */
+ Y.each = function(o, f, c, proto) {
+
+ if (o.each && o.item) {
+ return o.each.call(o, f, c);
+ } 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, proto);
+ }
+ }
+
+ // return Y.Object.each(o, f, c);
+ };
+
+ /**
+ * Deep obj/array copy. Functions will are cloned with Y.bind.
+ * 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
+ */
+ Y.clone = function(o, safe, f, c, owner) {
+
+ 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':
+ o2 = Y.bind(o, owner);
+ break;
+ case 'array':
+ o2 = [];
+ break;
+ default:
+ o2 = (safe) ? {} : Y.Object(o);
+ }
+
+ Y.each(o, function(v, k) {
+ if (!f || (f.call(c || this, v, k, this, o) !== false)) {
+ this[k] = Y.clone(v, safe, f, c, this);
+ }
+ }, 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 beginning of the arguments collection the
+ * supplied to the function.
+ *
+ * @method bind
+ * @param f {Function|String} the function to bind, or a function name
+ * to execute on the context object
+ * @param c the execution context
+ * @param args* 0..n arguments to include before the arguments the
+ * function is executed with.
+ * @return {function} the wrapped function
+ */
+ Y.bind = function(f, c) {
+ var xargs = arguments.length > 2 ? Y.Array(arguments, 2, true) : null;
+ return function () {
+ var fn = L.isString(f) ? c[f] : f,
+ args = (xargs) ? xargs.concat(Y.Array(arguments, 0, true)) : arguments;
+ return fn.apply(c || fn, args);
+ };
+ };
+
+ /**
+ * 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.
+ *
+ * @method rbind
+ * @param f {Function|String} the function to bind, or a function name
+ * to execute on the context object
+ * @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.rbind = function(f, c) {
+ var xargs = arguments.length > 2 ? Y.Array(arguments, 2, true) : null;
+ return function () {
+ var fn = L.isString(f) ? c[f] : f,
+ args = (xargs) ? Y.Array(arguments, 0, true).concat(xargs) : arguments;
+ return fn.apply(c || fn, args);
+ };
+ };
+
+
+
+}, '3.0.0b1' );