patrick/KaTeX
1
0
Fork 0
mirror of https://github.com/Smaug123/KaTeX synced 2025-10-07 20:28:38 +00:00
Code Issues Packages Projects Releases Wiki Activity

Flatten a bunch of non-pervasive ParseNode types (part 2) (#1552)

Browse Source 
* Flatten "operatorname" ParseNode.

* Flatten "overline" ParseNode.

* Flatten "raisebox" ParseNode.

* Flatten "rule" ParseNode.

* Flatten "sizing" ParseNode.

* Flatten "smash" ParseNode.

* Flatten "sqrt" ParseNode.

* Flatten "underline" ParseNode.

* Flatten "enclose" ParseNode.

* Flatten "environment" ParseNode.

* Flatten "genfrac" ParseNode.

* Flatten "htmlmathml" ParseNode.

* Flatten "infix" ParseNode.

* Flatten "kern" ParseNode.

* Flatten "lap" ParseNode.

* Flatten "color" ParseNode.
This commit is contained in:
Ashish Myles
2018-08-06 01:59:44 -04:00
committed by ylemkimon
parent 1506dc1d88
commit 5b6ffd7b9d
21 changed files with 412 additions and 553 deletions
Download Patch File Download Diff File Expand all files Collapse all files

154
test/katex-spec.js
View File

@@ -92,7 +92,7 @@ describe("A rel parser", function() {
for (let i = 0; i < parse.length; i++) {
let group = parse[i];
if (group.type === "htmlmathml") {
group = group.value.html[0];
group = group.html[0];
}
if (group.type === "mclass") {
expect(group.mclass).toEqual("mrel");
@@ -342,7 +342,8 @@ describe("An implicit group parser", function() {
const sizing = parse[0];
expect(sizing.type).toEqual("sizing");
expect(sizing.value).toBeTruthy();
expect(sizing.body).toBeTruthy();
expect(sizing.size).toBeDefined();
});
it("should apply only after the function", function() {
@@ -353,7 +354,7 @@ describe("An implicit group parser", function() {
const sizing = parse[1];
expect(sizing.type).toEqual("sizing");
expect(sizing.value.value).toHaveLength(3);
expect(sizing.body).toHaveLength(3);
});
it("should stop at the ends of groups", function() {
@@ -363,7 +364,7 @@ describe("An implicit group parser", function() {
const sizing = group.value[1];
expect(sizing.type).toEqual("sizing");
expect(sizing.value.value).toHaveLength(1);
expect(sizing.body).toHaveLength(1);
});
describe("within optional groups", () => {
@@ -441,8 +442,8 @@ describe("A frac parser", function() {
const parse = getParsed(expression)[0];
expect(parse.type).toEqual("genfrac");
expect(parse.value.numer).toBeDefined();
expect(parse.value.denom).toBeDefined();
expect(parse.numer).toBeDefined();
expect(parse.denom).toBeDefined();
});
it("should also parse cfrac, dfrac, tfrac, and genfrac", function() {
@@ -457,28 +458,28 @@ describe("A frac parser", function() {
const dfracParse = getParsed(dfracExpression)[0];
expect(dfracParse.type).toEqual("genfrac");
expect(dfracParse.value.numer).toBeDefined();
expect(dfracParse.value.denom).toBeDefined();
expect(dfracParse.numer).toBeDefined();
expect(dfracParse.denom).toBeDefined();
const tfracParse = getParsed(tfracExpression)[0];
expect(tfracParse.type).toEqual("genfrac");
expect(tfracParse.value.numer).toBeDefined();
expect(tfracParse.value.denom).toBeDefined();
expect(tfracParse.numer).toBeDefined();
expect(tfracParse.denom).toBeDefined();
const cfracParse = getParsed(cfracExpression)[0];
expect(cfracParse.type).toEqual("genfrac");
expect(cfracParse.value.numer).toBeDefined();
expect(cfracParse.value.denom).toBeDefined();
expect(cfracParse.numer).toBeDefined();
expect(cfracParse.denom).toBeDefined();
const genfracParse = getParsed(genfrac1)[0];
expect(genfracParse.type).toEqual("genfrac");
expect(genfracParse.value.numer).toBeDefined();
expect(genfracParse.value.denom).toBeDefined();
expect(genfracParse.value.leftDelim).toBeDefined();
expect(genfracParse.value.rightDelim).toBeDefined();
expect(genfracParse.numer).toBeDefined();
expect(genfracParse.denom).toBeDefined();
expect(genfracParse.leftDelim).toBeDefined();
expect(genfracParse.rightDelim).toBeDefined();
});
it("should fail, given math as a line thickness to genfrac", function() {
@@ -495,9 +496,9 @@ describe("A frac parser", function() {
const parse = getParsed`x \atop y`[0];
expect(parse.type).toEqual("genfrac");
expect(parse.value.numer).toBeDefined();
expect(parse.value.denom).toBeDefined();
expect(parse.value.hasBarLine).toEqual(false);
expect(parse.numer).toBeDefined();
expect(parse.denom).toBeDefined();
expect(parse.hasBarLine).toEqual(false);
});
});
@@ -520,43 +521,43 @@ describe("An over/brace/brack parser", function() {
parse = getParsed(simpleOver)[0];
expect(parse.type).toEqual("genfrac");
expect(parse.value.numer).toBeDefined();
expect(parse.value.denom).toBeDefined();
expect(parse.numer).toBeDefined();
expect(parse.denom).toBeDefined();
parse = getParsed(complexOver)[0];
expect(parse.type).toEqual("genfrac");
expect(parse.value.numer).toBeDefined();
expect(parse.value.denom).toBeDefined();
expect(parse.numer).toBeDefined();
expect(parse.denom).toBeDefined();
const parseBraceFrac = getParsed(braceFrac)[0];
expect(parseBraceFrac.type).toEqual("genfrac");
expect(parseBraceFrac.value.numer).toBeDefined();
expect(parseBraceFrac.value.denom).toBeDefined();
expect(parseBraceFrac.value.leftDelim).toBeDefined();
expect(parseBraceFrac.value.rightDelim).toBeDefined();
expect(parseBraceFrac.numer).toBeDefined();
expect(parseBraceFrac.denom).toBeDefined();
expect(parseBraceFrac.leftDelim).toBeDefined();
expect(parseBraceFrac.rightDelim).toBeDefined();
const parseBrackFrac = getParsed(brackFrac)[0];
expect(parseBrackFrac.type).toEqual("genfrac");
expect(parseBrackFrac.value.numer).toBeDefined();
expect(parseBrackFrac.value.denom).toBeDefined();
expect(parseBrackFrac.value.leftDelim).toBeDefined();
expect(parseBrackFrac.value.rightDelim).toBeDefined();
expect(parseBrackFrac.numer).toBeDefined();
expect(parseBrackFrac.denom).toBeDefined();
expect(parseBrackFrac.leftDelim).toBeDefined();
expect(parseBrackFrac.rightDelim).toBeDefined();
});
it("should create a numerator from the atoms before \\over", function() {
const parse = getParsed(complexOver)[0];
const numer = parse.value.numer;
const numer = parse.numer;
expect(numer.value).toHaveLength(4);
});
it("should create a demonimator from the atoms after \\over", function() {
const parse = getParsed(complexOver)[0];
const denom = parse.value.numer;
const denom = parse.numer;
expect(denom.value).toHaveLength(4);
});
@@ -564,24 +565,24 @@ describe("An over/brace/brack parser", function() {
const emptyNumerator = r`\over x`;
const parse = getParsed(emptyNumerator)[0];
expect(parse.type).toEqual("genfrac");
expect(parse.value.numer).toBeDefined();
expect(parse.value.denom).toBeDefined();
expect(parse.numer).toBeDefined();
expect(parse.denom).toBeDefined();
});
it("should handle empty denominators", function() {
const emptyDenominator = r`1 \over`;
const parse = getParsed(emptyDenominator)[0];
expect(parse.type).toEqual("genfrac");
expect(parse.value.numer).toBeDefined();
expect(parse.value.denom).toBeDefined();
expect(parse.numer).toBeDefined();
expect(parse.denom).toBeDefined();
});
it("should handle \\displaystyle correctly", function() {
const displaystyleExpression = r`\displaystyle 1 \over 2`;
const parse = getParsed(displaystyleExpression)[0];
expect(parse.type).toEqual("genfrac");
expect(parse.value.numer.value[0].type).toEqual("styling");
expect(parse.value.denom).toBeDefined();
expect(parse.numer.value[0].type).toEqual("styling");
expect(parse.denom).toBeDefined();
});
it("should handle \\textstyle correctly", function() {
@@ -593,11 +594,11 @@ describe("An over/brace/brack parser", function() {
const nestedOverExpression = r`{1 \over 2} \over 3`;
const parse = getParsed(nestedOverExpression)[0];
expect(parse.type).toEqual("genfrac");
expect(parse.value.numer.value[0].type).toEqual("genfrac");
expect(parse.value.numer.value[0].value.numer.value[0].value).toEqual("1");
expect(parse.value.numer.value[0].value.denom.value[0].value).toEqual("2");
expect(parse.value.denom).toBeDefined();
expect(parse.value.denom.value[0].value).toEqual("3");
expect(parse.numer.value[0].type).toEqual("genfrac");
expect(parse.numer.value[0].numer.value[0].value).toEqual("1");
expect(parse.numer.value[0].denom.value[0].value).toEqual("2");
expect(parse.denom).toBeDefined();
expect(parse.denom.value[0].value).toEqual("3");
});
it("should fail with multiple overs in the same group", function() {
@@ -641,7 +642,8 @@ describe("A sizing parser", function() {
const parse = getParsed(sizeExpression)[0];
expect(parse.type).toEqual("sizing");
expect(parse.value).toBeDefined();
expect(parse.size).toBeDefined();
expect(parse.body).toBeDefined();
});
});
@@ -778,8 +780,8 @@ describe("A color parser", function() {
const parse = getParsed(colorExpression)[0];
expect(parse.type).toEqual("color");
expect(parse.value.color).toBeDefined();
expect(parse.value.value).toBeDefined();
expect(parse.color).toBeDefined();
expect(parse.body).toBeDefined();
});
it("should parse a custom color", function() {
@@ -791,8 +793,8 @@ describe("A color parser", function() {
const parse1 = getParsed(customColorExpression1)[0];
const parse2 = getParsed(customColorExpression2)[0];
expect(parse1.value.color).toEqual("#fA6");
expect(parse2.value.color).toEqual("#fA6fA6");
expect(parse1.color).toEqual("#fA6");
expect(parse2.color).toEqual("#fA6fA6");
});
it("should not parse a bad custom color", function() {
@@ -984,25 +986,25 @@ describe("A rule parser", function() {
const emParse = getParsed(emRule)[0];
const exParse = getParsed(exRule)[0];
expect(emParse.value.width.unit).toEqual("em");
expect(emParse.value.height.unit).toEqual("em");
expect(emParse.width.unit).toEqual("em");
expect(emParse.height.unit).toEqual("em");
expect(exParse.value.width.unit).toEqual("ex");
expect(exParse.value.height.unit).toEqual("em");
expect(exParse.width.unit).toEqual("ex");
expect(exParse.height.unit).toEqual("em");
});
it("should parse the number correctly", function() {
const hardNumberParse = getParsed(hardNumberRule)[0];
expect(hardNumberParse.value.width.number).toBeCloseTo(1.24);
expect(hardNumberParse.value.height.number).toBeCloseTo(2.45);
expect(hardNumberParse.width.number).toBeCloseTo(1.24);
expect(hardNumberParse.height.number).toBeCloseTo(2.45);
});
it("should parse negative sizes", function() {
const parse = getParsed`\rule{-1em}{- 0.2em}`[0];
expect(parse.value.width.number).toBeCloseTo(-1);
expect(parse.value.height.number).toBeCloseTo(-0.2);
expect(parse.width.number).toBeCloseTo(-1);
expect(parse.height.number).toBeCloseTo(-0.2);
});
});
@@ -1020,10 +1022,10 @@ describe("A kern parser", function() {
const muParse = getParsed(muKern)[0];
const abParse = getParsed(abKern)[1];
expect(emParse.value.dimension.unit).toEqual("em");
expect(exParse.value.dimension.unit).toEqual("ex");
expect(muParse.value.dimension.unit).toEqual("mu");
expect(abParse.value.dimension.unit).toEqual("em");
expect(emParse.dimension.unit).toEqual("em");
expect(exParse.dimension.unit).toEqual("ex");
expect(muParse.dimension.unit).toEqual("mu");
expect(abParse.dimension.unit).toEqual("em");
});
it("should not parse invalid units", function() {
@@ -1033,12 +1035,12 @@ describe("A kern parser", function() {
it("should parse negative sizes", function() {
const parse = getParsed`\kern{-1em}`[0];
expect(parse.value.dimension.number).toBeCloseTo(-1);
expect(parse.dimension.number).toBeCloseTo(-1);
});
it("should parse positive sizes", function() {
const parse = getParsed`\kern{+1em}`[0];
expect(parse.value.dimension.number).toBeCloseTo(1);
expect(parse.dimension.number).toBeCloseTo(1);
});
});
@@ -1060,12 +1062,12 @@ describe("A non-braced kern parser", function() {
const abParse2 = getParsed(abKern2)[1];
const abParse3 = getParsed(abKern3)[1];
expect(emParse.value.dimension.unit).toEqual("em");
expect(exParse.value.dimension.unit).toEqual("ex");
expect(muParse.value.dimension.unit).toEqual("mu");
expect(abParse1.value.dimension.unit).toEqual("mu");
expect(abParse2.value.dimension.unit).toEqual("mu");
expect(abParse3.value.dimension.unit).toEqual("mu");
expect(emParse.dimension.unit).toEqual("em");
expect(exParse.dimension.unit).toEqual("ex");
expect(muParse.dimension.unit).toEqual("mu");
expect(abParse1.dimension.unit).toEqual("mu");
expect(abParse2.dimension.unit).toEqual("mu");
expect(abParse3.dimension.unit).toEqual("mu");
});
it("should parse elements on either side of a kern", function() {
@@ -1091,12 +1093,12 @@ describe("A non-braced kern parser", function() {
it("should parse negative sizes", function() {
const parse = getParsed`\kern-1em`[0];
expect(parse.value.dimension.number).toBeCloseTo(-1);
expect(parse.dimension.number).toBeCloseTo(-1);
});
it("should parse positive sizes", function() {
const parse = getParsed`\kern+1em`[0];
expect(parse.value.dimension.number).toBeCloseTo(1);
expect(parse.dimension.number).toBeCloseTo(1);
});
it("should handle whitespace", function() {
@@ -1105,7 +1107,7 @@ describe("A non-braced kern parser", function() {
expect(abParse).toHaveLength(3);
expect(abParse[0].value).toEqual("a");
expect(abParse[1].value.dimension.unit).toEqual("mu");
expect(abParse[1].dimension.unit).toEqual("mu");
expect(abParse[2].value).toEqual("b");
});
});
@@ -1511,9 +1513,9 @@ describe("A font parser", function() {
it("should work with \\textcolor", function() {
const colorMathbbParse = getParsed`\textcolor{blue}{\mathbb R}`[0];
expect(colorMathbbParse.value.type).toEqual("color");
expect(colorMathbbParse.value.color).toEqual("blue");
const body = colorMathbbParse.value.value;
expect(colorMathbbParse.type).toEqual("color");
expect(colorMathbbParse.color).toEqual("blue");
const body = colorMathbbParse.body;
expect(body).toHaveLength(1);
expect(body[0].type).toEqual("font");
expect(body[0].font).toEqual("mathbb");
@@ -2589,7 +2591,7 @@ describe("A parser that does not throw on unsupported commands", function() {
it("should produce color nodes with a color value given by errorColor", function() {
const parsedInput = getParsed(r`\error`, noThrowSettings);
expect(parsedInput[0].type).toBe("color");
expect(parsedInput[0].value.color).toBe(errorColor);
expect(parsedInput[0].color).toBe(errorColor);
});
it("should build katex-error span for other type of KaTeX error", function() {