Hi, I am trying to migrate a Gradle Groovy DSL to ...

# gradle

[jrgonzalez]

Hi, I am trying to migrate a Gradle Groovy DSL to Kotlin DSL and I am trying to declare dependencies in buildSrc in a way similar to this: https://proandroiddev.com/gradle-dependency-management-with-kotlin-94eed4df9a28). The problem is that I have some dependencies that are not just the simple artifact and version and need some extra configuration. On the Groovy DSL I used code like this:

dep = dependencies.create('com.squareup.retrofit2:converter-simplexml:' + constants.versions.retrofit) {
    // We need to exclude dependencies which are already provided by the Android platform
    exclude module: 'stax-api'
    exclude module: 'stax'
    exclude module: 'xpp3'
  }

But I can't figure out how to convert that to Kotlin DSL and I don't even have access to the "dependencies.create" method on the buildSrc object where I am declaring the dependencies. Is it possible to define a dependency with exclusions like that outside a DependencyHandler scope? Is there a standalone constructor / builder for dependencies that is not an extension method only available at specific places?

[gildor]

In this case you have not just version, but config snippet also you need dependencies object to do that
So possible way just extract it to extension function for dependencies and apply where you need this

[gildor]

But I believe you need this only if you use it multiple times in different modules, otherwise easier just define in it on place

[jrgonzalez]

Yes, I want it for multi-module projects to declare dependencies with its configuration only once. The problem with the extension function would be that I can not declare it on a big Dependencies object and access it like: Dependencies.retrofit2ConverterSimpleXML as the ones that I have with no configuration. Also, don't know how to do the configuration like in Groovy.

[gildor]

Problem that you need project instance to create dependency

[gildor]

So or it should be extension function, or retrofit2ConverterSimpleXML must be function, not a property

[gildor]

And you pass DependencyHandler or Project instance, you just cannot resolve it statically, you need instance of DependencyHandler to create dependency

[jrgonzalez]

it does not seem to work if a declare it as fun DependencyHandler.retrofit2ConverterSimpleXML() inside the Dependencies object

[gildor]

Why?

[jrgonzalez]

If I try to autocomplete in a line like: implementation(Dependencies.) I don't get the function appearing at all

[jrgonzalez]

neither it works as implementation(Dependencies.retrofit2ConverterSimpleXML()) or offers anything to import as implementation(retrofit2ConverterSimpleXML())

[gildor]

Maybe just some tooling problem, if you have function in buildSrc it must be available on you build.gradle

[jrgonzalez]

yeah, after several tries now I got the last one implementation(retrofit2ConverterSimpleXML()) to offer to import it as import Dependencies.retrofit2ConverterSimpleXML but that is not ideal either cause I lose autocompletion, so I have to look them up on the object manually and also to add imports, which the other dependencies do not need

[jrgonzalez]

Why is a project / DependencyHandler needed for creating a dependency when it is not used on creation?

[jrgonzalez]

shouldn't it just be a simple object / model?

[gildor]

Apparently it used. create is method of DependencyHandler

[gildor]

You shouldn't import Dependencies, not sure what is exactly you problem. If your Dependencies object uses default package it just should work, same for any top level extension

[jrgonzalez]

yeah, I saw that, but it may be just a convenience extension and it could be possible to create it in some other way that is not scoped to DependencyHandler, but I haven't found any doc about that

[jrgonzalez]

Also the config does not work easily, it expects a Closure<Any>

[gildor]

If you have:

object Dependencies {
  fun retrofitSimpleXml(dep: DependencyHandler)
}

Than I don't see any problem

[jrgonzalez]

maybe doing: closureOf<ExternalModuleDependency> { }? 😅

[jrgonzalez]

oh, so no extension function but a function receiving the dependency handler?

[jrgonzalez]

How that would be called?: Dependencies.retrofitSimpleXml(this)?

[gildor]

Yes

[gildor]

Extension function is just an option, it's easier to use, but you right, it's not related anymore to your Dependencies object

[gildor]

Also the config does not work easily, it expects a Closure<Any>

Just create dependency, cast it to ExternalDependency and use apply to configure

[jrgonzalez]

This seems to compile:

fun retrofit2ConverterSimpleXML(dependencyHandler: DependencyHandler): Dependency =
    dependencyHandler.create(
        "com.squareup.retrofit2:converter:-simplexml${Versions.retrofit}", closureOf<ExternalModuleDependency> {
      exclude(module = "stax-api")
      exclude(module = "stax")
      exclude(module = "xpp3")
    })

