Ticket #4060: patchClass.diff

src/base.js

@@ -1 +1 @@
-var Class = {
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    }
+
+    return ctor;
+  },
+
+  _attachClassProperty: function(propName, prop, ownPrototype) {
+    ownPrototype[propName] = prop;
+    if (typeof(prop) == 'function')
+      Class._addStackLogic(ownPrototype, propName);
+  },
+
+  _setUpAndHideCallStack: function() {
+
+    var __callStack = []; // stores [function-name, receiver] pairs
+
+    Class._lastOnCallStack = function() {
+      if (__callStack.length == 0) return ['', null];
+      else return __callStack[__callStack.length - 1];
+    };
+    
+    Class._addStackLogic = function(obj, fnName) {
+      switch (fnName) {
+        case 'sup':
+        case 'toString':
+        case 'valueOf': return;
+        default:
+        var __func = obj[fnName];
+        obj[fnName] = function() {
+          var lastRef = Class._refOfLastCallingObject();
+          if (Class.followsPrivateNamingConvention(fnName) &&
+              (lastRef || {}).constructor !== this.constructor) {
+            Class.privateCallError(fnName);
+          } else {
+            __callStack.push([fnName, this]);
+            var result = __func.apply(this, arguments);
+            __callStack.pop();
+            return result;
+          }
+        };
+      }
+    };
+    
+    Class._grant = function(obj) {
+      var __func = this;
+      var __callStackMemory = Class._lastOnCallStack();
+      return function() {
+        __callStack.push(__callStackMemory);
+        var result = __func.apply(obj || this, arguments);
+        __callStack.pop();
+        return result;
+      }
+    }
+
+    // this function commits seppuku
+    Class._setUpAndHideCallStack = undefined;
+    
+  }, // ends: _setUpAndHideCallStack
+
+  _nameOfLastCalledMethod: function() {
+    return Class._lastOnCallStack()[0];
+  },
+
+  _refOfLastCallingObject: function() {
+    return Class._lastOnCallStack()[1];
+  },
+
+  // change this at will
+  followsPrivateNamingConvention: function(propName) {
+    return propName.charAt(0) == '_';
+  },
+  
+  privateCallError: function(fnName) {
+    alert("Error: Tried to access private member " + fnName +
+          " from from non-member method " +
+          Class._nameOfLastCalledMethod());
+  },
+
+  _ensureDefaults: function(ownPrototype, declarations) {
+    ['toString',
+     'toLocaleString',
+     'valueOf'].each(function(prop) {
+       if (declarations[prop]) {
+         Class._attachClassProperty(prop, declarations[prop], ownPrototype);
+       }
+     });
+
+    // see whether property was implemented by *this* class
+    ownPrototype.ownPrototypeHas = function(property) {
+      return (typeof(declarations[property]) != 'undefined');
+    }
+  },
+
+  _makeSup: function(parentPrototype) {
+    Class._skipOver = false;
+    
+    return function() {
+      var origin = Class._nameOfLastCalledMethod();
+      
+      if (!Class._skipOver && !this.ownPrototypeHas(origin) &&
+          parentPrototype.sup && !parentPrototype.ownPrototypeHas(origin)) {
+        return parentPrototype.sup.apply(this, arguments);
+      }
+      
+      if (parentPrototype.sup && !Class._skipOver) {
+        Class._skipOver = true; // skip this test next time
+        return parentPrototype.sup.apply(this, arguments);
+      }
+
+      Class._skipOver = false;
+      
+      var args = $A(arguments);
+      with (this.sup = parentPrototype.sup || this.sup)
+        return parentPrototype[origin].apply(this, args);
+    };
+  },
+
+  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;
+    }
+  },
+
+  // superclass can be a constructor function or an existing object
+  _inherit: function(subclass, superclass) {
+    if (typeof(superclass) == 'function') {
+      superclass.getInstance = superclass.getInstance ||
+        Class.encap(new superclass(Class._doNotInit));
+      subclass.prototype = superclass.getInstance();
+    } else if (typeof(superclass) == 'object')
+      subclass.prototype = superclass;
+    return subclass.prototype;
-  }
+
-}
-
+// Initialize and forever hide the call stack:
+Class._setUpAndHideCallStack();
+
+Function.prototype.grant = Class._grant;
+var createClass = Class.create;
+
-var Abstract = new Object();
-
-Object.extend = function(destination, source) {