tiddlywiki 5.3.3 → 5.3.4

package/editions/test/tiddlers/tests/data/macros/unusedtitle/basic-params.tid

@@ -0,0 +1,20 @@
+title: Macros/unusedtitle/basic-params
+description: test <<unusedtitle>> with basic macro parameters
+type: text/vnd.tiddlywiki-multiple
+tags: [[$:/tags/wiki-test-spec]]
+
+title: Output
+
+<<unusedtitle>>
+
+<!-- EDGECASE: separator is ignored if tiddler title does not exist -->
+<<unusedtitle separator:"-">>
+
+<<unusedtitle baseName:"anotherBase">>
+
+<<unusedtitle baseName:"About" separator:"-">>
+
++
+title: ExpectedResult
+
+<p>New Tiddler</p><p>New Tiddler</p><p>anotherBase</p><p>About</p>

package/editions/test/tiddlers/tests/data/macros/unusedtitle/template-empty-params-tiddler-exist.tid

@@ -0,0 +1,50 @@
+title: Macros/unusedtitle/template-empty-params-tiddler-exist
+description: test <<unusedtitle>> with templates where parameters are empty
+type: text/vnd.tiddlywiki-multiple
+tags: [[$:/tags/wiki-test-spec]]
+
+title: New Tiddler
+
++
+title: xxx
+
++
+title: 00-New Tiddler
+
++
+title: 0000 asdf
+
++
+title: 0001 asdf
+
++
+title: 0000 abc
+
++
+title: Output
+
+<!-- empty template - no template handling at all -->
+<<unusedtitle template:"">>
+
+<!--
+	uses basename AND separator if tiddler exists
+	because it uses default naming build rules - no template handling
+-->
+<<unusedtitle template:"" separator:"-y-" baseName:"xxx">>
+
+<<unusedtitle baseName:"" template:"$count:2$-$basename$">>
+
+<!-- 
+	EDGECASE: if separator is empty it will be initialized with a single space " "
+	to have the same rules for templates and default title creation
+-->
+<<unusedtitle baseName:"asdf" separator:"" template:"$count:4$$separator$$basename$">>
+
+<!-- separator = " " -->
+<<unusedtitle baseName:"abc" separator:" " template:"$count:4$$separator$$basename$">>
+
+
++
+title: ExpectedResult
+
+<p>New Tiddler 1</p><p>xxx-y-1</p><p>01-New Tiddler</p><p>0002 asdf</p><p>0001 abc</p>

package/editions/test/tiddlers/tests/data/macros/unusedtitle/template-empty-params.tid

@@ -0,0 +1,24 @@
+title: Macros/unusedtitle/template-empty-params
+description: test <<unusedtitle>> with templates where parameters are empty
+type: text/vnd.tiddlywiki-multiple
+tags: [[$:/tags/wiki-test-spec]]
+
+title: Output
+
+<!-- empty template -->
+<<unusedtitle template:"">>
+
+<!--
+	uses basename but ignores separator,
+	because it uses default naming build rules -- no template handling is active
+-->
+<<unusedtitle template:"" separator:"-x-" baseName:"xxx">>
+
+<<unusedtitle baseName:"" template:"$count:2$-$basename$">>
+
+<<unusedtitle baseName:"asdf" separator:"" template:"$count:4$$separator$$basename$">>
+
++
+title: ExpectedResult
+
+<p>New Tiddler</p><p>xxx</p><p>00-New Tiddler</p><p>0000 asdf</p>

package/editions/test/tiddlers/tests/data/macros/unusedtitle/template.tid

@@ -0,0 +1,28 @@
+title: Macros/unusedtitle/template
+description: test <<unusedtitle>> with templates
+type: text/vnd.tiddlywiki-multiple
+tags: [[$:/tags/wiki-test-spec]]
+
+title: Output
+
+<!-- empty template - standard rules are used -->
+<<unusedtitle template:"">>
+
+<<unusedtitle template:"count-missing">>
+
+<<unusedtitle template:"$count:2$-new">>
+
+<!-- template is handled using $tw.utils.formatTitleString -->
+<<unusedtitle baseName:"base" template:"$count:2$-$basename$">>
+
+<<unusedtitle baseName:"" template:"$count:2$-$basename$">>
+
+<!-- UPPERCASES are intentional in template strings. They should be case-insensistive -->
+<<unusedtitle baseName:"asdf" separator:"-" template:"$coUNT:2$$sepaRATor$$baseName$">>
+
+<<unusedtitle baseName:"asdf" separator:"" template:"$count:2$$separator$$basename$">>
+
++
+title: ExpectedResult
+
+<p>New Tiddler</p><p>count-missing</p><p>00-new</p><p>00-base</p><p>00-New Tiddler</p><p>00-asdf</p><p>00 asdf</p>

