tiddlywiki 5.3.8 → 5.4.0

package/core/wiki/viewswitcher.tid

@@ -4,13 +4,14 @@ title: $:/snippets/viewswitcher
 $:/core/images/storyview-$(storyview)$
 \end
 \whitespace trim
+\function view.filter() [<storyview>prefix{$:/view}]
+
 <$linkcatcher to="$:/view">
-<div class="tc-chooser tc-viewswitcher">
+<div class="tc-chooser tc-viewswitcher" role="listbox">
 <$list filter="[storyviews[]]" variable="storyview">
-<$set name="cls" filter="[<storyview>prefix{$:/view}]" value="tc-chooser-item tc-chosen" emptyValue="tc-chooser-item"><div class=<<cls>>>
-<$button tag="a" class="tc-tiddlylink tc-btn-invisible" to=<<storyview>>><$transclude tiddler=<<icon>>/><$text text=<<storyview>>/></$button>
+<div class={{{ [view.filter[]then[tc-chooser-item tc-chosen]else[tc-chooser-item]] }}}>
+<$button tag="a" class="tc-tiddlylink tc-btn-invisible" role="option" to=<<storyview>> aria-selected={{{ [view.filter[]then[true]else[false]] }}}><$transclude tiddler=<<icon>>/><$text text=<<storyview>>/></$button>
 </div>
-</$set>
 </$list>
 </div>
 </$linkcatcher>

package/core-server/commander.js

