trufflesuite/truffle

import debugModule from "debug";
const debug = debugModule("debugger:sourcemapping:reducers");

import { combineReducers } from "redux";

import * as actions from "./actions";

const DEFAULT_SOURCES = {
  byCompilationId: {}, //user sources
  byContext: {} //internal sources
};

//This piece of state is organized as follows:
//1. byId: contains all the sources, by ID.  straightforward.
//2. byCompilationId: contains the IDs of the user sources,
//organized by compilation ID and then index (this last part
//takes the form of an array).
//3. byContext: contains the IDs of the internal sources,
//organized by context hash and then index (again, this
//last part takes the form of an array, although a sparse
//array be aware).
function sources(state = DEFAULT_SOURCES, action) {
  switch (action.type) {
    /*
     * Adding new sources
     */
    case actions.ADD_SOURCES:
      //NOTE: this code assumes that we are only ever adding compilations or contexts
      //wholesale, and never adding to existing ones!
      return {
        byCompilationId: {
          ...state.byCompilationId,
          ...Object.assign(
            {},
            ...Object.entries(action.sources.user).map(([id, compilation]) => ({
              [id]: {
                byIndex: compilation.map(source => source.id)
              }
            }))
          )
        },
        byContext: {
          ...state.byContext,
          ...Object.assign(
            {},
            ...Object.entries(action.sources.internal).map(
              ([hash, context]) => ({
                [hash]: {
                  byIndex: context.map(source => source.id)
                }
              })
            )
          )
        },
        byId: {
          ...state.byId,
          ...Object.assign(
            {},
            ...Object.values(action.sources.user)
              .concat(Object.values(action.sources.internal))
              .flat()
              .map(source => (source ? { [source.id]: source } : {}))
          )
        }
      };
    /*
     * Default case
     */
    default:
      return state;
  }
}

const info = combineReducers({
  sources
});

function functionDepthStack(state = [], action) {
  switch (action.type) {
    case actions.JUMP:
      let newState = state.slice(); //clone the state
      const delta = spelunk(action.jumpDirection);
      let top = newState[newState.length - 1];
      let belowTop = newState.length > 1 ? newState[newState.length - 2] : -1;
      newState[newState.length - 1] = Math.max(top + delta, belowTop + 1);
      return newState;

    case actions.RESET:
      return [0];

    case actions.UNLOAD_TRANSACTION:
      return [];

    case actions.EXTERNAL_CALL:
      if (state.length === 0) {
        return [0];
      }
      return [...state, state[state.length - 1] + 1];

    case actions.EXTERNAL_RETURN:
      //just pop the stack! unless, HACK, that would leave it empty
      return state.length > 1 ? state.slice(0, -1) : state;

    default:
      return state;
  }
}

function nextFrameIsPhantom(state = null, action) {
  switch (action.type) {
    case actions.CLEAR_PHANTOM_GUARD:
      return false;
    case actions.EXTERNAL_RETURN:
      return false;
    case actions.EXTERNAL_CALL:
      return action.guard;
    case actions.RESET:
      return action.guard;
    case actions.UNLOAD_TRANSACTION:
      return null;
    default:
      return state;
  }
}

function spelunk(jump) {
  if (jump === "i") {
    return 1;
  } else if (jump === "o") {
    return -1;
  } else {
    return 0;
  }
}

const proc = combineReducers({
  functionDepthStack,
  nextFrameIsPhantom
});

const reducer = combineReducers({
  info,
  proc
});

export default reducer;