TiddlyWiki5/js/Recipe.js

483 wiersze
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];
}
if(recipeLine.tiddlers) {
// 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 = /^(?:<!--@@(.*)@@-->)|(?:&lt;!--@@(.*)@@--&gt;)$/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\" data-tiddler-title=\"" + title + "\">");
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;
})();