How do I define a compile-time *only* classpath in Gradle?

Question

Can someone please give me a simple build.gradle example of how I can specify compile-time-only classes that are not included in the runtime deployment (war).

Gradl

Answer 1

The OP apparently didn't look for an Android answer, but some answers are specific to Android. So I suggest you look at this page : http://tools.android.com/tech-docs/new-build-system

Version 0.9.0 introduced a provided scope. So, just use

dependencies {
    provided "groupId:artifcatId:version"
}

Answer 2

I figured it out for my project setup. I use Android Studio running with the gradle plugin 0.9.+ with gradle 1.11 The main project uses amazon ads and amazon inapp purchases. It depends on a library project using amazon device messaging(ADM).

My main issue was with the the ADM where I got the "RuntimeException: Stub!" error.

1.) Library Project: The "provided configuration" proposed by Lukas does not work, as stated by him, so I used Richards approach, which however did not work as well out of the box. I had to change it a little since I could not find the lib in the ext_libs folder of the aar file. Gradle seems to pack all libraries in the libs folder in the in the final aar-file.

android.libraryVariants.all { variant ->
variant.packageLibrary.exclude( 'libs/amazon-device-messaging-1.0.1.jar' )
}

2.) Application Project : Here, the approach with the "provided configuration" worked.

configurations{
    provided
} 
dependencies {
    compile 'fr.avianey:facebook-android-api:+@aar'
    compile files('ext_libs/amazon-ads-5.3.22.jar')
    compile files('ext_libs/in-app-purchasing-1.0.3.jar' )
    provided files('ext_libs/amazon-device-messaging-1.0.1.jar')
}

android.applicationVariants.all {
    variant -> variant.javaCompile.classpath += configurations.provided
}

Answer 3

If you use the war plugin, providedCompile should do the trick. However if you need to exclude dependencies from being included in a jar, you'll have to extend the jar task. Below is an example for building a "fat jar" or "uber jar" (a single jar that includes all classes of its dependencies) excluding depndencies marked provided:

configurations {
    provided
    compile.extendsFrom provided
}

dependencies {
    provided "group.artifact:version"
    compile "group.artifact:version"
}

jar {
    dependsOn configurations.runtime
    from {
        (configurations.runtime - configurations.provided).collect {
            it.isDirectory() ? it : zipTree(it)
        }
    } 
}

Credit: http://kennethjorgensen.com/blog/2014/fat-jars-with-excluded-dependencies-in-gradle/

Update:

As of Gradle 2.12 the issue of defining compile only dependencies is finally solved in a simple and natural manner by the new "copmpileOnly" configuration:

dependencies {
    compileOnly 'javax.servlet:servlet-api:2.5'
}

Answer 4

It's quite common to have runtime dependencies that aren't compile time dependencies. The other way around is a fairly special case and as such requires a few lines of configuration in Gradle. I suggest to search the Gradle forum for provided.

It sounds like what you are really after is declaring dependencies for your build, not for the compile class path. How this is done depends on how the desired functionality gets invoked (Ant task, Gradle task/plugin, ad-hoc use from build script). If you provide more detailed information on what you are trying to do, I can provide a more specific answer.

Here are some links to relevant information in the Gradle user guide:

• External dependencies for the build script
• Declaring the class path for a custom Ant task

Answer 5

In Gradle 2.12 a compileOnly configuration has been introduced. A blog post introducing this features can be found here:

Gradle latest feature: Compile only dependencies

Please be aware of one important side effect:

As a result of the addition of the “compileOnly” configuration, the “compile” configuration no longer represents a complete picture of all compile time dependencies. When needing reference a compile classpath in build scripts or custom plugins, the appropriate source set’s compileClasspath property should be used instead.

Answer 6

It turns out that they have added a "provided" configuration in the gradle android plugin 0.8.0 but it doesn't quite work. It does add the provided libraries to the compile path automatically, but it also includes them in the final aar/apk.

What worked for me was the solution provided by @lukas-hanaceck but by changing the name from "provided" to any other custom name. In my case this is a library project which is a dependency for my final android application project. Heres a gist of what worked for me.

configurations {
   providedlibs
}

dependencies {
   providedlibs files('provided/library.jar')
}

libraryVariants.all {
    variant -> variant.javaCompile.classpath += configurations.providedlibs
}

It compiles perfectly and the provided/library.jar is not included in the final apk. The only issue I am having is notifying Android studio of the existence of library.jar. The idea plugin doesn't seem to work for Android studio. Im guessing that they have another custom plugin for syncing gradle with studio.