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
132
133
134
135
136
137
138
139
140
141
142
143
144
|
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift open source project
//
// Copyright (c) 2023 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 the list of Swift project authors
//
//===----------------------------------------------------------------------===//
import ArgumentParser
import struct Basics.Environment
import CoreCommands
import Foundation
import PackageModel
import TSCBasic
extension SwiftPackageCommand {
struct Install: SwiftCommand {
static let configuration = CommandConfiguration(
commandName: "experimental-install",
abstract: "Offers the ability to install executable products of the current package."
)
@OptionGroup()
var globalOptions: GlobalOptions
@Option(help: "The name of the executable product to install")
var product: String?
func run(_ commandState: SwiftCommandState) throws {
let swiftpmBinDir = try commandState.fileSystem.getOrCreateSwiftPMInstalledBinariesDirectory()
let env = Environment.current
if let path = env[.path], !path.contains(swiftpmBinDir.pathString), !globalOptions.logging.quiet {
commandState.observabilityScope.emit(
warning: """
PATH doesn't include \(swiftpmBinDir.pathString)! This means you won't be able to access \
the installed executables by default, and will need to specify the full path.
"""
)
}
let alreadyExisting = (try? InstalledPackageProduct.installedProducts(commandState.fileSystem)) ?? []
let workspace = try commandState.getActiveWorkspace()
let packageRoot = try commandState.getPackageRoot()
let packageGraph = try workspace.loadPackageGraph(
rootPath: packageRoot,
observabilityScope: commandState.observabilityScope
)
let possibleCandidates = packageGraph.rootPackages.flatMap(\.products)
.filter { $0.type == .executable }
let productToInstall: Product
switch possibleCandidates.count {
case 0:
throw StringError("No Executable Products in Package.swift.")
case 1:
productToInstall = possibleCandidates[0].underlying
default:
guard let product, let first = possibleCandidates.first(where: { $0.name == product }) else {
throw StringError(
"""
Multiple candidates found, however, no product was specified. Specify a product with the \
`--product` option
"""
)
}
productToInstall = first.underlying
}
if let existingPkg = alreadyExisting.first(where: { $0.name == productToInstall.name }) {
throw StringError("\(productToInstall.name) is already installed at \(existingPkg.path)")
}
if commandState.options.build.configuration == nil {
commandState.preferredBuildConfiguration = .release
}
try commandState.createBuildSystem(explicitProduct: productToInstall.name)
.build(subset: .product(productToInstall.name))
let binPath = try commandState.productsBuildParameters.buildPath.appending(component: productToInstall.name)
let finalBinPath = swiftpmBinDir.appending(component: binPath.basename)
try commandState.fileSystem.copy(from: binPath, to: finalBinPath)
print("Executable product `\(productToInstall.name)` was successfully installed to \(finalBinPath).")
}
}
struct Uninstall: SwiftCommand {
static let configuration = CommandConfiguration(
commandName: "experimental-uninstall",
abstract: "Offers the ability to uninstall executable products previously installed by `swift package experimental-install`."
)
@OptionGroup
var globalOptions: GlobalOptions
@Argument(help: "Name of the executable to uninstall.")
var name: String
func run(_ tool: SwiftCommandState) throws {
let alreadyInstalled = (try? InstalledPackageProduct.installedProducts(tool.fileSystem)) ?? []
guard let removedExecutable = alreadyInstalled.first(where: { $0.name == name }) else {
// The installed executable doesn't exist - let the user know, and stop here.
throw StringError("No such installed executable as \(name)")
}
try tool.fileSystem.removeFileTree(removedExecutable.path)
print("Executable product `\(self.name)` was successfully uninstalled from \(removedExecutable.path).")
}
}
}
private struct InstalledPackageProduct {
static func installedProducts(_ fileSystem: FileSystem) throws -> [InstalledPackageProduct] {
let binPath = try fileSystem.getOrCreateSwiftPMInstalledBinariesDirectory()
let contents = ((try? fileSystem.getDirectoryContents(binPath)) ?? [])
.map { binPath.appending($0) }
return contents.map { path in
InstalledPackageProduct(path: .init(path))
}
}
/// The name of this installed product, being the basename of the path.
var name: String {
self.path.basename
}
/// Path of the executable.
let path: AbsolutePath
}
|
