samples/build/SampleGenProperties.groovy

/*
* Copyright 2013 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*     http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.example.android.samples.build

import freemarker.ext.dom.NodeModel
import groovy.transform.Canonical
import org.gradle.api.GradleException
import org.gradle.api.Project
import org.gradle.api.file.FileTree

/**
 * Gradle extension that holds properties for sample generation.
 *
 * The sample generator needs a number of properties whose values can be
 * inferred by convention from a smaller number of initial properties.
 * This class defines fields for the initial properties, and getter
 * methods for the inferred properties. It also defines a small number
 * of convenience methods for setting up template-generation tasks.
 */
@Canonical
class SampleGenProperties {
    /**
     * The Gradle project that this extension is being applied to.
     */
    Project project

    /**
     *  Directory where the top-level sample project lives
     */
    def targetProjectPath

    /**
     * Relative path to samples/common directory
     */
    def pathToSamplesCommon

    /**
     * Relative path to build directory (platform/developers/build)
     */
    def pathToBuild

    /**
     * Java package name for the root package of this sample.
     */
    String targetSamplePackage

    /**
     *
     * @return The path to the sample project (as opposed to the top-level project, which
     *         what is that even for anyway?)
     */
    String targetSamplePath() {
        return "${targetProjectPath}/${targetSampleModule()}"
    }


    /**
     *
     * @return The path that contains common files -- can be cleaned without harming
     *         the sample
     */
    String targetCommonPath() {
        return "${targetSamplePath()}/src/common/java/com/example/android/common"
    }

    /**
     *
     * @return The path that contains template files -- can be cleaned without harming
     *         the sample
     */
    String targetTemplatePath() {
        return "${targetSamplePath()}/src/template"
    }

    /**
     * The name of this sample (and also of the corresponding .iml file)
     */
    String targetSampleName() {
        return project.file(targetProjectPath).getName()
    }

    /**
     * The name of the main module in the sample project
     */
    String targetSampleModule() {
        return "Application"
    }

    /**
     * The path to the template parameters file
     */
    String templateXml() {
        return "${targetProjectPath}/template-params.xml"
    }

    /**
     * Transforms a package name into a java-style OS dependent path
     * @param pkg cccc
     * @return The java-style path to the package's code
     */
    String packageAsPath(String pkg) {
        return pkg.replaceAll(/\./, File.separator)
    }

    /**
     * Transforms a path into a java-style package name
     * @param path The java-style path to the package's code
     * @return Name of the package to transform
     */
    String pathAsPackage(String path) {
        return path.replaceAll(File.separator, /\./)
    }

    /**
     * Returns the path to the common/build/templates directory
     */
    String templatesRoot() {
        return "${targetProjectPath}/${pathToBuild}/templates"
    }


    /**
     * Returns the path to common/src/java
     */
    String commonSourceRoot() {
        return "${targetProjectPath}/${pathToSamplesCommon}/src/java/com/example/android/common"
    }

    /**
     * Returns the path to the template include directory
     */
    String templatesInclude() {
        return "${templatesRoot()}/include"
    }

    /**
     * Returns the output file that will be generated for a particular
     * input, by replacing generic pathnames with project-specific pathnames
     * and dropping the .ftl extension from freemarker files.
     *
     * @param relativeInputPath Input file as a relative path from the template directory
     * @return Relative output file path
     */
    String getOutputForInput(String relativeInputPath) {
        String outputPath = relativeInputPath
        outputPath = outputPath.replaceAll('_PROJECT_', targetSampleName())
        outputPath = outputPath.replaceAll('_MODULE_', targetSampleModule())
        outputPath = outputPath.replaceAll('_PACKAGE_', packageAsPath(targetSamplePackage))

        // This is kind of a hack; IntelliJ picks up any and all subdirectories named .idea, so
        // named them ._IDE_ instead. TODO: remove when generating .idea projects is no longer necessary.
        outputPath = outputPath.replaceAll('_IDE_', "idea")
        outputPath = outputPath.replaceAll(/\.ftl$/, '')

        // Any file beginning with a dot won't get picked up, so rename them as necessary here.
        outputPath = outputPath.replaceAll('gitignore', '.gitignore')
        return outputPath
    }

