Part III. Writing Gradle build scripts

Table of Contents

15. Build Script Basics

15.1. Projects and tasks
15.2. Hello world
15.3. A shortcut task definition
15.4. Build scripts are code
15.5. Task dependencies
15.6. Dynamic tasks
15.7. Manipulating existing tasks
15.8. Shortcut notations
15.9. Extra task properties
15.10. Using Ant Tasks
15.11. Using methods
15.12. Default tasks
15.13. Configure by DAG
15.14. Where to next?

16. Build Init Plugin

16.1. Tasks
16.2. What to set up
16.3. Build init types

17. Writing Build Scripts

17.1. The Gradle build language
17.2. The Project API
17.3. The Script API
17.4. Declaring variables
17.5. Configuring arbitrary objects
17.6. Configuring arbitrary objects using an external script
17.7. Some Groovy basics
17.8. Default imports

18. More about Tasks

18.1. Defining tasks
18.2. Locating tasks
18.3. Configuring tasks
18.4. Adding dependencies to a task
18.5. Ordering tasks
18.6. Adding a description to a task
18.7. Replacing tasks
18.8. Skipping tasks
18.9. Up-to-date checks (AKA Incremental Build)
18.10. Task rules
18.11. Finalizer tasks
18.12. Summary

19. Working With Files

19.1. Locating files
19.2. File collections
19.3. File trees
19.4. Using the contents of an archive as a file tree
19.5. Specifying a set of input files
19.6. Copying files
19.7. Using the Sync task
19.8. Creating archives

20. Using Ant from Gradle

20.1. Using Ant tasks and types in your build
20.2. Importing an Ant build
20.3. Ant properties and references
20.4. Ant logging
20.5. API

21. The Build Lifecycle

21.1. Build phases
21.2. Settings file
21.3. Multi-project builds
21.4. Initialization
21.5. Configuration and execution of a single project build
21.6. Responding to the lifecycle in the build script

22. Wrapper Plugin

22.1. Usage
22.2. Tasks

23. Logging

23.1. Choosing a log level
23.2. Writing your own log messages
23.3. Logging from external tools and libraries
23.4. Changing what Gradle logs

24. Dependency Management

24.1. Introduction
24.2. Dependency Management Best Practices
24.3. Dependency configurations
24.4. How to declare your dependencies
24.5. Working with dependencies
24.6. Repositories
24.7. How dependency resolution works
24.8. Fine-tuning the dependency resolution process
24.9. The dependency cache
24.10. Strategies for transitive dependency management

25. Multi-project Builds

25.1. Cross project configuration
25.2. Subproject configuration
25.3. Execution rules for multi-project builds
25.4. Running tasks by their absolute path
25.5. Project and task paths
25.6. Dependencies - Which dependencies?
25.7. Project lib dependencies
25.8. Parallel project execution
25.9. Decoupled Projects
25.10. Multi-Project Building and Testing
25.11. Multi Project and buildSrc
25.12. Property and method inheritance
25.13. Summary

26. Gradle Plugins

26.1. What plugins do
26.2. Types of plugins
26.3. Using plugins
26.4. Script plugins
26.5. Binary plugins
26.6. Finding community plugins
26.7. More on plugins

27. Standard Gradle plugins

27.1. Language plugins
27.2. Incubating language plugins
27.3. Integration plugins
27.4. Incubating integration plugins
27.5. Software development plugins
27.6. Incubating software development plugins
27.7. Base plugins
27.8. Third party plugins

28. The Project Report Plugin

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

29. The Build Dashboard Plugin

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

30. Comparing Builds

30.1. Definition of terms
30.2. Current Capabilities
30.3. Comparing Gradle Builds

31. Publishing artifacts

31.1. Introduction
31.2. Artifacts and configurations
31.3. Declaring artifacts
31.4. Publishing artifacts
31.5. More about project libraries

32. The Maven Plugin

32.1. Usage
32.2. Tasks
32.3. Dependency management
32.4. Convention properties
32.5. Convention methods
32.6. Interacting with Maven repositories

33. The Signing Plugin

33.1. Usage
33.2. Signatory credentials
33.3. Specifying what to sign
33.4. Publishing the signatures
33.5. Signing POM files

34. Ivy Publishing (new)

34.1. The “ivy-publish” Plugin
34.2. Publications
34.3. Repositories
34.4. Performing a publish
34.5. Generating the Ivy module descriptor file without publishing
34.6. Complete example
34.7. Future features

35. Maven Publishing (new)

35.1. The “maven-publish” Plugin
35.2. Publications
35.3. Repositories
35.4. Performing a publish
35.5. Publishing to Maven Local
35.6. Generating the POM file without publishing

36. The Distribution Plugin

36.1. Usage
36.2. Tasks
36.3. Distribution contents
36.4. Publishing distributions

37. The Announce Plugin

37.1. Usage
37.2. Configuration

38. The Build Announcements Plugin

38.1. Usage