tw5-graph 1.7.1

package/plugins/graph/propertytypes/image.js

@@ -0,0 +1,185 @@
+/*\
+
+Defines images types, and manages fetching a url from titles.
+
+\*/
+
+"use strict";
+
+var Color = require("./color.js");
+
+exports.name = "image";
+
+exports.type = "title";
+
+exports.toProperty = function(info, value, options) {
+	var parentWidget = options.widget;
+	var wiki = parentWidget.wiki;
+	var widget = parentWidget.imageWidget;
+	if (!wiki.tiddlerExists(value) && !wiki.isShadowTiddler(value)) {
+		// It's a tiddler. It must be a literal link to an external source.
+		return value;
+	}
+	if (!widget) {
+		var parser = wiki.getCacheForTiddler(value, "graphImageParser", function() {
+			return getImageParser(value, wiki);
+		});
+		widget = wiki.makeWidget(parser, {parentWidget: parentWidget});
+		widget.typeInfo = parser.typeInfo;
+		parentWidget.imageWidget = widget;
+	}
+	if (!widget.uri) {
+		var widget = parentWidget.imageWidget;
+		var container = $tw.fakeDocument.createElement("div");
+		var typeInfo = widget.typeInfo;
+		var url, svg;
+		widget.render(container, null);
+		if (!widget.typeInfo) {
+			// Probably just a literal link to an external image
+			url = container.innerHTML;
+		} else if (typeInfo.encoding === "base64") {
+			// .pdf .png .jpg etc.
+			url = "data:" + (typeInfo.deserializerType || "utf8") + ";base64," + container.innerHTML;
+		} else if (svg = findSVGElement(container)) {
+			// wikitext-based SVG?
+			//data = "data:" + deserializerType + ";" + encoding + "," + encodeURIComponent(text);
+			injectNamespace(svg);
+			var style = getStyle(info, parentWidget);
+			injectStyle(svg, style);
+			var encoding = "";
+			if(wiki.isImageTiddler(value)) {
+				encoding = ";utf8";
+			}
+			url = "data:image/svg+xml" + encoding + "," + encodeURIComponent(container.innerHTML);
+		} else {
+			url = null;
+		}
+		widget.url = url;
+	}
+	return parentWidget.imageWidget.url;
+};
+
+exports.refresh = function(info, value, changedTiddlers, widget) {
+	if (changedTiddlers[value]) {
+		widget.imageWidget = undefined;
+		return true;
+	}
+	if (!widget.imageWidget) {
+		return true;
+	}
+	if (widget.imageWidget.refresh(changedTiddlers)) {
+		widget.imageWidget.uri = undefined;
+		return true;
+	}
+	// Now we need to check whether any property-dependent styles for the
+	// image have changed.
+	return refreshStyle(info, widget, changedTiddlers);
+};
+
+function getImageParser(title, wiki) {
+	var parser;
+	var typeInfo;
+	// Check if it is an image tiddler
+	if(wiki.isImageTiddler(title)) {
+		var tiddler = wiki.getTiddler(title),
+			type = tiddler.fields.type,
+			text = tiddler.fields.text,
+			data;
+		typeInfo = $tw.config.contentTypeInfo[type] || {};
+		if(text) {
+			var encoding = typeInfo.encoding || "utf8";
+			if (encoding === "base64") {
+				parser = { tree: [{
+					type: "text",
+					attributes: { text: {type: "string", value: text} }
+				}]};
+			} else {
+				// It's an xml svg probably. We still need to parse it into
+				// a DOM tree for manipulation.
+				text = text.replace(/^<\?[^?]*\?>/, "");
+				// Also remove DOCTYPE declarations
+				text = text.replace(/^\s*<!DOCTYPE\s[^>]*>/, "");
+				parser = wiki.parseText("text/vnd.tiddlywiki", "\\rules only html commentinline commentblock\n" + text, {parseAsInline: true});
+			}
+			//deserializerType = typeInfo.deserializerType || type;
+			// Render the appropriate element for the image type by
+			// looking up the encoding in the content type info
+		} else if(tiddler.fields._canonical_uri) {
+			parser = {
+				tree: [{
+					type: "text",
+					attributes: { text: {type: "string", value: tiddler.fields._canonical_uri} }
+			}]};
+			// It's a link. We don't need to describe type info
+			typeInfo = null;
+		} else {
+			// This must be a lazily loaded tiddler. We don't support those yet.
+			text = null;
+		}
+	} else if (wiki.tiddlerExists(title) || wiki.isShadowTiddler(title)) {
+		// We assume it is wikitext trying to make an svg
+		parser = wiki.parseTiddler(title, {parseAsInline: true});
+		typeInfo = $tw.config.contentTypeInfo["image/svg+xml"];
+	} else {
+		parser = { tree: [{
+			type: "text",
+			attributes: { text: {type: "string", value: title} }
+		}]};
+	}
+	parser.typeInfo = typeInfo;
+	return parser;
+};
+
+function findSVGElement(element) {
+	if (element.tag === "svg") {
+		return element;
+	}
+	if (element.children) {
+		for (var i = 0; i < element.children.length; i++) {
+			var found = findSVGElement(element.children[i]);
+			if (found) {
+				return found;
+			}
+		}
+	}
+	return null;
+};
+
+function getStyle(info, objectWidget) {
+	if (!info.style) {
+		return "";
+	}
+	var styleParts = [];
+	for (var attribute in info.style) {
+		var key = info.style[attribute];
+		var styleValue = objectWidget.evaluateProperty(key);
+		if (styleValue) {
+			// probably "fill:color", but any kind of css styling is allowed.
+			styleParts.push(attribute + ":" + styleValue + ";");
+		}
+	}
+	return styleParts.length > 0? ":root{" + styleParts.join("") + "}": "";
+};
+
+function refreshStyle(info, objectWidget, changedTiddlers) {
+	for (var attribute in info.style) {
+		var key = info.style[attribute];
+		if (objectWidget.refreshProperty(key, changedTiddlers)) {
+			return true;
+		}
+	}
+	return false;
+};
+
+function injectNamespace(svg) {
+	// wikitext svg does not need namespacing, but data URIs do
+	svg.setAttribute("xmlns", "http://www.w3.org/2000/svg");
+};
+
+function injectStyle(svg, style) {
+	if (style) {
+		var styleElement = $tw.fakeDocument.createElement("style");
+		styleElement.textContent = style;
+		svg.insertBefore(styleElement, svg.children[0]);
+	}
+};

