AbstractArchiveTask is the base class for all archive tasks.

Base implementation for build cache service configuration.

Common superclass for all ClasspathEntry instances.

The base class for all JVM-based language compilation tasks.

AbstractCopyTask is the base class for all copy tasks.

Displays the dependency tree for a configuration.

AbstractExecTask is the base class for all exec tasks.

Common superclass for the library elements.

Base task for linking a native binary from object files and libraries.

Compiles native source files into object files.

Compiles native header source files into object files.

Compiles native source files into object files.

Base class for compilation-related options.

Base class for tasks that publish a org.gradle.api.publish.maven.MavenPublication.

The base class for all project report tasks.

An abstract Scala compile task sharing common functionality for compiling scala.

Convenience base class for SignatureType implementations.

Convenience base class for SignatureTypeProvider implementations.

Abstract class for all test task.

• Support for test listeners
• Support for reporting
• Support for report linking in the console output

Note: This abstract class is not intended for implementation by build script or plugin authors.

Access rule associated with an Eclipse classpath entry.

Access rule associated to a classpath entry.

Performs some action against objects of type T.

Allows specification of configuration for some action.

The configuration is represented using zero or more initialization parameters to use when constructing an instance of the implementation class. The following types are supported:

• String
• Boolean
• Integer, Long, Short and other Number subtypes.
• java.io.File
• A java.util.List or java.util.Set of any supported type.
• An array of any supported type.
• A java.util.Map with keys and values of any supported type.
• An Enum type.
• A Named type created using org.gradle.api.model.ObjectFactory#named(Class, String).
• Any serializable type.

A org.gradle.api.specs.CompositeSpec which requires all its specs to be true in order to evaluate to true. Uses lazy evaluation.

This plugin allows to send announce messages to Twitter.

The extension used by the AnnouncePlugin.

An Announcer allows messages to be sent.

An AntBuilder allows you to use Ant from your build script.

An AntBuilderAware represents an object which can add itself to Ant tasks, using an org.gradle.api.AntBuilder.

A task which executes an Ant target.

A plugin for adding Antlr support to JavaPlugin.

Contract for a Gradle "convention object" that acts as a handler for what I call a virtual directory mapping, injecting a virtual directory named 'antlr' into the project's various org.gradle.api.tasks.SourceSet.

Generates parsers from Antlr grammars.

Assembles an "API Jar" containing only the members of a library's public API.

This task and the Jar it produces are designed primarily for internal use in support of Gradle's "compile avoidance" performance feature. The task is automatically included in the task graph for any JVM library that declares an api { ... } specification, and the resulting Jar will automatically be placed on the compile time classpath of projects that depend on the library in lieu of the library's complete so-called "Runtime Jar".

Swapping the API Jar in for the Runtime Jar at compile time is what makes "compile avoidance" possible: because the contents of the API Jar change only when actual API changes are made, the API Jar passes Gradle's up-to-date checks, even if the implementation in the Runtime Jar has changed. Ultimately, this means that projects depending on the library in question will need to recompile potentially far less often.

In order to ensure that API Jars change as infrequently as possible, this task and its supporting classes ensure that only actual public API members are included in the API Jar, and that the methods among those members are stripped of their implementation. Because the members included in API Jars exist only for compilation purposes, they need no actual implementation, and for this reason, all such methods throw UnsupportedOperationException in the unlikely event that they are present on the classpath and invoked at runtime.

The inputs to this task are Java class files which must be provided via org.gradle.api.tasks.TaskInputs.

A software application.

A binary produced from a `org.gradle.platform.base.ApplicationSpec`.

A Plugin which runs a project as a Java Application.

The plugin can be configured via its companion ApplicationPluginConvention object.

The Convention used for configuring the ApplicationPlugin.

A specification of a org.gradle.platform.base.Application.

Represents a plugin that has been applied.

Currently just provides information about the ID of the plugin.

A cpu architecture. Instruction Set 32-bit names 64-bit names Intel x86 "x86", "i386", "ia-32", "i686" "x86_64", "amd64", "x64", "x86-64" Intel Itanium N/A "ia-64", "ia64" Power PC "ppc" "ppc64" Sparc "sparc", "sparc32", "sparc-v8" "sparc64", "ultrasparc", "sparc-v9" ARM "arm", "arm-v7", "armv7", "arm32" "arm64", "arm-v8"

Armored signature type.

An artifact of a software component that may be requested in the result of an artifact query.

A collection of artifacts resolved for a configuration. The configuration is resolved on demand when the collection is queried.

This class is for defining artifacts to be published and adding them to configurations. Creating publish artifacts does not mean to create an archive. What is created is a domain object which represents a file to be published and information on how it should be published (e.g. the name).

To create an publish artifact and assign it to a configuration you can use the following syntax:

The notation can be one of the following types:

• PublishArtifact.
• org.gradle.api.tasks.bundling.AbstractArchiveTask. The information for publishing the artifact is extracted from the archive task (e.g. name, extension, ...). The task will be executed if the artifact is required.
• A org.gradle.api.provider.Provider of java.io.File, org.gradle.api.file.RegularFile or org.gradle.api.file.Directory. The information for publishing the artifact is extracted from the file or directory name. When the provider represents an output of a particular task, that task will be executed if the artifact is required.
• java.io.File. The information for publishing the artifact is extracted from the file name.
• java.util.Map. The map should contain a 'file' key. This is converted to an artifact as described above. You can also specify other properties of the artifact using entries in the map.

In each case, a ConfigurablePublishArtifact instance is created for the artifact, to allow artifact properties to be configured. You can also override the default values for artifact properties by using a closure to configure the properties of the artifact instance

