main/kotlin/Generator.kt

/*
 * Copyright (C) 2020 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.
 */

import com.squareup.javapoet.ClassName
import com.squareup.javapoet.FieldSpec
import com.squareup.javapoet.JavaFile
import com.squareup.javapoet.MethodSpec
import com.squareup.javapoet.NameAllocator
import com.squareup.javapoet.ParameterSpec
import com.squareup.javapoet.TypeSpec
import java.io.File
import java.io.FileInputStream
import java.io.FileNotFoundException
import java.io.FileOutputStream
import java.io.IOException
import java.nio.charset.StandardCharsets
import java.time.Year
import java.util.Objects
import javax.lang.model.element.Modifier

// JavaPoet only supports line comments, and can't add a newline after file level comments.
val FILE_HEADER = """
    /*
     * Copyright (C) ${Year.now().value} 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.
     */

    // Generated by xmlpersistence. DO NOT MODIFY!
    // CHECKSTYLE:OFF Generated code
    // @formatter:off
""".trimIndent() + "\n\n"

private val atomicFileType = ClassName.get("android.util", "AtomicFile")

fun generate(persistence: PersistenceInfo): JavaFile {
    val distinctClassFields = persistence.root.allClassFields.distinctBy { it.type }
    val type = TypeSpec.classBuilder(persistence.name)
        .addJavadoc(
            """
                Generated class implementing XML persistence for${'$'}W{@link $1T}.
                <p>
                This class provides atomicity for persistence via {@link $2T}, however it does not provide
                thread safety, so please bring your own synchronization mechanism.
            """.trimIndent(), persistence.root.type, atomicFileType
        )
        .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
        .addField(generateFileField())
        .addMethod(generateConstructor())
        .addMethod(generateReadMethod(persistence.root))
        .addMethod(generateParseMethod(persistence.root))
        .addMethods(distinctClassFields.map { generateParseClassMethod(it) })
        .addMethod(generateWriteMethod(persistence.root))
        .addMethod(generateSerializeMethod(persistence.root))
        .addMethods(distinctClassFields.map { generateSerializeClassMethod(it) })
        .addMethod(generateDeleteMethod())
        .build()
    return JavaFile.builder(persistence.root.type.packageName(), type)
        .skipJavaLangImports(true)
        .indent("    ")
        .build()
}

private val nonNullType = ClassName.get("android.annotation", "NonNull")

private fun generateFileField(): FieldSpec =
    FieldSpec.builder(atomicFileType, "mFile", Modifier.PRIVATE, Modifier.FINAL)
        .addAnnotation(nonNullType)
        .build()

private fun generateConstructor(): MethodSpec =
    MethodSpec.constructorBuilder()
        .addJavadoc(
            """
                Create an instance of this class.

                @param file the XML file for persistence
            """.trimIndent()
        )
        .addModifiers(Modifier.PUBLIC)
        .addParameter(
            ParameterSpec.builder(File::class.java, "file").addAnnotation(nonNullType).build()
        )
        .addStatement("mFile = new \$1T(file)", atomicFileType)
        .build()

private val nullableType = ClassName.get("android.annotation", "Nullable")

private val xmlPullParserType = ClassName.get("org.xmlpull.v1", "XmlPullParser")

private val xmlType = ClassName.get("android.util", "Xml")

private val xmlPullParserExceptionType = ClassName.get("org.xmlpull.v1", "XmlPullParserException")

private fun generateReadMethod(rootField: ClassFieldInfo): MethodSpec =
    MethodSpec.methodBuilder("read")
        .addJavadoc(
            """
                Read${'$'}W{@link $1T}${'$'}Wfrom${'$'}Wthe${'$'}WXML${'$'}Wfile.

                @return the persisted${'$'}W{@link $1T},${'$'}Wor${'$'}W{@code null}${'$'}Wif${'$'}Wthe${'$'}WXML${'$'}Wfile${'$'}Wdoesn't${'$'}Wexist
                @throws IllegalArgumentException if an error occurred while reading
            """.trimIndent(), rootField.type
        )
        .addAnnotation(nullableType)
        .addModifiers(Modifier.PUBLIC)
        .returns(rootField.type)
        .addControlFlow("try (\$1T inputStream = mFile.openRead())", FileInputStream::class.java) {
            addStatement("final \$1T parser = \$2T.newPullParser()", xmlPullParserType, xmlType)
            addStatement("parser.setInput(inputStream, null)")
            addStatement("return parse(parser)")
            nextControlFlow("catch (\$1T e)", FileNotFoundException::class.java)
            addStatement("return null")
            nextControlFlow(
                "catch (\$1T | \$2T e)", IOException::class.java, xmlPullParserExceptionType
            )
            addStatement("throw new IllegalArgumentException(e)")
        }
        .build()

