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.
This commit is contained in:
Mihaela Mihaljevic 2026-06-09 02:37:43 +02:00
parent 46393b3aa2
commit e30672d72b
6 changed files with 80 additions and 2 deletions

View File

@ -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

View File

@ -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 {

View File

@ -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).

View File

@ -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),
)
}
}

View File

@ -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)
}

View File

@ -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 {
"""
<xsl:stylesheet version="1.0" \(xsl)>
<xsl:output method="text"/>
<xsl:template match="/"><xsl:for-each select="r/v"><xsl:sort select="." \(caseOrder)/><xsl:value-of select="."/><xsl:text>,</xsl:text></xsl:for-each></xsl:template>
</xsl:stylesheet>
"""
}
@Test("case-order=upper-first puts uppercase before its lowercase twin")
func test_upperFirst() throws {
let out = try transform(sortStyle("case-order=\"upper-first\""), "<r><v>b</v><v>A</v><v>a</v><v>B</v></r>")
#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\""), "<r><v>b</v><v>A</v><v>a</v><v>B</v></r>")
#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(""), "<r><v>b</v><v>A</v><v>a</v><v>B</v></r>")
// Codepoint order: all uppercase (A,B) before all lowercase (a,b).
#expect(out == "A,B,a,b,")
}
}