Refactoring while testing a bug with UnionExpr.

Author: leonelsanchesdasilva

CHANGELOG.md

@@ -1,4 +1,4 @@
-This document is no longer maintained in favor of GitHub's release system, and just kept here for historical reasons.
+This document is no longer maintained in favor of [GitHub's release system](https://github.com/DesignLiquido/xslt-processor/releases), and just kept here for historical reasons.
 
 2018-03-20  Johannes Wilm <[email protected]>
 

TODO.md

@@ -5,5 +5,6 @@ XSLT-processor TODO
 * XSLT validation, besides the version number;
 * XSL:number
 * `attribute-set`, `decimal-format`, etc. (check `src/xslt.ts`)
+* `/html/body//ul/li|html/body//ol/li` has `/html/body//ul/li` evaluated by this XPath implementation as "absolute", and `/html/body//ol/li` as "relative". Both should be evaluated as "absolute".
 
 Help is much appreciated. It seems to currently work for most of our purposes, but fixes and additions are always welcome!

src/dom/util.ts

@@ -18,7 +18,7 @@ export function mapExec(array: any[], func: Function) {
 
 // Returns an array that contains the return value of the given
 // function applied to every element of the input array.
-export function mapExpr(array, func) {
+export function mapExpr(array: any[], func: Function) {
     const ret = [];
     for (let i = 0; i < array.length; ++i) {
         ret.push(func(array[i]));

src/xpath/node-tests/node-test-pi.ts

@@ -10,8 +10,8 @@ export class NodeTestPI implements NodeTest {
         this.target = target;
     }
 
-    evaluate(ctx: ExprContext) {
-        const node = ctx.nodeList[ctx.position];
+    evaluate(context: ExprContext) {
+        const node = context.nodeList[context.position];
         return new BooleanValue(
             node.nodeType == DOM_PROCESSING_INSTRUCTION_NODE && (!this.target || node.nodeName == this.target)
         );

src/xpath/tokens.ts

@@ -328,13 +328,13 @@ export const xPathTokenRules: XPathTokenRule[] = [
 ];
 
 // Quantifiers that are used in the productions of the grammar.
-export const Q_01 = {
+export const Q_ZERO_OR_ONE = {
     label: '?'
 };
-export const Q_MM = {
+export const Q_ZERO_OR_MULTIPLE = {
     label: '*'
 };
-export const Q_1M = {
+export const Q_ONE_OR_MULTIPLE = {
     label: '+'
 };
 

src/xpath/xpath.ts

@@ -56,9 +56,9 @@ import {
 import { Expression } from './expressions/expression';
 
 import {
-    Q_MM,
-    Q_01,
-    Q_1M,
+    Q_ZERO_OR_MULTIPLE,
+    Q_ZERO_OR_ONE,
+    Q_ONE_OR_MULTIPLE,
     xPathTokenRules,
     TOK_DIV,
     TOK_MOD,
@@ -135,7 +135,7 @@ export class XPath {
 
     // The productions of the grammar. Columns of the table:
     //
-    // - target nonterminal,
+    // - target non-terminal,
     // - pattern,
     // - precedence,
     // - semantic value factory
@@ -148,14 +148,14 @@ export class XPath {
     // and thus evaluates XPath expressions.
     //
     // The precedence is used to decide between reducing and shifting by
-    // comparing the precendence of the rule that is candidate for
+    // comparing the precedence of the rule that is candidate for
     // reducing with the precedence of the look ahead token. Precedence of
     // -1 means that the precedence of the tokens in the pattern is used
     // instead. TODO: It shouldn't be necessary to explicitly assign
     // precedences to rules.
 
     // DGF As it stands, these precedences are purely empirical; we're
-    // not sure they can be made to be consistent at all.
+    // not sure if they can be made to be consistent at all.
     xPathGrammarRules = [
         [XPathLocationPath, [XPathRelativeLocationPath], 18, this.passExpr],
         [XPathLocationPath, [XPathAbsoluteLocationPath], 18, this.passExpr],
@@ -194,7 +194,7 @@ export class XPath {
         [XPathFunctionCall, [TOK_QNAME, TOK_PARENO, TOK_PARENC], -1, this.makeFunctionCallExpr1],
         [
             XPathFunctionCall,
-            [TOK_QNAME, TOK_PARENO, XPathExpr, XPathArgumentRemainder, Q_MM, TOK_PARENC],
+            [TOK_QNAME, TOK_PARENO, XPathExpr, XPathArgumentRemainder, Q_ZERO_OR_MULTIPLE, TOK_PARENC],
             -1,
             this.makeFunctionCallExpr2
         ],
@@ -208,7 +208,7 @@ export class XPath {
         [XPathPathExpr, [XPathFilterExpr, TOK_SLASH, XPathRelativeLocationPath], 19, this.makePathExpr1],
         [XPathPathExpr, [XPathFilterExpr, TOK_DSLASH, XPathRelativeLocationPath], 19, this.makePathExpr2],
 
-        [XPathFilterExpr, [XPathPrimaryExpr, XPathPredicate, Q_MM], 31, this.makeFilterExpr],
+        [XPathFilterExpr, [XPathPrimaryExpr, XPathPredicate, Q_ZERO_OR_MULTIPLE], 31, this.makeFilterExpr],
 
         [XPathExpr, [XPathPrimaryExpr], 16, this.passExpr],
         [XPathExpr, [XPathUnionExpr], 16, this.passExpr],
@@ -356,7 +356,7 @@ export class XPath {
         return new NodeTestNC(ncname.value);
     }
 
-    makeNodeTestExpr3(qname: any) {
+    makeNodeTestExpr3(qname: TokenExpr) {
         return new NodeTestName(qname.value);
     }
 
@@ -385,12 +385,12 @@ export class XPath {
         return new NodeTestPI(target.value);
     }
 
-    makePredicateExpr(pareno: any, expr: any) {
-        return new PredicateExpr(expr);
+    makePredicateExpr(pareno: any, expression: any) {
+        return new PredicateExpr(expression);
     }
 
-    makePrimaryExpr(pareno: any, expr: any) {
-        return expr;
+    makePrimaryExpr(pareno: any, expression: any) {
+        return expression;
     }
 
     makeFunctionCallExpr1(name: any) {
@@ -406,11 +406,11 @@ export class XPath {
         return ret;
     }
 
-    makeArgumentExpr(comma: any, expr: any) {
-        return expr;
+    makeArgumentExpr(comma: any, expression: any) {
+        return expression;
     }
 
-    makeUnionExpr(expr1: any, pipe: any, expr2: any) {
+    makeUnionExpr(expr1: Expression, pipe: TokenExpr, expr2: Expression) {
         return new UnionExpr(expr1, expr2);
     }
 
@@ -567,56 +567,56 @@ export class XPath {
         }
     }
 
-    xPathMatchStack(stack: any, pattern: any) {
+    xPathMatchStack(stack: any[], pattern: any[]) {
         // NOTE(mesch): The stack matches for variable cardinality are
         // greedy but don't do backtracking. This would be an issue only
         // with rules of the form A* A, i.e. with an element with variable
         // cardinality followed by the same element. Since that doesn't
         // occur in the grammar at hand, all matches on the stack are
         // unambiguous.
 
-        const S = stack.length;
-        const P = pattern.length;
+        const stackLength = stack.length;
+        const patternLength = pattern.length;
         let p;
         let s;
         const match: any = [];
-        match.matchlength = 0;
+        match.matchLength = 0;
         let ds = 0;
-        for (p = P - 1, s = S - 1; p >= 0 && s >= 0; --p, s -= ds) {
+        for (p = patternLength - 1, s = stackLength - 1; p >= 0 && s >= 0; --p, s -= ds) {
             ds = 0;
             const qmatch: any = [];
-            if (pattern[p] == Q_MM) {
+            if (pattern[p] == Q_ZERO_OR_MULTIPLE) {
                 p -= 1;
                 match.push(qmatch);
                 while (s - ds >= 0 && stack[s - ds].tag == pattern[p]) {
                     qmatch.push(stack[s - ds]);
                     ds += 1;
-                    match.matchlength += 1;
+                    match.matchLength += 1;
                 }
-            } else if (pattern[p] == Q_01) {
+            } else if (pattern[p] == Q_ZERO_OR_ONE) {
                 p -= 1;
                 match.push(qmatch);
                 while (s - ds >= 0 && ds < 2 && stack[s - ds].tag == pattern[p]) {
                     qmatch.push(stack[s - ds]);
                     ds += 1;
-                    match.matchlength += 1;
+                    match.matchLength += 1;
                 }
-            } else if (pattern[p] == Q_1M) {
+            } else if (pattern[p] == Q_ONE_OR_MULTIPLE) {
                 p -= 1;
                 match.push(qmatch);
                 if (stack[s].tag == pattern[p]) {
                     while (s - ds >= 0 && stack[s - ds].tag == pattern[p]) {
                         qmatch.push(stack[s - ds]);
                         ds += 1;
-                        match.matchlength += 1;
+                        match.matchLength += 1;
                     }
                 } else {
                     return [];
                 }
             } else if (stack[s].tag == pattern[p]) {
                 match.push(stack[s]);
                 ds += 1;
-                match.matchlength += 1;
+                match.matchLength += 1;
             } else {
                 return [];
             }
@@ -764,10 +764,10 @@ export class XPath {
             const pattern: any = rule[1];
 
             for (let j = pattern.length - 1; j >= 0; --j) {
-                if (pattern[j] == Q_1M) {
+                if (pattern[j] == Q_ONE_OR_MULTIPLE) {
                     push_(this.xPathRules, pattern[j - 1].key, rule);
                     break;
-                } else if (pattern[j] == Q_MM || pattern[j] == Q_01) {
+                } else if (pattern[j] == Q_ZERO_OR_MULTIPLE || pattern[j] == Q_ZERO_OR_ONE) {
                     push_(this.xPathRules, pattern[j - 1].key, rule);
                     --j;
                 } else {
@@ -924,8 +924,8 @@ export class XPath {
      * grammatical rules to them, "reducing" them to higher-level
      * tokens. Ultimately, any valid XPath should reduce to exactly one
      * "Expr" token.
-
-     * Reduce too early or too late and you'll have two tokens that can't reduce
+     *
+     * Reduce too early or too late, and you'll have two tokens that can't reduce
      * to single Expr. For example, you may hastily reduce a qname that
      * should name a function, incorrectly treating it as a tag name.
      * Or you may reduce too late, accidentally reducing the last part of the
@@ -940,11 +940,15 @@ export class XPath {
      *
      * Some tokens have left associativity, in which case we shift when they
      * have LOWER precedence than the candidate.
+     * @param stack The actual grammar rule stack.
+     * @param ahead The grammar rule ahead.
+     * @return `true` if a grammar rule candidate was applied. `false` otherwise.
+     * @private
      */
     private xPathReduce(
         stack: GrammarRuleCandidate[],
         ahead: GrammarRuleCandidate
-    ) {
+    ): boolean {
         let candidate: GrammarRuleCandidate = null;
 
         if (stack.length > 0) {
@@ -956,9 +960,8 @@ export class XPath {
             }
         }
 
-        let ret;
         if (candidate && (!ahead || candidate.prec > ahead.prec || (ahead.tag.left && candidate.prec >= ahead.prec))) {
-            for (let i = 0; i < candidate.match.matchlength; ++i) {
+            for (let i = 0; i < candidate.match.matchLength; ++i) {
                 stack.pop();
             }
 
@@ -968,12 +971,12 @@ export class XPath {
                 }`
             );
 
-            const matchExpression = mapExpr(candidate.match, (m) => m.expr);
+            const matchExpression = mapExpr(candidate.match, (m: GrammarRuleCandidate) => m.expr);
             this.xPathLog(`going to apply ${candidate.rule[3]}`);
             candidate.expr = candidate.rule[3].apply(this, matchExpression);
 
             stack.push(candidate);
-            ret = true;
+            return true;
         } else {
             if (ahead) {
                 this.xPathLog(
@@ -983,9 +986,9 @@ export class XPath {
                 );
                 stack.push(ahead);
             }
-            ret = false;
+
+            return false;
         }
-        return ret;
     }
 
     /**

tests/lmht/html-to-lmht.test.tsx

@@ -162,7 +162,7 @@ describe('HTML to LMHT', () => {
                     <xsl:apply-templates select="@*|node()" />
                 </cabeça>
             </xsl:template>
-            <xsl:template match="/html/base">
+            <xsl:template match="/html/head/base">
                 <base-ligações>
                     <xsl:for-each select="@*">
                         <xsl:choose>
@@ -184,7 +184,7 @@ describe('HTML to LMHT', () => {
                 </base-ligações>
             </xsl:template>
             <!-- Tag \`style\` não é traduzida. -->
-            <xsl:template match="/html/style">
+            <xsl:template match="/html/head/style">
                 <style>
                     <xsl:apply-templates select="@*|node()" />
                 </style>
@@ -1061,7 +1061,7 @@ describe('HTML to LMHT', () => {
                     <xsl:apply-templates select="@*|node()" />
                 </lista-simples>
             </xsl:template>
-            <xsl:template match="/html/body//ol/li|html/body//ul/li">
+            <xsl:template match="/html/body//ul/li|html/body//ol/li">
                 <item-lista>
                     <xsl:apply-templates select="node()" />
                 </item-lista>
@@ -1571,6 +1571,44 @@ describe('HTML to LMHT', () => {
         assert.equal(outXmlString, expectedOutString);
     });
 
+    it('https://github.com/DesignLiquido/lmht-js/issues/2', async () => {
+        const xmlString = `<!DOCTYPE html>
+            <html lang="pt-BR">
+                <body>
+                    <h1><a href="#">Delégua Blog</a></h1>
+                    <nav>
+                        <ul>
+                            <li><a href="#">Início</a></li>
+                            <li><a href="#">Sobre</a></li>
+                            <li><a href="#">Contato</a></li>
+                        </ul>
+                    </nav>
+                </body>
+            </html>
+        `;
+
+        const expectedOutString = `<lmht>`+
+            `<corpo>`+
+                `<título1><ligação destino="#">Delégua Blog</ligação></título1>`+
+                `<navegação>`+
+                    `<lista-simples>`+
+                        `<item-lista><ligação destino="#">Início</ligação></item-lista>`+
+                        `<item-lista><ligação destino="#">Sobre</ligação></item-lista>`+
+                        `<item-lista><ligação destino="#">Contato</ligação></item-lista>`+
+                    `</lista-simples>`+
+                `</navegação>`+
+            `</corpo>`+
+        `</lmht>`;
+
+        const xsltClass = new Xslt({ selfClosingTags: true });
+        const xmlParser = new XmlParser();
+        const xml = xmlParser.xmlParse(xmlString);
+        const xslt = xmlParser.xmlParse(xsltString);
+        const outXmlString = await xsltClass.xsltProcess(xml, xslt);
+
+        assert.equal(outXmlString, expectedOutString);
+    });
+
     it('https://github.com/DesignLiquido/lmht-js/issues/3', async () => {
         const xmlString = `<!DOCTYPE html>
             <html lang="pt-BR">
@@ -1625,5 +1663,5 @@ describe('HTML to LMHT', () => {
         const outXmlString = await xsltClass.xsltProcess(xml, xslt);
 
         assert.equal(outXmlString, expectedOutString);
-    })
+    });
 });

tests/xpath/xpath.test.tsx

@@ -728,17 +728,17 @@ describe('xpath', () => {
         ];
 
         const parsedXML = xmlParser.xmlParse(xml);
-        const ctx = new ExprContext([parsedXML], []);
+        const context = new ExprContext([parsedXML], []);
 
         for (const test of tests) {
-            const expr = xPath.xPathParse(test[0] as any);
+            const expression = xPath.xPathParse(test[0] as any);
 
-            ctx.setReturnOnFirstMatch(false);
-            const normalResults = expr.evaluate(ctx);
+            context.setReturnOnFirstMatch(false);
+            const normalResults = expression.evaluate(context);
             assert.equal(normalResults.value.length, test[1], `normal results count: ${test[0]}`);
 
-            ctx.setReturnOnFirstMatch(true);
-            const firstMatchResults = expr.evaluate(ctx);
+            context.setReturnOnFirstMatch(true);
+            const firstMatchResults = expression.evaluate(context);
             assert.equal(firstMatchResults.value.length, 1, `first match results count: ${test[0]}`);
 
             assert.equal(