forked from Kotlin/dokka
/
ServiceLocator.kt
94 lines (75 loc) · 4.02 KB
/
ServiceLocator.kt
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
package org.jetbrains.dokka.utilities
import java.io.File
import java.net.URISyntaxException
import java.net.URL
import java.util.*
import java.util.jar.JarFile
import java.util.zip.ZipEntry
data class ServiceDescriptor(val name: String, val category: String, val description: String?, val className: String)
class ServiceLookupException(message: String) : Exception(message)
object ServiceLocator {
fun <T : Any> lookup(clazz: Class<T>, category: String, implementationName: String): T {
val descriptor = lookupDescriptor(category, implementationName)
return lookup(clazz, descriptor)
}
fun <T : Any> lookup(
clazz: Class<T>,
descriptor: ServiceDescriptor
): T {
val loadedClass = javaClass.classLoader.loadClass(descriptor.className)
val constructor = loadedClass.constructors.firstOrNull { it.parameterTypes.isEmpty() } ?: throw ServiceLookupException("Class ${descriptor.className} has no corresponding constructor")
val implementationRawType: Any =
if (constructor.parameterTypes.isEmpty()) constructor.newInstance() else constructor.newInstance(constructor)
if (!clazz.isInstance(implementationRawType)) {
throw ServiceLookupException("Class ${descriptor.className} is not a subtype of ${clazz.name}")
}
@Suppress("UNCHECKED_CAST")
return implementationRawType as T
}
private fun lookupDescriptor(category: String, implementationName: String): ServiceDescriptor {
val properties = javaClass.classLoader.getResourceAsStream("dokka/$category/$implementationName.properties")?.use { stream ->
Properties().let { properties ->
properties.load(stream)
properties
}
} ?: throw ServiceLookupException("No implementation with name $implementationName found in category $category")
val className = properties["class"]?.toString() ?: throw ServiceLookupException("Implementation $implementationName has no class configured")
return ServiceDescriptor(implementationName, category, properties["description"]?.toString(), className)
}
fun URL.toFile(): File {
assert(protocol == "file")
return try {
File(toURI())
} catch (e: URISyntaxException) { //Try to handle broken URLs, with unescaped spaces
File(path)
}
}
fun allServices(category: String): List<ServiceDescriptor> {
val entries = this.javaClass.classLoader.getResources("dokka/$category")?.toList() ?: emptyList()
return entries.flatMap {
when (it.protocol) {
"file" -> it.toFile().listFiles()?.filter { it.extension == "properties" }?.map { lookupDescriptor(category, it.nameWithoutExtension) } ?: emptyList()
"jar" -> {
JarFile(URL(it.file.substringBefore("!")).toFile()).use { file ->
val jarPath = it.file.substringAfterLast("!").removePrefix("/").removeSuffix("/")
file.entries()
.asSequence()
.filter { entry -> !entry.isDirectory && entry.path == jarPath && entry.extension == "properties" }
.map { entry ->
lookupDescriptor(category, entry.fileName.substringBeforeLast("."))
}.toList()
}
}
else -> emptyList()
}
}
}
}
inline fun <reified T : Any> ServiceLocator.lookup(category: String, implementationName: String): T = lookup(T::class.java, category, implementationName)
inline fun <reified T : Any> ServiceLocator.lookup(desc: ServiceDescriptor): T = lookup(T::class.java, desc)
private val ZipEntry.fileName: String
get() = name.substringAfterLast("/", name)
private val ZipEntry.path: String
get() = name.substringBeforeLast("/", "").removePrefix("/")
private val ZipEntry.extension: String?
get() = fileName.let { fn -> if ("." in fn) fn.substringAfterLast(".") else null }