/
PackageGraphRoot.swift
131 lines (113 loc) · 5.44 KB
/
PackageGraphRoot.swift
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
/*
This source file is part of the Swift.org open source project
Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
Licensed under Apache License v2.0 with Runtime Library Exception
See http://swift.org/LICENSE.txt for license information
See http://swift.org/CONTRIBUTORS.txt for Swift project authors
*/
import Basics
import PackageModel
import SourceControl
import TSCBasic
import TSCUtility
/// Represents the input to the package graph root.
public struct PackageGraphRootInput {
/// The list of root packages.
public let packages: [AbsolutePath]
/// Top level dependencies to the graph.
public let dependencies: [PackageDependencyDescription]
/// Create a package graph root.
public init(packages: [AbsolutePath], dependencies: [PackageDependencyDescription] = []) {
self.packages = packages
self.dependencies = dependencies
}
}
/// Represents the inputs to the package graph.
public struct PackageGraphRoot {
/// The root packages.
public let packages: [PackageIdentity: (reference: PackageReference, manifest: Manifest)]
/// The root manifests.
public var manifests: [PackageIdentity: Manifest] {
return self.packages.compactMapValues { $0.manifest }
}
/// The root package references.
public var packageReferences: [PackageReference] {
return self.packages.values.map { $0.reference }
}
/// The top level dependencies.
public let dependencies: [PackageDependencyDescription]
/// Create a package graph root.
/// Note this quietly skip inputs for which manifests are not found. this could be because the manifest failed to load or for some other reasons
// FIXME: This API behavior wrt to non-found manifests is fragile, but required by IDEs
// it may lead to incorrect assumption in downstream code which may expect an error if a manifest was not found
// we should refactor this API to more clearly return errors for inputs that do not have a corresponding manifest
public init(input: PackageGraphRootInput, manifests: [AbsolutePath: Manifest], explicitProduct: String? = nil) {
self.packages = input.packages.reduce(into: .init(), { partial, inputPath in
if let manifest = manifests[inputPath] {
let packagePath = manifest.path.parentDirectory
let identity = PackageIdentity(path: packagePath) // this does not use the identity resolver which is fine since these are the root packages
partial[identity] = (.root(identity: identity, path: packagePath), manifest)
}
})
// FIXME: Deprecate special casing once the manifest supports declaring used executable products.
// Special casing explicit products like this is necessary to pass the test suite and satisfy backwards compatibility.
// However, changing the dependencies based on the command line arguments may force pins to temporarily change,
// which can become a nuissance.
// Such pin switching can currently be worked around by declaring the executable product as a dependency of a dummy target.
// But in the future it might be worth providing a way of declaring them in the manifest without a dummy target,
// at which time the current special casing can be deprecated.
var adjustedDependencies = input.dependencies
if let product = explicitProduct {
for dependency in manifests.values.lazy.map({ $0.dependenciesRequired(for: .everything) }).joined() {
adjustedDependencies.append(dependency.filtered(by: .specific([product])))
}
}
self.dependencies = adjustedDependencies
}
/// Returns the constraints imposed by root manifests + dependencies.
public func constraints() throws -> [PackageContainerConstraint] {
let constraints = self.packageReferences.map {
PackageContainerConstraint(package: $0, requirement: .unversioned, products: .everything)
}
let depend = try dependencies.map{
PackageContainerConstraint(
package: $0.createPackageRef(),
requirement: try $0.toConstraintRequirement(),
products: $0.productFilter
)
}
return constraints + depend
}
}
extension PackageDependencyDescription {
/// Returns the constraint requirement representation.
public func toConstraintRequirement() throws -> PackageRequirement {
switch self {
case .local:
return .unversioned
case .scm(let data):
return try data.requirement.toConstraintRequirement()
}
}
}
extension PackageDependencyDescription.Requirement {
/// Returns the constraint requirement representation.
public func toConstraintRequirement() throws -> PackageRequirement {
switch self {
case .range(let range):
return .versionSet(.range(range))
case .revision(let identifier):
guard Git.checkRefFormat(ref: identifier) else {
throw StringError("Could not find revision: '\(identifier)'")
}
return .revision(identifier)
case .branch(let identifier):
guard Git.checkRefFormat(ref: identifier) else {
throw StringError("Could not find branch: '\(identifier)'")
}
return .revision(identifier)
case .exact(let version):
return .versionSet(.exact(version))
}
}
}