private val ClassFieldInfo.allClassFields: List<ClassFieldInfo>
    get() =
        mutableListOf<ClassFieldInfo>().apply {
            this += this@allClassFields
            for (field in fields) {
                when (field) {
                    is ClassFieldInfo -> this += field.allClassFields
                    is ListFieldInfo -> this += field.element.allClassFields
                    else -> {}
                }
            }
        }

private fun generateParseMethod(rootField: ClassFieldInfo): MethodSpec =
    MethodSpec.methodBuilder("parse")
        .addAnnotation(nonNullType)
        .addModifiers(Modifier.PRIVATE, Modifier.STATIC)
        .returns(rootField.type)
        .addParameter(
            ParameterSpec.builder(xmlPullParserType, "parser").addAnnotation(nonNullType).build()
        )
        .addExceptions(listOf(ClassName.get(IOException::class.java), xmlPullParserExceptionType))
        .apply {
            addStatement("int type")
            addStatement("int depth")
            addStatement("int innerDepth = parser.getDepth() + 1")
            addControlFlow(
                "while ((type = parser.next()) != \$1T.END_DOCUMENT\$W"
                    + "&& ((depth = parser.getDepth()) >= innerDepth || type != \$1T.END_TAG))",
                xmlPullParserType
            ) {
                addControlFlow(
                    "if (depth > innerDepth || type != \$1T.START_TAG)", xmlPullParserType
                ) {
                    addStatement("continue")
                }
                addControlFlow(
                    "if (\$1T.equals(parser.getName(),\$W\$2S))", Objects::class.java,
                    rootField.tagName
                ) {
                    addStatement("return \$1L(parser)", rootField.parseMethodName)
                }
            }
            addStatement(
                "throw new IllegalArgumentException(\$1S)",
                "Missing root tag <${rootField.tagName}>"
            )
        }
        .build()

