add hidingOlderIdenticalBuilds helper

Author: MattKiazyk

Sources/XcodesKit/Models/Xcodes/XcodeListGrouping.swift

@@ -167,7 +167,9 @@ public extension Array {
 
     /// Groups arbitrary elements by the major version of a derived Xcode list item.
     func groupedByMajorVersion(item: (Element) -> XcodeListItem) -> [XcodeListElementMajorVersionGroup<Element>] {
-        Dictionary(grouping: self, by: { item($0).version.major })
+        let visibleElements = hidingOlderIdenticalBuilds(item: item)
+
+        return Dictionary(grouping: visibleElements, by: { item($0).version.major })
             .map { majorVersion, elements in
                 let minorVersionGroups = Dictionary(grouping: elements, by: { item($0).version.minor })
                     .map { minorVersion, minorElements in
@@ -223,7 +225,9 @@ public extension Array where Element == XcodeListItem {
 
     /// Groups Xcode list items by major version, then minor version.
     func groupedByMajorVersion() -> [XcodeMajorVersionGroup] {
-        Dictionary(grouping: self, by: { $0.version.major })
+        let visibleItems = hidingOlderIdenticalBuilds(item: { $0 })
+
+        return Dictionary(grouping: visibleItems, by: { $0.version.major })
             .map { majorVersion, xcodes in
                 let minorVersionGroups = Dictionary(grouping: xcodes, by: { $0.version.minor })
                     .map { minorVersion, minorXcodes in
@@ -275,6 +279,30 @@ private struct XcodeListFilteredElement<Element> {
     let item: XcodeListItem
 }
 
+private extension Array {
+    func hidingOlderIdenticalBuilds(item: (Element) -> XcodeListItem) -> [Element] {
+        let items = map(item)
+        let visibleIDs = Set(items.map(\.id))
+        let identicalBuildGroups = items
+            .map(\.identicalBuilds)
+            .filter { $0.isEmpty == false }
+
+        return filter { element in
+            let currentID = item(element).id
+
+            return identicalBuildGroups.contains { identicalBuilds in
+                guard identicalBuilds.contains(currentID) else { return false }
+
+                return identicalBuilds.contains { identicalID in
+                    identicalID.architectures == currentID.architectures &&
+                        identicalID.version > currentID.version &&
+                        visibleIDs.contains(identicalID)
+                }
+            } == false
+        }
+    }
+}
+
 private extension Array {
     func applying(_ filters: XcodeListFilters) -> [Element] where Element: XcodeListFilterable {
         var elements = self

Tests/XcodesKitTests/XcodeListGroupingTests.swift

@@ -57,6 +57,44 @@ final class XcodeListGroupingTests: XCTestCase {
         XCTAssertTrue(minorGroup.hasInstalling)
     }
 
+    func testGroupedVersionsHideOlderIdenticalBuildsWhenNewerBuildIsVisible() throws {
+        let releaseID = XcodeID(version: try XCTUnwrap(Version("26.5.0+17F76")))
+        let releaseCandidateID = XcodeID(version: try XCTUnwrap(Version("26.5.0-Release.Candidate+17F76")))
+        let items = try [
+            item("26.5.0+17F76", identicalBuilds: [releaseID, releaseCandidateID]),
+            item("26.5.0-Release.Candidate+17F76")
+        ]
+
+        let versions = try XCTUnwrap(items.groupedByMajorVersion().first?.versions.map(\.version))
+
+        XCTAssertEqual(versions, [try XCTUnwrap(Version("26.5.0+17F76"))])
+    }
+
+    func testGroupedVersionsKeepOlderIdenticalBuildsWhenNewerBuildIsFilteredOut() throws {
+        let releaseID = XcodeID(version: try XCTUnwrap(Version("26.5.0+17F76")))
+        let releaseCandidateID = XcodeID(version: try XCTUnwrap(Version("26.5.0-Release.Candidate+17F76")))
+        let items = try [
+            item("26.5.0-Release.Candidate+17F76", identicalBuilds: [releaseID, releaseCandidateID])
+        ]
+
+        let versions = try XCTUnwrap(items.groupedByMajorVersion().first?.versions.map(\.version))
+
+        XCTAssertEqual(versions, [try XCTUnwrap(Version("26.5.0-Release.Candidate+17F76"))])
+    }
+
+    func testGenericGroupedVersionsHideOlderIdenticalBuildsWhenNewerBuildIsVisible() throws {
+        let releaseID = XcodeID(version: try XCTUnwrap(Version("26.5.0+17F76")))
+        let releaseCandidateID = XcodeID(version: try XCTUnwrap(Version("26.5.0-Release.Candidate+17F76")))
+        let items = try [
+            PositionedXcodeListItem(position: 0, item: item("26.5.0+17F76", identicalBuilds: [releaseID, releaseCandidateID])),
+            PositionedXcodeListItem(position: 1, item: item("26.5.0-Release.Candidate+17F76"))
+        ]
+
+        let groups = items.groupedByMajorVersion(item: \.item)
+
+        XCTAssertEqual(groups.first?.versions.map(\.position), [0])
+    }
+
     func testAppliesVersionArchitectureSearchAndInstalledFilters() throws {
         let installedPath = try XCTUnwrap(Path("/Applications/Xcode-16.0.app"))
         let items = try [
@@ -109,12 +147,14 @@ final class XcodeListGroupingTests: XCTestCase {
 
     private func item(
         _ version: String,
+        identicalBuilds: [XcodeID] = [],
         installState: XcodeInstallState = .notInstalled,
         selected: Bool = false,
         architectures: [Architecture]? = nil
     ) throws -> XcodeListItem {
         XcodeListItem(
             version: try XCTUnwrap(Version(version)),
+            identicalBuilds: identicalBuilds,
             installState: installState,
             selected: selected,
             architectures: architectures