6062654729

Committed 03 Sep 2023 05:21AM UTC coverage: 80.232% (-0.04%) from 80.269%

Build # 6062654729

Build Type

push

github

Committed by

iddan

Commit Message

Fix formatting

Run Details

417 of 568 branches covered (0.0%)

Branch coverage included in aggregate %.

1 of 1 new or added line in 1 file covered. (100.0%)

967 of 1157 relevant lines covered (83.58%)

28.47 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

68.42

/src/engine.ts

import FormulaParser, { FormulaError, Value } from "fast-formula-parser";
import { getReferences } from "./formula";
import * as Matrix from "./matrix";
import * as Formula from "./formula";
import { Point } from "./point";
import { PointGraph } from "./point-graph";
import { PointSet } from "./point-set";
import { CellBase } from "./types";

export class Model<Cell extends CellBase> {
  readonly data!: Matrix.Matrix<Cell>;
  readonly evaluatedData!: Matrix.Matrix<Cell>;

  readonly referenceGraph!: PointGraph;

  constructor(
    data: Matrix.Matrix<Cell>,
    referenceGraph?: PointGraph,
    evaluatedData?: Matrix.Matrix<Cell>
  ) {
    this.data = data;
    this.referenceGraph = referenceGraph || createReferenceGraph(data);
    this.evaluatedData =
      evaluatedData || createEvaluatedData(data, this.referenceGraph);
  }
}

export function updateCellValue<Cell extends CellBase>(
  model: Model<Cell>,
  point: Point,
  cell: Cell,
  parserConstructor?: (getData: () => Matrix.Matrix<CellBase>) => FormulaParser
): Model<Cell> {
  const nextData = Matrix.set(point, cell, model.data);
  const nextReferenceGraph = Formula.isFormulaValue(cell.value)
    ? updateReferenceGraph(model.referenceGraph, point, cell, nextData)
    : model.referenceGraph;

  const nextEvaluatedData = evaluateCell(
    model.evaluatedData,
    nextData,
    nextReferenceGraph,
    point,
    cell,
    parserConstructor
  );
  return new Model(nextData, nextReferenceGraph, nextEvaluatedData);
}

function updateReferenceGraph(
  referenceGraph: PointGraph,
  point: Point,
  cell: CellBase<string>,
  data: Matrix.Matrix<CellBase>
): PointGraph {
  const references = getReferences(
    Formula.extractFormula(cell.value),
    point,
    data
  );
  const nextReferenceGraph = referenceGraph.set(point, references);
  return nextReferenceGraph;
}

function evaluateCell<Cell extends CellBase>(
  prevEvaluatedData: Matrix.Matrix<Cell>,
  data: Matrix.Matrix<Cell>,
  referenceGraph: PointGraph,
  point: Point,
  cell: Cell,
  parserConstructor?: (getData: () => Matrix.Matrix<CellBase>) => FormulaParser
): Matrix.Matrix<Cell> {
  if (referenceGraph.hasCircularDependency(point)) {
    let visited = PointSet.from([point]);
    let nextEvaluatedData = Matrix.set(
      point,
      { ...cell, value: FormulaError.REF },
      prevEvaluatedData
    );
    for (const referrer of referenceGraph.getBackwardsRecursive(point)) {
      if (visited.has(referrer)) {
        break;
      }
      visited = visited.add(referrer);
      const referrerCell = Matrix.get(referrer, data);
      if (!referrerCell) {
        continue;
      }
      nextEvaluatedData = Matrix.set(
        referrer,
        { ...referrerCell, value: FormulaError.REF },
        nextEvaluatedData
      );
    }
    return nextEvaluatedData;
  }

  let nextEvaluatedData = prevEvaluatedData;

  const formulaParser = (parserConstructor ?? Formula.createBoundFormulaParser)(
    () => nextEvaluatedData
  );

  const evaluatedValue = Formula.isFormulaValue(cell.value)
    ? getFormulaComputedValue(cell.value, point, formulaParser)
    : cell.value;

  const evaluatedCell = { ...cell, value: evaluatedValue };

  nextEvaluatedData = Matrix.set(point, evaluatedCell, nextEvaluatedData);

  // for every formula cell that references the cell re-evaluate (recursive)
  for (const referrer of referenceGraph.getBackwardsRecursive(point)) {
    const referrerCell = Matrix.get(referrer, data);
    if (!referrerCell) {
      continue;
    }
    const evaluatedValue = Formula.isFormulaValue(referrerCell.value)
      ? getFormulaComputedValue(referrerCell.value, point, formulaParser)
      : referrerCell.value;
    const evaluatedCell = { ...referrerCell, value: evaluatedValue };
    nextEvaluatedData = Matrix.set(referrer, evaluatedCell, nextEvaluatedData);
  }

  return nextEvaluatedData;
}

