blob: 2174b8b38fd3ddf30af3254e55e1cf69f72d73b8 [file] [log] [blame]
ext.configureJvmProject = { Project project ->
project.configure(project) {
task sourcesJar(type: Jar, dependsOn: classes) {
classifier = 'sources'
from sourceSets.main.kotlin
}
tasks.withType(JavaCompile) {
options.fork = true
options.forkOptions.javaHome = file(JDK_18)
}
tasks.withType(project.compileKotlin.class) {
kotlinOptions.jdkHome = JDK_18
}
test {
executable = "$JDK_16/bin/java"
}
}
}
ext.configureJavaOnlyJvm6Project = { Project project ->
project.tasks.withType(JavaCompile) {
sourceCompatibility = 1.6
targetCompatibility = 1.6
options.fork = true
options.forkOptions.javaHome = file(JDK_16)
}
}
ext.configureJvm6Project = { Project project ->
project.configure(project) {
project.ext.jvmTarget = "1.6"
project.ext.javaHome = JDK_16
task sourcesJar(type: Jar, dependsOn: classes) {
classifier = 'sources'
from sourceSets.main.kotlin
}
configureJavaOnlyJvm6Project(project)
tasks.withType(project.compileKotlin.class) {
kotlinOptions.jdkHome = JDK_16
kotlinOptions.jvmTarget = "1.6"
}
test {
executable = "$JDK_16/bin/java"
}
}
}
ext.compileJava9Sources = { Project project, String moduleName, Collection<FileCollection> moduleOutputs = [project.sourceSets.main.output] ->
// module-info.java should be in java9 source set by convention
SourceDirectorySet java9SourceSet = project.sourceSets.java9.java
project.tasks.getByName("compileJava9Java").configure { JavaCompile it ->
dependsOn(moduleOutputs)
it.sourceCompatibility = 1.9
it.targetCompatibility = 1.9
it.destinationDir = file("${java9SourceSet.outputDir}/META-INF/versions/9")
it.options.fork = true
it.options.forkOptions.javaHome = file(JDK_9)
it.options.sourcepath = files(java9SourceSet.srcDirs)
doFirst {
def moduleFiles = moduleOutputs.collect { it.files }.flatten().join(File.pathSeparator)
options.compilerArgs = [
'--module-path', project.configurations.compileClasspath.asPath,
'--patch-module', "$moduleName=$moduleFiles"
]
classpath = files()
}
}
}
ext.manifestAttributes = { Manifest manifest, Project project, String component = null, boolean multiRelease = false ->
project.configure(manifest) {
attributes \
'Implementation-Vendor': 'JetBrains',
'Implementation-Title': project.archivesBaseName,
'Implementation-Version': project.buildNumber,
'Build-Jdk': System.getProperty('java.version')
if (component != null) {
attributes \
'Kotlin-Runtime-Component': component,
'Kotlin-Version': project.kotlinLanguageVersion
}
// TODO: enable as soon as this doesn't cause D8/DX to crash
/*
if (multiRelease) {
attributes \
'Multi-Release': 'true'
}
*/
}
}
task preparePublication {
def properties = project.properties
assert project.version != 'unspecified'
Map<String, String> repositoryProviders = ['sonatype-nexus-staging' : 'sonatype', 'sonatype-nexus-snapshots' : 'sonatype']
project.ext.isRelease = !project.version.toString().contains('-SNAPSHOT')
String repo = properties["deployRepo"] ?: properties['deploy-repo']
String repoProvider = repositoryProviders.get(repo, repo)
project.ext.isSonatypePublish = repoProvider == 'sonatype'
project.ext.isSonatypeRelease = isSonatypePublish && isRelease
project.ext['signing.keyId'] = project.properties['kotlin.key.name']
project.ext['signing.password'] = project.properties['kotlin.key.passphrase']
String sonatypeSnapshotsUrl = (isSonatypePublish && !isRelease) ? "https://oss.sonatype.org/content/repositories/snapshots/" : null
ext.repoUrl = properties["deployRepoUrl"] ?: sonatypeSnapshotsUrl ?: properties["deploy-url"] ?: "file://${rootProject.buildDir}/repo".toString()
ext.username = properties["deployRepoUsername"] ?: properties["kotlin.${repoProvider}.user"]
ext.password = properties["deployRepoPassword"] ?: properties["kotlin.${repoProvider}.password"]
logger.info("Deployment repository preliminary url: $repoUrl ($repoProvider)")
doLast {
println("Deployment repository url: $repoUrl")
}
}
ext.signPom = { Project project, MavenDeployer deployer ->
deployer.beforeDeployment { MavenDeployment deployment ->
if (project.signing.required)
project.signing.signPom(deployment)
}
}
ext.configureDist = { Project project ->
project.configure(project) {
configurations {
distJar
}
task dist(type: Copy, dependsOn: assemble) {
rename "-${java.util.regex.Pattern.quote(version)}", ''
into distLibDir
afterEvaluate {
project.artifacts {
distJar file: file("$distLibDir${File.separator}${archivesBaseName}.jar"), builtBy: "dist"
}
}
}
}
}
ext.configurePublishing = { Project project ->
project.configure(project) {
apply plugin: 'maven'
if (!project.hasProperty('prebuiltJar')) {
apply plugin: 'signing'
signing {
required { (project.properties["signingRequired"] ?: project.isSonatypeRelease) }
sign configurations.archives
}
signArchives {
enabled signing.required
}
}
uploadArchives {
def prepareTask = rootProject.preparePublication
dependsOn prepareTask
doFirst {
repositories.mavenDeployer.repository.url = prepareTask.repoUrl
}
repositories {
mavenDeployer {
signPom(project, it)
repository(url: prepareTask.repoUrl) {
authentication(userName: prepareTask.username, password: prepareTask.password)
}
pom.project {
name "${project.group}:${project.name}"
packaging 'jar'
// optionally artifactId can be defined here
description project.description
url 'https://kotlinlang.org/'
licenses {
license {
name 'The Apache License, Version 2.0'
url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
}
}
scm {
url 'https://github.com/JetBrains/kotlin'
connection 'scm:git:https://github.com/JetBrains/kotlin.git'
developerConnection 'scm:git:https://github.com/JetBrains/kotlin.git'
}
developers {
developer {
name 'Kotlin Team'
organization = 'JetBrains'
organizationUrl 'https://www.jetbrains.com'
}
}
}
}
}
}
task publish(dependsOn: uploadArchives)
}
}
ext.createPreprocessorTask = { Project project, def name, def sourceDir, def targetDir, def profile = "JS" ->
return project.tasks.create("preprocessSources$name", JavaExec) {
// dependsOn(rootProject.prepareBootstrap)
inputs.dir(sourceDir)
outputs.dir(targetDir)
classpath = rootProject.configurations.bootstrapCompile
// classpath = project.files(bootstrapCompilerFile)
main = "org.jetbrains.kotlin.preprocessor.PreprocessorCLI"
args = [sourceDir, targetDir, profile]
}
}