Apply Spotless formatting to Gradle script plugins

junit-team · Aug 11, 2024 · d8ec757 · d8ec757
1 parent dae525d
commit d8ec757
Show file tree

Hide file tree

Showing 8 changed files with 64 additions and 65 deletions.
diff --git a/gradle/plugins/code-generator/build.gradle.kts b/gradle/plugins/code-generator/build.gradle.kts
@@ -1,15 +1,15 @@
 plugins {
-    `kotlin-dsl`
+	`kotlin-dsl`
 }
 
 repositories {
-    gradlePluginPortal()
+	gradlePluginPortal()
 }
 
 dependencies {
-    implementation("junitbuild.base:code-generator-model")
-    implementation(projects.common)
-    implementation(libs.jackson.dataformat.yaml)
-    implementation(libs.jackson.module.kotlin)
-    implementation(libs.jte)
+	implementation("junitbuild.base:code-generator-model")
+	implementation(projects.common)
+	implementation(libs.jackson.dataformat.yaml)
+	implementation(libs.jackson.module.kotlin)
+	implementation(libs.jte)
 }
diff --git a/gradle/plugins/code-generator/src/main/kotlin/junitbuild.code-generator.gradle.kts b/gradle/plugins/code-generator/src/main/kotlin/junitbuild.code-generator.gradle.kts
@@ -1,13 +1,13 @@
 import junitbuild.generator.GenerateJreRelatedSourceCode
 
 plugins {
-    java
+	java
 }
 
 val templates by sourceSets.registering
 dependencies {
-    add(templates.get().compileOnlyConfigurationName, dependencyFromLibs("jte"))
-    add(templates.get().compileOnlyConfigurationName, "junitbuild.base:code-generator-model")
+	add(templates.get().compileOnlyConfigurationName, dependencyFromLibs("jte"))
+	add(templates.get().compileOnlyConfigurationName, "junitbuild.base:code-generator-model")
 }
 
 val license: License by rootProject.extra
@@ -16,20 +16,20 @@ val generateCode by tasks.registering
 
 sourceSets.named { it != templates.name }.configureEach {
 
-    val sourceSetName = name
-    val sourceSetTargetDir = rootTargetDir.map { it.dir(sourceSetName) }
+	val sourceSetName = name
+	val sourceSetTargetDir = rootTargetDir.map { it.dir(sourceSetName) }
 
-    val task = tasks.register(getTaskName("generateJreRelated", "SourceCode"), GenerateJreRelatedSourceCode::class) {
-        templateDir.convention(layout.dir(templates.map {
-            it.resources.srcDirs.single().resolve(sourceSetName)
-        }))
-        targetDir.convention(sourceSetTargetDir)
-        licenseHeaderFile.convention(license.headerFile)
-    }
+	val task = tasks.register(getTaskName("generateJreRelated", "SourceCode"), GenerateJreRelatedSourceCode::class) {
+		templateDir.convention(layout.dir(templates.map {
+			it.resources.srcDirs.single().resolve(sourceSetName)
+		}))
+		targetDir.convention(sourceSetTargetDir)
+		licenseHeaderFile.convention(license.headerFile)
+	}
 
-    java.srcDir(files(sourceSetTargetDir).builtBy(task))
+	java.srcDir(files(sourceSetTargetDir).builtBy(task))
 
-    generateCode {
-        dependsOn(task)
-    }
+	generateCode {
+		dependsOn(task)
+	}
 }
diff --git a/gradle/plugins/common/src/main/kotlin/junitbuild.java-library-conventions.gradle.kts b/gradle/plugins/common/src/main/kotlin/junitbuild.java-library-conventions.gradle.kts
@@ -162,15 +162,15 @@ val allMainClasses by tasks.registering {
 }
 
 val prepareModuleSourceDir by tasks.registering(Sync::class) {
-    from(moduleSourceDir)
-    from(sourceSets.named { it.startsWith("main") }.map { it.allJava })
-    into(combinedModuleSourceDir.map { it.dir(javaModuleName) })
-    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+	from(moduleSourceDir)
+	from(sourceSets.named { it.startsWith("main") }.map { it.allJava })
+	into(combinedModuleSourceDir.map { it.dir(javaModuleName) })
+	duplicatesStrategy = DuplicatesStrategy.EXCLUDE
 }
 
 val compileModule by tasks.registering(JavaCompile::class) {
 	dependsOn(allMainClasses)
-    enabled = project in modularProjects
+	enabled = project in modularProjects
 	source = fileTree(combinedModuleSourceDir).builtBy(prepareModuleSourceDir)
 	destinationDirectory = moduleOutputDir
 	sourceCompatibility = "9"
@@ -184,22 +184,22 @@ val compileModule by tasks.registering(JavaCompile::class) {
 			"--module-version", "${project.version}",
 	))
 
