@trenskow/parse 0.1.0 → 0.1.3

package/.vscode/launch.json

@@ -7,7 +7,7 @@
 		{
 			"type": "pwa-node",
 			"request": "launch",
-			"name": "Launch Program",
+			"name": "Run test",
 			"skipFiles": [
 				"<node_internals>/**"
 			],

package/README.md

@@ -10,7 +10,9 @@ Below is an example on how to use the library.
 ````javascript
 import parse from '@trenskow/parse';
 
-parse('${', '}').do('This ${is ${my ${nested ${string}}}}');
+parse('${', '}', {
+    ignoreInside: ['"', '\'']
+}).do('This ${\'is\' ${my ${"nested" ${string}}}}');
 ````
 
 The above example will return the following structure
@@ -31,6 +33,8 @@ The above example will return the following structure
 ]
 ````
 
+> One caveat: opening and closing token cannot be the same.
+
 # License
 
 See license in LICENSE.

package/index.js

@@ -1,7 +1,7 @@
 // Created 02/05/22 by Kristian Trenskow
 // See LICENSE for license.
 
-export default (opening, closing) => {
+export default (opening, closing, options) => {
 
 	if (typeof opening !== 'string' || typeof closing !== 'string') {
 		throw new TypeError('Opening and closing tokens must be strings.');
@@ -15,38 +15,101 @@ export default (opening, closing) => {
 		throw new TypeError('Opening and closing tokens cannot be the same.');
 	}
 
+	if (typeof options === 'undefined') options = {};
+	if (typeof options !== 'object' || options === null) {
+		throw new TypeError('Options must be an object.');
+	}
+
+	let ignoreInside = options.ignoreInside;
+
+	if (typeof ignoreInside === 'undefined') ignoreInside = [];
+	if (!Array.isArray(ignoreInside)) ignoreInside = [ignoreInside];
+
+	if (ignoreInside.filter((ignore) => typeof ignore !== 'string').length) {
+		throw new TypeError('Ignore inside must be a string.');
+	}
+
+	let maxDepth = options.maxDepth;
+
+	if (typeof maxDepth === 'undefined') maxDepth = Infinity;
+
+	if (typeof maxDepth !== 'number') {
+		throw new TypeError('Max depth must be a number.');
+	}
+
+	if (maxDepth < 0) {
+		throw new TypeError('Max depth must be greater than zero.');
+	}
+
+	const ignoring = [];
+
 	return {
 		do: (text) => {
 
-			const next = (text, offset = 0) => {
+			const next = (text, offset, depth) => {
 
 				let result = [];
 
 				let literal = '';
 
 				let idx = offset;
+				let ignoredDepths = 0;
 
 				for (idx ; idx < text.length ; idx++) {
-					if (text[idx] === '\\') {
-						literal += text[++idx];
-					} else if (text.substring(idx, idx + opening.length) === opening) {
-						result.push(literal);
-						let value;
-						[idx, value] = next(text, idx + opening.length);
-						result.push(value);
-						literal = '';
-					} else if (text.substring(idx, idx + closing.length) === closing) {
-
-						if (literal.length > 0) result.push(literal);
-
-						if (result.length === 1 && typeof result[0] === 'string') {
-							result = result[0];
+
+					if (text[idx] === '\\') literal += text[++idx];
+					else {
+
+						const matchedIgnore = ignoreInside
+							.map((ignore) => [ignore, text.substring(idx, idx + ignore.length)])
+							.filter(([ignore, matched]) => ignore === matched)
+							.map(([_, matched]) => matched)[0];
+
+						if (typeof matchedIgnore !== 'undefined') {
+							literal += matchedIgnore;
+							if (matchedIgnore === ignoring[ignoring.length - 1]) {
+								ignoring.pop();
+							} else {
+								ignoring.push(matchedIgnore);
+							}
 						}
+						else if (ignoring.length === 0) {
+							if (text.substring(idx, idx + opening.length) === opening) {
+
+								if (maxDepth > depth) {
+									result.push(literal);
+									let value;
+									[idx, value] = next(text, idx + opening.length, depth + 1);
+									result.push(value);
+									literal = '';
+								} else {
+									literal += text[idx];
+									ignoredDepths++;
+								}
+
+							} else if (text.substring(idx, idx + closing.length) === closing) {
+
+								if (ignoredDepths === 0) {
 
-						return [idx + closing.length - 1, result];
+									if (literal.length > 0) result.push(literal);
+
+									if (result.length === 1 && typeof result[0] === 'string') {
+										result = result[0];
+									}
+
+									return [idx + closing.length - 1, result];
+
+								} else {
+									literal += text[idx];
+									ignoredDepths--;
+								}
+
+							} else {
+								literal += text[idx];
+							}
+						}
+						else literal += text[idx];
 
-					} else {
-						literal += text[idx];
 					}
 				}
 
@@ -54,7 +117,7 @@ export default (opening, closing) => {
 
 			};
 
-			return next(text + closing)[1];
+			return next(text + closing, 0, 0)[1];
 
 		}
 	};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trenskow/parse",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "description": "A small library for parsing a string into a tree.",
   "main": "index.js",
   "type": "module",

package/test.js

@@ -5,31 +5,29 @@ import { expect } from 'chai';
 
 import parse from './index.js';
 
-console.info(JSON.stringify(parse('[', ']').do('This [is [my [nested [string]]]]'), null, 4));
-
 describe('parser', () => {
-	it ('should come back with parsed tree (with escapes).', () => {
-		expect(parse('[', ']').do('This [is [my [\\[nested\\]] string]].')).to.eql([
+	it ('should come back with parsed tree.', () => {
+		expect(parse('{', '}').do('This {is {my {nested} string}}.')).to.eql([
 			'This ',
 			[
 				'is ',
 				[
 					'my ',
-					'[nested]',
+					'nested',
 					' string'
 				]
 			],
 			'.'
 		]);
 	});
-	it ('should come back with parsed tree.', () => {
-		expect(parse('{', '}').do('This {is {my {nested} string}}.')).to.eql([
+	it ('should come back with parsed tree (with escapes).', () => {
+		expect(parse('[', ']').do('This [is [my [\\[nested\\]] string]].')).to.eql([
 			'This ',
 			[
 				'is ',
 				[
 					'my ',
-					'nested',
+					'[nested]',
 					' string'
 				]
 			],
@@ -50,6 +48,27 @@ describe('parser', () => {
 			],
 			'.']);
 	});
+	it ('should come back with parsed tree (with ignore).', () => {
+		expect(parse('[', ']', { ignoreInside: ['"', '\''] }).do('This [is "my [\'nested\']" [string]]')).to.eql([
+			'This ',
+			[
+				'is "my [\'nested\']" ',
+				'string'
+			]
+		]);
+	});
+	it ('should come back with parsed tree (max depth = 1).', () => {
+		expect(parse('[', ']', { maxDepth: 1 }).do('This [is [my nested string]].')).to.eql([
+			'This ',
+			'is [my nested string]',
+			'.'
+		]);
+	});
+	it ('should come back with parsed tree (max depth = 0).', () => {
+		expect(parse('[', ']', { maxDepth: 0 }).do('This [is [my nested string]].')).to.eql(
+			'This [is [my nested string]].'
+		);
+	});
 	it ('should throw an error if closing token is missing.', () => {
 		expect(() => {
 			parse('[', ']').do('[this');
@@ -70,4 +89,24 @@ describe('parser', () => {
 			parse('123', '123').do('[this');
 		}).to.throw('Opening and closing tokens cannot be the same.');
 	});
+	it ('should throw an error if options is not an object.', () => {
+		expect(() => {
+			parse('[', ']', '123');
+		}).to.throw('Options must be an object');
+	});
+	it ('should throw an error if ignoreInside is not a string.', () => {
+		expect(() => {
+			parse('[', ']', { ignoreInside: null });
+		}).to.throw('Ignore inside must be a string.');
+	});
+	it ('should throw an error if maxDepth is not a number.', () => {
+		expect(() => {
+			parse('[', ']', { maxDepth: true });
+		}).to.throw('Max depth must be a number.');
+	});
+	it ('should throw an error if max depth is less that zero.', () => {
+		expect(() => {
+			parse('[', ']', { maxDepth: -1 });
+		}).to.throw('Max depth must be greater than zero.');
+	});
 });