Define spec/tests for rules.js (Rule and Sym classes)

lib/parser.js

@@ -215,8 +215,8 @@ function dfsHelper(states, root, state, depth, tokens) {
 //let sentence = '( ( 12 ) )';
 //let sentence = '1 * 2 + 3 * 4 + 5';
 //let sentence = '1 + 2 + 3';
-let sentence = '1^3 + 2 * 3(3)';
-let tree = parse(sentence, rules.rules);
+//let sentence = '1^3 + 2 * 3(3)';
+//let tree = parse(sentence, rules.rules);
 
 //console.log(JSON.stringify(tree, null, 2));
 

lib/rules.js

@@ -10,7 +10,7 @@ function Rule(lhs, rhs, valuator) {
 
  Object.defineProperty(arr, 'lhs', { value: lhs });
  Object.defineProperty(arr, 'evaluate', {
- value: (values) => valuator.apply(null, values)
+ value: (values) => (valuator) ? valuator.apply(null, values) : null
  });
 
  arr.__proto__ = Rule.prototype;

package.json

@@ -28,6 +28,7 @@
  "homepage": "https://github.com/patgrasso/parsey#readme",
  "devDependencies": {
  "coveralls": "^2.11.12",
+ "eslint": "^3.2.2",
  "istanbul": "^0.4.4",
  "jasmine": "^2.4.1"
  }

spec/parser-spec.js

@@ -0,0 +1,2 @@
+/*global describe, it, expect, beforeAll*/
+

spec/rules-spec.js

@@ -0,0 +1,89 @@
+/*global describe, it, expect, beforeAll*/
+
+const Sym = require('../lib/rules').Sym;
+const Rule = require('../lib/rules').Rule;
+
+var sum, prod, r, f;
+
+describe('Sym', () => {
+
+ describe('constructor()', () => {
+
+ it('takes a name parameter and assigns it to `name`', () => {
+ sum = new Sym('sum');
+ expect(sum.name).toBe('sum');
+ });
+
+ });
+
+});
+
+describe('Rule', () => {
+
+ beforeAll(() => {
+ sum = new Sym('sum');
+ prod = new Sym('prod');
+ });
+
+ describe('constructor()', () => {
+
+ it('extends Array', () => {
+ r = new Rule(sum, ['+']);
+ expect(r instanceof Array).toBe(true);
+ });
+
+ it('takes a LHS parameter and assigns it to `lhs`', () => {
+ r = new Rule(sum, ['+']);
+ expect(r.lhs).toBe(sum);
+ });
+
+ it('throws if no RHS is given', () => {
+ f = () => r = new Rule(sum);
+ expect(f).toThrowError();
+ });
+
+ it('throws if an empty RHS is given', () => {
+ f = () => r = new Rule(sum, []);
+ expect(f).toThrowError();
+ });
+
+ it('accepts a valuator function as third optional param', () => {
+ r = new Rule(sum, [sum, '+', prod], (x, _, y) => x + y);
+ expect(r.evaluate instanceof Function).toBe(true);
+ });
+
+ });
+
+ describe('evaluate()', () => {
+
+ it('evaluates an array of values using the given function', () => {
+ r = new Rule(sum, [sum, '+', prod], (x, _, y) => x + y);
+ expect(r.evaluate([1, '+', 2])).toBe(3);
+ });
+
+ it('fails if the first argument is not an array', () => {
+ f = () => new Rule(sum, [sum, '+', prod], (x, _, y) => x + y).evaluate(1);
+ expect(f).toThrowError();
+ });
+
+ });
+
+ it('\'s RHS is accessible via array indices', () => {
+ r = new Rule(sum, ['+']);
+ expect(r[0]).toBe('+');
+ });
+
+ it('\'s `lhs` property is non-enumerable', () => {
+ r = new Rule(sum, ['+']);
+ expect(Object.propertyIsEnumerable(r, 'lhs')).toBe(false);
+ });
+
+ it('\'s `rhs` can be iterated with forEach', () => {
+ let items = [sum, '+', prod];
+ r = new Rule(sum, items);
+ let filteredRhs = r.filter((item, index) => item === items[index]);
+ expect(filteredRhs.length).toBe(3);
+ });
+
+});
+