tiddlywiki 5.3.8 → 5.4.0

package/editions/test/tiddlers/tests/test-json-filters.js

@@ -7,16 +7,13 @@ Tests the JSON filters and the format:json operator
 
 \*/
 
-
-/* jslint node: true, browser: true */
 /* eslint-env node, browser, jasmine */
 /* eslint no-mixed-spaces-and-tabs: ["error", "smart-tabs"]*/
-/* global $tw, require */
 "use strict";
 
 describe("json filter tests", function() {
 
-	var wiki = new $tw.Wiki();
+	var wiki = $tw.test.wiki();
 	var tiddlers = [{
 		title: "First",
 		text: '{"a":"one","b":"","c":1.618,"d": {"e": "four","f": ["five","six",true,false,null]}}',
@@ -127,7 +124,7 @@ describe("json filter tests", function() {
 		expect(wiki.filterTiddlers("[jsonset[a],[aa]]")).toEqual(['"First"','"Second"','"Third"']);
 		expect(wiki.filterTiddlers("[{First}jsonset[]]")).toEqual(['{"a":"one","b":"","c":1.618,"d":{"e":"four","f":["five","six",true,false,null]}}']);
 		expect(wiki.filterTiddlers("[{First}jsonset[],[Antelope]]")).toEqual(['"Antelope"']);
-		expect(wiki.filterTiddlers("[{First}jsonset:number[],[not a number]]")).toEqual(['0']);
+		expect(wiki.filterTiddlers("[{First}jsonset:number[],[not a number]]")).toEqual(["0"]);
 		expect(wiki.filterTiddlers("[{First}jsonset[id],[Antelope]]")).toEqual(['{"a":"one","b":"","c":1.618,"d":{"e":"four","f":["five","six",true,false,null]},"id":"Antelope"}']);
 		expect(wiki.filterTiddlers("[{First}jsonset:notatype[id],[Antelope]]")).toEqual(['{"a":"one","b":"","c":1.618,"d":{"e":"four","f":["five","six",true,false,null]},"id":"Antelope"}']);
 		expect(wiki.filterTiddlers("[{First}jsonset:boolean[id],[false]]")).toEqual(['{"a":"one","b":"","c":1.618,"d":{"e":"four","f":["five","six",true,false,null]},"id":false}']);
@@ -143,6 +140,33 @@ describe("json filter tests", function() {
 		expect(wiki.filterTiddlers("[{First}jsonset:json[notjson]]")).toEqual(['{"a":"one","b":"","c":1.618,"d":{"e":"four","f":["five","six",true,false,null]}}']);
 	});
 
+	it("should support the jsondelete operator", function() {
+		// Delete top-level object property
+		expect(wiki.filterTiddlers("[{First}jsondelete[a]]")).toEqual(['{"b":"","c":1.618,"d":{"e":"four","f":["five","six",true,false,null]}}']);
+		expect(wiki.filterTiddlers("[{First}jsondelete[b]]")).toEqual(['{"a":"one","c":1.618,"d":{"e":"four","f":["five","six",true,false,null]}}']);
+		expect(wiki.filterTiddlers("[{First}jsondelete[c]]")).toEqual(['{"a":"one","b":"","d":{"e":"four","f":["five","six",true,false,null]}}']);
+		// Delete nested object property
+		expect(wiki.filterTiddlers("[{First}jsondelete[d],[e]]")).toEqual(['{"a":"one","b":"","c":1.618,"d":{"f":["five","six",true,false,null]}}']);
+		// Delete array element
+		expect(wiki.filterTiddlers("[{First}jsondelete[d],[f],[0]]")).toEqual(['{"a":"one","b":"","c":1.618,"d":{"e":"four","f":["six",true,false,null]}}']);
+		expect(wiki.filterTiddlers("[{First}jsondelete[d],[f],[1]]")).toEqual(['{"a":"one","b":"","c":1.618,"d":{"e":"four","f":["five",true,false,null]}}']);
+		// Delete using negative array index
+		expect(wiki.filterTiddlers("[{First}jsondelete[d],[f],[-1]]")).toEqual(['{"a":"one","b":"","c":1.618,"d":{"e":"four","f":["five","six",true,false]}}']);
+		expect(wiki.filterTiddlers("[{First}jsondelete[d],[f],[-2]]")).toEqual(['{"a":"one","b":"","c":1.618,"d":{"e":"four","f":["five","six",true,null]}}']);
+		expect(wiki.filterTiddlers("[{First}jsondelete[d],[f],[-5]]")).toEqual(['{"a":"one","b":"","c":1.618,"d":{"e":"four","f":["six",true,false,null]}}']);
+		// Delete from array
+		expect(wiki.filterTiddlers("[{Second}jsondelete[0]]")).toEqual(['["deux","trois",["quatre","cinq"]]']);
+		expect(wiki.filterTiddlers("[{Second}jsondelete[1]]")).toEqual(['["une","trois",["quatre","cinq"]]']);
+		expect(wiki.filterTiddlers("[{Second}jsondelete[-1]]")).toEqual(['["une","deux","trois"]']);
+		// Attempting to delete non-existent property should return unchanged
+		expect(wiki.filterTiddlers("[{First}jsondelete[missing-property]]")).toEqual(['{"a":"one","b":"","c":1.618,"d":{"e":"four","f":["five","six",true,false,null]}}']);
+		expect(wiki.filterTiddlers("[{First}jsondelete[d],[missing]]")).toEqual(['{"a":"one","b":"","c":1.618,"d":{"e":"four","f":["five","six",true,false,null]}}']);
+		// Attempting to delete root should return unchanged
+		expect(wiki.filterTiddlers("[{First}jsondelete[]]")).toEqual(['{"a":"one","b":"","c":1.618,"d":{"e":"four","f":["five","six",true,false,null]}}']);
+		// Non-JSON input should return unchanged
+		expect(wiki.filterTiddlers("[{Third}jsondelete[a]]")).toEqual(["This is not JSON"]);
+	});
+
 	it("should support the format:json operator", function() {
 		expect(wiki.filterTiddlers("[{First}format:json[]]")).toEqual(["{\"a\":\"one\",\"b\":\"\",\"c\":1.618,\"d\":{\"e\":\"four\",\"f\":[\"five\",\"six\",true,false,null]}}"]);
 		expect(wiki.filterTiddlers("[{First}format:json[4]]")).toEqual(["{\n    \"a\": \"one\",\n    \"b\": \"\",\n    \"c\": 1.618,\n    \"d\": {\n        \"e\": \"four\",\n        \"f\": [\n            \"five\",\n            \"six\",\n            true,\n            false,\n            null\n        ]\n    }\n}"]);

package/editions/test/tiddlers/tests/test-linked-list.js

@@ -29,7 +29,7 @@ describe("LinkedList class tests", function() {
 	// creates and initializes a new {array, list} pair for testing
 	function newPair(initialArray) {
 		var pair = {array: [], list: new $tw.utils.LinkedList()};
-		if (initialArray) {
+		if(initialArray) {
 			push(pair, initialArray);
 		}
 		return pair;
@@ -126,7 +126,7 @@ describe("LinkedList class tests", function() {
 		compare(pushTop(remove(newPair(["A", "A"]), ["A", "A"]), ["B", "A"])); // BA
 
 		// Again, but this time with other values mixed in
-		compare(remove(newPair(["B", "A", "A", "C"]), ["A", "A"])) // BC;
+		compare(remove(newPair(["B", "A", "A", "C"]), ["A", "A"])); // BC;
 		// And again, but this time with value inbetween too.
 		compare(remove(newPair(["B", "A", "X", "Y", "Z", "A", "C"]), ["A", "A"])); // BXYZC
 
@@ -195,10 +195,10 @@ describe("LinkedList class tests", function() {
 		// This actually caused an infinite loop once. So important test here.
 		push(pair, ["A"]);
 		compare(pair); // XYCAA
-		pushTop(pair, "A") // switch those last As
+		pushTop(pair, "A"); // switch those last As
 		compare(pair); // XYCAA
 		remove(pair, ["A", "A"]); // Remove all As, then add them back
-		pushTop(pair, ["A", "A"])
+		pushTop(pair, ["A", "A"]);
 		compare(pair); // XYCAA
 	});
 

package/editions/test/tiddlers/tests/test-parsetextreference.js

@@ -12,7 +12,7 @@ Tests for source attribute in parser returned from wiki.parseTextReference
 describe("Wiki.parseTextReference tests", function() {
 
 	// Create a wiki
-	var wiki = new $tw.Wiki();
+	var wiki = $tw.test.wiki();
 	wiki.addTiddler({
 		title: "TiddlerOne",
 		text: "The quick brown fox in $:/TiddlerTwo",

package/editions/test/tiddlers/tests/test-prefixes-filter.js

@@ -14,7 +14,7 @@ Tests the reduce prefix and filter.
 
 describe("general filter prefix tests", function() {
 	it("should handle nonexistent prefixes gracefully", function() {
-		var wiki = new $tw.Wiki();
+		var wiki = $tw.test.wiki();
 		var results = wiki.filterTiddlers("[tag[A]] :nonexistent[tag[B]]");
 		expect(results).toEqual(["Filter Error: Unknown prefix for filter run"]);
 	});
@@ -215,7 +215,7 @@ describe("general filter prefix tests", function() {
 
 describe("'reduce' and 'intersection' filter prefix tests", function() {
 
-	var wiki = new $tw.Wiki();
+	var wiki = $tw.test.wiki();
 
 	wiki.addTiddler({
 		title: "Brownies",
@@ -337,7 +337,7 @@ describe("'reduce' and 'intersection' filter prefix tests", function() {
 	it("should handle the reduce operator", function() {
 		var widget = require("$:/core/modules/widgets/widget.js");
 		var rootWidget = new widget.widget({ type:"widget", children:[ {type:"widget", children:[]} ] },
-										   { wiki:wiki, document:$tw.document});
+			{ wiki:wiki, document:$tw.document});
 		rootWidget.makeChildWidgets();
 		var anchorWidget = rootWidget.children[0];
 		rootWidget.setVariable("add-price","[get[price]multiply{!!quantity}add<accumulator>]");
@@ -372,13 +372,13 @@ describe("'reduce' and 'intersection' filter prefix tests", function() {
 	it("should handle the variance operator", function() {
 		expect(parseFloat(wiki.filterTiddlers("[tag[shopping]get[price]variance[]]").join(","))).toBeCloseTo(2.92);
 		expect(parseFloat(wiki.filterTiddlers("[tag[food]get[price]variance[]]").join(","))).toBeCloseTo(3.367);
-		expect(wiki.filterTiddlers(" +[variance[]]").toString()).toBe("NaN");
+		expect(wiki.filterTiddlers(" +[variance[]]").toString()).toBe("");
 	});
 
 	it("should handle the standard-deviation operator", function() {
 		expect(parseFloat(wiki.filterTiddlers("[tag[shopping]get[price]standard-deviation[]]").join(","))).toBeCloseTo(1.71);
 		expect(parseFloat(wiki.filterTiddlers("[tag[food]get[price]standard-deviation[]]").join(","))).toBeCloseTo(1.835);
-		expect(wiki.filterTiddlers(" +[standard-deviation[]]").toString()).toBe("NaN");
+		expect(wiki.filterTiddlers(" +[standard-deviation[]]").toString()).toBe("");
 	});	
 
 	it("should handle the :intersection prefix", function() {
@@ -392,7 +392,7 @@ describe("'reduce' and 'intersection' filter prefix tests", function() {
 	it("should handle the :filter prefix and filter operator", function() {
 		var widget = require("$:/core/modules/widgets/widget.js");
 		var rootWidget = new widget.widget({ type:"widget", children:[ {type:"widget", children:[]} ] },
-										   { wiki:wiki, document:$tw.document});
+			{ wiki:wiki, document:$tw.document});
 		rootWidget.makeChildWidgets();
 		var anchorWidget = rootWidget.children[0];
 		rootWidget.setVariable("larger-than-18","[get[text]length[]compare:integer:gteq[18]]");
@@ -420,6 +420,8 @@ describe("'reduce' and 'intersection' filter prefix tests", function() {
 		expect(wiki.filterTiddlers("[tag[cakes]] :sort:string[{!!title}]").join(",")).toBe("cheesecake,Cheesecake,chocolate cake,Chocolate Cake,Persian love cake,Pound cake");
 		expect(wiki.filterTiddlers("[tag[cakes]] :sort:string:casesensitive[{!!title}]").join(",")).toBe("Cheesecake,Chocolate Cake,Persian love cake,Pound cake,cheesecake,chocolate cake");
 		expect(wiki.filterTiddlers("[tag[cakes]] :sort:string:casesensitive,reverse[{!!title}]").join(",")).toBe("chocolate cake,cheesecake,Pound cake,Persian love cake,Chocolate Cake,Cheesecake");
+		expect(wiki.filterTiddlers("1.2.0 1.0.0 1.0.5 :sort:version[{!!title}]").join(",")).toBe("1.0.0,1.0.5,1.2.0");
+		expect(wiki.filterTiddlers("1.2.0 1.0.0 1.0.5 :sort:version:reverse[{!!title}]").join(",")).toBe("1.2.0,1.0.5,1.0.0");
 	});
 
 	it("should handle the :map prefix", function() {
@@ -446,7 +448,7 @@ describe("'reduce' and 'intersection' filter prefix tests", function() {
 	it("should handle macro parameters for filter run prefixes",function() {
 		var widget = require("$:/core/modules/widgets/widget.js");
 		var rootWidget = new widget.widget({ type:"widget", children:[ {type:"widget", children:[]} ] },
-										   { wiki:wiki, document:$tw.document});
+			{ wiki:wiki, document:$tw.document});
 		rootWidget.makeChildWidgets();
 		var anchorWidget = rootWidget.children[0];
 		rootWidget.setVariable("greet","Hello $name$",[{name:"name"}],true);

package/editions/test/tiddlers/tests/test-tags-operator.js

@@ -11,64 +11,64 @@ Tests the tagging mechanism.
 
 describe("Tags Operator tests", function() {
 
-describe("With no indexers", function() {
-	var wikiOptions = {enableIndexers: []},
-		wiki = setupWiki(wikiOptions);
-	runTests(wiki,wikiOptions);
-});
+	describe("With no indexers", function() {
+		var wikiOptions = {enableIndexers: []},
+			wiki = setupWiki(wikiOptions);
+		runTests(wiki,wikiOptions);
+	});
 
-describe("With all indexers", function() {
-	var wikiOptions = {},
-		wiki = setupWiki();
-	runTests(wiki,wikiOptions);
-});
+	describe("With all indexers", function() {
+		var wikiOptions = {},
+			wiki = setupWiki();
+		runTests(wiki,wikiOptions);
+	});
 
-function setupWiki(wikiOptions) {
+	function setupWiki(wikiOptions) {
 	// Create a wiki
-	var wiki = new $tw.Wiki(wikiOptions);
-
-	// Add a few  tiddlers
-	wiki.addTiddler({ title: "aaa",text: "text aaa",color: "red"});
-	wiki.addTiddler({ title: "1"});
-	wiki.addTiddler({ title: "10"});
-	wiki.addTiddler({ title: "bbb"});
-	wiki.addTiddler({ title: "bb bb"});
-	wiki.addTiddler({ title: "BBB"});
-	wiki.addTiddler({ title: "AAA"});
-	wiki.addTiddler({ title: "BB BB"});
-	wiki.addTiddler({ title: "bb bb", text: "text bb bb"});
-	return wiki;
-}
+		var wiki = new $tw.Wiki(wikiOptions);
+
+		// Add a few  tiddlers
+		wiki.addTiddler({ title: "aaa",text: "text aaa",color: "red"});
+		wiki.addTiddler({ title: "1"});
+		wiki.addTiddler({ title: "10"});
+		wiki.addTiddler({ title: "bbb"});
+		wiki.addTiddler({ title: "bb bb"});
+		wiki.addTiddler({ title: "BBB"});
+		wiki.addTiddler({ title: "AAA"});
+		wiki.addTiddler({ title: "BB BB"});
+		wiki.addTiddler({ title: "bb bb", text: "text bb bb"});
+		return wiki;
+	}
 
 	// Our tests
-function runTests(wiki,wikiOptions) {
+	function runTests(wiki,wikiOptions) {
 
-	var TAGS = "aaa 10 1 bbb AAA [[bb bb]] BBB [[BB BB]]";
+		var TAGS = "aaa 10 1 bbb AAA [[bb bb]] BBB [[BB BB]]";
 
-	// Tests before PR #8228 to make sure there are now incompatibilities
-	it("should apply tags ordering in SORT order up to TW v5.3.6", function () {
-		var wiki = new $tw.Wiki(wikiOptions);
-		var EXPECTED = "1,10,aaa,AAA,bb bb,BB BB,bbb,BBB";
+		// Tests before PR #8228 to make sure there are now incompatibilities
+		it("should apply tags ordering in SORT order up to TW v5.3.6", function () {
+			var wiki = new $tw.Wiki(wikiOptions);
+			var EXPECTED = "1,10,aaa,AAA,bb bb,BB BB,bbb,BBB";
 
-		wiki.addTiddler({ title: "test-tags-operator", text: "", tags: TAGS});
-		expect(wiki.filterTiddlers("[[test-tags-operator]tags[]sort[title]]").join(',')).toBe(EXPECTED);
+			wiki.addTiddler({ title: "test-tags-operator", text: "", tags: TAGS});
+			expect(wiki.filterTiddlers("[[test-tags-operator]tags[]sort[title]]").join(",")).toBe(EXPECTED);
 
-		wiki.addTiddler({ title: "$:/config/Tags/CustomSort/subfilter", text: "[{!!title}]"});
-		expect(wiki.filterTiddlers("[[test-tags-operator]tags[]] :sort:alphanumeric:caseinsensitive[subfilter{$:/config/Tags/CustomSort/subfilter}]").join(',')).toBe(EXPECTED);
+			wiki.addTiddler({ title: "$:/config/Tags/CustomSort/subfilter", text: "[{!!title}]"});
+			expect(wiki.filterTiddlers("[[test-tags-operator]tags[]] :sort:alphanumeric:caseinsensitive[subfilter{$:/config/Tags/CustomSort/subfilter}]").join(",")).toBe(EXPECTED);
 
 		// Due to the implementation of the tags[] operator with v5.3.6 we can not guarantee the order that `[tags[]]` returns
-	});
+		});
 
-	// The following test can be enabled once the core allows us to do so.
-	xit("should apply tags ordering in order of creation. TW v5.3.7+", function () {
-		var wiki = new $tw.Wiki(wikiOptions);
+		// The following test can be enabled once the core allows us to do so.
+		xit("should apply tags ordering in order of creation. TW v5.3.7+", function () {
+			var wiki = new $tw.Wiki(wikiOptions);
 
-		wiki.addTiddler({ title: "$:/config/Tags/CustomSort/subfilter", text: ""});
-		wiki.addTiddler({ title: "test-tags-operator", text: "", tags: TAGS});
+			wiki.addTiddler({ title: "$:/config/Tags/CustomSort/subfilter", text: ""});
+			wiki.addTiddler({ title: "test-tags-operator", text: "", tags: TAGS});
 
-		var EXPECTED = "aaa,10,1,bbb,AAA,bb bb,BBB,BB BB"
-		expect(wiki.filterTiddlers("[[test-tags-operator]tags[]] :sort:alphanumeric:caseinsensitive[subfilter{$:/config/Tags/CustomSort/subfilter}]").join(',')).toBe(EXPECTED);
-	});
-}
+			var EXPECTED = "aaa,10,1,bbb,AAA,bb bb,BBB,BB BB";
+			expect(wiki.filterTiddlers("[[test-tags-operator]tags[]] :sort:alphanumeric:caseinsensitive[subfilter{$:/config/Tags/CustomSort/subfilter}]").join(",")).toBe(EXPECTED);
+		});
+	}
 
 });

package/editions/test/tiddlers/tests/test-tags.js

@@ -11,168 +11,168 @@ Tests the tagging mechanism.
 
 describe("Tag tests", function() {
 
-describe("With no indexers", function() {
-	var wikiOptions = {enableIndexers: []},
-		wiki = setupWiki(wikiOptions);
-	runTests(wiki,wikiOptions);
-});
-
-describe("With all indexers", function() {
-	var wikiOptions = {},
-		wiki = setupWiki();
-	runTests(wiki,wikiOptions);
-});
-
-function setupWiki(wikiOptions) {
-	// Create a wiki
-	var wiki = new $tw.Wiki(wikiOptions);
-
-	// Add a few  tiddlers
-	wiki.addTiddler({
-		title: "TiddlerOne",
-		text: "The quick brown fox in $:/TiddlerTwo",
-		tags: ["one","TiddlerSeventh"],
-		modifier: "JoeBloggs",
-		modified: "201304152222"});
-	wiki.addTiddler({
-		title: "$:/TiddlerTwo",
-		text: "The rain in Spain\nfalls mainly on the plain and [[a fourth tiddler]]",
-		tags: ["two"],
-		modifier: "JohnDoe",
-		modified: "201304152211"});
-	wiki.addTiddler({
-		title: "Tiddler Three",
-		text: "The speed of sound in light\n\nThere is no TiddlerZero but TiddlerSix",
-		tags: ["one","two","TiddlerSeventh"],
-		modifier: "JohnDoe",
-		modified: "201304162202"});
-	wiki.addTiddler({
-		title: "a fourth tiddler",
-		text: "The quality of mercy is not drained by [[Tiddler Three]]",
-		tags: ["TiddlerSeventh"],
-		modifier: "JohnDoe"});
-	wiki.addTiddler({
-		title: "one",
-		text: "This is the text of tiddler [[one]]",
-		list: "[[Tiddler Three]] [[TiddlerOne]]",
-		modifier: "JohnDoe"});
-	wiki.addTiddler({
-		title: "$:/TiddlerFive",
-		text: "Everything in federation",
-		tags: ["two"]});
-	wiki.addTiddler({
-		title: "TiddlerSix",
-		text: "Missing inaction from TiddlerOne",
-		tags: []});
-	wiki.addTiddler({
-		title: "TiddlerSeventh",
-		text: "",
-		list: "TiddlerOne [[Tiddler Three]] [[a fourth tiddler]] MissingTiddler",
-		tags: []});
-	wiki.addTiddler({
-		title: "Tiddler8",
-		text: "Tidd",
-		tags: [],
-		"test-field": "JoeBloggs"});
-	wiki.addTiddler({
-		title: "Tiddler9",
-		text: "Another tiddler",
-		tags: ["TiddlerSeventh"],
-		"list-before": "a fourth tiddler"});
-	wiki.addTiddler({
-		title: "Tiddler10",
-		text: "Another tiddler",
-		tags: ["TiddlerSeventh"],
-		"list-before": ""});
-	wiki.addTiddler({
-		title: "Tiddler11",
-		text: "Another tiddler",
-		tags: ["TiddlerSeventh"],
-		"list-after": "Tiddler Three"});
-	return wiki;
-}
-
-	// Our tests
-function runTests(wiki,wikiOptions) {
-
-	it("should handle custom tag ordering", function() {
-		expect(wiki.filterTiddlers("[tag[TiddlerSeventh]]").join(",")).toBe("Tiddler10,TiddlerOne,Tiddler Three,Tiddler11,Tiddler9,a fourth tiddler");
-	});
-
-	it("should apply identical tag ordering irrespective of tag creation order", function () {
-		var wiki;
-		wiki = new $tw.Wiki(wikiOptions);
-		wiki.addTiddler({ title: "A", text: "", tags: "sortTag"});
-		wiki.addTiddler({ title: "B", text: "", tags: "sortTag"});
-		wiki.addTiddler({ title: "C", text: "", tags: "sortTag"});
-		expect(wiki.filterTiddlers("[tag[sortTag]]").join(',')).toBe("A,B,C");
-		wiki = new $tw.Wiki(wikiOptions);
-		wiki.addTiddler({ title: "A", text: "", tags: "sortTag"});
-		wiki.addTiddler({ title: "C", text: "", tags: "sortTag"});
-		wiki.addTiddler({ title: "B", text: "", tags: "sortTag"});
-		expect(wiki.filterTiddlers("[tag[sortTag]]").join(',')).toBe("A,B,C");
-		wiki = new $tw.Wiki(wikiOptions);
-		wiki.addTiddler({ title: "C", text: "", tags: "sortTag"});
-		wiki.addTiddler({ title: "B", text: "", tags: "sortTag"});
-		wiki.addTiddler({ title: "A", text: "", tags: "sortTag"});
-		expect(wiki.filterTiddlers("[tag[sortTag]]").join(',')).toBe("A,B,C");
-	});
-
-	// Tests for issue (#3296)
-	it("should apply tag ordering in order of dependency", function () {
-		var wiki = new $tw.Wiki(wikiOptions);
-
-		wiki.addTiddler({ title: "A", text: "", tags: "sortTag", "list-after": "B"});
-		wiki.addTiddler({ title: "B", text: "", tags: "sortTag", "list-after": "C"});
-		wiki.addTiddler({ title: "C", text: "", tags: "sortTag"});
-
-		expect(wiki.filterTiddlers("[tag[sortTag]]").join(',')).toBe("C,B,A");
-	});
-
-	it("should handle self-referencing dependency without looping infinitely", function() {
-		var wiki = new $tw.Wiki(wikiOptions);
-
-		wiki.addTiddler({ title: "A", text: "", tags: "sortTag"});
-		wiki.addTiddler({ title: "B", text: "", tags: "sortTag", "list-after": "B"});
-		wiki.addTiddler({ title: "C", text: "", tags: "sortTag"});
-
-		expect(wiki.filterTiddlers("[tag[sortTag]]").join(',')).toBe("A,B,C");
-	});
-
-	it("should handle empty list-after ordering", function() {
-		var wiki = new $tw.Wiki(wikiOptions);
-
-		wiki.addTiddler({ title: "A", text: "", tags: "sortTag", "list-after": ""});
-		wiki.addTiddler({ title: "B", text: "", tags: "sortTag"});
-		wiki.addTiddler({ title: "C", text: "", tags: "sortTag"});
-
-		expect(wiki.filterTiddlers("[tag[sortTag]]").join(',')).toBe("B,C,A");
+	describe("With no indexers", function() {
+		var wikiOptions = {enableIndexers: []},
+			wiki = setupWiki(wikiOptions);
+		runTests(wiki,wikiOptions);
 	});
 
-	// If a tiddler in the tag references a tiddler OUTSIDE of the tag
-	// with list-after/before, we need to make sure we don't accidentally
-	// handle that external tiddler, or that reference.
-	it("should gracefully handle dependencies that aren't in the tag list", function() {
-		var wiki = new $tw.Wiki(wikiOptions);
-
-		wiki.addTiddler({ title: "A", text: "", tags: "sortTag"});
-		wiki.addTiddler({ title: "B", text: "", tags: "sortTag", "list-after": "Z"});
-		wiki.addTiddler({ title: "C", text: "", tags: "sortTag"});
-		wiki.addTiddler({ title: "Z", text: "", tags: "EXCLUDED", "list-before": ""});
-
-		expect(wiki.filterTiddlers("[tag[sortTag]]").join(',')).toBe("A,B,C");
+	describe("With all indexers", function() {
+		var wikiOptions = {},
+			wiki = setupWiki();
+		runTests(wiki,wikiOptions);
 	});
 
-	it("should handle javascript-specific titles", function() {
+	function setupWiki(wikiOptions) {
+	// Create a wiki
 		var wiki = new $tw.Wiki(wikiOptions);
 
-		wiki.addTiddler({ title: "A", text: "", tags: "sortTag"});
-		wiki.addTiddler({ title: "__proto__", text: "", tags: "sortTag", "list-before": ""});
-
-		expect(wiki.filterTiddlers("[tag[sortTag]]").join(',')).toBe("__proto__,A");
-	});
+		// Add a few  tiddlers
+		wiki.addTiddler({
+			title: "TiddlerOne",
+			text: "The quick brown fox in $:/TiddlerTwo",
+			tags: ["one","TiddlerSeventh"],
+			modifier: "JoeBloggs",
+			modified: "201304152222"});
+		wiki.addTiddler({
+			title: "$:/TiddlerTwo",
+			text: "The rain in Spain\nfalls mainly on the plain and [[a fourth tiddler]]",
+			tags: ["two"],
+			modifier: "JohnDoe",
+			modified: "201304152211"});
+		wiki.addTiddler({
+			title: "Tiddler Three",
+			text: "The speed of sound in light\n\nThere is no TiddlerZero but TiddlerSix",
+			tags: ["one","two","TiddlerSeventh"],
+			modifier: "JohnDoe",
+			modified: "201304162202"});
+		wiki.addTiddler({
+			title: "a fourth tiddler",
+			text: "The quality of mercy is not drained by [[Tiddler Three]]",
+			tags: ["TiddlerSeventh"],
+			modifier: "JohnDoe"});
+		wiki.addTiddler({
+			title: "one",
+			text: "This is the text of tiddler [[one]]",
+			list: "[[Tiddler Three]] [[TiddlerOne]]",
+			modifier: "JohnDoe"});
+		wiki.addTiddler({
+			title: "$:/TiddlerFive",
+			text: "Everything in federation",
+			tags: ["two"]});
+		wiki.addTiddler({
+			title: "TiddlerSix",
+			text: "Missing inaction from TiddlerOne",
+			tags: []});
+		wiki.addTiddler({
+			title: "TiddlerSeventh",
+			text: "",
+			list: "TiddlerOne [[Tiddler Three]] [[a fourth tiddler]] MissingTiddler",
+			tags: []});
+		wiki.addTiddler({
+			title: "Tiddler8",
+			text: "Tidd",
+			tags: [],
+			"test-field": "JoeBloggs"});
+		wiki.addTiddler({
+			title: "Tiddler9",
+			text: "Another tiddler",
+			tags: ["TiddlerSeventh"],
+			"list-before": "a fourth tiddler"});
+		wiki.addTiddler({
+			title: "Tiddler10",
+			text: "Another tiddler",
+			tags: ["TiddlerSeventh"],
+			"list-before": ""});
+		wiki.addTiddler({
+			title: "Tiddler11",
+			text: "Another tiddler",
+			tags: ["TiddlerSeventh"],
+			"list-after": "Tiddler Three"});
+		return wiki;
+	}
 
-}
+	// Our tests
+	function runTests(wiki,wikiOptions) {
+
+		it("should handle custom tag ordering", function() {
+			expect(wiki.filterTiddlers("[tag[TiddlerSeventh]]").join(",")).toBe("Tiddler10,TiddlerOne,Tiddler Three,Tiddler11,Tiddler9,a fourth tiddler");
+		});
+
+		it("should apply identical tag ordering irrespective of tag creation order", function () {
+			var wiki;
+			wiki = new $tw.Wiki(wikiOptions);
+			wiki.addTiddler({ title: "A", text: "", tags: "sortTag"});
+			wiki.addTiddler({ title: "B", text: "", tags: "sortTag"});
+			wiki.addTiddler({ title: "C", text: "", tags: "sortTag"});
+			expect(wiki.filterTiddlers("[tag[sortTag]]").join(",")).toBe("A,B,C");
+			wiki = new $tw.Wiki(wikiOptions);
+			wiki.addTiddler({ title: "A", text: "", tags: "sortTag"});
+			wiki.addTiddler({ title: "C", text: "", tags: "sortTag"});
+			wiki.addTiddler({ title: "B", text: "", tags: "sortTag"});
+			expect(wiki.filterTiddlers("[tag[sortTag]]").join(",")).toBe("A,B,C");
+			wiki = new $tw.Wiki(wikiOptions);
+			wiki.addTiddler({ title: "C", text: "", tags: "sortTag"});
+			wiki.addTiddler({ title: "B", text: "", tags: "sortTag"});
+			wiki.addTiddler({ title: "A", text: "", tags: "sortTag"});
+			expect(wiki.filterTiddlers("[tag[sortTag]]").join(",")).toBe("A,B,C");
+		});
+
+		// Tests for issue (#3296)
+		it("should apply tag ordering in order of dependency", function () {
+			var wiki = new $tw.Wiki(wikiOptions);
+
+			wiki.addTiddler({ title: "A", text: "", tags: "sortTag", "list-after": "B"});
+			wiki.addTiddler({ title: "B", text: "", tags: "sortTag", "list-after": "C"});
+			wiki.addTiddler({ title: "C", text: "", tags: "sortTag"});
+
+			expect(wiki.filterTiddlers("[tag[sortTag]]").join(",")).toBe("C,B,A");
+		});
+
+		it("should handle self-referencing dependency without looping infinitely", function() {
+			var wiki = new $tw.Wiki(wikiOptions);
+
+			wiki.addTiddler({ title: "A", text: "", tags: "sortTag"});
+			wiki.addTiddler({ title: "B", text: "", tags: "sortTag", "list-after": "B"});
+			wiki.addTiddler({ title: "C", text: "", tags: "sortTag"});
+
+			expect(wiki.filterTiddlers("[tag[sortTag]]").join(",")).toBe("A,B,C");
+		});
+
+		it("should handle empty list-after ordering", function() {
+			var wiki = new $tw.Wiki(wikiOptions);
+
+			wiki.addTiddler({ title: "A", text: "", tags: "sortTag", "list-after": ""});
+			wiki.addTiddler({ title: "B", text: "", tags: "sortTag"});
+			wiki.addTiddler({ title: "C", text: "", tags: "sortTag"});
+
+			expect(wiki.filterTiddlers("[tag[sortTag]]").join(",")).toBe("B,C,A");
+		});
+
+		// If a tiddler in the tag references a tiddler OUTSIDE of the tag
+		// with list-after/before, we need to make sure we don't accidentally
+		// handle that external tiddler, or that reference.
+		it("should gracefully handle dependencies that aren't in the tag list", function() {
+			var wiki = new $tw.Wiki(wikiOptions);
+
+			wiki.addTiddler({ title: "A", text: "", tags: "sortTag"});
+			wiki.addTiddler({ title: "B", text: "", tags: "sortTag", "list-after": "Z"});
+			wiki.addTiddler({ title: "C", text: "", tags: "sortTag"});
+			wiki.addTiddler({ title: "Z", text: "", tags: "EXCLUDED", "list-before": ""});
+
+			expect(wiki.filterTiddlers("[tag[sortTag]]").join(",")).toBe("A,B,C");
+		});
+
+		it("should handle javascript-specific titles", function() {
+			var wiki = new $tw.Wiki(wikiOptions);
+
+			wiki.addTiddler({ title: "A", text: "", tags: "sortTag"});
+			wiki.addTiddler({ title: "__proto__", text: "", tags: "sortTag", "list-before": ""});
+
+			expect(wiki.filterTiddlers("[tag[sortTag]]").join(",")).toBe("__proto__,A");
+		});
+
+	}
 
 });