if (dimensions.isEmpty()) {
            return ''
        }
        return dimensions.values()*.name.join('/') + '/'
    }

    String getAsVariantName() {
        return dimensions.values()*.name*.capitalize().join('').uncapitalize()
    }

    String getAsPublishName() {
        if (dimensions.isEmpty()) {
            return ''
        }
        return '_' + dimensions.values()*.name.join('_').replaceAll('-', '_')

        ["compile", "runtime"].each { base ->
            [6: "android", 8: "jre"].each { targetJvmVersion, jarName ->
                context.details.addVariant("jdk$targetJvmVersion${base.capitalize()}", base) {
                    attributes {
                        attributes.attribute(TargetJvmVersion.TARGET_JVM_VERSION_ATTRIBUTE, targetJvmVersion)
                    }
                    withFiles {

 */

package gradlebuild.basics

import java.util.Locale

fun String.toLowerCase(): String =
    lowercase(Locale.US)

fun String.toUpperCase(): String =
    uppercase(Locale.US)

fun String.capitalize(): String =
    replaceFirstChar { it.uppercase(Locale.US) }

fun String.decapitalize(): String =

            override fun exception(): ProblemFactory.Builder {
                exceptionMessage = message.toString().capitalized()
                return this
            }

            override fun exception(builder: (String) -> String): ProblemFactory.Builder {
                exceptionMessage = builder(message.toString().capitalized())
                return this
            }

        listOf("compile", "runtime").forEach { base ->
            mapOf(6 to "android", 8 to "jre").forEach { (targetJvmVersion, jarName) ->
                context.details.addVariant("jdk$targetJvmVersion${base.capitalize()}", base) {
                    attributes {
                        attributes.attribute(TargetJvmVersion.TARGET_JVM_VERSION_ATTRIBUTE, targetJvmVersion)
                    }
                    withFiles {

    public static Person maggie() { return MAGGIE; }

    // ...
//end::sample[]
    public static Person named(String firstName) {
        String capitalized = WordUtils.capitalizeFully(firstName);
        for (Person person : FAMILY) {
            if (capitalized.equals(person.getFirstName())) {
                return person;
            }
        }
        return null;
    }

        projectFile.projectConfigurations.values().each {
            assert it.buildCommand == "\"../../../${hostGradleWrapperFile.name}\" -p \"../../..\" :installMain${it.name.capitalize()}Executable"
            assert it.outputFile == OperatingSystem.current().getExecutableName("../../../build/install/main/${it.name}/lib/main")
        }
        def filtersFile = filtersFile("other/filters.vcxproj.filters")

    private final String projectName;

    public SwiftSourceElement(String projectName) {
        this.projectName = projectName;
    }

    public String getModuleName() {
        return StringUtils.capitalize(projectName);
    }

    public final String getProjectName() {
        return projectName;
    }

        buildScriptBuilder.repositories().mavenCentral("Use Maven Central for resolving dependencies.");

        String pluginId = settings.getPackageName() + ".greeting";
        String pluginClassName = StringUtils.capitalize(GUtil.toCamelCase(settings.getProjectName())) + "Plugin";

        buildScriptBuilder
            .fileComment("This generated file contains a sample Gradle plugin project to get you started.")

        }
        tasks.withType<Delete>().configureEach {
            if (name == "clean${name.capitalize()}") {
                // do not use 'tasks.named("clean...")' because that realizes the base task to apply the clean rule
                delete(performanceTestReport)
                dependsOn("clean${performanceTestReportZipTask.name.capitalize()}")
            }
        }
        return performanceTestReport
    }