Ticket #4060: base.js.2.diff

src/base.js

@@ -1 @@
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    }
-  }
-}
-
+    // Returns a constructor identical to the original, except that the
+    // specified object will become a part of the prototype chain of any
+    // instantitated objects.  The inheritance chain of the extending
+    // class has precedence over the prototype chain of obj, the extended
+    // object, so mimicking other Class.created objects will break those
+    // objects' existing inheritance relationships.  Time taken is linear
+    // in the number of properties of the extending class.
+    ctor['mimic'] = function(obj) {
+      // Unfortunately it seems that you just can't use
+      // DOM objects as prototypes for constructor functions
+      // in Safari... how braindead is that?  Ugh :(
+      var __ctor = this;
+      var fn = function(/*arguments*/) {
+        __ctor.apply(this, arguments);
+      };
+      Object.extend(obj, __ctor.prototype);
+      __ensureDefaults(obj, __ctor.prototype);
+      fn.prototype = obj;
+      return fn;
+    };
+
+    return ctor;
+  };
+
+  // superclass can be constructor function or any 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;
+      superclass.initialize = superclass.constructor;
+    }
+    return subclass.prototype;
+  };
+  
+  // Functions marked here will be denied this.sup and privacy benefits,
+  // but will be slightly 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 (typeof(prop) == 'function') {
+        if (!prop._critical && typeof(prop.body) != 'function')
+          __addStackLogic(obj, propName);
+        var __origStr = prop.toString(); // never changes
+        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 __lastOnCallStack = function() {
+    if (__callStack.empty()) return ['', null];
+    else return __callStack.peek();
+  };
+    
+  var __addStackLogic = function(obj, fnName) {
+    switch (fnName) {
+      case 'sup': 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 || lastRef.constructor !== this.constructor)) {
+            Class.privateCallError(fnName);
+          } else {
+            __callStack.push([fnName, this]);
+            try { // don't let exceptions corrupt the callstack
+              var result = __func.apply(this, arguments);
+            } catch (exception) {
+              throw exception;
+            } finally {
+              __callStack.pop();
+            }
+            return result;
+          }
+        };
+      }
+      obj[fnName].body = __func; // preserve original
+      // e.g. obj[fnName].body.call(obj, arg1, ...)
+    }
+  };
+    
+  Function.prototype.grant = function(obj) {
+    var __func = this;
+    var __callStackMemory = __lastOnCallStack();
+    return function() {
+      __callStack.push(__callStackMemory);
+      try { // don't let exceptions corrupt the callstack
+        var result = __func.apply(obj || this, arguments);
+      } catch (exception) {
+        throw exception;
+      } finally {
+        __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) {
+      __attachClassProperty(prop, declarations[prop], 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 method = __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 &&
+             !curObj.ownPrototypeHas(method) &&
+              curObj.getBaseInstance)
+        curObj = curObj.getBaseInstance();
+      curObj = curObj.getBaseInstance
+        ? curObj.getBaseInstance()
+        : {}; // the ultimate baseInstance
+
+      var prevBase = __platform;
+      __platform = curObj;
+      try { // don't let exceptions break the lookup
+        var result = curObj[method].apply(this, arguments);
+      } catch (exception) {
+        throw exception;
+      } finally {
+        __platform = prevBase;
+      }
+      return result;
+    };
+  };
+
+})(); // good place to pass in parameters that determine what features are
+      // enabled (production, development, debug, etc.)
+
+var createClass = Class.create;
+
-var Abstract = new Object();
-
-Object.extend = function(destination, source) {