added feature to resolve objects and arrays (#3)

* added feature to resolve objects and arrays

* update version

Co-authored-by: Oleksandr_Halichenko <[email protected]>

Author: AlexGalichenko

package.json

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

src/Memory.js

@@ -7,34 +7,77 @@ const NUMBER_TYPE_REGEXP = /^\d+|\d+\.\d+$/;
 
 class Memory {
 
+    /**
+     * Get value from memory
+     * @param {string} str - string to resolve
+     * @returns {any} - resolved value
+     * @example const value = memory.getValue('$val');
+     */
     getValue(str) {
         if (KEY_REGEXP.test(str)) return this.getKey(str)
         if (PARSE_STRING_REGEXP.test(str)) return this.getString(str)
         return str
     }
 
+    /**
+     * Set value in memory
+     * @param {string} key - key to store
+     * @param {any} value - value to store
+     * @example memory.setValue('value', 42);
+     */
     setValue(key, value) {
         this[key] = value;
     }
 
+    /**
+     * Get key from memory
+     * @private
+     * @param {string} str - key to resolve
+     * @returns {any} - resolved value
+     */
     getKey(str) {
         const keyMatch = str.match(KEY_REGEXP);
         const key = keyMatch ? keyMatch[1] : null;
         if (key) {
-            if (!(key in this)) throw new Error(`${key} is not found in memory`);
-            if (typeof this[key] === 'function') {
+            const value = this.getProperty(key);
+            if (typeof value === 'function') {
                 const params = this.getComputedParams(str);
-                return this[key].apply(null, params)
+                return value.apply(null, params)
             }
-            return this[key]
+            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((value, prop) => value[prop], obj)
+    }
+
+    /**
+     * Resolve string with interpolation
+     * @private
+     * @param {string} str - string to resolve
+     * @returns {string} - resolved string
+     */
     getString(str) {
         const matches = str.match(PARSE_STRING_REGEXP).map(match => match.replace(/{|}/g, ``));
         return matches.reduce((string, variable) => string.replace(`{${variable}}`, this.getKey(variable)), str);
     }
 
+    /**
+     * Extract arguments for computed function
+     * @private
+     * @param {string} str - string with params
+     * @returns {Array<string>} - array of params
+     */
     getComputedParams(str) {
         const paramsString = str.match(KEY_REGEXP);
         if (!(paramsString && paramsString[3])) return []
@@ -46,6 +89,10 @@ class Memory {
         })
     }
 
+    /**
+     * Register memory object
+     * @param obj - object to register
+     */
     register(obj) {
         for (const prop in obj) {
             this[prop] = obj[prop];

tests/memory.spec.js

@@ -82,4 +82,72 @@ 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');
-});
+});
+
+test('property from object in dot notation', () => {
+	memory.register({
+		someValue: {
+			prop: 42
+		}
+	});
+
+	expect(memory.getValue('$someValue.prop')).to.equal(42);
+});
+
+test('property from object in bracket notation', () => {
+	memory.register({
+		someValue: {
+			prop: 42
+		}
+	});
+
+	expect(memory.getValue('$someValue[\'prop\']')).to.equal(42);
+	expect(memory.getValue('$someValue["prop"]')).to.equal(42);
+});
+
+test('element from array', () => {
+	memory.register({
+		someValue: [1,2,3]
+	});
+
+	expect(memory.getValue('$someValue[2]')).to.equal(3);
+});
+
+test('property is function (number argument)', () => {
+	memory.register({
+		someValue: {
+			fn: function (val) { return val }
+		}
+	});
+
+	expect(memory.getValue('$someValue.fn(42)')).to.equal(42);
+});
+
+test('property is function (string argument)', () => {
+	memory.register({
+		someValue: {
+			fn: function (val) { return val }
+		}
+	});
+
+	expect(memory.getValue('$someValue.fn("42")')).to.equal('42');
+});
+
+test('property two level', () => {
+	memory.register({
+		someValue: {
+			arr: [
+				{ prop: 42 }
+			]
+		}
+	});
+
+	expect(memory.getValue('$someValue.arr[0].prop')).to.equal(42);
+});
+
+test('property from added object', () => {
+	const obj = { prop: 42 };
+	memory.setValue('obj', obj);
+
+	expect(memory.getValue('$obj.prop')).to.equal(42);
+});