[jrgonzalez]

but not on usage 😅

[jrgonzalez]

does not accept this later: implementation(Dependencies.retrofitConverterSimplexml(this))

[jrgonzalez]

` ^ Type mismatch: inferred type is Dependency? but Any was expected``

[gildor]

Your dependency is nullable

[gildor]

Not sure why

[gildor]

Looks that your code explicitly defines it as non nullable

[jrgonzalez]

also tried this based on what you said:

fun retrofit2ConverterSimpleXML(dependencyHandler: DependencyHandler): Dependency =
    (dependencyHandler.create(
        "com.squareup.retrofit2:converter:-simplexml${Versions.retrofit}"
    ) as ExternalDependency).apply {
      exclude(module = "stax-api")
      exclude(module = "stax")
      exclude(module = "xpp3")
    }

[gildor]

It's the same

[jrgonzalez]

it also compiles that part, but fails with same error on implementation reference

[gildor]

Check why dependency is nullable

[gildor]

It just doesn't allow to pass nullable

[gildor]

But I don't see the reason

[gildor]

Just for test add !! To usage

[jrgonzalez]

it seems not that, but that implementation expects either any or 2 parameters one of which is a Dependency?

[jrgonzalez]

so it is going to

fun DependencyHandler.`implementation`(dependencyNotation: Any): Dependency?

[jrgonzalez]

instead of:

fun <T : ModuleDependency> DependencyHandler.`implementation`(
    dependency: T,
    dependencyConfiguration: T.() -> Unit
): T

[gildor]

Ah, I see

[gildor]

Yeah, type safe accessor generated oy for string

[gildor]

You have to use

add("implementation", dependency)

[gildor]

Maybe you can solve this in another way and just globally exclude those dependencies for all modules instead attaching this to your dependency definition

[jrgonzalez]

same complain 😅

[gildor]

Sorry, I confused

[gildor]

Where is type mismatch?

[jrgonzalez]

that one also expects a Any

[jrgonzalez]

not a Dependency

[gildor]

Any is super type of Dependency

[gildor]

So it's fine

[gildor]

Your problem with nullability

[gildor]

Not with class

[jrgonzalez]

I don't know how to get it to use this one:

fun <T : ModuleDependency> DependencyHandler.`implementation`(
    dependency: T,
    dependencyConfiguration: T.() -> Unit
): T

[jrgonzalez]

seem that is the one that allows to pass a Dependency as the created one

[gildor]

Pass empty lambda

[jrgonzalez]

but since it expects a second parameter

[gildor]

Second param just an empty lambda

[gildor]

implementation(dependency, {})

[jrgonzalez]

like this?: implementation(Dependencies.retrofitConverterSimplexml(this), {})

[jrgonzalez]

also tried, but it then gives this different error:

[jrgonzalez]

implementation(Dependencies.retrofitConverterSimplexml(this), {})
              ^ None of the following functions can be called with the arguments supplied: 
                  public fun <T : Dependency> DependencyHandler.implementation(dependency: TypeVariable(T), action: Action<TypeVariable(T)>): TypeVariable(T) defined in org.gradle.kotlin.dsl
                  public fun DependencyHandler.implementation(group: String, name: String, version: String? = ..., configuration: String? = ..., classifier: String? = ..., ext: String? = ..., dependencyConfiguration: Action<ExternalModuleDependency>? = ...): ExternalModuleDependency defined in org.gradle.kotlin.dsl
                  public fun DependencyHandler.implementation(dependencyNotation: String, dependencyConfiguration: Action<ExternalModuleDependency>): ExternalModuleDependency defined in org.gradle.kotlin.dsl

[gildor]

I'm away from my PC and IDE, just check types that possible to pass to type safe accessors and to dynamic add setters, one of them should allow pass Dependency

[gildor]

Probably your method should return ExternalDependency, not sure

[jrgonzalez]

ok, thanks!, it has been really helpful, at least looks there is some path this way 🙂. I will keep tinkering..

[gildor]

Ahh, correct, I see it now in generic, function that you showed above, only for module dependencies, not for external dependency

[gildor]

I still think that global configuration resolution is just better solution

[jrgonzalez]

but the odd thing is that with Groovy it works

[gildor]

Exclude those dependencies from all modules in allproject block

[gildor]

This also will work

[jrgonzalez]

I mean, I can pass a dependency created with the create() method to implementation() and it just takes it

[gildor]

Because groovy dynamic, try to use add(), it probably also will work

[gildor]

It should have compatible overload for this case

[gildor]

But usage of not type safe add Imo just destroying all the idea of type safe dependency definition

[gildor]

So global configuration resolution strategy imo the best, keeps your dependency definition and usage simple and obvious

[gildor]

Also solves problem of transitive dependencies which also can bring excluded dependencies

[jrgonzalez]

yes, it kinda also feels like if somehow the Groovy variant of implementation method allowing what I did before is not accesible through the Kotlin DSL

[jrgonzalez]

there are some calls of add with an ExternalModuleDependency but it requires like 3 parameters 😅

[jrgonzalez]

oh, not even that, is not an ExternalModuleDependency but its configuration

[jrgonzalez]

so I guess, yes, I should go the global route

[jrgonzalez]

this also seems to work:

implementation(Dependencies.retrofitConverterSimplexml) {
    exclude(module = "stax-api")
    exclude(module = "stax")
    exclude(module = "xpp3")
  }

[jrgonzalez]

which would mean basic unconfigured dependency declaration and duplicated config block per usage

[gildor]

add("implementation", ...) is the same as "implementation"(...), But in both cases you lose type safety

[jrgonzalez]

yes, deleted cause I think it was wrong, was trying to trick it to use the groovy version of implementation that supports a dependency as single parameter 😅

[jrgonzalez]

it seems to accept several things, but I can not fully compile the project yet to be sure they are valid and doing what I intend. This compiles too:

withGroovyBuilder {   "implementation(${Dependencies.retrofit2ConverterSimpleXML(this@dependencies)})"
  }

[jrgonzalez]

but I am only guessing there and it is type unsafe as soon as you add groovy in

[jrgonzalez]

The global exclude is also a bit tricky, may work for this one, but on others I am excluding for different reasons, not all versions of a module but only those coming transitively on a specific dependency due to conflicts. The duplicated config section may be better for now to not have several different ways to do the same

[jrgonzalez]

Also, luckily I don't have many that need configuration

[jrgonzalez]

and it even seems some of those issues are fixed since last time I checked, so maybe I can remove a few more customizations

[jrgonzalez]

Thanks for all your help, 1am here, time to sleep 😄

[gildor]

You don't need groovy builder for this, I will check later today

[gildor]

I agree, global exclude may be not so straight forward, but usually it's more stable and clean solution.
To solve version conflict you also can use global configuration resolution, I would still take a look on this solution

[jrgonzalez]

Also, there is another type of configuration I have on some dependencies, that require isTransitive = true which I am not sure if it has a global way.

[gildor]

Why is your use case for isTransitive = true? This is default behavior of any dependency

[jrgonzalez]

It fails without it on an old Twitter dependency I have not had time to remove since they discontinued it. I will post when I'm back at home in a bit, I have no idea why it fails without the isTransitive either.

[jrgonzalez]

I have also seen instructions for several libs that say to include it like that so there may be some differences. Others like glide had it and then seemingly removed the requirement but I'm not sure what changed.

[gildor]

Could you show this dependency?

[jrgonzalez]

This is it on "normal" syntax:

implementation("com.twitter.sdk.android:tweet-composer:3.3.0@aar") {
    isTransitive = true
  }

[jrgonzalez]

without the isTransitive my build fails with unknown com.twitter.sdk.android.core package

[gildor]

Just remove <@U27HSU2U9> and isTransitive

[gildor]

Those guys from Twitter don't know how to use dependencies probably. Because explicit declaration of resources extension obviously disables transitive dependencies (because you cannot get transitive dependencies without pom file)

[jrgonzalez]

Oh, ok, so maybe the others I have with @aar also should get rid of it. I thought it was something to distinguish aar vs jar or something like that.

[jrgonzalez]

seems to compile now with just implementation(Dependencies.twitterSdkTweetComposer) 🎉

[gildor]

👍

[gildor]

Really not sure how they decided to use such config, maybe some super old legacy when they don't have pom, only raw aar.
Funny, that Crashlytics used the same strange config in their docs when they owned by Twitter, now Google acquired them and this thing moved also to Firebase docs for Crashlytics 😬