Cannot define anything in publishing block of build.gradle - maven

I'm trying to create a library and publish it to maven local. When I start trying to add a MavenPublication to publications, the IDE gives it a dotted underline like it's an unresolved reference. Same with parameters like from and artifact.
If I uncomment the pom block, gradle sync fails and says Cause: invalid type code: B3, ultimately because of org.gradle.internal.metaobject.AbstractDynamicObject$CustomMessageMissingMethodException on one of the parameters within.
This build.gradle file is in one of my modules. The top level build.gradle is pretty simple.
buildscript {
repositories {
mavenLocal()
mavenCentral()
maven { url "https://plugins.gradle.org/m2/" }
maven { url "https://oss.sonatype.org/content/repositories/snapshots/" }
jcenter()
}
dependencies {
}
}
allprojects {
apply plugin: "idea"
group = 'com.mygroup'
version = '1.0.0'
repositories {
mavenLocal()
mavenCentral()
jcenter()
maven { url "https://oss.sonatype.org/content/repositories/snapshots/" }
maven { url "https://oss.sonatype.org/content/repositories/releases/" }
}
}
And here's the module's build.gradle.
plugins {
id 'java-library'
id 'maven-publish'
id 'signing'
}
task sourcesJar(type: Jar) {
from sourceSets.main.allJava
archiveClassifier = 'sources'
}
task javadocJar(type: Jar) {
from javadoc
archiveClassifier = 'javadoc'
}
publishing {
publications {
mavenJava(MavenPublication) {
artifactId = 'mylibrary'
from components.java
artifact sourcesJar
artifact javadocJar
pom {
name = 'MyLibrary'
organization {
name 'MyOrg'
url 'www.myurl.com'
}
}
}
}
}
signing {
sign publishing.publications.mavenJava
}
javadoc {
if(JavaVersion.current().isJava9Compatible()) {
options.addBooleanOption('html5', true)
}
}
I'm using Gradle 5.1.1, IntelliJ Idea 2019.1.2, and JDK 12.0.1.

As it's a bit long explanation, let me clarify the situation here instead of replying in the comments to my question about providing the complete example with a pom-offender block. As the OP has already figured out, the problem is in the missing = sign. It's necessary for pom.organization and must not be present in the plugin.id.
For plugins block, it's a well-known Groovy convention of method call, which allow us to omit parentheses. And you can't use assignment here because id is not a property of a class. Look at the Gradle source code for plugins block.
However, if we look at pom.organization block we see the receiver of Action is MavenPomOrganization which has getName() and getUrl() returning Property<String> and not taking any arguments. From bare Groovy standpoint, it's definitely not the case of omitting parentheses. But I don't know for sure how the assignment syntax (name = 'MyOrg') works here under the hood. At first glance I can just speculate that it's some sort of Gradle magic using Groovy magic, e.g. AST transformation or something

Related

Define Kotlin's detekt version as extra property (ext)