private fun generateParseClassMethod(classField: ClassFieldInfo): MethodSpec =
    MethodSpec.methodBuilder(classField.parseMethodName)
        .addAnnotation(nonNullType)
        .addModifiers(Modifier.PRIVATE, Modifier.STATIC)
        .returns(classField.type)
        .addParameter(
            ParameterSpec.builder(xmlPullParserType, "parser").addAnnotation(nonNullType).build()
        )
        .apply {
            val (attributeFields, tagFields) = classField.fields
                .partition { it is PrimitiveFieldInfo || it is StringFieldInfo }
            if (tagFields.isNotEmpty()) {
                addExceptions(
                    listOf(ClassName.get(IOException::class.java), xmlPullParserExceptionType)
                )
            }
            val nameAllocator = NameAllocator().apply {
                newName("parser")
                newName("type")
                newName("depth")
                newName("innerDepth")
            }
            for (field in attributeFields) {
                val variableName = nameAllocator.newName(field.variableName, field)
                when (field) {
                    is PrimitiveFieldInfo -> {
                        val stringVariableName =
                            nameAllocator.newName("${field.variableName}String")
                        addStatement(
                            "final String \$1L =\$Wparser.getAttributeValue(null,\$W\$2S)",
                            stringVariableName, field.attributeName
                        )
                        if (field.isRequired) {
                            addControlFlow("if (\$1L == null)", stringVariableName) {
                                addStatement(
                                    "throw new IllegalArgumentException(\$1S)",
                                    "Missing attribute \"${field.attributeName}\""
                                )
                            }
                        }
                        val boxedType = field.type.box()
                        val parseTypeMethodName = if (field.type.isPrimitive) {
                            "parse${field.type.toString().capitalize()}"
                        } else {
                            "valueOf"
                        }
                        if (field.isRequired) {
                            addStatement(
                                "final \$1T \$2L =\$W\$3T.\$4L($5L)", field.type, variableName,
                                boxedType, parseTypeMethodName, stringVariableName
                            )
                        } else {
                            addStatement(
                                "final \$1T \$2L =\$W$3L != null ?\$W\$4T.\$5L($3L)\$W: null",
                                field.type, variableName, stringVariableName, boxedType,
                                parseTypeMethodName
                            )
                        }
                    }
                    is StringFieldInfo ->
                        addStatement(
                            "final String \$1L =\$Wparser.getAttributeValue(null,\$W\$2S)",
                            variableName, field.attributeName
                        )
                    else -> error(field)
                }
            }
            if (tagFields.isNotEmpty()) {
                for (field in tagFields) {
                    val variableName = nameAllocator.newName(field.variableName, field)
                    when (field) {
                        is ClassFieldInfo ->
                            addStatement("\$1T \$2L =\$Wnull", field.type, variableName)
                        is ListFieldInfo ->
                            addStatement(
                                "final \$1T \$2L =\$Wnew \$3T<>()", field.type, variableName,
                                ArrayList::class.java
                            )
                        else -> error(field)
                    }
                }
                addStatement("int type")
                addStatement("int depth")
                addStatement("int innerDepth = parser.getDepth() + 1")
                addControlFlow(
                    "while ((type = parser.next()) != \$1T.END_DOCUMENT\$W"
                        + "&& ((depth = parser.getDepth()) >= innerDepth || type != \$1T.END_TAG))",
                    xmlPullParserType
                ) {
                    addControlFlow(
                        "if (depth > innerDepth || type != \$1T.START_TAG)", xmlPullParserType
                    ) {
                        addStatement("continue")
                    }
                    addControlFlow("switch (parser.getName())") {
                        for (field in tagFields) {
                            addControlFlow("case \$1S:", field.tagName) {
                                val variableName = nameAllocator.get(field)
                                when (field) {
                                    is ClassFieldInfo -> {
                                        addControlFlow("if (\$1L != null)", variableName) {
                                            addStatement(
                                                "throw new IllegalArgumentException(\$1S)",
                                                "Duplicate tag \"${field.tagName}\""
                                            )
                                        }
                                        addStatement(
                                            "\$1L =\$W\$2L(parser)", variableName,
                                            field.parseMethodName
                                        )
                                        addStatement("break")
                                    }
                                    is ListFieldInfo -> {
                                        val elementNameAllocator = nameAllocator.clone()
                                        val elementVariableName = elementNameAllocator.newName(
                                            field.element.xmlName!!.toLowerCamelCase()
                                        )
                                        addStatement(
                                            "final \$1T \$2L =\$W\$3L(parser)", field.element.type,
                                            elementVariableName, field.element.parseMethodName
                                        )
                                        addStatement(
                                            "\$1L.add(\$2L)", variableName, elementVariableName
                                        )
                                        addStatement("break")
                                    }
                                    else -> error(field)
                                }
                            }
                        }
                    }
                }
            }
            for (field in tagFields.filter { it is ClassFieldInfo && it.isRequired }) {
                addControlFlow("if ($1L == null)", nameAllocator.get(field)) {
                    addStatement(
                        "throw new IllegalArgumentException(\$1S)", "Missing tag <${field.tagName}>"
                    )
                }
            }
            addStatement(
                classField.fields.joinToString(",\$W", "return new \$1T(", ")") {
                    nameAllocator.get(it)
                }, classField.type
            )
        }
        .build()

private val ClassFieldInfo.parseMethodName: String
    get() = "parse${type.simpleName().toUpperCamelCase()}"

private val xmlSerializerType = ClassName.get("org.xmlpull.v1", "XmlSerializer")

