jolanrensen / docprocessorgradleplugin Goto Github PK
View Code? Open in Web Editor NEWGradle Plugin: KDoc / JavaDoc Preprocessor that can produce modified sources
License: MIT License
Gradle Plugin: KDoc / JavaDoc Preprocessor that can produce modified sources
License: MIT License
Kotlin 2.0 support needs to be explored
Adding a dependency on a created plugin results in an exception:
java.lang.AbstractMethodError: org.jetbrains.dokka.analysis.AnalysisEnvironment$createResolutionFacade$library$1.getCapabilities()Ljava/util/Map;
at org.jetbrains.kotlin.analyzer.AbstractResolverForProject.createModuleDescriptor(AbstractResolverForProject.kt:207)
at org.jetbrains.kotlin.analyzer.AbstractResolverForProject.access$createModuleDescriptor(AbstractResolverForProject.kt:17)
at org.jetbrains.kotlin.analyzer.AbstractResolverForProject$doGetDescriptorForModule$1.invoke(AbstractResolverForProject.kt:175)
at org.jetbrains.kotlin.analyzer.AbstractResolverForProject$doGetDescriptorForModule$1.invoke(AbstractResolverForProject.kt:173)
at org.jetbrains.kotlin.storage.LockBasedStorageManager.compute(LockBasedStorageManager.java:290)
at org.jetbrains.kotlin.analyzer.AbstractResolverForProject.doGetDescriptorForModule(AbstractResolverForProject.kt:173)
at org.jetbrains.kotlin.analyzer.AbstractResolverForProject.descriptorForModule(AbstractResolverForProject.kt:150)
at org.jetbrains.kotlin.analyzer.AbstractResolverForProject.descriptorForModule(AbstractResolverForProject.kt:17)
at org.jetbrains.dokka.analysis.AnalysisEnvironment.createResolutionFacade(AnalysisEnvironment.kt:272)
at org.jetbrains.dokka.analysis.AnalysisContextKt.createAnalysisContext(AnalysisContext.kt:51)
at org.jetbrains.dokka.analysis.AnalysisContextKt.createAnalysisContext(AnalysisContext.kt:24)
at org.jetbrains.dokka.analysis.KotlinAnalysisKt.ProjectKotlinAnalysis(KotlinAnalysis.kt:18)
at org.jetbrains.dokka.analysis.KotlinAnalysisKt.ProjectKotlinAnalysis$default(KotlinAnalysis.kt:15)
at org.jetbrains.dokka.base.DokkaBase$defaultKotlinAnalysis$2$1.invoke(DokkaBase.kt:194)
at org.jetbrains.dokka.base.DokkaBase$defaultKotlinAnalysis$2$1.invoke(DokkaBase.kt:47)
at org.jetbrains.dokka.plugability.LazyEvaluated.get$core(LazyEvaluated.kt:8)
at org.jetbrains.dokka.plugability.DokkaContextConfigurationImpl.single(DokkaContext.kt:159)
at org.jetbrains.dokka.base.translators.psi.DefaultPsiToDocumentableTranslator.<init>(DefaultPsiToDocumentableTranslator.kt:867)
at org.jetbrains.dokka.base.DokkaBase$psiToDocumentableTranslator$2$1.invoke(DokkaBase.kt:74)
at org.jetbrains.dokka.base.DokkaBase$psiToDocumentableTranslator$2$1.invoke(DokkaBase.kt:47)
at org.jetbrains.dokka.plugability.LazyEvaluated.get$core(LazyEvaluated.kt:8)
at org.jetbrains.dokka.plugability.DokkaContextConfigurationImpl.actions(DokkaContext.kt:164)
at org.jetbrains.dokka.plugability.DokkaContextConfigurationImpl.get(DokkaContext.kt:147)
at nl.jolanrensen.docProcessor.ProcessDocsAction.analyseSourcesWithDokka(ProcessDocsAction.kt:99)
at nl.jolanrensen.docProcessor.ProcessDocsAction.process(ProcessDocsAction.kt:48)
at nl.jolanrensen.docProcessor.gradle.ProcessDocsGradleAction.execute(ProcessDocsGradleAction.kt:30)
at org.gradle.workers.internal.DefaultWorkerServer.execute(DefaultWorkerServer.java:63)
at org.gradle.workers.internal.AbstractClassLoaderWorker$1.create(AbstractClassLoaderWorker.java:49)
at org.gradle.workers.internal.AbstractClassLoaderWorker$1.create(AbstractClassLoaderWorker.java:43)
at org.gradle.internal.classloader.ClassLoaderUtils.executeInClassloader(ClassLoaderUtils.java:97)
at org.gradle.workers.internal.AbstractClassLoaderWorker.executeInClassLoader(AbstractClassLoaderWorker.java:43)
at org.gradle.workers.internal.IsolatedClassloaderWorker.run(IsolatedClassloaderWorker.java:49)
at org.gradle.workers.internal.IsolatedClassloaderWorker.run(IsolatedClassloaderWorker.java:30)
at org.gradle.workers.internal.IsolatedClassloaderWorkerFactory$1.lambda$execute$0(IsolatedClassloaderWorkerFactory.java:57)
at org.gradle.workers.internal.AbstractWorker$1.call(AbstractWorker.java:44)
at org.gradle.workers.internal.AbstractWorker$1.call(AbstractWorker.java:41)
at org.gradle.internal.operations.DefaultBuildOperationRunner$CallableBuildOperationWorker.execute(DefaultBuildOperationRunner.java:204)
at org.gradle.internal.operations.DefaultBuildOperationRunner$CallableBuildOperationWorker.execute(DefaultBuildOperationRunner.java:199)
at org.gradle.internal.operations.DefaultBuildOperationRunner$2.execute(DefaultBuildOperationRunner.java:66)
at org.gradle.internal.operations.DefaultBuildOperationRunner$2.execute(DefaultBuildOperationRunner.java:59)
at org.gradle.internal.operations.DefaultBuildOperationRunner.execute(DefaultBuildOperationRunner.java:157)
at org.gradle.internal.operations.DefaultBuildOperationRunner.execute(DefaultBuildOperationRunner.java:59)
at org.gradle.internal.operations.DefaultBuildOperationRunner.call(DefaultBuildOperationRunner.java:53)
at org.gradle.internal.operations.DefaultBuildOperationExecutor.call(DefaultBuildOperationExecutor.java:73)
at org.gradle.workers.internal.AbstractWorker.executeWrappedInBuildOperation(AbstractWorker.java:41)
at org.gradle.workers.internal.IsolatedClassloaderWorkerFactory$1.execute(IsolatedClassloaderWorkerFactory.java:49)
at org.gradle.workers.internal.DefaultWorkerExecutor.lambda$submitWork$2(DefaultWorkerExecutor.java:205)
at java.util.concurrent.FutureTask.run(FutureTask.java:266)
at org.gradle.internal.work.DefaultConditionalExecutionQueue$ExecutionRunner.runExecution(DefaultConditionalExecutionQueue.java:187)
at org.gradle.internal.work.DefaultConditionalExecutionQueue$ExecutionRunner.access$700(DefaultConditionalExecutionQueue.java:120)
at org.gradle.internal.work.DefaultConditionalExecutionQueue$ExecutionRunner$1.run(DefaultConditionalExecutionQueue.java:162)
at org.gradle.internal.Factories$1.create(Factories.java:31)
at org.gradle.internal.work.DefaultWorkerLeaseService.withLocks(DefaultWorkerLeaseService.java:270)
at org.gradle.internal.work.DefaultWorkerLeaseService.runAsWorkerThread(DefaultWorkerLeaseService.java:119)
at org.gradle.internal.work.DefaultWorkerLeaseService.runAsWorkerThread(DefaultWorkerLeaseService.java:124)
at org.gradle.internal.work.DefaultConditionalExecutionQueue$ExecutionRunner.runBatch(DefaultConditionalExecutionQueue.java:157)
at org.gradle.internal.work.DefaultConditionalExecutionQueue$ExecutionRunner.run(DefaultConditionalExecutionQueue.java:126)
at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511)
at java.util.concurrent.FutureTask.run(FutureTask.java:266)
at org.gradle.internal.concurrent.ExecutorPolicy$CatchAndRecordFailures.onExecute(ExecutorPolicy.java:64)
at org.gradle.internal.concurrent.ManagedExecutorImpl$1.run(ManagedExecutorImpl.java:48)
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
at java.lang.Thread.run(Thread.java:750)
given
public interface ColumnWithPath<out T> : DataColumn<T> {}
public fun <T> DataColumn<T>.any(predicate: Predicate<T>)
/**
* [ColumnWithPath.any]
*/
IntelliJ can link this reference up fine, but the plugin cannot.
Might be a Dokka limitation, but currently DTypeAlias
is not a WithSource
, so no DocumentableWithSources
can be created for it. Explore if we can still access its docs and/or modify them.
Maybe relevant: #13
Such as docs from libraries, perhaps type aliases etc.
Currently only Kotlin references are recognized and expanded to their full path when copied using @include
or when used as key in @arg
/@includeArg
. Java link statements are more difficult to support since they are more complex, but they can still be supported if there exists a need for it.
Currently in KDocs only http(s) urls are clickable in KDocs, like: [test](https://google.com)
. It would be very useful and safe to be able to click on a file URL that opens the file in the IDE.
I mentioned it here https://youtrack.jetbrains.com/issue/KTIJ-24290/Improve-KDoc-experience
Currently, doc processors can only be run and tested in a full gradle project with access to Dokka Documentables that cannot (easily) be mocked.
This also limits the processors to only being run in this environment and not in, potentially, other ones (such as an IntelliJ plugin).
Like the title says. Might also be combined with a new way of setting arguments.
currently, doc like
/**
* @a {
* @b}
* @c
*/
is broken up like ["@a {\n@b}", "@c"]
. This is helpful if inline tags cross multiple lines, but I think it may be better to honor the actual KDoc rule of "starting a line with @tag creates a block", making it split up like ["@a {", "@b}", "@c"]
.
Additional settings could be:
Especially for the intellij plugin, it would be great if the exception was rendered inside the kdoc instead of throwing an exception
Also allows for them to be inlined and broken up with @comment
s.
{@getArg [Key] default value}
notation could enable setting a default for getting an argument for if no argument is given.
for instance:
/**
* First sample:
* @sample [someSample]
*
* {@sampleNoComments [someSample]}
*
* Second sample:
* {@sample [someOtherSample]}
*
* Java sample:
* @sample JavaClass.javaMethod
*/
Need to update to 1.9.10
..that would remove any definition it's used on. Currently, the interfaces used only for docs clog the sources.jar.
[test]
turns into [test][test]
after @include
ing it. This is unnecessary and can cause strange behaviour, such as with @param
Running the processor with Gradle can take a long while in a project the size of DataFrame. This can be felt most using the @include
and arg processors, mainly, probably, because they're used the most in the project.
Some performance steps need to be researched.
Currently, only the following characters are taken into account when splitting up tag arguments or docs: {}, [], (), <>, `, ", ', '''.
Html tags are also supported in JavaDoc and MarkDown but are ignored for now.
highlight custom tags with a different color + bold on the fly.
`df.`[select][DataFrame.select]` { `[colsOf][colsOf]`<`[String][String]`>()`[`[`][cols]`1, 3, 5`]` }`
{@includeArg something}
works but
`df.`[select][DataFrame.select]` { `[colsOf][colsOf]`<`[String][String]`>()`[`[`][cols]`1, 3, 5`[`]`][cols]` }`
{@includeArg something}
does not.
The includeArg does not get rendered because it probably thinks it's still in a code block or something.
Makes it so "\}" notations etc. aren't necessary anymore.
This is dependent on splitDocContentPerBlock()
to work correctly #31
java.lang.IllegalArgumentException: Could not find end of comment.
Paths: [org.jetbrains.kotlinx.dataframe.api.fillNulls, org.jetbrains.kotlinx.dataframe.DataFrame.fillNulls]
Comment Content: "null"
Query: "e interface CommonFillNullsFunctionDoc
/**
* @include [CommonFillNullsFunctionDoc]
* @include [SelectingColumns.Dsl.WithExample] {@include [SetFillNullsOper"
https://github.com/LemonAppDev/konsist
I've been unable to update Dokka past v1.8.10, since they've been closing off parts of their analysis API. Maybe Konsist could provide a new approach
A declarative, efficient, and flexible JavaScript library for building user interfaces.
๐ Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
An Open Source Machine Learning Framework for Everyone
The Web framework for perfectionists with deadlines.
A PHP framework for web artisans
Bring data to life with SVG, Canvas and HTML. ๐๐๐
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
Some thing interesting about web. New door for the world.
A server is a program made to process requests and deliver data to clients.
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Some thing interesting about visualization, use data art
Some thing interesting about game, make everyone happy.
We are working to build community through open source technology. NB: members must have two-factor auth.
Open source projects and samples from Microsoft.
Google โค๏ธ Open Source for everyone.
Alibaba Open Source for everyone
Data-Driven Documents codes.
China tencent open source team.