avocado-old/packages/behavior/context/index.js

import D from 'debug';

import {fastApply} from '@avocado/core';
import {Vector} from '@avocado/math';

import {Globals} from './globals';
import {TraversalCompiler} from './traversal-compiler';
import {TypeMap} from './types';

const compiled = new Map();
const debug = D('@avocado:behavior:context');

class Context extends Map {

  add(key, value) {
    this.set(key, value);
  }

  clear() {
    super.clear();
    this.add('context', this);
    this.add('global', new Globals());
    this.add('Vector', Vector);
  }

  compile(traversal) {
    // Compile traversal.
    if (!compiled.has(traversal.hash)) {
      const compilation = new TraversalCompiler(traversal);
      const fn = new Function('context', compilation.emit());
      compiled.set(traversal.hash, fn);
    }
    return compiled.get(traversal.hash);
  }

  renderStepsUntilNow(steps, step) {
    const stepsUntilNow = steps.slice(0, steps.indexOf(step));
    return TypeMap.renderSteps(stepsUntilNow);
  }

  takeStep(value, fn) {
    if (value instanceof Promise) {
      return value.then((value) => {
        return fn(value);
      });
    }
    else {
      return fn(value);
    }
  }

  traverse(traversal) {
    // Compile?
    if (traversal.hash) {
      return this.compile(traversal)(this);
    }
    else {
      return this.traverseRaw(traversal);
    }
  }

  traverseAndDo(steps, fn) {
    const [first, ...rest] = steps;
    if ('key' !== first.type) {
      throw new TypeError(`First step in a traversal must be type "key"`);
    }
    let previousNode = null;
    return rest.reduce((node, step, index) => {
      return this.takeStep(node, (node) => {
        const result = fn(node, previousNode, step, index);
        previousNode = node;
        return result;
      });
    }, this.get(first.key));
  }

  traverseOneStep(steps, previousNode, node, step) {
    if ('undefined' === typeof node) {
      const rendered = this.renderStepsUntilNow(steps, step);
      debug(`"${rendered}" is traversed through but undefined`);
      return;
    }
    switch (step.type) {
      case 'key':
        return node[step.key];
      case 'invoke':
        const args = step.args.map((arg) => arg.get(this));
        return fastApply(previousNode, node, args);
    }
  }

  traverseRaw(traversal) {
    const {steps, value} = traversal;
    return this.traverseAndDo(steps, (node, previousNode, step, index) => {
      const isLastStep = index === steps.length - 2;
      // Traverse if we're not at the final step with a value.
      if (!isLastStep || !value) {
        return this.traverseOneStep(steps, previousNode, node, step);
      }
      // Try to set the value.
      switch (step.type) {
        case 'key':
          return node[step.key] = value.get(this);
        case 'invoke':
          const rendered = this.renderStepsUntilNow(steps, step);
          debug(`invalid assignment to function "${rendered}"`);
          return;
      }
    });
  }
}

export function createContext() {
  const context = new Context();
  context.clear();
  return context;
}