Ticket #6810: aspect.diff

test/unit/base.html

@@ -49 +49 @@
-    }
-    
-  var globalBindTest = null;
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-  new Test.Unit.Runner({
-    
-    testFunctionBind: function() { with(this) {
@@ -123 +168 @@
-          this.assertEqual.bind(this,arg3), arg1, arg2, arg3 );
-        call(eventTest);
-      }
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
+      account.transaction(-10);
+      assertEqual(89, account.currentBalance);
+      assertEqual('transaction request for $ -10', account.log[2]);
+      assertEqual('transaction was successfully processed', account.log.last());
+    }},
+    
+    testCachingOriginalMethods: function() {with(this) {     
+      var account = new BankAccount('anyone', 100);      
+      Object.extend(account, Aspect);
+      
+      account.addBeforeAdvice('toString', Prototype.emptyFunction);
+      assertIdentical(BankAccount.prototype.toString, account.originalMethods._toString);
+      
+      // check that the cached method is not overwritten
+      account.addBeforeAdvice('toString', Prototype.emptyFunction);
+      assertIdentical(BankAccount.prototype.toString, account.originalMethods._toString);
+      account.restoreOriginalMethod('toString');
+      
+      ['addBeforeAdvice', 'addAfterAdvice', 'addAroundAdvice'].each(function(advice) {
+        account[advice]('toString', Prototype.emptyFunction);
+        assertIdentical(BankAccount.prototype.toString, account.originalMethods._toString);
+        account.restoreOriginalMethod(advice);
+      });
+    }},
+    
+    testRestoreOriginalMethods: function() {with(this) {
+      account = new BankAccount('Anyone', 100);      
+      Object.extend(account, Aspect);
+      account.addBeforeAdvice('toString', Prototype.emptyFunction);
+      account.addBeforeAdvice('transaction', Prototype.emptyFunction);
+      
+      account.restoreOriginalMethod('toString');
+      assertIdentical(BankAccount.prototype.toString, account.toString);
+      assertNotEqual(BankAccount.prototype.transaction, account.transaction);
+      
+      account = new BankAccount('Anyone', 100);      
+      Object.extend(account, Aspect);
+      account.addBeforeAdvice('toString', Prototype.emptyFunction);
+      account.addBeforeAdvice('transaction', Prototype.emptyFunction);
+      account.restoreOriginalMethod('toString', 'transaction');
+      assertIdentical(BankAccount.prototype.toString, account.toString);
+      assertIdentical(BankAccount.prototype.transaction, account.transaction);
+    }},
+    
+    testAspectAppliedDirectlyToPrototype: function() {with(this) {
+      Object.extend(BankAccount.prototype, Aspect);
+      BankAccount.prototype.addAfterAdvice('initialize', TransactionAspects.welcomeGift);
+      BankAccount.prototype.addAroundAdvice('transaction', TransactionAspects.limitCredit);
+      BankAccount.prototype.addBeforeAdvice('transaction', TransactionAspects.logTransaction);
+      BankAccount.prototype.addAfterAdvice('transaction', TransactionAspects.transactionFee);
+      BankAccount.prototype.addBeforeAdvice('toString', Prototype.emptyFunction);
+      
+      var account = new BankAccount('You', 10000);
+      assertEqual(10050, account.currentBalance);
+      
+      account.transaction(-1000);
+      assertEqual(8950, account.currentBalance);
+      assertEqual('transaction request for $ -1000', account.log.first());
+      assertEqual('transaction was successfully processed', account.log.last());
+
+      account.transaction(-10000);
+      assertEqual(8950, account.currentBalance);
+      assertEqual('transaction request for $ -10000', account.log[2]);
+      assertEqual('cannot process transaction', account.log[3]);
+
+      BankAccount.prototype.restoreOriginalMethod('initialize');
+
+      var account_2 = new BankAccount('Him', 1000);
+      assertEqual(1000, account_2.currentBalance);
+
+      BankAccount.prototype.restoreOriginalMethod('toString', 'transaction');
+      account.transaction(-10000);
+      assertEqual(-1050, account.currentBalance);
+      assertUndefined(account.log[4]);
+      assertUndefined(account.log[5]);
+    }}
-  }, 'testlog');
-
-// ]]>

src/base.js

@@ -60 +60 @@
-  }
-}
-
+var Aspect = {
+  originalMethods: {},
+  addBeforeAdvice: function(method, advice) {
+    var original = this[method];
+    if(!this.originalMethods['_' + method]) this.originalMethods['_' + method] = original;
+    var original = this[method];
+    this[method] = function() {
+      advice.apply(this, arguments);
+      return original.apply(this, arguments);
+    }
+  },
+  addAfterAdvice: function(method, advice) {
+    var original = this[method];
+    if(!this.originalMethods['_' + method]) this.originalMethods['_' + method] = original;
+    this[method] = function() {
+      var returnedValue = original.apply(this, arguments);
+      return advice.apply(this, [returnedValue].concat($A(arguments)));
+    }
+  },
+  addAroundAdvice: function(method, advice) {
+    var original = this[method];
+    if(!this.originalMethods['_' + method]) this.originalMethods['_' + method] = original;
+    this[method] = function() {
+      return advice.apply(this, [original.bind(this)].concat($A(arguments)));
+    }
+  },
+  restoreOriginalMethod: function() {
+    $A(arguments).each(function(method) {
+      this[method] = this.originalMethods['_' + method];
+      delete this.originalMethods['_' + method];
+    }.bind(this));
+  }
+}
+
-Object.extend(Number.prototype, {
-  toColorPart: function() {
-    var digits = this.toString(16);