Is it possible to prevent code from importing packages from transitive dependencies pulled from maven central? I know you can do that from other gradle projects via 'implementation' and 'api' Something similar to Bazel's 'strict visibility'?

I’m trying to figure out how to publish the “fat jar” created by the shadow plugin, via the

shadowJar

task using the gradle kotlin dsl. So far I’ve had no success after reading through the shadow and maven-publish documentation. Has anyone solved this issue?

i have a more general project layout question: i have a gradle project with submodules ... commons, test-commons and app ... test-commons has only external dependencies, commons depends on test-commons .. and app has the dependency commons and the test dependency test-commons. now in my test-commons i use for example the library wiremock, so i added implementation("com.github.tomakehurst:wiremock-jre8:2.27.2"). if i want to have wiremock also in commons as test dependency there are 2 ways to do that. instead of implementation("wiremock") in test-commons i could use api("wiremock") which exposes wiremock to all projects which depend on test-commons. the other way would be to use testImplementation("wiremock") in my test.kotlin-common-conventions.gradle.kts and just use the same version. but that feels somehow not clean (because i would have to reuse the version somehow). any ideas on that?

Has anyone out there used buildSrc or a custom distributions to enhance the gradle DSL via extension functions? I am thinking like this

fun PluginDependenciesSpecScope.libraryPlugins(){
    id("java-library")
    id("io.freefair.lombok")
}

which could then be called in a project like

plugins {
    libraryPlugins()
}

or better yet, an extension method that could be invoked at the root in the project script that could add plugins and dependencies all at once? For some reason, I just get unresolved references, even though my IDE thinks it is fine

Trying to create a gradle plugin in the buildsrc directory and get this cryptic error even though my build.gradle.kts and plugin definitions seem ok: Cannot access 'java.lang.Object' which is a supertype of ConfigPlugin. Check your module classpath for missing or conflicting dependencies and there are bunch of warnings about Kotlin stdlib conflicts between 1.3.72 and 1.4.10. Kotlin 1.4 includes its own stdlib so I don't see why it's complaining about these conflicts? Gradle is version 6.7

Hi, I am trying

versionCode = majorVersion * 10000 + minorVersion * 100 + patchVersion

in build.gradle.kts

Hi folks, I'm using kotlin dsl in my gradle scripts for android project, but as is showing me

Expression 'android' cannot be invoked as a function. The function 'invoke()' is not found

a brief view of my gradle file is this:

plugins {
	id("com.android.application")
	kotlin("android")
}

android {
	compileSdkVersion(TARGET_SDK_VERSION)

	defaultConfig {
		minSdkVersion(MIN_SDK_VERSION)
		targetSdkVersion(TARGET_SDK_VERSION)

		testInstrumentationRunner("androidx.test.runner.AndroidJUnitRunner")
		consumerProguardFiles("<http://consumer-rules.pro|consumer-rules.pro>")
	}

	buildTypes {
		getByName("release") {
			isMinifyEnabled = false
			proguardFiles(
				getDefaultProguardFile("proguard-android-optimize.txt"),
				"<http://proguard-rules.pro|proguard-rules.pro>"
			)
		}
	}

	compileOptions {
		sourceCompatibility = JavaVersion.VERSION_1_8
		targetCompatibility = JavaVersion.VERSION_1_8
	}

	kotlinOptions {
		jvmTarget = "1.8"
		useIR = true
	}

	buildFeatures {
		compose = true
	}
	composeOptions {
		kotlinCompilerExtensionVersion = COMPOSE_VERSION
		kotlinCompilerVersion = KOTLIN_VERSION
	}
}

Hello. I've a question about exposing dependencies in libs builded with gradle. In my spring boot application (A) I'm using my own starter (S1), which use another starter(S2), which use a library (L).

A -> S1 -> S2 -> L

In my starter (S1) I can use all classes from the library (L). But if I add my starter (S1) as a dependency to my application (A) then I can't use classes from the library and from the second starter (S2), because they aren't in