package/editions/test/tiddlers/tests/data/pragmas/WhitespaceAfterPragma.tid

@@ -58,7 +58,10 @@ title: ExpectedResult
                 "value": "Something"
             }
         ],
-        "isProcedureDefinition": true
+        "isProcedureDefinition": true,
+        "start": 0,
+        "end": 43,
+        "rule": "fnprocdef"
     }
 ]
 </p>

package/editions/test/tiddlers/tests/data/procedures/EndInBody.tid

@@ -0,0 +1,16 @@
+title: Procedures/EndInBody
+description: \end line starting with non-whitespace is part of procedure body
+type: text/vnd.tiddlywiki-multiple
+tags: [[$:/tags/wiki-test-spec]]
+
+title: Output
+
+\procedure hello()
+ hello \end
+\end
+
+Out: <<hello>>
++
+title: ExpectedResult
+
+<p>Out:  hello \end</p>

package/editions/test/tiddlers/tests/data/procedures/IndentedEnd.tid

@@ -0,0 +1,16 @@
+title: Procedures/IndentedEnd
+description: \end line starting with whitespace ends a procedure body
+type: text/vnd.tiddlywiki-multiple
+tags: [[$:/tags/wiki-test-spec]]
+
+title: Output
+
+\procedure hello()
+ hello \end
+  \end
+
+Out: <<hello>>
++
+title: ExpectedResult
+
+<p>Out:  hello \end</p>

package/editions/test/tiddlers/tests/data/procedures/MismatchedNamedEnd.tid

@@ -0,0 +1,16 @@
+title: Procedures/MismatchedNamedEnd
+description: Mismatched named end is part of the body
+type: text/vnd.tiddlywiki-multiple
+tags: [[$:/tags/wiki-test-spec]]
+
+title: Output
+
+\procedure hello()
+ \end goodbye
+\end
+
+Out: <<hello>>
++
+title: ExpectedResult
+
+<p>Out:  \end goodbye</p>

package/editions/test/tiddlers/tests/data/procedures/WhitespaceOnlyWithEnd.tid

@@ -0,0 +1,18 @@
+title: Procedures/WhitespaceOnlyWithEnd
+description: The /end should be detected when procedure definition contains only whitespace
+type: text/vnd.tiddlywiki-multiple
+tags: [[$:/tags/wiki-test-spec]]
+
+title: Output
+
+\procedure max()
+\end
+Nothing
+\end
+
+Out: <<max>>
++
+title: ExpectedResult
+
+<p>Nothing
+\end</p><p>Out: </p>

package/editions/test/tiddlers/tests/data/procedures/WhitespaceOnlyWithEnd2.tid

@@ -0,0 +1,15 @@
+title: Procedures/WhitespaceOnlyWithEnd2
+description: Line with \end can start with whitespace
+type: text/vnd.tiddlywiki-multiple
+tags: [[$:/tags/wiki-test-spec]]
+
+title: Output
+
+\procedure empty()
+ \end
+
+Out: <<empty>>
++
+title: ExpectedResult
+
+<p>Out: </p>

package/editions/test/tiddlers/tests/data/transclude/Procedures-Whitespace2.tid

@@ -0,0 +1,25 @@
+title: Transclude/Procedures/Whitespace2
+description: Procedures should inherit whitespace settings from definition site
+type: text/vnd.tiddlywiki-multiple
+tags: [[$:/tags/wiki-test-spec]]
+
+title: Output
+
+\procedure testproc()
+This is a sentence    
+\end
+
+\define testmacro()
+This is a sentence    
+\end
+This is a sentence
+[<<testproc>>]
+[<<testmacro>>]
+
++
+title: ExpectedResult
+
+<p>This is a sentence
+[This is a sentence    ]
+[This is a sentence    ]
+</p>

package/editions/test/tiddlers/tests/data/transclude/Procedures-Whitespace3.tid

