# Project

API Documentation: | `Project`

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.

### Lifecycle

There is a one-to-one relationship between a `Project` and a ``build.gradle`` file. During build initialisation, Gradle assembles a `Project` object for each project which is to participate in the build, as follows:

- Create a `Settings` instance for the build.
- Evaluate the ``settings.gradle`` script, if present, against the `Settings` object to configure it.
- Use the configured `Settings` object to create the hierarchy of `Project` instances.
- Finally, evaluate each `Project` by executing its ``build.gradle`` 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 ``Project.evaluationDependsOnChildren()`` or by adding an explicit evaluation dependency using ``Project.evaluationDependsOn(java.lang.String)``.

### Tasks

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(java.lang.String)`. You can locate existing tasks using one of the lookup methods on `TaskContainer`, such as `TaskCollection.getByName(java.lang.String)`.

### Dependencies

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 `ConfigurationContainer` returned by `Project.getConfigurations()` method to manage the configurations. The `DependencyHandler` returned by `Project.getDependencies()` method to manage the dependencies. The `ArtifactHandler` returned by `Project.getArtifacts()` method to manage the artifacts. The `RepositoryHandler` returned by `Project.getRepositories()` method to manage the repositories.

### Multi-project Builds

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

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 `PluginDependenciesSpec` plugins script block.

### Dynamic Project Properties

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 `Project.property(java.lang.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, `Project.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 `Project.property(java.lang.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 `Project.setProperty(java.lang.String, java.lang.Object)` for more details.

#### Extra Properties

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
    }

#### Dynamic Methods

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 `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 `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.

### Properties

Property | Description
`allprojects` | The set containing this project and its subprojects.
`ant` | The `AntBuilder` for this project. You can use this in your build file to execute ant tasks. See example below.
`artifacts` | Returns a handler for assigning artifacts produced by the project to configurations.
`buildDir` | 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`
`buildFile` | The build script for this project.
`buildscript` | 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.
`childProjects` | The direct children of this project.
`configurations` | The configurations of this project.
`convention` | The `Convention` for this project.
`defaultTasks` | The names of the default tasks of this project. These are used when no tasks names are provided when starting the build.
`dependencies` | 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.
`dependencyLocking` | Provides access to configuring dependency locking
`description` | The description of this project, if any.
`extensions` | Allows adding DSL extensions to the project. Useful for plugin authors.
`gradle` | The `Gradle` invocation which this project belongs to.
`group` | The group of this project. Gradle always uses the `toString()` value of the group. The group defaults to the path with dots as separators.
`logger` | The logger for this project. You can use this in your build file to write log messages.
`logging` | The `LoggingManager` which can be used to receive logging and to control the 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.
`name` | 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.
`normalization` | Provides access to configuring input normalization.
`parent` | The parent project of this project, if any.
`path` | The path of this project. The path is the fully qualified name of the project.
`pluginManager` | The plugin manager for this plugin aware object.
`plugins` | The container of plugins that have been applied to this object.
`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.
`projectDir` | The directory containing the project build file.
`properties` | The properties of this project. See here for details of the properties which are available for a project.
`repositories` | Returns a handler to create repositories which are used for retrieving dependencies and uploading artifacts produced by the project.
`resources` | Provides access to resource-specific utility methods, for example factory methods that create various resources.
`rootDir` | The root directory of this project. The root directory is the project directory of the root project.
`rootProject` | The root project for the hierarchy that this project belongs to. In the case of a single-project build, this method returns this project.
`state` | 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.
`status` | The status of this project. Gradle always uses the `toString()` value of the status. The status defaults to `release`.
`subprojects` | The set containing the subprojects of this project.
`tasks` | The tasks of this project.
`version` | The version of this project. Gradle always uses the `toString()` value of the version. The version defaults to `unspecified`.

#### Properties added by the `application` plugin

Property | Description
`application` | The `JavaApplication` added by the application plugin.
`applicationDefaultJvmArgs` | Array of string arguments to pass to the JVM when running the application
`applicationDistribution` | The specification of the contents of the distribution.
`applicationName` | The name of the application.
`executableDir` | Directory to place executables in
`mainClassName` | The fully qualified name of the application's main class.

#### Properties added by the `checkstyle` plugin

Property | Description
`checkstyle` | The `CheckstyleExtension` added by the checkstyle plugin.

#### Properties added by the `codenarc` plugin

Property | Description
`codenarc` | The `CodeNarcExtension` added by the codenarc plugin.

#### Properties added by the `distribution` plugin

Property | Description
`distributions` | The `DistributionContainer` added by the distribution plugin.

#### Properties added by the `ear` plugin

Property | Description
`appDirName` | The name of the application directory, relative to the project directory. Default is "src/main/application".
`deploymentDescriptor` | A custom deployment descriptor configuration. Default is an "application.xml" with sensible defaults.
`generateDeploymentDescriptor` | Incubating Specifies if the deploymentDescriptor should be generated if it does not exist. Default is true.
`libDirName` | The name of the library directory in the EAR file. Default is "lib".

#### Properties added by the `eclipse` plugin

Property | Description
`eclipse` | The `EclipseModel` added by the eclipse plugin.

#### Properties added by the `idea` plugin

Property | Description
`idea` | The `IdeaModel` added by the idea plugin.

#### Properties added by the `jacoco` plugin

Property | Description
`jacoco` | The `JacocoPluginExtension` added by the jacoco plugin.

#### Properties added by the `java` plugin

Property | Description
`archivesBaseName` | The base name to use for archive files.
`distsDir` | Deprecated The directory to generate TAR and ZIP archives into.
`distsDirName` | The name for the distributions directory. This in interpreted relative to the project' build directory.
`distsDirectory` | The directory to generate TAR and ZIP archives into.
`docsDir` | Returns a file pointing to the root directory supposed to be used for all docs.
`docsDirName` | The name of the docs directory. Can be a name or a path relative to the build dir.
`libsDir` | Deprecated The directory to generate JAR and WAR archives into.
`libsDirName` | The name for the libs directory. This in interpreted relative to the project' build directory.
`libsDirectory` | The directory to generate JAR and WAR archives into.
`reporting` | The `ReportingExtension` added by the java plugin.
`sourceCompatibility` | The source compatibility used for compiling Java sources.
`sourceCompatibility` | The source compatibility used for compiling Java sources.
`sourceSets` | The source sets container.
`targetCompatibility` | The target compatibility used for compiling Java sources.
`targetCompatibility` | The target compatibility used for compiling Java sources.
`testReportDir` | Returns a file pointing to the root directory to be used for reports.
`testReportDirName` | The name of the test reports directory. Can be a name or a path relative to `ReportingExtension.getBaseDir()`.
`testResultsDir` | Returns a file pointing to the root directory of the test results.
`testResultsDirName` | The name of the test results directory. Can be a name or a path relative to the build dir.

#### Properties added by the `maven` plugin

Property | Description
`conf2ScopeMappings` | The set of rules for how to map Gradle dependencies to Maven scopes.
`mavenPomDir` | The directory to generate Maven POMs into.

#### Properties added by the `pmd` plugin

Property | Description
`pmd` | The `PmdExtension` added by the pmd plugin.

#### Properties added by the `project-report` plugin

Property | Description
`projectReportDir` | The directory to generate the project reports into.
`projectReportDirName` | The name of the directory to generate the project reports into, relative to the project's reports dir.

#### Properties added by the `publishing` plugin

Property | Description
`publishing` | The `PublishingExtension` added by the publishing plugin.

#### Properties added by the `signing` plugin

Property | Description
`signing` | The `SigningExtension` added by the signing plugin.

#### Properties added by the `visual-studio` plugin

Property | Description
`visualStudio` | The `VisualStudioRootExtension` added by the visual-studio plugin.

#### Properties added by the `war` plugin

Property | Description
`webAppDir` | The web application directory.
`webAppDirName` | The name of the web application directory, relative to the project directory.

#### Properties added by the `xcode` plugin

Property | Description
`xcode` | The `XcodeRootExtension` added by the xcode plugin.

### Methods

Method | Description
`absoluteProjectPath(path)` | Converts a name to an absolute project path, resolving names relative to this project.
`afterEvaluate(closure)` | 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.
`afterEvaluate(action)` | Adds an action to execute immediately after this project is evaluated.
`allprojects(action)` | Configures this project and each of its sub-projects.
`ant(configureAction)` | Executes the given action against the `AntBuilder` for this project. You can use this in your build file to execute ant tasks. See example in javadoc for `Project.getAnt()`
`apply(closure)` | Applies zero or more plugins or scripts.
`apply(options)` | Applies a plugin or script, using the given options provided as a map. Does nothing if the plugin has already been applied.
`apply(action)` | Applies zero or more plugins or scripts.
`artifacts(configureAction)` | Configures the published artifacts for this project.
`beforeEvaluate(closure)` | Adds a closure to be called immediately before this project is evaluated. The project is passed to the closure as a parameter.
`beforeEvaluate(action)` | Adds an action to execute immediately before this project is evaluated.
`configure(objects, configureClosure)` | Configures a collection of objects via a closure. This is equivalent to calling `Project.configure(java.lang.Object, groovy.lang.Closure)` for each of the given objects.
`configure(objects, configureAction)` | Configures a collection of objects via an action.
`configure(object, configureClosure)` | 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.
`container(type)` | 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.
`container(type, factoryClosure)` | 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.
`container(type, factory)` | Creates a container for managing named objects of the specified type. The given factory is used to create object instances.
`copy(closure)` | Copies the specified files. The given closure is used to configure a `CopySpec`, which is then used to copy the files. Example:
`copy(action)` | Copies the specified files. The given action is used to configure a `CopySpec`, which is then used to copy the files.
`copySpec()` | Creates a `CopySpec` which can later be used to copy files or create an archive.
`copySpec(closure)` | 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.
`copySpec(action)` | Creates a `CopySpec` which can later be used to copy files or create an archive. The given action is used to configure the `CopySpec` before it is returned by this method.
`defaultTasks(defaultTasks)` | Sets the names of the default tasks of this project. These are used when no tasks names are provided when starting the build.
`delete(paths)` | Deletes files and directories.
`delete(action)` | Deletes the specified files. The given action is used to configure a `DeleteSpec`, which is then used to delete the files.
`dependencyLocking(configuration)` | Configures dependency locking
`evaluationDependsOn(path)` | Declares that this project has an evaluation dependency on the project with the given path.
`exec(closure)` | Executes an external command. The closure configures a `ExecSpec`.
`exec(action)` | Executes an external command.
`file(path)` | Resolves a file path relative to the project directory of this project. This method converts the supplied path based on its type:
`file(path, validation)` | 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.
`fileTree(baseDir)` | Creates a new `ConfigurableFileTree` using the given base directory. The given baseDir path is evaluated as per `Project.file(java.lang.Object)`.
`fileTree(baseDir, configureClosure)` | Creates a new `ConfigurableFileTree` using the given base directory. The given baseDir path is evaluated as per `Project.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:
`fileTree(baseDir, configureAction)` | Creates a new `ConfigurableFileTree` using the given base directory. The given baseDir path is evaluated as per `Project.file(java.lang.Object)`. The action will be used to configure the new file tree. Example:
`fileTree(args)` | Creates a new `ConfigurableFileTree` using the provided map of arguments. The map will be applied as properties on the new file tree. Example:
`files(paths, configureClosure)` | Creates a new `ConfigurableFileCollection` using the given paths. The paths are evaluated as per `Project.files(java.lang.Object[])`. The file collection is configured using the given closure. The file collection is passed to the closure as its delegate. Example:
`files(paths, configureAction)` | Creates a new `ConfigurableFileCollection` using the given paths. The paths are evaluated as per `Project.files(java.lang.Object[])`. The file collection is configured using the given action. Example:
`files(paths)` | Returns a `ConfigurableFileCollection` containing the given files. You can pass any of the following types to this method:
`findProject(path)` | Locates a project by path. If the path is relative, it is interpreted relative to this project.
`findProperty(propertyName)` | Returns the value of the given property or null if not found. This method locates a property as follows:
`getAllTasks(recursive)` | Returns a map of the tasks contained in this project, and optionally its subprojects.
`getTasksByName(name, recursive)` | 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.
`hasProperty(propertyName)` | Determines if this project has the given property. See here for details of the properties which are available for a project.
`javaexec(closure)` | Executes a Java main class. The closure configures a `JavaExecSpec`.
`javaexec(action)` | Executes an external Java process.
`mkdir(path)` | Creates a directory and returns a file pointing to it.
`normalization(configuration)` | Configures input normalization.
`project(path)` | Locates a project by path. If the path is relative, it is interpreted relative to this project.
`project(path, configureClosure)` | 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.
`project(path, configureAction)` | Locates a project by path and configures it using the given action. If the path is relative, it is interpreted relative to this project.
`property(propertyName)` | Returns the value of the given property. This method locates a property as follows:
`relativePath(path)` | Returns the relative path from the project directory to the given path. The given path object is (logically) resolved as described for `Project.file(java.lang.Object)`, from which a relative path is calculated.
`relativeProjectPath(path)` | Converts a name to a project path relative to this project.
`setProperty(name, value)` | 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.
`subprojects(action)` | Configures the sub-projects of this project
`sync(action)` | Synchronizes the contents of a destination directory with some source directories and files. The given action is used to configure a `CopySpec`, which is then used to synchronize the files.
`tarTree(tarPath)` | Creates a new `FileTree` which contains the contents of the given TAR file. The given tarPath path can be:
`task(name)` | Creates a `Task` with the given name and adds it to this project. Calling this method is equivalent to calling `Project.task(java.util.Map, java.lang.String)` with an empty options map.
`task(name, configureClosure)` | 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.
`task(name, configureAction)` | Creates a `Task` with the given name and adds it to this project. Before the task is returned, the given action is executed to configure the task.
`task(args, name)` | 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:
`task(args, name, configureClosure)` | 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(java.util.Map, java.lang.String)` for the available options.
`uri(path)` | 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(java.lang.Object)`, with the exception that any URI scheme is supported, not just 'file:' URIs.
`zipTree(zipPath)` | Creates a new `FileTree` which contains the contents of the given ZIP file. The given zipPath path is evaluated as per `Project.file(java.lang.Object)`. You can combine this method with the `Project.copy(groovy.lang.Closure)` method to unzip a ZIP file.

#### Methods added by the `ear` plugin

Method | Description
`appDirName(appDirName)` | Allows changing the application directory. Default is "src/main/application".
`deploymentDescriptor(configureAction)` | Configures the deployment descriptor for this EAR archive.
`libDirName(libDirName)` | Allows changing the library directory in the EAR file. Default is "lib".

#### Methods added by the `java` plugin

Method | Description
`disableAutoTargetJvm()` | If this method is called, Gradle will not automatically try to fetch dependencies which have a JVM version compatible with the target compatibility of this module.
`manifest()` | Creates a new instance of a `Manifest`.
`manifest(closure)` | Creates and configures a new instance of a `Manifest`. The given closure configures the new manifest instance before it is returned.
`manifest(action)` | Creates and configures a new instance of a `Manifest`.
`registerFeature(name, configureAction)` | Registers a feature.
`withJavadocJar()` | Incubating Adds a task `javadocJar` that will package the output of the `javadoc` task in a JAR with classifier `javadoc`.
`withSourcesJar()` | Incubating Adds a task `sourcesJar` that will package the Java sources of the main `SourceSet` in a JAR with classifier `sources`.

#### Methods added by the `maven` plugin

Method | Description
`pom()` | Creates a new `MavenPom`.
`pom(configureClosure)` | Creates and configures a new `MavenPom`. The given closure is executed to configure the new POM instance.
`pom(configureAction)` | Creates and configures a new `MavenPom`. The given action is executed to configure the new POM instance.

### Script blocks

Block | Description
`allprojects` | Configures this project and each of its sub-projects.
`ant` | 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()`
`artifacts` | Configures the published artifacts for this project.
`buildscript` | Configures the build script classpath for this project.
`configurations` | Configures the dependency configurations for this project.
`dependencies` | Configures the dependencies for this project.
`repositories` | Configures the repositories for this project.
`subprojects` | Configures the sub-projects of this project.

#### Script blocks added by the `application` plugin

Block | Description
`application` | Configures the `JavaApplication` added by the application plugin.

#### Script blocks added by the `checkstyle` plugin

Block | Description
`checkstyle` | Configures the `CheckstyleExtension` added by the checkstyle plugin.

#### Script blocks added by the `codenarc` plugin

Block | Description
`codenarc` | Configures the `CodeNarcExtension` added by the codenarc plugin.

#### Script blocks added by the `distribution` plugin

Block | Description
`distributions` | Configures the `DistributionContainer` added by the distribution plugin.

#### Script blocks added by the `ear` plugin

Block | Description
`deploymentDescriptor` | Configures the deployment descriptor for this EAR archive.

#### Script blocks added by the `eclipse` plugin

Block | Description
`eclipse` | Configures the `EclipseModel` added by the eclipse plugin.

#### Script blocks added by the `idea` plugin

Block | Description
`idea` | Configures the `IdeaModel` added by the idea plugin.

#### Script blocks added by the `jacoco` plugin

Block | Description
`jacoco` | Configures the `JacocoPluginExtension` added by the jacoco plugin.

#### Script blocks added by the `java` plugin

Block | Description
`reporting` | Configures the `ReportingExtension` added by the java plugin.
`sourceSets` | Configures the source sets of this project.

#### Script blocks added by the `pmd` plugin

Block | Description
`pmd` | Configures the `PmdExtension` added by the pmd plugin.

#### Script blocks added by the `publishing` plugin

Block | Description
`publishing` | Configures the `PublishingExtension` added by the publishing plugin.

#### Script blocks added by the `signing` plugin

Block | Description
`signing` | Configures the `SigningExtension` added by the signing plugin.

#### Script blocks added by the `visual-studio` plugin

Block | Description
`visualStudio` | Configures the `VisualStudioRootExtension` added by the visual-studio plugin.

#### Script blocks added by the `xcode` plugin

Block | Description
`xcode` | Configures the `XcodeRootExtension` added by the xcode plugin.

### Property details

#### ``Set`<`Project`>` `allprojects` (read-only)

The set containing this project and its subprojects.

#### `AntBuilder` `ant` (read-only)

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")
      }
    }

