Table of Contents
Chapter 1. Introduction to project automation
1.1. Life without project automation
1.2. Benefits of project automation
1.2.1. Prevents manual intervention
1.3. Types of project automation
Chapter 2. Next-generation builds with Gradle
2.2. Gradle’s compelling feature set
2.2.1. Expressive build language and deep API
2.2.4. Robust and powerful dependency management
2.2.6. Effortless extendibility
2.2.7. Integration with other build tools
2.3. The bigger picture: continuous delivery
2.5. Getting started with Gradle
Chapter 3. Building a Gradle project by example
3.1. Introducing the case study
3.1.2. Task management use cases
3.3. Web development with Gradle
Chapter 4. Build script essentials
4.2.1. Managing the project version
4.2.3. Accessing DefaultTask properties
4.2.4. Defining task dependencies
4.2.7. Understanding task configuration
4.2.8. Declaring task inputs and outputs
4.2.9. Writing and using a custom task
4.3. Hooking into the build lifecycle
Internal task graph representation
4.3.1. Hooking into the task execution graph
Chapter 5. Dependency management
5.1. A quick overview of dependency management
5.1.1. Imperfect dependency management techniques
5.1.2. Importance of automated dependency management
5.2. Learning dependency management by example
5.3. Dependency configurations
5.3.1. Understanding the configuration API representation
5.4.1. Understanding the dependency API representation
5.5. Using and configuring repositories
5.6. Understanding the local dependency cache
5.7. Troubleshooting dependency problems
5.7.1. Responding to version conflicts
5.7.2. Enforcing a specific version
Chapter 6. Multiproject builds
6.2. Assembling a multiproject build
6.2.1. Introducing the settings file
6.2.2. Understanding the Settings API representation
6.3.1. Understanding the Project API representation
6.3.2. Defining specific behavior
6.3.3. Declaring project dependencies
6.3.4. Partial multiproject builds
6.4.1. Creating build files per project
Chapter 7. Testing with Gradle
7.2. Testing Java applications
7.4. Configuring test execution
7.4.2. Understanding the Test API representation
7.4.3. Controlling runtime behavior
7.4.4. Controlling test logging
7.4.5. Parallel test execution
7.5.1. Introducing the case study
7.5.3. Supporting integration tests in the build
8.1. Introducing the plugin case study
8.4. Writing custom task classes
8.5. Using and building object plugins
8.5.1. Applying object plugins
8.5.2. Anatomy of an object plugin
8.5.3. Writing an object plugin
8.5.4. Plugin extension mechanism
8.5.5. Assigning a meaningful plugin name
Chapter 9. Integration and migration
9.1.1. Using Ant script functionality from Gradle
Chapter 10. IDE support and tooling
10.1. Using IDE plugins to generate project files
10.2. Managing Gradle projects in popular IDEs
10.2.1. Gradle support in SpringSource STS
Chapter 11. Building polyglot projects
11.1. Managing JavaScript with Gradle
11.1.1. Typical tasks when dealing with JavaScript
11.1.2. Using JavaScript in the To Do application
11.1.3. Dependency management for JavaScript libraries
11.1.4. Merging and minifying JavaScript using a third-party Ant task
11.1.5. JavaScript optimization as part of the development workflow
11.1.6. JavaScript code analysis using an external Java library
11.2. Building polyglot, JVM-based projects
11.2.1. Base capabilities of JVM language plugins
Chapter 12. Code quality management and monitoring
12.1. Integrating code analysis into your build
12.2.1. Exploring code coverage tools
12.3. Performing static code analysis
12.3.1. Exploring static code analysis tools
12.3.2. Using the Checkstyle plugin
12.4.1. Installing and running Sonar
Chapter 13. Continuous integration
13.1. Benefits of continuous integration
13.2.1. Creating a GitHub account
13.3. Building a project with Jenkins
13.3.2. Installing the Git and Gradle plugins
13.3.3. Defining the build job
13.4. Exploring cloud-based solutions
13.5. Modeling a build pipeline with Jenkins
13.5.1. Challenges of building a pipeline
Chapter 14. Artifact assembly and publishing
14.1. Building artifacts and distributions
14.2. Publishing artifacts to a binary repository
14.2.1. Publishing to a Maven repository
14.2.2. Old versus new publishing mechanisms
14.2.3. Declaring a software component as a Maven publication
14.2.4. Publishing a software component to the local Maven cache
14.2.5. Declaring custom artifacts for publication
14.2.6. Modifying the generated POM
14.3. Publishing to a public binary repository
14.4. Artifact assembly and publishing as part of the build pipeline
14.4.2. Publish once, reuse later
14.4.3. Picking an appropriate versioning scheme
14.4.4. Including build information in a deployable artifact
Chapter 15. Infrastructure provisioning and deployment
15.1. Infrastructure provisioning
15.1.1. Infrastructure as code
15.2. Targeting a deployment environment
15.2.1. Defining configuration in a Groovy script
15.2.2. Reading the configuration with Groovy’s ConfigSlurper
15.3.1. Retrieving the artifact from the binary repository
15.4.1. Verifying a successful deployment with smoke tests
15.4.2. Verifying application functionality with acceptance tests
15.5. Deployment as part of the build pipeline
15.5.1. Automatic deployment to test environment
15.5.3. On-demand deployment to UAT and production environment
Appendix A. Driving the command line
Appendix B. Groovy for Gradle users
B.2. How much Groovy do I need to know?
B.3. Comparing Java and Groovy syntax
B.4. Essential Groovy features
B.4.2. Optional data type declaration