This library provides simple aspect oriented programming features in javascript using ES7 decorators.
It is a derivative of Board project.
Please note that this library is intended to do simple runtime checks and should be used as the last resort. It is not async-compatible, i.e. the activities in an Aspect class cannot contain any callbacks or promises, whereas the original function can be async.
In gru-aspect.js
:
import Aspect from 'es7-aspect';
export default class GruAspect extends Aspect {
//Once again, no async calls in any of these functions
@Aspect.before('stealsTheMoon')
eatsABanana(bananas) {
if (bananas) {
console.log(`There're ${bananas.length} banana(s). Eat one.`);
bananas.pop();
}
}
@Aspect.intercept('stealsTheMoon')
checkBananas(resolve, reject, bananas) {
if (!bananas || bananas.length === 0) {
console.log('No banana. Nah.');
reject();
}
else {
console.log(`${bananas.length} banana(s)!`);
resolve();
}
}
@Aspect.after('stealsTheMoon')
givesBananas(bananas) {
console.log(`${bananas.length} banana(s) left.`);
}
}
In gru.js
:
import Aspect from 'es7-aspect';
import GruAspect from './gru-aspect';
@Aspect.use(GruAspect)
export default class Gru {
stealsTheMoon(bananas) {
console.log('Just stole the moon!');
}
}
In a console:
new Gru().stealsTheMoon();
// Prints 'No banana. Nah.'
new Gru().stealsTheMoon(['banana', 'banana']);
// Prints
// There're 2 banana(s). Eat one.
// Just stole the moon!
// 1 banana(s) left.
There are three advices: Before, After and Intercept.
Perform certain activities before the original function executes. After all defined activities finishes, the original will run. The pre-activities have access to the actual arguments that will be eventually applied.
The intercept advice runs before the original function, similar to the before advice, except that there can be one and only one intercept advice defined for a method, and it has the ability to prevent the original function from execution.
- To continue running after completing the interception, call
resolve()
. - Otherwise, to stop execution, call
reject([val])
.[val]
is an optional argument that will be used as the return value of original function.
Perform certain activities after the original function executes. All activities run after the original function completes execution. The post-activities have access to the actual arguments that will be eventually applied.