private fun generateWriteMethod(rootField: ClassFieldInfo): MethodSpec =
    MethodSpec.methodBuilder("write")
        .apply {
            val nameAllocator = NameAllocator().apply {
                newName("outputStream")
                newName("serializer")
            }
            val parameterName = nameAllocator.newName(rootField.variableName)
            addJavadoc(
                """
                    Write${'$'}W{@link $1T}${'$'}Wto${'$'}Wthe${'$'}WXML${'$'}Wfile.

                    @param $2L the${'$'}W{@link ${'$'}1T}${'$'}Wto${'$'}Wpersist
                """.trimIndent(), rootField.type, parameterName
            )
            addAnnotation(nullableType)
            addModifiers(Modifier.PUBLIC)
            addParameter(
                ParameterSpec.builder(rootField.type, parameterName)
                    .addAnnotation(nonNullType)
                    .build()
            )
            addStatement("\$1T outputStream = null", FileOutputStream::class.java)
            addControlFlow("try") {
                addStatement("outputStream = mFile.startWrite()")
                addStatement(
                    "final \$1T serializer =\$W\$2T.newSerializer()", xmlSerializerType, xmlType
                )
                addStatement(
                    "serializer.setOutput(outputStream, \$1T.UTF_8.name())",
                    StandardCharsets::class.java
                )
                addStatement(
                    "serializer.setFeature(\$1S, true)",
                    "http://xmlpull.org/v1/doc/features.html#indent-output"
                )
                addStatement("serializer.startDocument(null, true)")
                addStatement("serialize(serializer,\$W\$1L)", parameterName)
                addStatement("serializer.endDocument()")
                addStatement("mFile.finishWrite(outputStream)")
                nextControlFlow("catch (Exception e)")
                addStatement("e.printStackTrace()")
                addStatement("mFile.failWrite(outputStream)")
            }
        }
        .build()

private fun generateSerializeMethod(rootField: ClassFieldInfo): MethodSpec =
    MethodSpec.methodBuilder("serialize")
        .addModifiers(Modifier.PRIVATE, Modifier.STATIC)
        .addParameter(
            ParameterSpec.builder(xmlSerializerType, "serializer")
                .addAnnotation(nonNullType)
                .build()
        )
        .apply {
            val nameAllocator = NameAllocator().apply { newName("serializer") }
            val parameterName = nameAllocator.newName(rootField.variableName)
            addParameter(
                ParameterSpec.builder(rootField.type, parameterName)
                    .addAnnotation(nonNullType)
                    .build()
            )
            addException(IOException::class.java)
            addStatement("serializer.startTag(null, \$1S)", rootField.tagName)
            addStatement("\$1L(serializer, \$2L)", rootField.serializeMethodName, parameterName)
            addStatement("serializer.endTag(null, \$1S)", rootField.tagName)
        }
        .build()

