so far I have

jar {
    archiveName = "onboarding.jar"

    manifest {
        attributes(
            "Class-Path" to ???
            "Main-Class" to "com.mything.MainKt"
        )
    }
}

but

configurations.compile.collect...

isn’t a thing in the Kotlin DSL

What’s the difference between the

application

plugin and just using the

java

plugin with the

jar

task?

And its also not including the other dependencies packages.

If your dependencies are marked with the

implementation

nor

api

configuration, those would not be available with

configurations.compile

Is it possible to add random print statements to gradle tasks?

tasks {
    jar {
        archiveName = "onboarding.jar"
        println("Hello world")
        }
    }
}

This compiles just fine, but doesn’t print for me, so I assume not.

Is the order of the various blocks important? ie.

tasks {...}

coming before/after

dependencies {...}

?

I recall there being a way to separate out dependency declarations from

build.gradle

into a separate file

dependencies.gradle

. Is it as simple as just copy-pasting the entire

dependencies { ... }

block into the new file and it just magically works?

Has anyone had luck with writing a kotlin subplugin with Gradle's TestKit? They don't seem to be happy together, because of the ServiceLoader logic that SubpluginEnvironment does with class loaders. I see that even Kotlin's tests don't use TestKit. 😞 I'd love to have a TestKit based test for a compiler plugin I'm writing.

Is it not possible to use kotlin in an

init.gradle

script? I'm trying to reference a property using

by project

but I get the error message

Line 1: val ptSnapshotsReaderPassword: String by project
                                                   ^ Function invocation 'project(...)' expected

I am attempting to revive using Jacoco in a Kotlin multiplatform project. It is worse than pulling teeth, given that 1) there is no Java or Application plugin in use that defines “jacocoTestReport”, 2) I am using Kotlin DSL so creating the task “jacocoTestReport” is non-trivial (for me anyway), 3) I am using Kotlin test (not Junit) which I’m guessing does not support Jacoco, and 4) the GooglePlex, Stack Overflow, Medium, etc. all are coming up empty for a simple example that illustrates what needs to be done. I would not be surprised at all to learn that it is even more complicated. In any case, a link to a project that has worked around the constraints I described would be much appreciated. Additional insight will also likely be invaluable.

I'm trying to force a maven package structure with my gradle build script since the new package layout seems to break certain libraries, or at least, it seems they're not picking up configs that's sitting inside src/main/resources The maven package layout basically dumps java, kotlin and resources content directly into the classes directory whereas gradle splits it into classes/kotlin/main, classes/java/main and resources/main

sourceSets {
	main {
		java {
			setSrcDirs(listOf("src/main/java"))
			outputDir = File("build/classes")
		}
		withConvention(KotlinSourceSet::class) {
			kotlin.setSrcDirs(listOf("src/main/kotlin"))
			kotlin.outputDir = File("build/classes")
		}
		resources {
			setSrcDirs(listOf("src/main/resources"))
			outputDir = File("build/classes")
		}
	}
	test {

	}
}

The Java one works perfectly, the resources one doesn't do anything and the Kotlin one i'm not sure how to configure.

