Add geospatial plugin

bin/build-site.sh

@@ -351,6 +351,17 @@ node $TW5_BUILD_TIDDLYWIKI \
 	--rendertiddler $:/core/save/empty plugins/tiddlywiki/highlight/empty.html text/plain \
 	|| exit 1
 
+# /plugins/tiddlywiki/geospatial/index.html		Demo wiki with geospatial plugin
+# /plugins/tiddlywiki/geospatial/empty.html		Empty wiki with geospatial plugin
+node $TW5_BUILD_TIDDLYWIKI \
+	./editions/geospatialdemo \
+	--verbose \
+	--load $TW5_BUILD_OUTPUT/build.tid \
+	--output $TW5_BUILD_OUTPUT \
+	--rendertiddler $:/core/save/all plugins/tiddlywiki/geospatial/index.html text/plain \
+	--rendertiddler $:/core/save/empty plugins/tiddlywiki/geospatial/empty.html text/plain \
+	|| exit 1
+
 ######################################################
 #
 # Language editions

core/modules/commands/setfield.js

@@ -39,9 +39,10 @@ Command.prototype.execute = function() {
 	$tw.utils.each(tiddlers,function(title) {
 		var parser = wiki.parseTiddler(templatetitle),
 			newFields = {},
-			tiddler = wiki.getTiddler(title);
+			tiddler = wiki.getTiddler(title),
+			currentValue = tiddler ? (tiddler.fields[fieldname] || "") : "";
 		if(parser) {
-			var widgetNode = wiki.makeWidget(parser,{variables: {currentTiddler: title}});
+			var widgetNode = wiki.makeWidget(parser,{variables: {currentTiddler: title, currentValue: currentValue}});
 			var container = $tw.fakeDocument.createElement("div");
 			widgetNode.render(container,null);
 			newFields[fieldname] = rendertype === "text/html" ? container.innerHTML : container.textContent;

core/modules/filters/json-ops.js

@@ -68,6 +68,54 @@ exports["jsontype"] = function(source,operator,options) {
 	return results;
 };
 
+exports["jsonset"] = function(source,operator,options) {
+	var suffixes = operator.suffixes || [],
+		type = suffixes[0] && suffixes[0][0],
+		indexes = operator.operands.slice(0,-1),
+		value = operator.operands[operator.operands.length - 1],
+		results = [];
+	if(operator.operands.length === 1 && operator.operands[0] === "") {
+		value = undefined; // Prevents the value from being assigned
+	}
+	switch(type) {
+		case "string":
+			// Use value unchanged
+			break;
+		case "boolean":
+			value = (value === "true" ? true : (value === "false" ? false : undefined));
+			break;
+		case "number":
+			value = $tw.utils.parseNumber(value);
+			break;
+		case "array":
+			indexes = operator.operands;
+			value = [];
+			break;
+		case "object":
+			indexes = operator.operands;
+			value = {};
+			break;
+		case "null":
+			indexes = operator.operands;
+			value = null;
+			break;
+		case "json":
+			value = $tw.utils.parseJSONSafe(value,function() {return undefined;});
+			break;
+		default:
+			// Use value unchanged
+			break;
+	}
+	source(function(tiddler,title) {
+		var data = $tw.utils.parseJSONSafe(title,title);
+		if(data) {
+			data = setDataItem(data,indexes,value);
+			results.push(JSON.stringify(data));
+		}
+	});
+	return results;
+};
+
 /*
 Given a JSON data structure and an array of index strings, return an array of the string representation of the values at the end of the index chain, or "undefined" if any of the index strings are invalid
 */
@@ -186,5 +234,34 @@ function getDataItem(data,indexes) {
 	return item;
 }
 
+/*
+Given a JSON data structure, an array of index strings and a value, return the data structure with the value added at the end of the index chain. If any of the index strings are invalid then the JSON data structure is returned unmodified. If the root item is targetted then a different data object will be returned
+*/
+function setDataItem(data,indexes,value) {
+	// Ignore attempts to assign undefined
+	if(value === undefined) {
+		return data;
+	}
+	// Check for the root item
+	if(indexes.length === 0 || (indexes.length === 1 && indexes[0] === "")) {
+		return value;
+	}
+	// Traverse the JSON data structure using the index chain
+	var current = data;
+	for(var i = 0; i < indexes.length - 1; i++) {
+		var index = indexes[i];
+		if($tw.utils.hop(current,index)) {
+			current = current[index];
+		} else {
+			// Return the original JSON data structure if any of the index strings are invalid
+			return data;
+		}
+	}
+	// Add the value to the end of the index chain
+	var lastIndex = indexes[indexes.length - 1];
+	current[lastIndex] = value;
+	return data;
+}
+
 })();
 

core/modules/filters/url-ops.js

@@ -0,0 +1,25 @@
+/*\
+title: $:/core/modules/filters/url-ops.js
+type: application/javascript
+module-type: filteroperator
+
+Filter operators for URL operations
+
+\*/
+(function(){
+
+/*jslint node: true, browser: true */
+/*global $tw: false */
+"use strict";
+
+exports["setquerystring"] = function(source,operator,options) {
+	var name = operator.operands.length >= 1 ? operator.operands[0] : null,
+		value = operator.operands.length >= 2 ? operator.operands[1] : "",
+		results = [];
+	source(function(tiddler,title) {
+		results.push($tw.utils.setQueryStringParameter(title,name,value));
+	});
+	return results;
+};
+
+})();

core/modules/widgets/data.js

@@ -0,0 +1,139 @@
+/*\
+title: $:/core/modules/widgets/data.js
+type: application/javascript
+module-type: widget
+
+Widget to represent a single item of data
+
+\*/
+(function(){
+
+/*jslint node: true, browser: true */
+/*global $tw: false */
+"use strict";
+
+var Widget = require("$:/core/modules/widgets/widget.js").widget;
+
+var DataWidget = function(parseTreeNode,options) {
+	this.dataWidgetTag = parseTreeNode.type;
+	this.initialise(parseTreeNode,options);
+};
+
+/*
+Inherit from the base widget class
+*/
+DataWidget.prototype = new Widget();
+
+/*
+Render this widget into the DOM
+*/
+DataWidget.prototype.render = function(parent,nextSibling) {
+	this.parentDomNode = parent;
+	this.computeAttributes();
+	this.execute();
+	this.renderChildren(parent,nextSibling);
+};
+
+/*
+Compute the internal state of the widget
+*/
+DataWidget.prototype.execute = function() {
+	// Construct the child widgets
+	this.makeChildWidgets();
+};
+
+/*
+Read the tiddler value(s) from a data widget – must be called after the .render() method
+*/
+DataWidget.prototype.readDataTiddlerValues = function() {
+	var self = this;
+	// Start with a blank object
+	var item = Object.create(null);
+	// Read any attributes not prefixed with $
+	$tw.utils.each(this.attributes,function(value,name) {
+		if(name.charAt(0) !== "$") {
+			item[name] = value;	
+		}
+	});
+	item = new $tw.Tiddler(item);
+	// Deal with $tiddler, $filter or $compound-tiddler attributes
+	var tiddlers = [],title;
+	if(this.hasAttribute("$tiddler")) {
+		title = this.getAttribute("$tiddler");
+		if(title) {
+			tiddlers.push(this.wiki.getTiddler(title));
+		}
+	}
+	if(this.hasAttribute("$filter")) {
+		var filter = this.getAttribute("$filter");
+		if(filter) {
+			var titles = this.wiki.filterTiddlers(filter);
+			$tw.utils.each(titles,function(title) {
+				var tiddler = self.wiki.getTiddler(title);
+				tiddlers.push(tiddler);
+			});
+		}
+	}
+	if(this.hasAttribute("$compound-tiddler")) {
+		title = this.getAttribute("$compound-tiddler");
+		if(title) {
+			tiddlers.push.apply(tiddlers,this.extractCompoundTiddler(title));
+		}
+	}
+	// Convert the literal item to field strings
+	item = item.getFieldStrings();
+	if(tiddlers.length === 0) {
+		if(Object.keys(item).length > 0 && !!item.title) {
+			return [item];
+		} else {
+			return [];
+		}
+	} else {
+		var results = [];
+		$tw.utils.each(tiddlers,function(tiddler,index) {
+			var fields = tiddler.getFieldStrings();
+			results.push($tw.utils.extend({},fields,item));
+		});
+		return results;	
+	}
+};
+
+/*
+Helper to extract tiddlers from text/vnd.tiddlywiki-multiple tiddlers
+*/
+DataWidget.prototype.extractCompoundTiddler = function(title) {
+	var tiddler = this.wiki.getTiddler(title);
+	if(tiddler && tiddler.fields.type === "text/vnd.tiddlywiki-multiple") {
+		var text = tiddler.fields.text || "",
+			rawTiddlers = text.split(/\r?\n\+\r?\n/),
+			tiddlers = [];
+		$tw.utils.each(rawTiddlers,function(rawTiddler) {
+			var fields = Object.create(null),
+				split = rawTiddler.split(/\r?\n\r?\n/mg);
+			if(split.length >= 1) {
+				fields = $tw.utils.parseFields(split[0],fields);
+			}
+			if(split.length >= 2) {
+				fields.text = split.slice(1).join("\n\n");
+			}
+			tiddlers.push(new $tw.Tiddler(fields));
+		});
+		return tiddlers;
+	} else {
+		return [];
+	}
+};
+
+/*
+Selectively refreshes the widget if needed. Returns true if the widget or any of its children needed re-rendering
+*/
+DataWidget.prototype.refresh = function(changedTiddlers) {
+	// Refresh our attributes
+	var changedAttributes = this.computeAttributes();
+	// Refresh our children, and indicate that we refreshed if any of our attribute values have changed
+	return this.refreshChildren(changedTiddlers) || $tw.utils.count(changedAttributes) > 0;
+};
+
+exports.data = DataWidget;
+
+})();