Gradle User Guide

Version 2.4

Copyright © 2007-2015 Hans Dockter, Adam Murdoch

Copies of this document may be made for your own use and for distribution to others, provided that you do not charge any fee for such copies and further provided that each copy contains this Copyright Notice, whether distributed in print or electronically.

Table of Contents

1. Introduction

1.1. About this user guide

2. Overview

2.1. Features
2.2. Why Groovy?

3. Tutorials

3.1. Getting Started

4. Installing Gradle

4.1. Prerequisites
4.2. Download
4.3. Unpacking
4.4. Environment variables
4.5. Running and testing your installation
4.6. JVM options

5. Troubleshooting

5.1. Working through problems
5.2. Getting help

6. Build Script Basics

6.1. Projects and tasks
6.2. Hello world
6.3. A shortcut task definition
6.4. Build scripts are code
6.5. Task dependencies
6.6. Dynamic tasks
6.7. Manipulating existing tasks
6.8. Shortcut notations
6.9. Extra task properties
6.10. Using Ant Tasks
6.11. Using methods
6.12. Default tasks
6.13. Configure by DAG
6.14. Where to next?

7. Java Quickstart

7.1. The Java plugin
7.2. A basic Java project
7.3. Multi-project Java build
7.4. Where to next?

8. Dependency Management Basics

8.1. What is dependency management?
8.2. Declaring your dependencies
8.3. Dependency configurations
8.4. External dependencies
8.5. Repositories
8.6. Publishing artifacts
8.7. Where to next?

9. Groovy Quickstart

9.1. A basic Groovy project
9.2. Summary

10. Web Application Quickstart

10.1. Building a WAR file
10.2. Running your web application
10.3. Summary

11. Using the Gradle Command-Line

11.1. Executing multiple tasks
11.2. Excluding tasks
11.3. Continuing the build when a failure occurs
11.4. Task name abbreviation
11.5. Selecting which build to execute
11.6. Obtaining information about your build
11.7. Dry Run
11.8. Summary

12. Using the Gradle Graphical User Interface

12.1. Task Tree
12.2. Favorites
12.3. Command Line
12.4. Setup

13. Writing Build Scripts

13.1. The Gradle build language
13.2. The Project API
13.3. The Script API
13.4. Declaring variables
13.5. Configuring arbitrary objects
13.6. Configuring arbitrary objects using an external script
13.7. Some Groovy basics

14. More about Tasks

14.1. Defining tasks
14.2. Locating tasks
14.3. Configuring tasks
14.4. Adding dependencies to a task
14.5. Ordering tasks
14.6. Adding a description to a task
14.7. Replacing tasks
14.8. Skipping tasks
14.9. Skipping tasks that are up-to-date
14.10. Task rules
14.11. Finalizer tasks
14.12. Summary

15. Working With Files

15.1. Locating files
15.2. File collections
15.3. File trees
15.4. Using the contents of an archive as a file tree
15.5. Specifying a set of input files
15.6. Copying files
15.7. Using the Sync task
15.8. Creating archives

16. Using Ant from Gradle

16.1. Using Ant tasks and types in your build
16.2. Importing an Ant build
16.3. Ant properties and references
16.4. API

17. Logging

17.1. Choosing a log level
17.2. Writing your own log messages
17.3. Logging from external tools and libraries
17.4. Changing what Gradle logs

18. The Gradle Daemon

18.1. What is the Gradle Daemon?
18.2. Management and configuration
18.3. When should I not use the Gradle Daemon?
18.4. Tools & IDEs
18.5. How does the Gradle Daemon make builds faster?

19. The Build Environment

19.1. Configuring the build environment via gradle.properties
19.2. Gradle properties and system properties
19.3. Accessing the web via a proxy

20. Gradle Plugins

20.1. What plugins do
20.2. Types of plugins
20.3. Applying plugins
20.4. Applying plugins with the buildscript block
20.5. Applying plugins with the plugins DSL
20.6. Finding community plugins
20.7. More on plugins

21. Standard Gradle plugins