@@ -0,0 +1,30 @@
+title: Transclude/Procedures/Whitespace3
+description: Procedures should inherit whitespace settings from definition site
+type: text/vnd.tiddlywiki-multiple
+tags: [[$:/tags/wiki-test-spec]]
+
+title: Output
+
+\import Definitions
+
+This is a sentence
+[<<testproc>>]
+[<<testmacro>>]
+
++
+title: Definitions
+
+\procedure testproc()
+This is a sentence    
+\end
+
+\define testmacro()
+This is a sentence    
+\end
++
+title: ExpectedResult
+
+<p>This is a sentence
+[This is a sentence    ]
+[This is a sentence    ]
+</p>

package/editions/test/tiddlers/tests/data/transclude/Recursion.tid

@@ -7,7 +7,8 @@ title: Output
 
 \whitespace trim
 <$transclude $tiddler="Output"/>
+
 +
 title: ExpectedResult
 
-<p><span class="tc-error">Recursive transclusion error in transclude widget</span></p>
+<span class="tc-error">Recursive transclusion error in transclude widget</span>

package/editions/test/tiddlers/tests/from-tw5.com/tiddlywiki.files

@@ -0,0 +1,5 @@
+{
+	"directories": [
+		"../../../../tw5.com/tiddlers/testcases"
+	]
+}

package/editions/test/tiddlers/tests/test-action-deletefield.js