#### `ArtifactHandler` `artifacts` (read-only)

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

##### Examples:

See docs for `ArtifactHandler`

#### `File` `buildDir`

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`

#### `File` `buildFile` (read-only)

The build script for this project.

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

#### `ScriptHandler` `buildscript` (read-only)

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.

#### ``Map`<`String`, `Project`>` `childProjects` (read-only)

The direct children of this project.

#### `ConfigurationContainer` `configurations` (read-only)

The configurations of this project.

##### Examples:

See docs for `ConfigurationContainer`

#### `Convention` `convention` (read-only)

The `Convention` for this project.

You can access this property in your build file using `convention`. You 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

#### ``List`<`String`>` `defaultTasks`

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

#### `DependencyHandler` `dependencies` (read-only)

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.

##### Examples:

See docs for `DependencyHandler`

#### `DependencyLockingHandler` `dependencyLocking` (read-only)

Provides access to configuring dependency locking

#### `String` `description`

The description of this project, if any.

#### `ExtensionContainer` `extensions` (read-only)

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

#### `Gradle` `gradle` (read-only)

The `Gradle` invocation which this project belongs to.

#### `Object` `group`

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

#### `Logger` `logger` (read-only)

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

#### `LoggingManager` `logging` (read-only)

The `LoggingManager` which can be used to receive logging and to control the 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.

#### `String` `name` (read-only)

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.

#### `InputNormalizationHandler` `normalization` (read-only)

Provides access to configuring input normalization.

#### `Project` `parent` (read-only)

The parent project of this project, if any.

#### `String` `path` (read-only)

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

#### `PluginManager` `pluginManager` (read-only)

The plugin manager for this plugin aware object.

#### `PluginContainer` `plugins` (read-only)

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 the `PluginAware.getPluginManager()` than use the plugin container.

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

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

#### `Project` `project` (read-only)

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.

#### `File` `projectDir` (read-only)

The directory containing the project build file.

#### ``Map`<`String`, ?>` `properties` (read-only)

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

#### `RepositoryHandler` `repositories` (read-only)

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

#### `ResourceHandler` `resources` (read-only)

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

#### `File` `rootDir` (read-only)

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

#### `Project` `rootProject` (read-only)

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

#### `ProjectState` `state` (read-only)

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.

#### `Object` `status`

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.

#### ``Set`<`Project`>` `subprojects` (read-only)

The set containing the subprojects of this project.

#### `TaskContainer` `tasks` (read-only)

The tasks of this project.

#### `Object` `version`

The version of this project. Gradle always uses the `toString()` value of the version. The version defaults to `unspecified`.

#### `JavaApplication` `application` (read-only)

The `JavaApplication` added by the application plugin.

#### ``Iterable`<`String`>` `applicationDefaultJvmArgs`

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

#### `CopySpec` `applicationDistribution`

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.

#### `String` `applicationName`

The name of the application.

#### `String` `executableDir`

Directory to place executables in

#### `String` `mainClassName`

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

#### `CheckstyleExtension` `checkstyle` (read-only)

The `CheckstyleExtension` added by the checkstyle plugin.

#### `CodeNarcExtension` `codenarc` (read-only)

The `CodeNarcExtension` added by the codenarc plugin.

#### `DistributionContainer` `distributions` (read-only)

The `DistributionContainer` added by the distribution plugin.

#### `String` `appDirName`

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

#### `DeploymentDescriptor` `deploymentDescriptor`

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

#### ``Property`<`Boolean`>` `generateDeploymentDescriptor`

Note: This property is incubating and may change in a future version of Gradle.

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

#### `String` `libDirName`

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

#### `EclipseModel` `eclipse` (read-only)

The `EclipseModel` added by the eclipse plugin.

#### `IdeaModel` `idea` (read-only)

The `IdeaModel` added by the idea plugin.

#### `JacocoPluginExtension` `jacoco` (read-only)

The `JacocoPluginExtension` added by the jacoco plugin.

#### `String` `archivesBaseName`

The base name to use for archive files.

#### `File` `distsDir` (read-only)

Note: This property is deprecated and will be removed in the next major version of Gradle.

The directory to generate TAR and ZIP archives into.

This property has been replaced by distsDirectory.

#### `String` `distsDirName`

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

#### `DirectoryProperty` `distsDirectory`

The directory to generate TAR and ZIP archives into.

#### `File` `docsDir` (read-only)

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

#### `String` `docsDirName`

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

#### `File` `libsDir` (read-only)

Note: This property is deprecated and will be removed in the next major version of Gradle.

The directory to generate JAR and WAR archives into.

This property has been replaced by libsDirectory.

#### `String` `libsDirName`

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

#### `DirectoryProperty` `libsDirectory`

The directory to generate JAR and WAR archives into.

#### `ReportingExtension` `reporting` (read-only)

The `ReportingExtension` added by the java plugin.

#### `JavaVersion` `sourceCompatibility`

The source compatibility used for compiling Java sources.

#### `JavaVersion` `sourceCompatibility`

The source compatibility used for compiling Java sources.

#### `SourceSetContainer` `sourceSets` (read-only)

The source sets container.

#### `JavaVersion` `targetCompatibility`

The target compatibility used for compiling Java sources.

#### `JavaVersion` `targetCompatibility`

The target compatibility used for compiling Java sources.

#### `File` `testReportDir` (read-only)

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

#### `String` `testReportDirName`

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

#### `File` `testResultsDir` (read-only)

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

#### `String` `testResultsDirName`

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

#### `Conf2ScopeMappingContainer` `conf2ScopeMappings`

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

#### `File` `mavenPomDir`

The directory to generate Maven POMs into.

#### `PmdExtension` `pmd` (read-only)

The `PmdExtension` added by the pmd plugin.

#### `File` `projectReportDir` (read-only)

The directory to generate the project reports into.

#### `String` `projectReportDirName`

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

#### `PublishingExtension` `publishing` (read-only)

The `PublishingExtension` added by the publishing plugin.

#### `SigningExtension` `signing` (read-only)

The `SigningExtension` added by the signing plugin.

#### `VisualStudioRootExtension` `visualStudio` (read-only)

The `VisualStudioRootExtension` added by the visual-studio plugin.

#### `File` `webAppDir` (read-only)

The web application directory.

#### `String` `webAppDirName`

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

#### `XcodeRootExtension` `xcode` (read-only)

The `XcodeRootExtension` added by the xcode plugin.

### Method details

#### `String` `absoluteProjectPath`(`String` path)

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

#### `void` `afterEvaluate`(`Closure` closure)

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.

#### `void` `afterEvaluate`(``Action`<? super `Project`>` action)

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

#### `void` `allprojects`(``Action`<? super `Project`>` action)

Configures this project and each of its sub-projects.

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

#### `AntBuilder` `ant`(``Action`<? super `AntBuilder`>` configureAction)

Executes the given action against the `AntBuilder` for this project. You can use this in your build file to execute ant tasks. See example in javadoc for `Project.getAnt()`

#### `void` `apply`(`Closure` closure)

Applies zero or more plugins or scripts.

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

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

#### `void` `apply`(``Map`<`String`, ?>` options)

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 created `ObjectConfigurationAction`. That is, each key in the map is expected to be the name of a method `ObjectConfigurationAction` and the value to be compatible arguments to that method.

The following options are available:

- `from`: A script to apply. Accepts any path supported by `Project.uri(java.lang.Object)`.
- `plugin`: The id or implementation class of the plugin to apply.
- `to`: The target delegate object or objects. The default is this plugin aware object. Use this to configure objects other than this object.

#### `void` `apply`(``Action`<? super `ObjectConfigurationAction`>` action)

Applies zero or more plugins or scripts.

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

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

#### `void` `artifacts`(``Action`<? super `ArtifactHandler`>` configureAction)

Configures the published artifacts for this project.

This method executes the given action against the `ArtifactHandler` 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 configuration
    artifacts {
      //configuration name and the task:
      schema schemaJar
    }

#### `void` `beforeEvaluate`(`Closure` closure)

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

#### `void` `beforeEvaluate`(``Action`<? super `Project`>` action)

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

#### ``Iterable`<?>` `configure`(``Iterable`<?>` objects, `Closure` configureClosure)

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

#### ``Iterable`<`T`>` `configure`(``Iterable`<`T`>` objects, ``Action`<? super `T`>` configureAction)

Configures a collection of objects via an action.

#### `Object` `configure`(`Object` object, `Closure` configureClosure)

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() }

#### ``NamedDomainObjectContainer`<`T`>` `container`(``Class`<`T`>` type)

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.

#### ``NamedDomainObjectContainer`<`T`>` `container`(``Class`<`T`>` type, `Closure` factoryClosure)

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.

#### ``NamedDomainObjectContainer`<`T`>` `container`(``Class`<`T`>` type, ``NamedDomainObjectFactory`<`T`>` factory)

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.

#### `WorkResult` `copy`(`Closure` closure)

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.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'
       }
    }

#### `WorkResult` `copy`(``Action`<? super `CopySpec`>` action)

Copies the specified files. The given action is used to configure a `CopySpec`, which is then used to copy the files.

#### `CopySpec` `copySpec`()

Creates a `CopySpec` which can later be used to copy files or create an archive.

#### `CopySpec` `copySpec`(`Closure` closure)

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
    }

#### `CopySpec` `copySpec`(``Action`<? super `CopySpec`>` action)

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

#### `void` `defaultTasks`(``String`...` defaultTasks)

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

#### `boolean` `delete`(``Object`...` paths)

Deletes files and directories.

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

#### `WorkResult` `delete`(``Action`<? super `DeleteSpec`>` action)

Deletes the specified files. The given action is used to configure a `DeleteSpec`, which is then used to delete the files.

Example:

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

#### `void` `dependencyLocking`(``Action`<? super `DependencyLockingHandler`>` configuration)

Configures dependency locking

#### `Project` `evaluationDependsOn`(`String` path)

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

#### `ExecResult` `exec`(`Closure` closure)

Executes an external command. The closure configures a `ExecSpec`.

#### `ExecResult` `exec`(``Action`<? super `ExecSpec`>` action)

Executes an external command.

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

#### `File` `file`(`Object` path)

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

- A `CharSequence`, including `String` or `GString`. Interpreted relative to the project directory. A string that starts with `file:` is treated as a file URL.
- A `File`. If the file is an absolute file, it is returned as is. Otherwise, the file's path is interpreted relative to the project directory.
- A `Path`. The path must be associated with the default provider and is treated the same way as an instance of `File`.
- A `URI` or `URL`. The URL's path is interpreted as the file path. Only `file:` URLs are supported.
- A `Directory` or `RegularFile`.
- A `Provider` of any supported type. The provider's value is resolved recursively.
- A `TextResource`.
- A Groovy `Closure` or Kotlin function that returns any supported type. The closure's return value is resolved recursively.
- A `Callable` that returns any supported type. The callable's return value is resolved recursively.

#### `File` `file`(`Object` path, `PathValidation` validation)

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.

#### `ConfigurableFileTree` `fileTree`(`Object` baseDir)

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

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.

    def myTree = fileTree("src")
    myTree.include "**/*.java"
    myTree.builtBy "someTask"

    task copy(type: Copy) {
       from myTree
    }

#### `ConfigurableFileTree` `fileTree`(`Object` baseDir, `Closure` configureClosure)

Creates a new `ConfigurableFileTree` using the given base directory. The given baseDir path is evaluated as per `Project.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 are queried. The file tree is also live, so that it scans for files each time the contents of the file tree are queried.