package/plugins/graph/propertytypes/number.js

@@ -0,0 +1,24 @@
+/*\
+
+Defines behavior for number types in graph engine properties.
+
+\*/
+
+"use strict";
+
+exports.name = "number";
+
+exports.toProperty = function(info, value) {
+	value = parseFloat(value);
+	if (isNaN(value)) {
+		// Ignore it. It's a bad number.
+		return null;
+	}
+	if (info.min !== undefined && value < info.min) {
+		value = info.min;
+	}
+	if (info.max !== undefined && value > info.max) {
+		value = info.max;
+	}
+	return value;
+};

package/plugins/graph/propertytypes/string.js

@@ -0,0 +1,13 @@
+/*\
+
+Defines behavior for string types in graph engine properties.
+
+\*/
+
+"use strict";
+
+exports.name = "string";
+
+exports.toProperty = function(info, value) {
+	return value || null;
+};

package/plugins/graph/propertytypes/tiddlywiki.files

@@ -0,0 +1,17 @@
+{
+	"directories": [
+		{
+			"path": ".",
+			"filesRegExp": "^.*\\.js$",
+			"isTiddlerFile": false,
+			"fields": {
+				"title": {
+					"source": "filename",
+					"prefix": "$:/plugins/flibbles/graph/propertytypes/"
+				},
+				"type": "application/javascript",
+				"module-type": "graphpropertytype"
+			}
+		}
+	]
+}

package/plugins/graph/readme.tid

