Ticket #4060: base.js.5.diff

src/base.js

@@ -1 @@
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    }
+    
+    return constructor;
+  };
+
+  var __enableMimicry = function(__ctor) {
+    var __old = __ctor.prototype;
+    __ctor['mimic'] = function(obj) {
+      var __new = Object.extend(obj, __old);
+      __ensureDefaults(__new, __old);
+      return Object.extend(function() {
+        return __ctor.apply(this, arguments);
+      }, { 'prototype': __new });
+    };
+  };
+
+  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) {
+        func.ancestor = this[fnName];
+        __attachClassProperty(fnName, func, this);
+      },
+      'deleteMethod': function(fnName) {
+        delete this[fnName];
+      }
+    });
+  };
+
+  var __validOverride = function(propName) {
+    switch (propName) {
+    case vocab['super']: case 'valueOf':
+    case 'attachMethod': case 'deleteMethod':
+    case 'getBaseInstance': return false;
+    default: return true;
+    }
+  };
+
+  // last receiving object
+  var __context = window;
+  
+  var __attachClassProperty = function(propName, prop, obj) {
+    
+    if (typeof(obj[propName] = prop) == 'function') {
+      
+      if (__validOverride(propName)) {
+        var __ancestor = prop.ancestor;
+          
+        obj[propName] = function() {
+          __ensurePrivacy(propName, this); // optional
+          // save this object reference globally
+          var __savedContext = __context;
+          __context = this;
+          // save the current version of the super function
+          var __superSaver = this[vocab['super']];
+          this[vocab['super']] = __ancestor;
+          
+          try { var result = prop.apply(this, arguments); }
+          catch (ex) { throw ex; }
+          finally { // restore super and object reference
+            this[vocab['super']] = __superSaver;
+            __context = __savedContext;
+          }  
+          return result;
+        };
+      
+        obj[propName].valueOf = Class.encap(prop);
+      }
+
+      var __origStr = prop.toString();
+      prop.toString = obj[propName].toString = function() {
+        return __origStr.replace(/^\s*function/, propName);
+      };
+    }
+  };
+
+  var __ensurePrivacy = function(propName, obj) {
+    if ((!__context || obj.constructor !== __context.constructor)
+        && propName[0] == '_') // private naming convention
+          alert("Tried to call private method " + propName +
+                " from foreign object " + __context + ".");
-  }
-}
-
+  // all the functionality of bind(), plus context-sensitivity
+  Function.prototype.grant = function(obj) {
+    var __func = this;
+    var __originalContext = __context;
+    return function() {
+      __savedContext = __context;
+      __context = __originalContext;
+      try { var result =
+              __func.apply(obj || this, arguments); }
+      catch (ex) { throw ex; }
+      finally { __context = __savedContext; }
+      return result;
+    }
+  };
+
+  var __ensureDefaults = function(ownPrototype, declarations) {
+    ['toString', 'toLocaleString', 'valueOf'].each(function(propName) {
+      var prop = declarations[propName];
+      if (!!prop) {
+        prop.ancestor = ownPrototype[propName];
+        __attachClassProperty(propName, prop, ownPrototype);
+      }
+    });
+  };
+
+  // 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;
+    }
+  };
+  
+})( // the vocabulary is arbitrary:
+{'super': 'sup', 'init': 'initialize'});
+
-var Abstract = new Object();
-
-Object.extend = function(destination, source) {