#### `ConfigurableFileTree` `fileTree`(`Object` baseDir, ``Action`<? super `ConfigurableFileTree`>` configureAction)

Creates a new `ConfigurableFileTree` using the given base directory. The given baseDir path is evaluated as per `Project.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 are queried. The file tree is also live, so that it scans for files each time the contents of the file tree are queried.

#### `ConfigurableFileTree` `fileTree`(``Map`<`String`, ?>` args)

Creates a new `ConfigurableFileTree` using the provided map of arguments. The map will be applied as properties 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 are queried. The file tree is also live, so that it scans for files each time the contents of the file tree are queried.

#### `ConfigurableFileCollection` `files`(`Object` paths, `Closure` configureClosure)

Creates a new `ConfigurableFileCollection` using the given paths. The paths are evaluated as per `Project.files(java.lang.Object[])`. 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.

#### `ConfigurableFileCollection` `files`(`Object` paths, ``Action`<? super `ConfigurableFileCollection`>` configureAction)

Creates a new `ConfigurableFileCollection` using the given paths. The paths are evaluated as per `Project.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 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.

#### `ConfigurableFileCollection` `files`(``Object`...` paths)

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

- A `CharSequence`, including `String` or `GString`. Interpreted relative to the project directory, as per `Project.file(java.lang.Object)`. A string that starts with `file:` is treated as a file URL.
- A `File`. Interpreted relative to the project directory, as per `Project.file(java.lang.Object)`.
- A `Path`, as per `Project.file(java.lang.Object)`.
- A `URI` or `URL`. The URL's path is interpreted as a file path. Only `file:` URLs are supported.
- A `Directory` or `RegularFile`.
- A `Collection`, `Iterable`, or an array that contains objects of any supported type. The elements of the collection are recursively converted to files.
- A `FileCollection`. The contents of the collection are included in the returned collection.
- A `FileTree` or `DirectoryTree`. The contents of the tree are included in the returned collection.
- A `Provider` of any supported type. The provider's value is recursively converted to files. If the provider represents an output of a task, that task is executed if the file collection is used as an input to another task.
- A `Callable` that returns any supported type. The return value of the `call()` method is recursively converted to files. A `null` return value is treated as an empty collection.
- A Groovy `Closure` or Kotlin function that returns any of the types listed here. The return value of the closure is recursively converted to files. A `null` return value is treated as an empty collection.
- A `Task`. Converted to the task's output files. The task is executed if the file collection is used as an input to another task.
- A `TaskOutputs`. Converted to the output files the related task. The task is executed if the file collection is used as an input to another task.
- Anything else is treated as an error.

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.

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.