@@ -0,0 +1,176 @@
+/*\
+title: $:/core/modules/commander.js
+type: application/javascript
+module-type: global
+
+The $tw.Commander class is a command interpreter
+
+\*/
+
+"use strict";
+
+/*
+Parse a sequence of commands
+	commandTokens: an array of command string tokens
+	wiki: reference to the wiki store object
+	streams: {output:, error:}, each of which has a write(string) method
+	callback: a callback invoked as callback(err) where err is null if there was no error
+*/
+var Commander = function(commandTokens,callback,wiki,streams) {
+	var path = require("path");
+	this.commandTokens = commandTokens;
+	this.nextToken = 0;
+	this.callback = callback;
+	this.wiki = wiki;
+	this.streams = streams;
+	this.outputPath = path.resolve($tw.boot.wikiPath,$tw.config.wikiOutputSubDir);
+};
+
+/*
+Log a string if verbose flag is set
+*/
+Commander.prototype.log = function(str) {
+	if(this.verbose) {
+		this.streams.output.write(str + "\n");
+	}
+};
+
+/*
+Write a string if verbose flag is set
+*/
+Commander.prototype.write = function(str) {
+	if(this.verbose) {
+		this.streams.output.write(str);
+	}
+};
+
+/*
+Add a string of tokens to the command queue
+*/
+Commander.prototype.addCommandTokens = function(commandTokens) {
+	var params = commandTokens.slice(0);
+	params.unshift(0);
+	params.unshift(this.nextToken);
+	Array.prototype.splice.apply(this.commandTokens,params);
+};
+
+/*
+Execute the sequence of commands and invoke a callback on completion
+*/
+Commander.prototype.execute = function() {
+	this.executeNextCommand();
+};
+
+/*
+Execute the next command in the sequence
+*/
+Commander.prototype.executeNextCommand = function() {
+	var self = this;
+	// Invoke the callback if there are no more commands
+	if(this.nextToken >= this.commandTokens.length) {
+		this.callback(null);
+	} else {
+		// Get and check the command token
+		var commandName = this.commandTokens[this.nextToken++];
+		if(commandName.substr(0,2) !== "--") {
+			this.callback("Missing command: " + commandName);
+		} else {
+			commandName = commandName.substr(2); // Trim off the --
+			// Accumulate the parameters to the command
+			var params = [];
+			while(this.nextToken < this.commandTokens.length && 
+				this.commandTokens[this.nextToken].substr(0,2) !== "--") {
+				params.push(this.commandTokens[this.nextToken++]);
+			}
+			// Get the command info
+			var command = $tw.commands[commandName],
+				c,err;
+			if(!command) {
+				this.callback("Unknown command: " + commandName);
+			} else {
+				if(this.verbose) {
+					this.streams.output.write("Executing command: " + commandName + " " + params.join(" ") + "\n");
+				}
+				// Parse named parameters if required
+				if(command.info.namedParameterMode) {
+					params = this.extractNamedParameters(params,command.info.mandatoryParameters);
+					if(typeof params === "string") {
+						return this.callback(params);
+					}
+				}
+				if(command.info.synchronous) {
+					// Synchronous command (await thenables)
+					c = new command.Command(params,this);
+					err = c.execute();
+					if(err && typeof err.then === "function") {
+						err.then((e) => { e ? this.callback(e) : this.executeNextCommand(); });
+					} else if(err) {
+						this.callback(err);
+					} else {
+						this.executeNextCommand();
+					}
+				} else {
+					// Asynchronous command (await thenables)
+					c = new command.Command(params,this,function(err) {
+						if(err) {
+							self.callback(err);
+						} else {
+							self.executeNextCommand();
+						}
+					});
+					err = c.execute();
+					if(err && typeof err.then === "function") {
+						err.then((e) => { if(e) this.callback(e); });
+					} else if(err) {
+						this.callback(err);
+					}
+				}
+			}
+		}
+	}
+};
+
+/*
+Given an array of parameter strings `params` in name:value format, and an array of mandatory parameter names in `mandatoryParameters`, returns a hashmap of values or a string if error
+*/
+Commander.prototype.extractNamedParameters = function(params,mandatoryParameters) {
+	mandatoryParameters = mandatoryParameters || [];
+	var errors = [],
+		paramsByName = Object.create(null);
+	// Extract the parameters
+	$tw.utils.each(params,function(param) {
+		var index = param.indexOf("=");
+		if(index < 1) {
+			errors.push("malformed named parameter: '" + param + "'");
+		}
+		paramsByName[param.slice(0,index)] = $tw.utils.trim(param.slice(index+1));
+	});
+	// Check the mandatory parameters are present
+	$tw.utils.each(mandatoryParameters,function(mandatoryParameter) {
+		if(!$tw.utils.hop(paramsByName,mandatoryParameter)) {
+			errors.push("missing mandatory parameter: '" + mandatoryParameter + "'");
+		}
+	});
+	// Return any errors
+	if(errors.length > 0) {
+		return errors.join(" and\n");
+	} else {
+		return paramsByName;
+	}
+};
+
+Commander.initCommands = function(moduleType) {
+	moduleType = moduleType || "command";
+	$tw.commands = {};
+	$tw.modules.forEachModuleOfType(moduleType,function(title,module) {
+		var c = $tw.commands[module.info.name] = {};
+		// Add the methods defined by the module
+		for(var f in module) {
+			if($tw.utils.hop(module,f)) {
+				c[f] = module[f];
+			}
+		}
+	});
+};
+
+exports.Commander = Commander;

package/core-server/commands/commands.js

@@ -0,0 +1,36 @@
+/*\
+title: $:/core/modules/commands/commands.js
+type: application/javascript
+module-type: command
+
+Runs the commands returned from a filter
+
+\*/
+
+"use strict";
+
+exports.info = {
+	name: "commands",
+	synchronous: true
+};
+
+var Command = function(params, commander) {
+	this.params = params;
+	this.commander = commander;
+};
+
+Command.prototype.execute = function() {
+	// Parse the filter
+	var filter = this.params[0];
+	if(!filter) {
+		return "No filter specified";
+	}
+	var commands = this.commander.wiki.filterTiddlers(filter);
+	if(commands.length === 0) {
+		return "No tiddlers found for filter '" + filter + "'";
+	}
+	this.commander.addCommandTokens(commands);
+	return null;
+};
+
+exports.Command = Command;

package/core-server/commands/deletetiddlers.js

