Finalized tests

Author: MitMaro

src/Parser.js

@@ -289,8 +289,10 @@ class Parser {
 			}
 			token = this.getExpectedToken(TOKEN_TYPE_BINARY_OPERATOR);
 			const precedenceInfo = PrecedenceTable[token.subType];
-			const nextPrecedence = precedenceInfo.association === LEFT_ASSOCIATIVE
-				? precedenceInfo.precedence + 1 : precedenceInfo.precedence;
+			const nextPrecedence = precedenceInfo.precedence + 1;
+			// there currently is no right associative binary operator 
+			// const nextPrecedence = precedenceInfo.association === LEFT_ASSOCIATIVE
+			//	? precedenceInfo.precedence + 1 : precedenceInfo.precedence;
 
 			tree = {
 				type: PARSER_TYPE_BINARY_OPERATOR,
@@ -306,6 +308,8 @@ class Parser {
 		const token = this.lookahead(1, [
 			TOKEN_TYPE_UNARY_OPERATOR,
 			TOKEN_BOUNDARY_BRACKET_OPEN,
+			TOKEN_BOUNDARY_STRING_DOUBLE,
+			TOKEN_BOUNDARY_STRING_SINGLE,
 			TOKEN_TYPE_VALUE
 		]);
 
@@ -336,25 +340,29 @@ class Parser {
 	}
 
 	generateValue() {
-		const token = this.getExpectedToken(TOKEN_TYPE_VALUE);
+		const token = this.getExpectedToken([
+			TOKEN_TYPE_VALUE, TOKEN_BOUNDARY_STRING_SINGLE, TOKEN_BOUNDARY_STRING_DOUBLE
+		]);
 		if (token.subType === TOKEN_VALUE_VARIABLE) {
 			return {
 				type: PARSER_TYPE_VARIABLE,
 				name: token.value
 			};
 		}
-
+		
 		let value;
+		if (token.subType === TOKEN_BOUNDARY_STRING_SINGLE || token.subType === TOKEN_BOUNDARY_STRING_DOUBLE) {
+			value = this.getExpectedToken(TOKEN_VALUE_STRING).value;
+			this.getExpectedToken(token.subType);
+		}
+		
 		if (token.subType === TOKEN_VALUE_FLOAT) {
 			value = parseFloat(token.value);
 		}
 		else if (token.subType === TOKEN_VALUE_INTEGER) {
 			value = parseInt(token.value, 10);
 		}
-		else if (token.subType === TOKEN_VALUE_STRING) {
-			value = token.value;
-		}
-
+		
 		return {
 			type: PARSER_TYPE_VALUE,
 			value

test/Parser/Parser.generate.spec.js

@@ -5,7 +5,6 @@ const Parser = require('../../src/Parser');
 const Lexer = require('../../src/Lexer');
 const nb = require('../nodeBuilder');
 
-
 function getParserResult(input) {
 	const inputString = Array.isArray(input) ? input.join('\n') : input;
 	const parser = new Parser(new Lexer(inputString));

test/Parser/Parser.generateExpression.spec.js

@@ -6,20 +6,12 @@ const Lexer = require('../../src/Lexer');
 const nb = require('../nodeBuilder');
 
 const {
-	OPERATOR_EQUALS,
-	OPERATOR_NOT_EQUALS,
-	OPERATOR_STRICT_EQUALS,
-	OPERATOR_STRICT_NOT_EQUALS,
 	OPERATOR_AND,
 	OPERATOR_OR,
-	OPERATOR_NOT,
 	OPERATOR_GREATER_THAN,
-	OPERATOR_LESS_THAN,
-	OPERATOR_GREATER_EQUAL_THAN,
-	OPERATOR_LESS_EQUAL_THAN,
 } = require('../../src/constants');
 
-describe.only('Parser.generateExpression', function() {
+describe('Parser.generateExpression', function() {
 	[
 		{
 			description: 'with base binary operator',
@@ -31,13 +23,99 @@ describe.only('Parser.generateExpression', function() {
 			)
 		},
 		{
-			description: 'with nested expression operator',
+			description: 'with expression chain',
 			input: 'a > b > c',
+			expected: nb.binaryExpression(
+					nb.binaryExpression(
+						nb.variable('a'),
+						nb.variable('b'),
+						OPERATOR_GREATER_THAN
+					),
+					nb.variable('c'),
+					OPERATOR_GREATER_THAN
+			)
+		},
+		{
+			description: 'with brackets on the right',
+			input: 'a > (b > c)',
 			expected: nb.binaryExpression(
 					nb.variable('a'),
-					nb.variable('b'),
+					nb.binaryExpression(
+							nb.variable('b'),
+							nb.variable('c'),
+							OPERATOR_GREATER_THAN
+					),
+					OPERATOR_GREATER_THAN
+			)
+		},
+		{
+			description: 'with brackets on the left',
+			input: '(a > b) > c',
+			expected: nb.binaryExpression(
+					nb.binaryExpression(
+							nb.variable('a'),
+							nb.variable('b'),
+							OPERATOR_GREATER_THAN
+					),
+					nb.variable('c'),
 					OPERATOR_GREATER_THAN
 			)
+		},
+		{
+			description: 'with ors and ands',
+			input: 'a || b && c',
+			expected: nb.binaryExpression(
+					nb.variable('a'),
+					nb.binaryExpression(
+							nb.variable('b'),
+							nb.variable('c'),
+							OPERATOR_AND
+					),
+					OPERATOR_OR
+			)
+		},
+		{
+			description: 'with a not on the left',
+			input: '!a || b',
+			expected: nb.binaryExpression(
+					nb.notConditional(nb.variable('a')),
+					nb.variable('b'),
+					OPERATOR_OR
+			)
+		},
+		{
+			description: 'with a not on the right',
+			input: 'a || !b',
+			expected: nb.binaryExpression(
+					nb.variable('a'),
+					nb.notConditional(nb.variable('b')),
+					OPERATOR_OR
+			)
+		},
+		{
+			description: 'with a variable',
+			input: 'a',
+			expected: nb.variable('a')
+		},
+		{
+			description: 'with a integer value',
+			input: '123',
+			expected: nb.value(123)
+		},
+		{
+			description: 'with a float value',
+			input: '123.34',
+			expected: nb.value(123.34)
+		},
+		{
+			description: 'with a single quote string',
+			input: '\'foo\'',
+			expected: nb.value('foo')
+		},
+		{
+			description: 'with a double quote string',
+			input: '"foo"',
+			expected: nb.value('foo')
 		}
 	].forEach((testCase) => {
 		it(`should parse ${testCase.description}`, function() {

test/nodeBuilder.js

@@ -63,7 +63,7 @@ module.exports = {
 		};
 	},
 	andConditional(left, right) {
-		module.exports.binaryExpression(left, right, OPERATOR_AND);
+		return module.exports.binaryExpression(left, right, OPERATOR_AND);
 	},
 	notConditional(expression) {
 		return {