#### `Project` `findProject`(`String` path)

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

#### `Object` `findProperty`(`String` propertyName)

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

1. If this project object has a property with the given name, return the value of the property.
2. If this project has an extension with the given name, return the extension.
3. If this project's convention object has a property with the given name, return the value of the property.
4. If this project has an extra property with the given name, return the value of the property.
5. If this project has a task with the given name, return the task.
6. Search up through this project's ancestor projects for a convention property or extra property with the given name.
7. If not found, null value is returned.

#### ``Map`<`Project`, `Set`<`Task`>>` `getAllTasks`(`boolean` recursive)

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

#### ``Set`<`Task`>` `getTasksByName`(`String` name, `boolean` recursive)

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.

#### `boolean` `hasProperty`(`String` propertyName)

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

#### `ExecResult` `javaexec`(`Closure` closure)

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

#### `ExecResult` `javaexec`(``Action`<? super `JavaExecSpec`>` action)

Executes an external Java process.

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

#### `File` `mkdir`(`Object` path)

Creates a directory and returns a file pointing to it.

#### `void` `normalization`(``Action`<? super `InputNormalizationHandler`>` configuration)

Configures input normalization.

#### `Project` `project`(`String` path)

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

#### `Project` `project`(`String` path, `Closure` configureClosure)

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.

