DepParser now throws FormulaError.

Author: LesterLyu

grammar/dependency/hooks.js

@@ -3,6 +3,7 @@ const {FormulaHelpers} = require('../../formulas/helpers');
 const {Parser} = require('../parsing');
 const lexer = require('../lexing');
 const Utils = require('./utils');
+const {formatChevrotainError} = require('../utils');
 
 class DepParser {
 
@@ -139,29 +140,27 @@ class DepParser {
      * Parse an excel formula and return the dependencies
      * @param {string} inputText
      * @param {{row: number, col: number, sheet: string}} position
-     * @param {boolean} [printOnError=true] print errors if true.
+     * @param {boolean} [ignoreError=true] print errors if true.
      * @returns {Array.<{}>}
      */
-    parse(inputText, position, printOnError = true) {
+    parse(inputText, position, ignoreError = false) {
         if (inputText.length === 0) throw Error('Input must not be empty.');
         this.data = [];
         this.position = position;
         const lexResult = lexer.lex(inputText);
         this.parser.input = lexResult.tokens;
         try {
-            let res = this.parser.formulaWithBinaryOp();
+            const res = this.parser.formulaWithBinaryOp();
             this.checkFormulaResult(res);
-            if (this.parser.errors.length > 0 && printOnError) {
-                const error = this.parser.errors[0];
-                console.warn(`Error in ${inputText}:`);
-                console.warn(error)
-            }
         } catch (e) {
-            if (printOnError) {
-                console.warn(`Error in ${inputText}:`);
-                console.warn(e);
+            if (!ignoreError) {
+                throw FormulaError.ERROR(e.message, e);
             }
         }
+        if (this.parser.errors.length > 0 && !ignoreError) {
+            const error = this.parser.errors[0];
+            throw formatChevrotainError(error, inputText);
+        }
 
         return this.data;
     }

test/grammar/errors.js

@@ -1,6 +1,7 @@
 const expect = require('chai').expect;
 const FormulaError = require('../../formulas/error');
 const {FormulaParser} = require('../../grammar/hooks');
+const {DepParser} = require('../../grammar/dependency/hooks');
 const {MAX_ROW, MAX_COLUMN} = require('../../index');
 
 const parser = new FormulaParser({
@@ -25,56 +26,69 @@ const parser = new FormulaParser({
     }
 );
 
+const depParser = new DepParser({
+    onVariable: variable => {
+        return 'aaaa' === variable ? {from: {row: 1, col: 1}, to: {row: 2, col: 2}} : {row: 1, col: 1};
+    }
+});
+
+const parsers = [parser, depParser];
+const names = ['', ' (DepParser)']
+
 const position = {row: 1, col: 1, sheet: 'Sheet1'};
 
 describe('#ERROR! Error handling', () => {
-    it('should handle NotAllInputParsedException', function () {
-        try {
-            parser.parse('SUM(1))', position);
-        } catch (e) {
-            expect(e).to.be.instanceof(FormulaError);
-            expect(e.details.errorLocation.line).to.eq(1);
-            expect(e.details.errorLocation.column).to.eq(7);
-            expect(e.name).to.eq('#ERROR!');
-            expect(e.details.name).to.eq('NotAllInputParsedException');
-            return;
-        }
-        throw Error('Should not reach here.');
-    });
+    parsers.forEach((parser, idx) => {
+        it('should handle NotAllInputParsedException' + names[idx], function () {
+            try {
+                parser.parse('SUM(1))', position);
+            } catch (e) {
+                expect(e).to.be.instanceof(FormulaError);
+                expect(e.details.errorLocation.line).to.eq(1);
+                expect(e.details.errorLocation.column).to.eq(7);
+                expect(e.name).to.eq('#ERROR!');
+                expect(e.details.name).to.eq('NotAllInputParsedException');
+                return;
+            }
+            throw Error('Should not reach here.');
+        });
 
-    it('should handle lexing error', function () {
-        try {
-            parser.parse('SUM(1)$', position);
-        } catch (e) {
-            expect(e).to.be.instanceof(FormulaError);
-            expect(e.details.errorLocation.line).to.eq(1);
-            expect(e.details.errorLocation.column).to.eq(7);
-            expect(e.name).to.eq('#ERROR!');
-            return;
-        }
-        throw Error('Should not reach here.');
-    });
+        it('should handle lexing error' + names[idx], function () {
+            try {
+                parser.parse('SUM(1)$', position);
+            } catch (e) {
+                expect(e).to.be.instanceof(FormulaError);
+                expect(e.details.errorLocation.line).to.eq(1);
+                expect(e.details.errorLocation.column).to.eq(7);
+                expect(e.name).to.eq('#ERROR!');
+                return;
+            }
+            throw Error('Should not reach here.');
 
-    it('should handle Parser error []', function () {
-        try {
-            parser.parse('SUM([Sales.xlsx]Jan!B2:B5)', position);
-        } catch (e) {
-            expect(e).to.be.instanceof(FormulaError);
-            expect(e.name).to.eq('#ERROR!');
-            return;
-        }
-        throw Error('Should not reach here.');
-    });
+        });
 
-    it('should handle Parser error', function () {
-        try {
-            parser.parse('SUM(B2:B5, "123"+)', position);
-        } catch (e) {
-            expect(e).to.be.instanceof(FormulaError);
-            expect(e.name).to.eq('#ERROR!');
-            return;
-        }
-        throw Error('Should not reach here.');
+        it('should handle Parser error []' + names[idx], function () {
+            try {
+                parser.parse('SUM([Sales.xlsx]Jan!B2:B5)', position);
+            } catch (e) {
+                expect(e).to.be.instanceof(FormulaError);
+                expect(e.name).to.eq('#ERROR!');
+                return;
+            }
+            throw Error('Should not reach here.');
+        });
+
+        it('should handle Parser error' + names[idx], function () {
+            try {
+                parser.parse('SUM(B2:B5, "123"+)', position);
+            } catch (e) {
+                expect(e).to.be.instanceof(FormulaError);
+                expect(e.name).to.eq('#ERROR!');
+                return;
+            }
+            throw Error('Should not reach here.');
+
+        });
     });
 
     it('should handle error from functions', function () {
@@ -87,6 +101,7 @@ describe('#ERROR! Error handling', () => {
             return;
         }
         throw Error('Should not reach here.');
+
     });
 
     it('should handle errors in async', async function () {
@@ -99,5 +114,12 @@ describe('#ERROR! Error handling', () => {
         }
         throw Error('Should not reach here.');
     });
-});
 
+    it('should not throw error when ignoreError = true (DepParser)', function () {
+        try {
+            depParser.parse('SUM(*()', position, true);
+        } catch (e) {
+            throw Error('Should not reach here.');
+        }
+    });
+});