fun generateRdModel()

in rd-kt/rd-gen/src/main/kotlin/com/jetbrains/rd/generator/nova/generate.kt [11:93]
56 lines of code
10 McCabe index (conditional complexity)

fun generateRdModel(
    classLoader: ClassLoader,
    namespacePrefixes: Array<String>,
    verbose: Boolean = false,
    generatorsFilter: Regex? = null,
    clearOutputFolderIfExists: Boolean = false,
    generationSpecs: List<GenerationSpec> = emptyList()
): Set<File> {
    val startTime = System.currentTimeMillis()

    val genfilter = generatorsFilter ?: Regex(".*")

    if (verbose) {
        println()
        println("RdGen model generator started")
        println("Searching classes with namespace prefixes: '${namespacePrefixes.joinToString(", ")}'")
        println("Regex for filtering generators: '${genfilter.pattern}'")

        if (generationSpecs.isNotEmpty())
            println("Found ${generationSpecs.size} gradle generators")
    }


    val javaClasses = collectClasses(classLoader, namespacePrefixes, verbose)

    val toplevels = collectTopLevels(javaClasses, verbose)


    val validationErrors = ArrayList<String>()

    val roots = toplevels.map { it.root }.distinct()
    roots.forEach { root ->
        root.initialize()
        root.validate(validationErrors)
    }


    if (validationErrors.isNotEmpty())
        throw GeneratorException("Model validation fail:" +
            validationErrors.joinToString ("") {"\n\n>> $it"}
        )

    val generatorsToInvoke = collectSortedGeneratorsToInvoke(roots, javaClasses, genfilter, verbose, generationSpecs)

    if (verbose) {
        println()
        println("After filtering ${generatorsToInvoke.size} generator(s) to run")
    }

    val generatedFolders = HashSet<File>()
    for ((gen, root) in generatorsToInvoke) {
        val shouldClear = clearOutputFolderIfExists &&
            //whether we cleared this folder before or not?
            generatorsToInvoke
                .asSequence()
                .map { it.generator }
                .takeWhile { it != gen }
                .map {it.folder.canonicalPath}
                .none { gen.folder.canonicalPath.run { this == it || this.startsWith(it + File.separator)} }

        //Here is the real part
        if (verbose)
            println("Invoke $gen on $root, clearFolder=$shouldClear")

        ::settingCtx.usingValue(gen) {
            prepareGenerationFolder(gen.folder, shouldClear)

///         -----------------------
///             ACTUAL GENERATE
///         ----------------------
            gen.generate(toplevels.filter { it.root == root })


        }

        generatedFolders.add(gen.folder)
    }

    val endTime = System.currentTimeMillis()
    if (verbose) println("Generation finished in ${endTime - startTime} ms")

    return generatedFolders
}