Developer demo of alternate wiki store implementation

core/modules/filters.js

@@ -171,15 +171,15 @@ exports.parseFilter = function(filterString) {
 				}
 				if(match[3]) {
 					operation.suffixes = [];
-					 $tw.utils.each(match[3].split(":"),function(subsuffix) {
+						$tw.utils.each(match[3].split(":"),function(subsuffix) {
 						operation.suffixes.push([]);
 						$tw.utils.each(subsuffix.split(","),function(entry) {
 							entry = $tw.utils.trim(entry);
 							if(entry) {
 								operation.suffixes[operation.suffixes.length -1].push(entry);
 							}
 						});
-					 });
+						});
 				}
 			}
 			if(match[4]) { // Opening square bracket
@@ -225,73 +225,31 @@ source: an iterator function for the source tiddlers, called source(iterator), w
 widget: an optional widget node for retrieving the current tiddler etc.
 */
 exports.compileFilter = function(filterString) {
-	var self = this;
-	// Use cached filter function if already present
+	// Set up the filter function cache
 	if(!this.filterCache) {
 		this.filterCache = Object.create(null);
 		this.filterCacheCount = 0;
 	}
+	// Use the cached version of this filter function if it exists
 	if(this.filterCache[filterString] !== undefined) {
 		return this.filterCache[filterString];
 	}
-	// Attempt to optimise the filter into a single query
-	var operationFunctions = this.optimiseFilter && this.optimiseFilter(filterString);
-	// Otherwise compile the filter step by step
-	if(!operationFunctions) {
-		// Parse filter
-		var filterParseTree;
-		try {
-			filterParseTree = this.parseFilter(filterString);
-		} catch(e) {
-			// We do not cache this result, so it adjusts along with localization changes
-			return function(source,widget) {
-				return [$tw.language.getString("Error/Filter") + ": " + e];
-			};
-		}
-		// Compile the filter operators into functions
-		operationFunctions = this.compileFilterOperations(filterParseTree);
-	}
-	// Return a function that applies the operations to a source iterator of tiddler titles
-	var fnMeasured = $tw.perf.measure("filter: " + filterString,function filterFunction(source,widget) {
-		if(!source) {
-			source = self.each;
-		} else if(typeof source === "object") { // Array or hashmap
-			source = self.makeTiddlerIterator(source);
-		}
-		if(!widget) {
-			widget = $tw.rootWidget;
-		}
-		var results = new $tw.utils.LinkedList();
-		self.filterRecursionCount = (self.filterRecursionCount || 0) + 1;
-		if(self.filterRecursionCount < MAX_FILTER_DEPTH) {
-			$tw.utils.each(operationFunctions,function(operationFunction) {
-				operationFunction(results,source,widget);
-			});
-		} else {
-			results.push("/**-- Excessive filter recursion --**/");
-		}
-		self.filterRecursionCount = self.filterRecursionCount - 1;
-		return results.toArray();
-	});
-	if(this.filterCacheCount >= 2000) {
-		// To prevent memory leak, we maintain an upper limit for cache size.
-		// Reset if exceeded. This should give us 95% of the benefit
-		// that no cache limit would give us.
-		this.filterCache = Object.create(null);
-		this.filterCacheCount = 0;
+	// Parse the filter string
+	var filterParseTree;
+	try {
+		filterParseTree = this.parseFilter(filterString);
+	} catch(e) {
+		// We do not cache this result, so it adjusts along with localization changes
+		return function(source,widget) {
+			return [$tw.language.getString("Error/Filter") + ": " + e];
+		};
 	}
-	this.filterCache[filterString] = fnMeasured;
-	this.filterCacheCount++;
-	return fnMeasured;
-};
-
-exports.compileFilterOperations = function(filterParseTree) {
-	var self = this;
 	// Get the hashmap of filter operator functions
 	var filterOperators = this.getFilterOperators();
 	// Assemble array of functions, one for each operation
 	var operationFunctions = [];
 	// Step through the operations
+	var self = this;
 	$tw.utils.each(filterParseTree,function(operation) {
 		// Create a function for the chain of operators in the operation
 		var operationSubFunction = function(source,widget) {
@@ -379,7 +337,42 @@ exports.compileFilterOperations = function(filterParseTree) {
 			}
 		})());
 	});
-	return operationFunctions;
+	// Make the filter function
+	var fnFilter = function filterFunction(source,widget) {
+		if(!source) {
+			source = self.each;
+		} else if(typeof source === "object") { // Array or hashmap
+			source = self.makeTiddlerIterator(source);
+		}
+		if(!widget) {
+			widget = $tw.rootWidget;
+		}
+		var results = new $tw.utils.LinkedList();
+		self.filterRecursionCount = (self.filterRecursionCount || 0) + 1;
+		if(self.filterRecursionCount < MAX_FILTER_DEPTH) {
+			$tw.utils.each(operationFunctions,function(operationFunction) {
+				operationFunction(results,source,widget);
+			});
+		} else {
+			results.push("/**-- Excessive filter recursion --**/");
+		}
+		self.filterRecursionCount = self.filterRecursionCount - 1;
+		return results.toArray();
+	};
+	// Return a function that applies the operations to a source iterator of tiddler titles
+	var fnMeasured = $tw.perf.measure("filter: " + filterString,fnFilter);
+	// Cache the measured filter function
+	if(this.filterCacheCount >= 2000) {
+		// To prevent memory leak, we maintain an upper limit for cache size.
+		// Reset if exceeded. This should give us 95% of the benefit
+		// that no cache limit would give us.
+		this.filterCache = Object.create(null);
+		this.filterCacheCount = 0;
+	}
+	this.filterCache[filterString] = fnMeasured;
+	this.filterCacheCount++;
+	return fnMeasured;
 };
 
 })();
+