@@ -0,0 +1,36 @@
+/*\
+title: $:/core/modules/commands/deletetiddlers.js
+type: application/javascript
+module-type: command
+
+Command to delete tiddlers
+
+\*/
+
+"use strict";
+
+exports.info = {
+	name: "deletetiddlers",
+	synchronous: true
+};
+
+var Command = function(params,commander,callback) {
+	this.params = params;
+	this.commander = commander;
+	this.callback = callback;
+};
+
+Command.prototype.execute = function() {
+	if(this.params.length < 1) {
+		return "Missing filter";
+	}
+	var wiki = this.commander.wiki,
+		filter = this.params[0],
+		tiddlers = wiki.filterTiddlers(filter);
+	$tw.utils.each(tiddlers,function(title) {
+		wiki.deleteTiddler(title);
+	});
+	return null;
+};
+
+exports.Command = Command;

package/core-server/commands/fetch.js

@@ -0,0 +1,170 @@
+/*\
+title: $:/core/modules/commands/fetch.js
+type: application/javascript
+module-type: command
+
+Commands to fetch external tiddlers
+
+\*/
+
+"use strict";
+
+exports.info = {
+	name: "fetch",
+	synchronous: false
+};
+
+var Command = function(params,commander,callback) {
+	this.params = params;
+	this.commander = commander;
+	this.callback = callback;
+};
+
+Command.prototype.execute = function() {
+	if(this.params.length < 2) {
+		return "Missing subcommand and url";
+	}
+	switch(this.params[0]) {
+		case "raw-file":
+			return this.fetchFiles({
+				raw: true,
+				url: this.params[1],
+				transformFilter: this.params[2] || "",
+				callback: this.callback
+			});
+			break;
+		case "file":
+			return this.fetchFiles({
+				url: this.params[1],
+				importFilter: this.params[2],
+				transformFilter: this.params[3] || "",
+				callback: this.callback
+			});
+			break;
+		case "raw-files":
+			return this.fetchFiles({
+				raw: true,
+				urlFilter: this.params[1],
+				transformFilter: this.params[2] || "",
+				callback: this.callback
+			});
+			break;
+		case "files":
+			return this.fetchFiles({
+				urlFilter: this.params[1],
+				importFilter: this.params[2],
+				transformFilter: this.params[3] || "",
+				callback: this.callback
+			});
+			break;
+	}
+	return null;
+};
+
+Command.prototype.fetchFiles = function(options) {
+	var self = this;
+	// Get the list of URLs
+	var urls;
+	if(options.url) {
+		urls = [options.url];
+	} else if(options.urlFilter) {
+		urls = this.commander.wiki.filterTiddlers(options.urlFilter);
+	} else {
+		return "Missing URL";
+	}
+	// Process each URL in turn
+	var next = 0;
+	var getNextFile = function(err) {
+		if(err) {
+			return options.callback(err);
+		}
+		if(next < urls.length) {
+			self.fetchFile(urls[next++],options,getNextFile);
+		} else {
+			options.callback(null);
+		}
+	};
+	getNextFile(null);
+	// Success
+	return null;
+};
+
+Command.prototype.fetchFile = function(url,options,callback,redirectCount) {
+	if(redirectCount > 10) {
+		return callback("Error too many redirects retrieving " + url);
+	}
+	var self = this,
+		lib = url.substr(0,8) === "https://" ? require("https") : require("http");
+	lib.get(url).on("response",function(response) {
+		var type = (response.headers["content-type"] || "").split(";")[0],
+			data = [];
+		self.commander.write("Reading " + url + ": ");
+		response.on("data",function(chunk) {
+			data.push(chunk);
+			self.commander.write(".");
+		});
+		response.on("end",function() {
+			self.commander.write("\n");
+			if(response.statusCode === 200) {
+				self.processBody(Buffer.concat(data),type,options,url);
+				callback(null);
+			} else {
+				if(response.statusCode === 302 || response.statusCode === 303 || response.statusCode === 307) {
+					return self.fetchFile(response.headers.location,options,callback,redirectCount + 1);
+				} else {
+					return callback("Error " + response.statusCode + " retrieving " + url);
+				}
+			}
+		});
+		response.on("error",function(e) {
+			console.log("Error on GET request: " + e);
+			callback(e);
+		});
+	});
+	return null;
+};
+
+Command.prototype.processBody = function(body,type,options,url) {
+	var self = this;
+	// Collect the tiddlers in a wiki
+	var incomingWiki = new $tw.Wiki();
+	if(options.raw) {
+		var typeInfo = type ? $tw.config.contentTypeInfo[type] : null,
+			encoding = typeInfo ? typeInfo.encoding : "utf8";
+		incomingWiki.addTiddler(new $tw.Tiddler({
+			title: url,
+			type: type,
+			text: body.toString(encoding)
+		}));
+	} else {
+		// Deserialise the file to extract the tiddlers
+		var tiddlers = this.commander.wiki.deserializeTiddlers(type || "text/html",body.toString("utf8"),{});
+		$tw.utils.each(tiddlers,function(tiddler) {
+			incomingWiki.addTiddler(new $tw.Tiddler(tiddler));
+		});
+	}
+	// Filter the tiddlers to select the ones we want
+	var filteredTitles = incomingWiki.filterTiddlers(options.importFilter || "[all[tiddlers]]");
+	// Import the selected tiddlers
+	var count = 0;
+	incomingWiki.each(function(tiddler,title) {
+		if(filteredTitles.indexOf(title) !== -1) {
+			var newTiddler;
+			if(options.transformFilter) {
+				var transformedTitle = (incomingWiki.filterTiddlers(options.transformFilter,null,self.commander.wiki.makeTiddlerIterator([title])) || [""])[0];
+				if(transformedTitle) {
+					self.commander.log("Importing " + title + " as " + transformedTitle);
+					newTiddler = new $tw.Tiddler(tiddler,{title: transformedTitle});
+				}
+			} else {
+				self.commander.log("Importing " + title);
+				newTiddler = tiddler;
+			}
+			self.commander.wiki.importTiddler(newTiddler);
+			count++;
+		}
+	});
+	self.commander.log("Imported " + count + " tiddlers");
+};
+
+exports.Command = Command;