21.1. Language plugins
21.2. Incubating language plugins
21.3. Integration plugins
21.4. Incubating integration plugins
21.5. Software development plugins
21.6. Incubating software development plugins
21.7. Base plugins
21.8. Third party plugins

22. The Java Plugin

22.1. Usage
22.2. Source sets
22.3. Tasks
22.4. Project layout
22.5. Dependency management
22.6. Convention properties
22.7. Working with source sets
22.8. Javadoc
22.9. Clean
22.10. Resources
22.11. CompileJava
22.12. Incremental Java compilation
22.13. Test
22.14. Jar
22.15. Uploading

23. The Groovy Plugin

23.1. Usage
23.2. Tasks
23.3. Project layout
23.4. Dependency management
23.5. Automatic configuration of groovyClasspath
23.6. Convention properties
23.7. Source set properties
23.8. GroovyCompile

24. The Scala Plugin

24.1. Usage
24.2. Tasks
24.3. Project layout
24.4. Dependency management
24.5. Automatic configuration of scalaClasspath
24.6. Convention properties
24.7. Source set properties
24.8. Fast Scala Compiler
24.9. Compiling in external process
24.10. Incremental compilation
24.11. Eclipse Integration
24.12. IntelliJ IDEA Integration

25. The War Plugin

25.1. Usage
25.2. Tasks
25.3. Project layout
25.4. Dependency management
25.5. Convention properties
25.6. War
25.7. Customizing

26. The Ear Plugin

26.1. Usage
26.2. Tasks
26.3. Project layout
26.4. Dependency management
26.5. Convention properties
26.6. Ear
26.7. Customizing
26.8. Using custom descriptor file

27. The Jetty Plugin

27.1. Usage
27.2. Tasks
27.3. Project layout
27.4. Dependency management
27.5. Convention properties

28. The Checkstyle Plugin

28.1. Usage
28.2. Tasks
28.3. Project layout
28.4. Dependency management
28.5. Configuration

29. The CodeNarc Plugin

29.1. Usage
29.2. Tasks
29.3. Project layout
29.4. Dependency management
29.5. Configuration

30. The FindBugs Plugin

30.1. Usage
30.2. Tasks
30.3. Dependency management
30.4. Configuration

31. The JDepend Plugin

31.1. Usage
31.2. Tasks
31.3. Dependency management
31.4. Configuration

32. The PMD Plugin

32.1. Usage
32.2. Tasks
32.3. Dependency management
32.4. Configuration

33. The JaCoCo Plugin

33.1. Getting Started
33.2. Configuring the JaCoCo Plugin
33.3. JaCoCo Report configuration
33.4. JaCoCo specific task configuration
33.5. Tasks
33.6. Dependency management

34. The Sonar Plugin

34.1. Usage
34.2. Analyzing Multi-Project Builds
34.3. Analyzing Custom Source Sets
34.4. Analyzing languages other than Java
34.5. Setting Custom Sonar Properties
34.6. Configuring Sonar Settings from the Command Line
34.7. Tasks

35. The Sonar Runner Plugin

35.1. Sonar Runner version and compatibility
35.2. Getting started
35.3. Configuring the Sonar Runner
35.4. Specifying the Sonar Runner version
35.5. Analyzing Multi-Project Builds
35.6. Analyzing Custom Source Sets
35.7. Analyzing languages other than Java
35.8. More on configuring Sonar properties
35.9. Setting Sonar Properties from the Command Line
35.10. Controlling the Sonar Runner process
35.11. Tasks

36. The OSGi Plugin

36.1. Usage
36.2. Implicitly applied plugins
36.3. Tasks
36.4. Dependency management
36.5. Convention object
36.6.

37. The Eclipse Plugins

37.1. Usage
37.2. Tasks
37.3. Configuration
37.4. Customizing the generated files

38. The IDEA Plugin

38.1. Usage
38.2. Tasks
38.3. Configuration
38.4. Customizing the generated files
38.5. Further things to consider

39. The ANTLR Plugin

39.1. Usage
39.2. Tasks
39.3. Project layout
39.4. Dependency management
39.5. Convention properties
39.6. Source set properties
39.7. Controlling the ANTLR generator process