/**
 *
 * @param data - the spreadsheet data
 * @returns the spreadsheet reference graph
 */
export function createReferenceGraph(
  data: Matrix.Matrix<CellBase>
): PointGraph {
  const entries: Array<[Point, PointSet]> = [];
  for (const [point, cell] of Matrix.entries(data)) {
    if (cell && Formula.isFormulaValue(cell.value)) {
      const references = getReferences(
        Formula.extractFormula(cell.value),
        point,
        data
      );
      entries.push([point, references]);
    }
  }
  return PointGraph.from(entries);
}

export function createEvaluatedData<Cell extends CellBase>(
  data: Matrix.Matrix<Cell>,
  referenceGraph: PointGraph,
  parserConstructor?: (getData: () => Matrix.Matrix<CellBase>) => FormulaParser
): Matrix.Matrix<Cell> {
  let evaluatedData = data;

  const formulaParser = (parserConstructor ?? Formula.createBoundFormulaParser)(
    () => evaluatedData
  );

  // Iterate over the points in the reference graph, starting from the leaves
  for (const point of referenceGraph.traverseBFS()) {
    // Get the cell at the current point in the data Matrix
    const cell = Matrix.get(point, data);
    if (!cell) {
      continue;
    }

    // If the cell is a formula cell, evaluate it
    if (Formula.isFormulaValue(cell.value)) {
      const evaluatedValue = getFormulaComputedValue(
        cell.value,
        point,
        formulaParser
      );
      evaluatedData = Matrix.set(
        point,
        { ...cell, value: evaluatedValue },
        evaluatedData
      );
    }
  }

  return evaluatedData;
}

/** Get the computed value of a formula cell */
export function getFormulaComputedValue(
  value: string,
  point: Point,
  formulaParser: FormulaParser
): Value {
  const formula = Formula.extractFormula(value);
  try {
    return Formula.evaluate(formula, point, formulaParser);
  } catch (e) {
    return FormulaError.REF;
  }
}

