Content-Length: 187686 | pFad | https://docs.gradle.org/1.6/userguide/userguide.html

Gradle User Guide

Gradle User Guide

Version 1.6

Copyright © 2007-2012 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. Some Groovy basics

14. Tutorial - 'This and That'

14.1. Directory creation
14.2. Gradle properties and system properties
14.3. Configuring the project using an external build script
14.4. Configuring arbitrary objects
14.5. Configuring arbitrary objects using an external script
14.6. Caching

15. More about Tasks

15.1. Defining tasks
15.2. Locating tasks
15.3. Configuring tasks
15.4. Adding dependencies to a task
15.5. Ordering tasks
15.6. Adding a description to a task
15.7. Replacing tasks
15.8. Skipping tasks
15.9. Skipping tasks that are up-to-date
15.10. Task rules
15.11. Summary

16. Working With Files

16.1. Locating files
16.2. File collections
16.3. File trees
16.4. Using the contents of an archive as a file tree
16.5. Specifying a set of input files
16.6. Copying files
16.7. Using the Sync task
16.8. Creating archives

17. Using Ant from Gradle

17.1. Using Ant tasks and types in your build
17.2. Importing an Ant build
17.3. Ant properties and references
17.4. API

18. Logging

18.1. Choosing a log level
18.2. Writing your own log messages
18.3. Logging from external tools and libraries
18.4. Changing what Gradle logs

19. The Gradle Daemon

19.1. Enter the daemon
19.2. Reusing and expiration of daemons
19.3. Usage and troubleshooting
19.4. Configuring the daemon

20. The Build Environment

20.1. Configuring the build environment via gradle.properties
20.2. Accessing the web via a proxy

21. Gradle Plugins

21.1. Applying plugins
21.2. What plugins do
21.3. Conventions
21.4. 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. Test
23.13. Jar
23.14. 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 Sonar Runner Plugin

36.1. Plugin Status and Compatibility
36.2. Getting Started
36.3. Configuring the Sonar Runner
36.4. Analyzing Multi-Project Builds
36.5. Analyzing Custom Source Sets
36.6. Analyzing languages other than Java
36.7. More on configuring Sonar properties
36.8. Setting Sonar Properties from the Command Line
36.9. Executing Sonar Runner in a separate process
36.10. 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 Plugin

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

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. Configure distributions
44.4. Multiple distributions
44.5. Extension properties

45. The Application Plugin

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

46. The Java Library Distribution Plugin

46.1. Usage
46.2. Tasks
46.3. Including other resources in the distribution

47. Build Setup Plugin

47.1. Maven conversion - features
47.2. Usage

48. The Build Dashboard Plugin

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

49. Dependency Management

49.1. Introduction
49.2. Dependency Management Best Practices
49.3. Dependency configurations
49.4. How to declare your dependencies
49.5. Working with dependencies
49.6. Repositories
49.7. How dependency resolution works
49.8. Fine-tuning the dependency resolution process
49.9. The dependency cache
49.10. Strategies for transitive dependency management

50. Publishing artifacts

50.1. Introduction
50.2. Artifacts and configurations
50.3. Declaring artifacts
50.4. Publishing artifacts
50.5. More about project libraries

51. The Maven Plugin

51.1. Usage
51.2. Tasks
51.3. Dependency management
51.4. Convention properties
51.5. Convention methods
51.6. Interacting with Maven repositories

52. The Signing Plugin

52.1. Usage
52.2. Signatory credentials
52.3. Specifying what to sign
52.4. Publishing the signatures
52.5. Signing POM files

53. C++ Support

53.1. Usage
53.2. Source code locations
53.3. Compiling
53.4. Configuring the compiler
53.5. Working with shared libraries
53.6. Dependencies
53.7. Publishing

54. The Build Lifecycle

54.1. Build phases
54.2. Settings file
54.3. Multi-project builds
54.4. Initialization
54.5. Configuration and execution of a single project build
54.6. Responding to the lifecycle in the build script

55. Multi-project Builds

55.1. Cross project configuration
55.2. Subproject configuration
55.3. Execution rules for multi-project builds
55.4. Running tasks by their absolute path
55.5. Project and task paths
55.6. Dependencies - Which dependencies?
55.7. Project lib dependencies
55.8. Parallel project execution
55.9. Decoupled Projects
55.10. Multi-Project Building and Testing
55.11. Property and method inheritance
55.12. Summary

56. Writing Custom Task Classes

56.1. Packaging a task class
56.2. Writing a simple task class
56.3. A standalone project

57. Incremental Tasks

