> For the complete documentation index, see [llms.txt](https://ondrej-kvasnovsky-2.gitbook.io/gradle-handbook/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://ondrej-kvasnovsky-2.gitbook.io/gradle-handbook/plugin.md).

# Plugin

Plugins can extend other plugins. For example, `war` plugin extends `java` plugin. That means, we can remove `apply plugin: 'java'` if we are using `war` plugin.

## Script plugin

Script Plugins are plugins that live in a `.gradle` file and can be imported in other gradle build files.

We can create a plugin using local script file. In order to create a new script plugin, create a file `scriptPlugin.gradle` and put there the plugin code.

```
// scriptPlugin.gradle
task myScriptPluginTask(description: 'Testing script plugins', group: 'Testing') {
    if (project.hasProperty('myName')) {

        inputs.property('myName', myName)
        inputs.file file('gradlew')

        doLast {
            println "Hi there $myName :) "
            println file('gradlew').text
        }
    }
}
```

Then we can import that plugin in our build.gradle file.

```
apply from: 'scriptPlugin.gradle'
```

We can execute the task from the script plugin.

```
gradle myScriptPluginTask -PmyName=Ondrej�
```

## Object plugin

Object plugin can live in its own Gradle project, in src folder. Or the object plugin can be placed into buildSrc if it is supposed to live next to project.

We need to add the internal dependencies into Gradle build.

```
// enable writing gradle tasks in buildSrc
apply plugin: 'groovy'
dependencies {
    compile gradleApi()
    compile localGroovy()
}
```

Lets create a object plugin. First create the plugin class and put this class into `buildSrc/src/main/groovy`.

```
package com.test

import org.gradle.api.Plugin
import org.gradle.api.Project

class MyPlugin implements Plugin<Project> {

    @Override
    void apply(Project project) {
        // add plugin extension
        def extensionName = 'mySuperPlugin'
        def extension = project.extensions.create(extensionName, MyPluginExtension)
        // gradle myTaskFromPlugin
        project.task('myTaskFromPlugin') {
            doLast {
                println extension.myName
            }
        }
    }
}
```

To try out plugin extensions, create another class, next to the `MyPlugin` class.

```
package com.test

class MyPluginExtension {
    String myName = 'Default message...'
}
```

Then create a new properties file in `resource` folder `META-INF/gradle-plugins/myplugin.properties` that declares name of the plugin. Name of this file says what is the name of the plugin.

```
# assigns meaningful name to a plugin
implementation-class=com.test.MyPlugin
```

If we don't create the myplugin.properties file, we would have to apply

```
apply plugin: com.test.MyPlugin
```

But because we provided the properties file, we can reference the plugin by its name.

```
apply plugin: 'myplugin' // loaded using META-INF/gradle-plugins/myplugin.properties
```

Before we continue, we can configure the plugin using the plugin extension.

```
// set value of extension
mySuperPlugin {
    myName = 'Value from gradle.build is passed into plugin via an extension'
}
```

## IDE integration

We can use IDE plugins to generate project files (to avoid project IDE files committed in source code repository, like Git).

```
allprojects {
    apply plugin: 'eclipse'
    eclipse {
        project {
            name = 'Learning Gradle'
            // you can even generate web.xml using this
        }
    }

    apply plugin: 'idea'
    idea {
        project {
            jdkName = '1.8'
            module {
                downloadSources = true
                downloadJavadoc  = true
            }
        }
    }
}
```


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://ondrej-kvasnovsky-2.gitbook.io/gradle-handbook/plugin.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.