return key;
        }
        String keyStr = key.toString();
        if (keyStr.indexOf('_') < 0) {
            keyStr = CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_UNDERSCORE, StringUtils.uncapitalize(keyStr));
        } else {
            keyStr = CaseFormat.LOWER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, keyStr);
        }
        return keyStr;
    }

    @Override
    public int size() {

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 =

        assertEquals("abc", StringUtil.decapitalize("abc"));
        assertEquals("abc", StringUtil.decapitalize("Abc"));
        assertEquals("ABC", StringUtil.decapitalize("ABC"));
        assertEquals("userId", StringUtil.decapitalize("UserId"));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testEndsWithIgnoreCase() throws Exception {

     * <p>
     * 次のように使います．
     * </p>
     *
     * <pre>
     * StringUtil.capitalize("UserId")  = "userId"
     * StringUtil.capitalize("ABC")  = "ABC"
     * </pre>
     *
     * @param name
     *            名前
     * @return 結果の文字列
     */
    public static String decapitalize(final String name) {
        if (isEmpty(name)) {
            return name;
        }

}

fun setupGeneratorTask(language: Language, kind: String, modularizationOption: ModularizationOption) {
    val buildInitType = "${language.getName()}-$kind"
    val capName = language.getName().capitalize()
    val capKind = kind.capitalize().replace("y", "ie") + "s"
    val languageDisplayName = language.toString().replace("C++", "{cpp}")
    val sampleName = "building$capName$capKind" + if (modularizationOption.isMulti()) "MultiProject" else ""

        else {
            val prefixRemoved = method.name.drop(3)
            if (hasSetterName && isBoolean) listOf("is$prefixRemoved", prefixRemoved.decapitalize())
            else listOf(prefixRemoved.decapitalize())
        }

    val propertyQualifiedNames =
        propertyNames.map { "$qualifiedBaseName.$it" }

    return collectDescendantsOfType { ktProperty ->
        when {

import gradlebuild.basics.capitalize
import gradlebuild.incubation.tasks.IncubatingApiAggregateReportTask

plugins {
    id("base")
}

val reports by configurations.creating {
    isVisible = false
    isCanBeResolved = false
    isCanBeConsumed = false
    description = "Dependencies to aggregate reports from"
}

val allIncubationReports = tasks.register<IncubatingApiAggregateReportTask>("allIncubationReports") {
    group = "verification"

#         ; propertiesHtmlList = list:{ [env or config or label or message] }
#     }
#     ; appMap = map:{
#         ; [application name, camel case, initial uncapitalised] = map:{
#             ; path = [relative path to application project from DBFlute client]
#             ; freeGenList = list:{ [env or config or label or message or html] }

import gradlebuild.basics.capitalize
import com.google.gson.Gson
import java.net.URL

wrapperUpdateTask("nightly", "nightly")
wrapperUpdateTask("rc", "release-candidate")
wrapperUpdateTask("current", "current")

tasks.withType<Wrapper>().configureEach {
    val jvmOpts = "-Dfile.encoding=UTF-8"
    inputs.property("jvmOpts", jvmOpts)
    doLast {
        val optsEnvVar = "DEFAULT_JVM_OPTS"

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import gradlebuild.basics.accessors.kotlinMainSourceSet
import gradlebuild.basics.capitalize
import gradlebuild.basics.releasedVersionsFile
import gradlebuild.basics.repoRoot
import gradlebuild.incubation.tasks.IncubatingApiReportTask

plugins {
    java
    groovy
}