-    val moduleOptions = objects.newInstance(ModuleCompileOptions::class)
-    extensions.add("moduleOptions", moduleOptions)
-    moduleOptions.modulePath.from(configurations.compileClasspath)
+	val moduleOptions = objects.newInstance(ModuleCompileOptions::class)
+	extensions.add("moduleOptions", moduleOptions)
+	moduleOptions.modulePath.from(configurations.compileClasspath)
 
 	options.compilerArgumentProviders.add(objects.newInstance(ModulePathArgumentProvider::class, project, combinedModuleSourceDir, modularProjects).apply {
-        modulePath.from(moduleOptions.modulePath)
-    })
+		modulePath.from(moduleOptions.modulePath)
+	})
 	options.compilerArgumentProviders.addAll(modularProjects.map { objects.newInstance(PatchModuleArgumentProvider::class, project, it) })
 
 	modularity.inferModulePath = false
 
-    doFirst {
-        options.allCompilerArgs.forEach {
-            logger.info(it)
-        }
-    }
+	doFirst {
+		options.allCompilerArgs.forEach {
+			logger.info(it)
+		}
+	}
 }
 
 tasks.withType<Jar>().configureEach {
@@ -315,16 +315,16 @@ checkstyle {
 
 tasks {
 	checkstyleMain {
-        config = resources.text.fromFile(checkstyle.configDirectory.file("checkstyleMain.xml"))
+		config = resources.text.fromFile(checkstyle.configDirectory.file("checkstyleMain.xml"))
 	}
 	checkstyleTest {
-        config = resources.text.fromFile(checkstyle.configDirectory.file("checkstyleTest.xml"))
+		config = resources.text.fromFile(checkstyle.configDirectory.file("checkstyleTest.xml"))
 	}
 }
 
 pluginManager.withPlugin("java-test-fixtures") {
 	tasks.named<Checkstyle>("checkstyleTestFixtures") {
-        config = resources.text.fromFile(checkstyle.configDirectory.file("checkstyleTest.xml"))
+		config = resources.text.fromFile(checkstyle.configDirectory.file("checkstyleTest.xml"))
 	}
 	tasks.named<JavaCompile>("compileTestFixturesJava") {
 		options.release = extension.testJavaVersion.majorVersion.toInt()

diff --git a/gradle/plugins/common/src/main/kotlin/junitbuild.java-multi-release-sources.gradle.kts b/gradle/plugins/common/src/main/kotlin/junitbuild.java-multi-release-sources.gradle.kts
@@ -30,7 +30,7 @@ listOf(9, 17).forEach { javaVersion ->
 		}
 
 		named<Checkstyle>("checkstyle${sourceSet.name.capitalized()}").configure {
-            config = resources.text.fromFile(checkstyle.configDirectory.file("checkstyleMain.xml"))
+			config = resources.text.fromFile(checkstyle.configDirectory.file("checkstyleMain.xml"))
 		}
 
 		if (project in mavenizedProjects) {

diff --git a/gradle/plugins/common/src/main/kotlin/junitbuild.java-toolchain-conventions.gradle.kts b/gradle/plugins/common/src/main/kotlin/junitbuild.java-toolchain-conventions.gradle.kts
@@ -9,18 +9,18 @@ project.pluginManager.withPlugin("java") {
 	val javaLanguageVersion = buildParameters.javaToolchain.version.map { JavaLanguageVersion.of(it) }.getOrElse(defaultLanguageVersion)
 	val jvmImplementation = buildParameters.javaToolchain.implementation.map {
 		when(it) {
-            "j9" -> JvmImplementation.J9
-            else -> throw InvalidUserDataException("Unsupported JDK implementation: $it")
-        }
+			"j9" -> JvmImplementation.J9
+			else -> throw InvalidUserDataException("Unsupported JDK implementation: $it")
+		}
 	}.getOrElse(JvmImplementation.VENDOR_SPECIFIC)
 
 	val extension = the<JavaPluginExtension>()
 	val javaToolchainService = the<JavaToolchainService>()
 
 	extension.toolchain {
-        languageVersion = javaLanguageVersion
-        implementation = jvmImplementation
-    }
+		languageVersion = javaLanguageVersion
+		implementation = jvmImplementation
+	}
 
 	pluginManager.withPlugin("org.jetbrains.kotlin.jvm") {
 		configure<KotlinJvmProjectExtension> {

diff --git a/gradle/plugins/common/src/main/kotlin/junitbuild.jmh-conventions.gradle.kts b/gradle/plugins/common/src/main/kotlin/junitbuild.jmh-conventions.gradle.kts
@@ -1,23 +1,23 @@
 plugins {
-    id("me.champeau.jmh")
+	id("me.champeau.jmh")
 }
 
 jmh {
-    jmhVersion = requiredVersionFromLibs("jmh")
+	jmhVersion = requiredVersionFromLibs("jmh")
 }
 
 dependencies {
-    jmh(dependencyFromLibs("jmh-core"))
-    jmhAnnotationProcessor(dependencyFromLibs("jmh-generator-annprocess"))
+	jmh(dependencyFromLibs("jmh-core"))
+	jmhAnnotationProcessor(dependencyFromLibs("jmh-generator-annprocess"))
 }
 
 tasks.jmhJar {
-    notCompatibleWithConfigurationCache("https://github.com/melix/jmh-gradle-plugin/issues/229")
+	notCompatibleWithConfigurationCache("https://github.com/melix/jmh-gradle-plugin/issues/229")
 }
 
 pluginManager.withPlugin("checkstyle") {
-    tasks.named<Checkstyle>("checkstyleJmh").configure {
-        // use same style rules as defined for tests
-        config = resources.text.fromFile(project.the<CheckstyleExtension>().configDirectory.file("checkstyleTest.xml"))
-    }
+	tasks.named<Checkstyle>("checkstyleJmh").configure {
+		// use same style rules as defined for tests
+		config = resources.text.fromFile(project.the<CheckstyleExtension>().configDirectory.file("checkstyleTest.xml"))
+	}
 }
diff --git a/gradle/plugins/common/src/main/kotlin/junitbuild.shadow-conventions.gradle.kts b/gradle/plugins/common/src/main/kotlin/junitbuild.shadow-conventions.gradle.kts
@@ -71,7 +71,7 @@ tasks {
 		classpath -= sourceSets.main.get().output
 		classpath += files(shadowJar.map { it.archiveFile })
 	}
-    named<JavaCompile>("compileModule") {
-        the<ModuleCompileOptions>().modulePath.from(shadowedClasspath.get())
-    }
+	named<JavaCompile>("compileModule") {
+		the<ModuleCompileOptions>().modulePath.from(shadowedClasspath.get())
+	}
 }
diff --git a/gradle/plugins/common/src/main/kotlin/junitbuild.spotless-conventions.gradle.kts b/gradle/plugins/common/src/main/kotlin/junitbuild.spotless-conventions.gradle.kts
@@ -7,24 +7,23 @@ val license: License by rootProject.extra
 spotless {
 
 	format("misc") {
-		target("*.gradle.kts", "buildSrc/**/*.gradle.kts", "*.gitignore")
-		targetExclude("buildSrc/build/**")
+		target("*.gradle.kts", "gradle/plugins/**/*.gradle.kts", "*.gitignore")
+		targetExclude("gradle/plugins/**/build/**")
 		indentWithTabs()
 		trimTrailingWhitespace()
 		endWithNewline()
 	}
 
 	format("documentation") {
 		target("*.adoc", "*.md", "src/**/*.adoc", "src/**/*.md")
-		targetExclude("**/build", "**/target")
 		trimTrailingWhitespace()
 		endWithNewline()
 	}
 
 	pluginManager.withPlugin("java") {
 
-        val configDir = rootProject.layout.projectDirectory.dir("gradle/config/eclipse")
-        val importOrderConfigFile = configDir.file("junit-eclipse.importorder")
+		val configDir = rootProject.layout.projectDirectory.dir("gradle/config/eclipse")
+		val importOrderConfigFile = configDir.file("junit-eclipse.importorder")
 		val javaFormatterConfigFile = configDir.file("junit-eclipse-formatter-settings.xml")
 
 		java {