53e416e296
This reverts commit 4d2e46e7f6.
Having trailing commans makes diffs easier to read as it avoids modifying a
line just to add a trailing comma if there is another item to add at the end
of a list. There are plans to switch to ES6 notation and to translate that
to ES5 as part of the build process. Since that translation would remove
trailing commas, the IE9 problems that originally motivated the commit
should vanish soon.
242 lines
8.6 KiB
JavaScript
242 lines
8.6 KiB
JavaScript
/* global beforeEach: false */
|
|
/* global jasmine: false */
|
|
/* global expect: false */
|
|
/* global it: false */
|
|
/* global describe: false */
|
|
|
|
var splitAtDelimiters = require("./splitAtDelimiters");
|
|
|
|
beforeEach(function() {
|
|
jasmine.addMatchers({
|
|
toSplitInto: function() {
|
|
return {
|
|
compare: function(actual, left, right, result) {
|
|
var message = {
|
|
pass: true,
|
|
message: "'" + actual + "' split correctly",
|
|
};
|
|
|
|
var startData = [{type: "text", data: actual}];
|
|
|
|
var split =
|
|
splitAtDelimiters(startData, left, right, false);
|
|
|
|
if (split.length !== result.length) {
|
|
message.pass = false;
|
|
message.message = "Different number of splits: " +
|
|
split.length + " vs. " + result.length + " (" +
|
|
JSON.stringify(split) + " vs. " +
|
|
JSON.stringify(result) + ")";
|
|
return message;
|
|
}
|
|
|
|
for (var i = 0; i < split.length; i++) {
|
|
var real = split[i];
|
|
var correct = result[i];
|
|
|
|
var good = true;
|
|
var diff;
|
|
|
|
if (real.type !== correct.type) {
|
|
good = false;
|
|
diff = "type";
|
|
} else if (real.data !== correct.data) {
|
|
good = false;
|
|
diff = "data";
|
|
} else if (real.display !== correct.display) {
|
|
good = false;
|
|
diff = "display";
|
|
}
|
|
|
|
if (!good) {
|
|
message.pass = false;
|
|
message.message = "Difference at split " +
|
|
(i + 1) + ": " + JSON.stringify(real) +
|
|
" vs. " + JSON.stringify(correct) +
|
|
" (" + diff + " differs)";
|
|
break;
|
|
}
|
|
}
|
|
|
|
return message;
|
|
},
|
|
};
|
|
},
|
|
});
|
|
});
|
|
|
|
describe("A delimiter splitter", function() {
|
|
it("doesn't split when there are no delimiters", function() {
|
|
expect("hello").toSplitInto("(", ")", [{type: "text", data: "hello"}]);
|
|
});
|
|
|
|
it("doesn't create a math node with only one left delimiter", function() {
|
|
expect("hello ( world").toSplitInto(
|
|
"(", ")",
|
|
[
|
|
{type: "text", data: "hello "},
|
|
{type: "text", data: "( world"},
|
|
]);
|
|
});
|
|
|
|
it("doesn't split when there's only a right delimiter", function() {
|
|
expect("hello ) world").toSplitInto(
|
|
"(", ")",
|
|
[
|
|
{type: "text", data: "hello ) world"},
|
|
]);
|
|
});
|
|
|
|
it("splits when there are both delimiters", function() {
|
|
expect("hello ( world ) boo").toSplitInto(
|
|
"(", ")",
|
|
[
|
|
{type: "text", data: "hello "},
|
|
{type: "math", data: " world ",
|
|
rawData: "( world )", display: false},
|
|
{type: "text", data: " boo"},
|
|
]);
|
|
});
|
|
|
|
it("splits on multi-character delimiters", function() {
|
|
expect("hello [[ world ]] boo").toSplitInto(
|
|
"[[", "]]",
|
|
[
|
|
{type: "text", data: "hello "},
|
|
{type: "math", data: " world ",
|
|
rawData: "[[ world ]]", display: false},
|
|
{type: "text", data: " boo"},
|
|
]);
|
|
});
|
|
|
|
it("splits mutliple times", function() {
|
|
expect("hello ( world ) boo ( more ) stuff").toSplitInto(
|
|
"(", ")",
|
|
[
|
|
{type: "text", data: "hello "},
|
|
{type: "math", data: " world ",
|
|
rawData: "( world )", display: false},
|
|
{type: "text", data: " boo "},
|
|
{type: "math", data: " more ",
|
|
rawData: "( more )", display: false},
|
|
{type: "text", data: " stuff"},
|
|
]);
|
|
});
|
|
|
|
it("leaves the ending when there's only a left delimiter", function() {
|
|
expect("hello ( world ) boo ( left").toSplitInto(
|
|
"(", ")",
|
|
[
|
|
{type: "text", data: "hello "},
|
|
{type: "math", data: " world ",
|
|
rawData: "( world )", display: false},
|
|
{type: "text", data: " boo "},
|
|
{type: "text", data: "( left"},
|
|
]);
|
|
});
|
|
|
|
it("doesn't split when close delimiters are in {}s", function() {
|
|
expect("hello ( world { ) } ) boo").toSplitInto(
|
|
"(", ")",
|
|
[
|
|
{type: "text", data: "hello "},
|
|
{type: "math", data: " world { ) } ",
|
|
rawData: "( world { ) } )", display: false},
|
|
{type: "text", data: " boo"},
|
|
]);
|
|
|
|
expect("hello ( world { { } ) } ) boo").toSplitInto(
|
|
"(", ")",
|
|
[
|
|
{type: "text", data: "hello "},
|
|
{type: "math", data: " world { { } ) } ",
|
|
rawData: "( world { { } ) } )", display: false},
|
|
{type: "text", data: " boo"},
|
|
]);
|
|
});
|
|
|
|
it("doesn't split at escaped delimiters", function() {
|
|
expect("hello ( world \\) ) boo").toSplitInto(
|
|
"(", ")",
|
|
[
|
|
{type: "text", data: "hello "},
|
|
{type: "math", data: " world \\) ",
|
|
rawData: "( world \\) )", display: false},
|
|
{type: "text", data: " boo"},
|
|
]);
|
|
|
|
/* TODO(emily): make this work maybe?
|
|
expect("hello \\( ( world ) boo").toSplitInto(
|
|
"(", ")",
|
|
[
|
|
{type: "text", data: "hello \\( "},
|
|
{type: "math", data: " world ",
|
|
rawData: "( world )", display: false},
|
|
{type: "text", data: " boo"},
|
|
]);
|
|
*/
|
|
});
|
|
|
|
it("splits when the right and left delimiters are the same", function() {
|
|
expect("hello $ world $ boo").toSplitInto(
|
|
"$", "$",
|
|
[
|
|
{type: "text", data: "hello "},
|
|
{type: "math", data: " world ",
|
|
rawData: "$ world $", display: false},
|
|
{type: "text", data: " boo"},
|
|
]);
|
|
});
|
|
|
|
it("remembers which delimiters are display-mode", function() {
|
|
var startData = [{type: "text", data: "hello ( world ) boo"}];
|
|
|
|
expect(splitAtDelimiters(startData, "(", ")", true)).toEqual(
|
|
[
|
|
{type: "text", data: "hello "},
|
|
{type: "math", data: " world ",
|
|
rawData: "( world )", display: true},
|
|
{type: "text", data: " boo"},
|
|
]);
|
|
});
|
|
|
|
it("works with more than one start datum", function() {
|
|
var startData = [
|
|
{type: "text", data: "hello ( world ) boo"},
|
|
{type: "math", data: "math", rawData: "(math)", display: true},
|
|
{type: "text", data: "hello ( world ) boo"},
|
|
];
|
|
|
|
expect(splitAtDelimiters(startData, "(", ")", false)).toEqual(
|
|
[
|
|
{type: "text", data: "hello "},
|
|
{type: "math", data: " world ",
|
|
rawData: "( world )", display: false},
|
|
{type: "text", data: " boo"},
|
|
{type: "math", data: "math", rawData: "(math)", display: true},
|
|
{type: "text", data: "hello "},
|
|
{type: "math", data: " world ",
|
|
rawData: "( world )", display: false},
|
|
{type: "text", data: " boo"},
|
|
]);
|
|
});
|
|
|
|
it("doesn't do splitting inside of math nodes", function() {
|
|
var startData = [
|
|
{type: "text", data: "hello ( world ) boo"},
|
|
{type: "math", data: "hello ( world ) boo",
|
|
rawData: "(hello ( world ) boo)", display: true},
|
|
];
|
|
|
|
expect(splitAtDelimiters(startData, "(", ")", false)).toEqual(
|
|
[
|
|
{type: "text", data: "hello "},
|
|
{type: "math", data: " world ",
|
|
rawData: "( world )", display: false},
|
|
{type: "text", data: " boo"},
|
|
{type: "math", data: "hello ( world ) boo",
|
|
rawData: "(hello ( world ) boo)", display: true},
|
|
]);
|
|
});
|
|
});
|