-
Notifications
You must be signed in to change notification settings - Fork 4.6k
/
InitScriptApi.kt
382 lines (353 loc) · 15.3 KB
/
InitScriptApi.kt
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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
/*
* Copyright 2023 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.gradle.kotlin.dsl
import org.gradle.api.PathValidation
import org.gradle.api.file.ConfigurableFileCollection
import org.gradle.api.file.ConfigurableFileTree
import org.gradle.api.file.CopySpec
import org.gradle.api.file.DeleteSpec
import org.gradle.api.file.FileTree
import org.gradle.api.internal.ProcessOperations
import org.gradle.api.internal.file.FileOperations
import org.gradle.api.invocation.Gradle
import org.gradle.api.logging.Logger
import org.gradle.api.logging.Logging
import org.gradle.api.logging.LoggingManager
import org.gradle.api.resources.ResourceHandler
import org.gradle.api.tasks.WorkResult
import org.gradle.internal.deprecation.DeprecationLogger
import org.gradle.kotlin.dsl.support.internalError
import org.gradle.kotlin.dsl.support.serviceOf
import org.gradle.kotlin.dsl.support.unsafeLazy
import org.gradle.process.ExecResult
import org.gradle.process.ExecSpec
import org.gradle.process.JavaExecSpec
import java.io.File
import java.net.URI
/**
* Standard implementation of the API exposed to all types of [Gradle] scripts,
* precompiled and otherwise.
*/
@Deprecated(
"Kept for compatibility with precompiled script plugins published with Gradle versions prior to 6.0",
replaceWith = ReplaceWith("Gradle", "org.gradle.api.invocation.Gradle")
)
abstract class InitScriptApi(
override val delegate: Gradle
) : @Suppress("DEPRECATION") org.gradle.kotlin.dsl.support.delegates.GradleDelegate() {
init {
@Suppress("DEPRECATION")
if (!org.gradle.kotlin.dsl.precompile.PrecompiledInitScript::class.java.isAssignableFrom(this::class.java) &&
!org.gradle.kotlin.dsl.KotlinInitScript::class.java.isAssignableFrom(this::class.java)) {
DeprecationLogger.deprecateType(InitScriptApi::class.java)
.willBeRemovedInGradle9()
.undocumented()
.nagUser()
}
}
protected
abstract val fileOperations: FileOperations
protected
abstract val processOperations: ProcessOperations
/**
* Configures the classpath of the init script.
*/
@Suppress("unused")
open fun initscript(block: ScriptHandlerScope.() -> Unit): Unit =
internalError()
/**
* Logger for init scripts. You can use this in your init script to write log messages.
*/
@Suppress("unused")
val logger: Logger by unsafeLazy { Logging.getLogger(Gradle::class.java) }
/**
* The [LoggingManager] which can be used to receive logging and to control the standard output/error capture for
* this script. By default, `System.out` is redirected to the Gradle logging system at the `QUIET` log level,
* and `System.err` is redirected at the `ERROR` log level.
*/
@Suppress("unused")
val logging by unsafeLazy { gradle.serviceOf<LoggingManager>() }
/**
* Provides access to resource-specific utility methods, for example factory methods that create various resources.
*/
@Suppress("unused")
val resources: ResourceHandler by unsafeLazy { fileOperations.resources }
/**
* Returns the relative path from this script's target base directory to the given path.
*
* The given path object is (logically) resolved as described for [KotlinInitScript.file],
* from which a relative path is calculated.
*
* @param path The path to convert to a relative path.
* @return The relative path.
*/
@Suppress("unused")
fun relativePath(path: Any): String =
fileOperations.relativePath(path)
/**
* Resolves a file path to a URI, relative to this script's target base directory.
*
* Evaluates the provided path object as described for [KotlinInitScript.file],
* with the exception that any URI scheme is supported, not just `file:` URIs.
*/
@Suppress("unused")
fun uri(path: Any): URI =
fileOperations.uri(path)
/**
* Resolves a file path relative to this script's target base directory.
*
* If this script targets [org.gradle.api.Project],
* then `path` is resolved relative to the project directory.
*
* If this script targets [org.gradle.api.initialization.Settings],
* then `path` is resolved relative to the build root directory.
*
* Otherwise the file is resolved relative to the script itself.
*
* This method converts the supplied path based on its type:
*
* - A [CharSequence], including [String].
* A string that starts with `file:` is treated as a file URL.
* - A [File].
* If the file is an absolute file, it is returned as is. Otherwise it is resolved.
* - A [java.nio.file.Path].
* The path must be associated with the default provider and is treated the same way as an instance of `File`.
* - A [URI] or [java.net.URL].
* The URL's path is interpreted as the file path. Only `file:` URLs are supported.
* - A [org.gradle.api.file.Directory] or [org.gradle.api.file.RegularFile].
* - A [org.gradle.api.provider.Provider] of any supported type.
* The provider's value is resolved recursively.
* - A [java.util.concurrent.Callable] that returns any supported type.
* The callable's return value is resolved recursively.
*
* @param path The object to resolve as a `File`.
* @return The resolved file.
*/
@Suppress("unused")
fun file(path: Any): File =
fileOperations.file(path)
/**
* Resolves a file path relative to this script's target base directory.
*
* @param path The object to resolve as a `File`.
* @param validation The validation to perform on the file.
* @return The resolved file.
* @see KotlinInitScript.file
*/
@Suppress("unused")
fun file(path: Any, validation: PathValidation): File =
fileOperations.file(path, validation)
/**
* Creates a [ConfigurableFileCollection] containing the given files.
*
* You can pass any of the following types to this method:
*
* - A [CharSequence], including [String] as defined by [KotlinInitScript.file].
* - A [File] as defined by [KotlinInitScript.file].
* - A [java.nio.file.Path] as defined by [KotlinInitScript.file].
* - A [URI] or [java.net.URL] as defined by [KotlinInitScript.file].
* - A [org.gradle.api.file.Directory] or [org.gradle.api.file.RegularFile]
* as defined by [KotlinInitScript.file].
* - A [Sequence], [Array] or [Iterable] that contains objects of any supported type.
* The elements of the collection are recursively converted to files.
* - A [org.gradle.api.file.FileCollection].
* The contents of the collection are included in the returned collection.
* - A [org.gradle.api.provider.Provider] of any supported type.
* The provider's value is recursively converted to files. If the provider represents an output of a task,
* that task is executed if the file collection is used as an input to another task.
* - A [java.util.concurrent.Callable] that returns any supported type.
* The callable's return value is recursively converted to files.
* A `null` return value is treated as an empty collection.
* - A [org.gradle.api.Task].
* Converted to the task's output files.
* The task is executed if the file collection is used as an input to another task.
* - A [org.gradle.api.tasks.TaskOutputs].
* Converted to the output files the related task.
* The task is executed if the file collection is used as an input to another task.
* - Anything else is treated as a failure.
*
* The returned file collection is lazy, so that the paths are evaluated only when the contents of the file
* collection are queried. The file collection is also live, so that it evaluates the above each time the contents
* of the collection is queried.
*
* The returned file collection maintains the iteration order of the supplied paths.
*
* The returned file collection maintains the details of the tasks that produce the files,
* so that these tasks are executed if this file collection is used as an input to some task.
*
* This method can also be used to create an empty collection, which can later be mutated to add elements.
*
* @param paths The paths to the files. May be empty.
* @return The file collection.
*/
@Suppress("unused")
fun files(vararg paths: Any): ConfigurableFileCollection =
fileOperations.configurableFiles(paths)
/**
* Creates a [ConfigurableFileCollection] containing the given files.
*
* @param paths The contents of the file collection. Evaluated as per [KotlinInitScript.files].
* @param configuration The block to use to configure the file collection.
* @return The file collection.
* @see KotlinInitScript.files
*/
@Suppress("unused")
fun files(paths: Any, configuration: ConfigurableFileCollection.() -> Unit): ConfigurableFileCollection =
fileOperations.configurableFiles(paths).also(configuration)
/**
* Creates a new [ConfigurableFileTree] using the given base directory.
*
* The given `baseDir` path is evaluated as per [KotlinInitScript.file].
*
* The returned file tree is lazy, so that it scans for files only when the contents of the file tree are
* queried. The file tree is also live, so that it scans for files each time the contents of the file tree are
* queried.
*
* @param baseDir The base directory of the file tree. Evaluated as per [KotlinInitScript.file].
* @return The file tree.
*/
@Suppress("unused")
fun fileTree(baseDir: Any): ConfigurableFileTree =
fileOperations.fileTree(baseDir)
/**
* Creates a new [ConfigurableFileTree] using the given base directory.
*
* @param baseDir The base directory of the file tree. Evaluated as per [KotlinInitScript.file].
* @param configuration The block to use to configure the file tree.
* @return The file tree.
* @see [KotlinInitScript.fileTree]
*/
@Suppress("unused")
fun fileTree(baseDir: Any, configuration: ConfigurableFileTree.() -> Unit): ConfigurableFileTree =
fileOperations.fileTree(baseDir).also(configuration)
/**
* Creates a new [FileTree] which contains the contents of the given ZIP file.
*
* The given `zipPath` path is evaluated as per [KotlinInitScript.file]
*
* The returned file tree is lazy, so that it scans for files only when the contents of the file tree are
* queried. The file tree is also live, so that it scans for files each time the contents of the file tree are
* queried.
*
* You can combine this method with the [KotlinInitScript.copy] method to unzip a ZIP file.
*
* @param zipPath The ZIP file. Evaluated as per [KotlinInitScript.file].
* @return The file tree.
*/
@Suppress("unused")
fun zipTree(zipPath: Any): FileTree =
fileOperations.zipTree(zipPath)
/**
* Creates a new [FileTree] which contains the contents of the given TAR file.
*
* The given tarPath path can be:
* - an instance of [org.gradle.api.resources.Resource],
* - any other object is evaluated as per [KotlinInitScript.file].
*
* The returned file tree is lazy, so that it scans for files only when the contents of the file tree are
* queried. The file tree is also live, so that it scans for files each time the contents of the file tree are
* queried.
*
* Unless custom implementation of resources is passed,
* the tar tree attempts to guess the compression based on the file extension.
*
* You can combine this method with the [KotlinInitScript.copy] method to unzip a ZIP file.
*
* @param tarPath The TAR file or an instance of [org.gradle.api.resources.Resource].
* @return The file tree.
*/
@Suppress("unused")
fun tarTree(tarPath: Any): FileTree =
fileOperations.tarTree(tarPath)
/**
* Copies the specified files.
*
* @param configuration The block to use to configure the [CopySpec].
* @return `WorkResult` that can be used to check if the copy did any work.
*/
@Suppress("unused")
fun copy(configuration: CopySpec.() -> Unit): WorkResult =
fileOperations.copy(configuration)
/**
* Creates a {@link CopySpec} which can later be used to copy files or create an archive.
*
* @return The created [CopySpec]
*/
@Suppress("unused")
fun copySpec(): CopySpec =
fileOperations.copySpec()
/**
* Creates a {@link CopySpec} which can later be used to copy files or create an archive.
*
* @param configuration The block to use to configure the [CopySpec].
* @return The configured [CopySpec]
*/
@Suppress("unused")
fun copySpec(configuration: CopySpec.() -> Unit): CopySpec =
fileOperations.copySpec().also(configuration)
/**
* Creates a directory and returns a file pointing to it.
*
* @param path The path for the directory to be created. Evaluated as per [KotlinInitScript.file].
* @return The created directory.
* @throws org.gradle.api.InvalidUserDataException If the path points to an existing file.
*/
@Suppress("unused")
fun mkdir(path: Any): File =
fileOperations.mkdir(path)
/**
* Deletes files and directories.
*
* This will not follow symlinks. If you need to follow symlinks too use [KotlinInitScript.delete].
*
* @param paths Any type of object accepted by [KotlinInitScript.file]
* @return true if anything got deleted, false otherwise
*/
@Suppress("unused")
fun delete(vararg paths: Any): Boolean =
fileOperations.delete(*paths)
/**
* Deletes the specified files.
*
* @param configuration The block to use to configure the [DeleteSpec].
* @return `WorkResult` that can be used to check if delete did any work.
*/
@Suppress("unused")
fun delete(configuration: DeleteSpec.() -> Unit): WorkResult =
fileOperations.delete(configuration)
/**
* Executes an external command.
*
* This method blocks until the process terminates, with its result being returned.
*
* @param configuration The block to use to configure the [ExecSpec].
* @return The result of the execution.
*/
@Suppress("unused")
fun exec(configuration: ExecSpec.() -> Unit): ExecResult =
processOperations.exec(configuration)
/**
* Executes an external Java process.
*
* This method blocks until the process terminates, with its result being returned.
*
* @param configuration The block to use to configure the [JavaExecSpec].
* @return The result of the execution.
*/
@Suppress("unused")
fun javaexec(configuration: JavaExecSpec.() -> Unit): ExecResult =
processOperations.javaexec(configuration)
}