Erik C. Thauvin
6a6d6ce62a
Some checks failed
bld-ci / build-bld-project (17, 1.19.24) (push) Has been cancelled
bld-ci / build-bld-project (17, 2.0.0) (push) Has been cancelled
bld-ci / build-bld-project (21, 1.19.24) (push) Has been cancelled
bld-ci / build-bld-project (21, 2.0.0) (push) Has been cancelled
bld-ci / build-bld-project (22, 1.19.24) (push) Has been cancelled
bld-ci / build-bld-project (22, 2.0.0) (push) Has been cancelled
javadocs-pages / deploy (push) Has been cancelled
727 lines
24 KiB
Java
727 lines
24 KiB
Java
/*
|
|
* Copyright 2023-2024 the original author or authors.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* https://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package rife.bld.extension;
|
|
|
|
import rife.bld.BaseProject;
|
|
import rife.bld.extension.dokka.LoggingLevel;
|
|
import rife.bld.extension.dokka.OutputFormat;
|
|
import rife.bld.extension.dokka.SourceSet;
|
|
import rife.bld.operations.AbstractProcessOperation;
|
|
import rife.bld.operations.exceptions.ExitStatusException;
|
|
import rife.tools.StringUtils;
|
|
|
|
import java.io.File;
|
|
import java.io.IOException;
|
|
import java.util.*;
|
|
import java.util.concurrent.ConcurrentHashMap;
|
|
import java.util.logging.Level;
|
|
import java.util.logging.Logger;
|
|
import java.util.stream.Collectors;
|
|
|
|
/**
|
|
* Builds documentation (javadoc, HTML, etc.) using Dokka.
|
|
*
|
|
* @author <a href="https://erik.thauvin.net/">Erik C. Thauvin</a>
|
|
* @since 1.0
|
|
*/
|
|
@SuppressWarnings("PMD.AvoidThrowingRawExceptionTypes")
|
|
public class DokkaOperation extends AbstractProcessOperation<DokkaOperation> {
|
|
public static final String SEMICOLON = ";";
|
|
private final static String GFM_PLUGIN_REGEXP =
|
|
"^.*(dokka-base|analysis-kotlin-descriptors|gfm-plugin|freemarker).*\\.jar$";
|
|
private final static String HTML_PLUGIN_REGEXP =
|
|
"^.*(dokka-base|analysis-kotlin-descriptors|kotlinx-html-jvm|freemarker).*\\.jar$";
|
|
private final static String JAVADOC_PLUGIN_REGEXP =
|
|
"^.*(dokka-base|analysis-kotlin-descriptors|javadoc-plugin|kotlin-as-java-plugin|korte-jvm).*\\.jar$";
|
|
private final static String JEKYLL_PLUGIN_REGEXP =
|
|
"^.*(dokka-base|analysis-kotlin-descriptors|jekyll-plugin|gfm-plugin|freemarker).*\\.jar$";
|
|
private final Logger LOGGER = Logger.getLogger(DokkaOperation.class.getName());
|
|
private final Map<String, String> globalLinks_ = new ConcurrentHashMap<>();
|
|
private final Collection<String> globalPackageOptions_ = new ArrayList<>();
|
|
private final Collection<String> globalSrcLinks_ = new ArrayList<>();
|
|
private final Collection<File> includes_ = new ArrayList<>();
|
|
private final Collection<File> pluginsClasspath_ = new ArrayList<>();
|
|
private final Map<String, String> pluginsConfiguration_ = new ConcurrentHashMap<>();
|
|
private boolean delayTemplateSubstitution_;
|
|
private boolean failOnWarning_;
|
|
private File json_;
|
|
private LoggingLevel loggingLevel_;
|
|
private String moduleName_;
|
|
private String moduleVersion_;
|
|
private boolean noSuppressObviousFunctions_;
|
|
private boolean offlineMode_;
|
|
private File outputDir_;
|
|
private BaseProject project_;
|
|
private SourceSet sourceSet_;
|
|
private boolean suppressInheritedMembers_;
|
|
|
|
// Encodes to JSON adding braces as needed
|
|
private static String encodeJson(final String json) {
|
|
var sb = new StringBuilder(json);
|
|
if (!json.startsWith("{") || !json.endsWith("}")) {
|
|
sb.insert(0, "{").append('}');
|
|
}
|
|
return StringUtils.encodeJson(sb.toString());
|
|
}
|
|
|
|
/**
|
|
* Returns the JARs contained in a given directory.
|
|
* <p>
|
|
* Sources and Javadoc JARs are ignored.
|
|
*
|
|
* @param directory the directory
|
|
* @param regex the regular expression to match
|
|
* @return the Java Archives
|
|
*/
|
|
public static List<File> getJarList(File directory, String regex) {
|
|
var jars = new ArrayList<File>();
|
|
|
|
if (directory.isDirectory()) {
|
|
var files = directory.listFiles();
|
|
if (files != null) {
|
|
for (var f : files) {
|
|
if (!f.getName().endsWith("-sources.jar") && (!f.getName().endsWith("-javadoc.jar")) &&
|
|
f.getName().matches(regex)) {
|
|
jars.add(f);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return jars;
|
|
}
|
|
|
|
/**
|
|
* Determines if the given string is not blank.
|
|
*
|
|
* @param s the string
|
|
* @return {@code true} if not blank, {@code false} otherwise.
|
|
*/
|
|
public static boolean isNotBlank(String s) {
|
|
return s != null && !s.isBlank();
|
|
}
|
|
|
|
/**
|
|
* Sets the delay substitution of some elements.
|
|
* <p>
|
|
* Used in incremental builds of multimodule projects.
|
|
*
|
|
* @param delayTemplateSubstitution the delay
|
|
* @return this operation instance
|
|
*/
|
|
public DokkaOperation delayTemplateSubstitution(Boolean delayTemplateSubstitution) {
|
|
delayTemplateSubstitution_ = delayTemplateSubstitution;
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public void execute() throws IOException, InterruptedException, ExitStatusException {
|
|
if (project_ == null) {
|
|
if (LOGGER.isLoggable(Level.SEVERE) && !silent()) {
|
|
LOGGER.severe("A project must be specified.");
|
|
}
|
|
throw new ExitStatusException(ExitStatusException.EXIT_FAILURE);
|
|
} else {
|
|
super.execute();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Part of the {@link #execute execute} operation, constructs the command list to use for building the process.
|
|
*
|
|
* @since 1.5
|
|
*/
|
|
@Override
|
|
protected List<String> executeConstructProcessCommandList() {
|
|
final List<String> args = new ArrayList<>();
|
|
|
|
if (project_ != null) {
|
|
// java
|
|
args.add(javaTool());
|
|
|
|
var jarList = getJarList(project_.libBldDirectory(), "^.*dokka-cli.*\\.jar$");
|
|
if (!jarList.isEmpty()) {
|
|
// class path
|
|
args.add("-cp");
|
|
args.add(jarList.stream().map(File::getAbsolutePath).collect(Collectors.joining(File.pathSeparator)));
|
|
}
|
|
|
|
// main class
|
|
args.add("org.jetbrains.dokka.MainKt");
|
|
|
|
// -pluginClasspath
|
|
if (!pluginsClasspath_.isEmpty()) {
|
|
args.add("-pluginsClasspath");
|
|
args.add(pluginsClasspath_.stream().map(File::getAbsolutePath).collect(Collectors.joining(SEMICOLON)));
|
|
}
|
|
|
|
// -sourceSet
|
|
var sourceSetArgs = sourceSet_.args();
|
|
if (sourceSetArgs.isEmpty()) {
|
|
throw new IllegalArgumentException("At least one sourceSet is required.");
|
|
} else {
|
|
args.add("-sourceSet");
|
|
args.add(String.join(" ", sourceSet_.args()));
|
|
}
|
|
|
|
// -outputDir
|
|
if (outputDir_ != null) {
|
|
if (!outputDir_.exists() && !outputDir_.mkdirs()) {
|
|
throw new RuntimeException("Could not create: " + outputDir_.getAbsolutePath());
|
|
}
|
|
|
|
args.add("-outputDir");
|
|
args.add(outputDir_.getAbsolutePath());
|
|
}
|
|
|
|
// -delayTemplateSubstitution
|
|
if (delayTemplateSubstitution_) {
|
|
args.add("-delayTemplateSubstitution");
|
|
}
|
|
|
|
// -failOnWarning
|
|
if (failOnWarning_) {
|
|
args.add("-failOnWarning");
|
|
}
|
|
|
|
// -globalLinks_
|
|
if (!globalLinks_.isEmpty()) {
|
|
args.add("-globalLinks");
|
|
var links = new ArrayList<String>();
|
|
globalLinks_.forEach((k, v) ->
|
|
links.add(String.format("%s^%s", k, v)));
|
|
args.add(String.join("^^", links));
|
|
}
|
|
|
|
// -globalPackageOptions
|
|
if (!globalPackageOptions_.isEmpty()) {
|
|
args.add("-globalPackageOptions");
|
|
args.add(String.join(SEMICOLON, globalPackageOptions_));
|
|
}
|
|
|
|
// -globalSrcLinks
|
|
if (!globalSrcLinks_.isEmpty()) {
|
|
args.add("-globalSrcLinks_");
|
|
args.add(String.join(SEMICOLON, globalSrcLinks_));
|
|
}
|
|
|
|
// -includes
|
|
if (!includes_.isEmpty()) {
|
|
args.add("-includes");
|
|
args.add(includes_.stream().map(File::getAbsolutePath).collect(Collectors.joining(SEMICOLON)));
|
|
}
|
|
|
|
// -loggingLevel
|
|
if (loggingLevel_ != null) {
|
|
args.add("-loggingLevel");
|
|
args.add(loggingLevel_.name().toLowerCase());
|
|
}
|
|
|
|
// -moduleName
|
|
if (isNotBlank(moduleName_)) {
|
|
args.add("-moduleName");
|
|
args.add(moduleName_);
|
|
}
|
|
|
|
// -moduleVersion
|
|
if (isNotBlank(moduleVersion_)) {
|
|
args.add("-moduleVersion");
|
|
args.add(moduleVersion_);
|
|
}
|
|
|
|
// -noSuppressObviousFunctions
|
|
if (noSuppressObviousFunctions_) {
|
|
args.add("-noSuppressObviousFunctions");
|
|
}
|
|
|
|
// -offlineMode
|
|
if (offlineMode_) {
|
|
args.add("-offlineMode");
|
|
}
|
|
|
|
// -pluginConfiguration
|
|
if (!pluginsConfiguration_.isEmpty()) {
|
|
args.add("-pluginsConfiguration");
|
|
var confs = new ArrayList<String>();
|
|
pluginsConfiguration_.forEach((k, v) ->
|
|
confs.add(String.format("%s=%s", encodeJson(k), encodeJson(v))));
|
|
args.add(String.join("^^", confs));
|
|
}
|
|
|
|
// -suppressInheritedMembers
|
|
if (suppressInheritedMembers_) {
|
|
args.add("-suppressInheritedMembers");
|
|
}
|
|
|
|
// json
|
|
if (json_ != null) {
|
|
args.add(json_.getAbsolutePath());
|
|
}
|
|
|
|
if (LOGGER.isLoggable(Level.FINE)) {
|
|
LOGGER.fine(String.join(" ", args));
|
|
}
|
|
}
|
|
|
|
return args;
|
|
}
|
|
|
|
/**
|
|
* Configures the operation from a {@link BaseProject}.
|
|
* <p>
|
|
* Sets the {@link #sourceSet sourceSet}, {@link SourceSet#jdkVersion jdkVersion}, {@link #moduleName moduleName}
|
|
* and {@link SourceSet#classpath(File...) classpath} from the project.
|
|
*
|
|
* @param project the project to configure the operation from
|
|
*/
|
|
@Override
|
|
public DokkaOperation fromProject(BaseProject project) {
|
|
project_ = project;
|
|
sourceSet_ = new SourceSet()
|
|
.src(new File(project.srcMainDirectory(), "kotlin"))
|
|
.classpath(project.compileClasspathJars())
|
|
.classpath(project.providedClasspathJars());
|
|
if (project.javaRelease() != null) {
|
|
sourceSet_ = sourceSet_.jdkVersion(project.javaRelease());
|
|
}
|
|
moduleName_ = project.name();
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets whether to fail documentation generation if Dokka has emitted a warning or an error.
|
|
* <p>
|
|
* Whether to fail documentation generation if Dokka has emitted a warning or an error. The process waits until all
|
|
* errors and warnings have been emitted first.
|
|
* <p>
|
|
* This setting works well with {@link SourceSet#reportUndocumented}
|
|
*
|
|
* @param failOnWarning {@code true} or {@code false}
|
|
* @return this operation instance
|
|
*/
|
|
public DokkaOperation failOnWarning(Boolean failOnWarning) {
|
|
failOnWarning_ = failOnWarning;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Retrieves the global external documentation links.
|
|
*
|
|
* @return the documentation links
|
|
*/
|
|
public Map<String, String> globalLinks() {
|
|
return globalLinks_;
|
|
}
|
|
|
|
/**
|
|
* Set the global external documentation links.
|
|
*
|
|
* @param url the external documentation URL
|
|
* @param packageListUrl the external documentation package list URL
|
|
* @return this operation instance
|
|
*/
|
|
public DokkaOperation globalLinks(String url, String packageListUrl) {
|
|
globalLinks_.put(url, packageListUrl);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Set the global external documentation links.
|
|
*
|
|
* @param globalLinks the map of global links
|
|
* @return this operation instance
|
|
* @see #globalSrcLink(String...) #globalSrcLink(String...)#globalSrcLink(String...)
|
|
*/
|
|
public DokkaOperation globalLinks(Map<String, String> globalLinks) {
|
|
globalLinks_.putAll(globalLinks);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets the global package configurations.
|
|
* <p>
|
|
* Using format:
|
|
* <ul>
|
|
* <li>matchingRegexp</li>
|
|
* <li>-deprecated</li>
|
|
* <li>-privateApi</li>
|
|
* <li>+warnUndocumented</li>
|
|
* <li>+suppress</li>
|
|
* <li>+visibility:PUBLIC</li>
|
|
* <li>...</li>
|
|
* </ul>
|
|
*
|
|
* @param options ome pr more package configurations
|
|
* @return this operation instance
|
|
*/
|
|
public DokkaOperation globalPackageOptions(String... options) {
|
|
globalPackageOptions_.addAll(List.of(options));
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Retrieves the global package configurations.
|
|
*
|
|
* @return the package configurations
|
|
*/
|
|
public Collection<String> globalPackageOptions() {
|
|
return globalPackageOptions_;
|
|
}
|
|
|
|
/**
|
|
* Sets the global package configurations.
|
|
* <p>
|
|
* Using format:
|
|
* <ul>
|
|
* <li>matchingRegexp</li>
|
|
* <li>-deprecated</li>
|
|
* <li>-privateApi</li>
|
|
* <li>+warnUndocumented</li>
|
|
* <li>+suppress</li>
|
|
* <li>+visibility:PUBLIC</li>
|
|
* <li>...</li>
|
|
* </ul>
|
|
*
|
|
* @param options the package configurations
|
|
* @return this operation instance
|
|
*/
|
|
public DokkaOperation globalPackageOptions(Collection<String> options) {
|
|
globalPackageOptions_.addAll(options);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets the global mapping between a source directory and a Web service for browsing the code.
|
|
*
|
|
* @param links one or more links mapping
|
|
* @return this operation instance
|
|
*/
|
|
public DokkaOperation globalSrcLink(String... links) {
|
|
globalSrcLinks_.addAll(List.of(links));
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Retrieves the global source links
|
|
*
|
|
* @return the source links
|
|
*/
|
|
public Collection<String> globalSrcLink() {
|
|
return globalSrcLinks_;
|
|
}
|
|
|
|
/**
|
|
* Sets the global mapping between a source directory and a Web service for browsing the code.
|
|
*
|
|
* @param links the links mapping
|
|
* @return this operation instance
|
|
*/
|
|
public DokkaOperation globalSrcLink(Collection<String> links) {
|
|
globalSrcLinks_.addAll(links);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets the Markdown files that contain module and package documentation.
|
|
* <p>
|
|
* The contents of specified files are parsed and embedded into documentation as module and package descriptions.
|
|
* <p>
|
|
* This can be configured on per-package basis.
|
|
*
|
|
* @param files one or more files
|
|
* @return this operation instance
|
|
*/
|
|
public DokkaOperation includes(File... files) {
|
|
includes_.addAll(List.of(files));
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets the Markdown files that contain module and package documentation.
|
|
* <p>
|
|
* The contents of specified files are parsed and embedded into documentation as module and package descriptions.
|
|
* <p>
|
|
* This can be configured on per-package basis.
|
|
*
|
|
* @param files one or more files
|
|
* @return this operation instance
|
|
*/
|
|
public DokkaOperation includes(String... files) {
|
|
includes_.addAll(Arrays.stream(files).map(File::new).toList());
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Retrieves the markdown files that contain the module and package documentation.
|
|
*
|
|
* @return the markdown files
|
|
*/
|
|
public Collection<File> includes() {
|
|
return includes_;
|
|
}
|
|
|
|
/**
|
|
* Sets the Markdown files that contain module and package documentation.
|
|
* <p>
|
|
* The contents of specified files are parsed and embedded into documentation as module and package descriptions.
|
|
* <p>
|
|
* This can be configured on per-package basis.
|
|
*
|
|
* @param files the markdown files
|
|
* @return this operation instance
|
|
*/
|
|
public DokkaOperation includes(Collection<File> files) {
|
|
includes_.addAll(files);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* JSON configuration file path.
|
|
*
|
|
* @param configuration the configuration file path
|
|
*/
|
|
public DokkaOperation json(File configuration) {
|
|
json_ = configuration;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets the logging level.
|
|
*
|
|
* @param loggingLevel the logging level
|
|
* @return this operation instance
|
|
*/
|
|
public DokkaOperation loggingLevel(LoggingLevel loggingLevel) {
|
|
loggingLevel_ = loggingLevel;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets the name of the project/module. Default is {@code root}.
|
|
* <p>
|
|
* The display name used to refer to the module. It is used for the table of contents, navigation, logging, etc.
|
|
*
|
|
* @param moduleName the project/module name
|
|
* @return this operation instance
|
|
*/
|
|
public DokkaOperation moduleName(String moduleName) {
|
|
moduleName_ = moduleName;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Set the documented version.
|
|
*
|
|
* @param version the version
|
|
* @return this operation instance
|
|
*/
|
|
public DokkaOperation moduleVersion(String version) {
|
|
moduleVersion_ = version;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets whether to suppress obvious functions such as inherited from
|
|
* <a href="https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-any/">kotlin.Any</a> and {@link java.lang.Object}.
|
|
* <p>
|
|
* A function is considered to be obvious if it is:
|
|
* <ul>
|
|
* <li>Inherited from <a href="https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-any/">kotlin.Any</a>,
|
|
* <a href="https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-enum/">Kotlin.Enum</a>, {@link java.lang.Object}
|
|
* or {@link java.lang.Enum}, such as {@code equals}, {@code hashCode}, {@code toString}.
|
|
* <li>Synthetic (generated by the compiler) and does not have any documentation, such as
|
|
* {@code dataClass.componentN} or {@code dataClass.copy}.
|
|
* </ul>
|
|
*
|
|
* @param noSuppressObviousFunctions {@code true} or {@code false}
|
|
* @return this operation instance
|
|
*/
|
|
public DokkaOperation noSuppressObviousFunctions(Boolean noSuppressObviousFunctions) {
|
|
noSuppressObviousFunctions_ = noSuppressObviousFunctions;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets whether to resolve remote files/links over network.
|
|
* <p>
|
|
* This includes package-lists used for generating external documentation links. For example, to make classes from
|
|
* the standard library clickable.
|
|
* <p>
|
|
* Setting this to true can significantly speed up build times in certain cases, but can also worsen documentation
|
|
* quality and user experience. For example, by not resolving class/member links from your dependencies, including
|
|
* the standard library.
|
|
* <p>
|
|
* Note: You can cache fetched files locally and provide them to Dokka as local paths.
|
|
*
|
|
* @param offlineMode the offline mode
|
|
* @return this operation instance
|
|
* @see SourceSet#externalDocumentationLinks(String, String)
|
|
*/
|
|
public DokkaOperation offlineMode(Boolean offlineMode) {
|
|
offlineMode_ = offlineMode;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets the output directory path, {@code ./dokka} by default.
|
|
* <p>
|
|
* The directory to where documentation is generated, regardless of output format.
|
|
*
|
|
* @param outputDir the output directory
|
|
* @return this operation instance
|
|
*/
|
|
public DokkaOperation outputDir(File outputDir) {
|
|
outputDir_ = outputDir;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets the output directory path, {@code ./dokka} by default.
|
|
* <p>
|
|
* The directory to where documentation is generated, regardless of output format.
|
|
*
|
|
* @param outputDir the output directory
|
|
* @return this operation instance
|
|
*/
|
|
public DokkaOperation outputDir(String outputDir) {
|
|
outputDir_ = new File(outputDir);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets the Dokka {@link OutputFormat output format}.
|
|
*
|
|
* @param format The {@link OutputFormat output format}
|
|
* @return this operation instance
|
|
*/
|
|
public DokkaOperation outputFormat(OutputFormat format) {
|
|
pluginsClasspath_.clear();
|
|
if (format.equals(OutputFormat.JAVADOC)) {
|
|
pluginsClasspath_.addAll(getJarList(project_.libBldDirectory(),
|
|
JAVADOC_PLUGIN_REGEXP));
|
|
} else if (format.equals(OutputFormat.HTML)) {
|
|
pluginsClasspath_.addAll(getJarList(project_.libBldDirectory(),
|
|
HTML_PLUGIN_REGEXP));
|
|
} else if (format.equals(OutputFormat.MARKDOWN)) {
|
|
pluginsClasspath_.addAll(getJarList(project_.libBldDirectory(),
|
|
GFM_PLUGIN_REGEXP));
|
|
} else if (format.equals(OutputFormat.JEKYLL)) {
|
|
pluginsClasspath_.addAll(getJarList(project_.libBldDirectory(),
|
|
JEKYLL_PLUGIN_REGEXP));
|
|
}
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets the configuration for Dokka plugins.
|
|
*
|
|
* @param name The fully-qualified plugin name
|
|
* @param jsonConfiguration The plugin JSON configuration
|
|
* @return this operation instance
|
|
*/
|
|
public DokkaOperation pluginConfigurations(String name, String jsonConfiguration) {
|
|
pluginsConfiguration_.put(name, jsonConfiguration);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets the configuration for Dokka plugins.
|
|
*
|
|
* @param pluginConfiguratione the map of configurations
|
|
* @return this operation instance
|
|
* @see #pluginConfigurations(String, String)
|
|
*/
|
|
public DokkaOperation pluginConfigurations(Map<String, String> pluginConfiguratione) {
|
|
pluginsConfiguration_.putAll(pluginConfiguratione);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Retrieves the plugin configurations.
|
|
*
|
|
* @return the plugin configurations.
|
|
*/
|
|
public Map<String, String> pluginConfigurations() {
|
|
return pluginsConfiguration_;
|
|
}
|
|
|
|
/**
|
|
* Sets the jars for Dokka plugins and their dependencies.
|
|
*
|
|
* @param jars one or more jars
|
|
* @return this operation instance
|
|
*/
|
|
public DokkaOperation pluginsClasspath(File... jars) {
|
|
pluginsClasspath_.addAll(List.of(jars));
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets the jars for Dokka plugins and their dependencies.
|
|
*
|
|
* @param jars one or more jars
|
|
* @return this operation instance
|
|
*/
|
|
public DokkaOperation pluginsClasspath(String... jars) {
|
|
pluginsClasspath_.addAll(Arrays.stream(jars).map(File::new).toList());
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Retrieves the plugins classpath.
|
|
*
|
|
* @return the classpath
|
|
*/
|
|
public Collection<File> pluginsClasspath() {
|
|
return pluginsClasspath_;
|
|
}
|
|
|
|
/**
|
|
* Sets the jars for Dokka plugins and their dependencies.
|
|
*
|
|
* @param jars the jars
|
|
* @return this operation instance
|
|
*/
|
|
public DokkaOperation pluginsClasspath(Collection<File> jars) {
|
|
pluginsClasspath_.addAll(jars);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets the configurations for a source set.
|
|
* <p>
|
|
* Individual and additional configuration of Kotlin source sets.
|
|
*
|
|
* @param sourceSet the source set configurations
|
|
* @return this operation instance
|
|
*/
|
|
public DokkaOperation sourceSet(SourceSet sourceSet) {
|
|
sourceSet_ = sourceSet;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets whether to suppress inherited members that aren't explicitly overridden in a given class.
|
|
*
|
|
* @param suppressInheritedMembers {@code true} or {@code false}
|
|
* @return this operation instance
|
|
*/
|
|
public DokkaOperation suppressInheritedMembers(Boolean suppressInheritedMembers) {
|
|
suppressInheritedMembers_ = suppressInheritedMembers;
|
|
return this;
|
|
}
|
|
}
|