40. The Project Report Plugin

40.1. Usage
40.2. Tasks
40.3. Project layout
40.4. Dependency management
40.5. Convention properties

41. The Announce Plugin

41.1. Usage
41.2. Configuration

42. The Build Announcements Plugin

42.1. Usage

43. The Distribution Plugin

43.1. Usage
43.2. Tasks
43.3. Distribution contents
43.4. Publishing distributions

44. The Application Plugin

44.1. Usage
44.2. Tasks
44.3. Convention properties

45. The Java Library Distribution Plugin

45.1. Usage
45.2. Tasks
45.3. Including other resources in the distribution

46. Build Init Plugin

46.1. Tasks
46.2. What to set up
46.3. Build init types

47. Wrapper Plugin

47.1. Usage
47.2. Tasks

48. The Build Dashboard Plugin

48.1. Usage
48.2. Tasks
48.3. Project layout
48.4. Dependency management
48.5. Configuration

49. The Java Gradle Plugin Development Plugin

49.1. Usage

50. Dependency Management

50.1. Introduction
50.2. Dependency Management Best Practices
50.3. Dependency configurations
50.4. How to declare your dependencies
50.5. Working with dependencies
50.6. Repositories
50.7. How dependency resolution works
50.8. Fine-tuning the dependency resolution process
50.9. The dependency cache
50.10. Strategies for transitive dependency management

51. Publishing artifacts

51.1. Introduction
51.2. Artifacts and configurations
51.3. Declaring artifacts
51.4. Publishing artifacts
51.5. More about project libraries

52. The Maven Plugin

52.1. Usage
52.2. Tasks
52.3. Dependency management
52.4. Convention properties
52.5. Convention methods
52.6. Interacting with Maven repositories

53. The Signing Plugin

53.1. Usage
53.2. Signatory credentials
53.3. Specifying what to sign
53.4. Publishing the signatures
53.5. Signing POM files

54. Building native binaries

54.1. Supported languages
54.2. Tool chain support
54.3. Tool chain installation
54.4. Component model
54.5. Parallel Compilation
54.6. Building a library
54.7. Building an executable
54.8. Tasks
54.9. Finding out more about your project
54.10. Language support
54.11. Configuring the compiler, assembler and linker
54.12. Windows Resources
54.13. Library Dependencies
54.14. Native Binary Variants
54.15. Tool chains
54.16. Visual Studio IDE integration
54.17. CUnit support
54.18. GoogleTest support

55. The Build Lifecycle

55.1. Build phases
55.2. Settings file
55.3. Multi-project builds
55.4. Initialization
55.5. Configuration and execution of a single project build
55.6. Responding to the lifecycle in the build script

56. Multi-project Builds

56.1. Cross project configuration
56.2. Subproject configuration
56.3. Execution rules for multi-project builds
56.4. Running tasks by their absolute path
56.5. Project and task paths
56.6. Dependencies - Which dependencies?
56.7. Project lib dependencies
56.8. Parallel project execution
56.9. Decoupled Projects
56.10. Multi-Project Building and Testing
56.11. Multi Project and buildSrc
56.12. Property and method inheritance
56.13. Summary

57. Writing Custom Task Classes

57.1. Packaging a task class
57.2. Writing a simple task class
57.3. A standalone project
57.4. Incremental tasks

58. Writing Custom Plugins

58.1. Packaging a plugin
58.2. Writing a simple plugin
58.3. Getting input from the build
58.4. Working with files in custom tasks and plugins
58.5. A standalone project
58.6. Maintaining multiple domain objects

59. Organizing Build Logic

59.1. Inherited properties and methods
59.2. Injected configuration
59.3. Configuring the project using an external build script
59.4. Build sources in the buildSrc project
59.5. Running another Gradle build from a build
59.6. External dependencies for the build script
59.7. Ant optional dependencies
59.8. Summary

60. Initialization Scripts

60.1. Basic usage
60.2. Using an init script
60.3. Writing an init script
60.4. External dependencies for the init script
60.5. Init script plugins

61. The Gradle Wrapper

61.1. Configuration
61.2. Unix file permissions

