第十三章. 编写构建脚本

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域模型中，所有增强的对象都可以保存用户定义的额外属性。这包括但不限于项目（projects），任务（tasks）和源码集（source sets）。额外属性可以通过所属对象的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 可以在你试图设置（预定义的或额外的） 属性，但拼写错误或不存在时快速失败。额外属性在任何能够访问它们所属对象的地方都可以被访问，这使它们有着比局部变量更广的作用域。父项目上的额外属性，在子项目中也可以访问。
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. 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 project are visible from its subprojects.

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

Groovy对标准的Java类添加了许多有用的方法。例如，Iterable新增了each方法，可以对Iterable的元素进行遍历：
Groovy adds lots of useful methods to the standard Java 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')
}