    /**
     * Returns the tree(s) where the templates to be processed live. The template
     * input paths that are passed to
     * {@link SampleGenProperties#getOutputForInput(java.lang.String) getOutputForInput}
     * are relative to the dir element in each tree.
     */
    FileTree[] templates() {
        def result = []
        def xmlFile = project.file(templateXml())
        if (xmlFile.exists()) {
            def xml = new XmlSlurper().parse(xmlFile)
            xml.template.each { template ->
                result.add(project.fileTree(dir: "${templatesRoot()}/${template.@src}"))
            }
        } else {
            result.add(project.fileTree(dir: "${templatesRoot()}/create"))
        }
        return result;
    }

    /**
     * Path(s) of the common directories to copy over to the sample project.
     */
    FileTree[] common() {
        def result = []
        def xmlFile = project.file(templateXml())
        if (xmlFile.exists()) {
            def xml = new XmlSlurper().parse(xmlFile)
            xml.common.each { common ->
                println "Adding common/${common.@src} from ${commonSourceRoot()}"
                result.add(project.fileTree (
                        dir: "${commonSourceRoot()}",
                        include: "${common.@src}/**/*"
                ))
            }
        }
        return result
    }

    /**
     * Returns the hash to supply to the freemarker template processor.
     * This is loaded from the file specified by {@link SampleGenProperties#templateXml()}
     * if such a file exists, or synthesized with some default parameters if it does not.
     * In addition, some data about the current project is added to the "meta" key of the
     * hash.
     *
     * @return The hash to supply to freemarker
     */
    Map templateParams() {
        Map result = new HashMap();

        def xmlFile = project.file(templateXml())
        if (xmlFile.exists()) {
            // Parse the xml into Freemarker's DOM structure
            def params = freemarker.ext.dom.NodeModel.parse(xmlFile)

            // Move to the <sample> node and stuff that in our map
            def sampleNode = (NodeModel)params.exec(['/sample'])
            result.put("sample", sampleNode)
        } else {
            // Fake data for use on creation
            result.put("sample", [
                    name:targetSampleName(),
                    package:targetSamplePackage,
                    minSdk:4
            ])
        }

        // Extra data that some templates find useful
        result.put("meta", [
                root: targetProjectPath,
                module: targetSampleModule(),
                common: pathToSamplesCommon,
                build: pathToBuild,
        ])
        return result
    }


    /**
     * Generate default values for properties that can be inferred from an existing
     * generated project, unless those properties have already been
     * explicitly specified.
     */
    void getRefreshProperties() {
        if (!this.targetProjectPath) {
            this.targetProjectPath = project.projectDir
        }
        def xmlFile = project.file(templateXml())
        if (xmlFile.exists()) {
            println "Template XML: $xmlFile"
            def xml = new XmlSlurper().parse(xmlFile)
            this.targetSamplePackage = xml.package.toString()
            println "Target Package: $targetSamplePackage"
        }
    }

    /**
     * Generate default values for creation properties, unless those properties
     * have already been explicitly specified. This method will attempt to get
     * these properties interactively from the user if necessary.
     */
    void getCreationProperties() {
        def calledFrom = project.hasProperty('calledFrom') ? new File(project.calledFrom)
                : project.projectDir
        calledFrom = calledFrom.getCanonicalPath()
        println('\n\n\nReady to create project...')

        if (project.hasProperty('pathToSamplesCommon')) {
            this.pathToSamplesCommon = project.pathToSamplesCommon
        } else {
            throw new GradleException (
                    'create task requires project property pathToSamplesCommon')
        }


        if (project.hasProperty('pathToBuild')) {
            this.pathToBuild = project.pathToBuild
        } else {
            throw new GradleException ('create task requires project property pathToBuild')
        }

        if (!this.targetProjectPath) {
            if (project.hasProperty('out')) {
                this.targetProjectPath = project.out
            } else {
                this.targetProjectPath = System.console().readLine(
                        "\noutput directory [$calledFrom]:")
                if (this.targetProjectPath.length() <= 0) {
                    this.targetProjectPath = calledFrom
                }
            }
        }

        if (!this.targetSamplePackage) {
            def defaultPackage = "com.example.android." +
                    this.targetSampleName().toLowerCase()
            this.targetSamplePackage = System.console().readLine(
                    "\nsample package name[$defaultPackage]:")
            if (this.targetSamplePackage.length() <= 0) {
                this.targetSamplePackage = defaultPackage
            }
        }
    }

}