• Create aSettings instance for the build.
• Evaluate thesettings.gradle script, ifpresent, against theSettings object to configure it.
• Use the configuredSettings object to create the hierarchy ofProject instances.
• Finally, evaluate eachProject by executing itsbuild.gradle file, ifpresent, against the project. The projects are evaluated in breadth-wise order, such that a project is evaluatedbefore its child projects. This order can be overridden by callingProject.evaluationDependsOnChildren() or by adding anexplicit evaluation dependency usingProject.evaluationDependsOn(java.lang.String).

• TheProject object itself. This scope includes any property getters and setters declared by theProject implementation class. For example,Project.getRootProject() is accessible as therootProject property. The properties of this scope are readable or writable depending on the presenceof the corresponding getter or setter method.
• Theextra properties of the project. Each project maintains a map of extra properties, whichcan contain any arbitrary name -> value pair. Once defined, the properties of this scope are readable and writable.Seeextra properties for more details.
• Theextensions added to the project by the plugins. Each extension is available as a read-only property with the same name as the extension.
• Theconvention properties added to the project by the plugins. A plugin can add properties and methodsto a project through the project'sConvention 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 thisscope are read-only. For example, a task calledcompile is accessible as thecompileproperty.
• The extra properties and convention properties are inherited from the project's parent, recursively up to the rootproject. The properties of this scope are read-only.

All extra properties must be defined through the "ext" namespace. Once an extra property has been defined,it is available directly on the owning object (in the below case the Project, Task, and sub-projects respectively) and canbe read and updated. Only the initial declaration that needs to be done via the namespace.

project.ext.prop1 ="foo"task doStuff {    ext.prop2 ="bar"}subprojects { ext.${prop3} = false }

Reading extra properties is done through the "ext" or through the owning object.