compileClasspath

. In my starter (S1) I'm adding second starter as

implementation

. And also I use this configuration for adding my starter to application. I've read that to expose dependency I should use ``java-library`` plugin for gradle and use

api

configuration in my starter (S1), but this didn't help me 😞 And if I add S2 to my S1 using deprecated

compile

configuration all works well. 🤔 build.gradle.kts (starter S1)

plugins {
	// other plugins
	`java-library`
}

dependencies {
    // other dependencies
	api("some:starter:1.0.0") // starter S2
}

build.gradle.kts (application A)

dependencies {
    // other dependencies
	implementation("own:starter:1.0.0") // starter S1
}

I am trying to convert a gradle build from groovy to Kotlin but I am stumped here - groovy version:

gradle.ext.token = "foo"

This is in settings.gradle, so rootProject is not available. (I think?!) In Kotlin "gradle" is also available in settings.xml, but it seems it does not implement "ExtensionAware", so the "extra" properties do not seem to work here.

val token: String by gradle.extra("foo")

=> Unresolved reference (on "extra")

Hello! Is it possible to create several common targets in MPP? If yes then how?

Trying to convert this into a buildSrc plugin and can't figure out the right syntax for this..googling for this is not useful as you can imagine 😂 You can get to kotlinOptions by doing this:

tasks.withType(KotlinCompile::class.java).configureEach {
    kotlinOptions {
        jvmTarget = "1.8"
    }
}

But there's no KaptCompile?

Is it possible to add imports in a custom gradle plugin automatically to the build.gradle.kts file, e.g

class MyPlugin : Plugin<Project> {
   fun apply(project: Project) {
      project.addImport("import com.foo.Foo") // i need the command for this
   }
}

so when i use it build.gradle i can directly access it

import com.foo.Foo   // i want to get rid of this import

plugins {
   id("MyPlugin")
}

dependencies {
   // use Foo here directly without the need to add the import on top of every build.gradle.kts file when adding the "MyPlugin" plugin
}

another question. at the moment i want to write custom gradle plugins with the help of includedBuild. so i created a directory and marked it as includedBuild in settings.gradle.ktx. • in android studio 4.1 it is working and shows no errors • in android studio 4.2.0-alpha15 it is also working (building the project) but every gradle.ktx file is now showing errors. is this a know bug?

I have a question, I have a gradle plugin I made that generates code using KotlinPoet, and it puts the code file in build/generated/bot-compiler-plugin/Code/Commands, but its not being registered as a sources root, like SQL Delight does, and I am not sure how to make it do that I am using Gradle 6.5.1 with kts gradle.build files, and am using the MyApt library for annotation preprocessing to generate the kotlin code

Hi there. I am trying to deploy gradle plugins to maven central. For them to be accepted in maven-central, I need to them to be signed. All of this how ever is going to be done in a CI & CD server. The signing needs a keyId, a password, and a file. A bit not suitable for CI. Are there best options? Those of you who have done this before, can you provide with me a helping hand? Probably point me to a

build.gradle.script

?

i have this file in my buildSrc project:

package r2dbcfun

object ProjectConfig {
    const val eap = false
    val kotlinVersion = if (eap) "1.4.20-RC" else "1.4.10"
}

in my normal build file i have an import for it:

import r2dbcfun.ProjectConfig

still in the plugins block i have to specify the whole package:

kotlin("jvm").version(r2dbcfun.ProjectConfig.kotlinVersion)

probably because the plugins block is treated separately from the build file. idea shows the package as grayed out and wants to remove it, which results in an invalid build file

I will start with the official repo content, which is not very old. Thanks

how long does it take gradle to approve plugins? its almost 12 hrs now, and still my plugins are pending

Does anyone else get this when trying to do kotlin dsl for android build.gradle files? Everything compiles and runs, it's just looks like android studio having a mood

