//可以省略参数括号,并且链式调用
// equivalent to: turn(left).then(right)
turn left then right

//groovy数字可以直接转换成字符串
// equivalent to: take(2.pills).of(chloroquinine).after(6.hours)
take 2.pills of chloroquinine after 6.hours

//两个参数用逗号隔开
// equivalent to: paint(wall).with(red, green).and(yellow)
paint wall with red, green and yellow

//命名参数用冒号
// with named parameters too
// equivalent to: check(that: margarita).tastes(good)
check that: margarita tastes good

//闭包作为参数也可以省略括号
// with closures as parameters
// equivalent to: given({}).when({}).then({})
given { } when { } then { }

//没有参数的方法必须有括号
// equivalent to: select(all).unique().from(names)
select all unique() from names

//如果调用链元素为奇数,那么最后一个元素是前面方法链返回对象的属性
//cookies 是take(3)返回值的一个属性
// equivalent to: take(3).cookies
// and also this: take(3).getCookies()
take 3 cookies

//将closure赋值给一个变量,这个closure接收一个参数,参数名是默认的 it
show = { println it }
square_root = { Math.sqrt(it) }

//为了容易理解,我将参数的type都添加上了,
//please方法需要一个closure,接着返回一个map,map的key是the,value是一个closure,
//这个closure接收一个closure,并返回一个map,
//这个map的keyu是of,value又是一个closure(不要晕了)
//最后一个closure接收一个参数n
def please(Closure action) {
     [the: { Closure what ->
        [of: { n -> action(what(n)) }]
    }]
}
//调用:
please show the square_root of 100
// 上面等价 please(show).the(square_root).of(100)
// 或 please { println it } .the { Math.sqrt(it) } .of 100

 as a build script executes, it configures an object of type Project. 
 This object is called the delegate object of the script. 
 The following table shows the delegate for each type of Gradle script.

三种不同的gradle脚本对应的委托对象
Build script（build.gradle） ->Project
Init script	->Gradle
Settings script(setting.gradle)	->Settings

• this: refers to the instance of the class that the closure was defined in.
• owner: is the same as this, unless the closure was defined inside another closure in which case the owner refers to the outer closure.
• delegate: is the same as owner. But, it is the only one that can be programmatically changed, and it is the one that makes Groovy closures really powerful.

the closure itself will be checked first, followed by the closure's this scope, then the closure's owner, then its delegate. 
However, Groovy is so flexible this strategy can be changed. 
Every closure has a property called resolvedStrategy. This can be set to:
	• Closure.OWNER_FIRST
	• Closure.DELEGATE_FIRST
	• Closure.OWNER_ONLY
	• Closure.DELEGATE_ONLY

来自 <https://dzone.com/articles/groovy-closures-owner-delegate> 

//method accepts 1 parameter - closure 
myMethod(myClosure)

//if method accepts only 1 parameter - parentheses can be omitted 
myMethod myClosure

//I can create in-line closure 
myMethod {println 'Hello World'}

//method accepts 2 parameters 
myMethod(arg1, myClosure)

//or the same as '4', but closure is in-line 
myMethod(arg1, { println 'Hello World' })

//if last parameter is closure - it can be moved out of parentheses 
myMethod(arg1) { println 'Hello World' }

buildscript {
    repositories {
        jcenter()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:1.2.3'
    }
}

allprojects { }	 Configures this project and each of its sub-projects.
artifacts { }	 Configures the published artifacts for this project.
buildscript { }	 Configures the build script classpath for this project.
configurations { }	 Configures the dependency configurations for this project.
dependencies { }	 Configures the dependencies for this project.
repositories { }	Configures the repositories for this project.
sourceSets { }	Configures the source sets of this project.
subprojects { }	Configures the sub-projects of this project.
publishing { }	Configures the PublishingExtension added by the publishing plugin.

apply plugin: 'com.android.application'

android {
    compileSdkVersion 22
    buildToolsVersion "22.0.1"

    defaultConfig {
        applicationId "com.trickyandroid.testapp"
        minSdkVersion 16
        targetSdkVersion 22
        versionCode 1
        versionName "1.0"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}

extension = project.extensions.create('android', AppExtension,
                this, (ProjectInternal) project, instantiator,
                buildTypeContainer, productFlavorContainer, signingConfigContainer)
        setDefaultConfig(extension.defaultConfig, extension.sourceSetsContainer)

//build.gradle
apply plugin: GreetingPlugin

//这里提供closure 来配置插件提供的greeting script block
greeting {
    message = 'Hi'
    greeter = 'Gradle'
}

class GreetingPlugin implements Plugin<Project> {
    void apply(Project project) {//注意我们是如果扩展Project对象的,通过extensions对象创建一个script block:greeting,而这个block关联的是一个对象
        project.extensions.create("greeting", GreetingPluginExtension)
        project.task('hello') << {  //注意我们是如何使用greeting的,没有通过extensioins
            println "${project.greeting.message} from ${project.greeting.greeter}"
        }
    }
}

class GreetingPluginExtension {
    String message
    String greeter
}
/*
    project.task('hello') << {  
        println "${project.greeting.message} from ${project.greeting.greeter}"
    }

    使用了重载操作符,等价:
    project.task('hello').leftShift({  println "${project.greeting.message} from ${project.greeting.greeter}" })

*/

Task task(String name, Closure configureClosure);
Task task(Map<String, ?> args, String name, Closure configureClosure);
Task task(Map<String, ?> args, String name) throws InvalidUserDataException;
Task task(String name) throws InvalidUserDataException;

task intro(dependsOn: hello) {
   doLast { println "I'm Gradle" }  
}