62. Embedding Gradle

62.1. Introduction to the Tooling API
62.2. Tooling API and the Gradle Build Daemon
62.3. Quickstart

63. Comparing Builds

63.1. Definition of terms
63.2. Current Capabilities
63.3. Comparing Gradle Builds

64. Ivy Publishing (new)

64.1. The “ivy-publish” Plugin
64.2. Publications
64.3. Repositories
64.4. Performing a publish
64.5. Generating the Ivy module descriptor file without publishing
64.6. Complete example
64.7. Future features

65. Maven Publishing (new)

65.1. The “maven-publish” Plugin
65.2. Publications
65.3. Repositories
65.4. Performing a publish
65.5. Publishing to Maven Local
65.6. Generating the POM file without publishing

66. Rule based model configuration

66.1. Background
66.2. Motivations for change
66.3. Concepts
66.4. Rule sources
66.5. The “model DSL”
66.6. The model report
66.7. Limitations and future direction

A. Gradle Samples

A.1. Sample customBuildLanguage
A.2. Sample customDistribution
A.3. Sample customPlugin
A.4. Sample java/multiproject

B. Potential Traps

B.1. Groovy script variables
B.2. Configuration and execution phase

C. The Feature Lifecycle

C.1. States
C.2. Backwards Compatibility Policy

D. Gradle Command Line

D.1. Deprecated command-line options
D.2. Daemon command-line options
D.3. System properties
D.4. Environment variables

E. Existing IDE Support and how to cope without it

E.1. IntelliJ
E.2. Eclipse
E.3. Using Gradle without IDE support

List of Examples

