iotagent-node-lib 3.1.0 → 3.3.0

package/lib/plugins/expressionParser.js

@@ -1,205 +0,0 @@
-/*
- * Copyright 2016 Telefonica Investigación y Desarrollo, S.A.U
- *
- * This file is part of fiware-iotagent-lib
- *
- * fiware-iotagent-lib is free software: you can redistribute it and/or
- * modify it under the terms of the GNU Affero General Public License as
- * published by the Free Software Foundation, either version 3 of the License,
- * or (at your option) any later version.
- *
- * fiware-iotagent-lib is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- * See the GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public
- * License along with fiware-iotagent-lib.
- * If not, see http://www.gnu.org/licenses/.
- *
- * For those usages not covered by the GNU Affero General Public License
- * please contact with::daniel.moranjimenez@telefonica.com
- *
- * Modified by: Daniel Calvo - ATOS Research & Innovation
- */
-
-/* eslint-disable consistent-return */
-
-const Parser = require('jison').Parser;
-const errors = require('../errors');
-const logger = require('logops');
-const fillService = require('../services/common/domain').fillService;
-const _ = require('underscore');
-let logContext = {
-    op: 'IoTAgentNGSI.Expression'
-};
-const grammar = {
-    lex: {
-        rules: [
-            ['\\s+', '/* skip whitespace */'],
-            ['@[a-zA-Z0-9_]+\\b', 'return "VARIABLE";'],
-            ['[0-9]+(?:\\.[0-9]+)?\\b', 'return "NUMBER";'],
-            ['\\*', 'return "*";'],
-            ['\\/', 'return "/";'],
-            ['-', 'return "-";'],
-            ['\\+', 'return "+";'],
-            ['\\^', 'return "^";'],
-            ['\\(', 'return "(";'],
-            ['\\)', 'return ")";'],
-            [',', 'return ",";'],
-            ['#', 'return "#";'],
-            ['indexOf', 'return "INDEX";'],
-            ['length', 'return "LENGTH";'],
-            ['substr', 'return "SUBSTR";'],
-            ['trim', 'return "TRIM";'],
-            ['"[a-zA-Z0-9\\s,]+"', 'return "STRING";'],
-            ["'[a-zA-Z0-9\\s,]+'", 'return "STRING";'],
-            ['$', 'return "EOF";']
-        ]
-    },
-
-    operators: [
-        ['left', '#', '+', '-'],
-        ['left', '*', '/'],
-        ['left', '^'],
-        ['left', 'UMINUS']
-    ],
-
-    bnf: {
-        expressions: [['e EOF', 'return $1;']],
-
-        e: [
-            ['e + e', '$$ = Number($1) + Number($3);'],
-            ['e - e', '$$ = $1 - $3;'],
-            ['e * e', '$$ = $1 * $3;'],
-            ['e / e', '$$ = $1 / $3;'],
-            ['e ^ e', '$$ = Math.pow($1, $3);'],
-            ['e # e', '$$ = String($1) + String($3);'],
-            ['- e', '$$ = -$2;', { prec: 'UMINUS' }],
-            ['INDEX ( e , e )', '$$ = String($3).indexOf($5)'],
-            ['SUBSTR ( e , e , e )', '$$ = String($3).substr($5, $7)'],
-            ['LENGTH ( e )', '$$ = String($3).length'],
-            ['TRIM ( e )', '$$ = String($3).trim()'],
-            ['( e )', '$$ = $2;'],
-            ['NUMBER', '$$ = Number(yytext);'],
-            ['VARIABLE', '$$ = yy[yytext.substr(1)];'],
-            ['STRING', '$$ = yytext.substr(1, yytext.length -2);'],
-            ['E', '$$ = Math.E;'],
-            ['PI', '$$ = Math.PI;']
-        ]
-    }
-};
-const parser = new Parser(grammar);
-
-function parse(expression, context, type, callback) {
-    let result;
-    let error;
-
-    if (type !== 'String' && type !== 'Number') {
-        error = new errors.WrongExpressionType(type);
-        if (callback) {
-            callback(error);
-        } else {
-            throw error;
-        }
-    } else {
-        parser.yy = context;
-
-        try {
-            result = parser.parse(expression);
-            logger.debug(logContext, 'parse expression "[%j]" over "[%j]" result "[%j]" ', expression, context, result);
-        } catch (e) {
-            error = new errors.InvalidExpression(expression);
-
-            if (callback) {
-                return callback(error);
-            } else {
-                throw error;
-            }
-        }
-
-        if (callback) {
-            callback(null, result);
-        } else {
-            return result;
-        }
-    }
-}
-
-function extractContext(attributeList) {
-    const context = {};
-
-    for (let i = 0; i < attributeList.length; i++) {
-        if (attributeList[i].name) {
-            context[attributeList[i].name] = attributeList[i].value;
-        }
-        if (attributeList[i].object_id) {
-            context[attributeList[i].object_id] = attributeList[i].value;
-        }
-    }
-
-    return context;
-}
-
-function processExpression(context) {
-    return function (expression) {
-        const cleanedExpression = expression.substr(2, expression.length - 3);
-        // Note that parse() function allows both String way processing and Number way processing
-        // (have a look to  expression-test.js). However, here we only use one of the possibilities, i.e. String
-        const result = parse(cleanedExpression, context, 'String');
-
-        return {
-            original: expression,
-            value: result
-        };
-    };
-}
-
-/* eslint-disable-next-line no-unused-vars */
-function applyExpression(expression, context, typeInformation) {
-    logContext = fillService(logContext, typeInformation);
-    const expressionList = expression.match(/\$\{.*?\}/g) || [];
-    const substitutions = expressionList.map(processExpression(context));
-    let expressionResult = expression;
-
-    for (let i = 0; i < substitutions.length; i++) {
-        expressionResult = expressionResult.replace(substitutions[i].original, substitutions[i].value);
-    }
-    logger.debug(
-        logContext,
-        'applyExpression "[%j]" over "[%j]" result "[%j]" ',
-        expression,
-        context,
-        expressionResult
-    );
-    return expressionResult;
-}
-
-function contextAvailable(expression, context) {
-    let error;
-    try {
-        const variablesList = expression.match(/@[a-zA-Z0-9_]+/g) || [];
-        const variables = variablesList.map(function (item) {
-            return item.substr(1);
-        });
-        const keys = Object.keys(context);
-        let validContext = _.difference(variables, keys).length === 0;
-        if (!validContext) {
-            logger.info(
-                logContext,
-                'For expression "[%s]" context "[%j]" does not have element to match',
-                expression,
-                context
-            );
-        }
-        return validContext;
-    } catch (e) {
-        error = new errors.InvalidExpression(expression);
-        throw error;
-    }
-}
-
-exports.parse = parse;
-exports.extractContext = extractContext;
-exports.contextAvailable = contextAvailable;
-exports.applyExpression = applyExpression;

