diff options
8 files changed, 82 insertions, 115 deletions
diff --git a/core/src/main/kotlin/DokkaBootstrapImpl.kt b/core/src/main/kotlin/DokkaBootstrapImpl.kt index cbec4985..eb2b2a65 100644 --- a/core/src/main/kotlin/DokkaBootstrapImpl.kt +++ b/core/src/main/kotlin/DokkaBootstrapImpl.kt @@ -1,6 +1,7 @@ package org.jetbrains.dokka import java.io.File +import java.util.function.BiConsumer fun parseSourceLinkDefinition(srcLink: String): SourceLinkDefinition { val (path, urlAndLine) = srcLink.split('=') @@ -9,12 +10,25 @@ fun parseSourceLinkDefinition(srcLink: String): SourceLinkDefinition { urlAndLine.substringAfter("#", "").let { if (it.isEmpty()) null else "#" + it }) } - class DokkaBootstrapImpl : DokkaBootstrap { + class DokkaProxyLogger(val consumer: BiConsumer<String, String>) : DokkaLogger { + override fun info(message: String) { + consumer.accept("info", message) + } + + override fun warn(message: String) { + consumer.accept("warn", message) + } + + override fun error(message: String) { + consumer.accept("error", message) + } + } + lateinit var generator: DokkaGenerator - override fun configure(logger: DokkaLogger, + override fun configure(logger: BiConsumer<String, String>, moduleName: String, classpath: List<String>, sources: List<String>, @@ -30,7 +44,7 @@ class DokkaBootstrapImpl : DokkaBootstrap { generateIndexPages: Boolean, sourceLinks: List<String>) { generator = DokkaGenerator( - logger, + DokkaProxyLogger(logger), classpath, sources, samples, diff --git a/core/src/main/kotlin/Utilities/DokkaLogging.kt b/core/src/main/kotlin/Utilities/DokkaLogging.kt index 2e0fb395..1ef52837 100644 --- a/core/src/main/kotlin/Utilities/DokkaLogging.kt +++ b/core/src/main/kotlin/Utilities/DokkaLogging.kt @@ -1,5 +1,11 @@ package org.jetbrains.dokka +interface DokkaLogger { + fun info(message: String) + fun warn(message: String) + fun error(message: String) +} + object DokkaConsoleLogger : DokkaLogger { var warningCount: Int = 0 diff --git a/integration/src/main/kotlin/org/jetbrains/dokka/DokkaBootstrap.kt b/integration/src/main/kotlin/org/jetbrains/dokka/DokkaBootstrap.kt index 548aceb0..50e8fb8d 100644 --- a/integration/src/main/kotlin/org/jetbrains/dokka/DokkaBootstrap.kt +++ b/integration/src/main/kotlin/org/jetbrains/dokka/DokkaBootstrap.kt @@ -1,8 +1,10 @@ package org.jetbrains.dokka +import java.util.function.BiConsumer + interface DokkaBootstrap { - fun configure(logger: DokkaLogger, + fun configure(logger: BiConsumer<String, String>, moduleName: String, classpath: List<String>, sources: List<String>, diff --git a/integration/src/main/kotlin/org/jetbrains/dokka/DokkaLogger.kt b/integration/src/main/kotlin/org/jetbrains/dokka/DokkaLogger.kt deleted file mode 100644 index fc1fac22..00000000 --- a/integration/src/main/kotlin/org/jetbrains/dokka/DokkaLogger.kt +++ /dev/null @@ -1,8 +0,0 @@ -package org.jetbrains.dokka - -interface DokkaLogger { - fun info(message: String) - fun warn(message: String) - fun error(message: String) -} - diff --git a/integration/src/main/kotlin/org/jetbrains/dokka/ProxyUtils.kt b/integration/src/main/kotlin/org/jetbrains/dokka/ProxyUtils.kt deleted file mode 100644 index 66356f66..00000000 --- a/integration/src/main/kotlin/org/jetbrains/dokka/ProxyUtils.kt +++ /dev/null @@ -1,76 +0,0 @@ -package org.jetbrains.dokka - -import java.lang.reflect.InvocationHandler -import java.lang.reflect.InvocationTargetException -import java.lang.reflect.Method -import java.lang.reflect.Proxy -import java.util.function.Predicate - - -/** - * Warning! Hard reflection magic used here. - * - * Creates [java.lang.reflect.Proxy] with pass through invocation algorithm, - * to create access proxy for [delegate] from [targetClassLoader] to [delegateClassLoader]. - * - * Every object type contained in method calls will be translated to proxy, if [filter.test] will success for it's class - * - */ -@Suppress("UNCHECKED_CAST") -fun <T> automagicTypedProxy(targetClassLoader: ClassLoader, targetType: Class<T>, - delegateClassLoader: ClassLoader, delegate: Any, - filter: Predicate<Class<*>>): T = - automagicProxy(targetClassLoader, targetType, delegateClassLoader, delegate, filter) as T - - -/** - * Warning! Hard reflection magic used here. - * - * Creates [java.lang.reflect.Proxy] with pass through invocation algorithm, - * to create access proxy for [delegate] from [targetClassLoader] to [delegateClassLoader]. - * - * Every object type contained in method calls will be translated to proxy, if [filter.test] will success for it's class - * - */ -fun automagicProxy(targetClassLoader: ClassLoader, targetType: Class<*>, - delegateClassLoader: ClassLoader, delegate: Any, - filter: Predicate<Class<*>>): Any = - Proxy.newProxyInstance( - targetClassLoader, - arrayOf(targetType), - DelegatedInvocationHandler( - delegate, - delegateClassLoader, - filter - ) - ) - -class DelegatedInvocationHandler(private val delegate: Any, - private val delegateClassLoader: ClassLoader, - private val filter: Predicate<Class<*>>) - : InvocationHandler { - - @Throws(Throwable::class) - override fun invoke(proxy: Any, method: Method, args: Array<Any?>?): Any? { - val (argTypes, argValues) = method.parameterTypes.zip(args ?: emptyArray()).map { typeAndValue -> - val (type, value) = typeAndValue - if (filter.test(type)) { - val newType = delegateClassLoader.loadClass(type.name) - val newValue = value?.let { - automagicProxy(delegateClassLoader, newType, type.classLoader, value, filter) - } - newType to newValue - } else - typeAndValue - }.unzip() - - val delegateMethod = delegate.javaClass.getMethod(method.name, *argTypes.toTypedArray()) - try { - delegateMethod.isAccessible = true - return delegateMethod.invoke(delegate, *argValues.toTypedArray()) - } catch (ex: InvocationTargetException) { - throw ex.targetException - } - - } -} diff --git a/runners/gradle-plugin/src/main/kotlin/ProxyUtils.kt b/runners/gradle-plugin/src/main/kotlin/ProxyUtils.kt new file mode 100644 index 00000000..7bdf2f9d --- /dev/null +++ b/runners/gradle-plugin/src/main/kotlin/ProxyUtils.kt @@ -0,0 +1,46 @@ +package org.jetbrains.dokka + +import java.lang.reflect.InvocationHandler +import java.lang.reflect.InvocationTargetException +import java.lang.reflect.Method +import java.lang.reflect.Proxy + + +/** + * Warning! Hard reflection magic used here. + * + * Creates [java.lang.reflect.Proxy] with pass through invocation algorithm, + * to create access proxy for [delegate] into [targetClassLoader]. + */ +@Suppress("UNCHECKED_CAST") +inline fun <reified T : Any> automagicTypedProxy(targetClassLoader: ClassLoader, delegate: Any): T = + automagicProxy(targetClassLoader, T::class.java, delegate) as T + + +/** + * Warning! Hard reflection magic used here. + * + * Creates [java.lang.reflect.Proxy] with pass through invocation algorithm, + * to create access proxy for [delegate] into [targetClassLoader]. + * + */ +fun automagicProxy(targetClassLoader: ClassLoader, targetType: Class<*>, delegate: Any): Any = + Proxy.newProxyInstance( + targetClassLoader, + arrayOf(targetType), + DelegatedInvocationHandler(delegate) + ) + +class DelegatedInvocationHandler(private val delegate: Any) : InvocationHandler { + + @Throws(Throwable::class) + override fun invoke(proxy: Any, method: Method, args: Array<Any?>?): Any? { + val delegateMethod = delegate.javaClass.getMethod(method.name, *method.parameterTypes) + try { + delegateMethod.isAccessible = true + return delegateMethod.invoke(delegate, *(args ?: emptyArray())) + } catch (ex: InvocationTargetException) { + throw ex.targetException + } + } +} diff --git a/runners/gradle-plugin/src/main/kotlin/logger.kt b/runners/gradle-plugin/src/main/kotlin/logger.kt deleted file mode 100644 index 715c1f04..00000000 --- a/runners/gradle-plugin/src/main/kotlin/logger.kt +++ /dev/null @@ -1,18 +0,0 @@ -package org.jetbrains.dokka.gradle - -import org.gradle.api.logging.Logger -import org.jetbrains.dokka.DokkaLogger - -class DokkaGradleLogger(val logger: Logger) : DokkaLogger { - override fun error(message: String) { - logger.error(message) - } - - override fun info(message: String) { - logger.info(message) - } - - override fun warn(message: String) { - logger.warn(message) - } -}
\ No newline at end of file diff --git a/runners/gradle-plugin/src/main/kotlin/main.kt b/runners/gradle-plugin/src/main/kotlin/main.kt index f3e46c4d..51061415 100644 --- a/runners/gradle-plugin/src/main/kotlin/main.kt +++ b/runners/gradle-plugin/src/main/kotlin/main.kt @@ -15,7 +15,7 @@ import java.io.File import java.io.Serializable import java.net.URLClassLoader import java.util.* -import java.util.function.Predicate +import java.util.function.BiConsumer open class DokkaPlugin : Plugin<Project> { @@ -124,15 +124,16 @@ open class DokkaTask : DefaultTask() { val bootstrapInstance = bootstrapClass.constructors.first().newInstance() - val bootstrapProxy = automagicTypedProxy(javaClass.classLoader, - DokkaBootstrap::class.java, - fatJarClassLoader!!, - bootstrapInstance, - Predicate { it.name.startsWith("org.jetbrains.dokka") } - ) + val bootstrapProxy: DokkaBootstrap = automagicTypedProxy(javaClass.classLoader, bootstrapInstance) bootstrapProxy.configure( - DokkaGradleLogger(logger), + BiConsumer { level, message -> + when (level) { + "info" -> logger.info(message) + "warn" -> logger.warn(message) + "error" -> logger.error(message) + } + }, moduleName, classpath.map { it.absolutePath }, sourceDirectories.map { it.absolutePath }, @@ -148,7 +149,7 @@ open class DokkaTask : DefaultTask() { true, linkMappings.map { val path = project.file(it.dir).absolutePath - return@map "$path=${it.url}${it.suffix}" + "$path=${it.url}${it.suffix}" }) bootstrapProxy.generate() |