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,")
+ }
+}