Groovy allows definition of extra properties for the project in ext.
I wanted to define Detekt's version inside groovy's extra properties. Detekt is a static code analysis tool for Kotlin lang.
However when I do it in the folloing way:
buildscript {
// testing, code-style, CI-tools
ext.detect_code_analysis = '1.0.0.RC6-3' //change to 1.0.0 when available
repositories {
google()
jcenter()
}
dependencies {
classpath "com.android.tools.build:gradle:$gradle_version"
classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
}
}
plugins {
id "io.gitlab.arturbosch.detekt" version "$detect_code_analysis"
}
allprojects {
repositories {
google()
jcenter()
}
}
task clean(type: Delete) {
delete rootProject.buildDir
}
detekt {
version = "$detect_code_analysis"
profile("main") {
input = "$projectDir/app/src/main/java"
config = "$projectDir/detekt-config.yml"
filters = ".*test.*,.*/resources/.*,.*/tmp/.*"
}
}
it complaing with:
Error:(17, 0) startup failed:
build file '/Users[...]build.gradle': 17: argument list must be exactly 1 literal non empty string
See https://docs.gradle.org/4.1/userguide/plugins.html#sec:plugins_block for information on the plugins {} block
# line 17, column 5.
id "io.gitlab.arturbosch.detekt" version "$detect_code_analysis"
^
1 error
“New style” Gradle plug-in definition (without including the full dependency on buildscript block) does not allow variables in the version.
For more information refer to the section of documentation that’s referred to in the error message. There is a subsection “Limitations of the plugins dsl” that explains everything.
If you want to continue using the variable version strings you need to return to the “old way” by using the apply plugin: “xxx” syntax.
You cannot use variables in plugins {}: docs
Where «plugin version» and «plugin id» must be constant, literal
This is an open bug: Allow the plugin DSL to expand properties as the version
Just as #Strelok suggested the final workaround (until bug is fixed) is to:
add a classpath in buildscript.dependecies
change plugins to apply plugin: "io.gitlab.arturbosch.detekt"
Solution:
buildscript {
// testing, code-style, CI-tools
ext.detect_code_analysis = '1.0.0.RC6-3' //change to 1.0.0 when available
repositories {
google()
jcenter()
maven { url "https://plugins.gradle.org/m2/" }
}
dependencies {
classpath "com.android.tools.build:gradle:$gradle_version"
classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
classpath "gradle.plugin.io.gitlab.arturbosch.detekt:detekt-gradle-plugin:$detect_code_analysis"
}
}
apply plugin: "io.gitlab.arturbosch.detekt"
allprojects {
repositories {
google()
jcenter()
}
}
task clean(type: Delete) {
delete rootProject.buildDir
}
detekt {
version = "$detect_code_analysis"
profile("main") {
input = "$projectDir/app/src/main/java"
config = "$projectDir/detekt-config.yml"
filters = ".*test.*,.*/resources/.*,.*/tmp/.*"
}
}

Gradle: manage dependency/plugin versions in multi-project builds

I was working with Maven before Gradle and Maven has such things like dependencyManagement and pluginManagement what allows to keep all versions "DRY" in one place with help of "properties".
Gradle supports project properties, so I can declare versions like:
buildscript {
ext.kotlin_version = '1.1.61'
repositories {
mavenCentral()
}
dependencies {
classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
}
}
But this approach cannot be applied to plugins {} DSL. I cannot write something like this:
plugins {
id 'org.jetbrains.kotlin:kotlin-gradle-plugin' version $kotlin_version
}
As according to docs:
values must be literal (e.g. constant strings, not variables)
Is there a way to workaround this limitation?
The latest versions of Gradle allows you to define your versions in a property file, map that version in a pluginManagement block, and then omit the version from all downstream plugin blocks. The pluginManagement block does not have the only-constant restriction.
In fact, once you use this approach, it is a compile time error to even try to declare a version downstream.
After using this approach, there is a good chance you can completely omit your buildscript.
gradle.properties
kotlinVersion=1.3.50
settings.gradle
pluginManagement {
resolutionStrategy {
eachPlugin {
if (requested.id.id == "org.jetbrains.kotlin.jvm") {
useVersion(kotlinVersion)
}
}
}
}
build.gradle
plugins {
id("org.jetbrains.kotlin.jvm")
}
If you are into kotlinscript, get your version from a delegate:
settings.gradle.kts
val kotlinVersion: String by settings
pluginManagement {
resolutionStrategy {
eachPlugin {
if (requested.id.id == "org.jetbrains.kotlin.jvm") {
useVersion(kotlinVersion)
}
}
}
}
Of course, you do not need the properties file. You can just hard code the version in your gradle.settings. But by having the property, you can then declare dependencies to the stdlib using it.
I think you can put the ext closure in a separate properties.gradle, and then reference the properties twice in buildscript as well as project build (buildscript block is evaluated at the very beginning, before any other part of groovy script).
For example, in $projectRoot/gradle/properties.gradle as below:
ext {
kotlinVersion = '1.1.61' // NOTE, the naming convention is better with kotlinVersion instead of kotlin_version
}
And your $projectRoot/build.gradle would look like this:
buildscript {
apply from: "gradle/properties.gradle"
repositories {
jcenter()
}
dependencies {
println "In buildscript, kotlinVersion is $kotlinVersion"
}
}
apply plugin: 'java'
apply from: "gradle/properties.gradle"
repositories {
jcenter()
}
dependencies {
println "In project, kotlinVersion is $kotlinVersion"
}
When you run ./gradlew dependencies, it would show you the populated versions:
> Configure project :
In buildscript, kotlinVersion is 1.1.61
In project, kotlinVersion is 1.1.61

