SebastianHGonzalez

inject(definition) {
  definition.decoreateTargets(joinPoint => this.decorate(joinPoint));
}

SebastianHGonzalez

around(context, joinPoint, ...args) {
  return this.aspects.reduce(
    function aroundReducer(next, aspect) {
      return function joinPointify(...newArgs) {
        const newContext = this;
        aspect.around(newContext, next, ...newArgs)
      }
    },
    joinPoint
  ).apply(context, args);

SebastianHGonzalez

before(context, joinPointName, ...args) {
  this.aspects.reduce(
    (_, aspect) => aspect.before(context, joinPointName, ...args)
  );
}

after(context, joinPointName, result, ...args) {
  return this.aspects.reduce(
    (prevResult, aspect) => aspect.after(context, joinPointName, prevResult, ...args),
    result

SebastianHGonzalez

addAspect(aspect) {
  this.aspects = [...this.aspects, aspect];
}

SebastianHGonzalez

class LoggerAspect {

  constructor(logger) {
    this.logger = logger;
  }
  
  before(context, joinPointName, ...args) {
    this.logger.log("logging");
  }
}

SebastianHGonzalez

function timeAspect(joinPoint, logger) {
    const aspect = {
      logger,
      timer: {
        start: function () { this.startTime = Date.now() },
        stop: function () { this.stopTime = Date.now() },
        time: function () { return this.stopTime - this.startTime }
      },
      before: function () { this.timer.start() },

SebastianHGonzalez

class PointCut {
    constructor(definition) {
        this.inject(definition);
    }

    inject(definition) {
        this.injectAspectToObjectMethods(definition.class.prototype);
    }

    injectAspectToObjectMethods(prototype) {

SebastianHGonzalez

const personGreetingPC = new PointCut({class: Person, methodName: "greet"});

jhon.greet();
// <- "Hello jhon"

personGreetingPC.addAspect(loggerAspect);

jhon.greet();
// logging
// <- "Hello jhon"

SebastianHGonzalez

function greet() {
    return "Hello " + this.name ;
}

const john = {
    name: "John"
}

const jane = {
    name: "Jane"

SebastianHGonzalez

function timeAspect(joinPoint, logger) {
    const timer = {
        start: function () { this.startTime = Date.now() },
        stop: function () { this.stopTime = Date.now() },
        time: function () { return this.stopTime - this.startTime }
    };

    function before() { timer.start() }
    function after() { timer.stop(), logger.log(timer.time) }
    return aspect(joinPoint, { before, after })