#### `Project` `project`(`String` path, ``Action`<? super `Project`>` configureAction)

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

#### `Object` `property`(`String` propertyName)

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

1. If this project object has a property with the given name, return the value of the property.
2. If this project has an extension with the given name, return the extension.
3. If this project's convention object has a property with the given name, return the value of the property.
4. If this project has an extra property with the given name, return the value of the property.
5. If this project has a task with the given name, return the task.
6. Search up through this project's ancestor projects for a convention property or extra property with the given name.
7. If not found, a `MissingPropertyException` is thrown.

#### `String` `relativePath`(`Object` path)

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

#### `String` `relativeProjectPath`(`String` path)

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

#### `void` `setProperty`(`String` name, `Object` value)

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.

1. The project object itself. For example, the `rootDir` project property.
2. The project's `Convention` object. For example, the `srcRootName` java plugin property.
3. The project's extra properties.

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

#### `void` `subprojects`(``Action`<? super `Project`>` action)

Configures the sub-projects of this project

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

#### `WorkResult` `sync`(``Action`<? super `CopySpec`>` action)

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

This method is like the `Project.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'
        }
    }

#### `FileTree` `tarTree`(`Object` tarPath)

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

- an instance of `Resource`
- any other object is evaluated as per `Project.file(java.lang.Object)`

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(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'
    }

#### `Task` `task`(`String` name)

Creates a `Task` with the given name and adds it to this project. Calling this method is equivalent to calling `Project.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 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.

