Gradle User Guide

Version 2.7

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. Continuous build
19.1. How do I start and stop a continuous build?
19.2. What will cause a subsequent build?
19.3. Limitations and quirks
20. The Build Environment
20.1. Configuring the build environment via gradle.properties
20.2. Gradle properties and system properties
20.3. Accessing the web via a proxy
21. Gradle Plugins
21.1. What plugins do
21.2. Types of plugins
21.3. Applying plugins
21.4. Applying plugins with the buildscript block
21.5. Applying plugins with the plugins DSL
21.6. Finding community plugins
21.7. More on plugins
22. Standard Gradle plugins
22.1. Language plugins
22.2. Incubating language plugins
22.3. Integration plugins
22.4. Incubating integration plugins
22.5. Software development plugins
22.6. Incubating software development plugins
22.7. Base plugins
22.8. Third party plugins
23. The Java Plugin
23.1. Usage
23.2. Source sets
23.3. Tasks
23.4. Project layout
23.5. Dependency management
23.6. Convention properties
23.7. Working with source sets
23.8. Javadoc
23.9. Clean
23.10. Resources
23.11. CompileJava
23.12. Incremental Java compilation
23.13. Test
23.14. Jar
23.15. Uploading
24. The Groovy Plugin
24.1. Usage
24.2. Tasks
24.3. Project layout
24.4. Dependency management
24.5. Automatic configuration of groovyClasspath
24.6. Convention properties
24.7. Source set properties
24.8. GroovyCompile
25. The Scala Plugin
25.1. Usage
25.2. Tasks
25.3. Project layout
25.4. Dependency management
25.5. Automatic configuration of scalaClasspath
25.6. Convention properties
25.7. Source set properties
25.8. Fast Scala Compiler
25.9. Compiling in external process
25.10. Incremental compilation
25.11. Eclipse Integration
25.12. IntelliJ IDEA Integration
26. The War Plugin
26.1. Usage
26.2. Tasks
26.3. Project layout
26.4. Dependency management
26.5. Convention properties
26.6. War
26.7. Customizing
27. The Ear Plugin
27.1. Usage
27.2. Tasks
27.3. Project layout
27.4. Dependency management
27.5. Convention properties
27.6. Ear
27.7. Customizing
27.8. Using custom descriptor file
28. The Jetty Plugin
28.1. Usage
28.2. Tasks
28.3. Project layout
28.4. Dependency management
28.5. Convention properties
29. The Checkstyle Plugin
29.1. Usage
29.2. Tasks
29.3. Project layout
29.4. Dependency management
29.5. Configuration
30. The CodeNarc Plugin
30.1. Usage
30.2. Tasks
30.3. Project layout
30.4. Dependency management
30.5. Configuration
31. The FindBugs Plugin
31.1. Usage
31.2. Tasks
31.3. Dependency management
31.4. Configuration
32. The JDepend Plugin
32.1. Usage
32.2. Tasks
32.3. Dependency management
32.4. Configuration
33. The PMD Plugin
33.1. Usage
33.2. Tasks
33.3. Dependency management
33.4. Configuration
34. The JaCoCo Plugin
34.1. Getting Started
34.2. Configuring the JaCoCo Plugin
34.3. JaCoCo Report configuration
34.4. JaCoCo specific task configuration
34.5. Tasks
34.6. Dependency management
35. The Sonar Plugin
35.1. Usage
35.2. Analyzing Multi-Project Builds
35.3. Analyzing Custom Source Sets
35.4. Analyzing languages other than Java
35.5. Setting Custom Sonar Properties
35.6. Configuring Sonar Settings from the Command Line
35.7. Tasks
36. The SonarQube Runner Plugin
36.1. SonarQube Runner version and compatibility
36.2. Getting started
36.3. Configuring the SonarQube Runner
36.4. Specifying the SonarQube Runner version
36.5. Analyzing Multi-Project Builds
36.6. Analyzing Custom Source Sets
36.7. Analyzing languages other than Java
36.8. More on configuring SonarQube properties
36.9. Setting SonarQube Properties from the Command Line
36.10. Controlling the SonarQube Runner process
36.11. Tasks
37. The OSGi Plugin
37.1. Usage
37.2. Implicitly applied plugins
37.3. Tasks
37.4. Dependency management
37.5. Convention object
37.6.
38. The Eclipse Plugins
38.1. Usage
38.2. Tasks
38.3. Configuration
38.4. Customizing the generated files
39. The IDEA Plugin
39.1. Usage
39.2. Tasks
39.3. Configuration
39.4. Customizing the generated files
39.5. Further things to consider
40. The ANTLR Plugin
40.1. Usage
40.2. Tasks
40.3. Project layout
40.4. Dependency management
40.5. Convention properties
40.6. Source set properties
40.7. Controlling the ANTLR generator process
41. The Project Report Plugin
41.1. Usage
41.2. Tasks
41.3. Project layout
41.4. Dependency management
41.5. Convention properties
42. The Announce Plugin
42.1. Usage
42.2. Configuration
43. The Build Announcements Plugin
43.1. Usage
44. The Distribution Plugin
44.1. Usage
44.2. Tasks
44.3. Distribution contents
44.4. Publishing distributions
45. The Application Plugin
45.1. Usage
45.2. Tasks
45.3. Convention properties
46. The Java Library Distribution Plugin
46.1. Usage
46.2. Tasks
46.3. Including other resources in the distribution
47. Build Init Plugin
47.1. Tasks
47.2. What to set up
47.3. Build init types
48. Wrapper Plugin
48.1. Usage
48.2. Tasks
49. The Build Dashboard Plugin
49.1. Usage
49.2. Tasks
49.3. Project layout
49.4. Dependency management
49.5. Configuration
50. The Java Gradle Plugin Development Plugin
50.1. Usage
51. The Gradle TestKit
51.1. Usage
51.2. Functionally testing with the Gradle runner
52. Dependency Management
52.1. Introduction
52.2. Dependency Management Best Practices
52.3. Dependency configurations
52.4. How to declare your dependencies
52.5. Working with dependencies
52.6. Repositories
52.7. How dependency resolution works
52.8. Fine-tuning the dependency resolution process
52.9. The dependency cache
52.10. Strategies for transitive dependency management
53. Publishing artifacts
53.1. Introduction
53.2. Artifacts and configurations
53.3. Declaring artifacts
53.4. Publishing artifacts
53.5. More about project libraries
54. The Maven Plugin
54.1. Usage
54.2. Tasks
54.3. Dependency management
54.4. Convention properties
54.5. Convention methods
54.6. Interacting with Maven repositories
55. The Signing Plugin
55.1. Usage
55.2. Signatory credentials
55.3. Specifying what to sign
55.4. Publishing the signatures
55.5. Signing POM files
56. Building native binaries
56.1. Supported languages
56.2. Tool chain support
56.3. Tool chain installation
56.4. Native software model
56.5. Parallel Compilation
56.6. Building a library
56.7. Building an executable
56.8. Tasks
56.9. Finding out more about your project
56.10. Language support
56.11. Configuring the compiler, assembler and linker
56.12. Windows Resources
56.13. Library Dependencies
56.14. Precompiled Headers
56.15. Native Binary Variants
56.16. Tool chains
56.17. Visual Studio IDE integration
56.18. CUnit support
56.19. GoogleTest support
57. The Play Plugin
57.1. Usage
57.2. Limitations
57.3. Software Model
57.4. Project Layout
57.5. Tasks
57.6. Finding out more about your project
57.7. Running a Play application
57.8. Configuring a Play application
57.9. Multi-project Play applications
57.10. Packaging a Play application for distribution
57.11. Resources
58. The Build Lifecycle
58.1. Build phases
58.2. Settings file
58.3. Multi-project builds
58.4. Initialization
58.5. Configuration and execution of a single project build
58.6. Responding to the lifecycle in the build script
59. Multi-project Builds
59.1. Cross project configuration
59.2. Subproject configuration
59.3. Execution rules for multi-project builds
59.4. Running tasks by their absolute path
59.5. Project and task paths
59.6. Dependencies - Which dependencies?
59.7. Project lib dependencies
59.8. Parallel project execution
59.9. Decoupled Projects
59.10. Multi-Project Building and Testing
59.11. Multi Project and buildSrc
59.12. Property and method inheritance
59.13. Summary
60. Writing Custom Task Classes
60.1. Packaging a task class
60.2. Writing a simple task class
60.3. A standalone project
60.4. Incremental tasks
61. Writing Custom Plugins
61.1. Packaging a plugin
61.2. Writing a simple plugin
61.3. Getting input from the build
61.4. Working with files in custom tasks and plugins
61.5. A standalone project
61.6. Maintaining multiple domain objects
62. Organizing Build Logic
62.1. Inherited properties and methods
62.2. Injected configuration
62.3. Configuring the project using an external build script
62.4. Build sources in the buildSrc project
62.5. Running another Gradle build from a build
62.6. External dependencies for the build script
62.7. Ant optional dependencies
62.8. Summary
63. Initialization Scripts
63.1. Basic usage
63.2. Using an init script
63.3. Writing an init script
63.4. External dependencies for the init script
63.5. Init script plugins
64. The Gradle Wrapper
64.1. Configuration
64.2. Verification of downloaded Gradle distributions
64.3. Unix file permissions
65. Embedding Gradle
65.1. Introduction to the Tooling API
65.2. Tooling API and the Gradle Build Daemon
65.3. Quickstart
66. Comparing Builds
66.1. Definition of terms
66.2. Current Capabilities
66.3. Comparing Gradle Builds
67. Ivy Publishing (new)
67.1. The “ivy-publish” Plugin
67.2. Publications
67.3. Repositories
67.4. Performing a publish
67.5. Generating the Ivy module descriptor file without publishing
67.6. Complete example
67.7. Future features
68. Maven Publishing (new)
68.1. The “maven-publish” Plugin
68.2. Publications
68.3. Repositories
68.4. Performing a publish
68.5. Publishing to Maven Local
68.6. Generating the POM file without publishing
69. Rule based model configuration
69.1. Background
69.2. Motivations for change
69.3. Concepts
69.4. Rule sources
69.5. The “model DSL”
69.6. The model report
69.7. Limitations and future direction
70. The New Java Plugin
70.1. The Software Model
70.2. Usage
70.3. Creating a library
70.4. Source Sets
70.5. Tasks
70.6. Finding out more about your project
70.7. Dependencies between components
70.8. Platform aware dependency management
70.9. Custom variant resolution
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
Glossary

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
20.1. Setting properties with a gradle.properties file
20.2. Configuring an HTTP proxy
20.3. Configuring an HTTPS proxy
21.1. Applying a script plugin
21.2. Applying a binary plugin
21.3. Applying a binary plugin by type
21.4. Applying a plugin with the buildscript block
21.5. Applying a core plugin
21.6. Applying a community plugin
23.1. Using the Java plugin
23.2. Custom Java source layout
23.3. Accessing a source set
23.4. Configuring the source directories of a source set
23.5. Defining a source set
23.6. Defining source set dependencies
23.7. Compiling a source set
23.8. Assembling a JAR for a source set
23.9. Generating the Javadoc for a source set
23.10. Running tests in a source set
23.11. Filtering tests in the build script
23.12. JUnit Categories
23.13. Grouping TestNG tests
23.14. Creating a unit test report for subprojects
23.15. Customization of MANIFEST.MF
23.16. Creating a manifest object.
23.17. Separate MANIFEST.MF for a particular archive
23.18. Separate MANIFEST.MF for a particular archive
24.1. Using the Groovy plugin
24.2. Custom Groovy source layout
24.3. Configuration of Groovy dependency
24.4. Configuration of Groovy test dependency
24.5. Configuration of bundled Groovy dependency
24.6. Configuration of Groovy file dependency
25.1. Using the Scala plugin
25.2. Custom Scala source layout
25.3. Declaring a Scala dependency for production code
25.4. Declaring a Scala dependency for test code
25.5. Enabling the Fast Scala Compiler
25.6. Adjusting memory settings
25.7. Activating the Zinc based compiler
26.1. Using the War plugin
26.2. Customization of war plugin
27.1. Using the Ear plugin
27.2. Customization of ear plugin
28.1. Using the Jetty plugin
29.1. Using the Checkstyle plugin
30.1. Using the CodeNarc plugin
31.1. Using the FindBugs plugin
32.1. Using the JDepend plugin
33.1. Using the PMD plugin
34.1. Applying the JaCoCo plugin
34.2. Configuring JaCoCo plugin settings
34.3. Configuring test task
34.4. Configuring test task
34.5. Using application plugin to generate code coverage data
34.6. Coverage reports generated by applicationCodeCoverageReport
35.1. Applying the Sonar plugin
35.2. Configuring Sonar connection settings
35.3. Configuring Sonar project settings
35.4. Global configuration in a multi-project build
35.5. Common project configuration in a multi-project build
35.6. Individual project configuration in a multi-project build
35.7. Configuring the language to be analyzed
35.8. Using property syntax
35.9. Analyzing custom source sets
35.10. Analyzing languages other than Java
35.11. Setting custom global properties
35.12. Setting custom project properties
35.13. Implementing custom command line properties
36.1. Applying the SonarQube Runner plugin
36.2. Configuring SonarQube connection settings
36.3. Configuring SonarQube runner version
36.4. Global configuration settings
36.5. Shared configuration settings
36.6. Individual configuration settings
36.7. Skipping analysis of a project
36.8. Analyzing custom source sets
36.9. Analyzing languages other than Java
36.10. setting custom SonarQube Runner fork options
37.1. Using the OSGi plugin
37.2. Configuration of OSGi MANIFEST.MF file
38.1. Using the Eclipse plugin
38.2. Using the Eclipse WTP plugin
38.3. Partial Overwrite for Classpath
38.4. Partial Overwrite for Project
38.5. Export Dependencies
38.6. Customizing the XML
39.1. Using the IDEA plugin
39.2. Partial Rewrite for Module
39.3. Partial Rewrite for Project
39.4. Export Dependencies
39.5. Customizing the XML
40.1. Using the ANTLR plugin
40.2. Declare ANTLR version
40.3. setting custom max heap size and extra arguments for ANTLR
42.1. Using the announce plugin
42.2. Configure the announce plugin
42.3. Using the announce plugin
43.1. Using the build announcements plugin
43.2. Using the build announcements plugin from an init script
44.1. Using the distribution plugin
44.2. Adding extra distributions
44.3. Configuring the main distribution
44.4. publish main distribution
45.1. Using the application plugin
45.2. Configure the application main class
45.3. Configure default JVM settings
45.4. Include output from other tasks in the application distribution
45.5. Automatically creating files for distribution
46.1. Using the Java library distribution plugin
46.2. Configure the distribution name
46.3. Include files in the distribution
49.1. Using the Build Dashboard plugin
50.1. Using the Java Gradle Plugin Development plugin
51.1. Declaring the TestKit dependency
51.2. Declaring the JUnit dependency
51.3. Using GradleRunner with JUnit
51.4. Using GradleRunner with Spock
51.5. Making the code under test classpath available to the tests
51.6. Injecting the code under test classes into test builds
52.1. Definition of a configuration
52.2. Accessing a configuration
52.3. Configuration of a configuration
52.4. Module dependencies
52.5. Artifact only notation
52.6. Dependency with classifier
52.7. Iterating over a configuration
52.8. Client module dependencies - transitive dependencies
52.9. Project dependencies
52.10. File dependencies
52.11. Generated file dependencies
52.12. Gradle API dependencies
52.13. Gradle's Groovy dependencies
52.14. Excluding transitive dependencies
52.15. Optional attributes of dependencies
52.16. Collections and arrays of dependencies
52.17. Dependency configurations
52.18. Dependency configurations for project
52.19. Configuration.copy
52.20. Accessing declared dependencies
52.21. Configuration.files
52.22. Configuration.files with spec
52.23. Configuration.copy
52.24. Configuration.copy vs. Configuration.files
52.25. Adding central Maven repository
52.26. Adding Bintray's JCenter Maven repository
52.27. Using Bintrays's JCenter with HTTP
52.28. Adding the local Maven cache as a repository
52.29. Adding custom Maven repository
52.30. Adding additional Maven repositories for JAR files
52.31. Accessing password protected Maven repository
52.32. Flat repository resolver
52.33. Ivy repository
52.34. Ivy repository with named layout
52.35. Ivy repository with pattern layout
52.36. Ivy repository with multiple custom patterns
52.37. Ivy repository with Maven compatible layout
52.38. Ivy repository
52.39. Declaring a Maven and Ivy repository
52.40. Providing credentials to a Maven and Ivy repository
52.41. Declaring a S3 backed Maven and Ivy repository
52.42. Configure repository to use only digest authentication
52.43. Configure repository to use preemptive authentication
52.44. Accessing a repository
52.45. Configuration of a repository
52.46. Definition of a custom repository
52.47. Forcing consistent version for a group of libraries
52.48. Using a custom versioning scheme
52.49. Blacklisting a version with a replacement
52.50. Changing dependency group and/or name at the resolution
52.51. Substituting a module with a project
52.52. Substituting a project with a module
52.53. Conditionally substituting a dependency
52.54. Specifying default dependencies on a configuration
52.55. Enabling dynamic resolve mode
52.56. 'Latest' version selector
52.57. Custom status scheme
52.58. Custom status scheme by module
52.59. Ivy component metadata rule
52.60. Rule source component metadata rule
52.61. Component selection rule
52.62. Component selection rule with module target
52.63. Component selection rule with metadata
52.64. Component selection rule using a rule source object
52.65. Declaring module replacement
52.66. Dynamic version cache control
52.67. Changing module cache control
53.1. Defining an artifact using an archive task
53.2. Defining an artifact using a file
53.3. Customizing an artifact
53.4. Map syntax for defining an artifact using a file
53.5. Configuration of the upload task
54.1. Using the Maven plugin
54.2. Creating a stand alone pom.
54.3. Upload of file to remote Maven repository
54.4. Upload of file via SSH
54.5. Customization of pom
54.6. Builder style customization of pom
54.7. Modifying auto-generated content
54.8. Customization of Maven installer
54.9. Generation of multiple poms
54.10. Accessing a mapping configuration
55.1. Using the Signing plugin
55.2. Signing a configuration
55.3. Signing a configuration output
55.4. Signing a task
55.5. Signing a task output
55.6. Conditional signing
55.7. Signing a POM for deployment
56.1. Defining a library component
56.2. Defining executable components
56.3. The components report
56.4. The 'cpp' plugin
56.5. C++ source set
56.6. The 'c' plugin
56.7. C source set
56.8. The 'assembler' plugin
56.9. The 'objective-c' plugin
56.10. The 'objective-cpp' plugin
56.11. Settings that apply to all binaries
56.12. Settings that apply to all shared libraries
56.13. Settings that apply to all binaries produced for the 'main' executable component
56.14. Settings that apply only to shared libraries produced for the 'main' library component
56.15. The 'windows-resources' plugin
56.16. Configuring the location of Windows resource sources
56.17. Building a resource-only dll
56.18. Providing a library dependency to the source set
56.19. Providing a library dependency to the binary
56.20. Declaring project dependencies
56.21. Creating a precompiled header file
56.22. Including a precompiled header file in a source file
56.23. Configuring a precompiled header
56.24. Defining build types
56.25. Configuring debug binaries
56.26. Defining platforms
56.27. Defining flavors
56.28. Targeting a component at particular platforms
56.29. Building all possible variants
56.30. Defining tool chains
56.31. Reconfigure tool arguments
56.32. Defining target platforms
56.33. Registering CUnit tests
56.34. Registering CUnit tests
56.35. Running CUnit tests
56.36. Registering GoogleTest tests
57.1. Using the Play plugin
57.2. The components report
57.3. Selecting a version of the Play Framework
57.4. Adding dependencies to a Play application
57.5. Adding extra source sets to a Play application
57.6. Adding extra source sets to a Play application
57.7. Configuring Scala compiler options
57.8. Configuring routes style
57.9. Configuring a custom asset pipeline
57.10. Configuring dependencies on Play subprojects
57.11. Add extra files to a Play application distribution
58.1. Single project build
58.2. Hierarchical layout
58.3. Flat layout
58.4. Modification of elements of the project tree
58.5. Modification of elements of the project tree
58.6. Adding of test task to each project which has certain property set
58.7. Notifications
58.8. Setting of certain property to all tasks
58.9. Logging of start and end of each task execution
59.1. Multi-project tree - water & bluewhale projects
59.2. Build script of water (parent) project
59.3. Multi-project tree - water, bluewhale & krill projects
59.4. Water project build script
59.5. Defining common behavior of all projects and subprojects
59.6. Defining specific behaviour for particular project
59.7. Defining specific behaviour for project krill
59.8. Adding custom behaviour to some projects (filtered by project name)
59.9. Adding custom behaviour to some projects (filtered by project properties)
59.10. Running build from subproject
59.11. Evaluation and execution of projects
59.12. Evaluation and execution of projects
59.13. Running tasks by their absolute path
59.14. Dependencies and execution order
59.15. Dependencies and execution order
59.16. Dependencies and execution order
59.17. Declaring dependencies
59.18. Declaring dependencies
59.19. Cross project task dependencies
59.20. Configuration time dependencies
59.21. Configuration time dependencies - evaluationDependsOn
59.22. Configuration time dependencies
59.23. Dependencies - real life example - crossproject configuration
59.24. Project lib dependencies
59.25. Project lib dependencies
59.26. Fine grained control over dependencies
59.27. Build and Test Single Project
59.28. Partial Build and Test Single Project
59.29. Build and Test Depended On Projects
59.30. Build and Test Dependent Projects
60.1. Defining a custom task
60.2. A hello world task
60.3. A customizable hello world task
60.4. A build for a custom task
60.5. A custom task
60.6. Using a custom task in another project
60.7. Testing a custom task
60.8. Defining an incremental task action
60.9. Running the incremental task for the first time
60.10. Running the incremental task with unchanged inputs
60.11. Running the incremental task with updated input files
60.12. Running the incremental task with an input file removed
60.13. Running the incremental task with an output file removed
60.14. Running the incremental task with an input property changed
61.1. A custom plugin
61.2. A custom plugin extension
61.3. A custom plugin with configuration closure
61.4. Evaluating file properties lazily
61.5. A build for a custom plugin
61.6. Wiring for a custom plugin
61.7. Using a custom plugin in another project
61.8. Applying a community plugin with the plugins DSL
61.9. Testing a custom plugin
61.10. Using the Java Gradle Plugin Development plugin
61.11. Managing domain objects
62.1. Using inherited properties and methods
62.2. Using injected properties and methods
62.3. Configuring the project using an external build script
62.4. Custom buildSrc build script
62.5. Adding subprojects to the root buildSrc project
62.6. Running another build from a build
62.7. Declaring external dependencies for the build script
62.8. A build script with external dependencies
62.9. Ant optional dependencies
63.1. Using init script to perform extra configuration before projects are evaluated
63.2. Declaring external dependencies for an init script
63.3. An init script with external dependencies
63.4. Using plugins in init scripts
64.1. Running the wrapper task
64.2. Wrapper task
64.3. Wrapper generated files
64.4. Generating a SHA-256 hash
64.5. Configuring SHA-256 checksum verification
67.1. Applying the “ivy-publish” plugin
67.2. Publishing a Java module to Ivy
67.3. Publishing additional artifact to Ivy
67.4. customizing the publication identity
67.5. Customizing the module descriptor file
67.6. Publishing multiple modules from a single project
67.7. Declaring repositories to publish to
67.8. Choosing a particular publication to publish
67.9. Publishing all publications via the “publish” lifecycle task
67.10. Generating the Ivy module descriptor file
67.11. Publishing a Java module
67.12. Example generated ivy.xml
68.1. Applying the 'maven-publish' plugin
68.2. Adding a MavenPublication for a Java component
68.3. Adding additional artifact to a MavenPublication
68.4. customizing the publication identity
68.5. Modifying the POM file
68.6. Publishing multiple modules from a single project
68.7. Declaring repositories to publish to
68.8. Publishing a project to a Maven repository
68.9. Publish a project to the Maven local repository
68.10. Generate a POM file without publishing
69.1. an example of a simple rule based build
69.2. a managed type
69.3. a String property
69.4. a File property
69.5. a Long property
69.6. a boolean property
69.7. an int property
69.8. a managed property
69.9. an enumeration type property
69.10. a managed set
69.11. applying a rule source plugin
69.12. a model creation rule
69.13. a model mutation rule
69.14. creating a task
69.15. the model dsl
69.16. a DSL creation rule
69.17. model task output
70.1. Using the new Java plugin
70.2. Creating a source set
70.3. Configuring a source set
70.4. Creating a new source set
70.5. The components report
70.6. Declaring a dependency onto a library
70.7. Declaring a dependency onto a project with an explicit library
70.8. Declaring a dependency onto a project with an implicit library
70.9. Declaring target platforms
70.10. Declaring binary specific sources
70.11. Declaring target platforms
B.1. Variables scope: local and script wide
B.2. Distinct configuration and execution phase