@@ -0,0 +1,176 @@
+/*\
+title: test-action-deletefield.js
+type: application/javascript
+tags: [[$:/tags/test-spec]]
+
+Tests <$action-deletefield />.
+
+\*/
+(function(){
+
+/* 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("<$action-deletefield /> tests", function() {
+
+const TEST_TIDDLER_TITLE = "TargetTiddler";
+const TEST_TIDDLER_MODIFIED = "20240313114828368";
+
+function setupWiki(condition, targetField, wikiOptions) {
+	// Create a wiki
+	var wiki = new $tw.Wiki({});
+	var tiddlers = [{
+		title: "Root",
+		text: "Some dummy content"
+	}];
+	var tiddler;
+	if(condition.targetTiddlerExists) {
+		var fields = {
+			title: TEST_TIDDLER_TITLE,
+		};
+		if(condition.modifiedFieldExists) {
+			fields.modified = TEST_TIDDLER_MODIFIED;
+		}
+		if(condition.targetFieldExists) {
+			fields[targetField] = "some text";
+		}
+		var tiddler = new $tw.Tiddler(fields);
+		tiddlers.push(tiddler);
+	}
+	wiki.addTiddlers(tiddlers);
+	wiki.addIndexersToWiki();
+	var widgetNode = wiki.makeTranscludeWidget("Root",{document: $tw.fakeDocument, parseAsInline: true});
+	var container = $tw.fakeDocument.createElement("div");
+	widgetNode.render(container,null);
+	return {
+		wiki: wiki,
+		widgetNode: widgetNode,
+		contaienr: container,
+		tiddler: tiddler,
+	};
+}
+
+function generateTestConditions() {
+	var conditions = [];
+
+	$tw.utils.each([true, false], function(tiddlerArgumentIsPresent) {
+		$tw.utils.each([true, false], function(targetTiddlerExists) {
+			$tw.utils.each([true, false], function(targetFieldExists) {
+				$tw.utils.each([true, false], function(fieldArgumentIsUsed) {
+					$tw.utils.each([true, false], function(modifiedFieldExists) {
+						$tw.utils.each(["", "yes", "no"], function(timestampArgument) {
+							conditions.push({
+								tiddlerArgumentIsPresent: tiddlerArgumentIsPresent,
+								targetTiddlerExists: targetTiddlerExists,
+								targetFieldExists: targetFieldExists,
+								fieldArgumentIsUsed: fieldArgumentIsUsed,
+								modifiedFieldExists: modifiedFieldExists,
+								timestampArgument: timestampArgument,
+							});
+						});
+					});
+				});
+			});
+		});
+	});
+
+	return conditions;
+}
+
+function generateActionWikitext(condition, targetField) {
+	var actionPieces = [
+		"<$action-deletefield",
+		(condition.tiddlerArgumentIsPresent ? "$tiddler='" + TEST_TIDDLER_TITLE + "'" : ""),
+		(condition.fieldArgumentIsUsed ? "$field='" + targetField + "'" : targetField),
+		(condition.timestampArgument !== "" ? "$timestamp='" + condition.timestampArgument + "'" : ""),
+		"/>",
+	];
+
+	return actionPieces.join(" ");
+}
+
+function generateTestContext(action, tiddler) {
+	var expectationContext = "action: " + action + "\ntiddler:\n\n";
+	if(tiddler) {
+		expectationContext += tiddler.getFieldStringBlock({exclude: ["text"]});
+		if(tiddler.text) {
+			expectationContext += "\n\n" + tiddler.text;
+		}
+		expectationContext += "\n\n";
+	} else {
+		expectationContext += "null";
+	}
+
+	return expectationContext;
+}
+
+it("should correctly delete fields", function() {
+	var fields = ['caption', 'description', 'text'];
+
+	var conditions = generateTestConditions();
+
+	$tw.utils.each(conditions, function(condition) {
+		$tw.utils.each(fields, function(field) {
+			var info = setupWiki(condition, field);
+			var originalTiddler = info.tiddler;
+
+			var invokeActions = function(actions) {
+				info.widgetNode.invokeActionString(actions,info.widgetNode,null,{
+					currentTiddler: TEST_TIDDLER_TITLE,
+				});
+			};
+
+			var action = generateActionWikitext(condition,field);
+
+			invokeActions(action);
+
+			var testContext = generateTestContext(action,originalTiddler);
+
+			var tiddler = info.wiki.getTiddler(TEST_TIDDLER_TITLE);
+			if(originalTiddler) {
+				// assert that the tiddler doesn't have the target field anymore
+				expect(tiddler.hasField(field)).withContext(testContext).toBeFalsy();
+
+				var targetFieldWasPresent = originalTiddler.hasField(field);
+				var updateTimestamps = condition.timestampArgument !== "no";
+
+				// "created" should exist if it did beforehand, or if the tiddler changed and we asked the widget to update timestamps
+				var createdFieldShouldExist = originalTiddler.hasField("created") || (targetFieldWasPresent && updateTimestamps);
+
+				// "created" should change only if it didn't exist beforehand and the tiddler changed and we asked the widget to update timestamps
+				var createdFieldShouldChange = !originalTiddler.hasField("created") && (targetFieldWasPresent && updateTimestamps);
+
+				// "modified" should exist if it did beforehand, or if the tiddler changed and we asked the widget to update timestamps
+				var modifiedFieldShouldExist = originalTiddler.hasField("modified") || (targetFieldWasPresent && updateTimestamps);
+
+				// "modified" should change if the tiddler changed and we asked the widget to update timestamps
+				var modifiedFieldShouldChange = targetFieldWasPresent && updateTimestamps;
+
+				expect(tiddler.hasField("created")).withContext(testContext).toBe(createdFieldShouldExist);
+				expect(tiddler.hasField("modified")).withContext(testContext).toBe(modifiedFieldShouldExist);
+
+				if(createdFieldShouldChange) {
+					expect(tiddler.fields.created).withContext(testContext).not.toEqual(originalTiddler.fields.created);
+				} else {
+					expect(tiddler.fields.created).withContext(testContext).toEqual(originalTiddler.fields.created);
+				}
+
+				if(modifiedFieldShouldChange) {
+					expect(tiddler.fields.modified).withContext(testContext).not.toEqual(originalTiddler.fields.modified);
+				} else {
+					expect(tiddler.fields.modified).withContext(testContext).toEqual(originalTiddler.fields.modified);
+				}
+			} else {
+				// assert that the tiddler didn't get created if it didn't exist already
+				expect(tiddler).withContext(testContext).toBeUndefined();
+			}
+		});
+	});
+});
+
+});
+
+})();

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

@@ -12,6 +12,24 @@ Tests the backlinks mechanism.
 "use strict";
 
 describe('Backlinks tests', function() {
+	function setupWiki(wikiOptions) {
+		wikiOptions = wikiOptions || {};
+		// Create a wiki
+		var wiki = new $tw.Wiki(wikiOptions);
+		wiki.addIndexersToWiki();
+
+		wiki.addTiddler({
+			title: 'TestIncoming',
+			text: '',
+		});
+		
+		wiki.addTiddler({
+			title: 'TestOutgoing',
+			text: 'A link to [[TestIncoming]]',
+		});
+		return wiki;
+	}
+
 	describe('a tiddler with no links to it', function() {
 		var wiki = new $tw.Wiki();
 
@@ -25,15 +43,7 @@ describe('Backlinks tests', function() {
 	});
 
 	describe('A tiddler added to the wiki with a link to it', function() {
-		var wiki = new $tw.Wiki();
-
-		wiki.addTiddler({
-			title: 'TestIncoming',
-			text: ''});
-
-		wiki.addTiddler({
-			title: 'TestOutgoing',
-			text: 'A link to [[TestIncoming]]'});
+		var wiki = setupWiki();
 
 		it('should have a backlink', function() {
 			expect(wiki.filterTiddlers('TestIncoming +[backlinks[]]').join(',')).toBe('TestOutgoing');
@@ -42,15 +52,7 @@ describe('Backlinks tests', function() {
 
 	describe('A tiddler that has a link added to it later', function() {
 		it('should have an additional backlink', function() {
-			var wiki = new $tw.Wiki();
-
-			wiki.addTiddler({
-				title: 'TestIncoming',
-				text: ''});
-
-			wiki.addTiddler({
-				title: 'TestOutgoing',
-				text: 'A link to [[TestIncoming]]'});
+			var wiki = setupWiki();
 
 			wiki.addTiddler({
 				title: 'TestOutgoing2',
@@ -67,15 +69,7 @@ describe('Backlinks tests', function() {
 	});
 
 	describe('A tiddler that has a link remove from it later', function() {
-		var wiki = new $tw.Wiki();
-
-		wiki.addTiddler({
-			title: 'TestIncoming',
-			text: ''});
-
-		wiki.addTiddler({
-			title: 'TestOutgoing',
-			text: 'A link to [[TestIncoming]]'});
+		var wiki = setupWiki();
 
 		it('should have one fewer backlink', function() {
 			expect(wiki.filterTiddlers('TestIncoming +[backlinks[]]').join(',')).toBe('TestOutgoing');
@@ -89,15 +83,7 @@ describe('Backlinks tests', function() {
 	});
 
 	describe('A tiddler linking to another that gets renamed', function() {
-		var wiki = new $tw.Wiki();
-
-		wiki.addTiddler({
-			title: 'TestIncoming',
-			text: ''});
-
-		wiki.addTiddler({
-			title: 'TestOutgoing',
-			text: 'A link to [[TestIncoming]]'});
+		var wiki = setupWiki();
 
 		it('should have its name changed in the backlinks', function() {
 			expect(wiki.filterTiddlers('TestIncoming +[backlinks[]]').join(',')).toBe('TestOutgoing');
@@ -109,22 +95,49 @@ describe('Backlinks tests', function() {
 	});
 
 	describe('A tiddler linking to another that gets deleted', function() {
-		var wiki = new $tw.Wiki();
+		var wiki = setupWiki();
+
+		it('should be removed from backlinks', function() {
+			expect(wiki.filterTiddlers('TestIncoming +[backlinks[]]').join(',')).toBe('TestOutgoing');
+
+			wiki.deleteTiddler('TestOutgoing');
+
+			expect(wiki.filterTiddlers('TestIncoming +[backlinks[]]').join(',')).toBe('');
+		});
+	});
+
+	describe('Binary tiddlers should not be parsed', function() {
+		var wiki = setupWiki();
 
 		wiki.addTiddler({
-			title: 'TestIncoming',
-			text: ''});
+			title: 'TestDoc.doc',
+			text: 'A link to [[TestOutgoing]]',
+			type: 'application/msword'
+		});
+
+		wiki.addTiddler({
+			title: 'TestExcel.xls',
+			text: 'A link to [[TestOutgoing]]',
+			type: 'application/excel'
+		});
 
 		wiki.addTiddler({
 			title: 'TestOutgoing',
-			text: 'A link to [[TestIncoming]]'});
+			text: 'Some links to [[TestDoc.doc]] and [[TestExcel.xls]].'
+		});
 
-		it('should be removed from backlinks', function() {
-			expect(wiki.filterTiddlers('TestIncoming +[backlinks[]]').join(',')).toBe('TestOutgoing');
+		it('should ignore office files', function() {
+			expect(wiki.getIndexer("BackIndexer").subIndexers.link._getTarget(wiki.getTiddler('TestExcel.xls'))).toEqual([]);
 
-			wiki.deleteTiddler('TestOutgoing');
+			expect(wiki.filterTiddlers('[all[]] +[backlinks[]]').join(',')).toBe('TestOutgoing');
+			
+			// make it tw5 tiddler
+			wiki.addTiddler({
+				title: 'TestExcel.xls',
+				text: 'A link to [[TestOutgoing]]'
+			});
 
-			expect(wiki.filterTiddlers('TestIncoming +[backlinks[]]').join(',')).toBe('');
+			expect(wiki.filterTiddlers('[all[]] +[backlinks[]]').join(',')).toBe('TestOutgoing,TestExcel.xls');
 		});
 	});
 });