@@ -0,0 +1,5 @@
+title: $:/plugins/flibbles/graph/readme
+
+//tw5-graph// is a plugin which provides a toolkit of widgets to interact with graph visualization software. This plugin does not include any visualization libraries itself. It must be coupled with a library plugin that acts as an engine.
+
+[ext[Project page is available on github.|https://github.com/flibbles/tw5-graph]]

package/plugins/graph/relink/attributes.js

@@ -0,0 +1,52 @@
+/*\
+title: $:/plugins/flibbles/graph/relink/attributes.js
+type: application/javascript
+module-type: relinkhtmlattributes
+
+Relinks attributes of $properties and other graph object widgets.
+
+\*/
+
+"use strict";
+
+exports.name = "graph";
+
+var utils = require("./utils.js");
+var graphObjects = Object.create(null);
+
+$tw.modules.forEachModuleOfType("widget-subclass", function(subclass, module) {
+	var type = module.prototype.graphObjectType;
+	if (module.baseClass === "graphobject") {
+		graphObjects["$" + module.name] = function() { return type; };
+	}
+});
+
+graphObjects["$graph"] = function() { return "graph"; };
+
+// Current behavior is if $for is specified, but it's empty or wrong, then
+// this widget gets ignored for relinking, just as it gets ignored by graphs.
+graphObjects["$properties"] = function(element) {
+	var forAttr = element.attributes["$for"];
+	return forAttr !== undefined? forAttr.value: "nodes";
+};
+
+exports.getHandler = function(element, attribute, options) {
+	var forFunc = graphObjects[element.tag];
+	if (forFunc) {
+		return processAttribute(forFunc(element), attribute, options);
+	}
+};
+
+function processAttribute(forObject, attribute, options) {
+	var name = attribute.name;
+	if (name[0] !== "$") {
+		var engine = utils.getEngine(options.wiki);
+		if (engine) {
+			var properties = engine.prototype.properties[forObject];
+			if (properties) {
+				var propertyInfo = properties[attribute.name];
+				return utils.getRelinker(propertyInfo);
+			}
+		}
+	}
+};

package/plugins/graph/relink/attributes.multids

@@ -0,0 +1,19 @@
+title: $:/config/flibbles/relink/attributes/
+
+$action-addtyped/$field: fieldname
+$action-addtyped/$tiddler: title
+$action-delay/$state: title
+$action-modal/$tiddler: title
+$action-removetyped/$field: fieldname
+$action-removetyped/$tiddler: title
+$boundingbox/length: filter
+$boundingbox/width: filter
+$edge/$from: title
+$edge/$to: title
+$fieldtranscriber/state: title
+$fieldtranscriber/field: fieldname
+$fieldtranscriber/tiddler: title
+$node/$tiddler: title
+$properties/$tiddler: title
+$properties/$field: fieldname
+$properties/$filter: filter

package/plugins/graph/relink/configprefix.js

@@ -0,0 +1,76 @@
+/*\
+title: $:/plugins/flibbles/graph/relink/configprefix.js
+type: application/javascript
+module-type: relinkprefix
+
+Takes care of relinking property data tiddlers
+in the $:/config/flibbles/graph namespace.
+
+\*/
+
+"use strict";
+
+exports.prefix = "$:/config/flibbles/graph/";
+
+var utils = require("./utils.js");
+var jsonType = "application/json";
+
+
+exports.report = function(tiddler, callback, options) {
+	forEachProperty(options.wiki, tiddler, function(key, data, relinker) {
+		relinker.report(data[key], function(title, blurb, info) {
+			var suffix = blurb? (": " + blurb): "";
+			callback(title, key + suffix, info);
+		}, options);
+	});
+};
+
+exports.relink = function(tiddler, fromTitle, toTitle, changes, options) {
+	var changed, tiddlerData;
+	var type = tiddler.fields.type;
+	var impossible = false;
+	forEachProperty(options.wiki, tiddler, function(key, data, relinker) {
+		var lineEntry = relinker.relink(data[key], fromTitle, toTitle, options);
+		if (lineEntry) {
+			changed = true;
+			if (lineEntry.output) {
+				data[key] = lineEntry.output;
+				tiddlerData = data;
+				if (!isLegalDictionaryValue(lineEntry.output)) {
+					type = jsonType;
+					changes.type = {output: jsonType};
+				}
+			}
+			impossible = lineEntry.impossible || impossible;
+		}
+	});
+	if (changed) {
+		changes.text = {};
+		if (tiddlerData) {
+			var text;
+			if (type === jsonType) {
+				text = JSON.stringify(tiddlerData, null, $tw.config.preferences.jsonSpaces);
+			} else {
+				text = $tw.utils.makeTiddlerDictionary(tiddlerData);
+			}
+			changes.text.output = text;
+		}
+		if (impossible) {
+			changes.text.impossible = true;
+		}
+	}
+};
+
+function forEachProperty(wiki, tiddler, callback) {
+	var title = tiddler.fields.title;
+	var slashPos = title.indexOf("/", exports.prefix.length);
+	if (slashPos >= 0) {
+		var objectType = title.substring(exports.prefix.length, slashPos);
+		var data = wiki.getTiddlerData(title);
+		utils.forEachPropertyIn(data, objectType, wiki, callback);
+	}
+};
+
+function isLegalDictionaryValue(text) {
+	return text.indexOf("\n") < 0;
+};

package/plugins/graph/relink/fieldedgeprefix.js

@@ -0,0 +1,39 @@
+/*\
+title: $:/plugins/flibbles/graph/relink/fieldedgeprefix.js
+type: application/javascript
+module-type: relinkprefix
+
+Takes care of relinking all edge property files in the "field" category.
+
+\*/
+
+"use strict";
+
+// We only use this module if relink-fieldnames is installed and active
+// Otherewise we don't engage in renaming field edges.
+if ($tw.wiki.getShadowSource("$:/plugins/flibbles/relink-fieldnames/utils.js")) {
+
+exports.prefix = "$:/config/flibbles/graph/edges/fields/";
+
+var utils = require("$:/plugins/flibbles/relink-fieldnames/utils.js");
+
+exports.report = function(tiddler, callback, options) {
+	var field = tiddler.fields.title.substr(exports.prefix.length);
+	if (!utils.isReserved(field, options)) {
+		callback(field, "#graph field edgetype: " + field);
+	}
+};
+
+exports.relink = function(tiddler, fromTitle, toTitle, changes, options) {
+	var field = tiddler.fields.title.substr(exports.prefix.length);
+	if (field === fromTitle && !utils.isReserved(field, options)) {
+		if (utils.isReserved(toTitle, options)
+		|| options.wiki.tiddlerExists(exports.prefix + toTitle)) {
+			changes.title = {impossible: true};
+		} else {
+			changes.title = {output: exports.prefix + toTitle};
+		}
+	}
+};
+
+}

package/plugins/graph/relink/fields.multids

@@ -0,0 +1,11 @@
+title: $:/config/flibbles/relink/fields/
+
+# This configuration already exists in Relink. We duplicate it here in case
+# anyone runs tw5-graph without relink installed. We'll still recognize filter.
+filter: filter
+
+# These, however, are unique to TW5-Graph
+template: title
+edges.fields: filter
+edges.functions: filter
+popup.template: wikitext

package/plugins/graph/relink/graphprefix.js

@@ -0,0 +1,28 @@
+/*\
+title: $:/plugins/flibbles/graph/relink/graphprefix.js
+type: application/javascript
+module-type: relinkprefix
+
+Takes care of relinking everything graphTiddler related.
+Such as the tiddlers in the $:/graph/ namespace.
+
+\*/
+
+"use strict";
+
+exports.prefix = "$:/graph/";
+
+var utils = require("./utils.js");
+var tag = "$:/tags/flibbles/graph/TiddlerData";
+
+exports.report = function(tiddler, callback, options) {
+	if (!tiddler.hasTag(tag)) {
+		return utils.reportTiddlerData(tiddler, callback, options);
+	}
+};
+
+exports.relink = function(tiddler, fromTitle, toTitle, changes, options) {
+	if (!tiddler.hasTag(tag)) {
+		return utils.relinkTiddlerData(tiddler, fromTitle, toTitle, changes, options);
+	}
+};

package/plugins/graph/relink/operators.multids

@@ -0,0 +1,3 @@
+title: $:/config/flibbles/relink/operators/
+
+gettyped: fieldname

package/plugins/graph/relink/propertyfields.js

@@ -0,0 +1,81 @@
+/*\
+title: $:/plugins/flibbles/graph/relink/propertyfields.js
+type: application/javascript
+module-type: relinkoperator
+
+Takes care of relinking graph.* properties across all tiddlers.
+
+\*/
+
+"use strict";
+
+exports.name = "graph fields";
+
+var utils = require("./utils.js");
+var fieldPrefix = "graph.";
+var tag = "$:/tags/flibbles/graph/TiddlerData";
+
+exports.report = function(tiddler, callback, options) {
+	if (tiddler.hasTag(tag)) {
+		utils.reportTiddlerData(tiddler, callback, options);
+	}
+	for (var field in tiddler.fields) {
+		if ($tw.utils.startsWith(field, fieldPrefix)) {
+			var type = field.substr(fieldPrefix.length);
+			var data;
+			try {
+				data = JSON.parse(tiddler.fields[field]);
+			} catch {}
+			utils.forEachPropertyIn(data, type, options.wiki, function(key, data, relinker) {
+				relinker.report(data[key], function(title, blurb, info) {
+					var prefix = "#" + type + " - " + key;
+					if (blurb) {
+						prefix += ": " + blurb;
+					}
+					callback(title, prefix, info);
+				}, options);
+			});
+		}
+	}
+};
+
+exports.relink = function(tiddler, fromTitle, toTitle, changes, options) {
+	if (tiddler.hasTag(tag)) {
+		utils.relinkTiddlerData(tiddler, fromTitle, toTitle, changes, options);
+	}
+	var changedField = {};
+	var impossibleFields = {};
+	for (var field in tiddler.fields) {
+		if ($tw.utils.startsWith(field, fieldPrefix)) {
+			var fieldData = undefined,
+				changed = false,
+				impossible = false;
+			var type = field.substr(fieldPrefix.length);
+			var data;
+			try {
+				data = JSON.parse(tiddler.fields[field]);
+			} catch {}
+			utils.forEachPropertyIn(data, type, options.wiki, function(key, data, relinker) {
+				var lineEntry = relinker.relink(data[key], fromTitle, toTitle, options);
+				if (lineEntry) {
+					changed = true;
+					if (lineEntry.output) {
+						data[key] = lineEntry.output;
+						fieldData = data;
+					}
+					impossible = lineEntry.impossible || impossible;
+				}
+			});
+			if (changed) {
+				changes[field] = {};
+				if (fieldData) {
+					var text = JSON.stringify(fieldData);
+					changes[field].output = text;
+				}
+				if (impossible) {
+					changes[field].impossible = true;
+				}
+			}
+		}
+	}
+};

package/plugins/graph/relink/utils.js

@@ -0,0 +1,99 @@
+/*\
+title: $:/plugins/flibbles/graph/relink/utils.js
+type: application/javascript
+module-type: library
+
+These utilities only ever get loaded if Relink is installed.
+
+\*/
+
+"use strict";
+
+var baseUtils = require("../utils.js");
+var relinkUtils = require("$:/plugins/flibbles/relink/js/utils.js");
+var PropertyTypes = $tw.modules.getModulesByTypeAsHashmap("graphpropertytype");
+
+exports.forEachPropertyIn = function(data, objectType, wiki, callback) {
+	if (data) {
+		var engine = exports.getEngine(wiki);
+		if (engine) {
+			var properties = engine.prototype.properties[objectType];
+			if (properties) {
+				for (var key in data) {
+					var propertyInfo = properties[key];
+					var relinker = exports.getRelinker(propertyInfo);
+					if (relinker) {
+						callback(key, data, relinker);
+					}
+				}
+			}
+		}
+	}
+};
+
+exports.getRelinker = function(propertyInfo) {
+	var relinker;
+	if (propertyInfo) {
+		var propertyClass = PropertyTypes[propertyInfo.type];
+		if (propertyClass && propertyClass.type) {
+			relinker = relinkUtils.getType(propertyClass.type);
+		}
+	}
+	return relinker;
+};
+
+exports.getEngine = function(wiki) {
+	var value = $tw.macros.graphengine.get(wiki);
+	return baseUtils.getEngine(value);
+};
+
+exports.reportTiddlerData = function(tiddler, callback, options) {
+	var data = options.wiki.getTiddlerDataCached(tiddler.fields.title, {});
+	for (var title in data) {
+		callback(title, data[title], {soft: true});
+	}
+};
+
+exports.relinkTiddlerData = function(tiddler, fromTitle, toTitle, changes, options) {
+	var data = options.wiki.getTiddlerDataCached(tiddler.fields.title, {});
+	if (data[fromTitle] !== undefined) {
+		var newData = {};
+		for (var title in data) {
+			if (title === fromTitle) {
+				newData[toTitle] = data[title];
+			} else {
+				newData[title] = data[title];
+			}
+		}
+		var newText;
+		var type = tiddler.fields.type;
+		if (type === "application/x-tiddler-dictionary") {
+			if (isLegalDictionaryKey(toTitle)) {
+				newText = $tw.utils.makeTiddlerDictionary(newData);
+			} else {
+				type = "application/json";
+				changes.type = {output: type};
+			}
+		}
+		if (type === "application/json") {
+			newText = JSON.stringify(newData, null, $tw.config.preferences.jsonSpaces);
+		}
+		changes.text = {output: newText};
+	}
+};
+
+function isLegalDictionaryKey(title) {
+	// We make a microdictionary with the value and make sure we get back
+	// a dictionary with the key pointing to an arbitrary x
+	var fields = $tw.utils.parseFields(title + ":x");
+	var found = false;
+	for (var key in fields) {
+		if (found
+		|| key !== title
+		|| fields[key] !== "x") {
+			return false;
+		}
+		found = true;
+	}
+	return found;
+};

package/plugins/graph/settings.tid

@@ -0,0 +1,13 @@
+title: $:/plugins/flibbles/graph/settings
+tags: [[$:/tags/ControlPanel/SettingsTab]]
+caption: Graph
+
+\procedure filterTab() [!has[filter]] ~[subfilter{!!filter}]
+\procedure settingsTabs() [[$:/tags/flibbles/graph/SettingsTab]tagging[]filter<filterTab>]
+
+Settings page for TW5-Graph. See the [ext[project website|https://flibbles.github.io/tw5-graph]] for complete documentation.
+
+<$transclude $variable=tabs
+	tabsList=<<settingsTabs>>
+	default={{{ [subfilter<settingsTabs>] }}}
+	explicitState="$:/state/flibbles/graph/settings" />