private fun generateSerializeClassMethod(classField: ClassFieldInfo): MethodSpec =
    MethodSpec.methodBuilder(classField.serializeMethodName)
        .addModifiers(Modifier.PRIVATE, Modifier.STATIC)
        .addParameter(
            ParameterSpec.builder(xmlSerializerType, "serializer")
                .addAnnotation(nonNullType)
                .build()
        )
        .apply {
            val nameAllocator = NameAllocator().apply {
                newName("serializer")
                newName("i")
            }
            val parameterName = nameAllocator.newName(classField.serializeParameterName)
            addParameter(
                ParameterSpec.builder(classField.type, parameterName)
                    .addAnnotation(nonNullType)
                    .build()
            )
            addException(IOException::class.java)
            val (attributeFields, tagFields) = classField.fields
                .partition { it is PrimitiveFieldInfo || it is StringFieldInfo }
            for (field in attributeFields) {
                val variableName = "$parameterName.${field.name}"
                if (!field.isRequired) {
                    beginControlFlow("if (\$1L != null)", variableName)
                }
                when (field) {
                    is PrimitiveFieldInfo -> {
                        if (field.isRequired && !field.type.isPrimitive) {
                            addControlFlow("if (\$1L == null)", variableName) {
                                addStatement(
                                    "throw new IllegalArgumentException(\$1S)",
                                    "Field \"${field.name}\" is null"
                                )
                            }
                        }
                        val stringVariableName =
                            nameAllocator.newName("${field.variableName}String")
                        addStatement(
                            "final String \$1L =\$WString.valueOf(\$2L)", stringVariableName,
                            variableName
                        )
                        addStatement(
                            "serializer.attribute(null, \$1S, \$2L)", field.attributeName,
                            stringVariableName
                        )
                    }
                    is StringFieldInfo -> {
                        if (field.isRequired) {
                            addControlFlow("if (\$1L == null)", variableName) {
                                addStatement(
                                    "throw new IllegalArgumentException(\$1S)",
                                    "Field \"${field.name}\" is null"
                                )
                            }
                        }
                        addStatement(
                            "serializer.attribute(null, \$1S, \$2L)", field.attributeName,
                            variableName
                        )
                    }
                    else -> error(field)
                }
                if (!field.isRequired) {
                    endControlFlow()
                }
            }
            for (field in tagFields) {
                val variableName = "$parameterName.${field.name}"
                if (field.isRequired) {
                    addControlFlow("if (\$1L == null)", variableName) {
                        addStatement(
                            "throw new IllegalArgumentException(\$1S)",
                            "Field \"${field.name}\" is null"
                        )
                    }
                }
                when (field) {
                    is ClassFieldInfo -> {
                        addStatement("serializer.startTag(null, \$1S)", field.tagName)
                        addStatement(
                            "\$1L(serializer, \$2L)", field.serializeMethodName, variableName
                        )
                        addStatement("serializer.endTag(null, \$1S)", field.tagName)
                    }
                    is ListFieldInfo -> {
                        val sizeVariableName = nameAllocator.newName("${field.variableName}Size")
                        addStatement(
                            "final int \$1L =\$W\$2L.size()", sizeVariableName, variableName
                        )
                        addControlFlow("for (int i = 0;\$Wi < \$1L;\$Wi++)", sizeVariableName) {
                            val elementNameAllocator = nameAllocator.clone()
                            val elementVariableName = elementNameAllocator.newName(
                                field.element.xmlName!!.toLowerCamelCase()
                            )
                            addStatement(
                                "final \$1T \$2L =\$W\$3L.get(i)", field.element.type,
                                elementVariableName, variableName
                            )
                            addControlFlow("if (\$1L == null)", elementVariableName) {
                                addStatement(
                                    "throw new IllegalArgumentException(\$1S\$W+ i\$W+ \$2S)",
                                    "Field element \"${field.name}[", "]\" is null"
                                )
                            }
                            addStatement("serializer.startTag(null, \$1S)", field.element.tagName)
                            addStatement(
                                "\$1L(serializer,\$W\$2L)", field.element.serializeMethodName,
                                elementVariableName
                            )
                            addStatement("serializer.endTag(null, \$1S)", field.element.tagName)
                        }
                    }
                    else -> error(field)
                }
            }
        }
        .build()

private val ClassFieldInfo.serializeMethodName: String
    get() = "serialize${type.simpleName().toUpperCamelCase()}"

private val ClassFieldInfo.serializeParameterName: String
    get() = type.simpleName().toLowerCamelCase()

private val FieldInfo.variableName: String
    get() = name.toLowerCamelCase()

private val FieldInfo.attributeName: String
    get() {
        check(this is PrimitiveFieldInfo || this is StringFieldInfo)
        return xmlNameOrName.toLowerCamelCase()
    }

private val FieldInfo.tagName: String
    get() {
        check(this is ClassFieldInfo || this is ListFieldInfo)
        return xmlNameOrName.toLowerKebabCase()
    }

private val FieldInfo.xmlNameOrName: String
    get() = xmlName ?: name

private fun generateDeleteMethod(): MethodSpec =
    MethodSpec.methodBuilder("delete")
        .addJavadoc("Delete the XML file, if any.")
        .addModifiers(Modifier.PUBLIC)
        .addStatement("mFile.delete()")
        .build()

private inline fun MethodSpec.Builder.addControlFlow(
    controlFlow: String,
    vararg args: Any,
    block: MethodSpec.Builder.() -> Unit
): MethodSpec.Builder {
    beginControlFlow(controlFlow, *args)
    block()
    endControlFlow()
    return this
}