"Cannot access 'java.lang.Comparable' which is a supertype of 'org.gradle.kotlin.dsl.KotlinBuildScript'. Check your module classpath for missing or conflicting dependencies"

Does the

kotlin

plugin automatically add dependencies to the Kotlin standard library when adding the plugin to a Java project? I just had the case, where our Android build's custom linter rules module leaked the standard library (as public module dependency), since the

kotlin-stdlib

dependency implicitly came from "somewhere". Explicitly stating the standard library as

compileOnly

dependency, configured Gradle to filter it away from the API/metadata configurations, and stopped leaking it.

Hi there, QQ:

build.gradle

using

plugin id 'com.android.dynamic-feature'

and `plugin id `kotlin-android``Im able to set :

buildFeatures.dataBinding = true

converting it to Kotlin DSL

build.gradle.kts

and using

buildFeatures.dataBinding = true

says

dataBinding

is non existent, I only see

viewBinding

: https://developer.android.com/reference/tools/gradle-api/4.1/com/android/build/api/dsl/BuildFeatures Does that mean I still need to use the deprecated way (

dataBinding.isEnabled = true

) on DSL?

WARNING: DSL element 'android.dataBinding.enabled' is obsolete and has been replaced with 'android.buildFeatures.dataBinding'.

in this PR i’m trying to make task inputs in a plugin that can be set in a build.gradle file, but for some reason I get a runtime error saying those properties don’t exist: https://github.com/cashapp/sqldelight/pull/2082#discussion_r520255932. tried a bunch of things to try to expose them. is this not possible? feel like i’m just missing something small

Is it possible to apply the maven-publish plugin in a custom build file? Seems as though there are no errors when applying the plugin, however the functionality that the plugin provides (eg publishing block) isn't being made available.

Is there a problem with JCenter?

Haven’t had this problem before, but I can’t build an Android project at all, from terminal or Android Studio. It just hangs forever, and --info isn’t particularly helpful. I’m using Kotlin 1.4.10, Kotlin Gradle DSL, Android Studio 4.2 Canary 16. Still on Catalina. Anyone have this problem?

I've an question. I have a gradle-plugin that generates some code. However, Kotlin doesn't seem to find the code during compilation... I'm using Multiplatform, is there something I'm missing?

class PropsToObjectPlugin : Plugin<Project> {
    override fun apply(target: Project) {
        val extension: PropsToObjectExtension = target
            .extensions
            .create("propsToObject")

        val buildDir = target.file(
            "${target.buildDir}/generated/source/props"
        )

        val taskProvider = target.tasks
            .register<PropertyObjectGeneratingTask>(
                "generatePropertyObject"
            ) {
                fileName = target.file(extension.propFileName)
                this.genDir = buildDir
            }

        target.tasks.withType<KotlinCompile> {
            //<https://youtrack.jetbrains.com/issue/KT-42241>
            val srcTask = this as SourceTask
            srcTask.dependsOn(taskProvider)
            val srcSet = target
                .objects
                .sourceDirectorySet("nl.devhaan.props", "generatedPropertyObject")
                .srcDir(buildDir)
            srcTask.source(srcSet)
        }
    }
}

I've been out of the kotlin/gradle loop for a minute but when did

gradle init

start creating a

lib

subdirectory to put

src

in when you create a library instead of just putting

src

in the current project directory? Did they just start doing that in 6.7? That seems really obnoxious to me. Is there a reason for this?

Is there a way to add an "implementation" dependency to

gradle-kotlin-dsl-extensions-6.7.jar

to a plugin project? I'm trying to access some extension functions in there like

fun DependencyHandler.`implementation`(dependencyNotation: Any): Dependency? =
    add("implementation", dependencyNotation)

anytime I add a implementation(project (":mycpplib")) I get a No variant found. And I'm struggling to find examples of people doing kotlin and JNI where everything is built with gradle