package/core-server/commands/import.js

@@ -0,0 +1,42 @@
+/*\
+title: $:/core/modules/commands/import.js
+type: application/javascript
+module-type: command
+
+Command to import tiddlers from a file
+
+\*/
+
+"use strict";
+
+exports.info = {
+	name: "import",
+	synchronous: true
+};
+
+var Command = function(params,commander,callback) {
+	this.params = params;
+	this.commander = commander;
+	this.callback = callback;
+};
+
+Command.prototype.execute = function() {
+	var self = this,
+		fs = require("fs");
+	if(this.params.length < 2) {
+		return "Missing parameters";
+	}
+	var filename = self.params[0],
+		deserializer = self.params[1],
+		title = self.params[2] || filename,
+		encoding = self.params[3] || "utf8",
+		text = fs.readFileSync(filename,encoding),
+		tiddlers = this.commander.wiki.deserializeTiddlers(null,text,{title: title},{deserializer: deserializer});
+	$tw.utils.each(tiddlers,function(tiddler) {
+		self.commander.wiki.importTiddler(new $tw.Tiddler(tiddler));
+	});
+	this.commander.log(tiddlers.length + " tiddler(s) imported");
+	return null;
+};
+
+exports.Command = Command;

package/core-server/commands/init.js

@@ -0,0 +1,53 @@
+/*\
+title: $:/core/modules/commands/init.js
+type: application/javascript
+module-type: command
+
+Command to initialise an empty wiki folder
+
+\*/
+
+"use strict";
+
+exports.info = {
+	name: "init",
+	synchronous: true
+};
+
+var Command = function(params,commander) {
+	this.params = params;
+	this.commander = commander;
+};
+
+Command.prototype.execute = function() {
+	var fs = require("fs");
+	// Check that we don't already have a valid wiki folder
+	if($tw.boot.wikiTiddlersPath || ($tw.utils.isDirectory($tw.boot.wikiPath) && !$tw.utils.isDirectoryEmpty($tw.boot.wikiPath))) {
+		return "Wiki folder is not empty";
+	}
+	// Loop through each of the specified editions
+	var editions = this.params.length > 0 ? this.params : ["empty"];
+	for(var editionIndex=0; editionIndex<editions.length; editionIndex++) {
+		var editionName = editions[editionIndex];
+		// Check the edition exists
+		var editionPath = $tw.findLibraryItem(editionName,$tw.getLibraryItemSearchPaths($tw.config.editionsPath,$tw.config.editionsEnvVar));
+		if(!$tw.utils.isDirectory(editionPath)) {
+			return "Edition '" + editionName + "' not found";
+		}
+		// Copy the edition content
+		var err = $tw.utils.copyDirectory(editionPath,$tw.boot.wikiPath);
+		if(!err) {
+			this.commander.streams.output.write("Copied edition '" + editionName + "' to " + $tw.boot.wikiPath + "\n");
+		} else {
+			return err;
+		}
+	}
+	// Tweak the tiddlywiki.info to remove any included wikis
+	var packagePath = $tw.boot.wikiPath + "/tiddlywiki.info",
+		packageJson = $tw.utils.parseJSONSafe(fs.readFileSync(packagePath));
+	delete packageJson.includeWikis;
+	fs.writeFileSync(packagePath,JSON.stringify(packageJson,null,$tw.config.preferences.jsonSpaces));
+	return null;
+};
+
+exports.Command = Command;

