mirrors/TiddlyWiki5
1
0
Fork 0
mirror of https://github.com/Jermolene/TiddlyWiki5 synced 2025-04-06 10:46:57 +00:00
Code Issues Releases Wiki Activity

Add inspect operator

Browse Source
This commit is contained in:
Jeremy Ruston 2025-04-01 12:06:10 +01:00
parent 961e74f73d
commit d4043fc1f4
4 changed files with 240 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

75
core/modules/filters.js
View File

@ -220,13 +220,22 @@ exports.filterTiddlers = function(filterString,widget,source) {
Compile a filter into a function with the signature fn(source,widget) where:
source: an iterator function for the source tiddlers, called source(iterator), where iterator is called as iterator(tiddler,title)
widget: an optional widget node for retrieving the current tiddler etc.
Parameters:
filterString: the filter string to compile
options: includes:
wrappers: a hashmap of wrapper functions to apply to the compiled filter function
*/
exports.compileFilter = function(filterString) {
exports.compileFilter = function(filterString,options) {
options = options || {};
var self = this;
var wrappers = options.wrappers || {};
if(!this.filterCache) {
this.filterCache = Object.create(null);
this.filterCacheCount = 0;
}
if(this.filterCache[filterString] !== undefined) {
if(this.filterCache[filterString] !== undefined && !wrappers) {
return this.filterCache[filterString];
}
var filterParseTree;
@ -252,17 +261,18 @@ exports.compileFilter = function(filterString) {
currTiddlerTitle = widget && widget.getVariable("currentTiddler");
$tw.utils.each(operation.operators,function(operator) {
var operands = [],
operatorFunction;
operatorName,operatorFunction;
if(!operator.operator) {
// Use the "title" operator if no operator is specified
operatorFunction = filterOperators.title;
operatorName = "title";
} else if(!filterOperators[operator.operator]) {
// Unknown operators treated as "[unknown]" - at run time we can distinguish between a custom operator and falling back to the default "field" operator
operatorFunction = filterOperators["[unknown]"];
operatorName = "[unknown]";
} else {
// Use the operator function
operatorFunction = filterOperators[operator.operator];
operatorName = operator.operator;
}
operatorFunction = filterOperators[operatorName];
$tw.utils.each(operator.operands,function(operand) {
if(operand.indirect) {
operand.value = self.getTextReference(operand.text,"",currTiddlerTitle);
@ -274,10 +284,14 @@ exports.compileFilter = function(filterString) {
}
operands.push(operand.value);
});
// Wrap the filter operator module if required
if(wrappers.operator) {
operatorFunction = wrappers.operator.bind(self,operatorFunction);
}
// Invoke the appropriate filteroperator module
results = operatorFunction(accumulator,{
operator: operator.operator,
operatorName: operatorName,
operand: operands.length > 0 ? operands[0] : undefined,
operands: operands,
prefix: operator.prefix,
@ -307,27 +321,44 @@ exports.compileFilter = function(filterString) {
var filterRunPrefixes = self.getFilterRunPrefixes();
// Wrap the operator functions in a wrapper function that depends on the prefix
operationFunctions.push((function() {
var options = {wiki: self, suffixes: operation.suffixes || []};
var prefixName;
switch(operation.prefix || "") {
case "": // No prefix means that the operation is unioned into the result
return filterRunPrefixes["or"](operationSubFunction, options);
prefixName = "or";
break;
case "=": // The results of the operation are pushed into the result without deduplication
return filterRunPrefixes["all"](operationSubFunction, options);
prefixName = "all";
break;
case "-": // The results of this operation are removed from the main result
return filterRunPrefixes["except"](operationSubFunction, options);
prefixName = "except";
break;
case "+": // This operation is applied to the main results so far
return filterRunPrefixes["and"](operationSubFunction, options);
prefixName = "and";
break;
case "~": // This operation is unioned into the result only if the main result so far is empty
return filterRunPrefixes["else"](operationSubFunction, options);
default:
if(operation.namedPrefix && filterRunPrefixes[operation.namedPrefix]) {
return filterRunPrefixes[operation.namedPrefix](operationSubFunction, options);
} else {
return function(results,source,widget) {
results.clear();
results.push($tw.language.getString("Error/FilterRunPrefix"));
};
}
prefixName = "else";
break;
default:
prefixName = operation.namedPrefix;
break;
}
if(prefixName && filterRunPrefixes[prefixName]) {
var options = {
wiki: self,
suffixes: operation.suffixes || [],
prefixName: prefixName
},
filterRunPrefixFunction = filterRunPrefixes[prefixName];
// Wrap the filter operator module if required
if(wrappers.prefix) {
filterRunPrefixFunction = wrappers.prefix.bind(self,filterRunPrefixFunction);
}
return filterRunPrefixFunction(operationSubFunction,options);
} else {
return function(results,source,widget) {
results.clear();
results.push($tw.language.getString("Error/FilterRunPrefix"));
};
}
})());
});

69
core/modules/filters/inspect.js Normal file
View File

@ -0,0 +1,69 @@
/*\
title: $:/core/modules/filters/inspect.js
type: application/javascript
module-type: filteroperator
Filter operator for inspecting the evaluation of a filter
\*/
"use strict";
/*
Export our filter function
*/
exports.inspect = function(source,operator,options) {
var self = this,
inputFilter = operator.operands[0] || "",
output = {input: [],runs: []},
currentRun;
// Save the input
source(function(tiddler,title) {
output.input.push(title);
});
// Compile the filter with wrapper functions to log the details
var compiledFilter = options.wiki.compileFilter(inputFilter,{
wrappers: {
prefix: function(filterRunPrefixFunction,operationFunction,innerOptions) {
return function(results,innerSource,innerWidget) {
var details ={
prefixName: innerOptions.prefixName,
operators: []
};
currentRun = details.operators;
var innerResults = filterRunPrefixFunction.call(this,operationFunction,innerOptions),
prefixOutput = new $tw.utils.LinkedList();
innerResults(prefixOutput,innerSource,innerWidget);
var prefixOutputArray = prefixOutput.toArray();
details.output = prefixOutputArray;
output.runs.push(details);
results.clear();
$tw.utils.each(prefixOutputArray,function(title) {
results.push(title);
});
};
},
operator: function(operatorFunction,innerSource,innerOperator,innerOptions) {
var details = {
operatorName: innerOperator.operatorName,
operands: innerOperator.operands,
prefix: innerOperator.prefix,
suffix: innerOperator.suffix,
suffixes: innerOperator.suffixes,
regexp: innerOperator.regexp,
input: []
},
innerResults = operatorFunction.apply(self,Array.prototype.slice.call(arguments,1));
innerSource(function(tiddler,title) {
details.input.push(title);
});
currentRun.push(details);
return innerResults;
}
}
});
output.output = compiledFilter.call(this,source,options.widget);
var results = [];
results.push(JSON.stringify(output,null,4));
return results;
};

92
editions/test/tiddlers/tests/data/filter-wrappers/Simple.tid Normal file
View File

@ -0,0 +1,92 @@
title: FiltersWrappers/Simple
description: Test filter inspection
type: text/vnd.tiddlywiki-multiple
tags: [[$:/tags/wiki-test-spec]]
title: Output
\whitespace trim
\procedure test-filter()
1 2 3
\end
\function test-filter-wrapper()
[inspect<test-filter>]
\end
<$text text=<<test-filter>>/>
-
<$text text=<<test-filter-wrapper>>/>
+
title: ExpectedResult
<p>1 2 3-{
"input": [
"$:/core",
"ExpectedResult",
"Output"
],
"runs": [
{
"prefixName": "or",
"operators": [
{
"operatorName": "title",
"operands": [
"1"
],
"input": [
"$:/core",
"ExpectedResult",
"Output"
]
}
],
"output": [
"1"
]
},
{
"prefixName": "or",
"operators": [
{
"operatorName": "title",
"operands": [
"2"
],
"input": [
"$:/core",
"ExpectedResult",
"Output"
]
}
],
"output": [
"2"
]
},
{
"prefixName": "or",
"operators": [
{
"operatorName": "title",
"operands": [
"3"
],
"input": [
"$:/core",
"ExpectedResult",
"Output"
]
}
],
"output": [
"3"
]
}
],
"output": [
"3"
]
}</p>

26
editions/tw5.com/tiddlers/filters/inspect Operator.tid Normal file
View File

@ -0,0 +1,26 @@
caption: inspect
created: 20250401094200994
modified: 20250401094200994
op-input: a [[selection of titles|Title Selection]]
op-output: a JSON object containing the input, output and intermediate results of evaluating the specified filter
op-parameter: the filter to be inspected
op-parameter-name: F
op-purpose: inspect the evaluation of a filter to aid debugging
tags: [[Filter Operators]]
title: inspect Operator
type: text/vnd.tiddlywiki
<<.from-version "5.3.7">> The <<.op inspect>> operator evaluates a filter with the specified input titles and returns a JSON object containing the input, output and intermediate results of evaluating the specified filter.
The JSON object contains the following properties:
* `input`: the input titles passed to the filter
* `output`: the output titles resulting from evaluating the filter
* `runs`: an array of objects, each of which represents a single run of the filter. Each object contains the following properties:
** `prefixName`: the name of the prefix operator that was used in this run
** `operators`: an array of objects, each of which represents a single operator that was used in this run. Each object contains the following properties:
*** `operatorName`: the name of the operator
*** `operands`: an array of string operands passed to the operator
*** `input`: the input titles passed to the operator
** `output`: the output titles resulting from evaluating this run