PureXML/Sources/XPath/Evaluator.swift

extension PureXML.XPath {
    /// Evaluates compiled steps over a node, returning the selected node-set in
    /// document order. The provided node is treated as the starting context (and,
    /// for an absolute path, as the root).
    enum Evaluator {
        static func evaluate(
            steps: [Step],
            over node: PureXML.Model.Node,
        ) throws -> [Selection] {
            guard !steps.isEmpty else { return [.node(node)] }
            var context: [PureXML.Model.Node] = [node]
            for (offset, step) in steps.enumerated() {
                if step.axis == .attribute {
                    guard offset == steps.count - 1 else { throw QueryError.attributeStepNotLast }
                    return attributeSelections(step, context: context)
                }
                var next: [PureXML.Model.Node] = []
                for contextNode in context {
                    let candidates = candidateNodes(step, contextNode)
                    next.append(contentsOf: applyPredicates(step.predicates, to: candidates))
                }
                context = next
            }
            return context.map { .node($0) }
        }

        private static func candidateNodes(_ step: Step, _ contextNode: PureXML.Model.Node) -> [PureXML.Model.Node] {
            let pool: [PureXML.Model.Node] = switch step.axis {
            case .child: children(of: contextNode)
            case .descendant: subtree(of: contextNode)
            case .selfNode: [contextNode]
            case .attribute: []
            }
            return pool.filter { matches($0, step.test) }
        }

        private static func attributeSelections(_ step: Step, context: [PureXML.Model.Node]) -> [Selection] {
            var result: [Selection] = []
            for contextNode in context {
                guard case let .element(element) = contextNode else { continue }
                var attributes = element.attributes.filter { attributeMatches($0, step.test) }
                for predicate in step.predicates {
                    if case let .position(index) = predicate {
                        attributes = (index >= 1 && index <= attributes.count) ? [attributes[index - 1]] : []
                    }
                }
                result.append(contentsOf: attributes.map { .attribute($0) })
            }
            return result
        }

        private static func applyPredicates(
            _ predicates: [Predicate],
            to nodes: [PureXML.Model.Node],
        ) -> [PureXML.Model.Node] {
            var result = nodes
            for predicate in predicates {
                switch predicate {
                case let .position(index):
                    result = (index >= 1 && index <= result.count) ? [result[index - 1]] : []
                case let .hasAttribute(name):
                    result = result.filter { attributeValue($0, name) != nil }
                case let .attributeEquals(name, value):
                    result = result.filter { attributeValue($0, name) == value }
                case let .hasChild(name):
                    result = result.filter { childElement($0, name) != nil }
                case let .childEquals(name, value):
                    result = result.filter { childElementText($0, name) == value }
                }
            }
            return result
        }

        private static func children(of node: PureXML.Model.Node) -> [PureXML.Model.Node] {
            switch node {
            case let .element(element): element.children
            case let .document(nodes): nodes
            default: []
            }
        }

        private static func subtree(of node: PureXML.Model.Node) -> [PureXML.Model.Node] {
            var result = [node]
            for child in children(of: node) {
                result.append(contentsOf: subtree(of: child))
            }
            return result
        }

        private static func matches(_ node: PureXML.Model.Node, _ test: NodeTest) -> Bool {
            switch test {
            case let .name(name):
                guard case let .element(element) = node else { return false }
                return element.name.description == name || element.name.localName == name
            case .wildcard:
                if case .element = node { return true }
                return false
            case .text:
                if case .text = node { return true }
                if case .cdata = node { return true }
                return false
            case .node:
                return true
            case .comment:
                if case .comment = node { return true }
                return false
            }
        }

        private static func attributeMatches(_ attribute: PureXML.Model.Attribute, _ test: NodeTest) -> Bool {
            switch test {
            case let .name(name): attribute.name.description == name || attribute.name.localName == name
            case .wildcard: true
            default: false
            }
        }

        private static func attributeValue(_ node: PureXML.Model.Node, _ name: String) -> String? {
            guard case let .element(element) = node else { return nil }
            return element.attributes.first { $0.name.description == name || $0.name.localName == name }?.value
        }

        private static func childElementNode(_ node: PureXML.Model.Node, _ name: String) -> PureXML.Model.Node? {
            guard case let .element(element) = node else { return nil }
            return element.children.first { child in
                if case let .element(inner) = child {
                    return inner.name.description == name || inner.name.localName == name
                }
                return false
            }
        }

        private static func childElement(_ node: PureXML.Model.Node, _ name: String) -> PureXML.Model.Element? {
            guard case let .element(found) = childElementNode(node, name) else { return nil }
            return found
        }

        private static func childElementText(_ node: PureXML.Model.Node, _ name: String) -> String? {
            guard let child = childElementNode(node, name) else { return nil }
            return Selection.node(child).stringValue
        }
    }
}