v3/pwiki/parser.js

@@ -223,7 +223,6 @@ module.BaseParser = {
 	// NOTE: this unifies the body, body argument and text argument (in 
 	// 		order of priority) and passes the value in the body macro 
 	// 		handler argument.
-	// XXX should a macro be run in the context of the page or the parser???
 	callMacro: function(page, macro, args, body, state, ...rest){
 		do {
 			macro = this.macros[macro] 
@@ -245,7 +244,12 @@ module.BaseParser = {
 				body
 					?? args.body 
 					?? args.text }
-		return macro.call(this, page, args, body, state, ...rest) },
+		return macro.call(page, 
+				this,
+				args,
+				body, 
+				state, 
+				...rest) },
 
 
 	// Strip comments...
@@ -1160,21 +1164,21 @@ module.parser = {
 		'': 'arg',
 		arg: Macro(
 			['name', 'else', ['local']],
-			function(page, args, _, state){
+			function(parser, args, _, state){
-				var v = (page.args ?? {})[args.name] 
+				var v = (this.args ?? {})[args.name] 
 					|| (!args.local 
-						&& (page.renderer
+						&& (this.renderer
-							&& page.renderer.args[args.name])
+							&& this.renderer.args[args.name])
-						|| (page.root
+						|| (this.root
-							&& page.root.args[args.name]))
+							&& this.root.args[args.name]))
 				v = v === true ?
 					args.name
 					: v
 				return v
 					|| (args['else']
-						&& this.expand(this, args['else'], state)) }),
+						&& parser.expand(this, args['else'], state)) }),
-		args: function(page){
+		args: function(){
-			return pwpath.obj2args(page.args) },
+			return pwpath.obj2args(this.args) },
 
 		// XXX EXPERIMENTAL...
 		//