package/core-server/commands/listen.js

@@ -0,0 +1,42 @@
+/*\
+title: $:/core/modules/commands/listen.js
+type: application/javascript
+module-type: command
+
+Listen for HTTP requests and serve tiddlers
+
+\*/
+
+"use strict";
+
+var Server = require("$:/core/modules/server/server.js").Server;
+
+exports.info = {
+	name: "listen",
+	synchronous: true,
+	namedParameterMode: true,
+	mandatoryParameters: []
+};
+
+var Command = function(params,commander,callback) {
+	this.params = params;
+	this.commander = commander;
+	this.callback = callback;
+};
+
+Command.prototype.execute = function() {
+	var self = this;
+	if(!$tw.boot.wikiTiddlersPath) {
+		$tw.utils.warning("Warning: Wiki folder '" + $tw.boot.wikiPath + "' does not exist or is missing a tiddlywiki.info file");
+	}
+	// Set up server
+	this.server = new Server({
+		wiki: this.commander.wiki,
+		variables: self.params
+	});
+	var nodeServer = this.server.listen();
+	$tw.hooks.invokeHook("th-server-command-post-start",this.server,nodeServer,"tiddlywiki");
+	return null;
+};
+
+exports.Command = Command;

package/core-server/commands/load.js

@@ -0,0 +1,44 @@
+/*\
+title: $:/core/modules/commands/load.js
+type: application/javascript
+module-type: command
+
+Command to load tiddlers from a file or directory
+
+\*/
+
+"use strict";
+
+exports.info = {
+	name: "load",
+	synchronous: false
+};
+
+var Command = function(params,commander,callback) {
+	this.params = params;
+	this.commander = commander;
+	this.callback = callback;
+};
+
+Command.prototype.execute = function() {
+	var self = this;
+	if(this.params.length < 1) {
+		return "Missing filename";
+	}
+	var tiddlers = $tw.loadTiddlersFromPath(self.params[0]),
+		count = 0;
+	$tw.utils.each(tiddlers,function(tiddlerInfo) {
+		$tw.utils.each(tiddlerInfo.tiddlers,function(tiddler) {
+			self.commander.wiki.importTiddler(new $tw.Tiddler(tiddler));
+			count++;
+		});
+	});
+	if(!count && self.params[1] !== "noerror") {
+		self.callback("No tiddlers found in file \"" + self.params[0] + "\"");
+	} else {
+		self.callback(null);
+	}
+	return null;
+};
+
+exports.Command = Command;

package/core-server/commands/output.js

@@ -0,0 +1,32 @@
+/*\
+title: $:/core/modules/commands/output.js
+type: application/javascript
+module-type: command
+
+Command to set the default output location (defaults to current working directory)
+
+\*/
+
+"use strict";
+
+exports.info = {
+	name: "output",
+	synchronous: true
+};
+
+var Command = function(params,commander,callback) {
+	this.params = params;
+	this.commander = commander;
+	this.callback = callback;
+};
+
+Command.prototype.execute = function() {
+	var path = require("path");
+	if(this.params.length < 1) {
+		return "Missing output path";
+	}
+	this.commander.outputPath = path.resolve(process.cwd(),this.params[0]);
+	return null;
+};
+
+exports.Command = Command;