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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
|
package moe.nea.firmament.features.texturepack
import com.google.gson.JsonArray
import com.google.gson.JsonElement
import com.google.gson.JsonNull
import com.google.gson.JsonObject
import com.google.gson.JsonPrimitive
import com.google.gson.internal.LazilyParsedNumber
import java.util.function.Predicate
import kotlinx.serialization.KSerializer
import kotlinx.serialization.Serializable
import kotlinx.serialization.descriptors.SerialDescriptor
import kotlinx.serialization.encoding.Decoder
import kotlinx.serialization.encoding.Encoder
import net.minecraft.nbt.NbtString
import net.minecraft.text.Text
import moe.nea.firmament.util.MC
import moe.nea.firmament.util.removeColorCodes
@Serializable(with = StringMatcher.Serializer::class)
interface StringMatcher {
fun matches(string: String): Boolean
fun matches(text: Text): Boolean {
return matches(text.string)
}
fun matches(nbt: NbtString): Boolean {
val string = nbt.asString()
val jsonStart = string.indexOf('{')
val stringStart = string.indexOf('"')
val isString = stringStart >= 0 && string.subSequence(0, stringStart).isBlank()
val isJson = jsonStart >= 0 && string.subSequence(0, jsonStart).isBlank()
if (isString || isJson)
return matches(Text.Serialization.fromJson(string, MC.defaultRegistries) ?: return false)
return matches(string)
}
class Equals(input: String, val stripColorCodes: Boolean) : StringMatcher {
private val expected = if (stripColorCodes) input.removeColorCodes() else input
override fun matches(string: String): Boolean {
return expected == (if (stripColorCodes) string.removeColorCodes() else string)
}
override fun toString(): String {
return "Equals($expected, stripColorCodes = $stripColorCodes)"
}
}
class Pattern(val patternWithColorCodes: String, val stripColorCodes: Boolean) : StringMatcher {
private val regex: Predicate<String> = patternWithColorCodes.toPattern().asMatchPredicate()
override fun matches(string: String): Boolean {
return regex.test(if (stripColorCodes) string.removeColorCodes() else string)
}
override fun toString(): String {
return "Pattern($patternWithColorCodes, stripColorCodes = $stripColorCodes)"
}
}
object Serializer : KSerializer<StringMatcher> {
val delegateSerializer = kotlinx.serialization.json.JsonElement.serializer()
override val descriptor: SerialDescriptor
get() = SerialDescriptor("StringMatcher", delegateSerializer.descriptor)
override fun deserialize(decoder: Decoder): StringMatcher {
val delegate = decoder.decodeSerializableValue(delegateSerializer)
val gsonDelegate = delegate.intoGson()
return parse(gsonDelegate)
}
override fun serialize(encoder: Encoder, value: StringMatcher) {
encoder.encodeSerializableValue(delegateSerializer, Companion.serialize(value).intoKotlinJson())
}
}
companion object {
fun serialize(stringMatcher: StringMatcher): JsonElement {
TODO("Cannot serialize string matchers rn")
}
fun parse(jsonElement: JsonElement): StringMatcher {
if (jsonElement is JsonPrimitive) {
return Equals(jsonElement.asString, true)
}
if (jsonElement is JsonObject) {
val regex = jsonElement["regex"] as JsonPrimitive?
val text = jsonElement["equals"] as JsonPrimitive?
val shouldStripColor = when (val color = (jsonElement["color"] as JsonPrimitive?)?.asString) {
"preserve" -> false
"strip", null -> true
else -> error("Unknown color preservation mode: $color")
}
if ((regex == null) == (text == null)) error("Could not parse $jsonElement as string matcher")
if (regex != null)
return Pattern(regex.asString, shouldStripColor)
if (text != null)
return Equals(text.asString, shouldStripColor)
}
error("Could not parse $jsonElement as a string matcher")
}
}
}
fun JsonElement.intoKotlinJson(): kotlinx.serialization.json.JsonElement {
when (this) {
is JsonNull -> return kotlinx.serialization.json.JsonNull
is JsonObject -> {
return kotlinx.serialization.json.JsonObject(this.entrySet()
.associate { it.key to it.value.intoKotlinJson() })
}
is JsonArray -> {
return kotlinx.serialization.json.JsonArray(this.map { it.intoKotlinJson() })
}
is JsonPrimitive -> {
if (this.isString)
return kotlinx.serialization.json.JsonPrimitive(this.asString)
if (this.isBoolean)
return kotlinx.serialization.json.JsonPrimitive(this.asBoolean)
return kotlinx.serialization.json.JsonPrimitive(this.asNumber)
}
else -> error("Unknown json variant $this")
}
}
fun kotlinx.serialization.json.JsonElement.intoGson(): JsonElement {
when (this) {
is kotlinx.serialization.json.JsonNull -> return JsonNull.INSTANCE
is kotlinx.serialization.json.JsonPrimitive -> {
if (this.isString)
return JsonPrimitive(this.content)
if (this.content == "true")
return JsonPrimitive(true)
if (this.content == "false")
return JsonPrimitive(false)
return JsonPrimitive(LazilyParsedNumber(this.content))
}
is kotlinx.serialization.json.JsonObject -> {
val obj = JsonObject()
for ((k, v) in this) {
obj.add(k, v.intoGson())
}
return obj
}
is kotlinx.serialization.json.JsonArray -> {
val arr = JsonArray()
for (v in this) {
arr.add(v.intoGson())
}
return arr
}
}
}
|