Apply external Plugin to a subset of subprojects

I am using the Gradle SSH Plugin to deploy some, but not all subprojects to two different remote machines. I want to configure these remotes in the main build script to avoid duplication, but cannot apply the plugin as per this:
configure([
project(':Subproject1'), project(':Subproject5'), project(':Subproject7')
])
{
buildscript {
dependencies {
classpath 'org.hidetake:gradle-ssh-plugin:2.4.2'
}
}
apply plugin: "org.hidetake.ssh"
ssh.settings {
user = getProperty('ssh.username')
identity = file(getProperty('ssh.identity'))
knownHosts = allowAnyHosts
}
remotes {
tomcat {
host = getProperty('ssh.hosts.tomcat')
}
jboss {
host = getProperty('ssh.hosts.jboss')
}
}
}
Gradle fails with > Plugin with id 'org.hidetake.ssh' not found.
Everything is fine when the contents of the configuration closure are applied per project. How can I elegantly solve this issue?
Guessing here as I haven't reproduced your issue, but the buildscript block is special as it is pre-parsed before normal groovy parsing of the build files and I suspect that having it inside a project block like you have will not work.
Have you tried moving the buildscript block to the root level in the script above?
edit 1: old gradle forums post discussion this can be found here
edit 2: adding a snippet of code in response to a comment.
To remove duplication and only define say the repository references in one place, you could use the following pattern:
buildscript {
ext.RepositoryConfigurator = {
maven {
credentials.username artifactoryReader
credentials.password artifactoryReaderPwd
url artifactoryReaderUrl
}
jcenter()
mavenCentral()
}
ext.DependencyConfigurator = {
classpath "org.sonarsource.scanner.gradle:sonarqube-gradle-plugin:1.2"
}
ext.ResolutionConfigurator = {
resolutionStrategy.cacheChangingModulesFor 60, 'minutes'
}
repositories RepositoryConfigurator
dependencies DependencyConfigurator
configurations.classpath ResolutionConfigurator
}
apply plugin: "some.plugin.requiring.above.classpath"
gradle.rootProject {
buildscript {
repositories RepositoryConfigurator
dependencies DependencyConfigurator
configurations.classpath ResolutionConfigurator
}
}
gradle.allprojects {
buildscript {
repositories RepositoryConfigurator
dependencies DependencyConfigurator
configurations.classpath ResolutionConfigurator
}
}
In other words: since the buildscript block is special and pre-parsed, you can not use things defined elsewhere in the buildscript block. Going in the other direction is ok though, i.e. you can define things in the buildscript block which are then visible elsewhere. We can use this to define the repository references once inside the buildscript block and then use that reference in other places in the build file.
The above is from a settings.gradle file so might or might not be a perfect fit, but should demonstrate the idea.

Gradle: How can I configure repositories in buildscript block of external script

