Remove relativePath property from ManagedDependency

Begin transitioning to identity-based resolution

Author: mattt

Sources/PackageModel/PackageIdentity.swift

@@ -27,7 +27,7 @@ internal protocol PackageIdentityProvider: CustomStringConvertible {
 }
 
 /// The canonical identifier for a package, based on its source location.
-public struct PackageIdentity: Hashable, CustomStringConvertible {
+public struct PackageIdentity: CustomStringConvertible {
     /// The underlying type used to create package identities.
     internal static var provider: PackageIdentityProvider.Type = LegacyPackageIdentity.self
 
@@ -70,12 +70,24 @@ public struct PackageIdentity: Hashable, CustomStringConvertible {
     }
 }
 
+extension PackageIdentity: Equatable {
+    public static func == (lhs: PackageIdentity, rhs: PackageIdentity) -> Bool {
+        return lhs.description.lowercased() == rhs.description.lowercased()
+    }
+}
+
 extension PackageIdentity: Comparable {
     public static func < (lhs: PackageIdentity, rhs: PackageIdentity) -> Bool {
         return lhs.description < rhs.description
     }
 }
 
+extension PackageIdentity: Hashable {
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(description.lowercased())
+    }
+}
+
 extension PackageIdentity: Codable {
     public init(from decoder: Decoder) throws {
         let container = try decoder.singleValueContainer()

Sources/SPMTestSupport/MockManifestLoader.swift

@@ -37,7 +37,7 @@ public final class MockManifestLoader: ManifestLoaderProtocol {
         public let version: Version?
 
         public init(url: String, version: Version? = nil) {
-            self.url = url
+            self.url = url.lowercased()
             self.version = version
         }
     }

Sources/SPMTestSupport/MockWorkspace.swift

@@ -449,7 +449,7 @@ public final class MockWorkspace {
         }
 
         public func check(notPresent name: String, file: StaticString = #file, line: UInt = #line) {
-            let dependency = self.managedDependencies[forNameOrIdentity: name]
+            let dependency = self.managedDependencies[named: name]
             XCTAssert(dependency == nil, "Unexpectedly found \(name) in managed dependencies", file: file, line: line)
         }
 
@@ -458,14 +458,16 @@ public final class MockWorkspace {
         }
 
         public func check(dependency name: String, at state: State, file: StaticString = #file, line: UInt = #line) {
-            guard let dependency = managedDependencies[forNameOrIdentity: name] else {
+            guard let dependency = managedDependencies[named: name] else {
                 XCTFail("\(name) does not exists", file: file, line: line)
                 return
             }
+
             switch state {
             case .checkout(let checkoutState):
                 guard case .checkout(let dependencyCheckoutState) = dependency.state else {
-                    return XCTFail("Expected checked out dependency; found '\(dependency.state)' instead", file: file, line: line)
+                    XCTFail("Expected checked out dependency; found '\(dependency.state)' instead", file: file, line: line)
+                    return
                 }
 
                 switch checkoutState {

Sources/Workspace/EditedState.swift

@@ -12,7 +12,7 @@ import TSCBasic
 
 public enum EditedState: Equatable {
     /// An edited dependency with a managed path relative to the editables directory.
-    case managed(RelativePath)
+    case managed
 
     /// An edited dependency with an unmanaged, absolute path.
     case unmanaged(AbsolutePath)

Sources/Workspace/ManagedDependency.swift

@@ -57,9 +57,6 @@ public class ManagedDependency {
         }
     }
 
-    /// The checked out path of the dependency on disk, relative to the workspace checkouts path.
-    public let subpath: RelativePath
-
     /// A dependency which in editable state is based on a dependency from
     /// which it edited from.
     ///
@@ -74,46 +71,28 @@ public class ManagedDependency {
         return ManagedDependency(
             package: package,
             state: .local,
-            // FIXME: This is just a fake entry, we should fix it.
-            subpath: RelativePath(package.identity.description),
             basedOn: nil
         )
     }
 
     /// Create an editable managed dependency based on a dependency which
     /// was *not* in edit state.
     public static func checkout(package: PackageReference, state: CheckoutState) -> ManagedDependency {
-        // FIXME: Temporary until subpath property is removed
-        let subpath: RelativePath
-        if let path = try? AbsolutePath(validating: package.location),
-           let lastPathComponent = path.components.last {
-            subpath = RelativePath(lastPathComponent)
-        } else {
-            subpath = RelativePath(package.identity.description)
-        }
-
-        return ManagedDependency(package: package, state: .checkout(state), subpath: subpath, basedOn: nil)
+        return ManagedDependency(package: package, state: .checkout(state), basedOn: nil)
     }
 
     /// Create an editable managed dependency based on a dependency which
     /// was *not* in edit state.
     public static func edited(basedOn dependency: ManagedDependency, state: EditedState) -> ManagedDependency {
-        switch state {
-        case .managed(let path):
-            return ManagedDependency(package: dependency.package, state: .edited(state), subpath: path, basedOn: dependency)
-        case .unmanaged:
-            return ManagedDependency(package: dependency.package, state: .edited(state), subpath: dependency.subpath, basedOn: dependency)
-        }
+        return ManagedDependency(package: dependency.package, state: .edited(state), basedOn: dependency)
     }
 
     internal init(
         package: PackageReference,
         state: State,
-        subpath: RelativePath,
         basedOn: ManagedDependency?
     ) {
         self.package = package
-        self.subpath = subpath
         self.basedOn = basedOn
         self.state = state
     }
@@ -131,59 +110,60 @@ extension ManagedDependency: CustomStringConvertible {
 /// A collection of managed dependencies.
 public final class ManagedDependencies {
     /// The dependencies keyed by the package URL.
-    private var dependencyMap: [String: ManagedDependency]
+    private var map: [PackageIdentity: ManagedDependency]
 
-    init(dependencyMap: [String: ManagedDependency] = [:]) {
-        self.dependencyMap = dependencyMap
+    init(_ dependencies: [ManagedDependency] = []) {
+        self.map = Dictionary(zip( dependencies.map { $0.package.identity }, dependencies), uniquingKeysWith: { lhs, _ in lhs })
     }
 
-    public subscript(forURL url: String) -> ManagedDependency? {
-        dependencyMap[url]
+    public subscript(_ identity: PackageIdentity) -> ManagedDependency? {
+        return map[identity]
+    }
+
+    public subscript(named name: String) -> ManagedDependency? {
+        return map[.plain(name)]
     }
 
-    public subscript(forIdentity identity: PackageIdentity) -> ManagedDependency? {
-        dependencyMap.values.first(where: { $0.package.identity == identity })
+    public subscript(forURL url: String) -> ManagedDependency? {
+        return self[.init(url: url)]
     }
 
-    public subscript(forNameOrIdentity nameOrIdentity: String) -> ManagedDependency? {
-        let lowercasedNameOrIdentity = nameOrIdentity.lowercased()
-        return dependencyMap.values.first(where: {
-            $0.package.name == nameOrIdentity || $0.package.identity.description == lowercasedNameOrIdentity
-        })
+    public subscript(atPath path: AbsolutePath) -> ManagedDependency? {
+        return self[.init(path: path)]
     }
 
     public func add(_ dependency: ManagedDependency) {
-        self.dependencyMap[dependency.package.location] = dependency
+        map[dependency.package.identity] = dependency
     }
 
-    public func remove(forURL url: String) {
-        self.dependencyMap[url] = nil
+    public func remove(_ dependency: ManagedDependency) {
+        map[dependency.package.identity] = nil
     }
 }
 
 extension ManagedDependencies: Collection {
-    public typealias Index = Dictionary<String, ManagedDependency>.Index
+    public typealias Index = Dictionary<PackageIdentity, ManagedDependency>.Index
     public typealias Element = ManagedDependency
 
     public var startIndex: Index {
-        self.dependencyMap.startIndex
+        map.startIndex
     }
 
     public var endIndex: Index {
-        self.dependencyMap.endIndex
+        map.endIndex
     }
 
     public subscript(index: Index) -> Element {
-        self.dependencyMap[index].value
+        map[index].value
     }
 
     public func index(after index: Index) -> Index {
-        self.dependencyMap.index(after: index)
+        map.index(after: index)
     }
 }
 
 extension ManagedDependencies: CustomStringConvertible {
     public var description: String {
-        "<ManagedDependencies: \(Array(dependencyMap.values))>"
+        "<ManagedDependencies: \(Array(map.values))>"
     }
 }