#### `Task` `task`(`String` name, `Closure` configureClosure)

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

#### `Task` `task`(`String` name, ``Action`<? super `Task`>` configureAction)

Creates a `Task` with the given name and adds it to this project. Before the task is returned, the given action 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

#### `Task` `task`(``Map`<`String`, ?>` args, `String` name)

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:

Option | Description | Default Value
``type`` | The class of the task to create. | `DefaultTask`
``overwrite`` | Replace an existing task? | `false`
``dependsOn`` | A task name or set of task names which this task depends on | `[]`
``action`` | A closure or `Action` to add to the task. | `null`
``description`` | A description of the task. | `null`
``group`` | A task group which this task belongs to. | `null`

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.

#### `Task` `task`(``Map`<`String`, ?>` args, `String` name, `Closure` configureClosure)

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(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 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.

#### `URI` `uri`(`Object` path)

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(java.lang.Object)`, with the exception that any URI scheme is supported, not just 'file:' URIs.

#### `FileTree` `zipTree`(`Object` zipPath)

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

#### `void` `appDirName`(`String` appDirName)

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

#### `EarPluginConvention` `deploymentDescriptor`(``Action`<? super `DeploymentDescriptor`>` configureAction)

Configures the deployment descriptor for this EAR archive.

The given action is executed to configure the deployment descriptor.

#### `void` `libDirName`(`String` libDirName)

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

#### `void` `disableAutoTargetJvm`()

If this method is called, Gradle will not automatically try to fetch dependencies which have a JVM version compatible with the target compatibility of this module.

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

#### `Manifest` `manifest`()

Creates a new instance of a `Manifest`.

#### `Manifest` `manifest`(`Closure` closure)

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

#### `Manifest` `manifest`(``Action`<? super `Manifest`>` action)

Creates and configures a new instance of a `Manifest`.

#### `void` `registerFeature`(`String` name, ``Action`<? super `FeatureSpec`>` configureAction)

Registers a feature.

#### `void` `withJavadocJar`()

Note: This method is incubating and may change in a future version of Gradle.

Adds a task `javadocJar` that will package the output of the `javadoc` task in a JAR with classifier `javadoc`.

The produced artifact is registered as a documentation variant on the `java` component and added as a dependency on the `assemble` task. This means that if `maven-publish` or `ivy-publish` is also applied, the javadoc JAR will be published.

If the project already has a task named `javadocJar` then no task is created.

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

#### `void` `withSourcesJar`()

Note: This method is incubating and may change in a future version of Gradle.

Adds a task `sourcesJar` that will package the Java sources of the main `SourceSet` in a JAR with classifier `sources`.

The produced artifact is registered as a documentation variant on the `java` component and added as a dependency on the `assemble` task. This means that if `maven-publish` or `ivy-publish` is also applied, the sources JAR will be published.

If the project already has a task named `sourcesJar` then no task is created.

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

#### `MavenPom` `pom`()

Creates a new `MavenPom`.

#### `MavenPom` `pom`(`Closure` configureClosure)

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

#### `MavenPom` `pom`(``Action`<? super `MavenPom`>` configureAction)

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

### Script block details

#### `allprojects` { }

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.

Delegates to:
  Each `Project` in `allprojects`

#### `ant` { }

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()`

Delegates to:
  `AntBuilder` from `ant`

#### `artifacts` { }

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
    }

