diff options
Diffstat (limited to 'README.md')
| -rw-r--r-- | README.md | 480 |
1 files changed, 308 insertions, 172 deletions
@@ -1,13 +1,11 @@ -dokka [](https://confluence.jetbrains.com/display/ALL/JetBrains+on+GitHub) -[](https://teamcity.jetbrains.com/viewType.html?buildTypeId=Kotlin_Dokka_DokkaAntMavenGradle&branch_KotlinTools_Dokka=%3Cdefault%3E&tab=buildTypeStatusDiv) [  ](https://bintray.com/kotlin/dokka/dokka/_latestVersion) -===== +# dokka [](https://confluence.jetbrains.com/display/ALL/JetBrains+on+GitHub) [/statusIcon)](https://teamcity.jetbrains.com/viewType.html?buildTypeId=Kotlin_Dokka_DokkaAntMavenGradle&branch_KotlinTools_Dokka=%3Cdefault%3E&tab=buildTypeStatusDiv) [](https://bintray.com/kotlin/dokka/dokka/_latestVersion) Dokka is a documentation engine for Kotlin, performing the same function as javadoc for Java. Just like Kotlin itself, Dokka fully supports mixed-language Java/Kotlin projects. It understands standard Javadoc comments in Java files and [KDoc comments](https://kotlinlang.org/docs/reference/kotlin-doc.html) in Kotlin files, and can generate documentation in multiple formats including standard Javadoc, HTML and Markdown. -## Using Dokka +## Using dokka ### Using the Gradle plugin @@ -27,136 +25,264 @@ repositories { apply plugin: 'org.jetbrains.dokka' ``` -or using the new plugins block: +or using the plugins block: ```groovy plugins { - id 'org.jetbrains.dokka' version '0.9.18' + id 'org.jetbrains.dokka' version '0.10.0' } repositories { jcenter() // or maven { url 'https://dl.bintray.com/kotlin/dokka' } } ``` -The plugin adds a task named "dokka" to the project. +The plugin adds a task named `dokka` to the project. If you encounter any problems when migrating from older versions of Dokka, please see the [FAQ](https://github.com/Kotlin/dokka/wiki/faq). Minimal dokka configuration: +Groovy ```groovy dokka { outputFormat = 'html' - outputDirectory = "$buildDir/javadoc" + outputDirectory = "$buildDir/dokka" +} +``` + +Kotlin +```kotlin +tasks { + val dokka by getting(DokkaTask::class) { + outputFormat = "html" + outputDirectory = "$buildDir/dokka" + } } ``` [Output formats](#output_formats) -The available configuration options are shown below: +The available configuration options for single platform are shown below: ```groovy dokka { - moduleName = 'data' outputFormat = 'html' outputDirectory = "$buildDir/javadoc" - // These tasks will be used to determine source directories and classpath - kotlinTasks { - defaultKotlinTasks() + [':some:otherCompileKotlin', project("another").compileKotlin] - } - - // List of files with module and package documentation - // https://kotlinlang.org/docs/reference/kotlin-doc.html#module-and-package-documentation - includes = ['packages.md', 'extra.md'] - - // The list of files or directories containing sample code (referenced with @sample tags) - samples = ['samples/basic.kt', 'samples/advanced.kt'] - - jdkVersion = 6 // Used for linking to JDK + // In case of a Gradle multiproject build, you can include subprojects here to get merged documentation + // Note however, that you have to have the Kotlin plugin available in the root project and in the subprojects + subProjects = ["subproject1", "subproject2"] + + // Used for disabling auto extraction of sources and platforms in both multi-platform and single-platform modes + // When set to true, subProject and kotlinTasks are also omitted + disableAutoconfiguration = false // Use default or set to custom path to cache directory // to enable package-list caching - // When set to default, caches stored in $USER_HOME/.cache/dokka + // When this is set to default, caches are stored in $USER_HOME/.cache/dokka cacheRoot = 'default' - // Use to include or exclude non public members. - includeNonPublic = false - - // Do not output deprecated members. Applies globally, can be overridden by packageOptions - skipDeprecated = false - - // Emit warnings about not documented members. Applies globally, also can be overridden by packageOptions - reportUndocumented = true - - skipEmptyPackages = true // Do not create index pages for empty packages - - impliedPlatforms = ["JVM"] // See platforms section of documentation - - // Manual adding files to classpath - // This property doesn't override classpath collected from kotlinTasks but appends to it - classpath = [new File("$buildDir/other.jar")] + configuration { + moduleName = 'data' - // By default, sourceRoots is taken from kotlinTasks, following roots will be appended to it - // Short form sourceRoots - sourceDirs = files('src/main/kotlin') + // Use to include or exclude non public members. + includeNonPublic = false + + // Do not output deprecated members. Applies globally, can be overridden by packageOptions + skipDeprecated = false + + // Emit warnings about not documented members. Applies globally, also can be overridden by packageOptions + reportUndocumented = true + + // Do not create index pages for empty packages + skipEmptyPackages = true + + // This is a list of platform names that will be shown in the final result. See the "Platforms" section of this readme + targets = ["JVM"] + + // Platform used for code analysis. See the "Platforms" section of this readme + platform = "JVM" + + // Property used for manual addition of files to the classpath + // This property does not override the classpath collected automatically but appends to it + classpath = [new File("$buildDir/other.jar")] - // By default, sourceRoots is taken from kotlinTasks, following roots will be appended to it - // Full form sourceRoot declaration - // Repeat for multiple sourceRoots - sourceRoot { - // Path to source root - path = "src" - // See platforms section of documentation - platforms = ["JVM"] - } + // By default, sourceRoots are taken from Kotlin Plugin, subProjects and kotlinTasks, following roots will be appended to them + sourceRoots = [files('src/main/kotlin')] + + // List of files with module and package documentation + // https://kotlinlang.org/docs/reference/kotlin-doc.html#module-and-package-documentation + includes = ['packages.md', 'extra.md'] - // Specifies the location of the project source code on the Web. - // If provided, Dokka generates "source" links for each declaration. - // Repeat for multiple mappings - linkMapping { - // Unix based directory relative path to the root of the project (where you execute gradle respectively). - dir = "src/main/kotlin" // or simply "./" - - // URL showing where the source code can be accessed through the web browser - url = "https://github.com/cy6erGn0m/vertx3-lang-kotlin/blob/master/src/main/kotlin" //remove src/main/kotlin if you use "./" above + // List of files or directories containing sample code (referenced with @sample tags) + samples = ['samples/basic.kt', 'samples/advanced.kt'] + + // By default, sourceRoots are taken from Kotlin Plugin, subProjects and kotlinTasks, following roots will be appended to them + // Full form sourceRoot declaration + // Repeat for multiple sourceRoots + sourceRoot { + // Path to a source root + path = "src" + } - // Suffix which is used to append the line number to the URL. Use #L for GitHub - suffix = "#L" + // These tasks will be used to determine source directories and classpath + kotlinTasks { + defaultKotlinTasks() + [':some:otherCompileKotlin', project("another").compileKotlin] + } + + // Specifies the location of the project source code on the Web. + // If provided, Dokka generates "source" links for each declaration. + // Repeat for multiple mappings + sourceLink { + // Unix based directory relative path to the root of the project (where you execute gradle respectively). + path = "src/main/kotlin" // or simply "./" + + // URL showing where the source code can be accessed through the web browser + url = "https://github.com/cy6erGn0m/vertx3-lang-kotlin/blob/master/src/main/kotlin" //remove src/main/kotlin if you use "./" above + + // Suffix which is used to append the line number to the URL. Use #L for GitHub + lineSuffix = "#L" + } + + // Used for linking to JDK documentation + jdkVersion = 6 + + // Disable linking to online kotlin-stdlib documentation + noStdlibLink = false + + // Disable linking to online JDK documentation + noJdkLink = false + + // Allows linking to documentation of the project's dependencies (generated with Javadoc or Dokka) + // Repeat for multiple links + externalDocumentationLink { + // Root URL of the generated documentation to link with. The trailing slash is required! + url = new URL("https://example.com/docs/") + + // If package-list file is located in non-standard location + // packageListUrl = new URL("file:///home/user/localdocs/package-list") + } + + // Allows to customize documentation generation options on a per-package basis + // Repeat for multiple packageOptions + perPackageOption { + prefix = "kotlin" // will match kotlin and all sub-packages of it + // All options are optional, default values are below: + skipDeprecated = false + reportUndocumented = true // Emit warnings about not documented members + includeNonPublic = false + } + // Suppress a package + perPackageOption { + prefix = "kotlin.internal" // will match kotlin.internal and all sub-packages of it + suppress = true + } } - - // Disable linking to online kotlin-stdlib documentation - noStdlibLink = false - - // Disable linking to online JDK documentation - noJdkLink = false - - // Allows linking to documentation of the project's dependencies (generated with Javadoc or Dokka) - // Repeat for multiple links - externalDocumentationLink { - // Root URL of the generated documentation to link with. The trailing slash is required! - url = new URL("https://example.com/docs/") +} +``` + +#### Multiplatform +Since version 0.10.0 dokka supports multiplatform projects. For a general understanding how a multiplatform documentation is generated, please consult the [FAQ](https://github.com/Kotlin/dokka/wiki/faq). +In the multiplatform mode, instead of using the `configuration` block, you should use a `multiplatform` block with inner blocks for each platform. +The `configuration` block's parameters belong to those inner blocks, which can be named arbitrarly, however if you want to use source roots and classpath provided by Kotlin Multiplatform plugin, +they must have the same names as in the Kotlin Multiplatform plugin. See an example below: + +Groovy +```groovy +kotlin { // Kotlin Multiplatform plugin configuration + jvm() + js("customName") // Define a js platform named "customName" If you want to generate docs for it, you need to have this name in dokka configuration below +} + +dokka { + outputDirectory = "$buildDir/dokka" + outputFormat = "html" + + multiplatform { + customName { // The same name as in Kotlin Multiplatform plugin, so the sources are fetched automatically + includes = ['packages.md', 'extra.md'] + samples = ['samples/basic.kt', 'samples/advanced.kt'] + } - // If package-list file located in non-standard location - // packageListUrl = new URL("file:///home/user/localdocs/package-list") + differentName { // Different name, so source roots, classpath and platform must be passed explicitly. + targets = ["JVM"] + platform = "jvm" + sourceRoot { + path = kotlin.sourceSets.jvmMain.kotlin.srcDirs[0] + } + sourceRoot { + path = kotlin.sourceSets.commonMain.kotlin.srcDirs[0] + } + } } - - // Allows to customize documentation generation options on a per-package basis - // Repeat for multiple packageOptions - packageOptions { - prefix = "kotlin" // will match kotlin and all sub-packages of it - // All options are optional, default values are below: - skipDeprecated = false - reportUndocumented = true // Emit warnings about not documented members - includeNonPublic = false +} +``` + +Kotlin +```kotlin +kotlin { // Kotlin Multiplatform plugin configuration + jvm() + js("customName") +} + +val dokka by getting(DokkaTask::class) { + outputDirectory = "$buildDir/dokka" + outputFormat = "html" + + multiplatform { + val customName by creating { // The same name as in Kotlin Multiplatform plugin, so the sources are fetched automatically + includes = listOf("packages.md", "extra.md") + samples = listOf("samples/basic.kt", "samples/advanced.kt") + } + + register("differentName") { // Different name, so source roots must be passed explicitly + targets = listOf("JVM") + platform = "jvm" + sourceRoot { + path = kotlin.sourceSets.getByName("jvmMain").kotlin.srcDirs.first().toString() + } + sourceRoot { + path = kotlin.sourceSets.getByName("commonMain").kotlin.srcDirs.first().toString() + } + } + } } - // Suppress a package - packageOptions { - prefix = "kotlin.internal" // will match kotlin.internal and all sub-packages of it - suppress = true +``` + +For convenience, there is also a reserved block called `global`, which is a top-level configuration of `perPackageOptions`, `externalDocumentationLinks`, and `sourceLinks` shared by every platform. Eg. + +```groovy +dokka { + multiplatform { + global { // perPackageOptions, sourceLinks and externalDocumentationLinks from here will be copied to every other platform (jvm and js in eg.) + perPackageOption { + prefix = "com.somePackage" + suppress = true + } + perPackageOption { // You can repeat this block for multiple perPackageOptions + prefix = "kotlin" + skipDeprecated = false + reportUndocumented = true + includeNonPublic = false + } + sourceLink { + path = "src/main/kotlin" + url = "https://github.com/cy6erGn0m/vertx3-lang-kotlin/blob/master/src/main/kotlin" + lineSuffix = "#L" + } + externalDocumentationLink { + url = new URL("https://example.com/docs/") + } + } + js {} + jvm {} } } ``` +The parameters from the `global` block are appended to all the other platform configurations (in the example - `js` and `jvm`) and cannot be overriden. + + +Note that `javadoc` output format cannot be used with multiplatform. To generate the documentation, use the `dokka` Gradle task: @@ -167,16 +293,16 @@ To generate the documentation, use the `dokka` Gradle task: More dokka tasks can be added to a project like this: ```groovy -task dokkaJavadoc(type: org.jetbrains.dokka.gradle.DokkaTask) { - outputFormat = 'javadoc' - outputDirectory = "$buildDir/javadoc" +task dokkaMarkdown(type: org.jetbrains.dokka.gradle.DokkaTask) { + outputFormat = 'markdown' + outputDirectory = "$buildDir/markdown" } ``` Please see the [Dokka Gradle example project](https://github.com/JetBrains/kotlin-examples/tree/master/gradle/dokka-gradle-example) for an example. #### Dokka Runtime -If you are using Gradle plugin and you want to change the version of Dokka, you can do it by setting `dokkaRuntime`: +If you are using Gradle plugin and you want to use a custom version of dokka, you can do it by setting `dokkaRuntime` configuration: ```groovy buildscript { @@ -190,16 +316,46 @@ repositories { } dependencies { - dokkaRuntime "org.jetbrains.dokka:dokka-fatjar:0.9.18" + dokkaRuntime "org.jetbrains.dokka:dokka-fatjar:0.10.0" +} + +dokka { + outputFormat = 'html' + outputDirectory = "$buildDir/dokkaHtml" } + ``` +To use your Fat Jar, just set the path to it: + + ```groovy + buildscript { + ... + } + + apply plugin: 'org.jetbrains.dokka' + + repositories { + jcenter() + } + + dependencies { + dokkaRuntime files("/path/to/fatjar/dokka-fatjar-0.10.0.jar") + } + + dokka { + outputFormat = 'html' + outputDirectory = "$buildDir/dokkaHtml" + } + + ``` #### FAQ If you encounter any problems, please see the [FAQ](https://github.com/Kotlin/dokka/wiki/faq). #### Android -If you are using Android there is a separate Gradle plugin. Just make sure you apply the plugin after +Since version 0.10.0 the separate Android plugin is merged with the default one. +Just make sure you apply the plugin after `com.android.library` and `kotlin-android`. ```groovy @@ -208,7 +364,7 @@ buildscript { jcenter() } dependencies { - classpath "org.jetbrains.dokka:dokka-android-gradle-plugin:${dokka_version}" + classpath "org.jetbrains.dokka:dokka-gradle-plugin:${dokka_version}" } } repositories { @@ -216,11 +372,17 @@ repositories { } apply plugin: 'com.android.library' apply plugin: 'kotlin-android' -apply plugin: 'org.jetbrains.dokka-android' +apply plugin: 'org.jetbrains.dokka' ``` +There is also a `noAndroidSdkLink` configuration parameter that works similar to `noJdkLink` and `noStdlibLink` +By default the variant documented by dokka is the first release variant encountered. If you want to change that, +you can disable the autoconfiguration and configure dokka manually. + ### Using the Maven plugin +The Maven plugin does not support multiplatform projects. + The Maven plugin is available in JCenter. You need to add the JCenter repository to the list of plugin repositories if it's not there: ```xml @@ -298,9 +460,9 @@ The available configuration options are shown below: </includes> <!-- List of sample roots --> - <samplesDirs> + <samples> <dir>src/test/samples</dir> - </samplesDirs> + </samples> <!-- Used for linking to JDK, default: 6 --> <jdkVersion>6</jdkVersion> @@ -308,15 +470,10 @@ The available configuration options are shown below: <!-- Do not output deprecated members, applies globally, can be overridden by packageOptions --> <skipDeprecated>false</skipDeprecated> <!-- Emit warnings about not documented members, applies globally, also can be overridden by packageOptions --> - <reportNotDocumented>true</reportNotDocumented> + <reportUndocumented>true</reportUndocumented> <!-- Do not create index pages for empty packages --> <skipEmptyPackages>true</skipEmptyPackages> - <!-- See platforms section of documentation --> - <impliedPlatforms> - <platform>JVM</platform> - </impliedPlatforms> - <!-- Short form list of sourceRoots, by default, set to ${project.compileSourceRoots} --> <sourceDirectories> <dir>src/main/kotlin</dir> @@ -336,11 +493,11 @@ The available configuration options are shown below: <sourceLinks> <link> <!-- Source directory --> - <dir>${project.basedir}/src/main/kotlin</dir> + <path>${project.basedir}/src/main/kotlin</path> <!-- URL showing where the source code can be accessed through the web browser --> <url>https://github.com/cy6erGn0m/vertx3-lang-kotlin/blob/master/src/main/kotlin</url> <!-- //remove src/main/kotlin if you use "./" above --> <!--Suffix which is used to append the line number to the URL. Use #L for GitHub --> - <urlSuffix>#L</urlSuffix> + <lineSuffix>#L</lineSuffix> </link> </sourceLinks> @@ -383,61 +540,72 @@ Please see the [Dokka Maven example project](https://github.com/JetBrains/kotlin ### Using the Ant task -The Ant task definition is also contained in the dokka-fatjar.jar referenced above. Here's an example of using it: +The Ant task definition is also contained in the dokka-fatjar.jar referenced above. Here's an example usage: ```xml <project name="Dokka" default="document"> - <typedef resource="dokka-antlib.xml" classpath="dokka-fatjar.jar"/> + <typedef resource="dokka-antlib.xml" classpath="dokka-fatjar.jar"/> - <target name="document"> - <dokka src="src" outputdir="doc" modulename="myproject"/> - </target> + <target name="document"> + <dokka format="html" outputDir="doc"/> + </target> </project> ``` The Ant task supports the following attributes: * `outputDir` - the output directory where the documentation is generated - * `outputFormat` - the output format (see the list of supported formats above) + * `format` - the output format (see the list of supported formats below) + * `cacheRoot` - Use `default` or set to custom path to cache directory to enable package-list caching. When set to `default`, caches stored in $USER_HOME/.cache/dokka + +Inside the `dokka` tag you can create another tags named `<passconfig/>` that support the following attributes: + * `classpath` - list of directories or .jar files to include in the classpath (used for resolving references) * `samples` - list of directories containing sample code (documentation for those directories is not generated but declarations from them can be referenced using the `@sample` tag) * `moduleName` - the name of the module being documented (used as the root directory of the generated documentation) * `include` - names of files containing the documentation for the module and individual packages * `skipDeprecated` - if set, deprecated elements are not included in the generated documentation * `jdkVersion` - version for linking to JDK - * `impliedPlatforms` - See [platforms](#platforms) section - * `<sourceRoot path="src" platforms="JVM" />` - analogue of src, but allows to specify [platforms](#platforms) + * `analysisPlatform="jvm"` - platform used for analysing sourceRoots, see the [platforms](#platforms) section + * `<sourceRoot path="src" />` - source root * `<packageOptions prefix="kotlin" includeNonPublic="false" reportUndocumented="true" skipDeprecated="false"/>` - Per package options for package `kotlin` and sub-packages of it * `noStdlibLink` - disable linking to online kotlin-stdlib documentation * `noJdkLink` - disable linking to online JDK documentation * `<externalDocumentationLink url="https://example.com/docs/" packageListUrl="file:///home/user/localdocs/package-list"/>` - linking to external documentation, packageListUrl should be used if package-list located not in standard location - * `cacheRoot` - Use `default` or set to custom path to cache directory to enable package-list caching. When set to `default`, caches stored in $USER_HOME/.cache/dokka + * `<target value="JVM"/>` - see the [platforms](#platforms) section ### Using the Command Line -To run Dokka from the command line, download the [Dokka jar](https://github.com/Kotlin/dokka/releases/download/0.9.10/dokka-fatjar.jar). +To run Dokka from the command line, download the [Dokka jar](https://github.com/Kotlin/dokka/releases/download/0.10.0/dokka-fatjar.jar). To generate documentation, run the following command: - java -jar dokka-fatjar.jar <source directories> <arguments> + java -jar dokka-fatjar.jar <arguments> Dokka supports the following command line arguments: * `-output` - the output directory where the documentation is generated * `-format` - the [output format](#output-formats): - * `-classpath` - list of directories or .jar files to include in the classpath (used for resolving references) - * `-samples` - list of directories containing sample code (documentation for those directories is not generated but declarations from them can be referenced using the `@sample` tag) - * `-module` - the name of the module being documented (used as the root directory of the generated documentation) - * `-include` - names of files containing the documentation for the module and individual packages - * `-nodeprecated` - if set, deprecated elements are not included in the generated documentation - * `-impliedPlatforms` - list of implied platforms (comma-separated) - * `-packageOptions` - list of package options in format `prefix,-deprecated,-privateApi,+warnUndocumented;...` - * `-links` - external documentation links in format `url^packageListUrl^^url2...` - * `-noStdlibLink` - disable linking to online kotlin-stdlib documentation - * `-noJdkLink` - disable linking to online JDK documentation * `-cacheRoot` - use `default` or set to custom path to cache directory to enable package-list caching. When set to `default`, caches stored in $USER_HOME/.cache/dokka + * `-pass` - (repeatable) - configuration for single analyser pass. Following this argument, you can pass other arguments: + * `-src` - (repeatable) - source file or directory (allows many paths separated by the system path separator) + * `-classpath` - (repeatable) - directory or .jar file to include in the classpath (used for resolving references) + * `-sample` - (repeatable) - directory containing a sample code (documentation for those directories is not generated but declarations from them can be referenced using the `@sample` tag) + * `-module` - the name of the module being documented (used as the root directory of the generated documentation) + * `-include` - (repeatable) - names of files containing the documentation for the module and individual packages + * `-skipDeprecated` - if set, deprecated elements are not included in the generated documentation + * `-reportUndocumented` - warn about undocumented members + * `-skipEmptyPackages` - do not create index pages for empty packages + * `-packageOptions` - list of package options in format `prefix,-deprecated,-privateApi,+warnUndocumented;prefix, ...` + * `-links` - external documentation links in format `url^packageListUrl^^url2...` + * `-srcLink` - (repeatable) - mapping between a source directory and a Web site for browsing the code in format `<path>=<url>[#lineSuffix]` + * `-noStdlibLink` - disable linking to online kotlin-stdlib documentation + * `-noJdkLink` - disable linking to online JDK documentation + * `-jdkVersion` - version of JDK to use for linking to JDK JavaDoc + * `-analysisPlatform` - platform used for analysis, see the [Platforms](#platforms) section + * `-target` - (repeatable) - generation target ### Output formats<a name="output_formats"></a> @@ -453,55 +621,23 @@ Dokka supports the following command line arguments: ### Platforms<a name="platforms"></a> Dokka can annotate elements with special `platform` block with platform requirements +Example result and usage can be found on [kotlinlang.org](https://kotlinlang.org/api/latest/jvm/stdlib/) -Example of usage can be found on [kotlinlang.org](https://kotlinlang.org/api/latest/jvm/stdlib/) - -Each source root has a list of platforms for which members are suitable. -Also, the list of 'implied' platforms is passed to Dokka. -If a member is not available for all platforms in the implied platforms set, its documentation will show -the list of platforms for which it's available. - -## Dokka Internals - -### Documentation Model - -Dokka uses Kotlin-as-a-service technology to build `code model`, then processes it into `documentation model`. -`Documentation model` is graph of items describing code elements such as classes, packages, functions, etc. +Each multiplatform closure has two properties: `platform` and `targets`. If you use autoconfiguration, those are filled automatically. -Each node has semantic attached, e.g. Value:name -> Type:String means that some value `name` is of type `String`. +`targets` property is a list of platform names that will be shown in the final result. Note that the value of this property +doesn't affect analysis of source code, it just changes the result. You can think of this as a `name` property -Each reference between nodes also has semantic attached, and there are three of them: - -1. Member - reference means that target is member of the source, form tree. -2. Detail - reference means that target describes source in more details, form tree. -3. Link - any link to any other node, free form. - -Member & Detail has reverse Owner reference, while Link's back reference is also Link. - -Nodes that are Details of other nodes cannot have Members. - -### Rendering Docs - -When we have documentation model, we can render docs in various formats, languages and layouts. We have some core services: - -* FormatService -- represents output format -* LocationService -- represents folder and file layout -* SignatureGenerator -- represents target language by generating class/function/package signatures from model - -Basically, given the `documentation` as a model, we do this: - -```kotlin - val signatureGenerator = KotlinSignatureGenerator() - val locationService = FoldersLocationService(arguments.outputDir) - val markdown = JekyllFormatService(locationService, signatureGenerator) - val generator = FileGenerator(signatureGenerator, locationService, markdown) - generator.generate(documentation) -``` +`platform` property is used for the analysis of source roots. Available values are: + * `jvm` + * `js` + * `native` + * `common` -## Building Dokka +## Building dokka Dokka is built with Gradle. To build it, use `./gradlew build`. -Alternatively, open the project directory in IntelliJ IDEA and use the IDE to build and run Dokka. +Alternatively, open the project directory in IntelliJ IDEA and use the IDE to build and run dokka. Here's how to import and configure Dokka in IntelliJ IDEA: * Select "Open" from the IDEA welcome screen, or File > Open if a project is |