In external script common/buildversion.gradle I have:
buildscript {
// Copy repositories definitions from this buildscript to all projects
(allprojects*.repositories + [repositories]).each {
it.configure {
apply from: rootProject.file('../../common/repositories.gradle')
}
}
dependencies { classpath "org.sonarsource.scanner.gradle:sonarqube-gradle-plugin:1.2" }
}
apply plugin: org.sonarqube.gradle.SonarQubePlugin
In common/repositories.gradle:
repositories{
maven { url "https://plugins.gradle.org/m2/" }
}
I am getting error:
Cannot resolve external dependency
sonarqube-gradle-plugin because no repositories are
defined.
Here is a way to have a single source for repositories definitions.
declare the repositories as an "ext" variables
// repositories.gradle
ext.repos = {
maven {
name "repo1"
url "repo1_url"
}
maven {
name "repo2"
url "repo2_url"
}
}
"apply" in your build.gradle
// build.gradle
apply from: "${project.projectDir}/repositories.gradle"
use variable in repositories declaration
// build.gradle
repositories repos
Externalizing sections of the buildScript block into other scripts is not supported. There is an open defect, you should vote on it.

Gradle Custom buildScriptRepository methods

I would like to make a custom buildScript repository method so I can easily reference our internal maven repo. Right now I'm required to declare a maven block everywhere we use our plugin.
Here is the current setup
buildscript {
repositories {
jcenter()
maven { url 'http://myNexus:8081/nexus/content/repositories/My-Release' }
}
dependencies {
classpath 'com.example.plugin:my-plugin:1+'
}
}
What I would like to do is something like this
buildscript {
repositories {
jcenter()
myReleaseRepo()
}
dependencies {
classpath 'com.example.plugin:my-plugin:1+'
}
}
How can I make a method available to create a repository anywhere we may use the plugin in the future?
Another solution is to add custom methods on RepositoryHandler using some Groovy goodness. Just chuck this in ~/.gradle/init.gradle
RepositoryHandler.metaClass.myReleaseRepo = {
delegate.maven {
name 'myReleaseRepo'
url 'http://myNexus:8081/nexus/content/repositories/My-Release'
}
}
After that, you can use it just as you described:
buildscript {
repositories {
myReleaseRepo()
}
}
Metaclasses in Groovy are just great. The delegate in this case is pretty much like the javascript this. This code is essentially using the RepositoryHandler instance (delegate keyword) and just calling repositoryHandlerInstance.maven(name, url).
It is possible to add a repo to an init script which would then apply to all gradle invocations that use the init script - without having to individually declare your maven repo in each build.gradle.
Solution 1:
Partial solution, does not do exactly what you're asking for. In init.gradle:
allprojects{
buildscript{
repositories{
maven{ url 'http://myNexus:8081/nexus/content/repositories/My-Release' }
}
}
}
Then your build.gradle can skip buildscript repo declaration entirely:
buildscript {
dependencies {
classpath 'com.example.plugin:my-plugin:1+'
}
}
Solution 2:
In fact, you can even move your buildscript classpath declaration to init and have the plugin apply to all projects that use the init script:
beefier init.gradle
allprojects{
buildscript{
repositories{
maven{ url 'http://myNexus:8081/nexus/content/repositories/My-Release' }
}
dependencies {
classpath 'com.example.plugin:my-plugin:1+'
}
}
}
gives you a lighter build.gradle
apply plugin: 'my-plugin'
I tried to, but apparently you cannot move the apply line to init.gradle as well. see this defect.
Solution 3:
I retract what I said in the comment above, I figured out how to do exactly what you're asking for. Apparently you can create extensions for the buildscript block using the initscript. However I still prefer solution2, because it gives you a cleaner build.gradle.
To create a buildscript extension, in your init.gradle:
class customRepos {
def buildscript
customRepos(buildscript) {
this.buildscript = buildscript
}
void addMyRepo() {
buildscript.repositories {
maven{ url 'http://myNexus:8081/nexus/content/repositories/My-Release' }
}
}
}
allprojects {
extensions.create('myRepo', customRepos, buildscript)
}
which then allows you to do this in your build.gradle
buildscript{
myRepo.addMyRepo()
dependencies {
classpath 'com.example.plugin:my-plugin:1+'
}
}
apply plugin: 'my-plugin'

Resources