feature: interpolate bracket access, close #14

package.json

@@ -1,6 +1,6 @@
 {
   "name": "shopify-liquid",
-  "version": "1.2.5",
+  "version": "1.3.0",
   "description": "Liquid template engine for JavaScript, Node.js and Browser",
   "main": "index.js",
   "scripts": {

src/lexical.js

@@ -34,6 +34,7 @@ var numberLine = new RegExp(`^${number.source}$`);
 var boolLine = new RegExp(`^${bool.source}$`, 'i');
 var quotedLine = new RegExp(`^${quoted.source}$`);
 var rangeLine = new RegExp(`^${rangeCapture.source}$`);
+var integerLine = new RegExp(`^${integer.source}$`);
 
 // filter related
 var valueList = new RegExp(`${value.source}(\\s*,\\s*${value.source})*`);
@@ -47,6 +48,10 @@ var operators = [
     /==|!=|<=|>=|<|>|\s+contains\s+/
 ];
 
+function isInteger(str){
+    return integerLine.test(str);
+}
+
 function isLiteral(str) {
     return literalLine.test(str);
 }
@@ -82,5 +87,5 @@ module.exports = {
     range, rangeCapture, 
     identifier, value, quoteBalanced, operators,
     quotedLine, numberLine, boolLine, rangeLine, literalLine, filterLine, tagLine,
-    isLiteral, isVariable, parseLiteral, isRange, matchValue
+    isLiteral, isVariable, parseLiteral, isRange, matchValue, isInteger
 };

src/scope.js

@@ -1,4 +1,5 @@
 const _ = require('./util/underscore.js');
+const lexical = require('./lexical.js');
 
 var Scope = {
 	safeGet: function(str) {
@@ -18,7 +19,7 @@ var Scope = {
 		}
 		// get one path
 		for (i = this.scopes.length - 1; i >= 0; i--) {
-            var v = getPropertyByPath(this.scopes[i], str);
+			var v = this.getPropertyByPath(this.scopes[i], str);
 			if (v !== undefined) return v;
 		}
 	},
@@ -30,7 +31,7 @@ var Scope = {
 		return val;
 	},
 	set: function(k, v) {
-        setPropertyByPath(this.scopes[this.scopes.length - 1], k, v);
+		this.setPropertyByPath(this.scopes[this.scopes.length - 1], k, v);
 		return this;
 	},
 	push: function(ctx) {
@@ -39,10 +40,9 @@ var Scope = {
 	},
 	pop: function() {
 		return this.scopes.pop();
-    }
+	},
-};
 
-function setPropertyByPath(obj, path, val) {
+	setPropertyByPath: function(obj, path, val) {
 		if (_.isString(path)) {
 			var paths = path.replace(/\[/g, '.').replace(/\]/g, '').split('.');
 			for (var i = 0; i < paths.length; i++) {
@@ -57,15 +57,93 @@ function setPropertyByPath(obj, path, val) {
 			return obj;
 		}
 		return obj[path] = val;
-}
+	},
 
-function getPropertyByPath(obj, path) {
+	getPropertyByPath: function(obj, path) {
-    if (_.isString(path)) {
+		if (_.isString(path) && path.length) {
-        var paths = path.replace(/\[/g, '.').replace(/\]/g, '').split('.');
+			var paths = this.propertyAccessSeq(path);
 			paths.forEach(p => obj = obj && obj[p]);
 			return obj;
 		}
 		return obj[path];
+	},
+
+	/*
+	 * Parse property access sequence from access string
+	 * @example
+	 * accessSeq("foo.bar")			// ['foo', 'bar']
+	 * accessSeq("foo['bar']")  	// ['foo', 'bar']
+	 * accessSeq("foo['b]r']")  	// ['foo', 'b]r']
+	 * accessSeq("foo[bar.coo]")    // ['foo', 'bar'], for bar.coo == 'bar'
+	 */
+	propertyAccessSeq: function(str) {
+		var seq = [],
+			name = '';
+		for (var i = 0; i < str.length; i++) {
+			if (str[i] === '[') {
+				seq.push(name);
+				name = '';
+
+				var delemiter = str[i + 1];
+				// foo[bar.coo]
+				if (delemiter !== "'" && delemiter !== '"') {
+					var j = matchRightBracket(str, i + 1);
+					if (j === -1) {
+						throw new Error(`unbalanced []: ${str}`);
+					}
+					name = str.slice(i + 1, j);
+					// foo[1]
+					if(lexical.isInteger(name)){
+						seq.push(name);
+					}
+					// foo["bar"]
+					else{
+						seq.push(this.get(name));
+					}
+					name = '';
+					i = j;
+				}
+				// foo["bar"]
+				else {
+					var j = str.indexOf(delemiter, i + 2);
+					if (j === -1) {
+						throw new Error(`unbalanced ${delemiter}: ${str}`);
+					}
+					name = str.slice(i + 2, j);
+					seq.push(name);
+					name = '';
+					i = j + 1;
+				}
+			}
+			// foo.bar
+			else if (str[i] === ".") {
+				seq.push(name);
+				name = '';
+			}
+			//foo.bar
+			else {
+				name += str[i];
+			}
+		}
+		if (name.length) seq.push(name);
+		return seq;
+	}
+};
+
+function matchRightBracket(str, begin) {
+	var stack = 1; // count of '[' - count of ']'
+	for (var i = begin; i < str.length; i++) {
+		if (str[i] === '[') {
+			stack++;
+		}
+		if (str[i] === ']') {
+			stack--;
+			if (stack === 0) {
+				return i;
+			}
+		}
+	}
+	return -1;
 }
 
 exports.factory = function(_ctx, opts) {

tags/layout.js

@@ -40,7 +40,7 @@ module.exports = function(liquid) {
     liquid.registerTag('block', {
         parse: function(token, remainTokens){
             var match = /\w+/.exec(token.args);
-            this.block = match ? match[0] : '';
+            this.block = match ? match[0] : 'anonymous';
 
             this.tpls = [];
             var p, stream = liquid.parser.parseStream(remainTokens)

test/scope.js

@@ -7,13 +7,40 @@ describe('scope', function() {
 	var scope, ctx;
 	beforeEach(function() {
 		ctx = {
-            foo: 'bar'
+			foo: 'zoo',
+			bar: {
+				zoo: 'coo',
+				"Mr.Smith": 'John',
+				arr: ['a', 'b']
+			}
 		};
 		scope = Scope.factory(ctx);
 	});
 
+	describe('#propertyAccessSeq()', function() {
+		it('should handle dot syntax', function() {
+			expect(scope.propertyAccessSeq('foo.bar'))
+				.to.deep.equal(['foo', 'bar']);
+		});
+		it('should handle [<String>] syntax', function() {
+			expect(scope.propertyAccessSeq('foo["bar"]'))
+				.to.deep.equal(['foo', 'bar']);
+		});
+		it('should handle [<Identifier>] syntax', function() {
+			expect(scope.propertyAccessSeq('foo[foo]'))
+				.to.deep.equal(['foo', 'zoo']);
+		});
+		it('should handle nested access', function() {
+			expect(scope.propertyAccessSeq('foo[bar.zoo]'))
+				.to.deep.equal(['foo', 'coo']);
+			expect(scope.propertyAccessSeq('foo[bar["zoo"]]'))
+				.to.deep.equal(['foo', 'coo']);
+		});
+	});
+
+	describe('#get()', function() {
 		it('should get direct property', function() {
-        expect(scope.get('foo')).equal('bar');
+			expect(scope.get('foo')).equal('zoo');
 		});
 
 		it('should get undefined property', function() {
@@ -42,17 +69,34 @@ describe('scope', function() {
 		});
 
 		it('should access child property via dot syntax', function() {
-        scope.set('oo.bar', 'FOO');
+			expect(scope.get('bar.zoo')).to.equal('coo');
-        expect(scope.get('oo.bar')).to.equal('FOO');
+			expect(scope.get('bar.arr')).to.deep.equal(['a', 'b']);
+		});
+
+		it('should access child property via [<String>] syntax', function() {
+			expect(scope.get('bar["zoo"]')).to.equal('coo');
 		});
 
 		it('should access child property via [<Number>] syntax', function() {
-        scope.set('bar', ['a', {'b': [1,2]}]);
+			expect(scope.get('bar.arr[0]')).to.equal('a');
-        expect(scope.get('bar[0]')).to.equal('a');
-        expect(scope.get('bar[1].b')).to.deep.equal([1, 2]);
-        expect(scope.get('bar[1].b[1]')).to.equal(2);
 		});
 
+		it('should access child property via [<Identifier>] syntax', function() {
+			expect(scope.get('bar[foo]')).to.equal('coo');
+		});
+
+		it('should support nested case', function() {
+			scope.set('posts', {
+				"first": {"name": "A Nice Day"}
+			});
+			scope.set('category', {
+				"diary": ["first"]
+			});
+			expect(scope.get('posts[category.diary[0]].name'), 'A Nice Day');
+		});
+	});
+
+	describe('.push(), .pop()', function() {
 		it('should push scope', function() {
 			scope.set('bar', 'bar');
 			scope.push({
@@ -67,6 +111,7 @@ describe('scope', function() {
 				foo: 'foo'
 			});
 			scope.pop();
-        expect(scope.get('foo')).to.equal('bar');
+			expect(scope.get('foo')).to.equal('zoo');
+		});
 	});
 });

test/syntax.js

@@ -13,8 +13,7 @@ describe('expression', function() {
         scope = Scope.factory({
             one: 1,
             two: 2,
-            x: 'XXX',
+            x: 'XXX'
-			z: 'z'
         });
     });
 
@@ -41,7 +40,6 @@ describe('expression', function() {
         expect(evalExp('one<=two', scope)).to.equal(true);
         expect(evalExp('x contains "x"', scope)).to.equal(false);
         expect(evalExp('x contains "X"', scope)).to.equal(true);
-        expect(evalExp('x contains z', scope)).to.equal(false);
         expect(evalExp('"<=" == "<="', scope)).to.equal(true);
     });