6.1. Your first build script
6.2. Execution of a build script
6.3. A task definition shortcut
6.4. Using Groovy in Gradle's tasks
6.5. Using Groovy in Gradle's tasks
6.6. Declaration of task that depends on other task
6.7. Lazy dependsOn - the other task does not exist (yet)
6.8. Dynamic creation of a task
6.9. Accessing a task via API - adding a dependency
6.10. Accessing a task via API - adding behaviour
6.11. Accessing task as a property of the build script
6.12. Adding extra properties to a task
6.13. Using AntBuilder to execute ant.loadfile target
6.14. Using methods to organize your build logic
6.15. Defining a default tasks
6.16. Different outcomes of build depending on chosen tasks
7.1. Using the Java plugin
7.2. Building a Java project
7.3. Adding Maven repository
7.4. Adding dependencies
7.5. Customization of MANIFEST.MF
7.6. Adding a test system property
7.7. Publishing the JAR file
7.8. Eclipse plugin
7.9. Java example - complete build file
7.10. Multi-project build - hierarchical layout
7.11. Multi-project build - settings.gradle file
7.12. Multi-project build - common configuration
7.13. Multi-project build - dependencies between projects
7.14. Multi-project build - distribution file
8.1. Declaring dependencies
8.2. Definition of an external dependency
8.3. Shortcut definition of an external dependency
8.4. Usage of Maven central repository
8.5. Usage of a remote Maven repository
8.6. Usage of a remote Ivy directory
8.7. Usage of a local Ivy directory
8.8. Publishing to an Ivy repository
8.9. Publishing to a Maven repository
9.1. Groovy plugin
9.2. Dependency on Groovy
9.3. Groovy example - complete build file
10.1. War plugin
10.2. Running web application with Jetty plugin
11.1. Executing multiple tasks
11.2. Excluding tasks
11.3. Abbreviated task name
11.4. Abbreviated camel case task name
11.5. Selecting the project using a build file
11.6. Selecting the project using project directory
11.7. Obtaining information about projects
11.8. Providing a description for a project
11.9. Obtaining information about tasks
11.10. Changing the content of the task report
11.11. Obtaining more information about tasks
11.12. Obtaining detailed help for tasks
11.13. Obtaining information about dependencies
11.14. Filtering dependency report by configuration
11.15. Getting the insight into a particular dependency
11.16. Information about properties
12.1. Launching the GUI
13.1. Accessing property of the Project object
13.2. Using local variables
13.3. Using extra properties
13.4. Configuring arbitrary objects
13.5. Configuring arbitrary objects using a script
13.6. Groovy JDK methods
13.7. Property accessors
13.8. Method call without parentheses
13.9. List and map literals
13.10. Closure as method parameter
13.11. Closure delegates
14.1. Defining tasks
14.2. Defining tasks - using strings for task names
14.3. Defining tasks with alternative syntax
14.4. Accessing tasks as properties
14.5. Accessing tasks via tasks collection
14.6. Accessing tasks by path
14.7. Creating a copy task
14.8. Configuring a task - various ways
14.9. Configuring a task - with closure
14.10. Defining a task with closure
14.11. Adding dependency on task from another project
14.12. Adding dependency using task object
14.13. Adding dependency using closure
14.14. Adding a 'must run after' task ordering
14.15. Adding a 'should run after' task ordering
14.16. Task ordering does not imply task execution
14.17. A 'should run after' task ordering is ignored if it introduces an ordering cycle
14.18. Adding a description to a task
14.19. Overwriting a task
14.20. Skipping a task using a predicate
14.21. Skipping tasks with StopExecutionException
14.22. Enabling and disabling tasks
14.23. A generator task
14.24. Declaring the inputs and outputs of a task
14.25. Task rule
14.26. Dependency on rule based tasks
14.27. Adding a task finalizer
14.28. Task finalizer for a failing task
15.1. Locating files
15.2. Creating a file collection
15.3. Using a file collection
15.4. Implementing a file collection
15.5. Creating a file tree
15.6. Using a file tree
15.7. Using an archive as a file tree
15.8. Specifying a set of files
15.9. Specifying a set of files
15.10. Copying files using the copy task
15.11. Specifying copy task source files and destination directory
15.12. Selecting the files to copy
15.13. Copying files using the copy() method without up-to-date check
15.14. Copying files using the copy() method with up-to-date check
15.15. Renaming files as they are copied
15.16. Filtering files as they are copied
15.17. Nested copy specs
15.18. Using the Sync task to copy dependencies
15.19. Creating a ZIP archive
15.20. Creation of ZIP archive
15.21. Configuration of archive task - custom archive name
15.22. Configuration of archive task - appendix & classifier
16.1. Using an Ant task
16.2. Passing nested text to an Ant task
16.3. Passing nested elements to an Ant task
16.4. Using an Ant type
16.5. Using a custom Ant task
16.6. Declaring the classpath for a custom Ant task
16.7. Using a custom Ant task and dependency management together
16.8. Importing an Ant build
16.9. Task that depends on Ant target
16.10. Adding behaviour to an Ant target
16.11. Ant target that depends on Gradle task
16.12. Renaming imported Ant targets
16.13. Setting an Ant property
16.14. Getting an Ant property
16.15. Setting an Ant reference
16.16. Getting an Ant reference
17.1. Using stdout to write log messages
17.2. Writing your own log messages
17.3. Using SLF4J to write log messages
17.4. Configuring standard output capture
17.5. Configuring standard output capture for a task
17.6. Customizing what Gradle logs
19.1. Setting properties with a gradle.properties file
19.2. Configuring an HTTP proxy
19.3. Configuring an HTTPS proxy
20.1. Applying a script plugin
20.2. Applying a binary plugin
20.3. Applying a binary plugin by type
20.4. Applying a plugin with the buildscript block
20.5. Applying a core plugin
20.6. Applying a community plugin
22.1. Using the Java plugin
22.2. Custom Java source layout
22.3. Accessing a source set
22.4. Configuring the source directories of a source set
22.5. Defining a source set
22.6. Defining source set dependencies
22.7. Compiling a source set
22.8. Assembling a JAR for a source set
22.9. Generating the Javadoc for a source set
22.10. Running tests in a source set
22.11. Filtering tests in the build script
22.12. JUnit Categories
22.13. Grouping TestNG tests
22.14. Creating a unit test report for subprojects
22.15. Customization of MANIFEST.MF
22.16. Creating a manifest object.
22.17. Separate MANIFEST.MF for a particular archive
22.18. Separate MANIFEST.MF for a particular archive
23.1. Using the Groovy plugin
23.2. Custom Groovy source layout
23.3. Configuration of Groovy dependency
23.4. Configuration of Groovy test dependency
23.5. Configuration of bundled Groovy dependency
23.6. Configuration of Groovy file dependency
24.1. Using the Scala plugin
24.2. Custom Scala source layout
24.3. Declaring a Scala dependency for production code
24.4. Declaring a Scala dependency for test code
24.5. Enabling the Fast Scala Compiler
24.6. Adjusting memory settings
24.7. Activating the Zinc based compiler
25.1. Using the War plugin
25.2. Customization of war plugin
26.1. Using the Ear plugin
26.2. Customization of ear plugin
27.1. Using the Jetty plugin
28.1. Using the Checkstyle plugin
29.1. Using the CodeNarc plugin
30.1. Using the FindBugs plugin
31.1. Using the JDepend plugin
32.1. Using the PMD plugin
33.1. Applying the JaCoCo plugin
33.2. Configuring JaCoCo plugin settings
33.3. Configuring test task
33.4. Configuring test task
33.5. Using application plugin to generate code coverage data
33.6. Coverage reports generated by applicationCodeCoverageReport
34.1. Applying the Sonar plugin
34.2. Configuring Sonar connection settings
34.3. Configuring Sonar project settings
34.4. Global configuration in a multi-project build
34.5. Common project configuration in a multi-project build
34.6. Individual project configuration in a multi-project build
34.7. Configuring the language to be analyzed
34.8. Using property syntax
34.9. Analyzing custom source sets
34.10. Analyzing languages other than Java
34.11. Setting custom global properties
34.12. Setting custom project properties
34.13. Implementing custom command line properties
35.1. Applying the Sonar Runner plugin
35.2. Configuring Sonar connection settings
35.3. Configuring Sonar runner version
35.4. Global configuration settings
35.5. Shared configuration settings
35.6. Individual configuration settings
35.7. Skipping analysis of a project
35.8. Analyzing custom source sets
35.9. Analyzing languages other than Java
35.10. setting custom Sonar Runner fork options
36.1. Using the OSGi plugin
36.2. Configuration of OSGi MANIFEST.MF file
37.1. Using the Eclipse plugin
37.2. Using the Eclipse WTP plugin
37.3. Partial Overwrite for Classpath
37.4. Partial Overwrite for Project
37.5. Export Dependencies
37.6. Customizing the XML
38.1. Using the IDEA plugin
38.2. Partial Rewrite for Module
38.3. Partial Rewrite for Project
38.4. Export Dependencies
38.5. Customizing the XML
39.1. Using the ANTLR plugin
39.2. Declare ANTLR version
39.3. setting custom max heap size for ANTLR
41.1. Using the announce plugin
41.2. Configure the announce plugin
41.3. Using the announce plugin
42.1. Using the build announcements plugin
42.2. Using the build announcements plugin from an init script
43.1. Using the distribution plugin
43.2. Adding extra distributions
43.3. Configuring the main distribution
43.4. publish main distribution
44.1. Using the application plugin
44.2. Configure the application main class
44.3. Configure default JVM settings
44.4. Include output from other tasks in the application distribution
44.5. Automatically creating files for distribution
45.1. Using the Java library distribution plugin
45.2. Configure the distribution name
45.3. Include files in the distribution
48.1. Using the Build Dashboard plugin
49.1. Using the Java Gradle Plugin Development plugin
50.1. Definition of a configuration
50.2. Accessing a configuration
50.3. Configuration of a configuration
50.4. Module dependencies
50.5. Artifact only notation
50.6. Dependency with classifier
50.7. Iterating over a configuration
50.8. Client module dependencies - transitive dependencies
50.9. Project dependencies
50.10. File dependencies
50.11. Generated file dependencies
50.12. Gradle API dependencies
50.13. Gradle's Groovy dependencies
50.14. Excluding transitive dependencies
50.15. Optional attributes of dependencies
50.16. Collections and arrays of dependencies
50.17. Dependency configurations
50.18. Dependency configurations for project
50.19. Configuration.copy
50.20. Accessing declared dependencies
50.21. Configuration.files
50.22. Configuration.files with spec
50.23. Configuration.copy
50.24. Configuration.copy vs. Configuration.files
50.25. Declaring a Maven and Ivy repository
50.26. Providing credentials to a Maven and Ivy repository
50.27. Declaring a S3 backed Maven and Ivy repository
50.28. Adding central Maven repository
50.29. Adding Bintray's JCenter Maven repository
50.30. Using Bintrays's JCenter with HTTP
50.31. Adding the local Maven cache as a repository
50.32. Adding custom Maven repository
50.33. Adding additional Maven repositories for JAR files
50.34. Accessing password protected Maven repository
50.35. Flat repository resolver
50.36. Ivy repository
50.37. Ivy repository with named layout
50.38. Ivy repository with pattern layout
50.39. Ivy repository with multiple custom patterns
50.40. Ivy repository with Maven compatible layout
50.41. Ivy repository
50.42. Accessing a repository
50.43. Configuration of a repository
50.44. Definition of a custom repository
50.45. Forcing consistent version for a group of libraries
50.46. Using a custom versioning scheme
50.47. Blacklisting a version with a replacement
50.48. Changing dependency group and/or name at the resolution
50.49. Declaring module replacement
50.50. Enabling dynamic resolve mode
50.51. 'Latest' version selector
50.52. Custom status scheme
50.53. Custom status scheme by module
50.54. Ivy component metadata rule
50.55. Rule source component metadata rule
50.56. Component selection rule
50.57. Component selection rule with module target
50.58. Component selection rule with metadata
50.59. Component selection rule using a rule source object
50.60. Dynamic version cache control
50.61. Changing module cache control
51.1. Defining an artifact using an archive task
51.2. Defining an artifact using a file
51.3. Customizing an artifact
51.4. Map syntax for defining an artifact using a file
51.5. Configuration of the upload task
52.1. Using the Maven plugin
52.2. Creating a stand alone pom.
52.3. Upload of file to remote Maven repository
52.4. Upload of file via SSH
52.5. Customization of pom
52.6. Builder style customization of pom
52.7. Modifying auto-generated content
52.8. Customization of Maven installer
52.9. Generation of multiple poms
52.10. Accessing a mapping configuration
53.1. Using the Signing plugin
53.2. Signing a configuration
53.3. Signing a configuration output
53.4. Signing a task
53.5. Signing a task output
53.6. Conditional signing
53.7. Signing a POM for deployment
54.1. Defining a library component
54.2. Defining executable components
54.3. The components report
54.4. The 'cpp' plugin
54.5. C++ source set
54.6. The 'c' plugin
54.7. C source set
54.8. The 'assembler' plugin
54.9. The 'objective-c' plugin
54.10. The 'objective-cpp' plugin
54.11. Settings that apply to all binaries
54.12. Settings that apply to all shared libraries
54.13. Settings that apply to all binaries produced for the 'main' executable component
54.14. Settings that apply only to shared libraries produced for the 'main' library component
54.15. The 'windows-resources' plugin
54.16. Configuring the location of Windows resource sources
54.17. Building a resource-only dll
54.18. Providing a library dependency to the source set
54.19. Providing a library dependency to the binary
54.20. Declaring project dependencies
54.21. Defining build types
54.22. Configuring debug binaries
54.23. Defining platforms
54.24. Defining flavors
54.25. Targeting a component at particular platforms
54.26. Building all possible variants
54.27. Defining tool chains
54.28. Reconfigure tool arguments
54.29. Defining target platforms
54.30. Registering CUnit tests
54.31. Registering CUnit tests
54.32. Running CUnit tests
54.33. Registering GoogleTest tests
55.1. Single project build
55.2. Hierarchical layout
55.3. Flat layout
55.4. Modification of elements of the project tree
55.5. Modification of elements of the project tree
55.6. Adding of test task to each project which has certain property set
55.7. Notifications
55.8. Setting of certain property to all tasks
55.9. Logging of start and end of each task execution
56.1. Multi-project tree - water & bluewhale projects
56.2. Build script of water (parent) project
56.3. Multi-project tree - water, bluewhale & krill projects
56.4. Water project build script
56.5. Defining common behavior of all projects and subprojects
56.6. Defining specific behaviour for particular project
56.7. Defining specific behaviour for project krill
56.8. Adding custom behaviour to some projects (filtered by project name)
56.9. Adding custom behaviour to some projects (filtered by project properties)
56.10. Running build from subproject
56.11. Evaluation and execution of projects
56.12. Evaluation and execution of projects
56.13. Running tasks by their absolute path
56.14. Dependencies and execution order
56.15. Dependencies and execution order
56.16. Dependencies and execution order
56.17. Declaring dependencies
56.18. Declaring dependencies
56.19. Cross project task dependencies
56.20. Configuration time dependencies
56.21. Configuration time dependencies - evaluationDependsOn
56.22. Configuration time dependencies
56.23. Dependencies - real life example - crossproject configuration
56.24. Project lib dependencies
56.25. Project lib dependencies
56.26. Fine grained control over dependencies
56.27. Build and Test Single Project
56.28. Partial Build and Test Single Project
56.29. Build and Test Depended On Projects
56.30. Build and Test Dependent Projects
57.1. Defining a custom task
57.2. A hello world task
57.3. A customizable hello world task
57.4. A build for a custom task
57.5. A custom task
57.6. Using a custom task in another project
57.7. Testing a custom task
57.8. Defining an incremental task action
57.9. Running the incremental task for the first time
57.10. Running the incremental task with unchanged inputs
57.11. Running the incremental task with updated input files
57.12. Running the incremental task with an input file removed
57.13. Running the incremental task with an output file removed
57.14. Running the incremental task with an input property changed
58.1. A custom plugin
58.2. A custom plugin extension
58.3. A custom plugin with configuration closure
58.4. Evaluating file properties lazily
58.5. A build for a custom plugin
58.6. Wiring for a custom plugin
58.7. Using a custom plugin in another project
58.8. Applying a community plugin with the plugins DSL
58.9. Testing a custom plugin
58.10. Using the Java Gradle Plugin Development plugin
58.11. Managing domain objects
59.1. Using inherited properties and methods
59.2. Using injected properties and methods
59.3. Configuring the project using an external build script
59.4. Custom buildSrc build script
59.5. Adding subprojects to the root buildSrc project
59.6. Running another build from a build
59.7. Declaring external dependencies for the build script
59.8. A build script with external dependencies
59.9. Ant optional dependencies
60.1. Using init script to perform extra configuration before projects are evaluated
60.2. Declaring external dependencies for an init script
60.3. An init script with external dependencies
60.4. Using plugins in init scripts
61.1. Running the wrapper task
61.2. Wrapper task
61.3. Wrapper generated files
64.1. Applying the “ivy-publish” plugin
64.2. Publishing a Java module to Ivy
64.3. Publishing additional artifact to Ivy
64.4. customizing the publication identity
64.5. Customizing the module descriptor file
64.6. Publishing multiple modules from a single project
64.7. Declaring repositories to publish to
64.8. Choosing a particular publication to publish
64.9. Publishing all publications via the “publish” lifecycle task
64.10. Generating the Ivy module descriptor file
64.11. Publishing a Java module
64.12. Example generated ivy.xml
65.1. Applying the 'maven-publish' plugin
65.2. Adding a MavenPublication for a Java component
65.3. Adding additional artifact to a MavenPublication
65.4. customizing the publication identity
65.5. Modifying the POM file
65.6. Publishing multiple modules from a single project
65.7. Declaring repositories to publish to
65.8. Publishing a project to a Maven repository
65.9. Publish a project to the Maven local repository
65.10. Generate a POM file without publishing
66.1. an example of a simple rule based build
66.2. applying a rule source plugin
66.3. a model creation rule
66.4. a model mutation rule
66.5. creating a task
66.6. the model dsl
66.7. a DSL creation rule
66.8. model task output
B.1. Variables scope: local and script wide
B.2. Distinct configuration and execution phase