Gradle Effective Implementation Guide

Table of Contents

• Preface

• Chapter 1: Starting with Gradle
• Introducing Gradle
• Declarative builds and convention over configuration
• Support for Ant tasks and Maven repositories
• Incremental builds
• Multi-project builds
• Gradle wrapper
• Free and open source
• Getting started
• Installing Gradle
• Writing our first build script
• Default Gradle tasks
• Task name abbreviation
• Executing multiple tasks
• Command-line options
• Logging options
• Changing the build file and directory
• Running tasks without execution
• Gradle daemon
• Profiling
• Understanding the Gradle user interface
• Task Tree
• Favorites
• Command Line
• Setup
• Summary

• Chapter 2: Creating Gradle Build Scripts
• Writing a build script
• Defining tasks
• Defining actions with the Action interface
• Build scripts are Groovy code
• Defining dependencies between tasks
• Defining dependencies via tasks
• Defining dependencies via closures
• Setting default tasks
• Organizing tasks
• Adding a description to tasks
• Grouping tasks together
• Adding tasks in other ways
• Using task rules
• Accessing tasks as project properties
• Adding additional properties to tasks
• Avoiding common pitfalls
• Skipping tasks
• Using onlyIf predicates
• Skipping tasks by throwing StopExecutionException
• Enabling and disabling tasks
• Skipping from the command line
• Skipping tasks that are up-to-date
• Summary

• Chapter 3: Working with Gradle Build Scripts
• Working with files
• Locating files
• Using file collections
• Working with file trees
• Copying files
• Renaming files
• Filtering files
• Archiving files
• Project properties
• Defining custom properties in script
• Passing properties via the command line
• Defining properties via system properties
• Adding properties via environment variables
• Defining properties using an external file
• Using logging
• Controlling output
• Using the Gradle wrapper
• Creating wrapper scripts
• Customizing the Gradle wrapper
• Summary

• Chapter 4: Using Gradle for Java Projects
• Using plugins
• Getting started
• Using the Java plugin
• Working with source sets
• Creating a new source set
• Custom configuration
• Working with properties
• Creating documentation
• Assembling archives
• Summary

• Chapter 5: Dependency Management
• Dependency configuration
• Repositories
• Adding Maven repositories
• Adding Ivy repositories
• Adding a local directory repository
• Defining dependencies
• Using external module dependencies
• Using project dependencies
• Using file dependencies
• Using client module dependencies
• Using Gradle and Groovy dependencies
• Accessing configuration dependencies
• Setting dynamic versions
• Resolving version conflicts
• Adding optional ANT tasks
• Using dependency configurations as files
• Summary

• Chapter 6: Testing, Building, and Publishing Artifacts
• Testing
• Using TestNG for testing
• Configuring the test process
• Determining tests
• Logging test output
• Generating test reports
• Running Java applications
• Running an application from a project
• Running an application as task
• Running an application with the application plugin
• Creating a distributable application archive
• Publishing artifacts
• Uploading to a Maven repository
• Multiple artifacts
• Signing artifacts
• Publishing signature files
• Configuring conditional signing
• Packaging Java Enterprise Edition applications
• Creating a WAR file
• Using the War plugin
• Creating an EAR file
• Using the Ear plugin
• Summary

• Chapter 7: Multi-project Builds
• Working with multi-project builds
• Executing tasks by project path
• Using a flat layout
• Defining projects
• Filtering projects
• Defining task dependencies between projects
• Defining configuration dependencies
• Working with Java multi-project builds
• Using partial builds
• Using the Jetty plugin
• Summary

• Chapter 8: Mixed Languages
• Using the Groovy plugin
• Creating documentation with the Groovy plugin
• Using the Scala plugin
• Creating documentation with the Scala plugin
• Summary

• Chapter 9: Maintaining Code Quality
• Using the Checkstyle plugin
• Using the PMD plugin
• Using the FindBugs plugin
• Using the JDepend plugin
• Using the CodeNarc plugin
• Using the Sonar plugin
• Summary

• Chapter 10: Writing Custom Tasks and Plugins
• Creating a custom task
• Creating a custom task in the build file
• Using incremental build support
• Creating a task in the project source directory
• Writing tests
• Creating a task in a standalone project
• Creating a custom plugin
• Creating a plugin in the build file
• Creating a plugin in the project source directory
• Testing a plugin
• Creating a plugin in a standalone project
• Summary

• Chapter 11: Using Gradle with Continuous Integration
• Creating a sample project
• Using Jenkins
• Adding the Gradle plugin
• Configuring Jenkins job
• Running the job
• Configuring artifacts and test results
• Adding Gradle versions
• Using JetBrains TeamCity
• Creating a project
• Running the project
• Using Atlassian Bamboo
• Defining a build plan
• Running the build plan
• Summary

• Chapter 12: IDE Support
• Using the Eclipse plugin
• Customizing generated files
• Customizing using DSL
• Customizing with merge hooks
• Customizing with XML manipulation
• Merging configuration
• Configuring WTP
• Customizing file generation
• Using the IntelliJ IDEA plugin
• Customizing file generation
• Customizing using DSL
• Customizing with merged hooks
• Customizing with XML manipulation
• Running Gradle in Eclipse
• Installing Gradle plugin
• Importing Gradle project
• Running tasks
• Editing build files
• Running Gradle in IntelliJ IDEA
• Installing the plugin
• Importing a project
• Running tasks
• Summary

• Index