kopia lustrzana https://github.com/miklobit/TiddlyWiki5
247 wiersze
7.2 KiB
JavaScript
247 wiersze
7.2 KiB
JavaScript
/*
|
|
|
|
WikiTextParser.js
|
|
|
|
Parses a block of tiddlywiki-format wiki text into a parse tree object.
|
|
|
|
HTML elements are stored in the tree like this:
|
|
|
|
{type: "div", attributes: {
|
|
attr1: value,
|
|
style: {
|
|
name: value,
|
|
name2: value2
|
|
}
|
|
}, children: [
|
|
{child},
|
|
{child},
|
|
]}
|
|
|
|
Text nodes are:
|
|
|
|
{type: "text", value: "string of text node"}
|
|
|
|
*/
|
|
|
|
/*jslint node: true */
|
|
"use strict";
|
|
|
|
var wikiTextMacros = require("./WikiTextMacros.js"),
|
|
wikiTextRules = require("./WikiTextRules.js").wikiTextRules,
|
|
utils = require("./Utils.js"),
|
|
util = require("util");
|
|
|
|
var WikiTextParser = function(text) {
|
|
this.autoLinkWikiWords = true;
|
|
this.source = text;
|
|
this.nextMatch = 0;
|
|
this.tree = [];
|
|
this.output = null;
|
|
this.subWikify(this.tree);
|
|
};
|
|
|
|
// Render the tiddler as HTML from its parse tree
|
|
// type - MIME type of required output
|
|
// store - store object providing context for inter-tiddler operations
|
|
// title - render the tree as if it came from a tiddler of this title
|
|
WikiTextParser.prototype.render = function(type,store,title) {
|
|
if(type === "text/html") {
|
|
return this.renderAsHtml(store,title);
|
|
} else if (type === "text/plain") {
|
|
return this.renderAsText(store,title);
|
|
} else {
|
|
return null;
|
|
}
|
|
};
|
|
|
|
WikiTextParser.prototype.renderAsHtml = function(store,title) {
|
|
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 "macro":
|
|
renderSubTree(tree[t].output);
|
|
break;
|
|
default:
|
|
renderElement(tree[t]);
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
wikiTextMacros.executeMacros(this.tree,store,title);
|
|
renderSubTree(this.tree);
|
|
return output.join("");
|
|
};
|
|
|
|
WikiTextParser.prototype.renderAsText = function(store,title) {
|
|
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);
|
|
}
|
|
}
|
|
};
|
|
wikiTextMacros.executeMacros(this.tree,store,title);
|
|
renderSubTree(this.tree);
|
|
return output.join("");
|
|
};
|
|
|
|
WikiTextParser.prototype.outputText = function(place,startPos,endPos) {
|
|
if(startPos < endPos) {
|
|
place.push({type: "text", value: this.source.substring(startPos,endPos)});
|
|
}
|
|
};
|
|
|
|
WikiTextParser.prototype.subWikify = function(output,terminator) {
|
|
// Handle the terminated and unterminated cases separately, this speeds up wikifikation by about 30%
|
|
if(terminator)
|
|
this.subWikifyTerm(output,new RegExp("(" + terminator + ")","mg"));
|
|
else
|
|
this.subWikifyUnterm(output);
|
|
};
|
|
|
|
WikiTextParser.prototype.subWikifyUnterm = function(output) {
|
|
// subWikify can be indirectly recursive, so we need to save the old output pointer
|
|
var oldOutput = this.output;
|
|
this.output = output;
|
|
// Get the first match
|
|
wikiTextRules.rulesRegExp.lastIndex = this.nextMatch;
|
|
var ruleMatch = wikiTextRules.rulesRegExp.exec(this.source);
|
|
while(ruleMatch) {
|
|
// Output any text before the match
|
|
if(ruleMatch.index > this.nextMatch)
|
|
this.outputText(this.output,this.nextMatch,ruleMatch.index);
|
|
// Set the match parameters for the handler
|
|
this.matchStart = ruleMatch.index;
|
|
this.matchLength = ruleMatch[0].length;
|
|
this.matchText = ruleMatch[0];
|
|
this.nextMatch = wikiTextRules.rulesRegExp.lastIndex;
|
|
// Figure out which rule matched and call its handler
|
|
var t;
|
|
for(t=1; t<ruleMatch.length; t++) {
|
|
if(ruleMatch[t]) {
|
|
wikiTextRules.rules[t-1].handler(this);
|
|
wikiTextRules.rulesRegExp.lastIndex = this.nextMatch;
|
|
break;
|
|
}
|
|
}
|
|
// Get the next match
|
|
ruleMatch = wikiTextRules.rulesRegExp.exec(this.source);
|
|
}
|
|
// Output any text after the last match
|
|
if(this.nextMatch < this.source.length) {
|
|
this.outputText(this.output,this.nextMatch,this.source.length);
|
|
this.nextMatch = this.source.length;
|
|
}
|
|
// Restore the output pointer
|
|
this.output = oldOutput;
|
|
};
|
|
|
|
WikiTextParser.prototype.subWikifyTerm = function(output,terminatorRegExp) {
|
|
// subWikify can be indirectly recursive, so we need to save the old output pointer
|
|
var oldOutput = this.output;
|
|
this.output = output;
|
|
// Get the first matches for the rule and terminator RegExps
|
|
terminatorRegExp.lastIndex = this.nextMatch;
|
|
var terminatorMatch = terminatorRegExp.exec(this.source);
|
|
wikiTextRules.rulesRegExp.lastIndex = this.nextMatch;
|
|
var ruleMatch = wikiTextRules.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)) {
|
|
// Output any text before the match
|
|
if(terminatorMatch.index > this.nextMatch)
|
|
this.outputText(this.output,this.nextMatch,terminatorMatch.index);
|
|
// Set the match parameters
|
|
this.matchText = terminatorMatch[1];
|
|
this.matchLength = terminatorMatch[1].length;
|
|
this.matchStart = terminatorMatch.index;
|
|
this.nextMatch = this.matchStart + this.matchLength;
|
|
// Restore the output pointer
|
|
this.output = oldOutput;
|
|
return;
|
|
}
|
|
// It must be a rule match; output any text before the match
|
|
if(ruleMatch.index > this.nextMatch)
|
|
this.outputText(this.output,this.nextMatch,ruleMatch.index);
|
|
// Set the match parameters
|
|
this.matchStart = ruleMatch.index;
|
|
this.matchLength = ruleMatch[0].length;
|
|
this.matchText = ruleMatch[0];
|
|
this.nextMatch = wikiTextRules.rulesRegExp.lastIndex;
|
|
// Figure out which rule matched and call its handler
|
|
var t;
|
|
for(t=1; t<ruleMatch.length; t++) {
|
|
if(ruleMatch[t]) {
|
|
wikiTextRules.rules[t-1].handler(this);
|
|
wikiTextRules.rulesRegExp.lastIndex = this.nextMatch;
|
|
break;
|
|
}
|
|
}
|
|
// Get the next match
|
|
terminatorRegExp.lastIndex = this.nextMatch;
|
|
terminatorMatch = terminatorRegExp.exec(this.source);
|
|
ruleMatch = wikiTextRules.rulesRegExp.exec(terminatorMatch ? this.source.substr(0,terminatorMatch.index) : this.source);
|
|
}
|
|
// Output any text after the last match
|
|
if(this.nextMatch < this.source.length) {
|
|
this.outputText(this.output,this.nextMatch,this.source.length);
|
|
this.nextMatch = this.source.length;
|
|
}
|
|
// Restore the output pointer
|
|
this.output = oldOutput;
|
|
};
|
|
|
|
exports.WikiTextParser = WikiTextParser;
|