This message was deleted.

The issue is this

schema.map { project.zipTree(it) }

The map here is not (!!) the Gradle provider map {}. But the normal Kotlin Collections map {}. Because a configuration can be treated as a set of files (Gradle then sneakily resolves the Configuration…) this method is offered here. This is unfortunately very easy to get wrong. 😞 There is a lot of “legacy” in the Configuration API that would be nice if it could be removed. When you call this map {}, Gradle looses all task dependency information. Instead, you can use

schema.elements

to get a provider for files/folder. On this you can use Gradle’s map{}. I think something like:

schema.elements.map { zipTree(it) }

could work.

Thank you,

schema.elements

brought me on the right track, just needed to tweak the

from

of my copy/unzip task a bit, bc.

zipTree

didn't like collections of files. Ended up with this:

val unpackSchemaDependencies by project.tasks.registering(Copy::class) {
    group = "build setup"
    description = "Extrahiert die Schema-Abhängigkeiten"
    from(schema.elements.map {
        var fc = project.files()
        it.forEach { fc.from(project.zipTree(it)) }
        return@map fc
    })
    into(schemaArtifactSpec._dependenciesDir)
}

Glad that it helped. The publishing could be “better” modelled using a component (

project.components

). So that the publication is only configured by

from(myComponent)

. And no direct reference of artifacts or modification of pom files. Have a look at: https://docs.gradle.org/current/userguide/publishing_customization.html#sec:publishing-custom-components

Thank you, that finally forced me to wrap my head around the components concept. 😀 I almost got it working, the only thing missing is that I can't seem to convince it to produce the "type" attribute in the POM dependencies (I want

<type>zip</type>

). Explicitly setting the type on the outgoing artifact doesn't seem to do the trick and I found no API to map a type for the Maven dependency (e.g. similar to

mapToMavenScope

)

val `schema-artifact` by project.configurations.creating {
    isTransitive = true
    isCanBeConsumed = true
    isCanBeResolved = false
    extendsFrom(schema)
    attributes {
        attribute(Category.CATEGORY_ATTRIBUTE, project.objects.named(Category.DOCUMENTATION))
        attribute(DocsType.DOCS_TYPE_ATTRIBUTE, project.objects.named("schema"))
        attribute(Bundling.BUNDLING_ATTRIBUTE, project.objects.named(Bundling.EXTERNAL))
        attribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, project.objects.named("schema-artifact"))
    }
    outgoing {
        artifact(schemaZip) {
            type = Zip.ZIP_EXTENSION
        }
    }
}

val schemaComponent = softwareComponentFactory.adhoc("schema")
project.components.add(schemaComponent)
schemaComponent.addVariantsFromConfiguration(`schema-artifact`) {
}

project.configure<PublishingExtension> {
    publications {
        maybeCreate<MavenPublication>(KONS_PUBLICATION).apply {
            from(schemaComponent)
        }
    }
}

Why can’t you rely on the Gradle Metadata? There your variant/attributes are published and things should just work.

For gradle consumers of those artifacts it will certainly do, but we'll likely have some inhouse teams using Maven. The suggested workaround will do nicely 🙂 Thanks again for all the help 👏