If I need to get kotlin_version value in

build.gradle.kts

from

gradle.properties

file, I can get the value by

val kotlin_version: String = property("kotlin_version").toString()

but can’t by

val kotlin_version: String by properties

. WHY?😂 , Anybody could tell me?

Is there a way to access properties of the plugins that do NOT support declaractive plugin syntax (e.g. only support

apply from

syntax) in kts gradle script? Currently I'm doing a hack by putting all properties of this plugin into regular non-kts gradle file and then applying that file, but it's ugly.

when using the kotlin gradle dsl is it finally possible to make versions like used here global so i dont have to change 423852311 occurances of them on an update?

plugins {
    kotlin("multiplatform") version "1.3.41"
}

i have a multi module build. in my parent build.gradle i used

plugins {
    id "org.jetbrains.kotlin.multiplatform" version '1.3.41' apply false
}

now i finally wanted to try out the kotlin dsl and creaed a child module with a build.gradle.kts where i use

apply(plugin = "org.jetbrains.kotlin.multiplatform")

but now the

kotlin { }

block cannot be resolved what am i doing wrong?

i have a task that copys the generated

.js

and

.meta.js

files from the

js()

target somewhere else for some reason. with the original groovy i could acces this folder with

compileKotlinJs.destinationDir

. How can i do that with kotlin dsl?

Can it be solved without installing xCode?

HI all, To reuse Gradle Configuration in subprojects, I would like to declare and then use a function, like is done here: https://github.com/JetBrains/kotlin-wrappers/blob/master/build.gradle#L54 How can I achieve the same in Kotlin DSL?

Any idea why I need to specify the version explicitely if I depend on

kotlin-stdlib-jdk8

but not for plain

kotlin-stdlib

?

implementation("org.jetbrains.kotlin:kotlin-stdlib")

works but

implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")

doesn't

We've been moving to use Kotlin DSL and therefore moving the dependencies to

buildSrc

as a

dependendies.kt

file. However we have tests inside

buildSrc

so the

build.gradle.kts

inside

buildSrc

has dependencies too. Anyone has or can think of a way to use the dependencies from the build script in the

buildSrc

folder?

is there a way to automatically apply the kotlin option

jvmTarget = "1.8

to all submodules?

intellij informs me that i could convert the following into a lambda (what i'd really like to do):

tasks.withType(Test::class).configureEach(object : Action<Test> {
        override fun execute(it: Test) {
            it.outputs.upToDateWhen { false }
        }
    })

Yet when i do it manually or let intellij do it for with following result:

tasks.withType(Test::class).configureEach {
        it.outputs.upToDateWhen { false }
    }

It complains that

it

is undefined. Any idea why?

Is it possible to write tasks in Kotlin in buildSrc, without migrating to DSL?

Hi, I have kotlinJS project and want publish artifact by maven-publish plugin, but created .pom hasn't our dependencies. How can I configure project for adding project dependencies to publicated .pom?

Is there a way to trigger apply dependencies with a keyboard shortcut? I couldn't find a relevant action

This message was deleted.

I wanted to do something like

tasks.register(CustomTask)

and just override the name in my CustomTask

Is there any plugin for AS that helps me to convert my build.gradle files to build.gradle.kts files ?

What dependency do I need to add to my buildSrc project to be able to call

Project.publishing

added by

maven-publish

?

My guess is that because I’m using

.kts

Gradle files Android Studio doesn’t import all settings properly and I cannot access the module settings to change the version manually.

Any clues on this one folks https://stackoverflow.com/questions/57627119/android-subprojects-with-kotlin-dsl ?

So I just bumped into this:

The Kotlin Gradle plugin was loaded multiple times in different subprojects, which is not supported and may break the build.
Please add the Kotlin plugin to the common parent project or the root project, then remove the versions in the subprojects.

What exact kotlin plugin are we talking about ? My root project has modules using

org.jetbrains.kotlin.android

and others using plain

org.jetbrains.kotlin.jvm

. Can they/Should they both be applied in the root build.gradle.kts ?

I'm converting some existing Groovy/Gradle scripts to Kotlin DSL and found a bit of a gap in Kotlin's capability when it comes to reading arbitrary JSON. In these Groovy scripts, an arbitrary JSON structure is read from a file using the wonderfully named JsonSlurper and accessed via 'dot' path. e.g.

val buildConfig : Any? = JsonSlurper().parseText(buildConfigFile.readText())
val defaultInstallDir = buildConfig.SetupDefaults.InstallDir  // Not compiling as Kotlin compiler doesn't generate dynamic access code

I understand this kind of dynamicism is exactly where Groovy excels (and suffers in equal measure), where Kotlin is meant to be more type safe.

But how best to convert this - am I basically left with having to create a model class; or use long-form reflection - is there a shorter way?

Is there any way of disabling the task but still running all the tasks which depends on it?:)

I'm converting a script to kotlin dsl. What is the correct syntax of kapt?

kapt("group:name:version")

results in

inferred type is String but Action<KaptExtension> was expected

When I try to

import kotlinx.serialization.*

it tells me it can't resolve

serialization

. I'm assuming it is cause my build.gradle is messed up or something

When converting from

build.gradle

to

build.gradle.kts

, it looks like autocomplete in IDEA doesn't work until a first gradle sync is successful. Generated accessors are missing but also more regular things are underlined in red. So what I do is usually comment all of the build.gradle.kts and then uncomment parts as I fix them. Is there a better way to do this ? I feel like even if my

android

block is wrong, the

dependencies

could be parsed correctly ?

Hi! In parent `build.gradle.kts`:

subprojects {
  dependencies {
    implementation(platform(SpringBootPlugin.BOM_COORDINATES))
  }
}

in a subproject:

dependencies {
  kapt("org.springframework.boot:spring-boot-configuration-processor")
}

result:

> Could not find org.springframework.boot😒pring-boot-configuration-processor:.

if I change

kapt

to

implementation

, dependency resolution will work, but obviously won't do what is needed. I know this is in part Spring question, but the problem seems to be more gradle than Spring. Basically there is a platform defined by BOM and there is a configuration defined by kapt plugin, gradle does not resolve dependency version for it.

Hi! I see similar questions, but I did not quite find my answer, so here we go again. I converted our gradle scripts to kotlin, extracting common version constants and logic to

buildSrc

. Now (hopefully) only last thing remains. In the

buildSrc/build.gradle.kts

we have:

dependencies {
    implementation("com.android.tools.build:gradle:3.4.1")
}

Then in root project’s

build.gradle.kts

we have:

buildscript {
    repositories {
        google()
        ...
    }
    dependencies {
        classpath("com.android.tools.build:gradle:3.4.1")
        ...
    }
}

Is there a way so that the version

3.4.1

would be specified only in single place? Thanks for any tips.