speaker {
    name 'Cédric Champeau'
    company 'Gradle Inc'
    oss 'Apache Groovy committer',
    successes 'Static type checker',
              'Static compilation',
              'Traits',
              'Markup template engine',
              'DSLs'
        failures Stream.of(bugs),
        twitter '@CedricChampeau',
        github 'melix',
        extraDescription '''Groovy in Action 2 co-author
Misc OSS contribs'''
}

speaker {
    name 'Louis Jacomet'
    company 'Gradle Inc'
    past 'Terracotta / Ehcache',
              'Freelance consultant',
        failures Stream.of(bugs),
        twitter '@ljacomet',
        github 'ljacomet',
        extraDescription '''Not fully figured out
how to stay out of management?!?'''
}

plugins {
    id 'com.gradle.build-scan' version '2.0.2'
}

buildScan {
    termsOfServiceUrl = 'https://gradle.com/terms-of-service'
    termsOfServiceAgree = 'yes'
}

./gradlew hello

./gradlew [taskName...] [--option-name...]

./gradlew :server:test

./gradlew tasks

./gradlew help --task <taskName>

./gradlew build -x test

./gradlew test --continue

./gradlew -t test

$ gradle hello -i
$ gradle -q hello

./gradlew

defaultTasks 'assemble', 'test'

configurations {
    implementation
    runtime
}

compileJava

task hello {
    doLast { print "Let's have a great week!" }
}

task compileMe(type: JavaCompile) {
    destinationDir "$buildDir/myDir"

    //enable compilation in a separate daemon process
    options.fork = true

    //enable incremental compilation
    options.incremental = true
}

configurations {
    implementation
}

dependencies {
    implementation 'org.slf4j:slf4j-api:1.7.25'
    implementation project(':common')
}

repositories {
   mavenCentral()
   jcenter()
   google()
}

repositories {
   maven {
      url "https://my-repo/
   }

   ivy {
      url "https://my-repo/
   }

   flatDir name: 'libs', dirs: "$projectDir/libs"
}

dependencies {
   api project(':core')
   implementation "com.google.code.gson:gson:2.8.2"
   implementation("org.ow2.asm:asm") {
      version { prefer "6.1.1" }
      because "Only version compatible with JDK 11"
   }

   testImplementation group:"junit", name:"junit", version:"4.12"
}

dependencies {
   api('dont.do.this.at:home:1.0') {
      changing = true
   }
}

configurations.all {
    resolutionStrategy {
        failOnVersionConflict()
        cacheDynamicVersionsFor(5, HOURS)
    }
}

configurations {
   compileClasspath.resolutionStrategy {
      eachDependency { DependencyResolveDetails details ->
         // specifying a fixed version for all
         // libraries with 'org.gradle' group
         if (details.requested.group == 'org.gradle') {
            details.useVersion '1.4'
         }
      }
   }
}

task shadedJar(type: ShadedJar) {
   jarFile = file("$buildDir/libs/shaded.jar")
   classpath = configurations.runtime
   mapping = ['org.apache': 'shaded.org.apache']
}

public class ShadedJar extends DefaultTask {
   ...
   @InputFiles
   FileCollection getClasspath() { ... }

   @Input
   Map<String, String> getMapping() { ... }
}

public class ShadedJar extends DefaultTask {
   ...

   @OutputFile
   File getJarFile() { ... }
}

@TaskAction
public void execute(IncrementalTaskInputs inputs) {
   if (!inputs.isIncremental()) {
      // clean build, for example
      // ...
   } else {
      inputs.outOfDate(change ->
         if (change.isAdded()) {
           ...
         } else if (change.isRemoved()) {
           ...
         } else {
            ...
         }
      });
   }
}

org.gradle.parallel = true
deployUrl = https://example.com/default

$ ./gradlew -Dorg.gradle.parallel=false \
> -PdeployUrl='https://example.com/custom'

def getRevision = {
    def cmd = 'git rev-parse HEAD'
    try {
        def proc = cmd.execute()
        return proc.text.trim()
    } catch (IOException) {
        return 'Unknown'
    }
}

ext.revision = getRevision()

class MyExtension {
    String someProperty
}

extensions.create("myDSL", MyExtension)

myDSL {
    someProperty = "someValue"
}

configurations.all {
    println "Configuration $it.name"
}
tasks.withType(Jar) {
    destinationDir = "somePath"
    doLast { /* do something */ }
}

plugins.withType(IdeaPlugin) {
    // Perform actions if plugin gets applied
}

task generateCode
task compileJava

compileJava.dependsOn generateCode

task jar {
  from sourceSets.main.output
}

task taskFromPlugin() {
    doLast { println "added by a script plugin!" }
}

apply from: "plugin.gradle"

buildCache {
    local(DirectoryBuildCache) {
        directory = new File(rootDir, 'build-cache')
        removeUnusedEntriesAfterDays = 30
    }
}

buildCache {
    remote(HttpBuildCache) {
        url = 'https://example.com:8123/cache/'
    }
}