ext.isSnapshot = version.endsWith("-SNAPSHOT")if (isSnapshot) {// do snapshot stuff}

A project has 5 method 'scopes', which it searches for methods:

The set containing this project and its subprojects.

TheAntBuilder for this project. You can use this in your build file to execute anttasks. See example below.

task printChecksum {  doLast {    ant {//using ant checksum task to store the file checksum in the checksumOut ant property      checksum(property:'checksumOut', file:'someFile.txt')//we can refer to the ant property created by checksum task:      println"The checksum is: " + checksumOut    }//we can refer to the ant property later as well:    println"I just love to print checksums: " + ant.checksumOut  }}

Consider following example of ant target:

<target name='printChecksum'>  <checksum property='checksumOut'>    <fileset dir='.'>      <include name='agile.txt'/>    </fileset>  </checksum>  <echo>The checksum is: ${checksumOut}</echo></target>

Here's how it would look like in gradle. Observe how the ant XML is represented in groovy by the ant builder

task printChecksum {  doLast {    ant {      checksum(property:'checksumOut') {        fileset(dir:'.') {          include name:'agile1.txt'        }      }    }    logger.lifecycle("The checksum is $ant.checksumOut")  }}

Returns a handler for assigning artifacts produced by the project to configurations.

The build directory of this project. The build directory is the directory which all artifacts aregenerated into. The default value for the build directory isprojectDir/build

The build script for this project.

If the file exists, it will be evaluated against this project when this project is configured.

The build script handler for this project. You can use this handler to query details about the buildscript for this project, and manage the classpath used to compile and execute the project's build script.

The direct children of this project.

The configurations of this project.

TheConvention for this project.

You can access this property in your build fileusingconvention. You can also access the properties and methods of the convention objectas if they were properties and methods of this project. Seehere for more details

The names of the default tasks of this project. These are used when no tasks names are provided whenstarting the build.

The dependency handler of this project. The returned dependency handler instance can be used for addingnew dependencies. For accessing already declared dependencies, the configurations can be used.

Provides access to configuring dependency locking

The description of this project, if any.

Allows adding DSL extensions to the project. Useful for plugin authors.

TheGradle invocation which this project belongs to.

The group of this project. Gradle always uses thetoString() value of the group. The groupdefaults to the path with dots as separators.

The logger for this project. You can use this in your build file to write log messages.

TheLoggingManager which can be used to receive logging and to control thestandard output/error capture for this project's build script. By default, System.out is redirected to the Gradlelogging system at the QUIET log level, and System.err is redirected at the ERROR log level.

The name of this project. The project's name is not necessarily unique within a project hierarchy. Youshould use theProject.getPath() method for a unique identifier for the project.

Provides access to configuring input normalization.

The parent project of this project, if any.

The path of this project. The path is the fully qualified name of the project.

The plugin manager for this plugin aware object.

The container of plugins that have been applied to this object.

While not deprecated, it is preferred to use the methods of this interface or thePluginAware.getPluginManager() than use the plugin container.

Use one of the 'apply' methods on this interface or on thePluginAware.getPluginManager() to apply plugins instead of applying via the plugin container.

UsePluginManager.hasPlugin(java.lang.String) or similar to query for the application of plugins instead of doing so via the plugin container.

Returns this project. This method is useful in build files to explicitly access project properties andmethods. For example, usingproject.name can express your intent better than usingname. This method also allows you to access project properties from a scope where the property maybe hidden, such as, for example, from a method or closure.

The directory containing the project build file.

The properties of this project. Seehere for details of the properties whichare available for a project.

Returns a handler to create repositories which are used for retrieving dependencies and uploading artifactsproduced by the project.

Provides access to resource-specific utility methods, for example factory methods that create various resources.

The root directory of this project. The root directory is the project directory of the rootproject.

The root project for the hierarchy that this project belongs to. In the case of a single-projectbuild, this method returns this project.

The evaluation state of this project. You can use this to access information about the evaluation of thisproject, such as whether it has failed.

The status of this project. Gradle always uses thetoString() value of the status. The statusdefaults torelease.

The status of the project is only relevant, if you upload libraries together with a module descriptor. Thestatus specified here, will be part of this module descriptor.

The set containing the subprojects of this project.

The tasks of this project.

The version of this project. Gradle always uses thetoString() value of the version. Theversion defaults tounspecified.

TheJavaApplication added by the application plugin.

Array of string arguments to pass to the JVM when running the application

The specification of the contents of the distribution.

Use thisCopySpec to include extra files/resource in the application distribution.

plugins {    id'application'}applicationDistribution.from("some/dir") {  include"*.txt"}

Note that the application plugin pre configures this spec to; include the contents of "src/dist",copy the application start scripts into the "bin" directory, and copy the built jar and its dependenciesinto the "lib" directory.

The name of the application.

Directory to place executables in

The fully qualified name of the application's main class.

TheCheckstyleExtension added by the checkstyle plugin.

TheCodeNarcExtension added by the codenarc plugin.

TheDistributionContainer added by the distribution plugin.

The name of the application directory, relative to the project directory.Default is "src/main/application".

A custom deployment descriptor configuration.Default is an "application.xml" with sensible defaults.

Specifies if the deploymentDescriptor should be generated if it does not exist.Default is true.

The name of the library directory in the EAR file.Default is "lib".

TheEclipseModel added by the eclipse plugin.

TheIdeaModel added by the idea plugin.

TheJacocoPluginExtension added by the jacoco plugin.

The base name to use for archive files.

The directory to generate TAR and ZIP archives into.

This property has been replaced by distsDirectory.

The name for the distributions directory. This in interpreted relative to the project' build directory.

The directory to generate TAR and ZIP archives into.

Returns a file pointing to the root directory supposed to be used for all docs.

The name of the docs directory. Can be a name or a path relative to the build dir.

The directory to generate JAR and WAR archives into.

This property has been replaced by libsDirectory.

The name for the libs directory. This in interpreted relative to the project' build directory.

The directory to generate JAR and WAR archives into.

TheReportingExtension added by the java plugin.

The source compatibility used for compiling Java sources.

The source compatibility used for compiling Java sources.

The source sets container.

The target compatibility used for compiling Java sources.

The target compatibility used for compiling Java sources.

Returns a file pointing to the root directory to be used for reports.

The name of the test reports directory. Can be a name or a path relative toReportingExtension.getBaseDir().

Returns a file pointing to the root directory of the test results.

The name of the test results directory. Can be a name or a path relative to the build dir.

Gets the project wide toolchain requirements that will be used for tasks requiring a tool from the toolchain (e.g.JavaCompile).

Configuring a toolchain cannot be used together withsourceCompatibility ortargetCompatibility on this extension.Both values will be sourced from the toolchain.

The set of rules for how to map Gradle dependencies to Maven scopes.

The directory to generate Maven POMs into.

ThePmdExtension added by the pmd plugin.

The directory to generate the project reports into.

The name of the directory to generate the project reports into, relative to the project's reports dir.

ThePublishingExtension added by the publishing plugin.

TheSigningExtension added by the signing plugin.

TheVisualStudioRootExtension added by the visual-studio plugin.

The web application directory.

The name of the web application directory, relative to the project directory.

TheXcodeRootExtension added by the xcode plugin.

Converts a name to an absolute project path, resolving names relative to this project.

Adds a closure to be called immediately after this project has been evaluated. The project is passed to theclosure as a parameter. Such a listener gets notified when the build file belonging to this project has beenexecuted. A parent project may for example add such a listener to its child project. Such a listener can furtherconfigure those child projects based on the state of the child projects after their build files have beenrun.

Adds an action to execute immediately after this project is evaluated.

Configures this project and each of its sub-projects.

This method executes the givenAction against this project and each of its sub-projects.

Executes the given action against theAntBuilder for this project. You can use this in yourbuild file to execute ant tasks. See example in javadoc forProject.getAnt()

Applies zero or more plugins or scripts.

The given closure is used to configure anObjectConfigurationAction, which “builds” the plugin application.

This method differs fromPluginAware.apply(java.util.Map) in that it allows methods of the configuration action to be invoked more than once.

Applies a plugin or script, using the given options provided as a map. Does nothing if the plugin has already been applied.

The given map is applied as a series of method calls to a newly createdObjectConfigurationAction.That is, each key in the map is expected to be the name of a methodObjectConfigurationAction and the value to be compatible arguments to that method.

The following options are available:

Applies zero or more plugins or scripts.

The given closure is used to configure anObjectConfigurationAction, which “builds” the plugin application.

This method differs fromPluginAware.apply(java.util.Map) in that it allows methods of the configuration action to be invoked more than once.

Configures the published artifacts for this project.

This method executes the given action against theArtifactHandler for this project.

Example:

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 the schema}//associating the task that produces the artifact with the configurationartifacts {//configuration name and the task:  schema schemaJar}

Adds a closure to be called immediately before this project is evaluated. The project is passed to the closureas a parameter.

Adds an action to execute immediately before this project is evaluated.

Configures a collection of objects via a closure. This is equivalent to callingProject.configure(java.lang.Object, groovy.lang.Closure) for each of the given objects.

Configures a collection of objects via an action.

Configures an object via a closure, with the closure's delegate set to the supplied object. This way you don'thave to specify the context of a configuration statement multiple times.

Instead of:

MyType myType =new MyType()myType.doThis()myType.doThat()

you can do:

MyType myType = configure(new MyType()) {    doThis()    doThat()}

The object being configured is also passed to the closure as a parameter, so you can access it explicitly ifrequired:

configure(someObj) { obj -> obj.doThis() }

Creates a container for managing named objects of the specified type. The specified type must have a public constructor which takes the name as a String parameter.

All objectsMUST expose their name as a bean property named "name". The name must be constant for the life of the object.

Creates a container for managing named objects of the specified type. The given closure is used to create object instances. The name of the instance to be created is passed as a parameter tothe closure.

All objectsMUST expose their name as a bean property named "name". The name must be constant for the life of the object.

Creates a container for managing named objects of the specified type. The given factory is used to create object instances.

All objectsMUST expose their name as a bean property named "name". The name must be constant for the life of the object.

Copies the specified files. The given closure is used to configure aCopySpec, which is then used tocopy the files. Example:

copy {   from configurations.runtimeClasspath   into'build/deploy/lib'}

Note that CopySpecs can be nested:

copy {   into'build/webroot'   exclude'**/.svn/**'   from('src/main/webapp') {      include'**/*.jsp'      filter(ReplaceTokens, tokens:[copyright:'2009', version:'2.3.1'])   }   from('src/main/js') {      include'**/*.js'   }}

Copies the specified files. The given action is used to configure aCopySpec, which is then used tocopy the files.

Creates aCopySpec which can later be used to copy files or create an archive.

Creates aCopySpec which can later be used to copy files or create an archive. The given closure is usedto configure theCopySpec before it is returned by this method.

def baseSpec = copySpec {   from"source"   include"**/*.java"}task copy(type: Copy) {   into"target"   with baseSpec}

Creates aCopySpec which can later be used to copy files or create an archive. The given action is usedto configure theCopySpec before it is returned by this method.

Sets the names of the default tasks of this project. These are used when no tasks names are provided whenstarting the build.

Deletes files and directories.

This will not follow symlinks. If you need to follow symlinks too useProject.delete(org.gradle.api.Action).

Deletes the specified files. The given action is used to configure aDeleteSpec, which is then used todelete the files.

Example:

project.delete {    delete'somefile'    followSymlinks = true}

Configures dependency locking

Declares that this project has an evaluation dependency on the project with the given path.

Executes an external command. The closure configures aExecSpec.

Executes an external command.

The given action configures aExecSpec, which is used to launch the process.This method blocks until the process terminates, with its result being returned.

Resolves a file path relative to the project directory of this project. This method converts the supplied pathbased on its type:

Resolves a file path relative to the project directory of this project and validates it using the givenscheme. SeePathValidation for the list of possible validations.

Creates a newConfigurableFileTree using the given base directory. The given baseDir path is evaluatedas perProject.file(java.lang.Object).

The returned file tree is lazy, so that it scans for files only when the contents of the file tree arequeried. The file tree is also live, so that it scans for files each time the contents of the file tree arequeried.

def myTree = fileTree("src")myTree.include"**/*.java"myTree.builtBy"someTask"task copy(type: Copy) {   from myTree}

The order of the files in aFileTree is not stable, even on a single computer.

Creates a newConfigurableFileTree using the given base directory. The given baseDir path is evaluatedas perProject.file(java.lang.Object). The closure will be used to configure the new file tree.The file tree is passed to the closure as its delegate. Example:

def myTree = fileTree('src') {   exclude'**/.data/**'   builtBy'someTask'}task copy(type: Copy) {   from myTree}

The returned file tree is lazy, so that it scans for files only when the contents of the file tree arequeried. The file tree is also live, so that it scans for files each time the contents of the file tree arequeried.

The order of the files in aFileTree is not stable, even on a single computer.

Creates a newConfigurableFileTree using the given base directory. The given baseDir path is evaluatedas perProject.file(java.lang.Object). The action will be used to configure the new file tree. Example:

def myTree = fileTree('src') {   exclude'**/.data/**'   builtBy'someTask'}task copy(type: Copy) {   from myTree}

The returned file tree is lazy, so that it scans for files only when the contents of the file tree arequeried. The file tree is also live, so that it scans for files each time the contents of the file tree arequeried.

The order of the files in aFileTree is not stable, even on a single computer.

Creates a newConfigurableFileTree using the provided map of arguments. The map will be applied asproperties on the new file tree. Example:

def myTree = fileTree(dir:'src', excludes:['**/ignore/**','**/.data/**'])task copy(type: Copy) {    from myTree}

The returned file tree is lazy, so that it scans for files only when the contents of the file tree arequeried. The file tree is also live, so that it scans for files each time the contents of the file tree arequeried.

The order of the files in aFileTree is not stable, even on a single computer.

Creates a newConfigurableFileCollection using the given paths. The paths are evaluated as perProject.files(java.lang.Object[]). The file collection is configured using the given closure. The file collection is passed tothe closure as its delegate. Example:

files"$buildDir/classes" {    builtBy'compile'}

The returned file collection is lazy, so that the paths are evaluated only when the contents of the filecollection are queried. The file collection is also live, so that it evaluates the above each time the contentsof the collection is queried.

Creates a newConfigurableFileCollection using the given paths. The paths are evaluated as perProject.files(java.lang.Object[]). The file collection is configured using the given action. Example:

files"$buildDir/classes" {    builtBy'compile'}

The returned file collection is lazy, so that the paths are evaluated only when the contents of the filecollection are queried. The file collection is also live, so that it evaluates the above each time the contentsof the collection is queried.

Returns aConfigurableFileCollection containing the given files. You can pass any of the followingtypes to this method:

The returned file collection is lazy, so that the paths are evaluated only when the contents of the filecollection are queried. The file collection is also live, so that it evaluates the above each time the contentsof the collection is queried.

The returned file collection maintains the iteration order of the supplied paths.

The returned file collection maintains the details of the tasks that produce the files, so that these tasks are executed if this file collection is used as an input to some task.

This method can also be used to create an empty collection, which can later be mutated to add elements.

Locates a project by path. If the path is relative, it is interpreted relative to this project.

Returns the value of the given property or null if not found.This method locates a property as follows:

Returns a map of the tasks contained in this project, and optionally its subprojects.

Returns the set of tasks with the given name contained in this project, and optionally its subprojects.NOTE: This is an expensive operation since it requires all projects to be configured.

Determines if this project has the given property. Seehere for details of theproperties which are available for a project.

Executes a Java main class. The closure configures aJavaExecSpec.

Executes an external Java process.

The given action configures aJavaExecSpec, which is used to launch the process.This method blocks until the process terminates, with its result being returned.

Creates a directory and returns a file pointing to it.

Configures input normalization.

Locates a project by path. If the path is relative, it is interpreted relative to this project.

Locates a project by path and configures it using the given closure. If the path is relative, it isinterpreted relative to this project. The target project is passed to the closure as the closure's delegate.

Locates a project by path and configures it using the given action. If the path is relative, it isinterpreted relative to this project.

Returns the value of the given property. This method locates a property as follows:

Returns the relative path from the project directory to the given path. The given path object is (logically)resolved as described forProject.file(java.lang.Object), from which a relative path is calculated.

Converts a name to a project path relative to this project.

Sets a property of this project. This method searches for a property with the given name in the followinglocations, and sets the property on the first location where it finds the property.

If the property is not found, aMissingPropertyException is thrown.

Configures the sub-projects of this project

This method executes the givenAction against the sub-projects of this project.

Synchronizes the contents of a destination directory with some source directories and files.The given action is used to configure aCopySpec, which is then used to synchronize the files.

This method is like theProject.copy(org.gradle.api.Action) 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 option is specified.

Example:

project.sync {   from'my/shared/dependencyDir'   into'build/deps/compile'}

Note that you can preserve output that already exists in the destination directory:

project.sync {    from'source'    into'dest'    preserve {        include'extraDir/**'        include'dir1/**'        exclude'dir1/extra.txt'    }}

Creates a newFileTree which contains the contents of the given TAR file. The given tarPath path can be:

The returned file tree is lazy, so that it scans for files only when the contents of the file tree arequeried. The file tree is also live, so that it scans for files each time the contents of the file tree arequeried.

Unless custom implementation of resources is passed, the tar tree attempts to guess the compression based on the file extension.

You can combine this method with theProject.copy(groovy.lang.Closure)method to untar a TAR file:

task untar(type: Copy) {  from tarTree('someCompressedTar.gzip')//tar tree attempts to guess the compression based on the file extension//however if you must specify the compression explicitly you can:  from tarTree(resources.gzip('someTar.ext'))//in case you work with unconventionally compressed tars//you can provide your own implementation of a ReadableResource://from tarTree(yourOwnResource as ReadableResource)  into'dest'}

Creates aTask with the given name and adds it to this project. Calling this method is equivalent tocallingProject.task(java.util.Map, java.lang.String) with an empty options map.

After the task is added to the project, it is made available as a property of the project, so that you canreference the task by name in your build file. Seehere for more details

If a task with the given name already exists in this project, an exception is thrown.

Creates aTask with the given name and adds it to this project. Before the task is returned, the givenclosure is executed to configure the task.

After the task is added to the project, it is madeavailable as a property of the project, so that you can reference the task by name in your build file. Seehere for more details

Creates aTask with the given name and adds it to this project. Before the task is returned, the givenaction is executed to configure the task.

After the task is added to the project, it is madeavailable as a property of the project, so that you can reference the task by name in your build file. Seehere for more details

Creates aTask with the given name and adds it to this project. A map of creation options can bepassed to this method to control how the task is created. The following options are available:

After the task is added to the project, it is made available as a property of the project, so that you canreference the task by name in your build file. Seehere for more details

If a task with the given name already exists in this project and theoverride option is not setto true, an exception is thrown.

Creates aTask with the given name and adds it to this project. Before the task is returned, the givenclosure is executed to configure the task. A map of creation options can be passed to this method to control howthe task is created. SeeProject.task(java.util.Map, java.lang.String) for the available options.

After the task is added to the project, it is made available as a property of the project, so that you canreference the task by name in your build file. Seehere for more details

If a task with the given name already exists in this project and theoverride option is not setto true, an exception is thrown.

Resolves a file path to a URI, relative to the project directory of this project. Evaluates the provided pathobject as described forProject.file(java.lang.Object), with the exception that any URI scheme is supported, not just'file:' URIs.

Creates a newFileTree which contains the contents of the given ZIP file. The given zipPath path isevaluated as perProject.file(java.lang.Object). You can combine this method with theProject.copy(groovy.lang.Closure)method to unzip a ZIP file.

The returned file tree is lazy, so that it scans for files only when the contents of the file tree arequeried. The file tree is also live, so that it scans for files each time the contents of the file tree arequeried.

Allows changing the application directory.Default is "src/main/application".

Configures the deployment descriptor for this EAR archive.

The given action is executed to configure the deployment descriptor.

Allows changing the library directory in the EAR file. Default is "lib".

If this method is called, Gradle will not automatically try to fetchdependencies which have a JVM version compatible with the target compatibilityof this module.

This should be used whenever the default behavior is notapplicable, in particular when for some reason it's not possible to splita module and that this module only has some classes which require dependencieson higher versions.

Creates a new instance of aManifest.

Creates and configures a new instance of aManifest. The given closure configuresthe new manifest instance before it is returned.

Creates and configures a new instance of aManifest.

Registers a feature.

Configures the project wide toolchain requirements for tasks that require a tool from the toolchain (e.g.JavaCompile).

Configuring a toolchain cannot be used together withsourceCompatibility ortargetCompatibility on this extension.Both values will be sourced from the toolchain.

Adds a taskjavadocJar that will package the output of thejavadoc task in a JAR with classifierjavadoc.

The produced artifact is registered as a documentation variant on thejava component and added as a dependency on theassemble task.This means that ifmaven-publish orivy-publish is also applied, the javadoc JAR will be published.

If the project already has a task namedjavadocJar then no task is created.

The publishing of the Javadoc variant can also be disabled usingConfigurationVariantDetails.skip()throughAdhocComponentWithVariants.withVariantsFromConfiguration(org.gradle.api.artifacts.Configuration, org.gradle.api.Action),if it should only be built locally by calling or wiring the ':javadocJar' task.

Adds a tasksourcesJar that will package the Java sources of the mainSourceSet in a JAR with classifiersources.

The produced artifact is registered as a documentation variant on thejava component and added as a dependency on theassemble task.This means that ifmaven-publish orivy-publish is also applied, the sources JAR will be published.

If the project already has a task namedsourcesJar then no task is created.

The publishing of the sources variant can be disabled usingConfigurationVariantDetails.skip()throughAdhocComponentWithVariants.withVariantsFromConfiguration(org.gradle.api.artifacts.Configuration, org.gradle.api.Action),if it should only be built locally by calling or wiring the ':sourcesJar' task.

Creates a newMavenPom.

Creates and configures a newMavenPom. The given closure is executed to configure the new POM instance.

Creates and configures a newMavenPom. The given action is executed to configure the new POM instance.

Configures this project and each of its sub-projects.

This method executes the given closure against this project and its sub-projects. The targetProjectis passed to the closure as the closure's delegate.

Executes the given closure against theAntBuilder for this project. You can use this in yourbuild file to execute ant tasks. TheAntBuild is passed to the closure as the closure'sdelegate. See example in javadoc forProject.getAnt()

Configures the published artifacts for this project.

This method executes the given closure against theArtifactHandler for this project. TheArtifactHandler is passed to the closure as the closure's delegate.

Example:

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 the schema}//associating the task that produces the artifact with the configurationartifacts {//configuration name and the task:  schema schemaJar}

Configures the build script classpath for this project.

The given closure is executed against this project'sScriptHandler. TheScriptHandler ispassed to the closure as the closure's delegate.

Configures the dependency configurations for this project.

This method executes the given closure against theConfigurationContainerfor this project. TheConfigurationContainer is passed to the closure as the closure's delegate.

Configures the dependencies for this project.

This method executes the given closure against theDependencyHandler for this project. TheDependencyHandler is passed to the closure as the closure's delegate.

Configures the repositories for this project.

This method executes the given closure against theRepositoryHandler for this project. TheRepositoryHandler is passed to the closure as the closure's delegate.

Configures the sub-projects of this project.

This method executes the given closure against each of the sub-projects of this project. The targetProject is passed to the closure as the closure's delegate.

Configures theJavaApplication added by the application plugin.

Configures theCheckstyleExtension added by the checkstyle plugin.

Configures theCodeNarcExtension added by the codenarc plugin.

Configures theDistributionContainer added by the distribution plugin.

Configures the deployment descriptor for this EAR archive.

The given closure is executed to configure the deployment descriptor.TheDeploymentDescriptor is passed to the closure as its delegate.

Configures theEclipseModel added by the eclipse plugin.

Configures theIdeaModel added by the idea plugin.

Configures theJacocoPluginExtension added by the jacoco plugin.

Configures theReportingExtension added by the java plugin.

Configures the source sets of this project.

The given closure is executed to configure theSourceSetContainer. TheSourceSetContaineris passed to the closure as its delegate.

See the example below howSourceSet 'main' is accessed and how theSourceDirectorySet 'java'is configured to exclude some package from compilation.

plugins {    id'java'}sourceSets {  main {    java {      exclude'some/unwanted/package/**'    }  }}

Configures thePmdExtension added by the pmd plugin.

Configures thePublishingExtension added by the publishing plugin.

Configures theSigningExtension added by the signing plugin.

Configures theVisualStudioRootExtension added by the visual-studio plugin.

Configures theXcodeRootExtension added by the xcode plugin.