This chapter introduces the basics of the Gradle command-line. You run a build using the gradle command, which you have already seen in action in previous chapters.
You can execute multiple tasks in a single build by listing each of the tasks on the command-line. For example,
the command gradle compile test will execute the compile and
test tasks. Gradle will execute the tasks in the order that they are listed on the
command-line, and will also execute the dependencies for each task. Each task is executed once only,
regardless of why it is included in the build: whether it was specified on the command-line, or it a
dependency of another task, or both. Let's look at an example.
Below four tasks are defined. Both dist and test depend on the
compile task. Running gradle dist test for this build script
results in the compile task being executed only once.
Example 10.1. Executing multiple tasks
build.gradle
task compile << {
println 'compiling source'
}
task compileTest(dependsOn: compile) << {
println 'compiling unit tests'
}
task test(dependsOn: [compile, compileTest]) << {
println 'running unit tests'
}
task dist(dependsOn: [compile, test]) << {
println 'building the distribution'
}Output of gradle dist test
> gradle dist test :compile compiling source :compileTest compiling unit tests :test running unit tests :dist building the distribution BUILD SUCCESSFUL Total time: 1 secs
Because each task is executed once only, executing gradle test test is exactly the same
as executing gradle test.
You can exclude a task from being executed using the -x command-line option and providing
the name of the task to exclude. Let's try this with the sample build file above.
Example 10.2. Excluding tasks
Output of gradle dist -x test
> gradle dist -x test :compile compiling source :dist building the distribution BUILD SUCCESSFUL Total time: 1 secs
You can see from the output of this example, that the test task is not executed, even
though it is a dependency of the dist task. You will also notice that the
test task's dependencies, such as compileTest
are not executed either. Those dependencies of test that are required by another task, such as
compile, are still executed.
When you specify tasks on the command-line, you don't have to provide the full name of the task. You only need to provide enough of the
task name to uniquely identify the task. For example, in the sample build above, you can execute task
dist by running gradle d:
Example 10.3. Abbreviated task name
Output of gradle d
> gradle d :compile compiling source :compileTest compiling unit tests :test running unit tests :dist building the distribution BUILD SUCCESSFUL Total time: 1 secs
You can also abbreviate each word in a camel case task name. For example, you can execute task compileTest
by running gradle compTest or even gradle cT
Example 10.4. Abbreviated camel case task name
Output of gradle cT
> gradle cT :compile compiling source :compileTest compiling unit tests BUILD SUCCESSFUL Total time: 1 secs
You can also use these abbreviations with the -x command-line option.
When you run the gradle command, it looks for a build file in the current directory.
You can use the -b option to select another build file. For example:
Example 10.5. Selecting the project using a build file
subdir/myproject.gradle
task hello << {
println "using build file '$buildFile.name' in '$buildFile.parentFile.name'."
}Output of gradle -q -b subdir/myproject.gradle hello
> gradle -q -b subdir/myproject.gradle hello using build file 'myproject.gradle' in 'subdir'.
Alternatively, you can use the -p option to specify the project directory to use:
Example 10.6. Selecting the project using project directory
Output of gradle -q -p subdir hello
> gradle -q -p subdir hello using build file 'build.gradle' in 'subdir'.
Gradle provides several command-line options which show particular details of your build. This can be useful for understanding the structure and dependencies of your build, and for debugging problems.
If a report option is used without additional parameters, the respective report is generated for the current project.
If you add append ? to the option the report is generated for the current project and all its subprojects.
If you add append a project path the report will be generated for the
specified project.
In addition to the command-line options shown below, you can also use the project report plugin to add tasks to your project which will generate these reports.
Running gradle --tasks or gradle -t
gives you a list of the main tasks which make up the selected project. This report shows the default
tasks for the project, if any, and a description for each task. Below is an example of this report:
Example 10.7. Obtaining information about tasks
Output of gradle -q -t
> gradle -q -t ------------------------------------------------------------ Root Project ------------------------------------------------------------ Default tasks: dists Build tasks ----------- :clean - Deletes the build directory (build) :dists - Builds the distribution
By default, this report shows only those tasks which have been assigned to a task group. You can do this
by setting the group property for the task. You can also set the description
property, to provide a description to be included in the report for the task.
Example 10.8. Changing the content of the task report
build.gradle
task dists {
description = 'Builds the distribution'
group = 'build'
}You can obtain more information in the task listing by adding the --all option. With
this option, the task report lists all tasks in the project, grouped by main task, and the dependencies
for each task. Here is an example:
Example 10.9. Obtaining more information about tasks
Output of gradle -q -t --all
> gradle -q -t --all
------------------------------------------------------------
Root Project
------------------------------------------------------------
Default tasks: dists
Build tasks
-----------
:clean - Deletes the build directory (build)
:dists - Builds the distribution [:api:libs, :webapp:libs]
:libs - Builds the JARRunning gradle --dependencies
gives you a list of the dependencies of the selected project, broken down by configuration. For each
configuration, the direct and transitive dependencies of that configuration are shown in a tree. Below
is an example of this report:
Example 10.10. Obtaining information about dependencies
Output of gradle -q --dependencies ?
> gradle -q --dependencies ? ------------------------------------------------------------ Root Project ------------------------------------------------------------ No configurations ------------------------------------------------------------ Project :api ------------------------------------------------------------ compile |-----junit:junit:4.7:default ------------------------------------------------------------ Project :webapp ------------------------------------------------------------ compile |-----commons-io:commons-io:1.2:default
Running gradle --properties gives you a list of the properties of the selected
project. This is a snippet from the output:
Example 10.11. Information about properties
Output of gradle -q --properties :api
> gradle -q --properties :api
------------------------------------------------------------
Project :api
------------------------------------------------------------
additionalProperties: {}
all: [task ':api:clean', task ':api:libs']
allprojects: [project ':api']
ant: org.gradle.api.internal.project.DefaultAntBuilder@12345
antBuilderFactory: org.gradle.api.internal.project.DefaultAntBuilderFactory@12345
artifacts: org.gradle.api.internal.artifacts.dsl.DefaultArtifactHandler@12345
asDynamicObject: org.gradle.api.internal.DynamicObjectHelper@12345
asMap: {clean=task ':api:clean', libs=task ':api:libs'}
buildDir: /home/user/gradle/samples/userguide/tutorial/projectReports/api/build
buildDirName: build
buildFile: /home/user/gradle/samples/userguide/tutorial/projectReports/api/build.gradleSometimes you are interested in which tasks are executed in which order for a given set of tasks specified on the
command line, but you don't want the tasks to be executed. You can use the -m option for this.
For example gradle -m clean compile shows you all tasks to be executed as
part of the clean and compile tasks.
This is complementary to the -t option, which shows you the tasks which are available for
execution.
In this chapter, you have seen some of the things you can do with Gradle from the command-line. You can find out more about the gradle command in Appendix C, Gradle Command Line.