Project

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 can be 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.

The AntBuilder for this project. You can use this in your build file to execute ant tasks. 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 are generated into. The default value for the build directory is projectDir/build

The build file Gradle will evaluate against this project object. The default is build.gradle. If an embedded script is provided the build file will be null.

The build script handler for this project. You can use this handler to query details about the build script 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.

The Convention for this project.

You can access this property in your build file using convention. You can also can also access the properties and methods of the convention object as if they were properties and methods of this project. See here for more details

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

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

The description of this project.

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

The Gradle invocation which this project belongs to.

The group of this project. Gradle always uses the toString() value of the group. The group defaults to the path with dots a separators.

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

The LoggingManager which can be used to control the logging level and standard output/error capture for this project's build script. By default, System.out is redirected to the Gradle logging 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. You should use the Project.getPath() method for a unique identifier for the project.

The parent project of this project, if any.

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

The plugins container for this project. The returned container can be used to manage the plugins which are used by this project.

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

The directory containing the project build file.

The properties of this project. See here for details of the properties which are available for a project.

Returns a handler to create repositories which are used for retrieving dependencies and uploading artifacts produced 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 root project.

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

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

The status of this project. Gradle always uses the toString() value of the status. The status defaults to release.

The status of the project is only relevant, if you upload libraries together with a module descriptor. The status 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 the toString() value of the version. The version defaults to unspecified.

The BinaryContainer added by the LanguageBasePlugin plugin.

The ComponentSpecContainer added by the LanguageBasePlugin plugin.

The ProjectSourceSet added by the LanguageBasePlugin plugin.

The AnnouncePluginExtension added by the announce plugin.

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

The specification of the contents of the distribution.

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

apply plugin: '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 dependencies into the "lib" directory.

The name of the application.

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

The CheckstyleExtension added by the checkstyle plugin.

The CodeNarcExtension added by the codenarc plugin.

The DistributionContainer 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.

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

The EclipseModel added by the eclipse plugin.

The FindBugsExtension added by the findbugs plugin.

The IdeaModel added by the idea plugin.

The JacocoPluginExtension added by the jacoco plugin.

The base name to use for archive files.

The directory to generate TAR and ZIP archives into.

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

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.

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

The ReportingExtension added by the java plugin.

The source compatibility used for compiling Java sources.

The source sets container.

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 to the build dir.

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.

The JDependExtension added by the jdepend plugin.

The TCP port for Jetty to listen on for incoming HTTP requests.

The key to use to stop Jetty.

The TCP port for Jetty to listen on for stop requests.

The JvmComponentExtension added by the jvm-component plugin.

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

The directory to generate Maven POMs into.

The BuildTypeContainer added by the native-component plugin.

The FlavorContainer added by the native-component plugin.

The NativeComponentExtension added by the native-component plugin.

The PlatformContainer added by the native-component plugin.

The ToolChainRegistry added by the native-component plugin.

The PmdExtension 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.

The PublishingExtension added by the publishing plugin.

The SigningExtension added by the signing plugin.

The VisualStudioExtension added by the visual-studio plugin.

The web application directory.

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

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 the closure as a parameter. Such a listener gets notified when the build file belonging to this project has been executed. A parent project may for example add such a listener to its child project. Such a listener can further configure those child projects based on the state of the child projects after their build files have been run.

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

Configures this project and each of its sub-projects.

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

Configures this project using plugins or scripts. The given closure is used to configure an ObjectConfigurationAction which is then used to configure this project.

Configures this project using plugins or scripts. The following options are available:

For more detail, see ObjectConfigurationAction.

Adds a closure to be called immediately before this project is evaluated. The project is passed to the closure as 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 calling Project.configure() 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't have 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 if required:

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 objects MUST 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 to the closure.

All objects MUST 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 objects MUST 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 a CopySpec, which is then used to copy the files. Example:

copy {
   from configurations.runtime
   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'
   }
}

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

def baseSpec = copySpec {
   from "source"
   include "**/*.java"
}

task copy(type: Copy) {
   into "target"
   with baseSpec
}

Deletes files and directories.

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

Executes an external command. The closure configures a ExecSpec.

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

Resolves a file path relative to the project directory of this project and validates it using the given scheme. See PathValidation for the list of possible validations.

Creates a new ConfigurableFileTree using the given base directory. The given baseDir path is evaluated as per Project.file().

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

Creates a new ConfigurableFileTree using the given base directory. The given baseDir path is evaluated as per Project.file(). The closure will be used to configure the new file tree. The file tree is passed to the closure as its delegate. Example:

fileTree('src') {
   exclude '**/.svn/**'
}.copy { into 'dest'}

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

Creates a new ConfigurableFileTree using the provided map of arguments. The map will be applied as properties on the new file tree. Example:

fileTree(dir:'src', excludes:['**/ignore/**','**/.svn/**'])

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

Creates a new ConfigurableFileCollection using the given paths. The paths are evaluated as per Project.files(). The file collection is configured using the given closure. The file collection is passed to the 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 file collection are queried. The file collection is also live, so that it evaluates the above each time the contents of the collection is queried.

Returns a ConfigurableFileCollection containing the given files. You can pass any of the following types to this method:

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

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

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

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.

Determines if this project has the given property. See here for details of the properties which are available for a project.

Executes a Java main class. The closure configures a JavaExecSpec.

Creates a directory and returns a file pointing to it.

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 is interpreted relative to this project. The target project is passed to the closure as the closure's delegate.

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 for Project.file(), 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 following locations, and sets the property on the first location where it finds the property.

If the property is not found, a MissingPropertyException is thrown.

Configures the sub-projects of this project

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

Creates a new FileTree 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 are queried. The file tree is also live, so that it scans for files each time the contents of the file tree are queried.

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 the Project.copy() 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 a Task with the given name and adds it to this project. Calling this method is equivalent to calling Project.task() 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 can reference the task by name in your build file. See here for more details

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

Creates a Task with the given name and adds it to this project. Before the task is returned, the given closure is executed to configure the task.

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

Creates a Task with the given name and adds it to this project. A map of creation options can be passed 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 can reference the task by name in your build file. See here for more details

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

Creates a Task with the given name and adds it to this project. Before the task is returned, the given closure is executed to configure the task. A map of creation options can be passed to this method to control how the task is created. See Project.task() 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 can reference the task by name in your build file. See here for more details

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

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

Creates a new FileTree which contains the contents of the given ZIP file. The given zipPath path is evaluated as per Project.file(). You can combine this method with the Project.copy() 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 are queried. The file tree is also live, so that it scans for files each time the contents of the file tree are queried.

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

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

Creates a new instance of a Manifest.

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

Creates a new MavenPom.

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

Creates a new instance of OsgiManifest. The returned object is preconfigured with:

version: project.version
name: project.archivesBaseName
symbolicName: project.group + "." + project.archivesBaseName (see below for exceptions to this rule)

The symbolic name is usually the group + "." + archivesBaseName, with the following exceptions

Creates and configures a new instance of an OsgiManifest . The closure configures the new manifest instance before it is returned.

Configures this project and each of its sub-projects.

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

Executes the given closure against the AntBuilder for this project. You can use this in your build file to execute ant tasks. The AntBuild is passed to the closure as the closure's delegate. See example in javadoc for Project.getAnt()

Configures the published artifacts for this project.

This method executes the given closure against the ArtifactHandler for this project. The ArtifactHandler 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 configuration
artifacts {
  //configuration name and the task:
  schema schemaJar
}

Configures the build script classpath for this project.

The given closure is executed against this project's ScriptHandler. The ScriptHandler is passed to the closure as the closure's delegate.

Configures the dependency configurations for this project.

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

Configures the dependencies for this project.

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

Configures the repositories for this project.

This method executes the given closure against the RepositoryHandler for this project. The RepositoryHandler 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 target Project is passed to the closure as the closure's delegate.

Configures the BinaryContainer added by the LanguageBasePlugin plugin.

Configures the ComponentSpecContainer added by the LanguageBasePlugin plugin.

Configures the ProjectSourceSet added by the LanguageBasePlugin plugin.

Configures the AnnouncePluginExtension added by the announce plugin.

Configures the CheckstyleExtension added by the checkstyle plugin.

Configures the CodeNarcExtension added by the codenarc plugin.

Configures the DistributionContainer added by the distribution plugin.

Configures the deployment descriptor for this EAR archive.

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

Configures the EclipseModel added by the eclipse plugin.

Configures the FindBugsExtension added by the findbugs plugin.

Configures the IdeaModel added by the idea plugin.

Configures the JacocoPluginExtension added by the jacoco plugin.

Configures the ReportingExtension added by the java plugin.

Configures the source sets of this project.

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

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/**'
    }
  }
}

Configures the JDependExtension added by the jdepend plugin.

Configures the JvmComponentExtension added by the jvm-component plugin.

Configures the BuildTypeContainer added by the native-component plugin.

Configures the FlavorContainer added by the native-component plugin.

Configures the NativeComponentExtension added by the native-component plugin.

Configures the PlatformContainer added by the native-component plugin.

Configures the ToolChainRegistry added by the native-component plugin.

Configures the PmdExtension added by the pmd plugin.

Configures the PublishingExtension added by the publishing plugin.

Configures the SigningExtension added by the signing plugin.

Configures the VisualStudioExtension added by the visual-studio plugin.