From e30672d72b1585fc51f0ab9fe0aa5f434da9f716 Mon Sep 17 00:00:00 2001 From: Mihaela Mihaljevic Date: Tue, 9 Jun 2026 02:37:43 +0200 Subject: [PATCH] feat(xslt): implement xsl:sort case-order case-order=upper-first/lower-first makes the string comparison case-insensitive, with case used only to break ties among otherwise-equal strings; without it the default codepoint order is unchanged. Part of #82. --- CHANGELOG.md | 1 + Sources/XSLT/XSLTElements.swift | 13 ++++++++++ Sources/XSLT/XSLTModel.swift | 16 ++++++++++++ Sources/XSLT/XSLTParser.swift | 9 +++++++ Sources/XSLT/XSLTTransformer.swift | 4 +-- Tests/XSLTSortCaseOrderTests.swift | 39 ++++++++++++++++++++++++++++++ 6 files changed, 80 insertions(+), 2 deletions(-) create mode 100644 Tests/XSLTSortCaseOrderTests.swift diff --git a/CHANGELOG.md b/CHANGELOG.md index b04d145..940db43 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Added +- XSLT `xsl:sort case-order` (#82). When `case-order="upper-first"`/`"lower-first"` is set, the sort comparison is case-insensitive with the case used only to break ties among otherwise-equal strings; without it the default codepoint order is kept. - XSLT functions `generate-id`, `system-property`, `element-available`, `function-available`, and an `unparsed-entity-uri` stub (#82). `generate-id` returns a stable per-node identifier (the context node when no argument is diff --git a/Sources/XSLT/XSLTElements.swift b/Sources/XSLT/XSLTElements.swift index 1a960c5..2620f73 100644 --- a/Sources/XSLT/XSLTElements.swift +++ b/Sources/XSLT/XSLTElements.swift @@ -1,4 +1,17 @@ extension PureXML.XSLT.Transformer { + /// Compares strings case-insensitively, with `caseOrder` breaking ties among + /// strings that differ only in case (the XSLT `case-order` semantics). + static func caseInsensitiveCompare(_ left: String, _ right: String, _ caseOrder: PureXML.XSLT.CaseOrder) -> Int { + let leftLower = left.lowercased() + let rightLower = right.lowercased() + if leftLower != rightLower { return leftLower < rightLower ? -1 : 1 } + if left == right { return 0 } + // Equal apart from case: codepoint order puts uppercase first. + let upperFirst = left < right + let leftFirst = caseOrder == .upperFirst ? upperFirst : !upperFirst + return leftFirst ? -1 : 1 + } + /// Rewrites a literal name in an `xsl:namespace-alias`ed stylesheet namespace /// to its result namespace and prefix; other names pass through unchanged. func aliased(_ name: PureXML.Model.QualifiedName) -> PureXML.Model.QualifiedName { diff --git a/Sources/XSLT/XSLTModel.swift b/Sources/XSLT/XSLTModel.swift index 638ab88..84ec3b0 100644 --- a/Sources/XSLT/XSLTModel.swift +++ b/Sources/XSLT/XSLTModel.swift @@ -16,11 +16,27 @@ public extension PureXML.XSLT { public var value: ValueTemplate } + /// Which case sorts first among strings equal apart from case. + enum CaseOrder: Sendable { + case upperFirst + case lowerFirst + } + /// A sort specification for `apply-templates`/`for-each`. struct Sort: Sendable { public var select: String public var descending: Bool public var numeric: Bool + /// `case-order`: when set, the comparison is case-insensitive and this + /// breaks ties; when nil, the comparison is the default codepoint order. + public var caseOrder: CaseOrder? + + public init(select: String, descending: Bool, numeric: Bool, caseOrder: CaseOrder? = nil) { + self.select = select + self.descending = descending + self.numeric = numeric + self.caseOrder = caseOrder + } } /// One instruction of a template body (a sequence constructor item). diff --git a/Sources/XSLT/XSLTParser.swift b/Sources/XSLT/XSLTParser.swift index 58c7d1f..c081e4b 100644 --- a/Sources/XSLT/XSLTParser.swift +++ b/Sources/XSLT/XSLTParser.swift @@ -322,12 +322,21 @@ extension PureXML.XSLT { (XSLTNode.attribute(node, "use-attribute-sets") ?? "").split(whereSeparator: \.isWhitespace).map(String.init) } + private static func caseOrder(_ node: Tree) -> PureXML.XSLT.CaseOrder? { + switch XSLTNode.attribute(node, "case-order") { + case "upper-first": .upperFirst + case "lower-first": .lowerFirst + default: nil + } + } + private static func sorts(_ node: Tree) -> [Sort] { XSLTNode.children(node, named: "sort").map { sort in Sort( select: XSLTNode.attribute(sort, "select") ?? ".", descending: XSLTNode.attribute(sort, "order") == "descending", numeric: XSLTNode.attribute(sort, "data-type") == "number", + caseOrder: caseOrder(sort), ) } } diff --git a/Sources/XSLT/XSLTTransformer.swift b/Sources/XSLT/XSLTTransformer.swift index 88e35bf..b544f3e 100644 --- a/Sources/XSLT/XSLTTransformer.swift +++ b/Sources/XSLT/XSLTTransformer.swift @@ -180,8 +180,6 @@ extension PureXML.XSLT { } extension PureXML.XSLT.Transformer { - // MARK: Instruction evaluation - fileprivate func evaluate(_ instruction: PureXML.XSLT.Instruction, _ context: XSLTContext) -> [ResultItem] { simpleEvaluate(instruction, context) ?? structuralEvaluate(instruction, context) } @@ -386,6 +384,8 @@ extension PureXML.XSLT.Transformer { let leftNumber = PureXML.XPath.Value.parseNumber(left) let rightNumber = PureXML.XPath.Value.parseNumber(right) order = leftNumber == rightNumber ? 0 : (leftNumber < rightNumber ? -1 : 1) + } else if let caseOrder = sort.caseOrder { + order = Self.caseInsensitiveCompare(left, right, caseOrder) } else { order = left == right ? 0 : (left < right ? -1 : 1) } diff --git a/Tests/XSLTSortCaseOrderTests.swift b/Tests/XSLTSortCaseOrderTests.swift new file mode 100644 index 0000000..bc3d773 --- /dev/null +++ b/Tests/XSLTSortCaseOrderTests.swift @@ -0,0 +1,39 @@ +@testable import PureXML +import Testing + +@Suite("XSLT xsl:sort case-order") +struct XSLTSortCaseOrderTests { + private let xsl = "xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\"" + + private func transform(_ stylesheet: String, _ source: String) throws -> String { + try PureXML.XSLT.transform(stylesheet: stylesheet, source: source) + } + + private func sortStyle(_ caseOrder: String) -> String { + """ + + + , + + """ + } + + @Test("case-order=upper-first puts uppercase before its lowercase twin") + func test_upperFirst() throws { + let out = try transform(sortStyle("case-order=\"upper-first\""), "bAaB") + #expect(out == "A,a,B,b,") + } + + @Test("case-order=lower-first puts lowercase before its uppercase twin") + func test_lowerFirst() throws { + let out = try transform(sortStyle("case-order=\"lower-first\""), "bAaB") + #expect(out == "a,A,b,B,") + } + + @Test("Without case-order the default codepoint order is unchanged") + func test_default() throws { + let out = try transform(sortStyle(""), "bAaB") + // Codepoint order: all uppercase (A,B) before all lowercase (a,b). + #expect(out == "A,B,a,b,") + } +}