Compare commits
No commits in common. "master" and "0.5.0" have entirely different histories.
21
.github/workflows/build.yml
vendored
21
.github/workflows/build.yml
vendored
@ -1,21 +0,0 @@
|
||||
name: Gradle build
|
||||
|
||||
on:
|
||||
push:
|
||||
branches: [ dev, master ]
|
||||
pull_request:
|
||||
|
||||
jobs:
|
||||
build:
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 40
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v2
|
||||
- uses: actions/setup-java@v2.5.0
|
||||
with:
|
||||
java-version: 11
|
||||
distribution: liberica
|
||||
- uses: gradle/gradle-build-action@v2
|
||||
with:
|
||||
arguments: build
|
||||
24
.github/workflows/publish.yml
vendored
24
.github/workflows/publish.yml
vendored
@ -1,24 +0,0 @@
|
||||
name: Gradle publish
|
||||
|
||||
on:
|
||||
workflow_dispatch:
|
||||
release:
|
||||
types: [ created ]
|
||||
|
||||
jobs:
|
||||
build:
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 40
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v2
|
||||
- uses: actions/setup-java@v2.5.0
|
||||
with:
|
||||
java-version: 11
|
||||
distribution: liberica
|
||||
- uses: gradle/gradle-build-action@v2
|
||||
with:
|
||||
arguments: |
|
||||
publishAllPublicationsToSpaceRepository
|
||||
-Ppublishing.space.user=${{ secrets.SPACE_APP_ID }}
|
||||
-Ppublishing.space.token=${{ secrets.SPACE_APP_SECRET }}
|
||||
43
.space.kts
43
.space.kts
@ -1,43 +0,0 @@
|
||||
import kotlin.io.path.readText
|
||||
|
||||
job("Build") {
|
||||
gradlew("openjdk:11", "build")
|
||||
}
|
||||
|
||||
job("Publish"){
|
||||
startOn {
|
||||
gitPush { enabled = false }
|
||||
}
|
||||
container("openjdk:11") {
|
||||
env["SPACE_USER"] = Secrets("space_user")
|
||||
env["SPACE_TOKEN"] = Secrets("space_token")
|
||||
kotlinScript { api ->
|
||||
|
||||
val spaceUser = System.getenv("SPACE_USER")
|
||||
val spaceToken = System.getenv("SPACE_TOKEN")
|
||||
|
||||
// write version to the build directory
|
||||
api.gradlew("version")
|
||||
|
||||
//read version from build file
|
||||
val version = java.nio.file.Path.of("build/project-version.txt").readText()
|
||||
|
||||
api.space().projects.automation.deployments.start(
|
||||
project = api.projectIdentifier(),
|
||||
targetIdentifier = TargetIdentifier.Key("gradle-tools"),
|
||||
version = version,
|
||||
// automatically update deployment status based on a status of a job
|
||||
syncWithAutomationJob = true
|
||||
)
|
||||
try {
|
||||
api.gradlew(
|
||||
"publishAllPublicationsToSpaceRepository",
|
||||
"-Ppublishing.space.user=\"$spaceUser\"",
|
||||
"-Ppublishing.space.token=\"$spaceToken\"",
|
||||
)
|
||||
} catch (ex: Exception) {
|
||||
println("Publish failed")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
332
CHANGELOG.md
332
CHANGELOG.md
@ -1,332 +0,0 @@
|
||||
# Changelog
|
||||
|
||||
All notable changes to this project will be documented in this file.
|
||||
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
|
||||
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
|
||||
|
||||
## Unreleased
|
||||
|
||||
### Added
|
||||
|
||||
### Changed
|
||||
|
||||
### Deprecated
|
||||
|
||||
### Removed
|
||||
|
||||
### Fixed
|
||||
|
||||
### Security
|
||||
|
||||
## 0.15.4-kotlin-2.0.0 - 2024-06-04
|
||||
|
||||
### Added
|
||||
|
||||
- Pass `compose` extension to the kscience extension so compose dependencies could be called directly from kscience block
|
||||
|
||||
### Changed
|
||||
|
||||
- Use ES6 modules by default in JS
|
||||
- Kotlin 2.0
|
||||
|
||||
## 0.15.2-kotlin-1.9.22 - 2024-02-09
|
||||
|
||||
### Added
|
||||
|
||||
- Add development mode for fullstack.
|
||||
|
||||
### Changed
|
||||
|
||||
- Kotlin 1.9.20
|
||||
- Remove publishing defaults for Space and GitHub. Now publishing repositories is configured quasi-manually. Property keys for username and tokens are generated automatically.
|
||||
- All publishing targets are enabled by default. Introduce `publishing.targets` variable to regulate what is added to the module.
|
||||
|
||||
### Deprecated
|
||||
|
||||
- JVM plugin in favor of Mpp.
|
||||
|
||||
### Removed
|
||||
|
||||
- JS plugin. It is deprecated in favor of MPP.
|
||||
- Unnecessary `dependsOn` for native dependencies.
|
||||
- Groovy gradle dependency notation.
|
||||
|
||||
## 0.14.4-kotlin-1.8.20-RC - 2023-03-12
|
||||
|
||||
### Added
|
||||
|
||||
- Easier dependency handling in `kscience` block
|
||||
- Customizable base jdk version
|
||||
|
||||
### Changed
|
||||
|
||||
- MPP does not use JVM and JS(IR) targets anymore. They could be turned manually via `js()`, `jvm()` or `fullStack()`
|
||||
- Signing is not applied if signingId is not provided
|
||||
|
||||
### Removed
|
||||
|
||||
- FX plugins
|
||||
- Unnecessary library shortcuts (html and datetime)
|
||||
- deploy/release tasks
|
||||
|
||||
### Fixed
|
||||
|
||||
- Gradle 8 compatibility
|
||||
- Dokka publication
|
||||
- issues with test sourcesets
|
||||
|
||||
## 0.13.4-kotlin-1.8.0 - 2022-12-31
|
||||
|
||||
### Added
|
||||
|
||||
- Public `isInDevelopment` project flag
|
||||
|
||||
### Changed
|
||||
|
||||
- Require manual pom config for publications
|
||||
- Kotlin 1.8.0
|
||||
- Versions update
|
||||
- Project group changed to `space.kscience`
|
||||
- Moved `yarn.lock` to `gradle` directory
|
||||
|
||||
### Deprecated
|
||||
|
||||
- FX configuration
|
||||
|
||||
### Removed
|
||||
|
||||
- Xjdk-release flag because it is broken until https://youtrack.jetbrains.com/issue/KT-52823
|
||||
- Use CSS loader in JS by default
|
||||
|
||||
## 0.11.6-kotlin-1.7.0
|
||||
|
||||
### Changed
|
||||
|
||||
- Coroutines tests are applied only when explicit `useCoroutines` is used.
|
||||
|
||||
### Removed
|
||||
|
||||
- Atomicfu support inside the plugin
|
||||
|
||||
### Fixed
|
||||
|
||||
- Rollback coroutines to 1.6.1
|
||||
|
||||
## 0.11.5-kotlin-1.7.0
|
||||
|
||||
### Added
|
||||
|
||||
- Coroutine tests as default dependency for tests
|
||||
- Context receiver flag
|
||||
|
||||
### Changed
|
||||
|
||||
- Separate release tasks for each target
|
||||
- Kotlin 1.7.0
|
||||
- Ktor 2.0.1
|
||||
- ExplicitAPI does not override existing value
|
||||
|
||||
### Removed
|
||||
|
||||
- Ktor specific artifacts from version catalog
|
||||
|
||||
### Fixed
|
||||
|
||||
- Moved signing out of sonatype block
|
||||
|
||||
## 0.11.1-kotlin-1.6.10
|
||||
|
||||
### Added
|
||||
|
||||
- Default templates for README and ARTIFACT
|
||||
|
||||
### Changed
|
||||
|
||||
- Replaced Groovy templates by FreeMarker
|
||||
|
||||
### Fixed
|
||||
|
||||
- JS publication sources jar
|
||||
|
||||
## 0.10.9-kotlin-1.6.10
|
||||
|
||||
### Added
|
||||
|
||||
- html builders for readme
|
||||
|
||||
### Changed
|
||||
|
||||
- Kotlin 1.6.0
|
||||
- Use indy lambdas by default #32
|
||||
- Change version scheme to `<version>-kotlin-<kotlin version>`
|
||||
|
||||
### Fixed
|
||||
|
||||
- remove `nativeMain` dependency from `nativeTest`
|
||||
|
||||
## 0.10.4
|
||||
|
||||
### Changed
|
||||
|
||||
- Kotlin 1.6
|
||||
|
||||
### Fixed
|
||||
|
||||
- Some issues with opt-ins
|
||||
|
||||
## 0.10.2
|
||||
|
||||
### Added
|
||||
|
||||
- Experimental automatic JS project bundling in MPP
|
||||
|
||||
### Changed
|
||||
|
||||
- Remove vcs requirement for Space publication
|
||||
|
||||
## 0.10.0
|
||||
|
||||
### Added
|
||||
|
||||
- Lazy readme properties
|
||||
- BOM for kotlin-wrappers on JS
|
||||
- Jupyter loader
|
||||
|
||||
### Changed
|
||||
|
||||
- API validation disabled for dev versions
|
||||
- Kotlin plugins are propagated downstream
|
||||
|
||||
### Removed
|
||||
|
||||
- bson support
|
||||
|
||||
## 0.9.5
|
||||
|
||||
### Added
|
||||
|
||||
- Disable API validation for snapshots
|
||||
- `-Xjvm-default=all` on JVM
|
||||
|
||||
### Changed
|
||||
|
||||
- `publication.platform` changed to `publishing.platform`
|
||||
- Dokka version to `1.4.30`
|
||||
- `useDateTime` in extension
|
||||
- Kotlin 1.5
|
||||
|
||||
### Removed
|
||||
|
||||
- Publish plugin. Use MavenPublish instead
|
||||
|
||||
### Fixed
|
||||
|
||||
- Removed unnecessary `afterEvaluate` for compatibility with gradle 7.0
|
||||
|
||||
## 0.9.0
|
||||
|
||||
### Added
|
||||
|
||||
- Skip sonatype publishing for dev versions
|
||||
|
||||
### Changed
|
||||
|
||||
- Publishing repositories are explicit and defined in the top level project
|
||||
- Paths to publishing properties now use dot notation like `publishing.github.user`
|
||||
|
||||
### Deprecated
|
||||
|
||||
- Publishing plugin
|
||||
|
||||
### Removed
|
||||
|
||||
- Bintray publishing
|
||||
|
||||
## 0.8.4
|
||||
|
||||
### Added
|
||||
|
||||
- Adaptive support for host OS in native
|
||||
- CSS support for JS targets
|
||||
|
||||
### Changed
|
||||
|
||||
- Kotlin 1.4.31
|
||||
- Coroutines 1.4.3
|
||||
|
||||
### Fixed
|
||||
|
||||
- Plugin loading order for publishing
|
||||
- Release task
|
||||
- Readme generation for multi-module project
|
||||
|
||||
## 0.8.1
|
||||
|
||||
### Added
|
||||
|
||||
- Ktor version to versions
|
||||
- Add sonatype publishing
|
||||
- Per-platform release publishing
|
||||
|
||||
### Changed
|
||||
|
||||
- Kotlin to 1.4.30 stable.
|
||||
- Added intermediate jsCommon main/test sourcesSet for node plugin.
|
||||
- Plugin names changed to `ru.mipt.npm` package.
|
||||
- Common plugin id changed to `common`
|
||||
- Plugins group changed to `ru.mipt.npm` with `gradle` prefix
|
||||
|
||||
### Removed
|
||||
|
||||
- kaml
|
||||
|
||||
### Fixed
|
||||
|
||||
- Fix publishing load order for sonatype
|
||||
- Fix root project readme
|
||||
|
||||
## 0.7.4
|
||||
|
||||
### Added
|
||||
|
||||
- Changelog plugin automatically applied to `project`.
|
||||
- Feature matrix and Readme generation task for a `project` plugin.
|
||||
- Add `binary-compatibility-validator` to the `project` plugin.
|
||||
- Separate `yamlKt` serialization target
|
||||
- Moved all logic to a common plugin, leaving only proxies for platform plugins
|
||||
- Suppress API validation for modules with maturity below DEVELOPMENT
|
||||
|
||||
### Changed
|
||||
|
||||
- Remove node plugin. Node binaries should be turned on manually.
|
||||
- Use default webpack distribution path.
|
||||
- `ru.mipt.npm.base` -> `ru.mipt.npm.project`.
|
||||
- Move publishing out of general extension and apply it to project plugin instead.
|
||||
- Platform plugins are now simple references to common plugin
|
||||
- FX configuration moved to extension
|
||||
- Moved internals to internals
|
||||
- Kotlin 1.4.30-RC
|
||||
|
||||
### Deprecated
|
||||
|
||||
- Support of `kaml` and `snake-yaml` in favor of `yamlKt`
|
||||
- Publish plugin
|
||||
|
||||
### Removed
|
||||
|
||||
- `useDokka` method. Documentation jar should be added manually if needed.
|
||||
|
||||
## 0.6.0
|
||||
|
||||
### Added
|
||||
|
||||
- Migrate to kotlin 1.4.0
|
||||
- Separate Native (current platform) and nodeJs plugins.
|
||||
- Add `application()` toggle in plugin configuration to produce binaries on JS and applicaion plugin on jvm.
|
||||
- Add `publish` to expose publishing configuration.
|
||||
|
||||
## 0.5.2
|
||||
|
||||
### Added
|
||||
|
||||
- Copy resources for jvm modules and jvm source sets in mpp.
|
||||
28
README.md
28
README.md
@ -1,28 +0,0 @@
|
||||
[](https://search.maven.org/search?q=g:%22space.kscience.gradle.project%22%20AND%20a:%22space.kscience.gradle.project.gradle.plugin%22)
|
||||
|
||||
# KScience build tools
|
||||
|
||||
A collection of gradle plugins for building and publish in *kscience* and *dataforge* projects.
|
||||
|
||||
## space.kscience.gradle.common
|
||||
A primary plugin. When used with kotlin-jvm, kotlin-js or kotlin-mulitplatform configures the project for appropriate target.
|
||||
|
||||
## space.kscience.gradle.project
|
||||
Root project tool including JetBrains changelog plugin an kotlin binary compatibility validator tool.
|
||||
|
||||
## space.kscience.gradle.mpp
|
||||
`= kotlin("multiplatform") + space.kscience.gradle.common`
|
||||
|
||||
Includes JVM-IR and JS-IR-Browser targets.
|
||||
|
||||
## space.kscience.gradle.jvm
|
||||
`= kotlin("jvm") + space.kscience.gradle.common`
|
||||
|
||||
## space.kscience.gradle.js
|
||||
`= kotlin("js") + space.kscience.gradle.common`
|
||||
|
||||
## space.kscience.gradle.native
|
||||
add default native targets to `space.kscience.gradle.mpp`
|
||||
|
||||
## space.kscience.gradle.node
|
||||
add node target to `space.kscience.gradle.mpp`
|
||||
256
build.gradle.kts
256
build.gradle.kts
@ -1,206 +1,134 @@
|
||||
import java.util.*
|
||||
|
||||
plugins {
|
||||
`java-gradle-plugin`
|
||||
`kotlin-dsl`
|
||||
`maven-publish`
|
||||
// signing
|
||||
`version-catalog`
|
||||
alias(libs.plugins.maven.publish)
|
||||
alias(libs.plugins.jetbrains.changelog)
|
||||
alias(libs.plugins.jetbrains.dokka)
|
||||
alias(libs.plugins.versions)
|
||||
alias(libs.plugins.versions.update)
|
||||
id("com.jfrog.bintray") version "1.8.5"
|
||||
}
|
||||
|
||||
group = "space.kscience"
|
||||
version = libs.versions.tools.get()
|
||||
|
||||
description = "Build tools for kotlin for science projects"
|
||||
|
||||
changelog.version.set(project.version.toString())
|
||||
group = "scientifik"
|
||||
version = "0.5.0"
|
||||
|
||||
repositories {
|
||||
mavenCentral()
|
||||
gradlePluginPortal()
|
||||
maven("https://repo.kotlin.link")
|
||||
jcenter()
|
||||
maven("https://kotlin.bintray.com/kotlinx")
|
||||
maven("https://dl.bintray.com/kotlin/kotlin-eap")
|
||||
}
|
||||
|
||||
val kotlinVersion = "1.3.72"
|
||||
|
||||
java {
|
||||
targetCompatibility = JavaVersion.VERSION_1_8
|
||||
}
|
||||
|
||||
// Add plugins used in buildSrc as dependencies, also we should specify version only here
|
||||
dependencies {
|
||||
api(libs.kotlin.gradle)
|
||||
api(libs.foojay.resolver)
|
||||
implementation(libs.binary.compatibility.validator)
|
||||
implementation(libs.changelog.gradle)
|
||||
implementation(libs.dokka.gradle)
|
||||
implementation(libs.kotlin.jupyter.gradle)
|
||||
implementation(libs.kotlin.serialization)
|
||||
implementation(libs.kotlinx.html)
|
||||
implementation(libs.tomlj)
|
||||
// // nexus publishing plugin
|
||||
// implementation("io.github.gradle-nexus:publish-plugin:_")
|
||||
|
||||
implementation(libs.freemarker)
|
||||
|
||||
testImplementation(kotlin("test"))
|
||||
implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion")
|
||||
implementation("org.jetbrains.kotlin:kotlin-serialization:$kotlinVersion")
|
||||
implementation("org.jetbrains.kotlinx:atomicfu-gradle-plugin:0.14.3")
|
||||
implementation("org.jetbrains.dokka:dokka-gradle-plugin:0.10.1")
|
||||
}
|
||||
|
||||
tasks.test {
|
||||
useJUnitPlatform()
|
||||
}
|
||||
|
||||
//declaring exported plugins
|
||||
|
||||
gradlePlugin {
|
||||
plugins {
|
||||
create("project") {
|
||||
id = "space.kscience.gradle.project"
|
||||
description = "The root plugin for multi-module project infrastructure"
|
||||
implementationClass = "space.kscience.gradle.KScienceProjectPlugin"
|
||||
create("scientifik-publish") {
|
||||
id = "scientifik.publish"
|
||||
description = "The publication plugin for bintray and github"
|
||||
implementationClass = "scientifik.ScientifikPublishPlugin"
|
||||
}
|
||||
|
||||
create("mpp") {
|
||||
id = "space.kscience.gradle.mpp"
|
||||
create("scientifik-mpp") {
|
||||
id = "scientifik.mpp"
|
||||
description = "Pre-configured multiplatform project"
|
||||
implementationClass = "space.kscience.gradle.KScienceMPPlugin"
|
||||
implementationClass = "scientifik.ScientifikMPPlugin"
|
||||
}
|
||||
|
||||
create("jvm") {
|
||||
id = "space.kscience.gradle.jvm"
|
||||
create("scientifik-jvm") {
|
||||
id = "scientifik.jvm"
|
||||
description = "Pre-configured JVM project"
|
||||
implementationClass = "space.kscience.gradle.KScienceJVMPlugin"
|
||||
implementationClass = "scientifik.ScientifikJVMPlugin"
|
||||
}
|
||||
|
||||
create("scientifik-js") {
|
||||
id = "scientifik.js"
|
||||
description = "Pre-configured JS project"
|
||||
implementationClass = "scientifik.ScientifikJSPlugin"
|
||||
}
|
||||
|
||||
// create("scientifik-atomic") {
|
||||
// id = "scientifik.atomic"
|
||||
// description = "Add kotlin atomic plugin to any flafor"
|
||||
// implementationClass = "scientifik.ScientifikAtomicPlugin"
|
||||
// }
|
||||
}
|
||||
}
|
||||
|
||||
tasks.create("version") {
|
||||
group = "publishing"
|
||||
val versionFileProvider = project.layout.buildDirectory.file("project-version.txt")
|
||||
outputs.file(versionFileProvider)
|
||||
doLast {
|
||||
val versionFile = versionFileProvider.get().asFile
|
||||
versionFile.createNewFile()
|
||||
versionFile.writeText(project.version.toString())
|
||||
}
|
||||
}
|
||||
|
||||
//publishing version catalog
|
||||
|
||||
catalog.versionCatalog {
|
||||
from(files("gradle/libs.versions.toml"))
|
||||
}
|
||||
|
||||
//publishing the artifact
|
||||
|
||||
val sourcesJar by tasks.creating(Jar::class) {
|
||||
archiveClassifier.set("sources")
|
||||
from(sourceSets.named("main").get().allSource)
|
||||
}
|
||||
|
||||
val javadocsJar by tasks.creating(Jar::class) {
|
||||
group = JavaBasePlugin.DOCUMENTATION_GROUP
|
||||
archiveClassifier.set("javadoc")
|
||||
from(tasks.dokkaHtml)
|
||||
}
|
||||
|
||||
val emptyJavadocJar by tasks.creating(Jar::class) {
|
||||
group = JavaBasePlugin.DOCUMENTATION_GROUP
|
||||
archiveBaseName.set("empty")
|
||||
archiveClassifier.set("javadoc")
|
||||
}
|
||||
|
||||
|
||||
val emptySourcesJar by tasks.creating(Jar::class) {
|
||||
archiveClassifier.set("sources")
|
||||
archiveBaseName.set("empty")
|
||||
}
|
||||
|
||||
mavenPublishing {
|
||||
configure(
|
||||
com.vanniktech.maven.publish.GradlePlugin(
|
||||
javadocJar = com.vanniktech.maven.publish.JavadocJar.Dokka("dokkaHtml"),
|
||||
sourcesJar = true,
|
||||
)
|
||||
)
|
||||
|
||||
project.publishing.publications.create("maven", MavenPublication::class.java) {
|
||||
from(project.components.getByName("versionCatalog"))
|
||||
publishing {
|
||||
repositories {
|
||||
maven("https://bintray.com/mipt-npm/scientifik")
|
||||
}
|
||||
|
||||
val vcs = "https://git.sciprog.center/kscience/gradle-tools"
|
||||
val vcs = "https://github.com/mipt-npm/scientifik-gradle-tools"
|
||||
|
||||
pom {
|
||||
name.set(project.name)
|
||||
description.set(project.description)
|
||||
url.set(vcs)
|
||||
// Process each publication we have in this project
|
||||
publications.filterIsInstance<MavenPublication>().forEach { publication ->
|
||||
|
||||
licenses {
|
||||
license {
|
||||
name.set("The Apache Software License, Version 2.0")
|
||||
url.set("https://www.apache.org/licenses/LICENSE-2.0.txt")
|
||||
distribution.set("repo")
|
||||
}
|
||||
}
|
||||
|
||||
developers {
|
||||
developer {
|
||||
id.set("SPC")
|
||||
name.set("Scientific Programming Centre")
|
||||
organization.set("SPC")
|
||||
organizationUrl.set("https://sciprog.center/")
|
||||
}
|
||||
}
|
||||
|
||||
scm {
|
||||
publication.pom {
|
||||
name.set(project.name)
|
||||
description.set(project.description)
|
||||
url.set(vcs)
|
||||
tag.set(project.version.toString())
|
||||
}
|
||||
}
|
||||
|
||||
val spaceRepo = "https://maven.sciprog.center/kscience"
|
||||
val spcUser: String? = findProperty("publishing.spc.user") as? String
|
||||
val spcToken: String? = findProperty("publishing.spc.token") as? String
|
||||
licenses {
|
||||
license {
|
||||
name.set("The Apache Software License, Version 2.0")
|
||||
url.set("http://www.apache.org/licenses/LICENSE-2.0.txt")
|
||||
distribution.set("repo")
|
||||
}
|
||||
}
|
||||
developers {
|
||||
developer {
|
||||
id.set("MIPT-NPM")
|
||||
name.set("MIPT nuclear physics methods laboratory")
|
||||
organization.set("MIPT")
|
||||
organizationUrl.set("http://npm.mipt.ru")
|
||||
}
|
||||
|
||||
if (spcUser != null && spcToken != null) {
|
||||
publishing.repositories.maven {
|
||||
name = "spc"
|
||||
url = uri(spaceRepo)
|
||||
|
||||
credentials {
|
||||
username = spcUser
|
||||
password = spcToken
|
||||
}
|
||||
scm {
|
||||
url.set(vcs)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
val centralUser: String? = project.findProperty("mavenCentralUsername") as? String
|
||||
val centralPassword: String? = project.findProperty("mavenCentralPassword") as? String
|
||||
bintray {
|
||||
user = project.findProperty("bintrayUser") as? String ?: System.getenv("BINTRAY_USER")
|
||||
key = project.findProperty("bintrayApiKey") as? String? ?: System.getenv("BINTRAY_API_KEY")
|
||||
publish = true
|
||||
override = true // for multi-platform Kotlin/Native publishing
|
||||
|
||||
// We have to use delegateClosureOf because bintray supports only dynamic groovy syntax
|
||||
// this is a problem of this plugin
|
||||
pkg.apply {
|
||||
userOrg = "mipt-npm"
|
||||
repo = if (project.version.toString().contains("dev")) "dev" else "scientifik"
|
||||
name = project.name
|
||||
issueTrackerUrl = "$vcs/issues"
|
||||
setLicenses("Apache-2.0")
|
||||
vcsUrl = vcs
|
||||
version.apply {
|
||||
name = project.version.toString()
|
||||
vcsTag = project.version.toString()
|
||||
released = Date().toString()
|
||||
}
|
||||
}
|
||||
|
||||
//workaround bintray bug
|
||||
project.afterEvaluate {
|
||||
setPublications(*project.extensions.findByType<PublishingExtension>()!!.publications.names.toTypedArray())
|
||||
}
|
||||
|
||||
if (centralUser != null && centralPassword != null) {
|
||||
publishToMavenCentral(com.vanniktech.maven.publish.SonatypeHost.CENTRAL_PORTAL)
|
||||
signAllPublications()
|
||||
}
|
||||
}
|
||||
|
||||
kotlin {
|
||||
explicitApiWarning()
|
||||
jvmToolchain(17)
|
||||
}
|
||||
|
||||
tasks.processResources.configure {
|
||||
duplicatesStrategy = DuplicatesStrategy.INCLUDE
|
||||
from("gradle/libs.versions.toml")
|
||||
}
|
||||
|
||||
// Workaround for https://github.com/gradle/gradle/issues/15568
|
||||
tasks.withType<AbstractPublishToMaven>().configureEach {
|
||||
mustRunAfter(tasks.withType<Sign>())
|
||||
}
|
||||
|
||||
versionCatalogUpdate {
|
||||
sortByKey.set(false)
|
||||
keep {
|
||||
keepUnusedVersions = true
|
||||
keepUnusedPlugins = true
|
||||
keepUnusedLibraries = true
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,3 +0,0 @@
|
||||
kotlin.code.style=official
|
||||
|
||||
nl.littlerobots.vcu.resolver=true
|
||||
@ -1,118 +0,0 @@
|
||||
[versions]
|
||||
# @pin
|
||||
kotlin = "2.1.0"
|
||||
# @pin
|
||||
tools = "0.15.8-kotlin-2.1.0"
|
||||
atomicfu = "0.26.1"
|
||||
changelog = "2.2.1"
|
||||
compose = "1.7.1"
|
||||
dokka = "2.0.0-Beta"
|
||||
jsBom = "1.0.0-pre.847"
|
||||
junit = "5.10.2"
|
||||
kotlin-jupyter = "0.12.0-352"
|
||||
kotlinx-benchmark = "0.4.13"
|
||||
kotlinx-cli = "0.3.6"
|
||||
kotlinx-coroutines = "1.9.0"
|
||||
kotlinx-datetime = "0.6.1"
|
||||
kotlinx-html = "0.11.0"
|
||||
kotlinx-knit = "0.5.0"
|
||||
kotlinx-nodejs = "0.0.7"
|
||||
kotlinx-serialization = "1.7.3"
|
||||
kover = "0.8.3"
|
||||
ktor = "3.0.2"
|
||||
ksp = "2.1.0-1.0.29"
|
||||
logback = "1.5.12"
|
||||
slf4j = "2.0.16"
|
||||
xmlutil = "0.90.3"
|
||||
yamlkt = "0.13.0"
|
||||
|
||||
[plugins]
|
||||
maven-publish = { id = "com.vanniktech.maven.publish", version = "0.30.0" }
|
||||
compose-compiler = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
|
||||
compose-jb = { id = "org.jetbrains.compose", version.ref = "compose" }
|
||||
jetbrains-changelog = "org.jetbrains.changelog:2.2.1"
|
||||
jetbrains-dokka = { id = "org.jetbrains.dokka", version.ref = "dokka" }
|
||||
kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
|
||||
kotlin-android-extensions = { id = "org.jetbrains.kotlin.android.extensions", version.ref = "kotlin" }
|
||||
kotlin-dsl = "org.gradle.kotlin.kotlin-dsl:5.1.2"
|
||||
kotlin-js = { id = "org.jetbrains.kotlin.js", version.ref = "kotlin" }
|
||||
kotlin-jupyter-api = { id = "org.jetbrains.kotlin.jupyter.api", version.ref = "kotlin-jupyter" }
|
||||
kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
|
||||
kotlin-kapt = { id = "org.jetbrains.kotlin.kapt", version.ref = "kotlin" }
|
||||
kotlin-multiplatform = { id = "org.jetbrains.kotlin.multiplatform", version.ref = "kotlin" }
|
||||
kotlin-native-cocoapods = { id = "org.jetbrains.kotlin.native.cocoapods", version.ref = "kotlin" }
|
||||
kotlin-plugin-allopen = { id = "org.jetbrains.kotlin.plugin.allopen", version.ref = "kotlin" }
|
||||
kotlin-plugin-jpa = { id = "org.jetbrains.kotlin.plugin.jpa", version.ref = "kotlin" }
|
||||
kotlin-plugin-lombok = { id = "org.jetbrains.kotlin.plugin.lombok", version.ref = "kotlin" }
|
||||
kotlin-plugin-noarg = { id = "org.jetbrains.kotlin.plugin.noarg", version.ref = "kotlin" }
|
||||
kotlin-plugin-parcelize = { id = "org.jetbrains.kotlin.plugin.parcelize", version.ref = "kotlin" }
|
||||
kotlin-plugin-scripting = { id = "org.jetbrains.kotlin.plugin.scripting", version.ref = "kotlin" }
|
||||
kotlin-plugin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }
|
||||
kotlin-plugin-spring = { id = "org.jetbrains.kotlin.plugin.spring", version.ref = "kotlin" }
|
||||
kotlinx-benchmark = { id = "org.jetbrains.kotlinx.benchmark", version.ref = "kotlinx-benchmark" }
|
||||
kotlinx-kover = { id = "org.jetbrains.kotlinx.kover", version.ref = "kover" }
|
||||
kscience-mpp = { id = "space.kscience.gradle.mpp", version.ref = "tools" }
|
||||
kscience-project = { id = "space.kscience.gradle.project", version.ref = "tools" }
|
||||
ksp = { id = "com.google.devtools.ksp", version.ref = "ksp" }
|
||||
ktor = { id = "io.ktor.plugin", version.ref = "ktor" }
|
||||
versions = "com.github.ben-manes.versions:0.51.0"
|
||||
versions-update = "nl.littlerobots.version-catalog-update:0.8.5"
|
||||
|
||||
[libraries]
|
||||
atomicfu = { module = "org.jetbrains.kotlinx:atomicfu", version.ref = "atomicfu" }
|
||||
atomicfu-gradle = { module = "org.jetbrains.kotlinx:atomicfu-gradle-plugin", version.ref = "atomicfu" }
|
||||
binary-compatibility-validator = "org.jetbrains.kotlinx:binary-compatibility-validator:0.15.0-Beta.3"
|
||||
changelog-gradle = { module = "org.jetbrains.intellij.plugins:gradle-changelog-plugin", version.ref = "changelog" }
|
||||
dokka-base = { module = "org.jetbrains.dokka:dokka-base", version.ref = "dokka" }
|
||||
dokka-gradle = { module = "org.jetbrains.dokka:dokka-gradle-plugin", version.ref = "dokka" }
|
||||
dokka-gradle-plugin = { module = "org.jetbrains.dokka:dokka-gradle-plugin", version.ref = "dokka" }
|
||||
foojay-resolver = "org.gradle.toolchains:foojay-resolver:0.9.0"
|
||||
freemarker = "org.freemarker:freemarker:2.3.33"
|
||||
gradle-changelog-plugin = { module = "org.jetbrains.intellij.plugins:gradle-changelog-plugin", version.ref = "changelog" }
|
||||
kotlin-assignment-compiler-plugin-embeddable = { module = "org.jetbrains.kotlin:kotlin-assignment-compiler-plugin-embeddable", version.ref = "kotlin" }
|
||||
kotlin-gradle = { module = "org.jetbrains.kotlin:kotlin-gradle-plugin", version.ref = "kotlin" }
|
||||
kotlin-gradle-plugin = { module = "org.jetbrains.kotlin:kotlin-gradle-plugin", version.ref = "kotlin" }
|
||||
kotlin-js-wrappers = { module = "org.jetbrains.kotlin-wrappers:kotlin-wrappers-bom", version.ref = "jsBom" }
|
||||
kotlin-jupyter-api-gradle-plugin = { module = "org.jetbrains.kotlin:kotlin-jupyter-api-gradle-plugin", version.ref = "kotlin" }
|
||||
kotlin-jupyter-gradle = { module = "org.jetbrains.kotlin:kotlin-jupyter-api-gradle-plugin", version.ref = "kotlin-jupyter" }
|
||||
kotlin-reflect = { module = "org.jetbrains.kotlin:kotlin-reflect", version.ref = "kotlin" }
|
||||
kotlin-sam-with-receiver-compiler-plugin-embeddable = { module = "org.jetbrains.kotlin:kotlin-sam-with-receiver-compiler-plugin-embeddable", version.ref = "kotlin" }
|
||||
kotlin-scripting-compiler-embeddable = { module = "org.jetbrains.kotlin:kotlin-scripting-compiler-embeddable", version.ref = "kotlin" }
|
||||
kotlin-serialization = { module = "org.jetbrains.kotlin:kotlin-serialization", version.ref = "kotlin" }
|
||||
kotlin-stdlib = { module = "org.jetbrains.kotlin:kotlin-stdlib", version.ref = "kotlin" }
|
||||
kotlin-test = { module = "org.jetbrains.kotlin:kotlin-test" }
|
||||
kotlinx-benchmark-runtime = { module = "org.jetbrains.kotlinx:kotlinx-benchmark-runtime", version.ref = "kotlinx-benchmark" }
|
||||
kotlinx-cli = { module = "org.jetbrains.kotlinx:kotlinx-cli", version.ref = "kotlinx-cli" }
|
||||
kotlinx-coroutines-android = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-android", version.ref = "kotlinx-coroutines" }
|
||||
kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlinx-coroutines" }
|
||||
kotlinx-coroutines-debug = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-debug", version.ref = "kotlinx-coroutines" }
|
||||
kotlinx-coroutines-guava = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-guava", version.ref = "kotlinx-coroutines" }
|
||||
kotlinx-coroutines-javafx = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-javafx", version.ref = "kotlinx-coroutines" }
|
||||
kotlinx-coroutines-jdk8 = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-jdk8", version.ref = "kotlinx-coroutines" }
|
||||
kotlinx-coroutines-play-services = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-play-services", version.ref = "kotlinx-coroutines" }
|
||||
kotlinx-coroutines-reactive = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-reactive", version.ref = "kotlinx-coroutines" }
|
||||
kotlinx-coroutines-reactor = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-reactor", version.ref = "kotlinx-coroutines" }
|
||||
kotlinx-coroutines-rx2 = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-rx2", version.ref = "kotlinx-coroutines" }
|
||||
kotlinx-coroutines-rx3 = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-rx3", version.ref = "kotlinx-coroutines" }
|
||||
kotlinx-coroutines-slf4j = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-slf4j", version.ref = "kotlinx-coroutines" }
|
||||
kotlinx-coroutines-swing = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-swing", version.ref = "kotlinx-coroutines" }
|
||||
kotlinx-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-test", version.ref = "kotlinx-coroutines" }
|
||||
kotlinx-datetime = { module = "org.jetbrains.kotlinx:kotlinx-datetime", version.ref = "kotlinx-datetime" }
|
||||
kotlinx-html = { module = "org.jetbrains.kotlinx:kotlinx-html", version.ref = "kotlinx-html" }
|
||||
kotlinx-knit = { module = "org.jetbrains.kotlinx:kotlinx-knit", version.ref = "kotlinx-knit" }
|
||||
kotlinx-nodejs = { module = "org.jetbrains.kotlinx:kotlinx-nodejs", version.ref = "kotlinx-nodejs" }
|
||||
kotlinx-serialization-cbor = { module = "org.jetbrains.kotlinx:kotlinx-serialization-cbor", version.ref = "kotlinx-serialization" }
|
||||
kotlinx-serialization-core = { module = "org.jetbrains.kotlinx:kotlinx-serialization-core", version.ref = "kotlinx-serialization" }
|
||||
kotlinx-serialization-hocon = { module = "org.jetbrains.kotlinx:kotlinx-serialization-hocon", version.ref = "kotlinx-serialization" }
|
||||
kotlinx-serialization-json = { module = "org.jetbrains.kotlinx:kotlinx-serialization-json", version.ref = "kotlinx-serialization" }
|
||||
kotlinx-serialization-properties = { module = "org.jetbrains.kotlinx:kotlinx-serialization-properties", version.ref = "kotlinx-serialization" }
|
||||
kotlinx-serialization-protobuf = { module = "org.jetbrains.kotlinx:kotlinx-serialization-protobuf", version.ref = "kotlinx-serialization" }
|
||||
ksp-api = { module = "com.google.devtools.ksp:symbol-processing-api", version.ref = "ksp" }
|
||||
ktor-bom = { module = "io.ktor:ktor-bom", version.ref = "ktor" }
|
||||
logback-classic = { module = "ch.qos.logback:logback-classic", version.ref = "logback" }
|
||||
slf4j = { module = "org.slf4j:slf4j-api", version.ref = "slf4j" }
|
||||
tomlj = "org.tomlj:tomlj:1.1.1"
|
||||
xmlutil-core = { module = "io.github.pdvrieze.xmlutil:core", version.ref = "xmlutil" }
|
||||
xmlutil-ktor = { module = "io.github.pdvrieze.xmlutil:ktor", version.ref = "xmlutil" }
|
||||
xmlutil-serialization = { module = "io.github.pdvrieze.xmlutil:serialization", version.ref = "xmlutil" }
|
||||
yamlkt = { module = "net.mamoe.yamlkt:yamlkt", version.ref = "yamlkt" }
|
||||
BIN
gradle/wrapper/gradle-wrapper.jar
vendored
BIN
gradle/wrapper/gradle-wrapper.jar
vendored
Binary file not shown.
2
gradle/wrapper/gradle-wrapper.properties
vendored
2
gradle/wrapper/gradle-wrapper.properties
vendored
@ -1,5 +1,5 @@
|
||||
distributionBase=GRADLE_USER_HOME
|
||||
distributionPath=wrapper/dists
|
||||
distributionUrl=https\://services.gradle.org/distributions/gradle-8.10-bin.zip
|
||||
distributionUrl=https\://services.gradle.org/distributions/gradle-6.2.2-bin.zip
|
||||
zipStoreBase=GRADLE_USER_HOME
|
||||
zipStorePath=wrapper/dists
|
||||
|
||||
259
gradlew
vendored
Executable file → Normal file
259
gradlew
vendored
Executable file → Normal file
@ -1,7 +1,7 @@
|
||||
#!/bin/sh
|
||||
#!/usr/bin/env sh
|
||||
|
||||
#
|
||||
# Copyright © 2015-2021 the original authors.
|
||||
# Copyright 2015 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.
|
||||
@ -17,113 +17,78 @@
|
||||
#
|
||||
|
||||
##############################################################################
|
||||
#
|
||||
# Gradle start up script for POSIX generated by Gradle.
|
||||
#
|
||||
# Important for running:
|
||||
#
|
||||
# (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
|
||||
# noncompliant, but you have some other compliant shell such as ksh or
|
||||
# bash, then to run this script, type that shell name before the whole
|
||||
# command line, like:
|
||||
#
|
||||
# ksh Gradle
|
||||
#
|
||||
# Busybox and similar reduced shells will NOT work, because this script
|
||||
# requires all of these POSIX shell features:
|
||||
# * functions;
|
||||
# * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
|
||||
# «${var#prefix}», «${var%suffix}», and «$( cmd )»;
|
||||
# * compound commands having a testable exit status, especially «case»;
|
||||
# * various built-in commands including «command», «set», and «ulimit».
|
||||
#
|
||||
# Important for patching:
|
||||
#
|
||||
# (2) This script targets any POSIX shell, so it avoids extensions provided
|
||||
# by Bash, Ksh, etc; in particular arrays are avoided.
|
||||
#
|
||||
# The "traditional" practice of packing multiple parameters into a
|
||||
# space-separated string is a well documented source of bugs and security
|
||||
# problems, so this is (mostly) avoided, by progressively accumulating
|
||||
# options in "$@", and eventually passing that to Java.
|
||||
#
|
||||
# Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
|
||||
# and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
|
||||
# see the in-line comments for details.
|
||||
#
|
||||
# There are tweaks for specific operating systems such as AIX, CygWin,
|
||||
# Darwin, MinGW, and NonStop.
|
||||
#
|
||||
# (3) This script is generated from the Groovy template
|
||||
# https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
|
||||
# within the Gradle project.
|
||||
#
|
||||
# You can find Gradle at https://github.com/gradle/gradle/.
|
||||
#
|
||||
##
|
||||
## Gradle start up script for UN*X
|
||||
##
|
||||
##############################################################################
|
||||
|
||||
# Attempt to set APP_HOME
|
||||
|
||||
# Resolve links: $0 may be a link
|
||||
app_path=$0
|
||||
|
||||
# Need this for daisy-chained symlinks.
|
||||
while
|
||||
APP_HOME=${app_path%"${app_path##*/}"} # leaves a trailing /; empty if no leading path
|
||||
[ -h "$app_path" ]
|
||||
do
|
||||
ls=$( ls -ld "$app_path" )
|
||||
link=${ls#*' -> '}
|
||||
case $link in #(
|
||||
/*) app_path=$link ;; #(
|
||||
*) app_path=$APP_HOME$link ;;
|
||||
esac
|
||||
PRG="$0"
|
||||
# Need this for relative symlinks.
|
||||
while [ -h "$PRG" ] ; do
|
||||
ls=`ls -ld "$PRG"`
|
||||
link=`expr "$ls" : '.*-> \(.*\)$'`
|
||||
if expr "$link" : '/.*' > /dev/null; then
|
||||
PRG="$link"
|
||||
else
|
||||
PRG=`dirname "$PRG"`"/$link"
|
||||
fi
|
||||
done
|
||||
|
||||
APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
|
||||
SAVED="`pwd`"
|
||||
cd "`dirname \"$PRG\"`/" >/dev/null
|
||||
APP_HOME="`pwd -P`"
|
||||
cd "$SAVED" >/dev/null
|
||||
|
||||
APP_NAME="Gradle"
|
||||
APP_BASE_NAME=${0##*/}
|
||||
APP_BASE_NAME=`basename "$0"`
|
||||
|
||||
# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
|
||||
DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
|
||||
|
||||
# Use the maximum available, or set MAX_FD != -1 to use that value.
|
||||
MAX_FD=maximum
|
||||
MAX_FD="maximum"
|
||||
|
||||
warn () {
|
||||
echo "$*"
|
||||
} >&2
|
||||
}
|
||||
|
||||
die () {
|
||||
echo
|
||||
echo "$*"
|
||||
echo
|
||||
exit 1
|
||||
} >&2
|
||||
}
|
||||
|
||||
# OS specific support (must be 'true' or 'false').
|
||||
cygwin=false
|
||||
msys=false
|
||||
darwin=false
|
||||
nonstop=false
|
||||
case "$( uname )" in #(
|
||||
CYGWIN* ) cygwin=true ;; #(
|
||||
Darwin* ) darwin=true ;; #(
|
||||
MSYS* | MINGW* ) msys=true ;; #(
|
||||
NONSTOP* ) nonstop=true ;;
|
||||
case "`uname`" in
|
||||
CYGWIN* )
|
||||
cygwin=true
|
||||
;;
|
||||
Darwin* )
|
||||
darwin=true
|
||||
;;
|
||||
MINGW* )
|
||||
msys=true
|
||||
;;
|
||||
NONSTOP* )
|
||||
nonstop=true
|
||||
;;
|
||||
esac
|
||||
|
||||
CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
|
||||
|
||||
|
||||
# Determine the Java command to use to start the JVM.
|
||||
if [ -n "$JAVA_HOME" ] ; then
|
||||
if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
|
||||
# IBM's JDK on AIX uses strange locations for the executables
|
||||
JAVACMD=$JAVA_HOME/jre/sh/java
|
||||
JAVACMD="$JAVA_HOME/jre/sh/java"
|
||||
else
|
||||
JAVACMD=$JAVA_HOME/bin/java
|
||||
JAVACMD="$JAVA_HOME/bin/java"
|
||||
fi
|
||||
if [ ! -x "$JAVACMD" ] ; then
|
||||
die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
|
||||
@ -132,7 +97,7 @@ Please set the JAVA_HOME variable in your environment to match the
|
||||
location of your Java installation."
|
||||
fi
|
||||
else
|
||||
JAVACMD=java
|
||||
JAVACMD="java"
|
||||
which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
|
||||
|
||||
Please set the JAVA_HOME variable in your environment to match the
|
||||
@ -140,95 +105,79 @@ location of your Java installation."
|
||||
fi
|
||||
|
||||
# Increase the maximum file descriptors if we can.
|
||||
if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
|
||||
case $MAX_FD in #(
|
||||
max*)
|
||||
MAX_FD=$( ulimit -H -n ) ||
|
||||
warn "Could not query maximum file descriptor limit"
|
||||
esac
|
||||
case $MAX_FD in #(
|
||||
'' | soft) :;; #(
|
||||
*)
|
||||
ulimit -n "$MAX_FD" ||
|
||||
warn "Could not set maximum file descriptor limit to $MAX_FD"
|
||||
esac
|
||||
if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
|
||||
MAX_FD_LIMIT=`ulimit -H -n`
|
||||
if [ $? -eq 0 ] ; then
|
||||
if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
|
||||
MAX_FD="$MAX_FD_LIMIT"
|
||||
fi
|
||||
ulimit -n $MAX_FD
|
||||
if [ $? -ne 0 ] ; then
|
||||
warn "Could not set maximum file descriptor limit: $MAX_FD"
|
||||
fi
|
||||
else
|
||||
warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
|
||||
fi
|
||||
fi
|
||||
|
||||
# Collect all arguments for the java command, stacking in reverse order:
|
||||
# * args from the command line
|
||||
# * the main class name
|
||||
# * -classpath
|
||||
# * -D...appname settings
|
||||
# * --module-path (only if needed)
|
||||
# * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
|
||||
# For Darwin, add options to specify how the application appears in the dock
|
||||
if $darwin; then
|
||||
GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
|
||||
fi
|
||||
|
||||
# For Cygwin or MSYS, switch paths to Windows format before running java
|
||||
if "$cygwin" || "$msys" ; then
|
||||
APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
|
||||
CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
|
||||
if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
|
||||
APP_HOME=`cygpath --path --mixed "$APP_HOME"`
|
||||
CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
|
||||
JAVACMD=`cygpath --unix "$JAVACMD"`
|
||||
|
||||
JAVACMD=$( cygpath --unix "$JAVACMD" )
|
||||
|
||||
# Now convert the arguments - kludge to limit ourselves to /bin/sh
|
||||
for arg do
|
||||
if
|
||||
case $arg in #(
|
||||
-*) false ;; # don't mess with options #(
|
||||
/?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath
|
||||
[ -e "$t" ] ;; #(
|
||||
*) false ;;
|
||||
esac
|
||||
then
|
||||
arg=$( cygpath --path --ignore --mixed "$arg" )
|
||||
fi
|
||||
# Roll the args list around exactly as many times as the number of
|
||||
# args, so each arg winds up back in the position where it started, but
|
||||
# possibly modified.
|
||||
#
|
||||
# NB: a `for` loop captures its iteration list before it begins, so
|
||||
# changing the positional parameters here affects neither the number of
|
||||
# iterations, nor the values presented in `arg`.
|
||||
shift # remove old arg
|
||||
set -- "$@" "$arg" # push replacement arg
|
||||
# We build the pattern for arguments to be converted via cygpath
|
||||
ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
|
||||
SEP=""
|
||||
for dir in $ROOTDIRSRAW ; do
|
||||
ROOTDIRS="$ROOTDIRS$SEP$dir"
|
||||
SEP="|"
|
||||
done
|
||||
OURCYGPATTERN="(^($ROOTDIRS))"
|
||||
# Add a user-defined pattern to the cygpath arguments
|
||||
if [ "$GRADLE_CYGPATTERN" != "" ] ; then
|
||||
OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
|
||||
fi
|
||||
# Now convert the arguments - kludge to limit ourselves to /bin/sh
|
||||
i=0
|
||||
for arg in "$@" ; do
|
||||
CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
|
||||
CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option
|
||||
|
||||
if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition
|
||||
eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
|
||||
else
|
||||
eval `echo args$i`="\"$arg\""
|
||||
fi
|
||||
i=`expr $i + 1`
|
||||
done
|
||||
case $i in
|
||||
0) set -- ;;
|
||||
1) set -- "$args0" ;;
|
||||
2) set -- "$args0" "$args1" ;;
|
||||
3) set -- "$args0" "$args1" "$args2" ;;
|
||||
4) set -- "$args0" "$args1" "$args2" "$args3" ;;
|
||||
5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
|
||||
6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
|
||||
7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
|
||||
8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
|
||||
9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
|
||||
esac
|
||||
fi
|
||||
|
||||
# Collect all arguments for the java command;
|
||||
# * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
|
||||
# shell script including quotes and variable substitutions, so put them in
|
||||
# double quotes to make sure that they get re-expanded; and
|
||||
# * put everything else in single quotes, so that it's not re-expanded.
|
||||
# Escape application args
|
||||
save () {
|
||||
for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
|
||||
echo " "
|
||||
}
|
||||
APP_ARGS=`save "$@"`
|
||||
|
||||
set -- \
|
||||
"-Dorg.gradle.appname=$APP_BASE_NAME" \
|
||||
-classpath "$CLASSPATH" \
|
||||
org.gradle.wrapper.GradleWrapperMain \
|
||||
"$@"
|
||||
|
||||
# Use "xargs" to parse quoted args.
|
||||
#
|
||||
# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
|
||||
#
|
||||
# In Bash we could simply go:
|
||||
#
|
||||
# readarray ARGS < <( xargs -n1 <<<"$var" ) &&
|
||||
# set -- "${ARGS[@]}" "$@"
|
||||
#
|
||||
# but POSIX shell has neither arrays nor command substitution, so instead we
|
||||
# post-process each arg (as a line of input to sed) to backslash-escape any
|
||||
# character that might be a shell metacharacter, then use eval to reverse
|
||||
# that process (while maintaining the separation between arguments), and wrap
|
||||
# the whole thing up as a single "set" statement.
|
||||
#
|
||||
# This will of course break if any of these variables contains a newline or
|
||||
# an unmatched quote.
|
||||
#
|
||||
|
||||
eval "set -- $(
|
||||
printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
|
||||
xargs -n1 |
|
||||
sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
|
||||
tr '\n' ' '
|
||||
)" '"$@"'
|
||||
# Collect all arguments for the java command, following the shell quoting and substitution rules
|
||||
eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
|
||||
|
||||
exec "$JAVACMD" "$@"
|
||||
|
||||
22
gradlew.bat
vendored
22
gradlew.bat
vendored
@ -40,7 +40,7 @@ if defined JAVA_HOME goto findJavaFromJavaHome
|
||||
|
||||
set JAVA_EXE=java.exe
|
||||
%JAVA_EXE% -version >NUL 2>&1
|
||||
if "%ERRORLEVEL%" == "0" goto execute
|
||||
if "%ERRORLEVEL%" == "0" goto init
|
||||
|
||||
echo.
|
||||
echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
|
||||
@ -54,7 +54,7 @@ goto fail
|
||||
set JAVA_HOME=%JAVA_HOME:"=%
|
||||
set JAVA_EXE=%JAVA_HOME%/bin/java.exe
|
||||
|
||||
if exist "%JAVA_EXE%" goto execute
|
||||
if exist "%JAVA_EXE%" goto init
|
||||
|
||||
echo.
|
||||
echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
|
||||
@ -64,14 +64,28 @@ echo location of your Java installation.
|
||||
|
||||
goto fail
|
||||
|
||||
:init
|
||||
@rem Get command-line arguments, handling Windows variants
|
||||
|
||||
if not "%OS%" == "Windows_NT" goto win9xME_args
|
||||
|
||||
:win9xME_args
|
||||
@rem Slurp the command line arguments.
|
||||
set CMD_LINE_ARGS=
|
||||
set _SKIP=2
|
||||
|
||||
:win9xME_args_slurp
|
||||
if "x%~1" == "x" goto execute
|
||||
|
||||
set CMD_LINE_ARGS=%*
|
||||
|
||||
:execute
|
||||
@rem Setup the command line
|
||||
|
||||
set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
|
||||
|
||||
|
||||
@rem Execute Gradle
|
||||
"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
|
||||
"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
|
||||
|
||||
:end
|
||||
@rem End local scope for the variables with windows NT shell
|
||||
|
||||
2
settings.gradle
Normal file
2
settings.gradle
Normal file
@ -0,0 +1,2 @@
|
||||
rootProject.name = 'gradle-tools'
|
||||
|
||||
@ -1,5 +0,0 @@
|
||||
rootProject.name = "gradle-tools"
|
||||
|
||||
plugins {
|
||||
id("org.gradle.toolchains.foojay-resolver-convention") version("0.8.0")
|
||||
}
|
||||
18
src/main/kotlin/Scientifik.kt
Normal file
18
src/main/kotlin/Scientifik.kt
Normal file
@ -0,0 +1,18 @@
|
||||
import org.gradle.api.JavaVersion
|
||||
|
||||
/**
|
||||
* Build constants
|
||||
*/
|
||||
object Scientifik {
|
||||
const val coroutinesVersion = "1.3.4"
|
||||
const val serializationVersion = "0.20.0"
|
||||
|
||||
val JVM_TARGET = JavaVersion.VERSION_11
|
||||
// val JVM_VERSION = JVM_TARGET.toString()
|
||||
|
||||
object Serialization{
|
||||
const val xmlVersion = "0.20.0.0"
|
||||
const val yamlVersion = "0.16.1"
|
||||
const val bsonVersion = "0.2.1"
|
||||
}
|
||||
}
|
||||
68
src/main/kotlin/scientifik/ScientifikJSPlugin.kt
Normal file
68
src/main/kotlin/scientifik/ScientifikJSPlugin.kt
Normal file
@ -0,0 +1,68 @@
|
||||
package scientifik
|
||||
|
||||
import org.gradle.api.Plugin
|
||||
import org.gradle.api.Project
|
||||
import org.gradle.api.tasks.Copy
|
||||
import org.gradle.kotlin.dsl.configure
|
||||
import org.gradle.kotlin.dsl.get
|
||||
import org.gradle.kotlin.dsl.getValue
|
||||
import org.gradle.kotlin.dsl.getting
|
||||
import org.jetbrains.kotlin.gradle.dsl.KotlinJsProjectExtension
|
||||
|
||||
open class ScientifikJSPlugin : Plugin<Project> {
|
||||
override fun apply(project: Project) {
|
||||
|
||||
with(project) {
|
||||
plugins.apply("org.jetbrains.kotlin.js")
|
||||
|
||||
repositories.applyRepos()
|
||||
|
||||
configure<KotlinJsProjectExtension> {
|
||||
target {
|
||||
browser {
|
||||
webpackTask {
|
||||
outputFileName = "main.bundle.js"
|
||||
}
|
||||
distribution {
|
||||
directory = project.jsDistDirectory
|
||||
}
|
||||
}
|
||||
}
|
||||
sourceSets["main"].apply {
|
||||
languageSettings.applySettings()
|
||||
|
||||
dependencies {
|
||||
api(kotlin("stdlib-js"))
|
||||
}
|
||||
}
|
||||
|
||||
sourceSets["test"].apply {
|
||||
languageSettings.applySettings()
|
||||
dependencies {
|
||||
implementation(kotlin("test-js"))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
tasks.apply {
|
||||
|
||||
val processResources by getting(Copy::class)
|
||||
processResources.copyJSResources(configurations["runtimeClasspath"])
|
||||
|
||||
val browserDistribution by getting {
|
||||
doLast {
|
||||
val indexFile = project.jsDistDirectory.resolve("index.html")
|
||||
if (indexFile.exists()) {
|
||||
println("Run JS distribution at: ${indexFile.canonicalPath}")
|
||||
}
|
||||
}
|
||||
group = "distribution"
|
||||
}
|
||||
|
||||
// findByName("assemble")?.dependsOn(installJsDist)
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
101
src/main/kotlin/scientifik/ScientifikJVMPlugin.kt
Normal file
101
src/main/kotlin/scientifik/ScientifikJVMPlugin.kt
Normal file
@ -0,0 +1,101 @@
|
||||
package scientifik
|
||||
|
||||
import Scientifik
|
||||
import org.gradle.api.Plugin
|
||||
import org.gradle.api.Project
|
||||
import org.gradle.api.plugins.JavaBasePlugin
|
||||
import org.gradle.api.plugins.JavaPluginExtension
|
||||
import org.gradle.api.publish.PublishingExtension
|
||||
import org.gradle.api.publish.maven.MavenPublication
|
||||
import org.gradle.api.tasks.bundling.Jar
|
||||
import org.gradle.api.tasks.testing.Test
|
||||
import org.gradle.kotlin.dsl.*
|
||||
import org.jetbrains.dokka.gradle.DokkaTask
|
||||
import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
|
||||
import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
|
||||
|
||||
open class ScientifikJVMPlugin : Plugin<Project> {
|
||||
override fun apply(project: Project) {
|
||||
with(project) {
|
||||
plugins.apply("org.jetbrains.kotlin.jvm")
|
||||
|
||||
repositories.applyRepos()
|
||||
|
||||
extensions.findByType<JavaPluginExtension>()?.apply {
|
||||
targetCompatibility = Scientifik.JVM_TARGET
|
||||
}
|
||||
|
||||
tasks.withType<KotlinCompile> {
|
||||
kotlinOptions {
|
||||
jvmTarget = Scientifik.JVM_TARGET.toString()
|
||||
}
|
||||
}
|
||||
|
||||
configure<KotlinJvmProjectExtension> {
|
||||
|
||||
val sourceSet = sourceSets["main"].apply {
|
||||
languageSettings.applySettings()
|
||||
dependencies {
|
||||
api(kotlin("stdlib-jdk8"))
|
||||
}
|
||||
}
|
||||
|
||||
sourceSets["test"].apply {
|
||||
languageSettings.applySettings()
|
||||
dependencies {
|
||||
implementation(kotlin("test"))
|
||||
// implementation(kotlin("test-junit"))
|
||||
implementation(kotlin("test-junit5"))
|
||||
implementation("org.junit.jupiter:junit-jupiter:5.6.1")
|
||||
}
|
||||
}
|
||||
|
||||
val sourcesJar by tasks.registering(Jar::class) {
|
||||
archiveClassifier.set("sources")
|
||||
from(sourceSet.kotlin.srcDirs.first())
|
||||
}
|
||||
|
||||
pluginManager.withPlugin("maven-publish") {
|
||||
|
||||
configure<PublishingExtension> {
|
||||
publications {
|
||||
register("jvm", MavenPublication::class) {
|
||||
from(components["java"])
|
||||
artifact(sourcesJar.get())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pluginManager.withPlugin("org.jetbrains.dokka") {
|
||||
logger.info("Adding dokka functionality to project ${this@with.name}")
|
||||
|
||||
val dokka by tasks.getting(DokkaTask::class) {
|
||||
outputFormat = "html"
|
||||
outputDirectory = "$buildDir/javadoc"
|
||||
}
|
||||
|
||||
val kdocJar by tasks.registering(Jar::class) {
|
||||
group = JavaBasePlugin.DOCUMENTATION_GROUP
|
||||
dependsOn(dokka)
|
||||
archiveClassifier.set("javadoc")
|
||||
from("$buildDir/javadoc")
|
||||
}
|
||||
|
||||
configure<PublishingExtension> {
|
||||
publications {
|
||||
getByName("jvm") {
|
||||
this as MavenPublication
|
||||
artifact(kdocJar.get())
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
tasks.withType<Test>(){
|
||||
useJUnitPlatform()
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
140
src/main/kotlin/scientifik/ScientifikMPPlugin.kt
Normal file
140
src/main/kotlin/scientifik/ScientifikMPPlugin.kt
Normal file
@ -0,0 +1,140 @@
|
||||
package scientifik
|
||||
|
||||
import Scientifik
|
||||
import org.gradle.api.Plugin
|
||||
import org.gradle.api.Project
|
||||
import org.gradle.api.plugins.JavaBasePlugin
|
||||
import org.gradle.api.publish.PublishingExtension
|
||||
import org.gradle.api.publish.maven.MavenPublication
|
||||
import org.gradle.api.tasks.Copy
|
||||
import org.gradle.api.tasks.bundling.Jar
|
||||
import org.gradle.api.tasks.testing.Test
|
||||
import org.gradle.kotlin.dsl.*
|
||||
import org.jetbrains.dokka.gradle.DokkaTask
|
||||
import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
|
||||
|
||||
open class ScientifikMPPlugin : Plugin<Project> {
|
||||
override fun apply(project: Project) {
|
||||
project.run {
|
||||
|
||||
plugins.apply("org.jetbrains.kotlin.multiplatform")
|
||||
|
||||
repositories.applyRepos()
|
||||
|
||||
configure<KotlinMultiplatformExtension> {
|
||||
|
||||
jvm {
|
||||
compilations.all {
|
||||
kotlinOptions {
|
||||
jvmTarget = Scientifik.JVM_TARGET.toString()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
val js = js {
|
||||
browser {
|
||||
webpackTask {
|
||||
outputFileName = "main.bundle.js"
|
||||
}
|
||||
distribution {
|
||||
directory = project.jsDistDirectory
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
sourceSets.invoke {
|
||||
val commonMain by getting {
|
||||
dependencies {
|
||||
api(kotlin("stdlib"))
|
||||
}
|
||||
}
|
||||
val commonTest by getting {
|
||||
dependencies {
|
||||
implementation(kotlin("test-common"))
|
||||
implementation(kotlin("test-annotations-common"))
|
||||
}
|
||||
}
|
||||
val jvmMain by getting {
|
||||
dependencies {
|
||||
api(kotlin("stdlib-jdk8"))
|
||||
}
|
||||
}
|
||||
val jvmTest by getting {
|
||||
dependencies {
|
||||
implementation(kotlin("test"))
|
||||
// implementation(kotlin("test-junit"))
|
||||
implementation(kotlin("test-junit5"))
|
||||
implementation("org.junit.jupiter:junit-jupiter:5.6.1")
|
||||
}
|
||||
}
|
||||
val jsMain by getting {
|
||||
dependencies {
|
||||
api(kotlin("stdlib-js"))
|
||||
}
|
||||
}
|
||||
val jsTest by getting {
|
||||
dependencies {
|
||||
implementation(kotlin("test-js"))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
targets.all {
|
||||
sourceSets.all {
|
||||
languageSettings.applySettings()
|
||||
}
|
||||
}
|
||||
|
||||
pluginManager.withPlugin("org.jetbrains.dokka") {
|
||||
logger.info("Adding dokka functionality to project ${this@run.name}")
|
||||
val dokka by tasks.getting(DokkaTask::class) {
|
||||
outputFormat = "html"
|
||||
outputDirectory = "$buildDir/javadoc"
|
||||
multiplatform {
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
val kdocJar by tasks.registering(Jar::class) {
|
||||
group = JavaBasePlugin.DOCUMENTATION_GROUP
|
||||
dependsOn(dokka)
|
||||
archiveClassifier.set("javadoc")
|
||||
from("$buildDir/javadoc")
|
||||
}
|
||||
|
||||
pluginManager.withPlugin("maven-publish") {
|
||||
configure<PublishingExtension> {
|
||||
|
||||
targets.all {
|
||||
val publication = publications.findByName(name) as MavenPublication
|
||||
|
||||
// Patch publications with fake javadoc
|
||||
publication.artifact(kdocJar.get())
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
tasks.apply {
|
||||
val jsProcessResources by getting(Copy::class)
|
||||
jsProcessResources.copyJSResources(configurations["jsRuntimeClasspath"])
|
||||
|
||||
val jsBrowserDistribution by getting {
|
||||
doLast {
|
||||
val indexFile = project.jsDistDirectory.resolve("index.html")
|
||||
if (indexFile.exists()) {
|
||||
println("Run JS distribution at: ${indexFile.canonicalPath}")
|
||||
}
|
||||
}
|
||||
group = "distribution"
|
||||
}
|
||||
|
||||
withType<Test>() {
|
||||
useJUnitPlatform()
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
38
src/main/kotlin/scientifik/ScientifikNativePlugin.kt
Normal file
38
src/main/kotlin/scientifik/ScientifikNativePlugin.kt
Normal file
@ -0,0 +1,38 @@
|
||||
package scientifik
|
||||
|
||||
import org.gradle.api.Plugin
|
||||
import org.gradle.api.Project
|
||||
import org.gradle.kotlin.dsl.*
|
||||
import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
|
||||
|
||||
class ScientifikNativePlugin : Plugin<Project> {
|
||||
override fun apply(target: Project) {
|
||||
target.pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
|
||||
target.configure<KotlinMultiplatformExtension> {
|
||||
linuxX64()
|
||||
mingwX64()
|
||||
|
||||
sourceSets.apply {
|
||||
val commonMain by getting {}
|
||||
|
||||
val native by creating {
|
||||
dependsOn(commonMain)
|
||||
|
||||
dependencies {
|
||||
api(kotlin("native"))
|
||||
//TODO add stdlib here
|
||||
}
|
||||
}
|
||||
|
||||
mingwX64().compilations["main"].defaultSourceSet {
|
||||
dependsOn(native)
|
||||
}
|
||||
|
||||
linuxX64().compilations["main"].defaultSourceSet {
|
||||
dependsOn(native)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
112
src/main/kotlin/scientifik/ScientifikPublishPlugin.kt
Normal file
112
src/main/kotlin/scientifik/ScientifikPublishPlugin.kt
Normal file
@ -0,0 +1,112 @@
|
||||
package scientifik
|
||||
|
||||
import org.gradle.api.Plugin
|
||||
import org.gradle.api.Project
|
||||
import org.gradle.api.publish.PublishingExtension
|
||||
import org.gradle.api.publish.maven.MavenPublication
|
||||
import org.gradle.kotlin.dsl.configure
|
||||
import org.gradle.kotlin.dsl.provideDelegate
|
||||
import org.gradle.kotlin.dsl.withType
|
||||
|
||||
|
||||
open class ScientifikPublishPlugin : Plugin<Project> {
|
||||
|
||||
override fun apply(project: Project) {
|
||||
|
||||
project.plugins.apply("maven-publish")
|
||||
|
||||
project.run {
|
||||
val githubProject = findProperty("githubProject") as? String
|
||||
val vcs = findProperty("vcs") as? String
|
||||
?: githubProject?.let { "https://github.com/mipt-npm/$it" }
|
||||
|
||||
if (vcs == null) {
|
||||
project.logger.warn("[${project.name}] Missing deployment configuration. Skipping publish.")
|
||||
return@apply
|
||||
}
|
||||
|
||||
project.configure<PublishingExtension> {
|
||||
// Process each publication we have in this project
|
||||
publications.withType<MavenPublication>().forEach { publication ->
|
||||
@Suppress("UnstableApiUsage")
|
||||
publication.pom {
|
||||
name.set(project.name)
|
||||
description.set(project.description)
|
||||
url.set(vcs)
|
||||
|
||||
licenses {
|
||||
license {
|
||||
name.set("The Apache Software License, Version 2.0")
|
||||
url.set("http://www.apache.org/licenses/LICENSE-2.0.txt")
|
||||
distribution.set("repo")
|
||||
}
|
||||
}
|
||||
developers {
|
||||
developer {
|
||||
id.set("MIPT-NPM")
|
||||
name.set("MIPT nuclear physics methods laboratory")
|
||||
organization.set("MIPT")
|
||||
organizationUrl.set("http://npm.mipt.ru")
|
||||
}
|
||||
|
||||
}
|
||||
scm {
|
||||
url.set(vcs)
|
||||
tag.set(project.version.toString())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
val githubUser: String? by project
|
||||
val githubToken: String? by project
|
||||
|
||||
if (githubProject != null && githubUser != null && githubToken != null) {
|
||||
project.logger.info("Adding github publishing to project [${project.name}]")
|
||||
repositories {
|
||||
maven {
|
||||
name = "github"
|
||||
url = uri("https://maven.pkg.github.com/mipt-npm/$githubProject/")
|
||||
credentials {
|
||||
username = githubUser
|
||||
password = githubToken
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
val bintrayOrg = project.findProperty("bintrayOrg") as? String ?: "mipt-npm"
|
||||
val bintrayUser = project.findProperty("bintrayUser") as? String
|
||||
val bintrayKey = project.findProperty("bintrayApiKey") as? String
|
||||
|
||||
|
||||
val bintrayRepo = if (project.version.toString().contains("dev")) {
|
||||
"dev"
|
||||
} else {
|
||||
findProperty("bintrayRepo") as? String
|
||||
}
|
||||
|
||||
val projectName = project.name
|
||||
|
||||
if (bintrayRepo != null && bintrayUser != null && bintrayKey != null) {
|
||||
project.logger.info("Adding bintray publishing to project [$projectName]")
|
||||
|
||||
repositories {
|
||||
maven {
|
||||
name = "bintray"
|
||||
url = uri(
|
||||
"https://api.bintray.com/maven/$bintrayOrg/$bintrayRepo/$projectName/;publish=0;override=1"
|
||||
)
|
||||
credentials {
|
||||
username = bintrayUser
|
||||
password = bintrayKey
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
73
src/main/kotlin/scientifik/common.kt
Normal file
73
src/main/kotlin/scientifik/common.kt
Normal file
@ -0,0 +1,73 @@
|
||||
package scientifik
|
||||
|
||||
import org.gradle.api.Project
|
||||
import org.gradle.api.artifacts.Configuration
|
||||
import org.gradle.api.artifacts.ProjectDependency
|
||||
import org.gradle.api.artifacts.dsl.RepositoryHandler
|
||||
import org.gradle.api.tasks.Copy
|
||||
import org.gradle.kotlin.dsl.maven
|
||||
import org.jetbrains.kotlin.gradle.plugin.LanguageSettingsBuilder
|
||||
import java.io.File
|
||||
|
||||
internal fun LanguageSettingsBuilder.applySettings(): Unit {
|
||||
progressiveMode = true
|
||||
enableLanguageFeature("InlineClasses")
|
||||
useExperimentalAnnotation("kotlin.Experimental")
|
||||
useExperimentalAnnotation("kotlin.ExperimentalUnsignedTypes")
|
||||
useExperimentalAnnotation("kotlin.ExperimentalStdlibApi")
|
||||
useExperimentalAnnotation("kotlin.time.ExperimentalTime")
|
||||
}
|
||||
|
||||
internal fun RepositoryHandler.applyRepos(): Unit {
|
||||
mavenCentral()
|
||||
jcenter()
|
||||
maven("https://dl.bintray.com/kotlin/kotlin-eap")
|
||||
maven("https://kotlin.bintray.com/kotlinx")
|
||||
maven("https://dl.bintray.com/mipt-npm/scientifik")
|
||||
maven("https://dl.bintray.com/mipt-npm/dev")
|
||||
maven("https://kotlin.bintray.com/kotlin-js-wrappers/")
|
||||
maven("https://dl.bintray.com/mipt-npm/dataforge")
|
||||
}
|
||||
|
||||
|
||||
internal fun Copy.copyJSResources(configuration: Configuration): Unit = project.afterEvaluate {
|
||||
val projectDeps = configuration
|
||||
.allDependencies
|
||||
.filterIsInstance<ProjectDependency>()
|
||||
.map { it.dependencyProject }
|
||||
|
||||
val destination = destinationDir
|
||||
|
||||
projectDeps.forEach { dep ->
|
||||
dep.pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
|
||||
dep.tasks.findByName("jsProcessResources")?.let { task ->
|
||||
val sourceDir = (task as Copy).destinationDir
|
||||
inputs.files(sourceDir)
|
||||
dependsOn(task)
|
||||
from(sourceDir)
|
||||
}
|
||||
}
|
||||
dep.pluginManager.withPlugin("org.jetbrains.kotlin.js") {
|
||||
dep.tasks.findByName("processResources")?.let { task ->
|
||||
val sourceDir = (task as Copy).destinationDir
|
||||
inputs.files(sourceDir)
|
||||
dependsOn(task)
|
||||
from(sourceDir)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
val Project.jsDistDirectory: File
|
||||
get() {
|
||||
val distributionName = listOf(
|
||||
name,
|
||||
"js",
|
||||
version.toString()
|
||||
).joinToString("-")
|
||||
|
||||
return buildDir.resolve(
|
||||
"distributions/$distributionName"
|
||||
)
|
||||
}
|
||||
97
src/main/kotlin/scientifik/extensions.kt
Normal file
97
src/main/kotlin/scientifik/extensions.kt
Normal file
@ -0,0 +1,97 @@
|
||||
package scientifik
|
||||
|
||||
import Scientifik
|
||||
import kotlinx.atomicfu.plugin.gradle.sourceSets
|
||||
import org.gradle.api.Project
|
||||
import org.gradle.kotlin.dsl.findByType
|
||||
import org.gradle.kotlin.dsl.invoke
|
||||
import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
|
||||
|
||||
enum class DependencyConfiguration {
|
||||
API,
|
||||
IMPLEMENTATION,
|
||||
COMPILE_ONLY
|
||||
}
|
||||
|
||||
enum class DependencySourceSet(val setName: String, val suffix: String) {
|
||||
MAIN("main", "Main"),
|
||||
TEST("test", "Test")
|
||||
}
|
||||
|
||||
internal fun Project.useDependency(
|
||||
vararg pairs: Pair<String, String>,
|
||||
dependencySourceSet: DependencySourceSet = DependencySourceSet.MAIN,
|
||||
dependencyConfiguration: DependencyConfiguration = DependencyConfiguration.API
|
||||
) {
|
||||
pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
|
||||
extensions.findByType<KotlinMultiplatformExtension>()?.apply {
|
||||
sourceSets {
|
||||
pairs.forEach { (target, dep) ->
|
||||
val name = target + dependencySourceSet.suffix
|
||||
findByName(name)?.apply {
|
||||
dependencies {
|
||||
when (dependencyConfiguration) {
|
||||
DependencyConfiguration.API -> api(dep)
|
||||
DependencyConfiguration.IMPLEMENTATION -> implementation(dep)
|
||||
DependencyConfiguration.COMPILE_ONLY-> compileOnly(dep)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pairs.find { it.first == "jvm" }?.let { dep ->
|
||||
pluginManager.withPlugin("org.jetbrains.kotlin.jvm") {
|
||||
sourceSets.findByName(dependencySourceSet.setName)?.apply {
|
||||
dependencies.apply {
|
||||
val configurationName = when (dependencyConfiguration) {
|
||||
DependencyConfiguration.API -> apiConfigurationName
|
||||
DependencyConfiguration.IMPLEMENTATION -> implementationConfigurationName
|
||||
DependencyConfiguration.COMPILE_ONLY-> compileOnlyConfigurationName
|
||||
}
|
||||
add(configurationName, dep.second)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pairs.find { it.first == "js" }?.let { dep ->
|
||||
pluginManager.withPlugin("org.jetbrains.kotlin.js") {
|
||||
sourceSets.findByName(dependencySourceSet.setName)?.apply {
|
||||
dependencies.apply {
|
||||
val configurationName = when (dependencyConfiguration) {
|
||||
DependencyConfiguration.API -> apiConfigurationName
|
||||
DependencyConfiguration.IMPLEMENTATION -> implementationConfigurationName
|
||||
DependencyConfiguration.COMPILE_ONLY-> compileOnlyConfigurationName
|
||||
}
|
||||
add(configurationName, dep.second)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun Project.useCoroutines(
|
||||
version: String = Scientifik.coroutinesVersion,
|
||||
sourceSet: DependencySourceSet = DependencySourceSet.MAIN,
|
||||
configuration: DependencyConfiguration = DependencyConfiguration.API
|
||||
) = useDependency(
|
||||
"common" to "org.jetbrains.kotlinx:kotlinx-coroutines-core-common:$version",
|
||||
"jvm" to "org.jetbrains.kotlinx:kotlinx-coroutines-core:$version",
|
||||
"js" to "org.jetbrains.kotlinx:kotlinx-coroutines-core-js:$version",
|
||||
"native" to "org.jetbrains.kotlinx:kotlinx-coroutines-core-native:$version",
|
||||
dependencySourceSet = sourceSet,
|
||||
dependencyConfiguration = configuration
|
||||
)
|
||||
|
||||
//fun Project.atomic(version: String = Scientifik.atomicfuVersion) {
|
||||
// plugins.apply("kotlinx-atomicfu")
|
||||
// useDependency(
|
||||
// "commonMain" to "org.jetbrains.kotlinx:atomicfu-common:$version",
|
||||
// "jvmMain" to "org.jetbrains.kotlinx:atomicfu:$version",
|
||||
// "jsMain" to "org.jetbrains.kotlinx:atomicfu-js:$version",
|
||||
// "nativeMain" to "org.jetbrains.kotlinx:atomicfu-native:$version"
|
||||
// )
|
||||
//}
|
||||
74
src/main/kotlin/scientifik/fx.kt
Normal file
74
src/main/kotlin/scientifik/fx.kt
Normal file
@ -0,0 +1,74 @@
|
||||
package scientifik
|
||||
|
||||
import org.apache.tools.ant.taskdefs.condition.Os
|
||||
import org.gradle.api.Project
|
||||
import org.gradle.kotlin.dsl.findByType
|
||||
import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
|
||||
import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
|
||||
import org.jetbrains.kotlin.gradle.plugin.KotlinDependencyHandler
|
||||
|
||||
enum class FXModule(val artifact: String, vararg val dependencies: FXModule) {
|
||||
BASE("javafx-base"),
|
||||
GRAPHICS("javafx-graphics", BASE),
|
||||
CONTROLS("javafx-controls", GRAPHICS, BASE),
|
||||
FXML("javafx-fxml", BASE),
|
||||
MEDIA("javafx-media", GRAPHICS, BASE),
|
||||
SWING("javafx-swing", GRAPHICS, BASE),
|
||||
WEB("javafx-web", CONTROLS, GRAPHICS, BASE)
|
||||
}
|
||||
|
||||
enum class FXPlatform(val id: String) {
|
||||
WINDOWS("win"),
|
||||
LINUX("linux"),
|
||||
MAC("mac")
|
||||
}
|
||||
|
||||
val defaultPlatform: FXPlatform = when {
|
||||
Os.isFamily(Os.FAMILY_WINDOWS) -> FXPlatform.WINDOWS
|
||||
Os.isFamily(Os.FAMILY_MAC) -> FXPlatform.MAC
|
||||
Os.isFamily(Os.FAMILY_UNIX) -> FXPlatform.LINUX
|
||||
else -> error("Platform not recognized")
|
||||
}
|
||||
|
||||
fun KotlinDependencyHandler.addFXDependencies(
|
||||
vararg modules: FXModule,
|
||||
configuration: DependencyConfiguration,
|
||||
version: String = "14",
|
||||
platform: FXPlatform = defaultPlatform
|
||||
) {
|
||||
modules.flatMap { it.dependencies.toList() + it }.distinct().forEach {
|
||||
val notation = "org.openjfx:${it.artifact}:$version:${platform.id}"
|
||||
when (configuration) {
|
||||
DependencyConfiguration.API -> api(notation)
|
||||
DependencyConfiguration.IMPLEMENTATION -> implementation(notation)
|
||||
DependencyConfiguration.COMPILE_ONLY -> compileOnly(notation)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun Project.useFx(
|
||||
vararg modules: FXModule,
|
||||
configuration: DependencyConfiguration = DependencyConfiguration.COMPILE_ONLY,
|
||||
version: String = "14",
|
||||
platform: FXPlatform = defaultPlatform
|
||||
): Unit = afterEvaluate{
|
||||
pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
|
||||
extensions.findByType<KotlinMultiplatformExtension>()?.apply {
|
||||
sourceSets.findByName("jvmMain")?.apply {
|
||||
dependencies {
|
||||
addFXDependencies(*modules, configuration = configuration, version = version, platform = platform)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pluginManager.withPlugin("org.jetbrains.kotlin.jvm") {
|
||||
extensions.findByType<KotlinJvmProjectExtension>()?.apply {
|
||||
sourceSets.findByName("main")?.apply {
|
||||
dependencies {
|
||||
addFXDependencies(*modules, configuration = configuration, version = version, platform = platform)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
89
src/main/kotlin/scientifik/serialization.kt
Normal file
89
src/main/kotlin/scientifik/serialization.kt
Normal file
@ -0,0 +1,89 @@
|
||||
package scientifik
|
||||
|
||||
import Scientifik
|
||||
import org.gradle.api.Project
|
||||
import org.gradle.kotlin.dsl.maven
|
||||
import org.gradle.kotlin.dsl.repositories
|
||||
|
||||
class SerializationTargets(
|
||||
val sourceSet: DependencySourceSet,
|
||||
val configuration: DependencyConfiguration
|
||||
) {
|
||||
fun Project.cbor(
|
||||
version: String = Scientifik.serializationVersion
|
||||
) {
|
||||
useDependency(
|
||||
"common" to "org.jetbrains.kotlinx:kotlinx-serialization-cbor-common:$version",
|
||||
"jvm" to "org.jetbrains.kotlinx:kotlinx-serialization-cbor:$version",
|
||||
"js" to "org.jetbrains.kotlinx:kotlinx-serialization-cbor-js:$version",
|
||||
"native" to "org.jetbrains.kotlinx:kotlinx-serialization-cbor-native:$version",
|
||||
dependencySourceSet = sourceSet,
|
||||
dependencyConfiguration = configuration
|
||||
)
|
||||
}
|
||||
|
||||
fun Project.protobuf(
|
||||
version: String = Scientifik.serializationVersion
|
||||
) {
|
||||
useDependency(
|
||||
"common" to "org.jetbrains.kotlinx:kotlinx-serialization-protobuf-common:$version",
|
||||
"jvm" to "org.jetbrains.kotlinx:kotlinx-serialization-protobuf:$version",
|
||||
"js" to "org.jetbrains.kotlinx:kotlinx-serialization-protobuf-js:$version",
|
||||
"native" to "org.jetbrains.kotlinx:kotlinx-serialization-protobuf-native:$version",
|
||||
dependencySourceSet = sourceSet,
|
||||
dependencyConfiguration = configuration
|
||||
)
|
||||
}
|
||||
|
||||
fun Project.xml(
|
||||
version: String = Scientifik.Serialization.xmlVersion
|
||||
) {
|
||||
repositories {
|
||||
maven("https://dl.bintray.com/pdvrieze/maven")
|
||||
}
|
||||
useDependency(
|
||||
"common" to "net.devrieze:xmlutil-serialization:$version",
|
||||
"jvm" to "net.devrieze:xmlutil-serialization:$version",
|
||||
"js" to "net.devrieze:xmlutil-serialization:$version",
|
||||
dependencySourceSet = sourceSet,
|
||||
dependencyConfiguration = configuration
|
||||
)
|
||||
}
|
||||
|
||||
fun Project.yaml(
|
||||
version: String = Scientifik.Serialization.yamlVersion
|
||||
) {
|
||||
useDependency(
|
||||
"jvm" to "com.charleskorn.kaml:kaml:$version",
|
||||
dependencySourceSet = sourceSet,
|
||||
dependencyConfiguration = configuration
|
||||
)
|
||||
}
|
||||
|
||||
fun Project.bson(
|
||||
version: String = Scientifik.Serialization.bsonVersion
|
||||
) {
|
||||
useDependency(
|
||||
"jvm" to "com.github.jershell:kbson:$version",
|
||||
dependencySourceSet = sourceSet,
|
||||
dependencyConfiguration = configuration
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
fun Project.useSerialization(
|
||||
version: String = Scientifik.serializationVersion,
|
||||
sourceSet: DependencySourceSet = DependencySourceSet.MAIN,
|
||||
configuration: DependencyConfiguration = DependencyConfiguration.API,
|
||||
block: SerializationTargets.() -> Unit = {}
|
||||
) {
|
||||
plugins.apply("org.jetbrains.kotlin.plugin.serialization")
|
||||
useDependency(
|
||||
"common" to "org.jetbrains.kotlinx:kotlinx-serialization-runtime-common:$version",
|
||||
"jvm" to "org.jetbrains.kotlinx:kotlinx-serialization-runtime:$version",
|
||||
"js" to "org.jetbrains.kotlinx:kotlinx-serialization-runtime-js:$version",
|
||||
"native" to "org.jetbrains.kotlinx:kotlinx-serialization-runtime-native:$version",
|
||||
dependencySourceSet = sourceSet
|
||||
)
|
||||
SerializationTargets(sourceSet, configuration).apply(block)
|
||||
}
|
||||
@ -1,547 +0,0 @@
|
||||
package space.kscience.gradle
|
||||
|
||||
import org.gradle.api.Project
|
||||
import org.gradle.api.file.DuplicatesStrategy
|
||||
import org.gradle.api.plugins.ApplicationPlugin
|
||||
import org.gradle.api.plugins.ExtensionAware
|
||||
import org.gradle.api.provider.Property
|
||||
import org.gradle.api.tasks.Copy
|
||||
import org.gradle.api.tasks.testing.Test
|
||||
import org.gradle.jvm.toolchain.JavaLanguageVersion
|
||||
import org.gradle.kotlin.dsl.*
|
||||
import org.gradle.language.jvm.tasks.ProcessResources
|
||||
import org.jetbrains.kotlin.gradle.ExperimentalKotlinGradlePluginApi
|
||||
import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
|
||||
import org.jetbrains.kotlin.gradle.dsl.KotlinJsProjectExtension
|
||||
import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
|
||||
import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
|
||||
import org.jetbrains.kotlin.gradle.dsl.KotlinProjectExtension
|
||||
import org.jetbrains.kotlin.gradle.plugin.KotlinCompilation
|
||||
import org.jetbrains.kotlin.gradle.plugin.KotlinDependencyHandler
|
||||
import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget
|
||||
import org.jetbrains.kotlin.gradle.targets.js.dsl.KotlinJsBrowserDsl
|
||||
import org.jetbrains.kotlin.gradle.targets.js.dsl.KotlinJsTargetDsl
|
||||
import org.jetbrains.kotlin.gradle.targets.js.dsl.KotlinWasmJsTargetDsl
|
||||
import org.jetbrains.kotlin.gradle.targets.jvm.KotlinJvmTarget
|
||||
import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
|
||||
import org.jetbrains.kotlinx.jupyter.api.plugin.tasks.JupyterApiResourcesTask
|
||||
import space.kscience.gradle.internal.defaultKotlinJvmArgs
|
||||
import space.kscience.gradle.internal.fromJsDependencies
|
||||
import space.kscience.gradle.internal.requestPropertyOrNull
|
||||
import space.kscience.gradle.internal.useCommonDependency
|
||||
import javax.inject.Inject
|
||||
|
||||
public enum class DependencyConfiguration {
|
||||
API,
|
||||
IMPLEMENTATION,
|
||||
COMPILE_ONLY,
|
||||
}
|
||||
|
||||
public enum class DependencySourceSet(public val setName: String, public val suffix: String) {
|
||||
MAIN("main", "Main"),
|
||||
TEST("test", "Test")
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Check if this project version has a development tag (`development` property to true, "dev" in the middle or "SNAPSHOT" in the end).
|
||||
*/
|
||||
public val Project.isInDevelopment: Boolean
|
||||
get() = findProperty("development") == true
|
||||
|| "dev" in version.toString()
|
||||
|| version.toString().endsWith("SNAPSHOT")
|
||||
|
||||
|
||||
private const val defaultJdkVersion = 17
|
||||
|
||||
public abstract class KScienceExtension @Inject constructor(public val project: Project): ExtensionAware {
|
||||
|
||||
public val jdkVersionProperty: Property<Int> = project.objects.property<Int>().apply {
|
||||
set(defaultJdkVersion)
|
||||
}
|
||||
|
||||
public var jdkVersion: Int by jdkVersionProperty
|
||||
|
||||
/**
|
||||
* Use coroutines-core with default version or [version]
|
||||
*/
|
||||
public fun useCoroutines(
|
||||
version: String = KScienceVersions.coroutinesVersion,
|
||||
sourceSet: DependencySourceSet = DependencySourceSet.MAIN,
|
||||
configuration: DependencyConfiguration = DependencyConfiguration.API,
|
||||
) {
|
||||
project.useCommonDependency(
|
||||
"org.jetbrains.kotlinx:kotlinx-coroutines-core:$version",
|
||||
dependencySourceSet = sourceSet,
|
||||
dependencyConfiguration = configuration
|
||||
)
|
||||
project.useCommonDependency(
|
||||
"org.jetbrains.kotlinx:kotlinx-coroutines-test:$version",
|
||||
dependencySourceSet = DependencySourceSet.TEST,
|
||||
dependencyConfiguration = DependencyConfiguration.IMPLEMENTATION
|
||||
)
|
||||
}
|
||||
|
||||
/**
|
||||
* Use core serialization library and configure targets
|
||||
*/
|
||||
public fun useSerialization(
|
||||
version: String = KScienceVersions.serializationVersion,
|
||||
sourceSet: DependencySourceSet = DependencySourceSet.MAIN,
|
||||
configuration: DependencyConfiguration = DependencyConfiguration.API,
|
||||
block: SerializationTargets.() -> Unit = {},
|
||||
): Unit = project.run {
|
||||
plugins.apply("org.jetbrains.kotlin.plugin.serialization")
|
||||
val artifactName = if (version.startsWith("0")) {
|
||||
"kotlinx-serialization-runtime"
|
||||
} else {
|
||||
"kotlinx-serialization-core"
|
||||
}
|
||||
useCommonDependency(
|
||||
"org.jetbrains.kotlinx:$artifactName:$version",
|
||||
dependencySourceSet = sourceSet,
|
||||
dependencyConfiguration = configuration
|
||||
)
|
||||
SerializationTargets(sourceSet, configuration).block()
|
||||
}
|
||||
|
||||
public fun useKtor(version: String = KScienceVersions.ktorVersion): Unit = with(project) {
|
||||
pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
|
||||
configure<KotlinMultiplatformExtension> {
|
||||
sourceSets.findByName("commonMain")?.apply {
|
||||
dependencies {
|
||||
api(project.dependencies.platform("io.ktor:ktor-bom:$version"))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
pluginManager.withPlugin("org.jetbrains.kotlin.jvm") {
|
||||
configure<KotlinJvmProjectExtension> {
|
||||
sourceSets.findByName("main")?.apply {
|
||||
dependencies {
|
||||
api(project.dependencies.platform("io.ktor:ktor-bom:$version"))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
pluginManager.withPlugin("org.jetbrains.kotlin.js") {
|
||||
configure<KotlinJsProjectExtension> {
|
||||
sourceSets.findByName("main")?.apply {
|
||||
dependencies {
|
||||
api(project.dependencies.platform("io.ktor:ktor-bom:$version"))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Apply jupyter plugin and add entry point for the jupyter library.
|
||||
* If left empty applies a plugin without declaring library producers
|
||||
*/
|
||||
public fun jupyterLibrary(vararg pluginClasses: String) {
|
||||
project.plugins.apply("org.jetbrains.kotlin.jupyter.api")
|
||||
project.tasks.named("processJupyterApiResources", JupyterApiResourcesTask::class.java) {
|
||||
libraryProducers = pluginClasses.toList()
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Apply common dependencies for different kind of targets
|
||||
*/
|
||||
public fun dependencies(sourceSet: String? = null, dependencyBlock: KotlinDependencyHandler.() -> Unit) {
|
||||
project.pluginManager.withPlugin("org.jetbrains.kotlin.jvm") {
|
||||
project.configure<KotlinJvmProjectExtension> {
|
||||
sourceSets.getByName(sourceSet ?: "main") {
|
||||
dependencies(dependencyBlock)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
project.pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
|
||||
project.configure<KotlinMultiplatformExtension> {
|
||||
sourceSets.getByName(sourceSet ?: "commonMain") {
|
||||
dependencies(dependencyBlock)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public fun testDependencies(sourceSet: String? = null, dependencyBlock: KotlinDependencyHandler.() -> Unit) {
|
||||
project.pluginManager.withPlugin("org.jetbrains.kotlin.jvm") {
|
||||
project.configure<KotlinJvmProjectExtension> {
|
||||
sourceSets.getByName(sourceSet ?: "test") {
|
||||
dependencies(dependencyBlock)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
project.pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
|
||||
project.configure<KotlinMultiplatformExtension> {
|
||||
sourceSets.getByName(sourceSet ?: "commonTest") {
|
||||
dependencies(dependencyBlock)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public class DefaultSourceSet(public val key: String)
|
||||
|
||||
public fun dependencies(
|
||||
defaultSourceSet: DefaultSourceSet,
|
||||
dependencyBlock: KotlinDependencyHandler.() -> Unit,
|
||||
): Unit = dependencies(defaultSourceSet.key, dependencyBlock)
|
||||
|
||||
|
||||
/**
|
||||
* Mark this module as an application module. JVM application should be enabled separately
|
||||
*/
|
||||
@Deprecated("Use platform-specific applications")
|
||||
public fun application() {
|
||||
project.extensions.findByType<KotlinProjectExtension>()?.apply {
|
||||
explicitApi = null
|
||||
}
|
||||
|
||||
project.pluginManager.withPlugin("org.jetbrains.kotlin.jvm") {
|
||||
project.apply<ApplicationPlugin>()
|
||||
}
|
||||
|
||||
project.extensions.findByType<KotlinJsProjectExtension>()?.apply {
|
||||
js(IR) {
|
||||
binaries.executable()
|
||||
}
|
||||
}
|
||||
|
||||
project.extensions.findByType<KotlinMultiplatformExtension>()?.apply {
|
||||
targets.withType<KotlinJsTargetDsl> {
|
||||
binaries.executable()
|
||||
}
|
||||
|
||||
targets.withType<KotlinNativeTarget> {
|
||||
binaries.executable()
|
||||
}
|
||||
|
||||
targets.withType<KotlinWasmJsTargetDsl> {
|
||||
binaries.executable()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Add context receivers to this project and all subprojects
|
||||
*/
|
||||
public fun useContextReceivers() {
|
||||
project.tasks.withType<KotlinCompile> {
|
||||
compilerOptions{
|
||||
freeCompilerArgs.add("-Xcontext-receivers")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public operator fun DefaultSourceSet.invoke(dependencyBlock: KotlinDependencyHandler.() -> Unit) {
|
||||
dependencies(this, dependencyBlock)
|
||||
}
|
||||
|
||||
public val commonMain: DefaultSourceSet get() = DefaultSourceSet("commonMain")
|
||||
public val commonTest: DefaultSourceSet get() = DefaultSourceSet("commonTest")
|
||||
|
||||
public val jvmMain: DefaultSourceSet get() = DefaultSourceSet("jvmMain")
|
||||
public val jvmTest: DefaultSourceSet get() = DefaultSourceSet("jvmTest")
|
||||
public val jsMain: DefaultSourceSet get() = DefaultSourceSet("jsMain")
|
||||
public val jsTest: DefaultSourceSet get() = DefaultSourceSet("jsTest")
|
||||
public val nativeMain: DefaultSourceSet get() = DefaultSourceSet("nativeMain")
|
||||
public val nativeTest: DefaultSourceSet get() = DefaultSourceSet("nativeTest")
|
||||
public val wasmJsMain: DefaultSourceSet get() = DefaultSourceSet("wasmJsMain")
|
||||
public val wasmJsTest: DefaultSourceSet get() = DefaultSourceSet("wasmJsTest")
|
||||
|
||||
}
|
||||
|
||||
public enum class KotlinNativePreset {
|
||||
linuxX64,
|
||||
mingwX64,
|
||||
macosX64,
|
||||
macosArm64,
|
||||
iosX64,
|
||||
iosArm64,
|
||||
iosSimulatorArm64,
|
||||
}
|
||||
|
||||
public data class KScienceNativeTarget(
|
||||
val preset: KotlinNativePreset,
|
||||
val targetName: String = preset.name,
|
||||
val targetConfiguration: KotlinNativeTarget.() -> Unit = { },
|
||||
) {
|
||||
public companion object {
|
||||
public val linuxX64: KScienceNativeTarget = KScienceNativeTarget(KotlinNativePreset.linuxX64)
|
||||
public val mingwX64: KScienceNativeTarget = KScienceNativeTarget(KotlinNativePreset.mingwX64)
|
||||
public val macosX64: KScienceNativeTarget = KScienceNativeTarget(KotlinNativePreset.macosX64)
|
||||
public val macosArm64: KScienceNativeTarget = KScienceNativeTarget(KotlinNativePreset.macosArm64)
|
||||
public val iosX64: KScienceNativeTarget = KScienceNativeTarget(KotlinNativePreset.iosX64)
|
||||
public val iosArm64: KScienceNativeTarget = KScienceNativeTarget(KotlinNativePreset.iosArm64)
|
||||
public val iosSimulatorArm64: KScienceNativeTarget = KScienceNativeTarget(KotlinNativePreset.iosSimulatorArm64)
|
||||
}
|
||||
}
|
||||
|
||||
public class KScienceNativeConfiguration(private val project: Project) {
|
||||
|
||||
|
||||
internal companion object {
|
||||
private fun defaultNativeTargets(project: Project): Map<KotlinNativePreset, KScienceNativeTarget> {
|
||||
val hostOs = System.getProperty("os.name")
|
||||
|
||||
val targets = project.requestPropertyOrNull("publishing.targets")
|
||||
|
||||
return when {
|
||||
targets == "all" -> listOf(
|
||||
KScienceNativeTarget.linuxX64,
|
||||
KScienceNativeTarget.mingwX64,
|
||||
KScienceNativeTarget.macosX64,
|
||||
KScienceNativeTarget.macosArm64,
|
||||
KScienceNativeTarget.iosX64,
|
||||
KScienceNativeTarget.iosArm64,
|
||||
KScienceNativeTarget.iosSimulatorArm64,
|
||||
)
|
||||
|
||||
targets != null -> {
|
||||
targets.split(",").map { KScienceNativeTarget(KotlinNativePreset.valueOf(it)) }
|
||||
}
|
||||
|
||||
hostOs.startsWith("Windows") -> listOf(
|
||||
KScienceNativeTarget.linuxX64,
|
||||
KScienceNativeTarget.mingwX64
|
||||
)
|
||||
|
||||
hostOs == "Mac OS X" -> listOf(
|
||||
KScienceNativeTarget.macosX64,
|
||||
KScienceNativeTarget.macosArm64,
|
||||
KScienceNativeTarget.iosX64,
|
||||
KScienceNativeTarget.iosArm64,
|
||||
KScienceNativeTarget.iosSimulatorArm64,
|
||||
)
|
||||
|
||||
hostOs == "Linux" -> listOf(KScienceNativeTarget.linuxX64)
|
||||
|
||||
else -> {
|
||||
emptyList()
|
||||
}
|
||||
}.associateBy { it.preset }
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
internal var targets: Map<KotlinNativePreset, KScienceNativeTarget> = defaultNativeTargets(project)
|
||||
|
||||
|
||||
/**
|
||||
* Replace all targets
|
||||
*/
|
||||
public fun setTargets(vararg target: KScienceNativeTarget) {
|
||||
targets = target.associateBy { it.preset }
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a native target
|
||||
*/
|
||||
public fun target(target: KScienceNativeTarget) {
|
||||
targets += target.preset to target
|
||||
}
|
||||
|
||||
public fun target(
|
||||
preset: KotlinNativePreset,
|
||||
targetName: String = preset.name,
|
||||
targetConfiguration: KotlinNativeTarget.() -> Unit = { },
|
||||
): Unit = target(KScienceNativeTarget(preset, targetName, targetConfiguration))
|
||||
}
|
||||
|
||||
public abstract class KScienceMppExtension @Inject constructor(project: Project) : KScienceExtension(project) {
|
||||
|
||||
/**
|
||||
* Enable jvm target
|
||||
*/
|
||||
public fun jvm(block: KotlinJvmTarget.() -> Unit = {}) {
|
||||
project.pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
|
||||
project.configure<KotlinMultiplatformExtension> {
|
||||
jvm {
|
||||
@OptIn(ExperimentalKotlinGradlePluginApi::class)
|
||||
compilerOptions{
|
||||
freeCompilerArgs.addAll(defaultKotlinJvmArgs)
|
||||
}
|
||||
block()
|
||||
}
|
||||
sourceSets {
|
||||
getByName("jvmTest") {
|
||||
dependencies {
|
||||
implementation(kotlin("test-junit5"))
|
||||
implementation("org.junit.jupiter:junit-jupiter:${KScienceVersions.junit}")
|
||||
}
|
||||
}
|
||||
}
|
||||
jvmToolchain {
|
||||
languageVersion.set(jdkVersionProperty.map { JavaLanguageVersion.of(it) })
|
||||
}
|
||||
}
|
||||
project.tasks.withType<Test> {
|
||||
useJUnitPlatform()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Enable JS-IR (browser) target.
|
||||
*/
|
||||
public fun js(block: KotlinJsTargetDsl.() -> Unit = {}) {
|
||||
project.pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
|
||||
project.configure<KotlinMultiplatformExtension> {
|
||||
js(IR) {
|
||||
browser()
|
||||
useEsModules()
|
||||
block()
|
||||
}
|
||||
sourceSets {
|
||||
getByName("jsTest") {
|
||||
dependencies {
|
||||
implementation(kotlin("test-js"))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
(project.tasks.findByName("jsProcessResources") as? Copy)?.apply {
|
||||
fromJsDependencies("jsRuntimeClasspath")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Add Wasm/Js target
|
||||
*/
|
||||
@OptIn(ExperimentalWasmDsl::class)
|
||||
public fun wasm(block: KotlinWasmJsTargetDsl.() -> Unit = {}) {
|
||||
|
||||
project.pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
|
||||
project.configure<KotlinMultiplatformExtension> {
|
||||
wasmJs {
|
||||
browser {
|
||||
testTask {
|
||||
useKarma {
|
||||
useChromeHeadless()
|
||||
}
|
||||
}
|
||||
}
|
||||
block()
|
||||
}
|
||||
sourceSets {
|
||||
getByName("wasmJsTest") {
|
||||
dependencies {
|
||||
implementation(kotlin("test-wasm-js"))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public fun jvmAndJs() {
|
||||
jvm()
|
||||
js()
|
||||
}
|
||||
|
||||
/**
|
||||
* Jvm and Js source sets including copy of Js bundle into JVM resources
|
||||
*/
|
||||
public fun fullStack(
|
||||
bundleName: String = "js/bundle.js",
|
||||
development: Boolean = false,
|
||||
jvmConfig: KotlinJvmTarget.() -> Unit = {},
|
||||
jsConfig: KotlinJsTargetDsl.() -> Unit = {},
|
||||
browserConfig: KotlinJsBrowserDsl.() -> Unit = {},
|
||||
) {
|
||||
js {
|
||||
browser {
|
||||
commonWebpackConfig{
|
||||
outputFileName = bundleName
|
||||
}
|
||||
browserConfig()
|
||||
}
|
||||
useEsModules()
|
||||
jsConfig()
|
||||
binaries.executable()
|
||||
}
|
||||
jvm {
|
||||
val processResourcesTaskName =
|
||||
compilations[KotlinCompilation.MAIN_COMPILATION_NAME].processResourcesTaskName
|
||||
|
||||
|
||||
val jsBrowserDistribution = project.tasks.getByName(
|
||||
if (development) "jsBrowserDevelopmentExecutableDistribution" else "jsBrowserDistribution"
|
||||
)
|
||||
|
||||
project.tasks.getByName<ProcessResources>(processResourcesTaskName) {
|
||||
duplicatesStrategy = DuplicatesStrategy.WARN
|
||||
dependsOn(jsBrowserDistribution)
|
||||
from(jsBrowserDistribution)
|
||||
}
|
||||
jvmConfig()
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Enable all supported native targets
|
||||
*/
|
||||
public fun native(block: KScienceNativeConfiguration.() -> Unit = {}): Unit = with(project) {
|
||||
val nativeConfiguration = KScienceNativeConfiguration(this).apply(block)
|
||||
pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
|
||||
configure<KotlinMultiplatformExtension> {
|
||||
nativeConfiguration.targets.values.forEach { nativeTarget ->
|
||||
when (nativeTarget.preset) {
|
||||
KotlinNativePreset.linuxX64 -> linuxX64(
|
||||
nativeTarget.targetName,
|
||||
nativeTarget.targetConfiguration
|
||||
)
|
||||
|
||||
KotlinNativePreset.mingwX64 -> mingwX64(
|
||||
nativeTarget.targetName,
|
||||
nativeTarget.targetConfiguration
|
||||
)
|
||||
|
||||
KotlinNativePreset.macosX64 -> macosX64(
|
||||
nativeTarget.targetName,
|
||||
nativeTarget.targetConfiguration
|
||||
)
|
||||
|
||||
KotlinNativePreset.macosArm64 -> macosArm64(
|
||||
nativeTarget.targetName,
|
||||
nativeTarget.targetConfiguration
|
||||
)
|
||||
|
||||
KotlinNativePreset.iosX64 -> iosX64(
|
||||
nativeTarget.targetName,
|
||||
nativeTarget.targetConfiguration
|
||||
)
|
||||
|
||||
KotlinNativePreset.iosArm64 -> iosArm64(
|
||||
nativeTarget.targetName,
|
||||
nativeTarget.targetConfiguration
|
||||
)
|
||||
|
||||
KotlinNativePreset.iosSimulatorArm64 -> iosSimulatorArm64(
|
||||
nativeTarget.targetName,
|
||||
nativeTarget.targetConfiguration
|
||||
)
|
||||
}
|
||||
}
|
||||
applyDefaultHierarchyTemplate()
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
internal inline fun <reified T : KScienceExtension> Project.registerKScienceExtension():T {
|
||||
// extensions.findByType<T>()?.let { return it }
|
||||
// return constructor(this).also {
|
||||
// extensions.add("kscience", it)
|
||||
// }
|
||||
|
||||
return extensions.create("kscience", T::class.java)
|
||||
}
|
||||
@ -1,59 +0,0 @@
|
||||
package space.kscience.gradle
|
||||
|
||||
import org.gradle.api.Plugin
|
||||
import org.gradle.api.Project
|
||||
import org.gradle.api.tasks.testing.Test
|
||||
import org.gradle.jvm.toolchain.JavaLanguageVersion
|
||||
import org.gradle.kotlin.dsl.apply
|
||||
import org.gradle.kotlin.dsl.configure
|
||||
import org.gradle.kotlin.dsl.get
|
||||
import org.gradle.kotlin.dsl.withType
|
||||
import org.jetbrains.dokka.gradle.DokkaPlugin
|
||||
import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
|
||||
import space.kscience.gradle.internal.applySettings
|
||||
import space.kscience.gradle.internal.defaultKotlinJvmArgs
|
||||
|
||||
public open class KScienceJVMPlugin : Plugin<Project> {
|
||||
override fun apply(project: Project): Unit = project.run {
|
||||
|
||||
logger.warn("KSCience JVM plugin is deprecated. Use MPP.")
|
||||
if (!plugins.hasPlugin("org.jetbrains.kotlin.jvm")) {
|
||||
plugins.apply("org.jetbrains.kotlin.jvm")
|
||||
} else {
|
||||
logger.info("Kotlin JVM plugin is already present")
|
||||
}
|
||||
val extension = registerKScienceExtension<KScienceExtension>()
|
||||
|
||||
//logger.info("Applying KScience configuration for JVM project")
|
||||
configure<KotlinJvmProjectExtension> {
|
||||
sourceSets.all {
|
||||
languageSettings.applySettings()
|
||||
compilerOptions{
|
||||
freeCompilerArgs.addAll(defaultKotlinJvmArgs)
|
||||
}
|
||||
}
|
||||
|
||||
sourceSets["test"].apply {
|
||||
dependencies {
|
||||
implementation(kotlin("test-junit5"))
|
||||
implementation("org.junit.jupiter:junit-jupiter:${KScienceVersions.junit}")
|
||||
}
|
||||
}
|
||||
|
||||
if (explicitApi == null) explicitApiWarning()
|
||||
jvmToolchain {
|
||||
languageVersion.set(extension.jdkVersionProperty.map { JavaLanguageVersion.of(it) })
|
||||
}
|
||||
}
|
||||
|
||||
tasks.withType<Test> {
|
||||
useJUnitPlatform()
|
||||
}
|
||||
|
||||
// apply dokka for all projects
|
||||
if (!plugins.hasPlugin("org.jetbrains.dokka")) {
|
||||
apply<DokkaPlugin>()
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@ -1,66 +0,0 @@
|
||||
package space.kscience.gradle
|
||||
|
||||
import org.gradle.api.Plugin
|
||||
import org.gradle.api.Project
|
||||
import org.gradle.kotlin.dsl.apply
|
||||
import org.gradle.kotlin.dsl.configure
|
||||
import org.gradle.kotlin.dsl.invoke
|
||||
import org.jetbrains.dokka.gradle.DokkaPlugin
|
||||
import org.jetbrains.kotlin.gradle.ExperimentalKotlinGradlePluginApi
|
||||
import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
|
||||
import space.kscience.gradle.internal.applySettings
|
||||
import space.kscience.gradle.internal.defaultKotlinCommonArgs
|
||||
|
||||
public open class KScienceMPPlugin : Plugin<Project> {
|
||||
|
||||
override fun apply(project: Project): Unit = project.run {
|
||||
if (!plugins.hasPlugin("org.jetbrains.kotlin.multiplatform")) {
|
||||
//apply<KotlinMultiplatformPlugin>() for some reason it does not work
|
||||
plugins.apply("org.jetbrains.kotlin.multiplatform")
|
||||
} else {
|
||||
logger.info("Kotlin MPP plugin is already present")
|
||||
}
|
||||
|
||||
val kscience = registerKScienceExtension<KScienceMppExtension>()
|
||||
|
||||
configure<KotlinMultiplatformExtension> {
|
||||
sourceSets {
|
||||
getByName("commonMain") {
|
||||
dependencies {
|
||||
api(project.dependencies.platform("org.jetbrains.kotlin-wrappers:kotlin-wrappers-bom:${KScienceVersions.jsBom}"))
|
||||
}
|
||||
}
|
||||
getByName("commonTest") {
|
||||
dependencies {
|
||||
implementation(kotlin("test"))
|
||||
implementation(kotlin("test-annotations-common"))
|
||||
}
|
||||
}
|
||||
all {
|
||||
languageSettings.applySettings()
|
||||
}
|
||||
}
|
||||
@OptIn(ExperimentalKotlinGradlePluginApi::class)
|
||||
compilerOptions {
|
||||
freeCompilerArgs.addAll(defaultKotlinCommonArgs)
|
||||
}
|
||||
|
||||
if (explicitApi == null) explicitApiWarning()
|
||||
|
||||
//pass compose extension inside kscience extensions to make it available inside kscience block
|
||||
plugins.withId("org.jetbrains.compose") {
|
||||
kscience.extensions.add(
|
||||
"compose",
|
||||
(this@configure as org.gradle.api.plugins.ExtensionAware).extensions.getByName("compose")
|
||||
)
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
// apply dokka for all projects
|
||||
if (!plugins.hasPlugin("org.jetbrains.dokka")) {
|
||||
apply<DokkaPlugin>()
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,250 +0,0 @@
|
||||
package space.kscience.gradle
|
||||
|
||||
import kotlinx.validation.ApiValidationExtension
|
||||
import kotlinx.validation.BinaryCompatibilityValidatorPlugin
|
||||
import org.gradle.api.Plugin
|
||||
import org.gradle.api.Project
|
||||
import org.gradle.api.publish.maven.MavenPom
|
||||
import org.gradle.api.publish.maven.tasks.AbstractPublishToMaven
|
||||
import org.gradle.kotlin.dsl.*
|
||||
import org.gradle.plugins.signing.Sign
|
||||
import org.jetbrains.changelog.ChangelogPlugin
|
||||
import org.jetbrains.changelog.ChangelogPluginExtension
|
||||
import org.jetbrains.dokka.gradle.AbstractDokkaTask
|
||||
import org.jetbrains.dokka.gradle.DokkaPlugin
|
||||
import org.jetbrains.kotlin.gradle.targets.js.yarn.YarnLockMismatchReport
|
||||
import org.jetbrains.kotlin.gradle.targets.js.yarn.YarnPlugin
|
||||
import org.jetbrains.kotlin.gradle.targets.js.yarn.YarnRootExtension
|
||||
import space.kscience.gradle.internal.addPublishing
|
||||
import space.kscience.gradle.internal.addSonatypePublishing
|
||||
import space.kscience.gradle.internal.setupPublication
|
||||
|
||||
/**
|
||||
* Simplifies adding repositories for Maven publishing, responds for releasing tasks for projects.
|
||||
*/
|
||||
public class KSciencePublishingExtension(public val project: Project) {
|
||||
private var isVcsInitialized = false
|
||||
|
||||
/**
|
||||
* Configures Git repository (sources) for the publication.
|
||||
*
|
||||
* @param vcsUrl URL of the repository's web interface.
|
||||
* @param connectionUrl URL of the Git repository.
|
||||
* @param developerConnectionUrl URL of the Git repository for developers.
|
||||
*/
|
||||
public fun pom(
|
||||
vcsUrl: String,
|
||||
connectionUrl: String? = null,
|
||||
developerConnectionUrl: String? = connectionUrl,
|
||||
connectionPrefix: String = "scm:git:",
|
||||
pomConfig: MavenPom.() -> Unit,
|
||||
) {
|
||||
if (!isVcsInitialized) {
|
||||
project.setupPublication {
|
||||
url.set(vcsUrl)
|
||||
|
||||
scm {
|
||||
url.set(vcsUrl)
|
||||
connectionUrl?.let { connection.set("$connectionPrefix$it") }
|
||||
developerConnectionUrl?.let { developerConnection.set("$connectionPrefix$it") }
|
||||
}
|
||||
pomConfig()
|
||||
}
|
||||
|
||||
isVcsInitialized = true
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a repository with [repositoryName]. Uses "publishing.$repositoryName.user" and "publishing.$repositoryName.token"
|
||||
* properties pattern to store user and token
|
||||
*/
|
||||
public fun repository(
|
||||
repositoryName: String,
|
||||
url: String,
|
||||
) {
|
||||
require(isVcsInitialized) { "The project vcs is not set up use 'pom' method to do so" }
|
||||
project.addPublishing(repositoryName, url)
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds Sonatype Maven repository to publishing.
|
||||
|
||||
*/
|
||||
public fun sonatype(sonatypeRoot: String = "https://s01.oss.sonatype.org") {
|
||||
require(isVcsInitialized) { "The project vcs is not set up use 'pom' method to do so" }
|
||||
project.addSonatypePublishing(sonatypeRoot)
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Applies third-party plugins (Dokka, Changelog, binary compatibility validator); configures Maven publishing, README
|
||||
* generation.
|
||||
*/
|
||||
public open class KScienceProjectPlugin : Plugin<Project> {
|
||||
override fun apply(target: Project): Unit = target.run {
|
||||
apply<ChangelogPlugin>()
|
||||
apply<DokkaPlugin>()
|
||||
apply<BinaryCompatibilityValidatorPlugin>()
|
||||
|
||||
allprojects {
|
||||
repositories {
|
||||
mavenCentral()
|
||||
maven("https://repo.kotlin.link")
|
||||
google()
|
||||
}
|
||||
|
||||
// Workaround for https://github.com/gradle/gradle/issues/15568
|
||||
tasks.withType<AbstractPublishToMaven>().configureEach {
|
||||
mustRunAfter(tasks.withType<Sign>())
|
||||
}
|
||||
}
|
||||
|
||||
afterEvaluate {
|
||||
if (isInDevelopment) {
|
||||
configure<ApiValidationExtension> {
|
||||
validationDisabled = true
|
||||
}
|
||||
} else {
|
||||
configure<ChangelogPluginExtension> {
|
||||
version.set(project.version.toString())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
val rootReadmeExtension = KScienceReadmeExtension(this)
|
||||
val ksciencePublish = KSciencePublishingExtension(this)
|
||||
extensions.add("ksciencePublish", ksciencePublish)
|
||||
extensions.add("readme", rootReadmeExtension)
|
||||
|
||||
//Add readme generators to individual subprojects
|
||||
subprojects {
|
||||
val readmeExtension = KScienceReadmeExtension(this)
|
||||
extensions.add("readme", readmeExtension)
|
||||
|
||||
tasks.create("generateReadme") {
|
||||
group = "documentation"
|
||||
description = "Generate a README file if stub is present"
|
||||
|
||||
inputs.property("extension", readmeExtension)
|
||||
|
||||
if (readmeExtension.readmeTemplate.exists()) {
|
||||
inputs.file(readmeExtension.readmeTemplate)
|
||||
}
|
||||
readmeExtension.inputFiles.forEach {
|
||||
if (it.exists()) {
|
||||
inputs.file(it)
|
||||
}
|
||||
}
|
||||
|
||||
val readmeFile = this@subprojects.file("README.md")
|
||||
outputs.file(readmeFile)
|
||||
|
||||
doLast {
|
||||
val readmeString = readmeExtension.readmeString()
|
||||
if (readmeString != null) {
|
||||
readmeFile.writeText(readmeString)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// tasks.withType<AbstractDokkaTask> {
|
||||
// dependsOn(generateReadme)
|
||||
// }
|
||||
}
|
||||
|
||||
val generateReadme by tasks.creating {
|
||||
group = "documentation"
|
||||
description = "Generate a README file and a feature matrix if stub is present"
|
||||
|
||||
subprojects {
|
||||
tasks.findByName("generateReadme")?.let {
|
||||
dependsOn(it)
|
||||
}
|
||||
}
|
||||
|
||||
inputs.property("extension", rootReadmeExtension)
|
||||
|
||||
if (rootReadmeExtension.readmeTemplate.exists()) {
|
||||
inputs.file(rootReadmeExtension.readmeTemplate)
|
||||
}
|
||||
|
||||
rootReadmeExtension.inputFiles.forEach {
|
||||
if (it.exists()) {
|
||||
inputs.file(it)
|
||||
}
|
||||
}
|
||||
|
||||
val readmeFile = project.file("README.md")
|
||||
outputs.file(readmeFile)
|
||||
|
||||
doLast {
|
||||
// val projects = subprojects.associate {
|
||||
// val normalizedPath = it.path.replaceFirst(":","").replace(":","/")
|
||||
// it.path.replace(":","/") to it.extensions.findByType<KScienceReadmeExtension>()
|
||||
// }
|
||||
|
||||
if (rootReadmeExtension.readmeTemplate.exists()) {
|
||||
|
||||
val modulesString = buildString {
|
||||
subprojects.forEach { subproject ->
|
||||
// val name = subproject.name
|
||||
subproject.extensions.findByType<KScienceReadmeExtension>()?.let { ext ->
|
||||
val path = subproject.path.replaceFirst(":", "").replace(":", "/")
|
||||
appendLine("\n### [$path]($path)")
|
||||
ext.description?.let { appendLine("> ${ext.description}") }
|
||||
appendLine(">\n> **Maturity**: ${ext.maturity}")
|
||||
val featureString = ext.featuresString(itemPrefix = "> - ", pathPrefix = "$path/")
|
||||
if (featureString.isNotBlank()) {
|
||||
appendLine(">\n> **Features:**")
|
||||
appendLine(featureString)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
rootReadmeExtension.property("modules", modulesString)
|
||||
|
||||
rootReadmeExtension.readmeString()?.let {
|
||||
readmeFile.writeText(it)
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
tasks.withType<AbstractDokkaTask> {
|
||||
dependsOn(generateReadme)
|
||||
}
|
||||
|
||||
tasks.create("version") {
|
||||
group = "publishing"
|
||||
val versionFileProvider = project.layout.buildDirectory.file("project-version.txt")
|
||||
outputs.file(versionFileProvider)
|
||||
doLast {
|
||||
val versionFile = versionFileProvider.get().asFile
|
||||
versionFile.createNewFile()
|
||||
versionFile.writeText(project.version.toString())
|
||||
}
|
||||
}
|
||||
|
||||
// Disable API validation for snapshots
|
||||
if (isInDevelopment) {
|
||||
extensions.findByType<ApiValidationExtension>()?.apply {
|
||||
validationDisabled = true
|
||||
logger.warn("API validation is disabled for snapshot or dev version")
|
||||
}
|
||||
}
|
||||
|
||||
plugins.withType<YarnPlugin>() {
|
||||
rootProject.configure<YarnRootExtension> {
|
||||
lockFileDirectory = rootDir.resolve("gradle")
|
||||
yarnLockMismatchReport = YarnLockMismatchReport.WARNING
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public companion object {
|
||||
public const val DEPLOY_GROUP: String = "deploy"
|
||||
}
|
||||
}
|
||||
@ -1,227 +0,0 @@
|
||||
package space.kscience.gradle
|
||||
|
||||
import freemarker.cache.StringTemplateLoader
|
||||
import freemarker.template.Configuration
|
||||
import freemarker.template.Template
|
||||
import freemarker.template.TemplateNotFoundException
|
||||
import kotlinx.html.TagConsumer
|
||||
import kotlinx.html.div
|
||||
import kotlinx.html.stream.createHTML
|
||||
import kotlinx.validation.ApiValidationExtension
|
||||
import org.gradle.api.Project
|
||||
import org.gradle.kotlin.dsl.findByType
|
||||
import org.intellij.lang.annotations.Language
|
||||
import java.io.File
|
||||
import java.io.StringWriter
|
||||
import kotlin.collections.component1
|
||||
import kotlin.collections.component2
|
||||
import kotlin.collections.set
|
||||
|
||||
public enum class Maturity {
|
||||
PROTOTYPE,
|
||||
EXPERIMENTAL,
|
||||
DEVELOPMENT,
|
||||
STABLE,
|
||||
DEPRECATED
|
||||
}
|
||||
|
||||
private fun Template.processToString(args: Map<String, Any?>): String {
|
||||
val writer = StringWriter()
|
||||
process(args, writer)
|
||||
return writer.toString()
|
||||
}
|
||||
|
||||
|
||||
public class KScienceReadmeExtension(public val project: Project) {
|
||||
public var description: String? = null
|
||||
get() = field ?: project.description
|
||||
|
||||
public var maturity: Maturity = Maturity.EXPERIMENTAL
|
||||
set(value) {
|
||||
field = value
|
||||
val projectName = project.name
|
||||
if (value == Maturity.EXPERIMENTAL || value == Maturity.PROTOTYPE) {
|
||||
project.rootProject.run {
|
||||
plugins.withId("org.jetbrains.kotlinx.binary-compatibility-validator") {
|
||||
extensions.findByType<ApiValidationExtension>()?.apply {
|
||||
project.logger.warn("$value project $projectName is excluded from API validation")
|
||||
ignoredProjects.add(projectName)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* If true, use default templates provided by plugin if override is not defined
|
||||
*/
|
||||
public var useDefaultReadmeTemplate: Boolean = true
|
||||
|
||||
/**
|
||||
* Use this template file if it is provided, otherwise use default template
|
||||
*/
|
||||
public var readmeTemplate: File = project.file("docs/README-TEMPLATE.md")
|
||||
set(value) {
|
||||
field = value
|
||||
if (value.exists()) {
|
||||
fmLoader.putTemplate("readme", value.readText())
|
||||
}
|
||||
}
|
||||
|
||||
private val fmLoader = StringTemplateLoader().apply {
|
||||
putTemplate(
|
||||
"artifact",
|
||||
this@KScienceReadmeExtension.javaClass.getResource("/templates/ARTIFACT-TEMPLATE.md")!!.readText()
|
||||
)
|
||||
if (readmeTemplate.exists()) {
|
||||
putTemplate("readme", readmeTemplate.readText())
|
||||
} else if (useDefaultReadmeTemplate) {
|
||||
putTemplate(
|
||||
"readme",
|
||||
this@KScienceReadmeExtension.javaClass.getResource("/templates/README-TEMPLATE.md")!!.readText()
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
private val fmCfg = Configuration(Configuration.VERSION_2_3_31).apply {
|
||||
defaultEncoding = "UTF-8"
|
||||
templateLoader = fmLoader
|
||||
}
|
||||
|
||||
public data class Feature(val id: String, val description: String, val ref: String?, val name: String = id)
|
||||
|
||||
public val features: MutableList<Feature> = mutableListOf()
|
||||
|
||||
/**
|
||||
* A plain readme feature with description
|
||||
*/
|
||||
public fun feature(
|
||||
id: String,
|
||||
@Language("File") ref: String? = null,
|
||||
name: String = id,
|
||||
description: () -> String,
|
||||
) {
|
||||
features += Feature(id, description(), ref, name)
|
||||
}
|
||||
|
||||
/**
|
||||
* A readme feature with HTML description
|
||||
*/
|
||||
public fun featureWithHtml(
|
||||
id: String,
|
||||
ref: String? = null,
|
||||
name: String = id,
|
||||
htmlBuilder: TagConsumer<String>.() -> Unit,
|
||||
) {
|
||||
val text = createHTML().apply {
|
||||
div("readme-feature") {
|
||||
htmlBuilder()
|
||||
}
|
||||
}.finalize()
|
||||
features += Feature(id, text, ref, name)
|
||||
}
|
||||
|
||||
private val properties: MutableMap<String, () -> Any?> = mutableMapOf(
|
||||
"name" to { project.name },
|
||||
"group" to { project.group },
|
||||
"version" to { project.version },
|
||||
"description" to { project.description ?: "" },
|
||||
"features" to { featuresString() },
|
||||
"published" to { project.plugins.findPlugin("maven-publish") != null },
|
||||
"artifact" to {
|
||||
val projectProperties = mapOf(
|
||||
"name" to project.name,
|
||||
"group" to project.group,
|
||||
"version" to project.version
|
||||
)
|
||||
fmCfg.getTemplate("artifact").processToString(projectProperties)
|
||||
}
|
||||
)
|
||||
|
||||
public fun getPropertyValues(): Map<String, Any?> = properties.mapValues { (_, value) -> value() }
|
||||
|
||||
public fun property(key: String, value: Any?) {
|
||||
properties[key] = { value }
|
||||
}
|
||||
|
||||
public fun property(key: String, value: () -> Any?) {
|
||||
properties[key] = value
|
||||
}
|
||||
|
||||
public fun propertyByTemplate(key: String, templateString: String) {
|
||||
//need to freeze it, otherwise values could change
|
||||
val actual = getPropertyValues()
|
||||
fmLoader.putTemplate(key, templateString)
|
||||
val template = fmCfg.getTemplate(key)
|
||||
|
||||
properties[key] = { template.processToString(actual) }
|
||||
}
|
||||
|
||||
/**
|
||||
* Files that are use in readme generation
|
||||
*/
|
||||
internal val inputFiles = ArrayList<File>()
|
||||
|
||||
public fun propertyByTemplate(key: String, templateFile: File) {
|
||||
//need to freeze it, otherwise values could change
|
||||
val actual = getPropertyValues()
|
||||
fmLoader.putTemplate(key, templateFile.readText())
|
||||
val template: Template = fmCfg.getTemplate(key)
|
||||
|
||||
properties[key] = { template.processToString(actual) }
|
||||
inputFiles += templateFile
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate a markdown string listing features
|
||||
*/
|
||||
internal fun featuresString(itemPrefix: String = " - ", pathPrefix: String = ""): String = buildString {
|
||||
features.forEach {
|
||||
appendLine("$itemPrefix[${it.name}]($pathPrefix${it.ref ?: "#"}) : ${it.description}")
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate a readme string from the template
|
||||
*/
|
||||
public fun readmeString(): String? = try {
|
||||
fmCfg.getTemplate("readme").processToString(getPropertyValues())
|
||||
} catch (ex: TemplateNotFoundException) {
|
||||
project.logger.warn("Template with name ${ex.templateName} not found in ${project.name}")
|
||||
null
|
||||
}
|
||||
|
||||
override fun equals(other: Any?): Boolean {
|
||||
if (this === other) return true
|
||||
if (javaClass != other?.javaClass) return false
|
||||
|
||||
other as KScienceReadmeExtension
|
||||
|
||||
if (project != other.project) return false
|
||||
if (maturity != other.maturity) return false
|
||||
if (useDefaultReadmeTemplate != other.useDefaultReadmeTemplate) return false
|
||||
if (readmeTemplate != other.readmeTemplate) return false
|
||||
if (fmLoader != other.fmLoader) return false
|
||||
if (fmCfg != other.fmCfg) return false
|
||||
if (features != other.features) return false
|
||||
if (properties != other.properties) return false
|
||||
if (inputFiles != other.inputFiles) return false
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
override fun hashCode(): Int {
|
||||
var result = project.hashCode()
|
||||
result = 31 * result + maturity.hashCode()
|
||||
result = 31 * result + useDefaultReadmeTemplate.hashCode()
|
||||
result = 31 * result + readmeTemplate.hashCode()
|
||||
result = 31 * result + fmLoader.hashCode()
|
||||
result = 31 * result + fmCfg.hashCode()
|
||||
result = 31 * result + features.hashCode()
|
||||
result = 31 * result + properties.hashCode()
|
||||
result = 31 * result + inputFiles.hashCode()
|
||||
return result
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
@ -1,30 +0,0 @@
|
||||
package space.kscience.gradle
|
||||
|
||||
|
||||
import org.tomlj.Toml
|
||||
|
||||
/**
|
||||
* Build constants
|
||||
*/
|
||||
public object KScienceVersions {
|
||||
|
||||
private val toml by lazy {
|
||||
Toml.parse(javaClass.getResource("/libs.versions.toml")!!.readText())
|
||||
}
|
||||
|
||||
public val kotlinVersion: String get() = toml.getString("versions.kotlin")!!
|
||||
public val kotlinxNodeVersion: String get() = toml.getString("versions.kotlinx-nodejs")!!
|
||||
public val coroutinesVersion: String get() = toml.getString("versions.kotlinx-coroutines")!!
|
||||
public val serializationVersion: String get() = toml.getString("versions.kotlinx-serialization")!!
|
||||
public val atomicVersion: String get() = toml.getString("versions.atomicfu")!!
|
||||
public val ktorVersion: String get() = toml.getString("versions.ktor")!!
|
||||
public val htmlVersion: String get() = toml.getString("versions.kotlinx-html")!!
|
||||
public val dateTimeVersion: String get() = toml.getString("versions.kotlinx-datetime")!!
|
||||
public val jsBom: String get() = toml.getString("versions.jsBom")!!
|
||||
internal val junit: String get() = toml.getString("versions.junit")!!
|
||||
|
||||
public object Serialization {
|
||||
public val xmlVersion: String get() = toml.getString("versions.xmlutil")!!
|
||||
public val yamlKtVersion: String get() = toml.getString("versions.yamlkt")!!
|
||||
}
|
||||
}
|
||||
@ -1,49 +0,0 @@
|
||||
package space.kscience.gradle
|
||||
|
||||
import org.gradle.api.Project
|
||||
import space.kscience.gradle.internal.useCommonDependency
|
||||
|
||||
public class SerializationTargets(
|
||||
public val sourceSet: DependencySourceSet,
|
||||
public val configuration: DependencyConfiguration,
|
||||
) {
|
||||
public fun Project.json(
|
||||
version: String = KScienceVersions.serializationVersion,
|
||||
): Unit = useCommonDependency(
|
||||
"org.jetbrains.kotlinx:kotlinx-serialization-json:$version",
|
||||
dependencySourceSet = sourceSet,
|
||||
dependencyConfiguration = configuration,
|
||||
)
|
||||
|
||||
public fun Project.cbor(
|
||||
version: String = KScienceVersions.serializationVersion,
|
||||
): Unit = useCommonDependency(
|
||||
"org.jetbrains.kotlinx:kotlinx-serialization-cbor:$version",
|
||||
dependencySourceSet = sourceSet,
|
||||
dependencyConfiguration = configuration,
|
||||
)
|
||||
|
||||
public fun Project.protobuf(
|
||||
version: String = KScienceVersions.serializationVersion,
|
||||
): Unit = useCommonDependency(
|
||||
"org.jetbrains.kotlinx:kotlinx-serialization-protobuf:$version",
|
||||
dependencySourceSet = sourceSet,
|
||||
dependencyConfiguration = configuration,
|
||||
)
|
||||
|
||||
public fun Project.xml(
|
||||
version: String = KScienceVersions.Serialization.xmlVersion,
|
||||
): Unit = useCommonDependency(
|
||||
"io.github.pdvrieze.xmlutil:serialization:$version",
|
||||
dependencySourceSet = sourceSet,
|
||||
dependencyConfiguration = configuration,
|
||||
)
|
||||
|
||||
public fun Project.yamlKt(
|
||||
version: String = KScienceVersions.Serialization.yamlKtVersion,
|
||||
): Unit = useCommonDependency(
|
||||
"net.mamoe.yamlkt:yamlkt:$version",
|
||||
dependencySourceSet = sourceSet,
|
||||
dependencyConfiguration = configuration,
|
||||
)
|
||||
}
|
||||
@ -1,60 +0,0 @@
|
||||
package space.kscience.gradle.internal
|
||||
|
||||
import org.gradle.api.artifacts.ProjectDependency
|
||||
import org.gradle.api.tasks.Copy
|
||||
import org.gradle.kotlin.dsl.get
|
||||
import org.jetbrains.kotlin.gradle.plugin.LanguageSettingsBuilder
|
||||
import space.kscience.gradle.KScienceVersions
|
||||
|
||||
|
||||
internal val defaultKotlinJvmArgs: List<String> = listOf(
|
||||
"-Xjvm-default=all"
|
||||
)
|
||||
|
||||
internal val defaultKotlinCommonArgs: List<String> = listOf(
|
||||
"-Xexpect-actual-classes"
|
||||
)
|
||||
|
||||
internal fun resolveKotlinVersion(): KotlinVersion {
|
||||
val (major, minor, patch) = KScienceVersions.kotlinVersion.split(".", "-")
|
||||
return KotlinVersion(major.toInt(), minor.toInt(), patch.toInt())
|
||||
}
|
||||
|
||||
internal fun LanguageSettingsBuilder.applySettings(
|
||||
kotlinVersion: KotlinVersion = resolveKotlinVersion(),
|
||||
) {
|
||||
val versionString = "${kotlinVersion.major}.${kotlinVersion.minor}"
|
||||
languageVersion = versionString
|
||||
apiVersion = versionString
|
||||
progressiveMode = true
|
||||
|
||||
|
||||
optIn("kotlin.RequiresOptIn")
|
||||
optIn("kotlin.ExperimentalUnsignedTypes")
|
||||
optIn("kotlin.ExperimentalStdlibApi")
|
||||
optIn("kotlin.time.ExperimentalTime")
|
||||
optIn("kotlin.contracts.ExperimentalContracts")
|
||||
optIn("kotlin.js.ExperimentalJsExport")
|
||||
}
|
||||
|
||||
internal fun Copy.fromJsDependencies(configurationName: String) = project.run {
|
||||
val configuration = configurations[configurationName]
|
||||
?: error("Configuration with name $configurationName could not be resolved.")
|
||||
val projectDeps = configuration.allDependencies.filterIsInstance<ProjectDependency>().map {
|
||||
it.dependencyProject
|
||||
}
|
||||
projectDeps.forEach { dep ->
|
||||
dep.pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
|
||||
dep.tasks.findByName("jsProcessResources")?.let { task ->
|
||||
dependsOn(task)
|
||||
from(task)
|
||||
}
|
||||
}
|
||||
dep.pluginManager.withPlugin("org.jetbrains.kotlin.js") {
|
||||
dep.tasks.findByName("processResources")?.let { task ->
|
||||
dependsOn(task)
|
||||
from(task)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,119 +0,0 @@
|
||||
package space.kscience.gradle.internal
|
||||
|
||||
import org.gradle.api.Project
|
||||
import org.gradle.kotlin.dsl.configure
|
||||
import org.gradle.kotlin.dsl.invoke
|
||||
import org.jetbrains.kotlin.gradle.dsl.KotlinJsProjectExtension
|
||||
import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
|
||||
import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
|
||||
import space.kscience.gradle.DependencyConfiguration
|
||||
import space.kscience.gradle.DependencySourceSet
|
||||
|
||||
internal fun Project.useDependency(
|
||||
vararg pairs: Pair<String, String>,
|
||||
dependencySourceSet: DependencySourceSet = DependencySourceSet.MAIN,
|
||||
dependencyConfiguration: DependencyConfiguration = DependencyConfiguration.IMPLEMENTATION
|
||||
) {
|
||||
pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
|
||||
configure<KotlinMultiplatformExtension> {
|
||||
sourceSets {
|
||||
pairs.forEach { (target, dep) ->
|
||||
val name = target + dependencySourceSet.suffix
|
||||
findByName(name)?.apply {
|
||||
dependencies {
|
||||
when (dependencyConfiguration) {
|
||||
DependencyConfiguration.API -> api(dep)
|
||||
DependencyConfiguration.IMPLEMENTATION -> implementation(dep)
|
||||
DependencyConfiguration.COMPILE_ONLY -> compileOnly(dep)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pairs.find { it.first == "jvm" }?.let { dep ->
|
||||
pluginManager.withPlugin("org.jetbrains.kotlin.jvm") {
|
||||
configure<KotlinJvmProjectExtension> {
|
||||
sourceSets.findByName(dependencySourceSet.setName)?.apply {
|
||||
dependencies.apply {
|
||||
val configurationName = when (dependencyConfiguration) {
|
||||
DependencyConfiguration.API -> apiConfigurationName
|
||||
DependencyConfiguration.IMPLEMENTATION -> implementationConfigurationName
|
||||
DependencyConfiguration.COMPILE_ONLY -> compileOnlyConfigurationName
|
||||
}
|
||||
add(configurationName, dep.second)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pairs.find { it.first == "js" }?.let { dep ->
|
||||
pluginManager.withPlugin("org.jetbrains.kotlin.js") {
|
||||
configure<KotlinJsProjectExtension> {
|
||||
sourceSets.findByName(dependencySourceSet.setName)?.apply {
|
||||
dependencies.apply {
|
||||
val configurationName = when (dependencyConfiguration) {
|
||||
DependencyConfiguration.API -> apiConfigurationName
|
||||
DependencyConfiguration.IMPLEMENTATION -> implementationConfigurationName
|
||||
DependencyConfiguration.COMPILE_ONLY -> compileOnlyConfigurationName
|
||||
}
|
||||
add(configurationName, dep.second)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
internal fun Project.useCommonDependency(
|
||||
dep: String,
|
||||
dependencySourceSet: DependencySourceSet = DependencySourceSet.MAIN,
|
||||
dependencyConfiguration: DependencyConfiguration = DependencyConfiguration.IMPLEMENTATION
|
||||
): Unit = pluginManager.run {
|
||||
withPlugin("org.jetbrains.kotlin.multiplatform") {
|
||||
configure<KotlinMultiplatformExtension> {
|
||||
sourceSets.findByName("common${dependencySourceSet.suffix}")?.apply {
|
||||
dependencies {
|
||||
when (dependencyConfiguration) {
|
||||
DependencyConfiguration.API -> api(dep)
|
||||
DependencyConfiguration.IMPLEMENTATION -> implementation(dep)
|
||||
DependencyConfiguration.COMPILE_ONLY -> compileOnly(dep)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
withPlugin("org.jetbrains.kotlin.jvm") {
|
||||
configure<KotlinJvmProjectExtension> {
|
||||
sourceSets.findByName(dependencySourceSet.setName)?.apply {
|
||||
dependencies.apply {
|
||||
val configurationName = when (dependencyConfiguration) {
|
||||
DependencyConfiguration.API -> apiConfigurationName
|
||||
DependencyConfiguration.IMPLEMENTATION -> implementationConfigurationName
|
||||
DependencyConfiguration.COMPILE_ONLY -> compileOnlyConfigurationName
|
||||
}
|
||||
add(configurationName, dep)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
withPlugin("org.jetbrains.kotlin.js") {
|
||||
configure<KotlinJsProjectExtension> {
|
||||
sourceSets.findByName(dependencySourceSet.setName)?.apply {
|
||||
dependencies.apply {
|
||||
val configurationName = when (dependencyConfiguration) {
|
||||
DependencyConfiguration.API -> apiConfigurationName
|
||||
DependencyConfiguration.IMPLEMENTATION -> implementationConfigurationName
|
||||
DependencyConfiguration.COMPILE_ONLY -> compileOnlyConfigurationName
|
||||
}
|
||||
add(configurationName, dep)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,130 +0,0 @@
|
||||
package space.kscience.gradle.internal
|
||||
|
||||
import org.gradle.api.Project
|
||||
import org.gradle.api.publish.PublishingExtension
|
||||
import org.gradle.api.publish.maven.MavenPom
|
||||
import org.gradle.api.publish.maven.MavenPublication
|
||||
import org.gradle.api.tasks.bundling.Jar
|
||||
import org.gradle.kotlin.dsl.*
|
||||
import org.gradle.plugins.signing.SigningExtension
|
||||
import org.gradle.plugins.signing.SigningPlugin
|
||||
import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
|
||||
import space.kscience.gradle.isInDevelopment
|
||||
|
||||
internal fun Project.requestPropertyOrNull(propertyName: String): String? = findProperty(propertyName) as? String
|
||||
?: System.getenv(propertyName)
|
||||
|
||||
internal fun Project.requestProperty(propertyName: String): String = requestPropertyOrNull(propertyName)
|
||||
?: error("Property $propertyName not defined")
|
||||
|
||||
|
||||
internal fun Project.setupPublication(mavenPomConfiguration: MavenPom.() -> Unit = {}) = allprojects {
|
||||
plugins.withId("maven-publish") {
|
||||
configure<PublishingExtension> {
|
||||
|
||||
plugins.withId("org.jetbrains.kotlin.jvm") {
|
||||
val kotlin = extensions.findByType<KotlinJvmProjectExtension>()!!
|
||||
|
||||
val sourcesJar by tasks.creating(Jar::class) {
|
||||
archiveClassifier.set("sources")
|
||||
kotlin.sourceSets.forEach {
|
||||
from(it.kotlin)
|
||||
}
|
||||
}
|
||||
|
||||
publications.create<MavenPublication>("jvm") {
|
||||
from(project.components["java"])
|
||||
|
||||
artifact(sourcesJar)
|
||||
}
|
||||
}
|
||||
|
||||
// Process each publication we have in this project
|
||||
publications.withType<MavenPublication> {
|
||||
pom {
|
||||
name.set(project.name)
|
||||
description.set(project.description ?: project.name)
|
||||
|
||||
scm {
|
||||
tag.set(project.version.toString())
|
||||
}
|
||||
|
||||
mavenPomConfiguration()
|
||||
}
|
||||
}
|
||||
|
||||
plugins.withId("org.jetbrains.dokka") {
|
||||
val dokkaJar by tasks.creating(Jar::class) {
|
||||
group = "documentation"
|
||||
archiveClassifier.set("javadoc")
|
||||
from(tasks.findByName("dokkaHtml"))
|
||||
}
|
||||
publications.withType<MavenPublication> {
|
||||
artifact(dokkaJar)
|
||||
}
|
||||
}
|
||||
|
||||
if (requestPropertyOrNull("publishing.signing.id") != null || requestPropertyOrNull("signing.gnupg.keyName") != null) {
|
||||
|
||||
if (!plugins.hasPlugin("signing")) {
|
||||
apply<SigningPlugin>()
|
||||
}
|
||||
|
||||
extensions.configure<SigningExtension>("signing") {
|
||||
val signingId: String? = requestPropertyOrNull("publishing.signing.id")
|
||||
if (!signingId.isNullOrBlank()) {
|
||||
val signingKey: String = requestProperty("publishing.signing.key")
|
||||
val signingPassphrase: String = requestProperty("publishing.signing.passPhrase")
|
||||
|
||||
// if a key is provided, use it
|
||||
useInMemoryPgpKeys(signingId, signingKey, signingPassphrase)
|
||||
} // else use agent signing
|
||||
sign(publications)
|
||||
}
|
||||
} else {
|
||||
logger.warn("Signing information is not provided. Skipping artefact signing.")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
internal fun Project.addPublishing(
|
||||
repositoryName: String,
|
||||
urlString:String
|
||||
){
|
||||
require(repositoryName.matches("\\w*".toRegex())){"Repository name must contain only letters or numbers"}
|
||||
val user: String? = requestPropertyOrNull("publishing.$repositoryName.user")
|
||||
val token: String? = requestPropertyOrNull("publishing.$repositoryName.token")
|
||||
|
||||
if (user == null || token == null) {
|
||||
logger.info("Skipping $repositoryName publishing because $repositoryName credentials are not defined")
|
||||
return
|
||||
}
|
||||
|
||||
allprojects {
|
||||
plugins.withId("maven-publish") {
|
||||
configure<PublishingExtension> {
|
||||
logger.info("Adding $repositoryName publishing to project [${project.name}]")
|
||||
|
||||
repositories.maven {
|
||||
name = repositoryName
|
||||
url = uri(urlString)
|
||||
|
||||
credentials {
|
||||
username = user
|
||||
password = token
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
internal fun Project.addSonatypePublishing(sonatypeRoot: String) {
|
||||
if (isInDevelopment) {
|
||||
logger.info("Sonatype publishing skipped for development version")
|
||||
} else {
|
||||
addPublishing("sonatype", "$sonatypeRoot/service/local/staging/deploy/maven2")
|
||||
}
|
||||
}
|
||||
@ -1,24 +0,0 @@
|
||||
package space.kscience.gradle
|
||||
|
||||
import org.gradle.api.publish.maven.MavenPom
|
||||
|
||||
public fun MavenPom.useApache2Licence(){
|
||||
licenses {
|
||||
license {
|
||||
name.set("The Apache Software License, Version 2.0")
|
||||
url.set("https://www.apache.org/licenses/LICENSE-2.0.txt")
|
||||
distribution.set("repo")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public fun MavenPom.useSPCTeam(){
|
||||
developers {
|
||||
developer {
|
||||
id.set("SPC")
|
||||
name.set("Scientific programming centre")
|
||||
organization.set("SPC")
|
||||
organizationUrl.set("https://sciprog.center/")
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,15 +0,0 @@
|
||||
## Artifact:
|
||||
|
||||
The Maven coordinates of this project are `${group}:${name}:${version}`.
|
||||
|
||||
**Gradle Kotlin DSL:**
|
||||
```kotlin
|
||||
repositories {
|
||||
maven("https://repo.kotlin.link")
|
||||
mavenCentral()
|
||||
}
|
||||
|
||||
dependencies {
|
||||
implementation("${group}:${name}:${version}")
|
||||
}
|
||||
```
|
||||
@ -1,15 +0,0 @@
|
||||
# Module ${name}
|
||||
|
||||
${description}
|
||||
|
||||
<#if features?has_content>
|
||||
## Features
|
||||
|
||||
${features}
|
||||
|
||||
</#if>
|
||||
<#if published>
|
||||
## Usage
|
||||
|
||||
${artifact}
|
||||
</#if>
|
||||
@ -1,9 +0,0 @@
|
||||
import org.junit.jupiter.api.Test
|
||||
import space.kscience.gradle.KScienceVersions
|
||||
|
||||
class TestPlugins {
|
||||
@Test
|
||||
fun testVersions() {
|
||||
println(KScienceVersions.coroutinesVersion)
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user