@trenskow/parse 0.1.7 → 0.1.9

package/.vscode/launch.json

@@ -5,7 +5,7 @@
 	"version": "0.2.0",
 	"configurations": [
 		{
-			"type": "pwa-node",
+			"type": "node",
 			"request": "launch",
 			"name": "Run test",
 			"skipFiles": [

package/.vscode/settings.json

@@ -0,0 +1,6 @@
+{
+    "[javascript]": {
+        "editor.formatOnSave": true,
+        "editor.formatOnPaste": true
+    }
+}

package/index.js

@@ -1,20 +1,42 @@
 // Created 02/05/22 by Kristian Trenskow
 // See LICENSE for license.
 
-export default (opening, closing, options) => {
+export default (...args) => {
 
-	if (typeof opening !== 'string' || typeof closing !== 'string') {
-		throw new TypeError('Opening and closing tokens must be strings.');
+	let boundaries;
+	let options;
+
+	if (typeof args[0] === 'string') {
+		boundaries = args.slice(0, 2);
+		options = args[2];
+	} else {
+		[ boundaries, options ] = args;
 	}
 
-	if (opening.length === 0 || closing.length === 0) {
-		throw new TypeError('Opening and closing tokens cannot be zero-length.');
+	if (!Array.isArray(boundaries)) {
+		throw new TypeError('Boundaries must be an array.');
 	}
 
-	if (opening === closing) {
-		throw new TypeError('Opening and closing tokens cannot be the same.');
+	if (boundaries.every((boundary) => typeof boundary === 'string')) {
+		boundaries = [boundaries];
 	}
 
+	boundaries
+		.forEach((boundaries) => {
+			if (boundaries.length !== 2) {
+				throw new TypeError('Boundaries must be an array containing the opening and closing boundary.');
+			}
+			if (!boundaries.every((boundary) => typeof boundary === 'string')) {
+				throw new TypeError('Boundaries must be strings.');
+			}
+			if (!boundaries.every((boundary) => boundary.length > 0)) {
+				throw new TypeError('Boundaries cannot be zero-length.');
+			}
+			if (boundaries.every((boundary) => boundary === boundaries[0])) {
+				throw new TypeError('Boundary tokens cannot be the same.');
+			}
+		});
+
 	if (typeof options === 'undefined') options = {};
 	if (typeof options !== 'object' || options === null) {
 		throw new TypeError('Options must be an object.');
@@ -37,6 +59,12 @@ export default (opening, closing, options) => {
 		throw new TypeError('Max depth must be a number.');
 	}
 
+	if (typeof options.boundaries === 'undefined') options.boundaries = 'exclude';
+
+	if (!['exclude', 'include'].includes(options.boundaries)) {
+		throw new TypeError('Boundaries must be either `\'exclude\'` (default) or `\'include\'`.');
+	}
+
 	if (maxDepth < 0) {
 		throw new TypeError('Max depth must be greater than zero.');
 	}
@@ -46,18 +74,24 @@ export default (opening, closing, options) => {
 	return {
 		do: (text) => {
 
-			const next = (text, offset, depth) => {
+			let foundBoundaries = [];
 
-				let result = [];
+			const next = (text, offset, depth) => {
 
-				let literal = '';
+				let result = [''];
 
 				let idx = offset;
 				let ignoredDepths = 0;
 
+				const appendResult = (text) => {
+					result[result.length - 1] += text;
+				};
+
 				for (idx ; idx < text.length ; idx++) {
 
-					if (text[idx] === '\\') literal += text[++idx];
+					const nextBoundary = foundBoundaries[foundBoundaries.length - 1];
+
+					if (text[idx] === '\\') appendResult(text[++idx]);
 					else {
 
 						const matchedIgnore = ignoreInside
@@ -66,7 +100,7 @@ export default (opening, closing, options) => {
 							.map(([_, matched]) => matched)[0];
 
 						if (typeof matchedIgnore !== 'undefined') {
-							literal += matchedIgnore;
+							appendResult(matchedIgnore);
 							if (matchedIgnore === ignoring[ignoring.length - 1]) {
 								ignoring.pop();
 							} else {
@@ -74,50 +108,72 @@ export default (opening, closing, options) => {
 							}
 						}
 						else if (ignoring.length === 0) {
-							if (text.substring(idx, idx + opening.length) === opening) {
+
+							const boundary = boundaries.find((boundaries) => text.substring(idx, idx + boundaries[0].length) === boundaries[0]);
+
+							if (typeof boundary !== 'undefined') {
 
 								if (maxDepth > depth) {
-									result.push(literal);
+
+									foundBoundaries.push(boundary);
+
 									let value;
-									[idx, value] = next(text, idx + opening.length, depth + 1);
+
+									[idx, value] = next(text, idx + boundary[0].length, depth + 1);
+
 									result.push(value);
-									literal = '';
+
+									result.push('');
+
 								} else {
-									literal += text[idx];
+									appendResult(text[idx]);
 									ignoredDepths++;
 								}
 
-							} else if (text.substring(idx, idx + closing.length) === closing) {
+							} else if (typeof nextBoundary !== 'undefined' && text.substring(idx, idx + nextBoundary[1].length) === nextBoundary[1]) {
 
 								if (ignoredDepths === 0) {
 
-									if (literal.length > 0) result.push(literal);
+									foundBoundaries.pop();
 
-									if (result.length === 1 && typeof result[0] === 'string') {
-										result = result[0];
+									if (depth > 0 && options.boundaries === 'include') {
+										if (Array.isArray(result[0])) result[0] = [nextBoundary[0]].concat(result[0]);
+										else result[0] = `${nextBoundary[0]}${result[0]}`;
+										if (Array.isArray(result[result.length - 1])) result.push(nextBoundary[1]);
+										else result[result.length - 1] = `${result[result.length - 1]}${nextBoundary[1]}`;
 									}
 
-									return [idx + closing.length - 1, result];
+									idx += nextBoundary[1].length - 1;
+
+									break;
 
 								} else {
-									literal += text[idx];
+									appendResult(text[idx]);
 									ignoredDepths--;
 								}
 
 							} else {
-								literal += text[idx];
+								appendResult(text[idx]);
 							}
 						}
-						else literal += text[idx];
+						else appendResult(text[idx]);
 
 					}
 				}
 
-				throw new Error('Missing closing token.');
+				if (Array.isArray(result)) {
+					result = result.filter((value) => value.length > 0);
+				}
+
+				if (result.length === 1 && typeof result[0] === 'string') {
+					result = result[0];
+				}
+
+				return [idx, result];
 
 			};
 
-			return next(text + closing, 0, 0)[1];
+			return next(text, 0, 0)[1];
 
 		}
 	};

package/package.json

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

package/test.js

@@ -34,6 +34,21 @@ describe('parser', () => {
 			'.'
 		]);
 	});
+	it ('should come back with parsed tree (with escapes and boundaries).', () => {
+		expect(parse([['[', ']'], ['{', '}']], { boundaries: 'include' }).do('This [is {my [\\[nested\\]] string}].')).to.eql(
+			[
+				'This ',
+				[
+					'[is ',
+					[
+						'{my ',
+						'[[nested]]',
+						' string}'
+					],
+					']'
+				],
+				'.']);
+	});
 	it ('should come back with parsed tree (long tokens).', () => {
 		expect(parse('hello', 'goodbye').do('This hello is hello my hello nested goodbye string goodbye goodbye.')).to.eql([
 			'This ',
@@ -71,23 +86,23 @@ describe('parser', () => {
 	});
 	it ('should throw an error if closing token is missing.', () => {
 		expect(() => {
-			parse('[', ']').do('[this');
-		}).to.throw('Missing closing token.');
+			parse('[').do('[this');
+		}).to.throw('Boundaries must be an array containing the opening and closing boundary.');
 	});
 	it ('should throw an error if opening or closing tokens are not a string.', () => {
 		expect(() => {
-			parse(0, 1).do('[this');
-		}).to.throw('Opening and closing tokens must be strings.');
+			parse([[0, 1]]).do('[this');
+		}).to.throw('Boundaries must be strings.');
 	});
 	it ('should throw an error if opening or closing tokens are zero-length.', () => {
 		expect(() => {
 			parse('', '').do('[this');
-		}).to.throw('Opening and closing tokens cannot be zero-length.');
+		}).to.throw('Boundaries cannot be zero-length.');
 	});
 	it ('should throw an error if opening or closing are the same.', () => {
 		expect(() => {
 			parse('123', '123').do('[this');
-		}).to.throw('Opening and closing tokens cannot be the same.');
+		}).to.throw('Boundary tokens cannot be the same.');
 	});
 	it ('should throw an error if options is not an object.', () => {
 		expect(() => {
@@ -109,4 +124,9 @@ describe('parser', () => {
 			parse('[', ']', { maxDepth: -1 });
 		}).to.throw('Max depth must be greater than zero.');
 	});
+	it ('should throw an error if boundaries is unknown value.', () => {
+		expect(() => {
+			parse('[', ']', { boundaries: 'wrong' });
+		}).to.throw('Boundaries must be either `\'exclude\'` (default) or `\'include\'`.');
+	});
 });