trime/build-logic/convention/src/main/kotlin/OpenCCDataPlugin.kt at 13dbc78869ba06240b69f27a0f9ffe18cf760da1 · osfans/trime · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
/*
 * SPDX-FileCopyrightText: 2015 - 2025 Rime community
 * SPDX-License-Identifier: GPL-3.0-or-later
 */

import org.gradle.api.DefaultTask
import org.gradle.api.Plugin
import org.gradle.api.Project
import org.gradle.api.file.DirectoryProperty
import org.gradle.api.tasks.Delete
import org.gradle.api.tasks.InputDirectory
import org.gradle.api.tasks.OutputDirectory
import org.gradle.api.tasks.PathSensitive
import org.gradle.api.tasks.PathSensitivity
import org.gradle.api.tasks.TaskAction
import org.gradle.kotlin.dsl.register

class OpenCCDataPlugin : Plugin<Project> {
    companion object {
        const val INSTALL_TASK = "installOpenCCData"
        const val CLEAN_TASK = "cleanOpenCCData"
    }

    private val Project.dataBaseDir
        get() = file("src/main/jni/OpenCC/data")

    private val Project.dataInstallDir
        get() = assetsDir.resolve("shared/opencc")

    override fun apply(target: Project) {
        registerInstallTask(target)
        registerCleanTask(target)
    }

    private fun registerInstallTask(project: Project) {
        val task =
            project.tasks.register<InstallOpenCCDataTask>(INSTALL_TASK) {
                inputDir.set(project.dataBaseDir)
                outputDir.set(project.dataInstallDir)
            }
        // make sure OpenCC data have been installed before generating data checksums
        project.tasks.getByName(DataChecksumsPlugin.TASK).dependsOn(task)
    }

    private fun registerCleanTask(project: Project) {
        project
            .tasks.register<Delete>(CLEAN_TASK) {
                delete(project.dataInstallDir)
            }.also {
                project.cleanTask.dependsOn(it)
            }
    }

    abstract class InstallOpenCCDataTask : DefaultTask() {
        @get:PathSensitive(PathSensitivity.NAME_ONLY)
        @get:InputDirectory
        abstract val inputDir: DirectoryProperty

        @get:OutputDirectory
        abstract val outputDir: DirectoryProperty

        private val input by lazy { inputDir.get().asFile }

        private val output by lazy { outputDir.get().asFile }

        companion object {
            private val DICTS_RAW =
                arrayOf(
                    "CJK_Compatibility_Ideographs",
                    "HKPhrasesRev",
                    "HKPhrases",
                    "HKVariantsPhrases",
                    "HKVariantsRevPhrases",
                    "HKVariants",
                    "JPShinjitaiCharacters",
                    "JPShinjitaiPhrases",
                    "STCharacters",
                    "STPhrases",
                    "TSCharacters",
                    "TSPhrases",
                    "TWPhrasesRev",
                    "TWPhrases",
                    "TWVariantsPhrases",
                    "TWVariantsRevPhrases",
                    "TWVariants",
                )

            private val DICTS_GENERATED = arrayOf("TWVariantsRev", "HKVariantsRev")
        }

        @TaskAction
        fun execute() {
            input.run {
                resolve("config")
                    .listFiles { f -> f.extension == "json" }
                    ?.forEach { f -> f.copyTo(output.resolve(f.name), overwrite = true) }

                val dictionary = resolve("dictionary")
                for (raw in DICTS_RAW) {
                    val basename = "$raw.txt"
                    dictionary.resolve(basename).copyTo(output.resolve(basename), overwrite = true)
                }
                val reverse = resolve("scripts/reverse.py").absolutePath

                fun reverse(
                    source: String,
                    outputFilePath: String,
                ) {
                    project.providers.exec {
                        workingDir = output
                        commandLine = listOf("python3", reverse, source, outputFilePath)
                    }.result.get()
                }
                for (dict in DICTS_GENERATED) {
                    val inputName = dict.substringBefore("Rev")
                    val inputFile = dictionary.resolve("$inputName.txt")
                    val outputFile = output.resolve("$dict.txt")
                    reverse(inputFile.absolutePath, outputFile.name)
                }
            }
        }
    }
}