| /* |
| * Copyright (C) 2016 The Android Open Source Project |
| * |
| * 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. |
| */ |
| |
| /** |
| * This file was created using the `create_project.py` script located in the |
| * `<AndroidX root>/development/project-creator` directory. |
| * |
| * Please use that script when creating a new project, rather than copying an existing project and |
| * modifying its settings. |
| */ |
| |
| import androidx.build.BuildOnServerKt |
| import androidx.build.KotlinTarget |
| import androidx.build.LibraryType |
| import androidx.build.SdkHelperKt |
| import org.jetbrains.kotlin.gradle.tasks.KotlinCompile |
| |
| import java.util.regex.Matcher |
| import java.util.regex.Pattern |
| |
| plugins { |
| id("AndroidXPlugin") |
| id("AndroidXRepackagePlugin") |
| id("kotlin") |
| } |
| |
| repackage { |
| // Must match what is in room/room-external-antlr/build.gradle |
| addRelocation { |
| sourcePackage = "org.antlr" |
| targetPackage = "androidx.room.jarjarred.org.antlr" |
| } |
| // Must match what is in room/room-external-antlr/build.gradle |
| addRelocation { |
| sourcePackage = "org.stringtemplate" |
| targetPackage = "androidx.room.jarjarred.org.stringtemplate" |
| } |
| } |
| |
| androidx.configureAarAsJarForConfiguration("testImplementation") |
| |
| dependencies { |
| implementation(project(":room:room-common")) |
| implementation(project(":room:room-external-antlr")) |
| implementation(project(":room:room-migration")) |
| implementation(project(":room:room-compiler-processing")) |
| implementation(libs.kotlinStdlib) |
| implementation(libs.autoCommon) |
| implementation(libs.autoValueAnnotations) |
| implementation(libs.javapoet) |
| implementation(libs.kotlinPoet) |
| implementation(libs.kotlinPoetJavaPoet) |
| implementation(libs.kspApi) |
| // Must be compileOnly to not bring in antlr4 in runtime |
| // Repackaged antlr4 brought in by |
| // project(":room:room-external-antlr") and used at runtime |
| compileOnly(libs.antlr4) { |
| // antlr has dependencies on unrelated projects for its gui stuff, do not include them |
| exclude group: "org.abego.treelayout" |
| exclude group: "com.ibm.icu" |
| exclude group: "org.glassfish" |
| } |
| implementation(libs.sqliteJdbc) |
| implementation(libs.apacheCommonsCodec) |
| implementation(libs.intellijAnnotations) |
| testImplementation(libs.truth) |
| testImplementation(project(":kruth:kruth")) |
| testImplementation(libs.testParameterInjector) |
| testImplementation(libs.autoValue) // to access the processor in tests |
| testImplementation(libs.autoServiceAnnotations) |
| testImplementation(libs.autoService) // to access the processor in tests |
| testImplementation(project(":paging:paging-common")) |
| testImplementation(project(":room:room-compiler-processing-testing")) |
| testImplementation(libs.junit) |
| testImplementation(libs.jsr250) |
| testImplementation(libs.mockitoCore4) |
| testImplementation(libs.antlr4) |
| testImplementation(SdkHelperKt.getSdkDependency(project)) |
| testImplementationAarAsJar(project(":room:room-runtime")) |
| testImplementationAarAsJar(project(":sqlite:sqlite")) |
| testImplementation(project(":internal-testutils-common")) |
| } |
| |
| def generateAntlrTask = tasks.register("generateAntlrGrammar", GenerateAntlrGrammar) { task -> |
| def sourceFiles = [ |
| "SQLiteLexer.g4", |
| "SQLiteParser.g4" |
| ] |
| task.getSourceFiles().set(sourceFiles.collect { layout.projectDirectory.file(it) }) |
| task.getAntlrClasspath().from(configurations.compileClasspath) |
| task.getOutputDirectory().set(layout.buildDirectory.dir("generated/antlr/grammar-gen/")) |
| } |
| |
| sourceSets { |
| main.java.srcDirs += generateAntlrTask.map { it.outputDirectory } |
| } |
| |
| @CacheableTask |
| abstract class GenerateAntlrGrammar extends DefaultTask { |
| @PathSensitive(PathSensitivity.NONE) |
| @InputFiles |
| abstract ListProperty<RegularFile> getSourceFiles() |
| |
| @Classpath |
| abstract ConfigurableFileCollection getAntlrClasspath() |
| |
| @OutputDirectory |
| abstract DirectoryProperty getOutputDirectory() |
| |
| @Inject |
| abstract ExecOperations getExecOperations() |
| |
| @Inject |
| public GenerateAntlrGrammar() { |
| description = "Generates ANTLR Grammar used by Room" |
| group = "build" |
| } |
| |
| @TaskAction |
| void generateAntlrGrammar() { |
| File outputDirectoryFile = getOutputDirectory().asFile.get() |
| outputDirectoryFile.deleteDir() |
| execOperations.javaexec { |
| mainClass.set("org.antlr.v4.Tool") |
| classpath = getAntlrClasspath() |
| args( |
| *getSourceFiles().get().collect { it.getAsFile().absolutePath }, |
| "-visitor", |
| "-o", new File(outputDirectoryFile, "androidx/room/parser").path, |
| "-package", "androidx.room.parser" |
| ) |
| } |
| } |
| } |
| |
| /** |
| * This task validates the published artifacts of room compiler to ensure dependencies are properly |
| * specified. |
| */ |
| abstract class CheckArtifactTask extends DefaultTask { |
| @InputFiles |
| abstract ConfigurableFileCollection getArtifactInputs() |
| @InputFile |
| abstract RegularFileProperty getPomFile() |
| @OutputFile |
| abstract RegularFileProperty getResult() |
| |
| /** |
| * Checks the generated pom file to ensure it does not depend on any jarjarred dependencies |
| * but still depends on others. |
| */ |
| void validatePomTaskOutputs() { |
| File pom = getPomFile().asFile.get() |
| if (!pom.canRead()) { |
| throw new GradleException("Cannot find the pom file for room-compiler") |
| } |
| def pomContents = pom.newReader().text |
| Pattern antlrDep = Pattern.compile("<dependency>\\s.*antlr(.*\\s)*</dependency>") |
| Matcher matcher = antlrDep.matcher(pomContents) |
| if (matcher.find()) { |
| throw new GradleException("Room-compiler pom file should not depend on antlr.\n" + |
| "Pom Contents:\n $pomContents") |
| } |
| if(!pomContents.contains("<artifactId>kotlin-stdlib</artifactId>")) { |
| throw new GradleException("room-compiler should depend on kotlin stdlib.\n" + |
| "Pom Contents:\n $pomContents") |
| } |
| } |
| |
| @TaskAction |
| void validate() { |
| getResult().asFile.get().write("fail\n") |
| validatePomTaskOutputs() |
| // have a no-op output to make gradle happy w/ input/output checking. |
| getResult().asFile.get().write("ok\n") |
| } |
| } |
| |
| def checkArtifactContentsTask = tasks.register("checkArtifact", CheckArtifactTask) { task -> |
| task.getResult().set(layout.buildDirectory.file("checkArtifactOutput.txt")) |
| def pomTask = (TaskProvider<GenerateMavenPom>) project.tasks.named("generatePomFileForMavenPublication") |
| task.getPomFile().set( |
| project.objects.fileProperty().fileProvider( |
| pomTask.map { it.destination } |
| ) |
| ) |
| } |
| |
| afterEvaluate { |
| def publishTaskProvider = project.tasks.named("publishMavenPublicationToMavenRepository") |
| checkArtifactContentsTask.configure { checkArtifactTask -> |
| checkArtifactTask.getArtifactInputs().from { |
| publishTaskProvider.map { |
| ((PublishToMavenRepository) it).getPublication().artifacts.matching { |
| it.classifier == null |
| }.collect { |
| it.file |
| } |
| } |
| } |
| } |
| } |
| |
| // make sure we validate published artifacts on the build server. |
| BuildOnServerKt.addToBuildOnServer(project, checkArtifactContentsTask) |
| |
| tasks.withType(KotlinCompile).configureEach { |
| kotlinOptions { |
| freeCompilerArgs += [ |
| "-opt-in=kotlin.contracts.ExperimentalContracts", |
| "-opt-in=androidx.room.compiler.processing.ExperimentalProcessingApi", |
| "-opt-in=com.squareup.kotlinpoet.javapoet.KotlinPoetJavaPoetPreview" |
| ] |
| } |
| } |
| |
| tasks.withType(Test).configureEach { |
| it.systemProperty("androidx.room.compiler.processing.strict", "true") |
| it.maxParallelForks = 8 |
| if (project.providers.environmentVariable("GITHUB_ACTIONS").present) { |
| // limit memory usage to avoid running out of memory in the docker container. |
| it.maxHeapSize = "512m" |
| } |
| } |
| |
| androidx { |
| name = "Room Compiler" |
| type = LibraryType.ANNOTATION_PROCESSOR |
| inceptionYear = "2017" |
| description = "Android Room annotation processor" |
| kotlinTarget = KotlinTarget.KOTLIN_2_0 |
| } |
