mirror of
https://github.com/Jermolene/TiddlyWiki5
synced 2024-08-31 21:42:49 +00:00
a1c8ac624f
There are still some whitespace and attribute ordering issues, but the result runs correctly.
520 lines
17 KiB
JavaScript
Executable File
520 lines
17 KiB
JavaScript
Executable File
// <![CDATA[
|
|
describe('Wikifier: getParser()', {
|
|
|
|
before_each: function(){
|
|
formatter = new Formatter(config.formatters);
|
|
},
|
|
|
|
after_each: function() {
|
|
formatter = null;
|
|
},
|
|
|
|
'it should return the default formatter if no tiddler argument is provided': function() {
|
|
var actual = getParser(null,null);
|
|
console.log(actual);
|
|
var expected = formatter;
|
|
console.log(expected);
|
|
value_of(actual).should_be(expected);
|
|
},
|
|
|
|
'it should return the default formatter if no format argument is provided and the tiddler has no "wikiformat" field and is not tagged with the value of formatTag of a member of config.parsers': function() {
|
|
var t = new Tiddler("t");
|
|
var actual = getParser(t,null);
|
|
var expected = formatter;
|
|
value_of(actual).should_be(expected);
|
|
},
|
|
|
|
'it should return the default formatter if a format argument is provided, but does not appear as a value of formatTag of a member of config.parsers; the tiddler has no "wikiformat" field and is not tagged with the value of formatTag from a member of config.parsers': function() {
|
|
var t = new Tiddler("t");
|
|
var actual = getParser(t,"nomatch");
|
|
var expected = formatter;
|
|
value_of(actual).should_be(expected);
|
|
},
|
|
|
|
'it should return the default formatter if the tiddler has a "wikiformat" field that does not appear as a value of formatTag of a member of config.parsers; no format argument is provided and the tiddler is not tagged with the value of formatTag from a member of config.parsers': function() {
|
|
var t = new Tiddler("t");
|
|
t.fields.wikiformat = "nomatch";
|
|
var actual = getParser(t,null);
|
|
var expected = formatter;
|
|
value_of(actual).should_be(expected);
|
|
},
|
|
|
|
'it should return the formatter specified by the "wikiformat" field even if a format tag is provided; no format parameter is provided': function() {
|
|
var t = new Tiddler("t");
|
|
t.fields.wikiformat = "format_field";
|
|
t.tags.push("format_tag");
|
|
config.parsers.field = {
|
|
format: "format_field"
|
|
};
|
|
config.parsers.tag = {
|
|
formatTag: "format_tag"
|
|
};
|
|
var actual = getParser(t,null);
|
|
var expected = config.parsers.field;
|
|
value_of(actual).should_be(expected);
|
|
},
|
|
|
|
'it should return the formatter specified by the format tag; the tiddler has no "wikiformat" field and no format parameter is provided': function() {
|
|
var t = new Tiddler("t");
|
|
t.tags.push("format_tag");
|
|
config.parsers.tag = {
|
|
formatTag: "format_tag"
|
|
};
|
|
var actual = getParser(t,null);
|
|
var expected = config.parsers.tag;
|
|
value_of(actual).should_be(expected);
|
|
},
|
|
|
|
'it should return the formatter specified by the format parameter even if a format tag and a "wikiformat" field are provided': function() {
|
|
var t = new Tiddler("t");
|
|
t.fields.wikiformat = "format_field";
|
|
t.tags.push("format_tag");
|
|
config.parsers.field = {
|
|
format: "format_field"
|
|
};
|
|
config.parsers.tag = {
|
|
formatTag: "format_tag"
|
|
};
|
|
config.parsers.parameter = {
|
|
format: "format_parameter"
|
|
};
|
|
var actual = getParser(t,"format_parameter");
|
|
var expected = config.parsers.parameter;
|
|
value_of(actual).should_be(expected);
|
|
}
|
|
});
|
|
|
|
describe('Wikifier: wikify()', {
|
|
|
|
before_each: function() {
|
|
place = document.createElement("div");
|
|
d = document.body.appendChild(place);
|
|
d.style.display = "none";
|
|
},
|
|
|
|
after_each: function() {
|
|
removeNode(d);
|
|
},
|
|
|
|
'it should not call subWikify() if the "source" parameter is not provided': function() {
|
|
var funcToMock = 'Wikifier.prototype.subWikify';
|
|
tests_mock.before(funcToMock);
|
|
wikify();
|
|
var actual = tests_mock.after(funcToMock).called;
|
|
value_of(actual).should_be_false();
|
|
},
|
|
|
|
'it should not call subWikify() if the "source" parameter is an empty string': function() {
|
|
var funcToMock = 'Wikifier.prototype.subWikify';
|
|
tests_mock.before(funcToMock);
|
|
var source = "";
|
|
wikify(source);
|
|
value_of(tests_mock.after(funcToMock).called).should_be_false();
|
|
},
|
|
|
|
'it should call subWikify()': function() {
|
|
var funcToMock = 'Wikifier.prototype.subWikify';
|
|
tests_mock.before(funcToMock);
|
|
var source = "hello";
|
|
wikify(source);
|
|
value_of(tests_mock.after(funcToMock).called).should_be(true);
|
|
}
|
|
});
|
|
|
|
describe('Wikifier: wikifyStatic()', {
|
|
'testing input strings for Formatter.characterFormat': function() {
|
|
wikifier_input_strings = {
|
|
bold:"''bold''",
|
|
italic:"//italic//",
|
|
underline:"__underline__",
|
|
superscript:"^^superscript^^",
|
|
subscript:"~~subscript~~",
|
|
strikeout:"--strikeout--",
|
|
code:"{{{code}}}"
|
|
};
|
|
|
|
wikifier_output_strings = {
|
|
bold:"<strong>bold</strong>",
|
|
italic:"<em>italic</em>",
|
|
underline:"<u>underline</u>",
|
|
superscript:"<sup>superscript</sup>",
|
|
subscript:"<sub>subscript</sub>",
|
|
strikeout:"<strike>strikeout</strike>",
|
|
code:"<code>code</code>"
|
|
};
|
|
|
|
formatter = new Formatter(config.formatters);
|
|
var actual = "";
|
|
var expected = "";
|
|
for (var i in wikifier_input_strings) {
|
|
actual = wikifyStatic(wikifier_input_strings[i]).toLowerCase();
|
|
expected = wikifier_output_strings[i];
|
|
value_of(actual).should_be(expected);
|
|
}
|
|
},
|
|
'testing table formatting': function() {
|
|
formatter = new Formatter(config.formatters);
|
|
var expected = '<table class="twtable"><tbody><tr class="evenrow"><td>a</td><td>b</td></tr><tr class="oddrow"><td>c</td><td>d</td></tr></tbody></table>';
|
|
var actual = wikifyStatic("|a|b|\n|c|d|").toLowerCase();
|
|
value_of(actual).should_be(expected);
|
|
}
|
|
/*'table surrounded by character formatting should not cause infinite loop': function() {
|
|
formatter = new Formatter(config.formatters);
|
|
var actual = wikifyStatic("''|a|b|\n|c|d|''").toLowerCase();
|
|
value_of(true).should_be_true(); // just check that above line did not cause infinite loop
|
|
}*/
|
|
});
|
|
|
|
describe('Wikifier: wikifyStatic()', {
|
|
before_each: function() {
|
|
place = document.createElement("div");
|
|
d = document.body.appendChild(place);
|
|
d.style.display = "none";
|
|
source = "some text";
|
|
},
|
|
|
|
after_each: function() {
|
|
removeNode(d);
|
|
},
|
|
|
|
'it should return an empty string if source does not exist or is an empty string': function() {
|
|
var expected = "";
|
|
var actual = wikifyStatic(null);
|
|
value_of(actual).should_be(expected);
|
|
actual = wikifyStatic("");
|
|
value_of(actual).should_be(expected);
|
|
},
|
|
|
|
'it should not require a tiddler to work': function() {
|
|
var actual = wikifyStatic(source);
|
|
value_of(actual).should_not_be_null();
|
|
},
|
|
|
|
'it should call subWikify() with the pre block as the only parameter': function() {
|
|
var funcToMock = 'Wikifier.prototype.subWikify';
|
|
tests_mock.before(funcToMock,function() {
|
|
tests_mock.frame[funcToMock].funcArgs = arguments;
|
|
});
|
|
wikifyStatic(source);
|
|
var tests_mock_return = tests_mock.after(funcToMock);
|
|
var expected = "PRE";
|
|
value_of(tests_mock_return.called).should_be(true);
|
|
value_of(tests_mock_return.funcArgs.length).should_be(1);
|
|
value_of(tests_mock_return.funcArgs[0].nodeName).should_be(expected);
|
|
},
|
|
|
|
'it should return a text string': function() {
|
|
var expected = "string";
|
|
var actual = typeof wikifyStatic(source);
|
|
},
|
|
|
|
'it should not leave any elements attached to the document body after returning': function() {
|
|
var expected = document.body.childNodes.length;
|
|
var html = wikifyStatic(source);
|
|
var actual = document.body.childNodes.length;
|
|
value_of(actual).should_be(expected);
|
|
}
|
|
});
|
|
|
|
describe('Wikifier: wikifyPlain', {
|
|
|
|
before_each: function() {
|
|
store = new TiddlyWiki();
|
|
loadShadowTiddlers();
|
|
store.saveTiddler("t","t","text");
|
|
formatter = new Formatter(config.formatters);
|
|
},
|
|
|
|
'it should use the store if only a title parameter is provided': function() {
|
|
var actual = wikifyPlain("t");
|
|
value_of(actual).should_not_be_null();
|
|
},
|
|
|
|
'it should call wikifyPlainText() if the tiddler exists in the store or is a shadow tiddler': function() {
|
|
tests_mock.before('wikifyPlainText');
|
|
wikifyPlain("t");
|
|
var actual = tests_mock.after('wikifyPlainText').called;
|
|
value_of(actual).should_be_true();
|
|
},
|
|
|
|
'it should call wikifyPlainText() if the tiddler is a shadow tiddler': function() {
|
|
|
|
var t = store.isShadowTiddler("SiteTitle");
|
|
value_of(t).should_be_true();
|
|
mockVars = tests_mock.before('wikifyPlainText');
|
|
wikifyPlain("SiteTitle");
|
|
var actual = tests_mock.after('wikifyPlainText').called;
|
|
value_of(actual).should_be_true();
|
|
},
|
|
|
|
'it should return an empty string if the tiddler is not in the store or a shadow tiddler': function() {
|
|
var tiddler = store.getTiddler("foo");
|
|
value_of(tiddler).should_be(null);
|
|
var actual = wikifyPlain("foo");
|
|
var expected = "";
|
|
value_of(actual).should_be(expected);
|
|
}
|
|
});
|
|
|
|
describe('Wikifier: wikifyPlainText', {
|
|
|
|
before_each: function() {
|
|
store = new TiddlyWiki();
|
|
loadShadowTiddlers();
|
|
formatter = new Formatter(config.formatters);
|
|
},
|
|
|
|
'if a limit parameter is provided and the input text is greater in length than the limit, the number of characters generated should equal the limit': function() {
|
|
var limit = 5;
|
|
var source = "aphraseof21characters";
|
|
var actual = wikifyPlainText(source,limit).length;
|
|
var expected = limit;
|
|
value_of(actual).should_be(expected);
|
|
},
|
|
|
|
'it should call Wikifier.prototype.wikifyPlain()': function() {
|
|
tests_mock.before('Wikifier.prototype.wikifyPlain');
|
|
wikifyPlainText("hello",1,new Tiddler("temp"));
|
|
var actual = tests_mock.after('Wikifier.prototype.wikifyPlain').called;
|
|
value_of(actual).should_be_true();
|
|
},
|
|
|
|
'it should take an optional tiddler parameter that sets the context for the wikification': function() {
|
|
var tiddler = new Tiddler("temp");
|
|
var source = "<<view text>>";
|
|
tiddler.text = "the text of a tiddler";
|
|
var expected = tiddler.text;
|
|
store.saveTiddler("temp","temp",tiddler.text);
|
|
var actual = wikifyPlainText(source,null,tiddler);
|
|
value_of(actual).should_be(expected);
|
|
}
|
|
});
|
|
|
|
describe('Wikifier: highlightify', {
|
|
|
|
before_each: function() {
|
|
output = document.body.appendChild(document.createElement("div"));
|
|
source = "test text";
|
|
highlightregexp = new RegExp("text","img");
|
|
tiddler = new Tiddler("temp");
|
|
},
|
|
|
|
'it should not add anything to the "output" element if the source parameter is empty': function() {
|
|
var actual = highlightify(null,output);
|
|
value_of(actual).shoufld_be_null;
|
|
},
|
|
|
|
'it should highlight output text by wrapping with a span of class "highlight"': function() {
|
|
var expected = 'test <span class="highlight">text</span>';
|
|
highlightify(source,output,highlightregexp,tiddler);
|
|
// value in IE is: test <SPAN class=highlight>text</SPAN>
|
|
// note SPAN is capitals and no quotes
|
|
actual = output.innerHTML;
|
|
value_of(actual).should_be(expected);
|
|
},
|
|
|
|
after_each: function() {
|
|
removeNode(output);
|
|
}
|
|
|
|
});
|
|
|
|
describe('Wikifier: Wikifier()', {
|
|
|
|
'it should return a Wikifier object': function() {
|
|
var actual = new Wikifier();
|
|
value_of(actual instanceof Wikifier).should_be_true();
|
|
},
|
|
|
|
'it should return an object with properties source, output, formatter, nextMatch, autoLinkWikiWords, highlightRegExp, highlightMatch, isStatic, tiddler': function() {
|
|
var actual = new Wikifier();
|
|
value_of(actual.hasOwnProperty("source")).should_be_true();
|
|
value_of(actual.hasOwnProperty("output")).should_be_true();
|
|
value_of(actual.hasOwnProperty("formatter")).should_be_true();
|
|
value_of(actual.hasOwnProperty("nextMatch")).should_be_true();
|
|
value_of(actual.hasOwnProperty("autoLinkWikiWords")).should_be_true();
|
|
value_of(actual.hasOwnProperty("highlightRegExp")).should_be_true();
|
|
value_of(actual.hasOwnProperty("highlightMatch")).should_be_true();
|
|
value_of(actual.hasOwnProperty("isStatic")).should_be_true();
|
|
value_of(actual.hasOwnProperty("tiddler")).should_be_true();
|
|
|
|
}
|
|
|
|
});
|
|
|
|
describe('Wikifier: wikifyPlain', {
|
|
|
|
'it should return the plain text value of the return value of this.subWikify()': function() {
|
|
store = new TiddlyWiki();
|
|
formatter = new Formatter(config.formatters);
|
|
var source = "a StringWith some [[wikitext]] ''inside''";
|
|
var w = new Wikifier(source,formatter);
|
|
var actual = w.wikifyPlain();
|
|
var expected = "a StringWith some wikitext inside";
|
|
value_of(actual).should_be(expected);
|
|
}
|
|
});
|
|
|
|
describe('Wikifier: subWikify', {
|
|
|
|
before_each: function() {
|
|
formatter = new Formatter(config.formatters);
|
|
output = document.body.appendChild(document.createElement("div"));
|
|
terminator = "";
|
|
w = new Wikifier("test",formatter);
|
|
},
|
|
|
|
'it should call this.subWikifyUnterm if second parameter is not provided': function() {
|
|
tests_mock.before('Wikifier.prototype.subWikifyUnterm');
|
|
w.subWikify(output);
|
|
var actual = tests_mock.after('Wikifier.prototype.subWikifyUnterm').called;
|
|
value_of(actual).should_be_true;
|
|
},
|
|
|
|
'it should call this.subWikifyTerm if a second parameter is provided': function() {
|
|
tests_mock.before('Wikifier.prototype.subWikifyTerm');
|
|
w.subWikify(output,terminator);
|
|
var actual = tests_mock.after('Wikifier.prototype.subWikifyTerm').called;
|
|
value_of(actual).should_be_true;
|
|
},
|
|
|
|
after_each: function() {
|
|
removeNode(output);
|
|
delete formatter;
|
|
delete terminator;
|
|
delete w;
|
|
}
|
|
});
|
|
|
|
describe('Wikifier: subWikifyUnterm', {
|
|
|
|
before_each: function() {
|
|
formatter = new Formatter([{
|
|
name: "test",
|
|
match: "test",
|
|
handler: function(w)
|
|
{
|
|
createTiddlyText(w.output,w.matchText);
|
|
}
|
|
}]);
|
|
|
|
output = document.body.appendChild(document.createElement("div"));
|
|
source = "some test input for a test of a function";
|
|
w = new Wikifier(source,formatter);
|
|
},
|
|
|
|
'it should pass any text that matches the formatter\'s regexp to the correct handler in the formatter': function() {
|
|
w.subWikifyUnterm(output);
|
|
var actual = output.innerHTML;
|
|
var expected = source;
|
|
value_of(actual).should_be(expected);
|
|
},
|
|
|
|
'it should output any text before, between or after a match': function() {
|
|
tests_mock.before('Wikifier.prototype.outputText');
|
|
w.subWikifyUnterm(output);
|
|
var actual = tests_mock.after('Wikifier.prototype.outputText').called;
|
|
value_of(actual).should_be(3);
|
|
actual = output.innerHTML;
|
|
var expected = "testtest";
|
|
value_of(actual).should_be(expected);
|
|
},
|
|
|
|
after_each: function() {
|
|
removeNode(output);
|
|
delete formatter;
|
|
delete source;
|
|
delete w;
|
|
}
|
|
});
|
|
|
|
describe('Wikifier: subWikifyTerm', {
|
|
|
|
before_each: function() {
|
|
formatter = new Formatter([{
|
|
name: "test",
|
|
match: "test",
|
|
handler: function(w)
|
|
{
|
|
createTiddlyText(w.output,w.matchText);
|
|
}
|
|
}]);
|
|
|
|
termRegExp = /(\n)/mg;
|
|
output = document.body.appendChild(document.createElement("div"));
|
|
source = "some test multi-line test input \n for a test of a function";
|
|
w = new Wikifier(source,formatter);
|
|
},
|
|
|
|
'it should ignore all input after a match with termRegExp': function() {
|
|
w.subWikifyTerm(output,termRegExp);
|
|
var actual = output.innerHTML;
|
|
var expected = source.substring(0,source.indexOf("\n"));
|
|
value_of(actual).should_be(expected);
|
|
},
|
|
|
|
'it should pass any text that matches the formatter\'s regexp to the correct handler in the formatter': function() {
|
|
tests_mock.before('formatter.formatters[0].handler');
|
|
w.subWikifyTerm(output,termRegExp);
|
|
var actual = tests_mock.after('formatter.formatters[0].handler').called;
|
|
value_of(actual).should_be(2);
|
|
},
|
|
|
|
'it should output any text before, between or after a formatter match': function() {
|
|
tests_mock.before('Wikifier.prototype.outputText');
|
|
w.subWikifyTerm(output,termRegExp);
|
|
var actual = tests_mock.after('Wikifier.prototype.outputText').called;
|
|
value_of(actual).should_be(3);
|
|
actual = output.innerHTML;
|
|
var expected = "testtest";
|
|
value_of(actual).should_be(expected);
|
|
},
|
|
|
|
after_each: function() {
|
|
removeNode(output);
|
|
delete formatter;
|
|
delete termRegExp;
|
|
delete source;
|
|
delete w;
|
|
}
|
|
});
|
|
|
|
describe('Wikifier: outputText', {
|
|
|
|
before_each: function() {
|
|
formatter = new Formatter(config.formatters);
|
|
source = "some test input";
|
|
highlightRegExp = /test/g;
|
|
output = document.body.appendChild(document.createElement("div"));
|
|
},
|
|
|
|
'it should output all the input text if the Wikifier object\'s highlightRegExp property is null': function() {
|
|
w = new Wikifier(source,formatter);
|
|
w.outputText(output,0,source.length);
|
|
var actual = output.innerHTML;
|
|
value_of(actual).should_be(source);
|
|
},
|
|
|
|
'it should wrap any text that matched by the Wikifier object\'s highlightRegExp in <span> tags with a class of "highlight"': function() {
|
|
w = new Wikifier(source,formatter,highlightRegExp);
|
|
w.outputText(output,0,source.length);
|
|
var actual = output.innerHTML;
|
|
var match = actual.match("<span");
|
|
if(!match)
|
|
match = actual.match("<SPAN");
|
|
var length = match ? match.length : -1;
|
|
value_of(length).should_be(1);
|
|
},
|
|
|
|
after_each: function() {
|
|
removeNode(output);
|
|
delete formatter;
|
|
delete source;
|
|
delete highlightRegExp;
|
|
}
|
|
|
|
});
|
|
|
|
// ]]>
|
|
|