Ticket #4060: base.js.3.diff

base.js

@@ -1 @@
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    }
-
-
+
+
+
-
+  var __enableMimicry = function(__ctor) {
+    var __old = __ctor.prototype;
+    __ctor['mimic'] = function(obj) {
+      var __new = Object.extend(obj, __old);
+      return Object.extend(function() {
+        return __ctor.apply(this, arguments);
+      }, { 'prototype':
+        __ensureDefaults(__new, __old) });
+    };
+  };
+
+  var __inherit = function(subclass, superclass) {
+    switch (typeof(superclass)) {
+      case 'object': default:
+        superclass[vocab['init']] = superclass.constructor;
+        subclass.prototype = superclass; break;
+      case 'function':
+        superclass.getInstance = superclass.getInstance ||
+          Class.encap(new superclass($doNotInit));
+        subclass.prototype = superclass.getInstance();
+    }
+    return subclass.prototype;
+  };
+
+  var __setupAttachDelete = function(declarations) {
+    return Object.extend(declarations, {
+      'attachMethod': function(fnName, func) {
+        if (!this.ownPrototypeHas(fnName)) {
+          this._runTimeDeclarations[fnName] = true;
+          __attachClassProperty(fnName, func, this);
+        } else throw "Can't replace existing methods."
+      },
+      
+      'deleteMethod': function(fnName) {
+        if (this._runTimeDeclarations[fnName]) {
+          __attachClassProperty(fnName, null, this, true);
+          this._runTimeDeclarations[fnName] = false;
+        } else throw "Only attachMethod additions can be deleted."
+      }
+    });
+  };
+  
+  var __attachClassProperty = function(propName, prop, obj,
+                                       /*optional*/ removeInstead) {
+    if (removeInstead) {
+      if (obj.ownPrototypeHas(propName))
+        delete obj[propName];
+    } else {
+      if (typeof(obj[propName] = prop) == 'function') {
+        if (typeof(prop.body) != 'function')
+          __addStackLogic(obj, propName);
+        var __origStr = prop.toString();
+        prop.toString = obj[propName].toString = function() {
+          return __origStr.replace(/^\s*function/, propName);
+        };
+      }
+    }
+  };
+  
+  // special-purpose array object (slightly faster in tests)
+  var __callStack = new (function() {
+    var stack = []; var index = 0;
+    this.push  = function(what) { stack[index++] = what; }
+    this.pop   = function()     { return stack[--index]; }
+    this.empty = function()     { return index == 0; }
+    this.peek  = function()     { return stack[index - 1]; }
+  })();
+
+  var $empty = ['', null];
+  var __lastOnCallStack = function() {
+    if (__callStack.empty()) return $empty;
+    else return __callStack.peek();
+  };
+    
+  var __addStackLogic = function(obj, fnName) {
+    switch (fnName) {
+      case vocab['super']: case 'valueOf':
+      case 'attachMethod': case 'deleteMethod':
+      case 'getBaseInstance': return;
+      default:
+        obj[fnName] = Object.extend(__wrap(obj[fnName], fnName), {
+          'body': obj[fnName] // preserve underlying function
+        });
+    }
+  };
+
+  // same as bind(), but remembers callstack contents too
+  Function.prototype.grant = function(obj) {
+    return __wrap(this, __lastOnCallStack(), obj);
+  };
+
+  var __wrap = function(func, toPush, base) {
+    var isArray = (typeof(toPush) == 'array');
+    if (!isArray) toPush = [toPush];
+    
+    return function() {
+      if (!isArray) toPush.push(this);
+      __callStack.push(toPush);
+      try {
+        var result =
+          func.apply(base || this, arguments);
+      } catch (ex) { throw ex; }
+      finally { __callStack.pop(); }
+      return result;
+    };
+  };
+
+  var __ensureDefaults = function(ownPrototype, declarations) {
+    ['toString', 'toLocaleString', 'valueOf'].each(function(prop) {
+      __attachClassProperty(prop, declarations[prop], ownPrototype);
+    });
+    return ownPrototype;
+  };
+
+  var __ensureOwnPrototypeMemory = function(ownPrototype, declarations) {
+    ownPrototype.ownPrototypeHas = function(property) {
+      return (typeof(declarations[property]) != 'undefined' ||
+              (this._runTimeDeclarations && // present if instantiated
+               this._runTimeDeclarations[property]));
+    };
+  };
+
+  // convenient mechanism for creating accessor functions
+  this.encap = function(__val, mutable) {
+    if (!mutable) return function() { return __val; }
+    else return function(/* optional new value */) {
+      if (arguments.length > 0) __val = arguments[0];
+      return __val;
+    }
+  };
+  
+  var __makeSup = function() {
+    var __platform = false; // where to start lookup
+    
+    return function() {
+      var methodName = __lastOnCallStack()[0];
+      var curObj = __platform || this;
+
+      while ( curObj.ownPrototypeHas &&
+             !curObj.ownPrototypeHas(methodName) &&
+              curObj.getBaseInstance)
+        curObj = curObj.getBaseInstance();
+      curObj = curObj.getBaseInstance
+        ? curObj.getBaseInstance() : {};
+
+      var prevBase = __platform;
+      __platform = curObj;
+      try { var result =
+              curObj[methodName].apply(this, arguments); }
+      catch (ex) { throw ex; }
+      finally { __platform = prevBase; }
+      return result;
+    };
+  };
+})( // the vocabulary is arbitrary:
+{'super': 'sup', 'init': 'initialize'});
+
+setTimeout(function() {
+  window.Base = Class.create({});
+}, 10);
+
-var Abstract = new Object();
-
-Object.extend = function(destination, source) {