1	import FormulaParser, { FormulaError, Value } from "fast-formula-parser";	11✔
2	import { getReferences } from "./formula";	11✔
3	import * as Matrix from "./matrix";	11✔
4	import * as Formula from "./formula";	11✔
5	import { Point } from "./point";
6	import { PointGraph } from "./point-graph";	11✔
7	import { PointSet } from "./point-set";	11✔
8	import { CellBase } from "./types";
9
10	export class Model<Cell extends CellBase> {	11✔
11	readonly data!: Matrix.Matrix<Cell>;
12	readonly evaluatedData!: Matrix.Matrix<Cell>;
13
14	readonly referenceGraph!: PointGraph;
15
16	constructor(
17	data: Matrix.Matrix<Cell>,
18	referenceGraph?: PointGraph,
19	evaluatedData?: Matrix.Matrix<Cell>
20	) {
21	this.data = data;	38✔
22	this.referenceGraph = referenceGraph \|\| createReferenceGraph(data);	38✔
23	this.evaluatedData =	38✔
24	evaluatedData \|\| createEvaluatedData(data, this.referenceGraph);	70✔
25	}
26	}
27
28	export function updateCellValue<Cell extends CellBase>(	11✔
29	model: Model<Cell>,
30	point: Point,
31	cell: Cell,
32	parserConstructor?: (getData: () => Matrix.Matrix<CellBase>) => FormulaParser
33	): Model<Cell> {
34	const nextData = Matrix.set(point, cell, model.data);	6✔
35	const nextReferenceGraph = Formula.isFormulaValue(cell.value)	6✔
36	? updateReferenceGraph(model.referenceGraph, point, cell, nextData)	6✔
37	: model.referenceGraph;
38
39	const nextEvaluatedData = evaluateCell(	6✔
40	model.evaluatedData,
41	nextData,
42	nextReferenceGraph,
43	point,
44	cell,
45	parserConstructor
46	);
47	return new Model(nextData, nextReferenceGraph, nextEvaluatedData);	6✔
48	}
49
50	function updateReferenceGraph(
51	referenceGraph: PointGraph,
52	point: Point,
53	cell: CellBase<string>,
54	data: Matrix.Matrix<CellBase>
55	): PointGraph {
56	const references = getReferences(	3✔
57	Formula.extractFormula(cell.value),
58	point,
59	data
60	);
61	const nextReferenceGraph = referenceGraph.set(point, references);	3✔
62	return nextReferenceGraph;	3✔
63	}
64
65	function evaluateCell<Cell extends CellBase>(
66	prevEvaluatedData: Matrix.Matrix<Cell>,
67	data: Matrix.Matrix<Cell>,
68	referenceGraph: PointGraph,
69	point: Point,
70	cell: Cell,
71	parserConstructor?: (getData: () => Matrix.Matrix<CellBase>) => FormulaParser
72	): Matrix.Matrix<Cell> {
73	if (referenceGraph.hasCircularDependency(point)) {	6✔
74	let visited = PointSet.from([point]);	1✔
75	let nextEvaluatedData = Matrix.set(	1✔
76	point,
77	{ ...cell, value: FormulaError.REF },
78	prevEvaluatedData
79	);
80	for (const referrer of referenceGraph.getBackwardsRecursive(point)) {	1✔
81	if (visited.has(referrer)) {	1✔
82	break;	1✔
83	}
84	visited = visited.add(referrer);	×
85	const referrerCell = Matrix.get(referrer, data);	×
86	if (!referrerCell) {	×
87	continue;	×
88	}
89	nextEvaluatedData = Matrix.set(	×
90	referrer,
91	{ ...referrerCell, value: FormulaError.REF },
92	nextEvaluatedData
93	);
94	}
95	return nextEvaluatedData;	1✔
96	}
97
98	let nextEvaluatedData = prevEvaluatedData;	5✔
99
100	const formulaParser = (parserConstructor ?? Formula.createBoundFormulaParser)(	5!
101	() => nextEvaluatedData	2✔
102	);
103
104	const evaluatedValue = Formula.isFormulaValue(cell.value)	5✔
105	? getFormulaComputedValue(cell.value, point, formulaParser)	5✔
106	: cell.value;
107
108	const evaluatedCell = { ...cell, value: evaluatedValue };	5✔
109
110	nextEvaluatedData = Matrix.set(point, evaluatedCell, nextEvaluatedData);	5✔
111
112	// for every formula cell that references the cell re-evaluate (recursive)
113	for (const referrer of referenceGraph.getBackwardsRecursive(point)) {	5✔
114	const referrerCell = Matrix.get(referrer, data);	×
115	if (!referrerCell) {	×
116	continue;	×
117	}
118	const evaluatedValue = Formula.isFormulaValue(referrerCell.value)	×
119	? getFormulaComputedValue(referrerCell.value, point, formulaParser)	×
120	: referrerCell.value;
121	const evaluatedCell = { ...referrerCell, value: evaluatedValue };	×
122	nextEvaluatedData = Matrix.set(referrer, evaluatedCell, nextEvaluatedData);	×
123	}
124
125	return nextEvaluatedData;	5✔
126	}
127
128	/**
129	*
130	* @param data - the spreadsheet data
131	* @returns the spreadsheet reference graph
132	*/
133	export function createReferenceGraph(	11✔
134	data: Matrix.Matrix<CellBase>
135	): PointGraph {
136	const entries: Array<[Point, PointSet]> = [];	32✔
137	for (const [point, cell] of Matrix.entries(data)) {	32✔
138	if (cell && Formula.isFormulaValue(cell.value)) {	268!
139	const references = getReferences(	×
140	Formula.extractFormula(cell.value),
141	point,
142	data
143	);
144	entries.push([point, references]);	×
145	}
146	}
147	return PointGraph.from(entries);	32✔
148	}
149
150	export function createEvaluatedData<Cell extends CellBase>(	11✔
151	data: Matrix.Matrix<Cell>,
152	referenceGraph: PointGraph,
153	parserConstructor?: (getData: () => Matrix.Matrix<CellBase>) => FormulaParser
154	): Matrix.Matrix<Cell> {
155	let evaluatedData = data;	32✔
156
157	const formulaParser = (parserConstructor ?? Formula.createBoundFormulaParser)(	32!
158	() => evaluatedData	×
159	);
160
161	// Iterate over the points in the reference graph, starting from the leaves
162	for (const point of referenceGraph.traverseBFS()) {	32✔
163	// Get the cell at the current point in the data Matrix
164	const cell = Matrix.get(point, data);	×
165	if (!cell) {	×
166	continue;	×
167	}
168
169	// If the cell is a formula cell, evaluate it
170	if (Formula.isFormulaValue(cell.value)) {	×
171	const evaluatedValue = getFormulaComputedValue(	×
172	cell.value,
173	point,
174	formulaParser
175	);
176	evaluatedData = Matrix.set(	×
177	point,
178	{ ...cell, value: evaluatedValue },
179	evaluatedData
180	);
181	}
182	}
183
184	return evaluatedData;	32✔
185	}
186
187	/** Get the computed value of a formula cell */
188	export function getFormulaComputedValue(	11✔
189	value: string,
190	point: Point,
191	formulaParser: FormulaParser
192	): Value {
193	const formula = Formula.extractFormula(value);	4✔
194	try {	4✔
195	return Formula.evaluate(formula, point, formulaParser);	4✔
196	} catch (e) {
197	return FormulaError.REF;	×
198	}
199	}

iddan / react-spreadsheet / 6062654729

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous