第十三章 编写构建脚本

Project 对象提供了一些在构建脚本中可用的标准的属性。下表列出了常用的几个属性。
The Project object provides some standard properties, which are available in your build script. The following table lists a few of the commonly used ones.

局部变量是用 def 关键字声明的。它们只在定义它们的范围内可以被访问。局部变量是Groovy 语言底层的一个特征。
Local variables are declared with the def keyword. They are only visible in the scope where they have been declared. Local variables are a feature of the underlying Groovy language.

def dest = "dest"

task copy(type: Copy) {
    from "source"
    into dest
}

Gradle 的域模型中，所有增强的对象都可以容纳用户定义的额外的属性。这包括但并不限于项目（project）、任务（task）和源码集（source set）。额外的属性可以通过所属对象的 ext 属性进行添加，读取和设置。或者，可以使用 ext 块同时添加多个属性。
All enhanced objects in Gradle's domain model can hold extra user-defined properties. This includes, but is not limited to, projects, tasks, and source sets. Extra properties can be added, read and set via the owning object's ext property. Alternatively, an ext block can be used to add multiple properties at once.

apply plugin: "java"

ext {
    springVersion = "3.1.0.RELEASE"
    emailNotification = "build@master.org"
}

sourceSets.all { ext.purpose = null }

sourceSets {
    main {
        purpose = "production"
    }
    test {
        purpose = "test"
    }
    plugin {
        purpose = "production"
    }
}

task printProperties << {
    println springVersion
    println emailNotification
    sourceSets.matching { it.purpose == "production" }.each { println it.name }
}

> gradle -q printProperties
3.1.0.RELEASE
build@master.org
main
plugin

在此示例中， 一个 ext 代码块将两个额外属性添加到 project 对象中。此外，通过将 ext.purpose 设置为 null （ null 是一个允许的值），一个名为 purpose 的属性被添加到每个源码集（source set）。一旦属性被添加，他们就可以像预定的属性一样被读取和设置。
In this example, an ext block adds two extra properties to the project object. Additionally, a property named purpose is added to each source set by setting ext.purpose to null ( null is a permissible value). Once the properties have been added, they can be read and set like predefined properties.

通过添加属性所要求特殊的语法，Gradle 可以在你试图设置 （预定义的或额外的） 的属性，但该属性拼写错误或不存在时 fail fast。 ^{[ 5 ]} 额外属性在任何能够访问它们所属的对象的地方都可以被访问，这使它们有着比局部变量更广泛的作用域。父项目上的额外属性，在子项目中也可以访问。
By requiring special syntax for adding a property, Gradle can fail fast when an attempt is made to set a (predefined or extra) property but the property is misspelled or does not exist. ^{[ 5 ]} Extra properties can be accessed from anywhere their owning object can be accessed, giving them a wider scope than local variables. Extra properties on a parent project are visible from subprojects.

有关额外属性和它们的 API 的详细信息，请参阅 ExtraPropertiesExtension 。
For further details on extra properties and their API, see ExtraPropertiesExtension .

Groovy 对 JVM 的类增加了很多有用的方法。例如， iterable 新增的 each 方法，会对 iterable 的元素进行遍历：
Groovy adds lots of useful methods to JVM classes. For example, Iterable gets an each method, which iterates over the elements of the Iterable :

// Iterable gets an each() method
configurations.runtime.each { File f -> println f }

可以看看 http://groovy.codehaus.org/groovy-jdk/ ，了解更多详细信息。
Have a look at http://groovy.codehaus.org/groovy-jdk/ for more details.

Groovy 会自动地把一个属性的引用转换为对适当的 getter 或 setter 方法的调用。
Groovy automatically converts a property reference into a call to the appropriate getter or setter method.

// Using a getter method
println project.buildDir
println getProject().getBuildDir()

// Using a setter method
project.buildDir = 'target'
getProject().setBuildDir('target')

调用方法时括号是可选的。
Parentheses are optional for method calls.

test.systemProperty 'some.prop', 'value'
test.systemProperty('some.prop', 'value')

Groovy 提供了一些定义 List 和 Map 实例的简洁写法。
Groovy provides some shortcuts for defining List and Map instances.

// List literal
test.includes = ['org/gradle/api/**', 'org/gradle/internal/**']

List<String> list = new ArrayList<String>()
list.add('org/gradle/api/**')
list.add('org/gradle/internal/**')
test.includes = list

// Map literal
apply plugin: 'java'

Map<String, String> map = new HashMap<String, String>()
map.put('plugin', 'java')
apply(map)

Gradle DSL 在很多地方使用闭包。你可以 在这里 查看更多有关闭包的资料。当方法的最后一个参数是一个闭包时，你可以把闭包放在方法调用之后：
The Gradle DSL uses closures in many places. You can find out more about closures here . When the last parameter of a method is a closure, you can place the closure after the method call:

repositories {
    println "in a closure"
}
repositories() { println "in a closure" }
repositories({ println "in a closure" })

每个闭包都有一个 委托 对象，Groovy 使用它来查找变量和方法的引用，而不是作为闭包的局部变量或参数。Gradle 在 配置闭包 中使用到它，把 委托 对象设置为被配置的对象。
Each closure has a delegate object, which Groovy uses to look up variable and method references which are not local variables or parameters of the closure. Gradle uses this for configuration closures , where the delegate object is set to the object to be configured.

dependencies {
    assert delegate == project.dependencies
    compile('junit:junit:4.11')
    delegate.compile('junit:junit:4.11')
}