✨ Make sure Placeholders are recursively resolved + add tests

lib/placeholder.js

@@ -75,7 +75,20 @@ const _resolvePlaceholders = (input, seen, args) => {
 	}
 
 	if (input instanceof Placeholder) {
-		return input.getResolvedValue(...args);
+
+		// Get the resolved value of the input
+		let result = input.getResolvedValue(...args);
+
+		// Remember this resolved value, to prevent infinite loops
+		seen.set(input, result);
+
+		// Also parse the returned result, it might also contain placeholders
+		result = _resolvePlaceholders(result, seen, args);
+
+		// Set this as the new seen value
+		seen.set(input, result);
+
+		return result;
 	}
 
 	let result,
@@ -99,7 +112,7 @@ const _resolvePlaceholders = (input, seen, args) => {
 			let key;
 
 			for (key in input) {
-				if (!Object.hasOwnProperty.call(obj, key)) {
+				if (!Object.hasOwnProperty.call(input, key)) {
 					continue;
 				}
 

test/placeholder.js

@@ -0,0 +1,87 @@
+let assert = require('assert'),
+    Blast,
+    Trail,
+    Placeholder;
+
+describe('Placeholder', function() {
+	Blast  = require('../index.js')();
+	Trail = Blast.Classes.Develry.Trail;
+	Placeholder = Blast.Classes.Develry.Placeholder;
+
+	describe('.deepResolve(input, ...args)', () => {
+		it('should recursively resolve all placeholders in objects', () => {
+
+			let pledge = new Pledge(),
+			    trail = Trail.fromArrow('my->nested->path');
+
+			pledge.resolve('PLEDGED!');
+
+			let context = {
+				my: {
+					nested: {
+						path: 1,
+					}
+				}
+			};
+
+			let data = {
+				pledge: pledge,
+				trail : trail,
+				deep  : {
+					arr: [pledge, trail]
+				}
+			};
+
+			let resolved = Placeholder.deepResolve(data, context);
+
+			assert.deepStrictEqual(resolved, {
+				pledge: 'PLEDGED!',
+				trail : 1,
+				deep  : {
+					arr : ['PLEDGED!', 1]
+				}
+			});
+		});
+
+		it('should also resolve values in resolved values', () => {
+
+			let pledge = new Pledge(),
+			    trail = Trail.fromArrow('my->nested->path');
+
+			pledge.resolve('PLEDGED!');
+
+			let somewhere_else = new Pledge();
+			somewhere_else.resolve('ELSE!');
+
+			let context = {
+				my: {
+					nested: {
+						path: Trail.fromArrow('somewhere->else'),
+					}
+				},
+				somewhere: {
+					else: somewhere_else,
+				}
+			};
+
+			let data = {
+				pledge: pledge,
+				trail : trail,
+				deep  : {
+					arr: [pledge, trail]
+				}
+			};
+
+			let resolved = Placeholder.deepResolve(data, context);
+
+			assert.deepStrictEqual(resolved, {
+				pledge: 'PLEDGED!',
+				trail : 'ELSE!',
+				deep  : {
+					arr : ['PLEDGED!', 'ELSE!']
+				}
+			});
+		});
+	});
+
+});

test/trail.js

@@ -0,0 +1,33 @@
+let assert = require('assert'),
+    Blast,
+    Trail;
+
+describe('Trail', function() {
+	Blast  = require('../index.js')();
+	Trail = Blast.Classes.Develry.Trail;
+
+	describe('.fromDot(path)', () => {
+		it('should create a new trail', () => {
+			let trail = Trail.fromDot('this.is.a.path');
+		});
+	});
+
+	describe('#getResolvedValue(context)', () => {
+		it('should extract the path from the given context', () => {
+
+			let trail = Trail.fromDot('my.nested.path');
+			let obj = {
+				my: {
+					nested: {
+						path: 1,
+					}
+				}
+			};
+
+			let value = trail.getResolvedValue(obj);
+
+			assert.strictEqual(value, 1);
+		});
+	});
+
+});