Delegates to:
  `ArtifactHandler` from `artifacts`

#### `buildscript` { }

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.

Delegates to:
  `ScriptHandler` from `buildscript`

#### `configurations` { }

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.

##### Examples:

See docs for `ConfigurationContainer`

Delegates to:
  `ConfigurationContainer` from `configurations`

#### `dependencies` { }

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.

##### Examples:

See docs for `DependencyHandler`

Delegates to:
  `DependencyHandler` from `dependencies`

#### `repositories` { }

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.

Delegates to:
  `RepositoryHandler` from `repositories`

#### `subprojects` { }

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.

Delegates to:
  Each `Project` in `subprojects`

#### `application` { }

Configures the `JavaApplication` added by the application plugin.

Delegates to:
  `JavaApplication` from `application`

#### `checkstyle` { }

Configures the `CheckstyleExtension` added by the checkstyle plugin.

Delegates to:
  `CheckstyleExtension` from `checkstyle`

#### `codenarc` { }

Configures the `CodeNarcExtension` added by the codenarc plugin.

Delegates to:
  `CodeNarcExtension` from `codenarc`

#### `distributions` { }

Configures the `DistributionContainer` added by the distribution plugin.

Delegates to:
  `DistributionContainer` from `distributions`

#### `deploymentDescriptor` { }

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.

