added basic filter tests...

Signed-off-by: Alex A. Naanou <alex.nanou@gmail.com>

v3/pwiki/parser.js

@@ -647,7 +647,6 @@ module.BaseParser = {
 				&& (body = this.expand(page, body, state, nested_handlers))
 
 			// call macro...
-			//* XXX LOCAL_STATE
 			// NOTE: here we separate local macro state and global/parent 
 			// 		state via the prototpype...
 			// 		This is mainly needed to sparate promises, since the 
@@ -655,7 +654,8 @@ module.BaseParser = {
 			// 		each macro can wait async for an arbitrary amount of 
 			// 		time it only should care about what was promised 
 			// 		before it neglecting what came after.
-			var res = that.callMacro(page, name, args, body, {
+			var res = 
+				that.callMacro(page, name, args, body, {
 					// global/parent state...
 					__proto__: state,
 					root: state.root ?? state,
@@ -664,9 +664,6 @@ module.BaseParser = {
 					waitAll: state.waitAll,
 					waitNested: state.waitNested,
 				})
-			/*/
-			var res = that.callMacro(page, name, args, body, state)
-			//*/
 
 			// async...
 			if(res instanceof Promise){
@@ -793,8 +790,6 @@ module.BaseParser = {
 				ast
 			: ast.iter()
 
-		// XXX LOCAL_STATE
-		//state.unresolved = []
 		var unresolved = []
 
 		// merge resolved elements into the last item of elems...
@@ -838,9 +833,6 @@ module.BaseParser = {
 			// nested macro with no value set -- skip...
 			if(that.macros[elem.name] instanceof Array){
 				continue }
-			// XXX LOCAL_STATE...
-			//		...use the same mechanism here as in .expand(..)
-			//state.unresolved
 			unresolved
 				.push(elem.resolving instanceof Promise ?
 					elem.resolving
@@ -850,13 +842,14 @@ module.BaseParser = {
 			// 		are the responsibility of the respective macros...
 			elems.push(elem) }
 
-		var resolving = 
+		if(unresolved.length > 0){
-		state.wait = 
+			var resolving = 
-			Promise.all([state.wait, ...unresolved])
+			state.wait = 
-				// cleanup...
+				Promise.all([state.wait, ...unresolved])
-				.then(function(){
+					// cleanup...
-					if(state.wait === resolving){
+					.then(function(){
-						delete state.wait } })
+						if(state.wait === resolving){
+							delete state.wait } }) }
 
 		return elems },
 
@@ -879,10 +872,12 @@ module.BaseParser = {
 	// - apply stage III post handlers
 	//
 	//
+	// XXX BUG: this seems to always return a promise... 
 	// XXX RECURSION might be a good idea to limit recursion/nesting depth 
 	// 		of inner resolve(..)...
 	// XXX RENAME...
 	finalize: function(page, ast, state={}, nested_handlers={}, wait='wait'){
+	//finalize: function(page, ast, state={}, nested_handlers={}, wait='waitNested'){
 		var that = this
 
 		var stage3 = function(ast){
@@ -895,7 +890,6 @@ module.BaseParser = {
 		var resolve = function(ast){
 			return Promise.awaitOrRun(
 				// XXX LOCAL_STATE
-				//...(state.unresolved ?? []),
 				state.hasOwnProperty('wait') ?
 					state.wait
 					// XXX
@@ -921,7 +915,7 @@ module.BaseParser = {
 			// XXX do we actually need to wait here???
 			// 		...each macro should already be waiting...
 			//...[state[wait]].flat(),
-			state.hasOwnProperty(wait) ?
+			(wait && state.hasOwnProperty(wait)) ?
 				state[wait]
 				: null,
 			function(){
@@ -931,12 +925,9 @@ module.BaseParser = {
 				return Promise.awaitOrRun(
 					// XXX LOCAL_STATE if we are nested we should not wait
 					// 		for anything after the caller...
-					//(state.unresolved 
+					that.isResolved(ast) ?
-					//		|| !that.isResolved(ast)) ?
+						ast
-					//state.hasOwnProperty('wait') ?
+						: resolve(ast),
-					!that.isResolved(ast) ?
-						resolve(ast)
-						: ast,
 			   		function(ast){
 						return (
 							// stage III post...
@@ -953,16 +944,8 @@ module.BaseParser = {
 			function(res){
 				return res.join('') }) },
 
-
-	// XXX
 	execNested: function(page, ast, state={}, nested_handlers={}){
-		//return ast
-		/* XXX LOCAL_STATE waitNested here deadlocks the parser -- not sure why...
-		//return this.exec(page, ast, state, nested_handlers, 'unresolved') },
 		return this.exec(page, ast, state, nested_handlers, 'waitNested') },
-		/*/
-		return this.exec(page, ast, state, nested_handlers, '') },
-		//*/
 
 
 	// XXX render api...
@@ -1047,20 +1030,7 @@ module.parser = {
 		echo: function(page, args, body, state){
 			console.log(['----', ...Object.keys(args), body ?? ''].join(' ').gray)
 			return Promise.awaitOrRun(
-				// XXX this works and sequences correctly...
 				state.waitNested,
-				// XXX this deadlocks...
-				// 		calling .execNested(..) from any macro (@include(..) 
-				// 		in the example code) will deadlock the execution
-				// 		if .execNested(..) is waiting for .waitNested...
-				// 		to reproduce:
-				// 			- uncomment the LOCAL_STATE track
-				// 			- run:
-				// 				@echo(A)@source(/async/echo)@echo(B)@include(/async/echo)@echo(C)
-				// 		-> need a way to call .exex(..) while evaluating...
-				//this.execNested(page, '', state),
-				// XXX this also does not work...
-				//this.resolve(page, '', state),
 				function(){
 					console.log('  --', ...Object.keys(args), body ?? '') }) },
 		//*/
@@ -1110,18 +1080,16 @@ module.parser = {
 						// stage III
 						return function(state){
 							return Promise.awaitOrRun(
-
 								// apply the filters...
 								that.finalize(
 									page, 
 									body, 
 									{
-										...state, 
+										__proto__: state, 
 										filters: clear ?
 											filters
 											: [...filters, ...state.filters ?? []],
 									}),
-
 								function(body){
 									// stage III post...
 									// NOTE: we are protecting the result from 
@@ -1200,12 +1168,9 @@ module.parser = {
 				if(!name){
 					return '' }
 
-				//* XXX LOCAL_STATE
+				// XXX LOCAL_STATE
 				var vars = state.parent.vars ??= {}
 				//var vars = state.root.vars ??= {}
-				/*/
-				var vars = state.vars ??= {}
-				//*/
 
 				return Promise.awaitOrRun(
 					this.execNested(page, name, state),
@@ -1350,12 +1315,9 @@ module.parser = {
 				var that = this
 				var name = args.name
 
-				//* XXX LOCAL_STATE
+				// XXX LOCAL_STATE
 				var slots = state.parent.slots ??= {}
 				//var slots = state.root.slots ??= {}
-				/*/
-				var slots = state.slots ??= {}
-				//*/
 
 				return Promise.awaitOrRun(
 					this.execNested(page, name, state),
@@ -1714,12 +1676,9 @@ module.parser = {
 			function(page, args, body, state){
 				var that = this
 
-				//* XXX LOCAL_STATE
+				// XXX LOCAL_STATE
 				var macros = state.parent.macros ??= {}
 				//var macros = state.root.macros ??= {}
-				/*/
-				var macros = state.macros ??= {}
-				//*/
 
 				return Promise.awaitOrRun(
 					this.execNested(page, args.name, state),

v3/pwiki/test/parser.js

@@ -399,7 +399,55 @@ test.Setups({
 	// XXX
 
 	// XXX filter...
-	// XXX
+	filter_local: function(assert){
+		return {
+			page: P,
+			code: [
+				'<filter upper>moo</filter>',
+					'MOO' ]} },
+	filter_local_sync: function(assert){
+		return {
+			page: P,
+			code: [
+				'<filter upper>@include(/page)</filter>',
+					'PAGE' ]} },
+	filter_local_async: function(assert){
+		return {
+			page: P,
+			code: [
+				'<filter upper>@include(/async/page)</filter>',
+					'PAGE' ]} },
+	filter_global: function(assert){
+		return {
+			page: P,
+			code: [
+				'<filter upper/>moo',
+					'MOO' ]} },
+	filter_global_sync: function(assert){
+		return {
+			page: P,
+			code: [
+				'<filter upper/>@include(/page)',
+					'PAGE' ]} },
+	filter_global_async: function(assert){
+		return {
+			page: P,
+			code: [
+				'<filter upper/>@include(/async/page)',
+					'PAGE' ]} },
+	filter_mixed_isolated_sync: function(assert){
+		return {
+			page: P,
+			code: [
+				'<filter upper/>local <filter -upper>@include(/page)</filter>',
+					'LOCAL Page' ]} },
+	// XXX BUG
+	filter_mixed_isolated_async: function(assert){
+		return {
+			page: P,
+			code: [
+				'<filter upper/>local <filter -upper>@include(/async/page)</filter>',
+					'LOCAL Page' ]} },
 
 })