How to build Groovy JAR w/ Gradle and publish it to in-house repo

Question

I have a Groovy project and am trying to build it with Gradle. First I want a package task that creates a JAR by compiling it against its dependencies. Then I need to generate a Maven POM for that JAR and publish the JAR/POM to an in-house Artifactory repo. The build.gradle:

apply plugin: "groovy"
apply plugin: "maven-publish"

repositories {
    maven {
        name "artifactory01"
        url "http://myartifactory/artifactory/libs-release"
    }
}
dependencies {
    compile "long list starts here"
}

// Should compile up myapp-<version>.jar
jar {
}

// Should publish myapp-<version>.jar and its (generated) POM to our in-house Maven/Artifactory repo.
publishing {
    publications {
        myPublication(MavenPublication) {
            from components.java
            artifact sourceJar {
                classifier "source"
            }

            pom.withXml {
                // ???
            }
        }
    }
}

task wrapper(type: Wrapper) {
    gradleVersion = '1.11'
}

However I do not believe I have set up versioning correctly with my jar task (for instance, how could I get it creating myapp-1.2.1 vs. myapp-1.2.2? I also don't think I have my publications configuration set up correctly: what should go in pom.withXml?

JBaruch · Answer 1 · 2014-08-12T10:08:20.357

You're more than welcome to use artifactory plugin for that. The documentation can be found in our user guide and below you can find a full working example of gradle build.

Run gradle build artifactoryPublish to build and publish the project.

buildscript {
    repositories {
        jcenter()
    }
    dependencies {
        classpath(group: 'org.jfrog.buildinfo', name: 'build-info-extractor-gradle', version: '3.0.1')
    }
}
apply plugin: 'java'
apply plugin: 'maven-publish'
apply plugin: 'com.jfrog.artifactory'

group = 'com.jfrog.example'
version = '1.2-SNAPSHOT'
status = 'SNAPSHOT'

dependencies {
    compile 'org.slf4j:slf4j-api:1.7.5'
    testCompile 'junit:junit:4.11'
}

task sourcesJar(type: Jar, dependsOn: classes) {
    classifier = 'sources'
    from sourceSets.main.allSource
}

publishing {
    publications {
        main(MavenPublication) {
            from components.java
            artifact sourcesJar
    }
}

artifactory {
    contextUrl = 'http://myartifactory/artifactory'
    resolve {
        repository {
            repoKey = 'libs-release'
        }
    }
    publish {
        repository {
            repoKey = 'libs-snapshot-local'
            username = 'whatever'
            password = 'whatever123'
        }
        defaults {
            publications 'main'
        }
    }
}

Thanks @JBaruch, I'll certainly give it a try! Curious: how would I package (JAR up) and publish a JAR using this buildscript? I assume `gradle jar` and `gradle publish`? Thanks again! — Venkat, Aug 12 '14 at 09:21

Peter Niederwieser · Answer 2 · 2014-08-12T07:30:57.730

package is a keyword in Java/Groovy, and you'd have to use a different syntax to declare a task with that name.

Anyway, the task declaration for package should be removed, as the jar task already serves that purpose. The jar task configuration (jar { from ... }) should be at the outermost level (not nested inside another task), but from configurations.compile is unlikely what you want, as that will include Jars of compile dependencies into the Jar (which regular Java class loaders can't deal with), rather than merging them into the Jar. (Are you even sure you need a fat Jar?)

Likewise, the publish task declaration should be removed, and replaced with publishing { publications { ... } }.

Also, the buildscript block should probably be removed, and repositories { ... } and dependencies { ... } moved to the outermost level. ( buildscript { dependencies { ... } } declares dependencies of the build script itself (e.g. Gradle plugins), not the dependencies of the code to be compiled/run.)

I suggest to check out the many self-contained example builds in the samples directory of the full Gradle distribution (gradle-all).

Thanks @Peter Niederwieser - please see my edits. Your input was very helpful and I pieced it together with the code samples in `gradle-all` like you suggested. I do, however, have a few follow up questions: (1) how do I implement versioning when running `gradle jar`? And for publishing, what should I be putting inside `pom.withXml`? — Venkat, Aug 12 '14 at 08:33
You set the `version` property. No need to use `pom.withXml` unless you want to add additional (and optional) information to the POM. — Peter Niederwieser, Aug 12 '14 at 14:30

How to build Groovy JAR w/ Gradle and publish it to in-house repo

2 Answers2

Linked