An example showing how to associate an archive task with a configuration via the artifact handler. This way the archive can be published or referred in other projects via the configuration.

 configurations { //declaring new configuration that will be used to associate with artifacts schema } task schemaJar(type: Jar) { //some imaginary task that creates a jar artifact with some schema } //associating the task that produces the artifact with the configuration artifacts { //configuration name and the task: schema schemaJar } 

The identifier for a module artifact.

A repository for resolving and publishing artifacts.

A ResolverContainer is responsible for managing a set of ArtifactRepository instances. Repositories are arranged in a sequence.

You can obtain a ResolverContainer instance by calling org.gradle.api.Project#getRepositories() or using the repositories property in your build script.

The resolvers in a container are accessible as read-only properties of the container, using the name of the resolver as the property name. For example:

 repositories.maven { name 'myResolver' } repositories.myResolver.url = 'some-url' 

A dynamic method is added for each resolver which takes a configuration closure. This is equivalent to calling #getByName(String, groovy.lang.Closure). For example:

 repositories.maven { name 'myResolver' } repositories.myResolver { url 'some-url' } 

A builder to construct a query that can resolve selected software artifacts of the specified components.

 apply plugin: 'java' task resolveCompileSources { doLast { def componentIds = configurations.compile.incoming.resolutionResult.allDependencies.collect { it.selected.id } def result = dependencies.createArtifactResolutionQuery() .forComponents(componentIds) .withArtifacts(JvmLibrary, SourcesArtifact, JavadocArtifact) .execute() for (component in result.resolvedComponents) { component.getArtifacts(SourcesArtifact).each { println "Source artifact for ${component.id}: ${it.file}" } } } } 

The result of executing an artifact resolution query.

The result of resolving an artifact.

Base class for artifact transformations.

An exception to report a problem during transformation execution.

Defines a set of known artifact types and related meta-data. This allows you to fine tune how dependency resolution handles artifacts of a specific type. Each entry in this container defines a particular artifact type, such as a JAR or an AAR, and some information about that artifact type.

Meta-data about a particular type of artifacts.

A view over the artifacts resolved for this set of dependencies. By default, the view returns all files and artifacts, but this can be restricted by component identifier or by attributes.

Translates Assembly language source files into object files.

Adds core Assembler language support.

A plugin for projects wishing to build native binary components from Assembly language sources.

Automatically includes the AssemblerLangPlugin for core Assembler support and the NativeComponentPlugin for native component support.

• Creates a org.gradle.language.assembler.tasks.Assemble task for each org.gradle.language.assembler.AssemblerSourceSet to assemble the sources.

A set of assembly language sources.

 apply plugin: "assembler" model { components { main(NativeLibrarySpec) { sources { asm { source { srcDirs "src/main/i386", "src/shared/asm" include "**/*.s" } } } } } } 

An attribute is a named entity with a type. It is used in conjunction with a AttributeContainer to provide a type safe container for attributes. This class isn't intended to store the value of an attribute, but only represent the identity of the attribute. It means that an attribute must be immutable and can potentially be pooled. Attributes can be created using the factory method.

A rule that determines whether a given attribute value is compatible some provided attribute value.

An attribute container is a container of Attribute, which are strongly typed named entities. Such a container is responsible for storing and getting attributes in a type safe way. In particular, attributes are strongly typed, meaning that when we get a value from the container, the returned value type is inferred from the type of the attribute. In a way, an attribute container is similar to a java.util.Map where the entry is a "typed String" and the value is of the string type. However the set of methods available to the container is much more limited. It is not allowed to have two attributes with the same name but different types in the container.

A rule that selects the best value out of a set of two or more candidates.

An attribute matching strategy is responsible for providing information about how an Attribute is matched during dependency resolution. In particular, it will tell if a value, provided by a consumer, is compatible with a value provided by a candidate.

Represent the attributes of a manifest section.

An attributes schema stores information about Attribute and how they can be matched together.

Base interface for transport authentication schemes.

Container for configuring repository authentication schemes of type org.gradle.authentication.Authentication.

An artifact repository which supports username/password authentication.

Represents credentials used to authenticate with Amazon Web Services.

Authentication scheme for digest access authentication over S3.

Base class that may be used for custom BinarySpec implementations. However, it is generally better to use an interface annotated with org.gradle.model.Managed and not use an implementation class at all.

Base class that may be used for custom GeneralComponentSpec implementations. However, it is generally better to use an interface annotated with org.gradle.model.Managed and not use an implementation class at all.

Specifies options for launching a child process.

Fork options for compilation. Only take effect if fork is true.

Base class that may be used for custom LanguageSourceSet implementations. However, it is generally better to use an interface annotated with org.gradle.model.Managed and not use an implementation class at all.

A org.gradle.api.Plugin which defines a basic project lifecycle and some common convention properties.

A Convention used for the BasePlugin.

Options for Scala platform compilation.

Authentication scheme for basic access authentication over HTTP. When using this scheme, credentials are sent preemptively.

Provides some basic details about a Gradle project.

IdeaProject that does not provide/resolve any external dependencies. Only project dependencies and local file dependencies are included on the modules' classpath.

Useful for 'previewing' the output model of IdeaProject because it is supposed to be fast (e.g. does not download dependencies from the web).

A physical binary artifact, which can run on a particular platform or runtime.

Base plugin for binaries support. - Adds a BinarySpec container named binaries to the project. - Registers the base BinarySpec type. - For each BinarySpec, registers a lifecycle task to assemble that binary. - For each BinarySpec, adds the binary's source sets as its default inputs. - Links the tasks for each BinarySpec across to the tasks container.

A collection of binaries that are created and configured as they are required.

Each element in this collection passes through several states. The element is created and becomes 'known'. The element is passed to any actions registered using #whenElementKnown(Action). The element is then configured using any actions registered using #configureEach(Action) and becomes 'finalized'. The element is passed to any actions registered using #whenElementFinalized(Action). Elements are created and configured only when required.

A container for project binaries, which represent physical artifacts that can run on a particular platform or runtime.

Represents a binary that is created and configured as required.

Binary signature type.

Represents a binary that is the result of building a component.

Declares the tasks to build a custom org.gradle.platform.base.BinarySpec binary. The following example demonstrates how to register multiple tasks for custom binary using a plugin with a org.gradle.platform.base.BinaryTasks annotation.

 @Managed interface SampleComponent extends ComponentSpec {} @Managed interface SampleBinary extends BinarySpec {} apply plugin: MyCustomBinariesPlugin class MyCustomBinaryCreationTask extends DefaultTask { @TaskAction void build() { //building the binary } } class MyCustomBinariesPlugin extends RuleSource { @ComponentType void register(TypeBuilder<SampleBinary> builder) {} @BinaryTasks void createBinaryTasks(ModelMap<Task> tasks, SampleBinary binary) { tasks.create("${binary.name}Task1", MyCustomBinaryCreationTask) tasks.create("${binary.name}Task2") { dependsOn "${binary.name}Task1" } } } 

A collection of tasks associated to a binary

An action that executes against a Gradle build and produces a result of type T.

You can execute a BuildAction using the ProjectConnection#action(BuildAction) method.

Used to execute a BuildAction in the build process.

Thrown when a BuildAction fails.

A BuildListener adapter class for receiving build events. The methods in this class are empty. This class exists as convenience for creating listener objects.

A plugin which announces interesting build lifecycle events.

Configuration object for a build cache.

Configuration for the build cache for an entire Gradle build.

A reader for build cache entries.

Writer to serialize a build cache entry.

BuildCacheException is the base class of all exceptions thrown by a BuildCacheService.

Cache key identifying an entry in the build cache.

Protocol interface to be implemented by a client to a build cache backend.

Build cache implementations should report a non-fatal failure as a BuildCacheException. Non-fatal failures could include failing to retrieve a cache entry or unsuccessfully completing an upload a new cache entry. Gradle will not fail the build when catching a BuildCacheException, but it may disable caching for the build if too many failures occur.

All other failures will be considered fatal and cause the Gradle build to fail. Fatal failures could include failing to read or write cache entries due to file permissions, authentication or corruption errors.

Every build cache implementation should define a org.gradle.caching.configuration.BuildCache configuration and BuildCacheServiceFactory factory.

Factory interface to be provided by build cache service implementations.

To be able to use a BuildCacheService, the factory that implements this interface and the configuration type (BuildCache) must be registered with the org.gradle.caching.configuration.BuildCacheConfiguration.

In settings.gradle:

 buildCache { // Register custom build cache implementation registerBuildCacheService(CustomBuildCache, CustomBuildCacheFactory) remote(CustomBuildCache) { // configure custom build cache. } } 

Thrown when a org.gradle.tooling.LongRunningOperation is cancelled before the operation completes.

A BuildCancelledException is thrown when a build is interrupted due to cancellation request.

A build command.

Provides a BuildAction various ways to control a Gradle build and access information about the build.

Adds a task, "buildDashboard", that aggregates the output of all tasks that produce reports.

The reporting configuration for the GenerateBuildDashboard task.

Informs about the build environment, like Gradle version or the Java home in use.

Example:

 ProjectConnection connection = GradleConnector.newConnector() .forProjectDirectory(new File("someProjectFolder")) .connect(); try { BuildEnvironment env = connection.getModel(BuildEnvironment.class); System.out.println("Gradle version: " + env.getGradle().getGradleVersion()); System.out.println("Java home: " + env.getJava().getJavaHome()); } finally { connection.close(); } 

Provides information about the build environment for the project that the task is associated with.

Currently, this information is limited to the project's declared build script dependencies visualised in a similar manner as provided by DependencyReportTask.

It is not necessary to manually add a task of this type to your project, as every project automatically has a task of this type by the name "buildEnvironment".

Thrown when a Gradle build fails or when a model cannot be built.

Identifies a Gradle build.

A Gradle Build is a collection of one or more projects.

Identifies a Gradle build. The identifier is unique within a Gradle invocation, so for example, each included build will have a different identifier.

The build init plugin.

A model providing access to org.gradle.tooling.model.Launchable instances that can be used to initiate Gradle build.

To launch a build, you pass one or more org.gradle.tooling.model.Launchable instances to either org.gradle.tooling.BuildLauncher#forTasks(Iterable) or org.gradle.tooling.BuildLauncher#forLaunchables(Iterable).

A BuildLauncher allows you to configure and execute a Gradle build.

Instances of BuildLauncher are not thread-safe. You use a BuildLauncher as follows:

• Create an instance of BuildLauncher by calling org.gradle.tooling.ProjectConnection#newBuild().
• Configure the launcher as appropriate.
• Call either #run() or #run(ResultHandler) to execute the build.
• Optionally, you can reuse the launcher to launch additional builds.

 ProjectConnection connection = GradleConnector.newConnector() .forProjectDirectory(new File("someFolder")) .connect(); try { BuildLauncher build = connection.newBuild(); //select tasks to run: build.forTasks("clean", "test"); //include some build arguments: build.withArguments("-i", "--project-dir", "someProjectDir"); //configure the standard input: build.setStandardInput(new ByteArrayInputStream("consume this!".getBytes())); //in case you want the build to use java different than default: build.setJavaHome(new File("/path/to/java")); //if your build needs crazy amounts of memory: build.setJvmArguments("-Xmx2048m", "-XX:MaxPermSize=512m"); //if you want to listen to the progress events: ProgressListener listener = null; // use your implementation build.addProgressListener(listener); //kick the build off: build.run(); } finally { connection.close(); } 

A BuildListener is notified of the major lifecycle events as a build is executed.

Represents a model that is associated with or represents some Gradle build.

A BuildResult packages up the results of a build executed by a org.gradle.initialization.GradleLauncher instance.

The result of executing a build, via the GradleRunner.

A task that was executed when running a specific build.

Specifies a build-type for a native binary. Common build types are 'debug' and 'release', but others may be defined.

A container of BuildTypes.

A Buildable represents an artifact or set of artifacts which are built by one or more Task instances.

Represents a component that can be built.

A ComponentSpec that is directly Buildable via a specified task.

Represents an element which has Gradle tasks associated with it.

Compiles C source files into object files.

Adds core C language support.

A plugin for projects wishing to build native binary components from C sources.

Automatically includes the CLangPlugin for core C++ support and the org.gradle.nativeplatform.plugins.NativeComponentPlugin for native component support.

• Creates a org.gradle.language.c.tasks.CCompile task for each org.gradle.language.c.CSourceSet to compile the C sources.

Compiles C header source files into object files.

A set of C source files.

A C source set contains a set of source files, together with an optional set of exported header files.

 apply plugin: "c" model { components { main(NativeLibrarySpec) { sources { c { source { srcDirs "src/main/cpp", "src/shared/c++" include "**/*.c" } exportedHeaders { srcDirs "src/main/include" } } } } } } 

A plugin that applies the CUnitPlugin and adds conventions on top of it.

A plugin that sets up the infrastructure for testing native binaries with CUnit.

An executable which run a CUnit test suite.

Test suite of CUnit tests.

Denotates a rule which execution is subject to caching.

Attached to a task type to indicate that task output caching should be enabled by default for tasks of this type.

Only tasks that produce reproducible and relocatable output should be marked with CacheableTask.

Caching for individual task instances can be disabled via TaskOutputs#cacheIf(String, Spec) or TaskOutputs#doNotCacheIf(String, Spec).

Token that propagates notification that an operation should be cancelled. See org.gradle.tooling.CancellationTokenSource for details.

All implementations of this interface are required to be thread safe.

A CancellationTokenSource allows you to issue cancellation requests to one or more org.gradle.tooling.LongRunningOperation instances. To use a token source:

• Create a token source using GradleConnector#newCancellationTokenSource().
• Attach the token to one or more operations using org.gradle.tooling.LongRunningOperation#withCancellationToken(CancellationToken). You need to do this before you start the operation.
• Later, you can cancel the associated operations by calling #cancel() on this token source.

All implementations of this interface are required to be thread safe.

Gives access to the list of capabilities of a component.

Represents a capability. Capabilities are versioned. Only one component for a specific capability can be found on a dependency graph.

A ComponentSpec that is directly checkable via a specified task.

Runs Checkstyle against some source files.

Configuration options for the Checkstyle plugin.

Checkstyle Plugin.

The reporting configuration for the Checkstyle task.

A CircularReferenceException is thrown if circular references exists between tasks, the project evaluation order or the project dependsOn order.

The Clang tool chain.

A Plugin which makes the Clang compiler available for compiling C/C++ code.

An exploded binary containing resources and compiled class files.

Represents the customizable elements of an eclipse classpath file. (via XML hooks everything is customizable).

A collection of files to be used as a class path.

Marks a property as specifying a JVM classpath for a task.

This annotation should be attached to the getter method in Java or the property in Groovy. Annotations on setters or just the field in Java are ignored.

Note: to stay compatible with versions prior to Gradle 3.2, classpath properties need to be annotated with @InputFiles as well.

Optional description associated with Eclipse classpath entries.

Represents an entry in the Eclipse classpath.

Normalizes file input that represents a Java runtime classpath. Compared to the default behavior this normalizer keeps the order of any root files, but ignores the order and timestamps of files in directories and ZIP/JAR files.

To model a module in your dependency declarations. Usually you can either declare a single dependency artifact or you declare a module dependency that depends on a module descriptor in a repository. With a client module you can declare a module dependency without the need of a module descriptor in a remote repository.

Receiver for ClientModule configuration blocks.

Runs CodeNarc against some source files.

Configuration options for the CodeNarc plugin.

CodeNarc Plugin.

The reporting configuration for the CodeNarc test.

Base Code Quality Extension.

Represents a source set for CoffeeScript sources

Provides arguments to a process.

An executable tool that forms part of a tool chain.

Executes two Gradle builds (that can be the same build) with specified versions and compares the outcomes. Please see the “Comparing Builds” chapter of the Gradle User Guide for more information.

Preconfigures the project to run a gradle build comparison.

Helper interface for binary compatibility with Gradle 2.x version of the TaskInputs interface.

Helper interface for binary compatibility with Gradle 2.x version of the TaskOutputs interface.

Provides context about attribute compatibility checks, and allows the user to define when an attribute is compatible with another.

A chain of compatibility checks, implemented as action rules. By default the chain is empty and will eventually tell the values are incompatible if no rule expressed an opinion.

For a given set of rules, the execution is done in order, and interrupts as soon as a rule expressed an option (through CompatibilityCheckDetails#compatible() or CompatibilityCheckDetails#incompatible()).

If the end of the rule chain is reached and that no rule expressed an opinion then we apply an equality check by default, and eventually fail if they are not equal.

Marks a property as specifying a Java compile classpath for a task. Attaching this annotation to a property means that changes that do not affect the API of the classes in classpath will be ignored. The following kinds of changes to the classpath will be ignored:

• Changes to the path of jar or top level directories.
• Changes to timestamps and the order of entries in Jars.
• Changes to resources and Jar manifests, including adding or removing resources.
• Changes to private class elements, such as private fields, methods and inner classes.
• Changes to code, such as method bodies, static initializers and field initializers (except for constants).
• Changes to debug information, for example when a change to a comment affects the line numbers in class debug information.
• Changes to directories, including directory entries in Jars.

This annotation should be attached to the getter method in Java or the property in Groovy. Annotations on setters or just the field in Java are ignored.

Note: to stay compatible with versions prior to Gradle 3.4, classpath properties need to be annotated with @InputFiles as well.

Normalizes file input that represents a Java compile classpath. Compared to the default behavior this normalizer keeps the order of any root files, but ignores the order and timestamps of files in directories and ZIP/JAR files. Compared to ClasspathNormalizer this normalizer only snapshots the ABIs of class files, and ignores any non-class resource.

Main options for Java compilation.

Provides command-line arguments to the compiler.

Version of a compiler.

A software component that can be queried via the Artifact Query API.

An opaque immutable identifier for an artifact that belongs to some component instance.

The result of successfully resolving a component with a set of artifacts.

Base plugin for ComponentSpec support. - Registers the infrastructure to support the base ComponentSpec type and extensions to this type.

Declares the binaries that should be built for a custom org.gradle.platform.base.ComponentSpec type. The following example demonstrates how to register a binary for a custom component type using a plugin with a org.gradle.platform.base.ComponentBinaries annotation. Furthermore the plugin registers 'DefaultSampleBinary' as implementation for org.gradle.platform.base.BinarySpec.

 interface SampleComponent extends VariantComponentSpec {} interface SampleBinary extends BinarySpec {} class DefaultSampleBinary extends BaseBinarySpec implements SampleBinary {} apply plugin: MyCustomBinariesPlugin class MyCustomBinariesPlugin extends RuleSource { @ComponentType void register(TypeBuilder<SampleBinary> builder) { builder.defaultImplementation(DefaultSampleBinary) } @ComponentBinaries void createBinariesForSampleLibrary(ModelMap<SampleBinary> binaries, SampleComponent component) { binaries.create("${component.name}Binary", SampleBinary) } } 

Allows the implementation dependencies of a component to be specified.

An opaque immutable identifier for a component instance. There are various sub-interfaces that expose specific details about the identifier.

Provides a read-only view of a resolved component's metadata, which typically originates from a component descriptor (Ivy file, Maven POM).

A component metadata builder.

Provides access to compoment metadata from a ComponentMetadataRule.

Describes a resolved component's metadata, which typically originates from a component descriptor (Ivy file, Maven POM). Some parts of the metadata can be changed via metadata rules (see org.gradle.api.artifacts.dsl.ComponentMetadataHandler.

Allows the build to provide rules that modify the metadata of depended-on software components.

Possible uses of component metadata rules are:

• Setting the status and status scheme of a component, overriding the value specified in the component descriptor.
• Declaring whether or not a component is 'changing', thus impacting the cache behaviour of the component.

Example:

 dependencies { components { // Set the status and status scheme for every component belonging to a module in the group "org.foo" all { ComponentMetadataDetails details -> if (details.id.group == "org.foo") { def version = details.id.version // assuming status is last part of version string details.status = version.substring(version.lastIndexOf("-") + 1) details.statusScheme = ["bronze", "silver", "gold", "platinum"] } } // Treat all components in the module "org.foo:bar" as changing withModule("org.foo:bar") { ComponentMetadataDetails details -> details.changing = true } } } 

Allows a custom version lister to specify the list of versions known for a specific module.

A rule that modify ComponentMetadataDetails.

A component metadata rule is responsible for providing the initial metadata of a component from a remote repository, in place of parsing the descriptor. Users may implement a provider to make dependency resolution faster.

A component metadata rule details, giving access to the identifier of the component being resolved, the metadata builder, and the repository resource accessor for this.

Interface for custom version listers. A version lister is reponsible for returning the list of versions of a module which are available in a specific repository. For this, Gradle is going to call the lister once for each module it needs the list of versions. This will typically happen in case a dynamic version is requested, in which case we need to know the list of versions published for this module. It will not, however, be called for fixed version numbers.

Base plugin for component support. Adds a org.gradle.platform.base.ComponentSpecContainer named components to the model. For each binary instance added to the binaries container, registers a lifecycle task to create that binary.

Contains immutable component module metadata information.

Contains and allows configuring component module metadata information. For information and examples please see org.gradle.api.artifacts.dsl.ComponentModuleMetadataHandler

Allows to modify the metadata of depended-on software components.

Example:

 dependencies { modules { //Configuring component module metadata for the entire "google-collections" module, // declaring that legacy library was replaced with "guava". //This way, Gradle's conflict resolution can use this information and use "guava" // in case both libraries appear in the same dependency tree. module("com.google.collections:google-collections") { replacedBy("com.google.guava:guava") } } } 

Displays some details about the software components produced by the project.

The result of resolving a component.

* Represents a tuple of the component selector of a module and a candidate version to be evaluated in a component selection rule.

The possible component selection causes. There are a limited number of causes, but each of them can be provided with a custom description, via ComponentSelectionDescriptor.

A component selection description, which wraps a cause with an optional custom description.

Answers the question why a component was selected during the dependency resolution.

* Represents a container for component selection rules. Rules can be applied as part of the resolutionStrategy of a configuration and individual components can be explicitly accepted or rejected by rule. Components that are neither accepted or rejected will be subject to the default version matching strategies.

 configurations { conf { resolutionStrategy { componentSelection { all { ComponentSelection selection -> if (selection.candidate.module == 'someModule' && selection.candidate.version == '1.1') { selection.reject("bad version '1.1' for 'someModule'") } } all { ComponentSelection selection, IvyModuleDescriptor descriptor, ComponentMetadata metadata -> if (selection.candidate.module == 'someModule' && descriptor.branch == 'testing') { if (metadata.status != 'milestone') { selection.reject("only use milestones for someModule:testing") } } } withModule("org.sample:api") { ComponentSelection selection -> if (selection.candidate.version == "1.1") { selection.reject("known bad version") } } } } } } 

Represents some opaque criteria used to select a component instance during dependency resolution. Various sub-interfaces expose specific details about the criteria.

A software component that is built by Gradle.

A container of software components.

Declares a custom org.gradle.platform.base.ComponentSpec type. The following example demonstrates how to register a custom component type using a plugin with a ComponentType annotation. Furthermore the plugin creates an instance of SampleComponent named 'sampleComponent'.

 interface SampleComponent extends ComponentSpec {} class DefaultSampleComponent extends BaseComponentSpec implements SampleComponent {} apply plugin: MySamplePlugin class MySamplePlugin extends RuleSource { @ComponentType void register(TypeBuilder<SampleComponent> builder) { builder.defaultImplementation(DefaultSampleComponent) } @Mutate void createSampleLibraryComponents(ModelMap<SampleComponent> componentSpecs) { componentSpecs.create("sampleComponent") } } 

Represents a component that is composed of one or more binaries.

Represents a component that determines its publication coordinates.

Represents a component with implementation dependencies.

Represents a native component that produces an executable.

Represents a native component that produces an application installation.

Represents a native component that produces a file to be used at link time.

Represents a native component whose link time file and dependencies are published for consumption by some other project.

Represents a component that produces outputs that run on a native platform.

Represents a component that produces object files.

Represents a component with output files.

Represents a native component that produces a file to be used at runtime.

Represents a native component whose runtime file and dependencies are published for consumption by some other project.

Represents a native component that produces a shared library.

Represents a component that produces a static library.

Represents a SoftwareComponent that provides one or more mutually exclusive children, or variants.

A org.gradle.api.specs.Spec which aggregates a sequence of other Spec instances.

Specifies the compression which should be applied to a TAR archive.

An immutable mapping to map a dependency configuration to a Maven scope. This class has implemented equality and hashcode based on its values not on object identity.

Defines a set of rules for how to map the Gradle dependencies to a POM. This mapping is based on the configuration the dependencies belong to.

A configuration file generated for Visual Studio.

A ConfigurableFileCollection is a mutable FileCollection.

You can obtain an instance of ConfigurableFileCollection by calling

A FileTree with a single base directory, which can be configured and modified.

You can obtain a ConfigurableFileTree instance by calling org.gradle.api.Project#fileTree(java.util.Map).

A build that is to be included in the composite.

A ConfigurableLauncher allows you to configure a long running operation.

A PublishArtifact whose properties can be modified.

A file based report to be created with a configurable destination.

A Configuration represents a group of artifacts and their dependencies. Find more information about declaring dependencies to a configuration or about managing configurations in docs for ConfigurationContainer

Configuration is an instance of a FileCollection that contains all dependencies (see also #getAllDependencies()) but not artifacts. If you want to refer to the artifacts declared in this configuration please use #getArtifacts() or #getAllArtifacts(). Read more about declaring artifacts in the configuration in docs for org.gradle.api.artifacts.dsl.ArtifactHandler Please see the Managing Dependency Configurations User Guide chapter for more information.

A ConfigurationContainer is responsible for declaring and managing configurations. See also Configuration.

You can obtain a ConfigurationContainer instance by calling org.gradle.api.Project#getConfigurations(), or using the configurations property in your build script.

The configurations in a container are accessible as read-only properties of the container, using the name of the configuration as the property name. For example:

 configurations.create('myConfiguration') configurations.myConfiguration.transitive = false 

A dynamic method is added for each configuration which takes a configuration closure. This is equivalent to calling #getByName(String, groovy.lang.Closure). For example:

 configurations.create('myConfiguration') configurations.myConfiguration { transitive = false } 

 apply plugin: 'java' //so that I can use 'compile' configuration //copying all dependencies attached to 'compile' into a specific folder task copyAllDependencies(type: Copy) { //referring to the 'compile' configuration from configurations.compile into 'allLibs' } 

 apply plugin: 'java' //so that I can use 'compile', 'testCompile' configurations configurations { //adding a configuration: myConfiguration //adding a configuration that extends existing configuration: //(testCompile was added by the java plugin) myIntegrationTestsCompile.extendsFrom(testCompile) //configuring existing configurations not to put transitive dependencies on the compile classpath //this way you can avoid issues with implicit dependencies to transitive libraries compile.transitive = false testCompile.transitive = false } 

Thrown when a cycle is encountered while configuring a model element.

Represents the outgoing artifacts associated with a configuration. These artifacts are used when the configuration is referenced during dependency resolution.

You can use this interface associate artifacts with a configuration using the #artifact(Object) methods. You can also define several variants of the configuration's artifacts. Each variant represents a set of artifacts that form some mutually exclusive usage of the component.

An implicit variant is defined for a configuration whenever any artifacts are attached directly to this object or inherited from another configuration.

Represents some variant of an outgoing configuration.

Attached to a task property to indicate that the property is not to be taken into account for up-to-date checking, because its value only influences the console output of the task.

This annotation should be attached to the getter method in Java or the property in Groovy. Annotations on setters or just the field in Java are ignored.

This will cause the task not to be considered out-of-date when the property has changed.

Specifies how to treat color and dynamic console output.

A container classpath entry.

Represents some binary resource whose content can be filtered.

A Convention manages a set of convention objects. When you add a convention object to a Convention, and the properties and methods of the convention object become available as properties and methods of the object which the convention is associated to. A convention object is simply a POJO or POGO. Usually, a Convention is used by plugins to extend a org.gradle.api.Project or a org.gradle.api.Task.

This class was previously used for documentation.

Copies files into a destination directory. This task can also rename and filter files as it copies. The task implements org.gradle.api.file.CopySpec for specifying what to copy.

Examples:

 task copyDocs(type: Copy) { from 'src/main/doc' into 'build/target/doc' } //for Ant filter import org.apache.tools.ant.filters.ReplaceTokens //for including in the copy task def dataContent = copySpec { from 'src/data' include '*.data' } task initConfig(type: Copy) { from('src/main/config') { include '**/*.properties' include '**/*.xml' filter(ReplaceTokens, tokens: [version: '2.3.1']) } from('src/main/config') { exclude '**/*.properties', '**/*.xml' } from('src/main/languages') { rename 'EN_US_(.*)', '$1' } into 'build/target/config' exclude '**/*.bak' includeEmptyDirs = false with dataContent } 

Specifies the destination of a copy.

Specifies sources for a file copy.

A set of specifications for copying files. This includes:

• source directories (multiples allowed)
• destination directory
• ANT like include patterns
• ANT like exclude patterns
• File relocating rules
• renaming rules
• content filters

 def myCopySpec = project.copySpec { into('webroot') exclude('**/.data/**') from('src/main/webapp') { include '**/*.jsp' } from('src/main/js') { include '**/*.js' } } 

 def contentSpec = copySpec { from("content") { include "**/*.txt" } } task copy(type: Copy) { into "$buildDir/copy" with contentSpec } 

Provides the core Javadoc Options. That is, provides the options which are not doclet specific.

Configuration for a C++ application, defining the source files that make up the application plus other settings.

An instance of this type is added as a project extension by the C++ executable plugin.

A plugin that produces a native application from C++ source.

Assumes the source files are located in `src/main/cpp` and header files are located in `src/main/headers`.

Adds a CppApplication extension to the project to allow configuration of the application.

A common base plugin for the C++ executable and library plugins

A binary built from C++ source and linked from the resulting object files.

Compiles C++ source files into object files.

Configuration for a C++ component, such as a library or executable, defining the source files and private header directories that make up the component. Private headers are those that are visible only to the source files of the component.

A C++ component is composed of some C++ source files that are compiled and then linked into some binary.

An instance of this type is added as a project extension by the C++ plugins.

An executable built from C++ source.

Adds core C++ language support.

Configuration for a C++ library, defining the source files and header directories that make up the library plus other settings.

An instance of this type is added as a project extension by the C++ library plugin.

A plugin that produces a native library from C++ source.

Assumes the source files are located in `src/main/cpp`, public headers are located in `src/main/public` and implementation header files are located in `src/main/headers`.

Adds a CppLibrary extension to the project to allow configuration of the library.

A target platform for building C++ binaries.

A plugin for projects wishing to build native binary components from C++ sources.

Automatically includes the CppLangPlugin for core C++ support and the NativeComponentPlugin for native component support.

• Creates a org.gradle.language.cpp.tasks.CppCompile task for each org.gradle.language.cpp.CppSourceSet to compile the C++ sources.

Compiles C++ header source files into object files.

A shared library built from C++ source.

A set of C++ source files.

A C++ source set contains a set of source files, together with an optional set of exported header files.

 apply plugin: "cpp" model { components { main(NativeLibrarySpec) { sources { cpp { source { srcDirs "src/main/cpp", "src/shared/c++" include "**/*.cpp" } exportedHeaders { srcDirs "src/main/include", "src/shared/include" } } } } } } 

A static library built from C++ source.

A test executable with tests implemented in C++.

A C++ test suite.

A plugin that sets up the infrastructure for testing C++ binaries using a simple test executable. Gradle will create a RunTestExecutable task that relies on the exit code of the binary.

Creates start scripts for launching JVM applications.

Example:

 task createStartScripts(type: CreateStartScripts) { outputDir = file('build/sample') mainClassName = 'org.gradle.test.Main' applicationName = 'myApp' classpath = files('path/to/some.jar') } 

Note: the Gradle "application" plugin adds a pre-configured task of this type named "startScripts".

The task generates separate scripts targeted at Microsoft Windows environments and UNIX-like environments (e.g. Linux, macOS). The actual generation is implemented by the #getWindowsStartScriptGenerator() and #getUnixStartScriptGenerator() properties, of type ScriptGenerator.

Example:

 task createStartScripts(type: CreateStartScripts) { unixStartScriptGenerator = new CustomUnixStartScriptGenerator() windowsStartScriptGenerator = new CustomWindowsStartScriptGenerator() } class CustomUnixStartScriptGenerator implements ScriptGenerator { void generateScript(JavaAppStartScriptGenerationDetails details, Writer destination) { // implementation } } class CustomWindowsStartScriptGenerator implements ScriptGenerator { void generateScript(JavaAppStartScriptGenerationDetails details, Writer destination) { // implementation } } 

The default generators are of the type org.gradle.jvm.application.scripts.TemplateBasedScriptGenerator, with default templates. This templates can be changed via the org.gradle.jvm.application.scripts.TemplateBasedScriptGenerator#setTemplate(org.gradle.api.resources.TextResource) method.

The default implementations used by this task use Groovy's SimpleTemplateEngine to parse the template, with the following variables available:

• applicationName
• optsEnvironmentVar
• exitEnvironmentVar
• mainClassName
• executableDir
• defaultJvmOpts
• appNameSystemProperty
• appHomeRelativePath
• classpath

Example:

 task createStartScripts(type: CreateStartScripts) { unixStartScriptGenerator.template = resources.text.fromFile('customUnixStartScript.txt') windowsStartScriptGenerator.template = resources.text.fromFile('customWindowsStartScript.txt') } 

Creates start scripts for launching JVM applications.

Example:

 task createStartScripts(type: CreateStartScripts) { outputDir = file('build/sample') mainClassName = 'org.gradle.test.Main' applicationName = 'myApp' classpath = files('path/to/some.jar') } 

Note: the Gradle "application" plugin adds a pre-configured task of this type named "startScripts".

The task generates separate scripts targeted at Microsoft Windows environments and UNIX-like environments (e.g. Linux, macOS). The actual generation is implemented by the #getWindowsStartScriptGenerator() and #getUnixStartScriptGenerator() properties, of type org.gradle.jvm.application.scripts.ScriptGenerator.

Example:

 task createStartScripts(type: CreateStartScripts) { unixStartScriptGenerator = new CustomUnixStartScriptGenerator() windowsStartScriptGenerator = new CustomWindowsStartScriptGenerator() } class CustomUnixStartScriptGenerator implements ScriptGenerator { void generateScript(JavaAppStartScriptGenerationDetails details, Writer destination) { // implementation } } class CustomWindowsStartScriptGenerator implements ScriptGenerator { void generateScript(JavaAppStartScriptGenerationDetails details, Writer destination) { // implementation } } 

The default generators are of the type org.gradle.jvm.application.scripts.TemplateBasedScriptGenerator, with default templates. This templates can be changed via the org.gradle.jvm.application.scripts.TemplateBasedScriptGenerator#setTemplate(org.gradle.api.resources.TextResource) method.

The default implementations used by this task use Groovy's SimpleTemplateEngine to parse the template, with the following variables available:

• applicationName
• optsEnvironmentVar
• exitEnvironmentVar
• mainClassName
• defaultJvmOpts
• appNameSystemProperty
• appHomeRelativePath
• classpath

Example:

 task createStartScripts(type: CreateStartScripts) { unixStartScriptGenerator.template = resources.text.fromFile('customUnixStartScript.txt') windowsStartScriptGenerator.template = resources.text.fromFile('customWindowsStartScript.txt') } 

Assembles a static library from object files.

Base interface for credentials used for different authentication purposes. (e.g authenticated org.gradle.api.artifacts.dsl.RepositoryHandler)

A HTML Report whose generation can be customized with a XSLT stylesheet.

Debug options for Java compilation. Only take effect if CompileOptions#debug is set to true.

The default SignatureTypeProvider implementation including support for BinarySignatureType and ArmoredSignatureType signatures.

DefaultTask is the standard Task implementation. You can extend this to implement your own task types.

Denotes that the RuleSource method rule carrying this annotation initializes the rule subject with default values.

Default rules execute first for a given subject, just after the subject has been created but before Model rules and Mutate rules. The first parameter of the rule is the rule subject, which is mutable for the duration of the rule.

Please see RuleSource for more information on method rules.

Indicates that the annotated object is designed to be configured only once, and that changes to configuration inputs made after configuration should not be allowed.

Deletes files or directories. Example:

 task makePretty(type: Delete) { delete 'uglyFolder', 'uglyFile' followSymlinks = true } 

A specification for deleting files from the filesystem.

Describes metadata about a dependency - direct dependencies or dependency constraints - declared in a resolved component's metadata.

Represents an artifact dependency.

Represents a dependency of an IDEA module.

A Dependency represents a dependency on the artifacts from a particular source. A source can be an Ivy module, a Maven POM, another Gradle project, a collection of Files, etc... A source can have zero or more artifacts.

An Artifact represents an artifact included in a org.gradle.api.artifacts.Dependency.

Represents a constraints over all, including transitive, dependencies.

A DependencyConstraintHandler is used to declare dependency constraints.

Describes a dependency constraint declared in a resolved component's metadata, which typically originates from a component descriptor (Gradle metadata file). This interface can be used to adjust a dependency constraint's properties via metadata rules (see org.gradle.api.artifacts.dsl.ComponentMetadataHandler.

A set of dependency constraint definitions that are associated with a configuration.

Describes the dependency constraints of a variant declared in a resolved component's metadata, which typically originate from a component descriptor (Gradle metadata file). This interface can be used to adjust the dependencies of a published component via metadata rules (see org.gradle.api.artifacts.dsl.ComponentMetadataHandler.

A DependencyHandler is used to declare dependencies. Dependencies are grouped into configurations (see org.gradle.api.artifacts.Configuration).

To declare a specific dependency for a configuration you can use the following syntax:

 dependencies { configurationName dependencyNotation1, dependencyNotation2, ... } 

Example shows a basic way of declaring dependencies.

 apply plugin: 'java' //so that we can use 'compile', 'testCompile' for dependencies dependencies { //for dependencies found in artifact repositories you can use //the group:name:version notation compile 'commons-lang:commons-lang:2.6' testCompile 'org.mockito:mockito:1.9.0-rc1' //map-style notation: compile group: 'com.google.code.guice', name: 'guice', version: '1.0' //declaring arbitrary files as dependencies compile files('hibernate.jar', 'libs/spring.jar') //putting all jars from 'libs' onto compile classpath compile fileTree('libs') } 

To do some advanced configuration on a dependency when it is declared, you can additionally pass a configuration closure:

 dependencies { configurationName(dependencyNotation){ configStatement1 configStatement2 } } 

• Forcing certain dependency version in case of the conflict.
• Excluding certain dependencies by name, group or both. More details about per-dependency exclusions can be found in docs for org.gradle.api.artifacts.ModuleDependency#exclude(java.util.Map).
• Avoiding transitive dependencies for certain dependency.

 apply plugin: 'java' //so that I can declare 'compile' dependencies dependencies { compile('org.hibernate:hibernate:3.1') { //in case of versions conflict '3.1' version of hibernate wins: force = true //excluding a particular transitive dependency: exclude module: 'cglib' //by artifact name exclude group: 'org.jmock' //by group exclude group: 'org.unwanted', module: 'iAmBuggy' //by both name and group //disabling all transitive dependencies of this dependency transitive = false } } 

• Declaring dependency to a specific configuration of the module.
• Explicit specification of the artifact. See also org.gradle.api.artifacts.ModuleDependency#artifact(groovy.lang.Closure).

 apply plugin: 'java' //so that I can declare 'compile' dependencies dependencies { //configuring dependency to specific configuration of the module compile configuration: 'someConf', group: 'org.someOrg', name: 'someModule', version: '1.0' //configuring dependency on 'someLib' module compile(group: 'org.myorg', name: 'someLib', version:'1.0') { //explicitly adding the dependency artifact: artifact { //useful when some artifact properties unconventional name = 'someArtifact' //artifact name different than module name extension = 'someExt' type = 'someType' classifier = 'someClassifier' } } } 

There are several supported dependency notations. These are described below. For each dependency declared this way, a Dependency object is created. You can use this object to query or further configure the dependency.

You can also always add instances of org.gradle.api.artifacts.Dependency directly:

There are two notations supported for declaring a dependency on an external module. One is a string notation formatted this way:

The other is a map notation:

In both notations, all properties, except name, are optional.

External dependencies are represented by a .

 apply plugin: 'java' //so that we can use 'compile', 'testCompile' for dependencies dependencies { //for dependencies found in artifact repositories you can use //the string notation, e.g. group:name:version compile 'commons-lang:commons-lang:2.6' testCompile 'org.mockito:mockito:1.9.0-rc1' //map notation: compile group: 'com.google.code.guice', name: 'guice', version: '1.0' } 

To add a project dependency, you use the following notation:

configurationName project(':someProject')

The notation project(':projectA') is similar to the syntax you use when configuring a projectA in a multi-module gradle project.

By default, when you declare dependency to projectA, you actually declare dependency to the 'default' configuration of the projectA. If you need to depend on a specific configuration of projectA, use map notation for projects:

configurationName project(path: ':projectA', configuration: 'someOtherConfiguration')

Project dependencies are represented using a org.gradle.api.artifacts.ProjectDependency.

You can also add a dependency using a org.gradle.api.file.FileCollection:

 apply plugin: 'java' //so that we can use 'compile', 'testCompile' for dependencies dependencies { //declaring arbitrary files as dependencies compile files('hibernate.jar', 'libs/spring.jar') //putting all jars from 'libs' onto compile classpath compile fileTree('libs') } 

File dependencies are represented using a org.gradle.api.artifacts.SelfResolvingDependency.

You can add a dependency using a org.gradle.api.artifacts.Configuration.

When the configuration is from the same project as the target configuration, the target configuration is changed to extend from the provided configuration.

When the configuration is from a different project, a project dependency is added.

It is possible to depend on certain Gradle APIs or libraries that Gradle ships with. It is particularly useful for Gradle plugin development. Example:

 //Our Gradle plugin is written in groovy apply plugin: 'groovy' //now we can use the 'compile' configuration for declaring dependencies dependencies { //we will use the Groovy version that ships with Gradle: compile localGroovy() //our plugin requires Gradle API interfaces and classes to compile: compile gradleApi() //we will use the Gradle test-kit to test build logic: testCompile gradleTestKit() } 

To add a client module to a configuration you can use the notation:

configurationName module(moduleNotation) { module dependencies } 

Receiver for dependencies block providing convenient utilities for configuring dependencies.

Generates a report that attempts to answer questions like:

• Why is this dependency in the dependency graph?
• Exactly which dependencies are pulling this dependency into the graph?
• What is the actual version (i.e. *selected* version) of the dependency that will be used? Is it the same as what was *requested*?
• Why is the *selected* version of a dependency different to the *requested*?

While the regular dependencies report (DependencyReportTask) shows the path from the top level dependencies down through the transitive dependencies, the dependency insight report shows the path from a particular dependency to the dependencies that pulled it in. That is, it is an inverted view of the regular dependencies report.

The task requires setting the dependency spec and the configuration. For more information on how to configure those please refer to docs for DependencyInsightReportTask#setDependencySpec(Object) and DependencyInsightReportTask#setConfiguration(String).

The task can also be configured from the command line. For more information please refer to DependencyInsightReportTask#setDependencySpec(Object) and DependencyInsightReportTask#setConfiguration(String)

A DependencyLockingHandler manages the behaviour and configuration of dependency locking.

Describes a metadata about a dependency - direct dependency or dependency constraint - declared in a resolved component's metadata.

The set of reports that can be generated by the HtmlDependencyReportTask task type.

Displays the dependency tree for a project. An instance of this type is used when you execute the dependencies task from the command-line.

A DependencyResolutionListener is notified as dependencies are resolved.

Provides details about a dependency when it is resolved. Provides means to manipulate dependency metadata when it is resolved.

An edge in the dependency graph. Provides information about the origin of the dependency and the requested component.

A set of artifact dependencies.

A dependency onto a Gradle component.

A builder of a DependencySpec. Implementations are required to return immutable dependency specs.

A container for dependency specifications.

Provides means to substitute a different dependency during resolution.

Allows replacing dependencies with other dependencies.

Displays dependent components.

A source set that depends on one or more org.gradle.nativeplatform.NativeDependencySets to be built.

A source set that can have dependencies on other Libraries.

A deployment descriptor such as application.xml.

Types can implement this interface when they provide a human-readable display name. It is strongly encouraged to compute this display name lazily: computing a display name, even if it's only a string concatenation, can take a significant amount of time during configuration for something that would only be used, typically, in error messages.

Marks a property as specifying a file or directory that a task destroys.

This annotation should be attached to the getter method or the field for the property.

This will cause the task to have exclusive access to this file or directory while running. This means that other tasks that either create or consume this file (by specifying the file or directory as an input or output) cannot execute concurrently with a task that destroys this file.

Authentication scheme for digest access authentication over HTTP.

Describes the dependencies of a variant declared in a resolved component's metadata, which typically originate from a component descriptor (Gradle metadata file, Ivy file, Maven POM). This interface can be used to adjust the dependencies of a published component via metadata rules (see org.gradle.api.artifacts.dsl.ComponentMetadataHandler.

Describes a dependency declared in a resolved component's metadata, which typically originates from a component descriptor (Gradle metadata file, Ivy file, Maven POM). This interface can be used to adjust a dependency's properties via metadata rules (see org.gradle.api.artifacts.dsl.ComponentMetadataHandler.

Represents a directory at some fixed location on the file system.

Note: This interface is not intended for implementation by build script or plugin authors. An instance of this class can be created using the #dir(String) method or using various methods on ProjectLayout such as ProjectLayout#getProjectDirectory().

Configuration object for the local directory build cache.

Represents some configurable directory location, whose value is mutable and is not necessarily currently known until later.

Note: This interface is not intended for implementation by build script or plugin authors. An instance of this class can be created using the ProjectLayout#directoryProperty() method.

A directory based report to be created.

A directory with some associated include and exclude patterns.

This interface does not allow mutation. However, the actual implementation may not be immutable.

Represents some configurable directory location, whose value is mutable and is not necessarily currently known until later.

Note: This interface is not intended for implementation by build script or plugin authors. An instance of this class can be created using the ProjectLayout#newDirectoryVar() method.

A chain of disambiguation rules. By default the chain is empty and will not do any disambiguation.

For a given set of rules, the execution is done in order, and interrupts as soon as a rule selected at least one candidate (through MultipleCandidatesDetails#closestMatch(Object)).

If the end of the rule chain is reached and that no rule selected a candidate then the candidate list is returned unmodified, meaning we still have an ambiguous match.

A distribution allow to bundle an application or a library including dependencies,sources...

A DistributionContainer manages a set of Distribution objects.

A Plugin to package project as a distribution.

A DomainObjectCollection is a specialised Collection that adds the ability to receive modification notifications and use live filtered sub collections.

The filtered collections returned by the filtering methods, such as #matching(Closure), return collections that are live. That is, they reflect changes made to the source collection that they were created from. This is true for filtered collections made from filtered collections etc.

You can also add actions which are executed as elements are added to the collection. Actions added to filtered collections will be fired if an addition/removal occurs for the source collection that matches the filter.

A set of domain objects of type T.

A DomainObjectSet is a specialisation of DomainObjectCollection that guarantees Set semantics.

Thrown when more than one file with the same relative path name is to be copied and the DuplicatesStrategy is set to DuplicatesStrategy.FAIL

Strategies for dealing with the potential creation of duplicate files for or archive entries.

Signals that a RuleSource rule should be applied to all matching descendant elements of the scope instead of the scope itself.

Assembles an EAR archive.

A module element in a deployment descriptor like application.xml.

A Plugin with tasks which assemble a web application into a EAR file.

Ear Plugin Convention.

A security-role element in a deployment descriptor like application.xml.

A module element in a deployment descriptor like application.xml that has a web child element.

An Eclipse build command is a reference to a project builder object which automatically executes whenever a resource in the associate project changes.

The build path settings for the generated Eclipse project. Used by the org.gradle.plugins.ide.eclipse.GenerateEclipseClasspath task to generate an Eclipse .classpath file.

The following example demonstrates the various configuration options. Keep in mind that all properties have sensible defaults; only configure them explicitly if the defaults don't match your needs.

 apply plugin: 'java' apply plugin: 'eclipse' configurations { provided someBoringConfig } eclipse { //if you want parts of paths in resulting file to be replaced by variables (files): pathVariables 'GRADLE_HOME': file('/best/software/gradle'), 'TOMCAT_HOME': file('../tomcat') classpath { //you can tweak the classpath of the Eclipse project by adding extra configurations: plusConfigurations += [ configurations.provided ] //you can also remove configurations from the classpath: minusConfigurations += [ configurations.someBoringConfig ] //if you want to append extra containers: containers 'someFriendlyContainer', 'andYetAnotherContainer' //customizing the classes output directory: defaultOutputDir = file('build-eclipse') //default settings for downloading sources and Javadoc: downloadSources = true downloadJavadoc = false } } 

The beforeMerged and whenMerged closures receive a Classpath object.

Examples of advanced configuration:

 apply plugin: 'java' apply plugin: 'eclipse' eclipse { classpath { file { //if you want to mess with the resulting XML in whatever way you fancy withXml { def node = it.asNode() node.appendNode('xml', 'is what I love') } //closure executed after .classpath content is loaded from existing file //but before gradle build information is merged beforeMerged { classpath -> //you can tinker with the Classpath here } //closure executed after .classpath content is loaded from existing file //and after gradle build information is merged whenMerged { classpath -> //you can tinker with the Classpath here } } } } 

Eclipse classpath entry used by third-party plugins to contribute to the project's classpath.

An element that can have classpath attributes.

Represents an Eclipse-specific external artifact dependency.

Describes Eclipse Java source settings for compiling and running some Java source code.

Enables fine-tuning jdt details of the Eclipse plugin

 apply plugin: 'java' apply plugin: 'eclipse' eclipse { jdt { //if you want to alter the java versions (by default they are configured with gradle java plugin settings): sourceCompatibility = 1.6 targetCompatibility = 1.5 javaRuntimeName = "J2SE-1.5" file { //whenMerged closure is the highest voodoo //and probably should be used only to solve tricky edge cases. //the type passed to the closure is Jdt //closure executed after jdt file content is loaded from existing file //and after gradle build information is merged whenMerged { jdt //you can tinker with the Jdt here } //withProperties allows addition of properties not currently //modeled by Gradle withProperties { properties -> //you can tinker with the java.util.Properties here } } } } 

Linked resources are files and folders that are stored in locations in the file system outside of the project's location.

DSL-friendly model of the Eclipse project information. First point of entry for customizing Eclipse project generation.

 apply plugin: 'java' apply plugin: 'eclipse' apply plugin: 'eclipse-wtp' //for web projects only eclipse { pathVariables 'GRADLE_HOME': file('/best/software/gradle'), 'TOMCAT_HOME': file('../tomcat') project { //see docs for EclipseProject } classpath { //see docs for EclipseClasspath } wtp { //see docs for EclipseWtp } } 

The output location of an Eclipse project.

A plugin which generates Eclipse files.

The complete model of an Eclipse project.

Note that the names of Eclipse projects are unique, and can be used as an identifier for the project.

Enables fine-tuning project details (.project file) of the Eclipse plugin

Example of use with a blend of all possible properties. Bear in mind that usually you don't have configure eclipse project directly because Gradle configures it for free!

 apply plugin: 'java' apply plugin: 'eclipse' eclipse { project { //if you don't like the name Gradle has chosen name = 'someBetterName' //if you want to specify the Eclipse project's comment comment = 'Very interesting top secret project' //if you want to append some extra referenced projects in a declarative fashion: referencedProjects 'someProject', 'someOtherProject' //if you want to assign referenced projects referencedProjects = ['someProject'] as Set //if you want to append some extra natures in a declarative fashion: natures 'some.extra.eclipse.nature', 'some.another.interesting.nature' //if you want to assign natures in a groovy fashion: natures = ['some.extra.eclipse.nature', 'some.another.interesting.nature'] //if you want to append some extra build command: buildCommand 'buildThisLovelyProject' //if you want to append a build command with parameters: buildCommand 'buildItWithTheArguments', argumentOne: "I'm first", argumentTwo: "I'm second" //if you want to create an extra link in the eclipse project, //by location uri: linkedResource name: 'someLinkByLocationUri', type: 'someLinkType', locationUri: 'file://someUri' //by location: linkedResource name: 'someLinkByLocation', type: 'someLinkType', location: '/some/location' //if you don't want any node_modules folder to appear in Eclipse, you can filter it out: resourceFilter { appliesTo = 'FOLDERS' type = 'EXCLUDE_ALL' matcher { id = 'org.eclipse.ui.ide.multiFilter' arguments = '1.0-name-matches-false-false-node_modules' } } } } 

beforeMerged and whenMerged closures receive Project object

Examples of advanced configuration:

 apply plugin: 'java' apply plugin: 'eclipse' eclipse { project { file { //if you want to mess with the resulting XML in whatever way you fancy withXml { def node = it.asNode() node.appendNode('xml', 'is what I love') } //closure executed after .project content is loaded from existing file //but before gradle build information is merged beforeMerged { project -> //if you want skip merging natures... (a very abstract example) project.natures.clear() } //closure executed after .project content is loaded from existing file //and after gradle build information is merged whenMerged { project -> //you can tinker with the Project here } } } } 

Represents a dependency on another Eclipse project.

An Eclipse project nature definition.

A source directory in an Eclipse project.

Enables fine-tuning wtp/wst details of the Eclipse plugin

For projects applying the eclipse plugin and either one of the ear or war plugins, this plugin is auto-applied.

More interesting examples you will find in docs for EclipseWtpComponent and EclipseWtpFacet

 apply plugin: 'war' //or 'ear' or 'java' apply plugin: 'eclipse-wtp' eclipse { //if you want parts of paths in resulting file(s) to be replaced by variables (files): pathVariables 'GRADLE_HOME': file('/best/software/gradle'), 'TOMCAT_HOME': file('../tomcat') wtp { component { //for examples see docs for EclipseWtpComponent } facet { //for examples see docs for EclipseWtpFacet } } } 

Enables fine-tuning wtp component details of the Eclipse plugin

Example of use with a blend of all possible properties. Bear in mind that usually you don't have to configure them directly because Gradle configures it for free!

 apply plugin: 'war' //or 'ear' or 'java' apply plugin: 'eclipse-wtp' configurations { someInterestingConfiguration anotherConfiguration } eclipse { //if you want parts of paths in resulting file(s) to be replaced by variables (files): pathVariables 'GRADLE_HOME': file('/best/software/gradle'), 'TOMCAT_HOME': file('../tomcat') wtp { component { //you can configure the context path: contextPath = 'someContextPath' //you can configure the deployName: deployName = 'killerApp' //you can alter the wb-resource elements. //non-existing source dirs won't be added to the component file. sourceDirs += file('someExtraFolder') // dependencies to mark as deployable with lib folder deploy path libConfigurations += [ configurations.someInterestingConfiguration ] // dependencies to mark as deployable with root folder deploy path rootConfigurations += [ configurations.someInterestingConfiguration ] // dependencies to exclude from wtp deployment minusConfigurations << configurations.anotherConfiguration //you can add a wb-resource elements; mandatory keys: 'sourcePath', 'deployPath': //if sourcePath points to non-existing folder it will *not* be added. resource sourcePath: 'extra/resource', deployPath: 'deployment/resource' //you can add a wb-property elements; mandatory keys: 'name', 'value': property name: 'moodOfTheDay', value: ':-D' } } } 

beforeMerged and whenMerged closures receive WtpComponent object

Examples of advanced configuration:

 apply plugin: 'war' apply plugin: 'eclipse-wtp' eclipse { wtp { component { file { //if you want to mess with the resulting XML in whatever way you fancy withXml { def node = it.asNode() node.appendNode('xml', 'is what I love') } //closure executed after wtp component file content is loaded from existing file //but before gradle build information is merged beforeMerged { wtpComponent -> //tinker with WtpComponent here } //closure executed after wtp component file content is loaded from existing file //and after gradle build information is merged whenMerged { wtpComponent -> //you can tinker with the WtpComponent here } } } } } 

Enables fine-tuning wtp facet details of the Eclipse plugin

Advanced configuration closures beforeMerged and whenMerged receive WtpFacet object as parameter.

 apply plugin: 'war' //or 'ear' or 'java' apply plugin: 'eclipse-wtp' eclipse { wtp { facet { //you can add some extra wtp facets; mandatory keys: 'name', 'version': facet name: 'someCoolFacet', version: '1.3' file { //if you want to mess with the resulting XML in whatever way you fancy withXml { def node = it.asNode() node.appendNode('xml', 'is what I love') } //beforeMerged and whenMerged closures are the highest voodoo for the tricky edge cases. //the type passed to the closures is WtpFacet //closure executed after wtp facet file content is loaded from existing file //but before gradle build information is merged beforeMerged { wtpFacet -> //tinker with WtpFacet here } //closure executed after wtp facet file content is loaded from existing file //and after gradle build information is merged whenMerged { wtpFacet -> //you can tinker with the WtpFacet here } } } } } 

A plugin which configures the Eclipse Web Tools Platform.

Described model element.

The embedded-kotlin plugin.

The EmptyFileVisitor can be extends by implementations that only require to implement one of the 2 visit methods (dir or file). This is just to limit the amount of code clutter when not both visit methods need to be implemented.

An ExcludeRule is used to describe transitive dependencies that should be excluded when resolving dependencies.

A container for adding exclude rules for dependencies.

Executes a command line process. Example:

 task stopTomcat(type:Exec) { workingDir '../tomcat/bin' //on windows: commandLine 'cmd', '/c', 'stop.bat' //on linux commandLine './stop.sh' //store the output instead of printing to the console: standardOutput = new ByteArrayOutputStream() //extension method stopTomcat.output() can be used to obtain the output: ext.output = { return standardOutput.toString() } } 

Represents the result of running an external process.

Specified the options for executing some command.

A org.gradle.api.PolymorphicDomainObjectContainer that can be extended at runtime to create elements of new types.

Objects that can be extended at runtime with other objects.

 // Extensions are just plain objects, there is no interface/type class MyExtension { String foo MyExtension(String foo) { this.foo = foo } } // Add new extensions via the extension container project.extensions.create('custom', MyExtension, "bar") // («name», «type», «constructor args», …) // extensions appear as properties on the target object by the given name assert project.custom instanceof MyExtension assert project.custom.foo == "bar" // also via a namespace method project.custom { assert foo == "bar" foo = "other" } assert project.custom.foo == "other" // Extensions added with the extension container's create method are themselves extensible assert project.custom instanceof ExtensionAware project.custom.extensions.create("nested", MyExtension, "baz") assert project.custom.nested.foo == "baz" // All extension aware objects have a special “ext” extension of type ExtraPropertiesExtension assert project.hasProperty("myProperty") == false project.ext.myProperty = "myValue" // Properties added to the “ext” extension are promoted to the owning object assert project.myProperty == "myValue" 

For more on adding & creating extensions, see ExtensionContainer.

For more on extra properties, see ExtraPropertiesExtension.

An ExtensionAware object has several 'scopes' that Gradle searches for properties. These scopes are:

• The object itself. This scope includes any property getters and setters declared by the implementation class. The properties of this scope are readable or writable depending on the presence of the corresponding getter or setter method.
• Groovy Meta-programming methods implemented by the object's class, like propertyMissing(). Care must be taken by plugin authors to ensure propertyMissing() is implemented such that if a property is not found a MissingPropertyException(String, Class) exception is thrown. If propertyMissing() always returns a value for any property, Gradle will not search the rest of the scopes below.
• The extra properties of the object. Each object maintains a map of extra properties, which can contain any arbitrary name -> value pair. Once defined, the properties of this scope are readable and writable.
• The extensions added to the object by plugins. Each extension is available as a read-only property with the same name as the extension.

Allows adding 'namespaced' DSL extensions to a target object.

Schema of extensions.

Represents an external artifact dependency.

An ExternalDependency is a Dependency on a source outside the current project hierarchy.

A ModuleDependency is a Dependency on a module outside the current project hierarchy.

Additional, ad-hoc, properties for Gradle domain objects.

Extra properties extensions allow new properties to be added to existing domain objects. They act like maps, allowing the storage of arbitrary key/value pairs. All ExtensionAware Gradle domain objects intrinsically have an extension named “{@value #EXTENSION_NAME}” of this type.

An important feature of extra properties extensions is that all of its properties are exposed for reading and writing via the ExtensionAware object that owns the extension.

 project.ext.set("myProp", "myValue") assert project.myProp == "myValue" project.myProp = "anotherValue" assert project.myProp == "anotherValue" assert project.ext.get("myProp") == "anotherValue" 

 project.ext { myprop = "a" } assert project.myprop == "a" assert project.ext.myprop == "a" project.myprop = "b" assert project.myprop == "b" assert project.ext.myprop == "b" 

 project.ext["otherProp"] = "a" assert project.otherProp == "a" assert project.ext["otherProp"] == "a" 

Extracts the debug symbols from a binary and stores them in a separate file.

A project facet.

Represents a failure. Failures are similar to exceptions but carry less information (only a message, a description and a cause) so they can be used in a wider scope than just the JVM where the exception failed.

Describes how an operation finished with failures.

A FileCollection represents a collection of files which you can query in certain ways. A file collection is often used to define a classpath, or to add files to a container.

You can obtain a FileCollection instance using org.gradle.api.Project#files.

A FileCollectionDependency is a Dependency on a collection of local files which are not stored in a repository.

Models the generation/parsing/merging capabilities.

For examples see docs for org.gradle.plugins.ide.eclipse.model.EclipseProject or org.gradle.plugins.ide.idea.model.IdeaProject and others.

Provides details about a file or directory about to be copied, and allows some aspects of the destination file to be modified.

Using this interface, you can change the destination path of the file, filter the content of the file, or exclude the file from the result entirely.

Access to the source file itself after any filters have been added is not a supported operation.

A normalizer used to remove unwanted noise when considering file inputs. The default behavior without specifying a normalizer is to ignore the order of the files.

A Path that keeps the reference to the File

A reference to a file in eclipse.

Represents some immutable location on the file system.

Note: This interface is not intended for implementation by build script or plugin authors.

A FileTree represents a hierarchy of files. It extends FileCollection to add hierarchy query and manipulation methods. You typically use a FileTree to represent files to copy or the contents of an archive.

You can obtain a FileTree instance using org.gradle.api.Project#fileTree(java.util.Map), org.gradle.api.Project#zipTree(Object) or org.gradle.api.Project#tarTree(Object).

Information about a file in a FileTree.

Provides access to details about a file or directory being visited by a FileVisitor.

A FileVisitor is used to visit each of the files in a FileTree.

Denotes that the RuleSource method rule carrying this annotation finalizes the rule subject.

Finalize rules execute after Mutate rules, but before Validate rules. The first parameter of the rule is the rule subject, which is mutable for the duration of the rule.

Please see RuleSource for more information on method rules.

Analyzes code with FindBugs. See the FindBugs Manual for additional information on configuration options.

Configuration options for the FindBugs plugin. All options have sensible defaults. See the FindBugs Manual for additional information on these options.

Below is a full configuration example. Since all properties have sensible defaults, typically only selected properties will be configured.

 apply plugin: "java" apply plugin: "findbugs" findbugs { toolVersion = "2.0.1" sourceSets = [sourceSets.main] ignoreFailures = true reportsDir = file("$project.buildDir/findbugsReports") effort = "max" showProgress = true reportLevel = "high" visitors = ["FindSqlInjection", "SwitchFallthrough"] omitVisitors = ["FindNonShortCircuit"] includeFilter = file("$rootProject.projectDir/config/findbugs/includeFilter.xml") excludeFilter = file("$rootProject.projectDir/config/findbugs/excludeFilter.xml") excludeBugsFilter = file("$rootProject.projectDir/config/findbugs/excludeBugsFilter.xml") } 

A plugin for the FindBugs byte code analyzer.

Declares a findbugs configuration which needs to be configured with the FindBugs library to be used. Additional plugins can be added to the findbugsPlugins configuration.

For projects that have the Java (base) plugin applied, a FindBugs task is created for each source set.

The reporting configuration for the FindBugs task. Only one of the reports can be enabled when the task executes. If more than one is enabled, an org.gradle.api.InvalidUserDataException will be thrown.

The single file XML report for FindBugs.

An event that informs about an operation having finished its execution.

A repository that looks into a number of directories for artifacts. The artifacts are expected to be located in the root of the specified directories. The repository ignores any group/organization information specified in the dependency section of your build script. If you only use this kind of resolver you can specify your dependencies like :junit:4.8.1 instead of junit:junit:4.8.1.

To resolve a dependency, this resolver looks for one of the following files. It will return the first match it finds:

• [artifact]-[version].[ext]
• [artifact]-[version]-[classifier].[ext]
• [artifact].[ext]
• [artifact]-[classifier].[ext]

Defines a custom variant that differentiate a NativeBinary.

A container of Flavors.

If no flavor is explicitly configured, will contain a single Flavor named 'default'. Any flavors explicitly configured will overwrite the default flavor.

Forking mode for workers.

Fork options for Java compilation. Only take effect if CompileOptions.fork is true.

A container holding LanguageSourceSets with a similar function (production code, test code, etc.).

The GNU GCC tool chain.

An executable tool used for GCC that allows customizing the executable.

A ToolChain that can handle additional platforms simply by configuring the NativeBinary.

A Plugin which makes the GNU GCC/G++ compiler available for compiling C/C++ code.

GCC specific settings for the tools used to build for a particular platform.

A general purpose component specification, that can be used to represent some software component built from source and producing multiple output variants.

Generates build dashboard report.

Generated the Gradle CUnit launcher: main method and header.

Generates an Eclipse .classpath file. If you want to fine tune the eclipse configuration

At this moment nearly all configuration is done via EclipseClasspath.

Generates the Eclipse JDT configuration file. If you want to fine tune the eclipse configuration

At this moment nearly all configuration is done via EclipseJdt.

Generates an Eclipse .project file. If you want to fine tune the eclipse configuration

At this moment nearly all configuration is done via EclipseProject.

Generates the org.eclipse.wst.common.component settings file for Eclipse WTP. If you want to fine tune the eclipse configuration

At this moment nearly all configuration is done via EclipseWtpComponent.

Generates the org.eclipse.wst.common.project.facet.core settings file for Eclipse WTP. If you want to fine tune the eclipse configuration

At this moment nearly all configuration is done via EclipseWtpFacet.

Task for generating a filters file.

Generates an IDEA module file. If you want to fine tune the idea configuration

Please refer to interesting examples on idea configuration in IdeaModule.

At this moment nearly all configuration is done via IdeaModule.

Generates an IDEA project file for root project *only*. If you want to fine tune the idea configuration

At this moment nearly all configuration is done via IdeaProject.

Generates an IDEA workspace file *only* for root project. There's little you can configure about workspace generation at the moment.

Generates an Ivy XML Module Descriptor file.

Generates a Maven module descriptor (POM) file.

Generates a Gradle metadata file to represent a published org.gradle.api.component.SoftwareComponent instance.

Generates plugin descriptors from plugin declarations.

Task for generating a project file.

Task for generating a scheme file.

Task for generating a solution file.

A task that produces a Swift Package Manager manifest.

Task for generating a workspace settings file.

Task for generating a project file.

Task for generating a workspace file.

A GeneratorTask generates a configuration file based on a domain object of type T. When executed the task:

• loads the object from the input file, if it exists.
• Calls the beforeConfigured actions, passing the object to each action.
• Configures the object in some task-specific way.
• Calls the afterConfigured actions, passing the object to each action.
• writes the object to the output file.

A specification of a Git repository.

A plugin that applies the GoogleTestPlugin and adds conventions on top of it.

A plugin that sets up the infrastructure for testing native binaries with GoogleTest.

An executable which run a Google Test test suite.

Test suite of Google Test tests.

Represents an invocation of Gradle.

You can obtain a Gradle instance by calling Project#getGradle().

Provides information about the structure of a Gradle build.

Executes a Gradle build.

A specification for launching a Gradle build with a specified Gradle version.

Thrown when there is some problem using a Gradle connection.

A GradleConnector is the main entry point to the Gradle tooling API. You use this API as follows:

1. Call #newConnector() to create a new connector instance.
2. Configure the connector. You must call #forProjectDirectory(java.io.File) to specify which project you wish to connect to. Other methods are optional.
3. Call #connect() to create the connection to a project.
4. When finished with the connection, call ProjectConnection#close() to clean up.

Example:

 ProjectConnection connection = GradleConnector.newConnector() .forProjectDirectory(new File("someProjectFolder")) .connect(); try { connection.newBuild().forTasks("tasks").run(); } finally { connection.close(); } 

The connection will use the version of Gradle that the target build is configured to use, for example in the Gradle wrapper properties file. When no Gradle version is defined for the build, the connection will use the tooling API's version as the Gradle version to run the build. Generally, you should avoid configuring a Gradle distribution or version and instead use the default provided by the tooling API.

Similarly, the connection will use the JVM and JVM arguments that the target build is configured to use, for example in the gradle.properties file. When no JVM or JVM arguments are defined for the build, the connection will use the current JVM and some default JVM arguments.

GradleConnector instances are not thread-safe. If you want to use a GradleConnector concurrently you must always create a new instance for each thread using #newConnector(). Note, however, the ProjectConnection instances that a connector creates are completely thread-safe.

The Tooling API is both forwards and backwards compatible with other versions of Gradle. It supports execution of Gradle builds that use older or newer versions of Gradle.

The current version of the Tooling API supports running builds using Gradle versions 1.2.

You should note that not all features of the Tooling API are available for all versions of Gradle. For example, build cancellation is only available for builds using Gradle 2.1 and later. Refer to the documentation for each class and method for more details.

The current Gradle version can be used from Tooling API versions 2.0 or later.

The Tooling API requires Java 8 or later. Java 7 is currently still supported but will be removed in Gradle 5.0. The Gradle version used by builds may have additional Java version requirements.

Delimits a Gradle DSL.

Informs about the Gradle environment, for example the Gradle version.

See example in BuildEnvironment

GradleException is the base class of all exceptions thrown by Gradle.

Informs about a module version, i.e. group, name, version.

Configuration options for the org.gradle.plugin.devel.plugins.JavaGradlePluginPlugin.

Below is a full configuration example. Since all properties have sensible defaults, typically only selected properties will be configured.

 apply plugin: "java-gradle-plugin" gradlePlugin { pluginSourceSet project.sourceSets.customMain testSourceSets project.sourceSets.functionalTest plugins { helloPlugin { id = 'org.example.hello' implementationClass = 'org.example.HelloPlugin' } } } 

Represents a Gradle project.

Represents some publication produced by a Gradle project, typically to a Maven or Ivy repository.

Executes a Gradle build, allowing inspection of the outcome.

A Gradle runner can be used to functionally test build logic, by executing a contrived build. Assertions can then be made on the outcome of the build, such as the state of files created by the build, or what tasks were actually executed during the build.

A runner can be created via the #create() method.

Typically, the test code using the runner will programmatically create a build (e.g. by writing Gradle build files to a temporary space) to execute. The build to execute is effectively specified by the #withProjectDir(File)} method. It is a requirement that a project directory be set.

The #withArguments(String...) method allows the build arguments to be specified, just as they would be on the command line.

The #build() method can be used to invoke the build when it is expected to succeed, while the #buildAndFail() method can be used when the build is expected to fail.

GradleRunner instances are not thread safe and cannot be used concurrently. However, multiple instances are able to be used concurrently.

Please see the Gradle TestKit User Guide chapter for more information.

Represents a Gradle script. A Gradle script may be a build script, settings script or initialization script.

A GradleScriptException is thrown when an exception occurs in the compilation or execution of a script.

Represents a task which is executable by Gradle.

Extends org.gradle.api.plugins.JavaBasePlugin to provide support for compiling and documenting Groovy source files.

Provides a dynamic dispatching DSL with Groovy semantics for better integration with plugins that rely on Groovy builders such as the core maven plugin.

Compiles Groovy source files, and optionally, Java source files.

Compilation options to be passed to the Groovy compiler.

Fork options for Groovy compilation. Only take effect if GroovyCompileOptions.fork is true.

Adds Groovy configuration convenience methods on top of the MavenDeployer. This class provides also a builder for repository and snapshot-repository:

 mavenUploader.repository(url: 'file://repoDir') { authentication(userName: 'myName') releases(updatePolicy: 'never') snapshots(updatePolicy: 'always') } 

A Plugin which extends the JavaPlugin to provide support for compiling and documenting Groovy source files.

Provides information related to the Groovy runtime(s) used in a project. Added by the org.gradle.api.plugins.GroovyBasePlugin as a project extension named groovyRuntime.

Example usage:

 apply plugin: "groovy" repositories { mavenCentral() } dependencies { compile "org.codehaus.groovy:groovy-all:2.1.2" } def groovyClasspath = groovyRuntime.inferGroovyClasspath(configurations.compile) // The returned class path can be used to configure the 'groovyClasspath' property of tasks // such as 'GroovyCompile' or 'Groovydoc', or to execute these and other Groovy tools directly. 

A GroovySourceSetConvention defines the properties and methods added to a SourceSet by the .

Generates HTML API documentation for Groovy source, and optionally, Java source.

This task uses Groovy's Groovydoc tool to generate the API documentation. Please note that the Groovydoc tool has some limitations at the moment. The version of the Groovydoc that is used, is the one from the Groovy dependency defined in the build script.

Represents something that carries attributes by utilizing an AttributeContainer

Represents something that carries attributes by utilizing an AttributeContainer that is configurable.

An element that is associated with a Gradle project. Via the Gradle project you can access (list, run, etc.) Gradle tasks.

Marks a SAM interface as a target for lambda expressions / closures where the single parameter is passed as the implicit receiver of the invocation (this in Kotlin, delegate in Groovy) as if the lambda expression was an extension method of the parameter type.

 // copySpec(Action<CopySpec>) copySpec { from("./sources") // the given CopySpec is the implicit receiver } 

Represents a property whose value can be set using multiple elements of type T, such as a collection property.

Note: This interface is not intended for implementation by build script or plugin authors. You can use the factory methods on org.gradle.api.model.ObjectFactory to create instances of this interface.

Allows a scriptable object, such as a project extension, to declare its preferred public type. The public type of an object is the one exposed to statically-typed consumers, such as Kotlin build scripts, by default.

A source set that exposes headers

Adds various reporting tasks that provide information about the project.

Represents the basic information about an Eclipse project.

Represents an element which belongs to some hierarchy.

Generates an HTML dependency report. This report combines the features of the ASCII dependency report and those of the ASCII dependency insight report. For a given project, it generates a tree of the dependencies of every configuration, and each dependency can be clicked to show the insight of this dependency.

This task generates a report for the task's containing project by default. But it can also generate a report for multiple projects, by setting the value of the projects property. Here's how to generate an HTML dependency report for all the projects of a multi-project build, for example:

 htmlDependencyReport { projects = project.allprojects } 

The report is generated in the build/reports/project/dependencies directory by default. This can also be changed by setting the reports.html.destination property:

 htmlDependencyReport { reports.html.destination = file("build/reports/project/dependencies") } 

Configuration object for the HTTP build cache. The build cache only supports BASIC authentication currently.

Cache entries are loaded via GET and stored via PUT requests.

Password credentials for a HTTP build cache backend.

Represents an IDE "workspace" that is generated by Gradle and can be opened in the IDE.

IDEA compiler output settings.

Contains content root information.

IDEA dependency.

The scope of the IDEA dependency.

Describes Java language settings for an IDEA module.

Language level setting for IDEA.

Java language level used by IDEA projects.

DSL-friendly model of the IDEA project information. First point of entry when it comes to customizing the IDEA generation.

See the examples in docs for IdeaModule or IdeaProject.

Represents information about the IDEA module.

Enables fine-tuning module details (*.iml file) of the IDEA plugin.

Example of use with a blend of most possible properties. Typically you don't have to configure this model directly because Gradle configures it for you.

 apply plugin: 'java' apply plugin: 'idea' //for the sake of this example, let's introduce a 'performanceTestCompile' configuration configurations { performanceTestCompile performanceTestCompile.extendsFrom(testCompile) } dependencies { //performanceTestCompile "some.interesting:dependency:1.0" } idea { //if you want parts of paths in resulting files (*.iml, etc.) to be replaced by variables (Files) pathVariables GRADLE_HOME: file('~/cool-software/gradle') module { //if for some reason you want to add an extra sourceDirs sourceDirs += file('some-extra-source-folder') //and some extra test source dirs testSourceDirs += file('some-extra-test-dir') //and some extra resource dirs resourceDirs += file('some-extra-resource-dir') //and some extra test resource dirs testResourceDirs += file('some-extra-test-resource-dir') //and hint to mark some of existing source dirs as generated sources generatedSourceDirs += file('some-extra-source-folder') //and some extra dirs that should be excluded by IDEA excludeDirs += file('some-extra-exclude-dir') //if you don't like the name Gradle has chosen name = 'some-better-name' //if you prefer different output folders inheritOutputDirs = false outputDir = file('muchBetterOutputDir') testOutputDir = file('muchBetterTestOutputDir') //if you prefer different SDK than the one inherited from IDEA project jdkName = '1.6' //put our custom test dependencies onto IDEA's TEST scope scopes.TEST.plus += [ configurations.performanceTestCompile ] //if 'content root' (as IDEA calls it) of the module is different contentRoot = file('my-module-content-root') //if you love browsing Javadoc downloadJavadoc = true //and hate reading sources :) downloadSources = false } } 

beforeMerged and whenMerged closures receive a Module parameter

Examples of advanced configuration:

 apply plugin: 'java' apply plugin: 'idea' idea { module { iml { //if you like to keep *.iml in a secret folder generateTo = file('secret-modules-folder') //if you want to mess with the resulting XML in whatever way you fancy withXml { def node = it.asNode() node.appendNode('iLoveGradle', 'true') node.appendNode('butAlso', 'I find increasing pleasure tinkering with output *.iml contents. Yeah!!!') } //closure executed after *.iml content is loaded from existing file //but before gradle build information is merged beforeMerged { module -> //if you want skip merging exclude dirs module.excludeFolders.clear() } //closure executed after *.iml content is loaded from existing file //and after gradle build information is merged whenMerged { module -> //you can tinker with Module } } } } 

Dependency on a module in a project.

Identifies an Idea module.

Models the generation/parsing/merging capabilities of an IDEA module.

For examples, see docs for IdeaModule.

Adds a GenerateIdeaModule task. When applied to a root project, also adds a GenerateIdeaProject task. For projects that have the Java plugin applied, the tasks receive additional Java-specific configuration.

Represents the information about the IDEA project.

Enables fine-tuning project details (*.ipr file) of the IDEA plugin.

Example of use with a blend of all possible properties. Typically you don't have to configure IDEA module directly because Gradle configures it for you.

 import org.gradle.plugins.ide.idea.model.* apply plugin: 'java' apply plugin: 'idea' idea { project { //if you want to set specific jdk and language level jdkName = '1.6' languageLevel = '1.5' //you can update the source wildcards wildcards += '!?*.ruby' //you can configure the VCS used by the project vcs = 'Git' //you can change the modules of the *.ipr //modules = project(':someProject').idea.module //you can change the output file outputFile = new File(outputFile.parentFile, 'someBetterName.ipr') //you can add project-level libraries projectLibraries << new ProjectLibrary(name: "my-library", classes: [new File("path/to/library")]) } } 

beforeMerged and whenMerged closures receive Project object

Examples of advanced configuration:

 apply plugin: 'java' apply plugin: 'idea' idea { project { ipr { //you can tinker with the output *.ipr file before it's written out withXml { def node = it.asNode() node.appendNode('iLove', 'tinkering with the output *.ipr file!') } //closure executed after *.ipr content is loaded from existing file //but before gradle build information is merged beforeMerged { project -> //you can tinker with Project } //closure executed after *.ipr content is loaded from existing file //and after gradle build information is merged whenMerged { project -> //you can tinker with Project } } } } 

"Single-Entry Module Library" as IDEA calls it. For example a single Jar file with sources Jar.

IDEA source directory.

Enables fine-tuning workspace details (*.iws file) of the IDEA plugin.

At the moment, the only practical way of manipulating the resulting content is via the withXml hook:

 apply plugin: 'java' apply plugin: 'idea' idea.workspace.iws.withXml { provider -> provider.asNode().appendNode('gradleRocks', 'true') } 

This exceptions is thrown, if a dependency is declared with a illegal notation.

A build that is included in the composite.

Options for incremental compilation of Scala code. Only used for compilation with Zinc.

Provides access to any input files that need to be processed by an incremental task.

An incremental task action is one that accepts a single IncrementalTaskInputs parameter. The task can then provide an action to execute for all input files that are out of date with respect to the previous execution of the task, and a separate action for all input files that have been removed since the previous execution.

 class IncrementalReverseTask extends DefaultTask { @InputDirectory def File inputDir @OutputDirectory def File outputDir @TaskAction void execute(IncrementalTaskInputs inputs) { if (!inputs.incremental) project.delete(outputDir.listFiles()) inputs.outOfDate { change -> def targetFile = project.file("$outputDir/${change.file.name}") targetFile.text = change.file.text.reverse() } inputs.removed { change -> def targetFile = project.file("$outputDir/${change.file.name}") if (targetFile.exists()) { targetFile.delete() } } } } 

In the case where Gradle is unable to determine which input files need to be reprocessed, then all of the input files will be reported as #outOfDate. Cases where this occurs include:

• There is no history available from a previous execution.
• An org.gradle.api.tasks.TaskOutputs#upToDateWhen(groovy.lang.Closure) criteria added to the task returns false.
• An org.gradle.api.tasks.Input property has changed since the previous execution.
• One or more output files have changed since the previous execution.

• #outOfDate and #removed can each only be executed a single time per IncrementalTaskInputs instance.
• #outOfDate must be executed before #removed is called.

Indicates that a feature is incubating. This means that the feature is currently a work-in-progress and may change at any time.

Generates a Gradle project structure.

Standard implementation of the API exposed to all types of Gradle scripts, precompiled and otherwise.

Enables typed access to extra properties with initial value.

The DSL for declaring plugins to inject into an included build. TODO: Plugins need to be located in this build's buildSrc.

Specification of a dependency on a plugin injected into an included build.

Attached to a task property to indicate that the property specifies some input value for the task.

This annotation should be attached to the getter method in Java or the property in Groovy. Annotations on setters or just the field in Java are ignored.

This will cause the task to be considered out-of-date when the property has changed. When used on a java.io.File object that refers to a file or directory, the up-to-date check is only dependent on the path and not the contents of the file or directory. To make it depend on the contents, use org.gradle.api.tasks.InputFile or org.gradle.api.tasks.InputDirectory respectively.

Marks a property as specifying an input directory for a task.

This annotation should be attached to the getter method in Java or the property in Groovy. Annotations on setters or just the field in Java are ignored.

This will cause the task to be considered out-of-date when the directory location or contents have changed. To make the task dependent on the directory location but not the contents, use an org.gradle.api.tasks.Input annotation instead.

Marks a property as specifying an input file for a task.

This annotation should be attached to the getter method in Java or the property in Groovy. Annotations on setters or just the field in Java are ignored.

This will cause the task to be considered out-of-date when the file path or contents have changed. To make the up-to-date check only dependent on the path and not the contents of the file or directory, annotate it instead with org.gradle.api.tasks.Input.

A change to an input file.

Marks a property as specifying the input files for a task.

This annotation should be attached to the getter method in Java or the property in Groovy. Annotations on setters or just the field in Java are ignored.

This will cause the task to be considered out-of-date when the file paths or contents have changed. Also see org.gradle.api.tasks.InputDirectory.

Input normalization configuration. Input normalization is used when Gradle tries to determine if two task inputs are different. Gradle normalizes both inputs and the inputs are considered different if and only if the normalizations are different.

Used to configure input normalization. Currently, it is only possible to configure runtime classpath normalization.

Installs an executable with it's dependent libraries so it can be easily executed.

Creates a XCTest bundle with a run script so it can be easily executed.

Represents a Java Development Kit machine installation.

A handler for an intermediate result obtained by a BuildActionExecuter.

Attached to a task property to indicate that the property is not to be taken into account for up-to-date checking.

This annotation should be attached to the getter method in Java or the property in Groovy. Annotations on setters or just the field in Java are ignored.

This will cause the task not to be considered out-of-date when the property has changed.

Thrown when a Closure is given as an Action implementation, but has the wrong signature.

Thrown when attempting to publish with an invalid IvyPublication.

Thrown when attempting to publish with an invalid MavenPublication.

Thrown when a component model is declared in an invalid way.

Thrown when a model rule, or source of model rules, is declared in an invalid way.

Thrown when there is a problem with the usage of a model rule.

This exception is different to InvalidModelRuleDeclarationException in that it signifies a problem with using a model rule in a particular context, whereas InvalidModelRuleDeclarationException signifies a problem with the declaration of the model rule itself (which therefore means that the rule could not be used in any context).

This exception should always have cause, that provides information about the actual problem.

Thrown when a plugin is found to be invalid when it is loaded.

Thrown when the plugin under test metadata cannot be read.

Thrown when a build cannot be executed due to the runner being in an invalid state.

A InvalidUserCodeException is thrown when user-provided code cannot be executed.

A InvalidUserDataException is thrown, if a user is providing illegal data for the build.

Isolation mode for workers.

An artifact published as part of a IvyPublication.

An artifact repository which uses an Ivy format to store artifacts and meta-data.

When used to resolve metadata and artifact files, all available patterns will be searched.

When used to upload metadata and artifact files, only a single, primary pattern will be used:

1. If a URL is specified via #setUrl(Object) then that URL will be used for upload, combined with the applied #layout(String).
2. If no URL has been specified but additional patterns have been added via #artifactPattern or #ivyPattern, then the first defined pattern will be used.

Repositories of this type are created by the org.gradle.api.artifacts.dsl.RepositoryHandler#ivy(org.gradle.api.Action) group of methods.

The meta-data provider for an Ivy repository. Uses the Ivy module descriptor (ivy.xml) to determine the meta-data for module versions and artifacts.

A Collection of IvyArtifacts to be included in an IvyPublication. Being a DomainObjectSet, a IvyArtifactSet provides convenient methods for querying, filtering, and applying actions to the set of IvyArtifacts.

 apply plugin: 'ivy-publish' def publication = publishing.publications.create("my-pub", IvyPublication) def artifacts = publication.artifacts artifacts.matching({ it.type == "source" }).all({ it.extension = "src.jar" }) 

A configuration included in an IvyPublication, which will be published in the ivy descriptor file generated.

The set of IvyConfigurations that will be included in the IvyPublication. Being a org.gradle.api.NamedDomainObjectContainer, a IvyConfigurationContainer provides convenient methods for adding, querying, filtering, and applying actions to the set of IvyConfigurations.

 apply plugin: 'ivy-publish' def publication = publishing.publications.create("my-pub", IvyPublication) def configurations = publication.configurations configurations.create("extended", { extend "default"}) configurations.all { extend "base" } 

A module dependency declared in an ivy dependency descriptor published as part of an IvyPublication.

An Ivy descriptor artifact.

Represents the set of "extra" info elements in the Ivy descriptor. These elements are children of the "ivy" element, but are not defined in the Ivy schema and come from other namespaces.

Represents a modifiable form of IvyExtraInfo so that "extra" info elements can be configured on an Ivy publication.

An Ivy Module component.

The metadata about an Ivy module that acts as an input to a component metadata rule.

An author of an Ivy publication.

The description of an Ivy publication.

A license of an Ivy publication.

The descriptor of any Ivy publication.

Corresponds to the XML version of the Ivy Module Descriptor.

The #withXml(org.gradle.api.Action) method can be used to modify the descriptor after it has been generated according to the publication data. However, the preferred way to customize the project information to be published is to use the dedicated configuration methods exposed by this class, e.g. #description(Action).

A repository layout that uses user-supplied patterns. Each pattern will be appended to the base URI for the repository. At least one artifact pattern must be specified. If no Ivy patterns are specified, then the artifact patterns will be used. Optionally supports a Maven style layout for the 'organisation' part, replacing any dots with forward slashes. For examples see the reference for org.gradle.api.artifacts.repositories.IvyArtifactRepository#layout(String, org.gradle.api.Action).

A IvyPublication is the representation/configuration of how Gradle should publish something in Ivy format, to an Ivy repository. You directly add a named Ivy Publication the project's publishing.publications container by providing IvyPublication as the type.

 publishing { publications { myPublicationName(IvyPublication) { // Configure the publication here } } } 

The Ivy module identifying attributes of the publication are mapped as follows:

• module - project.name
• organisation - project.group
• revision - project.version
• status - project.status

For certain common use cases, it's often sufficient to specify the component to publish, using (#from(org.gradle.api.component.SoftwareComponent). The published component is used to determine which artifacts to publish, and which configurations and dependencies should be listed in the generated ivy descriptor file.

You can add configurations to the generated ivy descriptor file, by supplying a Closure to the #configurations(org.gradle.api.Action) method.

To add additional artifacts to the set published, use the #artifact(Object) and #artifact(Object, org.gradle.api.Action) methods. You can also completely replace the set of published artifacts using #setArtifacts(Iterable). Together, these methods give you full control over the artifacts to be published.

In addition, IvyModuleDescriptorSpec provides configuration methods to customize licenses, authors, and the description to be published in the Ivy module descriptor.

For any other tweaks to the publication, it is possible to modify the generated Ivy descriptor file prior to publication. This is done using the IvyModuleDescriptorSpec#withXml(org.gradle.api.Action) method, normally via a Closure passed to the #descriptor(org.gradle.api.Action) method.

 apply plugin: "java" apply plugin: "ivy-publish" task sourceJar(type: Jar) { from sourceSets.main.allJava } publishing { publications { myPublication(IvyPublication) { from components.java artifact(sourceJar) { type "source" extension "src.jar" conf "runtime" } descriptor { license { name = "Custom License" } author { name = "Custom Name" } description { text = "Custom Description" } } } } } 

Adds the ability to publish in the Ivy format to Ivy repositories.

Analyzes code with JDepend.

Configuration options for the JDepend plugin.

A org.gradle.api.Plugin that generates design quality metrics by scanning your source packages. This is done using the JDepend tool. This plugin will automatically generate a task for each Java source set. See JDepend for more information.

The reporting configuration for the JDepend task. Exactly one of the XML or HTML reports can be enabled when the task executes. If more than one or none is enabled, an org.gradle.api.InvalidUserDataException will be thrown.

The JUnit specific test options.

The JUnit platform specific test options.

Represents a JUnit test suite binary.

This plugin adds support for execution of JUnit test suites to the Java software model.

Represents a JUnit test suite.

The JUnit XML files, commonly used to communicate results to CI servers.

Base class for Jacoco tasks.

Task for verifying code coverage metrics. Fails the task if violations are detected based on specified rules.

Requires JaCoCo version >= 0.6.3.

Defines a Jacoco rule limit.

Task to merge multiple execution data files into one.

Plugin that provides support for generating Jacoco coverage data.

Extension including common properties and methods for Jacoco.

Task to generate HTML, Xml and CSV reports of Jacoco coverage data.

Base class for Jacoco report tasks.

The reporting configuration for the JacocoReport task.

Extension for tasks that should run with a Jacoco agent to generate coverage execution data.

Defines a Jacoco violation rule.

The violation rules configuration for the org.gradle.testing.jacoco.tasks.JacocoReport task.

Assembles a JAR archive.

Assembles a JAR archive.

Definition of a Jar file binary that is to be built by Gradle.

Represents a jar directory element of an idea module library.

Details for generating Java-based application start scripts.

A org.gradle.api.Plugin which compiles and tests Java source, and assembles it into a JAR file.

Compiles Java source files.

 apply plugin: 'java' tasks.withType(JavaCompile) { //enable compilation in a separate daemon process options.fork = true //enable incremental compilation options.incremental = true } 

Informs about the Java environment, for example the Java home or the JVM args used. See example in BuildEnvironment.

Executes a Java application in a child process.

Similar to org.gradle.api.tasks.Exec, but starts a JVM with the given classpath and application class.

 apply plugin: 'java' task runApp(type: JavaExec) { classpath = sourceSets.main.runtimeClasspath main = 'package.Main' // arguments to pass to the application args 'appArg1' } 

The process can be started in debug mode (see #getDebug()) in an ad-hoc manner by supplying the `--debug-jvm` switch when invoking the build.

 gradle someJavaExecTask --debug-jvm 

Specifies the options for executing a Java application.

Specifies the options to use to fork a Java process.

A plugin for building java gradle plugins. Automatically generates plugin descriptors. Emits warnings for common error conditions.

Provides a direct integration with TestKit by declaring the gradleTestKit() dependency for the test compile configuration and a dependency on the plugin classpath manifest generation task for the test runtime configuration. Default conventions can be customized with the help of GradlePluginDevelopmentExtension. Integrates with the 'maven-publish' and 'ivy-publish' plugins to automatically publish the plugins so they can be resolved using the `pluginRepositories` and `plugins` DSL.

Plugin for compiling Java code. Applies the org.gradle.language.base.plugins.ComponentModelBasePlugin and org.gradle.language.jvm.plugins.JvmResourcesPlugin. Registers "java" language support with the JavaSourceSet.

A Plugin which package a Java project as a distribution including the JAR and runtime dependencies.

A Plugin which extends the capabilities of the JavaPlugin by cleanly separating the API and implementation dependencies of a library.

Defines and configures a Java SE runtime environment, consisting of a JVM runtime and a set of class libraries.

 plugins { id "jvm-component" id "java-lang" } model { components { myLib(JvmLibrarySpec) { targetPlatform "java6" } } } 

A Plugin which compiles and tests Java source, and assembles it into a JAR file.

Is mixed into the project when applying the org.gradle.api.plugins.JavaBasePlugin or the org.gradle.api.plugins.JavaPlugin.

Represents a Java virtual machine installation.

Task to minify JavaScript assets.

Represents a source set containing javascript sources.

A set of sources passed to the Java compiler.

A set of tools for building from Java source.

A JavaToolChain is able to:

• Compile Java source to bytecode.
• Generate Javadoc from Java source.

A container for JavaToolChains.

An enumeration of Java versions. Before 9: http://www.oracle.com/technetwork/java/javase/versioning-naming-139433.html 9+: http://openjdk.java.net/jeps/223

Generates HTML API documentation for Java classes.

If you create your own Javadoc tasks remember to specify the 'source' property! Without source the Javadoc task will not create any documentation. Example:

 apply plugin: 'java' task myJavadocs(type: Javadoc) { source = sourceSets.main.allJava } 

An example how to create a task that runs a custom doclet implementation:

 apply plugin: 'java' configurations { jaxDoclet } dependencies { //jaxDoclet "some.interesting:Dependency:1.0" } task generateRestApiDocs(type: Javadoc) { source = sourceSets.main.allJava destinationDir = reporting.file("rest-api-docs") options.docletpath = configurations.jaxDoclet.files.asType(List) options.doclet = "com.lunatech.doclets.jax.jaxrs.JAXRSDoclet" options.addStringOption("jaxrscontext", "http://localhost:8080/myapp") } 

An artifact containing Javadoc documentation.

This enum maps to the -public, -protected, -package and -private options of the javadoc executable.

This class is used to hold the information that can be provided to the javadoc executable via the -linkoffline option.

Represents a Javadoc command-line option.

This enum maps to the -verbose and -quiet options of the javadoc executable.

Represents information for the project Java SDK. This translates to attributes of the ProjectRootManager element in the ipr.

Represents the Eclipse JDT settings.

Specifies the packages that constitute the API of a library. Facilitates separation of API and implementation binaries for that library. Backing object for the api {} DSL.

Represents a binary artifact that is the result of building a jvm component.

LanguageOutputType marking Jvm byte code.

A set of classes and resources that operate together.

Base plugin for JVM component support. Applies the org.gradle.language.base.plugins.ComponentModelBasePlugin. Registers the JvmLibrarySpec library type for the components container.

Definition of a software component that is to be built by Gradle to run a on JVM platform.

A Library component that runs on the Java Virtual Machine.

Definition of a JVM library component that is to be built by Gradle.

A set of resource files.

LanguageOutputType marking Jvm Resource Output

Plugin for packaging JVM resources. Applies the org.gradle.language.base.plugins.ComponentModelBasePlugin. Registers "resources" language support with the .

Enumerates the different kinds of JVM tests. This allows to differentiate between test suites, atomic tests, etc.

Describes a test that runs on the JVM and for which an event has occurred. At least a suite name, class name, or method name is available for each JVM test.

The base plugin that needs to be applied by all plugins which provide testing support for the Java software model.

Base type of JVM test suite binaries.

Base type for all JVM test suites.

Base class for Kotlin build scripts.

Kotlin build script template model.

Adapts a parameterless Kotlin function to a parameterless Groovy Closure.

Adapts an unary Kotlin function to an unary Groovy Closure.

Adapts a binary Kotlin function to a binary Groovy Closure.

Configures the Kotlin compiler to recognise Gradle functional interface annotated with HasImplicitReceiver.

The kotlin-dsl plugin.

Base class for Kotlin init scripts.

Temporary workaround for Kotlin 1.2.50.

Base class for Kotlin settings scripts.

Base plugin for language support. - Adds a ProjectSourceSet named sources to the project. - Registers the base LanguageSourceSet type.

A set of sources for a programming language.

Represents an object that can be used to launch a Gradle build, such as a task.

To launch a build, you pass one or more org.gradle.tooling.model.Launchable instances to either org.gradle.tooling.BuildLauncher#forTasks(Iterable) or org.gradle.tooling.BuildLauncher#forLaunchables(Iterable).

Resolved configuration that does not fail eagerly when some dependencies are not resolved, or some artifacts do not exist.

A classpath entry representing a library.

A library that can be linked into or depended on by another software element.

A dependency onto a specific binary of a library published by a project.

An identifier for a library instance that is built as part of the current build.

A binary produced from a `org.gradle.platform.base.LibrarySpec`.

Criteria for selecting a library instance that is built as part of the current build.

Allows the API and implementation dependencies of a library to be specified.

A specification of a org.gradle.platform.base.Library.

A org.gradle.api.Plugin which defines a basic project lifecycle.

Link.

Links a binary executable from object files and libraries.

Links a binary bundle from object files and imported libraries.

Links a binary shared library from object files and imported libraries.

Specify how a native library should be linked into another binary.

Represents a property whose type is a List of elements of type T.

Note: This interface is not intended for implementation by build script or plugin authors. An instance of this class can be created through the factory method org.gradle.api.model.ObjectFactory#listProperty(Class).

Thrown whenever a listener fails with an exception, which in general implies that the build completed like it should, but that one of the listeners failed with an exception.

A local JDK, JRE or Java 9+ installation.

Marks a property as specifying local state for a task.

This annotation should be attached to the getter method in Java or the property in Groovy. Annotations on setters or just the field in Java are ignored.

Local state is removed when the task is loaded from cache.

The log levels supported by Gradle.

An extension to the SLF4J Logger interface, which adds the quiet and lifecycle log levels.

You can obtain a Logger instance using Logging#getLogger(Class) or . A Logger instance is also available through , org.gradle.api.Task#getLogger() and .

The main entry point for Gradle's logging system. Gradle routes all logging via SLF4J. You can use either an SLF4J org.slf4j.Logger or a Gradle Logger to perform logging.

A LoggingConfiguration defines the logging settings for a Gradle build.

A LoggingManager provides access to and control over the Gradle logging system. Using this interface, you can control standard output and error capture and receive logging events.

Provides access to the output of the Gradle logging system.

Offers ways to communicate both ways with a Gradle operation, be it building a model or running tasks.

Enables tracking progress via listeners that will receive events from the Gradle operation.

Allows providing standard output streams that will receive output if the Gradle operation writes to standard streams.

Allows providing standard input that can be consumed by the gradle operation (useful for interactive builds).

Enables configuring the build run / model request with options like the Java home or JVM arguments. Those settings might not be supported by the target Gradle version. Refer to Javadoc for those methods to understand what kind of exception throw and when is it thrown.

A managed type is transparent to the model space, and enforces immutability at the appropriate times in the object's lifecycle.

Gradle generates implementations for managed types. As such, managed types are declared either as interfaces or abstract classes. The generated implementation integrates with the model space mechanisms, and manages mutability.

Managed types are mostly behaviour-less, as they are data. Instances of managed types should effectively be considered value objects.

Managed types declare their structure as properties, via getter and setter methods. Getter and setter methods are expected to conform to the well-known Java Bean naming conventions. A read/write “name” property would be expressed via the following methods:

 void setName(String name); String getName(); 

A getter and setter must be declared for each property that is not of a managed type or of ModelSet. For properties of managed types or of ModelSet the getter is mandatory and the setter is optional. If no setter is provided the property is considered inherent and defaults to an "empty" instance of the type. In addition to the traditional getter method, properties of type boolean (but not Boolean) also support a getter method which name starts with is, for example:

 void setEnabled(boolean enabled); boolean isEnabed(); 

The following JDK types are allowed:

• String
• Boolean
• Character
• Byte
• Short
• Integer
• Long
• Float
• Double
• java.math.BigInteger
• java.math.BigDecimal
• java.io.File

All primitive types and Enum types are also allowed.

Properties that are themselves of a managed type are also supported.

Currently, the only collection types that are supported are ModelSet and ModelMap, as well as java.util.Set or java.util.List of org.gradle.model.internal.manage.schema.extract.ScalarTypes, where scalar types is either one of the supported immutable JDK types above or an enumeration.

Properties of any other type must have their getter annotated with Unmanaged. An unmanaged property is not transparent to the model infrastructure and is guaranteed to be immutable when realized.

Managed types may implement/extend the org.gradle.api.Named interface. Any managed type implementing this interface will have its name attribute populated automatically based on the name of the corresponding node in the model graph.

The ModelMap type requires that its elements are org.gradle.api.Named.

Managed types can be arranged into an inheritance hierarchy. Every type in the hierarchy must conform to the constraints of managed types.

Managed types can contain getter methods that return calculated values, based on other properties. For example, a “name” property may return the concatenation of a “firstName” and “lastName” property. When using Java 8 or later, such properties can be implemented as interface default methods. Alternatively, the managed type can be implemented as an abstract class with the calculated property implemented as a non-abstract getter method. In both cases, the implementation of the calculated property getter may not call any setter method.

A managed type can be implemented as an abstract class. All property getters and setters must be declared abstract (with the exception of calculated read-only properties). The class cannot contain instance variables, constructors, or any methods that are not a getter or setter.

Please see Model for information on creating model elements of managed types.

Represents the manifest file of a JAR file.

Is thrown in the case an operation is applied against a org.gradle.api.java.archives.Manifest that violates the Manifest specification.

Details of a value being merged from two different manifests.

Specifies how the entries of multiple manifests should be merged together.

Simple build cache implementation that delegates to a ConcurrentMap.

An artifact published as part of a MavenPublication.

An artifact repository which uses a Maven format to store artifacts and meta-data.

Repositories of this type are created by the org.gradle.api.artifacts.dsl.RepositoryHandler#maven(org.gradle.api.Action) group of methods.

A Collection of MavenArtifacts to be included in a MavenPublication. Being a DomainObjectSet, a MavenArtifactSet provides convenient methods for querying, filtering, and applying actions to the set of MavenArtifacts.

 apply plugin: 'maven-publish' def publication = publishing.publications.create("name", MavenPublication) def artifacts = publication.artifacts artifacts.matching({ it.classifier == "classy" }).all({ it.extension = "ext" }) 

A dependency declared as part of an MavenPublication.

A resolver that can only be used for uploading artifacts to a Maven repository. If you use this resolver for getting dependencies from a Maven repository, an exception is thrown. This resolver support all aspects of Maven deployment, including snapshot deployment and metadata.xml manipulation.

You have to specify at least one repository. Otherwise, if there is only one artifact, usually there is not more to do. If there is more than one artifact you have to decide what to do about this, as a Maven POM can only deal with one artifact. There are two strategies. If you want to deploy only one artifact you have to specify a filter to select this artifact. If you want to deploy more than one artifact, you have to specify filters which select each artifact. Associated with each filter is a separate configurable POM.

You can create an instance of this type via the org.gradle.api.tasks.Upload#getRepositories() container

Represents the artifacts which will be deployed to a Maven repository. You can use this interface to modify the set of artifacts.

A Maven Module component.

A org.gradle.api.Plugin which allows project artifacts to be deployed to a Maven repository, or installed to the local Maven cache.

Properties and methods added by the org.gradle.api.plugins.MavenPlugin.

Is used for generating a Maven POM file and customizing the generation. To learn about the Maven POM see: http://maven.apache.org/pom.html

The POM for a Maven publication.

The #withXml(org.gradle.api.Action) method can be used to modify the descriptor after it has been generated according to the publication data. However, the preferred way to customize the project information to be published is to use the dedicated properties exposed by this class, e.g. #getDescription(). Please refer to the official POM Reference for detailed information about the individual properties.

A Maven POM artifact.

The CI management system of a Maven publication.

A contributor of a Maven publication.

Allows to add contributors of a Maven publication.

A developer of a Maven publication.

Allows to add developers to a Maven publication.

The distribution management configuration of a Maven publication.

The issue management system of a Maven publication.

A license of a Maven publication.

Allows to add licenses to a Maven publication.

A mailing list of a Maven publication.

Allows to add mailing lists to a Maven publication.

The organization of a Maven publication.

The relocation information of a Maven publication that has been moved to a new group and/or artifact ID.

The SCM (source control management) of a Maven publication.

A MavenPublication is the representation/configuration of how Gradle should publish something in Maven format. You directly add a named Maven Publication the project's publishing.publications container by providing MavenPublication as the type.

 publishing { publications { myPublicationName(MavenPublication) { // Configure the publication here } } } 

• groupId - project.group
• artifactId - project.name
• version - project.version

For certain common use cases, it's often sufficient to specify the component to publish, and nothing more (#from(org.gradle.api.component.SoftwareComponent). The published component is used to determine which artifacts to publish, and which dependencies should be listed in the generated POM file.

To add additional artifacts to the set published, use the #artifact(Object) and #artifact(Object, org.gradle.api.Action) methods. You can also completely replace the set of published artifacts using #setArtifacts(Iterable). Together, these methods give you full control over what artifacts will be published.

To customize the metadata published in the generated POM, set properties, e.g. MavenPom#getDescription(), on the POM returned via the #getPom() method or directly by an action (or closure) passed into #pom(org.gradle.api.Action). As a last resort, it is possible to modify the generated POM using the MavenPom#withXml(org.gradle.api.Action) method.

 apply plugin: "java" apply plugin: "maven-publish" task sourceJar(type: Jar) { from sourceSets.main.allJava classifier "sources" } publishing { publications { myPublication(MavenPublication) { from components.java artifact sourceJar pom { name = "Demo" description = "A demonstration of Maven POM customization" url = "http://www.example.com/project" licenses { license { name = "The Apache License, Version 2.0" url = "http://www.apache.org/licenses/LICENSE-2.0.txt" } } developers { developer { id = "johnd" name = "John Doe" email = "john.doe@example.com" } } scm { connection = "scm:svn:http://subversion.example.com/svn/project/trunk/" developerConnection = "scm:svn:https://subversion.example.com/svn/project/trunk/" url = "http://subversion.example.com/svn/project/trunk/" } } } } } 

Adds the ability to publish in the Maven format to Maven repositories.

Allows Maven repositories for publishing artifacts to be defined. The Maven plugin mixes-in this interface to the org.gradle.api.artifacts.dsl.RepositoryHandler associated with each task of type org.gradle.api.tasks.Upload.

An ArtifactRepository which can be used to publish artifacts to Maven repositories.

Interface for repositories which support custom metadata suppliers and/or version listers. A custom version lister or metadata supplier can be used as an optimization technique to avoid too many requests on a server. By providing such rules, a plugin or build author can provide the necessary information to perform component selection without having to actually fetch the component metadata on a server.

A Plugin which makes the Microsoft Visual C++ compiler available to compile C/C++ code.

Provides the core Javadoc options.

Exception thrown when the resource does not exist

A model that is buildable by the Tooling API. Models contain various information regarding the build. Models are typically tailored to a specific domain, for example build environment or IDE.

Denotes that the RuleSource method rule carrying this annotation creates a new top level element in the model space.

The method must advertise a name and type for the model element. The name is defined either by the name of the method, or the #value of this annotation. The type is defined differently depending on whether the new element is Managed or not.

If the element is to be of a managed type, the method must return void and receive the newly created instance as the first parameter. All other parameters are considered inputs.

It is an error for a @Model rule to return void and specify a non-managed type as the first parameter. It is an error for a @Model rule to return void and for the first parameter to be annotated with Path. It is an error for a @Model rule to specify a managed type as the return type.

If the element is to be of a non-managed type, the method must return the newly created instance. All parameters are considered inputs. Please see RuleSource for more information on method rules.

A ModelBuilder allows you to fetch a snapshot of some model for a project or a build. Instances of ModelBuilder are not thread-safe.

You use a ModelBuilder as follows:

• Create an instance of ModelBuilder by calling org.gradle.tooling.ProjectConnection#model(Class).
• Configure the builder as appropriate.
• Call either #get() or #get(ResultHandler) to build the model.
• Optionally, you can reuse the builder to build the model multiple times.

 ProjectConnection connection = GradleConnector.newConnector() .forProjectDirectory(new File("someFolder")) .connect(); try { ModelBuilder<GradleProject> builder = connection.model(GradleProject.class); //if you use a different than usual build file name: builder.withArguments("--build-file", "theBuild.gradle"); //configure the standard input in case your build is interactive: builder.setStandardInput(new ByteArrayInputStream("consume this!".getBytes())); //if you want to listen to the progress events: ProgressListener listener = null; // use your implementation builder.addProgressListener(listener); //get the model: GradleProject project = builder.get(); //query the model for information: System.out.println("Available tasks: " + project.getTasks()); } finally { connection.close(); } 

Represents an element in a model. Elements are arranged in a hierarchy.

Thrown when a model element cannot be instantiated for some reason.

Model backed map like structure allowing adding of items where instantiation is managed.

org.gradle.model.Managed types may declare model map properties. Model maps can only contain managed types.

Displays some details about the configuration model of the project. An instance of this type is used when you execute the model task from the command-line.

Thrown when there is a problem binding the model element references of a model rule.

Should always be thrown as the cause of a org.gradle.model.InvalidModelRuleException.

A set of managed model objects.

org.gradle.model.Managed types may declare managed set properties. Managed sets can only contain managed types.

Managed set objects cannot be mutated via the mutative methods of the java.util.Set interface (e.g. java.util.Set#add(Object), java.util.Set#clear()). To add elements to the set, the #create(Action) method can be used.

Thrown when at attempt is made to mutate a subject of a rule after the rule has completed.

This can potentially happen when a reference to the subject is retained during a rule and then used afterwards, Such as when an anonymous inner class or closure “closes over” the subject.

Represents the customizable elements of an iml (via XML hooks everything of the iml is customizable).

An identifier for a component instance which is available as a module version.

Criteria for selecting a component instance that is available as a module version.

Represents an orderEntry of type module in the iml XML.

A ModuleDependency is a org.gradle.api.artifacts.Dependency on a module outside the current project.

For examples on configuring the exclude rules please refer to #exclude(java.util.Map).

A dependency onto a module.

A builder of a ModuleDependencySpec.

The identifier of a module.

Represents an orderEntry of type module-library in the iml XML.

The identifier of a module version.

Selects a module version. If you need to change this interface, you're probably doing it wrong: it is superceded by org.gradle.api.artifacts.component.ModuleComponentSelector, so check this first, and only add methods here if it's for bridging.

Provides context about candidates for an attribute. In particular, this class gives access to the list of candidates on the producer side.

Describes the capabilities of a component in a mutable way. This interface can be used to adjust the capabilities of a published component via metadata rules (see org.gradle.api.artifacts.dsl.ComponentMetadataHandler.

Provides efficient access to a mutable dynamic property.

A configurable version constraint. This is exposed to the build author, so that one can express more constraints on a version,

Denotes that the RuleSource method rule carrying this annotation mutates the rule subject.

Mutate rules execute after Defaults rules, but before Finalize rules. The first parameter of the rule is the rule subject, which is mutable for the duration of the rule.

Please see RuleSource for more information on method rules.

Types can implement this interface and use the embedded Namer implementation, to satisfy API that calls for a namer.

A NamedDomainObjectCollection represents a collection of domain objects that have an inherent, constant, name.

Objects to be added to a named domain object collection must implement equals() in such a way that no two objects with different names are considered equal. That is, all equality tests must consider the name as an equality key. Behavior is undefined if two objects with different names are considered equal by their equals() implementation.

All implementations must guarantee that all elements in the collection are uniquely named. That is, an attempt to add an object with a name equal to the name of any existing object in the collection will fail. Implementations may choose to simply return false from add(T) or to throw an exception.

Objects in the collection are accessible as read-only properties, using the name of the object as the property name. For example (assuming the 'name' property provides the object name):

 books.add(new Book(name: "gradle", title: null)) books.gradle.title = "Gradle in Action" 

A dynamic method is added for each object which takes a configuration closure. This is equivalent to calling #getByName(String, groovy.lang.Closure). For example:

 books.add(new Book(name: "gradle", title: null)) books.gradle { title = "Gradle in Action" } 

You can also use the [] operator to access the objects of a collection by name. For example:

 books.add(new Book(name: "gradle", title: null)) books['gradle'].title = "Gradle in Action" 

Rule objects can be attached to the collection in order to respond to requests for objects by name where no object with name exists in the collection. This mechanism can be used to create objects on demand. For example:

 books.addRule('create any') { books.add(new Book(name: "gradle", title: null)) } books.gradle.name == "gradle" 

A named domain object container is a specialisation of NamedDomainObjectSet that adds the ability to create instances of the element type.

Implementations may use different strategies for creating new object instances.

Note that a container is an implementation of java.util.SortedSet, which means that the container is guaranteed to only contain elements with unique names within this container. Furthermore, items are ordered by their name.

A property delegate that creates elements in the given NamedDomainObjectContainer.

Receiver for NamedDomainObjectContainer configuration blocks.

A factory for named objects of type T.

A specialisation of org.gradle.api.NamedDomainObjectCollection that also implements java.util.List.

All object equality is determined in terms of object names. That is, calling remove() with an object that is NOT equal to an existing object in terms of equals, but IS in terms of name equality will result in the existing collection item with the equal name being removed.

A specialisation of NamedDomainObjectCollection that also implements Set and orders objects by their inherent name.

All object equality is determined in terms of object names. That is, calling remove() with an object that is NOT equal to an existing object in terms of equals, but IS in terms of name equality will result in the existing collection item with the equal name being removed.

A namer is capable of providing a name based on some inherent characteristic of an object.

A common base plugin for the native plugins.

Expects plugins to register the native components in the Project#getComponents() container, and defines a number of rules that act on these components to configure them.

• Configures the {@value LifecycleBasePlugin#ASSEMBLE_TASK_NAME} task to build the development binary of the main component, if present. Expects the main component to be of type ProductionComponent and ComponentWithBinaries.
• Adds an "assemble" task for each binary of the main component.
• Adds tasks to compile and link an executable. Currently requires component implements internal API ConfigurableComponentWithExecutable.
• Adds tasks to compile and link a shared library. Currently requires component implements internal API ConfigurableComponentWithSharedLibrary.
• Adds tasks to compile and create a static library. Currently requires component implements internal API ConfigurableComponentWithStaticLibrary.
• Adds outgoing configuration and artifacts for link file. Currently requires component implements internal API ConfigurableComponentWithLinkUsage.
• Adds outgoing configuration and artifacts for runtime file. Currently requires component implements internal API ConfigurableComponentWithRuntimeUsage.
• Maven publications. Currently requires component implements internal API PublicationAwareComponent.

A plugin that sets up the infrastructure for testing native binaries.

Represents a particular binary artifact.

Represents a binary artifact that is the result of building a native component.

The configuration for native components generated by this build.

A plugin that sets up the infrastructure for defining native binaries.

A plugin that creates tasks used for constructing native binaries.

Definition of a software component that is to be built by Gradle to run a on JVM platform.

Models a collection of native type dependencies.

An executable native component that is built by Gradle.

A binary artifact for a NativeExecutable, targeted at a particular platform with specific configuration.

An binary built by Gradle for a native application.

Specifies how to build and where to place a native executable file.

TODO:HH resolve naming conflict with existing NativeExecutableSpec

Definition of a native executable component that is to be built by Gradle.

Specifies the installation location for a native executable.

A library component that is built by a gradle project.

A physical representation of a NativeLibrary component.

Represents a binary artifact that is the result of building a native library component.

A dependency on a native library within the build.

Definition of a native library component that is to be built by Gradle.

A target platform for building native binaries. Each target platform is given a name, and may optionally be given a specific Architecture and/or OperatingSystem to target.

 model { platforms { windows_x86 { architecture "i386" operatingSystem "windows" } } } 

A platform specific configurable tool chain.

A source set that provides resources.

An executable which runs a suite of tests.

A component representing a suite of tests that will be executed together.

Common base plugin for all native testing plugins.

Expects plugins to register the native test suites in the Project#getComponents() container, and defines a number of rules that act on these components to configure them.

• Adds a "test" task.
• Configures the "test" task to run the tests of the test component, if present. Expects the test component to be of type TestSuiteComponent.

A set of compilers and linkers that are used together to construct a native binary.

A container for NativeToolChains.

Marks a property as specifying a nested bean, whose properties should be checked for annotations.

This annotation should be attached to the getter method in Java or the property in Groovy. Annotations on setters or just the field in Java are ignored.

The implementation of the nested bean is tracked as an input, too. This allows tracking behavior such as org.gradle.api.Actions as task inputs.

This annotations supports org.gradle.api.provider.Provider values by treating the result of org.gradle.api.provider.Provider#get() as a nested bean.

This annotation supports Iterable values by treating each element as a separate nested bean. As a property name, the index of the element in the iterable prefixed by $ is used, e.g. $0. If the element implements org.gradle.api.Named, then the property name is composed of org.gradle.api.Named#getName() and the index, e.g. name$1. The ordering of the elements in the iterable is crucial for for reliable up-to-date checks and caching.

This annotation supports $java.util.Map values by treating each value of the map as a separate nested bean. The keys of the map are used as property names.

Indicates that the type, when DSL enhanced, does not support extensibility.

This means that it will not be enhanced with org.gradle.api.plugins.ExtensionAware.

Marks a type or a whole package as providing a non-null API by default. All parameter and return types are assumed to be Nonnull unless specifically marked as Nullable.

A org.gradle.api.specs.Spec implementation which negates another Spec.

Indicates that the value of an element can be null.

An ObjectConfigurationAction allows you to apply org.gradle.api.Plugins and scripts to an object or objects.

A factory for creating various kinds of model objects.

An instance of the factory can be injected into a task or plugin by annotating a public constructor or method with javax.inject.Inject. It is also available via org.gradle.api.Project#getObjects().

LanguageOutputType marking object file output type.

A task that combines a set of object files into a single binary.

Thrown when an object cannot be instantiated.

Compiles Objective-C source files into object files.

Adds core Objective-C language support.

A plugin for projects wishing to build native binary components from Objective-C sources.

Automatically includes the ObjectiveCLangPlugin for core Objective-C support and the org.gradle.nativeplatform.plugins.NativeComponentPlugin for native component support.

• Creates a org.gradle.language.objectivec.tasks.ObjectiveCCompile task for each org.gradle.language.objectivec.ObjectiveCSourceSet to compile the Objective-C sources.

Compiles Objective C header source files into object files.

A set of Objective-C source files.

An ObjectiveC source set contains a set of source files, together with an optional set of exported header files.

 apply plugin: "objective-c" model { components { main(NativeLibrarySpec) { sources { objc { source { srcDirs "src/main/objectiveC", "src/shared/objectiveC" include "**/*.m" } exportedHeaders { srcDirs "src/main/include" } } } } } } 

Compiles Objective-C++ source files into object files.

Adds core Objective-Cpp language support.

A plugin for projects wishing to build native binary components from Objective-C++ sources.

Automatically includes the ObjectiveCppLangPlugin for core Objective-C++ support and the NativeComponentPlugin for native component support.

• Creates a org.gradle.language.objectivecpp.tasks.ObjectiveCppCompile task for each org.gradle.language.objectivecpp.ObjectiveCppSourceSet to compile the Objective-C++ sources.

Compiles Objective C++ header source files into object files.

A set of Objective-C++ source files.

An Objective-C++ source set contains a set of source files, together with an optional set of exported header files.

 apply plugin: "objective-cpp" model { components { main(NativeLibrarySpec) { sources { objcpp { source { srcDirs "src/main/objectiveCpp", "src/shared/objectiveCpp" include "**/*.mm" } exportedHeaders { srcDirs "src/main/include" } } } } } } 

A machine operating system. Operating System Aliases Windows "windows" GNU/Linux "linux" MacOS "osx", "mac os x", "darwin" Solaris "solaris", "sunos"

Represents the operating system of a configuration. Typical operating system include Windows, Linux, and macOS. This interface allows the user to customize operating systems by implementing this interface.

Describes an operation for which an event has occurred.

You can use equals() to determine whether 2 different descriptors refer to the same operation.

The subtypes of this interface define specific types of operations, such as task execution.

Describes the result of running an operation.

Enumerates the different types of operations for which progress events can be received.

Marks a property of a org.gradle.api.Task as being configurable from the command-line.

This annotation should be attached to a field or a setter method. When attached to a field, #option() will use the name of the field by default. When attached to a method, #option() must be specified.

An option may have one of the following types:

• boolean
• Boolean
• Enum
• List<Enum>
• List<String>
• String

Represents a Javadoc option.

Marks a method on a org.gradle.api.Task as providing the possible values for a String or List<String> Option. At most one option values method may be provided for a particular option.

This annotation should be attached to a getter method that returns a java.util.Collection of possible values. The entries in the collection may be of any type. If necessary, they are transformed into String by calling toString().

Marks a task property as optional. This means that a value does not have to be specified for the property, but any value specified must meet the validation constraints for the property.

This annotation should be attached to the getter method in Java or the property in Groovy. Annotations on setters or just the field in Java are ignored.

• org.gradle.api.tasks.Input
• org.gradle.api.tasks.InputFile
• org.gradle.api.tasks.InputDirectory
• org.gradle.api.tasks.InputFiles
• org.gradle.api.tasks.OutputFile
• org.gradle.api.tasks.OutputDirectory

A CompositeSpec which requires any one of its specs to be true in order to evaluate to true. Uses lazy evaluation.

Represents a manifest file for a JAR containing an OSGi bundle.

A Plugin which extends the JavaPlugin to add OSGi meta-information to the project Jars.

Is mixed into the project when applying the org.gradle.api.plugins.osgi.OsgiPlugin.

A classpath entry representing an output folder.

Marks a property as specifying one or more output directories for a task.

This annotation should be attached to the getter method in Java or the property in Groovy. Annotations on setters or just the field in Java are ignored.

This will cause the task to be considered out-of-date when the directory paths or task output to those directories have been modified since the task was last run.

When the annotated property is a java.util.Map, then each output directory will be associated with an identity. For cacheable tasks this is a requirement. The keys of the map must be non-empty strings. The values of the map will be evaluated to individual directories as per org.gradle.api.Project#file(Object).

Otherwise the given directories will be evaluated as per org.gradle.api.Project#files(Object...), and task output caching will be disabled for the task.

Marks a property as specifying an output directory for a task.

This annotation should be attached to the getter method in Java or the property in Groovy. Annotations on setters or just the field in Java are ignored.

This will cause the task to be considered out-of-date when the directory path or task output to that directory has been modified since the task was last run.

Marks a property as specifying an output file for a task.

This annotation should be attached to the getter method in Java or the property in Groovy. Annotations on setters or just the field in Java are ignored.

This will cause the task to be considered out-of-date when the file path or contents are different to when the task was last run.

Marks a property as specifying one or more output files for a task.

This annotation should be attached to the getter method in Java or the property in Groovy. Annotations on setters or just the field in Java are ignored.

This will cause the task to be considered out-of-date when the file paths or contents are different to when the task was last run.

When the annotated property is a java.util.Map, then each output file will be associated with an identity. For cacheable tasks this is a requirement. The keys of the map must be non-empty strings. The values of the map will be evaluated to individual files as per org.gradle.api.Project#file(Object).

Otherwise the given files will be evaluated as per org.gradle.api.Project#files(Object...), and task output caching will be disabled for the task.

Represents a Swift Package Manager package.

A ParallelismConfiguration defines the parallel settings for a Gradle build.

A ToolingModelBuilder which can be parametrized by the client.

The parameter type T does not need to implement the interface defined in the client side, but it does need to have the same structure. The Tooling API will create a view from the client side parameter type to the one defined in this model builder, and deal automatically with missing methods in order to allow evolution of the models.

All classes implementing this interface should also implement methods from ToolingModelBuilder, which will be used to determine if a model can be built by the current builder and to generate the model in case no parameter is passed from the client. The parameter type should be bound to the model type.

A username/password credentials that can be used to login to password-protected remote repository.

A username/password credentials that can be used to login to something protected by a username and password.

Represents a path in a format as used often in ipr and iml files.

Specifies a model path on a parameter

Path Factory.

Annotates a task file property, specifying which part of the file paths should be considered during up-to-date checks.

This annotation should be attached to the getter method in Java or the property in Groovy. Annotations on setters or just the field in Java are ignored.

Enumeration of different path handling strategies for task properties.

An enumeration for describing validation policies for file paths.

A PatternFilterable represents some file container which Ant-style include and exclude patterns or specs can be applied to.

Patterns may include:

• '*' to match any number of characters
• '?' to match any single character
• '**' to match any number of directories or files

Either '/' or '\' may be used in a pattern to separate directories. Patterns ending with '/' or '\' will have '**' automatically appended.

Examples:

 all files ending with 'jsp' (including subdirectories) **/*.jsp all files beginning with 'template_' in the level1/level2 directory level1/level2/template_* all files (including subdirectories) beneath src/main/webapp src/main/webapp/ all files beneath any .svn directory (including subdirectories) under src/main/java src/main/java/**/.svn/** 

You may also use a closure or Spec to specify which files to include or exclude. The closure or Spec is passed a org.gradle.api.file.FileTreeElement, and must return a boolean value.

If no include patterns or specs are specified, then all files in this container will be included. If any include patterns or specs are specified, then a file is included if it matches any of the patterns or specs.

If no exclude patterns or spec are specified, then no files will be excluded. If any exclude patterns or specs are specified, then a file is include only if it matches none of the patterns or specs.

Standalone implementation of PatternFilterable.

A normalised form for keys, which are friendliest for users as hex strings but used internally as longs.

PGP signatory from PGP key and password.

Creates PgpSignatory instances.

A SignatoryProvider of PgpSignatory instances.

The platform or runtime that a binary is designed to run on. Examples: the JvmPlatform defines a java runtime, while the NativePlatform defines the Operating System and Architecture for a native app.

Defines Platform specific operations for ComponentSpecs

A container of Platforms.

A platform-aware Java compile task.

A platform-aware Scala compile task.

Represents a binary artifact that is the result of building a Play application software component.

Plugin for Play Framework component support. Registers the org.gradle.play.PlayApplicationSpec component type for the components container.

Definition of a Play Framework software component that is built by Gradle.

Task for compiling CoffeeScript sources into JavaScript.

Plugin for adding coffeescript compilation to a Play application. Adds support for defining org.gradle.language.coffeescript.CoffeeScriptSourceSet source sets. A "coffeeScript" source set is created by default.

Represents a Play distribution package

Manages a set of org.gradle.api.distribution.Distribution objects.

A plugin that adds a distribution zip to a Play application build.

Plugin for configuring IDE plugins when the project uses the Play Framework component support.

NOTE: This currently supports configuring the 'idea' plugin only.

Plugin for adding javascript processing to a Play application. Registers "javascript" language support with the org.gradle.language.javascript.JavaScriptSourceSet.

Defines and configures a Play Framework environment including versions of Play, Scala and Java.

Platform aware aspect of a Play Framework software component.

Plugin for Play Framework component support. Registers the org.gradle.play.PlayApplicationSpec component type for the components container.

Conventional locations and names for play plugins.

Plugin for compiling Play routes sources in a Play application.

Task to run a Play application.

Plugin for executing tests from a Play Framework application.

A set of tools for building applications using the Play Framework.

Plugin for compiling Twirl sources in a Play application.

A Plugin represents an extension to Gradle. A plugin applies some configuration to a target object. Usually, this target object is a org.gradle.api.Project, but plugins can be applied to any type of objects.

Something that can have plugins applied to it.

The plugin manager can be used for applying and detecting whether plugins have been applied.

For more on writing and applying plugins, see org.gradle.api.Plugin.

A PluginCollection represents a collection of org.gradle.api.Plugin instances.

A PluginContainer is used to manage a set of org.gradle.api.Plugin instances applied to a particular project.

Plugins can be specified using either an id or type. The id of a plugin is specified using a META-INF/gradle-plugins/${id}.properties classpath resource.

Describes a Gradle plugin under development.

The DSL for declaring plugins to use in a script.

In a build script, the plugins {} script block API is of this type. That is, you can use this API in the body of the plugins script block to declare plugins to be used for the script.

The plugins {} block serves a similar purpose to the org.gradle.api.plugins.PluginAware#apply(java.util.Map) method that can be used to apply a plugin directly to a Project object or similar. A key difference is that plugins applied via the plugins {} block are conceptually applied to the script, and by extension the script target. At this time there is no observable practical difference between the two approaches with regard to the end result. The plugins {} block is a new, incubating, Gradle feature that will evolve to offer benefits over the apply() approach.

The plugins {} block only allows a strict subset of the full build script programming language. Only the API of this type can be used, and values must be literal (e.g. constant strings, not variables). Moreover, the plugins {} block must be the first code of a build script. There is one exception to this, in that the buildscript {} block (used for declaring script dependencies) must precede it.

This implies the following constraints:

• Only #id(String) method calls may be top level statements
• #id(String) calls may only be followed by a PluginDependencySpec#version(String) and/or PluginDependencySpec#apply(boolean) method call on the returned object
• #id(String), PluginDependencySpec#version(String) and PluginDependencySpec#apply(boolean) methods must be called with a literal argument (i.e. not a variable)
• The plugins {} script block must follow any buildscript {} script block, but must precede all other logic in the script

Core Gradle plugins are able to be applied using the plugins {} block. Core plugins must be specified without a version number, and can have a qualified or unqualified id. That is, the java plugin can be used via:

 plugins { id 'java' } 

Or via:

 plugins { id 'org.gradle.java' } 

Core Gradle plugins use the org.gradle namespace.

For the list of available core plugins for a particular Gradle version, please consult the User Guide.

Non-core plugins are available from the Gradle Plugin Portal. These plugins are contributed by users of Gradle to extend Gradle's functionality. Visit plugins.gradle.org to browse the available plugins and versions.

To use a community plugin, the fully qualified id must be specified along with a version.

Receiver for the plugins block.

A mutable specification of a dependency on a plugin.

Can be used to specify the version of the plugin to use.

See PluginDependenciesSpec for more information about declaring plugin dependencies.

A description of a plugin.

A PluginInstantiationException is thrown when a plugin cannot be instantiated.

Configures how plugins are resolved.

Facilitates applying plugins and determining which plugins have been applied to a PluginAware object.

Contains information about a plugin that has been requested for resolution.

Allows modification of PluginRequests before they are resolved.

Allows plugin resolution rules to inspect a requested plugin and modify which target plugin will be used.

Custom task for generating the metadata for a plugin user test.

Runs a set of static code analysis rules on Java source code files and generates a report of problems found.

Configuration options for the PMD plugin.

A plugin for the PMD source code analyzer.

Declares a pmd configuration which needs to be configured with the PMD library to be used.

For each source set that is to be analyzed, a Pmd task is created and configured to analyze all Java code.

All PMD tasks (including user-defined ones) are added to the check lifecycle task.

The reporting configuration for the Pmd task.

A NamedDomainObjectContainer that allows to create domain objects with different types.

A property delegate that creates elements of the given type with the given configuration in the given container.

A property delegate that gets elements of the given type in the given container.

A property delegate that gets elements of the given type from the given container and applies the given configuration.

Manages a set of MavenPom instances and their associated PublishFilter instances.

A container of PrebuiltLibrary instances.

A library component that is not built by gradle.

A shared library that exists at a known location on the filesystem.

A static library that exists at a known location on the filesystem.

Generates a prefix header file from a list of headers to be precompiled.

A tool that permits configuration of the C preprocessor.

Specifies the options to use to fork a process.

Copies resources from their source to their target directory, potentially processing them. Makes sure no stale resources remain in the target directory.

A product in a Swift Package Manager package.

Represents a component that is the main product of a project.

Represents a C++ component that is the main product of a project.

Represents a Swift component that is the main product of a project.

Some information about a piece of work of a long running operation.

Root interface for all events that signal progress while executing an operation. For example, an operation can be the execution of a build, of a task, of a test, etc. A progress event can, for example, signal that a test has started, a task has finished, etc.

A listener which is notified as some long running operation makes progress.

A listener which is notified when operations that are executed as part of running a build make progress.

Represents the customizable elements of an eclipse project file. (via XML hooks everything is customizable).

Represents the customizable elements of an ipr (via XML hooks everything of the ipr is customizable).

This interface is the main API you use to interact with Gradle from your build file. From a Project, you have programmatic access to all of Gradle's features.

There is a one-to-one relationship between a Project and a {@value #DEFAULT_BUILD_FILE} file. During build initialisation, Gradle assembles a Project object for each project which is to participate in the build, as follows:

• Create a org.gradle.api.initialization.Settings instance for the build.
• Evaluate the {@value org.gradle.api.initialization.Settings#DEFAULT_SETTINGS_FILE} script, if present, against the org.gradle.api.initialization.Settings object to configure it.
• Use the configured org.gradle.api.initialization.Settings object to create the hierarchy of Project instances.
• Finally, evaluate each Project by executing its {@value #DEFAULT_BUILD_FILE} file, if present, against the project. The projects are evaluated in breadth-wise order, such that a project is evaluated before its child projects. This order can be overridden by calling #evaluationDependsOnChildren() or by adding an explicit evaluation dependency using #evaluationDependsOn(String).

A project is essentially a collection of Task objects. Each task performs some basic piece of work, such as compiling classes, or running unit tests, or zipping up a WAR file. You add tasks to a project using one of the create() methods on TaskContainer, such as TaskContainer#create(String). You can locate existing tasks using one of the lookup methods on TaskContainer, such as org.gradle.api.tasks.TaskCollection#getByName(String).

A project generally has a number of dependencies it needs in order to do its work. Also, a project generally produces a number of artifacts, which other projects can use. Those dependencies are grouped in configurations, and can be retrieved and uploaded from repositories. You use the org.gradle.api.artifacts.ConfigurationContainer returned by #getConfigurations() method to manage the configurations. The returned by #getDependencies() method to manage the dependencies. The org.gradle.api.artifacts.dsl.ArtifactHandler returned by #getArtifacts() method to manage the artifacts. The org.gradle.api.artifacts.dsl.RepositoryHandler returned by method to manage the repositories.

Projects are arranged into a hierarchy of projects. A project has a name, and a fully qualified path which uniquely identifies it in the hierarchy.

Plugins can be used to modularise and reuse project configuration. Plugins can be applied using the PluginAware#apply(java.util.Map) method, or by using the org.gradle.plugin.use.PluginDependenciesSpec plugins script block.

Gradle executes the project's build file against the Project instance to configure the project. Any property or method which your script uses is delegated through to the associated Project object. This means, that you can use any of the methods and properties on the Project interface directly in your script.

For example:

 defaultTasks('some-task') // Delegates to Project.defaultTasks() reportsDir = file('reports') // Delegates to Project.file() and the Java Plugin 

You can also access the Project instance using the project property. This can make the script clearer in some cases. For example, you could use project.name rather than name to access the project's name.

A project has 5 property 'scopes', which it searches for properties. You can access these properties by name in your build file, or by calling the project's #property(String) method. The scopes are:

• The Project object itself. This scope includes any property getters and setters declared by the Project implementation class. For example, #getRootProject() is accessible as the rootProject property. The properties of this scope are readable or writable depending on the presence of the corresponding getter or setter method.
• The extra properties of the project. Each project maintains a map of extra properties, which can contain any arbitrary name -> value pair. Once defined, the properties of this scope are readable and writable. See extra properties for more details.
• The extensions added to the project by the plugins. Each extension is available as a read-only property with the same name as the extension.
• The convention properties added to the project by the plugins. A plugin can add properties and methods to a project through the project's Convention object. The properties of this scope may be readable or writable, depending on the convention objects.
• The tasks of the project. A task is accessible by using its name as a property name. The properties of this scope are read-only. For example, a task called compile is accessible as the compile property.
• The extra properties and convention properties are inherited from the project's parent, recursively up to the root project. The properties of this scope are read-only.

When reading a property, the project searches the above scopes in order, and returns the value from the first scope it finds the property in. If not found, an exception is thrown. See #property(String) for more details.

When writing a property, the project searches the above scopes in order, and sets the property in the first scope it finds the property in. If not found, an exception is thrown. See #setProperty(String, Object) for more details.

 project.ext.prop1 = "foo" task doStuff { ext.prop2 = "bar" } subprojects { ext.${prop3} = false } 

 ext.isSnapshot = version.endsWith("-SNAPSHOT") if (isSnapshot) { // do snapshot stuff } 

A project has 5 method 'scopes', which it searches for methods:

• The Project object itself.
• The build file. The project searches for a matching method declared in the build file.
• The extensions added to the project by the plugins. Each extension is available as a method which takes a closure or org.gradle.api.Action as a parameter.
• The convention methods added to the project by the plugins. A plugin can add properties and method to a project through the project's Convention object.
• The tasks of the project. A method is added for each task, using the name of the task as the method name and taking a single closure or org.gradle.api.Action parameter. The method calls the Task#configure(groovy.lang.Closure) method for the associated task with the provided closure. For example, if the project has a task called compile, then a method is added with the following signature: void compile(Closure configureClosure).
• The methods of the parent project, recursively up to the root project.
• A property of the project whose value is a closure. The closure is treated as a method and called with the provided parameters. The property is located as described above.

Creates dummy instances of org.gradle.api.Project which you can use in testing custom task and plugin implementations.

To create a project instance:

1. Create a ProjectBuilder instance by calling #builder().
2. Optionally, configure the builder.
3. Call #build() to create the Project instance.

You can reuse a builder to create multiple Project instances.

The ProjectBuilder implementation bundled with Gradle 3.0 and 3.1 suffers from a binary compatibility issue exposed by applying plugins compiled with Gradle 2.7 and earlier. Applying those pre-compiled plugins in a ProjectBuilder context will result in a ClassNotFoundException.

An identifier for a component instance that is built as part of the current build.

Criteria for selecting a component instance that is built as part of the current build.

Indicates a problem that occurs during project configuration (evaluation) phase.

Represents a long-lived connection to a Gradle project. You obtain an instance of a ProjectConnection by using org.gradle.tooling.GradleConnector#connect().

 try (ProjectConnection connection = GradleConnector.newConnector() .forProjectDirectory(new File("someFolder")) .connect()) { //obtain some information from the build BuildEnvironment environment = connection.model(BuildEnvironment.class).get(); //run some tasks connection.newBuild() .forTasks("tasks") .setStandardOutput(System.out) .run(); } 

All implementations of ProjectConnection are thread-safe, and may be shared by any number of threads.

All notifications from a given ProjectConnection instance are delivered by a single thread at a time. Note, however, that the delivery thread may change over time.

Represents a dependency on another project.

A classpath entry representing a project dependency.

A ProjectDependency is a Dependency on another project in the current project hierarchy.

A dependency onto a library published by a project.

A builder of a ProjectDependencySpec.

A ProjectDescriptor declares the configuration required to create and evaluate a .

A ProjectDescriptor is created when you add a project to the build from the settings script, using or Settings#includeFlat(String...). You can access the descriptors using one of the lookup methods on the Settings object.

An ProjectEvaluationListener is notified when a project is evaluated. You add can add an ProjectEvaluationListener to a org.gradle.api.invocation.Gradle using .

Identifies a Gradle project.

A Gradle Project is a project in a multi-project Gradle build or a single "standalone" project.

Provides access to several important locations for a project. An instance of the factory can be injected into a task or plugin by annotating a public constructor or method with javax.inject.Inject. It is also available via org.gradle.api.Project#getLayout().

A project-level IDEA library.

Represents a model that is associated with some Gradle project.

A model providing information about the publications of a Gradle project.

Displays a list of projects in the build. An instance of this type is used when you execute the projects task from the command-line.

A Plugin which adds some project visualization report tasks to a project.

The conventional configuration for the `ProjectReportsPlugin`.

A container of org.gradle.language.base.LanguageSourceSets. Added to a project by the org.gradle.language.base.plugins.LanguageBasePlugin.

ProjectState provides information about the execution state of a project.

Models the generation/parsing/merging capabilities. Adds properties-related hooks.

For examples see docs for org.gradle.plugins.ide.eclipse.model.EclipseJdt and others.

A convenience superclass for those tasks which generate Properties configuration files from a domain object of type T.

A Provider representation for capturing the state of a property. The value can be provided by using the method #set(Object) or #set(Provider).

Note: This interface is not intended for implementation by build script or plugin authors. An instance of this class can be created through the factory method org.gradle.api.model.ObjectFactory#property(Class). There are also several specialized subtypes of this interface that can be created using various other factory methods.

Provides efficient access to a property.

A convenience superclass for those tasks which generate Property List configuration files from a domain object of type T.

Displays the properties of a project. An instance of this type is used when you execute the properties task from the command-line.

A Provider representation for capturing the state of a property. The value can be provided by using the method #set(Object) or #set(Provider).

Note: This interface is not intended for implementation by build script or plugin authors. An instance of this class can be created through the factory methods org.gradle.api.Project#property(java.lang.Class) or org.gradle.api.provider.ProviderFactory#property(java.lang.Class).

A container object that provides a value of a specific type. The value can be retrieved by the method #get() or #getOrNull().

A provider may not always have a value available, for example when the value may not yet be known but will be known at some point in the future. When a value is not available, #isPresent() returns false and retrieving the value will fail with an exception.

A provider may not always provide the same value. Although there are no methods on this interface to change the value, the provider implementation may be mutable or use values from some changing source.

A provider may provide a value that is mutable and that changes over time.

A typical use of a provider is to pass values from one DSL element to another, e.g. from an extension to a task. Providers also allow expensive computations to be deferred until their value is actually needed, usually at task execution time.

For a provider whose value can be mutated, see Property.

Do not use Provider<File>. Use org.gradle.api.file.Directory or org.gradle.api.file.RegularFile instead.

Note: This interface is not intended for implementation by build script or plugin authors. An instance of this class can be created through the factory methods org.gradle.api.Project#provider(java.util.concurrent.Callable) or org.gradle.api.provider.ProviderFactory#provider(java.util.concurrent.Callable).

A factory for creating instances of Provider and PropertyState.

An instance of the factory can be injected into a task or plugin by annotating a public constructor or method with javax.inject.Inject.

 public class MyTask extends DefaultTask { // injection into a constructor @javax.inject.Inject public MyTask(ProviderFactory providerFactory) { } // injection into a method @javax.inject.Inject public ProviderFactory getProviderFactory() { throw new UnsupportedOperationException(); } } 

An instance of the factory is also available using Project#getProviders()

A set of public assets added to a binary.

A publication is a description of a consumable representation of one or more artifacts, and possibly associated metadata.

An artifact published as part of a Publication.

A PublicationContainer is responsible for creating and managing Publication instances. The set of available publication types is dependent on the application of particular plugins:

• The org.gradle.api.publish.maven.plugins.MavenPublishPlugin makes it possible to create org.gradle.api.publish.maven.MavenPublication instances.
• The org.gradle.api.publish.ivy.plugins.IvyPublishPlugin makes it possible to create org.gradle.api.publish.ivy.IvyPublication instances.

 apply plugin: 'ivy-publish' publishing.publications.create('publication-name', IvyPublication) { // Configure the ivy publication here } 

A PublishArtifact is an artifact produced by a project.

A set of artifacts to be published.

A PublishException is thrown when a dependency configuration cannot be published for some reason.

A filter for artifacts to be published.

Publishes an IvyPublication to an IvyArtifactRepository.

Publishes a org.gradle.api.publish.maven.MavenPublication to the Maven Local repository.

Publishes a org.gradle.api.publish.maven.MavenPublication to a MavenArtifactRepository.

Represents a component that can be published.

The configuration of how to “publish” the different components of a project.

Installs a org.gradle.api.publish.PublishingExtension with name {@value org.gradle.api.publish.PublishingExtension#NAME}.

Thrown when an attempt is made to change the value of a model element that is not writable at the time.

A resource that can be read. The simplest example is a file.

Represents a regular file at a fixed location on the file system. A regular file is a file that is not a directory and is not some special kind of file such as a device.

Note: This interface is not intended for implementation by build script or plugin authors. An instance of this class can be created from a Directory instance using the Directory#file(String) method or via various methods on ProjectLayout such as ProjectLayout#getProjectDirectory().

Represents some configurable regular file location, whose value is mutable and not necessarily currently known until later.

Note: This interface is not intended for implementation by build script or plugin authors. An instance of this class can be created using the ProjectLayout#fileProperty() method.

Represents some configurable regular file location, whose value is mutable and not necessarily currently known until later.

Note: This interface is not intended for implementation by build script or plugin authors. An instance of this class can be created using the ProjectLayout#newFileVar() method.

Represents a relative path from some base directory to a file. Used in file copying to represent both a source and target file path when copying files.

RelativePath instances are immutable.

A file based report to be created.

Tasks that produce reports expose instances of this type for configuration via the Reporting interface.

A container of Report objects, that represent potential reports.

Things that produce reports (typically tasks) expose a report container that contains Report objects for each possible report that they can produce. Each report object can be configured individually, including whether or not it should be produced by way of its enabled property.

ReportContainer implementations are immutable in that standard collection methods such as add(), remove() and clear() will throw an ImmutableViolationException. However, implementations may provide new methods that allow the addition of new report object and/or the removal of existing report objects.

An object that provides reporting options.

Tasks that produce reports as part of their execution expose configuration options of those reports via these methods. The Reporting interface is parameterized, where the parameter denotes the specific type of reporting container that is exposed. The specific type of the reporting container denotes the different types of reports available.

For example, given a task such as:

 class MyTask implements Reporting<MyReportContainer> { // implementation } interface MyReportContainer extends ReportContainer<Report> { Report getHtml(); Report getCsv(); } 

The reporting aspects of such a task can be configured as such:

 task my(type: MyTask) { reports { html.enabled = true csv.enabled = false } } 

See the documentation for the specific ReportContainer type for the task for information on report types and options.

A Plugin which provides the basic skeleton for reporting.

This plugin adds the following extension objects to the project:

• org.gradle.api.reporting.ReportingExtension

A project extension named "reporting" that provides basic reporting settings and utilities.

Example usage:

 reporting { baseDir "$buildDir/our-reports" } 

When implementing a task that produces reports, the location of where to generate reports should be obtained via the #file(String) method of this extension.

The repositories that Gradle will search for prebuilt libraries.

A RepositoryHandler manages a set of repositories, allowing repositories to be defined and queried.

Represents the directory structure for a repository. For examples see the reference for org.gradle.api.artifacts.repositories.IvyArtifactRepository#layout(String, org.gradle.api.Action)

Provides access to resources on an artifact repository. Gradle takes care of caching the resources locally. The scope of the cache may depend on the accessor: users should refer to the javadocs of the methods providing an accessor to determine the scope.

Visitor which can request a reproducible file order.

Contains the information about the result of dependency resolution. You can use this type to determine all the component instances that are included in the resolved dependency graph, and the dependencies between them.

Defines the strategies around dependency resolution. For example, forcing certain dependency versions, substitutions, conflict resolutions or snapshot timeouts.

Examples:

 apply plugin: 'java' //so that there are some configurations configurations.all { resolutionStrategy { // fail eagerly on version conflict (includes transitive dependencies) // e.g. multiple different versions of the same dependency (group and name are equal) failOnVersionConflict() // prefer modules that are part of this build (multi-project or composite build) over external modules preferProjectModules() // force certain versions of dependencies (including transitive) // *append new forced modules: force 'asm:asm-all:3.3.1', 'commons-io:commons-io:1.4' // *replace existing forced modules with new ones: forcedModules = ['asm:asm-all:3.3.1'] // add dependency substitution rules dependencySubstitution { substitute module('org.gradle:api') with project(':api') substitute project(':util') with module('org.gradle:util:3.0') } // cache dynamic versions for 10 minutes cacheDynamicVersionsFor 10*60, 'seconds' // don't cache changing modules at all cacheChangingModulesFor 0, 'seconds' } } 

A set of Dependency objects which can be resolved to a set of files. There are various methods on this type that you can use to get the result in different forms:

• #getFiles() returns a FileCollection that provides the result as a set of java.io.File instances.
• #getResolutionResult() returns a ResolutionResult that provides information about the dependency graph.
• #getArtifacts() returns an ArtifactCollection that provides the files with additional metadata.

The dependencies are resolved once only, when the result is first requested. The result is reused and returned for subsequent calls. Once resolved, any mutation to the dependencies will result in an error.

A ResolveException is thrown when dependency resolution fails for some reason.

Information about a resolved artifact.

The result of successfully resolving an artifact.

Represents a component instance in the resolved dependency graph. Provides some basic identity and dependency information about the component.

A ResolvedConfiguration represents the result of resolving a Configuration, and provides access to both the artifacts and the meta-data of the result.

Information about a resolved dependency.

A dependency that was resolved successfully.

Represents meta-data about a resolved module version.

The result of successfully resolving a component variant.

A generic resource of some kind. Only describes the resource. There are more specific interface that extend this one and specify ways of accessing the resource's content.

Generic resource exception that all other resource-related exceptions inherit from.

The gradle DSL model of an Eclipse resource filter. This allows specifying a filter with a custom matcher and configuring whether it is an include/exclude filter that applies to files, folders, or both. The following example excludes the 'node_modules' folder.

 apply plugin: 'java' apply plugin: 'eclipse' eclipse { project { resourceFilter { appliesTo = 'FOLDERS' type = 'EXCLUDE_ALL' matcher { id = 'org.eclipse.ui.ide.multiFilter' // to find out which arguments to use, configure the desired // filter with Eclipse's UI and copy the arguments string over arguments = '1.0-name-matches-false-false-node_modules' } } } } 

Specifies the type of resource that the Eclipse ResourceFilter applies to.

The model of an Eclipse resource filter matcher.

The matcher decides when the containing filter (or containing matcher) applies. The matcher configures things like whether this ResourceFilter matches resources by name, project relative path, location, last modified, etc. Eclipse has many types of built-in matchers and it is possible to specify the id and arguments for custom matchers using this model.

A matcher must have an id. It may have either a custom string argument or a set of nested child matchers (e.g. an 'or' matcher will have several nested condition matchers).

For more documentation on usage with examples, see ResourceFilter.

Specifies whether an Eclipse ResourceFilter is including or excluding resources.

Provides access to resource-specific utility methods, for example factory methods that create various resources.

A handler for an asynchronous operation which returns an object of type T.

Task for compiling routes templates into Scala code.

This task is usually created as one of the build tasks when building a Play application with the org.gradle.play.plugins.PlayPlugin plugin. Explicit configuration of this task is not expected and should be performed on the equivalent settings at the org.gradle.play.PlayApplicationSpec level.

Represents a source set containing routes files

A Rule represents some action to perform when an unknown domain object is referenced. The rule can use the domain object name to add an implicit domain object.

Attached to the getter for a property on a RuleSource to denote that the property defines an implicit input for all rules defined by the rule source.

A marker type for a class that is a collection of rules.

A rule source is not used like a regular Java object. It is a stateless container of methods and possibly constants.

Please consult the “Rule based model configuration” chapter of the Gradle User Guide for general information about “rules”.

Each method that is annotated with one of the following is considered a rule:

• Model
• Defaults
• Mutate
• Finalize
• Validate
• Rules
• org.gradle.platform.base.ComponentType
• org.gradle.platform.base.ComponentBinaries
• org.gradle.platform.base.BinaryTasks

Each annotation specifies the type of the rule, which affects when it will be executed.

The following constraints apply to all rule methods:

• A method may only be annotated by at most one of the above annotations.
• A rule method may be static or not; it makes no difference.
• A rule method cannot be generic (i.e. cannot have type parameters).
• With the exception of Model methods, all methods must have at least one parameter.
• With the exception of Model methods, all methods must have a void return type.

See Model for information on the significance of the return type of a Model method.

Method rules declare the subject and any inputs as parameters to the method. With the exception of Model methods, the subject of the rule is the, required, first parameter and all subsequent parameters are inputs. For a non-void Model method, the subject (i.e. model element being created) is the return object. For a void Model method, the subject is the first method parameter.

The Path annotation can be placed on any parameter (except the subject of Model rules) to indicate the model element to bind to. If there is no Path annotation, a “by-type” binding will be attempted. The binding scope is determined by how the rule source is applied.

Along with the constraints on individual rule methods by their associated annotation, the following are general constraints of rule source implementations:

• Constructors are not allowed.
• Inheritance hierarchies are not allowed (i.e. all rules sources must directly extend RuleSource).
• Instance variables are not allowed.
• Non-final static variables are not allowed (i.e. constants are allowed).
• Methods cannot be overloaded.
• Implementations cannot be generic (i.e. cannot use type parameters).

Attached to the getter for a property on a RuleSource to denote that the property defines the target for the rule source.

Denotes that the RuleSource method rule carrying this annotation defines additional rules based on its inputs.

Runs a compiled and installed test executable.

Configuration of runtime classpath normalization.

A Plugin which compiles and tests Scala sources.

Compiles Scala source files, and optionally, Java source files.

Options for Scala Compilation.

Generates HTML API documentation for Scala source files.

Options for the ScalaDoc tool.

Fork options for Scala compilation. Only take effect if BaseScalaCompileOptions.fork is true.

Plugin for compiling Scala code. Applies the org.gradle.language.base.plugins.ComponentModelBasePlugin and org.gradle.language.jvm.plugins.JvmResourcesPlugin. Registers "scala" language support with the org.gradle.language.scala.ScalaLanguageSourceSet.

A set of sources passed to the Scala compiler.

Defines and configures a Scala Platform.

A Plugin which sets up a Scala project.

Provides information related to the Scala runtime(s) used in a project. Added by the org.gradle.api.plugins.scala.ScalaBasePlugin as a project extension named scalaRuntime.

Example usage:

 apply plugin: "scala" repositories { mavenCentral() } dependencies { compile "org.scala-lang:scala-library:2.10.1" } def scalaClasspath = scalaRuntime.inferScalaClasspath(configurations.compile) // The returned class path can be used to configure the 'scalaClasspath' property of tasks // such as 'ScalaCompile' or 'ScalaDoc', or to execute these and other Scala tools directly. 

A ScalaSourceSetConvention defines the properties and methods added to a by the ScalaPlugin.

A set of tools for building Scala applications

This interface is implemented by all Gradle scripts to add in some Gradle-specific methods. As your compiled script class will implement this interface, you can use the methods and properties declared by this interface directly in your script.

Generally, a Script object will have a delegate object attached to it. For example, a build script will have a Project instance attached to it, and an initialization script will have a instance attached to it. Any property reference or method call which is not found on this Script object is forwarded to the delegate object.

Generates a script to start a JVM application.

A ScriptHandler allows you to manage the compilation and execution of a build script. You can declare the classpath used to compile and execute a build script. This classpath is also used to load the plugins which the build script uses.

You can obtain a ScriptHandler instance using org.gradle.api.Project#getBuildscript() or .

To declare the script classpath, you use the org.gradle.api.artifacts.dsl.DependencyHandler provided by #getDependencies() to attach dependencies to the {@value #CLASSPATH_CONFIGURATION} configuration. These dependencies are resolved just prior to script compilation, and assembled into the classpath for the script.

For most external dependencies you will also need to declare one or more repositories where the dependencies can be found, using the org.gradle.api.artifacts.dsl.RepositoryHandler provided by .

Receiver for the buildscript block.

A SelfResolvingDependency is a Dependency which is able to resolve itself, independent of a repository.

Represents a property whose type is a Set of elements of type T. Retains iteration order.

Note: This interface is not intended for implementation by build script or plugin authors. An instance of this class can be created through the factory method org.gradle.api.model.ObjectFactory#setProperty(Class).

Declares the configuration required to instantiate and configure the hierarchy of instances which are to participate in a build.

There is a one-to-one correspondence between a Settings instance and a {@value * #DEFAULT_SETTINGS_FILE} settings file. Before Gradle assembles the projects for a build, it creates a Settings instance and executes the settings file against it.

One of the purposes of the Settings object is to allow you to declare the projects which are to be included in the build. You add projects to the build using the #include(String...) method. There is always a root project included in a build. It is added automatically when the Settings object is created. The root project's name defaults to the name of the directory containing the settings file. The root project's project directory defaults to the directory containing the settings file.

When a project is included in the build, a ProjectDescriptor is created. You can use this descriptor to change the default values for several properties of the project.

In addition to the properties of this interface, the Settings object makes some additional read-only properties available to the settings script. This includes properties from the following sources:

• Defined in the {@value org.gradle.api.Project#GRADLE_PROPERTIES} file located in the settings directory of the build.
• Defined the {@value org.gradle.api.Project#GRADLE_PROPERTIES} file located in the user's .gradle directory.
• Provided on the command-line using the -P option.

Standard implementation of the API exposed to all types of Settings scripts, precompiled and otherwise.

A NativeLibrary that has been compiled and linked as a shared library.

A shared library binary built by Gradle for a native library.

Specifies the detail to include in stacktraces.

A task for creating digital signature files for one or more; tasks, files, publishable artifacts or configurations.

The task produces Signature

The signature objects are created with defaults and using this tasks signatory and signature type.

A sign operation creates digital signatures for one or more files or PublishArtifact.

The external representation of the signature is specified by the signature type property, while the #signatory property specifies who is to sign.

A sign operation manages one or more Signature objects. The sign methods are used to register things to generate signatures for. The #execute() method generates the signatures for all of the registered items at that time.

A signatory is an object capable of providing a signature for an arbitrary stream of bytes.

Provides implementations of signatory implementations for a project.

Convenience base class for Signatory implementations.

A digital signature file artifact.

A signature file is always generated from another file, which may be a PublishArtifact.

Specifies how objects will be signed.

The type of signature.

Provider of SignatureType.

The global signing configuration for a project.

Adds the ability to digitally sign files and artifacts.

Single entry module library

A report that is a single file.

Attached to a task property to indicate that the task should be skipped when the value of the property is an empty org.gradle.api.file.FileCollection or directory.

If all of the inputs declared with this annotation are empty, the task will be skipped with a "NO-SOURCE" message.

This annotation should be attached to the getter method in Java or the property in Groovy. Annotations on setters or just the field in Java are ignored.

• org.gradle.api.tasks.InputFiles
• org.gradle.api.tasks.InputDirectory

Describes how an operation was skipped.

A software component produced by a Gradle software project.

An implementation of this interface may also implement:

• ComponentWithVariants to provide information about the variants that the component provides.

A Container that contains all of the Software Components produced by a Project.

Represents some component whose implementation can be represented as a collection of source files, and whose other outputs are built from this source.

Configuration related to source dependencies.

Represents a source directory.

A SourceDirectorySet represents a set of source files composed from a set of source directories, along with associated include and exclude patterns.

SourceDirectorySet extends FileTree. The contents of the file tree represent the source files of this set, arranged in a hierarchy. The file tree is live and reflects changes to the source directories and their contents.

SourceFolder.path contains only project relative path.

A SourceSet represents a logical group of Java source and resources.

See the example below how SourceSet 'main' is accessed and how the SourceDirectorySet 'java' is configured to exclude some package from compilation.

 apply plugin: 'java' sourceSets { main { java { exclude 'some/unwanted/package/**' } } } 

A SourceSetContainer manages a set of SourceSet objects.

A collection of all output directories (compiled classes, processed resources, etc.) - notice that SourceSetOutput extends FileCollection.

Provides output information of the source set. Allows configuring the default output dirs and specify additional output dirs.

 apply plugin: 'java' sourceSets { main { //if you truly want to override the defaults: output.resourcesDir = file('out/bin') // Compiled Java classes should use this directory java.outputDir = file('out/bin') } } 

In general, we recommend generating resources into folders different than the regular resourcesDir and classesDir. Usually, it makes the build easier to understand and maintain. Also it gives some additional benefits because other Gradle plugins can take advantage of the output dirs 'registered' in the SourceSet.output. For example: Java plugin will use those dirs in calculating class paths and for jarring the content; IDEA and Eclipse plugins will put those folders on relevant classpath.

An example how to work with generated resources:

 apply plugin: 'java' def generatedResources = "$buildDir/generated-resources/main" sourceSets { main { //let's register an output folder on the main SourceSet: output.dir(generatedResources, builtBy: 'generateMyResources') //it is now a part of the 'main' classpath and will be a part of the jar } } //a task that generates the resources: task generateMyResources { doLast { def generated = new File(generatedResources, "myGeneratedResource.properties") generated.text = "message=Stay happy!" } } //Java plugin task 'classes' and 'testClasses' will automatically depend on relevant tasks registered with 'builtBy' //Eclipse/IDEA plugins will automatically depend on 'generateMyResources' //because the output dir was registered with 'builtBy' information apply plugin: 'idea'; apply plugin: 'eclipse' 

A SourceTask performs some operation on source files.

Thrown when a source code transformation fails.

An artifact containing sources for a software component.

Represents some predicate against objects of type T.

Provides a number of org.gradle.api.specs.Spec implementations.

Provides the options for the standard Javadoc doclet.

A StandardOutputListener receives text written by Gradle's logging system to standard output or error.

An event that informs about an operation having started its execution.

StartParameter defines the configuration used by a Gradle instance to execute a build. The properties of StartParameter generally correspond to the command-line options of Gradle.

You can obtain an instance of a StartParameter by either creating a new one, or duplicating an existing one using #newInstance or #newBuild.

A NativeLibrary that has been compiled and archived into a static library.

A static library binary built by Gradle for a native library.

An event that informs about an interim results of the operation.

A StopActionException is be thrown by a task org.gradle.api.Action or task action closure to stop its own execution and to start execution of the task's next action. An action can usually be stopped by just calling return inside the action closure. But if the action works with helper methods that can lead to redundant code. For example:

 List existentSourceDirs = HelperUtil.getExistentSourceDirs() if (!existentSourceDirs) {return} 

If the getExistentSourceDirs() throws a StopActionException instead, the tasks does not need the if statement.

Note that throwing this exception does not fail the execution of the task or the build.

A StopExecutionException is thrown by a org.gradle.api.Action or task action closure to stop execution of the current task and start execution of the next task. This allows, for example, precondition actions to be added to a task which abort execution of the task if the preconditions are not met.

Note that throwing this exception does not fail the execution of the task or the build.

Strips the debug symbols from a binary

Describes how an operation finished successfully.

Configuration for a Swift application, defining the source files that make up the application plus other settings.

An instance of this type is added as a project extension by the Swift application plugin.

A plugin that produces an executable from Swift source.

Adds compile, link and install tasks to build the executable. Defaults to looking for source files in `src/main/swift`.

Adds a SwiftApplication extension to the project to allow configuration of the executable.

A common base plugin for the Swift application and library plugins

A binary built from Swift source and linked from the resulting object files.

Compiles Swift source files into object files.

A Plugin which makes the Swiftc compiler available for compiling Swift code.

Configuration for a Swift component, such as a library or executable, defining the source files that make up the component plus other settings.

Swift component is composed of some Swift source files that are compiled and then linked into some binary.

An instance of this type is added as a project extension by the Swift plugins.

An executable built from Swift source.

Configuration for a Swift library, defining the source files that make up the library plus other settings.

An instance of this type is added as a project extension by the Swift library plugin.

A plugin that produces a shared library from Swift source.

Adds compile, link and install tasks to build the shared library. Defaults to looking for source files in `src/main/swift`.

Adds a SwiftComponent extension to the project to allow configuration of the library.

A plugin that produces a Swift Package Manager manifests from the Gradle model.

This plugin should only be applied to the root project of a build.

A target platform for building Swift binaries.

A shared library built from Swift source.

A static library built from Swift source.

Swift version.

An test binary built from Swift source.

An XCTest executable for tests implemented in Swift.

An XCTest executable for tests implemented in Swift.

A XCTest suite, implemented in Swift.

The Swift Compiler tool chain.

Swiftc specific settings for the tools used to build for a particular platform.

Synchronizes the contents of a destination directory with some source directories and files.

This task is like the Copy task, except the destination directory will only contain the files copied. All files that exist in the destination directory will be deleted before copying files, unless a #preserve(Action) is specified.

Examples:

 // Sync can be used like a Copy task // See the Copy documentation for more examples task syncDependencies(type: Sync) { from 'my/shared/dependencyDir' into 'build/deps/compile' } // You can preserve output that already exists in the // destination directory. Files matching the preserve // filter will not be deleted. task sync(type: Sync) { from 'source' into 'dest' preserve { include 'extraDir/**' include 'dir1/**' exclude 'dir1/extra.txt' } } 

Assembles a TAR archive.

Represents the PMD targetjdk property available for PMD < 5.0

A native component that can be configured to target certain variant dimensions. This functionality is a temporary workaround to eliminate configuration of unnecessary domain objects and tasks.

Represents a task which is executable by Gradle.

Note: Task extends Launchable since 1.12.

A Task represents a single atomic piece of work for a build, such as compiling classes or generating javadoc.

Each task belongs to a Project. You can use the various methods on to create and lookup task instances. For example, creates an empty task with the given name. You can also use the task keyword in your build file:

 task myTask task myTask { configure closure } task myTask(type: SomeType) task myTask(type: SomeType) { configure closure } 

Each task has a name, which can be used to refer to the task within its owning project, and a fully qualified path, which is unique across all tasks in all projects. The path is the concatenation of the owning project's path and the task's name. Path elements are separated using the {@value org.gradle.api.Project#PATH_SEPARATOR} character.

A Task is made up of a sequence of Action objects. When the task is executed, each of the actions is executed in turn, by calling Action#execute. You can add actions to a task by calling or #doLast(Action).

Groovy closures can also be used to provide a task action. When the action is executed, the closure is called with the task as parameter. You can add action closures to a task by calling #doFirst(groovy.lang.Closure) or #doLast(groovy.lang.Closure).

There are 2 special exceptions which a task action can throw to abort execution and continue without failing the build. A task action can abort execution of the action and continue to the next action of the task by throwing a org.gradle.api.tasks.StopActionException. A task action can abort execution of the task and continue to the next task by throwing a org.gradle.api.tasks.StopExecutionException. Using these exceptions allows you to have precondition actions which skip execution of the task, or part of the task, if not true.

A task may have dependencies on other tasks or might be scheduled to always run after another task. Gradle ensures that all task dependencies and ordering rules are honored when executing tasks, so that the task is executed after all of its dependencies and any "must run after" tasks have been executed.

Dependencies to a task are controlled using #dependsOn(Object...) or #setDependsOn(Iterable), and #mustRunAfter(Object...), #setMustRunAfter(Iterable), #shouldRunAfter(Object...) and #setShouldRunAfter(Iterable) are used to specify ordering between tasks. You can use objects of any of the following types to specify dependencies and ordering:

• A String, CharSequence or groovy.lang.GString task path or name. A relative path is interpreted relative to the task's Project. This allows you to refer to tasks in other projects.
• A Task.
• A closure. The closure may take a Task as parameter. It may return any of the types listed here. Its return value is recursively converted to tasks. A null return value is treated as an empty collection.
• A TaskDependency object.
• A Buildable object.
• A org.gradle.api.file.RegularFileProperty or org.gradle.api.file.DirectoryProperty.
• A Iterable, Collection, Map or array. May contain any of the types listed here. The elements of the iterable/collection/map/array are recursively converted to tasks.
• A Callable. The call() method may return any of the types listed here. Its return value is recursively converted to tasks. A null return value is treated as an empty collection.

A Task has 4 'scopes' for properties. You can access these properties by name from the build file or by calling the #property(String) method. You can change the value of these properties by calling the #setProperty(String, Object) method.

• The Task object itself. This includes any property getters and setters declared by the Task implementation class. The properties of this scope are readable or writable based on the presence of the corresponding getter and setter methods.
• The extensions added to the task by plugins. Each extension is available as a read-only property with the same name as the extension.
• The convention properties added to the task by plugins. A plugin can add properties and methods to a task through the task's Convention object. The properties of this scope may be readable or writable, depending on the convention objects.
• The extra properties of the task. Each task object maintains a map of additional properties. These are arbitrary name -> value pairs which you can use to dynamically add properties to a task object. Once defined, the properties of this scope are readable and writable.

A Plugin may add methods to a Task using its Convention object.

By default, tasks are not executed in parallel unless a task is waiting on asynchronous work and another task (which is not dependent) is ready to execute. Parallel execution can be enabled by the --parallel flag when the build is initiated. In parallel mode, the tasks of different projects (i.e. in a multi project build) are able to be executed in parallel.

Marks a method as the action to run when the task is executed.

A TaskActionListener is notified of the actions that a task performs.

A TaskCollection contains a set of Task instances, and provides a number of query methods.

A TaskContainer is responsible for managing a set of Task instances.

You can obtain a TaskContainer instance by calling org.gradle.api.Project#getTasks(), or using the tasks property in your build script.

A TaskDependency represents an unordered set of tasks which a Task depends on. Gradle ensures that all the dependencies of a task are executed before the task itself is executed.

You can add a TaskDependency to a task by calling the task's Task#dependsOn(Object...) method.

Represents the files or directories that a org.gradle.api.Task destroys (removes).

A TaskExecutionListener adapter class for receiving task execution events. The methods in this class are empty. This class exists as convenience for creating listener objects.

A TaskExecutionException is thrown when a task fails to execute successfully.