From mobile apps to microservices, from small startups to big enterprises, Gradle helps teams build, automate and deliver better software, faster.

Gradle Community

Not 100% but I doubt it.
What would be the use-case to upload to repo A signed but to repo B unsigned?

I basically only have one "real" remote repo, and Maven local. For the latter I want to skip signing. Going forward, I might also skip signing for artifacts published to a private snapshot repository.

But what is the problem to sign if you actually can sign? Does it break something if you upload signed?

I am skipping signing the artifacts when publishing `-SNAPSHOT` versions and/or when running `publishToMavenLocal` tasks

No, but I'd like to 1) limit the sharing of signing secrets in a team, and 2) avoid forcing devs to set up "fake" signing just because they want to publish to Maven local.

Ah, ok, now we come to it. :slightly_smiling_face:

Simplified setup of what I have:
```configure&lt;SigningExtension&gt; {
    val hasPublishToMavenLocalTasks: Boolean =
        allTasks.any { task -&gt;
            task == "publishToMavenLocal" ||
                task == "publishToMavenLocalTest" ||
                task == "publishToMavenLocalBuildTest" ||
                task == "publishAllPublicationsToMavenLocalTestRepository" ||
                task == "publishAllPublicationsToMavenLocalBuildTestRepository"
        }
    isRequired = hasPublishToMavenLocalTasks
}```

How about setting "signing required" only if some project property is set, so you can set it to true where you need to sign, e. g. CI that publishes. In all other cases it will then skip signing if no signatory is configured and do the signing if it is present anyway.

I really miss a lot `isRequired`  is not accepting a `Provider`

Yep, indeed the whole approach I have, it is doing that at the end, where `shouldSign` is a Gradle project property

```isRequired = (hasTaskCondition &amp;&amp; hasSemverCondition) || shouldSign.get()```

In my case, I'll try
```    setRequired({
        val mavenPublishingTasks = tasks.withType&lt;PublishToMavenRepository&gt;()
        mavenPublishingTasks.any { gradle.taskGraph.hasTask(it) }
    })```

But that would avoid signing in all cases, right?

I don't think so... publishing to Maven local uses a different task type if I'm not mistaken.

This is what I have:
```signing {
    setRequired {
        // signing is required if this is a release version and the artifacts are to be published
        // do not use hasTask() as this require realization of the tasks that maybe are not necessary
        releaseVersion &amp;&amp; gradle.taskGraph.allTasks.any { it is PublishToMavenRepository }
    }
    sign(publishing.publications)
}```

It's lazy if you pass a lambda to it :slightly_smiling_face:

See the remark at <https://docs.gradle.org/current/userguide/signing_plugin.html#sec:conditional_signing>

Chances are it becomes a proper `Property` in Gradle 9 though: <https://github.com/orgs/gradle/projects/31/views/1?pane=issue&amp;itemId=5719703>