57.1. Implementing an incremental task
57.2. Which inputs are considered out of date?
57.3. An incremental task in action

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. Build sources in the buildSrc project
59.4. Running another Gradle build from a build
59.5. External dependencies for the build script
59.6. Ant optional dependencies
59.7. 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

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. The 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 dependencies between tasks
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 1.7.10
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 information about dependencies
11.13. Filtering dependency report by configuration
11.14. Getting the insight into a particular dependency
11.15. 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. Groovy JDK methods
13.5. Property accessors
13.6. Method call without parentheses
13.7. List and map literals
13.8. Closure as method parameter
13.9. Closure delegates
14.1. Directory creation with mkdir
14.2. Setting properties with a gradle.properties file
14.3. Configuring the project using an external build script
14.4. Configuring arbitrary objects
14.5. Configuring arbitrary objects using a script
15.1. Defining tasks
15.2. Defining tasks - using strings
15.3. Defining tasks with alternative syntax
15.4. Accessing tasks as properties
15.5. Accessing tasks via tasks collection
15.6. Accessing tasks by path
15.7. Creating a copy task
15.8. Configuring a task - various ways
15.9. Configuring a task - fluent interface
15.10. Configuring a task - with closure
15.11. Configuring a task - with configure() method
15.12. Defining a task with closure
15.13. Adding dependency on task from another project
15.14. Adding dependency using task object
15.15. Adding dependency using closure
15.16. Adding a 'must run after' task ordering
15.17. Task ordering does not imply task execution
15.18. Adding a description to a task
15.19. Overwriting a task
15.20. Skipping a task using a predicate
15.21. Skipping tasks with StopExecutionException
15.22. Enabling and disabling tasks
15.23. A generator task
15.24. Declaring the inputs and outputs of a task
15.25. Task rule
15.26. Dependency on rule based tasks
16.1. Locating files
16.2. Creating a file collection
16.3. Using a file collection
16.4. Implementing a file collection
16.5. Creating a file tree
16.6. Using a file tree
16.7. Using an archive as a file tree
16.8. Specifying a set of files
16.9. Specifying a set of files
16.10. Copying files using the copy task
16.11. Specifying copy task source files and destination directory
16.12. Selecting the files to copy
16.13. Copying files using the copy() method
16.14. Renaming files as they are copied
16.15. Filtering files as they are copied
16.16. Nested copy specs
16.17. Using the Sync task to copy dependencies
16.18. Creating a ZIP archive
16.19. Creation of ZIP archive
16.20. Configuration of archive task - custom archive name
16.21. Configuration of archive task - appendix & classifier
17.1. Using an Ant task
17.2. Passing nested text to an Ant task
17.3. Passing nested elements to an Ant task
17.4. Using an Ant type
17.5. Using a custom Ant task
17.6. Declaring the classpath for a custom Ant task
17.7. Using a custom Ant task and dependency management together
17.8. Importing an Ant build
17.9. Task that depends on Ant target
17.10. Adding behaviour to an Ant target
17.11. Ant target that depends on Gradle task
17.12. Setting an Ant property
17.13. Getting an Ant property
17.14. Setting an Ant reference
17.15. Getting an Ant reference
18.1. Using stdout to write log messages
18.2. Writing your own log messages
18.3. Using SLF4J to write log messages
18.4. Configuring standard output capture
18.5. Configuring standard output capture for a task
18.6. Customizing what Gradle logs
20.1. Configuring an HTTP proxy
20.2. Configuring an HTTPS proxy
21.1. Applying a plugin
21.2. Applying a plugin by type
21.3. Applying a plugin by type
21.4. Tasks added by a plugin
21.5. Changing plugin defaults
21.6. Plugin convention object
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. JUnit Categories
23.12. Grouping TestNG tests
23.13. Creating a unit test report for subprojects
23.14. Customization of MANIFEST.MF
23.15. Creating a manifest object.
23.16. Separate MANIFEST.MF for a particular archive
23.17. 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 Sonar Runner plugin
36.2. Configuring Sonar connection settings
36.3. Global configuration settings
36.4. Shared configuration settings
36.5. Individual configuration settings
36.6. Skipping analysis of a project
36.7. Analyzing custom source sets
36.8. Analyzing languages other than Java
37.1. Using the OSGi plugin
37.2. Configuration of OSGi MANIFEST.MF file
38.1. Using the Eclipse plugin
38.2. Partial Overwrite for Classpath
38.3. Partial Overwrite for Project
38.4. Export Dependencies
38.5. Customizing the XML
39.1. Using the IDEA plugin
39.2. Partial Overwrite for Module
39.3. Partial Overwrite for Project
39.4. Export Dependencies
39.5. Customizing the XML
40.1. Using the ANTLR plugin
40.2. Declare ANTLR version
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. Configure the distribution name
44.3. Declare multiple distributions
44.4. Declare multiple distributions
45.1. Using the application plugin
45.2. Configure the application main class
45.3. Include output from other tasks in the application distribution
45.4. 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
48.1. Using the Build Dashboard plugin
49.1. Definition of a configuration
49.2. Accessing a configuration
49.3. Configuration of a configuration
49.4. Module dependencies
49.5. Artifact only notation
49.6. Dependency with classifier
49.7. Usage of external dependency of a configuration
49.8. Client module dependencies - transitive dependencies
49.9. Project dependencies
49.10. File dependencies
49.11. Generated file dependencies
49.12. Gradle API dependencies
49.13. Gradle's Groovy dependencies
49.14. Excluding transitive dependencies
49.15. Optional attributes of dependencies
49.16. Collections and arrays of dependencies
49.17. Dependency configurations
49.18. Dependency configurations for project
49.19. Configuration.copy
49.20. Accessing declared dependencies
49.21. Configuration.files
49.22. Configuration.files with spec
49.23. Configuration.copy
49.24. Configuration.copy vs. Configuration.files
49.25. Adding central Maven repository
49.26. Adding the local Maven cache as a repository
49.27. Adding custom Maven repository
49.28. Adding additional Maven repositories for JAR files
49.29. Accessing password protected Maven repository
49.30. Flat repository resolver
49.31. Ivy repository
49.32. Ivy repository with pattern layout
49.33. Ivy repository with Maven compatible layout
49.34. Ivy repository with custom patterns
49.35. Ivy repository
49.36. Accessing a repository
49.37. Configuration of a repository
49.38. Definition of a custom repository
49.39. Forcing consistent version for a group of libraries
49.40. Using a custom versioning scheme
49.41. Blacklisting a version with a replacement
49.42. Changing dependency group and/or name at the resolution
49.43. Enabling dynamic resolve mode
49.44. Dynamic version cache control
49.45. Changing module cache control
50.1. Defining an artifact using an archive task
50.2. Defining an artifact using a file
50.3. Customizing an artifact
50.4. Map syntax for defining an artifact using a file
50.5. Configuration of the upload task
51.1. Using the Maven plugin
51.2. Creating a stand alone pom.
51.3. Upload of file to remote Maven repository
51.4. Upload of file via SSH
51.5. Customization of pom
51.6. Builder style customization of pom
51.7. Modifying auto-generated content
51.8. Customization of Maven installer
51.9. Generation of multiple poms
51.10. Accessing a mapping configuration
52.1. Using the Signing plugin
52.2. Signing a configuration
52.3. Signing a configuration output
52.4. Signing a task
52.5. Signing a task output
52.6. Conditional signing
52.7. Signing a POM for deployment
53.1. Using the 'cpp-exe' plugin
53.2. Using the 'cpp-lib' plugin
53.3. Supplying arbitrary args to the compiler
53.4. Declaring dependencies
53.5. Declaring project dependencies
53.6. Uploading exe or lib
54.1. Single project build
54.2. Hierarchical layout
54.3. Flat layout
54.4. Modification of elements of the project tree
54.5. Modification of elements of the project tree
54.6. Adding of test task to each project which has certain property set
54.7. Notifications
54.8. Setting of certain property to all tasks
54.9. Logging of start and end of each task execution
55.1. Multi-project tree - water & bluewhale projects
55.2. Build script of water (parent) project
55.3. Multi-project tree - water, bluewhale & krill projects
55.4. Water project build script
55.5. Defining common behaviour of all projects and subprojects
55.6. Defining specific behaviour for particular project
55.7. Defining specific behaviour for project krill
55.8. Adding custom behaviour to some projects (filtered by project name)
55.9. Adding custom behaviour to some projects (filtered by project properties)
55.10. Running build from subproject
55.11. Evaluation and execution of projects
55.12. Evaluation and execution of projects
55.13. Running tasks by their absolute path
55.14. Dependencies and execution order
55.15. Dependencies and execution order
55.16. Dependencies and execution order
55.17. Declaring dependencies
55.18. Declaring dependencies
55.19. Cross project task dependencies
55.20. Configuration time dependencies
55.21. Configuration time dependencies - evaluationDependsOn
55.22. Configuration time dependencies
55.23. Dependencies - real life example - crossproject configuration
55.24. Project lib dependencies
55.25. Project lib dependencies
55.26. Fine grained control over dependencies
55.27. Build and Test Single Project
55.28. Partial Build and Test Single Project
55.29. Build and Test Depended On Projects
55.30. Build and Test Dependent Projects
56.1. Defining a custom task
56.2. A hello world task
56.3. A customizable hello world task
56.4. A build for a custom task
56.5. A custom task
56.6. Using a custom task in another project
56.7. Testing a custom task
57.1. Defining an incremental task action
57.2. Running the incremental task for the first time
57.3. Running the incremental task with unchanged inputs
57.4. Running the incremental task with updated input files
57.5. Running the incremental task with an input file removed
57.6. Running the incremental task with an output file removed
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. Testing a custom plugin
58.9. Managing domain objects
59.1. Using inherited properties and methods
59.2. Using injected properties and methods
59.3. Custom buildSrc build script
59.4. Adding subprojects to the root buildSrc project
59.5. Running another build from a build
59.6. Declaring external dependencies for the build script
59.7. A build script with external dependencies
59.8. 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. Wrapper task
61.2. 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 module descriptor file
64.5. Declaring repositories to publish to
64.6. Choosing a particular publication to publish
64.7. Publishing all publications via the “publish” lifecycle task
64.8. Generating the Ivy module descriptor file
64.9. Publishing a java module
64.10. 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. Modifying the POM file
65.5. Declaring repositories to publish to
65.6. Publishing a project to a Maven repository
65.7. Publish a project to the Maven local repository
65.8. Generate a POM file without publishing
B.1. Variables scope: local and script wide
B.2. Distinct configuration and execution phase