CODEWITHSUNDEEP
javagradle
Bobbake4
Bobbake4

Reputation: 24857

Adding local plugin to a Gradle project

I have a Gradle plugin that compiles and works as expected. I would like to distribute with the source code an example application using the Gradle plugin which would also allow me to test changes to the plugin easily. Now to do this I must add a classpath dependency to the buildScript block. Is it possible to add a dependent local plugin that will be compiled with the example project? The main issue I'm having now is that the plugin does not exist when trying to sync the example project resulting in a failure.

Upvotes: 57

Views: 57725

Answers (5)

RaGe
RaGe

Reputation: 23677

If writing integration tests is your eventual goal, I still recommend using ProjectBuilder. You can see an example of this in Section 39.5.4 here. There are a lot more real-world test implementation examples in gradle source. See here for instance.

That being said, I got curious about the literal question you posted and tried a few things. What did work for me is this:

buildscript{
    repositories{
        ...
    }
    
    dependencies{
        classpath files('relative/path/to/plugin.jar')
    }
}

apply plugin: fully.qualified.package.PluginClassName

Note that the class name is not enclosed in 'quotes' to make it a string.

This is not very useful since this declaration requires the plugin.jar to be built and available before the project consuming the plugin is built - but at this point, you might as well be depending on an external repo dependency.

A second problem with this is that the transitive dependencies of the plugin project are not added to your plugin-consumer project automatically.

I couldn't get a project dependency like classpath project(':plugin-project') to work inside buildscript.

One (extremely hacky) way to ensure that the plugin project is always build and available while building the plugin-consumer project is to have a "parent" build.gradle that always builds the plugin first before building the consumer project. I uploaded an example here.

UPDATE (2024) The (excellent!!!) code in the github repository still works, except for the old syntax for the list task, you can use tasks.register() or comment that task out. There is no gradle wrapper, but a wrapper from another project worked for me: ../../myplugin621/gradlew build (621 for Gradle v6.2.1).

A real gotcha is that you MUST use the old syntax for applying YOUR plugin (that is, you need to mix the old syntax with the new one):

plugins {
    id 'application'
}
apply plugin: 'io.github.myname.myplugin'

(worked for me with Gradle 8.9)

Upvotes: 46

Cristian
Cristian

Reputation: 200080

Found a clean way to do it with composite builds, as Doron noticed. These are the steps:

  • Define your plugin with a build.gradle that has group:
// some-plugin/build.gradle
...
group = "some.group.id"
...
  • Reference your project in the settings.gradle like this:
// settings.gradle
...
includeBuild 'some-plugin'
  • In your projects you can make use of the plugin by:
// some-project/build.gradle
buildscript {
  dependencies {
    classpath "some.group.id:some-plugin"
  }
}

apply(plugin: "your.plugin.id")

Notice how the classpath is made out of the group defined in the plugin's gradle file and the name of its directory.

Upvotes: 14

Siddharth Yadav
Siddharth Yadav

Reputation: 161

Addition to above answer. You need to also add "gradlePlugin" along with "uploadArchives" something like below:

gradlePlugin {
    plugins {
        testgen {
            id = "com.egos.gradle.plugins"
            implementationClass = "com.egos.gradle.plugins.<PluginClassName>"
        }
    }
}

instead of this set your plugin classname. Rest remains same as above answer. Thanks!

Upvotes: 3

Egos Zhang
Egos Zhang

Reputation: 1354

I encounter when i want to debug my gradle plugin in Android Studio, I solve it finally.

First, upload your gradle plugin to local maven.

apply plugin: 'java'
apply plugin: 'groovy'
apply plugin: 'maven'

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile gradleApi()
}

sourceCompatibility = "1.7"
targetCompatibility = "1.7"


group='com.egos.gradle.plugins'
name='plugintest'
version='0.0.1'

uploadArchives {
    repositories {
        mavenDeployer {
            repository(url: uri('../repo'))
        }
    }
}

execute gradle uploadArchives . Then use local plugin.

buildscript {
    repositories {
        maven {
            url uri('../repo')
        }
    }
    dependencies {
        classpath group: 'com.egos.gradle.plugins',
                  name: 'plugintest',
                  version: '0.0.1'
    }
}

apply plugin: 'com.egos'

Upvotes: 19

Doron Gold
Doron Gold

Reputation: 3779

With the current Gradle version (3.3 as of writing) you can use the Composite Build feature to substitute plugin dependencies.

For example, you can build your example project with the following command (run in the root of your example project): gradle build --include-build /path/to/local-plugin

This would pick up your plugin from your local directory. It would even build your plugin first, then build your example project with the just built plugin as dependency.

This feature is also supported by IDEs: Simple instructions for configuring Composite Build in IntelliJ

See docs here: https://docs.gradle.org/current/userguide/composite_builds.html

Notice that substituting plugins only works with the buildscript block but not with the plugins block.

Upvotes: 9

Related Questions