Ticket #4060: base.js.diff

src/base.js

@@ -1 @@
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    }
-  }
-}
-
+    return ctor;
+  };
+
+  // superclass can be constructor function or existing object
+  var __inherit = function(subclass, superclass) {
+    if (typeof(superclass) == 'function') {
+      superclass.getInstance = superclass.getInstance ||
+        Class.encap(new superclass(__doNotInit));
+      subclass.prototype = superclass.getInstance();
+    } else if (typeof(superclass) == 'object')
+      subclass.prototype = superclass;
+    return subclass.prototype;
+  };
+  
+  // Functions marked here will be denied this.sup and privacy benefits,
+  // but will be faster because they will be called directly.
+  var __markCriticalFunctions = function(declarations) {
+    var critical = declarations.critical;
+    if (typeof(critical) == 'object') {
+      for (var i in critical) {
+        critical[i]._critical = true;
+        declarations[i] = critical[i];
+      }
+    }
+  };
+
+  var __setupAttachDelete = function(declarations) {
+    // these two methods allow runtime method attachment and deletion,
+    // with all the benefits of this.sup and privacy restrictions
+    declarations['attachMethod'] = function(fnName, func,
+                                            /*optional*/ critical) {
+      // can't replace existing methods
+      if (!this.ownPrototypeHas(fnName)) {
+        func._critical = !!critical;
+        this._runTimeDeclarations[fnName] = true;
+        __attachClassProperty(fnName, func, this);
+      }
+    };
+    declarations['deleteMethod'] = function(fnName) {
+      // can only delete non-runtime additions
+      if (this._runTimeDeclarations[fnName]) {
+        __attachClassProperty(fnName, null, this, true);
+        this._runTimeDeclarations[fnName] = false;
+      }
+    };
+  };
+  
+  var __attachClassProperty = function(propName, prop, obj,
+                                       /*optional*/ removeInstead) {
+    if (removeInstead) {
+      if (obj.ownPrototypeHas(propName)) delete obj[propName];
+    } else {
+      obj[propName] = prop;
+      if (!prop._critical && typeof(prop) == 'function')
+        __addStackLogic(obj, 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 __lastOnCallStack = function() {
+    if (__callStack.empty()) return ['', null];
+    else return __callStack.peek();
+  };
+    
+  var __addStackLogic = function(obj, fnName) {
+    switch (fnName) {
+      case 'sup': case 'toString': case 'valueOf':
+      case 'attachMethod': case 'deleteMethod':
+      case 'getBaseInstance': return;
+      default: {
+        var __func = obj[fnName];
+        obj[fnName] = function() {
+          // this privacy check can be omitted for slight performance
+          // gains in production code (privacy is a development tool)
+          var lastRef = __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;
+          }
+        };
+      }
+      obj[fnName].core = __func; // preserve original
+      // e.g. obj[fnName].core.call(obj, arg1, ...)
+    }
+  };
+    
+  Function.prototype.grant = function(obj) {
+    var __func = this;
+    var __callStackMemory = __lastOnCallStack();
+    return function() {
+      __callStack.push(__callStackMemory);
+      var result = __func.apply(obj || this, arguments);
+      __callStack.pop();
+      return result;
+    }
+  };
+
+  // consider exposing these (they expose nothing but useful info)
+  var __nameOfLastCalledMethod = function() {
+    return __lastOnCallStack()[0];
+  };
+
+  var __refOfLastCallingObject = function() {
+    return __lastOnCallStack()[1];
+  };
+
+  // change this at will
+  this.followsPrivateNamingConvention = function(propName) {
+    return propName.charAt(0) == '_';
+  };
+  
+  this.privateCallError = function(fnName) {
+    alert("Error: Tried to access private member " + fnName +
+          " from from non-member method " +
+          __nameOfLastCalledMethod());
+  };
+
+  var __ensureDefaults = function(ownPrototype, declarations) {
+    ['toString',
+     'toLocaleString',
+     'valueOf'].each(function(prop) {
+       if (declarations[prop]) {
+         __attachClassProperty(prop, declarations[prop], ownPrototype);
+       }
+     });
+    ownPrototype.ownPrototypeHas = function(property) {
+      return (typeof(declarations[property]) != 'undefined' ||
+              (this._runTimeDeclarations && // present if instantiated
+               this._runTimeDeclarations[property]));
+    }
+  };
+
+  var __makeSup = function(parentPrototype) {
+    var __platform = false; // where to start lookup
+    
+    return function() {
+      var origin = __nameOfLastCalledMethod();
+      var curObj = __platform || this;
+
+      // walk up inheritance chain until we've found the first class that
+      // actually implements the method from which this.sup was called
+      while (!curObj.ownPrototypeHas(origin)
+             && curObj.getBaseInstance)
+        curObj = curObj.getBaseInstance();
+      curObj = curObj.getBaseInstance
+        ? curObj.getBaseInstance()
+        : {}; // origin won't be found here!
+
+      var prevBase = __platform;
+      __platform = curObj;
+      var result = curObj[origin].apply(this, arguments);
+      __platform = prevBase;
+      return result;
+    };
+  };
+
+  // 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;
+    }
+  };
+
+})(); // construct the Class object
+
+var createClass = Class.create;
+
-var Abstract = new Object();
-
-Object.extend = function(destination, source) {