From cbda9281417aa7e57d366b278f7e96b8c41ac084 Mon Sep 17 00:00:00 2001 From: Adam <897017+asemy@users.noreply.github.com> Date: Sat, 30 Oct 2021 07:26:12 +0200 Subject: [PATCH] protoc download - working! --- .../build.gradle.kts | 187 ++++++++++-------- 1 file changed, 105 insertions(+), 82 deletions(-) diff --git a/modules/factorio-events-data-model/build.gradle.kts b/modules/factorio-events-data-model/build.gradle.kts index 6acd8ce..fcd58ea 100644 --- a/modules/factorio-events-data-model/build.gradle.kts +++ b/modules/factorio-events-data-model/build.gradle.kts @@ -1,15 +1,14 @@ +import java.util.function.Supplier import org.gradle.api.DefaultTask import org.gradle.api.Plugin import org.gradle.api.Project -import org.gradle.api.artifacts.ExternalDependency -import org.gradle.api.plugins.ExtensionAware import org.gradle.api.provider.Property import org.gradle.api.tasks.TaskAction -import org.gradle.kotlin.dsl.domainObjectContainer import org.gradle.kotlin.dsl.create -import org.gradle.kotlin.dsl.withType import org.gradle.kotlin.dsl.property import org.gradle.nativeplatform.platform.internal.DefaultNativePlatform +import org.gradle.nativeplatform.platform.internal.DefaultOperatingSystem +import org.jetbrains.kotlin.util.parseSpaceSeparatedArgs plugins { id("dev.adamko.factoriowebmap.archetype.base") @@ -19,6 +18,7 @@ plugins { val projectId: String by project.extra val buildDir: Directory = layout.buildDirectory.dir(projectId).get() + dependencies { } @@ -41,65 +41,59 @@ class ProtocPlugin : Plugin { // } // } - project.tasks.register("protocPrepare") { +// project.dependencies.createArtifactResolutionQuery().forComponents() - } + val protocPrepare = project.tasks.register("protocPrepare") +// project.tasks.register("protobufCompile") { // -// val prepareTask = project.tasks.register("protocPrepare") { // group = "protoc" +// dependsOn(protocPrepare) // -// val outputDir = project.rootProject.layout.projectDirectory.dir(".gradle/protoc") +// workingDir(temporaryDir) // -// outputs.dir(outputDir) // -//// doLast { -// val protoc: File = protocDep.resolve().single() -// logger.lifecycle("protoc file $protoc") -// -// from(protoc) -// into(outputDir) -//// } -// } -// -// project.tasks.build { dependsOn(prepareTask) } -// -// val generateTask = project.tasks.create("protocGenerate") { -// dependsOn(prepareTask) -// } - -// val protocDeps = project.configurations.create("pbAndG") { -// this.let { config -> -// -// config.isVisible = false -// config.isCanBeConsumed = false -// config.isCanBeResolved = true -// config.description = "protoc dependencies" -// -// config.defaultDependencies { -// add(protocConfig.dependencyProvider()) -// } +// if (protocConfig.operatingSystemProvider.get().get().isWindows) { +// args("cmd", "/c") // } // -// val generatorsContainer = -// project.objects.domainObjectContainer(ProtocGenerationTask::class) -// protocConfig.extensions.add("protocGenerate", generatorsContainer) +// val srcDir = project.layout.projectDirectory.dir("src") +// val javaOut = project.layout.buildDirectory.dir("proto/java") +// val kotlinOut = project.layout.buildDirectory.dir("proto/kotlin") +// val protoFile = +// project.layout.projectDirectory.file("src/main/proto/FactorioServerLogRecord.proto") // +// args( +// parseSpaceSeparatedArgs( +// """ +// -I=${srcDir.asFile.canonicalPath} +// --java_out=${javaOut.get().asFile.canonicalPath} +// --kotlin_out=${kotlinOut.get().asFile.canonicalPath} +// ${protoFile.asFile.canonicalPath} // -// project.extensions.add("testingExtensionThingy", project.provider { -// DefaultNativePlatform.getCurrentOperatingSystem().toFamilyName() -// }) -// -// project.tasks.withType { +// """.trimIndent() +//// """ +//// -I=$SRC_DIR +//// --java_out=$DST_DIR +//// --kotlin_out=$DST_DIR +//// $SRC_DIR/addressbook.proto" +//// +//// """.trimIndent() +// ) +// ) +// doLast { +// executable = protocPrepare.flatMap { it.protocOutput }.get().asFile.canonicalPath // } -// // } -// } } abstract class ProtocPluginConfig(private val project: Project) : java.io.Serializable { + val protocWorkingDir: DirectoryProperty = + project.objects.directoryProperty() + .convention(project.rootProject.layout.projectDirectory.dir(".gradle/protoc")) + val protocVersion: Property = project.objects.property(String::class).convention("3.9.2") @@ -112,6 +106,10 @@ abstract class ProtocPluginConfig(private val project: Project) : java.io.Serial val protocArtifactExtension: Property = project.objects.property(String::class).convention("exe") + val operatingSystemProvider: Property> = + project.objects.property>() + .convention { DefaultNativePlatform.getCurrentOperatingSystem() } + /** * Should return one of * @@ -119,9 +117,13 @@ abstract class ProtocPluginConfig(private val project: Project) : java.io.Serial * * `osx` * * `windows` */ - var osFamilyNameProvider: () -> String = { - DefaultNativePlatform.getCurrentOperatingSystem().toFamilyName() - } + val operatingSystemName: Property = + project.objects + .property() + .convention(operatingSystemProvider.map { it.get().toFamilyName() }) + + private val architectureProvider: Provider = + project.provider { DefaultNativePlatform.getCurrentArchitecture() } /** * Should return one of @@ -131,11 +133,13 @@ abstract class ProtocPluginConfig(private val project: Project) : java.io.Serial * * `x86_32` * * `x86_64` */ - var architectureProvider: () -> String = { - DefaultNativePlatform.getCurrentArchitecture() - .name - .replace("-", "_") - } + val architectureName: Property = + project.objects + .property() + .convention(architectureProvider.map { it.name.replace("-", "_") }) + + private val classifierProvider: Provider = + project.provider { "${operatingSystemName.get()}-${architectureName.get()}" } /** * Default: concatenate [osFamilyNameProvider] and [architectureProvider] @@ -149,49 +153,63 @@ abstract class ProtocPluginConfig(private val project: Project) : java.io.Serial * * `osx-x86_64` * * `windows-x86_32` */ - var classifierProvider: () -> String = { - "${osFamilyNameProvider()}-${architectureProvider()}" - } + val classifier: Property = + project.objects + .property() + .convention(classifierProvider) - var dependencyProvider: () -> ExternalModuleDependency = { - project.dependencies.create( - group = protocGroup.get(), - name = protocArtifactName.get(), - version = protocVersion.get(), - classifier = classifierProvider(), - ext = protocArtifactExtension.get(), - ) - } -// val generators = project.objects.domainObjectContainer(ProtocGenerationConfig::class) + private val dependencyProvider: Provider = + project.provider { + project.dependencies.create( + group = protocGroup.get(), + name = protocArtifactName.get(), + version = protocVersion.get(), + classifier = classifierProvider.get(), + ext = protocArtifactExtension.get(), + ) + } + + val dependency: Property = + project.objects + .property() + .convention(dependencyProvider) + } abstract class ProtocGenerationConfig abstract class ProtocPrepareTask : DefaultTask() { - @get:OutputDirectory - val outputDirectory: DirectoryProperty = project.objects.directoryProperty() - .convention(project.rootProject.layout.projectDirectory.dir(".gradle/protoc")) - - @get:OutputFile - val protocOutput: RegularFileProperty = project.objects.fileProperty() - .convention { outputDirectory.asFileTree.singleFile } - @Internal val protocPluginConfig: Provider = project.provider { project.extensions.getByType() } + @get:OutputDirectory + val outputDirectory: DirectoryProperty = project.objects.directoryProperty() + .convention(protocPluginConfig.flatMap { it.protocWorkingDir }) + @Internal - val protocDependency: Provider = protocPluginConfig.map { - it.dependencyProvider() - } + val protocOutput: RegularFileProperty = project.objects.fileProperty() +// @get:OutputFile +// val protocOutput: RegularFileProperty = project.objects.fileProperty() +// .convention { outputDirectory.asFileTree.singleFile } +// .convention(outputDirectory.map { project it.asFileTree.singleFile }) + + @Internal + val protocDependency: Provider = + protocPluginConfig.flatMap { it.dependency } init { super.setGroup("protoc") - } +// project.dependencies { +// protocDep(protocDependency.get()) +// } +// +// super.dependsOn(protocDep) + } @TaskAction fun prepare() { @@ -207,15 +225,20 @@ abstract class ProtocPrepareTask : DefaultTask() { } } - val resolvedProtocDep = protocDep.resolve() + logger.lifecycle("Downloading protoc") + val resolvedProtocDep = protocDep.singleFile + logger.lifecycle("Downloaded $resolvedProtocDep") - require(resolvedProtocDep.singleOrNull() != null) { - "Expected to download a single protoc.exe, but got ${resolvedProtocDep.size}: ${resolvedProtocDep.joinToString()}" - } +// require(resolvedProtocDep.singleOrNull() != null) { +// "Expected to download a single protoc.exe, but got ${resolvedProtocDep.size}: ${resolvedProtocDep.joinToString()}" +// } project.sync { from(resolvedProtocDep) into(outputDirectory) +// doLast { +// logger.lifecycle("Syncing from $resolvedProtocDep to $outputDirectory") +// } } } }