This is probably a standard newbie question (but the only solution i found so far used [buildSrc]() which I couldn’t make to work0, so how can I externalise the version information using KotlinDSL so I don’t have to retype the same String? The naive approach is along the lines of

val kotlinVersion = "1.3.21"

plugins {
    kotlin("jvm") version kotlinVersion
    ...
}

dependencies {
    ...
    testImplementation("org.jetbrains.kotlin:kotlin-test-junit:$kotlinVersion")
}

But this fails (“String can’t be called from this context by implicit receiver”) for the usage in plugins.

so I got a local plugin that my other project just can’t seem to find (with the local maven repository):

group = "uk.co.mulecode"
version = "1.0.0-SNAPSHOT"

...

gradlePlugin {
    plugins {
        create("easy-scm") {
            id = "uk.co.mulecode.easy-scm"
            implementationClass = "uk.co.mulecode.EasyScm"
        }
    }
}

after running

gradle install

I can find it in /Users/MDuke/.m2/repository/uk/co/mulecode/easy-scm/1.0.0-SNAPSHOT/easy-scm-1.0.0-SNAPSHOT.jar. Still when trying to use it in another project by importing it locally

buildscript {
    repositories {
        mavenLocal()
//        mavenCentral()
    }
    dependencies {
//        classpath("uk.co.mulecode:easy-scm:1.0.0-SNAPSHOT")
//        classpath("uk.co.mulecode:uk.co.mulecode.easy-scm:1.0.0-SNAPSHOT")
        classpath(group = "uk.co.mulecode", name="easy-scm", version = "1.0.0-SNAPSHOT")
    }
}

plugins {
    id("java")
    id("maven")
    id("uk.co.mulecode.easy-scm") version "1.0.0-SNAPSHOT"
}
...

it isn’t found, as can be seen by running `gradle tasks`:

FAILURE: Build failed with an exception.

* Where:
Build file '/Users/SSchrod/progs/progtests/sandbox-project/build.gradle.kts' line: 12

* What went wrong:
Plugin [id: 'uk.co.mulecode.easy-scm', version: '1.0.0-SNAPSHOT'] was not found in any of the following sources:

- Gradle Core Plugins (plugin is not in 'org.gradle' namespace)
- Plugin Repositories (could not resolve plugin artifact 'uk.co.mulecode.easy-scm:uk.co.mulecode.easy-scm.gradle.plugin:1.0.0-SNAPSHOT')
  Searched in the following repositories:
    Gradle Central Plugin Repository

the artifact path looks pretty messed up but I just can’t figure out what the problem is. To add insult to injury importing of the plugin actually works from an equivalent Groovy-DSL gradle project.

Is there a similar thing in Gradle as Maven’s Archetypes? Basically pre-made project templates with boilerplate?

Hi, I'm setting up a simple android app to test the gradle kotlin DSL. I have an app module with this setting (simplified version):

plugins {
    id("com.android.application")
    id("kotlin-android")
    id("kotlin-android-extensions")
}
android {
    [...]
}
dependencies {
    implementation(kotlin("stdlib-jdk8"))
    implementation(project(":domain"))
    implementation(project(":presentation"))
    [...]
}

I have two other modules: one is

domain

which is a basic kotlin module (

plugins { kotlin("jvm") }

), and the other one is

presentation

, which is an android library:

plugins {
    id("com.android.library")
}
android {
    [...]
}
dependencies {
    implementation(kotlin("stdlib-jdk8"))
    implementation(project(":domain"))
    [...]
}

In the IDE, everything works fine. But when I'm trying to launch a build, I get weird

unresolved reference

issues only on the

presentation

module. Do you know where the problem can come from?

heh, i was trying that last week, and gave up (specifically maven central publish)

@SrSouza @wakingrufus I have an example that publishes to mavenLocal and bintray (for jcenter, which can sync to mavenCentral) for Android, JVM and JS. Should I link it?

oh come on... why is

apply { from(...) }

not available in

buildscript

section - obviously I might want to apply some common configuration from a file at the earliest point of evaluation. Are the Gradle authors trying to be awkward?? 😠

Has anyone seen

Could not find org.jetbrains.kotlin:kotlin-scripting-compiler-embeddable:1.3.21

? I'm just trying to update to Gradle 5.4 (and have a buildSrc project)

I'm trying to create a Kotlin convention script plugin similar to the Java one in Example 19 here: https://docs.gradle.org/current/userguide/kotlin_dsl.html#sec:kotlin-dsl_plugin Project: https://github.com/ianbrandt/multi-kotlin-project Code: https://github.com/ianbrandt/multi-kotlin-project/blob/49cdae7f3f782af51d9d511b994b0fb412d9a8d5/buildSrc/src/main/kotlin/kotlin-project.gradle.kts I'm getting the following errors:

> Task :buildSrc:compileKotlin FAILED
e: multi-kotlin-project/buildSrc/src/main/kotlin/kotlin-project.gradle.kts: (2, 22): Unresolved reference: kotlin
e: multi-kotlin-project/buildSrc/src/main/kotlin/kotlin-project.gradle.kts: (9, 2): Unresolved reference: implementation
e: multi-kotlin-project/buildSrc/src/main/kotlin/kotlin-project.gradle.kts: (13, 11): Unresolved reference: KotlinCompile
e: multi-kotlin-project/buildSrc/src/main/kotlin/kotlin-project.gradle.kts: (13, 26): Type mismatch: inferred type is () -> TypeVariable(_L) but Class<TypeVariable(S)> was expected
e: multi-kotlin-project/buildSrc/src/main/kotlin/kotlin-project.gradle.kts: (14, 3): Unresolved reference: kotlinOptions

The intent is to have a multi-project build where standardized Kotlin, Java, etc. plugins and configuration can be mixed into child projects as needed. Any ideas as to what I'm doing wrong?

is anyone familiar with any open issues to gradle core or on youtrack for intellij freezing on changes to

buildSrc

code? im struggling to find anything right now

Can someone point me in the right direction?

…but somehow,

from(compileJava)

is not working. Any advice?

Hello! How can I apply a plugin that is only available through another plugin? The case is one jar containing all plugins, and explanation in comments 👇

how do I set the main class name when I use spring boot?

Looking at the nebula-kotlin project, I can see they do some magic in order to allow you to specify any kotlin version and have it apply that kotlin dependency. what is not obvious to me is if that same logic applies to the

apply

of the kotlin plugin. I can't parse whether the apply works because they increment the nebula-kotlin version whenever a new kotlin version is released, or if it works because of the

configurations

block that changes the resolution strategy. https://github.com/nebula-plugins/nebula-kotlin-plugin/blob/master/src/main/kotlin/netflix/nebula/NebulaKotlinPlugin.kt

Hello all, I am working on putting together a project that has at it’s core 2 android apps and an IOS app supported via kotlin native. I have been struggling with the gradle portion, combine with getting the project itself to be nice and clean. Largely the biggest hurdle comes from having 2 android apps living in the same project it seems to mess with gradle. I’ve also been struggling with getting the project itself have a nice structure without 10 top level modules, 1 for each app and common, plus a test for each. I’d love to be able to ask some questions about people’s experience on this front if possible

not strictly Kotlin-related, but has anybody noticed any differences in how Gradle metadata handles snapshots? I’ve published a snapshot of a Kotlin multiplatform library two days ago, and my build that depends on that library still can’t pick it up unless I use

--refresh-dependencies

Have you used JOOQ with Gradle and Kotlin ? Is it possible to generate nullsafety code?