- Moving back the ExprContext to xpath directory;

- Adding the `MatchResolver` class, since `Xslt` class should only work with the XSLT operations, not with XPath matches.

Author: leonelsanchesdasilva

src/xslt/expr-context.ts renamed to src/xpath/expr-context.ts

@@ -1,11 +1,11 @@
 import { DOM_DOCUMENT_NODE } from '../constants';
-import { BooleanValue } from '../xpath/values/boolean-value';
-import { NodeSetValue } from '../xpath/values/node-set-value';
-import { NumberValue } from '../xpath/values/number-value';
-import { StringValue } from '../xpath/values/string-value';
-import { TOK_NUMBER } from '../xpath/tokens';
+import { BooleanValue } from './values/boolean-value';
+import { NodeSetValue } from './values/node-set-value';
+import { NumberValue } from './values/number-value';
+import { StringValue } from './values/string-value';
+import { TOK_NUMBER } from './tokens';
 import { XNode } from '../dom';
-import { XsltDecimalFormatSettings } from './xslt-decimal-format-settings';
+import { XsltDecimalFormatSettings } from '../xslt/xslt-decimal-format-settings';
 
 /** XPath expression evaluation context. An XPath context consists of a
  * DOM node, a list of DOM nodes that contains this node, a number

src/xpath/expressions/binary-expr.ts

@@ -1,5 +1,5 @@
 import { xmlValue } from "../../dom";
-import { ExprContext } from "../../xslt/expr-context";
+import { ExprContext } from "../expr-context";
 import { BooleanValue } from "../values/boolean-value";
 import { NumberValue } from "../values/number-value";
 import { Expression } from "./expression";

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

@@ -1,4 +1,4 @@
-import { ExprContext } from '../../xslt/expr-context';
+import { ExprContext } from '../expr-context';
 import {
     count,
     generateId,

src/xpath/expressions/location-expr.ts

@@ -1,4 +1,4 @@
-import { ExprContext } from "../../xslt/expr-context";
+import { ExprContext } from "../expr-context";
 import { NodeSetValue } from "../values/node-set-value";
 import { NodeTestAny } from "../node-tests/node-test-any";
 import { xPathAxis } from "../tokens";

src/xpath/expressions/step-expr.ts

@@ -1,6 +1,6 @@
 import { DOM_ATTRIBUTE_NODE } from '../../constants';
 import { XNode } from '../../dom';
-import { ExprContext } from '../../xslt/expr-context';
+import { ExprContext } from '../expr-context';
 import { NodeSetValue } from '../values/node-set-value';
 import { NodeTestAny } from '../node-tests/node-test-any';
 import { xPathAxis } from '../tokens';

src/xpath/functions/non-standard.ts

@@ -1,5 +1,5 @@
 import { xmlValue } from "../../dom";
-import { ExprContext } from "../../xslt/expr-context";
+import { ExprContext } from "../expr-context";
 import { NodeSetValue, StringValue } from "../values";
 import { assert } from "./internal-functions";
 

src/xpath/functions/standard.ts

@@ -1,5 +1,5 @@
 import { XNode, xmlValue } from "../../dom";
-import { ExprContext } from "../../xslt/expr-context";
+import { ExprContext } from "../expr-context";
 import { XsltDecimalFormatSettings } from "../../xslt/xslt-decimal-format-settings";
 import { BooleanValue, NodeSetValue, NumberValue, StringValue } from "../values";
 import { assert, regExpEscape } from "./internal-functions";

src/xpath/index.ts

@@ -1,3 +1,3 @@
-export * from '../xslt/expr-context';
+export * from './expr-context';
 export * from './xpath';
 export * from './xpath-token-rule';

src/xpath/match-resolver.ts

@@ -0,0 +1,112 @@
+import { XNode } from "../dom";
+import { ExprContext } from "./expr-context";
+import { LocationExpr, UnionExpr } from "./expressions";
+import { Expression } from "./expressions/expression";
+
+/**
+ * Class that resolves XPath expressions, returning nodes.
+ */
+export class MatchResolver {
+
+    /**
+     * This class entry point.
+     * @param expression The expression to be resolved.
+     * @param context The Expression Context
+     * @returns An array of nodes.
+     */
+    expressionMatch(expression: Expression, context: ExprContext): XNode[] {
+        if (expression instanceof LocationExpr) {
+            return this.locationExpressionMatch(expression, context);
+        }
+
+        if (expression instanceof UnionExpr) {
+            return this.unionExpressionMatch(expression, context);
+        }
+
+        // TODO: Other expressions
+        return [];
+    }
+
+    /**
+     * Resolves a `LocationExpr`.
+     * @param expression The Location Expression.
+     * @param context The Expression Context.
+     * @returns Either the results of a relative resolution, or the results of an
+     *          absolute resolution.
+     */
+    private locationExpressionMatch(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.');
+        }
+
+        if (expression.absolute) {
+            return this.absoluteXsltMatch(expression, context);
+        }
+
+        return this.relativeXsltMatch(expression, context);
+    }
+
+    /**
+     * Resolves a `UnionExpr`.
+     * @param expression The Union Expression.
+     * @param context The Expression Context.
+     * @returns The concatenated result of evaluating the both sides of the expression.
+     */
+    private unionExpressionMatch(expression: UnionExpr, context: ExprContext) {
+        let expr1Nodes = this.expressionMatch(expression.expr1, context);
+        return expr1Nodes.concat(this.expressionMatch(expression.expr2, context));
+    }
+
+    /**
+     * Finds all the nodes through absolute xPath search.
+     * Returns only nodes that match either the context position node,
+     * or an ancestor.
+     * @param expression The Expression.
+     * @param context The Expression Context.
+     * @returns The list of found nodes.
+     */
+    private absoluteXsltMatch(expression: LocationExpr, context: ExprContext): XNode[] {
+        const clonedContext = context.clone([context.root], undefined, 0, undefined);
+        const matchedNodes = expression.evaluate(clonedContext).nodeSetValue();
+        const finalList = [];
+
+        for (let element of matchedNodes) {
+            if (element.id === context.nodeList[context.position].id) {
+                finalList.push(element);
+                continue;
+            }
+
+            if (element.getAncestorById(context.nodeList[context.position].id) !== undefined) {
+                finalList.push(element);
+            }
+        }
+
+        return finalList;
+    }
+
+    /**
+     * Tries to find relative nodes from the actual context position.
+     * If found nodes are already in the context, or if they are children of
+     * nodes in the context, they are returned.
+     * @param expression The expression used.
+     * @param context The Expression Context.
+     * @returns The list of found nodes.
+     */
+    private relativeXsltMatch(expression: LocationExpr, context: ExprContext): XNode[] {
+        // For some reason, XPath understands a default as 'child axis'.
+        // There's no "self + siblings" axis, so what is expected at this point
+        // is to have in the expression context the parent that should
+        // have the nodes we are interested in.
+
+        const clonedContext = context.clone();
+        let nodes = expression.evaluate(clonedContext).nodeSetValue();
+        if (nodes.length === 1 && nodes[0].nodeName === '#document') {
+            // As we don't work with the #document node directly, this part
+            // returns its first sibling.
+            // By the way, it should be *always* one sibling here.
+            return [nodes[0].childNodes[0]];
+        }
+
+        return nodes;
+    }
+}

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

@@ -1,5 +1,5 @@
 import { DOM_COMMENT_NODE } from "../../constants";
-import { ExprContext } from "../../xslt/expr-context";
+import { ExprContext } from "../expr-context";
 import { NodeTest } from "./node-test";
 import { BooleanValue } from "../values/boolean-value";