mirror of
https://github.com/Jermolene/TiddlyWiki5
synced 2024-12-30 20:10:28 +00:00
481 lines
15 KiB
JavaScript
Executable File
481 lines
15 KiB
JavaScript
Executable File
/*\
|
|
title: js/Recipe.js
|
|
|
|
Recipe processing is in four parts:
|
|
|
|
1) The recipe file is parsed and any subrecipe files loaded recursively into this structure:
|
|
|
|
this.recipe = [
|
|
{marker: <marker>, filepath: <filepath>, baseDir: <baseDir>},
|
|
...
|
|
{marker: <marker>, filepath: <filepath>, baseDir: <baseDir>},
|
|
[
|
|
{marker: <marker>, filepath: <filepath>, baseDir: <baseDir>},
|
|
...
|
|
{marker: <marker>, filepath: <filepath>, baseDir: <baseDir>},
|
|
]
|
|
];
|
|
|
|
2) The tiddler files referenced by the recipe structure are loaded into it as an additional 'tiddlers'
|
|
member that contains an array of hashmaps of tiddler field values.
|
|
|
|
3) The recipe is scanned to create a hashmap of markers and their associated tiddlers. In cases where more
|
|
than one tiddler with the same title is assigned to a marker, the one that is later in the recipe file wins.
|
|
At this point tiddlers are placed in the store so that they can be referenced by title
|
|
|
|
this.markers = {
|
|
<marker>: [<tiddler title>,<tiddler title>,...],
|
|
<marker>: [<tiddler title>,<tiddler title>,...],
|
|
...
|
|
}
|
|
|
|
4) Finally, to actually cook the recipe, the template is processed by replacing the markers with the text of the associated tiddlers
|
|
|
|
\*/
|
|
(function(){
|
|
|
|
/*jslint node: true */
|
|
"use strict";
|
|
|
|
var Tiddler = require("./Tiddler.js").Tiddler,
|
|
utils = require("./Utils.js"),
|
|
retrieveFile = require("./FileRetriever.js").retrieveFile,
|
|
fs = require("fs"),
|
|
path = require("path"),
|
|
util = require("util"),
|
|
async = require("async");
|
|
|
|
/*
|
|
Load a recipe file. Arguments are:
|
|
|
|
options: See below
|
|
callback: Function to be called when the recipe has been loaded as callback(err), null === success
|
|
|
|
Options include:
|
|
|
|
filepath: The filepath of the recipe file to load. Can be a local path or an HTTP URL
|
|
store: Indicates the WikiStore to use to store the tiddlers (mandatory)
|
|
|
|
*/
|
|
var Recipe = function(options,callback) {
|
|
var me = this;
|
|
this.filepath = options.filepath;
|
|
this.store = options.store;
|
|
this.callback = callback;
|
|
this.recipe = [];
|
|
this.markers = {};
|
|
// A task queue for loading recipe files
|
|
this.recipeQueue = async.queue(function(task,callback) {
|
|
retrieveFile(task.filepath,task.baseDir,function(err,data) {
|
|
if(err) {
|
|
me.callback(err);
|
|
} else {
|
|
callback(me.processRecipeFile(task.recipe,data.text,data.path));
|
|
}
|
|
});
|
|
},1);
|
|
// A task queue for loading tiddler files
|
|
this.tiddlerQueue = async.queue(function(task,callback) {
|
|
me.readTiddlerFile(task.filepath,task.baseDir,function(err,data) {
|
|
if(err) {
|
|
me.callback(err);
|
|
} else {
|
|
if(data.length === 0) {
|
|
callback("Tiddler file '" + task.filepath + "' does not contain any tiddlers");
|
|
} else {
|
|
if(task.recipeLine.fields) {
|
|
for(var t=0; t<data.length; t++) {
|
|
for(var f in task.recipeLine.fields) {
|
|
data[t][f] = task.recipeLine.fields[f];
|
|
}
|
|
}
|
|
}
|
|
if(!task.recipeLine.tiddlers) {
|
|
task.recipeLine.tiddlers = [];
|
|
}
|
|
Array.prototype.push.apply(task.recipeLine.tiddlers,data);
|
|
callback(null);
|
|
}
|
|
}
|
|
});
|
|
},1);
|
|
// Called when all the recipes have been loaded
|
|
this.recipeQueue.drain = function() {
|
|
// Initiate the loading of the tiddlers referenced by the recipe
|
|
for(var r=0; r<me.recipe.length; r++) {
|
|
me.loadTiddlerFiles(me.recipe[r]);
|
|
}
|
|
};
|
|
// Called when all the tiddlers have been loaded
|
|
this.tiddlerQueue.drain = function() {
|
|
// Select the tiddlers that are associated with each marker
|
|
me.chooseTiddlers(me.recipe);
|
|
// Sort the main content tiddlers (makes it easier to diff TiddlyWiki files)
|
|
me.sortTiddlersForMarker("tiddler");
|
|
me.callback(null);
|
|
};
|
|
// Start the process off by queueing up the loading of the initial recipe
|
|
this.recipeQueue.push({filepath: this.filepath,
|
|
baseDir: process.cwd(),
|
|
recipe: this.recipe});
|
|
};
|
|
|
|
/*
|
|
Recursively queue loading the tiddler files referenced by a recipe line
|
|
*/
|
|
Recipe.prototype.loadTiddlerFiles = function(recipeLine) {
|
|
var me = this;
|
|
if(recipeLine instanceof Array) {
|
|
for(var r=0; r<recipeLine.length; r++) {
|
|
me.loadTiddlerFiles(recipeLine[r]);
|
|
}
|
|
} else {
|
|
var filepath = recipeLine.filepath, // eg ../js/*.js
|
|
filedir = path.dirname(filepath), // eg ../js
|
|
filename = path.basename(filepath), // eg *.js
|
|
posStar = filename.indexOf("*");
|
|
if(posStar !== -1) {
|
|
var fileRegExp = new RegExp("^" + filename.replace(/[\-\[\]{}()+?.,\\\^$|#\s]/g, "\\$&").replace("*",".*") + "$");
|
|
var files = fs.readdirSync(path.resolve(recipeLine.baseDir,filedir));
|
|
for(var f=0; f<files.length; f++) {
|
|
if(fileRegExp.test(files[f])) {
|
|
me.tiddlerQueue.push({
|
|
filepath: filedir + "/" + files[f],
|
|
baseDir: recipeLine.baseDir,
|
|
recipeLine: recipeLine
|
|
});
|
|
}
|
|
}
|
|
} else {
|
|
me.tiddlerQueue.push({filepath: filepath, baseDir: recipeLine.baseDir, recipeLine: recipeLine});
|
|
}
|
|
}
|
|
};
|
|
|
|
/*
|
|
Choose the tiddlers to be included on each marker
|
|
*/
|
|
Recipe.prototype.chooseTiddlers = function(recipe) {
|
|
// Loop through the lines of the recipe
|
|
for(var r=0; r<recipe.length; r++) {
|
|
var recipeLine = recipe[r];
|
|
if(recipeLine instanceof Array) {
|
|
// Process subrecipes recursively
|
|
this.chooseTiddlers(recipeLine);
|
|
} else {
|
|
// Choose the store and marker array to be used for this marker
|
|
var store = recipeLine.marker === "shadow" ? this.store.shadows : this.store,
|
|
markerArray = this.markers[recipeLine.marker];
|
|
// Create the marker array if necessary
|
|
if(markerArray === undefined) {
|
|
this.markers[recipeLine.marker] = [];
|
|
markerArray = this.markers[recipeLine.marker];
|
|
}
|
|
// Process each of the tiddlers referenced by the recipe line
|
|
for(var t=0; t<recipeLine.tiddlers.length; t++) {
|
|
// Only add the tiddler to the marker if it isn't already there
|
|
var found = false;
|
|
for(var m=0; m<markerArray.length; m++) {
|
|
if(markerArray[m] === recipeLine.tiddlers[t].title) {
|
|
found = true;
|
|
}
|
|
}
|
|
if(!found) {
|
|
markerArray.push(recipeLine.tiddlers[t].title);
|
|
}
|
|
// Add the tiddler to the store
|
|
store.addTiddler(new Tiddler(recipeLine.tiddlers[t]));
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
/*
|
|
Sort the tiddlers associated with a particular marker
|
|
*/
|
|
Recipe.prototype.sortTiddlersForMarker = function(marker) {
|
|
if(this.markers[marker]) {
|
|
this.markers[marker].sort();
|
|
}
|
|
};
|
|
|
|
/*
|
|
Process the contents of a recipe file
|
|
recipe: a reference to the array in which to store the recipe contents
|
|
text: the text of the recipe file
|
|
recipePath: the full pathname used to reach the recipe file
|
|
The return value is `null` if the operation succeeded, or an error string if not
|
|
*/
|
|
Recipe.prototype.processRecipeFile = function(recipe,text,recipePath) {
|
|
var matchLine = function(linetext) {
|
|
var lineRegExp = /^(#?)(\s*)(#?)([^\s\:]+)\s*:\s*(.+)*\s*$/,
|
|
match = lineRegExp.exec(linetext);
|
|
return match ? {
|
|
comment: match[1] || match[3],
|
|
indent: match[2],
|
|
marker: match[4],
|
|
value: match[5]
|
|
} : null;
|
|
},
|
|
lines = text.split("\n"),
|
|
line = 0;
|
|
while(line < lines.length) {
|
|
var linetext = lines[line++],
|
|
match = matchLine(linetext);
|
|
if(match && !match.comment) {
|
|
if(match.indent.length > 0) {
|
|
return "Unexpected indentation in recipe file '" + recipePath + "'";
|
|
}
|
|
if(match.marker === "recipe") {
|
|
var insertionPoint = recipe.push([]) - 1;
|
|
this.recipeQueue.push({
|
|
filepath: match.value,
|
|
baseDir: path.dirname(recipePath),
|
|
recipe: recipe[insertionPoint]
|
|
});
|
|
} else {
|
|
var fieldLines = [],
|
|
fieldMatch = matchLine(lines[line]);
|
|
while(fieldMatch && fieldMatch.indent.length > 0) {
|
|
fieldLines.push(lines[line++]);
|
|
fieldMatch = matchLine(lines[line]);
|
|
}
|
|
var fields = {};
|
|
if(fieldLines.length > 0) {
|
|
fields = this.store.deserializeTiddlers("application/x-tiddler",fieldLines.join("\n"),{})[0];
|
|
}
|
|
recipe.push({
|
|
marker: match.marker,
|
|
filepath: match.value,
|
|
baseDir: path.dirname(recipePath),
|
|
fields: fields});
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
|
|
/*
|
|
Read a tiddler file and callback with an array of hashmaps of tiddler fields. For single
|
|
tiddler files it also looks for an accompanying .meta file
|
|
filepath: the filepath to the tiddler file (possibly relative)
|
|
baseDir: the base directory from which the filepath is taken
|
|
callback: called on completion as callback(err,data) where data is an array of tiddler fields
|
|
*/
|
|
Recipe.prototype.readTiddlerFile = function(filepath,baseDir,callback) {
|
|
var me = this;
|
|
// Read the tiddler file
|
|
retrieveFile(filepath,baseDir,function(err,data) {
|
|
if (err) {
|
|
callback(err);
|
|
return;
|
|
}
|
|
// Use the filepath as the default title for the tiddler
|
|
var fields = {
|
|
title: data.path
|
|
};
|
|
var tiddlers = me.store.deserializeTiddlers(data.extname,data.text,fields);
|
|
// Check for the .meta file
|
|
if(data.extname !== ".json" && tiddlers.length === 1) {
|
|
var metafile = filepath + ".meta";
|
|
retrieveFile(metafile,baseDir,function(err,data) {
|
|
if(err && err.code !== "ENOENT" && err.code !== "404") {
|
|
callback(err);
|
|
} else {
|
|
var fields = tiddlers[0];
|
|
if(!err) {
|
|
var text = data.text.split("\n\n")[0];
|
|
if(text) {
|
|
fields = me.store.deserializeTiddlers("application/x-tiddler",text,fields)[0];
|
|
}
|
|
}
|
|
callback(null,[fields]);
|
|
}
|
|
});
|
|
} else {
|
|
callback(null,tiddlers);
|
|
}
|
|
});
|
|
};
|
|
|
|
// Return a string of the cooked recipe
|
|
Recipe.prototype.cook = function() {
|
|
var template = this.markers.template ? this.store.getTiddlerText(this.markers.template[0]) : "",
|
|
out = [],
|
|
templateLines = template.split("\n");
|
|
for(var line=0; line<templateLines.length; line++) {
|
|
var templateRegExp = /^(?:<!--@@(.*)@@-->)|(?:<!--@@(.*)@@-->)$/gi;
|
|
var match = templateRegExp.exec(templateLines[line]);
|
|
if(match) {
|
|
var marker = match[1] === undefined ? match[2] : match[1];
|
|
this.outputTiddlersForMarker(out,marker);
|
|
} else {
|
|
if(line !== templateLines.length-1) {
|
|
out.push(templateLines[line],"\n");
|
|
}
|
|
}
|
|
}
|
|
return out.join("");
|
|
};
|
|
|
|
// Output all the tiddlers in the recipe with a particular marker
|
|
Recipe.prototype.outputTiddlersForMarker = function(out,marker) {
|
|
var tiddlers = this.markers[marker],
|
|
outputType = Recipe.tiddlerOutputMapper[marker] || "raw",
|
|
outputter = Recipe.tiddlerOutputter[outputType];
|
|
if(!tiddlers) {
|
|
tiddlers = [];
|
|
}
|
|
if(outputter) {
|
|
if((out.length > 1) && (Recipe.compatibilityCheats[marker] === "suppressLeadingNewline")) {
|
|
var lastLine = out[out.length-1];
|
|
if(lastLine.substr(-1) === "\n") {
|
|
out[out.length-1] = lastLine.substr(0,lastLine.length-1);
|
|
}
|
|
}
|
|
outputter.call(this,out,tiddlers);
|
|
if(Recipe.compatibilityCheats[marker] === "addTrailingNewline") {
|
|
out.push("\n");
|
|
}
|
|
}
|
|
};
|
|
|
|
// Allows for specialised processing for certain markers
|
|
Recipe.tiddlerOutputMapper = {
|
|
tiddler: "div",
|
|
js: "javascript",
|
|
jslib: "javascript",
|
|
jsdeprecated: "javascript",
|
|
jquery: "javascript",
|
|
shadow: "shadow",
|
|
title: "title",
|
|
jsmodule: "jsmodule"
|
|
};
|
|
|
|
Recipe.compatibilityCheats = {
|
|
"prehead": "addTrailingNewline",
|
|
"posthead": "addTrailingNewline",
|
|
"prebody": "addTrailingNewline",
|
|
"postscript": "addTrailingNewline",
|
|
"title": "suppressLeadingNewline"
|
|
};
|
|
|
|
Recipe.tiddlerOutputter = {
|
|
raw: function(out,tiddlers) {
|
|
// The default is just to output the raw text of the tiddler, ignoring any metadata
|
|
for(var t=0; t<tiddlers.length; t++) {
|
|
out.push(this.store.getTiddlerText(tiddlers[t]));
|
|
}
|
|
},
|
|
div: function(out,tiddlers) {
|
|
// Ordinary tiddlers are output as a <DIV>
|
|
for(var t=0; t<tiddlers.length; t++) {
|
|
var tid = this.store.getTiddler(tiddlers[t]);
|
|
out.push(this.store.serializeTiddler("application/x-tiddler-html-div",tid),"\n");
|
|
}
|
|
},
|
|
javascript: function(out,tiddlers) {
|
|
// Lines starting with //# are removed from javascript tiddlers
|
|
for(var t=0; t<tiddlers.length; t++) {
|
|
var tid = this.store.getTiddler(tiddlers[t]),
|
|
text = tid.text;
|
|
var lines = text.split("\n");
|
|
for(var line=0; line<lines.length; line++) {
|
|
var commentRegExp = /^\s*\/\/#/gi;
|
|
if(!commentRegExp.test(lines[line])) {
|
|
out.push(lines[line]);
|
|
if(line !== lines.length-1) {
|
|
out.push("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
shadow: function(out,tiddlers) {
|
|
for(var t=0; t<tiddlers.length; t++) {
|
|
var title = tiddlers[t],
|
|
tid = this.store.shadows.getTiddler(title);
|
|
out.push(this.store.serializeTiddler("application/x-tiddler-html-div",tid),"\n");
|
|
}
|
|
},
|
|
title: function(out,tiddlers) {
|
|
out.push(" ",this.store.renderTiddler("text/plain","WindowTitle")," ");
|
|
},
|
|
jsmodule: function(out,tiddlers) {
|
|
// JavaScript modules are output as a special script tag
|
|
for(var t=0; t<tiddlers.length; t++) {
|
|
var title = tiddlers[t],
|
|
tid = this.store.getTiddler(title);
|
|
out.push("<" + "script type=\"application/javascript\">");
|
|
out.push("define(\"" + title + "\",function(require,exports,module) {");
|
|
out.push(tid.text);
|
|
out.push("});");
|
|
out.push("</" + "script>");
|
|
}
|
|
}
|
|
};
|
|
|
|
// Cook an RSS file of the most recent 20 tiddlers
|
|
Recipe.prototype.cookRss = function() {
|
|
var me = this,
|
|
numRssItems = 20,
|
|
s = [],
|
|
d = new Date(),
|
|
u = this.store.renderTiddler("text/plain","SiteUrl"),
|
|
encodeTiddlyLink = function(title) {
|
|
return title.indexOf(" ") == -1 ? title : "[[" + title + "]]";
|
|
},
|
|
tiddlerToRssItem = function(tiddler,uri) {
|
|
var s = "<title" + ">" + utils.htmlEncode(tiddler.title) + "</title" + ">\n";
|
|
s += "<description>" + utils.htmlEncode(me.store.renderTiddler("text/html",tiddler.title)) + "</description>\n";
|
|
var i;
|
|
if(tiddler.tags) {
|
|
for(i=0; i<tiddler.tags.length; i++) {
|
|
s += "<category>" + tiddler.tags[i] + "</category>\n";
|
|
}
|
|
}
|
|
s += "<link>" + uri + "#" + encodeURIComponent(encodeTiddlyLink(tiddler.title)) + "</link>\n";
|
|
if(tiddler.modified) {
|
|
s +="<pubDate>" + tiddler.modified.toUTCString() + "</pubDate>\n";
|
|
}
|
|
return s;
|
|
},
|
|
getRssTiddlers = function(sortField,excludeTag) {
|
|
var r = [];
|
|
me.store.forEachTiddler(sortField,excludeTag,function(title,tiddler) {
|
|
if(!tiddler.hasTag(excludeTag) && tiddler.modified !== undefined) {
|
|
r.push(tiddler);
|
|
}
|
|
});
|
|
return r;
|
|
};
|
|
// Assemble the header
|
|
s.push("<" + "?xml version=\"1.0\"?" + ">");
|
|
s.push("<rss version=\"2.0\">");
|
|
s.push("<channel>");
|
|
s.push("<title" + ">" + utils.htmlEncode(this.store.renderTiddler("text/plain","SiteTitle")) + "</title" + ">");
|
|
if(u)
|
|
s.push("<link>" + utils.htmlEncode(u) + "</link>");
|
|
s.push("<description>" + utils.htmlEncode(this.store.renderTiddler("text/plain","SiteSubtitle")) + "</description>");
|
|
//s.push("<language>" + config.locale + "</language>");
|
|
s.push("<pubDate>" + d.toUTCString() + "</pubDate>");
|
|
s.push("<lastBuildDate>" + d.toUTCString() + "</lastBuildDate>");
|
|
s.push("<docs>http://blogs.law.harvard.edu/tech/rss</docs>");
|
|
s.push("<generator>https://github.com/Jermolene/cook.js</generator>");
|
|
// The body
|
|
var tiddlers = getRssTiddlers("modified","excludeLists");
|
|
var i,n = numRssItems > tiddlers.length ? 0 : tiddlers.length-numRssItems;
|
|
for(i=tiddlers.length-1; i>=n; i--) {
|
|
s.push("<item>\n" + tiddlerToRssItem(tiddlers[i],u) + "\n</item>");
|
|
}
|
|
// And footer
|
|
s.push("</channel>");
|
|
s.push("</rss>");
|
|
// Save it all
|
|
return s.join("\n");
|
|
};
|
|
|
|
exports.Recipe = Recipe;
|
|
|
|
})();
|