Delegates to:
  `DeploymentDescriptor` from `deploymentDescriptor`

#### `eclipse` { }

Configures the `EclipseModel` added by the eclipse plugin.

Delegates to:
  `EclipseModel` from `eclipse`

#### `idea` { }

Configures the `IdeaModel` added by the idea plugin.

Delegates to:
  `IdeaModel` from `idea`

#### `jacoco` { }

Configures the `JacocoPluginExtension` added by the jacoco plugin.

Delegates to:
  `JacocoPluginExtension` from `jacoco`

#### `reporting` { }

Configures the `ReportingExtension` added by the java plugin.

Delegates to:
  `ReportingExtension` from `reporting`

#### `sourceSets` { }

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

Delegates to:
  `SourceSetContainer` from `sourceSets`

#### `pmd` { }

Configures the `PmdExtension` added by the pmd plugin.

Delegates to:
  `PmdExtension` from `pmd`

#### `publishing` { }

Configures the `PublishingExtension` added by the publishing plugin.

Delegates to:
  `PublishingExtension` from `publishing`

#### `signing` { }

Configures the `SigningExtension` added by the signing plugin.

Delegates to:
  `SigningExtension` from `signing`

#### `visualStudio` { }

Configures the `VisualStudioRootExtension` added by the visual-studio plugin.

Delegates to:
  `VisualStudioRootExtension` from `visualStudio`

#### `xcode` { }

Configures the `XcodeRootExtension` added by the xcode plugin.

Delegates to:
  `XcodeRootExtension` from `xcode`