package/test/unit/expressions/expression-test.js

@@ -1,197 +0,0 @@
-/*
- * Copyright 2016 Telefonica Investigación y Desarrollo, S.A.U
- *
- * This file is part of fiware-iotagent-lib
- *
- * fiware-iotagent-lib is free software: you can redistribute it and/or
- * modify it under the terms of the GNU Affero General Public License as
- * published by the Free Software Foundation, either version 3 of the License,
- * or (at your option) any later version.
- *
- * fiware-iotagent-lib is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- * See the GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public
- * License along with fiware-iotagent-lib.
- * If not, see http://www.gnu.org/licenses/.
- *
- * For those usages not covered by the GNU Affero General Public License
- * please contact with::[contacto@tid.es]
- */
-
-/* eslint-disable no-unused-vars */
-
-const should = require('should');
-const expressionParser = require('../../../lib/plugins/expressionParser');
-
-describe('Expression interpreter', function () {
-    const scope = {
-        value: 6,
-        other: 3,
-        theString: '12.6,   -19.4',
-        spaces: '5 a b c d 5',
-        big: 2000,
-        number: 145,
-        number2: 155,
-        number3inside: 200
-    };
-
-    describe('When a expression with a single value is parsed', function () {
-        it('should return that value', function (done) {
-            expressionParser.parse('5 * @value', scope, 'Number', function (error, result) {
-                should.not.exist(error);
-                result.should.equal(30);
-                done();
-            });
-        });
-    });
-
-    const arithmetic = [
-        ['5 * @value', 30],
-        ['(6 + @value) * 3', 36],
-        ['@value / 12 + 1', 1.5],
-        ['(5 + 2) * (@value + 7)', 91],
-        ['(5 - @other) * (@value + 7)', 26],
-        ['3 * 5.2', 15.6],
-        ['@value * 5.2', 31.2]
-    ];
-
-    function arithmeticUseCase(arithmeticExpr) {
-        describe('When an expression with the arithmetic operation [' + arithmeticExpr[0] + '] is parsed', function () {
-            it('should be interpreted appropriately', function (done) {
-                expressionParser.parse(arithmeticExpr[0], scope, 'Number', function (error, result) {
-                    should.not.exist(error);
-                    result.should.approximately(arithmeticExpr[1], 0.000001);
-                    done();
-                });
-            });
-        });
-    }
-
-    for (let i = 0; i < arithmetic.length; i++) {
-        arithmeticUseCase(arithmetic[i]);
-    }
-
-    describe('When an expression with two strings is concatenated', function () {
-        it('should return the concatenation of both strings', function (done) {
-            expressionParser.parse('"Pruebas" # "DeStrings"', scope, 'String', function (error, result) {
-                should.not.exist(error);
-                result.should.equal('PruebasDeStrings');
-                done();
-            });
-        });
-    });
-
-    describe('When string transformation functions are executed', function () {
-        it('should return the appropriate piece of the string', function (done) {
-            expressionParser.parse(
-                'trim(substr(@theString, indexOf(@theString, ",") + 1, length(@theString)))',
-                scope,
-                'String',
-                function (error, result) {
-                    should.not.exist(error);
-                    result.should.equal('-19.4');
-                    done();
-                }
-            );
-        });
-    });
-
-    describe('When an expression contains variables with numbers', function () {
-        it('should return the appropriate result', function (done) {
-            expressionParser.parse('@number + @number2 + @number3inside', scope, 'String', function (error, result) {
-                should.not.exist(error);
-                result.should.equal(500);
-                done();
-            });
-        });
-    });
-
-    describe('When an expression contains multiple parenthesis', function () {
-        it('should return the appropriate result', function (done) {
-            expressionParser.parse('((@number) * (@number2))', scope, 'String', function (error, result) {
-                should.not.exist(error);
-                result.should.equal(22475);
-                done();
-            });
-        });
-    });
-
-    describe('When trim() function is executed', function () {
-        it('should return the appropriate piece of the string', function (done) {
-            expressionParser.parse('trim(@spaces)', scope, 'String', function (error, result) {
-                should.not.exist(error);
-                result.should.equal('5 a b c d 5');
-                done();
-            });
-        });
-    });
-
-    describe('When an expression with strings containing spaces is concatenated', function () {
-        it('should honour the whitespaces', function (done) {
-            expressionParser.parse('"Pruebas " # "De Strings"', scope, 'String', function (error, result) {
-                should.not.exist(error);
-                result.should.equal('Pruebas De Strings');
-                done();
-            });
-        });
-    });
-
-    describe('When an expression with strings with single quotation marks is parsed', function () {
-        it('should accept the strings', function (done) {
-            expressionParser.parse(
-                "'Pruebas ' # 'De Strings'",
-
-                scope,
-                'String',
-                function (error, result) {
-                    should.not.exist(error);
-                    result.should.equal('Pruebas De Strings');
-                    done();
-                }
-            );
-        });
-    });
-
-    describe('When a string is concatenated with a number', function () {
-        it('should result in a string concatenation', function (done) {
-            expressionParser.parse('"number " # 5', scope, 'String', function (error, result) {
-                should.not.exist(error);
-                result.should.equal('number 5');
-                done();
-            });
-        });
-    });
-
-    describe('When an expression with a wrong type is parsed', function () {
-        it('should raise a WRONG_EXPRESSION_TYPE error', function (done) {
-            expressionParser.parse('"number " # 5', scope, 'Device', function (error, result) {
-                should.exist(error);
-                error.name.should.equal('WRONG_EXPRESSION_TYPE');
-                done();
-            });
-        });
-    });
-
-    describe('When an expression with a parse error is parsed', function () {
-        it('should raise an INVALID_EXPRESSION error', function (done) {
-            expressionParser.parse('"numb+sd ññ ((', scope, 'Number', function (error, result) {
-                should.exist(error);
-                error.name.should.equal('INVALID_EXPRESSION');
-                done();
-            });
-        });
-    });
-
-    describe('When an string function is used with an expression', function () {
-        it('should work on the expression value', function (done) {
-            expressionParser.parse('indexOf(24 * @big, "80")', scope, 'String', function (error, result) {
-                should.not.exist(error);
-                result.should.equal(1);
-                done();
-            });
-        });
-    });
-});