implemented chaining of computed results (#11)

* implemented chaining of computed results
* fixed empty string as computed param

Author: AlexGalichenko

CHANGELOG.MD

@@ -4,6 +4,10 @@ All notable changes to the "@qavajs/memory" will be documented in this file.
 
 Check [Keep a Changelog](http://keepachangelog.com/) for recommendations on how to structure this file.
 
+## [1.3.0]
+- :rocket: implemented chaining of computed results
+- :beetle: fixed empty string as computed param
+
 ## [1.2.1]
 - :beetle: fixed context for methods calling
 

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@qavajs/memory",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "description": "memory package for @qavajs framework",
   "main": "index.js",
   "scripts": {

package.json

@@ -1,8 +1,9 @@
 const KEY_REGEXP = /^\$(.+?)(\((.*)\))?$/;
+const PARAMS_REGEXP = /^(.+?)(\((.*)\))?$/;
 const ESCAPED_REGEXP = /^\\\$/;
 const PARSE_STRING_REGEXP = /({\$.+?})/g;
 const QUOTES_REPLACE_REGEXP = /^['"]|['"]$/g;
-const STRING_TYPE_REGEXP = /^'.+'|".+"$/;
+const STRING_TYPE_REGEXP = /^'.*'|".*"$/;
 const NUMBER_TYPE_REGEXP = /^\d+|\d+\.\d+$/;
 
 class Memory {
@@ -37,29 +38,20 @@ class Memory {
      * @returns {any} - resolved value
      */
     getKey(str) {
-        const keyMatch = str.match(KEY_REGEXP);
-        const key = keyMatch ? keyMatch[1] : null;
-        if (key) {
-            const { value, ctx } = this.getProperty(key);
-            if (typeof value === 'function' && str.includes('(') && str.includes(')')) {
-                const params = this.getComputedParams(str);
-                return value.apply(ctx, params)
+        const props = this.parseChain(str);
+        props[0] = props[0].replace(/^\$/, '');
+        const traverse = props.reduce((prev, prop) => {
+            const ctx = prev.value;
+            const key = prop.replace(/\((.*)\)/, '');
+            let value = ctx[key];
+            if (value === undefined) throw new Error(`${str}\n'${key}' is not defined`);
+            if (typeof value === 'function' && prop.includes('(') && prop.includes(')')) {
+                const params = this.getComputedParams(prop);
+                value = value.apply(ctx, params)
             }
-            return value
-        }
-    }
-
-    /**
-     * Resolve object
-     * @private
-     * @param {string} key - key to resolve
-     * @returns {any} - resolved value
-     */
-    getProperty(key) {
-        const props = key.replace(/]/g, '').split(/[[.]/).map(prop => prop.replace(QUOTES_REPLACE_REGEXP, ''));
-        const obj = this[props.shift()];
-        if (obj === undefined) throw new Error(`${key} is not found in memory`);
-        return props.reduce((prev, prop) => ({value: prev.value[prop], ctx: prev.value}), {value: obj, ctx: null})
+            return {value, ctx}
+        }, {value: this, ctx: null});
+        return traverse.value
     }
 
     /**
@@ -80,7 +72,7 @@ class Memory {
      * @returns {Array<any>} - array of params
      */
     getComputedParams(str) {
-        const paramsString = str.match(KEY_REGEXP);
+        const paramsString = str.match(PARAMS_REGEXP);
         if (!(paramsString && paramsString[3])) return []
         const params = [];
         let singleQuoteClosed = true;
@@ -113,6 +105,44 @@ class Memory {
             this[prop] = obj[prop];
         }
     }
+
+    parseChain(chain) {
+        const tokens = [];
+        let currentToken = '';
+        let insideSquareBracket = false;
+        let insideParenthesis = false;
+
+        for (let i = 0; i < chain.length; i++) {
+            const char = chain.charAt(i);
+
+            if (char === '.' && !insideSquareBracket && !insideParenthesis) {
+                tokens.push(currentToken);
+                currentToken = '';
+            } else if (char === '[') {
+                insideSquareBracket = true;
+                tokens.push(currentToken);
+                currentToken = '';
+            } else if (char === ']' && insideSquareBracket) {
+                insideSquareBracket = false;
+                tokens.push(currentToken);
+                currentToken = '';
+            } else {
+                if (char === '(') {
+                    insideParenthesis = true;
+                } else if (char === ')') {
+                    insideParenthesis = false
+                }
+                currentToken += char;
+            }
+        }
+
+        if (currentToken !== '') {
+            tokens.push(currentToken);
+        }
+
+        return tokens.filter(token => token).map(token => token.replace(QUOTES_REPLACE_REGEXP, ''));
+    }
+
 }
 
 module.exports = new Memory();

src/Memory.js

@@ -52,7 +52,7 @@ test('simple string returns as is', () => {
 });
 
 test('throw error if key is not present in memory', () => {
-	expect(() => memory.getValue('$val')).to.throw('val is not found in memory');
+	expect(() => memory.getValue('$val')).to.throw('$val\n\'val\' is not defined');
 });
 
 test('memory is singleton', () => {
@@ -81,7 +81,7 @@ test('query string with two existing variables', () => {
 test('throws for query string with one existing and one non-existent variables', () => {
 	memory.ind1 = 3;
 	const queryString = 'Component > #{$ind1} of Collection1 > #{$notExists} of Collection2'
-	expect(() => memory.getValue(queryString)).to.throw('notExists is not found in memory');
+	expect(() => memory.getValue(queryString)).to.throw('$notExists\n\'notExists\' is not defined');
 });
 
 test('property from object in dot notation', () => {
@@ -202,3 +202,43 @@ test('save context for methods', () => {
 	})
 	expect(memory.getValue('$obj.getProp()')).to.equal(42);
 });
+
+test('chaining method calls', () => {
+	memory.setValue('obj', {
+		method1() {
+			return {
+				method2() {
+					return 'Im method'
+				},
+				prop: 42
+			}
+		}
+	})
+	expect(memory.getValue('$obj.method1().method2()')).to.equal('Im method');
+	expect(memory.getValue('$obj.method1().prop')).to.equal(42);
+});
+
+test('inner computed call', () => {
+	memory.setValue('comp1', function (val) { return val });
+	expect(memory.getValue('$comp1($comp1(42))')).to.equal(42);
+});
+
+test('inner method call', () => {
+	memory.setValue('obj1', {
+		method1(val) {
+			return val
+		}
+	})
+	memory.setValue('obj2', {
+		method1(val) {
+			return val
+		}
+	})
+	expect(memory.getValue('$obj1.method1($obj2.method1(42))')).to.equal(42);
+});
+
+test('empty string', () => {
+	memory.setValue('fn', function (val) { return val })
+	expect(memory.getValue('$fn("")')).to.equal('');
+	expect(memory.getValue("$fn('')")).to.equal('');
+});