Merge branch 'release/1.0.18'

package.json

@@ -1,6 +1,6 @@
 {
   "name": "hot-formula-parser",
-  "version": "1.0.17",
+  "version": "1.0.18",
   "description": "Formula parser",
   "main": "dist/formula-parser.js",
   "scripts": {

src/grammar-parser/grammar-parser.jison

@@ -155,17 +155,35 @@ cell
    : ABSOLUTE_CELL {
       $$ = yy.cellValue($1);
     }
+  | RELATIVE_CELL {
+      $$ = yy.cellValue($1);
+    }
+  | MIXED_CELL {
+      $$ = yy.cellValue($1);
+    }
   | ABSOLUTE_CELL ':' ABSOLUTE_CELL {
       $$ = yy.rangeValue($1, $3);
     }
-  | RELATIVE_CELL {
-      $$ = yy.cellValue($1);
+  | ABSOLUTE_CELL ':' RELATIVE_CELL {
+      $$ = yy.rangeValue($1, $3);
+    }
+  | ABSOLUTE_CELL ':' MIXED_CELL {
+      $$ = yy.rangeValue($1, $3);
+    }
+  | RELATIVE_CELL ':' ABSOLUTE_CELL {
+      $$ = yy.rangeValue($1, $3);
     }
   | RELATIVE_CELL ':' RELATIVE_CELL {
       $$ = yy.rangeValue($1, $3);
     }
-  | MIXED_CELL {
-      $$ = yy.cellValue($1);
+  | RELATIVE_CELL ':' MIXED_CELL {
+      $$ = yy.rangeValue($1, $3);
+    }
+  | MIXED_CELL ':' ABSOLUTE_CELL {
+      $$ = yy.rangeValue($1, $3);
+    }
+  | MIXED_CELL ':' RELATIVE_CELL {
+      $$ = yy.rangeValue($1, $3);
     }
   | MIXED_CELL ':' MIXED_CELL {
       $$ = yy.rangeValue($1, $3);

test/integration/parsing/coordinates.js

@@ -0,0 +1,50 @@
+import {Parser} from '../../../src/parser';
+
+describe('.parse() coordinates', () => {
+  let parser;
+
+  beforeEach(() => {
+    parser = new Parser();
+
+    parser.on('callCellValue', function(cell, done) {
+      done(55);
+    });
+    parser.on('callRangeValue', function(startCellCoord, endCellCoord, done) {
+      done([[3, 6, 10]]);
+    });
+  });
+  afterEach(() => {
+    parser = null;
+  });
+
+  it('should parse relative cell', () => {
+    expect(parser.parse('A1')).to.deep.equal({error: null, result: 55});
+  });
+
+  it('should parse absolute cell', () => {
+    expect(parser.parse('$A$1')).to.deep.equal({error: null, result: 55});
+  });
+
+  it('should parse mixed cell', () => {
+    expect(parser.parse('$A1')).to.deep.equal({error: null, result: 55});
+    expect(parser.parse('A$1')).to.deep.equal({error: null, result: 55});
+  });
+
+  it('should parse relative cells range', () => {
+    expect(parser.parse('A1:B2')).to.deep.equal({error: null, result: [[3, 6, 10]]});
+  });
+
+  it('should parse absolute cells range', () => {
+    expect(parser.parse('$A$1:$B$2')).to.deep.equal({error: null, result: [[3, 6, 10]]});
+  });
+
+  it('should parse mixed cells range', () => {
+    expect(parser.parse('$A$1:B2')).to.deep.equal({error: null, result: [[3, 6, 10]]});
+    expect(parser.parse('A1:$B$2')).to.deep.equal({error: null, result: [[3, 6, 10]]});
+    expect(parser.parse('$A$1:B$2')).to.deep.equal({error: null, result: [[3, 6, 10]]});
+    expect(parser.parse('A1:$B2')).to.deep.equal({error: null, result: [[3, 6, 10]]});
+    expect(parser.parse('A$1:B2')).to.deep.equal({error: null, result: [[3, 6, 10]]});
+    expect(parser.parse('A$1:$B$2')).to.deep.equal({error: null, result: [[3, 6, 10]]});
+    expect(parser.parse('A$1:$B2')).to.deep.equal({error: null, result: [[3, 6, 10]]});
+  });
+});

test/integration/parsing/variable.js

@@ -10,13 +10,13 @@ describe('.parse() variable', () => {
     parser = null;
   });
 
-  it('defaults', () => {
+  it('should evaluate defaults variables', () => {
     expect(parser.parse('TRUE')).to.deep.equal({error: null, result: true});
     expect(parser.parse('FALSE')).to.deep.equal({error: null, result: false});
     expect(parser.parse('NULL')).to.deep.equal({error: null, result: null});
   });
 
-  it('custom', () => {
+  it('should evaluate custom variables', () => {
     expect(parser.parse('foo')).to.deep.equal({error: '#NAME?', result: null});
 
     parser.setVariable('foo', 'bar');

test/unit/parser.js

@@ -331,4 +331,42 @@ describe('Parser', () => {
       sinon.assert.calledWithMatch(obj.cb, startCell, endCell);
     });
   });
+
+  describe('._throwError()', () => {
+    it('should throw general error', () => {
+      expect(() => parser._throwError('#ERROR!')).to.throw('ERROR');
+    });
+
+    it('should throw dividing by 0 error', () => {
+      expect(() => parser._throwError('#DIV/0!')).to.throw('DIV/0');
+    });
+
+    it('should throw name error', () => {
+      expect(() => parser._throwError('#NAME?')).to.throw('NAME');
+    });
+
+    it('should throw not available error', () => {
+      expect(() => parser._throwError('#N/A')).to.throw('N/A');
+    });
+
+    it('should throw null error', () => {
+      expect(() => parser._throwError('#NULL!')).to.throw('NULL');
+    });
+
+    it('should throw num error', () => {
+      expect(() => parser._throwError('#NUM!')).to.throw('NUM');
+    });
+
+    it('should throw ref error', () => {
+      expect(() => parser._throwError('#REF!')).to.throw('REF');
+    });
+
+    it('should throw value error', () => {
+      expect(() => parser._throwError('#VALUE!')).to.throw('VALUE');
+    });
+
+    it('should return value if not matched to any of defined error', () => {
+      expect(parser._throwError('VALUE foo')).to.be.eq('VALUE foo');
+    });
+  });
 });