generate-id (#57)

* Using `xsl:output` tag.

* - Implementing `generate-id()` XPath method;
- Each node now has a random id;
- Using `cyrb53` method to generate the id based on the node id.

Author: leonelsanchesdasilva

.eslintrc.js

@@ -85,7 +85,6 @@ module.exports = {
         'no-array-constructor': 'error',
         'no-async-promise-executor': 'error',
         'no-await-in-loop': 'error',
-        'no-bitwise': 'error',
         'no-buffer-constructor': 'error',
         'no-caller': 'error',
         'no-case-declarations': 'off',
@@ -115,7 +114,6 @@ module.exports = {
         'no-loop-func': 'error',
         'no-magic-numbers': 'off',
         'no-misleading-character-class': 'error',
-        'no-mixed-operators': 'error',
         'no-mixed-requires': 'error',
         'no-multi-assign': 'error',
         'no-multi-spaces': 'error',

src/dom/functions.ts

@@ -128,7 +128,7 @@ export function xmlParse(xml: any) {
         } else {
             // VersionInfo is missing, or unknown version number.
             // TODO : Fallback to XML 1.0 or XML 1.1, or just return null?
-            throw 'VersionInfo is missing, or unknown version number.';
+            throw new Error('VersionInfo is missing, or unknown version number.');
         }
     } else {
         // When an XML declaration is missing it's an XML 1.0 document.

src/dom/xnode.ts

@@ -9,6 +9,7 @@ import { XDocument } from './xdocument';
 
 // operate on native DOM nodes.
 export class XNode {
+    id: number;
     attributes: XNode[];
     childNodes: XNode[];
     nodeType: any;
@@ -45,6 +46,7 @@ export class XNode {
     static _unusedXNodes: any[] = [];
 
     constructor(type: any, name: any, opt_value: any, opt_owner: any, opt_namespace?: any) {
+        this.id = Math.random() * (Number.MAX_SAFE_INTEGER - 1) + 1;
         this.attributes = [];
         this.childNodes = [];
         this.transformedAttributes = [];

src/xpath/expressions/function-call-expr.ts

@@ -11,27 +11,49 @@ export class FunctionCallExpr extends Expression {
     name: any;
     args: any[];
 
+    private cyrb53(str: string, seed = 0) {
+        let h1 = 0xdeadbeef ^ seed;
+        let h2 = 0x41c6ce57 ^ seed;
+
+        for(let i = 0, ch: any; i < str.length; i++) {
+            ch = str.charCodeAt(i);
+            h1 = Math.imul(h1 ^ ch, 2654435761);
+            h2 = Math.imul(h2 ^ ch, 1597334677);
+        }
+
+        h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507);
+        h1 ^= Math.imul(h2 ^ (h2 >>> 13), 3266489909);
+        h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507);
+        h2 ^= Math.imul(h1 ^ (h1 >>> 13), 3266489909);
+
+        return 4294967296 * (2097151 & h2) + (h1 >>> 0);
+    }
+
     xpathfunctions = {
-        last(ctx) {
+        last(ctx: ExprContext) {
             assert(this.args.length == 0);
             // NOTE(mesch): XPath position starts at 1.
             return new NumberValue(ctx.contextSize());
         },
 
-        position(ctx) {
+        position(ctx: ExprContext) {
             assert(this.args.length == 0);
             // NOTE(mesch): XPath position starts at 1.
             return new NumberValue(ctx.position + 1);
         },
 
-        count(ctx) {
+        count(ctx: ExprContext) {
             assert(this.args.length == 1);
             const v = this.args[0].evaluate(ctx);
             return new NumberValue(v.nodeSetValue().length);
         },
 
-        'generate-id'(_ctx) {
-            throw 'not implmented yet: XPath function generate-id()';
+        'generate-id'(_ctx: ExprContext) {
+            return new StringValue(
+                'A' + this.cyrb53(
+                    JSON.stringify(_ctx.nodelist[_ctx.position].id)
+                )
+            );
         },
 
         id(ctx: ExprContext) {
@@ -382,7 +404,7 @@ export class FunctionCallExpr extends Expression {
         this.args = [];
     }
 
-    appendArg(arg) {
+    appendArg(arg: any) {
         this.args.push(arg);
     }
 

src/xpath/expressions/step-expr.ts

@@ -112,7 +112,7 @@ export class StepExpr extends Expression {
                 nodelist.push(n);
             }
         } else if (this.axis == xpathAxis.NAMESPACE) {
-            throw 'not implemented: axis namespace';
+            throw new Error('not implemented: axis namespace');
         } else if (this.axis == xpathAxis.PARENT) {
             if (input.parentNode) {
                 nodelist.push(input.parentNode);

src/xslt.ts

@@ -41,6 +41,7 @@ import {
 } from './constants';
 import { Expression } from './xpath/expressions/expression';
 import { StringValue, NodeSetValue } from './xpath/values';
+import { LocationExpr } from './xpath/expressions';
 
 /**
  * The main class for XSL-T processing. The implementation is NOT
@@ -68,9 +69,13 @@ import { StringValue, NodeSetValue } from './xpath/values';
  */
 export class Xslt {
     xPath: XPath;
+    outputMethod: string;
+    outputOmitXmlDeclaration: string;
 
     constructor() {
         this.xPath = new XPath();
+        this.outputMethod = "xml";
+        this.outputOmitXmlDeclaration = "no";
     }
 
     /**
@@ -273,10 +278,8 @@ export class Xslt {
                 case 'otherwise':
                     throw `error if here: ${template.localName}`;
                 case 'output':
-                    // Ignored. -- Since we operate on the DOM, and all further use
-                    // of the output of the XSL transformation is determined by the
-                    // browser that we run in, this parameter is not applicable to
-                    // this implementation.
+                    this.outputMethod = xmlGetAttribute(template, 'method');
+                    this.outputOmitXmlDeclaration = xmlGetAttribute(template, 'omit-xml-declaration');
                     break;
                 case 'preserve-space':
                     throw `not implemented: ${template.localName}`;
@@ -656,32 +659,41 @@ export class Xslt {
     protected xsltMatch(match: string, context: ExprContext) {
         const expr = this.xPath.xPathParse(match);
 
-        if (expr.steps.length <= 0) {
+        if (expr instanceof LocationExpr) {
+            return this.xsltLocationExpressionMatch(match, expr, context);
+        }
+
+        // TODO: Other expressions
+        return true;
+    }
+
+    private xsltLocationExpressionMatch(match: string, expression: LocationExpr, context: ExprContext) {
+        if (expression === undefined || expression.steps === undefined || expression.steps.length <= 0) {
             throw new Error('Error resolving XSLT match: Location Expression should have steps.');
         }
 
-        const firstStep = expr.steps[0];
+        const firstStep = expression.steps[0];
 
         // Shortcut for the most common case.
         if (
-            expr.steps &&
-            !expr.absolute &&
-            expr.steps.length == 1 &&
+            expression.steps &&
+            !expression.absolute &&
+            expression.steps.length == 1 &&
             firstStep.axis == 'child' &&
             firstStep.predicate.length === 0
         ) {
             return firstStep.nodetest.evaluate(context).booleanValue();
         }
 
-        if (expr.absolute && firstStep.axis !== 'self') {
+        if (expression.absolute && firstStep.axis !== 'self') {
             // TODO: `xPathCollectDescendants()`?
             const levels = match.split('/');
             if (levels.length > 1) {
-                return this.absoluteXsltMatch(levels, expr, context);
+                return this.absoluteXsltMatch(levels, expression, context);
             }
         }
 
-        return this.relativeXsltMatch(expr, context);
+        return this.relativeXsltMatch(expression, context);
     }
 
     /**

tests/xpath/functions.test.tsx

@@ -0,0 +1,98 @@
+/* eslint-disable no-undef */
+
+// Copyright 2023 Design Liquido
+// All Rights Reserved.
+
+import assert from 'assert';
+
+import { dom } from 'isomorphic-jsx';
+import React from 'react';
+import { xmlParse } from '../../src/dom';
+import { Xslt } from '../../src/xslt';
+
+// Just touching the `dom`, otherwise Babel prunes the import.
+console.log(dom);
+
+describe('XPath Functions', () => {
+    it('generate-id, trivial', () => {
+        const xml = xmlParse(<root></root>);
+        const xsltDefinition = xmlParse(
+            <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
+                <xsl:template match="/">
+                    <xsl:attribute name="uid">
+                        <xsl:value-of select="generate-id(.)"/>
+                    </xsl:attribute>
+                </xsl:template>
+            </xsl:stylesheet>
+        );
+
+        const xsltClass = new Xslt();
+
+        const outXmlString = xsltClass.xsltProcess(
+            xml,
+            xsltDefinition
+        );
+
+        assert.ok(outXmlString);
+    });
+
+    it.skip('generate-id, complete', () => {
+        const xsltDefinition = xmlParse(
+            <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
+                <xsl:output method="xml" omit-xml-declaration="yes"/>
+
+                <xsl:template match="chapter | sect1 | sect2">
+                    <xsl:copy>
+                        <xsl:attribute name="uid">
+                            <xsl:value-of select="generate-id(.)"/>
+                        </xsl:attribute>
+                        <xsl:apply-templates select="@*|node()"/>
+                    </xsl:copy>
+                </xsl:template>
+
+                <xsl:template match="@*|node()">
+                    <xsl:copy>
+                        <xsl:apply-templates select="@*|node()"/>
+                    </xsl:copy>
+                </xsl:template>
+
+            </xsl:stylesheet>
+        );
+
+        const xml = xmlParse(
+            <chapter>
+                <para>Then with expanded wings he steers his flight</para>
+                <figure>
+                    <title>"Incumbent on the Dusky Air"</title>
+                    <graphic fileref="pic1.jpg"/>
+                </figure>
+                <para>Aloft, incumbent on the dusky Air</para>
+                <sect1>
+                    <para>That felt unusual weight, till on dry Land</para>
+                    <figure>
+                        <title>"He Lights"</title>
+                        <graphic fileref="pic2.jpg"/>
+                    </figure>
+                    <para>He lights, if it were Land that ever burned</para>
+                    <sect2>
+                        <para>With solid, as the Lake with liquid fire</para>
+                        <figure>
+                            <title>"The Lake with Liquid Fire"</title>
+                            <graphic fileref="pic3.jpg"/>
+                        </figure>
+                    </sect2>
+                </sect1>
+            </chapter>
+        );
+
+        const xsltClass = new Xslt();
+
+        const outXmlString = xsltClass.xsltProcess(
+            xml,
+            xsltDefinition
+        );
+
+        console.log(outXmlString)
+        assert.ok(!outXmlString);
+    });
+});

tests/xpath.test.tsx renamed to tests/xpath/xpath.test.tsx

@@ -16,11 +16,11 @@ import assert from 'assert';
 import { dom } from 'isomorphic-jsx';
 import React from 'react';
 
-import { ExprContext, XPath } from '../src/xpath';
-import { xmlParse, xmlValue } from '../src/dom';
-import { BooleanValue } from '../src/xpath/values/boolean-value';
-import { NumberValue } from '../src/xpath/values/number-value';
-import { StringValue } from '../src/xpath/values/string-value';
+import { ExprContext, XPath } from '../../src/xpath';
+import { xmlParse, xmlValue } from '../../src/dom';
+import { BooleanValue } from '../../src/xpath/values/boolean-value';
+import { NumberValue } from '../../src/xpath/values/number-value';
+import { StringValue } from '../../src/xpath/values/string-value';
 
 // Just touching the `dom`, otherwise Babel prunes the import.
 console.log(dom);