build.gradle

import org.gradle.plugins.jsoup.Jsoup
import org.gradle.plugins.pegdown.PegDown
import org.gradle.plugins.lesscss.LessCss
import org.gradle.plugins.xhtmlrenderer.XhtmlToPdf

def systemCharset = java.nio.charset.Charset.defaultCharset().name()
assert systemCharset == "UTF-8" : "Platform encoding must be UTF-8. Is currently $systemCharset. Set -Dfile.encoding=UTF-8."

// Put the downloads in a different place so clean doesn't wipe them outs
ext.downloadDir = file("downloads")
task cleanDownloads(type: Delete) {
    delete downloadDir
}

apply from: "gradle/downloads.gradle"

allprojects {
    apply plugin: "base"
    apply plugin: "idea"
    apply plugin: "jsoup"
    apply plugin: "lesscss"

    if (project == rootProject) {
        apply from: "idea/idea.gradle"
    }

    repositories {
        jcenter()
    }

    configurations {
        rhino
    }

    dependencies {
        rhino "rhino:js:1.7R2"
    }

    lesscss {
        rhinoClasspath = configurations.rhino
        lessCssRhinoJs = files(downloadLessCssRhino)
    }

    // Common output settings for all html transforms
    tasks.withType(Jsoup) {
        destination "$buildDir/html/${name}.html"
        inputEncoding "utf-8"
        transform {
            outputSettings().indentAmount(2).prettyPrint(true)
        }
    }

    ext.copyWithLess = { String name, String dir, Closure config = null ->
        def lessTask = task("${name}Less", type: LessCss) {
            source fileTree("$dir/style", { include "*.less" })
            destination "$buildDir/less/$name"
        }

        def copyTask = task("${name}Files", type: Sync) {
            into "$buildDir/$name"
            from(dir) {
                exclude "**/*.less"
            }

            from lessTask, {
                into "style"
            }
        }

        configure(copyTask, config)
    }
}

copyWithLess("base", "src/resources/base")  {
    from "src/fonts/lato", {
        into "style/fonts"
        include "Lato-Regular.ttf"
        include "Lato-Bold.ttf"
    }
}

copyWithLess("pdf", "src/resources/pdf")
copyWithLess("show", "src/resources/show")

project(":talks").subprojects {
    apply plugin: "base"
    apply plugin: "pegdown"
    apply plugin: "xhtmlrenderer"

    task concatSlidesMd(type: FileConcatTask) {
        source (fileTree("src/slides") { include "*.md" })
        destination "$buildDir/slides.md"
        joiner "\n\n"
    }

    task rawHtml(type: PegDown) {
        source concatSlidesMd
        destination "$buildDir/html/slides-raw.html"
        options << "definitions" << "smartypants" << "tables"
    }

    ["base", "pdf", "show"].each { transformType ->
        task ("${transformType}Html", type: Jsoup) { task ->
            def path = "src/transforms/${transformType}.groovy"

            def global = "$rootDir/$path"
            inputs.file global
            apply from: global, to: task

            def local = "$projectDir/$path"
            if (file(local).exists()) {
                inputs.file local
                apply from: local, to: task
            }
        }
    }

    baseHtml.source rawHtml
    [pdfHtml, showHtml]*.source baseHtml

    copyWithLess("base", "src/resources/base") {
        from rootProject.baseFiles
        from(baseHtml) {
            rename ".*", "index.html"
        }
    }

    copyWithLess("pdf", "src/resources/pdf") {
        from rootProject.pdfFiles
        from(baseFiles) {
            exclude "index.html"
        }

        from(pdfHtml) {
            rename ".*", "index.html"
        }
    }

    copyWithLess("show", "src/resources/show") {
        from rootProject.showFiles
        from(baseFiles) {
            exclude "index.html"
        }

        from(showHtml) {
            rename ".*", "index.html"
        }

        into ("deckjs") {
            from(rootProject.downloadDeckJs) {
                include "core/**/*"
                include "themes/transition/**/*"
                include "jquery*"
                include "modernizr*"
                include "*license*"
                include "extensions/hash/**/*"
            }
            from(rootProject.downloadDeckExtJs) {
                include "extensions/notes/**/*"
                include "extensions/clone/**/*"
            }
        }
    }

    task pdf(type: XhtmlToPdf) {
        inputs.files pdfFiles
        source "$pdfFiles.destinationDir/index.html"
        pdf = file("$buildDir/${project.name}.pdf")
        fonts = fileTree("$pdfFiles.destinationDir/style/fonts") {
            include "*.ttf"
        }
    }

    ext.demosSpec = copySpec {
        from "src/demos"
        exclude \
            "**/*/build",
            "**/*/target",
            "**/*/.gradle",
            "**/*/out",
            "**/*/*.ipr",
            "**/*/*.iws",
            "**/*/*.iml"
    }
    
    task "package"(overwrite: true, type: Sync) {
        into "$buildDir/package"
        from showFiles, {
            into "slides"
        }
        from pdf, {
            rename ".*", "slides.pdf"
        }
        into "demos", {
            with demosSpec
        }
        includeEmptyDirs = false
    }

    task packageZip(type: Zip) {
        from tasks.package
        archiveName "gradle-${project.name}.zip"
        destinationDir buildDir
    }
    
    task openShow() {
        dependsOn tasks.package
        doLast {
            try {
                def desktop = getClass().classLoader.loadClass("java.awt.Desktop").newInstance()
                desktop.browse(file("${tasks.package.destinationDir}/slides/index.html").toURI())
            } catch (ClassNotFoundException e) {
                throw new Exception("Must be Java 6+ to use this task")
            }
        }
    }
    
    clean {
        def demos = file("src/demos")
        if (demos.exists()) {
            demos.eachDir {
                delete file("$it/build")
                delete file("$it/.gradle")
            }
        }
    }
}

["package", "packageZip", "pdf"].each {
    task(it, dependsOn: getTasksByName(it, true))
}

class FileConcatTask extends SourceTask {
    @Input @Optional String joiner

    private destination
    @OutputFile File getDestination() { project.file(destination) }
    void setDestination(destination) { this.destination = destination }

    @TaskAction
    void doFileConcat() {
        getDestination().withOutputStream { out ->
            getSource().files.sort { it.name }.each {
                it.withInputStream { out << it }
                if (joiner) {
                    out << joiner
                }
            }
        }
    }
}