@@ -1194,14 +1198,13 @@ module.parser = {
 				/*/
 				['shown', 'hidden']],
 				//*/
-			function(page, args, body, state){
+			function(parser, args, body, state){
-				var that = this
 				var name = args.name
 				if(!name){
 					return '' }
 
 				return Promise.awaitOrRun(
-					this.parseNested(page, name, state),
+					parser.parseNested(this, name, state),
 					function(name){
 						// XXX INC_DEC
 						var inc = args.inc
@@ -1272,7 +1275,7 @@ module.parser = {
 						if(text){
 							return Promise.awaitOrRun(
 								//state.waitNested,
-								that.parseNested(page, text, state),
+								parser.parseNested(this, text, state),
 								function(value){
 									text = vars[name] = value
 									return show ?? false ?
@@ -1281,13 +1284,12 @@ module.parser = {
 						// get...
 						} else {
 							return handleFormat(vars[name] ?? '') } }) }),
-		vars: function(page, args, body, state){
+		vars: function(parser, args, body, state){
-			var that = this
 			var lst = []
 			for(var [name, value] of Object.entries(args)){
 				lst.push(
-					this.parseNested(page, name, state),
+					parser.parseNested(this, name, state),
-					this.parseNested(page, value, state)) }
+					parser.parseNested(this, value, state)) }
 			var vars = state.vars ??= {}
 			return Promise.awaitOrRun(
 				state.waitNested,
@@ -1340,12 +1342,11 @@ module.parser = {
 			// NOTE: this is needed to be able to control the sequence of
 			// 		overrides in nesteed slots...
 			lazy(
-			function(page, args, body, state){
+			function(parser, args, body, state){
-				var that = this
 				var name = args.name
 
 				return Promise.awaitOrRun(
-					this.parseNested(page, name, state),
+					parser.parseNested(this, name, state),
 					function(name){
 						var slots = state.slots ??= {}
 
@@ -1368,7 +1369,7 @@ module.parser = {
 						slot.splice(0, slot.length, placeholder)
 						// expand body...
 						body = body ?
-							that.expand(page, body ?? [], state)
+							parser.expand(this, body ?? [], state)
 							: body
 						// if slot not overriden, write our value...
 						if(slot[0] === placeholder){
@@ -1424,16 +1425,13 @@ module.parser = {
 		// 		not 100% correct manner focusing on path depth and ignoring
 		// 		the context, this potentially can lead to false positives.
 		//
-		// XXX add path recursion test to data -- fail if two paths resolve 
-		// 		to the same context...
 		// XXX need a way to make encode option transparent...
 		// XXX need a way to wrap the included page...
 		// 		- template page...
 		// 		- prefix/sufix...
 		// XXX store a page cache in state...
-		// XXX do we want to load a specific slot/block???
 		// XXX UPDATE...
-		include: Macro(
+		include2: Macro(
 			['src', 'recursive', 'join', 
 				['s', 'strict', 'isolated']],
 			// XXX thinking that reimplementing this is a bit less boring than
@@ -1445,8 +1443,7 @@ module.parser = {
 			// 		.get(path)
 			// 			is this a promise/value, iterable promise a generator
 			// 			an async generator, ... or a combination/stack of the above???
-			lazy(
+			function(parser, args, body, state, key='included', handler){
-			function(page, args, body, state, key='included', handler){
 				var that = this
 
 				var recursive = 
@@ -1455,12 +1452,11 @@ module.parser = {
 						?? body
 						?? state.recursive
 
-				var base = page.basepath
+				var base = this.basepath
-				// XXX we do this before or after we parse???
+				var src = this.resolvePathVars(args.src)
-				var src = page.resolvePathVars(args.src)
 
 				return Promise.awaitOrRun(
-					this.parseNested(page, src, state),
+					parser.parseNested(this, src, state),
 					function(src){
 						var cache = state.cache ??= {}
 						if(cache[src]){
@@ -1492,30 +1488,30 @@ module.parser = {
 
 						// content handler...
 						handler ??= 
-							function(page, text, state){
+							function(parser, text, state){
-								return this._parse(page, text, state) }
+								return parser._parse(that, text, state) }
 
 						var pageHandler =
 							function(text, i, l){
 								return [
-									handler.call(that, 
+										handler.call(that, 
-										page, 
+											parser, 
-										text, 
+											text, 
-										// isolated up -- will see all 
+											// isolated up -- will see all 
-										// the state but can have no 
+											// the state but can have no 
-										// side-effects...
+											// side-effects...
-										args.isolated == 'partial' ?
+											args.isolated == 'partial' ?
-												serialize.partialDeepCopy(state)
+													serialize.partialDeepCopy(state)
-											// fully isolated...
+												// fully isolated...
-											: args.isolated ?
+												: args.isolated ?
-												{}
+													{}
-											: state),
+												: state),
-									// join...
+										// join...
-									(args.join 
+										(args.join 
-											&& i < l.length - 1) ?
+												&& i < l.length - 1) ?
-										that._parse(page, args.join, state)
+											parser._parse(that, args.join, state)
-										: []
+											: []
-								].flat() }
+									].flat() }
 						var resultHandler =
 							function(pages){
 								// XXX not sure if this can happen or why...
@@ -1533,7 +1529,7 @@ module.parser = {
 
 						// get and run things...
 						return Promise.awaitOrRun(
-							page.get(src).raw,
+							that.get(src).raw,
 							function(pages){
 								pages = pages instanceof Array ?
 									pages
@@ -1545,9 +1541,9 @@ module.parser = {
 											.map( pageHandler ))
 										.flat()
 										.sync(),
-									resultHandler ) }) }) })),
+									resultHandler ) }) }) }),
 
-		_include: Macro(
+		include: Macro(
 			['src', 'recursive', 'join', 
 				['s', 'strict', 'isolated']],
 			async function*(parser, args, body, state, key='included', handler){
@@ -2074,5 +2070,32 @@ module.parser = {
 
 
 
+// XXX for testing...
+
+var P = 
+module.P = {
+	//* XXX
+	_content: [
+		'first page text',
+		'second page text',
+	],
+	/*/
+	_content: 'page text',
+	//*/
+	
+	path: '/path/to/page',
+	basepath: '/path/to/',
+
+	get raw(){
+		return this._content ?? '' },
+	get: function(){
+		return this },
+
+	resolvePathVars: function(path){
+		return path },
+}
+
+
+
 /**********************************************************************
 * vim:set ts=4 sw=4 nowrap :                        */ return module })

v3/pwiki/test/parser.js

@@ -1,52 +1,12 @@
 #!/usr/bin/node
 //---------------------------------------------------------------------
 
-var path = require('path')
-
 var test = require('ig-test')
 var serialize = require('ig-serialize')
 
 var parser = require('../parser').parser
 
 
-//---------------------------------------------------------------------
-
-var PAGES = 
-module.exports.PAGES = {
-	'/blank': '',
-	'/page': 'Page',
-	'/async/page': Promise.resolve('Page'),
-	'/includePage': '@include(/page)',
-}
-
-var P = 
-module.exports.P = {
-	__pages__: PAGES,
-	__parser__: parser,
-	
-	path: '/',
-
-	get basepath(){
-		return path.dirname(this.path ?? '') },
-
-	get raw(){
-		return this.__pages__[this.path] ?? '' },
-	get text(){
-		return this.__parser__.parse(this, this.raw, {}) },
-
-	get: function(p){
-		return {
-			__proto__: P,
-			path: path.resolve(this.path, p),
-		} },
-
-	// XXX
-	resolvePathVars: function(path){
-		return path },
-}
-
-
-
 //---------------------------------------------------------------------
 
 test.Setups({
@@ -180,28 +140,6 @@ test.Setups({
 	// XXX arg...
 	// XXX
 
-	// include...
-	// XXX these do not play well with modifiers...
-	include: function(assert, path='/blank', expected){
-		return { 
-			page: P,
-			code: [ 
-				`@include(${path})`, 
-				// XXX for some reason this does not parse int a macro....
-				//'<include /blank />', 
-				`<include "${path}" />`, 
-					expected 
-						?? P.get(path).raw,
-			],
-		}},
-	include_page: function(assert){
-		return this.include(assert, '/page') },
-	include_include_page: function(assert){
-		return this.include(assert, '/includePage', 'Page') },
-	/* XXX
-	include_async: function(assert){
-		return this.include(assert, '/async/page') },
-	//*/
 })