Refactoring the wikitext parser

To match the structure of the JavaScript parser, and make it less
complicated

js/App.js

@@ -13,7 +13,7 @@ var WikiStore = require("./WikiStore.js").WikiStore,
 	Tiddler = require("./Tiddler.js").Tiddler,
 	tiddlerInput = require("./TiddlerInput.js"),
 	tiddlerOutput = require("./TiddlerOutput.js"),
-	WikiTextProcessor = require("./WikiTextProcessor.js").WikiTextProcessor,
+	WikiTextParser = require("./WikiTextParser.js").WikiTextParser,
 	JavaScriptParser = require("./JavaScriptParser.js").JavaScriptParser,
 	Navigators = require("./Navigators.js").Navigators,
 	StoryNavigator = require("./StoryNavigator.js").StoryNavigator;
@@ -24,8 +24,8 @@ var App = function() {
 	this.isBrowser = typeof window !== "undefined";
 	// Create the main store
 	this.store = new WikiStore();	
-	// Register the wikitext processor
+	// Register the wikitext parser
-	this.store.registerTextProcessor("text/x-tiddlywiki",new WikiTextProcessor({
+	this.store.registerParser("text/x-tiddlywiki",new WikiTextParser({
 		store: this.store
 	}));
 	// Register the standard tiddler serializers and deserializers

js/WikiStore.js

@@ -19,7 +19,7 @@ Available options are:
 var WikiStore = function WikiStore(options) {
 	options = options || {};
 	this.tiddlers = {};
-	this.textProcessors = {};
+	this.parsers = {};
 	this.tiddlerSerializers = {};
 	this.tiddlerDeserializers = {};
 	this.sandbox = options.sandbox;
@@ -28,8 +28,8 @@ var WikiStore = function WikiStore(options) {
 	});
 };
 
-WikiStore.prototype.registerTextProcessor = function(type,processor) {
+WikiStore.prototype.registerParser = function(type,parser) {
-	this.textProcessors[type] = processor;
+	this.parsers[type] = parser;
 };
 
 WikiStore.prototype.registerTiddlerSerializer = function(extension,mimeType,serializer) {
@@ -255,12 +255,12 @@ WikiStore.prototype.listTiddlers = function(type,template,emptyMessage) {
 */
 
 WikiStore.prototype.parseText = function(type,text) {
-	var processor = this.textProcessors[type];
+	var parser = this.parsers[type];
-	if(!processor) {
+	if(!parser) {
-		processor = this.textProcessors["text/x-tiddlywiki"];
+		parser = this.parsers["text/x-tiddlywiki"];
 	}
-	if(processor) {
+	if(parser) {
-		return processor.parse(text);
+		return parser.parse(text);
 	} else {
 		return null;
 	}

js/WikiTextParseTree.js

@@ -0,0 +1,250 @@
+/*\
+title: js/WikiTextParseTree.js
+
+Compile a wikitext parse tree into a JavaScript function that renders the required
+representation of the tree.
+
+\*/
+(function(){
+
+/*jslint node: true */
+"use strict";
+
+var ArgParser = require("./ArgParser.js").ArgParser,
+	JavaScriptParseTree = require("./JavaScriptParseTree.js").JavaScriptParseTree,
+	utils = require("./Utils.js"),
+	util = require("util");
+
+// Intialise the parse tree object
+var WikiTextParseTree = function(tree,store) {
+	this.tree = tree;
+	this.store = store;
+};
+
+WikiTextParseTree.prototype.render = function(type,treenode,store,title) {
+	/*jslint evil: true */
+	var code = this.compile(type,treenode);
+	var fn = eval(code);
+	var tiddler = store.getTiddler(title);
+	return fn(tiddler,store,utils);
+};
+
+// Compile the parse tree into a JavaScript function that returns the required
+// representation of the tree
+WikiTextParseTree.prototype.compile = function(type,treenode) {
+	treenode = treenode || this.tree;
+	this.output = [];
+	if(type === "text/html") {
+		this.compileSubTreeHtml(treenode);
+	} else if(type === "text/plain") {
+		this.compileSubTreePlain(treenode);
+	} else {
+		return null;
+	}
+	// And then wrap the javascript tree and render it back into JavaScript code
+	var parseTree = this.store.jsParser.createTree(
+		[
+			{
+				type: "Function",
+				name: null,
+				params: ["tiddler","store","utils"],
+				elements: [
+					{
+					type: "ReturnStatement",
+					value: {
+						type: "FunctionCall",
+						name: {
+							type: "PropertyAccess",
+							base: {
+								type: "ArrayLiteral",
+								elements: this.output
+							},
+							name: "join"
+						},
+						"arguments": [ {
+							type: "StringLiteral",
+							value: ""
+							}
+						]
+						}
+					}
+				]
+			}
+		]);
+	return parseTree.render();
+};
+
+WikiTextParseTree.prototype.pushString = function(s) {
+	var last = this.output[this.output.length-1];
+	if(this.output.length > 0 && last.type === "StringLiterals") {
+		last.value.push(s);
+	} else if (this.output.length > 0 && last.type === "StringLiteral") {
+		last.type = "StringLiterals";
+		last.value = [last.value,s];
+	} else {
+		this.output.push({type: "StringLiteral", value: s});
+	}
+};
+
+WikiTextParseTree.prototype.compileMacroCall = function(type,name,params) {
+	var me = this,
+		macro = this.store.macros[name];
+	if(macro) {
+		var args = new ArgParser(params,{defaultName: "anon"}),
+			paramsProps = {};
+		var insertParam = function(name,arg) {
+			if(arg.evaluated) {
+				paramsProps[name] = me.store.jsParser.parse(arg.string).tree.elements[0];
+			} else {
+				paramsProps[name] = {type: "StringLiteral", value: arg.string};
+			}
+		};
+		for(var m in macro.params) {
+			var param = macro.params[m];
+			if("byPos" in param && args.byPos[param.byPos]) {
+				insertParam(m,args.byPos[param.byPos].v);
+			} else if("byName" in param) {
+				var arg = args.getValueByName(m);
+				if(!arg && param.byName === "default") {
+					arg = args.getValueByName("anon");
+				}
+				if(arg) {
+					insertParam(m,arg);
+				}
+			}
+		}
+		var macroCall = {
+			type: "FunctionCall",
+			name: {
+				type: "Function",
+				name: null,
+				params: ["params"],
+				elements: []},
+			"arguments": [ {
+				type: "ObjectLiteral",
+				properties: []	
+			}]
+		};
+		macroCall.name.elements = macro.code[type].tree.elements;
+		for(m in paramsProps) {
+			macroCall["arguments"][0].properties.push({
+				type: "PropertyAssignment",
+				name: m,
+				value: paramsProps[m]
+			});
+		}
+		this.output.push(macroCall);
+	} else {
+		this.pushString("<span class='error errorUnknownMacro'>Unknown macro '" + name + "'</span>");
+	}
+};
+
+WikiTextParseTree.prototype.compileElementHtml = function(element, options) {
+	options = options || {};
+	var tagBits = [element.type];
+	if(element.attributes) {
+		for(var a in element.attributes) {
+			var r = element.attributes[a];
+			if(a === "style") {
+				var s = [];
+				for(var t in r) {
+					s.push(t + ":" + r[t] + ";");
+				}
+				r = s.join("");
+			}
+			tagBits.push(a + "=\"" + utils.htmlEncode(r) + "\"");
+		}
+	}
+	this.pushString("<" + tagBits.join(" ") + (options.selfClosing ? " /" : ""));
+	if(options.insertAfterAttributes) {
+		this.pushString(" ");
+		this.output.push(options.insertAfterAttributes);
+	}
+	this.pushString(">");
+	if(!options.selfClosing) {
+		if(element.children) {
+			this.compileSubTreeHtml(element.children);
+		}
+		this.pushString("</" + element.type + ">");
+	}
+};
+
+WikiTextParseTree.prototype.compileSubTreeHtml = function(tree) {
+	for(var t=0; t<tree.length; t++) {
+		switch(tree[t].type) {
+			case "text":
+				this.pushString(utils.htmlEncode(tree[t].value));
+				break;
+			case "entity":
+				this.pushString(tree[t].value);
+				break;
+			case "br":
+			case "img":
+				this.compileElementHtml(tree[t],{selfClosing: true}); // Self closing elements
+				break;
+			case "context":
+				//compileSubTree(tree[t].children);
+				break;
+			case "macro":
+				this.compileMacroCall("text/html",tree[t].name,tree[t].params);
+				break;
+			case "a":
+				this.compileElementHtml(tree[t],{
+					insertAfterAttributes: {
+						"type": "FunctionCall",
+						"name": {
+							"type": "PropertyAccess",
+							"base": {
+								"type": "Variable",
+								"name": "store"},
+							"name": "classesForLink"},
+						"arguments":[{
+							"type": "StringLiteral",
+							"value": tree[t].attributes.href}]}
+				});
+				break;
+			default:
+				this.compileElementHtml(tree[t]);
+				break;
+		}
+	}
+};
+
+WikiTextParseTree.prototype.compileElementPlain = function(element, options) {
+	options = options || {};
+	if(!options.selfClosing) {
+		if(element.children) {
+			this.compileSubTreePlain(element.children);
+		}
+	}
+};
+
+WikiTextParseTree.prototype.compileSubTreePlain = function(tree) {
+	for(var t=0; t<tree.length; t++) {
+		switch(tree[t].type) {
+			case "text":
+				this.pushString(utils.htmlEncode(tree[t].value));
+				break;
+			case "entity":
+				this.pushString(tree[t].value);
+				break;
+			case "br":
+			case "img":
+				this.compileElementPlain(tree[t],{selfClosing: true}); // Self closing elements
+				break;
+			case "context":
+				//compileSubTree(tree[t].children);
+				break;
+			case "macro":
+				this.compileMacroCall("text/plain",tree[t].name,tree[t].params);
+				break;
+			default:
+				this.compileElementPlain(tree[t]);
+				break;
+		}
+	}
+};
+
+exports.WikiTextParseTree = WikiTextParseTree;
+
+})();

js/WikiTextParser.js

@@ -9,18 +9,44 @@ Parses a block of tiddlywiki-format wiki text into a parse tree object.
 /*jslint node: true */
 "use strict";
 
-var WikiTextCompiler = require("./WikiTextCompiler.js").WikiTextCompiler,
+var WikiTextRules = require("./WikiTextRules.js"),
+	WikiTextParseTree = require("./WikiTextParseTree.js").WikiTextParseTree,
 	utils = require("./Utils.js"),
 	util = require("util");
 
-var WikiTextParser = function(text,processor) {
+/*
-	this.processor = processor;
+Creates a new instance of the wiki text parser with the specified options. The
+options are a hashmap of mandatory members as follows:
+
+	store: The store object to use to parse any cascaded content (eg transclusion)
+
+Planned:
+
+	enableRules: An array of names of wiki text rules to enable. If not specified, all rules are available
+	extraRules: An array of additional rule handlers to add
+	enableMacros: An array of names of macros to enable. If not specified, all macros are available
+	extraMacros: An array of additional macro handlers to add
+*/
+
+var WikiTextParser = function(options) {
+	this.store = options.store;
 	this.autoLinkWikiWords = true;
+	this.rules = WikiTextRules.rules;
+	var pattern = [];
+	for(var n=0; n<this.rules.length; n++) {
+		pattern.push("(" + this.rules[n].match + ")");
+	}
+	this.rulesRegExp = new RegExp(pattern.join("|"),"mg");
+
+};
+
+WikiTextParser.prototype.parse = function(text) {
 	this.source = text;
 	this.nextMatch = 0;
 	this.children = [];
 	this.output = null;
 	this.subWikify(this.children);
+	return new WikiTextParseTree(this.children,this.store);
 };
 
 WikiTextParser.prototype.outputText = function(place,startPos,endPos) {
@@ -42,8 +68,8 @@ WikiTextParser.prototype.subWikifyUnterm = function(output) {
 	var oldOutput = this.output;
 	this.output = output;
 	// Get the first match
-	this.processor.rulesRegExp.lastIndex = this.nextMatch;
+	this.rulesRegExp.lastIndex = this.nextMatch;
-	var ruleMatch = this.processor.rulesRegExp.exec(this.source);
+	var ruleMatch = this.rulesRegExp.exec(this.source);
 	while(ruleMatch) {
 		// Output any text before the match
 		if(ruleMatch.index > this.nextMatch)
@@ -52,18 +78,18 @@ WikiTextParser.prototype.subWikifyUnterm = function(output) {
 		this.matchStart = ruleMatch.index;
 		this.matchLength = ruleMatch[0].length;
 		this.matchText = ruleMatch[0];
-		this.nextMatch = this.processor.rulesRegExp.lastIndex;
+		this.nextMatch = this.rulesRegExp.lastIndex;
 		// Figure out which rule matched and call its handler
 		var t;
 		for(t=1; t<ruleMatch.length; t++) {
 			if(ruleMatch[t]) {
-				this.processor.rules[t-1].handler(this);
+				this.rules[t-1].handler(this);
-				this.processor.rulesRegExp.lastIndex = this.nextMatch;
+				this.rulesRegExp.lastIndex = this.nextMatch;
 				break;
 			}
 		}
 		// Get the next match
-		ruleMatch = this.processor.rulesRegExp.exec(this.source);
+		ruleMatch = this.rulesRegExp.exec(this.source);
 	}
 	// Output any text after the last match
 	if(this.nextMatch < this.source.length) {
@@ -81,8 +107,8 @@ WikiTextParser.prototype.subWikifyTerm = function(output,terminatorRegExp) {
 	// Get the first matches for the rule and terminator RegExps
 	terminatorRegExp.lastIndex = this.nextMatch;
 	var terminatorMatch = terminatorRegExp.exec(this.source);
-	this.processor.rulesRegExp.lastIndex = this.nextMatch;
+	this.rulesRegExp.lastIndex = this.nextMatch;
-	var ruleMatch = this.processor.rulesRegExp.exec(terminatorMatch ? this.source.substr(0,terminatorMatch.index) : this.source);
+	var ruleMatch = this.rulesRegExp.exec(terminatorMatch ? this.source.substr(0,terminatorMatch.index) : this.source);
 	while(terminatorMatch || ruleMatch) {
 		// Check for a terminator match before the next rule match
 		if(terminatorMatch && (!ruleMatch || terminatorMatch.index <= ruleMatch.index)) {
@@ -105,20 +131,20 @@ WikiTextParser.prototype.subWikifyTerm = function(output,terminatorRegExp) {
 		this.matchStart = ruleMatch.index;
 		this.matchLength = ruleMatch[0].length;
 		this.matchText = ruleMatch[0];
-		this.nextMatch = this.processor.rulesRegExp.lastIndex;
+		this.nextMatch = this.rulesRegExp.lastIndex;
 		// Figure out which rule matched and call its handler
 		var t;
 		for(t=1; t<ruleMatch.length; t++) {
 			if(ruleMatch[t]) {
-				this.processor.rules[t-1].handler(this);
+				this.rules[t-1].handler(this);
-				this.processor.rulesRegExp.lastIndex = this.nextMatch;
+				this.rulesRegExp.lastIndex = this.nextMatch;
 				break;
 			}
 		}
 		// Get the next match
 		terminatorRegExp.lastIndex = this.nextMatch;
 		terminatorMatch = terminatorRegExp.exec(this.source);
-		ruleMatch = this.processor.rulesRegExp.exec(terminatorMatch ? this.source.substr(0,terminatorMatch.index) : this.source);
+		ruleMatch = this.rulesRegExp.exec(terminatorMatch ? this.source.substr(0,terminatorMatch.index) : this.source);
 	}
 	// Output any text after the last match
 	if(this.nextMatch < this.source.length) {
@@ -129,15 +155,6 @@ WikiTextParser.prototype.subWikifyTerm = function(output,terminatorRegExp) {
 	this.output = oldOutput;
 };
 
-WikiTextParser.prototype.render = function(type,treenode,store,title) {
-	/*jslint evil: true */
-	var compiler = new WikiTextCompiler(store,title,this);
-	var code = compiler.compile(type,treenode);
-	var fn = eval(code);
-	var tiddler = store.getTiddler(title);
-	return fn(tiddler,store,utils);
-};
-
 exports.WikiTextParser = WikiTextParser;
 
 })();

js/WikiTextProcessor.js

@@ -1,43 +0,0 @@
-/*\
-title: js/WikiTextProcessor.js
-
-\*/
-(function(){
-
-/*jslint node: true */
-"use strict";
-
-var WikiTextRules = require("./WikiTextRules.js"),
-	WikiTextParser = require("./WikiTextParser.js").WikiTextParser;
-
-/*
-Creates a new instance of the wiki text processor with the specified options. The
-options are a hashmap of mandatory members as follows:
-
-	store: The store object to use to parse any cascaded content (eg transclusion)
-
-Planned:
-
-	enableRules: An array of names of wiki text rules to enable. If not specified, all rules are available
-	extraRules: An array of additional rule handlers to add
-	enableMacros: An array of names of macros to enable. If not specified, all macros are available
-	extraMacros: An array of additional macro handlers to add
-*/
-var WikiTextProcessor = function(options) {
-	options = options || {};
-	this.store = options.store;
-	this.rules = WikiTextRules.rules;
-	var pattern = [];
-	for(var n=0; n<this.rules.length; n++) {
-		pattern.push("(" + this.rules[n].match + ")");
-	}
-	this.rulesRegExp = new RegExp(pattern.join("|"),"mg");
-};
-
-WikiTextProcessor.prototype.parse = function(text) {
-	return new WikiTextParser(text,this);
-};
-
-exports.WikiTextProcessor = WikiTextProcessor;
-
-})();

js/WikiTextRenderer.js

@@ -1,387 +0,0 @@
-/*\
-title: js/WikiTextRenderer.js
-
-\*/
-(function(){
-
-/*jslint node: true */
-"use strict";
-
-var ArgParser = require("./ArgParser.js").ArgParser,
-	utils = require("./Utils.js"),
-	util = require("util");
-
-var WikiTextRenderer = function(store,title,parser) {
-	this.parser = parser;
-	this.store = store;
-	this.title = title;
-};
-
-WikiTextRenderer.prototype.render = function(type,treenode) {
-	if(type === "text/html") {
-		return this.renderAsHtml(treenode);
-	} else if (type === "text/plain") {
-		return this.renderAsText(treenode);
-	} else {
-		return null;
-	}
-};
-
-WikiTextRenderer.prototype.renderAsHtml = function(treenode) {
-	var output = [],
-		renderSubTree;
-	var renderElement = function(element, selfClosing) {
-		var tagBits = [element.type];
-		if(element.attributes) {
-			for(var a in element.attributes) {
-				var r = element.attributes[a];
-				if(a === "style") {
-					var s = [];
-					for(var t in r) {
-						s.push(t + ":" + r[t] + ";");
-					}
-					r = s.join("");
-				}
-				tagBits.push(a + "=\"" + utils.htmlEncode(r) + "\"");
-			}
-		}
-		output.push("<" + tagBits.join(" ") + (selfClosing ? " /" : "") + ">");
-		if(!selfClosing) {
-			if(element.children) {
-				renderSubTree(element.children);
-			}
-			output.push("</" + element.type + ">");
-		}
-	};
-	renderSubTree = function(tree) {
-		for(var t=0; t<tree.length; t++) {
-			switch(tree[t].type) {
-				case "text":
-					output.push(utils.htmlEncode(tree[t].value));
-					break;
-				case "entity":
-					output.push(tree[t].value);
-					break;
-				case "br":
-				case "img":
-					renderElement(tree[t],true); // Self closing elements
-					break;
-				case "context":
-					renderSubTree(tree[t].children);
-					break;
-				case "macro":
-					renderSubTree(tree[t].output);
-					break;
-				default:
-					renderElement(tree[t]);
-					break;
-			}
-		}
-	};
-	this.executeMacros(treenode,this.title);
-	renderSubTree(treenode);
-	return output.join("");	
-};
-
-WikiTextRenderer.prototype.renderAsText = function(treenode) {
-	var output = [];
-	var renderSubTree = function(tree) {
-		for(var t=0; t<tree.length; t++) {
-			switch(tree[t].type) {
-				case "text":
-					output.push(tree[t].value);
-					break;
-				case "entity":
-					var c = utils.entityDecode(tree[t].value);
-					if(c) {
-						output.push(c);
-					} else {
-						output.push(tree[t].value);
-					}
-					break;
-				case "macro":
-					renderSubTree(tree[t].output);
-					break;
-			}
-			if(tree[t].children) {
-				renderSubTree(tree[t].children);
-			}
-		}
-	};
-	this.executeMacros(treenode,this.title);
-	renderSubTree(treenode);
-	return output.join("");	
-};
-
-WikiTextRenderer.prototype.executeMacros = function(tree,title) {
-	for(var t=0; t<tree.length; t++) {
-		if(tree[t].type === "macro") {
-			this.executeMacro(tree[t],title);
-		}
-		if(tree[t].children) {
-			var contextForChildren = tree[t].type === "context" ? tree[t].tiddler : title;
-			this.executeMacros(tree[t].children,contextForChildren);
-		}
-	}
-};
-
-WikiTextRenderer.prototype.executeMacro = function(macroNode,title) {
-	var macroInfo = WikiTextRenderer.macros[macroNode.name];
-	macroNode.output = [];
-	if(macroInfo) {
-		var args;
-		if(macroInfo.argOptions) {
-			var argOptions = {
-				globals: {
-					title: title
-				},
-				sandbox: this.store.jsProcessor
-			};
-			for(var g in macroInfo.argOptions) {
-				argOptions[g] = macroInfo.argOptions[g];
-			}
-			args = new ArgParser(macroNode.params,argOptions);
-		}
-		macroInfo.handler.call(this,macroNode,args,title);
-	} else {
-		macroNode.output.push({type: "text", value: "Unknown macro " + macroNode.name});
-	}
-};
-
-WikiTextRenderer.versionTiddlyWiki = "2.6.5";
-
-WikiTextRenderer.macros = {
-	allTags: {
-		handler: function(macroNode,args,title) {
-		}
-	},
-	br: {
-		handler: function(macroNode,args,title) {
-			macroNode.output.push({type: "br"});
-		}
-	},
-	echo: {
-		argOptions: {defaultName: "anon"},
-		handler: function(macroNode,args,title) {
-			var globals = {title: title};
-			macroNode.output.push({type: "text", value: args.byPos[0].v});
-		}	
-	},
-	timeline: {
-		argOptions: {defaultName:"anon"},
-		handler: function(macroNode,args,title) {
-			var anonByPos = args.getValuesByName("anon",[]),
-				field = anonByPos[0] || "modified",
-				limit = anonByPos[1] || null,
-				dateformat = anonByPos[2] || "DD MMM YYYY",
-				template = args.getValueByName("template",null),
-				templateType = "text/x-tiddlywiki",
-				templateText = "<<view title link>>",
-				groupTemplate = args.getValueByName("groupTemplate",null),
-				groupTemplateType = "text/x-tiddlywiki",
-				groupTemplateText = "<<view " + field + " date '" + dateformat + "'>>",
-				filter = args.getValueByName("filter",null),
-				tiddlers,
-				lastGroup = "",
-				ul,
-				last = 0,
-				t;
-			limit = limit ? parseInt(limit,10) : null;
-			template = template ? this.store.getTiddler(template) : null;
-			if(template) {
-				templateType = template.fields.type;
-				templateText = template.fields.text;
-			}
-			groupTemplate = groupTemplate ? this.store.getTiddler(groupTemplate) : null;
-			if(groupTemplate) {
-				groupTemplateType = groupTemplate.fields.type;
-				groupTemplateText = groupTemplate.fields.text;
-			}
-			if(filter) {
-				// Filtering not implemented yet
-				tiddlers = this.store.getTitles(field,"excludeLists");
-			} else {
-				tiddlers = this.store.getTitles(field,"excludeLists");
-			}
-			if(limit !== null) {
-				last = tiddlers.length - Math.min(tiddlers.length,limit);
-			}
-			for(t=tiddlers.length-1; t>=last; t--) {
-				var tiddler = tiddlers[t],
-					theGroupParseTree = this.store.parseText(groupTemplateType,groupTemplateText),
-					theGroup = theGroupParseTree.render("text/plain",theGroupParseTree.children,this.store,tiddler);
-				if(theGroup !== "") {
-					if(ul === undefined || theGroup !== lastGroup) {
-						ul = {type: "ul", attributes: {"class": "timeline"}, children: []};
-						macroNode.output.push(ul);
-						ul.children.push({type: "li", attributes: {"class": "listTitle"}, children: [{type: "text", value: theGroup}]});
-						lastGroup = theGroup;
-					}
-					var item = {
-									type: "li",
-									attributes: {
-										"class": "listLink"}, 
-									children: [ {
-										type: "context",
-										tiddler: tiddler,
-										children: []
-								}]};
-					ul.children.push(item);
-					item.children[0].children = this.store.parseText(templateType,templateText).children;
-				}
-			}
-			this.executeMacros(macroNode.output,title);
-		}
-	},
-	list: {
-		argOptions: {defaultName:"type"},
-		handler: function(macroNode,args,title) {
-			var type = args.getValueByName("type","all"),
-				template = args.getValueByName("template",null),
-				templateType = "text/x-tiddlywiki", templateText = "<<view title link>>",
-				emptyMessage = args.getValueByName("emptyMessage",null);
-			// Get the template to use
-			template = template ? this.store.getTiddler(template) : null;
-			if(template) {
-				templateType = template.fields.type;
-				templateText = template.fields.text;
-			}
-			// Get the handler and the tiddlers
-			var handler = WikiTextRenderer.macros.list.types[type];
-			handler = handler || WikiTextRenderer.macros.list.types.all;
-			var tiddlers = handler.call(this);
-			// Render them as a list
-			var ul = {type: "ul", children: []};
-			for(var t=0; t<tiddlers.length; t++) {
-				var li = {
-						type: "li",
-						children: [ {
-							type: "context",
-							tiddler: tiddlers[t],
-							children: []
-						} ] 
-				};
-				li.children[0].children = this.store.parseText(templateType,templateText).children;
-				ul.children.push(li);
-			}
-			if(ul.children.length > 0) {
-				macroNode.output.push(ul);
-				this.executeMacros(macroNode.output,title);
-			} else if (emptyMessage) {
-				macroNode.output.push({type: "text", value: emptyMessage});	
-			}
-		},
-		types: {
-			all: function() {
-				return this.store.getTitles("title","excludeLists");
-			},
-			missing: function() {
-				return this.store.getMissingTitles();
-			},
-			orphans: function() {
-				return this.store.getOrphanTitles();
-			},
-			shadowed: function() {
-				return this.store.getShadowTitles();
-			},
-			touched: function() {
-				// Server syncing isn't implemented yet
-				return [];
-			},
-			filter: function() {
-				// Filters aren't implemented yet
-				return [];
-			}
-		}
-	},
-	slider: {
-		handler: function(macroNode,args,title) {
-		}
-	},
-	tabs: {
-		handler: function(macroNode,args,title) {
-		}
-	},
-	tag: {
-		handler: function(macroNode,args,title) {
-		}
-	},
-	tagging: {
-		handler: function(macroNode,args,title) {
-		}
-	},
-	tags: {
-		handler: function(macroNode,args,title) {
-		}
-	},
-	tiddler: {
-		argOptions: {defaultName:"name",cascadeDefaults:true},
-		handler: function(macroNode,args,title) {
-			var targetTitle = args.getValueByName("name",null),
-				withTokens = args.getValuesByName("with",[]),
-				tiddler = this.store.getTiddler(targetTitle),
-				text = this.store.getTiddlerText(targetTitle,""),
-				t;
-			for(t=0; t<withTokens.length; t++) {
-				var placeholderRegExp = new RegExp("\\$"+(t+1),"mg");
-				text = text.replace(placeholderRegExp,withTokens[t]);
-			}
-			macroNode.output = this.store.parseText(tiddler.fields.type,text).children;
-			// Execute any macros in the copy
-			this.executeMacros(macroNode.output,title);
-		}
-	},
-	today: {
-		argOptions: {noNames:true},
-		handler: function(macroNode,args,title) {
-			var now = new Date(),
-				value = args.byPos[0] ? utils.formatDateString(now,args.byPos[0].v) : now.toLocaleString();
-			macroNode.output.push({type: "text", value: value});
-		}
-	},
-	version: {
-		handler: function(macroNode,args,title) {
-			macroNode.output.push({type: "text", value: WikiTextRenderer.versionTiddlyWiki});
-		}
-	},
-	view: {
-		argOptions: {noNames:true},
-		handler: function(macroNode,args,title) {
-			var field = args.byPos[0] ? args.byPos[0].v : null,
-				format = args.byPos[1] ? args.byPos[1].v : "text",
-				tiddler = this.store.getTiddler(title),
-				value = tiddler ? tiddler.fields[field] : null;
-			if(tiddler && field && value) {
-				switch(format) {
-					case "text":
-						macroNode.output.push({type: "text", value: value});
-						break;
-					case "link":
-						macroNode.output.push({
-							type: "a",
-							attributes: {
-								href: value
-								},
-							children: [
-								{type: "text", value: value}
-							]
-						});
-						break;
-					case "wikified":
-						macroNode.output = this.store.parseText("text/x-tiddlywiki",value).children;
-						// Execute any macros in the copy
-						this.executeMacros(macroNode.output,title);
-						break;
-					case "date":
-						var template = args.byPos[2] ? args.byPos[2].v : "DD MMM YYYY";
-						macroNode.output.push({type: "text", value: utils.formatDateString(value,template)});
-						break;
-				}
-			}
-		}
-	}
-};
-
-exports.WikiTextRenderer = WikiTextRenderer;
-
-})();

tiddlywiki.js

@@ -13,7 +13,6 @@ var App = require("./js/App.js").App,
 	Recipe = require("./js/Recipe.js").Recipe,
 	tiddlerInput = require("./js/TiddlerInput.js"),
 	tiddlerOutput = require("./js/TiddlerOutput.js"),
-	WikiTextProcessor = require("./js/WikiTextProcessor.js").WikiTextProcessor,
 	util = require("util"),
 	fs = require("fs"),
 	url = require("url"),

tiddlywiki5/tiddlywiki5.recipe

@@ -16,11 +16,9 @@ jsmodule: ../js/Tiddler.js
 jsmodule: ../js/TiddlerInput.js
 jsmodule: ../js/TiddlerOutput.js
 jsmodule: ../js/WikiStore.js
-jsmodule: ../js/WikiTextProcessor.js
 jsmodule: ../js/WikiTextParser.js
 jsmodule: ../js/WikiTextRules.js
-jsmodule: ../js/WikiTextRenderer.js
+jsmodule: ../js/WikiTextParseTree.js
-jsmodule: ../js/WikiTextCompiler.js
 jsmodule: ../js/Navigators.js
 jsmodule: ../js/StoryNavigator.js
 jsmodule: ../js/App.js